@d8x/perpetuals-sdk 0.0.45 → 0.0.46

package/dist/priceFeeds.js

@@ -0,0 +1,373 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const triangulator_1 = __importDefault(require("./triangulator"));
+const d8XMath_1 = require("./d8XMath");
+/**
+ * This class communicates with the REST API that provides price-data that is
+ * to be submitted to the smart contracts for certain functions such as
+ * trader liquidations, trade executions, change of trader margin amount.
+ */
+class PriceFeeds {
+    constructor(dataHandler, priceFeedConfigNetwork) {
+        this.THRESHOLD_MARKET_CLOSED_SEC = 15; // smallest lag for which we consider the market as being closed
+        let configs = require("../config/priceFeedConfig.json");
+        this.config = PriceFeeds._selectConfig(configs, priceFeedConfigNetwork);
+        [this.feedInfo, this.feedEndpoints] = PriceFeeds._constructFeedInfo(this.config);
+        this.dataHandler = dataHandler;
+        this.triangulations = new Map();
+    }
+    /**
+     * Pre-processing of triangulations for symbols, given the price feeds
+     * @param symbols set of symbols we want to triangulate from price feeds
+     */
+    initializeTriangulations(symbols) {
+        let feedSymbols = new Array();
+        for (let [key, value] of this.feedInfo) {
+            feedSymbols.push(value.symbol);
+        }
+        for (let symbol of symbols.values()) {
+            let triangulation = triangulator_1.default.triangulate(feedSymbols, symbol);
+            this.triangulations.set(symbol, triangulation);
+        }
+    }
+    /**
+     * Get required information to be able to submit a blockchain transaction with price-update
+     * such as trade execution, liquidation
+     * @param symbol symbol of perpetual, e.g., BTC-USD-MATIC
+     * @returns PriceFeedSubmission, index prices, market closed information
+     */
+    fetchFeedPriceInfoAndIndicesForPerpetual(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let indexSymbols = this.dataHandler.getIndexSymbols(symbol);
+            // fetch prices from required price-feeds (REST)
+            let submission = yield this.fetchLatestFeedPriceInfoForPerpetual(symbol);
+            // calculate index-prices from price-feeds
+            let [_idxPrices, _mktClosed] = this.calculateTriangulatedPricesFromFeedInfo(indexSymbols.filter((x) => x != ''), submission);
+            let idxPrices = [_idxPrices[0], 0];
+            let mktClosed = [_mktClosed[0], false];
+            if (idxPrices.length > 1) {
+                idxPrices[1] = _idxPrices[1];
+                mktClosed[1] = _mktClosed[1];
+            }
+            return { submission: submission, pxS2S3: idxPrices, mktClosed: mktClosed };
+        });
+    }
+    /**
+    * Get all prices/isMarketClosed for the provided symbols via
+    * "latest_price_feeds" and triangulation. Triangulation must be defined in config, unless
+    * it is a direct price feed.
+    * @returns map of feed-price symbol to price/isMarketClosed
+    */
+    fetchPrices(symbols) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let feedPrices = yield this.fetchAllFeedPrices();
+            let [prices, mktClosed] = this.triangulatePricesFromFeedPrices(symbols, feedPrices);
+            let symMap = new Map;
+            for (let k = 0; k < symbols.length; k++) {
+                symMap.set(symbols[k], [prices[k], mktClosed[k]]);
+            }
+            return symMap;
+        });
+    }
+    /**
+     * Get index prices and market closed information for the given perpetual
+     * @param symbol perpetual symbol such as ETH-USD-MATIC
+     * @returns
+     */
+    fetchPricesForPerpetual(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let indexSymbols = this.dataHandler.getIndexSymbols(symbol).filter(x => x != "");
+            // determine relevant price feeds
+            let feedSymbols = new Array();
+            for (let sym of indexSymbols) {
+                if (sym != "") {
+                    let triang = this.triangulations.get(sym);
+                    if (triang == undefined) {
+                        // no triangulation defined, so symbol must be a feed (unless misconfigured)
+                        feedSymbols.push(sym);
+                    }
+                    else {
+                        // push all required feeds to array
+                        triang[0].map((feedSym) => feedSymbols.push(feedSym));
+                    }
+                }
+            }
+            // get all feed prices
+            let feedPrices = yield this.fetchFeedPrices(feedSymbols);
+            // triangulate
+            let [prices, mktClosed] = this.triangulatePricesFromFeedPrices(indexSymbols, feedPrices);
+            // ensure we return an array of 2 in all cases
+            if (prices.length == 1) {
+                prices.push(0);
+                mktClosed.push(false);
+            }
+            return { idxPrices: prices, mktClosed: mktClosed };
+        });
+    }
+    /**
+     * Fetch the provided feed prices and bool whether market is closed or open
+     * - requires the feeds to be defined in priceFeedConfig.json
+     * - if undefined, all feeds are queried
+     * @param symbols array of feed-price symbols (e.g., [btc-usd, eth-usd]) or undefined
+     * @returns mapping symbol-> [price, isMarketClosed]
+     */
+    fetchFeedPrices(symbols) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let queries = new Array(this.feedEndpoints.length);
+            let symbolsOfEndpoint = [];
+            for (let j = 0; j < queries.length; j++) {
+                symbolsOfEndpoint.push([]);
+            }
+            for (let k = 0; k < this.config.ids.length; k++) {
+                let currFeed = this.config.ids[k];
+                if (symbols != undefined && !symbols.includes(currFeed.symbol)) {
+                    continue;
+                }
+                // feedInfo: Map<string, {symbol:string, endpointId: number}>; // priceFeedId -> symbol, endpointId
+                let endpointId = this.feedInfo.get(currFeed.id).endpointId;
+                symbolsOfEndpoint[endpointId].push(currFeed.symbol);
+                if (queries[endpointId] == undefined) {
+                    // each id can have a different endpoint, but we cluster
+                    // the queries into one per endpoint
+                    queries[endpointId] = this.feedEndpoints[endpointId] + "/latest_price_feeds?";
+                }
+                queries[endpointId] = queries[endpointId] + "ids[]=" + currFeed.id + "&";
+            }
+            let resultPrices = new Map();
+            for (let k = 0; k < queries.length; k++) {
+                if (queries[k] == undefined) {
+                    continue;
+                }
+                let [id, pxInfo] = yield this.fetchPriceQuery(queries[k]);
+                let tsSecNow = Math.round(Date.now() / 1000);
+                for (let j = 0; j < pxInfo.length; j++) {
+                    let price = (0, d8XMath_1.decNToFloat)(ethers_1.BigNumber.from(pxInfo[j].price), -pxInfo[j].expo);
+                    let isMarketClosed = tsSecNow - pxInfo[j].publish_time > this.THRESHOLD_MARKET_CLOSED_SEC;
+                    resultPrices.set(symbolsOfEndpoint[k][j], [price, isMarketClosed]);
+                }
+            }
+            return resultPrices;
+        });
+    }
+    /**
+     * Get all configured feed prices via "latest_price_feeds"
+     * @returns map of feed-price symbol to price/isMarketClosed
+     */
+    fetchAllFeedPrices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.fetchFeedPrices();
+        });
+    }
+    /**
+     * Get the latest prices for a given perpetual from the offchain oracle
+     * networks
+     * @param symbol perpetual symbol of the form BTC-USD-MATIC
+     * @returns array of price feed updates that can be submitted to the smart contract
+     * and corresponding price information
+     */
+    fetchLatestFeedPriceInfoForPerpetual(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let feedIds = this.dataHandler.getPriceIds(symbol);
+            let queries = new Array(this.feedEndpoints.length);
+            // we need to preserve the order of the price feeds
+            let orderEndpointNumber = new Array();
+            // count how many prices per endpoint
+            let idCountPriceFeeds = new Array(this.feedEndpoints.length);
+            let symbols = new Array();
+            for (let k = 0; k < feedIds.length; k++) {
+                let info = this.feedInfo.get(feedIds[k]);
+                if (info == undefined) {
+                    throw new Error(`priceFeeds: config for symbol ${symbol} insufficient`);
+                }
+                let id = info.endpointId;
+                symbols.push(info.symbol);
+                if (queries[id] == undefined) {
+                    // each id can have a different endpoint, but we cluster
+                    // the queries into one per endpoint
+                    queries[id] = this.feedEndpoints[id] + "/latest_vaas_px?";
+                    idCountPriceFeeds[id] = 0;
+                }
+                queries[id] = queries[id] + "ids[]=" + feedIds[k] + "&";
+                orderEndpointNumber.push(id * 100 + idCountPriceFeeds[id]);
+                idCountPriceFeeds[id] = idCountPriceFeeds[id] + 1;
+            }
+            let data = yield Promise.all(queries.map((q) => __awaiter(this, void 0, void 0, function* () {
+                if (q != undefined) {
+                    return this.fetchVAAQuery(q);
+                }
+                else {
+                    return [[], []];
+                }
+            })));
+            // re-order arrays so we preserve the order of the feeds
+            const priceFeedUpdates = new Array();
+            const prices = new Array();
+            const mktClosed = new Array();
+            const timestamps = new Array();
+            const tsSecNow = Math.round(Date.now() / 1000);
+            for (let k = 0; k < orderEndpointNumber.length; k++) {
+                let endpointId = Math.floor(orderEndpointNumber[k] / 100);
+                let idWithinEndpoint = orderEndpointNumber[k] - 100 * endpointId;
+                priceFeedUpdates.push(data[endpointId][0][idWithinEndpoint]);
+                let pxInfo = data[endpointId][1][idWithinEndpoint];
+                let price = (0, d8XMath_1.decNToFloat)(ethers_1.BigNumber.from(pxInfo.price), -pxInfo.expo);
+                let isMarketClosed = tsSecNow - pxInfo.publish_time > this.THRESHOLD_MARKET_CLOSED_SEC;
+                mktClosed.push(isMarketClosed);
+                prices.push(price);
+                timestamps.push(pxInfo.publish_time);
+            }
+            return { "symbols": symbols, priceFeedVaas: priceFeedUpdates, prices: prices, isMarketClosed: mktClosed, timestamps: timestamps };
+        });
+    }
+    /**
+     * Extract pair-prices from underlying price feeds via triangulation
+     * The function either needs a direct price feed or a defined triangulation to succesfully
+     * return a triangulated price
+     * @param symbols array of pairs for which we want prices, e.g., [BTC-USDC, ETH-USD]
+     * @param feeds data obtained via fetchLatestFeedPriceInfo or fetchLatestFeedPrices
+     * @returns array of prices with same order as symbols
+     */
+    calculateTriangulatedPricesFromFeedInfo(symbols, feeds) {
+        let priceMap = new Map();
+        for (let j = 0; j < feeds.prices.length; j++) {
+            priceMap.set(feeds.symbols[j], [feeds.prices[j], feeds.isMarketClosed[j]]);
+        }
+        return this.triangulatePricesFromFeedPrices(symbols, priceMap);
+    }
+    /**
+    * Extract pair-prices from underlying price feeds via triangulation
+    * The function either needs a direct price feed or a defined triangulation to succesfully
+    * return a triangulated price
+    * @param symbols array of pairs for which we want prices, e.g., [BTC-USDC, ETH-USD]
+    * @param feeds data obtained via fetchLatestFeedPriceInfo or fetchLatestFeedPrices
+    * @returns array of prices with same order as symbols
+    */
+    triangulatePricesFromFeedPrices(symbols, feedPriceMap) {
+        let prices = new Array();
+        let mktClosed = new Array();
+        for (let k = 0; k < symbols.length; k++) {
+            let triangulation = this.triangulations.get(symbols[k]);
+            if (triangulation == undefined) {
+                let feedPrice = feedPriceMap.get(symbols[k]);
+                if (feedPrice == undefined) {
+                    throw new Error(`PriceFeeds: no triangulation defined for ${symbols[k]}`);
+                }
+                else {
+                    prices.push(feedPrice[0]); //price
+                    mktClosed.push(feedPrice[1]); //market closed?
+                    continue;
+                }
+            }
+            let [px, isMktClosed] = triangulator_1.default.calculateTriangulatedPrice(triangulation, feedPriceMap);
+            prices.push(px);
+            mktClosed.push(isMktClosed);
+        }
+        return [prices, mktClosed];
+    }
+    /**
+     * Queries the REST endpoint and returns parsed VAA price data
+     * @param query query price-info from endpoint
+     * @returns vaa and price info
+     */
+    fetchVAAQuery(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const headers = { headers: { 'Content-Type': 'application/json' } };
+            let response = yield fetch(query, headers);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch posts (${response.status}): ${response.statusText}`);
+            }
+            let values = (yield response.json());
+            const priceFeedUpdates = new Array();
+            const px = new Array();
+            for (let k = 0; k < values.length; k++) {
+                priceFeedUpdates.push("0x" + Buffer.from(values[k][0], "base64").toString("hex"));
+                px.push(values[k][1]);
+            }
+            return [priceFeedUpdates, px];
+        });
+    }
+    /**
+     * Queries the REST endpoint and returns parsed price data
+     * @param query query price-info from endpoint
+     * @returns vaa and price info
+     */
+    fetchPriceQuery(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const headers = { headers: { 'Content-Type': 'application/json' } };
+            let response = yield fetch(query, headers);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch posts (${response.status}): ${response.statusText}`);
+            }
+            let values = yield response.json();
+            const priceFeedUpdates = new Array();
+            const px = new Array();
+            for (let k = 0; k < values.length; k++) {
+                priceFeedUpdates.push("0x" + Buffer.from(values[k].id, "base64").toString("hex"));
+                px.push(values[k].price);
+            }
+            return [priceFeedUpdates, px];
+        });
+    }
+    /**
+     * Searches for configuration for given network
+     * @param configs pricefeed configuration from json
+     * @param network e.g. testnet
+     * @returns selected configuration
+     */
+    static _selectConfig(configs, network) {
+        let k = 0;
+        while (k < configs.length) {
+            if (configs[k].network == network) {
+                return configs[k];
+            }
+            k = k + 1;
+        }
+        throw new Error(`PriceFeeds: config not found for network ${network}`);
+    }
+    /**
+     * Wraps configuration into convenient data-structure
+     * @param config configuration for the selected network
+     * @returns feedInfo-map and endPoints-array
+     */
+    static _constructFeedInfo(config) {
+        let feed = new Map();
+        let endpointId = -1;
+        let type = "";
+        let feedEndpoints = new Array();
+        for (let k = 0; k < config.endpoints.length; k++) {
+            feedEndpoints.push(config.endpoints[k].endpoint);
+        }
+        for (let k = 0; k < config.ids.length; k++) {
+            if (type != config.ids[k].type) {
+                type = config.ids[k].type;
+                let j = 0;
+                while (j < config.endpoints.length) {
+                    if (config.endpoints[j].type == type) {
+                        endpointId = j;
+                        j = config.endpoints.length;
+                    }
+                    j++;
+                }
+                if (config.endpoints[endpointId].type != type) {
+                    throw new Error(`priceFeeds: no enpoint found for ${type} check priceFeedConfig`);
+                }
+            }
+            feed.set(config.ids[k].id, { symbol: config.ids[k].symbol.toUpperCase(), endpointId: endpointId });
+        }
+        return [feed, feedEndpoints];
+    }
+}
+exports.default = PriceFeeds;

package/dist/triangulator.d.ts

@@ -0,0 +1,27 @@
+export default class Triangulator {
+    /**
+     * Find all possible triangulation paths
+     * @param ccyBase array of base currencies ['BTC', 'ETH', 'MATIC', ...]
+     * @param ccyQuote array of quote currencies corresponding to base ['USD', 'USD', ...]
+     * @param pair pair we want to calculate, e.g. BTC-USDC
+     * @returns array of different paths for which multiplication leads to
+     *  desired pair, e.g. [['MATIC-USD'], ['MATIC-ETH', 'ETH-USD']]
+     */
+    static findPath(ccyBase: string[], ccyQuote: string[], pair: string): Array<Array<string>>;
+    /**
+     * Calculate the triangulated price from underlying prices
+     * @param triangulation triangulation of with symbol and is-inverted flag
+     * @param feedIdxPrices map of symbol to price
+     * @returns triangulated price (scalar), true if market closed or price unavailable
+     */
+    static calculateTriangulatedPrice(triangulation: [string[], boolean[]], feedIdxPrices: Map<string, [number, boolean]>): [number, boolean];
+    /**
+     * Finds shortest path and returns indices required and whether to divide or not
+     * @example triangulate BTC-USDC:  [ [ 'BTC-USD', 'USDC-USD' ], [ false, true ] ]
+     * @param ccyArr array of available indices (e.g. from websocket)
+     * @param symbol symbol we are looking for (e.g. MATIC-USDC)
+     * @returns shortest path with given indices, array whether we have to divide (true) or multiply
+     *  to arrive at the desired price
+     */
+    static triangulate(ccyArr: string[], symbol: string): [string[], boolean[]];
+}

package/dist/triangulator.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Triangulator {
+    /**
+     * Find all possible triangulation paths
+     * @param ccyBase array of base currencies ['BTC', 'ETH', 'MATIC', ...]
+     * @param ccyQuote array of quote currencies corresponding to base ['USD', 'USD', ...]
+     * @param pair pair we want to calculate, e.g. BTC-USDC
+     * @returns array of different paths for which multiplication leads to
+     *  desired pair, e.g. [['MATIC-USD'], ['MATIC-ETH', 'ETH-USD']]
+     */
+    static findPath(ccyBase, ccyQuote, pair) {
+        let [base, quote] = pair.split("-");
+        let paths = new Array();
+        for (let k = 0; k < ccyBase.length; k++) {
+            let currentPath = [];
+            if (ccyBase[k] == base) {
+                currentPath.push(ccyBase[k] + "-" + ccyQuote[k]);
+                if (ccyQuote[k] == quote) {
+                    // we are done
+                    paths.push(currentPath);
+                }
+                else {
+                    // find path for ccyQuote[k]-quote without the currency
+                    let newBase = new Array();
+                    let newQuote = new Array();
+                    for (let j = 0; j < ccyBase.length; j++) {
+                        if (j != k && ccyQuote[j] + "-" + ccyBase[j] != ccyBase[k] + "-" + ccyQuote[k]) {
+                            newBase.push(ccyBase[j]);
+                            newQuote.push(ccyQuote[j]);
+                        }
+                    }
+                    let recPaths = Triangulator.findPath(newBase, newQuote, ccyQuote[k] + "-" + quote);
+                    for (let j = 0; j < recPaths.length; j++) {
+                        paths.push(currentPath.concat(recPaths[j]));
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    /**
+     * Calculate the triangulated price from underlying prices
+     * @param triangulation triangulation of with symbol and is-inverted flag
+     * @param feedIdxPrices map of symbol to price
+     * @returns triangulated price (scalar), true if market closed or price unavailable
+     */
+    static calculateTriangulatedPrice(triangulation, feedIdxPrices) {
+        let px = 1;
+        let isOpen = true;
+        for (let j = 0; j < triangulation[0].length; j++) {
+            let pxFeed = feedIdxPrices.get(triangulation[0][j]);
+            if (pxFeed == undefined) {
+                // no price available for given index
+                return [-1, true];
+            }
+            px = triangulation[1][j] ? px / pxFeed[0] : px * pxFeed[0];
+            let isClosed = pxFeed[1];
+            isOpen = isOpen && !isClosed;
+        }
+        return [px, !isOpen];
+    }
+    /**
+     * Finds shortest path and returns indices required and whether to divide or not
+     * @example triangulate BTC-USDC:  [ [ 'BTC-USD', 'USDC-USD' ], [ false, true ] ]
+     * @param ccyArr array of available indices (e.g. from websocket)
+     * @param symbol symbol we are looking for (e.g. MATIC-USDC)
+     * @returns shortest path with given indices, array whether we have to divide (true) or multiply
+     *  to arrive at the desired price
+     */
+    static triangulate(ccyArr, symbol) {
+        let ccyBase = ccyArr.map((x) => x.split("-")[0]);
+        let ccyQuote = ccyArr.map((x) => x.split("-")[1]);
+        let p = Triangulator.findPath(ccyBase.concat(ccyQuote), ccyQuote.concat(ccyBase), symbol);
+        if (p.length == 0) {
+            return [[], []];
+        }
+        let len = p.map((x) => x.length);
+        let minLen = 100;
+        let minIdx = -1;
+        for (let j = 0; j < p.length; j++) {
+            if (len[j] < minLen) {
+                minLen = len[j];
+                minIdx = j;
+                if (minLen == 1) {
+                    break;
+                }
+            }
+        }
+        let path = p[minIdx];
+        let invert = new Array();
+        let indexPath = new Array();
+        for (let k = 0; k < path.length; k++) {
+            if (ccyArr.includes(path[k], 0)) {
+                indexPath.push(path[k]);
+                invert.push(false);
+            }
+            else {
+                let inv = path[k].split("-");
+                indexPath.push(inv[1] + "-" + inv[0]);
+                invert.push(true);
+            }
+        }
+        return [indexPath, invert];
+    }
+}
+exports.default = Triangulator;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const D8X_SDK_VERSION = "0.0.45";
+export declare const D8X_SDK_VERSION = "0.0.46";

package/dist/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.D8X_SDK_VERSION = void 0;
-exports.D8X_SDK_VERSION = "0.0.45";
+exports.D8X_SDK_VERSION = "0.0.46";

package/package.json

@@ -33,7 +33,7 @@
   },
   "name": "@d8x/perpetuals-sdk",
   "description": "Node TypeScript SDK for D8X Perpetual Futures",
-  "version": "0.0.45",
+  "version": "0.0.46",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "directories": {

package/src/accountTrade.ts

@@ -2,12 +2,14 @@ import { ethers } from "ethers";
 import { ABK64x64ToFloat, floatToABK64x64 } from "./d8XMath";
 import MarketData from "./marketData";
 import {
+  MOCK_TOKEN_SWAP_ABI,
   NodeSDKConfig,
   Order,
   OrderResponse,
   PerpetualStaticInfo,
   SmartContractOrder,
   ZERO_ADDRESS,
+  PriceFeedSubmission,
 } from "./nodeSDKTypes";
 import PerpetualDataHandler from "./perpetualDataHandler";
 import TraderDigests from "./traderDigests";
@@ -78,12 +80,6 @@ export default class AccountTrade extends WriteAccessHandler {
     return await this._cancelOrder(symbol, orderId, orderBookContract);
   }
 
-  /*
-    TODO: -deposit (margin into account)
-          -withdraw margin withdraw(uint24 _iPerpetualId, int128 _fAmount)
-
-  */
-
   /**
    * Submits an order to the exchange.
    * @param {Order} order Order structure. As a minimum the structure needs to
@@ -339,7 +335,11 @@ export default class AccountTrade extends WriteAccessHandler {
     }
     let perpId = this.getPerpIdFromSymbol(symbol);
     let fAmountCC = floatToABK64x64(amount);
-    return await this.proxyContract.deposit(perpId, fAmountCC);
+    let priceFeedData: PriceFeedSubmission = await this.fetchLatestFeedPriceInfo(symbol);
+    return await this.proxyContract.deposit(perpId, fAmountCC, priceFeedData.priceFeedVaas, priceFeedData.timestamps, {
+      gasLimit: this.gasLimit,
+      value: this.PRICE_UPDATE_FEE_GWEI * priceFeedData.priceFeedVaas.length,
+    });
   }
 
   /**
@@ -353,6 +353,29 @@ export default class AccountTrade extends WriteAccessHandler {
     }
     let perpId = this.getPerpIdFromSymbol(symbol);
     let fAmountCC = floatToABK64x64(amount);
-    return await this.proxyContract.withdraw(perpId, fAmountCC);
+    let priceFeedData: PriceFeedSubmission = await this.fetchLatestFeedPriceInfo(symbol);
+    return await this.proxyContract.withdraw(perpId, fAmountCC, priceFeedData.priceFeedVaas, priceFeedData.timestamps, {
+      gasLimit: this.gasLimit,
+      value: this.PRICE_UPDATE_FEE_GWEI * priceFeedData.priceFeedVaas.length,
+    });
+  }
+
+  public async swapForMockToken(symbol: string, amountToPay: string) {
+    if (this.signer == null) {
+      throw Error("no wallet initialized. Use createProxyInstance().");
+    }
+    let tokenAddress = this.getMarginTokenFromSymbol(symbol);
+    if (tokenAddress == undefined) {
+      throw Error("symbols not found");
+    }
+    let tokenToSwap = new Map<string, string>(Object.entries(require("../config/mockSwap.json")));
+    let swapAddress = tokenToSwap.get(tokenAddress);
+    if (swapAddress == undefined) {
+      throw Error("No swap contract found for symbol.");
+    }
+    let contract = new ethers.Contract(swapAddress, MOCK_TOKEN_SWAP_ABI, this.signer.provider);
+    return await contract.swapToMockToken({
+      value: ethers.utils.parseEther(amountToPay),
+    });
   }
 }

package/src/d8XMath.ts

@@ -28,6 +28,24 @@ export function ABK64x64ToFloat(x: BigNumber | number): number {
   return parseFloat(NumberStr) * s;
 }
 
+/**
+ *
+ * @param {BigNumber} x BigNumber in Dec-N format
+ * @returns {number} x as a float (number)
+ */
+export function decNToFloat(x: BigNumber, numDec: number) {
+  //x: BigNumber in DecN format to float
+  const DECIMALS = BigNumber.from(10).pow(BigNumber.from(numDec));
+  let s = x.lt(0) ? -1 : 1;
+  x = x.mul(s);
+  let xInt = x.div(DECIMALS);
+  let xDec = x.sub(xInt.mul(DECIMALS));
+  let k = numDec - xDec.toString().length;
+  let sPad = "0".repeat(k);
+  let NumberStr = xInt.toString() + "." + sPad + xDec.toString();
+  return parseFloat(NumberStr) * s;
+}
+
 /**
  *
  * @param {BigNumber} x BigNumber in Dec18 format