@proton/wrap-constants 0.1.1 → 0.2.2

package/src/constants.ts

@@ -1,31 +1,37 @@
 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 } = initializeCoins(chain)
+    const { swapCoins, bridgeCoins, allEnabledCoins, allCoins, lendCoins, borrowCoins, loanCoins } = initializeCoins(chain)
 
     const constants = {
         SWAP_CONTRACT: 'proton.swaps',
-        FEE_FACTOR: 10000,
+        DEX_CONTRACT: chain === 'proton'
+            ? 'dex'
+            : 'dextest21',    
+        FEE_FACTOR,
         GOOGLE_MAPS_KEY: 'AIzaSyDb2_CrK032kSIqBXbkdwmaLKWELl0SxVs',
         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-public'
-            : 'https://www.api.bloks.io/proton-wrap-testnet-public',
+            ? 'https://www.api.bloks.io/proton-wrap-public2'
+            : 'https://www.api.bloks.io/proton-wrap-testnet-public2',
         WRAP_CONTRACT,
         WRAP_ACTIONS: {
-            SAVE_ADDRESS: 'saveaddress',
-            WRAP_START: 'wrapstart',
-            WRAP_FINISH: 'wrapfinish',
-            WRAP_PROCESS: 'wrapprocess',
-            WRAP_SET_CONF: 'wrapsetconf'
+            SAVE_ADDRESS: 'saveaddress2',
+            DELETE_ADDRESS: 'deladdress2',
+            WRAP_START: 'wrapstart2',
+            WRAP_FINISH: 'wrapfinish2',
+            WRAP_PROCESS: 'wrapprocess2',
+            WRAP_SET_CONF: 'wrapsetconf2',
         },
         WRAP_TABLES: {
-            ADDRESSES: 'addresses',
-            WRAPS: 'wraps'
+            ADDRESSES: 'addresses2',
+            WRAPS: 'wraps2'
         },
         ADDRESSES_INDEXES: {
             BY_ACCOUNT: 2,
@@ -42,7 +48,8 @@ export const initializeConstants = (chain: string) => {
 
         WEBHOOK_PERMISSION: 'webhook',
         PUBLIC_PERMISSION: 'public',
-        WRAP_AUTH_ACTION: 'generateauth',
+        LIGHT_PERMISSION: 'light',
+        WRAP_AUTH_ACTION: WRAP_AUTH_ACTION,
 
         METAL_ENDPOINT: chain === 'proton'
             ? 'https://cirrus.metalpay.com'
@@ -52,9 +59,13 @@ export const initializeConstants = (chain: string) => {
             ? 'https://api.protonchain.com'
             : 'https://api-dev.protonchain.com',
 
+        METAL_DEX_ENDPOINT: chain === 'proton'
+            ? 'https://metallicus-dbapi-dev01.binfra.one'
+            : 'https://metallicus-dbapi-dev01.binfra.one',
+
         PROTON_ENDPOINTS: chain === 'proton'
-            ? ['https://proton.greymass.com', 'https://proton.eoscafeblock.com', 'https://proton.cryptolions.io', 'https://proton.eosusa.news']
-            : ['https://testnet.protonchain.com'],
+            ? ['https://metal-proton-rpc.global.binfra.one', 'https://proton.greymass.com', 'https://proton.eoscafeblock.com', 'https://proton.cryptolions.io', 'https://proton.eosusa.news']
+            : ['https://metal-protontest-rpc.global.binfra.one', 'https://testnet.protonchain.com'],
 
         CHAIN_ID: chain === 'proton'
             ? '384da888112027f0321850a169f737c33e53b388aad48b5adace4bab97f437e0'
@@ -65,11 +76,27 @@ export const initializeConstants = (chain: string) => {
         SWAP_COINS: swapCoins,
         BRIDGE_COINS: bridgeCoins,
         ALL_ENABLED_COINS: allEnabledCoins,
+        LEND_COINS: lendCoins,
+        BORROW_COINS: borrowCoins,
+        LOAN_COINS: loanCoins,
         ALL_COINS: allCoins,
 
+        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
 

package/src/graph.ts

@@ -0,0 +1,126 @@
+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,4 +1,6 @@
 export * from './coins'
 export * from './parsers'
 export * from './constants'
-export * from './utils'
+export * from './utils'
+export * from './graph'
+export * from './math'

package/src/math.ts

@@ -0,0 +1,112 @@
+import { BigNumber as 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.multipliedBy(pool2)
+  const term2under = pool1.plus(swap)
+  const term2 = term2over.dividedBy(term2under).integerValue(BN.ROUND_DOWN)
+  const term = term1.minus(term2)
+  const fee = new BN(exchange_fee).dividedBy(FEE_FACTOR)
+  const result = term.minus(term.multipliedBy(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).dividedBy(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.multipliedBy(exchange_fee).dividedBy(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.multipliedBy(pool)
+  const under = lt_supply
+  const result = over.dividedBy(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

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,18 @@
+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>

package/src/parsers/currency.ts

@@ -0,0 +1,89 @@
+import * as z from 'zod'
+
+export interface CurrencyStat {
+    supply    : string;
+    max_supply: string;
+    issuer    : string;
+}
+export interface CurrencyStats {
+   [key: string]: CurrencyStat;
+}
+
+export const rateParser = z.object({
+    counterCurrency   : z.string(),
+    price             : z.number(),
+    priceChangePercent: z.number(),
+    marketCap         : z.number(),
+    volume            : z.number(),
+    timestamp         : z.number()
+})
+export type Rate = z.infer<typeof rateParser>
+
+export const exchangeRateParser = z.object({
+    contract: z.string(),
+    symbol  : z.string(),
+    rank    : z.number(),
+    rates   : z.array(rateParser)
+})
+export type ExchangeRate = z.infer<typeof exchangeRateParser>
+
+export const exchangeRatesParser = z.array(exchangeRateParser)
+export type ExchangeRates = z.infer<typeof exchangeRatesParser>
+
+export const bloksRatesParser = z.array(z.object({
+    contract: z.string(),
+    symbol  : z.string(),
+    rank    : z.number(),
+    rates   : z.array(rateParser)
+}))
+
+export type BloksRate = {
+    key: string;
+    symbol: string;
+    account: string;
+    chain: string;
+    supply: {
+        circulating: number;
+        max: number;
+        precision: number;
+        last_update: string;
+    };
+    metadata: {
+        name: string;
+        website: string;
+        logo: string;
+        created_at: string;
+        desc: string;
+    };
+    pairs: [
+        {
+            id: string;
+            pair_base: string;
+            pair_quote: string;
+            exchange: string;
+            quote:{
+                price: number
+                volume_base_24h: number
+                volume_quote_24h: number
+                market_cap: number
+                price_usd: number
+                volume_usd_24h: number
+            },
+            percentage_daily_volume: number
+        },
+    ];
+    price: {
+        quotes: {
+            [key: string]: number
+        },
+        usd: number;
+        volume_base_24h: number;
+        volume_usd_24h: number;
+        marketcap_usd: number;
+        change_24hr: number;
+    },
+    rank: number;
+    chain_rank: number;
+}
+
+export type BloksRates = BloksRate[]

package/src/parsers/deposit.ts

@@ -0,0 +1,30 @@
+import * as z from 'zod'
+
+export enum Type {
+    RECEIVE = 'receive',
+    SEND    = 'send'
+}
+
+export const depositBodyParser = z.object({
+    id        : z.string(), // "0x000010203121388fac991"
+    type      : z.nativeEnum(Type), // "receive" or "send"
+    hash      : z.string(), // "0x000010203121388fac991"
+    coin      : z.string(), // "ETH" or "XPR"
+    wallet    : z.string(), // "ETH-ROPSTEN" or "XPR-MAINNET"
+})
+export type DepositBody = z.infer<typeof depositBodyParser>
+
+export const transactionParser = z.object({
+    id            : z.string(), // "2629304740076324677"
+    wallet        : z.string(), // "ETH"
+    value         : z.number(), // 10000000000000000
+    valueString   : z.string(), // "10000000000000000"
+    address       : z.string(), // "0x0000"
+    type          : z.nativeEnum(Type), // "receive" or "send"
+    state         : z.string(), // "confirmed"
+    confirmations : z.number(), // 1
+    hash          : z.string(), // "b4781422be95fee8fbbf720e3e0fa9705ae834474ef25f5724cdd0f5d23211ed"
+    blockHash     : z.string().optional().nullable(), // "000000000000000000089b270eb99f75107d6a9cde37ec944cb80a2998df7b43"
+    blockHeight   : z.number().optional().nullable(), // 643159
+})
+export type Transaction = z.infer<typeof transactionParser>