@d8x/perpetuals-sdk 0.0.1

package/dist/perpetualDataHandler.js

@@ -0,0 +1,474 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const nodeSDKTypes_1 = require("./nodeSDKTypes");
+const utils_1 = require("./utils");
+const d8XMath_1 = require("./d8XMath");
+/**
+ * Parent class for AccountTrade and MarketData that handles
+ * common data and chain operations
+ */
+class PerpetualDataHandler {
+    constructor(config) {
+        this.proxyContract = null;
+        // limit order book
+        this.lobFactoryContract = null;
+        this.provider = null;
+        this.signerOrProvider = null;
+        this.symbolToPerpStaticInfo = new Map();
+        this.poolStaticInfos = new Array();
+        this.symbolToTokenAddrMap = new Map();
+        this.nestedPerpetualIDs = new Array();
+        this.proxyAddr = config.proxyAddr;
+        this.lobFactoryAddr = config.limitOrderBookFactoryAddr;
+        this.nodeURL = config.nodeURL;
+        this.proxyABI = require(config.proxyABILocation);
+        this.lobFactoryABI = require(config.limitOrderBookFactoryABILocation);
+        this.lobABI = require(config.limitOrderBookABILocation);
+    }
+    initContractsAndData(signerOrProvider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.signerOrProvider = signerOrProvider;
+            this.proxyContract = new ethers_1.ethers.Contract(this.proxyAddr, this.proxyABI, signerOrProvider);
+            this.lobFactoryContract = new ethers_1.ethers.Contract(this.lobFactoryAddr, this.lobFactoryABI, signerOrProvider);
+            yield this._fillSymbolMaps(this.proxyContract);
+        });
+    }
+    /**
+     * Returns the order-book contract for the symbol if found or fails
+     * @param symbol symbol of the form ETH-USD-MATIC
+     * @returns order book contract for the perpetual
+     */
+    getOrderBookContract(symbol) {
+        var _a;
+        let cleanSymbol = PerpetualDataHandler.symbolToBytes4Symbol(symbol);
+        let orderBookAddr = (_a = this.symbolToPerpStaticInfo.get(cleanSymbol)) === null || _a === void 0 ? void 0 : _a.limitOrderBookAddr;
+        if (orderBookAddr == "" || orderBookAddr == undefined || this.signerOrProvider == null) {
+            throw Error(`no limit order book found for ${symbol} or no signer`);
+        }
+        let lobContract = new ethers_1.ethers.Contract(orderBookAddr, this.lobABI, this.signerOrProvider);
+        return lobContract;
+    }
+    /**
+     * Called when initializing. This function fills this.symbolToTokenAddrMap,
+     * and this.nestedPerpetualIDs and this.symbolToPerpStaticInfo
+     *
+     */
+    _fillSymbolMaps(proxyContract) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (proxyContract == null || this.lobFactoryContract == null) {
+                throw Error("proxy or limit order book not defined");
+            }
+            this.nestedPerpetualIDs = yield PerpetualDataHandler.getNestedPerpetualIds(proxyContract);
+            for (let j = 0; j < this.nestedPerpetualIDs.length; j++) {
+                let pool = yield proxyContract.getLiquidityPool(j + 1);
+                let poolMarginTokenAddr = pool.marginTokenAddress;
+                let perpetualIDs = this.nestedPerpetualIDs[j];
+                let poolCCY = undefined;
+                let currentSymbols = [];
+                let currentSymbolsS3 = [];
+                let currentLimitOrderBookAddr = [];
+                let ccy = [];
+                let mgnRate = [];
+                for (let k = 0; k < perpetualIDs.length; k++) {
+                    let perp = yield proxyContract.getPerpetual(perpetualIDs[k]);
+                    let base = (0, utils_1.fromBytes4HexString)(perp.S2BaseCCY);
+                    let quote = (0, utils_1.fromBytes4HexString)(perp.S2QuoteCCY);
+                    let base3 = (0, utils_1.fromBytes4HexString)(perp.S3BaseCCY);
+                    let quote3 = (0, utils_1.fromBytes4HexString)(perp.S3QuoteCCY);
+                    currentSymbols.push(base + "-" + quote);
+                    currentSymbolsS3.push(base3 + "-" + quote3);
+                    mgnRate.push((0, d8XMath_1.ABK64x64ToFloat)(perp.fMaintenanceMarginRate));
+                    // try to find a limit order book
+                    let lobAddr = yield this.lobFactoryContract.getOrderBookAddress(perpetualIDs[k]);
+                    currentLimitOrderBookAddr.push(lobAddr);
+                    // we find out the pool currency by looking at all perpetuals
+                    // unless for quanto perpetuals, we know the pool currency
+                    // from the perpetual. This fails if we have a pool with only
+                    // quanto perpetuals
+                    if (perp.eCollateralCurrency == nodeSDKTypes_1.COLLATERAL_CURRENCY_BASE) {
+                        poolCCY = base;
+                        ccy.push(nodeSDKTypes_1.CollaterlCCY.BASE);
+                    }
+                    else if (perp.eCollateralCurrency == nodeSDKTypes_1.COLLATERAL_CURRENCY_QUOTE) {
+                        poolCCY = quote;
+                        ccy.push(nodeSDKTypes_1.CollaterlCCY.QUOTE);
+                    }
+                    else {
+                        ccy.push(nodeSDKTypes_1.CollaterlCCY.QUANTO);
+                    }
+                }
+                if (perpetualIDs.length == 0) {
+                    continue;
+                }
+                if (poolCCY == undefined) {
+                    throw Error("Pool only has quanto perps, unable to determine collateral currency");
+                }
+                let oracleFactoryAddr = yield proxyContract.getOracleFactory();
+                let info = {
+                    poolId: j + 1,
+                    poolMarginSymbol: poolCCY,
+                    poolMarginTokenAddr: poolMarginTokenAddr,
+                    shareTokenAddr: pool.shareTokenAddress,
+                    oracleFactoryAddr: oracleFactoryAddr,
+                };
+                this.poolStaticInfos.push(info);
+                let currentSymbols3 = currentSymbols.map((x) => x + "-" + poolCCY);
+                // push into map
+                for (let k = 0; k < perpetualIDs.length; k++) {
+                    this.symbolToPerpStaticInfo.set(currentSymbols3[k], {
+                        id: perpetualIDs[k],
+                        limitOrderBookAddr: currentLimitOrderBookAddr[k],
+                        maintenanceMarginRate: mgnRate[k],
+                        collateralCurrencyType: ccy[k],
+                        S2Symbol: currentSymbols[k],
+                        S3Symbol: currentSymbolsS3[k],
+                    });
+                }
+                // push margin token address into map
+                this.symbolToTokenAddrMap.set(poolCCY, poolMarginTokenAddr);
+            }
+        });
+    }
+    getSymbolFromPoolId(poolId) {
+        return PerpetualDataHandler._getSymbolFromPoolId(poolId, this.poolStaticInfos);
+    }
+    getPoolIdFromSymbol(symbol) {
+        return PerpetualDataHandler._getPoolIdFromSymbol(symbol, this.poolStaticInfos);
+    }
+    static _getSymbolFromPoolId(poolId, staticInfos) {
+        let idx = poolId - 1;
+        return staticInfos[idx].poolMarginSymbol;
+    }
+    static _getPoolIdFromSymbol(symbol, staticInfos) {
+        let symbols = symbol.split("-");
+        //in case user provided ETH-USD-MATIC instead of MATIC; or similar
+        if (symbols.length == 3) {
+            symbol = symbols[2];
+        }
+        let cleanSymbol = (0, utils_1.to4Chars)(symbol);
+        cleanSymbol = cleanSymbol.replace(/\0/g, "");
+        let j = 0;
+        while (j < staticInfos.length && staticInfos[j].poolMarginSymbol != cleanSymbol) {
+            j++;
+        }
+        if (j == staticInfos.length) {
+            throw new Error(`no pool found for symbol ${symbol}`);
+        }
+        return j + 1;
+    }
+    static getNestedPerpetualIds(_proxyContract) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let poolCount = yield _proxyContract.getPoolCount();
+            let poolIds = new Array(poolCount);
+            for (let i = 1; i < poolCount + 1; i++) {
+                let perpetualCount = yield _proxyContract.getPerpetualCountInPool(i);
+                poolIds[i - 1] = new Array(perpetualCount);
+                for (let j = 0; j < perpetualCount; j++) {
+                    let id = yield _proxyContract.getPerpetualId(i, j);
+                    poolIds[i - 1][j] = id;
+                }
+            }
+            return poolIds;
+        });
+    }
+    static getMarginAccount(traderAddr, symbol, symbolToPerpStaticInfo, _proxyContract) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let cleanSymbol = PerpetualDataHandler.symbolToBytes4Symbol(symbol);
+            let perpId = PerpetualDataHandler.symbolToPerpetualId(cleanSymbol, symbolToPerpStaticInfo);
+            const idx_cash = 3;
+            const idx_notional = 4;
+            const idx_locked_in = 5;
+            const idx_mark_price = 8;
+            const idx_lvg = 7;
+            const idx_s3 = 9;
+            let traderState = yield _proxyContract.getTraderState(perpId, traderAddr);
+            let isEmpty = traderState[idx_notional] == 0;
+            let cash = (0, d8XMath_1.ABK64x64ToFloat)(traderState[idx_cash]);
+            let S2Liq = 0, S3Liq = 0, tau = Infinity, pnl = 0, unpaidFundingCC = 0, fLockedIn = ethers_1.BigNumber.from(0), side = nodeSDKTypes_1.CLOSED_SIDE, entryPrice = 0;
+            if (!isEmpty) {
+                [S2Liq, S3Liq, tau, pnl, unpaidFundingCC] = PerpetualDataHandler._calculateLiquidationPrice(cleanSymbol, traderState, symbolToPerpStaticInfo);
+                fLockedIn = traderState[idx_locked_in];
+                side = traderState[idx_locked_in] > 0 ? nodeSDKTypes_1.BUY_SIDE : nodeSDKTypes_1.SELL_SIDE;
+                entryPrice = (0, d8XMath_1.ABK64x64ToFloat)((0, d8XMath_1.div64x64)(fLockedIn, traderState[idx_notional]));
+            }
+            let mgn = {
+                symbol: symbol,
+                positionNotionalBaseCCY: isEmpty ? 0 : (0, d8XMath_1.ABK64x64ToFloat)(traderState[idx_notional]),
+                side: isEmpty ? nodeSDKTypes_1.CLOSED_SIDE : side,
+                entryPrice: isEmpty ? 0 : entryPrice,
+                leverage: isEmpty ? 0 : (0, d8XMath_1.ABK64x64ToFloat)(traderState[idx_lvg]),
+                markPrice: (0, d8XMath_1.ABK64x64ToFloat)(traderState[idx_mark_price].abs()),
+                unrealizedPnlQuoteCCY: isEmpty ? 0 : pnl,
+                unrealizedFundingCollateralCCY: isEmpty ? 0 : unpaidFundingCC,
+                collateralCC: cash,
+                liquidationLvg: isEmpty ? 0 : 1 / tau,
+                liquidationPrice: isEmpty ? [0, 0] : [S2Liq, S3Liq],
+                collToQuoteConversion: (0, d8XMath_1.ABK64x64ToFloat)(traderState[idx_s3]),
+            };
+            return mgn;
+        });
+    }
+    /**
+     * Liquidation price
+     * @param cleanSymbol symbol after calling symbolToBytes4Symbol
+     * @param traderState BigInt array according to smart contract
+     * @param symbolToPerpStaticInfo mapping symbol->PerpStaticInfo
+     * @returns liquidation mark-price, corresponding collateral/quote conversion
+     */
+    static _calculateLiquidationPrice(cleanSymbol, traderState, symbolToPerpStaticInfo) {
+        const idx_availableCashCC = 2;
+        const idx_cash = 3;
+        const idx_notional = 4;
+        const idx_locked_in = 5;
+        const idx_mark_price = 8;
+        const idx_s3 = 9;
+        const idx_s2 = 10;
+        let S2Liq;
+        let S3Liq = (0, d8XMath_1.ABK64x64ToFloat)(traderState[idx_s3]);
+        let perpInfo = symbolToPerpStaticInfo.get(cleanSymbol);
+        if (perpInfo == undefined) {
+            throw new Error(`no info for perpetual ${cleanSymbol}`);
+        }
+        let tau = perpInfo.maintenanceMarginRate;
+        let lockedInValueQC = (0, d8XMath_1.ABK64x64ToFloat)(traderState[idx_locked_in]);
+        let position = (0, d8XMath_1.ABK64x64ToFloat)(traderState[idx_notional]);
+        let cashCC = (0, d8XMath_1.ABK64x64ToFloat)(traderState[idx_availableCashCC]);
+        let Sm = (0, d8XMath_1.ABK64x64ToFloat)(traderState[idx_mark_price]);
+        let unpaidFundingCC = (0, d8XMath_1.ABK64x64ToFloat)(traderState[idx_availableCashCC].sub(traderState[idx_cash]));
+        let unpaidFunding = unpaidFundingCC;
+        if (perpInfo.collateralCurrencyType == nodeSDKTypes_1.CollaterlCCY.BASE) {
+            S2Liq = (0, d8XMath_1.calculateLiquidationPriceCollateralBase)(lockedInValueQC, position, cashCC, tau);
+            S3Liq = S2Liq;
+            unpaidFunding = unpaidFunding / (0, d8XMath_1.ABK64x64ToFloat)(traderState[idx_s2]);
+        }
+        else if (perpInfo.collateralCurrencyType == nodeSDKTypes_1.CollaterlCCY.QUANTO) {
+            let S3 = S3Liq;
+            S3Liq = S3;
+            S2Liq = (0, d8XMath_1.calculateLiquidationPriceCollateralQuanto)(lockedInValueQC, position, cashCC, tau, S3, Sm);
+            unpaidFunding = unpaidFunding / S3;
+        }
+        else {
+            S2Liq = (0, d8XMath_1.calculateLiquidationPriceCollateralQuote)(lockedInValueQC, position, cashCC, tau);
+        }
+        let pnl = position * Sm - lockedInValueQC - unpaidFunding;
+        return [S2Liq, S3Liq, tau, pnl, unpaidFundingCC];
+    }
+    /**
+     * Finds the perpetual id for a symbol of the form
+     * <base>-<quote>-<collateral>. The function first converts the
+     * token names into bytes4 representation
+     * @param symbol                  symbol (e.g., BTC-USD-MATIC)
+     * @param symbolToPerpStaticInfo  map that contains the bytes4-symbol to PerpetualStaticInfo
+     * including id mapping
+     * @returns perpetual id or it fails
+     */
+    static symbolToPerpetualId(symbol, symbolToPerpStaticInfo) {
+        var _a;
+        let cleanSymbol = PerpetualDataHandler.symbolToBytes4Symbol(symbol);
+        let id = (_a = symbolToPerpStaticInfo.get(cleanSymbol)) === null || _a === void 0 ? void 0 : _a.id;
+        if (id == undefined) {
+            throw Error(`No perpetual found for symbol ${symbol}`);
+        }
+        return id;
+    }
+    static symbolToBytes4Symbol(symbol) {
+        //split by dashes BTC-USD-MATIC
+        let symbols = symbol.split("-");
+        if (symbols.length != 3) {
+            throw Error(`Symbol ${symbol} not valid. Expecting CCY-CCY-CCY format`);
+        }
+        //transform into bytes4 currencies (without the space): "BTC", "USD", "MATC"
+        symbols = symbols.map((x) => {
+            let v = (0, utils_1.to4Chars)(x);
+            v = v.replace(/\0/g, "");
+            return v;
+        });
+        // concatenate and find perpetual Id in map
+        return symbols[0] + "-" + symbols[1] + "-" + symbols[2];
+    }
+    static _getByValue(map, searchValue) {
+        for (let [key, value] of map.entries()) {
+            if (value === searchValue) {
+                return key;
+            }
+        }
+    }
+    static fromSmartContractOrder(order, symbolToPerpInfoMap) {
+        // find symbol of perpetual id
+        let symbol = PerpetualDataHandler._getByValue(symbolToPerpInfoMap, order.iPerpetualId);
+        let side = order.fAmount > 0 ? nodeSDKTypes_1.BUY_SIDE : nodeSDKTypes_1.SELL_SIDE;
+        let limitPrice, stopPrice;
+        let fLimitPrice = ethers_1.BigNumber.from(order.fLimitPrice);
+        if (fLimitPrice.eq(0) || fLimitPrice.eq(nodeSDKTypes_1.MAX_64x64)) {
+            limitPrice = undefined;
+        }
+        else {
+            limitPrice = (0, d8XMath_1.ABK64x64ToFloat)(fLimitPrice);
+        }
+        let fStopPrice = ethers_1.BigNumber.from(order.fTriggerPrice);
+        if (fStopPrice.eq(0) || fStopPrice.eq(nodeSDKTypes_1.MAX_64x64)) {
+            stopPrice = undefined;
+        }
+        else {
+            stopPrice = (0, d8XMath_1.ABK64x64ToFloat)(fStopPrice);
+        }
+        let userOrder = {
+            symbol: symbol,
+            side: side,
+            type: PerpetualDataHandler._flagToOrderType(order),
+            quantity: Math.abs((0, d8XMath_1.ABK64x64ToFloat)(ethers_1.BigNumber.from(order.fAmount))),
+            reduceOnly: (0, utils_1.containsFlag)(ethers_1.BigNumber.from(order.flags), nodeSDKTypes_1.MASK_CLOSE_ONLY),
+            limitPrice: limitPrice,
+            keepPositionLvg: (0, utils_1.containsFlag)(ethers_1.BigNumber.from(order.flags), nodeSDKTypes_1.MASK_KEEP_POS_LEVERAGE),
+            brokerFeeTbps: Number(order.brokerFeeTbps),
+            brokerAddr: order.brokerAddr,
+            brokerSignature: order.brokerSignature,
+            stopPrice: stopPrice,
+            leverage: (0, d8XMath_1.ABK64x64ToFloat)(ethers_1.BigNumber.from(order.fLeverage)),
+            deadline: Number(order.iDeadline),
+            timestamp: Number(order.createdTimestamp),
+        };
+        return userOrder;
+    }
+    /**
+     * Transform the convenient form of the order into a smart-contract accepted type of order
+     * @param order                 order type
+     * @param traderAddr            address of the trader
+     * @param symbolToPerpetualMap  mapping of symbol to perpetual Id
+     * @returns SmartContractOrder
+     */
+    static toSmartContractOrder(order, traderAddr, perpStaticInfo) {
+        let flags = PerpetualDataHandler._orderTypeToFlag(order);
+        let brokerSig = order.brokerSignature == undefined ? [] : order.brokerSignature;
+        let perpetualId = PerpetualDataHandler.symbolToPerpetualId(order.symbol, perpStaticInfo);
+        let fAmount;
+        if (order.side == nodeSDKTypes_1.BUY_SIDE) {
+            fAmount = (0, d8XMath_1.floatToABK64x64)(Math.abs(order.quantity));
+        }
+        else if (order.side == nodeSDKTypes_1.SELL_SIDE) {
+            fAmount = (0, d8XMath_1.floatToABK64x64)(-Math.abs(order.quantity));
+        }
+        else {
+            throw Error(`invalid side in order spec, use ${nodeSDKTypes_1.BUY_SIDE} or ${nodeSDKTypes_1.SELL_SIDE}`);
+        }
+        let fLimitPrice;
+        if (order.limitPrice == undefined) {
+            // we need to set the limit price to infinity or zero for
+            // the trade to go through
+            // Also: stop orders always have limits set, so even  for this case
+            // we set the limit to 0 or infinity
+            fLimitPrice = order.side == nodeSDKTypes_1.BUY_SIDE ? nodeSDKTypes_1.MAX_64x64 : ethers_1.BigNumber.from(0);
+        }
+        else {
+            fLimitPrice = (0, d8XMath_1.floatToABK64x64)(order.limitPrice);
+        }
+        let iDeadline = order.deadline == undefined ? Date.now() + nodeSDKTypes_1.ORDER_MAX_DURATION_SEC : order.deadline;
+        let fTriggerPrice = order.stopPrice == undefined ? ethers_1.BigNumber.from(0) : (0, d8XMath_1.floatToABK64x64)(order.stopPrice);
+        if (order.reduceOnly != undefined && order.reduceOnly == true) {
+        }
+        let smOrder = {
+            flags: flags,
+            iPerpetualId: ethers_1.BigNumber.from(perpetualId),
+            brokerFeeTbps: order.brokerFeeTbps == undefined ? ethers_1.BigNumber.from(0) : ethers_1.BigNumber.from(order.brokerFeeTbps),
+            traderAddr: traderAddr,
+            brokerAddr: order.brokerAddr == undefined ? nodeSDKTypes_1.ZERO_ADDRESS : order.brokerAddr,
+            referrerAddr: nodeSDKTypes_1.ZERO_ADDRESS,
+            brokerSignature: brokerSig,
+            fAmount: fAmount,
+            fLimitPrice: fLimitPrice,
+            fTriggerPrice: fTriggerPrice,
+            fLeverage: order.leverage == undefined ? ethers_1.BigNumber.from(0) : (0, d8XMath_1.floatToABK64x64)(order.leverage),
+            iDeadline: ethers_1.BigNumber.from(iDeadline),
+            createdTimestamp: ethers_1.BigNumber.from(order.timestamp),
+        };
+        return smOrder;
+    }
+    static _flagToOrderType(order) {
+        let hasTrigger = ethers_1.BigNumber.from(order.fTriggerPrice).eq(0);
+        let hasLimit = !ethers_1.BigNumber.from(order.fTriggerPrice).eq(0) || !ethers_1.BigNumber.from(order.fTriggerPrice).eq(nodeSDKTypes_1.MAX_64x64);
+        if (hasTrigger && hasLimit) {
+            return nodeSDKTypes_1.ORDER_TYPE_STOP_LIMIT;
+        }
+        else if (hasTrigger && !hasLimit) {
+            return nodeSDKTypes_1.ORDER_TYPE_STOP_MARKET;
+        }
+        else if (hasLimit && (0, utils_1.containsFlag)(ethers_1.BigNumber.from(order.flags), nodeSDKTypes_1.MASK_LIMIT_ORDER)) {
+            return nodeSDKTypes_1.ORDER_TYPE_LIMIT;
+        }
+        else {
+            return nodeSDKTypes_1.ORDER_TYPE_MARKET;
+        }
+    }
+    /**
+     * Determine the correct order flags based on the order-properties.
+     * Checks for some misspecifications.
+     * @param order     order type
+     * @returns BigNumber flags
+     */
+    static _orderTypeToFlag(order) {
+        let flag;
+        switch (order.type) {
+            case nodeSDKTypes_1.ORDER_TYPE_LIMIT:
+                flag = nodeSDKTypes_1.MASK_LIMIT_ORDER;
+                break;
+            case nodeSDKTypes_1.ORDER_TYPE_MARKET:
+                flag = nodeSDKTypes_1.MASK_MARKET_ORDER;
+                break;
+            case nodeSDKTypes_1.ORDER_TYPE_STOP_MARKET:
+                flag = nodeSDKTypes_1.MASK_STOP_ORDER;
+                break;
+            case nodeSDKTypes_1.ORDER_TYPE_STOP_LIMIT:
+                flag = nodeSDKTypes_1.MASK_STOP_ORDER;
+                break;
+            default: {
+                throw Error(`Order type ${order.type} not found.`);
+            }
+        }
+        if (order.keepPositionLvg != undefined && order.keepPositionLvg) {
+            flag = (0, utils_1.combineFlags)(flag, nodeSDKTypes_1.MASK_KEEP_POS_LEVERAGE);
+        }
+        if (order.reduceOnly != undefined && order.reduceOnly) {
+            flag = (0, utils_1.combineFlags)(flag, nodeSDKTypes_1.MASK_CLOSE_ONLY);
+        }
+        if ((order.type == nodeSDKTypes_1.ORDER_TYPE_LIMIT || order.type == nodeSDKTypes_1.ORDER_TYPE_STOP_LIMIT) && order.limitPrice == undefined) {
+            throw Error(`Order type ${order.type} requires limit price.`);
+        }
+        if ((order.type == nodeSDKTypes_1.ORDER_TYPE_STOP_MARKET || order.type == nodeSDKTypes_1.ORDER_TYPE_STOP_LIMIT) && order.stopPrice == undefined) {
+            throw Error(`Order type ${order.type} requires trigger price.`);
+        }
+        if ((order.type == nodeSDKTypes_1.ORDER_TYPE_MARKET || order.type == nodeSDKTypes_1.ORDER_TYPE_LIMIT) && order.stopPrice != undefined) {
+            throw Error(`Order type ${order.type} has no trigger price.`);
+        }
+        if (order.type != nodeSDKTypes_1.ORDER_TYPE_MARKET && order.stopPrice != undefined) {
+            throw Error(`Order type ${order.type} has no trigger price.`);
+        }
+        return flag;
+    }
+    /**
+     * Read config file into NodeSDKConfig interface
+     * @param fileLocation json-file with required variables for config
+     * @returns NodeSDKConfig
+     */
+    static readSDKConfig(fileLocation) {
+        if (fileLocation == nodeSDKTypes_1.DEFAULT_CONFIG_MAINNET_NAME) {
+            fileLocation = nodeSDKTypes_1.DEFAULT_CONFIG_MAINNET;
+        }
+        else if (fileLocation == nodeSDKTypes_1.DEFAULT_CONFIG_TESTNET_NAME) {
+            fileLocation = nodeSDKTypes_1.DEFAULT_CONFIG_TESTNET;
+        }
+        let configFile = require(fileLocation);
+        let config = configFile;
+        return config;
+    }
+}
+exports.default = PerpetualDataHandler;

package/dist/utils.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+import { BigNumber } from "ethers";
+/**
+ *
+ * @param   s string to shorten/extend to 4 characters
+ * @returns string with 4 characters (or characters + null chars)
+ */
+export declare function to4Chars(s: string): string;
+/**
+ * Converts string into 4-character bytes4
+ * uses to4Chars to first convert the string into
+ * 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
+ */
+export declare function toBytes4(s: string): Buffer;
+/**
+ * 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
+ */
+export declare function fromBytes4(b: Buffer): string;
+/**
+ * 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,
+ * where x was originally encoded and
+ * returned by the smart contract as bytes4
+ */
+export declare function fromBytes4HexString(s: string): string;
+export declare function combineFlags(f1: BigNumber, f2: BigNumber): BigNumber;
+export declare function containsFlag(f1: BigNumber, f2: BigNumber): boolean;

package/dist/utils.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containsFlag = exports.combineFlags = exports.fromBytes4HexString = exports.fromBytes4 = exports.toBytes4 = exports.to4Chars = void 0;
+const ethers_1 = require("ethers");
+const ethers = require("ethers");
+function _isVocal(char) {
+    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)
+ */
+function to4Chars(s) {
+    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);
+        }
+        k--;
+    }
+    s = s.substring(0, 4);
+    return s;
+}
+exports.to4Chars = to4Chars;
+/**
+ * Converts string into 4-character bytes4
+ * uses to4Chars to first convert the string into
+ * 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
+ */
+function toBytes4(s) {
+    s = to4Chars(s);
+    let valBuff = Buffer.from(s, "ascii");
+    return valBuff;
+}
+exports.toBytes4 = toBytes4;
+/**
+ * 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
+ */
+function fromBytes4(b) {
+    let val = b.toString("ascii");
+    val = val.replace(/\0/g, "");
+    return val;
+}
+exports.fromBytes4 = fromBytes4;
+/**
+ * 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,
+ * where x was originally encoded and
+ * returned by the smart contract as bytes4
+ */
+function fromBytes4HexString(s) {
+    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;
+}
+exports.fromBytes4HexString = fromBytes4HexString;
+function combineFlags(f1, f2) {
+    return ethers_1.BigNumber.from(parseInt(f1.toString()) | parseInt(f2.toString()));
+}
+exports.combineFlags = combineFlags;
+function containsFlag(f1, f2) {
+    return (parseInt(f1.toString()) & parseInt(f2.toString())) > 0;
+}
+exports.containsFlag = containsFlag;

package/dist/writeAccessHandler.d.ts

@@ -0,0 +1,36 @@
+import { BigNumber, ethers } from "ethers";
+import PerpetualDataHandler from "./perpetualDataHandler";
+import { NodeSDKConfig } from "./nodeSDKTypes";
+/**
+ * This is a parent class for the classes that require
+ * write access to the contracts.
+ * This class requires a private key and executes smart-contract interaction that
+ * require gas-payments.
+ */
+export default class WriteAccessHandler extends PerpetualDataHandler {
+    protected privateKey: string;
+    protected traderAddr: string;
+    protected signer: ethers.Wallet | null;
+    protected gasLimit: number;
+    protected chainId: number;
+    /**
+     * Constructor
+     * @param config configuration
+     * @param privateKey private key of account that trades
+     */
+    constructor(config: NodeSDKConfig, privateKey: string);
+    /**
+     * Initialize the AccountTrade-Class with this function
+     * to create instance of D8X perpetual contract and gather information
+     * about perpetual currencies
+     */
+    createProxyInstance(): Promise<void>;
+    /**
+     * Set allowance for ar margin token (e.g., MATIC, ETH, USDC)
+     * @param symbol token in 'long-form' such as MATIC, symbol also fine (ETH-USD-MATIC)
+     * @param amount optional, amount to approve if not 'infinity'
+     * @returns transaction hash
+     */
+    setAllowance(symbol: string, amount?: number | undefined): Promise<string>;
+    protected static _setAllowance(tokenAddr: string, proxyAddr: string, signer: ethers.Wallet, amount: BigNumber): Promise<string>;
+}