@d8x/perpetuals-sdk 0.0.7 → 0.0.9

package/config/defaultConfig.json

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

package/dist/accountTrade.d.ts

@@ -9,7 +9,22 @@ import WriteAccessHandler from "./writeAccessHandler";
 export default class AccountTrade extends WriteAccessHandler {
     /**
      * Constructor
-     * @param {NodeSDKConfig} config Configuration object, see PerpetualDataHandler.readSDKConfig.
+     * @param {NodeSDKConfig} config Configuration object, see PerpetualDataHandler.
+     * readSDKConfig.
+     * @example
+     * import { AccountTrade, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(AccountTrade);
+     *   // load configuration for testnet
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   // AccountTrade (authentication required, PK is an environment variable with a private key)
+     *   const pk: string = <string>process.env.PK;
+     *   let accTrade = new AccountTrade(config, pk);
+     *   // Create a proxy instance to access the blockchain
+     *   await accTrade.createProxyInstance();
+     * }
+     * main();
+     *
      * @param {string} privateKey Private key of account that trades.
      */
     constructor(config: NodeSDKConfig, privateKey: string);
@@ -21,10 +36,19 @@ export default class AccountTrade extends WriteAccessHandler {
     cancelOrder(symbol: string, orderId: string): Promise<string | undefined>;
     /**
      * Submits an order to the exchange.
-     * @param {Order} order Order struct.
-     * @returns {string} Transaction hash.
+     * @param {Order} order Order structure. As a minimum the structure needs to
+     * specify symbol, side, type and quantity.
+     * @example
+     * let order: Order = {
+     *       symbol: "MATIC-USD-MATIC",
+     *       side: "BUY",
+     *       type: "MARKET",
+     *       quantity: 1,
+     * }
+     *
+     * @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).
@@ -32,6 +56,21 @@ export default class AccountTrade extends WriteAccessHandler {
      * 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.
+     * @example
+     * import { AccountTrade, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(AccountTrade);
+     *   // Setup (authentication required, PK is an environment variable with a private key)
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   const pk: string = <string>process.env.PK;
+     *   let accTrade = new AccountTrade(config, pk);
+     *   await accTrade.createProxyInstance();
+     *   // query exchange fee
+     *   let fees = await accTrade.queryExchangeFee("MATIC");
+     *   console.log(fees);
+     * }
+     * main();
+     *
      * @returns Exchange fee, in decimals (i.e. 0.1% is 0.001).
      */
     queryExchangeFee(poolSymbolName: string, brokerAddr?: string): Promise<number>;
@@ -39,9 +78,30 @@ export default class AccountTrade extends WriteAccessHandler {
      * 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).
+     * @example
+     * import { AccountTrade, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(AccountTrade);
+     *   // Setup (authentication required, PK is an environment variable with a private key)
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   const pk: string = <string>process.env.PK;
+     *   let accTrade = new AccountTrade(config, pk);
+     *   await accTrade.createProxyInstance();
+     *   // query 30 day volume
+     *   let vol = await accTrade.getCurrentTraderVolume("MATIC");
+     *   console.log(vol);
+     * }
+     * main();
+     *
      * @returns {number} Current trading volume for this trader, in USD.
      */
     getCurrentTraderVolume(poolSymbolName: string): Promise<number>;
+    /**
+     *
+     * @param symbol Symbol of the form ETH-USD-MATIC.
+     * @returns {string[]} Array of Ids for all the orders currently open by this trader.
+     */
+    getOrderIds(symbol: string): Promise<string[]>;
     /**
      * Static order function
      * @param order order type (not SmartContractOrder but Order)
@@ -55,7 +115,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

@@ -14,6 +14,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 marketData_1 = __importDefault(require("./marketData"));
 const nodeSDKTypes_1 = require("./nodeSDKTypes");
 const writeAccessHandler_1 = __importDefault(require("./writeAccessHandler"));
 /**
@@ -24,7 +25,22 @@ const writeAccessHandler_1 = __importDefault(require("./writeAccessHandler"));
 class AccountTrade extends writeAccessHandler_1.default {
     /**
      * Constructor
-     * @param {NodeSDKConfig} config Configuration object, see PerpetualDataHandler.readSDKConfig.
+     * @param {NodeSDKConfig} config Configuration object, see PerpetualDataHandler.
+     * readSDKConfig.
+     * @example
+     * import { AccountTrade, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(AccountTrade);
+     *   // load configuration for testnet
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   // AccountTrade (authentication required, PK is an environment variable with a private key)
+     *   const pk: string = <string>process.env.PK;
+     *   let accTrade = new AccountTrade(config, pk);
+     *   // Create a proxy instance to access the blockchain
+     *   await accTrade.createProxyInstance();
+     * }
+     * main();
+     *
      * @param {string} privateKey Private key of account that trades.
      */
     constructor(config, privateKey) {
@@ -52,8 +68,17 @@ class AccountTrade extends writeAccessHandler_1.default {
     */
     /**
      * Submits an order to the exchange.
-     * @param {Order} order Order struct.
-     * @returns {string} Transaction hash.
+     * @param {Order} order Order structure. As a minimum the structure needs to
+     * specify symbol, side, type and quantity.
+     * @example
+     * let order: Order = {
+     *       symbol: "MATIC-USD-MATIC",
+     *       side: "BUY",
+     *       type: "MARKET",
+     *       quantity: 1,
+     * }
+     *
+     * @returns {ContractTransaction} Contract Transaction (containing events).
      */
     order(order) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -74,6 +99,21 @@ class AccountTrade extends writeAccessHandler_1.default {
      * 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.
+     * @example
+     * import { AccountTrade, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(AccountTrade);
+     *   // Setup (authentication required, PK is an environment variable with a private key)
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   const pk: string = <string>process.env.PK;
+     *   let accTrade = new AccountTrade(config, pk);
+     *   await accTrade.createProxyInstance();
+     *   // query exchange fee
+     *   let fees = await accTrade.queryExchangeFee("MATIC");
+     *   console.log(fees);
+     * }
+     * main();
+     *
      * @returns Exchange fee, in decimals (i.e. 0.1% is 0.001).
      */
     queryExchangeFee(poolSymbolName, brokerAddr) {
@@ -93,6 +133,21 @@ class AccountTrade extends writeAccessHandler_1.default {
      * 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).
+     * @example
+     * import { AccountTrade, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(AccountTrade);
+     *   // Setup (authentication required, PK is an environment variable with a private key)
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   const pk: string = <string>process.env.PK;
+     *   let accTrade = new AccountTrade(config, pk);
+     *   await accTrade.createProxyInstance();
+     *   // query 30 day volume
+     *   let vol = await accTrade.getCurrentTraderVolume("MATIC");
+     *   console.log(vol);
+     * }
+     * main();
+     *
      * @returns {number} Current trading volume for this trader, in USD.
      */
     getCurrentTraderVolume(poolSymbolName) {
@@ -105,6 +160,20 @@ class AccountTrade extends writeAccessHandler_1.default {
             return (0, d8XMath_1.ABK64x64ToFloat)(volume);
         });
     }
+    /**
+     *
+     * @param symbol Symbol of the form ETH-USD-MATIC.
+     * @returns {string[]} Array of Ids for all the orders currently open by this trader.
+     */
+    getOrderIds(symbol) {
+        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 orderBookContract = this.getOrderBookContract(symbol);
+            return yield marketData_1.default.orderIdsOfTrader(this.traderAddr, orderBookContract);
+        });
+    }
     /**
      * Static order function
      * @param order order type (not SmartContractOrder but Order)
@@ -136,7 +205,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

@@ -3,43 +3,120 @@ import { NodeSDKConfig, Order, PerpetualStaticInfo } from "./nodeSDKTypes";
 import { BigNumber, ethers } from "ethers";
 /**
  * Functions for brokers to determine fees, deposit lots, and sign-up traders.
+ * This class requires a private key and executes smart-contract interactions that
+ * require gas-payments.
  */
 export default class BrokerTool extends WriteAccessHandler {
     /**
      * Constructor
-     * @param {NodeSDKConfig} config Configuration object.
+     * @param {NodeSDKConfig} config Configuration object, see PerpetualDataHandler.
+     * readSDKConfig.
+     * @example
+     * import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(BrokerTool);
+     *   // load configuration for testnet
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   // BrokerTool (authentication required, PK is an environment variable with a private key)
+     *   const pk: string = <string>process.env.PK;
+     *   let brokTool = new BrokerTool(config, pk);
+     *   // Create a proxy instance to access the blockchain
+     *   await brokTool.createProxyInstance();
+     * }
+     * main();
+     *
      * @param {string} privateKey Private key of a broker.
      */
     constructor(config: NodeSDKConfig, privateKey: string);
     /**
      * 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.
+     * This is the final exchange fee that this broker can offer to traders that trade through him.
      * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
+     * @example
+     * import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(BrokerTool);
+     *   // Setup (authentication required, PK is an environment variable with a private key)
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   const pk: string = <string>process.env.PK;
+     *   let brokTool = new BrokerTool(config, pk);
+     *   await brokTool.createProxyInstance();
+     *   // get broker induced fee
+     *   let brokFee = await brokTool.getBrokerInducedFee("MATIC");
+     *   console.log(brokFee);
+     * }
+     * main();
+     *
      * @returns {number} Exchange fee for this broker, in decimals (i.e. 0.1% is 0.001)
      */
     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
+     * The final exchange fee that this broker can offer to traders that trade through him 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.
+     * @example
+     * import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(BrokerTool);
+     *   // Setup (authentication required, PK is an environment variable with a private key)
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   const pk: string = <string>process.env.PK;
+     *   let brokTool = new BrokerTool(config, pk);
+     *   await brokTool.createProxyInstance();
+     *   // get broker fee induced by lots
+     *   let brokFeeLots = await brokTool.getFeeForBrokerDesignation("MATIC");
+     *   console.log(brokFeeLots);
+     * }
+     * main();
+     *
      * @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>;
     /**
      * Determine the exchange fee based on volume traded under this broker.
-     * The final exchange fee paid by the broker is equal to
+     * The final exchange fee that this broker can offer to traders that trade through him is equal to
      * maximum(brokerTool.getFeeForBrokerDesignation(poolSymbolName),  brokerTool.getFeeForBrokerVolume(poolSymbolName), brokerTool.getFeeForBrokerStake())
      * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
+     * @example
+     * import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(BrokerTool);
+     *   // Setup (authentication required, PK is an environment variable with a private key)
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   const pk: string = <string>process.env.PK;
+     *   let brokTool = new BrokerTool(config, pk);
+     *   await brokTool.createProxyInstance();
+     *   // get broker fee induced by volume
+     *   let brokFeeVol = await brokTool.getFeeForBrokerVolume("MATIC");
+     *   console.log(brokFeeVol);
+     * }
+     * main();
+     *
      * @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
+     * The final exchange fee that this broker can offer to traders that trade through him 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.
+     * @example
+     * import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(BrokerTool);
+     *   // Setup (authentication required, PK is an environment variable with a private key)
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   const pk: string = <string>process.env.PK;
+     *   let brokTool = new BrokerTool(config, pk);
+     *   await brokTool.createProxyInstance();
+     *   // get broker fee induced by staked d8x
+     *   let brokFeeStake = await brokTool.getFeeForBrokerStake("0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B");
+     *   console.log(brokFeeStake);
+     * }
+     * main();
+     *
      * @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>;
@@ -50,7 +127,30 @@ export default class BrokerTool extends WriteAccessHandler {
      * 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 {Order} order Order structure. As a minimum the structure needs to
+     * specify symbol, side, type and quantity.
+     * @example
+     * import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(BrokerTool);
+     *   // Setup (authentication required, PK is an environment variable with a private key)
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   const pk: string = <string>process.env.PK;
+     *   let brokTool = new BrokerTool(config, pk);
+     *   await brokTool.createProxyInstance();
+     *   // get exchange fee based on an order and trader
+     *   let order = {symbol: "ETH-USD-MATIC",
+     *       side: "BUY",
+     *       type: "MARKET",
+     *       quantity: 1,
+     *       timestamp: Date.now()
+     *    };
+     *    let exchFee = await brokTool.determineExchangeFee(order,
+     *        "0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B");
+     *   console.log(exchFee);
+     * }
+     * main();
+     *
      * @param {string} traderAddr Address of the trader for whom to determine the fee.
      * @returns {number} Fee in decimals (i.e. 0.1% is 0.001).
      */
@@ -59,6 +159,21 @@ export default class BrokerTool extends WriteAccessHandler {
      * 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).
+     * @example
+     * import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(BrokerTool);
+     *   // Setup (authentication required, PK is an environment variable with a private key)
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   const pk: string = <string>process.env.PK;
+     *   let brokTool = new BrokerTool(config, pk);
+     *   await brokTool.createProxyInstance();
+     *   // get 30 day volume for broker
+     *   let brokVolume = await brokTool.getCurrentBrokerVolume("MATIC");
+     *   console.log(brokVolume);
+     * }
+     * main();
+     *
      * @returns {number} Current trading volume for this broker, in USD.
      */
     getCurrentBrokerVolume(poolSymbolName: string): Promise<number>;
@@ -66,6 +181,21 @@ export default class BrokerTool extends WriteAccessHandler {
      * 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).
+     * @example
+     * import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(BrokerTool);
+     *   // Setup (authentication required, PK is an environment variable with a private key)
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   const pk: string = <string>process.env.PK;
+     *   let brokTool = new BrokerTool(config, pk);
+     *   await brokTool.createProxyInstance();
+     *   // get lot price
+     *   let brokLotSize = await brokTool.getLotSize("MATIC");
+     *   console.log(brokLotSize);
+     * }
+     * main();
+     *
      * @returns {number} Broker lot size in a given pool's currency, e.g. in MATIC for poolSymbolName MATIC.
      */
     getLotSize(poolSymbolName: string): Promise<number>;
@@ -73,6 +203,21 @@ export default class BrokerTool extends WriteAccessHandler {
      * 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).
+     * @example
+     * import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(BrokerTool);
+     *   // Setup (authentication required, PK is an environment variable with a private key)
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   const pk: string = <string>process.env.PK;
+     *   let brokTool = new BrokerTool(config, pk);
+     *   await brokTool.createProxyInstance();
+     *   // get broker designation
+     *   let brokDesignation = await brokTool.getBrokerDesignation("MATIC");
+     *   console.log(brokDesignation);
+     * }
+     * main();
+     *
      * @returns {number} Number of lots purchased by this broker.
      */
     getBrokerDesignation(poolSymbolName: string): Promise<number>;
@@ -80,15 +225,54 @@ export default class BrokerTool extends WriteAccessHandler {
      * Deposit lots to the default fund of a given pool.
      * @param {string} poolSymbolName Pool symbol name (e.g. MATIC, USDC, etc).
      * @param {number} lots Number of lots to deposit into this pool.
-     * @returns {ethers.providers.TransactionResponse} Transaction object.
+     * @example
+     * import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
+     * async function main() {
+     *   console.log(BrokerTool);
+     *   // Setup (authentication required, PK is an environment variable with a private key)
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   const pk: string = <string>process.env.PK;
+     *   let brokTool = new BrokerTool(config, pk);
+     *   await brokTool.createProxyInstance();
+     *   // deposit to default fund
+     *   let respDeposit = await brokTool.brokerDepositToDefaultFund("MATIC",1);
+     *   console.log(respDeposit);
+     * }
+     * main();
+     *
+     * @returns {ethers.ContractTransaction} ContractTransaction object.
      */
-    brokerDepositToDefaultFund(poolSymbolName: string, lots: number): Promise<ethers.providers.TransactionResponse>;
+    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.
+     * 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 {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.
+     * @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() {
+     *   console.log(BrokerTool);
+     *   // Setup (authentication required, PK is an environment variable with a private key)
+     *   const config = PerpetualDataHandler.readSDKConfig("testnet");
+     *   const pk: string = <string>process.env.PK;
+     *   let brokTool = new BrokerTool(config, pk);
+     *   await brokTool.createProxyInstance();
+     *   // sign order
+     *   let order = {symbol: "ETH-USD-MATIC",
+     *       side: "BUY",
+     *       type: "MARKET",
+     *       quantity: 1,
+     *       timestamp: Date.now()
+     *    };
+     *    let signedOrder = await brokTool.signOrder(order, "0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B",
+     *        0.0001, 1669723339);
+     *   console.log(signedOrder);
+     * }
+     * main();
+     *
      * @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>;
@@ -105,7 +289,9 @@ export default class BrokerTool extends WriteAccessHandler {
     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.
+     * Transfer ownership of a broker's status to a new wallet. This function transfers the values related to
+     * (i) trading volume and (ii) deposited lots to newAddress. The broker needs in addition to manually transfer
+     * his D8X holdings to newAddress. Until this transfer is completed, the broker will not have his current designation reflected at newAddress.
      * @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