@d8x/perpetuals-sdk 0.0.23 → 0.0.25

package/config/symbolList.json

@@ -1,9 +1,13 @@
-[
-  { "symbol": "USD", "cleanSymbol": "USD" },
-  { "symbol": "BTC", "cleanSymbol": "BTC" },
-  { "symbol": "ETH", "cleanSymbol": "ETH" },
-  { "symbol": "MATIC", "cleanSymbol": "MATC" },
-  { "symbol": "CHF", "cleanSymbol": "CHF" },
-  { "symbol": "GBP", "cleanSymbol": "GBP" },
-  { "symbol": "XAU", "cleanSymbol": "XAU" }
-]
+{
+  "MATC": "MATIC",
+  "ETH": "ETH",
+  "BTC": "BTC",
+  "USDC": "USDC",
+  "XAU": "XAU",
+  "XAG": "XAG",
+  "USD": "USD",
+  "GBP": "GBP",
+  "CHF": "CHF",
+  "EUR": "EUR",
+  "JPY": "JPY"
+}

package/dist/accountTrade.d.ts

@@ -1,6 +1,7 @@
 import { ethers } from "ethers";
 import { NodeSDKConfig, Order, PerpetualStaticInfo, OrderResponse } from "./nodeSDKTypes";
 import WriteAccessHandler from "./writeAccessHandler";
+import TraderDigests from "./traderDigests";
 /**
  * Functions to create, submit and cancel orders on the exchange.
  * This class requires a private key and executes smart-contract interactions that
@@ -8,6 +9,7 @@ import WriteAccessHandler from "./writeAccessHandler";
  * @extends WriteAccessHandler
  */
 export default class AccountTrade extends WriteAccessHandler {
+    protected digestTool: TraderDigests;
     /**
      * Constructor
      * @param {NodeSDKConfig} config Configuration object, see PerpetualDataHandler.
@@ -204,22 +206,4 @@ export default class AccountTrade extends WriteAccessHandler {
      * @ignore
      */
     private _createSignature;
-    /**
-     * Creates an order-id from the digest. Order-id is the 'digest' used in the smart contract.
-     * @param digest  created with _createDigest
-     * @returns orderId string
-     * @ignore
-     */
-    private createOrderId;
-    /**
-     * Creates a digest (order-id)
-     * @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 digest
-     * @ignore
-     */
-    private _createDigest;
 }

package/dist/accountTrade.js

@@ -12,14 +12,12 @@ 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 strings_1 = require("@ethersproject/strings");
-const bytes_1 = require("@ethersproject/bytes");
 const d8XMath_1 = require("./d8XMath");
 const marketData_1 = __importDefault(require("./marketData"));
 const nodeSDKTypes_1 = require("./nodeSDKTypes");
 const perpetualDataHandler_1 = __importDefault(require("./perpetualDataHandler"));
 const writeAccessHandler_1 = __importDefault(require("./writeAccessHandler"));
+const traderDigests_1 = __importDefault(require("./traderDigests"));
 /**
  * Functions to create, submit and cancel orders on the exchange.
  * This class requires a private key and executes smart-contract interactions that
@@ -49,6 +47,7 @@ class AccountTrade extends writeAccessHandler_1.default {
      */
     constructor(config, privateKey) {
         super(config, privateKey);
+        this.digestTool = new traderDigests_1.default();
     }
     /**
      * Cancels an existing order on the exchange.
@@ -154,8 +153,6 @@ class AccountTrade extends writeAccessHandler_1.default {
                 throw Error("order size too small");
             }
             let orderBookContract = this.getOrderBookContract(order.symbol);
-            let tx;
-            let orderId;
             let res = yield this._order(order, this.traderAddr, this.symbolToPerpStaticInfo, this.proxyContract, orderBookContract, this.chainId, this.signer, this.gasLimit);
             return res;
         });
@@ -279,7 +276,7 @@ class AccountTrade extends writeAccessHandler_1.default {
             // all orders are sent to the order-book
             let [signature, digest] = yield this._createSignature(scOrder, chainId, true, signer, proxyContract.address);
             tx = yield orderBookContract.postOrder(scOrder, signature, { gasLimit: gasLimit });
-            let id = yield this.createOrderId(digest);
+            let id = yield this.digestTool.createOrderId(digest);
             return { tx: tx, orderId: id };
         });
     }
@@ -305,74 +302,11 @@ class AccountTrade extends writeAccessHandler_1.default {
      */
     _createSignature(order, chainId, isNewOrder, signer, proxyAddress) {
         return __awaiter(this, void 0, void 0, function* () {
-            let digest = yield this._createDigest(order, chainId, isNewOrder, proxyAddress);
+            let digest = yield this.digestTool.createDigest(order, chainId, isNewOrder, proxyAddress);
             let digestBuffer = Buffer.from(digest.substring(2, digest.length), "hex");
             let signature = yield signer.signMessage(digestBuffer);
             return [signature, digest];
         });
     }
-    /**
-     * Creates an order-id from the digest. Order-id is the 'digest' used in the smart contract.
-     * @param digest  created with _createDigest
-     * @returns orderId string
-     * @ignore
-     */
-    createOrderId(digest) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let digestBuffer = Buffer.from(digest.substring(2, digest.length), "hex");
-            const messagePrefix = "\x19Ethereum Signed Message:\n";
-            let tmp = (0, bytes_1.concat)([(0, strings_1.toUtf8Bytes)(messagePrefix), (0, strings_1.toUtf8Bytes)(String(digestBuffer.length)), digestBuffer]);
-            // see: https://github.com/ethers-io/ethers.js/blob/c80fcddf50a9023486e9f9acb1848aba4c19f7b6/packages/hash/src.ts/message.ts#L7
-            return ethers_1.ethers.utils.keccak256(tmp);
-        });
-    }
-    /**
-     * Creates a digest (order-id)
-     * @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 digest
-     * @ignore
-     */
-    _createDigest(order, chainId, isNewOrder, proxyAddress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const NAME = "Perpetual Trade Manager";
-            const DOMAIN_TYPEHASH = ethers_1.ethers.utils.keccak256(Buffer.from("EIP712Domain(string name,uint256 chainId,address verifyingContract)"));
-            let abiCoder = ethers_1.ethers.utils.defaultAbiCoder;
-            let domainSeparator = ethers_1.ethers.utils.keccak256(abiCoder.encode(["bytes32", "bytes32", "uint256", "address"], [DOMAIN_TYPEHASH, ethers_1.ethers.utils.keccak256(Buffer.from(NAME)), chainId, proxyAddress]));
-            const TRADE_ORDER_TYPEHASH = ethers_1.ethers.utils.keccak256(Buffer.from("Order(uint24 iPerpetualId,uint16 brokerFeeTbps,address traderAddr,address brokerAddr,int128 fAmount,int128 fLimitPrice,int128 fTriggerPrice,uint64 iDeadline,uint32 flags,int128 fLeverage,uint64 createdTimestamp)"));
-            let structHash = ethers_1.ethers.utils.keccak256(abiCoder.encode([
-                "bytes32",
-                "uint24",
-                "uint16",
-                "address",
-                "address",
-                "int128",
-                "int128",
-                "int128",
-                "uint64",
-                "uint32",
-                "int128",
-                "uint64",
-            ], [
-                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_1.ethers.utils.keccak256(abiCoder.encode(["bytes32", "bytes32", "bool"], [domainSeparator, structHash, isNewOrder]));
-            return digest;
-        });
-    }
 }
 exports.default = AccountTrade;

package/dist/apiInterface.d.ts

@@ -0,0 +1,40 @@
+import { ethers } from "ethers";
+import MarketData from "./marketData";
+import { NodeSDKConfig, SmartContractOrder, Order } from "./nodeSDKTypes";
+import TraderDigests from "./traderDigests";
+export default class APIInterface extends MarketData {
+    protected chainId: number;
+    protected digestTool: TraderDigests;
+    constructor(config: NodeSDKConfig);
+    /**
+     * Initialize the marketData-Class with this function
+     * to create instance of D8X perpetual contract and gather information
+     * about perpetual currencies
+     * @param provider optional provider
+     */
+    createProxyInstance(provider?: ethers.providers.JsonRpcProvider): Promise<void>;
+    /**
+     * Get digest to cancel an order. Digest needs to be signed and submitted via
+     * orderBookContract.cancelOrder(orderId, signature);
+     * @param symbol
+     * @param orderId
+     * @returns tuple of digest which the trader needs to sign and address of order book contract
+     */
+    cancelOrderDigest(symbol: string, orderId: string): Promise<{
+        digest: string;
+        OBContractAddr: string;
+    }>;
+    /**
+     * Create smart contract order and digest that the trader signs.
+     * await orderBookContract.postOrder(scOrder, signature, { gasLimit: gasLimit });
+     * Order must contain broker fee and broker address if there is supposed to be a broker.
+     * @param order order struct
+     * @param traderAddr address of the trader
+     * @returns tuple of digest that the trader has to sign, order book address, and smart contract order
+     */
+    orderDigest(order: Order, traderAddr: string): Promise<{
+        digest: string;
+        OBAddr: string;
+        SCOrder: SmartContractOrder;
+    }>;
+}

package/dist/apiInterface.js

@@ -0,0 +1,92 @@
+"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 marketData_1 = __importDefault(require("./marketData"));
+const perpetualDataHandler_1 = __importDefault(require("./perpetualDataHandler"));
+const traderDigests_1 = __importDefault(require("./traderDigests"));
+/*
+   interface that can be used by front-end that wraps all private functions
+   so that signatures can be handled in frontend via wallet
+
+*/
+class APIInterface extends marketData_1.default {
+    // accTrade.order(order)
+    // cancelOrder(symbol: string, orderId: string)
+    // accTrade.setAllowance
+    // accTrade.queryExchangeFee("MATIC")
+    // accTrade.getCurrentTraderVolume("MATIC")
+    // accTrade.getOrderIds("MATIC-USD-MATIC")
+    constructor(config) {
+        super(config);
+        this.chainId = 0;
+        this.digestTool = new traderDigests_1.default();
+    }
+    /**
+     * Initialize the marketData-Class with this function
+     * to create instance of D8X perpetual contract and gather information
+     * about perpetual currencies
+     * @param provider optional provider
+     */
+    createProxyInstance(provider) {
+        const _super = Object.create(null, {
+            createProxyInstance: { get: () => super.createProxyInstance }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.createProxyInstance.call(this, provider);
+            this.chainId = (yield this.provider.getNetwork()).chainId;
+        });
+    }
+    /**
+     * Get digest to cancel an order. Digest needs to be signed and submitted via
+     * orderBookContract.cancelOrder(orderId, signature);
+     * @param symbol
+     * @param orderId
+     * @returns tuple of digest which the trader needs to sign and address of order book contract
+     */
+    cancelOrderDigest(symbol, orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.proxyContract == null) {
+                throw Error("no proxy contract initialized. Use createProxyInstance().");
+            }
+            let orderBookContract = this.getOrderBookContract(symbol);
+            let scOrder = yield orderBookContract.orderOfDigest(orderId);
+            let digest = yield this.digestTool.createDigest(scOrder, this.chainId, false, this.proxyAddr);
+            return { digest: digest, OBContractAddr: orderBookContract.address };
+        });
+    }
+    /**
+     * Create smart contract order and digest that the trader signs.
+     * await orderBookContract.postOrder(scOrder, signature, { gasLimit: gasLimit });
+     * Order must contain broker fee and broker address if there is supposed to be a broker.
+     * @param order order struct
+     * @param traderAddr address of the trader
+     * @returns tuple of digest that the trader has to sign, order book address, and smart contract order
+     */
+    orderDigest(order, traderAddr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.proxyContract == null) {
+                throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
+            }
+            let minSize = perpetualDataHandler_1.default._getMinimalPositionSize(order.symbol, this.symbolToPerpStaticInfo);
+            if (Math.abs(order.quantity) < minSize) {
+                throw Error("order size too small");
+            }
+            let orderBookContract = this.getOrderBookContract(order.symbol);
+            let scOrder = APIInterface.toSmartContractOrder(order, traderAddr, this.symbolToPerpStaticInfo);
+            let digest = yield this.digestTool.createDigest(scOrder, this.chainId, true, this.proxyContract.address);
+            return { digest: digest, OBAddr: orderBookContract.address, SCOrder: scOrder };
+        });
+    }
+}
+exports.default = APIInterface;

package/dist/brokerTool.d.ts

@@ -249,11 +249,8 @@ export default class BrokerTool extends WriteAccessHandler {
     /**
      * Adds this broker's signature to an order. An order signed by a broker is considered
      * to be routed through this broker and benefits from the broker's fee conditions.
-     * @param {Order} order Order to sign.
+     * @param {Order} order Order to sign. It must contain valid broker fee, broker address, and order deadline.
      * @param {string} traderAddr Address of trader submitting the order.
-     * @param {number} feeDecimals Fee that this broker imposes on this order.
-     * The fee is sent to the broker's wallet. Fee should be specified in decimals, e.g., 0.0001 equals 1bps.
-     * @param {number} deadline Deadline for the order to be executed. Specify deadline as a unix timestamp
      * @example
      * import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
      * async function main() {
@@ -281,7 +278,7 @@ export default class BrokerTool extends WriteAccessHandler {
      *
      * @returns {Order} An order signed by this broker, which can be submitted directly with AccountTrade.order.
      */
-    signOrder(order: Order, traderAddr: string, brokerFee: number, deadline: number): Promise<Order>;
+    signOrder(order: Order, traderAddr: string): Promise<Order>;
     /**
      * Creates a signature that a trader can use to place orders with this broker.
      * This signature can be used to pass on to a trader who wishes to trade via this SDK or directly on the blockchain.

package/dist/brokerTool.js

@@ -367,11 +367,8 @@ class BrokerTool extends writeAccessHandler_1.default {
     /**
      * Adds this broker's signature to an order. An order signed by a broker is considered
      * to be routed through this broker and benefits from the broker's fee conditions.
-     * @param {Order} order Order to sign.
+     * @param {Order} order Order to sign. It must contain valid broker fee, broker address, and order deadline.
      * @param {string} traderAddr Address of trader submitting the order.
-     * @param {number} feeDecimals Fee that this broker imposes on this order.
-     * The fee is sent to the broker's wallet. Fee should be specified in decimals, e.g., 0.0001 equals 1bps.
-     * @param {number} deadline Deadline for the order to be executed. Specify deadline as a unix timestamp
      * @example
      * import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
      * async function main() {
@@ -399,15 +396,13 @@ class BrokerTool extends writeAccessHandler_1.default {
      *
      * @returns {Order} An order signed by this broker, which can be submitted directly with AccountTrade.order.
      */
-    signOrder(order, traderAddr, brokerFee, deadline) {
+    signOrder(order, traderAddr) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.proxyContract == null || this.signer == null) {
                 throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
             }
             order.brokerAddr = this.traderAddr;
-            order.brokerFeeTbps = brokerFee * 100000;
-            order.deadline = Math.round(deadline);
-            order.brokerSignature = yield BrokerTool._signOrder(order.symbol, order.brokerFeeTbps, traderAddr, ethers_1.BigNumber.from(Math.round(deadline)), this.signer, this.chainId, this.proxyAddr, this.symbolToPerpStaticInfo);
+            order.brokerSignature = yield BrokerTool._signOrder(order.symbol, order.brokerFeeTbps, traderAddr, ethers_1.BigNumber.from(order.deadline), this.signer, this.chainId, this.proxyAddr, this.symbolToPerpStaticInfo);
             return order;
         });
     }

package/dist/d8XMath.d.ts

@@ -83,7 +83,7 @@ export declare function calculateLiquidationPriceCollateralQuote(LockedInValueQC
  * @param indexPriceS3 Collateral index price, positive.
  * @param tradePrice Expected price to trade tradeAmount.
  * @param feeRate
- * @returns
+ * @returns Total collateral amount needed for the new position to have he desired leverage.
  */
 export declare function getMarginRequiredForLeveragedTrade(targetLeverage: number | undefined, currentPosition: number, currentLockedInValue: number, tradeAmount: number, markPrice: number, indexPriceS2: number, indexPriceS3: number, tradePrice: number, feeRate: number): number;
 export declare function getMaxSignedPositionSize(marginCollateral: number, currentPosition: number, currentLockedInValue: number, direction: number, limitPrice: number, initialMarginRate: number, feeRate: number, markPrice: number, indexPriceS2: number, indexPriceS3: number): number;

package/dist/d8XMath.js

@@ -173,7 +173,7 @@ exports.calculateLiquidationPriceCollateralQuote = calculateLiquidationPriceColl
  * @param indexPriceS3 Collateral index price, positive.
  * @param tradePrice Expected price to trade tradeAmount.
  * @param feeRate
- * @returns
+ * @returns Total collateral amount needed for the new position to have he desired leverage.
  */
 function getMarginRequiredForLeveragedTrade(targetLeverage, currentPosition, currentLockedInValue, tradeAmount, markPrice, indexPriceS2, indexPriceS3, tradePrice, feeRate) {
     // we solve for margin in:

package/dist/liquidatorTool.d.ts

@@ -1,5 +1,6 @@
 import WriteAccessHandler from "./writeAccessHandler";
 import { NodeSDKConfig } from "./nodeSDKTypes";
+import { ethers } from "ethers";
 /**
  * Functions to liquidate traders. This class requires a private key
  * and executes smart-contract interactions that require gas-payments.
@@ -49,9 +50,9 @@ export default class LiquidatorTool extends WriteAccessHandler {
      * }
      * main();
      *
-     * @returns {number} Liquidated amount.
+     * @returns Transaction object.
      */
-    liquidateTrader(symbol: string, traderAddr: string, liquidatorAddr?: string): Promise<number>;
+    liquidateTrader(symbol: string, traderAddr: string, liquidatorAddr?: string): Promise<ethers.ContractTransaction>;
     /**
      * Check if the collateral of a trader is above the maintenance margin ("maintenance margin safe").
      * If not, the position can be liquidated.
@@ -85,7 +86,7 @@ export default class LiquidatorTool extends WriteAccessHandler {
      * @param gasLimit Gas limit.
      * @ignore
      */
-    _liquidateByAMM(perpetualId: number, liquidatorAddr: string, traderAddr: string, gasLimit: number): Promise<number>;
+    _liquidateByAMM(perpetualId: number, liquidatorAddr: string, traderAddr: string, gasLimit: number): Promise<any>;
     /**
      * Total number of active accounts for this symbol, i.e. accounts with positions that are currently open.
      * @param {string} symbol Symbol of the form ETH-USD-MATIC.

package/dist/liquidatorTool.js

@@ -13,7 +13,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const writeAccessHandler_1 = __importDefault(require("./writeAccessHandler"));
-const d8XMath_1 = require("./d8XMath");
 /**
  * Functions to liquidate traders. This class requires a private key
  * and executes smart-contract interactions that require gas-payments.
@@ -65,7 +64,7 @@ class LiquidatorTool extends writeAccessHandler_1.default {
      * }
      * main();
      *
-     * @returns {number} Liquidated amount.
+     * @returns Transaction object.
      */
     liquidateTrader(symbol, traderAddr, liquidatorAddr = "") {
         return __awaiter(this, void 0, void 0, function* () {
@@ -129,12 +128,10 @@ class LiquidatorTool extends writeAccessHandler_1.default {
      * @ignore
      */
     _liquidateByAMM(perpetualId, liquidatorAddr, traderAddr, gasLimit) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            let tx = yield this.proxyContract.liquidateByAMM(perpetualId, liquidatorAddr, traderAddr, {
+            return yield this.proxyContract.liquidateByAMM(perpetualId, liquidatorAddr, traderAddr, {
                 gasLimit: gasLimit,
             });
-            return (0, d8XMath_1.ABK64x64ToFloat)((_a = tx.value) !== null && _a !== void 0 ? _a : 0);
         });
     }
     /**

package/dist/marketData.d.ts

@@ -150,6 +150,7 @@ export default class MarketData extends PerpetualDataHandler {
      * @returns {number} Price of index in given currency.
      */
     getOraclePrice(base: string, quote: string): Promise<number | undefined>;
+    getOrderStatus(symbol: string, orderId: string): Promise<string>;
     /**
      * Get the current mark price
      * @param symbol symbol of the form ETH-USD-MATIC
@@ -233,7 +234,5 @@ export default class MarketData extends PerpetualDataHandler {
      * @ignore
      */
     static orderIdsOfTrader(traderAddr: string, orderBookContract: ethers.Contract): Promise<string[]>;
-    static _exchangeInfo(_proxyContract: ethers.Contract, _poolStaticInfos: Array<PoolStaticInfo>, _symbolList: Array<{
-        [key: string]: string;
-    }>): Promise<ExchangeInfo>;
+    static _exchangeInfo(_proxyContract: ethers.Contract, _poolStaticInfos: Array<PoolStaticInfo>, _symbolList: Map<string, string>): Promise<ExchangeInfo>;
 }

package/dist/marketData.js

@@ -293,6 +293,17 @@ class MarketData extends perpetualDataHandler_1.default {
             return px == undefined ? undefined : (0, d8XMath_1.ABK64x64ToFloat)(px);
         });
     }
+    getOrderStatus(symbol, orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.proxyContract == null) {
+                throw Error("no proxy contract initialized. Use createProxyInstance().");
+            }
+            let orderBookContract = null;
+            orderBookContract = this.getOrderBookContract(symbol);
+            let status = yield orderBookContract.getOrderStatus(orderId);
+            return status;
+        });
+    }
     /**
      * Get the current mark price
      * @param symbol symbol of the form ETH-USD-MATIC

package/dist/orderReferrerTool.d.ts

@@ -61,7 +61,7 @@ export default class OrderReferrerTool extends WriteAccessHandler {
      * main();
      * @returns Transaction object.
      */
-    executeOrder(symbol: string, orderId: string, referrerAddr?: string): Promise<ethers.ContractTransaction>;
+    executeOrder(symbol: string, orderId: string, referrerAddr?: string, nonce?: number): Promise<ethers.ContractTransaction>;
     /**
      * All the orders in the order book for a given symbol that are currently open.
      * @param {string} symbol Symbol of the form ETH-USD-MATIC.
@@ -172,4 +172,5 @@ export default class OrderReferrerTool extends WriteAccessHandler {
      * @returns true if order can be executed for the current state of the perpetuals
      */
     isTradeable(order: Order): Promise<boolean>;
+    getTransactionCount(blockTag?: ethers.providers.BlockTag): Promise<number>;
 }

package/dist/orderReferrerTool.js

@@ -78,7 +78,7 @@ class OrderReferrerTool extends writeAccessHandler_1.default {
      * main();
      * @returns Transaction object.
      */
-    executeOrder(symbol, orderId, referrerAddr) {
+    executeOrder(symbol, orderId, referrerAddr, nonce) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.proxyContract == null || this.signer == null) {
                 throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
@@ -87,7 +87,8 @@ class OrderReferrerTool extends writeAccessHandler_1.default {
             if (typeof referrerAddr == "undefined") {
                 referrerAddr = this.traderAddr;
             }
-            return yield orderBookSC.executeOrder(orderId, referrerAddr, { gasLimit: this.gasLimit });
+            const options = { gasLimit: this.gasLimit, nonce: nonce };
+            return yield orderBookSC.executeOrder(orderId, referrerAddr, options);
         });
     }
     /**
@@ -280,5 +281,13 @@ class OrderReferrerTool extends writeAccessHandler_1.default {
             return true;
         });
     }
+    getTransactionCount(blockTag) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.signer == null) {
+                throw Error("no wallet initialized. Use createProxyInstance().");
+            }
+            return yield this.signer.getTransactionCount(blockTag);
+        });
+    }
 }
 exports.default = OrderReferrerTool;

package/dist/perpetualDataHandler.d.ts

@@ -7,9 +7,7 @@ import { NodeSDKConfig, Order, SmartContractOrder, PerpetualStaticInfo, MarginAc
 export default class PerpetualDataHandler {
     protected symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>;
     protected poolStaticInfos: Array<PoolStaticInfo>;
-    protected symbolList: Array<{
-        [key: string]: string;
-    }>;
+    protected symbolList: Map<string, string>;
     protected symbolToTokenAddrMap: Map<string, string>;
     protected proxyContract: ethers.Contract | null;
     protected proxyABI: ethers.ContractInterface;

package/dist/perpetualDataHandler.js

@@ -34,7 +34,7 @@ class PerpetualDataHandler {
         this.proxyABI = require(config.proxyABILocation);
         this.lobFactoryABI = require(config.limitOrderBookFactoryABILocation);
         this.lobABI = require(config.limitOrderBookABILocation);
-        this.symbolList = require(config.symbolListLocation);
+        this.symbolList = new Map(Object.entries(require(config.symbolListLocation)));
     }
     initContractsAndData(signerOrProvider) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -95,21 +95,23 @@ class PerpetualDataHandler {
                     // try to find a limit order book
                     let lobAddr = yield this.lobFactoryContract.getOrderBookAddress(perpetualIDs[k]);
                     currentLimitOrderBookAddr.push(lobAddr);
-                    // we find out the pool currency by looking at all perpetuals
-                    // unless for quanto perpetuals, we know the pool currency
-                    // from the perpetual. This fails if we have a pool with only
-                    // quanto perpetuals
-                    if (perp.eCollateralCurrency == nodeSDKTypes_1.COLLATERAL_CURRENCY_BASE) {
-                        poolCCY = base;
-                        ccy.push(nodeSDKTypes_1.CollaterlCCY.BASE);
-                    }
-                    else if (perp.eCollateralCurrency == nodeSDKTypes_1.COLLATERAL_CURRENCY_QUOTE) {
-                        poolCCY = quote;
-                        ccy.push(nodeSDKTypes_1.CollaterlCCY.QUOTE);
-                    }
-                    else {
-                        poolCCY = base3;
-                        ccy.push(nodeSDKTypes_1.CollaterlCCY.QUANTO);
+                    if (poolCCY == undefined) {
+                        // we find out the pool currency by looking at all perpetuals
+                        // unless for quanto perpetuals, we know the pool currency
+                        // from the perpetual. This fails if we have a pool with only
+                        // quanto perpetuals
+                        if (perp.eCollateralCurrency == nodeSDKTypes_1.COLLATERAL_CURRENCY_BASE) {
+                            poolCCY = base;
+                            ccy.push(nodeSDKTypes_1.CollaterlCCY.BASE);
+                        }
+                        else if (perp.eCollateralCurrency == nodeSDKTypes_1.COLLATERAL_CURRENCY_QUOTE) {
+                            poolCCY = quote;
+                            ccy.push(nodeSDKTypes_1.CollaterlCCY.QUOTE);
+                        }
+                        else {
+                            poolCCY = base3;
+                            ccy.push(nodeSDKTypes_1.CollaterlCCY.QUANTO);
+                        }
                     }
                 }
                 if (perpetualIDs.length == 0) {

package/dist/perpetualEventHandler.d.ts

@@ -35,6 +35,7 @@ export default class PerpetualEventHandler {
     private traderAddr;
     private ordersInPerpetual;
     private positionInPerpetual;
+    private poolIndexForPerpetual;
     private exchangeInfo;
     constructor(mktData: MarketData, traderAddr: string);
     /**
@@ -85,7 +86,7 @@ export default class PerpetualEventHandler {
      * @param fSpotIndexPrice spot index price in ABDK format
      * @returns void
      */
-    onUpdateMarkPrice(perpetualId: number, fMarkPricePremium: BigNumber, fSpotIndexPrice: BigNumber): void;
+    onUpdateMarkPrice(perpetualId: number, fMidPricePremium: BigNumber, fMarkPricePremium: BigNumber, fSpotIndexPrice: BigNumber): void;
     /**
      * Handle the event UpdateFundingRate and update relevant
      * data