@d8x/perpetuals-sdk 0.0.1 → 0.0.3

package/src/marketData.ts

@@ -1,17 +1,17 @@
 import {
-    ExchangeInfo,
-    NodeSDKConfig,
-    MarginAccount,
-    PoolState,
-    PerpetualState,
-    COLLATERAL_CURRENCY_BASE,
-    COLLATERAL_CURRENCY_QUANTO,
-    PERP_STATE_STR,
-    ZERO_ADDRESS,
+  ExchangeInfo,
+  NodeSDKConfig,
+  MarginAccount,
+  PoolState,
+  PerpetualState,
+  COLLATERAL_CURRENCY_BASE,
+  COLLATERAL_CURRENCY_QUANTO,
+  PERP_STATE_STR,
+  ZERO_ADDRESS,
 } from "./nodeSDKTypes";
 import { BigNumber, BytesLike, ethers } from "ethers";
 import { floatToABK64x64, ABK64x64ToFloat } from "./d8XMath";
-import { fromBytes4HexString } from "./utils";
+import { fromBytes4HexString, toBytes4 } from "./utils";
 import PerpetualDataHandler from "./perpetualDataHandler";
 import { SmartContractOrder, Order } from "./nodeSDKTypes";
 
@@ -20,130 +20,161 @@ import { SmartContractOrder, Order } from "./nodeSDKTypes";
  * No gas required for the queries here.
  */
 export default class MarketData extends PerpetualDataHandler {
-    public constructor(config: NodeSDKConfig) {
-        super(config);
-    }
+  public constructor(config: NodeSDKConfig) {
+    super(config);
+  }
 
-    public async createProxyInstance() {
-        this.provider = new ethers.providers.JsonRpcProvider(this.nodeURL);
-        await this.initContractsAndData(this.provider);
-    }
+  public async createProxyInstance() {
+    this.provider = new ethers.providers.JsonRpcProvider(this.nodeURL);
+    await this.initContractsAndData(this.provider);
+  }
 
-    public async exchangeInfo(): Promise<ExchangeInfo> {
-        if (this.proxyContract == null) {
-            throw Error("no proxy contract initialized. Use createProxyInstance().");
-        }
-        return await MarketData._exchangeInfo(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.
+   */
+  public async exchangeInfo(): Promise<ExchangeInfo> {
+    if (this.proxyContract == null) {
+      throw Error("no proxy contract initialized. Use createProxyInstance().");
     }
+    return await MarketData._exchangeInfo(this.proxyContract);
+  }
+
+  /**
+   * All open orders for a trader-address and a symbol.
+   * @param {string} traderAddr Address of the trader for which we get the open orders.
+   * @param {string} symbol Symbol of the form ETH-USD-MATIC.
+   * @returns {Array<Array<Order>, Array<string>>} Array of open orders and corresponding order-ids.
+   */
+  public async openOrders(traderAddr: string, symbol: string): Promise<{ orders: Order[]; orderIds: string[] }> {
+    // open orders requested only for given symbol
+    let orderBookContract = this.getOrderBookContract(symbol);
+    let [orders, digests] = await Promise.all([
+      this.openOrdersOnOrderBook(traderAddr, orderBookContract),
+      this.orderIdsOfTrader(traderAddr, orderBookContract),
+    ]);
+    return { orders: orders, orderIds: digests };
+  }
 
-    /**
-     * Get all open orders for a trader-address and a symbol
-     * @param traderAddr address of the trader for which we get the open order
-     * @param symbol symbol of the form ETH-USD-MATIC
-     * @returns array of open orders and corresponding order-ids
-     */
-    public async openOrders(traderAddr: string, symbol: string): Promise<{ orders: Order[]; orderIds: string[] }> {
-        // open orders requested only for given symbol
-        let orderBookContract = this.getOrderBookContract(symbol);
-        let [orders, digests] = await Promise.all([
-            this.openOrdersOnOrderBook(traderAddr, orderBookContract),
-            this.orderIdsOfTrader(traderAddr, orderBookContract),
-        ]);
-        return { orders: orders, orderIds: digests };
+  /**
+   * Information about the position open by a given trader in a given perpetual contract.
+   * @param {string} traderAddr Address of the trader for which we get the position risk.
+   * @param {string} symbol Symbol of the form ETH-USD-MATIC.
+   * @returns {MarginAccount}
+   */
+  public async positionRisk(traderAddr: string, symbol: string): Promise<MarginAccount> {
+    if (this.proxyContract == null) {
+      throw Error("no proxy contract initialized. Use createProxyInstance().");
     }
+    let mgnAcct = await PerpetualDataHandler.getMarginAccount(
+      traderAddr,
+      symbol,
+      this.symbolToPerpStaticInfo,
+      this.proxyContract
+    );
+    return mgnAcct;
+  }
 
-    public async positionRisk(traderAddr: string, symbol: string): Promise<MarginAccount> {
-        if (this.proxyContract == null) {
-            throw Error("no proxy contract initialized. Use createProxyInstance().");
-        }
-        let mgnAcct = await PerpetualDataHandler.getMarginAccount(traderAddr, symbol, this.symbolToPerpStaticInfo, this.proxyContract);
-        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.
+   */
+  public async getOraclePrice(base: string, quote: string): Promise<number | undefined> {
+    if (this.proxyContract == null) {
+      throw Error("no proxy contract initialized. Use createProxyInstance().");
     }
+    let px = await this.proxyContract.getOraclePrice([toBytes4(base), toBytes4(quote)]);
+    return px == undefined ? undefined : ABK64x64ToFloat(px);
+  }
 
-    /**
-     * Query smart contract to get user orders and convert to user friendly order format
-     * @param traderAddr address of trader
-     * @param orderBookContract instance of order book
-     * @returns array of user friendly order struct
-     */
-    protected async openOrdersOnOrderBook(traderAddr: string, orderBookContract: ethers.Contract): Promise<Order[]> {
-        let orders: SmartContractOrder[] = await orderBookContract.getOrders(traderAddr, 0, 15);
-        //eliminate empty orders and map to user friendly orders
-        let userFriendlyOrders: Order[] = new Array<Order>();
-        let k = 0;
-        while (k < orders.length && orders[k].traderAddr != ZERO_ADDRESS) {
-            userFriendlyOrders.push(PerpetualDataHandler.fromSmartContractOrder(orders[k], this.symbolToPerpStaticInfo));
-            k++;
-        }
-        return userFriendlyOrders;
+  /**
+   * Query smart contract to get user orders and convert to user friendly order format.
+   * @param {string} traderAddr Address of trader.
+   * @param {ethers.Contract} orderBookContract Instance of order book.
+   * @returns {Order[]} Array of user friendly order struct.
+   * @ignore
+   */
+  protected async openOrdersOnOrderBook(traderAddr: string, orderBookContract: ethers.Contract): Promise<Order[]> {
+    let orders: SmartContractOrder[] = await orderBookContract.getOrders(traderAddr, 0, 15);
+    //eliminate empty orders and map to user friendly orders
+    let userFriendlyOrders: Order[] = new Array<Order>();
+    let k = 0;
+    while (k < orders.length && orders[k].traderAddr != ZERO_ADDRESS) {
+      userFriendlyOrders.push(PerpetualDataHandler.fromSmartContractOrder(orders[k], this.symbolToPerpStaticInfo));
+      k++;
     }
+    return userFriendlyOrders;
+  }
 
-    /**
-     *
-     * @param traderAddr address of the trader
-     * @param orderBookContract instance of order book contract
-     * @returns array of order-id's
-     */
-    protected async orderIdsOfTrader(traderAddr: string, orderBookContract: ethers.Contract): Promise<string[]> {
-        let digestsRaw: string[] = await orderBookContract.limitDigestsOfTrader(traderAddr, 0, 15);
-        let k: number = 0;
-        let digests: string[] = [];
-        while (k < digestsRaw.length && BigNumber.from(digestsRaw[k]).gt(0)) {
-            digests.push(digestsRaw[k]);
-            k++;
-        }
-        return digests;
+  /**
+   *
+   * @param traderAddr address of the trader
+   * @param orderBookContract instance of order book contract
+   * @returns array of order-id's
+   * @ignore
+   */
+  protected async orderIdsOfTrader(traderAddr: string, orderBookContract: ethers.Contract): Promise<string[]> {
+    let digestsRaw: string[] = await orderBookContract.limitDigestsOfTrader(traderAddr, 0, 15);
+    let k: number = 0;
+    let digests: string[] = [];
+    while (k < digestsRaw.length && BigNumber.from(digestsRaw[k]).gt(0)) {
+      digests.push(digestsRaw[k]);
+      k++;
     }
+    return digests;
+  }
 
-    public static async _exchangeInfo(_proxyContract: ethers.Contract): Promise<ExchangeInfo> {
-        let nestedPerpetualIDs = await PerpetualDataHandler.getNestedPerpetualIds(_proxyContract);
-        let info: ExchangeInfo = { pools: [] };
-        const numPools = nestedPerpetualIDs.length;
-        for (var j = 0; j < numPools; j++) {
-            let perpetualIDs = nestedPerpetualIDs[j];
-            let pool = await _proxyContract.getLiquidityPool(j + 1);
-            let PoolState: PoolState = {
-                isRunning: pool.isRunning,
-                marginTokenAddr: pool.marginTokenAddress,
-                poolShareTokenAddr: pool.shareTokenAddress,
-                defaultFundCashCC: ABK64x64ToFloat(pool.fDefaultFundCashCC),
-                pnlParticipantCashCC: ABK64x64ToFloat(pool.fPnLparticipantsCashCC),
-                totalAMMFundCashCC: ABK64x64ToFloat(pool.fAMMFundCashCC),
-                totalTargetAMMFundSizeCC: ABK64x64ToFloat(pool.fTargetAMMFundSize),
-                brokerCollateralLotSize: ABK64x64ToFloat(pool.fBrokerCollateralLotSize),
-                perpetuals: [],
-            };
-            for (var k = 0; k < perpetualIDs.length; k++) {
-                let perp = await _proxyContract.getPerpetual(perpetualIDs[k]);
-                let fIndexS2 = await _proxyContract.getOraclePrice([perp.S2BaseCCY, perp.S2QuoteCCY]);
-                let indexS2 = ABK64x64ToFloat(fIndexS2);
-                let indexS3 = 1;
-                if (perp.eCollateralCurrency == COLLATERAL_CURRENCY_BASE) {
-                    indexS3 = indexS2;
-                } else if (perp.eCollateralCurrency == COLLATERAL_CURRENCY_QUANTO) {
-                    indexS3 = ABK64x64ToFloat(await _proxyContract.getOraclePrice([perp.S3BaseCCY, perp.S3QuoteCCY]));
-                }
-                let markPremiumRate = ABK64x64ToFloat(perp.currentMarkPremiumRate.fPrice);
-                let currentFundingRateBps = 1e4 * ABK64x64ToFloat(perp.fCurrentFundingRate);
-                let state = PERP_STATE_STR[perp.state];
-                let PerpetualState: PerpetualState = {
-                    id: perp.id,
-                    state: state,
-                    baseCurrency: fromBytes4HexString(perp.S2BaseCCY),
-                    quoteCurrency: fromBytes4HexString(perp.S2QuoteCCY),
-                    indexPrice: indexS2,
-                    collToQuoteIndexPrice: indexS3,
-                    markPrice: indexS2 * (1 + markPremiumRate),
-                    currentFundingRateBps: currentFundingRateBps,
-                    initialMarginRate: ABK64x64ToFloat(perp.fInitialMarginRate),
-                    maintenanceMarginRate: ABK64x64ToFloat(perp.fMaintenanceMarginRate),
-                    openInterestBC: ABK64x64ToFloat(perp.fOpenInterest),
-                    maxPositionBC: ABK64x64ToFloat(perp.fMaxPositionBC),
-                };
-                PoolState.perpetuals.push(PerpetualState);
-            }
-            info.pools.push(PoolState);
+  public static async _exchangeInfo(_proxyContract: ethers.Contract): Promise<ExchangeInfo> {
+    let nestedPerpetualIDs = await PerpetualDataHandler.getNestedPerpetualIds(_proxyContract);
+    let info: ExchangeInfo = { pools: [] };
+    const numPools = nestedPerpetualIDs.length;
+    for (var j = 0; j < numPools; j++) {
+      let perpetualIDs = nestedPerpetualIDs[j];
+      let pool = await _proxyContract.getLiquidityPool(j + 1);
+      let PoolState: PoolState = {
+        isRunning: pool.isRunning,
+        marginTokenAddr: pool.marginTokenAddress,
+        poolShareTokenAddr: pool.shareTokenAddress,
+        defaultFundCashCC: ABK64x64ToFloat(pool.fDefaultFundCashCC),
+        pnlParticipantCashCC: ABK64x64ToFloat(pool.fPnLparticipantsCashCC),
+        totalAMMFundCashCC: ABK64x64ToFloat(pool.fAMMFundCashCC),
+        totalTargetAMMFundSizeCC: ABK64x64ToFloat(pool.fTargetAMMFundSize),
+        brokerCollateralLotSize: ABK64x64ToFloat(pool.fBrokerCollateralLotSize),
+        perpetuals: [],
+      };
+      for (var k = 0; k < perpetualIDs.length; k++) {
+        let perp = await _proxyContract.getPerpetual(perpetualIDs[k]);
+        let fIndexS2 = await _proxyContract.getOraclePrice([perp.S2BaseCCY, perp.S2QuoteCCY]);
+        let indexS2 = ABK64x64ToFloat(fIndexS2);
+        let indexS3 = 1;
+        if (perp.eCollateralCurrency == COLLATERAL_CURRENCY_BASE) {
+          indexS3 = indexS2;
+        } else if (perp.eCollateralCurrency == COLLATERAL_CURRENCY_QUANTO) {
+          indexS3 = ABK64x64ToFloat(await _proxyContract.getOraclePrice([perp.S3BaseCCY, perp.S3QuoteCCY]));
         }
-        return info;
+        let markPremiumRate = ABK64x64ToFloat(perp.currentMarkPremiumRate.fPrice);
+        let currentFundingRateBps = 1e4 * ABK64x64ToFloat(perp.fCurrentFundingRate);
+        let state = PERP_STATE_STR[perp.state];
+        let PerpetualState: PerpetualState = {
+          id: perp.id,
+          state: state,
+          baseCurrency: fromBytes4HexString(perp.S2BaseCCY),
+          quoteCurrency: fromBytes4HexString(perp.S2QuoteCCY),
+          indexPrice: indexS2,
+          collToQuoteIndexPrice: indexS3,
+          markPrice: indexS2 * (1 + markPremiumRate),
+          currentFundingRateBps: currentFundingRateBps,
+          initialMarginRate: ABK64x64ToFloat(perp.fInitialMarginRate),
+          maintenanceMarginRate: ABK64x64ToFloat(perp.fMaintenanceMarginRate),
+          openInterestBC: ABK64x64ToFloat(perp.fOpenInterest),
+          maxPositionBC: ABK64x64ToFloat(perp.fMaxPositionBC),
+        };
+        PoolState.perpetuals.push(PerpetualState);
+      }
+      info.pools.push(PoolState);
     }
+    return info;
+  }
 }

package/src/orderReferrerTool.ts

@@ -1,17 +1,143 @@
 import WriteAccessHandler from "./writeAccessHandler";
-import { NodeSDKConfig } from "./nodeSDKTypes";
+import { BUY_SIDE, NodeSDKConfig, Order, SELL_SIDE, ZERO_ADDRESS } from "./nodeSDKTypes";
+import { ethers } from "ethers";
 
 /**
- * OrderReferrerTool
- * Methods to refer orders from the limit order book
+ * Methods to execute existing orders from the limit order book.
  */
 export default class OrderReferrerTool extends WriteAccessHandler {
   /**
-   * Constructor
-   * @param config configuration
-   * @param privateKey private key of account that trades
+   * Constructor.
+   * @param {NodeSDKConfig} config Configuration object.
+   * @param {string} privateKey Private key of the wallet that executes the conditional orders.
    */
   public constructor(config: NodeSDKConfig, privateKey: string) {
     super(config, privateKey);
   }
+
+  /**
+   * Executes an order by symbol and ID. This action interacts with the blockchain and incurs in gas costs.
+   * @param {string} symbol Symbol of the form ETH-USD-MATIC.
+   * @param {string} orderId ID of the order to be executed.
+   * @param {string=} referrerAddr Address of the wallet to be credited for executing the order,
+   * if different from the one submitting this transaction.
+   * @returns Transaction object.
+   */
+  public async executeOrder(
+    symbol: string,
+    orderId: string,
+    referrerAddr?: string
+  ): Promise<ethers.providers.TransactionResponse> {
+    if (this.proxyContract == null || this.signer == null) {
+      throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
+    }
+    const orderBookSC = this.getOrderBookContract(symbol);
+    if (typeof referrerAddr == "undefined") {
+      referrerAddr = this.traderAddr;
+    }
+    return await orderBookSC.executeLimitOrderByDigest(orderId, referrerAddr);
+  }
+
+  /**
+   * All the orders in the order book for a given symbol that are currently open.
+   * @param {string} symbol Symbol of the form ETH-USD-MATIC.
+   * @returns Array with all open orders and their IDs.
+   */
+  public async getAllOpenOrders(symbol: string): Promise<[Order[], string[]]> {
+    let totalOrders = await this.numberOfOpenOrders(symbol);
+    return await this.pollLimitOrders(symbol, totalOrders);
+  }
+
+  /**
+   * Total number of limit orders for this symbol, excluding those that have been cancelled/removed.
+   * @param {string} symbol Symbol of the form ETH-USD-MATIC.
+   * @returns {number} Number of open orders.
+   */
+  public async numberOfOpenOrders(symbol: string): Promise<number> {
+    if (this.proxyContract == null) {
+      throw Error("no proxy contract initialized. Use createProxyInstance().");
+    }
+    const orderBookSC = this.getOrderBookContract(symbol);
+    return await orderBookSC.numberOfOrderBookDigests();
+  }
+
+  /**
+   * Get a list of active conditional orders in the order book.
+   * This a read-only action and does not incur in gas costs.
+   * @param {string} symbol Symbol of the form ETH-USD-MATIC.
+   * @param {number} numElements Maximum number of orders to poll.
+   * @param {string=} startAfter Optional order ID from where to start polling. Defaults to the first order.
+   * @returns Array of orders and corresponding order IDs
+   */
+  public async pollLimitOrders(symbol: string, numElements: number, startAfter?: string): Promise<[Order[], string[]]> {
+    if (this.proxyContract == null) {
+      throw Error("no proxy contract initialized. Use createProxyInstance().");
+    }
+    if (typeof startAfter == "undefined") {
+      startAfter = ethers.constants.HashZero;
+    }
+    const orderBookSC = this.getOrderBookContract(symbol);
+    let [orders, orderIds] = await orderBookSC.pollLimitOrders(startAfter, numElements);
+    let userFriendlyOrders: Order[] = new Array<Order>();
+    let k = 0;
+    while (k < orders.length && orders[k].traderAddr != ZERO_ADDRESS) {
+      userFriendlyOrders.push(WriteAccessHandler.fromSmartContractOrder(orders[k], this.symbolToPerpStaticInfo));
+      k++;
+    }
+    return [userFriendlyOrders, orderIds];
+  }
+
+  public async isTradeable(order: Order) {
+    if (this.proxyContract == null) {
+      throw Error("no proxy contract initialized. Use createProxyInstance().");
+    }
+    if (order.limitPrice == undefined) {
+      throw Error("order does not have a limit price");
+    }
+    // check expiration date
+    if (order.deadline != undefined && order.deadline < Date.now()) {
+      return false;
+    }
+    // check limit price
+    let orderPrice = await WriteAccessHandler._queryPerpetualPrice(
+      order.symbol,
+      order.quantity,
+      this.symbolToPerpStaticInfo,
+      this.proxyContract
+    );
+    if (
+      (order.side == BUY_SIDE && orderPrice > order.limitPrice) ||
+      (order.side == SELL_SIDE && orderPrice < order.limitPrice)
+    ) {
+      return false;
+    }
+    // do we need to check trigger/stop?
+    if (order.stopPrice == undefined) {
+      // nothing to check, order is tradeable
+      return true;
+    }
+    // we need the mark price to check
+    let markPrice = await WriteAccessHandler._queryPerpetualMarkPrice(
+      order.symbol,
+      this.symbolToPerpStaticInfo,
+      this.proxyContract
+    );
+    if (
+      (order.side == BUY_SIDE && markPrice < order.stopPrice) ||
+      (order.side == SELL_SIDE && markPrice > order.stopPrice)
+    ) {
+      return false;
+    }
+    // all checks passed -> order is tradeable
+    return true;
+  }
+
+  /**
+   * TODO:
+   * - [x] executeLimitOrderByDigest
+   * - [x] pollLimitOrders
+   * - [x] isTradeable
+   * - [ ] get all limit orders
+   * - [ ] tests
+   */
 }

package/src/perpetualDataHandler.ts

@@ -28,6 +28,7 @@ import {
   DEFAULT_CONFIG_MAINNET,
   DEFAULT_CONFIG_TESTNET_NAME,
   DEFAULT_CONFIG_TESTNET,
+  ONE_64x64,
 } from "./nodeSDKTypes";
 import { fromBytes4HexString, to4Chars, combineFlags, containsFlag } from "./utils";
 import {
@@ -282,6 +283,27 @@ export default class PerpetualDataHandler {
     return mgn;
   }
 
+  protected static async _queryPerpetualPrice(
+    symbol: string,
+    tradeAmount: number,
+    symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>,
+    _proxyContract: ethers.Contract
+  ): Promise<number> {
+    let perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
+    let fPrice = await _proxyContract.queryPerpetualPrice(perpId, floatToABK64x64(tradeAmount));
+    return ABK64x64ToFloat(fPrice);
+  }
+
+  protected static async _queryPerpetualMarkPrice(
+    symbol: string,
+    symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>,
+    _proxyContract: ethers.Contract
+  ): Promise<number> {
+    let perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
+    let ammState = await _proxyContract.getAMMState(perpId);
+    return ABK64x64ToFloat(ammState[6].mul(ONE_64x64.add(ammState[8])));
+  }
+
   /**
    * Liquidation price
    * @param cleanSymbol symbol after calling symbolToBytes4Symbol
@@ -368,12 +390,13 @@ export default class PerpetualDataHandler {
     return symbols[0] + "-" + symbols[1] + "-" + symbols[2];
   }
 
-  private static _getByValue(map: any, searchValue: any) {
+  private static _getByValue(map: any, searchValue: any, valueField: any) {
     for (let [key, value] of map.entries()) {
-      if (value === searchValue) {
+      if (value[valueField] === searchValue) {
         return key;
       }
     }
+    return undefined;
   }
 
   protected static fromSmartContractOrder(
@@ -381,7 +404,10 @@ export default class PerpetualDataHandler {
     symbolToPerpInfoMap: Map<string, PerpetualStaticInfo>
   ): Order {
     // find symbol of perpetual id
-    let symbol = PerpetualDataHandler._getByValue(symbolToPerpInfoMap, order.iPerpetualId);
+    let symbol = PerpetualDataHandler._getByValue(symbolToPerpInfoMap, order.iPerpetualId, "id");
+    if (symbol == undefined) {
+      throw Error(`Perpetual id ${order.iPerpetualId} not found. Check with marketData.exchangeInfo().`);
+    }
     let side = order.fAmount > 0 ? BUY_SIDE : SELL_SIDE;
     let limitPrice, stopPrice;
     let fLimitPrice: BigNumber | undefined = BigNumber.from(order.fLimitPrice);
@@ -397,16 +423,16 @@ export default class PerpetualDataHandler {
       stopPrice = ABK64x64ToFloat(fStopPrice);
     }
     let userOrder: Order = {
-      symbol: symbol,
+      symbol: symbol!,
       side: side,
       type: PerpetualDataHandler._flagToOrderType(order),
       quantity: Math.abs(ABK64x64ToFloat(BigNumber.from(order.fAmount))),
       reduceOnly: containsFlag(BigNumber.from(order.flags), MASK_CLOSE_ONLY),
       limitPrice: limitPrice,
       keepPositionLvg: containsFlag(BigNumber.from(order.flags), MASK_KEEP_POS_LEVERAGE),
-      brokerFeeTbps: Number(order.brokerFeeTbps),
-      brokerAddr: order.brokerAddr,
-      brokerSignature: order.brokerSignature,
+      brokerFeeTbps: order.brokerFeeTbps == 0 ? undefined : Number(order.brokerFeeTbps),
+      brokerAddr: order.brokerAddr == ZERO_ADDRESS ? undefined : order.brokerAddr,
+      brokerSignature: order.brokerSignature == "0x" ? undefined : order.brokerSignature,
       stopPrice: stopPrice,
       leverage: ABK64x64ToFloat(BigNumber.from(order.fLeverage)),
       deadline: Number(order.iDeadline),

package/src/utils.ts

@@ -1,32 +1,33 @@
 import { BigNumber } from "ethers";
-
-const ethers = require("ethers");
+/**
+ * @module utils
+ */
 
 function _isVocal(char: string) {
-    char = char.toLowerCase();
-    return char == "a" || char == "e" || char == "i" || char == "o" || char == "u";
+  char = char.toLowerCase();
+  return char == "a" || char == "e" || char == "i" || char == "o" || char == "u";
 }
 
 /**
  *
- * @param   s string to shorten/extend to 4 characters
- * @returns string with 4 characters (or characters + null chars)
+ * @param {string} s String to shorten/extend to 4 characters
+ * @returns {string} String with 4 characters (or characters + null chars)
  */
 export function to4Chars(s: string) {
-    while (s.length < 4) {
-        s = s + "\0";
+  while (s.length < 4) {
+    s = s + "\0";
+  }
+  let k = s.length - 1;
+  while (s.length > 4 && k >= 0) {
+    // chop off vocals from the end of string
+    // e.g. MATIC -> MATC
+    if (_isVocal(s.charAt(k))) {
+      s = s.substring(0, k) + s.substring(k + 1, s.length);
     }
-    let k = s.length - 1;
-    while (s.length > 4 && k >= 0) {
-        // chop off vocals from the end of string
-        // e.g. MATIC -> MATC
-        if (_isVocal(s.charAt(k))) {
-            s = s.substring(0, k) + s.substring(k + 1, s.length);
-        }
-        k--;
-    }
-    s = s.substring(0, 4);
-    return s;
+    k--;
+  }
+  s = s.substring(0, 4);
+  return s;
 }
 
 /**
@@ -35,49 +36,49 @@ export function to4Chars(s: string) {
  * 4 characters.
  * Resulting buffer can be used with smart contract to
  * identify tokens (BTC, USDC, MATIC etc.)
- * @param s string to encode into bytes4
- * @returns buffer
+ * @param {string} s String to encode into bytes4
+ * @returns {Buffer} 4-character bytes4.
  */
 export function toBytes4(s: string): Buffer {
-    s = to4Chars(s);
-    let valBuff: Buffer = Buffer.from(s, "ascii");
-    return valBuff;
+  s = to4Chars(s);
+  let valBuff: Buffer = Buffer.from(s, "ascii");
+  return valBuff;
 }
 
 /**
  * Decodes a buffer encoded with toBytes4 into
  * a string. The string is the result of to4Chars of the
  * originally encoded string stripped from null-chars
- * @param b correctly encoded bytes4 buffer using toBytes4
- * @returns string decoded into to4Chars-type string without null characters
+ * @param {Buffer} b Correctly encoded bytes4 buffer using toBytes4
+ * @returns {string} String decoded into to4Chars-type string without null characters
  */
 export function fromBytes4(b: Buffer): string {
-    let val: string = b.toString("ascii");
-    val = val.replace(/\0/g, "");
-    return val;
+  let val: string = b.toString("ascii");
+  val = val.replace(/\0/g, "");
+  return val;
 }
 
 /**
  * Decodes the bytes4 encoded string received from the
  * smart contract as a hex-number in string-format
- * @param s string representing a hex-number ("0x...")
- * @returns x of to4Chars(x) stripped from null-chars,
+ * @param {string} s string representing a hex-number ("0x...")
+ * @returns {string} x of to4Chars(x) stripped from null-chars,
  * where x was originally encoded and
  * returned by the smart contract as bytes4
  */
 export function fromBytes4HexString(s: string): string {
-    let res = "";
-    for (let k = 2; k < s.length; k = k + 2) {
-        res = res + String.fromCharCode(parseInt(s.substring(k, k + 2), 16));
-    }
-    res = res.replace(/\0/g, "");
-    return res;
+  let res = "";
+  for (let k = 2; k < s.length; k = k + 2) {
+    res = res + String.fromCharCode(parseInt(s.substring(k, k + 2), 16));
+  }
+  res = res.replace(/\0/g, "");
+  return res;
 }
 
 export function combineFlags(f1: BigNumber, f2: BigNumber): BigNumber {
-    return BigNumber.from(parseInt(f1.toString()) | parseInt(f2.toString()));
+  return BigNumber.from(parseInt(f1.toString()) | parseInt(f2.toString()));
 }
 
 export function containsFlag(f1: BigNumber, f2: BigNumber): boolean {
-    return (parseInt(f1.toString()) & parseInt(f2.toString())) > 0;
+  return (parseInt(f1.toString()) & parseInt(f2.toString())) > 0;
 }