@d8x/perpetuals-sdk 0.0.1

package/dist/writeAccessHandler.js

@@ -0,0 +1,95 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const perpetualDataHandler_1 = __importDefault(require("./perpetualDataHandler"));
+const nodeSDKTypes_1 = require("./nodeSDKTypes");
+const utils_1 = require("./utils");
+const d8XMath_1 = require("./d8XMath");
+/**
+ * This is a parent class for the classes that require
+ * write access to the contracts.
+ * This class requires a private key and executes smart-contract interaction that
+ * require gas-payments.
+ */
+class WriteAccessHandler extends perpetualDataHandler_1.default {
+    /**
+     * Constructor
+     * @param config configuration
+     * @param privateKey private key of account that trades
+     */
+    constructor(config, privateKey) {
+        super(config);
+        this.traderAddr = "";
+        this.signer = null;
+        this.gasLimit = 15000000;
+        this.chainId = 0;
+        this.privateKey = privateKey;
+        if (config.gasLimit != undefined) {
+            this.gasLimit = config.gasLimit;
+        }
+    }
+    /**
+     * Initialize the AccountTrade-Class with this function
+     * to create instance of D8X perpetual contract and gather information
+     * about perpetual currencies
+     */
+    createProxyInstance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.provider = new ethers_1.ethers.providers.JsonRpcProvider(this.nodeURL);
+            const wallet = new ethers_1.ethers.Wallet(this.privateKey);
+            this.signer = wallet.connect(this.provider);
+            yield this.initContractsAndData(this.signer);
+            this.traderAddr = wallet.address;
+            this.chainId = (yield this.provider.getNetwork()).chainId;
+        });
+    }
+    /**
+     * Set allowance for ar margin token (e.g., MATIC, ETH, USDC)
+     * @param symbol token in 'long-form' such as MATIC, symbol also fine (ETH-USD-MATIC)
+     * @param amount optional, amount to approve if not 'infinity'
+     * @returns transaction hash
+     */
+    setAllowance(symbol, amount = undefined) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //extract margin-currency name
+            let symbolarr = symbol.split("-");
+            symbol = symbol.length == 3 ? symbolarr[2] : symbolarr[0];
+            //transform into bytes4 currencies (without the space): "BTC", "USD", "MATC"
+            symbol = (0, utils_1.to4Chars)(symbol);
+            symbol = symbol.replace(/\0/g, "");
+            let marginTokenAddr = this.symbolToTokenAddrMap.get(symbol);
+            if (marginTokenAddr == undefined || this.signer == null) {
+                throw Error("No margin token or signer defined, call createProxyInstance");
+            }
+            let amountDec18;
+            if (amount == undefined) {
+                amountDec18 = nodeSDKTypes_1.MAX_UINT_256;
+            }
+            else {
+                amountDec18 = (0, d8XMath_1.floatToDec18)(amount);
+            }
+            return WriteAccessHandler._setAllowance(marginTokenAddr, this.proxyAddr, this.signer, amountDec18);
+        });
+    }
+    static _setAllowance(tokenAddr, proxyAddr, signer, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marginToken = new ethers_1.ethers.Contract(tokenAddr, nodeSDKTypes_1.ERC20_ABI, signer);
+            let tx = yield marginToken.approve(proxyAddr, amount);
+            yield tx.wait();
+            return tx.hash;
+        });
+    }
+}
+exports.default = WriteAccessHandler;

package/module.d.ts

@@ -0,0 +1 @@
+declare module "@d8x/perpetuals-sdk";

package/package.json

@@ -0,0 +1,63 @@
+{
+  "dependencies": {
+    "@babel/core": "^7.20.2",
+    "@types/jest": "^29.2.3",
+    "@types/node": "^18.11.9",
+    "babel-jest": "^29.3.1",
+    "ethers": "^5.7.2",
+    "jest": "^29.3.1",
+    "ts-jest": "^29.0.3",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.3"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:doc": "jsdoc2md --files ./src/accountTrade.ts --configure ./jsdoc2md.json > ./doc/accountTrade.md",
+    "test": "jest",
+    "coverage": "nyc -r lcov -e .ts -x \"*.test.ts\" npm run test"
+  },
+  "devDependencies": {
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/plugin-proposal-object-rest-spread": "^7.20.2",
+    "@babel/preset-env": "^7.20.2",
+    "@babel/preset-typescript": "^7.18.6",
+    "jsdoc-babel": "^0.5.0",
+    "jsdoc-to-markdown": "^7.1.1",
+    "json2md": "^2.0.0"
+  },
+  "name": "@d8x/perpetuals-sdk",
+  "description": "Node TypeScript SDK for D8X Perpetual Futures",
+  "version": "0.0.1",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "directories": {
+    "test": "test"
+  },
+  "files": [
+    "module.d.ts",
+    "src/*.ts",
+    "src/*.json",
+    "src/*.md",
+    "dist/*.ts",
+    "dist/*.js",
+    "abi/*.json",
+    "config/*.json"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/D8-X/d8x-futures-node-sdk.git"
+  },
+  "keywords": [
+    "d8x",
+    "perpetuals",
+    "node",
+    "sdk",
+    "api"
+  ],
+  "author": "d8x",
+  "license": "UNLICENSED",
+  "bugs": {
+    "url": "https://github.com/D8-X/d8x-futures-node-sdk/issues"
+  },
+  "homepage": "https://github.com/D8-X/d8x-futures-node-sdk#readme"
+}

package/src/accountTrade.ts

@@ -0,0 +1,217 @@
+import { BigNumber, BigNumberish, ethers, Wallet } from "ethers";
+import {
+  BUY_SIDE,
+  NodeSDKConfig,
+  Order,
+  SmartContractOrder,
+  SELL_SIDE,
+  ZERO_ADDRESS,
+  MAX_64x64,
+  MAX_UINT_256,
+  ORDER_MAX_DURATION_SEC,
+  ORDER_TYPE_LIMIT,
+  ORDER_TYPE_MARKET,
+  ORDER_TYPE_STOP_MARKET,
+  ORDER_TYPE_STOP_LIMIT,
+  MASK_CLOSE_ONLY,
+  MASK_LIMIT_ORDER,
+  MASK_MARKET_ORDER,
+  MASK_STOP_ORDER,
+  MASK_KEEP_POS_LEVERAGE,
+  COLLATERAL_CURRENCY_BASE,
+  COLLATERAL_CURRENCY_QUOTE,
+  ERC20_ABI,
+  PerpetualStaticInfo,
+} from "./nodeSDKTypes";
+import { floatToABK64x64, ABK64x64ToFloat, dec18ToFloat } from "./d8XMath";
+import { combineFlags, to4Chars } from "./utils";
+import WriteAccessHandler from "./writeAccessHandler";
+//import { abi, rawEncode } from "ethereumjs-abi";
+
+/**
+ * Account and Trade.
+ * This class requires a private key and executes smart-contract interaction that
+ * require gas-payments.
+ */
+export default class AccountTrade extends WriteAccessHandler {
+  /**
+   * Constructor
+   * @param {NodeSDKConfig} config Configuration object, see PerpetualDataHandler.readSDKConfig.
+   * @param {string} privateKey Private key of account that trades.
+   */
+  public constructor(config: NodeSDKConfig, privateKey: string) {
+    super(config, privateKey);
+  }
+
+  /**
+   * Cancels an existing order on the exchange.
+   * @param {string} symbol Symbol of the form ETH-USD-MATIC.
+   * @param {string} orderId ID of the order to be cancelled.
+   */
+  public async cancelOrder(symbol: string, orderId: string): Promise<string | undefined> {
+    if (this.proxyContract == null || this.signer == null) {
+      throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
+    }
+    let orderBookContract: ethers.Contract | null = null;
+    orderBookContract = this.getOrderBookContract(symbol);
+
+    return await this._cancelOrder(symbol, orderId, orderBookContract);
+  }
+
+  /*
+    TODO: -deposit (margin into account)
+          -withdraw margin withdraw(uint24 _iPerpetualId, int128 _fAmount)
+
+  */
+
+  /**
+   * Submits an order to the exchange.
+   * @param {Order} order Order struct.
+   * @returns {string} Transaction hash.
+   */
+  public async order(order: Order): Promise<string | undefined> {
+    if (this.proxyContract == null || this.signer == null) {
+      throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
+    }
+    let orderBookContract: ethers.Contract | null = null;
+    if (order.type != ORDER_TYPE_MARKET) {
+      orderBookContract = this.getOrderBookContract(order.symbol);
+    }
+    return await this._order(
+      order,
+      this.traderAddr,
+      this.symbolToPerpStaticInfo,
+      this.proxyContract,
+      orderBookContract,
+      this.chainId,
+      this.signer,
+      this.gasLimit
+    );
+  }
+
+  /**
+   * Static order function
+   * @param order order type (not SmartContractOrder but Order)
+   * @param traderAddr trader address
+   * @param symbolToPerpetualMap maps the symbol (MATIC-USD-MATIC)-type format to the perpetual id
+   * @param proxyContract contract instance of D8X perpetuals
+   * @param orderBookContract order book contract or null
+   * @param chainId chain Id of network
+   * @param signer instance of ethers wallet that can write
+   * @param gasLimit gas limit to be used for the trade
+   * @returns transaction hash
+   * @ignore
+   */
+  public async _order(
+    order: Order,
+    traderAddr: string,
+    symbolToPerpetualMap: Map<string, PerpetualStaticInfo>,
+    proxyContract: ethers.Contract,
+    orderBookContract: ethers.Contract | null,
+    chainId: number,
+    signer: ethers.Wallet,
+    gasLimit: number
+  ): Promise<string | undefined> {
+    let scOrder = AccountTrade.toSmartContractOrder(order, traderAddr, symbolToPerpetualMap);
+    // if we are here, we have a clean order
+    // decide whether to send order to Limit Order Book or AMM based on order type
+    let tx: ethers.Transaction;
+    if (order.type == ORDER_TYPE_MARKET) {
+      // send market order
+      tx = await proxyContract.trade(scOrder, { gasLimit: gasLimit });
+    } else {
+      // conditional order so the order is sent to the order-book
+      if (orderBookContract == null) {
+        throw Error("Order book contract not provided.");
+      }
+      let signature = await this._createSignature(scOrder, chainId, true, signer, proxyContract.address);
+      tx = await orderBookContract.createLimitOrder(scOrder, signature, { gasLimit: gasLimit });
+    }
+    return tx.hash;
+  }
+
+  protected async _cancelOrder(
+    symbol: string,
+    orderId: string,
+    orderBookContract: ethers.Contract | null
+  ): Promise<string | undefined> {
+    if (orderBookContract == null || this.signer == null) {
+      throw Error(`Order Book contract for symbol ${symbol} or signer not defined`);
+    }
+    let scOrder: SmartContractOrder = await orderBookContract.orderOfDigest(orderId);
+    let signature = await this._createSignature(scOrder, this.chainId, false, this.signer, this.proxyAddr);
+    return await orderBookContract.cancelLimitOrder(orderId, signature);
+  }
+
+  /**
+   * Creates a signature
+   * @param order         smart-contract-type order
+   * @param chainId       chainId of network
+   * @param isNewOrder    true unless we cancel
+   * @param signer        ethereum-type wallet
+   * @param proxyAddress  address of the contract
+   * @returns signature as string
+   * @ignore
+   */
+  private async _createSignature(
+    order: SmartContractOrder,
+    chainId: number,
+    isNewOrder: boolean,
+    signer: ethers.Wallet,
+    proxyAddress: string
+  ): Promise<String> {
+    const NAME = "Perpetual Trade Manager";
+    const DOMAIN_TYPEHASH = ethers.utils.keccak256(
+      Buffer.from("EIP712Domain(string name,uint256 chainId,address verifyingContract)")
+    );
+    let abiCoder = ethers.utils.defaultAbiCoder;
+    let domainSeparator = ethers.utils.keccak256(
+      abiCoder.encode(
+        ["bytes32", "bytes32", "uint256", "address"],
+        [DOMAIN_TYPEHASH, ethers.utils.keccak256(Buffer.from(NAME)), chainId, proxyAddress]
+      )
+    );
+    const TRADE_ORDER_TYPEHASH = ethers.utils.keccak256(
+      Buffer.from(
+        "Order(uint24 iPerpetualId,uint16 brokerFeeTbps,address traderAddr,address brokerAddr,int128 fAmount,int128 fLimitPrice,int128 fTriggerPrice,uint256 iDeadline,uint32 flags,int128 fLeverage,uint256 createdTimestamp)"
+      )
+    );
+    let structHash = ethers.utils.keccak256(
+      abiCoder.encode(
+        [
+          "bytes32",
+          "uint24",
+          "uint16",
+          "address",
+          "address",
+          "int128",
+          "int128",
+          "int128",
+          "uint256",
+          "uint32",
+          "int128",
+          "uint256",
+        ],
+        [
+          TRADE_ORDER_TYPEHASH,
+          order.iPerpetualId,
+          order.brokerFeeTbps,
+          order.traderAddr,
+          order.brokerAddr,
+          order.fAmount,
+          order.fLimitPrice,
+          order.fTriggerPrice,
+          order.iDeadline,
+          order.flags,
+          order.fLeverage,
+          order.createdTimestamp,
+        ]
+      )
+    );
+    let digest = ethers.utils.keccak256(
+      abiCoder.encode(["bytes32", "bytes32", "bool"], [domainSeparator, structHash, isNewOrder])
+    );
+    let digestBuffer = Buffer.from(digest.substring(2, digest.length), "hex");
+    return await signer.signMessage(digestBuffer);
+  }
+}

package/src/brokerTool.ts

@@ -0,0 +1,155 @@
+import WriteAccessHandler from "./writeAccessHandler";
+import { NodeSDKConfig, Order, ORDER_MAX_DURATION_SEC, ZERO_ADDRESS } from "./nodeSDKTypes";
+import PerpetualDataHandler from "./perpetualDataHandler";
+import { ABK64x64ToFloat } from "./d8XMath";
+import { text } from "stream/consumers";
+import { ethers } from "ethers";
+import AccountTrade from "./accountTrade";
+/**
+ * BrokerTool.
+ * Signature method for brokers
+ */
+export default class BrokerTool extends WriteAccessHandler {
+  /**
+   * Constructor
+   * @param config configuration
+   * @param privateKey private key of account that trades
+   */
+  public constructor(config: NodeSDKConfig, privateKey: string) {
+    super(config, privateKey);
+  }
+
+  /**
+   *
+   * @param symbol symbol of the form "ETH-USD-MATIC" or just "MATIC"
+   * @returns broker lot size in collateral currency, e.g. in MATIC for symbol ETH-USD-MATIC or MATIC
+   */
+  public async getLotSize(symbol: string): Promise<number | undefined> {
+    if (this.proxyContract == null) {
+      throw Error("no proxy contract initialized. Use createProxyInstance().");
+    }
+    let poolId = PerpetualDataHandler._getPoolIdFromSymbol(symbol, this.poolStaticInfos);
+    let pool = await this.proxyContract.getLiquidityPool(poolId);
+    let lot = pool?.fBrokerCollateralLotSize;
+    if (lot != undefined) {
+      lot = ABK64x64ToFloat(pool.fBrokerCollateralLotSize);
+    }
+    return lot;
+  }
+
+  public async brokerDepositToDefaultFund(symbol: string, lots: number): Promise<ethers.providers.TransactionResponse> {
+    if (this.proxyContract == null || this.signer == null) {
+      throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
+    }
+    let poolId = PerpetualDataHandler._getPoolIdFromSymbol(symbol, this.poolStaticInfos);
+    let tx = await this.proxyContract.brokerDepositToDefaultFund(poolId, lots, { gasLimit: this.gasLimit });
+    return tx;
+  }
+
+  public async getFeeForBrokerVolume(symbol: string): Promise<number | undefined> {
+    if (this.proxyContract == null) {
+      throw Error("no proxy contract initialized.");
+    }
+    let poolId = PerpetualDataHandler._getPoolIdFromSymbol(symbol, this.poolStaticInfos);
+    let feeTbps = await this.proxyContract.getFeeForBrokerVolume(poolId, this.traderAddr);
+    return feeTbps / 100_000;
+  }
+
+  /**
+   *
+   * @param symbol symbol of the form "ETH-USD-MATIC" or just "MATIC"
+   * @returns number of lots deposited by broker
+   */
+  public async getBrokerDesignation(symbol: string): Promise<number> {
+    if (this.proxyContract == null) {
+      throw Error("no proxy contract initialized.");
+    }
+    let poolId = PerpetualDataHandler._getPoolIdFromSymbol(symbol, this.poolStaticInfos);
+    let designation = await this.proxyContract.getBrokerDesignation(poolId, this.traderAddr);
+    return designation;
+  }
+
+  /**
+   * @param symbol symbol of the form "ETH-USD-MATIC" or just "MATIC"
+   * @param lots number of lots for which to get the fee. Defaults to this broker's current deposit if not specified
+   * @returns fee in decimals based on given number of lots
+   */
+  public async getFeeForBrokerDesignation(symbol: string, newLots: number = 0): Promise<number | undefined> {
+    if (this.proxyContract == null) {
+      throw Error("no proxy contract initialized.");
+    }
+    if (newLots < 0) {
+      throw Error("new lots must be a positive number.");
+    }
+    let lots = await this.getBrokerDesignation(symbol);
+    lots += newLots;
+    let feeTbps = await this.proxyContract.getFeeForBrokerDesignation(lots);
+    return feeTbps / 100_000;
+  }
+
+  /**
+   * @param order order for which to determine the trading fee
+   * @param traderAddr address of the trader for whom to determine the fee, defaults to lowest tier
+   * @returns fee in decimals (1% is 0.01)
+   */
+  public async determineExchangeFee(order: Order, traderAddr: string = ZERO_ADDRESS): Promise<number | undefined> {
+    if (this.proxyContract == null) {
+      throw Error("no proxy contract initialized.");
+    }
+    // broker does not need to enter address in the order if he's signed in
+    if (order.brokerAddr == undefined) {
+      if (this.signer == null) {
+        throw Error("no wallet initialized.");
+      }
+      order.brokerAddr = this.traderAddr;
+    }
+    let scOrder = AccountTrade.toSmartContractOrder(order, traderAddr, this.symbolToPerpStaticInfo);
+    let feeTbps = await this.proxyContract.determineExchangeFee(scOrder);
+    return feeTbps / 100_000;
+  }
+
+  // public async sign(traderAddr: string, deadline: number, fee: number): Promise<string> {
+  //   /**
+  //    * structHash = keccak256(
+  //           abi.encode(
+  //               TRADE_BROKER_TYPEHASH,
+  //               _order.iPerpetualId,
+  //               _order.brokerFeeTbps,
+  //               _order.traderAddr,
+  //               _order.iDeadline
+  //           )
+  //       );
+  //       return structHash;
+  //    */
+  //   const NAME = "Perpetual Trade Manager";
+  //   const DOMAIN_TYPEHASH = ethers.utils.keccak256(
+  //     Buffer.from("EIP712Domain(string name,uint256 chainId,address verifyingContract)")
+  //   );
+  //   let abiCoder = ethers.utils.defaultAbiCoder;
+  //   let domainSeparator = ethers.utils.keccak256(
+  //     abiCoder.encode(
+  //       ["bytes32", "bytes32", "uint256", "address"],
+  //       [DOMAIN_TYPEHASH, ethers.utils.keccak256(Buffer.from(NAME)), chainId, proxyAddress]
+  //     )
+  //   );
+  //   let digest = ethers.utils.keccak256(
+  //     abiCoder.encode(["bytes32", "bytes32", "bool"], [domainSeparator, structHash, isNewOrder])
+  //   );
+  //   let digestBuffer = Buffer.from(digest.substring(2, digest.length), "hex");
+  //   return await signer.signMessage(digestBuffer);
+  // }
+
+  /*
+  TODO:
+  - get lot size DONE
+  - purchase n lots:
+      brokerDepositToDefaultFund(symbol, amountLots) DONE
+  - fees:
+      getFeeForBrokerVolume DONE
+      determineExchangeFee(order) DONE
+      getBrokerDesignation DONE
+      getFeeForBrokerDesignation DONE
+  - get fee for trader and broker
+  - sign {trader address, deadline, broker fee}
+  */
+}