@d8x/perpetuals-sdk 0.0.2 → 0.0.4

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/dist/accountTrade.d.ts

@@ -22,9 +22,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).
      */
-    order(order: Order): Promise<string | undefined>;
+    order(order: Order): Promise<ethers.ContractTransaction>;
     /**
      * Fee charged by the exchange for trading any perpetual on a given pool.
      * It accounts for the current trader's fee tier (based on the trader's D8X balance and trading volume).
@@ -35,6 +35,13 @@ export default class AccountTrade extends WriteAccessHandler {
      * @returns Exchange fee, in decimals (i.e. 0.1% is 0.001).
      */
     queryExchangeFee(poolSymbolName: string, brokerAddr?: string): Promise<number>;
+    /**
+     * Exponentially weighted EMA of the total trading volume of all trades performed by this trader.
+     * The weights are chosen so that in average this coincides with the 30 day volume.
+     * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
+     * @returns {number} Current trading volume for this trader, in USD.
+     */
+    getCurrentTraderVolume(poolSymbolName: string): Promise<number>;
     /**
      * Static order function
      * @param order order type (not SmartContractOrder but Order)
@@ -48,7 +55,7 @@ export default class AccountTrade extends WriteAccessHandler {
      * @returns transaction hash
      * @ignore
      */
-    _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>;
+    _order(order: Order, traderAddr: string, symbolToPerpetualMap: Map<string, PerpetualStaticInfo>, proxyContract: ethers.Contract, orderBookContract: ethers.Contract | null, chainId: number, signer: ethers.Wallet, gasLimit: number): Promise<ethers.ContractTransaction>;
     protected _cancelOrder(symbol: string, orderId: string, orderBookContract: ethers.Contract | null): Promise<string | undefined>;
     /**
      * Creates a signature

package/dist/accountTrade.js

@@ -13,6 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
+const d8XMath_1 = require("./d8XMath");
 const nodeSDKTypes_1 = require("./nodeSDKTypes");
 const writeAccessHandler_1 = __importDefault(require("./writeAccessHandler"));
 /**
@@ -52,7 +53,7 @@ class AccountTrade extends writeAccessHandler_1.default {
     /**
      * Submits an order to the exchange.
      * @param {Order} order Order struct.
-     * @returns {string} Transaction hash.
+     * @returns {ContractTransaction} Contract Transaction (containing events).
      */
     order(order) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -88,6 +89,22 @@ class AccountTrade extends writeAccessHandler_1.default {
             return feeTbps / 100000;
         });
     }
+    /**
+     * Exponentially weighted EMA of the total trading volume of all trades performed by this trader.
+     * The weights are chosen so that in average this coincides with the 30 day volume.
+     * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
+     * @returns {number} Current trading volume for this trader, in USD.
+     */
+    getCurrentTraderVolume(poolSymbolName) {
+        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().");
+            }
+            let poolId = writeAccessHandler_1.default._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
+            let volume = yield this.proxyContract.getCurrentTraderVolume(poolId, this.traderAddr);
+            return (0, d8XMath_1.ABK64x64ToFloat)(volume);
+        });
+    }
     /**
      * Static order function
      * @param order order type (not SmartContractOrder but Order)
@@ -119,7 +136,7 @@ class AccountTrade extends writeAccessHandler_1.default {
                 let signature = yield this._createSignature(scOrder, chainId, true, signer, proxyContract.address);
                 tx = yield orderBookContract.createLimitOrder(scOrder, signature, { gasLimit: gasLimit });
             }
-            return tx.hash;
+            return tx;
         });
     }
     _cancelOrder(symbol, orderId, orderBookContract) {

package/dist/brokerTool.d.ts

@@ -11,35 +11,20 @@ export default class BrokerTool extends WriteAccessHandler {
      * @param {string} privateKey Private key of a broker.
      */
     constructor(config: NodeSDKConfig, privateKey: string);
-    getBrokerInducedFee(poolSymbolName: string): Promise<number>;
-    /**
-     * Total amount of collateral currency a broker has to deposit into the default fund to purchase one lot.
-     * This is equivalent to the price of a lot expressed in a given pool's currency (e.g. MATIC, USDC, etc).
-     * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
-     * @returns Broker lot size in a given pool's currency, e.g. in MATIC for poolSymbolName MATIC.
-     */
-    getLotSize(poolSymbolName: string): Promise<number>;
-    /**
-     * Provides information on how many lots a broker purchased for a given pool.
-     * This is relevant to determine the broker's fee tier.
-     * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
-     * @returns Number of lots purchased by this broker.
-     */
-    getBrokerDesignation(poolSymbolName: string): Promise<number>;
     /**
-     * Deposit lots to the default fund of a given pool.
+     * Determine the exchange fee based on lots, traded volume, and D8X balance of this broker.
+     * This is the final exchange fee paid by the broker.
      * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
-     * @param lots Number of lots to deposit into this pool.
-     * @returns Transaction object.
+     * @returns {number} Exchange fee for this broker, in decimals (i.e. 0.1% is 0.001)
      */
-    brokerDepositToDefaultFund(poolSymbolName: string, lots: number): Promise<ethers.providers.TransactionResponse>;
+    getBrokerInducedFee(poolSymbolName: string): Promise<number>;
     /**
      * Determine the exchange fee based on lots purchased by this broker.
      * The final exchange fee paid by the broker is equal to
      * maximum(brokerTool.getFeeForBrokerDesignation(poolSymbolName),  brokerTool.getFeeForBrokerVolume(poolSymbolName), brokerTool.getFeeForBrokerStake())
      * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
-     * @param {number} lots Optional, designation to use if different from this broker's.
-     * @returns Fee based solely on this broker's designation, in decimals (i.e. 0.1% is 0.001).
+     * @param {number=} lots Optional, designation to use if different from this broker's.
+     * @returns {number} Fee based solely on this broker's designation, in decimals (i.e. 0.1% is 0.001).
      */
     getFeeForBrokerDesignation(poolSymbolName: string, lots?: number): Promise<number>;
     /**
@@ -47,15 +32,15 @@ export default class BrokerTool extends WriteAccessHandler {
      * The final exchange fee paid by the broker is equal to
      * maximum(brokerTool.getFeeForBrokerDesignation(poolSymbolName),  brokerTool.getFeeForBrokerVolume(poolSymbolName), brokerTool.getFeeForBrokerStake())
      * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
-     * @returns Fee based solely on a broker's traded volume in the corresponding pool, in decimals (i.e. 0.1% is 0.001).
+     * @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 | undefined>;
+    getFeeForBrokerVolume(poolSymbolName: string): Promise<number>;
     /**
      * 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
      * maximum(brokerTool.getFeeForBrokerDesignation(symbol, lots),  brokerTool.getFeeForBrokerVolume(symbol), brokerTool.getFeeForBrokerStake)
      * @param {string=} brokerAddr Address of the broker in question, if different from the one calling this function.
-     * @returns Fee based solely on a broker's D8X balance, in decimals (i.e. 0.1% is 0.001).
+     * @returns {number} Fee based solely on a broker's D8X balance, in decimals (i.e. 0.1% is 0.001).
      */
     getFeeForBrokerStake(brokerAddr?: string): Promise<number>;
     /**
@@ -64,18 +49,47 @@ export default class BrokerTool extends WriteAccessHandler {
      * and it takes into account whether the order given here has been signed by a broker or not.
      * Use this, for instance, to verify that the fee to be charged for a given order is as expected,
      * before and after signing it with brokerTool.signOrder.
+     * This fee is equal or lower than the broker induced fee, provided the order is properly signed.
      * @param {Order} order Order for which to determine the exchange fee. Not necessarily signed by this broker.
      * @param {string} traderAddr Address of the trader for whom to determine the fee.
-     * @returns Fee in decimals (i.e. 0.1% is 0.001).
+     * @returns {number} Fee in decimals (i.e. 0.1% is 0.001).
      */
     determineExchangeFee(order: Order, traderAddr: string): Promise<number>;
+    /**
+     * Exponentially weighted EMA of the total trading volume of all trades performed under this broker.
+     * The weights are chosen so that in average this coincides with the 30 day volume.
+     * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
+     * @returns {number} Current trading volume for this broker, in USD.
+     */
+    getCurrentBrokerVolume(poolSymbolName: string): Promise<number>;
+    /**
+     * Total amount of collateral currency a broker has to deposit into the default fund to purchase one lot.
+     * This is equivalent to the price of a lot expressed in a given pool's currency (e.g. MATIC, USDC, etc).
+     * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
+     * @returns {number} Broker lot size in a given pool's currency, e.g. in MATIC for poolSymbolName MATIC.
+     */
+    getLotSize(poolSymbolName: string): Promise<number>;
+    /**
+     * Provides information on how many lots a broker purchased for a given pool.
+     * This is relevant to determine the broker's fee tier.
+     * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
+     * @returns {number} Number of lots purchased by this broker.
+     */
+    getBrokerDesignation(poolSymbolName: string): Promise<number>;
+    /**
+     * 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.ContractTransaction} ContractTransaction object.
+     */
+    brokerDepositToDefaultFund(poolSymbolName: string, lots: number): Promise<ethers.ContractTransaction>;
     /**
      * Adds this broker's signature to an order so that it can be submitted by an approved trader.
      * @param {Order} order Order to sign.
      * @param {string} traderAddr Address of trader submitting the order.
      * @param {number} feeDecimals Fee that this broker is approving for the trader.
      * @param {number} deadline Deadline for the order to be executed.
-     * @returns An order signed by this broker, which can be submitted directly with AccountTrade.order.
+     * @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>;
     /**
@@ -85,16 +99,16 @@ export default class BrokerTool extends WriteAccessHandler {
      * @param {string} symbol Perpetual that this trader will be trading, of the form ETH-USD-MATIC.
      * @param {number} brokerFee Broker fee for this trader, in decimals (i.e. 0.1% is 0.001).
      * @param {number} deadline Deadline for the order to be executed.
-     * @returns Broker signature approving this trader's fee, symbol, and deadline.
+     * @returns {string} Broker signature approving this trader's fee, symbol, and deadline.
      * @ignore
      */
     createSignatureForTrader(traderAddr: string, symbol: string, brokerFee: number, deadline: number): Promise<string>;
     static _signOrder(symbol: string, brokerFeeTbps: number, traderAddr: string, iDeadline: BigNumber, signer: ethers.Wallet, chainId: number, proxyAddress: string, symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>): Promise<string>;
     /**
      * Transfer ownership of a broker's status to a new wallet.
-     * @param poolSymbolName     Symbol refers to the pool (e.g., MATIC for the MATIC-pool)
-     * @param newAddress         The address this broker wants to use from now on.
-     * @returns ethers transaction object
+     * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
+     * @param {string} newAddress The address this broker wants to use from now on.
+     * @returns {ethers.providers.TransactionResponse} ethers transaction object
      */
     transferOwnership(poolSymbolName: string, newAddress: string): Promise<ethers.providers.TransactionResponse>;
 }

package/dist/brokerTool.js

@@ -29,63 +29,21 @@ class BrokerTool extends writeAccessHandler_1.default {
     constructor(config, privateKey) {
         super(config, privateKey);
     }
-    getBrokerInducedFee(poolSymbolName) {
-        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().");
-            }
-            let poolId = perpetualDataHandler_1.default._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
-            let feeTbps = yield this.proxyContract.getBrokerInducedFee(poolId, this.traderAddr);
-            return feeTbps / 100000;
-        });
-    }
-    /**
-     * Total amount of collateral currency a broker has to deposit into the default fund to purchase one lot.
-     * This is equivalent to the price of a lot expressed in a given pool's currency (e.g. MATIC, USDC, etc).
-     * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
-     * @returns Broker lot size in a given pool's currency, e.g. in MATIC for poolSymbolName MATIC.
-     */
-    getLotSize(poolSymbolName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.proxyContract == null) {
-                throw Error("no proxy contract initialized. Use createProxyInstance().");
-            }
-            let poolId = perpetualDataHandler_1.default._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
-            let pool = yield this.proxyContract.getLiquidityPool(poolId);
-            let lot = (0, d8XMath_1.ABK64x64ToFloat)(pool.fBrokerCollateralLotSize);
-            return lot;
-        });
-    }
+    // Fee getters
     /**
-     * Provides information on how many lots a broker purchased for a given pool.
-     * This is relevant to determine the broker's fee tier.
-     * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
-     * @returns Number of lots purchased by this broker.
-     */
-    getBrokerDesignation(poolSymbolName) {
-        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().");
-            }
-            let poolId = perpetualDataHandler_1.default._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
-            let designation = yield this.proxyContract.getBrokerDesignation(poolId, this.traderAddr);
-            return designation;
-        });
-    }
-    /**
-     * Deposit lots to the default fund of a given pool.
+     * Determine the exchange fee based on lots, traded volume, and D8X balance of this broker.
+     * This is the final exchange fee paid by the broker.
      * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
-     * @param lots Number of lots to deposit into this pool.
-     * @returns Transaction object.
+     * @returns {number} Exchange fee for this broker, in decimals (i.e. 0.1% is 0.001)
      */
-    brokerDepositToDefaultFund(poolSymbolName, lots) {
+    getBrokerInducedFee(poolSymbolName) {
         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().");
             }
             let poolId = perpetualDataHandler_1.default._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
-            let tx = yield this.proxyContract.brokerDepositToDefaultFund(poolId, lots, { gasLimit: this.gasLimit });
-            return tx;
+            let feeTbps = yield this.proxyContract.getBrokerInducedFee(poolId, this.traderAddr);
+            return feeTbps / 100000;
         });
     }
     /**
@@ -93,8 +51,8 @@ class BrokerTool extends writeAccessHandler_1.default {
      * The final exchange fee paid by the broker is equal to
      * maximum(brokerTool.getFeeForBrokerDesignation(poolSymbolName),  brokerTool.getFeeForBrokerVolume(poolSymbolName), brokerTool.getFeeForBrokerStake())
      * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
-     * @param {number} lots Optional, designation to use if different from this broker's.
-     * @returns Fee based solely on this broker's designation, in decimals (i.e. 0.1% is 0.001).
+     * @param {number=} lots Optional, designation to use if different from this broker's.
+     * @returns {number} Fee based solely on this broker's designation, in decimals (i.e. 0.1% is 0.001).
      */
     getFeeForBrokerDesignation(poolSymbolName, lots) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -118,7 +76,7 @@ class BrokerTool extends writeAccessHandler_1.default {
      * The final exchange fee paid by the broker is equal to
      * maximum(brokerTool.getFeeForBrokerDesignation(poolSymbolName),  brokerTool.getFeeForBrokerVolume(poolSymbolName), brokerTool.getFeeForBrokerStake())
      * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
-     * @returns Fee based solely on a broker's traded volume in the corresponding pool, in decimals (i.e. 0.1% is 0.001).
+     * @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) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -135,7 +93,7 @@ class BrokerTool extends writeAccessHandler_1.default {
      * The final exchange fee paid by the broker is equal to
      * maximum(brokerTool.getFeeForBrokerDesignation(symbol, lots),  brokerTool.getFeeForBrokerVolume(symbol), brokerTool.getFeeForBrokerStake)
      * @param {string=} brokerAddr Address of the broker in question, if different from the one calling this function.
-     * @returns Fee based solely on a broker's D8X balance, in decimals (i.e. 0.1% is 0.001).
+     * @returns {number} Fee based solely on a broker's D8X balance, in decimals (i.e. 0.1% is 0.001).
      */
     getFeeForBrokerStake(brokerAddr) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -155,9 +113,10 @@ class BrokerTool extends writeAccessHandler_1.default {
      * and it takes into account whether the order given here has been signed by a broker or not.
      * Use this, for instance, to verify that the fee to be charged for a given order is as expected,
      * before and after signing it with brokerTool.signOrder.
+     * This fee is equal or lower than the broker induced fee, provided the order is properly signed.
      * @param {Order} order Order for which to determine the exchange fee. Not necessarily signed by this broker.
      * @param {string} traderAddr Address of the trader for whom to determine the fee.
-     * @returns Fee in decimals (i.e. 0.1% is 0.001).
+     * @returns {number} Fee in decimals (i.e. 0.1% is 0.001).
      */
     determineExchangeFee(order, traderAddr) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -169,13 +128,81 @@ class BrokerTool extends writeAccessHandler_1.default {
             return feeTbps / 100000;
         });
     }
+    // Volume
+    /**
+     * Exponentially weighted EMA of the total trading volume of all trades performed under this broker.
+     * The weights are chosen so that in average this coincides with the 30 day volume.
+     * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
+     * @returns {number} Current trading volume for this broker, in USD.
+     */
+    getCurrentBrokerVolume(poolSymbolName) {
+        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().");
+            }
+            let poolId = perpetualDataHandler_1.default._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
+            let volume = yield this.proxyContract.getCurrentBrokerVolume(poolId, this.traderAddr);
+            return (0, d8XMath_1.ABK64x64ToFloat)(volume);
+        });
+    }
+    // Lots
+    /**
+     * Total amount of collateral currency a broker has to deposit into the default fund to purchase one lot.
+     * This is equivalent to the price of a lot expressed in a given pool's currency (e.g. MATIC, USDC, etc).
+     * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
+     * @returns {number} Broker lot size in a given pool's currency, e.g. in MATIC for poolSymbolName MATIC.
+     */
+    getLotSize(poolSymbolName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.proxyContract == null) {
+                throw Error("no proxy contract initialized. Use createProxyInstance().");
+            }
+            let poolId = perpetualDataHandler_1.default._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
+            let pool = yield this.proxyContract.getLiquidityPool(poolId);
+            let lot = (0, d8XMath_1.ABK64x64ToFloat)(pool.fBrokerCollateralLotSize);
+            return lot;
+        });
+    }
+    /**
+     * Provides information on how many lots a broker purchased for a given pool.
+     * This is relevant to determine the broker's fee tier.
+     * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
+     * @returns {number} Number of lots purchased by this broker.
+     */
+    getBrokerDesignation(poolSymbolName) {
+        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().");
+            }
+            let poolId = perpetualDataHandler_1.default._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
+            let designation = yield this.proxyContract.getBrokerDesignation(poolId, this.traderAddr);
+            return designation;
+        });
+    }
+    /**
+     * 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.ContractTransaction} ContractTransaction object.
+     */
+    brokerDepositToDefaultFund(poolSymbolName, lots) {
+        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().");
+            }
+            let poolId = perpetualDataHandler_1.default._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
+            let tx = yield this.proxyContract.brokerDepositToDefaultFund(poolId, lots, { gasLimit: this.gasLimit });
+            return tx;
+        });
+    }
+    // Signatures
     /**
      * Adds this broker's signature to an order so that it can be submitted by an approved trader.
      * @param {Order} order Order to sign.
      * @param {string} traderAddr Address of trader submitting the order.
      * @param {number} feeDecimals Fee that this broker is approving for the trader.
      * @param {number} deadline Deadline for the order to be executed.
-     * @returns An order signed by this broker, which can be submitted directly with AccountTrade.order.
+     * @returns {Order} An order signed by this broker, which can be submitted directly with AccountTrade.order.
      */
     signOrder(order, traderAddr, brokerFee, deadline) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -196,7 +223,7 @@ class BrokerTool extends writeAccessHandler_1.default {
      * @param {string} symbol Perpetual that this trader will be trading, of the form ETH-USD-MATIC.
      * @param {number} brokerFee Broker fee for this trader, in decimals (i.e. 0.1% is 0.001).
      * @param {number} deadline Deadline for the order to be executed.
-     * @returns Broker signature approving this trader's fee, symbol, and deadline.
+     * @returns {string} Broker signature approving this trader's fee, symbol, and deadline.
      * @ignore
      */
     createSignatureForTrader(traderAddr, symbol, brokerFee, deadline) {
@@ -224,11 +251,12 @@ class BrokerTool extends writeAccessHandler_1.default {
             return yield signer.signMessage(digestBuffer);
         });
     }
+    // Transfer ownership
     /**
      * Transfer ownership of a broker's status to a new wallet.
-     * @param poolSymbolName     Symbol refers to the pool (e.g., MATIC for the MATIC-pool)
-     * @param newAddress         The address this broker wants to use from now on.
-     * @returns ethers transaction object
+     * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
+     * @param {string} newAddress The address this broker wants to use from now on.
+     * @returns {ethers.providers.TransactionResponse} ethers transaction object
      */
     transferOwnership(poolSymbolName, newAddress) {
         return __awaiter(this, void 0, void 0, function* () {

package/dist/liquidatorTool.d.ts

@@ -35,4 +35,24 @@ export default class LiquidatorTool extends WriteAccessHandler {
      * @ignore
      */
     _liquidateByAMM(perpetualId: number, liquidatorAddr: string, traderAddr: string, gasLimit: number): Promise<number>;
+    /**
+     * 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.
+     * @returns {number} Number of active accounts.
+     */
+    countActivePerpAccounts(symbol: string): Promise<number>;
+    /**
+     * 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.
+     */
+    getActiveAccountsByChunks(symbol: string, from: number, to: number): Promise<string[]>;
+    /**
+     * Addresses for all the active accounts in this perpetual symbol.
+     * @param {string} symbol Symbol of the form ETH-USD-MATIC.
+     * @returns {string[]} Array of addresses.
+     */
+    getAllActiveAccounts(symbol: string): 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.isMaintenanceMarginSafe(perpID, traderAddr);
+            return yield this.proxyContract.isTraderMaintenanceMarginSafe(perpID, traderAddr);
         });
     }
     /**
@@ -79,5 +79,47 @@ class LiquidatorTool extends writeAccessHandler_1.default {
             return (0, d8XMath_1.ABK64x64ToFloat)(fAmount);
         });
     }
+    /**
+     * 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.
+     * @returns {number} Number of active accounts.
+     */
+    countActivePerpAccounts(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.proxyContract == null) {
+                throw Error("no proxy contract initialized. Use createProxyInstance().");
+            }
+            let perpID = LiquidatorTool.symbolToPerpetualId(symbol, this.symbolToPerpStaticInfo);
+            return yield this.proxyContract.countActivePerpAccounts(perpID);
+        });
+    }
+    /**
+     * 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.
+     */
+    getActiveAccountsByChunks(symbol, from, to) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.proxyContract == null) {
+                throw Error("no proxy contract initialized. Use createProxyInstance().");
+            }
+            let perpID = LiquidatorTool.symbolToPerpetualId(symbol, this.symbolToPerpStaticInfo);
+            return yield this.proxyContract.getActivePerpAccountsByChunks(perpID, from, to);
+        });
+    }
+    /**
+     * Addresses for all the active accounts in this perpetual symbol.
+     * @param {string} symbol Symbol of the form ETH-USD-MATIC.
+     * @returns {string[]} Array of addresses.
+     */
+    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);
+        });
+    }
 }
 exports.default = LiquidatorTool;

package/dist/liquidityProviderTool.d.ts

@@ -28,7 +28,7 @@ export default class LiquidityProviderTool extends WriteAccessHandler {
      * @param {number} amountCC  Amount in pool-collateral currency
      * @return Transaction object
      */
-    addLiquidity(poolSymbolName: string, amountCC: number): Promise<ethers.providers.TransactionResponse>;
+    addLiquidity(poolSymbolName: string, amountCC: number): Promise<ethers.ContractTransaction>;
     /**
      * Remove liquidity from the pool.
      * @param {string} poolSymbolName Name of pool symbol (e.g. MATIC).

package/dist/marketData.d.ts

@@ -9,6 +9,11 @@ import { Order } from "./nodeSDKTypes";
 export default class MarketData extends PerpetualDataHandler {
     constructor(config: NodeSDKConfig);
     createProxyInstance(): Promise<void>;
+    /**
+     * Get contract instance. Useful for event listening.
+     * @returns read-only proxy instance
+     */
+    getReadOnlyProxyInstance(): ethers.Contract;
     /**
      * Information about the products traded in the exchange.
      * @returns {ExchangeInfo} Array of static data for all the pools and perpetuals in the system.
@@ -31,6 +36,26 @@ 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>;
+    /**
+     * Get the current mark price
+     * @param symbol symbol of the form ETH-USD-MATIC
+     * @returns mark price
+     */
+    getMarkPrice(symbol: string): Promise<number>;
+    /**
+     * 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)
+     */
+    getPerpetualPrice(symbol: string, quantity: number): Promise<number>;
     /**
      * Query smart contract to get user orders and convert to user friendly order format.
      * @param {string} traderAddr Address of trader.

package/dist/marketData.js

@@ -31,6 +31,16 @@ class MarketData extends perpetualDataHandler_1.default {
             yield this.initContractsAndData(this.provider);
         });
     }
+    /**
+     * Get contract instance. Useful for event listening.
+     * @returns read-only proxy instance
+     */
+    getReadOnlyProxyInstance() {
+        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.
@@ -75,6 +85,48 @@ 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);
+        });
+    }
+    /**
+     * Get the current mark price
+     * @param symbol symbol of the form ETH-USD-MATIC
+     * @returns mark price
+     */
+    getMarkPrice(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.proxyContract == null) {
+                throw Error("no proxy contract initialized. Use createProxyInstance().");
+            }
+            return yield perpetualDataHandler_1.default._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)
+     */
+    getPerpetualPrice(symbol, quantity) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.proxyContract == null) {
+                throw Error("no proxy contract initialized. Use createProxyInstance().");
+            }
+            return yield perpetualDataHandler_1.default._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/dist/nodeSDKTypes.d.ts

@@ -9,6 +9,7 @@ export declare const COLLATERAL_CURRENCY_BASE = 1;
 export declare const COLLATERAL_CURRENCY_QUANTO = 2;
 export declare const PERP_STATE_STR: string[];
 export declare const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+export declare const ZERO_ORDER_ID = "0x0000000000000000000000000000000000000000000000000000000000000000";
 export declare const ONE_64x64: BigNumber;
 export declare const MAX_64x64: BigNumber;
 export declare const MAX_UINT_256: BigNumber;