@d8x/perpetuals-sdk 0.0.1 → 0.0.2

package/dist/accountTrade.d.ts

@@ -2,8 +2,8 @@ import { ethers } from "ethers";
 import { NodeSDKConfig, Order, PerpetualStaticInfo } from "./nodeSDKTypes";
 import WriteAccessHandler from "./writeAccessHandler";
 /**
- * Account and Trade.
- * This class requires a private key and executes smart-contract interaction that
+ * Functions to create, submit and cancel orders on the exchange.
+ * This class requires a private key and executes smart-contract interactions that
  * require gas-payments.
  */
 export default class AccountTrade extends WriteAccessHandler {
@@ -25,6 +25,16 @@ export default class AccountTrade extends WriteAccessHandler {
      * @returns {string} Transaction hash.
      */
     order(order: Order): Promise<string | undefined>;
+    /**
+     * 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).
+     * If trading with a broker, it also accounts for the selected broker's fee tier.
+     * Note that this result only includes exchange fees, additional broker fees are not included.
+     * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
+     * @param {string=} brokerAddr Optional address of a broker this trader may use to trade under.
+     * @returns Exchange fee, in decimals (i.e. 0.1% is 0.001).
+     */
+    queryExchangeFee(poolSymbolName: string, brokerAddr?: string): Promise<number>;
     /**
      * Static order function
      * @param order order type (not SmartContractOrder but Order)

package/dist/accountTrade.js

@@ -15,10 +15,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const nodeSDKTypes_1 = require("./nodeSDKTypes");
 const writeAccessHandler_1 = __importDefault(require("./writeAccessHandler"));
-//import { abi, rawEncode } from "ethereumjs-abi";
 /**
- * Account and Trade.
- * This class requires a private key and executes smart-contract interaction that
+ * Functions to create, submit and cancel orders on the exchange.
+ * This class requires a private key and executes smart-contract interactions that
  * require gas-payments.
  */
 class AccountTrade extends writeAccessHandler_1.default {
@@ -67,6 +66,28 @@ class AccountTrade extends writeAccessHandler_1.default {
             return yield this._order(order, this.traderAddr, this.symbolToPerpStaticInfo, this.proxyContract, orderBookContract, this.chainId, this.signer, this.gasLimit);
         });
     }
+    /**
+     * 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).
+     * If trading with a broker, it also accounts for the selected broker's fee tier.
+     * Note that this result only includes exchange fees, additional broker fees are not included.
+     * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
+     * @param {string=} brokerAddr Optional address of a broker this trader may use to trade under.
+     * @returns Exchange fee, in decimals (i.e. 0.1% is 0.001).
+     */
+    queryExchangeFee(poolSymbolName, brokerAddr) {
+        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().");
+            }
+            if (typeof brokerAddr == "undefined") {
+                brokerAddr = nodeSDKTypes_1.ZERO_ADDRESS;
+            }
+            let poolId = writeAccessHandler_1.default._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
+            let feeTbps = yield this.proxyContract.queryExchangeFee(poolId, this.traderAddr, brokerAddr);
+            return feeTbps / 100000;
+        });
+    }
     /**
      * Static order function
      * @param order order type (not SmartContractOrder but Order)

package/dist/brokerTool.d.ts

@@ -1,41 +1,100 @@
 import WriteAccessHandler from "./writeAccessHandler";
-import { NodeSDKConfig, Order } from "./nodeSDKTypes";
-import { ethers } from "ethers";
+import { NodeSDKConfig, Order, PerpetualStaticInfo } from "./nodeSDKTypes";
+import { BigNumber, ethers } from "ethers";
 /**
- * BrokerTool.
- * Signature method for brokers
+ * Functions for brokers to determine fees, deposit lots, and sign-up traders.
  */
 export default class BrokerTool extends WriteAccessHandler {
     /**
      * Constructor
-     * @param config configuration
-     * @param privateKey private key of account that trades
+     * @param {NodeSDKConfig} config Configuration object.
+     * @param {string} privateKey Private key of a broker.
      */
     constructor(config: NodeSDKConfig, privateKey: string);
+    getBrokerInducedFee(poolSymbolName: string): Promise<number>;
     /**
-     *
-     * @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
+     * 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(symbol: string): Promise<number | undefined>;
-    brokerDepositToDefaultFund(symbol: string, lots: number): Promise<ethers.providers.TransactionResponse>;
-    getFeeForBrokerVolume(symbol: string): Promise<number | undefined>;
+    getLotSize(poolSymbolName: string): Promise<number>;
     /**
-     *
-     * @param symbol symbol of the form "ETH-USD-MATIC" or just "MATIC"
-     * @returns number of lots deposited by broker
+     * 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(symbol: string): Promise<number>;
+    getBrokerDesignation(poolSymbolName: string): Promise<number>;
     /**
-     * @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
+     * Deposit lots to the default fund of a given pool.
+     * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
+     * @param lots Number of lots to deposit into this pool.
+     * @returns Transaction object.
      */
-    getFeeForBrokerDesignation(symbol: string, newLots?: number): Promise<number | undefined>;
+    brokerDepositToDefaultFund(poolSymbolName: string, lots: number): Promise<ethers.providers.TransactionResponse>;
     /**
-     * @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)
+     * 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).
      */
-    determineExchangeFee(order: Order, traderAddr?: string): Promise<number | undefined>;
+    getFeeForBrokerDesignation(poolSymbolName: string, lots?: number): Promise<number>;
+    /**
+     * Determine the exchange fee based on volume traded under 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).
+     * @returns 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>;
+    /**
+     * 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).
+     */
+    getFeeForBrokerStake(brokerAddr?: string): Promise<number>;
+    /**
+     * Determine exchange fee based on an order and a trader.
+     * This is the fee charged by the exchange only, excluding the broker fee,
+     * 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.
+     * @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).
+     */
+    determineExchangeFee(order: Order, traderAddr: string): Promise<number>;
+    /**
+     * 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.
+     */
+    signOrder(order: Order, traderAddr: string, brokerFee: number, deadline: number): 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.
+     * @param {string} traderAddr Address of the trader signing up with this broker.
+     * @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.
+     * @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
+     */
+    transferOwnership(poolSymbolName: string, newAddress: string): Promise<ethers.providers.TransactionResponse>;
 }

package/dist/brokerTool.js

@@ -13,117 +13,232 @@ 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 perpetualDataHandler_1 = __importDefault(require("./perpetualDataHandler"));
 const d8XMath_1 = require("./d8XMath");
+const ethers_1 = require("ethers");
 const accountTrade_1 = __importDefault(require("./accountTrade"));
 /**
- * BrokerTool.
- * Signature method for brokers
+ * Functions for brokers to determine fees, deposit lots, and sign-up traders.
  */
 class BrokerTool extends writeAccessHandler_1.default {
     /**
      * Constructor
-     * @param config configuration
-     * @param privateKey private key of account that trades
+     * @param {NodeSDKConfig} config Configuration object.
+     * @param {string} privateKey Private key of a broker.
      */
     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;
+        });
+    }
     /**
-     *
-     * @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
+     * 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(symbol) {
+    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(symbol, this.poolStaticInfos);
+            let poolId = perpetualDataHandler_1.default._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
             let pool = yield this.proxyContract.getLiquidityPool(poolId);
-            let lot = pool === null || pool === void 0 ? void 0 : pool.fBrokerCollateralLotSize;
-            if (lot != undefined) {
-                lot = (0, d8XMath_1.ABK64x64ToFloat)(pool.fBrokerCollateralLotSize);
-            }
+            let lot = (0, d8XMath_1.ABK64x64ToFloat)(pool.fBrokerCollateralLotSize);
             return lot;
         });
     }
-    brokerDepositToDefaultFund(symbol, lots) {
+    /**
+     * 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(symbol, this.poolStaticInfos);
+            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 lots Number of lots to deposit into this pool.
+     * @returns Transaction 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;
         });
     }
-    getFeeForBrokerVolume(symbol) {
+    /**
+     * 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).
+     */
+    getFeeForBrokerDesignation(poolSymbolName, lots) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.proxyContract == null) {
-                throw Error("no proxy contract initialized.");
+            if (this.proxyContract == null || this.signer == null) {
+                throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
             }
-            let poolId = perpetualDataHandler_1.default._getPoolIdFromSymbol(symbol, this.poolStaticInfos);
-            let feeTbps = yield this.proxyContract.getFeeForBrokerVolume(poolId, this.traderAddr);
+            // check if designation should be taken from the caller or as a parameter
+            let brokerDesignation;
+            if (typeof lots == "undefined") {
+                brokerDesignation = yield this.getBrokerDesignation(poolSymbolName);
+            }
+            else {
+                brokerDesignation = lots;
+            }
+            let feeTbps = yield this.proxyContract.getFeeForBrokerDesignation(brokerDesignation);
             return feeTbps / 100000;
         });
     }
     /**
-     *
-     * @param symbol symbol of the form "ETH-USD-MATIC" or just "MATIC"
-     * @returns number of lots deposited by broker
+     * Determine the exchange fee based on volume traded under 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).
+     * @returns Fee based solely on a broker's traded volume in the corresponding pool, in decimals (i.e. 0.1% is 0.001).
      */
-    getBrokerDesignation(symbol) {
+    getFeeForBrokerVolume(poolSymbolName) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.proxyContract == null) {
-                throw Error("no proxy contract initialized.");
+            if (this.proxyContract == null || this.signer == null) {
+                throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
             }
-            let poolId = perpetualDataHandler_1.default._getPoolIdFromSymbol(symbol, this.poolStaticInfos);
-            let designation = yield this.proxyContract.getBrokerDesignation(poolId, this.traderAddr);
-            return designation;
+            let poolId = perpetualDataHandler_1.default._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
+            let feeTbps = yield this.proxyContract.getFeeForBrokerVolume(poolId, this.traderAddr);
+            return feeTbps / 100000;
         });
     }
     /**
-     * @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
+     * 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).
      */
-    getFeeForBrokerDesignation(symbol, newLots = 0) {
+    getFeeForBrokerStake(brokerAddr) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.proxyContract == null) {
-                throw Error("no proxy contract initialized.");
+            if (this.proxyContract == null || this.signer == null) {
+                throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
             }
-            if (newLots < 0) {
-                throw Error("new lots must be a positive number.");
+            if (typeof brokerAddr == "undefined") {
+                brokerAddr = this.traderAddr;
             }
-            let lots = yield this.getBrokerDesignation(symbol);
-            lots += newLots;
-            let feeTbps = yield this.proxyContract.getFeeForBrokerDesignation(lots);
+            let feeTbps = yield this.proxyContract.getFeeForBrokerStake(brokerAddr);
             return feeTbps / 100000;
         });
     }
     /**
-     * @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)
+     * Determine exchange fee based on an order and a trader.
+     * This is the fee charged by the exchange only, excluding the broker fee,
+     * 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.
+     * @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).
      */
-    determineExchangeFee(order, traderAddr = nodeSDKTypes_1.ZERO_ADDRESS) {
+    determineExchangeFee(order, traderAddr) {
         return __awaiter(this, void 0, void 0, function* () {
-            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;
+            if (this.proxyContract == null || this.signer == null) {
+                throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
             }
             let scOrder = accountTrade_1.default.toSmartContractOrder(order, traderAddr, this.symbolToPerpStaticInfo);
             let feeTbps = yield this.proxyContract.determineExchangeFee(scOrder);
             return feeTbps / 100000;
         });
     }
+    /**
+     * 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.
+     */
+    signOrder(order, traderAddr, brokerFee, deadline) {
+        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 = deadline;
+            order.brokerSignature = yield BrokerTool._signOrder(order.symbol, order.brokerFeeTbps, traderAddr, ethers_1.BigNumber.from(deadline), this.signer, this.chainId, this.proxyAddr, this.symbolToPerpStaticInfo);
+            return 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.
+     * @param {string} traderAddr Address of the trader signing up with this broker.
+     * @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.
+     * @ignore
+     */
+    createSignatureForTrader(traderAddr, symbol, brokerFee, deadline) {
+        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 iDeadline = ethers_1.BigNumber.from(deadline);
+            let brokerFeeTbps = 100000 * brokerFee;
+            return yield BrokerTool._signOrder(symbol, brokerFeeTbps, traderAddr, iDeadline, this.signer, this.chainId, this.proxyAddr, this.symbolToPerpStaticInfo);
+        });
+    }
+    static _signOrder(symbol, brokerFeeTbps, traderAddr, iDeadline, signer, chainId, proxyAddress, symbolToPerpStaticInfo) {
+        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_BROKER_TYPEHASH = ethers_1.ethers.utils.keccak256(Buffer.from("Order(uint24 iPerpetualId,uint16 brokerFeeTbps,address traderAddr,uint256 iDeadline)"));
+            let iPerpetualId = perpetualDataHandler_1.default.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
+            let structHash = ethers_1.ethers.utils.keccak256(abiCoder.encode(["bytes32", "uint24", "uint16", "address", "uint256"], [TRADE_BROKER_TYPEHASH, iPerpetualId, brokerFeeTbps, traderAddr, iDeadline]));
+            let digest = ethers_1.ethers.utils.keccak256(abiCoder.encode(["bytes32", "bytes32"], [domainSeparator, structHash]));
+            let digestBuffer = Buffer.from(digest.substring(2, digest.length), "hex");
+            return yield signer.signMessage(digestBuffer);
+        });
+    }
+    /**
+     * 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
+     */
+    transferOwnership(poolSymbolName, newAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.proxyContract == 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.transferOwnership(poolId, newAddress);
+            return tx;
+        });
+    }
 }
 exports.default = BrokerTool;

package/dist/d8XMath.d.ts

@@ -1,41 +1,44 @@
 import { BigNumber } from "ethers";
+/**
+ * @module d8xMath
+ */
 /**
  * Convert ABK64x64 bigint-format to float.
  * Result = x/2^64 if big number, x/2^29 if number
- * @param   x number in ABDK-format or 2^29
- * @returns x/2^64 in number-format (float)
+ * @param  {BigNumber|number} x number in ABDK-format or 2^29
+ * @returns {number} x/2^64 in number-format (float)
  */
 export declare function ABK64x64ToFloat(x: BigNumber | number): number;
 /**
  *
- * @param x BigNumber in Dec18 format
- * @returns x as a float (number)
+ * @param {BigNumber} x BigNumber in Dec18 format
+ * @returns {number} x as a float (number)
  */
 export declare function dec18ToFloat(x: BigNumber): number;
 /**
  * Converts x into ABDK64x64 format
- * @param   x   number (float)
- * @returns x^64 in big number format
+ * @param {number} x   number (float)
+ * @returns {BigNumber} x^64 in big number format
  */
 export declare function floatToABK64x64(x: number): BigNumber;
 /**
  *
- * @param x number (float)
- * @returns x as a BigNumber in Dec18 format
+ * @param {number} x number (float)
+ * @returns {BigNumber} x as a BigNumber in Dec18 format
  */
 export declare function floatToDec18(x: number): BigNumber;
 /**
  *
- * @param x
- * @param y
- * @returns x * y
+ * @param {BigNumber} x
+ * @param {BigNumber} y
+ * @returns {BigNumber} x * y
  */
 export declare function mul64x64(x: BigNumber, y: BigNumber): BigNumber;
 /**
  *
- * @param x
- * @param y
- * @returns x / y
+ * @param {BigNumber} x
+ * @param {BigNumber} y
+ * @returns {BigNumber} x / y
  */
 export declare function div64x64(x: BigNumber, y: BigNumber): BigNumber;
 /**

package/dist/d8XMath.js

@@ -3,12 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateLiquidationPriceCollateralQuote = exports.calculateLiquidationPriceCollateralQuanto = exports.calculateLiquidationPriceCollateralBase = exports.div64x64 = exports.mul64x64 = exports.floatToDec18 = exports.floatToABK64x64 = exports.dec18ToFloat = exports.ABK64x64ToFloat = void 0;
 const ethers_1 = require("ethers");
 const nodeSDKTypes_1 = require("./nodeSDKTypes");
-const BN = ethers_1.BigNumber;
+/**
+ * @module d8xMath
+ */
 /**
  * Convert ABK64x64 bigint-format to float.
  * Result = x/2^64 if big number, x/2^29 if number
- * @param   x number in ABDK-format or 2^29
- * @returns x/2^64 in number-format (float)
+ * @param  {BigNumber|number} x number in ABDK-format or 2^29
+ * @returns {number} x/2^64 in number-format (float)
  */
 function ABK64x64ToFloat(x) {
     if (typeof x == "number") {
@@ -29,8 +31,8 @@ function ABK64x64ToFloat(x) {
 exports.ABK64x64ToFloat = ABK64x64ToFloat;
 /**
  *
- * @param x BigNumber in Dec18 format
- * @returns x as a float (number)
+ * @param {BigNumber} x BigNumber in Dec18 format
+ * @returns {number} x as a float (number)
  */
 function dec18ToFloat(x) {
     //x: BigNumber in Dec18 format to float
@@ -46,8 +48,8 @@ function dec18ToFloat(x) {
 exports.dec18ToFloat = dec18ToFloat;
 /**
  * Converts x into ABDK64x64 format
- * @param   x   number (float)
- * @returns x^64 in big number format
+ * @param {number} x   number (float)
+ * @returns {BigNumber} x^64 in big number format
  */
 function floatToABK64x64(x) {
     // convert float to ABK64x64 bigint-format
@@ -69,8 +71,8 @@ function floatToABK64x64(x) {
 exports.floatToABK64x64 = floatToABK64x64;
 /**
  *
- * @param x number (float)
- * @returns x as a BigNumber in Dec18 format
+ * @param {number} x number (float)
+ * @returns {BigNumber} x as a BigNumber in Dec18 format
  */
 function floatToDec18(x) {
     // float number to dec 18
@@ -89,9 +91,9 @@ function floatToDec18(x) {
 exports.floatToDec18 = floatToDec18;
 /**
  *
- * @param x
- * @param y
- * @returns x * y
+ * @param {BigNumber} x
+ * @param {BigNumber} y
+ * @returns {BigNumber} x * y
  */
 function mul64x64(x, y) {
     return x.mul(y).div(nodeSDKTypes_1.ONE_64x64);
@@ -99,9 +101,9 @@ function mul64x64(x, y) {
 exports.mul64x64 = mul64x64;
 /**
  *
- * @param x
- * @param y
- * @returns x / y
+ * @param {BigNumber} x
+ * @param {BigNumber} y
+ * @returns {BigNumber} x / y
  */
 function div64x64(x, y) {
     return x.mul(nodeSDKTypes_1.ONE_64x64).div(y);