@shapeshiftoss/swapper 17.6.9 → 17.6.11

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

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

package/dist/esm/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/esm/swappers/StonfiSwapper/StonfiSwapper.d.ts

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

package/dist/esm/swappers/StonfiSwapper/StonfiSwapper.js

@@ -0,0 +1,5 @@
+export const stonfiSwapper = {
+    executeTonTransaction: (txToSign, { signAndBroadcastTransaction }) => {
+        return signAndBroadcastTransaction(txToSign);
+    },
+};

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

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

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

@@ -0,0 +1,224 @@
+import { toAddressNList } from '@shapeshiftoss/chain-adapters';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import { Blockchain } from '@ston-fi/omniston-sdk';
+import { createDefaultStatusResponse, getExecutableTradeStep, isExecutableTradeQuote, } from '../../utils.js';
+import { getTradeQuote } from './swapperApi/getTradeQuote.js';
+import { getTradeRate } from './swapperApi/getTradeRate.js';
+import { omnistonManager } from './utils/omnistonManager.js';
+const TRADE_TRACKING_TIMEOUT_MS = 60000;
+const waitForFirstTradeStatus = (request, timeoutMs) => {
+    const omniston = 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);
+            },
+        });
+    });
+};
+export const stonfiApi = {
+    getTradeQuote: (input, _deps) => getTradeQuote(input),
+    getTradeRate: input => getTradeRate(input),
+    getUnsignedTonTransaction: async ({ stepIndex, tradeQuote, from, assertGetTonChainAdapter }) => {
+        if (!isExecutableTradeQuote(tradeQuote)) {
+            throw new Error('Unable to execute a trade rate quote');
+        }
+        const step = 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.getInstance();
+        const maxRetries = 3;
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                const txResponse = await omniston.buildTransfer({
+                    sourceAddress: { blockchain: Blockchain.TON, address: from },
+                    destinationAddress: {
+                        blockchain: 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: 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 (!isExecutableTradeQuote(tradeQuote)) {
+            throw new Error('Unable to execute a trade rate quote');
+        }
+        const step = 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 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 === TxStatus.Confirmed ? sellTxHash : undefined,
+                    message: undefined,
+                };
+            }
+            catch (err) {
+                console.error('[Stonfi] Error checking tx status via chain adapter:', err);
+                return createDefaultStatusResponse(sellTxHash);
+            }
+        };
+        const { metadata } = swap;
+        if (!metadata?.quoteId) {
+            return checkTxStatusViaChainAdapter();
+        }
+        try {
+            const tradeStatus = await waitForFirstTradeStatus({
+                quoteId: metadata.quoteId,
+                traderWalletAddress: {
+                    blockchain: 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 === TxStatus.Confirmed) {
+                    return chainStatus;
+                }
+                if (statusOneOf.awaitingTransfer) {
+                    return {
+                        status: TxStatus.Pending,
+                        buyTxHash: undefined,
+                        message: 'trade.statuses.awaitingDeposit',
+                    };
+                }
+                if (statusOneOf.transferring) {
+                    return {
+                        status: TxStatus.Pending,
+                        buyTxHash: undefined,
+                        message: 'trade.statuses.depositing',
+                    };
+                }
+                if (statusOneOf.swapping) {
+                    return {
+                        status: TxStatus.Pending,
+                        buyTxHash: undefined,
+                        message: 'trade.statuses.swapping',
+                    };
+                }
+                if (statusOneOf.receivingFunds) {
+                    return {
+                        status: TxStatus.Pending,
+                        buyTxHash: undefined,
+                        message: 'trade.statuses.receivingFunds',
+                    };
+                }
+            }
+            if (statusOneOf.tradeSettled) {
+                const result = statusOneOf.tradeSettled.result;
+                if (result === 'TRADE_RESULT_FULLY_FILLED') {
+                    return {
+                        status: TxStatus.Confirmed,
+                        buyTxHash: sellTxHash,
+                        message: undefined,
+                    };
+                }
+                if (result === 'TRADE_RESULT_PARTIALLY_FILLED') {
+                    return {
+                        status: TxStatus.Confirmed,
+                        buyTxHash: sellTxHash,
+                        message: 'trade.statuses.partiallyFilled',
+                    };
+                }
+                if (result === 'TRADE_RESULT_ABORTED') {
+                    return {
+                        status: 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/esm/swappers/StonfiSwapper/index.d.ts

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

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

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

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

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

package/dist/esm/swappers/StonfiSwapper/swapperApi/getTradeQuote.js

@@ -0,0 +1,125 @@
+import { Err, Ok } from '@sniptt/monads';
+import { SettlementMethod } from '@ston-fi/omniston-sdk';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
+import { getTreasuryAddressFromChainId } from '../../utils/helpers/helpers.js';
+import { STONFI_DEFAULT_SLIPPAGE_BPS, STONFI_QUOTE_TIMEOUT_MS } from '../utils/constants.js';
+import { affiliateBpsToNumber, calculateRate, slippageDecimalToBps, tonAddressToOmnistonAddress, validateTonAssets, waitForQuote, } from '../utils/helpers.js';
+import { omnistonManager } from '../utils/omnistonManager.js';
+const buildStonfiSpecific = (quote, bidAssetAddress, askAssetAddress) => ({
+    quoteId: quote.quoteId,
+    resolverId: quote.resolverId,
+    resolverName: quote.resolverName,
+    tradeStartDeadline: quote.tradeStartDeadline,
+    gasBudget: quote.gasBudget,
+    bidAssetAddress: quote.bidAssetAddress ?? bidAssetAddress,
+    askAssetAddress: quote.askAssetAddress ?? askAssetAddress,
+    bidUnits: quote.bidUnits,
+    askUnits: quote.askUnits,
+    referrerAddress: quote.referrerAddress,
+    referrerFeeAsset: quote.referrerFeeAsset,
+    referrerFeeUnits: quote.referrerFeeUnits,
+    protocolFeeAsset: quote.protocolFeeAsset,
+    protocolFeeUnits: quote.protocolFeeUnits,
+    quoteTimestamp: quote.quoteTimestamp,
+    estimatedGasConsumption: quote.estimatedGasConsumption,
+    params: quote.params,
+});
+export const getTradeQuote = async (input) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, accountNumber, slippageTolerancePercentageDecimal, affiliateBps, } = input;
+    const validation = validateTonAssets(sellAsset, buyAsset);
+    if (!validation.isValid) {
+        return validation.error;
+    }
+    const { bidAssetAddress, askAssetAddress } = validation;
+    const omniston = omnistonManager.getInstance();
+    try {
+        const slippageBps = slippageDecimalToBps(slippageTolerancePercentageDecimal, STONFI_DEFAULT_SLIPPAGE_BPS);
+        const referrerFeeBps = affiliateBpsToNumber(affiliateBps);
+        const tonTreasuryAddress = getTreasuryAddressFromChainId(sellAsset.chainId);
+        const referrerAddress = tonAddressToOmnistonAddress(tonTreasuryAddress);
+        const quoteResult = await waitForQuote(omniston, {
+            settlementMethods: [SettlementMethod.SETTLEMENT_METHOD_SWAP],
+            bidAssetAddress,
+            askAssetAddress,
+            amount: { bidUnits: sellAmountIncludingProtocolFeesCryptoBaseUnit },
+            referrerAddress,
+            referrerFeeBps,
+            settlementParams: {
+                maxPriceSlippageBps: slippageBps,
+                gaslessSettlement: 'GASLESS_SETTLEMENT_PROHIBITED',
+                flexibleReferrerFee: true,
+            },
+        }, STONFI_QUOTE_TIMEOUT_MS);
+        if (quoteResult.type === 'error') {
+            console.error('[Stonfi] Quote request error:', quoteResult.error);
+            return Err(makeSwapErrorRight({
+                message: `[Stonfi] Connection error while fetching quote`,
+                code: TradeQuoteError.QueryFailed,
+                cause: quoteResult.error,
+            }));
+        }
+        if (quoteResult.type === 'timeout') {
+            return Err(makeSwapErrorRight({
+                message: `[Stonfi] Quote request timed out`,
+                code: TradeQuoteError.QueryFailed,
+            }));
+        }
+        if (quoteResult.type === 'noQuote') {
+            return Err(makeSwapErrorRight({
+                message: `[Stonfi] No quote available for this pair`,
+                code: TradeQuoteError.NoRouteFound,
+            }));
+        }
+        const quote = quoteResult.quote;
+        const buyAmountCryptoBaseUnit = quote.askUnits;
+        const networkFeeCryptoBaseUnit = quote.gasBudget;
+        const rate = calculateRate(buyAmountCryptoBaseUnit, sellAmountIncludingProtocolFeesCryptoBaseUnit, buyAsset.precision, sellAsset.precision);
+        const tradeQuote = {
+            id: quote.quoteId,
+            rate,
+            receiveAddress,
+            affiliateBps,
+            slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ?? String(STONFI_DEFAULT_SLIPPAGE_BPS / 10000),
+            quoteOrRate: 'quote',
+            swapperName: SwapperName.Stonfi,
+            steps: [
+                {
+                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    feeData: {
+                        networkFeeCryptoBaseUnit,
+                        protocolFees: undefined,
+                    },
+                    rate,
+                    source: SwapperName.Stonfi,
+                    buyAsset,
+                    sellAsset,
+                    accountNumber,
+                    allowanceContract: '0x0',
+                    estimatedExecutionTimeMs: 30000,
+                    stonfiSpecific: buildStonfiSpecific(quote, bidAssetAddress, askAssetAddress),
+                    affiliateFee: buildAffiliateFee({
+                        strategy: 'buy_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                        buyAmountCryptoBaseUnit,
+                        isEstimate: true,
+                    }),
+                },
+            ],
+        };
+        return Ok([tradeQuote]);
+    }
+    catch (err) {
+        return Err(makeSwapErrorRight({
+            message: `[Stonfi] Error getting quote: ${err}`,
+            code: TradeQuoteError.QueryFailed,
+            cause: err,
+        }));
+    }
+};

package/dist/esm/swappers/StonfiSwapper/swapperApi/getTradeRate.d.ts

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

package/dist/esm/swappers/StonfiSwapper/swapperApi/getTradeRate.js

@@ -0,0 +1,111 @@
+import { Err, Ok } from '@sniptt/monads';
+import { SettlementMethod } from '@ston-fi/omniston-sdk';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils.js';
+import { buildAffiliateFee } from '../../utils/affiliateFee.js';
+import { getTreasuryAddressFromChainId } from '../../utils/helpers/helpers.js';
+import { STONFI_DEFAULT_SLIPPAGE_BPS, STONFI_QUOTE_TIMEOUT_MS } from '../utils/constants.js';
+import { affiliateBpsToNumber, calculateRate, slippageDecimalToBps, tonAddressToOmnistonAddress, validateTonAssets, waitForQuote, } from '../utils/helpers.js';
+import { omnistonManager } from '../utils/omnistonManager.js';
+const buildStonfiSpecific = (quote, bidAssetAddress, askAssetAddress) => ({
+    quoteId: quote.quoteId,
+    resolverId: quote.resolverId,
+    resolverName: quote.resolverName,
+    tradeStartDeadline: quote.tradeStartDeadline,
+    gasBudget: quote.gasBudget,
+    bidAssetAddress: quote.bidAssetAddress ?? bidAssetAddress,
+    askAssetAddress: quote.askAssetAddress ?? askAssetAddress,
+    bidUnits: quote.bidUnits,
+    askUnits: quote.askUnits,
+    referrerAddress: quote.referrerAddress,
+    referrerFeeAsset: quote.referrerFeeAsset,
+    referrerFeeUnits: quote.referrerFeeUnits,
+    protocolFeeAsset: quote.protocolFeeAsset,
+    protocolFeeUnits: quote.protocolFeeUnits,
+    quoteTimestamp: quote.quoteTimestamp,
+    estimatedGasConsumption: quote.estimatedGasConsumption,
+    params: quote.params,
+});
+export const getTradeRate = async (input) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, slippageTolerancePercentageDecimal, affiliateBps, } = input;
+    const validation = validateTonAssets(sellAsset, buyAsset);
+    if (!validation.isValid) {
+        return validation.error;
+    }
+    const { bidAssetAddress, askAssetAddress } = validation;
+    const omniston = omnistonManager.getInstance();
+    try {
+        const slippageBps = slippageDecimalToBps(slippageTolerancePercentageDecimal, STONFI_DEFAULT_SLIPPAGE_BPS);
+        const referrerFeeBps = affiliateBpsToNumber(affiliateBps);
+        const tonTreasuryAddress = getTreasuryAddressFromChainId(sellAsset.chainId);
+        const referrerAddress = tonAddressToOmnistonAddress(tonTreasuryAddress);
+        const quoteResult = await waitForQuote(omniston, {
+            settlementMethods: [SettlementMethod.SETTLEMENT_METHOD_SWAP],
+            bidAssetAddress,
+            askAssetAddress,
+            amount: { bidUnits: sellAmountIncludingProtocolFeesCryptoBaseUnit },
+            referrerAddress,
+            referrerFeeBps,
+            settlementParams: {
+                maxPriceSlippageBps: slippageBps,
+                gaslessSettlement: 'GASLESS_SETTLEMENT_PROHIBITED',
+                flexibleReferrerFee: true,
+            },
+        }, STONFI_QUOTE_TIMEOUT_MS);
+        if (quoteResult.type !== 'success') {
+            return Err(makeSwapErrorRight({
+                message: `[Stonfi] No quote available for this pair`,
+                code: TradeQuoteError.NoRouteFound,
+            }));
+        }
+        const quote = quoteResult.quote;
+        const buyAmountCryptoBaseUnit = quote.askUnits;
+        const networkFeeCryptoBaseUnit = quote.gasBudget;
+        const rate = calculateRate(buyAmountCryptoBaseUnit, sellAmountIncludingProtocolFeesCryptoBaseUnit, buyAsset.precision, sellAsset.precision);
+        const tradeRate = {
+            id: quote.quoteId,
+            rate,
+            receiveAddress,
+            affiliateBps,
+            slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ?? String(STONFI_DEFAULT_SLIPPAGE_BPS / 10000),
+            quoteOrRate: 'rate',
+            swapperName: SwapperName.Stonfi,
+            steps: [
+                {
+                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    feeData: {
+                        networkFeeCryptoBaseUnit,
+                        protocolFees: undefined,
+                    },
+                    rate,
+                    source: SwapperName.Stonfi,
+                    buyAsset,
+                    sellAsset,
+                    accountNumber: undefined,
+                    allowanceContract: '0x0000000000000000000000000000000000000000',
+                    estimatedExecutionTimeMs: 30000,
+                    stonfiSpecific: buildStonfiSpecific(quote, bidAssetAddress, askAssetAddress),
+                    affiliateFee: buildAffiliateFee({
+                        strategy: 'buy_asset',
+                        affiliateBps,
+                        sellAsset,
+                        buyAsset,
+                        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                        buyAmountCryptoBaseUnit,
+                        isEstimate: true,
+                    }),
+                },
+            ],
+        };
+        return Ok([tradeRate]);
+    }
+    catch (err) {
+        return Err(makeSwapErrorRight({
+            message: `[Stonfi] Error getting rate: ${err}`,
+            code: TradeQuoteError.QueryFailed,
+            cause: err,
+        }));
+    }
+};