Commit 1279243

This is a demo application using `gate-api` to show how Gate APIv4 works.

Instead of running it, it is recommended to read the source code to get a general idea of

how this SDK is used. However, you can modify this code directly to implement your own logic.

1. Clone this project and make sure it is named with `gateapi-python`

2. Run `./build.sh`, then your demo application will be created beside `gateapi-python`

**READ THIS BEFORE YOU RUN ANYTHING**

**This application is shown for demo only. It will try to use your input API key and secret to

trade, lend and borrow, etc. Make sure you know exactly what it does before running it.**

python app.py futures -k <YOUR_TESTNET_API_KEY> -s <YOUR_TESTNET_API_SECRET> -u fx-api-testnet.gateio.ws

python app.py futures -k <YOUR_API_KEY> -s <YOUR_API_SECRET>

python app.py spot -k <YOUR_API_KEY> -s <YOUR_API_SECRET>

python app.py margin -k <YOUR_API_KEY> -s <YOUR_API_SECRET>

import logging

from argparse import ArgumentParser

from config import RunConfig

from futures import futures_demo

from margin import margin_demo

from spot import spot_demo

logging.basicConfig(format="%(asctime)s: %(message)s", level=logging.DEBUG)

logger = logging.getLogger(__name__)

def main():

parser = ArgumentParser(description="Run Gate APIv4 demo application")

parser.add_argument("-k", "--key", required=True, help="Gate APIv4 Key")

parser.add_argument("-s", "--secret", required=True, help="Gate APIv4 Secret")

parser.add_argument("-u", "--url", required=False, help="API base URL used to test")

parser.add_argument("tests", nargs='+', help="tests to run")

options = parser.parse_args()

host_used = options.url

if not host_used:

host_used = "https://api.gateio.ws/api/v4"

if not host_used.startswith("http"):

host_used = "https://" + host_used

host_used = host_used.rstrip("/")

if not host_used.endswith("/api/v4"):

host_used += '/api/v4'

run_config = RunConfig(options.key, options.secret, host_used)

for t in options.tests:

logger.info("run %s API demo", t)

if t == 'spot':

spot_demo(run_config)

elif t == 'margin':

margin_demo(run_config)

elif t == 'futures':

futures_demo(run_config)

else:

logger.warning("ignore unknown test %s", t)

if __name__ == '__main__':

main()

set -e

WORKDIR="${PWD}/gateapi-demo"

VENV_DIR="$WORKDIR/.venv"

: "${GATEAPI_SOURCE_DIR:=gateapi-python}"

python=$(command -v python3 || true)

if [ -z "$python" ]; then

python=$(command -v python2 || true)

if [ -z "$python" ]; then

echo >&2 "No python executable found."

exit 1

fi

mkdir -p "$WORKDIR"

virtualenv=$(command -v virtualenv || true)

if [ -z "$virtualenv" ]; then

echo "No virtualenv found. Native python environment will be used"

LOCAL_INSTALL="--user"

if [ -n "$VIRTUAL_ENV" ]; then

# find original python path, osx compatible

while true; do

orig=$(readlink "$python")

if [ -z "$orig" ]; then

break

elif [ "$orig" != "${orig#/}" ]; then

python=$orig

break

else

python="$(dirname "${python}")"/"$orig"

fi

done

fi

if [ ! -d "$VENV_DIR" ]; then

"$virtualenv" -p "$python" "$VENV_DIR"

fi

python="$VENV_DIR/bin/python"

echo "Python used: $python"

cd "$GATEAPI_SOURCE_DIR" && "$python" setup.py install ${LOCAL_INSTALL+"$LOCAL_INSTALL"} && cd -

cp "$GATEAPI_SOURCE_DIR"/example/*.py "$WORKDIR"

if [ -n "$virtualenv" ]; then

echo "run \`source $VENV_DIR/bin/activate \` and then "

echo "run \`cd $WORKDIR && $python app.py -h\` for help"

from six.moves.urllib.parse import urlparse

class RunConfig(object):

def __init__(self, api_key=None, api_secret=None, host_used=None):

# type: (str, str, str) -> None

self.api_key = api_key

self.api_secret = api_secret

self.host_used = host_used

self.use_test = urlparse(host_used).hostname == "fx-api-testnet.gateio.ws"

import logging

import time

from decimal import Decimal as D, ROUND_UP, getcontext

from gate_api import ApiClient, Configuration, FuturesApi, FuturesOrder, Transfer, WalletApi

from gate_api.exceptions import GateApiException

from config import RunConfig

logger = logging.getLogger(__name__)

def futures_demo(run_config):

# type: (RunConfig) -> None

settle = "usdt"

contract = "BTC_USDT"

# Initialize API client

# Setting host is optional. It defaults to https://api.gateio.ws/api/v4

config = Configuration(key=run_config.api_key, secret=run_config.api_secret, host=run_config.host_used)

futures_api = FuturesApi(ApiClient(config))

# update position leverage

leverage = "3"

futures_api.update_position_leverage(settle, contract, leverage)

# retrieve position size

position_size = 0

try:

position = futures_api.get_position(settle, contract)

position_size = position.size

except GateApiException as ex:

if ex.label != "POSITION_NOT_FOUND":

raise ex

# set order size

futures_contract = futures_api.get_futures_contract(settle, contract)

order_size = 10

if futures_contract.order_size_min and futures_contract.order_size_min > order_size:

order_size = futures_contract.order_size_min

if position_size < 0:

order_size = 0 - order_size

# example to update risk limit

assert futures_contract.risk_limit_base

assert futures_contract.risk_limit_step

risk_limit = D(futures_contract.risk_limit_base) + D(futures_contract.risk_limit_step)

futures_api.update_position_risk_limit(settle, contract, str(risk_limit))

# retrieve last price to calculate margin needed

tickers = futures_api.list_futures_tickers(settle, contract=contract)

assert len(tickers) == 1

last_price = tickers[0].last

logger.info("last price of contract %s: %s", contract, last_price)

getcontext().prec = 8

getcontext().rounding = ROUND_UP

assert futures_contract.quanto_multiplier

margin = order_size * D(last_price) * D(futures_contract.quanto_multiplier) / D(leverage) * D("1.1")

logger.info("needs margin amount: %s", str(margin))

# if balance is not enough, transfer from spot account

available = "0"

try:

futures_account = futures_api.list_futures_accounts(settle)

available = futures_account.available

except GateApiException as ex:

if ex.label != "USER_NOT_FOUND":

raise ex

logger.info("futures account available: %s %s", available, settle.upper())

if D(available) < margin:

if run_config.use_test:

logger.warning("testnet account balance not enough. make a transferal on web")

return

transfer = Transfer(amount=str(margin), currency=settle.upper(), _from='spot', to='futures')

wallet_api = WalletApi(ApiClient(config))

wallet_api.transfer(transfer)

# example to cancel all open orders in contract

futures_api.cancel_futures_orders(settle, contract)

# order using market price

order = FuturesOrder(contract=contract, size=order_size, price="0", tif='ioc')

try:

order_response = futures_api.create_futures_order(settle, order)

except GateApiException as ex:

logger.error("error encountered creating futures order: %s", ex)

return

logger.info("order %s created with status: %s", order_response.id, order_response.status)

if order_response.status == 'open':

futures_order = futures_api.get_futures_order(settle, str(order_response.id))

logger.info("order %s status %s, total size %s, left %s", futures_order.id, futures_order.status,

futures_order.size, futures_order.left)

futures_api.cancel_futures_order(settle, str(futures_order.id))

logger.info("order %s cancelled", futures_order.id)

else:

time.sleep(0.2)

order_trades = futures_api.get_my_trades(settle, contract=contract, order=order_response.id)

assert len(order_trades) > 0

trade_size = 0

for t in order_trades:

assert t.order_id == str(order_response.id)

trade_size += t.size

logger.info("order %s filled size %s with price %s", t.order_id, t.size, t.price)

assert trade_size == order_size

# example to update position margin

futures_api.update_position_margin(settle, contract, "0.01")

import logging

import random

from decimal import Decimal as D, ROUND_UP, getcontext

from gate_api import ApiClient, Configuration, Loan, MarginApi, Order, RepayRequest, SpotApi, Transfer, WalletApi

from gate_api.exceptions import GateApiException

from config import RunConfig

logger = logging.getLogger(__name__)

def margin_demo(run_config):

# type: (RunConfig) -> None

currency_pair = 'BTC_USDT'

currency = currency_pair.split("_")[1]

# Initialize API client

# Setting host is optional. It defaults to https://api.gateio.ws/api/v4

config = Configuration(key=run_config.api_key, secret=run_config.api_secret, host=run_config.host_used)

spot_api = SpotApi(ApiClient(config))

margin_api = MarginApi(ApiClient(config))

wallet_api = WalletApi(ApiClient(config))

# retrieve currency pair last price

tickers = spot_api.list_tickers(currency_pair=currency_pair)

assert len(tickers) == 1

last_price = tickers[0].last

logger.info("currency pair %s last price %s", currency_pair, last_price)

pairs = margin_api.list_margin_currency_pairs()

pair = next(p for p in pairs if p.id == currency_pair)

loan_amount = D("0") if not pair.min_quote_amount else D(pair.min_quote_amount)

if pair.min_base_amount:

min_loan_amount = D(pair.min_base_amount) * D(last_price)

if loan_amount < min_loan_amount:

loan_amount = min_loan_amount

logger.info("minimum loan amount in currency pair %s: %s %s", currency_pair, str(loan_amount), currency)

getcontext().prec = 8

getcontext().rounding = ROUND_UP

# example to lend

funding_accounts = margin_api.list_funding_accounts(currency=currency)

lend_amount = loan_amount + D(random.random())

if len(funding_accounts) == 1 and D(funding_accounts[0].available) >= lend_amount:

lending_loan = Loan(amount=str(lend_amount), auto_renew=False, days=10, currency=currency, rate="0.002",

side='lend')

created_loan = margin_api.create_loan(lending_loan)

logger.info("place a lending loan %s with currency %s, rate %s, amount %s", created_loan.id,

created_loan.currency, created_loan.rate, created_loan.amount)

loan_result = margin_api.get_loan(created_loan.id, 'lend')

if loan_result.status == 'loaned':

records = margin_api.list_loan_records(loan_result.id)

for r in records:

logger.info("loan %s is borrowed with record id %s, amount %s, status: %s", r.loan_id, r.id, r.amount,

r.status)

else:

margin_api.cancel_loan(created_loan.id, currency)

assert pair.leverage

margin = loan_amount / (pair.leverage - 1)

accounts = margin_api.list_margin_accounts(currency_pair=currency_pair)

assert len(accounts) == 1

available = D(accounts[0].quote.available)

logger.info("available margin balance of currency %s in currency pair %s: %s", currency, currency_pair,

str(available))

if margin > available:

transfer = Transfer(currency_pair=currency_pair, currency=currency, amount=str(margin - available),

_from='spot', to='margin')

wallet_api.transfer(transfer)

logger.info("transferred %s %s to margin account", transfer.amount, transfer.currency)

# borrow with minimum rate

borrow_amount = loan_amount + D(random.random())

min_rate_item = min(

filter(lambda x: x.rate and D(x.amount) > borrow_amount, margin_api.list_funding_book(currency)),

key=lambda x: D(x.rate)

)

loan = Loan(side='borrow', currency=currency, rate=min_rate_item.rate, amount=str(borrow_amount),

days=min_rate_item.days, currency_pair=currency_pair)

borrowed = margin_api.create_loan(loan)

logger.info("borrowed %s %s in currency pair %s with rate %s, id %s", borrowed.amount, borrowed.currency,

borrowed.currency_pair, borrowed.rate, borrowed.id)

assert borrowed.status == 'loaned'

# create margin order

order_amount = spot_api.get_currency_pair(currency_pair).min_quote_amount

order = Order(account='margin', currency_pair=currency_pair, price=last_price, amount=order_amount or "1",

side='sell')

try:

created_order = spot_api.create_order(order)

logger.info("margin order created with id %s, status %s", created_order.id, created_order.status)

except GateApiException as ex:

logger.error("failed to create margin order: %s", ex)

repay_request = RepayRequest(mode='all', currency=currency, currency_pair=currency_pair)

margin_api.repay_loan(borrowed.id, repay_request)

for r in margin_api.list_loan_repayments(borrowed.id):

logger.info("loan %s repaid %s with interest %s", borrowed.id, r.principal, r.interest)