zo-sdk 0.0.4

package/src/api.ts

@@ -0,0 +1,544 @@
+/* eslint-disable no-param-reassign */
+/* eslint-disable class-methods-use-this */
+import type { SuiClient } from '@mysten/sui/client'
+import { Transaction } from '@mysten/sui/transactions'
+import { SUI_CLOCK_OBJECT_ID } from '@mysten/sui/utils'
+
+import type { Network } from './consts'
+import { ALLOW_TRADE_CAN_TRADE, ALLOW_TRADE_MUST_TRADE, ALLOW_TRADE_NO_TRADE } from './consts'
+import type { ICredential } from './data'
+import { DataAPI } from './data'
+import { joinSymbol } from './utils'
+
+export class API extends DataAPI {
+  private static instance: API
+
+  // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+  constructor(
+    network: Network,
+    provider: SuiClient | null,
+    apiEndpoint: string,
+    connectionURL: string,
+  ) {
+    super(network, provider, apiEndpoint, connectionURL)
+  }
+
+  public static getInstance(
+    network: Network,
+    provider: SuiClient | null,
+    apiEndpoint: string,
+    connectionURL: string,
+  ): API {
+    if (!API.instance) {
+      API.instance = new API(network, provider, apiEndpoint, connectionURL)
+    }
+    return API.instance
+  }
+
+  #processCoins = (tx: Transaction, coin: string, coinObjects: string[]) => {
+    if (coin === 'sui') {
+      return tx.gas
+    }
+    if (coinObjects.length > 1) {
+      tx.mergeCoins(tx.object(coinObjects[0]), coinObjects.slice(1).map(coinObject => tx.object(coinObject)))
+    }
+    return tx.object(coinObjects[0])
+  }
+
+  #processSlippage(indexPrice: number, long: boolean, slippage: number) {
+    const raw = long ? (indexPrice * (1 + slippage)) : (indexPrice * (1 - slippage))
+    return BigInt(Math.round(raw * 1e18))
+  }
+
+  deposit = async (
+    coin: string,
+    coinObjects: string[],
+    amount: number,
+    minAmountOut = 0,
+  ) => {
+    const tx = await this.initOracleTxb(Object.keys(this.consts.pythFeeder.feeder))
+    const coinObject = this.#processCoins(tx, coin, coinObjects)
+    const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)])
+
+    const {
+      vaultsValuation,
+      symbolsValuation,
+    } = this.valuate(tx)
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.package}::market::deposit`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[coin].module,
+      ],
+      arguments: [
+        tx.object(this.consts.zoCore.market),
+        tx.object(this.consts.zoCore.rebaseFeeModel),
+        depositObject,
+        tx.pure.u64(minAmountOut),
+        vaultsValuation,
+        symbolsValuation,
+      ],
+    })
+    return tx
+  }
+
+  withdraw = async (
+    coin: string,
+    zlpCoinObjects: string[],
+    amount: number,
+    minAmountOut = 0,
+  ) => {
+    const tx = await this.initOracleTxb(Object.keys(this.consts.pythFeeder.feeder))
+    const zlpCoinObject = this.#processCoins(tx, 'zlp', zlpCoinObjects)
+    const [withdrawObject] = tx.splitCoins(zlpCoinObject, [tx.pure.u64(amount)])
+
+    const {
+      vaultsValuation,
+      symbolsValuation,
+    } = this.valuate(tx)
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.package}::market::withdraw`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[coin].module,
+      ],
+      arguments: [
+        tx.object(this.consts.zoCore.market),
+        tx.object(this.consts.zoCore.rebaseFeeModel),
+        withdrawObject,
+        tx.pure.u64(minAmountOut),
+        vaultsValuation,
+        symbolsValuation,
+      ],
+    })
+    return tx
+  }
+
+  openPosition = async (
+    collateralToken: string,
+    indexToken: string,
+    size: bigint,
+    collateralAmount: bigint,
+    coinObjects: string[],
+    long: boolean,
+    reserveAmount: bigint,
+    indexPrice: number,
+    collateralPrice: number,
+    slippage = 0.003,
+    isLimitOrder = false,
+    isIocOrder = false,
+    relayerFee = BigInt(1),
+    referralAddress = '',
+    sender = '',
+  ) => {
+    let tx = new Transaction()
+    if (referralAddress && !await this.hasReferral(sender || '')) {
+      tx = await this.addReferral(referralAddress, tx)
+    }
+    tx = await this.initOracleTxb([collateralToken, indexToken], tx)
+    const coinObject = this.#processCoins(tx, collateralToken, coinObjects)
+    const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(collateralAmount)])
+    const feeObject = tx.splitCoins(tx.gas, [tx.pure.u64(relayerFee)])
+
+    const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+    const adjustPrice = this.#processSlippage(indexPrice, long, isLimitOrder ? 0 : slippage)
+    const adjustCollateralPrice = this.#processSlippage(collateralPrice, false, 0.5)
+
+    let allowTrade = ALLOW_TRADE_MUST_TRADE
+    if (isLimitOrder) {
+      allowTrade = isIocOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
+    }
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.package}::market::open_position`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins.sui.module,
+      ],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.zoCore.market),
+        tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+        tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+        tx.object(this.consts.zoCore.symbols[symbol].positionConfig),
+        tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+        tx.object(this.consts.pythFeeder.feeder[indexToken]),
+        depositObject,
+        feeObject,
+        tx.pure.u8(allowTrade),
+        tx.pure.u64(size),
+        tx.pure.u64(reserveAmount),
+        tx.pure.u256(adjustCollateralPrice),
+        tx.pure.u256(adjustPrice),
+      ],
+    })
+    return tx
+  }
+
+  pledgeInPosition = async (
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: number,
+    coinObjects: string[],
+    long: boolean,
+  ) => {
+    const tx = await this.initOracleTxb([collateralToken, indexToken])
+    const coinObject = this.#processCoins(tx, collateralToken, coinObjects)
+    const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)])
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.package}::market::pledge_in_position`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+      ],
+      arguments: [
+        tx.object(this.consts.zoCore.market),
+        tx.object(pcpId),
+        depositObject,
+      ],
+    })
+    return tx
+  }
+
+  redeemFromPosition = async (
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: number,
+    long: boolean,
+  ) => {
+    const tx = await this.initOracleTxb([collateralToken, indexToken])
+    const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.package}::market::redeem_from_position`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+      ],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.zoCore.market),
+        tx.object(pcpId),
+        tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+        tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+        tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+        tx.object(this.consts.pythFeeder.feeder[indexToken]),
+        tx.pure.u64(amount),
+      ],
+    })
+
+    return tx
+  }
+
+  decreasePosition = async (
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    amount: bigint,
+    long: boolean,
+    indexPrice: number,
+    collateralPrice: number,
+    isTriggerOrder = false,
+    isTakeProfitOrder = true,
+    isIocOrder = false,
+    slippage = 0.003,
+    relayerFee = BigInt(1),
+  ) => {
+    const tx = await this.initOracleTxb([collateralToken, indexToken])
+    const symbol = joinSymbol(long ? 'long' : 'short', indexToken)
+    const feeObject = tx.splitCoins(tx.gas, [tx.pure.u64(relayerFee)])
+
+    const adjustPrice = this.#processSlippage(indexPrice, !long, isTriggerOrder ? 0 : slippage)
+    const adjustCollateralPrice = this.#processSlippage(collateralPrice, false, 0.5)
+
+    let allowTrade = ALLOW_TRADE_MUST_TRADE
+    if (isTriggerOrder) {
+      allowTrade = isIocOrder || !isTakeProfitOrder ? ALLOW_TRADE_NO_TRADE : ALLOW_TRADE_CAN_TRADE
+    }
+    else {
+      isTakeProfitOrder = true
+    }
+
+    /*     console.log('isTriggerOrder:', isTriggerOrder)
+    console.log('isIocOrder:', isIocOrder)
+    console.log('isTakeProfitOrder:', isTakeProfitOrder)
+    console.log('adjustPrice:', adjustPrice)
+    console.log('allowTrade:', allowTrade)
+    console.log('isTriggerOrder:', isTriggerOrder)
+    console.log('isTakeProfitOrder:', isTakeProfitOrder) */
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.package}::market::decrease_position`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins.sui.module,
+      ],
+      arguments: [
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        tx.object(this.consts.zoCore.market),
+        tx.object(pcpId),
+        tx.object(this.consts.zoCore.vaults[collateralToken].reservingFeeModel),
+        tx.object(this.consts.zoCore.symbols[symbol].fundingFeeModel),
+        tx.object(this.consts.pythFeeder.feeder[collateralToken]),
+        tx.object(this.consts.pythFeeder.feeder[indexToken]),
+        feeObject,
+        tx.pure.u8(allowTrade),
+        tx.pure.bool(isTakeProfitOrder),
+        tx.pure.u64(amount),
+        tx.pure.u256(adjustCollateralPrice),
+        tx.pure.u256(adjustPrice),
+      ],
+    })
+
+    return tx
+  }
+
+  cancelOrder = (
+    orderCapId: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    type: string,
+    isV11Order = false,
+  ) => {
+    const tx = new Transaction()
+    let functionName = ''
+    switch (type) {
+      case 'OPEN_POSITION': {
+        functionName = isV11Order ? 'clear_open_position_order' : 'clear_open_position_order'
+        break
+      }
+      case 'DECREASE_POSITION': {
+        functionName = isV11Order ? 'clear_decrease_position_order' : 'clear_decrease_position_order'
+        break
+      }
+      default: {
+        throw new Error('invalid order type')
+      }
+    }
+    tx.moveCall({
+      target: `${this.consts.zoCore.package}::market::${functionName}`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins.sui.module,
+      ],
+      arguments: [
+        tx.object(this.consts.zoCore.market),
+        tx.object(orderCapId),
+      ],
+    })
+    return tx
+  }
+
+  swap = async (
+    fromToken: string,
+    toToken: string,
+    fromAmount: bigint,
+    fromCoinObjects: string[],
+  ) => {
+    const tx = await this.initOracleTxb(Object.keys(this.consts.zoCore.vaults))
+    const fromCoinObject = this.#processCoins(tx, fromToken, fromCoinObjects)
+    const [fromDepositObject] = tx.splitCoins(fromCoinObject, [tx.pure.u64(fromAmount)])
+    const vaultsValuation = this.valuateVaults(tx)
+
+    tx.moveCall({
+      target: `${this.consts.zoCore.package}::market::swap`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[fromToken].module,
+        this.consts.coins[toToken].module,
+      ],
+      arguments: [
+        tx.object(this.consts.zoCore.market),
+        tx.object(this.consts.zoCore.rebaseFeeModel),
+        fromDepositObject,
+        // FIXME: minAmountOut
+        tx.pure.u64(0),
+        vaultsValuation,
+      ],
+    })
+    return tx
+  }
+
+  clearClosedPosition = (
+    pcpId: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    tx: Transaction,
+  ) => {
+    tx.moveCall({
+      target: `${this.consts.zoCore.package}::market::clear_closed_position`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+      ],
+      arguments: [
+        tx.object(this.consts.zoCore.market),
+        tx.object(pcpId),
+      ],
+    })
+  }
+
+  clearOpenPositionOrder = (
+    orderCapId: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    tx: Transaction,
+    isV11Order = false,
+  ) => {
+    const funcName = isV11Order ? 'clear_open_position_order' : 'clear_open_position_order'
+    tx.moveCall({
+      target: `${this.consts.zoCore.package}::market::${funcName}`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins.sui.module,
+      ],
+      arguments: [
+        tx.object(this.consts.zoCore.market),
+        tx.object(orderCapId),
+      ],
+    })
+  }
+
+  clearDecreasePositionOrder = (
+    orderCapId: string,
+    collateralToken: string,
+    indexToken: string,
+    long: boolean,
+    tx: Transaction,
+    isV11Order = false,
+  ) => {
+    const funcName = isV11Order ? 'clear_decrease_position_order' : 'clear_decrease_position_order'
+    tx.moveCall({
+      target: `${this.consts.zoCore.package}::market::${funcName}`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins[collateralToken].module,
+        this.consts.coins[indexToken].module,
+        `${this.consts.zoCore.package}::market::${long ? 'LONG' : 'SHORT'}`,
+        this.consts.coins.sui.module,
+      ],
+      arguments: [
+        tx.object(this.consts.zoCore.market),
+        tx.object(orderCapId),
+      ],
+    })
+  }
+
+  stake = (
+    coinObjects: string[],
+    amount: bigint,
+    pool: string,
+    tx?: Transaction | undefined,
+  ) => {
+    if (!tx) {
+      tx = new Transaction()
+    }
+    const coinObject = this.#processCoins(tx, 'zlp', coinObjects)
+    const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)])
+
+    tx.moveCall({
+      target: `${this.consts.zoStaking.package}::pool::deposit`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        this.consts.coins.sui.module,
+      ],
+      arguments: [
+        tx.object(pool),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        depositObject,
+      ],
+    })
+
+    return tx
+  }
+
+  unstake = (
+    credentials: ICredential[],
+    amount: bigint,
+    pool: string,
+    tx?: Transaction | undefined,
+  ) => {
+    if (!tx) {
+      tx = new Transaction()
+    }
+    for (const credential of credentials) {
+      // eslint-disable-next-line unicorn/prefer-math-min-max
+      const withdrawAmount = amount < credential.amount ? amount : credential.amount
+      amount -= withdrawAmount
+      tx.moveCall({
+        target: `0xdb353cb79a88d5ee83b7c0ca0249662a1facab17ba62879080ea3d61b9d21112::pool::withdraw`,
+        typeArguments: [
+          `${this.consts.zoCore.package}::zlp::ZLP`,
+          this.consts.coins.sui.module,
+        ],
+        arguments: [
+          tx.object(pool),
+          tx.object(SUI_CLOCK_OBJECT_ID),
+          tx.object(credential.id),
+          tx.pure.u64(withdrawAmount),
+        ],
+      })
+      if (credential.amount === BigInt(0)) {
+        tx.moveCall({
+          target: `${this.consts.zoStaking.package}::pool::clear_empty_credential`,
+          typeArguments: [
+            `${this.consts.zoCore.package}::zlp::ZLP`,
+            this.consts.coins.sui.module,
+          ],
+          arguments: [
+            tx.object(credential.id),
+          ],
+        })
+      }
+    }
+
+    return tx
+  }
+
+  addReferral = (
+    referrer: string,
+    tx?: Transaction | undefined,
+  ) => {
+    if (!tx) {
+      tx = new Transaction()
+    }
+    tx.moveCall({
+      target: `${this.consts.zoCore.package}::market::add_new_referral`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+      ],
+      arguments: [
+        tx.object(this.consts.zoCore.market),
+        tx.object(referrer),
+      ],
+    })
+
+    return tx
+  }
+}

package/src/consts/deployments-mainnet.json

@@ -0,0 +1,28 @@
+{
+  "zo_core": {
+    "package": "",
+    "upgrade_cap": "",
+    "admin_cap": "",
+    "market": "",
+    "zlp_metadata": "",
+    "rebase_fee_model": "",
+    "referrals_parent": "",
+    "vaults_parent": "",
+    "symbols_parent": "",
+    "positions_parent": "",
+    "orders_parent": "",
+    "vaults": {},
+    "symbols": {}
+  },
+  "pyth_feeder": {
+    "package": "0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e",
+    "package_v2": "0x04e20ddf36af412a4096f9014f4a565af9e812db9a05cc40254846cf6ed0ad91",
+    "state": "0x1f9310238ee9298fb703c3419030b35b22bb1cc37113e3bb5007c99aec79e5b8",
+    "wormhole": {
+      "package": "0x5306f64e312b581766351c07af79c72fcb1cd25147157fdc2f8ad76de9a3fb6a",
+      "state": "0xaeab97f96cf9877fee2883315d459552b2b921edc16d7ceac6eab944dd88919c"
+    },
+    "feeder": {}
+  },
+  "coins": {}
+}

package/src/consts/deployments-testnet.json

@@ -0,0 +1,93 @@
+{
+  "zo_core": {
+    "package": "0xa7d1d1f3a8346753674223473f6b71d6c8a6ca9475da0501368f57bb6d35cc0b",
+    "upgrade_cap": "0x7f6bb9305da4d35576be0ffd3b56c0085db46ba4b7ce8c0022f65b683c5ad5b4",
+    "admin_cap": "0x2d2ef02c1fd1ba0baf144e9f7a9d7365d50dff34e6f249be0e23ad01d7a1d700",
+    "market": "0xf6fb5acc78a6c85bfca39719088a7ac74ab199a58097bf8fe79df75ec5f535d1",
+    "zlp_metadata": "0xeb6eb4bd199cd4c0699855a5337fef75df05e0ee728ed507fed7041ecd8ed910",
+    "rebase_fee_model": "0x285d0c1f21858db319481ae35e1d6ad735c3176df7c3eef9b95b8deed24faf7d",
+    "referrals_parent": "0xcf63fb9086d2f3ed710d980f48da4443144225f1024f48debeba638072998345",
+    "vaults_parent": "0xa1ed162b3b9c545d2cc46224750bf76e22f55a12ddedc8eacd685930f1287da6",
+    "symbols_parent": "0xc73cc19cb9df994db7859638373279f678f7e837ba3f29f0e54029bcc9f7f376",
+    "positions_parent": "0x70c9c9cb6cfe9da0c730553a22281cb9c44c647d6a0d60a656b73e27eb08497d",
+    "orders_parent": "0xc62365fb575103f559c147fcac8379760faf68d91914e4e0ac296fbeb78c2905",
+    "vaults": {
+      "usdt": {
+        "weight": "1000000000000000000",
+        "reserving_fee_model": "0x095aa141f72af6045b0691773ca1da621bdd50de048f78226190627521c6bb99"
+      }
+    },
+    "symbols": {
+      "long_btc": {
+        "supported_collaterals": [
+          "usdt"
+        ],
+        "funding_fee_model": "0x13e2cf849c6bcbec5c2d95897359e956612dbfd9f6eac0f2f46f9954e725118a",
+        "position_config": "0x6a02e6e75dba447d7c2f59ac26ce94d33039a45c07b0180e50d0e67bb1ad3f43"
+      },
+      "short_btc": {
+        "supported_collaterals": [
+          "usdt"
+        ],
+        "funding_fee_model": "0x5a5ca35b5c6e997cff46b24137353d2df70365d801cab47f45eab113193a138f",
+        "position_config": "0x65b1d0f4f4c4d60e3f4670331f145d70f90cf3558280bc207dc369f38c8b40bb"
+      },
+      "long_eth": {
+        "supported_collaterals": [
+          "usdt"
+        ],
+        "funding_fee_model": "0xffcf6a37a465feff40e2f003dfb9c75875d9c66da520be8ab71a787af4d15fe9",
+        "position_config": "0x8fd32f908c4810d51cb088a5b147d5a5e0e463db252dbffc2fed8578077de35c"
+      },
+      "short_eth": {
+        "supported_collaterals": [
+          "usdt"
+        ],
+        "funding_fee_model": "0xe0a3468419ef07a4ec1a564b32971bdd301fb8a5a900b98280074d13914f0ec0",
+        "position_config": "0x1f499a262fa1d30c8177b2f887f2f5423ab4c33d9a5954606739743336673dac"
+      }
+    }
+  },
+  "pyth_feeder": {
+    "package": "0xabf837e98c26087cba0883c0a7a28326b1fa3c5e1e2c5abdb486f9e8f594c837",
+    "state": "0x243759059f4c3111179da5878c12f68d612c21a8d54d85edc86164bb18be1c7c",
+    "wormhole": {
+      "package": "0xf47329f4344f3bf0f8e436e2f7b485466cff300f12a166563995d3888c296a94",
+      "state": "0x31358d198147da50db32eda2562951d53973a0c0ad5ed738e9b17d88b213d790"
+    },
+    "feeder": {
+      "btc": "0x72431a238277695d3f31e4425225a4462674ee6cceeea9d66447b210755fffba",
+      "sui": "0x1ebb295c789cc42b3b2a1606482cd1c7124076a0f5676718501fda8c7fd075a0",
+      "eth": "0x4fde30cb8a5dc3cfee1c1c358fc66dc308408827efb217247c7ba54d76ccbee9",
+      "sol": "0x33fbce1cad5ca155f2f5051430b23a694bc6e5de6df43e0f8aefe29f4a84336d",
+      "usdt": "0x956fdcbf83a26c962319f7742f5728a0a7ce59c7f0cbe13c112b259e7ee953cd"
+    }
+  },
+  "coins": {
+    "sui": {
+      "decimals": 9,
+      "module": "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI",
+      "metadata": "0x9258181f5ceac8dbffb7030890243caed69a9599d2886d957a9cb7656af3bdb3"
+    },
+    "btc": {
+      "decimals": 6,
+      "module": "0x997965ea613857d34f13511fbe27f94728ab079615cd083ed24aef70516ab2e4::btc::BTC",
+      "metadata": "0xca50f9e2bae829ee73dc5079d3882298070b7b36451ec35f9455947163b4854e"
+    },
+    "eth": {
+      "decimals": 9,
+      "module": "0x0d3dd3ff9950dfbe34c52dbb552c36b618a3263f20f84309c9dfef7e140b6301::eth::ETH",
+      "metadata": "0x009c984d2d0c3afac3a598fd1ce77bb93740e8948e9665c7a7fe24046e129313"
+    },
+    "sol": {
+      "decimals": 9,
+      "module": "0x7eb2d1737cf4901218956dbd798f461a2606792da2df87b3c670e364ced35ce7::sol::SOL",
+      "metadata": "0xf77d6b54b007e45ea17ad9fa41821649e9ee16a9b14d3aabc2bb07b7874a90e9"
+    },
+    "usdt": {
+      "decimals": 6,
+      "module": "0x8684c115c57c725a832abe63b5cfa7268b77126a8a7a52883f602e5513c9de2d::usdt::USDT",
+      "metadata": "0xac3fcd1e6d7bd32d33afb1a0864b05b0adefeaddb2933ead5d5df1af21b1b741"
+    }
+  }
+}