HTClient Documentation

Introduction

HTClient is the HedgeTech app. It can be operated in order to customize, run and monitor trading algorithms.
This documentation helps naviguating through the infrastructure of HTClient and its User Interface (UI). We recommend reading this document while having HTClient opened.

Target Audience and Target Markets

HTClient is particularly suitable for token issuers, exchanges, market makers and broker/dealers.

Token issuers can operate the systems within their company, on all exchanges they are listed on.
Exchanges can operate the systems in-house for their main pairs as well as all other altcoins listed on their platform.
Market makers can chose to either use the algorithms designed by HedgeTech or to design their own custom scripts, benefiting from our integration capabilities and server infrastructure.
Broker/dealers can add to the services they offer with an all-in-one liquidity provision system.

The scripts are suitable for any market environment: major coins, altcoins, utility tokens, security tokens, futures, perpetual contracts, swaps, ETFs and all other digital assets.

Installation

After registering a HedgeTech account, the username, password and secretkey can be used to access HTClient. Each of these should be carefully saved and securely stored.

Windows

After downloading HTClient at https://www.hedgetech.io, the first time HTClient.exe is opened, a message might show up saying that Windows Defender Smartscreen has protected the PC. If that is the case, please click More info and if the developer shows HedgeTech LLC, safely select Run Anyway. Windows may run a security scan. The next times HTClient.exe is opened, this extra step is not required.

Mac OS X

After downloading HTClient at https://www.hedgetech.io, and installing it at the desired location (by dragging the app to that location), the first time HTClient.app is opened, an error message may appear saying that this app cannot be opened. If that is the case, simply run the following code in your Mac Terminal:

sudo xattr -rd com.apple.quarantine 
  

Followed by a space, and then drag the app file in the Terminal. Hit Enter, enter the password of the device (note: the password will not be displayed on the screen) and hit Enter. The next times HTClient.app is opened, this extra step is not required.

Syntax

Please make sure to follow accurately the syntax such as upper and lower cases.

str: text, e.g. some text

int: integer number, e.g. 1

float: decimal number, e.g. 1.1

bool: True or False

expression: the expression of a function that is calculated with the following operators: +, -, *, /, (, ) and the following components:

• ask: The lowest ask price
• bid: The highest bid price
• unit: The base price increment
• last: The last traded price
• mid: The middle price between the lowest ask and the highest bid (only applies to schedule)
• unitR: A random integer among -1, 0 or 1 (only applies to schedule)
• uniformR: A random float between 0 and 1 (only applies to schedule)

e.g. bid+unit will return the price that is one base price increment higher than the highest bid

IP Adresses

For security reasons, our servers use non-static IPs. In order to use HTClient, make sure to whitelist all IPs on your exchange accounts by not filling any IP under the exchange website IP whitelist field. If the exchange does not provide this feature on their website, please get in touch with the exchange directly.

API Permissions

For your own security, please make sure to manage permissions if the exchange offers this feature. In order to use HTClient read/write permissions for everything except withdrawal/deposit should be enabled.

Python Library

HedgeTech has developed and maintains htwrapper, its official Python Library. It allows users to interact with HedgeTech's API that gives access to all of HTClient's functionalities and more. Installation is available via the command pip install htwrapper. A detailed documentation is available via the command help(htwrapper).

Strategy Catalog

Market Making

Script class symbol: maker

Purpose: The maker script class provides liquidity to the market, it narrows the market spread and it makes profits from the spread when the price fluctuates.
Details: It maintains a number of orders on both the buy and sell sides for a currency pair. It lets the price behave according to supply and demand in the market, it adjusts the maintained orders automatically: when people sell, the price will move down; when people buy, the price will move up.
Use cases: Provide liquidity on any market and offer a competitive spread in price to achieve an efficient market environment where traders can enter and exit at fair prices.

Account(s): Main account only.

Note: after putting maker online, if you need to change the following parameters: levels, aveVolume, randomness, spread, density, the script will automatically clear storage, clear orders and restart with the desired parameters.

Stable Market Making (or Market Making with Price Matching)

Script class symbol: stable

Purpose: The stable script class provides liquidity to the market and narrows the market spread, while matching the price to a desired index.
Details: It maintains a number of orders on both the buy and sell sides for a currency pair around a given price. Such a price is defined by the base value and/or quote value. You can define the base value and the quote value to be set values, or use the market price that is reported by CoinGecko.
Warning: It can place taker orders to match the price to the index value. As a result, there are situations in which external orders can be actively filled. Please reach out if more information is necessary.
Use cases: Provide liquidity and narrow spread on stablecoin markets or tokens that are pegged to a specific value.

Account(s): Main account only.

Create an API Expression

An API expression is used to assign the baseValue and/or quoteValue to a value automatically read from a third party API. Only REST APIs with a json response body are allowed.

To create an API expression, the first step is to construct a json object that has the following attributes:

Once the json object is constructed, convert it to str and encode it with base64.

Finally, add REST- at the beginning of the base64 encoded string. The API expression should look like this: REST-eyJ1cmwiOiAiaHR0cHM6Ly9hcGkuYmluYW5jZS5jb20vYXBpL3YzL3RpY2tlci8yNGhyP3N5bWJvbD1CTkJCVEMiLCAibWV0aG9kIjogImdldCIsICJrZXlDaGFpbiI6IFsibGFzdFByaWNlIl19

Keychain Example

Assuming the raw response of the API is as follows:

{
    "key1": {
      "key11": 6,
      "key12": [
        1,
        3,
        7
      ]
    },
    "key2": 10
  }

The keyChain should be an array of keys that leads to the value to be resolved. If the value to be resolved is 3, the keyChain should be ["key1", "key12", 1] (note that the index of an array starts from 0). If the value to be resolved is 10, the keyChain should be ["key2"].

Orderbook Replication

Script class symbol: replication

Purpose: The orderbook replication strategy replicates the liquidity from an exchange with more liquidity to an exchange with less liquidity, in order to provide liquidity on the exchange with less liquidity. This strategy makes profits from strictly hedging the risk.
Details: Whenever the orders maintained on the exchange with less liquidity are filled, it will hedge the position by placing market orders and take the liquidity from the exchange with more liquidity.
Warning: This is a relatively advanced script class, please reach out if more information is necessary before implementing it.
Use cases: Provide liquidity and narrow spread on major pairs on exchanges with little liquidity, pairs with little liquidity for a given token.

Account(s): Both main account and secondary account. Main account is the account on the exchange on which liquidity will be added (the one with less liquidity), secondary account is the account on the exchange on which liquidity will be taken from (the one with more liquidity).

Pool Liquidity Migration

Purpose: The migrate strategy builds and maintains a dense tradeable orderbook on an exchange by taking liquidity provided by the community from a liquidity pool. This strategy makes profits from strictly hedging the risk.
Details: Whenever the orders maintained on the exchange are filled, it will hedge the position by swapping and thus taking liquidity from liquidity pool.
Warning: This is a relatively advanced script class, please reach out if more information is necessary before implementing it.
Use cases: Build and maintain a tradeable orderbook on an exchange while fully hedging the risk against a liquidity pool and realizing profits.

Account(s): Both main account and swap wallet. Main account is the account on the exchange on which liquidity will be added (orderbook will be built), swap wallet is the wallet connected to the liquidity pool. The swap account first needs to follow the instructions on the liquidity pool to approve swaping for the desired pair.

Arbitrage

Script class symbol: arbitrage

Purpose: For a given base currency, the arbitrage strategy can do same exchange cross pair arbitrage, cross exchange same pair arbitrage and cross exchange cross pair arbitrage.
Details: The script will look for all arbitrage opportunities for a given base currency. If only a main account is specified, the script will only look for cross pair arbitrage opportunities on the exchange of the account. However, if both a main and a secondary accounts are specified, the script will look for all combinations of arbitrage opportunities (i.e. cross pairs on the main account exchange, cross pairs on the secondary account exchange, same pair and cross pairs accross both exchanges). Arbitrage opportunities are defined by the threshold parameter.
Warning: For cross exchange arbitrage (whether same pair or cross pair), rebalance will be needed at times between the main and secondary accounts. Losses will be incurred if the threshold parameter is not large enough to cover fees (see below).
Use cases: Generate profits from price discrepancies between pairs for a given base currency. Works very well in combination with maker to effectively reduce price discrepancies between pairs for a given currency, especially major pairs on small exchanges that want to reduce adverse arbitrage opportunities and pairs with price dicrepancies for a given token in order to reduce adverse arbitrage opportunities.

Account(s): Main account only for same exchange cross pair arbitrage; main account and secondary account for both same exchange and cross exchange arbitrage (whether same pair or cross pair).

Liquidity Pool Arbitrage

Purpose: For a given base currency, the swaparb strategy can do arbitrage between an exchange and a liquidity pool.
Details: The script will look for all arbitrage opportunities for a given base currency. Arbitrage opportunities are defined by the threshold parameter.
Warning: Rebalance will be needed at times between the main account and swap wallet. Losses will be incurred if the threshold parameter is not large enough to cover fees (see below).
Use cases: Generate profits from price discrepancies between pairs for a given base currency.

Account(s): Both main account and swap wallet. Main account is the account on the exchange that is not the liquidity pool, swap wallet is the wallet connected to the liquidity pool. The swap account first needs to follow the instructions on the liquidity pool to approve swaping for the desired pair.

Pools Arbitrage

Purpose: For a given base currency, the poolsarb strategy can do arbitrage between liquidity pools.
Details: The script will look for all arbitrage opportunities for a given base currency. Arbitrage opportunities are defined by the threshold parameter.
Warning: Rebalance will be needed at times between the main wallet and secondary wallet. Losses will be incurred if the threshold parameter is not large enough to cover fees (see below).
Use cases: Generate profits from price discrepancies between pools for a given base currency.

Account(s): Both main wallet and secondary wallet. Wallets first need to follow the instructions on the liquidity pools to approve swaping for the desired pairs.

Market Entry (or Buy-Back, or Accumulate)

Script class symbol: enter

Purpose: The enter strategy is designed to efficiently purchase a large amount of tokens on the secondary market without influencing the price and suffering from a large slippage.
Details: The user specifies a certain price threshold and the script will purchase as much as possible at or under that threshold.
Use cases: Efficiently accumulate tokens at the lowest price possible, build a price support (that can be moved up gradually).

Account(s): Main account only.

Market Exit (or Sell-Off, or Liquidate)

Script class symbol: exit

Purpose: The exit strategy is designed to efficiently sell a large amount of tokens on the secondary market without influencing the price and suffering from a large slippage.
Details: The user specifies a certain price threshold and the script will sell as much as possible at or above that threshold.
Use cases: Efficiently liquidate tokens at the highest price possible.

Account(s): Main account only.

Smart Swap

Script class symbol: smartswap

Purpose: smartswap allows to specify conditional swaps on liquidity pools.
Warning: This is a relatively advanced script class, please reach out if more information is necessary before implementing it.

Account(s): swap wallet. Swap wallet is the wallet connected to the liquidity pool. The swap account first needs to follow the instructions on the liquidity pool to approve swaping for the desired pair.

Smartswap Expression

smartswapExpression is a special expression that is used for the smartswap script class. It follows standard python syntax and can use the following expression variables:

API Expression

apiExpression is used to get values from third party APIs. Only REST APIs with a json response body are supported.

To create an API expression, the first step is to construct a json object that has the following attributes:

Once the json object is constructed, convert it to str and encode it with base64.

Finally, add REST- at the beginning of the base64 encoded string. The API expression should look like this: REST-eyJ1cmwiOiAiaHR0cHM6Ly9hcGkuYmluYW5jZS5jb20vYXBpL3YzL3RpY2tlci8yNGhyP3N5bWJvbD1CTkJCVEMiLCAibWV0aG9kIjogImdldCIsICJrZXlDaGFpbiI6IFsibGFzdFByaWNlIl19

Keychain Example

Assuming the raw response of the API is as follows:

{
    "key1": {
      "key11": 6,
      "key12": [
        1,
        3,
        7
      ]
    },
    "key2": 10
  }

The keyChain should be an array of keys that leads to the value to be resolved. If the value to be resolved is 3, the keyChain should be ["key1", "key12", 1]. If the value to be resolved is 10, the keyChain should be ["key2"]. Note that the index of an array starts from 0.

Scheduled Orders

Script class symbol: schedule

Purpose: schedule recursive orders over time, spaced out by a given time interval.
Details: Every time it places a buy order, it will use the account that has more quote currency; everytime it places a sell order, it will use the account that has less quote currency.
Use cases: Customize a trading strategy without any coding background.

Account(s): Main account, secondary account is optional.

Note: at least one pair (buyAmount, buyPrice) and/or (sellAmount, sellPrice) has to be specified.

HTClient Components

Accounts

Accounts are the exchanges accounts. Accounts also more broadly designate wallets connected to liquidity pools (note that you first need to approve a wallet for swaping on given pair of a liquidity pool before being able to use it on HTClient).
An account is defined by: the exchange it is on and its API keys. Some exchanges may require a trading password; others may require to specify if the main account is to be used (input $main in the relevant field in HTClient's account page) or if a subaccount is to be used; yet others (such as liquidity pools) require wallet information.

The exchanges currently supported are: binance, huobi, kraken, kucoin, bithumb, bitfinex, uniswap, pancakeswap, gate.io, okex, bittrex, ftx, poloniex, liquid, ascendex, upbit, probit, mxc.com, hitbtc, bitcoin.com, digifinex, whitebit, bitrue, bitbns, cointiger, latoken, coineal, lbank, bitforex, bw.com, btse, dragonex, bitmart, stex, biki, vitex, idex, coinall, bispex, smartvalor, nbx, mandala.

Scripts

Scripts are the algorithms that run on our servers.
A script is defined by: script class, parameters and account(s) it uses.
Note that you cannot run multiple script classes for the same market(pair) with the same account.

Classes

A script class is the strategy that a script uses. There are public script classes that are available for all users, and there are also customized script classes that are defined by each individual user.

The public script classes are: maker, stable, replication, migrate, arbitrage, swaparb, poolsarb, enter, exit, smartswap and schedule.

HTClient User Interface

Accounts Page

The account page is used to add new accounts, manage the existing accounts, and balances.

Scripts Page

The scripts page is used to add new scripts, manage and monitor existing scripts, clear orders and storage, check the server logs of a script and download reports (reports can be downloaded individually following the config parameters of each script or in bulk using the top right button which takes into consideration search key words). For some script classes, the recommended funding can be checked based on the parameters it uses.

Classes Page

The classes page is used to create and manage customized script classes.

Monitor Page

The monitor page displays all the scripts that may require attention on one screen.

In each script monitor, Monitor Metrics is displayed on the left and Server Logs is displayed on the right.
The Monitor Metrics field displays some metrics of the script, account balances in the format: available/total. If the script monitor of a script is displayed on the monitor page, it shows that some of the script metrics are different from the config parameters settings. If that happens, check the Server Logs field to see if there is any error.

If there is no error in logs, the script will normally correct itself and maintain the right metrics.
If there are errors in logs, some action will have to be taken according to the error. For example, if the error says insufficient balance, you will have to refill the account accordingly.
In case the error returned by the exchange is not clear, i.e. the exchange returns an error followed by a number, please refer to the error section of the API documentation of that exchange for more information on the error encountered. A general error encountered happens when an exchange performs maintenance: in that case the error will have an HTML format (involving characters such as <>), at that time the script is not running and no new order is being placed.

HedgeTech Account Page

The HedgeTech account page shows user's information and allows to manage subscription and change password.

Settings Page

The settings page is used to customize the number of logs for the monitor, the monitor refresh rate and the report dates. It provides the app version number as well as useful links such as root directory (where reports can be found), documentation, terms of use and privacy policy.

Search Bars

Several terms separated by commas can be entered when searching. Spaces are ignored.
If all these terms are contained in an account name, script name, script class or status (online or offline), the appropriate results will be shown; otherwise nothing will be displayed.
When using the search bar within the monitor page, the results will be displayed among the items present on the last update of the monitor. Searching something will not update the monitor.

Customized Scripts

Coding background is required passed this point.

Customized scripts allow to define your own script class and run it on our backend, thus benefiting from our centralized script management, exchange integration and servers stability and scalability.

Components

To define a customized script class, the following components need to be defined: Meta, Code Block and Monitor Metrics.

Meta

Meta is a json object that defines the required and optional config parameters and accounts. It has to following attributes:

In addition to what is defined in Meta, there will be two public config parameters that apply to all customized script classes:

Note: if the account type main is defined, the exchange logo of that account will be displayed within the script on the monitor page.

Code Block

Code block is the code that defines what the script will do within each iteration. It follows python3.6 runtime, and it supports the following libraries: requests, websocket_client, numpy, scipy, pandas and Crypto. In addition predefined functions and objects can be used, and it is possible to interact with the server storage, server logs and the exchanges APIs.

Any Exception raised will be output to the server logs, you can use "View Logs" in the script page to debug your code.

In code block, all variables you defined will not be considered as global. In the functions or classes, if you want to refer to a name in a way that has been defined previously, you have to pass it in the argument. Otherwise it will raise a nameError. Here is an example:

message = 'hello world'

def output():
  log(message)

output()

The above code will raise a nameError: name "message" is not defined. Instead, you should use the following code:

message = 'hellow world'

def output(message):
  log(message)

output(message)

Monitor Metrics

Monitor metrics determine what will be displayed within the script monitor on the script page and monitor page. As many monitor metrics as needed can be defined. Each monitor metric has the following three attributes:

Predefined Functions and Objects

The following objects and functions are predefined, they can be used in the code block and the expressions of the monitor metrics. Warning: these names shall not be overwritten when working on the code block.

Get the config parameter value

get(key)

It returns the value of the config parameter. If the config parameter is not defined, it returns None.

Interact with the script storage

Each script has a designated storage that can store key/value pairs. The following functions are used to interact with them.

read(key)

It returns the value associated with the key in the storage. If the key is not defined, it returns None.

write(key, value)

This function writes a key/value pair in the storage.

Output to logs

Use the following function to output a message to logs instead of the print statement:

log(message)

Check CoinGecko price

market_price(symbol, fullName=None)

It returns the reported price of the token/coin in USD.

Get Exchange API Client

HT(accType)

It returns a Client object that can be used to interact with the exchange API.

The Exchange API Client

The Client object represents an account that is used by the script. It is used to interact with the exchange API. Note that the proper way to get an instance of this class is to call the HT function. The following are the methods defined:

Get the orderbook

Client.orderbook(self, base, quote)

It returns a nested dict, i.e.

{
  	'asks': [
  		{
  			'price': 9186,
  			'volume': 0.32
  		},
  		...
  	],
  	'bids': [
  		{
  			'price': 9185,
  			'volume': 1.05
  		},
  		...
  	]
  }

Get the rolling 24 hours volume in USD

Client.volume24(self, baes, quote)

It returns the rolling 24 hours volume in USD as a float.

Get the last traded price

Client.last(self, base, quote)

It returns the last traded price as a float.

Get the pair meta

Client.meta(self, base, quote)

It returns a dict that is defined as follows:

Check balance of the account

Client.balance(self, *args)

It returns a nested dict, i.e.:

{
  	'btc': {
  		'available': 3.5,
  		'total': 3.7
  	},
  	...
  }

Place an order

Client.place_order(self, base, quote, side, volume, price)

It returns {'success': True} if the order goes through; it raises an Exception with the exchange error message if it does not go through.

Get all open orders

Client.get_orders(self, base, quote)

It returns a nested dict, i.e.:

{
  	'asks': [
  		{
  			'symbol': 'btc_usdt',
  			'_type': 'ask',
  			'price': 9186,
  			'volume': 0.58,
  			'order_id': 49830927
  		},
  		...
  	],
  	'bids': []
  }

Cancel an order

Client.cancel(self, order)

The argument order is a dict that has the same format as the return of the get_orders function, order can be referred to the element of the 'asks' or 'bids' field from the return of the get_orders function, i.e.:

{
  	'symbol': 'btc_usdt',
  	'_type': 'ask',
  	'price': 9186,
  	'volume': 0.58,
  	'order_id': 49830927
  }

It returns {'success': True} if the order is cancelled successfully; it raises an Exception with the exchange error message if cancelling does not go through.

Cancel all orders for a certain pair

Client.cancel_all(self, base, quote)

It returns {'success': True} if all orders are cancelled successfully; it raises an Exception with the exchange error message if one or more order(s) did not get cancelled.