@7kprotocol/sdk-ts 3.4.2-beta.4 → 3.4.2-beta.6

package/lib/cjs/utils/ObjectCache.js

@@ -0,0 +1,273 @@
+"use strict";
+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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _InMemoryObjectCache_caches, _CustomObjectCache_client, _CustomObjectCache_cache, _CustomObjectCache_onEffects;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomObjectCache = exports.InMemoryObjectCache = exports.AsyncCache = void 0;
+const utils_1 = require("@mysten/sui/utils");
+class AsyncCache {
+    async getObject(id) {
+        const [owned, shared] = await Promise.all([
+            this.get("OwnedObject", id),
+            this.get("SharedOrImmutableObject", id),
+        ]);
+        return owned ?? shared ?? null;
+    }
+    async getObjects(ids) {
+        return Promise.all(ids.map((id) => this.getObject(id)));
+    }
+    async addObject(object) {
+        if (object.owner) {
+            await this.set("OwnedObject", object.objectId, object);
+        }
+        else {
+            await this.set("SharedOrImmutableObject", object.objectId, object);
+        }
+        return object;
+    }
+    async addObjects(objects) {
+        await Promise.all(objects.map(async (object) => this.addObject(object)));
+    }
+    async deleteObject(id) {
+        await Promise.all([
+            this.delete("OwnedObject", id),
+            this.delete("SharedOrImmutableObject", id),
+        ]);
+    }
+    async deleteObjects(ids) {
+        await Promise.all(ids.map((id) => this.deleteObject(id)));
+    }
+    async getMoveFunctionDefinition(ref) {
+        const functionName = `${(0, utils_1.normalizeSuiAddress)(ref.package)}::${ref.module}::${ref.function}`;
+        return this.get("MoveFunction", functionName);
+    }
+    async addMoveFunctionDefinition(functionEntry) {
+        const pkg = (0, utils_1.normalizeSuiAddress)(functionEntry.package);
+        const functionName = `${pkg}::${functionEntry.module}::${functionEntry.function}`;
+        const entry = {
+            ...functionEntry,
+            package: pkg,
+        };
+        await this.set("MoveFunction", functionName, entry);
+        return entry;
+    }
+    async deleteMoveFunctionDefinition(ref) {
+        const functionName = `${(0, utils_1.normalizeSuiAddress)(ref.package)}::${ref.module}::${ref.function}`;
+        await this.delete("MoveFunction", functionName);
+    }
+    async getCustom(key) {
+        return this.get("Custom", key);
+    }
+    async setCustom(key, value) {
+        return this.set("Custom", key, value);
+    }
+    async deleteCustom(key) {
+        return this.delete("Custom", key);
+    }
+}
+exports.AsyncCache = AsyncCache;
+class InMemoryObjectCache extends AsyncCache {
+    constructor() {
+        super(...arguments);
+        _InMemoryObjectCache_caches.set(this, {
+            OwnedObject: new Map(),
+            SharedOrImmutableObject: new Map(),
+            MoveFunction: new Map(),
+            Custom: new Map(),
+        });
+    }
+    async get(type, key) {
+        return __classPrivateFieldGet(this, _InMemoryObjectCache_caches, "f")[type].get(key) ?? null;
+    }
+    async set(type, key, value) {
+        __classPrivateFieldGet(this, _InMemoryObjectCache_caches, "f")[type].set(key, value);
+    }
+    async delete(type, key) {
+        __classPrivateFieldGet(this, _InMemoryObjectCache_caches, "f")[type].delete(key);
+    }
+    async clear(type) {
+        if (type) {
+            __classPrivateFieldGet(this, _InMemoryObjectCache_caches, "f")[type].clear();
+        }
+        else {
+            for (const cache of Object.values(__classPrivateFieldGet(this, _InMemoryObjectCache_caches, "f"))) {
+                cache.clear();
+            }
+        }
+    }
+}
+exports.InMemoryObjectCache = InMemoryObjectCache;
+_InMemoryObjectCache_caches = new WeakMap();
+class CustomObjectCache {
+    constructor({ cache = new InMemoryObjectCache(), onEffects, client, }) {
+        _CustomObjectCache_client.set(this, void 0);
+        _CustomObjectCache_cache.set(this, void 0);
+        _CustomObjectCache_onEffects.set(this, void 0);
+        __classPrivateFieldSet(this, _CustomObjectCache_client, client, "f");
+        __classPrivateFieldSet(this, _CustomObjectCache_cache, cache, "f");
+        __classPrivateFieldSet(this, _CustomObjectCache_onEffects, onEffects, "f");
+    }
+    async applyCache(transactionData, unresolvedObjects) {
+        const cached = (await __classPrivateFieldGet(this, _CustomObjectCache_cache, "f").getObjects(unresolvedObjects)).filter((obj) => obj !== null);
+        const byId = new Map(cached.map((obj) => [obj.objectId, obj]));
+        const unresolved = [];
+        for (const input of transactionData.inputs) {
+            if (!input.UnresolvedObject) {
+                continue;
+            }
+            const cached = byId.get(input.UnresolvedObject.objectId);
+            if (!cached) {
+                unresolved.push(input.UnresolvedObject.objectId);
+                continue;
+            }
+            if (cached.initialSharedVersion &&
+                !input.UnresolvedObject.initialSharedVersion) {
+                input.UnresolvedObject.initialSharedVersion =
+                    cached.initialSharedVersion;
+            }
+            else {
+                if (cached.version && !input.UnresolvedObject.version) {
+                    input.UnresolvedObject.version = cached.version;
+                }
+                if (cached.digest && !input.UnresolvedObject.digest) {
+                    input.UnresolvedObject.digest = cached.digest;
+                }
+            }
+        }
+        return unresolved;
+    }
+    async resolveObjects(transactionData, unresolved) {
+        const unresolvedObjects = await this.applyCache(transactionData, unresolved);
+        if (unresolvedObjects.length === 0) {
+            return [];
+        }
+        const dedup = [...new Set(unresolvedObjects)];
+        const res = await __classPrivateFieldGet(this, _CustomObjectCache_client, "f").multiGetObjects({
+            ids: dedup,
+            options: {
+                showOwner: true,
+            },
+        });
+        const objects = [];
+        for (const obj of res || []) {
+            if (!obj.data) {
+                continue;
+            }
+            const owner = obj.data.owner;
+            const initialSharedVersion = owner && typeof owner === "object" && "Shared" in owner
+                ? owner.Shared.initial_shared_version
+                : null;
+            const ownerAddress = owner && typeof owner === "object" && "AddressOwner" in owner
+                ? owner.AddressOwner
+                : null;
+            const cached = {
+                objectId: obj.data.objectId,
+                version: obj.data.version,
+                digest: obj.data.digest,
+                initialSharedVersion,
+                owner: ownerAddress,
+            };
+            objects.push(cached);
+        }
+        await __classPrivateFieldGet(this, _CustomObjectCache_cache, "f").addObjects(objects);
+        return await this.applyCache(transactionData, unresolvedObjects);
+    }
+    asPlugin() {
+        return async (transactionData, _options, next) => {
+            const unresolvedObjects = transactionData.inputs
+                .filter((input) => input.UnresolvedObject)
+                .map((input) => input.UnresolvedObject.objectId);
+            // if object is not in cache yet, fetch from RPC and save to cache and resolve all objects
+            await this.resolveObjects(transactionData, unresolvedObjects);
+            await Promise.all(transactionData.commands.map(async (commands) => {
+                if (commands.MoveCall) {
+                    const def = await this.getMoveFunctionDefinition({
+                        package: commands.MoveCall.package,
+                        module: commands.MoveCall.module,
+                        function: commands.MoveCall.function,
+                    });
+                    if (def) {
+                        commands.MoveCall._argumentTypes = def.parameters;
+                    }
+                }
+            }));
+            await next();
+            await Promise.all(transactionData.commands.map(async (commands) => {
+                if (commands.MoveCall?._argumentTypes) {
+                    await __classPrivateFieldGet(this, _CustomObjectCache_cache, "f").addMoveFunctionDefinition({
+                        package: commands.MoveCall.package,
+                        module: commands.MoveCall.module,
+                        function: commands.MoveCall.function,
+                        parameters: commands.MoveCall._argumentTypes,
+                    });
+                }
+            }));
+        };
+    }
+    async clear() {
+        await __classPrivateFieldGet(this, _CustomObjectCache_cache, "f").clear();
+    }
+    async getMoveFunctionDefinition(ref) {
+        return __classPrivateFieldGet(this, _CustomObjectCache_cache, "f").getMoveFunctionDefinition(ref);
+    }
+    async getObjects(ids) {
+        return __classPrivateFieldGet(this, _CustomObjectCache_cache, "f").getObjects(ids);
+    }
+    async deleteObjects(ids) {
+        return __classPrivateFieldGet(this, _CustomObjectCache_cache, "f").deleteObjects(ids);
+    }
+    async clearOwnedObjects() {
+        await __classPrivateFieldGet(this, _CustomObjectCache_cache, "f").clear("OwnedObject");
+    }
+    async clearCustom() {
+        await __classPrivateFieldGet(this, _CustomObjectCache_cache, "f").clear("Custom");
+    }
+    async getCustom(key) {
+        return __classPrivateFieldGet(this, _CustomObjectCache_cache, "f").getCustom(key);
+    }
+    async setCustom(key, value) {
+        return __classPrivateFieldGet(this, _CustomObjectCache_cache, "f").setCustom(key, value);
+    }
+    async deleteCustom(key) {
+        return __classPrivateFieldGet(this, _CustomObjectCache_cache, "f").deleteCustom(key);
+    }
+    async applyEffects(effects) {
+        if (!effects.V2) {
+            throw new Error(`Unsupported transaction effects version ${effects.$kind}`);
+        }
+        const { lamportVersion, changedObjects } = effects.V2;
+        const deletedIds = [];
+        const addedObjects = [];
+        changedObjects.forEach(([id, change]) => {
+            if (change.outputState.NotExist) {
+                deletedIds.push(id);
+            }
+            else if (change.outputState.ObjectWrite) {
+                const [digest, owner] = change.outputState.ObjectWrite;
+                addedObjects.push({
+                    objectId: id,
+                    digest,
+                    version: lamportVersion,
+                    owner: owner.AddressOwner ?? owner.ObjectOwner ?? null,
+                    initialSharedVersion: owner.Shared?.initialSharedVersion ?? null,
+                });
+            }
+        });
+        await Promise.all([
+            __classPrivateFieldGet(this, _CustomObjectCache_cache, "f").addObjects(addedObjects),
+            __classPrivateFieldGet(this, _CustomObjectCache_cache, "f").deleteObjects(deletedIds),
+            __classPrivateFieldGet(this, _CustomObjectCache_onEffects, "f")?.call(this, effects),
+        ]);
+    }
+}
+exports.CustomObjectCache = CustomObjectCache;
+_CustomObjectCache_client = new WeakMap(), _CustomObjectCache_cache = new WeakMap(), _CustomObjectCache_onEffects = new WeakMap();

package/lib/cjs/utils/SuiClientUtils.js

@@ -0,0 +1,50 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+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 _SuiClientUtils_devInspectCache;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuiClientUtils = void 0;
+const transactions_1 = require("@mysten/sui/transactions");
+const ObjectCache_1 = require("./ObjectCache");
+/**
+ * Utility class for interacting with Sui blockchain coins
+ */
+class SuiClientUtils {
+    /**
+     * Creates a new instance of SuiClientUtils
+     * @param client - The Sui client instance to use for blockchain interactions
+     */
+    constructor(client) {
+        this.client = client;
+        _SuiClientUtils_devInspectCache.set(this, void 0);
+        this.devInspectTransactionBlock = async (params) => {
+            if (params.transactionBlock instanceof transactions_1.Transaction) {
+                params.transactionBlock.addBuildPlugin(__classPrivateFieldGet(this, _SuiClientUtils_devInspectCache, "f").asPlugin());
+            }
+            try {
+                const res = await this.client.devInspectTransactionBlock(params);
+                return res;
+            }
+            catch (error) {
+                // clear all cache if devInspectTransactionBlock fails
+                await __classPrivateFieldGet(this, _SuiClientUtils_devInspectCache, "f").clear();
+                throw error;
+            }
+            finally {
+                await __classPrivateFieldGet(this, _SuiClientUtils_devInspectCache, "f").clearOwnedObjects();
+            }
+        };
+        __classPrivateFieldSet(this, _SuiClientUtils_devInspectCache, new ObjectCache_1.CustomObjectCache({ client: this.client }), "f");
+    }
+}
+exports.SuiClientUtils = SuiClientUtils;
+_SuiClientUtils_devInspectCache = new WeakMap();

package/lib/cjs/utils/condition.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = assert;
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message || "Assertion failed");
+    }
+}

package/lib/esm/constants/_7k.js

@@ -7,3 +7,7 @@ export const _7K_CONFIG = "0x47442a93f7727d188ba7cb71031170d1786af70013cb7ad5115
 //legacy v3: "0x0f8fc23dbcc9362b72c7a4c5aa53fcefa02ebfbb83a812c8c262ccd2c076d9ee";
 export const _7K_VAULT = "0x442ad50389ed5cda6f7a6f5a7ae6361a4c05ef1d9fb2e54fbba5a268d690bfe6";
 //legacy v3: "0x39a3c55742c0e011b6f65548e73cf589e1ae5e82dbfab449ca57f24c3bcd9514";
+export const _7K_META_PUBLISHED_AT = "0x17c0b1f7a6ad73f51268f16b8c06c049eecc2f28a270cdd29c06e3d2dea23302";
+export const _7K_META_PACKAGE_ID = "0x17c0b1f7a6ad73f51268f16b8c06c049eecc2f28a270cdd29c06e3d2dea23302";
+export const _7K_META_VAULT = "0x9a8abd32fe5721307ce3b697cf982ee84e9ffbd58d667a4a199f1683c1a3d23c";
+export const _7K_META_CONFIG = "0xbbb3a51877ed9b492f26f4e2181811cfb2bd70c532f6f7621263d122d5e96b56";

package/lib/esm/constants/sui.js

@@ -0,0 +1 @@
+export const SUI_ADDRESS_ZERO = "0x0000000000000000000000000000000000000000000000000000000000000000";

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

@@ -0,0 +1,210 @@
+import { getFullnodeUrl, SuiClient } from "@mysten/sui/client";
+import { coinWithBalance, Transaction, } from "@mysten/sui/transactions";
+import { _7K_META_CONFIG, _7K_META_PACKAGE_ID, _7K_META_PUBLISHED_AT, _7K_META_VAULT, } from "../../constants/_7k";
+import { SUI_ADDRESS_ZERO } from "../../constants/sui";
+import { EProvider, } from "../../types/metaAg";
+import { assert } from "../../utils/condition";
+import { SuiClientUtils } from "../../utils/SuiClientUtils";
+import { getExpectedReturn } from "../swap/buildTx";
+import { BluefinProvider } from "./providers/bluefin";
+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: options?.providers ?? DEFAULT_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;
+        switch (provider) {
+            case EProvider.BLUEFIN7K:
+                const bluefinOptions = this.options.providers[provider];
+                assert(!!bluefinOptions, `Provider not found: ${provider}`);
+                this.providers[EProvider.BLUEFIN7K] = new BluefinProvider(bluefinOptions, this.options, this.client);
+                break;
+            case EProvider.FLOWX:
+                const flowxOptions = this.options.providers[provider];
+                assert(!!flowxOptions, `Provider not found: ${provider}`);
+                const { FlowxProvider } = await import("./providers/flowx").catch(catchImportError(EProvider.FLOWX));
+                this.providers[EProvider.FLOWX] = new FlowxProvider(flowxOptions, this.options, this.client);
+                break;
+            case EProvider.CETUS:
+                const cetusOptions = this.options.providers[provider];
+                assert(!!cetusOptions, `Provider not found: ${provider}`);
+                const { CetusProvider } = await import("./providers/cetus").catch(catchImportError(EProvider.CETUS));
+                this.providers[EProvider.CETUS] = new CetusProvider(cetusOptions, this.options, this.client);
+                break;
+            default:
+                throw new Error(`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,
+                }),
+                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}`);
+            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);
+        }
+    }
+    async _quote(provider, options, simulation) {
+        const quote = await timeout(() => provider.quote(options), 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) => {
+                    payload && simulation.onSimulated?.(payload);
+                });
+            }
+            else {
+                const updated = await this._simulate(provider, quote, simulation);
+                quote.simulatedAmountOut = updated?.simulatedAmountOut;
+                quote.gasUsed = updated?.gasUsed;
+            }
+        }
+        return quote;
+    }
+    /**
+     * 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 quotes = await Promise.allSettled(Object.keys(this.options.providers).map(async (provider) => {
+            const p = await this._getProvider(provider);
+            return this._quote(p, options, simulation);
+        }));
+        return quotes
+            .map((quote) => quote.status === "fulfilled"
+            ? quote.value
+            : (console.log(quote.reason), null))
+            .filter((quote) => quote !== null);
+    }
+    /**
+     * Build transaction from quote
+     * @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}`);
+        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;
+    }
+}
+/**
+ * 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, // use for calculate expected amount out
+        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(0), // commission must be 0 since all integrated aggregators already charge commission fee for partner
+                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",
+        };
+        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

@@ -0,0 +1,67 @@
+import { SuiPriceServiceConnection, SuiPythClient, } from "@pythnetwork/pyth-sui-js";
+import { v4 } from "uuid";
+import { Config } from "../../../config";
+import { API_ENDPOINTS } from "../../../constants/apiEndpoints";
+import { SUI_ADDRESS_ZERO } from "../../../constants/sui";
+import { EProvider, } from "../../../types/metaAg";
+import { assert } from "../../../utils/condition";
+import { getExpectedReturn } from "../../swap/buildTx";
+import { buildTxV2 } from "../../swap/buildTxV2";
+import { getQuote } from "../../swap/getQuote";
+const WORMHOLE_STATE_ID = "0xaeab97f96cf9877fee2883315d459552b2b921edc16d7ceac6eab944dd88919c";
+const PYTH_STATE_ID = "0x1f9310238ee9298fb703c3419030b35b22bb1cc37113e3bb5007c99aec79e5b8";
+export class BluefinProvider {
+    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);
+        options.apiKey && Config.setApiKey(options.apiKey);
+        Config.setSuiClient(client);
+        Config.setPythClient(pythClient);
+        Config.setPythConnection(pythConnection);
+    }
+    async quote(options) {
+        const quote = await getQuote({
+            amountIn: options.amountIn,
+            tokenIn: options.coinInType,
+            tokenOut: options.coinOutType,
+            api: this.options.api || API_ENDPOINTS.MAIN,
+            sources: this.options.sources,
+            maxPaths: this.options.maxPaths,
+            excludedPools: this.options.excludedPools,
+            targetPools: this.options.targetPools,
+        });
+        const { expectedAmount } = getExpectedReturn(quote.returnAmountWithDecimal.toString(), 0, this.metaOptions.partnerCommissionBps ?? 0, this.metaOptions.tipBps ?? 0);
+        return {
+            id: v4(),
+            provider: EProvider.BLUEFIN7K,
+            quote,
+            amountIn: quote.swapAmountWithDecimal,
+            rawAmountOut: quote.returnAmountWithDecimal,
+            amountOut: expectedAmount,
+            coinTypeIn: quote.tokenIn,
+            coinTypeOut: quote.tokenOut,
+        };
+    }
+    async swap({ quote, signer, tx, coinIn }) {
+        assert(quote.provider === EProvider.BLUEFIN7K, "Invalid quote");
+        const { coinOut } = await buildTxV2({
+            quoteResponse: quote.quote,
+            accountAddress: signer,
+            commission: {
+                commissionBps: this.metaOptions.partnerCommissionBps ?? 0,
+                partner: this.metaOptions.partner ?? SUI_ADDRESS_ZERO,
+            },
+            slippage: 1,
+            extendTx: {
+                tx,
+                coinIn,
+            },
+        });
+        return coinOut;
+    }
+}