@proton/wrap-constants 0.2.193 → 0.3.1

package/src/constants.ts

@@ -1,202 +0,0 @@
-import { Coin, CoinWallet, initializeCoins, Wallet } from "./coins";
-
-export const WRAP_CONTRACT = "proton.wrap";
-export const WRAP_AUTH_ACTION = "generateauth";
-export const FEE_FACTOR = 10000;
-
-export const initializeConstants = (chain: string) => {
-  const {
-    swapCoins,
-    bridgeCoins,
-    allEnabledCoins,
-    allCoins,
-    lendCoins,
-    borrowCoins,
-    loanCoins,
-  } = initializeCoins(chain);
-
-  const constants = {
-    SWAP_CONTRACT: "proton.swaps",
-    VEST_CONTRACT: "vest",
-    DEX_CONTRACT: "dex",
-    FEE_FACTOR,
-    SWAP_URL:
-      chain === "proton"
-        ? "https://otc.protonswap.com"
-        : "https://otc-test.protonswap.com",
-    WRAP_SERVER_URL:
-      chain === "proton"
-        ? "https://www.api.bloks.io/proton-wrap-public2"
-        : "https://www.api.bloks.io/proton-wrap-testnet-public2",
-    WRAP_CONTRACT,
-    WRAP_ACTIONS: {
-      SAVE_ADDRESS: "saveaddress2",
-      DELETE_ADDRESS: "deladdress2",
-      WRAP_START: "wrapstart2",
-      WRAP_FINISH: "wrapfinish2",
-      WRAP_PROCESS: "wrapprocess2",
-      WRAP_SET_CONF: "wrapsetconf2",
-    },
-    WRAP_TABLES: {
-      ADDRESSES: "addresses2",
-      WRAPS: "wraps2",
-    },
-    ADDRESSES_INDEXES: {
-      BY_ACCOUNT: 2,
-      BY_ADDR_HASH: 3,
-    },
-    WRAPS_INDEXES: {
-      BY_ACCOUNT: 2,
-      BY_STATUS: 3,
-      BY_WRAP_HASH: 4,
-    },
-    WRAP_PROCESS_TIMER: 5000,
-
-    FARM_CONTRACT: "yield.farms",
-
-    WEBHOOK_PERMISSION: "webhook",
-    PUBLIC_PERMISSION: "public",
-    LIGHT_PERMISSION: "light",
-    WRAP_AUTH_ACTION: WRAP_AUTH_ACTION,
-
-    METAL_ENDPOINT:
-      chain === "proton"
-        ? "https://cirrus.metalpay.com"
-        : "https://cirrus-dev.metalpay.com",
-
-    METAL_PROTON_ENDPOINT:
-      chain === "proton"
-        ? "https://identity.api.prod.metalx.com"
-        : "https://identity.api.dev.metalx.com",
-
-    METAL_DEX_HTTP_ENDPOINT:
-      chain === "proton"
-        ? "https://dex.api.mainnet.metalx.com/dex"
-        : "https://dex.api.testnet.metalx.com/dex",
-
-    METAL_DEX_WS_ENDPOINT:
-      chain === "proton"
-        ? "wss://dex.api.mainnet.metalx.com/dexws"
-        : "wss://dex.api.testnet.metalx.com/dexws",
-
-    PROTON_ENDPOINTS:
-      chain === "proton"
-        ? [
-            "https://rpc.api.mainnet.metalx.com",
-            "https://proton.greymass.com",
-            "https://proton.eoscafeblock.com",
-            "https://proton.cryptolions.io",
-            "https://proton.eosusa.news",
-          ]
-        : [
-            "https://rpc.api.testnet.metalx.com",
-            "https://testnet.protonchain.com",
-          ],
-
-    CHAIN_ID:
-      chain === "proton"
-        ? "384da888112027f0321850a169f737c33e53b388aad48b5adace4bab97f437e0"
-        : "71ee83bcf52142d61019d95f9cc5427ba6a0d7ff8accd9e2088ae2abeaf3d3dd",
-
-    COINS_URL:
-      chain === "proton"
-        ? "https://app.metalx.com/mainnet-coins.json"
-        : "https://app.metalx.com/testnet-coins.json",
-
-    DEX_PROCESS_SIZE: 30,
-    DEX_SLTPPROCESS_SIZE: 10,
-    MAX_PRICE: "9223372036854775806",
-    MAX_ITEMS_PER_PAGE_DESKTOP: 100,
-    MIN_PRICE: 1,
-    DEFAULT_DEX_SYMBOL: "XPR_XMD",
-
-    CHAIN: chain,
-
-    SWAP_COINS: swapCoins,
-    BRIDGE_COINS: bridgeCoins,
-    ALL_ENABLED_COINS: allEnabledCoins,
-    LEND_COINS: lendCoins,
-    BORROW_COINS: borrowCoins,
-    LOAN_COINS: loanCoins,
-    ALL_COINS: allCoins,
-
-    XMD_CONTRACT: "xmd.treasury",
-    XMD_TOKEN_CONTRACT: "xmd.token",
-    XMD_SYMBOL_CODE: "XMD",
-    XMD_DECIMALS: 6,
-
-    findBridgeCoinWalletByXtokenAndChain(
-      xtokenSymbol: string,
-      chain: string
-    ): CoinWallet | undefined {
-      const bridgeCoin = constants.BRIDGE_COINS.find(
-        (bridgeCoin: Coin) => bridgeCoin.xtokenSymbol === xtokenSymbol
-      );
-      if (!bridgeCoin) return undefined;
-      const bridgeWallet = bridgeCoin.wallets.find(
-        (bridgeWallet: Wallet) => bridgeWallet.chain === chain
-      );
-      if (!bridgeWallet) return undefined;
-
-      return {
-        ...bridgeCoin,
-        ...bridgeWallet,
-      };
-    },
-
-    findBridgeCoinWallet(coin: string, wallet: string): CoinWallet | undefined {
-      const bridgeCoin = constants.BRIDGE_COINS.find(
-        (bridgeCoin: Coin) => bridgeCoin.coin === coin
-      );
-      if (!bridgeCoin) return undefined;
-
-      const bridgeWallet = bridgeCoin.wallets.find(
-        (bridgeWallet: Wallet) => bridgeWallet.wallet === wallet
-      );
-      if (!bridgeWallet) return undefined;
-
-      return {
-        ...bridgeCoin,
-        ...bridgeWallet,
-      };
-    },
-
-    findBridgeCoinWalletByWallet(wallet: string): CoinWallet | undefined {
-      const matches: CoinWallet[] = [];
-
-      constants.BRIDGE_COINS.forEach((bridgeCoin: Coin) => {
-        bridgeCoin.wallets.forEach((bridgeWallet: Wallet) => {
-          if (bridgeWallet.wallet === wallet) {
-            matches.push({
-              ...bridgeCoin,
-              ...bridgeWallet,
-            });
-          }
-        });
-      });
-
-      return matches.length === 1 ? matches[0] : undefined;
-    },
-
-    findBridgeCoinNetwork(
-      coin: string,
-      network: string
-    ): CoinWallet | undefined {
-      const bridgeCoin = constants.BRIDGE_COINS.find(
-        (bridgeCoin: Coin) => bridgeCoin.coin === coin
-      );
-      if (!bridgeCoin) return undefined;
-      const bridgeWallet = bridgeCoin.wallets.find(
-        (bridgeWallet: Wallet) => bridgeWallet.network === network
-      );
-      if (!bridgeWallet) return undefined;
-
-      return {
-        ...bridgeCoin,
-        ...bridgeWallet,
-      };
-    },
-  };
-
-  return constants;
-};

package/src/graph.ts

@@ -1,126 +0,0 @@
-import cloneDeep from 'lodash.clonedeep'
-
-export class INode <T> {
-    data: T = {} as T
-    constructor (public key: string, data?: T) {
-        if (data) {
-            this.data = data
-        }
-    }
-}
-
-export class ILink <T> {
-    data: T = {} as T
-    constructor (public from: INode<T>, public to: INode<T>, data?: T) {
-        if (data) {
-            this.data = data
-        }
-    }
-}
-
-export class Graph <T> {
-    nodes: INode<T>[] = []
-    links: ILink<T>[] = []
-    lastPathFound: INode<T>[] = []
-
-    isEquals = (a: INode<T>, b: INode<T>) => a.key === b.key
-
-    addNode (k: string, v?: T): void {
-        const node = this.findNode(k)
-        if (!node) {
-            this.nodes.push(new INode(k, v))
-        }
-    }
-
-    addNodes (...nodes: (string | [string, T?])[]): void {
-        nodes.forEach(node => typeof node === "string" ? this.addNode(node) : this.addNode(node[0], node[1]))
-    }
-
-    findNode (k: string): INode<T> | undefined {
-        const inode = new INode<T>(k)
-        return this.nodes.find(node => this.isEquals(node, inode))
-    }
-
-    findNodes (...keys: string[]): (INode<T> | undefined)[] {
-        return keys.map(k => this.findNode(k))
-    }
-
-    requireFindNodes (...keys: string[]): INode<T>[] {
-        const nodes = this.findNodes(...keys)
-        if (nodes.some(n => n === undefined)) {
-            throw new Error('One of the nodes does not exist')
-        }
-        return nodes as INode<T>[]
-    }
-
-    addLink (nodeA: string, nodeB: string, data?: T): void {
-        const [inodeA, inodeB] = this.requireFindNodes(nodeA, nodeB)
-        this.links.push(new ILink<T>(inodeA, inodeB, data))
-    }
-
-    addLinks (...links: [nodeA: string, nodeB: string, data?: T][]): void {
-        links.forEach(link => this.addLink(...link))
-    }
-    
-    /** 
-     * Get all nodes linked 
-     * to from `node`.
-     */
-    findLinkedNodes (node: INode<T>) {
-        return this.links.reduce((acc, link) => {
-            if (this.isEquals(link.from, node)) {
-                acc.push(link.to)
-            }
-            return acc;
-        }, [] as INode<T>[]);
-    }
-
-    findAllPaths(from: string, to: string) {
-        const allPaths: INode<T>[][] = []
-
-        const [fromNode, toNode] = this.requireFindNodes(from, to)
-
-        const path: INode<T>[] = [fromNode]
-        let seen = new Set()
-
-        const stuck = (x: INode<T>) => {
-            if (this.isEquals(x, toNode)) {
-                return false
-            }
-
-            for (const y of this.findLinkedNodes(x)) {
-                if (!seen.has(y.key)) {
-                    seen.add(y.key)
-                    if (!stuck(y)) {
-                        return false
-                    }
-                }
-            }
-
-            return true
-        }
-
-        const search = (x: INode<T>) => {
-            if (this.isEquals(x, toNode)) {
-                allPaths.push(cloneDeep(path))
-                return
-            }
-            seen = new Set(path.map(p => p.key))
-            if (stuck(x)) {
-                return
-            }
-
-            for (const y of this.findLinkedNodes(x)) {
-                if (!path.includes(y)) {
-                    path.push(y)
-                    search(y)
-                    path.pop()
-                }
-            }
-        }
-
-        search(fromNode)
-
-        return allPaths
-    }
-}

package/src/index.ts

@@ -1,6 +0,0 @@
-export * from './coins'
-export * from './parsers'
-export * from './constants'
-export * from './utils'
-export * from './graph'
-export * from './math'

package/src/math.ts

@@ -1,147 +0,0 @@
-import BN from "bignumber.js";
-import { FEE_FACTOR } from "./constants";
-
-/**
- * XPR<>XUSDT (XPR -> XUSDT)
- *
- *                     pool1 * pool2
- *  term =  pool2  -  --------------
- *                     pool1 + swap
- *
- *  result = term - (term * fee)
- */
-export const compute_transfer = (
-  pool1: BN.Instance,
-  pool2: BN.Instance,
-  swap: BN.Instance,
-  exchange_fee: number,
-  precision: number
-): BN => {
-  const term1 = pool2;
-  const term2over = pool1.times(pool2);
-  const term2under = pool1.plus(swap);
-  const term2 = term2over.div(term2under).integerValue(BN.ROUND_DOWN);
-  const term = term1.minus(term2);
-  const fee = new BN(exchange_fee).div(FEE_FACTOR);
-  const result = term.minus(term.times(fee));
-
-  return result.integerValue(BN.ROUND_DOWN).shiftedBy(-precision);
-};
-
-export const compute_transfer_curve = (
-  reserve_in: number,
-  reserve_out: number,
-  amount_in: number,
-  exchange_fee: number,
-  precision: number,
-  amplifier: number
-): BN => {
-  if (amplifier === 0) {
-    return compute_transfer(
-      new BN(reserve_in),
-      new BN(reserve_out),
-      new BN(amount_in),
-      exchange_fee,
-      precision
-    );
-  }
-
-  const MAX_ITERATIONS = 10;
-
-  const sum = reserve_in + reserve_out;
-  let D = sum;
-  let D_prev = 0;
-
-  const F = (v: number) => {
-    return (v >= 0 ? 1 : -1) * Math.floor(Math.abs(v));
-  };
-
-  let i = MAX_ITERATIONS;
-  while (D != D_prev && i--) {
-    const prod1 = F((F((D * D) / (reserve_in * 2)) * D) / (reserve_out * 2));
-    D_prev = D;
-    D = F(
-      (2 * D * (amplifier * sum + prod1)) /
-        ((2 * amplifier - 1) * D + 3 * prod1)
-    );
-  }
-
-  const b = reserve_in + amount_in + F(D / (amplifier * 2)) - D;
-
-  const c = F(
-    (F((D * D) / ((reserve_in + amount_in) * 2)) * D) / (amplifier * 4)
-  );
-
-  let x = D,
-    x_prev = 0;
-  i = MAX_ITERATIONS;
-  while (x != x_prev && i--) {
-    x_prev = F(x);
-    x = +new BN(x * x + c).div(2 * x + b).toFixed(0, BN.ROUND_DOWN);
-  }
-
-  if (reserve_out <= x) {
-    throw new Error("curve: insufficient reserve out");
-  }
-
-  // Amount out + Fee + 1
-  const amount_out_with_fee = new BN(reserve_out - x);
-
-  // Fee + 1
-  // +1 covers small precision issues
-  const fee = amount_out_with_fee
-    .times(exchange_fee)
-    .div(FEE_FACTOR)
-    .plus(1)
-    .toFixed(0, BN.ROUND_DOWN);
-
-  // Amount out
-  const amount_out = amount_out_with_fee.minus(fee);
-
-  return amount_out.integerValue(BN.ROUND_DOWN).shiftedBy(-precision);
-};
-
-export const compute_liquidity = (
-  amount_lt: BN.Instance,
-  pool: BN.Instance,
-  lt_supply: BN.Instance,
-  precision: number
-): number => {
-  const over = amount_lt.times(pool);
-  const under = lt_supply;
-  const result = over.div(under).integerValue(BN.ROUND_DOWN);
-
-  return +result.shiftedBy(-precision).toFixed(precision, BN.ROUND_DOWN);
-};
-
-export const isInputInvalid = (
-  data: string,
-  value: string | number,
-  pool: { xtokenPrecision: number }
-): boolean => {
-  value = String(value);
-
-  const isBackspace = data === null;
-  const isNumber = !/[0-9]|\./.test(data);
-  const isDoubleDot = data === "." && value.indexOf(".") !== value.length - 1;
-  const isPrecisionTooHigh =
-    value &&
-    value.indexOf(".") !== -1 &&
-    value.split(".")[1].length > pool.xtokenPrecision;
-  const isInvalid =
-    !isBackspace && Boolean(isNumber || isDoubleDot || isPrecisionTooHigh);
-
-  return isInvalid;
-};
-
-export const applyDiscountToFee = (fee: number, staked: number): number => {
-  if (staked >= 10000000) {
-    return fee * 0;
-  } else if (staked >= 1000000) {
-    return fee * 0.33;
-  } else if (staked >= 100000) {
-    return fee * 0.66;
-  } else {
-    return fee;
-  }
-};

package/src/parsers/actions.ts

@@ -1,82 +0,0 @@
-import * as z from 'zod';
-import { accountParser, authorizationsParser } from './base'
-
-const actionParser = z.object({
-    account: z.string(),
-    name: z.string(),
-    authorization: z.array(
-        z.object({
-            actor: z.string(),
-            permission: z.string(),
-        })
-    ),
-    data: z.any(),
-    hex_data: z.string().optional()
-})
-
-const transactionExtensionsParser = z.array(z.number().or(z.string())).optional()
-
-const rawTransactionParser = z.object({
-    expiration            : z.string(),
-    ref_block_num         : z.number(),
-    ref_block_prefix      : z.number(),
-    max_net_usage_words   : z.number(),
-    max_cpu_usage_ms      : z.number(),
-    delay_sec             : z.number(),
-    context_free_actions  : z.array(actionParser),
-    transaction_extensions: z.array(transactionExtensionsParser)
-})
-
-export const baseActionParser = <T extends z.ZodRawShape>(contract: string, action: string, data: T) => z.object({
-    account: contract === '*' ? accountParser : z.literal(contract),
-    name: z.literal(action),
-    data: z.object(data),
-    authorization: authorizationsParser
-})
-
-export const baseActionSerializedParser = <T extends z.ZodRawShape>(contract: string, action: string, data: T) => z.object({
-    account: contract === '*' ? accountParser : z.literal(contract),
-    name: z.literal(action),
-    data: z.string().or(z.object(data)),
-    authorization: authorizationsParser
-})
-
-export const webauthActionParser = <T extends z.ZodRawShape>(contract: string, action: string, data: T) => z.object({
-    account: z.literal('webauthn'),
-    name: z.literal('exec'),
-    data: z.object({
-        account: accountParser,
-        key: z.object({
-            key: z.array(z.string().or(z.object({
-                modulus: z.string(),
-                exponent: z.string()
-            }))),
-            user_presence: z.number(),
-            rpid: z.string()
-        }),
-        nonce: z.number(),
-        permissions: authorizationsParser,
-        signature: z.object({
-            auth_data: z.string(),
-            client_json: z.string(),
-            signature: z.string()
-        }),
-        trx: rawTransactionParser.merge(
-            z.object({
-                actions: z.array(
-                    baseActionSerializedParser(contract, action, data)
-                ).length(1)
-            })
-        )
-    }),
-    authorization: authorizationsParser
-})
-
-export const singleActionTransactionParser = <T extends z.ZodRawShape>(contract: string, action: string, data: T) => {
-    const baseAction = baseActionParser(contract, action, data)
-    const webauthAction = webauthActionParser(contract, action, data)
-
-    return rawTransactionParser.merge(z.object({
-        actions: z.array(baseAction.or(webauthAction)).length(1)
-    }))
-}

package/src/parsers/address.ts

@@ -1,27 +0,0 @@
-import * as z from 'zod';
-import { accountParser } from './base'
-import { generateAuthParser } from './auth'
-
-export const addressParser = z.object({
-    index       : z.number(),
-    account     : accountParser,
-    chain       : z.string(),
-    address     : z.string(),
-    address_hash: z.string(),
-})
-export type Address = z.infer<typeof addressParser>
-
-export const generateAddressBodyParser = z.object({
-    coin: z.string(),
-    wallet: z.string(),
-}).merge(generateAuthParser)
-export type GenerateAddressBody = z.infer<typeof generateAddressBodyParser>
-
-export const generateAddressResponse = z.object({
-    id     : z.string(),            // "2448834505708930950",
-    address: z.string(),            // "0x617C03C1E2Bf81C062A4CEfbE312c070E1d86d18",
-    coin   : z.string(),            // "ETH",
-    wallet : z.string(),            // "ETH",
-    memo   : z.string().optional()
-})
-export type GenerateAddressResponse = z.infer<typeof generateAddressResponse>

package/src/parsers/auth.ts

@@ -1,36 +0,0 @@
-import * as z from "zod";
-import { baseActionParser, singleActionTransactionParser } from "./actions";
-import { authorizationParser } from "./base";
-import { WRAP_CONTRACT, WRAP_AUTH_ACTION } from "../constants";
-
-export const createAbstractAuthParser = (
-  contract: string,
-  action: string,
-  data: z.ZodRawShape
-) => {
-  return z.object({
-    signer: authorizationParser,
-    signatures: z.array(z.string()).length(1),
-    transaction: singleActionTransactionParser(contract, action, data),
-  });
-};
-
-const generateAuthData = {
-  time: z.string(),
-  protonAccount: z.string(),
-};
-const generateAuthActionsBaseParser = baseActionParser(
-  WRAP_CONTRACT,
-  WRAP_AUTH_ACTION,
-  generateAuthData
-);
-export type GenerateAuthBaseAction = z.infer<
-  typeof generateAuthActionsBaseParser
->;
-
-export const generateAuthParser = createAbstractAuthParser(
-  WRAP_CONTRACT,
-  WRAP_AUTH_ACTION,
-  generateAuthData
-);
-export type GenerateAuth = z.infer<typeof generateAuthParser>;

package/src/parsers/base.ts

@@ -1,24 +0,0 @@
-import * as z from "zod";
-
-export const accountParser = z.string().regex(/^[.1-5a-z]{0,12}[.1-5a-j]?$/);
-
-export const authorizationParser = z.object({
-  actor: accountParser,
-  permission: z.string(),
-});
-export type Authorization = z.infer<typeof authorizationParser>;
-
-export const authorizationsParser = z.array(authorizationParser).min(1);
-export type Authorizations = z.infer<typeof authorizationsParser>;
-
-export const ExtendedAssetParser = z.object({
-  quantity: z.string(),
-  contract: accountParser,
-});
-export type ExtendedAsset = z.infer<typeof ExtendedAssetParser>;
-
-export const accountRamDeltaParser = z.object({
-  account: z.string(),
-  delta: z.string(),
-});
-export type HistoryAccountRamDelta = z.infer<typeof accountRamDeltaParser>;