@7kprotocol/sdk-ts 3.5.4 → 3.6.1-beta.0

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

@@ -1,13 +1,14 @@
-import { getFullnodeUrl, SuiClient } from "@mysten/sui/client";
+import { getFullnodeUrl, SuiClient, } from "@mysten/sui/client";
 import { coinWithBalance, Transaction, } from "@mysten/sui/transactions";
-import { normalizeStructTag } from "@mysten/sui/utils";
-import { _7K_META_CONFIG, _7K_META_PACKAGE_ID, _7K_META_PUBLISHED_AT, _7K_META_VAULT, } from "../../constants/_7k";
+import { normalizeStructTag, toBase64 } from "@mysten/sui/utils";
 import { SUI_ADDRESS_ZERO } from "../../constants/sui";
-import { EProvider, } from "../../types/metaAg";
-import { assert } from "../../utils/condition";
+import { EProvider, isAggregatorProvider, isSwapAPIProvider, } from "../../types/metaAg";
+import { isSystemAddress } from "../../utils/sui";
 import { SuiClientUtils } from "../../utils/SuiClientUtils";
-import { getExpectedReturn } from "../swap/buildTx";
-import { BluefinProvider } from "./providers/bluefin";
+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]: {},
@@ -39,10 +40,11 @@ export class MetaAg {
         if (p)
             return p;
         const providerOptions = this.options.providers[provider];
-        assert(!!providerOptions, `Provider not found: ${provider}`);
+        MetaAgError.assert(!!providerOptions, `Provider not found: ${provider}`, MetaAgErrorCode.PROVIDER_NOT_FOUND, { provider });
         switch (provider) {
             case EProvider.BLUEFIN7K:
-                this.providers[EProvider.BLUEFIN7K] = new BluefinProvider(providerOptions, this.options, this.client);
+                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));
@@ -52,69 +54,64 @@ export class MetaAg {
                 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 Error(`Provider not supported: ${provider}`);
+                throw new MetaAgError(`Provider not supported: ${provider}`, MetaAgErrorCode.PROVIDER_NOT_SUPPORTED, { provider });
         }
         return this.providers[provider];
     }
     async _simulate(provider, quote, simulation) {
         try {
-            const tx = new Transaction();
-            const id = quote.id;
-            const coinOut = await provider.swap({
-                quote,
-                coinIn: coinWithBalance({
-                    balance: BigInt(quote.amountIn),
-                    type: quote.coinTypeIn,
-                    useGasCoin: false,
-                }),
-                signer: simulation.sender,
-                tx,
-            });
-            tx.add(metaSettle(quote, coinOut, 10000, this.options.tipBps, this.options.partner, this.options.partnerCommissionBps));
-            tx.transferObjects([coinOut], simulation.sender);
-            const res = await timeout(() => this.inspector.devInspectTransactionBlock({
-                sender: simulation.sender,
-                transactionBlock: tx,
-            }), simulation.timeout ?? 2000, `simulation for ${provider.kind} provider with id ${id}`);
-            if (res.effects.status.status === "failure") {
-                throw new Error(res.error ?? "Simulation failed");
+            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 });
             }
-            const amountOut = extractAmountOutWrapper(res.events);
-            return {
-                id,
-                simulatedAmountOut: amountOut,
-                gasUsed: res.effects.gasUsed,
-                provider: provider.kind,
-            };
         }
         catch (error) {
-            console.warn(`Failed to simulate ${provider.kind}: `, error);
+            console.warn(error, { provider: provider.kind, quote: quote.id });
         }
     }
-    async _quote(provider, options, simulation) {
+    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.coinInType} to ${options.coinOutType}`);
-        if (simulation) {
-            if (simulation.onSimulated) {
-                this._simulate(provider, quote, simulation).then((payload) => {
-                    if (payload) {
-                        simulation.onSimulated?.(payload);
-                    }
-                });
-            }
-            else {
-                const updated = await this._simulate(provider, quote, simulation);
-                quote.simulatedAmountOut = updated?.simulatedAmountOut;
-                quote.gasUsed = updated?.gasUsed;
-            }
-        }
+        }, 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
@@ -124,35 +121,73 @@ export class MetaAg {
     async quote(options, simulation) {
         const opts = {
             ...options,
-            coinInType: normalizeStructTag(options.coinInType),
-            coinOutType: normalizeStructTag(options.coinOutType),
+            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, simulation);
+            return this._quote(p, opts);
         }));
-        return quotes
+        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);
-        assert(!!provider, `Provider not found: ${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
@@ -185,71 +220,15 @@ export class MetaAg {
         }
     }
 }
-/**
- * this settlement does not charge commission fee for partner, since all integrated aggregators already charge commission fee for partner
- * @param quote Meta Aggregator Quote
- * @param coinOut Coin Out Object
- * @param slippageBps Slippage Bps
- * @param tipBps Tip Bps default = 0
- * @param partner address of partner for analytic default is zero address
- */
-const metaSettle = (quote, coinOut, slippageBps = 100, tipBps = 0, partner, commissionBps = 0) => {
-    return (tx) => {
-        const { minAmount, expectedAmount } = getExpectedReturn(quote.rawAmountOut, slippageBps, commissionBps, tipBps);
-        if (tipBps > 0) {
-            tx.moveCall({
-                target: `${_7K_META_PUBLISHED_AT}::vault::collect_tip`,
-                typeArguments: [quote.coinTypeOut],
-                arguments: [
-                    tx.object(_7K_META_VAULT),
-                    tx.object(_7K_META_CONFIG),
-                    coinOut,
-                    tx.pure.u64(tipBps),
-                ],
-            });
-        }
-        tx.moveCall({
-            target: `${_7K_META_PUBLISHED_AT}::settle::settle`,
-            typeArguments: [quote.coinTypeIn, quote.coinTypeOut],
-            arguments: [
-                tx.object(_7K_META_CONFIG),
-                tx.object(_7K_META_VAULT),
-                tx.pure.u64(quote.amountIn),
-                coinOut,
-                tx.pure.u64(minAmount),
-                tx.pure.u64(expectedAmount),
-                tx.pure.option("address", partner),
-                tx.pure.u64(commissionBps),
-                tx.pure.u64(0), // ps
-            ],
-        });
-    };
-};
-const extractAmountOutWrapper = (events) => {
-    const swapEvent = events
-        .filter((event) => event.type === `${_7K_META_PACKAGE_ID}::settle::Swap`)
-        ?.pop();
-    return swapEvent?.parsedJson?.amount_out;
-};
 const catchImportError = (provider) => {
     return (e) => {
         const map = {
             [EProvider.CETUS]: "@cetusprotocol/aggregator-sdk",
             [EProvider.FLOWX]: "@flowx-finance/sdk",
-            [EProvider.BLUEFIN7K]: "@7kprotocol/sdk-ts",
+            [EProvider.BLUEFIN7K]: "@bluefin-exchange/bluefin7k-aggregator-sdk",
+            [EProvider.OKX]: "",
         };
         console.warn(`Please install ${map[provider]} to use ${provider} provider`);
         throw e;
     };
 };
-const timeout = async (fn, timeout, msg) => {
-    if (timeout <= 0)
-        return fn();
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new Error(`Timeout ${msg ?? "operation"}`)), timeout);
-        fn()
-            .then(resolve)
-            .catch(reject)
-            .finally(() => clearTimeout(timer));
-    });
-};

package/lib/esm/features/metaAg/providers/{bluefin.js → bluefin7k.js}

@@ -1,40 +1,29 @@
-import { SuiPriceServiceConnection, SuiPythClient, } from "@pythnetwork/pyth-sui-js";
+import { buildTx, Config, getQuote, } from "@bluefin-exchange/bluefin7k-aggregator-sdk";
 import { v4 } from "uuid";
-import { Config } from "../../../config";
 import { _7K_PARTNER_ADDRESS } from "../../../constants/_7k";
-import { API_ENDPOINTS } from "../../../constants/apiEndpoints";
 import { EProvider, } from "../../../types/metaAg";
-import { assert } from "../../../utils/condition";
-import { buildTxV2 } from "../../swap/buildTxV2";
-import { getQuote } from "../../swap/getQuote";
-const WORMHOLE_STATE_ID = "0xaeab97f96cf9877fee2883315d459552b2b921edc16d7ceac6eab944dd88919c";
-const PYTH_STATE_ID = "0x1f9310238ee9298fb703c3419030b35b22bb1cc37113e3bb5007c99aec79e5b8";
-export class BluefinProvider {
+import { MetaAgError, MetaAgErrorCode } from "../error";
+export class Bluefin7kProvider {
     options;
     metaOptions;
     kind = EProvider.BLUEFIN7K;
     constructor(options, metaOptions, client) {
         this.options = options;
         this.metaOptions = metaOptions;
-        const pythClient = new SuiPythClient(client, PYTH_STATE_ID, WORMHOLE_STATE_ID);
-        const pythConnection = new SuiPriceServiceConnection(this.metaOptions.hermesApi);
         if (options.apiKey)
             Config.setApiKey(options.apiKey);
         Config.setSuiClient(client);
-        Config.setPythClient(pythClient);
-        Config.setPythConnection(pythConnection);
     }
-    async quote(options) {
+    async quote(quoteOptions) {
         const quote = await getQuote({
-            amountIn: options.amountIn,
-            tokenIn: options.coinInType,
-            tokenOut: options.coinOutType,
-            api: this.options.api || API_ENDPOINTS.MAIN,
+            tokenIn: quoteOptions.coinTypeIn,
+            tokenOut: quoteOptions.coinTypeOut,
+            amountIn: quoteOptions.amountIn,
             sources: this.options.sources,
-            maxPaths: this.options.maxPaths,
             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,
@@ -42,13 +31,13 @@ export class BluefinProvider {
             amountIn: quote.swapAmountWithDecimal,
             rawAmountOut: quote.returnAmountWithDecimal,
             amountOut: quote.returnAmountWithDecimal,
-            coinTypeIn: options.coinInType,
-            coinTypeOut: options.coinOutType,
+            coinTypeIn: quoteOptions.coinTypeIn,
+            coinTypeOut: quoteOptions.coinTypeOut,
         };
     }
     async swap({ quote, signer, tx, coinIn }) {
-        assert(quote.provider === EProvider.BLUEFIN7K, "Invalid quote");
-        const { coinOut } = await buildTxV2({
+        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: {

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

@@ -2,7 +2,7 @@ import { AggregatorClient, Env } from "@cetusprotocol/aggregator-sdk";
 import { v4 } from "uuid";
 import { _7K_PARTNER_ADDRESS } from "../../../constants/_7k";
 import { EProvider, } from "../../../types/metaAg";
-import { assert } from "../../../utils/condition";
+import { MetaAgError, MetaAgErrorCode } from "../error";
 export class CetusProvider {
     options;
     kind = EProvider.CETUS;
@@ -23,8 +23,8 @@ export class CetusProvider {
         const quote = await this.cetusClient.findRouters({
             amount: quoteOptions.amountIn,
             byAmountIn: true,
-            from: quoteOptions.coinInType,
-            target: quoteOptions.coinOutType,
+            from: quoteOptions.coinTypeIn,
+            target: quoteOptions.coinTypeOut,
             providers: this.options.sources,
             splitCount: this.options.splitCount,
             splitAlgorithm: this.options.splitAlgorithm,
@@ -32,7 +32,7 @@ export class CetusProvider {
             depth: this.options.depth,
             liquidityChanges: this.options.liquidityChanges,
         });
-        assert(!!quote, "No quote found");
+        MetaAgError.assert(!!quote, "No quote found", MetaAgErrorCode.QUOTE_NOT_FOUND, { provider: this.kind });
         return {
             id: v4(),
             provider: EProvider.CETUS,
@@ -40,12 +40,12 @@ export class CetusProvider {
             amountIn: quote.amountIn.toString() || "0",
             rawAmountOut: quote.amountOut.toString() || "0",
             amountOut: quote.amountOut.toString() || "0",
-            coinTypeIn: quoteOptions.coinInType,
-            coinTypeOut: quoteOptions.coinOutType,
+            coinTypeIn: quoteOptions.coinTypeIn,
+            coinTypeOut: quoteOptions.coinTypeOut,
         };
     }
     async swap(options) {
-        assert(options.quote.provider === EProvider.CETUS, "Expect Cetus quote");
+        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,

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

@@ -2,7 +2,7 @@ import { AggregatorQuoter, Commission, CommissionType, TradeBuilder, } from "@fl
 import { v4 } from "uuid";
 import { _7K_PARTNER_ADDRESS } from "../../../constants/_7k";
 import { EProvider, } from "../../../types/metaAg";
-import { assert } from "../../../utils/condition";
+import { MetaAgError, MetaAgErrorCode } from "../error";
 export class FlowxProvider {
     options;
     client;
@@ -16,8 +16,8 @@ export class FlowxProvider {
     async quote(quoteOptions) {
         const quote = await this.quoter.getRoutes({
             amountIn: quoteOptions.amountIn,
-            tokenIn: quoteOptions.coinInType,
-            tokenOut: quoteOptions.coinOutType,
+            tokenIn: quoteOptions.coinTypeIn,
+            tokenOut: quoteOptions.coinTypeOut,
             includeSources: this.options.sources,
             excludePools: this.options.excludePools,
             excludeSources: this.options.excludeSources,
@@ -31,12 +31,12 @@ export class FlowxProvider {
             amountIn: quote.amountIn?.toString() ?? "0",
             rawAmountOut: quote.amountOut?.toString() ?? "0",
             amountOut: quote.amountOut?.toString() ?? "0",
-            coinTypeIn: quoteOptions.coinInType,
-            coinTypeOut: quoteOptions.coinOutType,
+            coinTypeIn: quoteOptions.coinTypeIn,
+            coinTypeOut: quoteOptions.coinTypeOut,
         };
     }
     async swap(options) {
-        assert(options.quote.provider === EProvider.FLOWX, "Invalid quote");
+        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);

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

@@ -0,0 +1,147 @@
+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,
+    };
+};