zo-sdk 0.0.4 → 0.0.5

package/dist/api.mjs

@@ -0,0 +1,462 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _API_instances, _API_processCoins, _API_processSlippage;
+import { Transaction } from "@mysten/sui/transactions";
+import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui/utils";
+import { ALLOW_TRADE_CAN_TRADE, ALLOW_TRADE_MUST_TRADE, ALLOW_TRADE_NO_TRADE } from "./consts/index.mjs";
+import { DataAPI } from "./data.mjs";
+import { joinSymbol } from "./utils.mjs";
+export class API extends DataAPI {
+    // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+    constructor(network, provider, apiEndpoint, connectionURL) {
+        super(network, provider, apiEndpoint, connectionURL);
+        _API_instances.add(this);
+        _API_processCoins.set(this, (tx, coin, coinObjects) => {
+            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]);
+        });
+        Object.defineProperty(this, "deposit", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async (coin, coinObjects, amount, minAmountOut = 0) => {
+                const tx = await this.initOracleTxb(Object.keys(this.consts.pythFeeder.feeder));
+                const coinObject = __classPrivateFieldGet(this, _API_processCoins, "f").call(this, 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;
+            }
+        });
+        Object.defineProperty(this, "withdraw", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async (coin, zlpCoinObjects, amount, minAmountOut = 0) => {
+                const tx = await this.initOracleTxb(Object.keys(this.consts.pythFeeder.feeder));
+                const zlpCoinObject = __classPrivateFieldGet(this, _API_processCoins, "f").call(this, 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;
+            }
+        });
+        Object.defineProperty(this, "openPosition", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async (collateralToken, indexToken, size, collateralAmount, coinObjects, long, reserveAmount, indexPrice, collateralPrice, 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 = __classPrivateFieldGet(this, _API_processCoins, "f").call(this, 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 = __classPrivateFieldGet(this, _API_instances, "m", _API_processSlippage).call(this, indexPrice, long, isLimitOrder ? 0 : slippage);
+                const adjustCollateralPrice = __classPrivateFieldGet(this, _API_instances, "m", _API_processSlippage).call(this, 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;
+            }
+        });
+        Object.defineProperty(this, "pledgeInPosition", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async (pcpId, collateralToken, indexToken, amount, coinObjects, long) => {
+                const tx = await this.initOracleTxb([collateralToken, indexToken]);
+                const coinObject = __classPrivateFieldGet(this, _API_processCoins, "f").call(this, 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;
+            }
+        });
+        Object.defineProperty(this, "redeemFromPosition", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async (pcpId, collateralToken, indexToken, amount, long) => {
+                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;
+            }
+        });
+        Object.defineProperty(this, "decreasePosition", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async (pcpId, collateralToken, indexToken, amount, long, indexPrice, collateralPrice, 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 = __classPrivateFieldGet(this, _API_instances, "m", _API_processSlippage).call(this, indexPrice, !long, isTriggerOrder ? 0 : slippage);
+                const adjustCollateralPrice = __classPrivateFieldGet(this, _API_instances, "m", _API_processSlippage).call(this, 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;
+            }
+        });
+        Object.defineProperty(this, "cancelOrder", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (orderCapId, collateralToken, indexToken, long, type, 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;
+            }
+        });
+        Object.defineProperty(this, "swap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async (fromToken, toToken, fromAmount, fromCoinObjects) => {
+                const tx = await this.initOracleTxb(Object.keys(this.consts.zoCore.vaults));
+                const fromCoinObject = __classPrivateFieldGet(this, _API_processCoins, "f").call(this, 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;
+            }
+        });
+        Object.defineProperty(this, "clearClosedPosition", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (pcpId, collateralToken, indexToken, long, tx) => {
+                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),
+                    ],
+                });
+            }
+        });
+        Object.defineProperty(this, "clearOpenPositionOrder", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (orderCapId, collateralToken, indexToken, long, tx, 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),
+                    ],
+                });
+            }
+        });
+        Object.defineProperty(this, "clearDecreasePositionOrder", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (orderCapId, collateralToken, indexToken, long, tx, 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),
+                    ],
+                });
+            }
+        });
+        Object.defineProperty(this, "stake", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (coinObjects, amount, pool, tx) => {
+                if (!tx) {
+                    tx = new Transaction();
+                }
+                const coinObject = __classPrivateFieldGet(this, _API_processCoins, "f").call(this, 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;
+            }
+        });
+        Object.defineProperty(this, "unstake", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (credentials, amount, pool, tx) => {
+                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;
+            }
+        });
+        Object.defineProperty(this, "addReferral", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (referrer, tx) => {
+                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;
+            }
+        });
+    }
+    static getInstance(network, provider, apiEndpoint, connectionURL) {
+        if (!API.instance) {
+            API.instance = new API(network, provider, apiEndpoint, connectionURL);
+        }
+        return API.instance;
+    }
+}
+_API_processCoins = new WeakMap(), _API_instances = new WeakSet(), _API_processSlippage = function _API_processSlippage(indexPrice, long, slippage) {
+    const raw = long ? (indexPrice * (1 + slippage)) : (indexPrice * (1 - slippage));
+    return BigInt(Math.round(raw * 1e18));
+};

package/dist/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/dist/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"
+        }
+    }
+}