@shapeshiftoss/swapper 17.6.9 → 17.6.10

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

@@ -0,0 +1,124 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { bn, convertPrecision } from '@shapeshiftoss/utils';
+import { Err } from '@sniptt/monads';
+import { Blockchain } from '@ston-fi/omniston-sdk';
+import { TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils.js';
+export const isTonAsset = (asset) => {
+    return asset.chainId === KnownChainIds.TonMainnet;
+};
+export const assetToOmnistonAddress = (asset) => {
+    if (!isTonAsset(asset))
+        return null;
+    const { assetNamespace, assetReference } = fromAssetId(asset.assetId);
+    if (assetNamespace === 'slip44') {
+        return {
+            blockchain: Blockchain.TON,
+            address: 'EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c',
+        };
+    }
+    if (assetNamespace === 'jetton') {
+        return { blockchain: Blockchain.TON, address: assetReference };
+    }
+    return null;
+};
+export const validateTonAssets = (sellAsset, buyAsset) => {
+    if (sellAsset.chainId !== KnownChainIds.TonMainnet) {
+        return {
+            isValid: false,
+            error: Err(makeSwapErrorRight({
+                message: `[Stonfi] Unsupported sell asset chain: ${sellAsset.chainId}`,
+                code: TradeQuoteError.UnsupportedChain,
+            })),
+        };
+    }
+    if (buyAsset.chainId !== KnownChainIds.TonMainnet) {
+        return {
+            isValid: false,
+            error: Err(makeSwapErrorRight({
+                message: `[Stonfi] Cross-chain swaps not supported`,
+                code: TradeQuoteError.CrossChainNotSupported,
+            })),
+        };
+    }
+    const bidAssetAddress = assetToOmnistonAddress(sellAsset);
+    const askAssetAddress = assetToOmnistonAddress(buyAsset);
+    if (!bidAssetAddress || !askAssetAddress) {
+        return {
+            isValid: false,
+            error: Err(makeSwapErrorRight({
+                message: `[Stonfi] Unable to convert assets to Omniston addresses`,
+                code: TradeQuoteError.UnsupportedTradePair,
+            })),
+        };
+    }
+    return {
+        isValid: true,
+        bidAssetAddress,
+        askAssetAddress,
+    };
+};
+export const calculateRate = (buyAmountCryptoBaseUnit, sellAmountCryptoBaseUnit, buyAssetPrecision, sellAssetPrecision) => {
+    if (bn(buyAmountCryptoBaseUnit).gt(0) && bn(sellAmountCryptoBaseUnit).gt(0)) {
+        return convertPrecision({
+            value: buyAmountCryptoBaseUnit,
+            inputExponent: buyAssetPrecision,
+            outputExponent: sellAssetPrecision,
+        })
+            .dividedBy(bn(sellAmountCryptoBaseUnit))
+            .toFixed();
+    }
+    return '0';
+};
+export 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);
+};
+export const tonAddressToOmnistonAddress = (address) => {
+    return {
+        blockchain: Blockchain.TON,
+        address,
+    };
+};
+export 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;
+};
+export 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 });
+            },
+        });
+    });
+};

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

@@ -0,0 +1,17 @@
+import { Omniston } from '@ston-fi/omniston-sdk';
+import { STONFI_WEBSOCKET_URL } from './constants.js';
+let cachedOmniston = null;
+export const omnistonManager = {
+    getInstance: () => {
+        if (!cachedOmniston) {
+            cachedOmniston = new Omniston({ apiUrl: STONFI_WEBSOCKET_URL });
+        }
+        return cachedOmniston;
+    },
+    disconnect: () => {
+        if (cachedOmniston) {
+            cachedOmniston.close();
+            cachedOmniston = null;
+        }
+    },
+};

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

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

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

@@ -1,5 +1,5 @@
 import { tronChainId } from '@shapeshiftoss/caip';
-import { bn, contractAddressOrUndefined } from '@shapeshiftoss/utils';
+import { BigAmount, bn, contractAddressOrUndefined } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { TronWeb } from 'tronweb';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
@@ -133,9 +133,10 @@ export async function getQuoteOrRate(input, deps) {
                 }
             }
         }
-        const buyAmountCryptoBaseUnit = bn(bestRoute.amountOut)
-            .times(bn(10).pow(buyAsset.precision))
-            .toFixed(0);
+        const buyAmountCryptoBaseUnit = BigAmount.fromPrecision({
+            value: bestRoute.amountOut,
+            precision: buyAsset.precision,
+        }).toBaseUnit();
         // Calculate protocol fees only for quotes
         const protocolFeeCryptoBaseUnit = isQuote
             ? bn(bestRoute.fee).times(sellAmountIncludingProtocolFeesCryptoBaseUnit).toFixed(0)

package/dist/esm/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.js").SwapErrorRight>;
+}) => import("@sniptt/monads/build/result/result").ResErr<unknown, import("../../../../types.js").SwapErrorRight> | import("@sniptt/monads/build/result/result").ResOk<boolean, never>;
 export declare const calculateRate: ({ buyAmount, sellAmount, buyAsset, sellAsset, }: {
     buyAmount: string;
     sellAmount: string;

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

@@ -1,14 +1,11 @@
-import { arbitrumNovaChainId } from '@shapeshiftoss/caip';
 import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
 const _filterEvmBuyAssetsBySellAssetId = ({ assets, sellAsset }, chainIdPredicate) => {
     // evm only
     if (!isEvmChainId(sellAsset.chainId))
         return [];
     return assets.filter(buyAsset => {
-        // evm only AND chain id predicate with no arbitrum nova support for any swappers
-        return (isEvmChainId(buyAsset.chainId) &&
-            chainIdPredicate(buyAsset.chainId, sellAsset.chainId) &&
-            buyAsset.chainId !== arbitrumNovaChainId);
+        // evm only AND chain id predicate
+        return isEvmChainId(buyAsset.chainId) && chainIdPredicate(buyAsset.chainId, sellAsset.chainId);
     });
 };
 export const filterSameChainEvmBuyAssetsBySellAssetId = (input) => {

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

@@ -1,6 +1,6 @@
 import { arbitrumAssetId, avalancheAssetId, baseAssetId, bscAssetId, ethAssetId, fromAssetId, gnosisAssetId, katanaAssetId, monadAssetId, optimismAssetId, plasmaAssetId, polygonAssetId, } from '@shapeshiftoss/caip';
 import { KnownChainIds } from '@shapeshiftoss/types';
-import { DAO_TREASURY_ARBITRUM, DAO_TREASURY_AVALANCHE, DAO_TREASURY_BASE, DAO_TREASURY_BITCOIN, DAO_TREASURY_BSC, DAO_TREASURY_ETHEREUM_MAINNET, DAO_TREASURY_GNOSIS, DAO_TREASURY_OPTIMISM, DAO_TREASURY_POLYGON, DAO_TREASURY_SOLANA, DAO_TREASURY_STARKNET, isTreasuryChainId, } from '@shapeshiftoss/utils';
+import { DAO_TREASURY_ARBITRUM, DAO_TREASURY_AVALANCHE, DAO_TREASURY_BASE, DAO_TREASURY_BITCOIN, DAO_TREASURY_BSC, DAO_TREASURY_ETHEREUM_MAINNET, DAO_TREASURY_GNOSIS, DAO_TREASURY_HYPEREVM, DAO_TREASURY_MONAD, DAO_TREASURY_OPTIMISM, DAO_TREASURY_POLYGON, DAO_TREASURY_SOLANA, DAO_TREASURY_STARKNET, DAO_TREASURY_TON, isTreasuryChainId, } from '@shapeshiftoss/utils';
 export const isNativeEvmAsset = (assetId) => {
     const { chainId } = fromAssetId(assetId);
     switch (chainId) {
@@ -42,6 +42,9 @@ const DAO_TREASURY_BY_CHAIN_ID = {
     [KnownChainIds.SolanaMainnet]: DAO_TREASURY_SOLANA,
     [KnownChainIds.BitcoinMainnet]: DAO_TREASURY_BITCOIN,
     [KnownChainIds.StarknetMainnet]: DAO_TREASURY_STARKNET,
+    [KnownChainIds.TonMainnet]: DAO_TREASURY_TON,
+    [KnownChainIds.MonadMainnet]: DAO_TREASURY_MONAD,
+    [KnownChainIds.HyperEvmMainnet]: DAO_TREASURY_HYPEREVM,
 };
 export const getTreasuryAddressFromChainId = (chainId) => {
     const maybeTreasuryChainId = isTreasuryChainId(chainId) ? chainId : undefined;

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

@@ -1,7 +1,7 @@
 import type { Asset } from '@shapeshiftoss/types';
 import type { SwapperConfig, SwapperName } from '../types.js';
 import type { ThorEvmTradeQuote } from './types.js';
-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/esm/thorchain-utils/getL1RateOrQuote.js

@@ -1,6 +1,6 @@
 import { CHAIN_NAMESPACE, fromAssetId } from '@shapeshiftoss/caip';
 import * as adapters from '@shapeshiftoss/chain-adapters';
-import { assertUnreachable, bn, bnOrZero, contractAddressOrUndefined, convertDecimalPercentageToBasisPoints, convertPrecision, fromBaseUnit, isFulfilled, isRejected, toBaseUnit, } from '@shapeshiftoss/utils';
+import { assertUnreachable, BigAmount, bn, bnOrZero, contractAddressOrUndefined, convertDecimalPercentageToBasisPoints, convertPrecision, isFulfilled, isRejected, } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { TronWeb } from 'tronweb';
 import { v4 as uuid } from 'uuid';
@@ -75,7 +75,13 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
         : '0';
     const getRouteBuyAmountBeforeFeesCryptoBaseUnit = (quote) => {
         const buyAmountBeforeFeesCryptoThorPrecision = bn(quote.expected_amount_out).plus(quote.fees.total);
-        return toBaseUnit(fromBaseUnit(buyAmountBeforeFeesCryptoThorPrecision, buyAssetNativePrecision), buyAsset.precision);
+        return BigAmount.fromPrecision({
+            value: BigAmount.fromBaseUnit({
+                value: buyAmountBeforeFeesCryptoThorPrecision,
+                precision: buyAssetNativePrecision,
+            }).toPrecision(),
+            precision: buyAsset.precision,
+        }).toBaseUnit();
     };
     const getProtocolFees = (quote) => {
         // Fees consist of liquidity, outbound, and affiliate fees
@@ -215,7 +221,11 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
             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
@@ -284,9 +294,15 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
                         const { sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = input;
                         const contractAddress = 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({ fullHost: deps.config.VITE_TRON_NODE_URL });
+                        const tronWeb = new 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;
@@ -296,7 +312,10 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
                             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
@@ -361,6 +380,12 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
                 code: TradeQuoteError.UnsupportedTradePair,
             }));
         }
+        case CHAIN_NAMESPACE.Ton: {
+            return Err(makeSwapErrorRight({
+                message: 'TON is not supported',
+                code: TradeQuoteError.UnsupportedTradePair,
+            }));
+        }
         default:
             return assertUnreachable(chainNamespace);
     }

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

@@ -1,5 +1,5 @@
 import { bchAssetId } from '@shapeshiftoss/caip';
-import { bn, fromBaseUnit, toBaseUnit } from '@shapeshiftoss/utils';
+import { BigAmount, bn } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import qs from 'qs';
 import { TradeQuoteError } from '../types.js';
@@ -19,9 +19,15 @@ export const getQuote = async (input, deps) => {
     });
     const buyPoolId = getPoolAssetId({ assetId: buyAssetId, swapperName });
     const sellPoolId = getPoolAssetId({ assetId: sellAsset.assetId, swapperName });
-    const sellAmountCryptoPrecision = fromBaseUnit(sellAmountCryptoBaseUnit, sellAsset.precision);
+    const sellAmountCryptoPrecision = BigAmount.fromBaseUnit({
+        value: sellAmountCryptoBaseUnit,
+        precision: sellAsset.precision,
+    }).toPrecision();
     // All pool amounts are native precision regardless of token precision
-    const sellAmountCryptoThorBaseUnit = bn(toBaseUnit(sellAmountCryptoPrecision, getNativePrecision(sellAsset.assetId, swapperName)));
+    const sellAmountCryptoThorBaseUnit = bn(BigAmount.fromPrecision({
+        value: sellAmountCryptoPrecision,
+        precision: getNativePrecision(sellAsset.assetId, swapperName),
+    }).toBaseUnit());
     // The swap endpoint expects BCH receiveAddress's to be stripped of the "bitcoincash:" prefix
     const parsedReceiveAddress = receiveAddress && buyAssetId === bchAssetId
         ? receiveAddress.replace('bitcoincash:', '')

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

@@ -1,16 +1,36 @@
+import { tronAssetId } from '@shapeshiftoss/caip';
 import { contractAddressOrUndefined } from '@shapeshiftoss/utils';
 import { getExecutableTradeStep, isExecutableTradeQuote } from '../utils.js';
 export const getUnsignedTronTransaction = ({ stepIndex, tradeQuote, from, assertGetTronChainAdapter, }) => {
     if (!isExecutableTradeQuote(tradeQuote))
         throw new Error('Unable to execute a trade rate quote');
     const step = 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 === 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 = contractAddressOrUndefined(sellAsset.assetId);
     return adapter.buildSendApiTransaction({
         to,

package/dist/esm/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.js';
 import type { CowMessageToSign } from './swappers/CowSwapper/types.js';
 import type { RelayTransactionMetadata } from './swappers/RelaySwapper/utils/types.js';
 import type { makeSwapperAxiosServiceMonadic } from './utils.js';
@@ -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/esm/types.js

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

package/dist/esm/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.js';
+import type { EvmTransactionExecutionProps, ExecutableTradeStep, NearTransactionExecutionProps, SolanaTransactionExecutionProps, StarknetTransactionExecutionProps, SuiTransactionExecutionProps, SupportedTradeQuoteStepIndex, SwapErrorRight, TonTransactionExecutionProps, TradeQuote, TradeQuoteStep, TradeRate, TradeStatus, TronTransactionExecutionProps } from './types.js';
 import { TradeQuoteError } from './types.js';
 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;