@shapeshiftoss/swapper 17.6.9 → 17.6.10

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,115 @@
+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 { 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),
+                },
+            ],
+        };
+        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,101 @@
+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 { 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),
+                },
+            ],
+        };
+        return Ok([tradeRate]);
+    }
+    catch (err) {
+        return Err(makeSwapErrorRight({
+            message: `[Stonfi] Error getting rate: ${err}`,
+            code: TradeQuoteError.QueryFailed,
+            cause: err,
+        }));
+    }
+};

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

@@ -0,0 +1,60 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { Quote } from '@ston-fi/omniston-sdk';
+import type { SwapErrorRight } from '../../types.js';
+export type StonfiSupportedChainId = typeof KnownChainIds.TonMainnet;
+export declare const stonfiSupportedChainIds: readonly [KnownChainIds.TonMainnet];
+export type OmnistonAssetAddress = {
+    blockchain: number;
+    address: string;
+};
+export type TonAssetValidationResult = {
+    isValid: true;
+    bidAssetAddress: OmnistonAssetAddress;
+    askAssetAddress: OmnistonAssetAddress;
+} | {
+    isValid: false;
+    error: Result<never, SwapErrorRight>;
+};
+export type QuoteResult = {
+    type: 'success';
+    quote: Quote;
+} | {
+    type: 'noQuote';
+} | {
+    type: 'timeout';
+} | {
+    type: 'error';
+    error: unknown;
+};
+export type StonfiQuote = {
+    quoteId: string;
+    resolverId: string;
+    resolverName: string;
+    bidAssetAddress: string;
+    askAssetAddress: string;
+    bidUnits: string;
+    askUnits: string;
+    gasBudget: string;
+    estimatedGasConsumption: string;
+    tradeStartDeadline: number;
+};
+export type StonfiTradeSpecific = {
+    quoteId: string;
+    resolverId: string;
+    resolverName: string;
+    tradeStartDeadline: number;
+    gasBudget: string;
+    bidAssetAddress: OmnistonAssetAddress;
+    askAssetAddress: OmnistonAssetAddress;
+    bidUnits: string;
+    askUnits: string;
+    referrerAddress?: OmnistonAssetAddress;
+    referrerFeeAsset?: OmnistonAssetAddress;
+    referrerFeeUnits: string;
+    protocolFeeAsset?: OmnistonAssetAddress;
+    protocolFeeUnits: string;
+    quoteTimestamp: number;
+    estimatedGasConsumption: string;
+    params?: unknown;
+};

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

@@ -0,0 +1,2 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export const stonfiSupportedChainIds = [KnownChainIds.TonMainnet];

package/dist/esm/swappers/StonfiSwapper/utils/constants.d.ts

@@ -0,0 +1,5 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export declare const STONFI_SUPPORTED_CHAIN_IDS: readonly [KnownChainIds.TonMainnet];
+export declare const STONFI_WEBSOCKET_URL = "wss://omni-ws.ston.fi";
+export declare const STONFI_DEFAULT_SLIPPAGE_BPS = 100;
+export declare const STONFI_QUOTE_TIMEOUT_MS = 30000;

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

@@ -0,0 +1,5 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export const STONFI_SUPPORTED_CHAIN_IDS = [KnownChainIds.TonMainnet];
+export const STONFI_WEBSOCKET_URL = 'wss://omni-ws.ston.fi';
+export const STONFI_DEFAULT_SLIPPAGE_BPS = 100;
+export const STONFI_QUOTE_TIMEOUT_MS = 30000;

package/dist/esm/swappers/StonfiSwapper/utils/helpers.d.ts

@@ -0,0 +1,11 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { Omniston, QuoteRequest } from '@ston-fi/omniston-sdk';
+import type { OmnistonAssetAddress, QuoteResult, TonAssetValidationResult } from '../types.js';
+export declare const isTonAsset: (asset: Asset) => boolean;
+export declare const assetToOmnistonAddress: (asset: Asset) => OmnistonAssetAddress | null;
+export declare const validateTonAssets: (sellAsset: Asset, buyAsset: Asset) => TonAssetValidationResult;
+export declare const calculateRate: (buyAmountCryptoBaseUnit: string, sellAmountCryptoBaseUnit: string, buyAssetPrecision: number, sellAssetPrecision: number) => string;
+export declare const slippageDecimalToBps: (slippageTolerancePercentageDecimal: string | undefined, defaultSlippageBps: number) => number;
+export declare const tonAddressToOmnistonAddress: (address: string) => OmnistonAssetAddress;
+export declare const affiliateBpsToNumber: (affiliateBps: string | undefined) => number;
+export declare const waitForQuote: (omniston: Omniston, request: QuoteRequest, timeoutMs: number) => Promise<QuoteResult>;