@d8x/perpetuals-sdk 0.0.3 → 0.0.5

package/README.md

@@ -15,3 +15,10 @@ Node TypeScript SDK for D8X Perpetual Futures
 ### Test
 
 `npm test`
+
+### NPM Package Deployment
+
+`npm run build`
+`npm login`
+increase version via `npm version patch`
+`npm publish`

package/config/defaultConfig.json

@@ -1,6 +1,6 @@
 {
   "name": "v1.1",
-  "proxyAddr": "0x55F4041DAea27c6F380d6E221d63EF300a293Ee5",
+  "proxyAddr": "0x51b05809eF1E84BB963D84ff95FB5E625d88152d",
   "nodeURL": "https://rpc-mumbai.maticvigil.com/",
   "proxyABILocation": "../abi/IPerpetualManager.json",
   "limitOrderBookFactoryAddr": "0xd63Faf780687795EBac85ce248a45E457752f021",

package/dist/brokerTool.d.ts

@@ -34,7 +34,7 @@ export default class BrokerTool extends WriteAccessHandler {
      * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
      * @returns {number} Fee based solely on a broker's traded volume in the corresponding pool, in decimals (i.e. 0.1% is 0.001).
      */
-    getFeeForBrokerVolume(poolSymbolName: string): Promise<number>;
+    getFeeForBrokerVolume(poolSymbolName: string): Promise<number | undefined>;
     /**
      * Determine the exchange fee based on the current D8X balance in a broker's wallet.
      * The final exchange fee paid by the broker is equal to

package/dist/liquidatorTool.d.ts

@@ -45,8 +45,8 @@ export default class LiquidatorTool extends WriteAccessHandler {
      * Get addresses of active accounts by chunks.
      * @param {string} symbol Symbol of the form ETH-USD-MATIC.
      * @param {number} from From which account we start counting (0-indexed).
-     * @param {number} to Until which account we count, non inclusive.
-     * @returns {string[]} Array of addresses at locations 'from', 'from'+1 ,..., 'to'-1.
+     * @param {number} to Until which account we count.
+     * @returns {string[]} Array of addresses.
      */
     getActiveAccountsByChunks(symbol: string, from: number, to: number): Promise<string[]>;
     /**

package/dist/liquidatorTool.js

@@ -60,7 +60,7 @@ class LiquidatorTool extends writeAccessHandler_1.default {
                 throw Error("no proxy contract initialized. Use createProxyInstance().");
             }
             let perpID = LiquidatorTool.symbolToPerpetualId(symbol, this.symbolToPerpStaticInfo);
-            return yield this.proxyContract.isTraderMaintenanceMarginSafe(perpID, traderAddr);
+            return yield this.proxyContract.isMaintenanceMarginSafe(perpID, traderAddr);
         });
     }
     /**
@@ -97,8 +97,8 @@ class LiquidatorTool extends writeAccessHandler_1.default {
      * Get addresses of active accounts by chunks.
      * @param {string} symbol Symbol of the form ETH-USD-MATIC.
      * @param {number} from From which account we start counting (0-indexed).
-     * @param {number} to Until which account we count, non inclusive.
-     * @returns {string[]} Array of addresses at locations 'from', 'from'+1 ,..., 'to'-1.
+     * @param {number} to Until which account we count.
+     * @returns {string[]} Array of addresses.
      */
     getActiveAccountsByChunks(symbol, from, to) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -117,8 +117,8 @@ class LiquidatorTool extends writeAccessHandler_1.default {
     getAllActiveAccounts(symbol) {
         return __awaiter(this, void 0, void 0, function* () {
             // checks are done inside the intermediate functions
-            let totalAccounts = yield this.countActivePerpAccounts(symbol);
-            return yield this.getActiveAccountsByChunks(symbol, 0, totalAccounts);
+            let totalAccoutns = yield this.countActivePerpAccounts(symbol);
+            return yield this.getActiveAccountsByChunks(symbol, 0, totalAccoutns - 1);
         });
     }
 }

package/dist/liquiditatorTool.d.ts

@@ -0,0 +1,14 @@
+import WriteAccessHandler from "./writeAccessHandler";
+import { NodeSDKConfig } from "./nodeSDKTypes";
+/**
+ * LiquidatorTool
+ * Methods to liquidate traders
+ */
+export default class LiquidatorTool extends WriteAccessHandler {
+    /**
+     * Constructor
+     * @param config configuration
+     * @param privateKey private key of account that trades
+     */
+    constructor(config: NodeSDKConfig, privateKey: string);
+}

package/dist/liquiditatorTool.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const writeAccessHandler_1 = __importDefault(require("./writeAccessHandler"));
+/**
+ * LiquidatorTool
+ * Methods to liquidate traders
+ */
+class LiquidatorTool extends writeAccessHandler_1.default {
+    /**
+     * Constructor
+     * @param config configuration
+     * @param privateKey private key of account that trades
+     */
+    constructor(config, privateKey) {
+        super(config, privateKey);
+    }
+}
+exports.default = LiquidatorTool;

package/dist/marketData.d.ts

@@ -31,13 +31,6 @@ export default class MarketData extends PerpetualDataHandler {
      * @returns {MarginAccount}
      */
     positionRisk(traderAddr: string, symbol: string): Promise<MarginAccount>;
-    /**
-     * Uses the Oracle(s) in the exchange to get the latest price of a given index in a given currency, if a route exists.
-     * @param {string} base Index name, e.g. ETH.
-     * @param {string} quote Quote currency, e.g. USD.
-     * @returns {number} Price of index in given currency.
-     */
-    getOraclePrice(base: string, quote: string): Promise<number | undefined>;
     /**
      * Query smart contract to get user orders and convert to user friendly order format.
      * @param {string} traderAddr Address of trader.

package/dist/marketData.js

@@ -75,21 +75,6 @@ class MarketData extends perpetualDataHandler_1.default {
             return mgnAcct;
         });
     }
-    /**
-     * Uses the Oracle(s) in the exchange to get the latest price of a given index in a given currency, if a route exists.
-     * @param {string} base Index name, e.g. ETH.
-     * @param {string} quote Quote currency, e.g. USD.
-     * @returns {number} Price of index in given currency.
-     */
-    getOraclePrice(base, quote) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.proxyContract == null) {
-                throw Error("no proxy contract initialized. Use createProxyInstance().");
-            }
-            let px = yield this.proxyContract.getOraclePrice([(0, utils_1.toBytes4)(base), (0, utils_1.toBytes4)(quote)]);
-            return px == undefined ? undefined : (0, d8XMath_1.ABK64x64ToFloat)(px);
-        });
-    }
     /**
      * Query smart contract to get user orders and convert to user friendly order format.
      * @param {string} traderAddr Address of trader.

package/dist/orderReferrerTool.d.ts

@@ -38,7 +38,7 @@ export default class OrderReferrerTool extends WriteAccessHandler {
      * @param {string} symbol Symbol of the form ETH-USD-MATIC.
      * @param {number} numElements Maximum number of orders to poll.
      * @param {string=} startAfter Optional order ID from where to start polling. Defaults to the first order.
-     * @returns Array of orders and corresponding order IDs
+     * @returns {[Order[], string[]]} Array of orders and corresponding order IDs
      */
     pollLimitOrders(symbol: string, numElements: number, startAfter?: string): Promise<[Order[], string[]]>;
     isTradeable(order: Order): Promise<boolean>;

package/dist/orderReferrerTool.js

@@ -14,7 +14,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const writeAccessHandler_1 = __importDefault(require("./writeAccessHandler"));
 const nodeSDKTypes_1 = require("./nodeSDKTypes");
-const ethers_1 = require("ethers");
 /**
  * Methods to execute existing orders from the limit order book.
  */
@@ -78,7 +77,7 @@ class OrderReferrerTool extends writeAccessHandler_1.default {
      * @param {string} symbol Symbol of the form ETH-USD-MATIC.
      * @param {number} numElements Maximum number of orders to poll.
      * @param {string=} startAfter Optional order ID from where to start polling. Defaults to the first order.
-     * @returns Array of orders and corresponding order IDs
+     * @returns {[Order[], string[]]} Array of orders and corresponding order IDs
      */
     pollLimitOrders(symbol, numElements, startAfter) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -86,7 +85,7 @@ class OrderReferrerTool extends writeAccessHandler_1.default {
                 throw Error("no proxy contract initialized. Use createProxyInstance().");
             }
             if (typeof startAfter == "undefined") {
-                startAfter = ethers_1.ethers.constants.HashZero;
+                startAfter = nodeSDKTypes_1.ZERO_ADDRESS;
             }
             const orderBookSC = this.getOrderBookContract(symbol);
             let [orders, orderIds] = yield orderBookSC.pollLimitOrders(startAfter, numElements);

package/dist/perpetualDataHandler.js

@@ -310,20 +310,16 @@ class PerpetualDataHandler {
         // concatenate and find perpetual Id in map
         return symbols[0] + "-" + symbols[1] + "-" + symbols[2];
     }
-    static _getByValue(map, searchValue, valueField) {
+    static _getByValue(map, searchValue) {
         for (let [key, value] of map.entries()) {
-            if (value[valueField] === searchValue) {
+            if (value === searchValue) {
                 return key;
             }
         }
-        return undefined;
     }
     static fromSmartContractOrder(order, symbolToPerpInfoMap) {
         // find symbol of perpetual id
-        let symbol = PerpetualDataHandler._getByValue(symbolToPerpInfoMap, order.iPerpetualId, "id");
-        if (symbol == undefined) {
-            throw Error(`Perpetual id ${order.iPerpetualId} not found. Check with marketData.exchangeInfo().`);
-        }
+        let symbol = PerpetualDataHandler._getByValue(symbolToPerpInfoMap, order.iPerpetualId);
         let side = order.fAmount > 0 ? nodeSDKTypes_1.BUY_SIDE : nodeSDKTypes_1.SELL_SIDE;
         let limitPrice, stopPrice;
         let fLimitPrice = ethers_1.BigNumber.from(order.fLimitPrice);
@@ -348,9 +344,9 @@ class PerpetualDataHandler {
             reduceOnly: (0, utils_1.containsFlag)(ethers_1.BigNumber.from(order.flags), nodeSDKTypes_1.MASK_CLOSE_ONLY),
             limitPrice: limitPrice,
             keepPositionLvg: (0, utils_1.containsFlag)(ethers_1.BigNumber.from(order.flags), nodeSDKTypes_1.MASK_KEEP_POS_LEVERAGE),
-            brokerFeeTbps: order.brokerFeeTbps == 0 ? undefined : Number(order.brokerFeeTbps),
-            brokerAddr: order.brokerAddr == nodeSDKTypes_1.ZERO_ADDRESS ? undefined : order.brokerAddr,
-            brokerSignature: order.brokerSignature == "0x" ? undefined : order.brokerSignature,
+            brokerFeeTbps: Number(order.brokerFeeTbps),
+            brokerAddr: order.brokerAddr,
+            brokerSignature: order.brokerSignature,
             stopPrice: stopPrice,
             leverage: (0, d8XMath_1.ABK64x64ToFloat)(ethers_1.BigNumber.from(order.fLeverage)),
             deadline: Number(order.iDeadline),

package/package.json

@@ -27,7 +27,7 @@
   },
   "name": "@d8x/perpetuals-sdk",
   "description": "Node TypeScript SDK for D8X Perpetual Futures",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "directories": {

package/src/accountTrade.ts

@@ -49,9 +49,9 @@ export default class AccountTrade extends WriteAccessHandler {
   /**
    * Submits an order to the exchange.
    * @param {Order} order Order struct.
-   * @returns {string} Transaction hash.
+   * @returns {ContractTransaction} Contract Transaction (containing events).
    */
-  public async order(order: Order): Promise<string | undefined> {
+  public async order(order: Order): Promise<ethers.ContractTransaction> {
     if (this.proxyContract == null || this.signer == null) {
       throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
     }
@@ -129,11 +129,11 @@ export default class AccountTrade extends WriteAccessHandler {
     chainId: number,
     signer: ethers.Wallet,
     gasLimit: number
-  ): Promise<string | undefined> {
+  ): Promise<ethers.ContractTransaction> {
     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;
+    let tx: ethers.ContractTransaction;
     if (order.type == ORDER_TYPE_MARKET) {
       // send market order
       tx = await proxyContract.trade(scOrder, { gasLimit: gasLimit });
@@ -145,7 +145,7 @@ export default class AccountTrade extends WriteAccessHandler {
       let signature = await this._createSignature(scOrder, chainId, true, signer, proxyContract.address);
       tx = await orderBookContract.createLimitOrder(scOrder, signature, { gasLimit: gasLimit });
     }
-    return tx.hash;
+    return tx;
   }
 
   protected async _cancelOrder(

package/src/brokerTool.ts

@@ -165,12 +165,9 @@ export default class BrokerTool extends WriteAccessHandler {
    * Deposit lots to the default fund of a given pool.
    * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
    * @param {number} lots Number of lots to deposit into this pool.
-   * @returns {ethers.providers.TransactionResponse} Transaction object.
+   * @returns {ethers.ContractTransaction} ContractTransaction object.
    */
-  public async brokerDepositToDefaultFund(
-    poolSymbolName: string,
-    lots: number
-  ): Promise<ethers.providers.TransactionResponse> {
+  public async brokerDepositToDefaultFund(poolSymbolName: string, lots: number): Promise<ethers.ContractTransaction> {
     if (this.proxyContract == null || this.signer == null) {
       throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
     }

package/src/index.ts

@@ -5,6 +5,7 @@ import MarketData from "./marketData";
 import OrderReferrerTool from "./orderReferrerTool";
 import PerpetualDataHandler from "./perpetualDataHandler";
 import WriteAccessHandler from "./writeAccessHandler";
+import LiquidatorTool from "./liquidatorTool";
 // import {
 //   NodeSDKConfig,
 //   MarginAccount,
@@ -29,4 +30,5 @@ export {
   OrderReferrerTool,
   PerpetualDataHandler,
   WriteAccessHandler,
+  LiquidatorTool,
 };

package/src/liquidityProviderTool.ts

@@ -59,7 +59,7 @@ export default class LiquidityProviderTool extends WriteAccessHandler {
    * @param {number} amountCC  Amount in pool-collateral currency
    * @return Transaction object
    */
-  public async addLiquidity(poolSymbolName: string, amountCC: number): Promise<ethers.providers.TransactionResponse> {
+  public async addLiquidity(poolSymbolName: string, amountCC: number): Promise<ethers.ContractTransaction> {
     if (this.proxyContract == null || this.signer == null) {
       throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
     }

package/src/marketData.ts

@@ -29,6 +29,17 @@ export default class MarketData extends PerpetualDataHandler {
     await this.initContractsAndData(this.provider);
   }
 
+  /**
+   * Get contract instance. Useful for event listening.
+   * @returns read-only proxy instance
+   */
+  public getReadOnlyProxyInstance(): ethers.Contract {
+    if (this.proxyContract == null) {
+      throw Error("no proxy contract initialized. Use createProxyInstance().");
+    }
+    return this.proxyContract;
+  }
+
   /**
    * Information about the products traded in the exchange.
    * @returns {ExchangeInfo} Array of static data for all the pools and perpetuals in the system.
@@ -89,6 +100,36 @@ export default class MarketData extends PerpetualDataHandler {
     return px == undefined ? undefined : ABK64x64ToFloat(px);
   }
 
+  /**
+   * Get the current mark price
+   * @param symbol symbol of the form ETH-USD-MATIC
+   * @returns mark price
+   */
+  public async getMarkPrice(symbol: string): Promise<number> {
+    if (this.proxyContract == null) {
+      throw Error("no proxy contract initialized. Use createProxyInstance().");
+    }
+    return await PerpetualDataHandler._queryPerpetualMarkPrice(symbol, this.symbolToPerpStaticInfo, this.proxyContract);
+  }
+
+  /**
+   * get the current price for a given quantity
+   * @param symbol symbol of the form ETH-USD-MATIC
+   * @param quantity quantity to be traded, negative if short
+   * @returns price (number)
+   */
+  public async getPerpetualPrice(symbol: string, quantity: number): Promise<number> {
+    if (this.proxyContract == null) {
+      throw Error("no proxy contract initialized. Use createProxyInstance().");
+    }
+    return await PerpetualDataHandler._queryPerpetualPrice(
+      symbol,
+      quantity,
+      this.symbolToPerpStaticInfo,
+      this.proxyContract
+    );
+  }
+
   /**
    * Query smart contract to get user orders and convert to user friendly order format.
    * @param {string} traderAddr Address of trader.

package/src/nodeSDKTypes.ts

@@ -1,4 +1,4 @@
-import { BytesLike, BigNumber, BigNumberish } from "ethers";
+import { BytesLike, BigNumber, BigNumberish, constants } from "ethers";
 export const DEFAULT_CONFIG_TESTNET = "../config/defaultConfig.json";
 export const DEFAULT_CONFIG_MAINNET = "notthereyet";
 export const DEFAULT_CONFIG_TESTNET_NAME = "testnet";
@@ -9,7 +9,8 @@ export const COLLATERAL_CURRENCY_QUOTE = 0;
 export const COLLATERAL_CURRENCY_BASE = 1;
 export const COLLATERAL_CURRENCY_QUANTO = 2;
 export const PERP_STATE_STR = ["INVALID", "INITIALIZING", "NORMAL", "EMERGENCY", "CLEARED"];
-export const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+export const ZERO_ADDRESS = constants.AddressZero;
+export const ZERO_ORDER_ID = constants.HashZero;
 
 export const ONE_64x64 = BigNumber.from("0x010000000000000000");
 export const MAX_64x64 = BigNumber.from("0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");

package/src/orderReferrerTool.ts

@@ -1,5 +1,5 @@
 import WriteAccessHandler from "./writeAccessHandler";
-import { BUY_SIDE, NodeSDKConfig, Order, SELL_SIDE, ZERO_ADDRESS } from "./nodeSDKTypes";
+import { BUY_SIDE, NodeSDKConfig, Order, SELL_SIDE, ZERO_ADDRESS, ZERO_ORDER_ID } from "./nodeSDKTypes";
 import { ethers } from "ethers";
 
 /**
@@ -27,7 +27,7 @@ export default class OrderReferrerTool extends WriteAccessHandler {
     symbol: string,
     orderId: string,
     referrerAddr?: string
-  ): Promise<ethers.providers.TransactionResponse> {
+  ): Promise<ethers.ContractTransaction> {
     if (this.proxyContract == null || this.signer == null) {
       throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
     }
@@ -61,6 +61,22 @@ export default class OrderReferrerTool extends WriteAccessHandler {
     return await orderBookSC.numberOfOrderBookDigests();
   }
 
+  /**
+   * Get order from the digest (=id)
+   * @param symbol symbol of order book, e.g. ETH-USD-MATIC
+   * @param digest digest of the order (=order ID)
+   * @returns order or undefined
+   */
+  public async getOrderById(symbol: string, id: string): Promise<Order | undefined> {
+    let ob = await this.getOrderBookContract(symbol);
+    let smartContractOrder = await ob.orderOfDigest(id);
+    if (smartContractOrder.traderAddr == ZERO_ADDRESS) {
+      return undefined;
+    }
+    let order = OrderReferrerTool.fromSmartContractOrder(smartContractOrder, this.symbolToPerpStaticInfo);
+    return order;
+  }
+
   /**
    * Get a list of active conditional orders in the order book.
    * This a read-only action and does not incur in gas costs.
@@ -74,7 +90,7 @@ export default class OrderReferrerTool extends WriteAccessHandler {
       throw Error("no proxy contract initialized. Use createProxyInstance().");
     }
     if (typeof startAfter == "undefined") {
-      startAfter = ethers.constants.HashZero;
+      startAfter = ZERO_ORDER_ID;
     }
     const orderBookSC = this.getOrderBookContract(symbol);
     let [orders, orderIds] = await orderBookSC.pollLimitOrders(startAfter, numElements);
@@ -87,7 +103,12 @@ export default class OrderReferrerTool extends WriteAccessHandler {
     return [userFriendlyOrders, orderIds];
   }
 
-  public async isTradeable(order: Order) {
+  /**
+   * Check if a conditional order can be executed
+   * @param order order structure
+   * @returns true if order can be executed for the current state of the perpetuals
+   */
+  public async isTradeable(order: Order): Promise<boolean> {
     if (this.proxyContract == null) {
       throw Error("no proxy contract initialized. Use createProxyInstance().");
     }
@@ -95,7 +116,7 @@ export default class OrderReferrerTool extends WriteAccessHandler {
       throw Error("order does not have a limit price");
     }
     // check expiration date
-    if (order.deadline != undefined && order.deadline < Date.now()) {
+    if (order.deadline != undefined && order.deadline < Date.now() / 1000) {
       return false;
     }
     // check limit price

package/src/perpetualDataHandler.ts

@@ -301,7 +301,7 @@ export default class PerpetualDataHandler {
   ): Promise<number> {
     let perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
     let ammState = await _proxyContract.getAMMState(perpId);
-    return ABK64x64ToFloat(ammState[6].mul(ONE_64x64.add(ammState[8])));
+    return ABK64x64ToFloat(ammState[6].mul(ONE_64x64.add(ammState[8])).div(ONE_64x64));
   }
 
   /**

package/src/writeAccessHandler.ts

@@ -47,9 +47,12 @@ export default class WriteAccessHandler extends PerpetualDataHandler {
    * 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
+   * @returns ContractTransaction
    */
-  public async setAllowance(symbol: string, amount: number | undefined = undefined): Promise<string> {
+  public async setAllowance(
+    symbol: string,
+    amount: number | undefined = undefined
+  ): Promise<ethers.ContractTransaction> {
     //extract margin-currency name
     let symbolarr = symbol.split("-");
     symbol = symbol.length == 3 ? symbolarr[2] : symbolarr[0];
@@ -74,10 +77,9 @@ export default class WriteAccessHandler extends PerpetualDataHandler {
     proxyAddr: string,
     signer: ethers.Wallet,
     amount: BigNumber
-  ): Promise<string> {
+  ): Promise<ethers.ContractTransaction> {
     const marginToken: ethers.Contract = new ethers.Contract(tokenAddr, ERC20_ABI, signer);
     let tx = await marginToken.approve(proxyAddr, amount);
-    await tx.wait();
-    return tx.hash;
+    return tx;
   }
 }