@7kprotocol/sdk-ts 3.6.1-beta.1 → 3.6.1-beta.2

package/lib/esm/features/metaAg/index.js

@@ -1,234 +0,0 @@
-import { getFullnodeUrl, SuiClient, } from "@mysten/sui/client";
-import { coinWithBalance, Transaction, } from "@mysten/sui/transactions";
-import { normalizeStructTag, toBase64 } from "@mysten/sui/utils";
-import { SUI_ADDRESS_ZERO } from "../../constants/sui";
-import { EProvider, isAggregatorProvider, isSwapAPIProvider, } from "../../types/metaAg";
-import { isSystemAddress } from "../../utils/sui";
-import { SuiClientUtils } from "../../utils/SuiClientUtils";
-import { getExpectedReturn } from "../../utils/swap";
-import { metaSettle, simulateAggregator, timeout } from "./common";
-import { MetaAgError, MetaAgErrorCode } from "./error";
-import { OkxProvider, simulateOKXSwap } from "./providers/okx";
-const HERMES_API = "https://hermes.pyth.network";
-const DEFAULT_PROVIDERS = {
-    [EProvider.BLUEFIN7K]: {},
-    [EProvider.FLOWX]: {},
-    [EProvider.CETUS]: {},
-};
-export class MetaAg {
-    client;
-    providers = {};
-    inspector;
-    options;
-    constructor(options) {
-        this.options = {
-            providers: { ...DEFAULT_PROVIDERS, ...options?.providers },
-            slippageBps: options?.slippageBps ?? 100,
-            fullnodeUrl: options?.fullnodeUrl ?? getFullnodeUrl("mainnet"),
-            hermesApi: options?.hermesApi ?? HERMES_API,
-            partner: options?.partner ?? SUI_ADDRESS_ZERO,
-            partnerCommissionBps: options?.partnerCommissionBps ?? 0,
-            tipBps: options?.tipBps ?? 0,
-        };
-        this.client = new SuiClient({
-            url: this.options.fullnodeUrl,
-        });
-        this.inspector = new SuiClientUtils(this.client);
-    }
-    async _getProvider(provider) {
-        const p = this.providers[provider];
-        if (p)
-            return p;
-        const providerOptions = this.options.providers[provider];
-        MetaAgError.assert(!!providerOptions, `Provider not found: ${provider}`, MetaAgErrorCode.PROVIDER_NOT_FOUND, { provider });
-        switch (provider) {
-            case EProvider.BLUEFIN7K:
-                const { Bluefin7kProvider } = await import("./providers/bluefin7k").catch(catchImportError(EProvider.BLUEFIN7K));
-                this.providers[EProvider.BLUEFIN7K] = new Bluefin7kProvider(providerOptions, this.options, this.client);
-                break;
-            case EProvider.FLOWX:
-                const { FlowxProvider } = await import("./providers/flowx").catch(catchImportError(EProvider.FLOWX));
-                this.providers[EProvider.FLOWX] = new FlowxProvider(providerOptions, this.client);
-                break;
-            case EProvider.CETUS:
-                const { CetusProvider } = await import("./providers/cetus").catch(catchImportError(EProvider.CETUS));
-                this.providers[EProvider.CETUS] = new CetusProvider(providerOptions, this.options, this.client);
-                break;
-            case EProvider.OKX:
-                this.providers[EProvider.OKX] = new OkxProvider(providerOptions, this.options, this.client);
-                break;
-            default:
-                throw new MetaAgError(`Provider not supported: ${provider}`, MetaAgErrorCode.PROVIDER_NOT_SUPPORTED, { provider });
-        }
-        return this.providers[provider];
-    }
-    async _simulate(provider, quote, simulation) {
-        try {
-            if (isAggregatorProvider(provider)) {
-                return simulateAggregator(provider, quote, simulation, this.inspector, this.options);
-            }
-            switch (quote.provider) {
-                case EProvider.OKX:
-                    return simulateOKXSwap(quote, this.inspector, simulation, this.options);
-                default:
-                    throw new MetaAgError(`Provider not supported: ${provider.kind}`, MetaAgErrorCode.PROVIDER_NOT_SUPPORTED, { provider: provider.kind });
-            }
-        }
-        catch (error) {
-            console.warn(error, { provider: provider.kind, quote: quote.id });
-        }
-    }
-    async _quote(provider, options) {
-        const quote = await timeout(async () => {
-            const quote = await provider.quote(options);
-            if (!quote)
-                return null;
-            const { expectedAmount } = getExpectedReturn(quote.rawAmountOut, 0, this.options.partnerCommissionBps, this.options.tipBps);
-            quote.amountOut = expectedAmount;
-            return quote;
-        }, options.timeout ?? 2000, `quote for ${provider.kind} provider from ${options.coinTypeIn} to ${options.coinTypeOut}`);
-        return quote;
-    }
-    async _fastSwap({ quote, signer, useGasCoin, signTransaction }, getTransactionBlockParams) {
-        const tx = new Transaction();
-        const coin = await this.swap({
-            quote,
-            signer,
-            tx,
-            coinIn: coinWithBalance({
-                type: quote.coinTypeIn,
-                balance: BigInt(quote.amountIn),
-                useGasCoin,
-            }),
-        });
-        tx.transferObjects([coin], signer);
-        tx.setSenderIfNotSet(signer);
-        const txBytes = await tx.build({ client: this.client });
-        const { signature, bytes } = await signTransaction(toBase64(txBytes));
-        return this.client.executeTransactionBlock({
-            transactionBlock: bytes,
-            signature,
-            options: getTransactionBlockParams?.options,
-            signal: getTransactionBlockParams?.signal,
-        });
-    }
-    /**
-     * Get quotes from all providers
-     * @param options - quote options
-     * @param simulation - if present, the quote will be simulated
-     * @returns quotes from all providers
-     */
-    async quote(options, simulation) {
-        const opts = {
-            ...options,
-            coinTypeIn: normalizeStructTag(options.coinTypeIn),
-            coinTypeOut: normalizeStructTag(options.coinTypeOut),
-        };
-        const quotes = await Promise.allSettled(Object.entries(this.options.providers)
-            .filter(([_k, v]) => !v.disabled)
-            .map(async ([provider]) => {
-            const p = await this._getProvider(provider);
-            return this._quote(p, opts);
-        }));
-        const result = quotes
-            .map((quote) => quote.status === "fulfilled"
-            ? quote.value
-            : (console.log(quote.reason), null))
-            .filter((quote) => quote !== null);
-        if (simulation) {
-            const requests = result.map(async (quote) => {
-                const provider = await this._getProvider(quote.provider);
-                const updated = await this._simulate(provider, quote, simulation);
-                quote.simulatedAmountOut = updated?.simulatedAmountOut;
-                quote.gasUsed = updated?.gasUsed;
-                simulation?.onSimulated?.({ ...quote });
-            });
-            if (!simulation.onSimulated) {
-                await Promise.all(requests);
-            }
-        }
-        return result;
-    }
-    /**
-     * Build transaction from quote
-     * @info Use this function to build composable transaction (ie: add more commands after the swap, consume the coin out object)
-     * @warning Providers that build transaction on the fly (typically RFQ, Swap-API providers ie: Okx, ...) are not supported, please use `fastSwap` instead
-     * @param options - build tx options
-     * @param slippageBps - slippage bps if not specified, fallback to global slippage bps, if none of them specified, default to 100
-     * @returns coin out object, you must consume it by transferObjects, or other sub sequence commands
-     */
-    async swap(options, slippageBps) {
-        const provider = await this._getProvider(options.quote.provider);
-        MetaAgError.assert(!!provider, `Provider not found: ${options.quote.provider}`, MetaAgErrorCode.PROVIDER_NOT_FOUND, { provider: options.quote.provider });
-        MetaAgError.assert(isAggregatorProvider(provider), `Provider does not support swap: ${provider.kind}, use fastSwap instead`, MetaAgErrorCode.PROVIDER_NOT_SUPPORT_SWAP, { provider: provider.kind });
-        MetaAgError.assert(!isSystemAddress(options.signer), "Invalid signer address", MetaAgErrorCode.INVALID_SIGNER_ADDRESS, { signer: options.signer });
-        const coinOut = await provider.swap(options);
-        options.tx.add(metaSettle(options.quote, coinOut, slippageBps ?? this.options.slippageBps ?? 100, this.options.tipBps, this.options.partner, this.options.partnerCommissionBps));
-        options.tx.setSenderIfNotSet(options.signer);
-        return coinOut;
-    }
-    /**
-     * Build, Sign, and Execute transaction in one step
-     * @param options - fast swap options
-     * @returns - txDigest of the transaction
-     */
-    async fastSwap(options, getTransactionBlockParams) {
-        MetaAgError.assert(!isSystemAddress(options.signer), "Invalid signer address", MetaAgErrorCode.INVALID_SIGNER_ADDRESS, { signer: options.signer });
-        const provider = await this._getProvider(options.quote.provider);
-        if (isAggregatorProvider(provider)) {
-            return this._fastSwap(options, getTransactionBlockParams);
-        }
-        else if (isSwapAPIProvider(provider)) {
-            return this.client.waitForTransaction({
-                ...getTransactionBlockParams,
-                digest: await provider.fastSwap(options),
-            });
-        }
-        else {
-            throw new MetaAgError(`Provider not supported: ${provider.kind}`, MetaAgErrorCode.PROVIDER_NOT_SUPPORTED, { provider: provider.kind });
-        }
-    }
-    /**
-     * Update meta aggregator options
-     * @param options - update options payload
-     */
-    updateMetaAgOptions(options) {
-        if (Object.keys(options).length === 0)
-            return;
-        this.options.slippageBps = options.slippageBps ?? this.options.slippageBps;
-        this.options.partner = options.partner ?? this.options.partner;
-        this.options.partnerCommissionBps =
-            options.partnerCommissionBps ?? this.options.partnerCommissionBps;
-        this.options.tipBps = options.tipBps ?? this.options.tipBps;
-        if (options.fullnodeUrl &&
-            options.fullnodeUrl !== this.options.fullnodeUrl) {
-            this.client = new SuiClient({ url: options.fullnodeUrl });
-            this.inspector = new SuiClientUtils(this.client);
-            this.options.fullnodeUrl = options.fullnodeUrl;
-        }
-        if (options.hermesApi && options.hermesApi !== this.options.hermesApi) {
-            this.providers = {};
-            this.options.hermesApi = options.hermesApi;
-        }
-        // if update provider's options, we need to re-initialize the provider
-        for (const [provider, opt] of Object.entries(options.providers || {})) {
-            this.options.providers[provider] = {
-                ...opt,
-                ...this.options.providers[provider],
-            };
-            delete this.providers[provider];
-        }
-    }
-}
-const catchImportError = (provider) => {
-    return (e) => {
-        const map = {
-            [EProvider.CETUS]: "@cetusprotocol/aggregator-sdk",
-            [EProvider.FLOWX]: "@flowx-finance/sdk",
-            [EProvider.BLUEFIN7K]: "@bluefin-exchange/bluefin7k-aggregator-sdk",
-            [EProvider.OKX]: "",
-        };
-        console.warn(`Please install ${map[provider]} to use ${provider} provider`);
-        throw e;
-    };
-};

package/lib/esm/features/metaAg/providers/bluefin7k.js

@@ -1,55 +0,0 @@
-import { buildTx, Config, getQuote, } from "@bluefin-exchange/bluefin7k-aggregator-sdk";
-import { v4 } from "uuid";
-import { _7K_PARTNER_ADDRESS } from "../../../constants/_7k";
-import { EProvider, } from "../../../types/metaAg";
-import { MetaAgError, MetaAgErrorCode } from "../error";
-export class Bluefin7kProvider {
-    options;
-    metaOptions;
-    kind = EProvider.BLUEFIN7K;
-    constructor(options, metaOptions, client) {
-        this.options = options;
-        this.metaOptions = metaOptions;
-        if (options.apiKey)
-            Config.setApiKey(options.apiKey);
-        Config.setSuiClient(client);
-    }
-    async quote(quoteOptions) {
-        const quote = await getQuote({
-            tokenIn: quoteOptions.coinTypeIn,
-            tokenOut: quoteOptions.coinTypeOut,
-            amountIn: quoteOptions.amountIn,
-            sources: this.options.sources,
-            excludedPools: this.options.excludedPools,
-            targetPools: this.options.targetPools,
-        });
-        MetaAgError.assert(!!quote, "No quote found", MetaAgErrorCode.QUOTE_NOT_FOUND, { provider: this.kind });
-        return {
-            id: v4(),
-            provider: EProvider.BLUEFIN7K,
-            quote,
-            amountIn: quote.swapAmountWithDecimal,
-            rawAmountOut: quote.returnAmountWithDecimal,
-            amountOut: quote.returnAmountWithDecimal,
-            coinTypeIn: quoteOptions.coinTypeIn,
-            coinTypeOut: quoteOptions.coinTypeOut,
-        };
-    }
-    async swap({ quote, signer, tx, coinIn }) {
-        MetaAgError.assert(quote.provider === EProvider.BLUEFIN7K, "Invalid quote", MetaAgErrorCode.INVALID_QUOTE, { quote, expectedProvider: EProvider.BLUEFIN7K });
-        const { coinOut } = await buildTx({
-            quoteResponse: quote.quote,
-            accountAddress: signer,
-            commission: {
-                commissionBps: 0,
-                partner: _7K_PARTNER_ADDRESS,
-            },
-            slippage: 1,
-            extendTx: {
-                tx,
-                coinIn,
-            },
-        });
-        return coinOut;
-    }
-}

package/lib/esm/features/metaAg/providers/cetus.js

@@ -1,57 +0,0 @@
-import { AggregatorClient, Env } from "@cetusprotocol/aggregator-sdk";
-import { v4 } from "uuid";
-import { _7K_PARTNER_ADDRESS } from "../../../constants/_7k";
-import { EProvider, } from "../../../types/metaAg";
-import { MetaAgError, MetaAgErrorCode } from "../error";
-export class CetusProvider {
-    options;
-    kind = EProvider.CETUS;
-    cetusClient;
-    constructor(options, metaOptions, client) {
-        this.options = options;
-        this.cetusClient = new AggregatorClient({
-            apiKey: options.apiKey,
-            client,
-            endpoint: options.api,
-            env: Env.Mainnet,
-            pythUrls: metaOptions.hermesApi ? [metaOptions.hermesApi] : [],
-            overlayFeeRate: 0,
-            overlayFeeReceiver: _7K_PARTNER_ADDRESS,
-        });
-    }
-    async quote(quoteOptions) {
-        const quote = await this.cetusClient.findRouters({
-            amount: quoteOptions.amountIn,
-            byAmountIn: true,
-            from: quoteOptions.coinTypeIn,
-            target: quoteOptions.coinTypeOut,
-            providers: this.options.sources,
-            splitCount: this.options.splitCount,
-            splitAlgorithm: this.options.splitAlgorithm,
-            splitFactor: this.options.splitFactor,
-            depth: this.options.depth,
-            liquidityChanges: this.options.liquidityChanges,
-        });
-        MetaAgError.assert(!!quote, "No quote found", MetaAgErrorCode.QUOTE_NOT_FOUND, { provider: this.kind });
-        return {
-            id: v4(),
-            provider: EProvider.CETUS,
-            quote,
-            amountIn: quote.amountIn.toString() || "0",
-            rawAmountOut: quote.amountOut.toString() || "0",
-            amountOut: quote.amountOut.toString() || "0",
-            coinTypeIn: quoteOptions.coinTypeIn,
-            coinTypeOut: quoteOptions.coinTypeOut,
-        };
-    }
-    async swap(options) {
-        MetaAgError.assert(options.quote.provider === EProvider.CETUS, "Expect Cetus quote", MetaAgErrorCode.INVALID_QUOTE, { quote: options.quote, expectedProvider: EProvider.CETUS });
-        const coinOut = await this.cetusClient.routerSwap({
-            inputCoin: options.coinIn,
-            router: options.quote.quote,
-            slippage: 1,
-            txb: options.tx,
-        });
-        return coinOut;
-    }
-}

package/lib/esm/features/metaAg/providers/flowx.js

@@ -1,51 +0,0 @@
-import { AggregatorQuoter, Commission, CommissionType, TradeBuilder, } from "@flowx-finance/sdk";
-import { v4 } from "uuid";
-import { _7K_PARTNER_ADDRESS } from "../../../constants/_7k";
-import { EProvider, } from "../../../types/metaAg";
-import { MetaAgError, MetaAgErrorCode } from "../error";
-export class FlowxProvider {
-    options;
-    client;
-    kind = EProvider.FLOWX;
-    quoter;
-    constructor(options, client) {
-        this.options = options;
-        this.client = client;
-        this.quoter = new AggregatorQuoter("mainnet", options.apiKey);
-    }
-    async quote(quoteOptions) {
-        const quote = await this.quoter.getRoutes({
-            amountIn: quoteOptions.amountIn,
-            tokenIn: quoteOptions.coinTypeIn,
-            tokenOut: quoteOptions.coinTypeOut,
-            includeSources: this.options.sources,
-            excludePools: this.options.excludePools,
-            excludeSources: this.options.excludeSources,
-            maxHops: this.options.maxHops,
-            splitDistributionPercent: this.options.splitDistributionPercent,
-        });
-        return {
-            id: v4(),
-            provider: EProvider.FLOWX,
-            quote: quote,
-            amountIn: quote.amountIn?.toString() ?? "0",
-            rawAmountOut: quote.amountOut?.toString() ?? "0",
-            amountOut: quote.amountOut?.toString() ?? "0",
-            coinTypeIn: quoteOptions.coinTypeIn,
-            coinTypeOut: quoteOptions.coinTypeOut,
-        };
-    }
-    async swap(options) {
-        MetaAgError.assert(options.quote.provider === EProvider.FLOWX, "Invalid quote", MetaAgErrorCode.INVALID_QUOTE, { quote: options.quote, expectedProvider: EProvider.FLOWX });
-        const builder = new TradeBuilder("mainnet", options.quote.quote.routes);
-        builder.sender(options.signer);
-        builder.slippage(10000 * 100);
-        builder.commission(new Commission(_7K_PARTNER_ADDRESS, options.quote.quote.coinOut, CommissionType.PERCENTAGE, 0, true));
-        const res = await builder.build().swap({
-            tx: options.tx,
-            client: this.client,
-            coinIn: options.coinIn,
-        });
-        return res;
-    }
-}

package/lib/esm/features/metaAg/providers/okx.js

@@ -1,147 +0,0 @@
-import { Commands, Transaction, TransactionDataBuilder, } from "@mysten/sui/transactions";
-import { normalizeStructTag, normalizeSuiAddress, toBase64, } from "@mysten/sui/utils";
-import { v4 } from "uuid";
-import { SUI_TYPE } from "../../../constants/tokens";
-import { EProvider, } from "../../../types/metaAg";
-import { isSystemAddress } from "../../../utils/sui";
-import { metaSettle, simulateSwapTx } from "../common";
-import { MetaAgError, MetaAgErrorCode } from "../error";
-const API = "https://web3.okx.com";
-const SWAP_PATH = "/api/v6/dex/aggregator/swap";
-const CHAIN_ID = "784";
-const NORMALIZED_SUI_TYPE = normalizeStructTag(SUI_TYPE);
-export class OkxProvider {
-    options;
-    metaOptions;
-    client;
-    kind = EProvider.OKX;
-    constructor(options, metaOptions, client) {
-        this.options = options;
-        this.metaOptions = metaOptions;
-        this.client = client;
-    }
-    async quote({ amountIn, coinTypeIn, coinTypeOut, signer, }) {
-        if (!signer || isSystemAddress(signer))
-            return null;
-        const request = {
-            chainIndex: CHAIN_ID,
-            amount: amountIn,
-            fromTokenAddress: coinTypeIn === NORMALIZED_SUI_TYPE ? SUI_TYPE : coinTypeIn,
-            toTokenAddress: coinTypeOut === NORMALIZED_SUI_TYPE ? SUI_TYPE : coinTypeOut,
-            slippagePercent: (this.metaOptions.slippageBps / 100).toString(),
-            userWalletAddress: signer,
-        };
-        const queryString = "?" + new URLSearchParams(request).toString();
-        const url = `${this.options.api ?? API}${SWAP_PATH}${queryString}`;
-        const response = await fetch(url, {
-            headers: await getHeaders(this.options, "GET", SWAP_PATH, queryString),
-        });
-        const quote = (await response.json());
-        MetaAgError.assert(quote.code === "0" && quote.data.length > 0, "No quote found", MetaAgErrorCode.QUOTE_NOT_FOUND, { provider: this.kind });
-        return {
-            id: v4(),
-            provider: this.kind,
-            coinTypeIn,
-            coinTypeOut,
-            amountIn,
-            amountOut: quote.data[0].routerResult.toTokenAmount,
-            rawAmountOut: quote.data[0].routerResult.toTokenAmount,
-            quote: quote.data[0],
-        };
-    }
-    async fastSwap(options) {
-        const { quote, signer, signTransaction } = options;
-        MetaAgError.assert(quote.provider === EProvider.OKX, "Invalid quote", MetaAgErrorCode.INVALID_QUOTE, { quote, expectedProvider: EProvider.OKX });
-        const { tx, coin } = buildTx({ quote, signer });
-        tx.add(metaSettle(quote, coin, this.metaOptions.slippageBps, this.metaOptions.tipBps, this.metaOptions.partner, this.metaOptions.partnerCommissionBps));
-        tx.transferObjects([coin], signer);
-        const txBytes = await tx.build({ client: this.client });
-        const { bytes, signature } = await signTransaction(toBase64(txBytes));
-        const res = await this.client.executeTransactionBlock({
-            signature,
-            transactionBlock: bytes,
-        });
-        return res.digest;
-    }
-}
-async function generateHmacSha256(message, secretKey) {
-    const encoder = new TextEncoder();
-    const encodeBase64 = (bytes) => {
-        if (typeof Buffer !== "undefined") {
-            return Buffer.from(bytes).toString("base64");
-        }
-        let binary = "";
-        for (let i = 0; i < bytes.byteLength; i++) {
-            binary += String.fromCharCode(bytes[i]);
-        }
-        if (typeof btoa !== "undefined") {
-            return btoa(binary);
-        }
-        throw new MetaAgError("Base64 encoder not available in this environment");
-    };
-    if (typeof globalThis !== "undefined" && globalThis.crypto?.subtle) {
-        const key = await globalThis.crypto.subtle.importKey("raw", encoder.encode(secretKey), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
-        const signature = await globalThis.crypto.subtle.sign("HMAC", key, encoder.encode(message));
-        return encodeBase64(new Uint8Array(signature));
-    }
-    const { createHmac } = await import("node:crypto");
-    return createHmac("sha256", secretKey).update(message).digest("base64");
-}
-async function getHeaders(options, method, requestPath, queryString = "") {
-    const { apiKey, secretKey, apiPassphrase, projectId } = options;
-    if (!apiKey || !secretKey || !apiPassphrase || !projectId) {
-        throw new MetaAgError("Missing required environment variables");
-    }
-    const timestamp = new Date().toISOString();
-    const stringToSign = timestamp + method + requestPath + queryString;
-    return {
-        "Content-Type": "application/json",
-        "OK-ACCESS-KEY": apiKey,
-        "OK-ACCESS-SIGN": await generateHmacSha256(stringToSign, secretKey),
-        "OK-ACCESS-TIMESTAMP": timestamp,
-        "OK-ACCESS-PASSPHRASE": apiPassphrase,
-        "OK-ACCESS-PROJECT": projectId,
-    };
-}
-const replaceFinalizeCommand = (tx, packageId) => {
-    const builder = TransactionDataBuilder.restore(tx.getData());
-    const i = builder.commands.findIndex((cmd) => cmd.$kind === "MoveCall" &&
-        normalizeSuiAddress(cmd.MoveCall.package) ===
-            normalizeSuiAddress(packageId) &&
-        cmd.MoveCall.module === "router" &&
-        cmd.MoveCall.function === "finalize");
-    const cmd = builder.commands[i];
-    MetaAgError.assert(cmd.MoveCall, "OKX: Finalize command not found", MetaAgErrorCode.OKX_FINALIZE_COMMAND_NOT_FOUND, { packageId });
-    builder.replaceCommand(i, Commands.MoveCall({
-        package: packageId,
-        module: "router",
-        function: "finalize_without_transfer",
-        typeArguments: cmd.MoveCall.typeArguments,
-        arguments: [
-            cmd.MoveCall.arguments[0],
-            cmd.MoveCall.arguments[5],
-            cmd.MoveCall.arguments[6],
-        ],
-    }));
-    const tx2 = Transaction.from(builder.build());
-    return { tx: tx2, coin: { NestedResult: [i, 0] } };
-};
-const buildTx = (options) => {
-    const { quote, signer } = options;
-    MetaAgError.assert(quote.provider === EProvider.OKX, "Invalid quote", MetaAgErrorCode.INVALID_QUOTE, { quote, expectedProvider: EProvider.OKX });
-    const tx = Transaction.from(quote.quote.tx.data);
-    tx.setSenderIfNotSet(signer);
-    const { tx: tx2, coin } = replaceFinalizeCommand(tx, quote.quote.tx.to);
-    return { tx: tx2, coin };
-};
-export const simulateOKXSwap = async (quote, inspector, simulation, metaOptions) => {
-    const { tx, coin } = buildTx({ quote, signer: quote.quote.tx.from });
-    tx.add(metaSettle(quote, coin, 10000, metaOptions.tipBps, metaOptions.partner, metaOptions.partnerCommissionBps));
-    tx.transferObjects([coin], quote.quote.tx.from);
-    const res = await simulateSwapTx(tx, inspector, simulation);
-    return {
-        id: quote.id,
-        provider: quote.provider,
-        ...res,
-    };
-};

package/lib/esm/features/prices/index.js

@@ -1,94 +0,0 @@
-import { fetchClient } from "../../config/fetchClient";
-import { API_ENDPOINTS } from "../../constants/apiEndpoints";
-import { SUI_FULL_TYPE } from "../../constants/tokens";
-import { normalizeTokenType } from "../../utils/token";
-const chunkArray = (array, chunkSize) => {
-    const chunks = [];
-    for (let i = 0; i < array.length; i += chunkSize) {
-        chunks.push(array.slice(i, i + chunkSize));
-    }
-    return chunks;
-};
-const MAX_TOTAL_IDS = 500;
-const MAX_IDS_PER_REQUEST = 100;
-/**
- * Get the current Unix timestamp as a string
- */
-function getCurrentTimestamp() {
-    return Math.floor(Date.now() / 1000).toString();
-}
-/**
- * Get price for a single token
- * @param id - Token ID (coin type)
- * @returns Token price, or 0 if not found or on error
- */
-export async function getTokenPrice(id) {
-    try {
-        const normalizedId = normalizeTokenType(id);
-        const prices = await getTokenPrices([normalizedId]);
-        return prices[normalizedId] || 0;
-    }
-    catch (_) {
-        return 0;
-    }
-}
-/**
- * Get prices for multiple tokens
- * @param ids - Array of token IDs (coin types)
- * @returns Record mapping token IDs to their prices
- */
-export async function getTokenPrices(ids) {
-    try {
-        if (ids.length === 0) {
-            return {};
-        }
-        const limitedIds = ids.slice(0, MAX_TOTAL_IDS).map(normalizeTokenType);
-        const idChunks = chunkArray(limitedIds, MAX_IDS_PER_REQUEST);
-        const timestamp = getCurrentTimestamp();
-        const responses = await Promise.all(idChunks.map(async (chunk) => {
-            const requestBody = {
-                timestamp,
-                token_ids: chunk,
-            };
-            const response = await fetchClient(`${API_ENDPOINTS.PRICES}/prices/batch`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify(requestBody),
-            });
-            if (!response.ok) {
-                throw new Error(`Price API returned status ${response.status}`);
-            }
-            const pricesRes = (await response.json());
-            return pricesRes;
-        }));
-        // Combine all responses into a single record
-        const combinedPrices = responses.reduce((acc, priceResponses) => {
-            priceResponses.forEach((priceResponse) => {
-                acc[priceResponse.token_id] = priceResponse.price;
-            });
-            return acc;
-        }, {});
-        // Ensure all requested IDs are in the result (set to 0 if not found)
-        const finalPrices = limitedIds.reduce((acc, id) => {
-            acc[id] = combinedPrices[id] || 0;
-            return acc;
-        }, {});
-        return finalPrices;
-    }
-    catch (_) {
-        // On error, return 0 for all requested IDs
-        return ids.slice(0, MAX_TOTAL_IDS).reduce((acc, id) => {
-            acc[normalizeTokenType(id)] = 0;
-            return acc;
-        }, {});
-    }
-}
-/**
- * Get the current SUI token price
- * @returns SUI price, or 0 if not found or on error
- */
-export async function getSuiPrice() {
-    return await getTokenPrice(SUI_FULL_TYPE);
-}

package/lib/esm/index.mjs

@@ -1,31 +0,0 @@
-export * from "./types/metaAg";
-import { MetaAg } from "./features/metaAg";
-import { getSuiPrice, getTokenPrice, getTokenPrices } from "./features/prices";
-import { cancelDcaOrder, cancelLimitOrder, claimExpiredLimitOrder, getClosedDcaOrders, getClosedLimitOrders, getDcaOrderExecutions, getOpenDcaOrders, getOpenLimitOrders, placeDcaOrder, placeLimitOrder, } from "./features/limitDca";
-export { MetaAg, cancelDcaOrder, cancelLimitOrder, claimExpiredLimitOrder, getClosedDcaOrders, getClosedLimitOrders, getDcaOrderExecutions, getOpenDcaOrders, getOpenLimitOrders, 
-// prices
-getSuiPrice, getTokenPrice, getTokenPrices, 
-// dca
-placeDcaOrder, 
-// limit order
-placeLimitOrder, };
-export default {
-    // prices
-    getTokenPrice,
-    getTokenPrices,
-    getSuiPrice,
-    // limit order
-    placeLimitOrder,
-    getOpenLimitOrders,
-    cancelLimitOrder,
-    claimExpiredLimitOrder,
-    getClosedLimitOrders,
-    // dca
-    placeDcaOrder,
-    getOpenDcaOrders,
-    cancelDcaOrder,
-    getClosedDcaOrders,
-    getDcaOrderExecutions,
-    // Meta aggregator
-    MetaAg,
-};