@7kprotocol/sdk-ts 3.5.2 → 3.6.0

package/lib/cjs/config/index.js

@@ -6,6 +6,7 @@ const pyth_sui_js_1 = require("@pythnetwork/pyth-sui-js");
 const HERMES_API = "https://hermes.pyth.network";
 const WORMHOLE_STATE_ID = "0xaeab97f96cf9877fee2883315d459552b2b921edc16d7ceac6eab944dd88919c";
 const PYTH_STATE_ID = "0x1f9310238ee9298fb703c3419030b35b22bb1cc37113e3bb5007c99aec79e5b8";
+let api = "";
 let apiKey = "";
 let bluefinXApiKey = "";
 let suiClient = new client_1.SuiClient({
@@ -13,6 +14,12 @@ let suiClient = new client_1.SuiClient({
 });
 let pythClient = new pyth_sui_js_1.SuiPythClient(suiClient, PYTH_STATE_ID, WORMHOLE_STATE_ID);
 let pythConnection = new pyth_sui_js_1.SuiPriceServiceConnection(HERMES_API);
+function setApi(url) {
+    api = url;
+}
+function getApi() {
+    return api;
+}
 function setApiKey(key) {
     apiKey = key;
 }
@@ -44,6 +51,8 @@ function getPythConnection() {
     return pythConnection;
 }
 const Config = {
+    setApi,
+    getApi,
     setApiKey,
     getApiKey,
     setBluefinXApiKey,

package/lib/cjs/constants/apiEndpoints.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.API_ENDPOINTS = void 0;
 exports.API_ENDPOINTS = {
-    MAIN: "https://aggregator.api.sui-prod.bluefin.io",
+    MAIN: "https://api.7k.ag",
     LO_DCA: "https://lod-dca.7k.ag",
     PRICES: "https://prices.7k.ag",
     STATISTIC: "https://statistic.7k.ag",

package/lib/cjs/features/metaAg/common.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeout = exports.metaSettle = exports.simulateAggregator = exports.simulateSwapTx = void 0;
+const transactions_1 = require("@mysten/sui/transactions");
+const _7k_1 = require("../../constants/_7k");
+const buildTx_1 = require("../swap/buildTx");
+const error_1 = require("./error");
+const simulateSwapTx = async (tx, inspector, simulation) => {
+    const res = await (0, exports.timeout)(() => inspector.devInspectTransactionBlock({
+        sender: simulation.sender,
+        transactionBlock: tx,
+    }), simulation.timeout ?? 2000);
+    if (res.effects.status.status === "failure") {
+        throw new error_1.MetaAgError(res.error ?? "Simulation failed", error_1.MetaAgErrorCode.SIMULATION_FAILED, { error: res.error });
+    }
+    const amountOut = extractAmountOutWrapper(res.events);
+    return {
+        simulatedAmountOut: amountOut,
+        gasUsed: res.effects.gasUsed,
+    };
+};
+exports.simulateSwapTx = simulateSwapTx;
+const simulateAggregator = async (provider, quote, simulation, inspector, options) => {
+    const tx = new transactions_1.Transaction();
+    const coinOut = await provider.swap({
+        quote,
+        coinIn: (0, transactions_1.coinWithBalance)({
+            balance: BigInt(quote.amountIn),
+            type: quote.coinTypeIn,
+            useGasCoin: false,
+        }),
+        signer: simulation.sender,
+        tx,
+    });
+    tx.add((0, exports.metaSettle)(quote, coinOut, 10000, options.tipBps, options.partner, options.partnerCommissionBps));
+    tx.transferObjects([coinOut], simulation.sender);
+    const res = await (0, exports.simulateSwapTx)(tx, inspector, simulation);
+    return {
+        id: quote.id,
+        provider: provider.kind,
+        ...res,
+    };
+};
+exports.simulateAggregator = simulateAggregator;
+/**
+ * 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 } = (0, buildTx_1.getExpectedReturn)(quote.rawAmountOut, slippageBps, commissionBps, tipBps);
+        if (tipBps > 0) {
+            tx.moveCall({
+                target: `${_7k_1._7K_META_PUBLISHED_AT}::vault::collect_tip`,
+                typeArguments: [quote.coinTypeOut],
+                arguments: [
+                    tx.object(_7k_1._7K_META_VAULT),
+                    tx.object(_7k_1._7K_META_CONFIG),
+                    coinOut,
+                    tx.pure.u64(tipBps),
+                ],
+            });
+        }
+        tx.moveCall({
+            target: `${_7k_1._7K_META_PUBLISHED_AT}::settle::settle`,
+            typeArguments: [quote.coinTypeIn, quote.coinTypeOut],
+            arguments: [
+                tx.object(_7k_1._7K_META_CONFIG),
+                tx.object(_7k_1._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
+            ],
+        });
+    };
+};
+exports.metaSettle = metaSettle;
+const extractAmountOutWrapper = (events) => {
+    const swapEvent = events
+        .filter((event) => event.type === `${_7k_1._7K_META_PACKAGE_ID}::settle::Swap`)
+        ?.pop();
+    return swapEvent?.parsedJson?.amount_out;
+};
+const timeout = async (fn, timeout, msg) => {
+    if (timeout <= 0)
+        return fn();
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new error_1.MetaAgError(`Timeout ${msg ?? "operation"}`, error_1.MetaAgErrorCode.TIMEOUT, { timeout })), timeout);
+        fn()
+            .then(resolve)
+            .catch(reject)
+            .finally(() => clearTimeout(timer));
+    });
+};
+exports.timeout = timeout;

package/lib/cjs/features/metaAg/error.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetaAgError = exports.MetaAgErrorCode = void 0;
+var MetaAgErrorCode;
+(function (MetaAgErrorCode) {
+    MetaAgErrorCode[MetaAgErrorCode["UNKNOWN"] = 1000] = "UNKNOWN";
+    MetaAgErrorCode[MetaAgErrorCode["TIMEOUT"] = 1001] = "TIMEOUT";
+    MetaAgErrorCode[MetaAgErrorCode["PROVIDER_NOT_FOUND"] = 1002] = "PROVIDER_NOT_FOUND";
+    MetaAgErrorCode[MetaAgErrorCode["PROVIDER_NOT_SUPPORTED"] = 1003] = "PROVIDER_NOT_SUPPORTED";
+    MetaAgErrorCode[MetaAgErrorCode["INVALID_QUOTE"] = 1004] = "INVALID_QUOTE";
+    MetaAgErrorCode[MetaAgErrorCode["QUOTE_NOT_FOUND"] = 1005] = "QUOTE_NOT_FOUND";
+    MetaAgErrorCode[MetaAgErrorCode["INVALID_SIGNER_ADDRESS"] = 1006] = "INVALID_SIGNER_ADDRESS";
+    MetaAgErrorCode[MetaAgErrorCode["PROVIDER_NOT_SUPPORT_SWAP"] = 1007] = "PROVIDER_NOT_SUPPORT_SWAP";
+    MetaAgErrorCode[MetaAgErrorCode["SIMULATION_FAILED"] = 1008] = "SIMULATION_FAILED";
+    // OKX error
+    MetaAgErrorCode[MetaAgErrorCode["OKX_FINALIZE_COMMAND_NOT_FOUND"] = 1100] = "OKX_FINALIZE_COMMAND_NOT_FOUND";
+    // BluefinX error
+    MetaAgErrorCode[MetaAgErrorCode["BLUEFINX_TRANSACTION_NOT_FOUND"] = 1200] = "BLUEFINX_TRANSACTION_NOT_FOUND";
+    MetaAgErrorCode[MetaAgErrorCode["BLUEFINX_TRANSACTION_NOT_APPROVED"] = 1201] = "BLUEFINX_TRANSACTION_NOT_APPROVED";
+    MetaAgErrorCode[MetaAgErrorCode["BLUEFINX_TRANSACTION_DIGEST_NOT_FOUND"] = 1202] = "BLUEFINX_TRANSACTION_DIGEST_NOT_FOUND";
+})(MetaAgErrorCode || (exports.MetaAgErrorCode = MetaAgErrorCode = {}));
+class MetaAgError extends Error {
+    constructor(message, code, details) {
+        super(message);
+        this.name = "MetaAgError";
+        this.code = code ?? MetaAgErrorCode.UNKNOWN;
+        this.details = details;
+    }
+    static assert(condition, message, code, details) {
+        if (!condition) {
+            throw new MetaAgError(message ?? "Assertion failed", code, details);
+        }
+    }
+}
+exports.MetaAgError = MetaAgError;

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

@@ -37,13 +37,15 @@ exports.MetaAg = void 0;
 const client_1 = require("@mysten/sui/client");
 const transactions_1 = require("@mysten/sui/transactions");
 const utils_1 = require("@mysten/sui/utils");
-const _7k_1 = require("../../constants/_7k");
 const sui_1 = require("../../constants/sui");
 const metaAg_1 = require("../../types/metaAg");
-const condition_1 = require("../../utils/condition");
+const sui_2 = require("../../utils/sui");
 const SuiClientUtils_1 = require("../../utils/SuiClientUtils");
 const buildTx_1 = require("../swap/buildTx");
-const bluefin_1 = require("./providers/bluefin");
+const common_1 = require("./common");
+const error_1 = require("./error");
+const bluefin7kLegacy_1 = require("./providers/bluefin7kLegacy");
+const okx_1 = require("./providers/okx");
 const HERMES_API = "https://hermes.pyth.network";
 const DEFAULT_PROVIDERS = {
     [metaAg_1.EProvider.BLUEFIN7K]: {},
@@ -72,10 +74,14 @@ class MetaAg {
         if (p)
             return p;
         const providerOptions = this.options.providers[provider];
-        (0, condition_1.assert)(!!providerOptions, `Provider not found: ${provider}`);
+        error_1.MetaAgError.assert(!!providerOptions, `Provider not found: ${provider}`, error_1.MetaAgErrorCode.PROVIDER_NOT_FOUND, { provider });
         switch (provider) {
+            case metaAg_1.EProvider.BLUEFIN7K_LEGACY:
+                this.providers[metaAg_1.EProvider.BLUEFIN7K_LEGACY] = new bluefin7kLegacy_1.BluefinLegacyProvider(providerOptions, this.options, this.client);
+                break;
             case metaAg_1.EProvider.BLUEFIN7K:
-                this.providers[metaAg_1.EProvider.BLUEFIN7K] = new bluefin_1.BluefinProvider(providerOptions, this.options, this.client);
+                const { Bluefin7kProvider } = await Promise.resolve().then(() => __importStar(require("./providers/bluefin7k"))).catch(catchImportError(metaAg_1.EProvider.BLUEFIN7K));
+                this.providers[metaAg_1.EProvider.BLUEFIN7K] = new Bluefin7kProvider(providerOptions, this.options, this.client);
                 break;
             case metaAg_1.EProvider.FLOWX:
                 const { FlowxProvider } = await Promise.resolve().then(() => __importStar(require("./providers/flowx"))).catch(catchImportError(metaAg_1.EProvider.FLOWX));
@@ -85,69 +91,64 @@ class MetaAg {
                 const { CetusProvider } = await Promise.resolve().then(() => __importStar(require("./providers/cetus"))).catch(catchImportError(metaAg_1.EProvider.CETUS));
                 this.providers[metaAg_1.EProvider.CETUS] = new CetusProvider(providerOptions, this.options, this.client);
                 break;
+            case metaAg_1.EProvider.OKX:
+                this.providers[metaAg_1.EProvider.OKX] = new okx_1.OkxProvider(providerOptions, this.options, this.client);
+                break;
             default:
-                throw new Error(`Provider not supported: ${provider}`);
+                throw new error_1.MetaAgError(`Provider not supported: ${provider}`, error_1.MetaAgErrorCode.PROVIDER_NOT_SUPPORTED, { provider });
         }
         return this.providers[provider];
     }
     async _simulate(provider, quote, simulation) {
         try {
-            const tx = new transactions_1.Transaction();
-            const id = quote.id;
-            const coinOut = await provider.swap({
-                quote,
-                coinIn: (0, transactions_1.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 ((0, metaAg_1.isAggregatorProvider)(provider)) {
+                return (0, common_1.simulateAggregator)(provider, quote, simulation, this.inspector, this.options);
+            }
+            switch (quote.provider) {
+                case metaAg_1.EProvider.OKX:
+                    return (0, okx_1.simulateOKXSwap)(quote, this.inspector, simulation, this.options);
+                default:
+                    throw new error_1.MetaAgError(`Provider not supported: ${provider.kind}`, error_1.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) {
-        const quote = await timeout(async () => {
+    async _quote(provider, options) {
+        const quote = await (0, common_1.timeout)(async () => {
             const quote = await provider.quote(options);
+            if (!quote)
+                return null;
             const { expectedAmount } = (0, buildTx_1.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 transactions_1.Transaction();
+        const coin = await this.swap({
+            quote,
+            signer,
+            tx,
+            coinIn: (0, transactions_1.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((0, utils_1.toBase64)(txBytes));
+        return this.client.executeTransactionBlock({
+            transactionBlock: bytes,
+            signature,
+            options: getTransactionBlockParams?.options,
+            signal: getTransactionBlockParams?.signal,
+        });
+    }
     /**
      * Get quotes from all providers
      * @param options - quote options
@@ -157,35 +158,73 @@ class MetaAg {
     async quote(options, simulation) {
         const opts = {
             ...options,
-            coinInType: (0, utils_1.normalizeStructTag)(options.coinInType),
-            coinOutType: (0, utils_1.normalizeStructTag)(options.coinOutType),
+            coinTypeIn: (0, utils_1.normalizeStructTag)(options.coinTypeIn),
+            coinTypeOut: (0, utils_1.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: BluefinX, 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);
-        (0, condition_1.assert)(!!provider, `Provider not found: ${options.quote.provider}`);
+        error_1.MetaAgError.assert(!!provider, `Provider not found: ${options.quote.provider}`, error_1.MetaAgErrorCode.PROVIDER_NOT_FOUND, { provider: options.quote.provider });
+        error_1.MetaAgError.assert((0, metaAg_1.isAggregatorProvider)(provider), `Provider does not support swap: ${provider.kind}, use fastSwap instead`, error_1.MetaAgErrorCode.PROVIDER_NOT_SUPPORT_SWAP, { provider: provider.kind });
+        error_1.MetaAgError.assert(!(0, sui_2.isSystemAddress)(options.signer), "Invalid signer address", error_1.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.add((0, common_1.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) {
+        error_1.MetaAgError.assert(!(0, sui_2.isSystemAddress)(options.signer), "Invalid signer address", error_1.MetaAgErrorCode.INVALID_SIGNER_ADDRESS, { signer: options.signer });
+        const provider = await this._getProvider(options.quote.provider);
+        if ((0, metaAg_1.isAggregatorProvider)(provider)) {
+            return this._fastSwap(options, getTransactionBlockParams);
+        }
+        else if ((0, metaAg_1.isSwapAPIProvider)(provider)) {
+            return this.client.waitForTransaction({
+                ...getTransactionBlockParams,
+                digest: await provider.fastSwap(options),
+            });
+        }
+        else {
+            throw new error_1.MetaAgError(`Provider not supported: ${provider.kind}`, error_1.MetaAgErrorCode.PROVIDER_NOT_SUPPORTED, { provider: provider.kind });
+        }
+    }
     /**
      * Update meta aggregator options
      * @param options - update options payload
@@ -219,71 +258,16 @@ class MetaAg {
     }
 }
 exports.MetaAg = 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 } = (0, buildTx_1.getExpectedReturn)(quote.rawAmountOut, slippageBps, commissionBps, tipBps);
-        if (tipBps > 0) {
-            tx.moveCall({
-                target: `${_7k_1._7K_META_PUBLISHED_AT}::vault::collect_tip`,
-                typeArguments: [quote.coinTypeOut],
-                arguments: [
-                    tx.object(_7k_1._7K_META_VAULT),
-                    tx.object(_7k_1._7K_META_CONFIG),
-                    coinOut,
-                    tx.pure.u64(tipBps),
-                ],
-            });
-        }
-        tx.moveCall({
-            target: `${_7k_1._7K_META_PUBLISHED_AT}::settle::settle`,
-            typeArguments: [quote.coinTypeIn, quote.coinTypeOut],
-            arguments: [
-                tx.object(_7k_1._7K_META_CONFIG),
-                tx.object(_7k_1._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_1._7K_META_PACKAGE_ID}::settle::Swap`)
-        ?.pop();
-    return swapEvent?.parsedJson?.amount_out;
-};
 const catchImportError = (provider) => {
     return (e) => {
         const map = {
             [metaAg_1.EProvider.CETUS]: "@cetusprotocol/aggregator-sdk",
             [metaAg_1.EProvider.FLOWX]: "@flowx-finance/sdk",
-            [metaAg_1.EProvider.BLUEFIN7K]: "@7kprotocol/sdk-ts",
+            [metaAg_1.EProvider.BLUEFIN7K_LEGACY]: "@7kprotocol/sdk-ts",
+            [metaAg_1.EProvider.BLUEFIN7K]: "@bluefin-exchange/bluefin7k-aggregator-sdk",
+            [metaAg_1.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/cjs/features/metaAg/providers/bluefin7k.js

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

package/lib/cjs/features/metaAg/providers/{bluefin.js → bluefin7kLegacy.js}

@@ -1,26 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BluefinProvider = void 0;
+exports.BluefinLegacyProvider = void 0;
 const pyth_sui_js_1 = require("@pythnetwork/pyth-sui-js");
 const uuid_1 = require("uuid");
 const config_1 = require("../../../config");
 const _7k_1 = require("../../../constants/_7k");
-const apiEndpoints_1 = require("../../../constants/apiEndpoints");
 const metaAg_1 = require("../../../types/metaAg");
-const condition_1 = require("../../../utils/condition");
 const buildTxV2_1 = require("../../swap/buildTxV2");
 const getQuote_1 = require("../../swap/getQuote");
+const error_1 = require("../error");
 const WORMHOLE_STATE_ID = "0xaeab97f96cf9877fee2883315d459552b2b921edc16d7ceac6eab944dd88919c";
 const PYTH_STATE_ID = "0x1f9310238ee9298fb703c3419030b35b22bb1cc37113e3bb5007c99aec79e5b8";
-class BluefinProvider {
+class BluefinLegacyProvider {
     constructor(options, metaOptions, client) {
         this.options = options;
         this.metaOptions = metaOptions;
-        this.kind = metaAg_1.EProvider.BLUEFIN7K;
+        this.kind = metaAg_1.EProvider.BLUEFIN7K_LEGACY;
         const pythClient = new pyth_sui_js_1.SuiPythClient(client, PYTH_STATE_ID, WORMHOLE_STATE_ID);
         const pythConnection = new pyth_sui_js_1.SuiPriceServiceConnection(this.metaOptions.hermesApi);
         if (options.apiKey)
             config_1.Config.setApiKey(options.apiKey);
+        if (options.api)
+            config_1.Config.setApi(options.api);
         config_1.Config.setSuiClient(client);
         config_1.Config.setPythClient(pythClient);
         config_1.Config.setPythConnection(pythConnection);
@@ -28,9 +29,8 @@ class BluefinProvider {
     async quote(options) {
         const quote = await (0, getQuote_1.getQuote)({
             amountIn: options.amountIn,
-            tokenIn: options.coinInType,
-            tokenOut: options.coinOutType,
-            api: this.options.api || apiEndpoints_1.API_ENDPOINTS.MAIN,
+            tokenIn: options.coinTypeIn,
+            tokenOut: options.coinTypeOut,
             sources: this.options.sources,
             maxPaths: this.options.maxPaths,
             excludedPools: this.options.excludedPools,
@@ -38,17 +38,17 @@ class BluefinProvider {
         });
         return {
             id: (0, uuid_1.v4)(),
-            provider: metaAg_1.EProvider.BLUEFIN7K,
+            provider: metaAg_1.EProvider.BLUEFIN7K_LEGACY,
             quote,
             amountIn: quote.swapAmountWithDecimal,
             rawAmountOut: quote.returnAmountWithDecimal,
             amountOut: quote.returnAmountWithDecimal,
-            coinTypeIn: options.coinInType,
-            coinTypeOut: options.coinOutType,
+            coinTypeIn: options.coinTypeIn,
+            coinTypeOut: options.coinTypeOut,
         };
     }
     async swap({ quote, signer, tx, coinIn }) {
-        (0, condition_1.assert)(quote.provider === metaAg_1.EProvider.BLUEFIN7K, "Invalid quote");
+        error_1.MetaAgError.assert(quote.provider === metaAg_1.EProvider.BLUEFIN7K_LEGACY, "Invalid quote", error_1.MetaAgErrorCode.INVALID_QUOTE, { quote, expectedProvider: metaAg_1.EProvider.BLUEFIN7K_LEGACY });
         const { coinOut } = await (0, buildTxV2_1.buildTxV2)({
             quoteResponse: quote.quote,
             accountAddress: signer,
@@ -65,4 +65,4 @@ class BluefinProvider {
         return coinOut;
     }
 }
-exports.BluefinProvider = BluefinProvider;
+exports.BluefinLegacyProvider = BluefinLegacyProvider;

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

@@ -5,7 +5,7 @@ const aggregator_sdk_1 = require("@cetusprotocol/aggregator-sdk");
 const uuid_1 = require("uuid");
 const _7k_1 = require("../../../constants/_7k");
 const metaAg_1 = require("../../../types/metaAg");
-const condition_1 = require("../../../utils/condition");
+const error_1 = require("../error");
 class CetusProvider {
     constructor(options, metaOptions, client) {
         this.options = options;
@@ -24,8 +24,8 @@ 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,
@@ -33,7 +33,7 @@ class CetusProvider {
             depth: this.options.depth,
             liquidityChanges: this.options.liquidityChanges,
         });
-        (0, condition_1.assert)(!!quote, "No quote found");
+        error_1.MetaAgError.assert(!!quote, "No quote found", error_1.MetaAgErrorCode.QUOTE_NOT_FOUND, { provider: this.kind });
         return {
             id: (0, uuid_1.v4)(),
             provider: metaAg_1.EProvider.CETUS,
@@ -41,12 +41,12 @@ 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) {
-        (0, condition_1.assert)(options.quote.provider === metaAg_1.EProvider.CETUS, "Expect Cetus quote");
+        error_1.MetaAgError.assert(options.quote.provider === metaAg_1.EProvider.CETUS, "Expect Cetus quote", error_1.MetaAgErrorCode.INVALID_QUOTE, { quote: options.quote, expectedProvider: metaAg_1.EProvider.CETUS });
         const coinOut = await this.cetusClient.routerSwap({
             inputCoin: options.coinIn,
             router: options.quote.quote,