@shapeshiftoss/swapper 17.6.8 → 17.6.10

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>;

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

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeQuote = void 0;
+const monads_1 = require("@sniptt/monads");
+const omniston_sdk_1 = require("@ston-fi/omniston-sdk");
+const types_1 = require("../../../types");
+const utils_1 = require("../../../utils");
+const helpers_1 = require("../../utils/helpers/helpers");
+const constants_1 = require("../utils/constants");
+const helpers_2 = require("../utils/helpers");
+const omnistonManager_1 = require("../utils/omnistonManager");
+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,
+});
+const getTradeQuote = async (input) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, accountNumber, slippageTolerancePercentageDecimal, affiliateBps, } = input;
+    const validation = (0, helpers_2.validateTonAssets)(sellAsset, buyAsset);
+    if (!validation.isValid) {
+        return validation.error;
+    }
+    const { bidAssetAddress, askAssetAddress } = validation;
+    const omniston = omnistonManager_1.omnistonManager.getInstance();
+    try {
+        const slippageBps = (0, helpers_2.slippageDecimalToBps)(slippageTolerancePercentageDecimal, constants_1.STONFI_DEFAULT_SLIPPAGE_BPS);
+        const referrerFeeBps = (0, helpers_2.affiliateBpsToNumber)(affiliateBps);
+        const tonTreasuryAddress = (0, helpers_1.getTreasuryAddressFromChainId)(sellAsset.chainId);
+        const referrerAddress = (0, helpers_2.tonAddressToOmnistonAddress)(tonTreasuryAddress);
+        const quoteResult = await (0, helpers_2.waitForQuote)(omniston, {
+            settlementMethods: [omniston_sdk_1.SettlementMethod.SETTLEMENT_METHOD_SWAP],
+            bidAssetAddress,
+            askAssetAddress,
+            amount: { bidUnits: sellAmountIncludingProtocolFeesCryptoBaseUnit },
+            referrerAddress,
+            referrerFeeBps,
+            settlementParams: {
+                maxPriceSlippageBps: slippageBps,
+                gaslessSettlement: 'GASLESS_SETTLEMENT_PROHIBITED',
+                flexibleReferrerFee: true,
+            },
+        }, constants_1.STONFI_QUOTE_TIMEOUT_MS);
+        if (quoteResult.type === 'error') {
+            console.error('[Stonfi] Quote request error:', quoteResult.error);
+            return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+                message: `[Stonfi] Connection error while fetching quote`,
+                code: types_1.TradeQuoteError.QueryFailed,
+                cause: quoteResult.error,
+            }));
+        }
+        if (quoteResult.type === 'timeout') {
+            return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+                message: `[Stonfi] Quote request timed out`,
+                code: types_1.TradeQuoteError.QueryFailed,
+            }));
+        }
+        if (quoteResult.type === 'noQuote') {
+            return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+                message: `[Stonfi] No quote available for this pair`,
+                code: types_1.TradeQuoteError.NoRouteFound,
+            }));
+        }
+        const quote = quoteResult.quote;
+        const buyAmountCryptoBaseUnit = quote.askUnits;
+        const networkFeeCryptoBaseUnit = quote.gasBudget;
+        const rate = (0, helpers_2.calculateRate)(buyAmountCryptoBaseUnit, sellAmountIncludingProtocolFeesCryptoBaseUnit, buyAsset.precision, sellAsset.precision);
+        const tradeQuote = {
+            id: quote.quoteId,
+            rate,
+            receiveAddress,
+            affiliateBps,
+            slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ?? String(constants_1.STONFI_DEFAULT_SLIPPAGE_BPS / 10000),
+            quoteOrRate: 'quote',
+            swapperName: types_1.SwapperName.Stonfi,
+            steps: [
+                {
+                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    feeData: {
+                        networkFeeCryptoBaseUnit,
+                        protocolFees: undefined,
+                    },
+                    rate,
+                    source: types_1.SwapperName.Stonfi,
+                    buyAsset,
+                    sellAsset,
+                    accountNumber,
+                    allowanceContract: '0x0',
+                    estimatedExecutionTimeMs: 30000,
+                    stonfiSpecific: buildStonfiSpecific(quote, bidAssetAddress, askAssetAddress),
+                },
+            ],
+        };
+        return (0, monads_1.Ok)([tradeQuote]);
+    }
+    catch (err) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `[Stonfi] Error getting quote: ${err}`,
+            code: types_1.TradeQuoteError.QueryFailed,
+            cause: err,
+        }));
+    }
+};
+exports.getTradeQuote = getTradeQuote;

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

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

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

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeRate = void 0;
+const monads_1 = require("@sniptt/monads");
+const omniston_sdk_1 = require("@ston-fi/omniston-sdk");
+const types_1 = require("../../../types");
+const utils_1 = require("../../../utils");
+const helpers_1 = require("../../utils/helpers/helpers");
+const constants_1 = require("../utils/constants");
+const helpers_2 = require("../utils/helpers");
+const omnistonManager_1 = require("../utils/omnistonManager");
+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,
+});
+const getTradeRate = async (input) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, slippageTolerancePercentageDecimal, affiliateBps, } = input;
+    const validation = (0, helpers_2.validateTonAssets)(sellAsset, buyAsset);
+    if (!validation.isValid) {
+        return validation.error;
+    }
+    const { bidAssetAddress, askAssetAddress } = validation;
+    const omniston = omnistonManager_1.omnistonManager.getInstance();
+    try {
+        const slippageBps = (0, helpers_2.slippageDecimalToBps)(slippageTolerancePercentageDecimal, constants_1.STONFI_DEFAULT_SLIPPAGE_BPS);
+        const referrerFeeBps = (0, helpers_2.affiliateBpsToNumber)(affiliateBps);
+        const tonTreasuryAddress = (0, helpers_1.getTreasuryAddressFromChainId)(sellAsset.chainId);
+        const referrerAddress = (0, helpers_2.tonAddressToOmnistonAddress)(tonTreasuryAddress);
+        const quoteResult = await (0, helpers_2.waitForQuote)(omniston, {
+            settlementMethods: [omniston_sdk_1.SettlementMethod.SETTLEMENT_METHOD_SWAP],
+            bidAssetAddress,
+            askAssetAddress,
+            amount: { bidUnits: sellAmountIncludingProtocolFeesCryptoBaseUnit },
+            referrerAddress,
+            referrerFeeBps,
+            settlementParams: {
+                maxPriceSlippageBps: slippageBps,
+                gaslessSettlement: 'GASLESS_SETTLEMENT_PROHIBITED',
+                flexibleReferrerFee: true,
+            },
+        }, constants_1.STONFI_QUOTE_TIMEOUT_MS);
+        if (quoteResult.type !== 'success') {
+            return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+                message: `[Stonfi] No quote available for this pair`,
+                code: types_1.TradeQuoteError.NoRouteFound,
+            }));
+        }
+        const quote = quoteResult.quote;
+        const buyAmountCryptoBaseUnit = quote.askUnits;
+        const networkFeeCryptoBaseUnit = quote.gasBudget;
+        const rate = (0, helpers_2.calculateRate)(buyAmountCryptoBaseUnit, sellAmountIncludingProtocolFeesCryptoBaseUnit, buyAsset.precision, sellAsset.precision);
+        const tradeRate = {
+            id: quote.quoteId,
+            rate,
+            receiveAddress,
+            affiliateBps,
+            slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ?? String(constants_1.STONFI_DEFAULT_SLIPPAGE_BPS / 10000),
+            quoteOrRate: 'rate',
+            swapperName: types_1.SwapperName.Stonfi,
+            steps: [
+                {
+                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit: buyAmountCryptoBaseUnit,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    feeData: {
+                        networkFeeCryptoBaseUnit,
+                        protocolFees: undefined,
+                    },
+                    rate,
+                    source: types_1.SwapperName.Stonfi,
+                    buyAsset,
+                    sellAsset,
+                    accountNumber: undefined,
+                    allowanceContract: '0x0000000000000000000000000000000000000000',
+                    estimatedExecutionTimeMs: 30000,
+                    stonfiSpecific: buildStonfiSpecific(quote, bidAssetAddress, askAssetAddress),
+                },
+            ],
+        };
+        return (0, monads_1.Ok)([tradeRate]);
+    }
+    catch (err) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `[Stonfi] Error getting rate: ${err}`,
+            code: types_1.TradeQuoteError.QueryFailed,
+            cause: err,
+        }));
+    }
+};
+exports.getTradeRate = getTradeRate;

package/dist/cjs/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';
+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/cjs/swappers/StonfiSwapper/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stonfiSupportedChainIds = void 0;
+const types_1 = require("@shapeshiftoss/types");
+exports.stonfiSupportedChainIds = [types_1.KnownChainIds.TonMainnet];

package/dist/cjs/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/cjs/swappers/StonfiSwapper/utils/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STONFI_QUOTE_TIMEOUT_MS = exports.STONFI_DEFAULT_SLIPPAGE_BPS = exports.STONFI_WEBSOCKET_URL = exports.STONFI_SUPPORTED_CHAIN_IDS = void 0;
+const types_1 = require("@shapeshiftoss/types");
+exports.STONFI_SUPPORTED_CHAIN_IDS = [types_1.KnownChainIds.TonMainnet];
+exports.STONFI_WEBSOCKET_URL = 'wss://omni-ws.ston.fi';
+exports.STONFI_DEFAULT_SLIPPAGE_BPS = 100;
+exports.STONFI_QUOTE_TIMEOUT_MS = 30000;

package/dist/cjs/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';
+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>;