@shapeshiftoss/swapper 17.6.9 → 17.6.10

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

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForQuote = exports.affiliateBpsToNumber = exports.tonAddressToOmnistonAddress = exports.slippageDecimalToBps = exports.calculateRate = exports.validateTonAssets = exports.assetToOmnistonAddress = exports.isTonAsset = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const types_1 = require("@shapeshiftoss/types");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const omniston_sdk_1 = require("@ston-fi/omniston-sdk");
+const types_2 = require("../../../types");
+const utils_2 = require("../../../utils");
+const isTonAsset = (asset) => {
+    return asset.chainId === types_1.KnownChainIds.TonMainnet;
+};
+exports.isTonAsset = isTonAsset;
+const assetToOmnistonAddress = (asset) => {
+    if (!(0, exports.isTonAsset)(asset))
+        return null;
+    const { assetNamespace, assetReference } = (0, caip_1.fromAssetId)(asset.assetId);
+    if (assetNamespace === 'slip44') {
+        return {
+            blockchain: omniston_sdk_1.Blockchain.TON,
+            address: 'EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c',
+        };
+    }
+    if (assetNamespace === 'jetton') {
+        return { blockchain: omniston_sdk_1.Blockchain.TON, address: assetReference };
+    }
+    return null;
+};
+exports.assetToOmnistonAddress = assetToOmnistonAddress;
+const validateTonAssets = (sellAsset, buyAsset) => {
+    if (sellAsset.chainId !== types_1.KnownChainIds.TonMainnet) {
+        return {
+            isValid: false,
+            error: (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: `[Stonfi] Unsupported sell asset chain: ${sellAsset.chainId}`,
+                code: types_2.TradeQuoteError.UnsupportedChain,
+            })),
+        };
+    }
+    if (buyAsset.chainId !== types_1.KnownChainIds.TonMainnet) {
+        return {
+            isValid: false,
+            error: (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: `[Stonfi] Cross-chain swaps not supported`,
+                code: types_2.TradeQuoteError.CrossChainNotSupported,
+            })),
+        };
+    }
+    const bidAssetAddress = (0, exports.assetToOmnistonAddress)(sellAsset);
+    const askAssetAddress = (0, exports.assetToOmnistonAddress)(buyAsset);
+    if (!bidAssetAddress || !askAssetAddress) {
+        return {
+            isValid: false,
+            error: (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: `[Stonfi] Unable to convert assets to Omniston addresses`,
+                code: types_2.TradeQuoteError.UnsupportedTradePair,
+            })),
+        };
+    }
+    return {
+        isValid: true,
+        bidAssetAddress,
+        askAssetAddress,
+    };
+};
+exports.validateTonAssets = validateTonAssets;
+const calculateRate = (buyAmountCryptoBaseUnit, sellAmountCryptoBaseUnit, buyAssetPrecision, sellAssetPrecision) => {
+    if ((0, utils_1.bn)(buyAmountCryptoBaseUnit).gt(0) && (0, utils_1.bn)(sellAmountCryptoBaseUnit).gt(0)) {
+        return (0, utils_1.convertPrecision)({
+            value: buyAmountCryptoBaseUnit,
+            inputExponent: buyAssetPrecision,
+            outputExponent: sellAssetPrecision,
+        })
+            .dividedBy((0, utils_1.bn)(sellAmountCryptoBaseUnit))
+            .toFixed();
+    }
+    return '0';
+};
+exports.calculateRate = calculateRate;
+const slippageDecimalToBps = (slippageTolerancePercentageDecimal, defaultSlippageBps) => {
+    if (!slippageTolerancePercentageDecimal) {
+        return defaultSlippageBps;
+    }
+    const parsed = parseFloat(slippageTolerancePercentageDecimal);
+    if (Number.isNaN(parsed) || !Number.isFinite(parsed) || parsed < 0) {
+        return defaultSlippageBps;
+    }
+    return Math.round(parsed * 10000);
+};
+exports.slippageDecimalToBps = slippageDecimalToBps;
+const tonAddressToOmnistonAddress = (address) => {
+    return {
+        blockchain: omniston_sdk_1.Blockchain.TON,
+        address,
+    };
+};
+exports.tonAddressToOmnistonAddress = tonAddressToOmnistonAddress;
+const affiliateBpsToNumber = (affiliateBps) => {
+    if (!affiliateBps)
+        return 0;
+    const parsed = parseInt(affiliateBps, 10);
+    if (Number.isNaN(parsed) || !Number.isFinite(parsed) || parsed < 0)
+        return 0;
+    return parsed;
+};
+exports.affiliateBpsToNumber = affiliateBpsToNumber;
+const waitForQuote = (omniston, request, timeoutMs) => {
+    return new Promise(resolve => {
+        const timer = setTimeout(() => {
+            subscription.unsubscribe();
+            resolve({ type: 'timeout' });
+        }, timeoutMs);
+        const subscription = omniston.requestForQuote(request).subscribe({
+            next: (event) => {
+                if (event.type === 'quoteUpdated' && event.quote) {
+                    clearTimeout(timer);
+                    subscription.unsubscribe();
+                    resolve({ type: 'success', quote: event.quote });
+                }
+                else if (event.type === 'noQuote') {
+                    clearTimeout(timer);
+                    subscription.unsubscribe();
+                    resolve({ type: 'noQuote' });
+                }
+            },
+            error: err => {
+                clearTimeout(timer);
+                subscription.unsubscribe();
+                resolve({ type: 'error', error: err });
+            },
+        });
+    });
+};
+exports.waitForQuote = waitForQuote;

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

@@ -0,0 +1,5 @@
+import { Omniston } from '@ston-fi/omniston-sdk';
+export declare const omnistonManager: {
+    getInstance: () => Omniston;
+    disconnect: () => void;
+};

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.omnistonManager = void 0;
+const omniston_sdk_1 = require("@ston-fi/omniston-sdk");
+const constants_1 = require("./constants");
+let cachedOmniston = null;
+exports.omnistonManager = {
+    getInstance: () => {
+        if (!cachedOmniston) {
+            cachedOmniston = new omniston_sdk_1.Omniston({ apiUrl: constants_1.STONFI_WEBSOCKET_URL });
+        }
+        return cachedOmniston;
+    },
+    disconnect: () => {
+        if (cachedOmniston) {
+            cachedOmniston.close();
+            cachedOmniston = null;
+        }
+    },
+};

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

@@ -46,7 +46,7 @@ exports.sunioApi = {
         const tronWeb = new tronweb_1.TronWeb({
             fullHost: rpcUrl,
         });
-        const routeParams = (0, buildSwapRouteParameters_1.buildSwapRouteParameters)(sunioMetadata.route, step.sellAmountIncludingProtocolFeesCryptoBaseUnit, step.buyAmountAfterFeesCryptoBaseUnit, from, slippageTolerancePercentageDecimal);
+        const routeParams = (0, buildSwapRouteParameters_1.buildSwapRouteParameters)(sunioMetadata.route, step.sellAmountIncludingProtocolFeesCryptoBaseUnit, step.buyAmountAfterFeesCryptoBaseUnit, tradeQuote.receiveAddress, slippageTolerancePercentageDecimal);
         const parameters = [
             { type: 'address[]', value: routeParams.path },
             { type: 'string[]', value: routeParams.poolVersion },

package/dist/cjs/swappers/SunioSwapper/utils/getQuoteOrRate.js

@@ -136,9 +136,10 @@ async function getQuoteOrRate(input, deps) {
                 }
             }
         }
-        const buyAmountCryptoBaseUnit = (0, utils_1.bn)(bestRoute.amountOut)
-            .times((0, utils_1.bn)(10).pow(buyAsset.precision))
-            .toFixed(0);
+        const buyAmountCryptoBaseUnit = utils_1.BigAmount.fromPrecision({
+            value: bestRoute.amountOut,
+            precision: buyAsset.precision,
+        }).toBaseUnit();
         // Calculate protocol fees only for quotes
         const protocolFeeCryptoBaseUnit = isQuote
             ? (0, utils_1.bn)(bestRoute.fee).times(sellAmountIncludingProtocolFeesCryptoBaseUnit).toFixed(0)

package/dist/cjs/swappers/ZrxSwapper/utils/helpers/helpers.d.ts

@@ -8,7 +8,7 @@ export declare const isSupportedChainId: (chainId: ChainId) => chainId is KnownC
 export declare const assertValidTrade: ({ buyAsset, sellAsset, }: {
     buyAsset: Asset;
     sellAsset: Asset;
-}) => import("@sniptt/monads/build/result/result").ResOk<boolean, never> | import("@sniptt/monads/build/result/result").ResErr<unknown, import("../../../../types").SwapErrorRight>;
+}) => import("@sniptt/monads/build/result/result").ResErr<unknown, import("../../../../types").SwapErrorRight> | import("@sniptt/monads/build/result/result").ResOk<boolean, never>;
 export declare const calculateRate: ({ buyAmount, sellAmount, buyAsset, sellAsset, }: {
     buyAmount: string;
     sellAmount: string;

package/dist/cjs/swappers/utils/filterBuyAssetsBySellAssetId/filterBuyAssetsBySellAssetId.js

@@ -1,17 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.filterCrossChainEvmBuyAssetsBySellAssetId = exports.filterSameChainEvmBuyAssetsBySellAssetId = void 0;
-const caip_1 = require("@shapeshiftoss/caip");
 const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
 const _filterEvmBuyAssetsBySellAssetId = ({ assets, sellAsset }, chainIdPredicate) => {
     // evm only
     if (!(0, chain_adapters_1.isEvmChainId)(sellAsset.chainId))
         return [];
     return assets.filter(buyAsset => {
-        // evm only AND chain id predicate with no arbitrum nova support for any swappers
-        return ((0, chain_adapters_1.isEvmChainId)(buyAsset.chainId) &&
-            chainIdPredicate(buyAsset.chainId, sellAsset.chainId) &&
-            buyAsset.chainId !== caip_1.arbitrumNovaChainId);
+        // evm only AND chain id predicate
+        return (0, chain_adapters_1.isEvmChainId)(buyAsset.chainId) && chainIdPredicate(buyAsset.chainId, sellAsset.chainId);
     });
 };
 const filterSameChainEvmBuyAssetsBySellAssetId = (input) => {

package/dist/cjs/swappers/utils/helpers/helpers.js

@@ -46,6 +46,9 @@ const DAO_TREASURY_BY_CHAIN_ID = {
     [types_1.KnownChainIds.SolanaMainnet]: utils_1.DAO_TREASURY_SOLANA,
     [types_1.KnownChainIds.BitcoinMainnet]: utils_1.DAO_TREASURY_BITCOIN,
     [types_1.KnownChainIds.StarknetMainnet]: utils_1.DAO_TREASURY_STARKNET,
+    [types_1.KnownChainIds.TonMainnet]: utils_1.DAO_TREASURY_TON,
+    [types_1.KnownChainIds.MonadMainnet]: utils_1.DAO_TREASURY_MONAD,
+    [types_1.KnownChainIds.HyperEvmMainnet]: utils_1.DAO_TREASURY_HYPEREVM,
 };
 const getTreasuryAddressFromChainId = (chainId) => {
     const maybeTreasuryChainId = (0, utils_1.isTreasuryChainId)(chainId) ? chainId : undefined;

package/dist/cjs/thorchain-utils/getCallDataFromQuote.d.ts

@@ -1,7 +1,7 @@
 import type { Asset } from '@shapeshiftoss/types';
 import type { SwapperConfig, SwapperName } from '../types';
 import type { ThorEvmTradeQuote } from './types';
-export declare const getCallDataFromQuote: ({ tradeType, data, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, memo: tcMemo, expiry, config, longtailData, slippageTolerancePercentageDecimal, vault, swapperName, }: Pick<ThorEvmTradeQuote, "data" | "slippageTolerancePercentageDecimal" | "memo" | "aggregator" | "vault" | "expiry" | "tradeType" | "longtailData"> & {
+export declare const getCallDataFromQuote: ({ tradeType, data, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, memo: tcMemo, expiry, config, longtailData, slippageTolerancePercentageDecimal, vault, swapperName, }: Pick<ThorEvmTradeQuote, "data" | "slippageTolerancePercentageDecimal" | "memo" | "expiry" | "tradeType" | "aggregator" | "vault" | "longtailData"> & {
     sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
     config: SwapperConfig;
     sellAsset: Asset;

package/dist/cjs/thorchain-utils/getL1RateOrQuote.js

@@ -101,7 +101,13 @@ const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType, swapp
         : '0';
     const getRouteBuyAmountBeforeFeesCryptoBaseUnit = (quote) => {
         const buyAmountBeforeFeesCryptoThorPrecision = (0, utils_1.bn)(quote.expected_amount_out).plus(quote.fees.total);
-        return (0, utils_1.toBaseUnit)((0, utils_1.fromBaseUnit)(buyAmountBeforeFeesCryptoThorPrecision, buyAssetNativePrecision), buyAsset.precision);
+        return utils_1.BigAmount.fromPrecision({
+            value: utils_1.BigAmount.fromBaseUnit({
+                value: buyAmountBeforeFeesCryptoThorPrecision,
+                precision: buyAssetNativePrecision,
+            }).toPrecision(),
+            precision: buyAsset.precision,
+        }).toBaseUnit();
     };
     const getProtocolFees = (quote) => {
         // Fees consist of liquidity, outbound, and affiliate fees
@@ -241,7 +247,11 @@ const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType, swapp
             const sellAdapter = assertGetUtxoChainAdapter(sellAsset.chainId);
             const maybeRoutes = await Promise.allSettled(perRouteValues.map(async (route) => {
                 const memo = getMemo(route);
-                const { vault } = await utxo.getThorTxData({ sellAsset, config, swapperName });
+                const { vault } = await utxo.getThorTxData({
+                    sellAsset,
+                    config,
+                    swapperName,
+                });
                 const feeData = await (async () => {
                     const protocolFees = getProtocolFees(route.quote);
                     // This is a rate without a wallet connected, so we can't get fees
@@ -310,9 +320,15 @@ const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType, swapp
                         const { sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = input;
                         const contractAddress = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
                         // Get vault address
-                        const { vault } = await tron.getThorTxData({ sellAsset, config, swapperName });
+                        const { vault } = await tron.getThorTxData({
+                            sellAsset,
+                            config,
+                            swapperName,
+                        });
                         // Estimate fees using the receive address for accurate energy calculation
-                        const tronWeb = new tronweb_1.TronWeb({ fullHost: deps.config.VITE_TRON_NODE_URL });
+                        const tronWeb = new tronweb_1.TronWeb({
+                            fullHost: deps.config.VITE_TRON_NODE_URL,
+                        });
                         const params = await tronWeb.trx.getChainParameters();
                         const bandwidthPrice = params.find(p => p.key === 'getTransactionFee')?.value ?? 1000;
                         const energyPrice = params.find(p => p.key === 'getEnergyFee')?.value ?? 100;
@@ -322,7 +338,10 @@ const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType, swapp
                             try {
                                 const result = await tronWeb.transactionBuilder.triggerConstantContract(contractAddress, 'transfer(address,uint256)', {}, [
                                     { type: 'address', value: vault },
-                                    { type: 'uint256', value: sellAmountIncludingProtocolFeesCryptoBaseUnit },
+                                    {
+                                        type: 'uint256',
+                                        value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                                    },
                                 ], input.receiveAddress);
                                 const energyUsed = result.energy_used ?? 65000;
                                 const energyFee = energyUsed * energyPrice * 1.5; // 1.5x safety margin
@@ -387,6 +406,12 @@ const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType, swapp
                 code: types_1.TradeQuoteError.UnsupportedTradePair,
             }));
         }
+        case caip_1.CHAIN_NAMESPACE.Ton: {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: 'TON is not supported',
+                code: types_1.TradeQuoteError.UnsupportedTradePair,
+            }));
+        }
         default:
             return (0, utils_1.assertUnreachable)(chainNamespace);
     }

package/dist/cjs/thorchain-utils/getQuote.js

@@ -25,9 +25,15 @@ const getQuote = async (input, deps) => {
     });
     const buyPoolId = (0, index_1.getPoolAssetId)({ assetId: buyAssetId, swapperName });
     const sellPoolId = (0, index_1.getPoolAssetId)({ assetId: sellAsset.assetId, swapperName });
-    const sellAmountCryptoPrecision = (0, utils_1.fromBaseUnit)(sellAmountCryptoBaseUnit, sellAsset.precision);
+    const sellAmountCryptoPrecision = utils_1.BigAmount.fromBaseUnit({
+        value: sellAmountCryptoBaseUnit,
+        precision: sellAsset.precision,
+    }).toPrecision();
     // All pool amounts are native precision regardless of token precision
-    const sellAmountCryptoThorBaseUnit = (0, utils_1.bn)((0, utils_1.toBaseUnit)(sellAmountCryptoPrecision, (0, index_1.getNativePrecision)(sellAsset.assetId, swapperName)));
+    const sellAmountCryptoThorBaseUnit = (0, utils_1.bn)(utils_1.BigAmount.fromPrecision({
+        value: sellAmountCryptoPrecision,
+        precision: (0, index_1.getNativePrecision)(sellAsset.assetId, swapperName),
+    }).toBaseUnit());
     // The swap endpoint expects BCH receiveAddress's to be stripped of the "bitcoincash:" prefix
     const parsedReceiveAddress = receiveAddress && buyAssetId === caip_1.bchAssetId
         ? receiveAddress.replace('bitcoincash:', '')

package/dist/cjs/tron-utils/getUnsignedTronTransaction.js

@@ -1,19 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getUnsignedTronTransaction = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
 const utils_1 = require("@shapeshiftoss/utils");
 const utils_2 = require("../utils");
 const getUnsignedTronTransaction = ({ stepIndex, tradeQuote, from, assertGetTronChainAdapter, }) => {
     if (!(0, utils_2.isExecutableTradeQuote)(tradeQuote))
         throw new Error('Unable to execute a trade rate quote');
     const step = (0, utils_2.getExecutableTradeStep)(tradeQuote, stepIndex);
-    const { accountNumber, sellAsset, relayTransactionMetadata, nearIntentsSpecific } = step;
+    const { accountNumber, sellAsset, relayTransactionMetadata, nearIntentsSpecific, butterSwapTransactionMetadata, } = step;
     const adapter = assertGetTronChainAdapter(sellAsset.chainId);
+    if (butterSwapTransactionMetadata) {
+        const { to, data, method, args, value: butterValue } = butterSwapTransactionMetadata;
+        if (!to)
+            throw new Error('Missing Butter swap contract address');
+        if (!data)
+            throw new Error('Missing Butter swap transaction data');
+        // Use Butter's value field which includes swap fees for same-chain swaps
+        // For native TRX sells, also include the sell amount
+        const isNativeTron = sellAsset.assetId === caip_1.tronAssetId;
+        const value = isNativeTron ? step.sellAmountIncludingProtocolFeesCryptoBaseUnit : butterValue;
+        return adapter.buildCustomApiTx({
+            from,
+            to,
+            accountNumber,
+            data,
+            value,
+            method,
+            args,
+        });
+    }
     const to = relayTransactionMetadata?.to ?? nearIntentsSpecific?.depositAddress;
     if (!to)
         throw new Error('Missing transaction destination address');
     const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
-    // Extract contract address for TRC20 tokens
     const contractAddress = (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
     return adapter.buildSendApiTransaction({
         to,

package/dist/cjs/types.d.ts

@@ -1,8 +1,8 @@
 import type { QuoteResponse } from '@jup-ag/api';
 import type { AccountId, AssetId, ChainId, Nominal } from '@shapeshiftoss/caip';
-import type { ChainAdapter, CosmosSdkChainAdapter, EvmChainAdapter, near, SignTx, solana, starknet, sui, tron, UtxoChainAdapter } from '@shapeshiftoss/chain-adapters';
+import type { ChainAdapter, CosmosSdkChainAdapter, EvmChainAdapter, near, SignTx, solana, starknet, sui, ton, tron, UtxoChainAdapter } from '@shapeshiftoss/chain-adapters';
 import type { HDWallet, SolanaSignTx, StarknetSignTx, SuiSignTx } from '@shapeshiftoss/hdwallet-core';
-import type { AccountMetadata, Asset, AssetsByIdPartial, CosmosSdkChainId, EvmChainId, KnownChainIds, NearChainId, OrderQuoteResponse, PartialRecord, TronChainId, UtxoAccountType, UtxoChainId } from '@shapeshiftoss/types';
+import type { AccountMetadata, Asset, AssetsByIdPartial, CosmosSdkChainId, EvmChainId, KnownChainIds, NearChainId, OrderQuoteResponse, PartialRecord, TonChainId, TronChainId, UtxoAccountType, UtxoChainId } from '@shapeshiftoss/types';
 import type { TxStatus } from '@shapeshiftoss/unchained-client';
 import type { Result } from '@sniptt/monads';
 import type { TransactionInstruction } from '@solana/web3.js';
@@ -11,6 +11,7 @@ import type { Mixpanel } from 'mixpanel-browser';
 import type Polyglot from 'node-polyglot';
 import type { InterpolationOptions } from 'node-polyglot';
 import type { Address, Hex } from 'viem';
+import type { AcrossTransactionMetadata } from './swappers/AcrossSwapper/utils/types';
 import type { CowMessageToSign } from './swappers/CowSwapper/types';
 import type { RelayTransactionMetadata } from './swappers/RelaySwapper/utils/types';
 import type { makeSwapperAxiosServiceMonadic } from './utils';
@@ -47,6 +48,8 @@ export type SwapperConfig = {
     VITE_TENDERLY_ACCOUNT_SLUG: string;
     VITE_TENDERLY_PROJECT_SLUG: string;
     VITE_SUI_NODE_URL: string;
+    VITE_ACROSS_API_URL: string;
+    VITE_ACROSS_INTEGRATOR_ID: string;
 };
 export declare enum SwapperName {
     Thorchain = "THORChain",
@@ -64,7 +67,9 @@ export declare enum SwapperName {
     NearIntents = "NEAR Intents",
     Cetus = "Cetus",
     Sunio = "Sun.io",
-    Avnu = "AVNU"
+    Avnu = "AVNU",
+    Stonfi = "STON.fi",
+    Across = "Across"
 }
 export type SwapSource = SwapperName | `${SwapperName} • ${string}`;
 export type SwapErrorRight = {
@@ -183,6 +188,15 @@ export type GetNearTradeQuoteInput = CommonTradeInput & {
 export type GetNearTradeRateInput = CommonTradeRateInput & {
     chainId: NearChainId;
 };
+export type GetTonTradeQuoteInputBase = CommonTradeInput & {
+    chainId: TonChainId;
+};
+export type GetTonTradeQuoteInput = CommonTradeInput & {
+    chainId: TonChainId;
+};
+export type GetTonTradeRateInput = CommonTradeRateInput & {
+    chainId: TonChainId;
+};
 type GetUtxoTradeQuoteWithWallet = CommonTradeQuoteInput & {
     chainId: UtxoChainId;
     accountType: UtxoAccountType;
@@ -196,9 +210,9 @@ export type GetUtxoTradeRateInput = CommonTradeRateInput & {
     xpub: string | undefined;
 };
 export type GetUtxoTradeQuoteInput = GetUtxoTradeQuoteWithWallet;
-export type GetTradeQuoteInput = GetUtxoTradeQuoteInput | GetEvmTradeQuoteInput | GetCosmosSdkTradeQuoteInput | GetTronTradeQuoteInput | GetNearTradeQuoteInput;
-export type GetTradeRateInput = GetEvmTradeRateInput | GetCosmosSdkTradeRateInput | GetUtxoTradeRateInput | GetTronTradeRateInput | GetNearTradeRateInput;
-export type GetTradeQuoteInputWithWallet = GetUtxoTradeQuoteWithWallet | GetEvmTradeQuoteInputBase | GetCosmosSdkTradeQuoteInputBase | GetTronTradeQuoteInputBase | GetNearTradeQuoteInputBase;
+export type GetTradeQuoteInput = GetUtxoTradeQuoteInput | GetEvmTradeQuoteInput | GetCosmosSdkTradeQuoteInput | GetTronTradeQuoteInput | GetNearTradeQuoteInput | GetTonTradeQuoteInput;
+export type GetTradeRateInput = GetEvmTradeRateInput | GetCosmosSdkTradeRateInput | GetUtxoTradeRateInput | GetTronTradeRateInput | GetNearTradeRateInput | GetTonTradeRateInput;
+export type GetTradeQuoteInputWithWallet = GetUtxoTradeQuoteWithWallet | GetEvmTradeQuoteInputBase | GetCosmosSdkTradeQuoteInputBase | GetTronTradeQuoteInputBase | GetNearTradeQuoteInputBase | GetTonTradeQuoteInputBase;
 export type EvmSwapperDeps = {
     assertGetEvmChainAdapter: (chainId: ChainId) => EvmChainAdapter;
     fetchIsSmartContractAddressQuery: (userAddress: string, chainId: ChainId) => Promise<boolean>;
@@ -224,12 +238,15 @@ export type NearSwapperDeps = {
 export type StarknetSwapperDeps = {
     assertGetStarknetChainAdapter: (chainId: ChainId) => starknet.ChainAdapter;
 };
+export type TonSwapperDeps = {
+    assertGetTonChainAdapter: (chainId: ChainId) => ton.ChainAdapter;
+};
 export type SwapperDeps = {
     assetsById: AssetsByIdPartial;
     config: SwapperConfig;
     mixPanel: Mixpanel | undefined;
     assertGetChainAdapter: (chainId: ChainId) => ChainAdapter<KnownChainIds>;
-} & EvmSwapperDeps & UtxoSwapperDeps & CosmosSdkSwapperDeps & SolanaSwapperDeps & TronSwapperDeps & SuiSwapperDeps & NearSwapperDeps & StarknetSwapperDeps;
+} & EvmSwapperDeps & UtxoSwapperDeps & CosmosSdkSwapperDeps & SolanaSwapperDeps & TronSwapperDeps & SuiSwapperDeps & NearSwapperDeps & StarknetSwapperDeps & TonSwapperDeps;
 export type TradeQuoteStep = {
     buyAmountBeforeFeesCryptoBaseUnit: string;
     buyAmountAfterFeesCryptoBaseUnit: string;
@@ -297,6 +314,13 @@ export type TradeQuoteStep = {
         data: string;
         value: Hex;
         gasLimit: string;
+        method?: string;
+        args?: {
+            type: string;
+            value: unknown;
+        }[];
+        memo?: string;
+        serializedSolanaTransaction?: string;
     };
     sunioTransactionMetadata?: {
         route: {
@@ -317,6 +341,41 @@ export type TradeQuoteStep = {
         quoteId: string;
         routes: any[];
     };
+    stonfiSpecific?: {
+        quoteId: string;
+        resolverId: string;
+        resolverName: string;
+        tradeStartDeadline: number;
+        gasBudget: string;
+        bidAssetAddress: {
+            blockchain: number;
+            address: string;
+        };
+        askAssetAddress: {
+            blockchain: number;
+            address: string;
+        };
+        bidUnits: string;
+        askUnits: string;
+        referrerAddress?: {
+            blockchain: number;
+            address: string;
+        };
+        referrerFeeAsset?: {
+            blockchain: number;
+            address: string;
+        };
+        referrerFeeUnits: string;
+        protocolFeeAsset?: {
+            blockchain: number;
+            address: string;
+        };
+        protocolFeeUnits: string;
+        quoteTimestamp: number;
+        estimatedGasConsumption: string;
+        params?: unknown;
+    };
+    acrossTransactionMetadata?: AcrossTransactionMetadata;
 };
 export type TradeRateStep = Omit<TradeQuoteStep, 'accountNumber'> & {
     accountNumber: undefined;
@@ -370,6 +429,7 @@ export type SwapperSpecificMetadata = {
         deadline: string;
     };
     relayTransactionMetadata: RelayTransactionMetadata | undefined;
+    acrossTransactionMetadata: AcrossTransactionMetadata | undefined;
     relayerExplorerTxLink: string | undefined;
     relayerTxHash: string | undefined;
     stepIndex: SupportedTradeQuoteStepIndex;
@@ -475,6 +535,9 @@ export type NearTransactionExecutionProps = {
 export type StarknetTransactionExecutionProps = {
     signAndBroadcastTransaction: (txToSign: StarknetSignTx) => Promise<string>;
 };
+export type TonTransactionExecutionProps = {
+    signAndBroadcastTransaction: (txToSign: ton.TonSignTx) => Promise<string>;
+};
 type EvmAccountMetadata = {
     from: string;
 };
@@ -517,6 +580,10 @@ export type GetUnsignedTronTransactionArgs = CommonGetUnsignedTransactionArgs &
 export type GetUnsignedSuiTransactionArgs = CommonGetUnsignedTransactionArgs & SuiAccountMetadata & SuiSwapperDeps;
 export type GetUnsignedNearTransactionArgs = CommonGetUnsignedTransactionArgs & NearAccountMetadata & NearSwapperDeps;
 export type GetUnsignedStarknetTransactionArgs = CommonGetUnsignedTransactionArgs & StarknetAccountMetadata & StarknetSwapperDeps;
+type TonAccountMetadata = {
+    from: string;
+};
+export type GetUnsignedTonTransactionArgs = CommonGetUnsignedTransactionArgs & TonAccountMetadata & TonSwapperDeps;
 export type GetUnsignedEvmMessageArgs = CommonGetUnsignedTransactionArgs & EvmAccountMetadata & Omit<EvmSwapperDeps, 'fetchIsSmartContractAddressQuery'>;
 export type GetUnsignedUtxoTransactionArgs = CommonGetUnsignedTransactionArgs & UtxoAccountMetadata & UtxoSwapperDeps;
 export type GetUnsignedCosmosSdkTransactionArgs = CommonGetUnsignedTransactionArgs & CosmosSdkAccountMetadata & CosmosSdkSwapperDeps;
@@ -535,7 +602,7 @@ export type CheckTradeStatusInput = {
     stepIndex: SupportedTradeQuoteStepIndex;
     config: SwapperConfig;
     swap: Swap | undefined;
-} & EvmSwapperDeps & UtxoSwapperDeps & CosmosSdkSwapperDeps & SolanaSwapperDeps & TronSwapperDeps & SuiSwapperDeps & NearSwapperDeps & StarknetSwapperDeps;
+} & EvmSwapperDeps & UtxoSwapperDeps & CosmosSdkSwapperDeps & SolanaSwapperDeps & TronSwapperDeps & SuiSwapperDeps & NearSwapperDeps & StarknetSwapperDeps & TonSwapperDeps;
 export type TradeStatus = {
     status: TxStatus;
     buyTxHash: string | undefined;
@@ -558,6 +625,7 @@ export type Swapper = {
     executeSuiTransaction?: (txToSign: SuiSignTx, callbacks: SuiTransactionExecutionProps) => Promise<string>;
     executeNearTransaction?: (txToSign: near.NearSignTx, callbacks: NearTransactionExecutionProps) => Promise<string>;
     executeStarknetTransaction?: (txToSign: StarknetSignTx, callbacks: StarknetTransactionExecutionProps) => Promise<string>;
+    executeTonTransaction?: (txToSign: ton.TonSignTx, callbacks: TonTransactionExecutionProps) => Promise<string>;
 };
 export type SwapperApi = {
     checkTradeStatus: (input: CheckTradeStatusInput) => Promise<TradeStatus>;
@@ -573,6 +641,7 @@ export type SwapperApi = {
     getUnsignedSuiTransaction?: (input: GetUnsignedSuiTransactionArgs) => Promise<SuiSignTx>;
     getUnsignedNearTransaction?: (input: GetUnsignedNearTransactionArgs) => Promise<near.NearSignTx>;
     getUnsignedStarknetTransaction?: (input: GetUnsignedStarknetTransactionArgs) => Promise<StarknetSignTx>;
+    getUnsignedTonTransaction?: (input: GetUnsignedTonTransactionArgs) => Promise<ton.TonSignTx>;
     getEvmTransactionFees?: (input: GetUnsignedEvmTransactionArgs) => Promise<string>;
     getSolanaTransactionFees?: (input: GetUnsignedSolanaTransactionArgs) => Promise<string>;
     getSuiTransactionFees?: (input: GetUnsignedSuiTransactionArgs) => Promise<string>;
@@ -581,6 +650,7 @@ export type SwapperApi = {
     getTronTransactionFees?: (input: GetUnsignedTronTransactionArgs) => Promise<string>;
     getNearTransactionFees?: (input: GetUnsignedNearTransactionArgs) => Promise<string>;
     getStarknetTransactionFees?: (input: GetUnsignedStarknetTransactionArgs) => Promise<string>;
+    getTonTransactionFees?: (input: GetUnsignedTonTransactionArgs) => Promise<string>;
 };
 export type QuoteResult = Result<TradeQuote[], SwapErrorRight> & {
     swapperName: SwapperName;
@@ -607,6 +677,7 @@ export type TronTransactionExecutionInput = CommonTradeExecutionInput & TronTran
 export type SuiTransactionExecutionInput = CommonTradeExecutionInput & SuiTransactionExecutionProps & SuiAccountMetadata;
 export type NearTransactionExecutionInput = CommonTradeExecutionInput & NearTransactionExecutionProps & NearAccountMetadata;
 export type StarknetTransactionExecutionInput = CommonTradeExecutionInput & StarknetTransactionExecutionProps & StarknetAccountMetadata;
+export type TonTransactionExecutionInput = CommonTradeExecutionInput & TonTransactionExecutionProps & TonAccountMetadata;
 export declare enum TradeExecutionEvent {
     SellTxHash = "sellTxHash",
     RelayerTxHash = "relayerTxHash",

package/dist/cjs/types.js

@@ -19,6 +19,8 @@ var SwapperName;
     SwapperName["Cetus"] = "Cetus";
     SwapperName["Sunio"] = "Sun.io";
     SwapperName["Avnu"] = "AVNU";
+    SwapperName["Stonfi"] = "STON.fi";
+    SwapperName["Across"] = "Across";
 })(SwapperName || (exports.SwapperName = SwapperName = {}));
 var TradeQuoteError;
 (function (TradeQuoteError) {

package/dist/cjs/utils.d.ts

@@ -1,12 +1,12 @@
 import type { AssetId, ChainId } from '@shapeshiftoss/caip';
-import type { EvmChainAdapter, near, SignTx, solana, starknet, sui } from '@shapeshiftoss/chain-adapters';
+import type { EvmChainAdapter, near, SignTx, solana, starknet, sui, ton } from '@shapeshiftoss/chain-adapters';
+import type { TronSignTx } from '@shapeshiftoss/chain-adapters/src/tron/types';
 import type { SolanaSignTx, StarknetSignTx, SuiSignTx } from '@shapeshiftoss/hdwallet-core';
 import type { Asset, EvmChainId } from '@shapeshiftoss/types';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
 import type { Result } from '@sniptt/monads';
 import type { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
-import type { TronSignTx } from '@shapeshiftoss/chain-adapters/src/tron/types';
-import type { EvmTransactionExecutionProps, ExecutableTradeStep, NearTransactionExecutionProps, SolanaTransactionExecutionProps, StarknetTransactionExecutionProps, SuiTransactionExecutionProps, SupportedTradeQuoteStepIndex, SwapErrorRight, TradeQuote, TradeQuoteStep, TradeRate, TradeStatus, TronTransactionExecutionProps } from './types';
+import type { EvmTransactionExecutionProps, ExecutableTradeStep, NearTransactionExecutionProps, SolanaTransactionExecutionProps, StarknetTransactionExecutionProps, SuiTransactionExecutionProps, SupportedTradeQuoteStepIndex, SwapErrorRight, TonTransactionExecutionProps, TradeQuote, TradeQuoteStep, TradeRate, TradeStatus, TronTransactionExecutionProps } from './types';
 import { TradeQuoteError } from './types';
 export declare const makeSwapErrorRight: ({ details, cause, code, message, }: {
     message: string;
@@ -32,6 +32,7 @@ export declare const executeTronTransaction: (txToSign: TronSignTx, callbacks: T
 export declare const executeSuiTransaction: (txToSign: SuiSignTx, callbacks: SuiTransactionExecutionProps) => Promise<string>;
 export declare const executeNearTransaction: (txToSign: near.NearSignTx, callbacks: NearTransactionExecutionProps) => Promise<string>;
 export declare const executeStarknetTransaction: (txToSign: StarknetSignTx, callbacks: StarknetTransactionExecutionProps) => Promise<string>;
+export declare const executeTonTransaction: (txToSign: ton.TonSignTx, callbacks: TonTransactionExecutionProps) => Promise<string>;
 export declare const createDefaultStatusResponse: (buyTxHash?: string) => {
     status: TxStatus;
     buyTxHash: string | undefined;