@d8x/perpetuals-sdk 0.1.12 → 0.2.0

package/src/triangulator.ts

@@ -1,105 +0,0 @@
-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']]
-   */
-  public static findPath(ccyBase: string[], ccyQuote: string[], pair: string): Array<Array<string>> {
-    let [base, quote] = pair.split("-");
-    let paths = new Array<Array<string>>();
-    for (let k = 0; k < ccyBase.length; k++) {
-      let currentPath: string[] = [];
-      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<string>();
-          let newQuote = new Array<string>();
-          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
-   */
-  public static calculateTriangulatedPrice(triangulation: [string[], boolean[]], feedIdxPrices: Map<string, [number, boolean]>) : [number,boolean] {
-    let px = 1;
-    let isOpen = true;
-    for (let j = 0; j < triangulation[0].length; j++) {
-      let pxFeed : [number, boolean]|undefined = 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
-   */
-  public static triangulate(ccyArr: string[], symbol: string): [string[], boolean[]] {
-    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<boolean>();
-    let indexPath = new Array<string>();
-    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];
-  }
-}

package/src/utils.ts

@@ -1,134 +0,0 @@
-import { BigNumber } from "ethers";
-import { Buffer } from "buffer";
-
-/**
- * @module utils
- */
-
-function _isVocal(char: string) {
-  char = char.toLowerCase();
-  return char == "a" || char == "e" || char == "i" || char == "o" || char == "u";
-}
-
-/**
- *
- * @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";
-  }
-  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;
-}
-
-/**
- * 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 {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;
-}
-
-/**
- * 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 {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;
-}
-
-/**
- * Decodes the bytes4 encoded string received from the
- * smart contract as a hex-number in string-format
- * @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;
-}
-
-/**
- *
- * @param {string} s String representing a hex-number ("0x...")
- * @param {Object} mapping List of symbol and clean symbol pairs, e.g. [{symbol: "MATIC", cleanSymbol: "MATC"}, ...]
- * @returns {string} User friendly currency symbol, e.g. "MATIC"
- */
-export function contractSymbolToSymbol(s: string, mapping: Map<string, string>): string {
-  let shortCCY = fromBytes4HexString(s);
-  // assume CCY is already short if not in the mapping file
-  let longCCY = mapping.get(shortCCY) ?? shortCCY;
-  return longCCY;
-}
-
-/**
- *
- * @param {string} s User friendly currency symbol, e.g. "MATIC"
- * @param {Object} mapping List of symbol and clean symbol pairs, e.g. [{symbol: "MATIC", cleanSymbol: "MATC"}, ...]
- * @returns {Buffer} Buffer that can be used with smart contract to identify tokens
- */
-export function symbolToContractSymbol(s: string, mapping: Map<string, string>): Buffer {
-  let shortCCY: string | undefined = undefined;
-  for (let [k, v] of mapping) {
-    if (v == s) {
-      shortCCY = k;
-    }
-  }
-  // if not in the mapping file, assume ccy is already valid
-  shortCCY = shortCCY ?? s;
-  return toBytes4(shortCCY);
-}
-
-/**
- * Converts symbol or symbol combination into long format
- * @param {string} s symbol, e.g., USDC-MATC-USDC, MATC, USDC, ...
- * @param {Object} mapping list of symbol and clean symbol pairs, e.g. [{symbol: "MATIC", cleanSymbol: "MATC"}, ...]
- * @returns {string} long format e.g. MATIC. if not found the element is ""
- */
-export function symbol4BToLongSymbol(s: string, mapping: Map<string, string>): string {
-  let ccy = s.split("-");
-  let longCCY = "";
-  for (let k = 0; k < ccy.length; k++) {
-    let sym = mapping.get(ccy[k]) ?? to4Chars(ccy[k]);
-    sym = sym.replace(/\0/g, "");
-    longCCY = longCCY + "-" + sym;
-  }
-  return longCCY.substring(1);
-}
-
-export function combineFlags(f1: BigNumber, f2: BigNumber): BigNumber {
-  return BigNumber.from((parseInt(f1.toString()) | parseInt(f2.toString())) >>> 0);
-}
-
-export function containsFlag(f1: BigNumber, f2: BigNumber): boolean {
-  return (parseInt(f1.toString()) & parseInt(f2.toString())) > 0;
-}

package/src/version.ts

@@ -1 +0,0 @@
-export const D8X_SDK_VERSION = "0.1.12";

package/src/writeAccessHandler.ts

@@ -1,127 +0,0 @@
-import { BigNumber, ethers } from "ethers";
-import { floatToDec18 } from "./d8XMath";
-import { ERC20_ABI, MAX_UINT_256, MOCK_TOKEN_SWAP_ABI, NodeSDKConfig } from "./nodeSDKTypes";
-import PerpetualDataHandler from "./perpetualDataHandler";
-
-/**
- * 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.
- * @extends PerpetualDataHandler
- */
-export default class WriteAccessHandler extends PerpetualDataHandler {
-  protected privateKey: string | undefined;
-  protected traderAddr: string = "";
-  protected signer: ethers.Signer | null = null;
-  protected gasLimit: number = 15_000_000;
-  /**
-   * Constructor
-   * @param {NodeSDKConfig} config configuration
-   * @param {string} privateKey private key of account that trades
-   */
-  public constructor(config: NodeSDKConfig, privateKey?: string, signer?: ethers.Signer) {
-    super(config);
-    if (privateKey) {
-      this.privateKey = privateKey;
-    } else if (signer) {
-      this.signer = signer;
-    } else {
-      throw new Error("No private key nor signer provided.");
-    }
-    if (config.gasLimit != undefined) {
-      this.gasLimit = config.gasLimit;
-    }
-  }
-
-  /**
-   * Initialize the writeAccessHandler-Class with this function
-   * to create instance of D8X perpetual contract and gather information
-   * about perpetual currencies
-   * @param provider optional provider
-   */
-  public async createProxyInstance(provider?: ethers.providers.Provider) {
-    if (provider == undefined) {
-      this.provider = new ethers.providers.JsonRpcBatchProvider(this.nodeURL);
-    } else {
-      this.provider = provider;
-    }
-    if (!this.signer) {
-      const wallet = new ethers.Wallet(this.privateKey!);
-      this.signer = wallet.connect(this.provider);
-    }
-    await this.initContractsAndData(this.signer);
-    this.traderAddr = await this.signer.getAddress();
-  }
-
-  /**
-   * 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 ContractTransaction
-   */
-  public async setAllowance(
-    symbol: string,
-    amount: number | undefined = undefined
-  ): Promise<ethers.ContractTransaction> {
-    //extract margin-currency name
-    let symbolarr = symbol.split("-");
-    symbol = symbol.length == 3 ? symbolarr[2] : symbolarr[0];
-    //note: symbol is in long format
-    let marginTokenAddr = this.symbolToTokenAddrMap.get(symbol);
-    if (marginTokenAddr == undefined || this.signer == null) {
-      throw Error("No margin token or signer defined, call createProxyInstance");
-    }
-    let amountDec18: BigNumber;
-    if (amount == undefined) {
-      amountDec18 = MAX_UINT_256;
-    } else {
-      amountDec18 = floatToDec18(amount);
-    }
-    return WriteAccessHandler._setAllowance(marginTokenAddr, this.proxyAddr, this.signer, amountDec18);
-  }
-
-  protected static async _setAllowance(
-    tokenAddr: string,
-    proxyAddr: string,
-    signer: ethers.Signer,
-    amount: BigNumber
-  ): Promise<ethers.ContractTransaction> {
-    const marginToken: ethers.Contract = new ethers.Contract(tokenAddr, ERC20_ABI, signer);
-    return await marginToken.approve(proxyAddr, amount);
-  }
-
-  /**
-   * Address corresponding to the private key used to instantiate this class.
-   * @returns {string} Address of this wallet.
-   */
-  public getAddress(): string {
-    return this.traderAddr;
-  }
-
-  /**
-   * Converts a given amount of chain native currency (test MATIC)
-   * into a mock token used for trading on testnet, with a rate of 1:100_000
-   * @param symbol Pool margin token e.g. MATIC
-   * @param amountToPay Amount in chain currency, e.g. "0.1" for 0.1 MATIC
-   * @returns Transaction object
-   */
-  public async swapForMockToken(symbol: string, amountToPay: string): Promise<ethers.ContractTransaction> {
-    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);
-    return await contract.swapToMockToken({
-      value: ethers.utils.parseEther(amountToPay),
-    });
-  }
-}