@shapeshiftoss/swapper 17.6.9 → 17.6.11

package/dist/cjs/swappers/RelaySwapper/constant.js

@@ -23,11 +23,37 @@ exports.chainIdToRelayChainId = {
     [caip_1.gnosisChainId]: chains_1.gnosis.id,
     [caip_1.avalancheChainId]: chains_1.avalanche.id,
     [caip_1.bscChainId]: chains_1.bsc.id,
-    [caip_1.tronChainId]: 728126428,
+    // DISABLED: Tron deposits are built as simple TRC20 transfers instead of depositErc20() vault calls,
+    // and the Relay indexer notification is never sent for non-EVM chains. This causes deposits to be
+    // untracked by Relay, resulting in stuck/lost funds. Re-enable once the Tron transaction building
+    // is verified to use the Relay quote calldata (depositErc20) correctly.
+    // [tronChainId]: 728126428,
     [caip_1.monadChainId]: chains_1.monad.id,
     [caip_1.hyperEvmChainId]: chains_1.hyperEvm.id,
+    [caip_1.mantleChainId]: chains_1.mantle.id,
+    [caip_1.inkChainId]: chains_1.ink.id,
+    [caip_1.megaethChainId]: 4326,
     [caip_1.plasmaChainId]: chains_1.plasma.id,
     [caip_1.katanaChainId]: chains_1.katana.id,
+    [caip_1.etherealChainId]: 5064014,
+    [caip_1.celoChainId]: chains_1.celo.id,
+    [caip_1.flowEvmChainId]: chains_1.flowMainnet.id,
+    [caip_1.plumeChainId]: chains_1.plumeMainnet.id,
+    [caip_1.storyChainId]: chains_1.story.id,
+    [caip_1.zkSyncEraChainId]: chains_1.zksync.id,
+    [caip_1.blastChainId]: chains_1.blast.id,
+    [caip_1.worldChainChainId]: chains_1.worldchain.id,
+    [caip_1.hemiChainId]: chains_1.hemi.id,
+    [caip_1.lineaChainId]: chains_1.linea.id,
+    [caip_1.berachainChainId]: chains_1.berachain.id,
+    [caip_1.scrollChainId]: chains_1.scroll.id,
+    [caip_1.cronosChainId]: chains_1.cronos.id,
+    [caip_1.sonicChainId]: chains_1.sonic.id,
+    [caip_1.unichainChainId]: chains_1.unichain.id,
+    [caip_1.bobChainId]: chains_1.bob.id,
+    [caip_1.modeChainId]: chains_1.mode.id,
+    [caip_1.soneiumChainId]: chains_1.soneium.id,
+    [caip_1.seiChainId]: chains_1.sei.id,
 };
 var RelayStatusMessage;
 (function (RelayStatusMessage) {

package/dist/cjs/swappers/RelaySwapper/utils/getRelayDefaultUserAddress.d.ts

@@ -1,2 +1,2 @@
 import type { ChainId } from '@shapeshiftoss/caip';
-export declare const getRelayDefaultUserAddress: (chainId: ChainId) => "0x000000000000000000000000000000000000dead" | "bc1q4vxn43l44h30nkluqfxd9eckf45vr2awz38lwa" | "CbKGgVKLJFb8bBrf58DnAkdryX6ubewVytn7X957YwNr" | "TLsV52sRDL79HXGGm9yzwKibb6BeruhUzy";
+export declare const getRelayDefaultUserAddress: (chainId: ChainId) => "0x000000000000000000000000000000000000dead" | "CbKGgVKLJFb8bBrf58DnAkdryX6ubewVytn7X957YwNr" | "bc1q4vxn43l44h30nkluqfxd9eckf45vr2awz38lwa" | "TLsV52sRDL79HXGGm9yzwKibb6BeruhUzy";

package/dist/cjs/swappers/RelaySwapper/utils/getTrade.js

@@ -14,6 +14,7 @@ const viem_1 = require("viem");
 const types_1 = require("../../../types");
 const utils_2 = require("../../../utils");
 const tenderly_1 = require("../../../utils/tenderly");
+const affiliateFee_1 = require("../../utils/affiliateFee");
 const helpers_1 = require("../../utils/helpers/helpers");
 const constant_1 = require("../constant");
 const getRelayAssetAddress_1 = require("../utils/getRelayAssetAddress");
@@ -142,6 +143,13 @@ async function getTrade({ input, deps, relayChainMap, }) {
         }));
     }
     const { data: quote } = maybeQuote.unwrap();
+    const orderId = quote.protocol?.v2?.orderId;
+    if (!orderId && sellAsset.chainId === caip_1.btcChainId) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'Relay quote missing protocol.v2.orderId',
+            code: types_1.TradeQuoteError.UnknownError,
+        }));
+    }
     const { slippageTolerance, currencyOut, timeEstimate } = quote.details;
     const buyAmountAfterFeesCryptoBaseUnit = currencyOut.amount;
     const rate = (0, utils_2.getInputOutputRate)({
@@ -336,7 +344,7 @@ async function getTrade({ input, deps, relayChainMap, }) {
                 value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
                 chainSpecific: {
                     pubkey: xpub ?? (0, getRelayDefaultUserAddress_1.getRelayDefaultUserAddress)(sellAsset.chainId),
-                    opReturnData: firstStep.requestId,
+                    opReturnData: orderId,
                 },
                 sendMax: false,
             };
@@ -389,7 +397,7 @@ async function getTrade({ input, deps, relayChainMap, }) {
         // Fallback to Relay's gas amount
         return quote.fees.gas.amount;
     })();
-    const steps = swapSteps.map((quoteStep) => {
+    const steps = await Promise.all(swapSteps.map(async (quoteStep) => {
         const selectedItem = quoteStep.items?.[0];
         if (!selectedItem)
             throw new Error('Relay quote step contains no items');
@@ -399,7 +407,7 @@ async function getTrade({ input, deps, relayChainMap, }) {
             .plus(relayerFeesBuyAssetCryptoBaseUnit)
             .plus(appFeesBaseUnit)
             .toFixed();
-        const { allowanceContract, relayTransactionMetadata, solanaTransactionMetadata } = (() => {
+        const { allowanceContract, relayTransactionMetadata, solanaTransactionMetadata } = await (async () => {
             if (!selectedItem.data)
                 throw new Error('Relay quote step contains no data');
             if ((0, types_2.isRelayQuoteUtxoItemData)(selectedItem.data)) {
@@ -411,9 +419,10 @@ async function getTrade({ input, deps, relayChainMap, }) {
                     relayTransactionMetadata: {
                         from: sendAddress,
                         psbt: selectedItem.data.psbt,
-                        opReturnData: quoteStep.requestId,
+                        opReturnData: orderId,
                         to: relayer,
                         relayId: quote.steps[0].requestId,
+                        orderId,
                     },
                     solanaTransactionMetadata: undefined,
                 };
@@ -431,19 +440,48 @@ async function getTrade({ input, deps, relayChainMap, }) {
                         gasLimit: selectedItem.data?.gas,
                         chainId: Number((0, caip_1.fromChainId)(sellAsset.chainId).chainReference),
                         relayId: quote.steps[0].requestId,
+                        orderId,
                     },
                     solanaTransactionMetadata: undefined,
                 };
             }
             if ((0, types_2.isRelayQuoteSolanaItemData)(selectedItem.data)) {
+                const solanaInstructions = selectedItem.data?.instructions?.map(convertSolanaInstruction);
+                const addressLookupTableAddresses = selectedItem.data?.addressLookupTableAddresses;
+                // Build a trial VersionedTransaction to check if it exceeds the 1232-byte Solana tx size limit
+                const isOversized = await (async () => {
+                    if (!solanaInstructions?.length || !sendAddress)
+                        return false;
+                    try {
+                        const adapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
+                        const lookupTableInfos = await adapter.getAddressLookupTableAccounts(addressLookupTableAddresses);
+                        const lookupTableAccounts = lookupTableInfos.map(info => new web3_js_1.AddressLookupTableAccount({
+                            key: new web3_js_1.PublicKey(info.key),
+                            state: web3_js_1.AddressLookupTableAccount.deserialize(new Uint8Array(info.data)),
+                        }));
+                        const messageV0 = web3_js_1.MessageV0.compile({
+                            payerKey: new web3_js_1.PublicKey(sendAddress),
+                            instructions: solanaInstructions,
+                            recentBlockhash: web3_js_1.PublicKey.default.toString(),
+                            addressLookupTableAccounts: lookupTableAccounts,
+                        });
+                        const txBytes = new web3_js_1.VersionedTransaction(messageV0).serialize();
+                        return txBytes.length > 1232;
+                    }
+                    catch {
+                        return false;
+                    }
+                })();
                 return {
                     allowanceContract: '',
                     solanaTransactionMetadata: {
-                        addressLookupTableAddresses: selectedItem.data?.addressLookupTableAddresses,
-                        instructions: selectedItem.data?.instructions?.map(convertSolanaInstruction),
+                        addressLookupTableAddresses,
+                        instructions: solanaInstructions,
+                        isOversized,
                     },
                     relayTransactionMetadata: {
                         relayId: quote.steps[0].requestId,
+                        orderId,
                     },
                 };
             }
@@ -453,6 +491,7 @@ async function getTrade({ input, deps, relayChainMap, }) {
                     solanaTransactionMetadata: undefined,
                     relayTransactionMetadata: {
                         relayId: quote.steps[0].requestId,
+                        orderId,
                         to: selectedItem.data?.parameter?.contract_address,
                     },
                 };
@@ -483,8 +522,19 @@ async function getTrade({ input, deps, relayChainMap, }) {
             estimatedExecutionTimeMs: timeEstimate * 1000,
             solanaTransactionMetadata,
             relayTransactionMetadata,
+            affiliateFee: (0, affiliateFee_1.buildAffiliateFee)({
+                strategy: 'fixed_asset',
+                affiliateBps,
+                sellAsset,
+                buyAsset,
+                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                fixedAssetId: (0, utils_1.chainIdToFeeAssetId)(caip_1.baseChainId),
+                fixedAsset: deps.assetsById[(0, utils_1.chainIdToFeeAssetId)(caip_1.baseChainId)],
+                isEstimate: true,
+            }),
         };
-    });
+    }));
     const baseQuoteOrRate = {
         id: quote.steps[0].requestId,
         rate,

package/dist/cjs/swappers/RelaySwapper/utils/relayTokenToAssetId.js

@@ -112,11 +112,121 @@ const relayTokenToAssetId = (relayToken) => {
                     assetReference: caip_1.ASSET_REFERENCE.Plasma,
                     assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
                 };
+            case caip_1.CHAIN_REFERENCE.MantleMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.Mantle,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
+            case caip_1.CHAIN_REFERENCE.InkMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.Ink,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
+            case caip_1.CHAIN_REFERENCE.MegaEthMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.MegaEth,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
+            case caip_1.CHAIN_REFERENCE.BerachainMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.Berachain,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
             case caip_1.CHAIN_REFERENCE.KatanaMainnet:
                 return {
                     assetReference: caip_1.ASSET_REFERENCE.Katana,
                     assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
                 };
+            case caip_1.CHAIN_REFERENCE.EtherealMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.Ethereal,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
+            case caip_1.CHAIN_REFERENCE.CeloMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.Celo,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
+            case caip_1.CHAIN_REFERENCE.FlowEvmMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.FlowEvm,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
+            case caip_1.CHAIN_REFERENCE.PlumeMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.Plume,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
+            case caip_1.CHAIN_REFERENCE.StoryMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.Story,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
+            case caip_1.CHAIN_REFERENCE.ZkSyncEraMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.ZkSyncEra,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
+            case caip_1.CHAIN_REFERENCE.BlastMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.Blast,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
+            case caip_1.CHAIN_REFERENCE.WorldChainMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.WorldChain,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
+            case caip_1.CHAIN_REFERENCE.HemiMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.Hemi,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
+            case caip_1.CHAIN_REFERENCE.LineaMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.Linea,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
+            case caip_1.CHAIN_REFERENCE.ScrollMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.Scroll,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
+            case caip_1.CHAIN_REFERENCE.CronosMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.Cronos,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
+            case caip_1.CHAIN_REFERENCE.SonicMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.Sonic,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
+            case caip_1.CHAIN_REFERENCE.UnichainMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.Unichain,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
+            case caip_1.CHAIN_REFERENCE.BobMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.Bob,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
+            case caip_1.CHAIN_REFERENCE.ModeMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.Mode,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
+            case caip_1.CHAIN_REFERENCE.SoneiumMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.Soneium,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
+            case caip_1.CHAIN_REFERENCE.SeiMainnet:
+                return {
+                    assetReference: caip_1.ASSET_REFERENCE.Sei,
+                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
+                };
             default:
                 throw Error(`chainId '${relayToken.chainId}' not supported`);
         }

package/dist/cjs/swappers/RelaySwapper/utils/types.d.ts

@@ -22,6 +22,7 @@ export type RelayTransactionMetadata = {
     psbt?: string;
     opReturnData?: string;
     relayId: string;
+    orderId: string | undefined;
 };
 export type RelayStatus = {
     status: 'success' | 'failed' | 'pending' | 'refund' | 'delayed' | 'waiting';
@@ -120,10 +121,24 @@ export type RelayQuoteStep = {
     requestId: string;
     items?: RelayQuoteItem[];
 };
+export type RelayProtocolV2 = {
+    orderId: string | undefined;
+    orderData?: unknown;
+    paymentDetails?: {
+        chainId: string;
+        depository: string;
+        currency: string;
+        amount: string;
+    };
+};
+export type RelayProtocol = {
+    v2?: RelayProtocolV2;
+};
 export type RelayQuote = {
     fees: RelayFees;
     details: QuoteDetails;
     steps: RelayQuoteStep[];
+    protocol?: RelayProtocol;
 };
 export declare const isRelayQuoteUtxoItemData: (item: RelayQuoteUtxoItemData | RelayQuoteEvmItemData | RelayQuoteSolanaItemData | RelayQuoteTronItemData) => item is RelayQuoteUtxoItemData;
 export declare const isRelayQuoteEvmItemData: (item: RelayQuoteUtxoItemData | RelayQuoteEvmItemData | RelayQuoteSolanaItemData | RelayQuoteTronItemData) => item is RelayQuoteEvmItemData;

package/dist/cjs/swappers/StonfiSwapper/StonfiSwapper.d.ts

@@ -0,0 +1,2 @@
+import type { Swapper } from '../../types';
+export declare const stonfiSwapper: Swapper;

package/dist/cjs/swappers/StonfiSwapper/StonfiSwapper.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stonfiSwapper = void 0;
+exports.stonfiSwapper = {
+    executeTonTransaction: (txToSign, { signAndBroadcastTransaction }) => {
+        return signAndBroadcastTransaction(txToSign);
+    },
+};

package/dist/cjs/swappers/StonfiSwapper/endpoints.d.ts

@@ -0,0 +1,2 @@
+import type { SwapperApi } from '../../types';
+export declare const stonfiApi: SwapperApi;

package/dist/cjs/swappers/StonfiSwapper/endpoints.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stonfiApi = void 0;
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const unchained_client_1 = require("@shapeshiftoss/unchained-client");
+const omniston_sdk_1 = require("@ston-fi/omniston-sdk");
+const utils_1 = require("../../utils");
+const getTradeQuote_1 = require("./swapperApi/getTradeQuote");
+const getTradeRate_1 = require("./swapperApi/getTradeRate");
+const omnistonManager_1 = require("./utils/omnistonManager");
+const TRADE_TRACKING_TIMEOUT_MS = 60000;
+const waitForFirstTradeStatus = (request, timeoutMs) => {
+    const omniston = omnistonManager_1.omnistonManager.getInstance();
+    return new Promise(resolve => {
+        const timer = setTimeout(() => {
+            subscription.unsubscribe();
+            resolve(null);
+        }, timeoutMs);
+        const subscription = omniston.trackTrade(request).subscribe({
+            next: (status) => {
+                clearTimeout(timer);
+                subscription.unsubscribe();
+                resolve(status);
+            },
+            error: err => {
+                console.error('[Stonfi] trackTrade error:', err);
+                clearTimeout(timer);
+                resolve(null);
+            },
+        });
+    });
+};
+exports.stonfiApi = {
+    getTradeQuote: (input, _deps) => (0, getTradeQuote_1.getTradeQuote)(input),
+    getTradeRate: input => (0, getTradeRate_1.getTradeRate)(input),
+    getUnsignedTonTransaction: async ({ stepIndex, tradeQuote, from, assertGetTonChainAdapter }) => {
+        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote)) {
+            throw new Error('Unable to execute a trade rate quote');
+        }
+        const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
+        const { accountNumber, sellAsset, stonfiSpecific } = step;
+        if (!stonfiSpecific) {
+            throw new Error('stonfiSpecific is required');
+        }
+        const adapter = assertGetTonChainAdapter(sellAsset.chainId);
+        const storedQuote = {
+            quoteId: stonfiSpecific.quoteId,
+            resolverId: stonfiSpecific.resolverId,
+            resolverName: stonfiSpecific.resolverName,
+            bidAssetAddress: stonfiSpecific.bidAssetAddress,
+            askAssetAddress: stonfiSpecific.askAssetAddress,
+            bidUnits: stonfiSpecific.bidUnits,
+            askUnits: stonfiSpecific.askUnits,
+            referrerAddress: stonfiSpecific.referrerAddress,
+            referrerFeeAsset: stonfiSpecific.referrerFeeAsset,
+            referrerFeeUnits: stonfiSpecific.referrerFeeUnits,
+            protocolFeeAsset: stonfiSpecific.protocolFeeAsset,
+            protocolFeeUnits: stonfiSpecific.protocolFeeUnits,
+            quoteTimestamp: stonfiSpecific.quoteTimestamp,
+            tradeStartDeadline: stonfiSpecific.tradeStartDeadline,
+            gasBudget: stonfiSpecific.gasBudget,
+            estimatedGasConsumption: stonfiSpecific.estimatedGasConsumption,
+            params: stonfiSpecific.params,
+        };
+        const omniston = omnistonManager_1.omnistonManager.getInstance();
+        const maxRetries = 3;
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                const txResponse = await omniston.buildTransfer({
+                    sourceAddress: { blockchain: omniston_sdk_1.Blockchain.TON, address: from },
+                    destinationAddress: {
+                        blockchain: omniston_sdk_1.Blockchain.TON,
+                        address: tradeQuote.receiveAddress,
+                    },
+                    quote: storedQuote,
+                    useRecommendedSlippage: true,
+                });
+                if (!txResponse?.ton?.messages || txResponse.ton.messages.length === 0) {
+                    throw new Error('No TON messages returned from buildTransfer');
+                }
+                const expireAt = Math.floor(Date.now() / 1000) + 300;
+                const convertBase64ToHex = (base64) => {
+                    if (!base64)
+                        return '';
+                    return Buffer.from(base64, 'base64').toString('hex');
+                };
+                const rawMessages = txResponse.ton.messages.map(msg => ({
+                    targetAddress: msg.targetAddress,
+                    sendAmount: msg.sendAmount,
+                    payload: convertBase64ToHex(msg.payload),
+                    stateInit: convertBase64ToHex(msg.jettonWalletStateInit),
+                }));
+                const seqno = await adapter.getSeqno(from);
+                return {
+                    addressNList: (0, chain_adapters_1.toAddressNList)(adapter.getBip44Params({ accountNumber })),
+                    rawMessages,
+                    seqno,
+                    expireAt,
+                };
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err : new Error(String(err));
+                console.error(`[Stonfi] buildTransfer attempt ${attempt}/${maxRetries} failed:`, lastError.message);
+                if (attempt < maxRetries) {
+                    await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
+                }
+            }
+        }
+        throw lastError ?? new Error('Failed to build transfer after retries');
+    },
+    getTonTransactionFees: ({ tradeQuote, stepIndex }) => {
+        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote)) {
+            throw new Error('Unable to execute a trade rate quote');
+        }
+        const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
+        if (!step.feeData.networkFeeCryptoBaseUnit) {
+            throw new Error('Missing network fee in quote');
+        }
+        return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit);
+    },
+    checkTradeStatus: async ({ swap, assertGetTonChainAdapter }) => {
+        if (!swap?.sellTxHash) {
+            return (0, utils_1.createDefaultStatusResponse)();
+        }
+        const { sellTxHash } = swap;
+        const checkTxStatusViaChainAdapter = async () => {
+            try {
+                const adapter = assertGetTonChainAdapter(swap.sellAsset.chainId);
+                const tx = await adapter.parseTx(sellTxHash, '');
+                return {
+                    status: tx.status,
+                    buyTxHash: tx.status === unchained_client_1.TxStatus.Confirmed ? sellTxHash : undefined,
+                    message: undefined,
+                };
+            }
+            catch (err) {
+                console.error('[Stonfi] Error checking tx status via chain adapter:', err);
+                return (0, utils_1.createDefaultStatusResponse)(sellTxHash);
+            }
+        };
+        const { metadata } = swap;
+        if (!metadata?.quoteId) {
+            return checkTxStatusViaChainAdapter();
+        }
+        try {
+            const tradeStatus = await waitForFirstTradeStatus({
+                quoteId: metadata.quoteId,
+                traderWalletAddress: {
+                    blockchain: omniston_sdk_1.Blockchain.TON,
+                    address: swap.sellAccountId.split(':')[2] ?? '',
+                },
+                outgoingTxHash: sellTxHash,
+            }, TRADE_TRACKING_TIMEOUT_MS);
+            if (!tradeStatus?.status) {
+                return checkTxStatusViaChainAdapter();
+            }
+            const statusOneOf = tradeStatus.status;
+            if (statusOneOf.awaitingTransfer ||
+                statusOneOf.transferring ||
+                statusOneOf.swapping ||
+                statusOneOf.receivingFunds) {
+                const chainStatus = await checkTxStatusViaChainAdapter();
+                if (chainStatus.status === unchained_client_1.TxStatus.Confirmed) {
+                    return chainStatus;
+                }
+                if (statusOneOf.awaitingTransfer) {
+                    return {
+                        status: unchained_client_1.TxStatus.Pending,
+                        buyTxHash: undefined,
+                        message: 'trade.statuses.awaitingDeposit',
+                    };
+                }
+                if (statusOneOf.transferring) {
+                    return {
+                        status: unchained_client_1.TxStatus.Pending,
+                        buyTxHash: undefined,
+                        message: 'trade.statuses.depositing',
+                    };
+                }
+                if (statusOneOf.swapping) {
+                    return {
+                        status: unchained_client_1.TxStatus.Pending,
+                        buyTxHash: undefined,
+                        message: 'trade.statuses.swapping',
+                    };
+                }
+                if (statusOneOf.receivingFunds) {
+                    return {
+                        status: unchained_client_1.TxStatus.Pending,
+                        buyTxHash: undefined,
+                        message: 'trade.statuses.receivingFunds',
+                    };
+                }
+            }
+            if (statusOneOf.tradeSettled) {
+                const result = statusOneOf.tradeSettled.result;
+                if (result === 'TRADE_RESULT_FULLY_FILLED') {
+                    return {
+                        status: unchained_client_1.TxStatus.Confirmed,
+                        buyTxHash: sellTxHash,
+                        message: undefined,
+                    };
+                }
+                if (result === 'TRADE_RESULT_PARTIALLY_FILLED') {
+                    return {
+                        status: unchained_client_1.TxStatus.Confirmed,
+                        buyTxHash: sellTxHash,
+                        message: 'trade.statuses.partiallyFilled',
+                    };
+                }
+                if (result === 'TRADE_RESULT_ABORTED') {
+                    return {
+                        status: unchained_client_1.TxStatus.Failed,
+                        buyTxHash: undefined,
+                        message: 'trade.statuses.aborted',
+                    };
+                }
+            }
+            return checkTxStatusViaChainAdapter();
+        }
+        catch (err) {
+            console.error('[Stonfi] Error checking trade status via Omniston:', err);
+            return checkTxStatusViaChainAdapter();
+        }
+    },
+};

package/dist/cjs/swappers/StonfiSwapper/index.d.ts

@@ -0,0 +1,4 @@
+export { stonfiApi } from './endpoints';
+export { stonfiSwapper } from './StonfiSwapper';
+export * from './types';
+export { STONFI_SUPPORTED_CHAIN_IDS, STONFI_WEBSOCKET_URL } from './utils/constants';

package/dist/cjs/swappers/StonfiSwapper/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STONFI_WEBSOCKET_URL = exports.STONFI_SUPPORTED_CHAIN_IDS = exports.stonfiSwapper = exports.stonfiApi = void 0;
+var endpoints_1 = require("./endpoints");
+Object.defineProperty(exports, "stonfiApi", { enumerable: true, get: function () { return endpoints_1.stonfiApi; } });
+var StonfiSwapper_1 = require("./StonfiSwapper");
+Object.defineProperty(exports, "stonfiSwapper", { enumerable: true, get: function () { return StonfiSwapper_1.stonfiSwapper; } });
+__exportStar(require("./types"), exports);
+var constants_1 = require("./utils/constants");
+Object.defineProperty(exports, "STONFI_SUPPORTED_CHAIN_IDS", { enumerable: true, get: function () { return constants_1.STONFI_SUPPORTED_CHAIN_IDS; } });
+Object.defineProperty(exports, "STONFI_WEBSOCKET_URL", { enumerable: true, get: function () { return constants_1.STONFI_WEBSOCKET_URL; } });

package/dist/cjs/swappers/StonfiSwapper/swapperApi/getTradeQuote.d.ts

@@ -0,0 +1,2 @@
+import type { CommonTradeQuoteInput, TradeQuoteResult } from '../../../types';
+export declare const getTradeQuote: (input: CommonTradeQuoteInput) => Promise<TradeQuoteResult>;