@shapeshiftoss/swapper 17.7.2 → 17.7.3

package/dist/esm/swappers/SunioSwapper/utils/sunioService.d.ts

@@ -1,6 +1,6 @@
 export declare const sunioServiceFactory: () => {
-    get: <T = any>(url: string, config?: import("axios").AxiosRequestConfig<any>) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T>, import("../../../index.js").SwapErrorRight>>;
-    post: <T = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any>) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T>, import("../../../index.js").SwapErrorRight>>;
-    delete: <T = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any>) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T>, import("../../../index.js").SwapErrorRight>>;
+    get: <T = any>(url: string, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T, any, {}>, import("../../../index.js").SwapErrorRight>>;
+    post: <T_1 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_1, any, {}>, import("../../../index.js").SwapErrorRight>>;
+    delete: <T_2 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_2, any, {}>, import("../../../index.js").SwapErrorRight>>;
 };
 export type SunioService = ReturnType<typeof sunioServiceFactory>;

package/dist/esm/swappers/ThorchainSwapper/getTradeQuote/getTradeQuote.test.js

@@ -76,6 +76,11 @@ const expectedQuoteResponse = [
                 thorchainSpecific: {
                     maxStreamingQuantity: undefined,
                 },
+                thorchainTransactionMetadata: {
+                    to: '0x3624525075b88B24ecc29CE226b0CEc1fFcB6976',
+                    data: '0x',
+                    value: '0',
+                },
             },
         ],
     },
@@ -119,6 +124,11 @@ const expectedQuoteResponse = [
                 thorchainSpecific: {
                     maxStreamingQuantity: undefined,
                 },
+                thorchainTransactionMetadata: {
+                    to: '0x3624525075b88B24ecc29CE226b0CEc1fFcB6976',
+                    data: '0x',
+                    value: '0',
+                },
             },
         ],
     },

package/dist/esm/swappers/ThorchainSwapper/utils/getL1ToLongtailQuote.js

@@ -101,7 +101,7 @@ export const getL1ToLongtailQuote = async (input, deps, streamingInterval, swapp
                 // This is wrong, we should get the get the value before fees or display ETH value received after the thorchain bridge
                 buyAmountBeforeFeesCryptoBaseUnit: quotedAmountOut.toString(),
                 allowanceContract: TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET,
-            })), // assuming multi-hop quote steps here since we're mapping over quote steps,
+            })),
             isLongtail: true,
             longtailData: {
                 L1ToLongtailExpectedAmountOut: quotedAmountOut.toString(),

package/dist/esm/swappers/ThorchainSwapper/utils/getL1ToLongtailRate.js

@@ -89,7 +89,7 @@ export const getL1ToLongtailRate = async (input, deps, streamingInterval, swappe
                 // This is wrong, we should get the get the value before fees or display ETH value received after the thorchain bridge
                 buyAmountBeforeFeesCryptoBaseUnit: quotedAmountOut.toString(),
                 allowanceContract: TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET,
-            })), // assuming multi-hop rate steps here since we're mapping over quote steps,
+            })),
             isLongtail: true,
             longtailData: {
                 L1ToLongtailExpectedAmountOut: quotedAmountOut.toString(),

package/dist/esm/swappers/ThorchainSwapper/utils/getLongtailQuote.js

@@ -55,7 +55,7 @@ export const getLongtailToL1Quote = async (input, deps, streamingInterval, swapp
                 sellAmountIncludingProtocolFeesCryptoBaseUnit,
                 sellAsset,
                 allowanceContract: TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET,
-            })), // assuming multi-hop quote steps here since we're mapping over quote steps
+            })),
             isLongtail: true,
             longtailData: {
                 longtailToL1ExpectedAmountOut: quotedAmountOut.toString(),

package/dist/esm/swappers/ThorchainSwapper/utils/getLongtailRate.js

@@ -55,7 +55,7 @@ export const getLongtailToL1Rate = async (input, deps, streamingInterval, swappe
                 sellAmountIncludingProtocolFeesCryptoBaseUnit,
                 sellAsset,
                 allowanceContract: TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET,
-            })), // assuming multi-hop quote steps here since we're mapping over quote steps
+            })),
             isLongtail: true,
             longtailData: {
                 longtailToL1ExpectedAmountOut: quotedAmountOut.toString(),

package/dist/esm/swappers/ZrxSwapper/utils/fetchFromZrx.js

@@ -24,9 +24,9 @@ const fetchFromZrx = async ({ quoteOrRate, buyAsset, sellAsset, sellAmountInclud
             sellAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
             taker: sellAddress,
             swapFeeBps: bn(affiliateBps).toNumber(),
-            swapFeeToken: assetIdToZrxToken(buyAsset.assetId), // must be set to the buy asset to simplify fee calcs
+            swapFeeToken: assetIdToZrxToken(buyAsset.assetId),
             slippageBps: convertDecimalPercentageToBasisPoints(slippageTolerancePercentageDecimal).toNumber(),
-            swapFeeRecipient: maybeTreasuryAddress, // Where affiliate fees are sent
+            swapFeeRecipient: maybeTreasuryAddress,
             feeRecipientTradeSurplus: maybeTreasuryAddress, // Where trade surplus is sent
         },
     });

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

@@ -1,9 +1,10 @@
 import type { AssetId, ChainId } from '@shapeshiftoss/caip';
 import type { Asset, AssetsByIdPartial } from '@shapeshiftoss/types';
-import type { ZrxFees, ZrxSupportedChainId } from '../../types.js';
+import { KnownChainIds } from '@shapeshiftoss/types';
+import type { ZrxFees } from '../../types.js';
 export declare const assetIdToZrxToken: (assetId: AssetId) => string;
 export declare const zrxTokenToAssetId: (token: string, chainId: ChainId) => AssetId;
-export declare const isSupportedChainId: (chainId: ChainId) => chainId is ZrxSupportedChainId;
+export declare const isSupportedChainId: (chainId: ChainId) => chainId is KnownChainIds.EthereumMainnet | KnownChainIds.AvalancheMainnet | KnownChainIds.OptimismMainnet | KnownChainIds.BnbSmartChainMainnet | KnownChainIds.PolygonMainnet | KnownChainIds.ArbitrumMainnet | KnownChainIds.BaseMainnet;
 export declare const assertValidTrade: ({ buyAsset, sellAsset, }: {
     buyAsset: Asset;
     sellAsset: Asset;

package/dist/esm/swappers/ZrxSwapper/utils/zrxService.d.ts

@@ -4,6 +4,6 @@ import type { MonadicSwapperAxiosService } from '../../../types.js';
 type AxiosInstanceHoF = (instance: AxiosInstance, options?: Omit<RetryConfig, 'instance'>) => AxiosInstance;
 export declare const zrxServiceFactory: ({ baseUrl, wrapper, }: {
     baseUrl: string;
-    wrapper?: AxiosInstanceHoF;
+    wrapper?: AxiosInstanceHoF | undefined;
 }) => MonadicSwapperAxiosService;
 export {};

package/dist/esm/swappers/utils/test-data/cryptoMarketDataById.d.ts

@@ -1,39 +1,5 @@
-import { AVAX, BSC, BTC, ETH, FOX_GNOSIS, FOX_MAINNET, OPTIMISM, RUNE, USDC_GNOSIS, USDC_MAINNET, WBTC, WETH } from './assets.js';
 export declare const marketDataByAssetIdUsd: {
-    [FOX_MAINNET.assetId]: {
-        price: string;
-    };
-    [FOX_GNOSIS.assetId]: {
-        price: string;
-    };
-    [ETH.assetId]: {
-        price: string;
-    };
-    [AVAX.assetId]: {
-        price: string;
-    };
-    [BSC.assetId]: {
-        price: string;
-    };
-    [BTC.assetId]: {
-        price: string;
-    };
-    [RUNE.assetId]: {
-        price: string;
-    };
-    [OPTIMISM.assetId]: {
-        price: string;
-    };
-    [USDC_MAINNET.assetId]: {
-        price: string;
-    };
-    [USDC_GNOSIS.assetId]: {
-        price: string;
-    };
-    [WBTC.assetId]: {
-        price: string;
-    };
-    [WETH.assetId]: {
+    [x: string]: {
         price: string;
     };
 };

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

@@ -62,7 +62,14 @@ export const checkTradeStatus = async ({ txHash, chainId, address, fetchIsSmartC
         return { buyTxHash, status: TxStatus.Pending, message };
     }
     catch (e) {
-        console.error(e);
+        const message = (() => {
+            if (axios.isAxiosError(e))
+                return e.response?.data?.message ?? e.message;
+            if (e instanceof Error)
+                return e.message;
+            return String(e);
+        })();
+        console.error(`checkTradeStatus(${nativeChain}, ${txHash}): ${message}`);
         return { buyTxHash: undefined, status: TxStatus.Unknown, message: undefined };
     }
 };

package/dist/esm/thorchain-utils/cosmossdk/getThorTxData.d.ts

@@ -0,0 +1,12 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { SwapperConfig, SwapperName } from '../../types.js';
+type GetThorTxDataArgs = {
+    sellAsset: Asset;
+    config: SwapperConfig;
+    swapperName: SwapperName;
+};
+type GetThorTxDataReturn = {
+    vault: string;
+};
+export declare const getThorTxData: ({ sellAsset, config, swapperName, }: GetThorTxDataArgs) => Promise<GetThorTxDataReturn>;
+export {};

package/dist/esm/thorchain-utils/cosmossdk/getThorTxData.js

@@ -0,0 +1,15 @@
+import { getInboundAddressDataForChain } from '../getInboundAddressDataForChain.js';
+import { getChainIdBySwapper, getDaemonUrl } from '../index.js';
+export const getThorTxData = async ({ sellAsset, config, swapperName, }) => {
+    // Native assets on the swapper's own chain (RUNE on THORChain, CACAO on MAYAChain)
+    // deposit via MsgDeposit and have no recipient address.
+    if (sellAsset.chainId === getChainIdBySwapper(swapperName))
+        return { vault: '' };
+    // Everything else (e.g. ATOM via THORChain, RUNE via MAYAChain) sends via MsgSend
+    // to the swapper's inbound vault on that chain.
+    const daemonUrl = getDaemonUrl(config, swapperName);
+    const res = await getInboundAddressDataForChain(daemonUrl, sellAsset.assetId, true, swapperName);
+    if (res.isErr())
+        throw res.unwrapErr();
+    return { vault: res.unwrap().address };
+};

package/dist/esm/thorchain-utils/cosmossdk/index.d.ts

@@ -1 +1,2 @@
 export * from './getCosmosSdkTransactionFees.js';
+export * from './getThorTxData.js';

package/dist/esm/thorchain-utils/cosmossdk/index.js

@@ -1 +1,2 @@
 export * from './getCosmosSdkTransactionFees.js';
+export * from './getThorTxData.js';

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, "vault" | "aggregator" | "data" | "memo" | "tradeType" | "expiry" | "longtailData" | "slippageTolerancePercentageDecimal"> & {
+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

@@ -7,8 +7,10 @@ import { TronWeb } from 'tronweb';
 import { v4 as uuid } from 'uuid';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../index.js';
 import { buildAffiliateFee } from '../swappers/utils/affiliateFee.js';
+import { isNativeEvmAsset } from '../swappers/utils/helpers/helpers.js';
 import { TradeQuoteError } from '../types.js';
 import { getInputOutputRate, makeSwapErrorRight } from '../utils.js';
+import * as cosmossdk from './cosmossdk/index.js';
 import * as evm from './evm/index.js';
 import { getLimitWithManualSlippage } from './getLimitWithManualSlippage/getLimitWithManualSlippage.js';
 import { getQuote } from './getQuote.js';
@@ -128,7 +130,7 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
             affilate: getAffiliate(swapperName),
         });
     };
-    const makeThorTradeRateOrQuote = ({ route, memo, allowanceContract, feeData, data, router, vault, }) => {
+    const makeThorTradeRateOrQuote = ({ route, memo, allowanceContract, feeData, data, router, vault, thorchainTransactionMetadata, }) => {
         const buyAmountAfterFeesCryptoBaseUnit = convertPrecision({
             value: route.expectedAmountOutThorBaseUnit,
             inputExponent: buyAssetNativePrecision,
@@ -182,6 +184,7 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
                     thorchainSpecific: {
                         maxStreamingQuantity: route.quote.max_streaming_quantity,
                     },
+                    thorchainTransactionMetadata,
                 },
             ],
         };
@@ -213,6 +216,11 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
                     data,
                     router,
                     vault,
+                    thorchainTransactionMetadata: {
+                        to: router,
+                        data,
+                        value: isNativeEvmAsset(sellAsset.assetId) ? sellAmountCryptoBaseUnit : '0',
+                    },
                     feeData: {
                         protocolFees: getProtocolFees(route.quote),
                         networkFeeCryptoBaseUnit,
@@ -258,8 +266,13 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
                 })();
                 return makeThorTradeRateOrQuote({
                     route,
-                    allowanceContract: '0x0', // not applicable to UTXOs
+                    allowanceContract: '0x0',
                     memo,
+                    thorchainTransactionMetadata: {
+                        to: vault,
+                        memo,
+                        value: sellAmountCryptoBaseUnit,
+                    },
                     feeData,
                 });
             }));
@@ -275,11 +288,18 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
         case CHAIN_NAMESPACE.CosmosSdk: {
             const cosmosChainAdapter = assertGetCosmosSdkChainAdapter(sellAsset.chainId);
             const { fast } = await cosmosChainAdapter.getFeeData({});
+            const { vault } = await cosmossdk.getThorTxData({ sellAsset, config, swapperName });
             return Ok(perRouteValues.map((route) => {
+                const memo = getMemo(route);
                 return makeThorTradeRateOrQuote({
                     route,
-                    memo: getMemo(route),
-                    allowanceContract: '0x0', // not applicable to cosmossdk
+                    memo,
+                    allowanceContract: '0x0',
+                    thorchainTransactionMetadata: {
+                        to: vault,
+                        memo,
+                        value: sellAmountCryptoBaseUnit,
+                    },
                     feeData: {
                         networkFeeCryptoBaseUnit: fast.txFee,
                         protocolFees: getProtocolFees(route.quote),
@@ -293,13 +313,13 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
         case CHAIN_NAMESPACE.Solana: {
             const adapter = assertGetSolanaChainAdapter(sellAsset.chainId);
             const sendAddress = input.sendAddress;
+            const { vault } = await solana.getThorTxData({ sellAsset, config, swapperName });
             const maybeRoutes = await Promise.allSettled(perRouteValues.map(async (route) => {
                 const memo = getMemo(route);
                 const protocolFees = getProtocolFees(route.quote);
                 const feeData = await (async () => {
                     if (!sendAddress)
                         return { networkFeeCryptoBaseUnit: undefined, protocolFees };
-                    const { vault } = await solana.getThorTxData({ sellAsset, config, swapperName });
                     const memoInstruction = new TransactionInstruction({
                         keys: [],
                         programId: new PublicKey(SOLANA_MEMO_PROGRAM_ID),
@@ -325,6 +345,11 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
                     route,
                     allowanceContract: '0x0',
                     memo,
+                    thorchainTransactionMetadata: {
+                        to: vault,
+                        memo,
+                        value: sellAmountCryptoBaseUnit,
+                    },
                     feeData,
                 });
             }));
@@ -338,20 +363,15 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
             return Ok(routes);
         }
         case CHAIN_NAMESPACE.Tron: {
+            const { vault } = await tron.getThorTxData({ sellAsset, config, swapperName });
             const maybeRoutes = await Promise.allSettled(perRouteValues.map(async (route) => {
                 const memo = getMemo(route);
                 let networkFeeCryptoBaseUnit = undefined;
                 // Calculate fees for rates when we have a receive address (wallet connected)
-                if (input.quoteOrRate === 'rate' && input.receiveAddress) {
+                if (input.quoteOrRate === 'rate' && input.receiveAddress && vault) {
                     try {
                         const { sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = input;
                         const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
-                        // Get vault address
-                        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,
@@ -364,7 +384,7 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
                             // TRC20: Estimate energy with actual recipient
                             try {
                                 const result = await tronWeb.transactionBuilder.triggerConstantContract(contractAddress, 'transfer(address,uint256)', {}, [
-                                    { type: 'address', value: vault }, // Use vault as recipient
+                                    { type: 'address', value: vault },
                                     {
                                         type: 'uint256',
                                         value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
@@ -398,8 +418,13 @@ export const getL1RateOrQuote = async (input, deps, streamingInterval, tradeType
                 // For quotes, fees will be calculated in getTronTransactionFees when executing
                 return Promise.resolve(makeThorTradeRateOrQuote({
                     route,
-                    allowanceContract: '0x0', // not applicable to TRON
+                    allowanceContract: '0x0',
                     memo,
+                    thorchainTransactionMetadata: {
+                        to: vault,
+                        memo,
+                        value: sellAmountCryptoBaseUnit,
+                    },
                     feeData: {
                         networkFeeCryptoBaseUnit,
                         protocolFees: getProtocolFees(route.quote),

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

@@ -1,7 +1,8 @@
+import type { AssetId } from '@shapeshiftoss/caip';
 import type { Asset } from '@shapeshiftoss/types';
 import type { SwapperConfig, SwapperName } from '../../types.js';
-export declare const getOutboundFeeInSellAssetThorBaseUnit: (runePerAsset: string, swapperName: SwapperName) => BigNumber;
-export declare const getExpectedAffiliateFeeSellAssetThorUnit: (sellAmountCryptoBaseUnit: string, sellAsset: Asset, affiliateBps: string, swapperName: SwapperName) => BigNumber;
+export declare const getOutboundFeeSellAssetThorBaseUnit: (runePerAsset: string, sellAssetId: AssetId, swapperName: SwapperName) => BigNumber;
+export declare const getExpectedAffiliateFeeSellAssetThorBaseUnit: (sellAmountCryptoBaseUnit: string, sellAsset: Asset, affiliateBps: string, swapperName: SwapperName) => BigNumber;
 export declare const getThresholdedAffiliateBps: ({ sellAsset, affiliateBps, sellAmountCryptoBaseUnit, config, swapperName, }: {
     sellAsset: Asset;
     affiliateBps: string;

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

@@ -1,21 +1,28 @@
-import { bn, convertBasisPointsToDecimalPercentage, convertPrecision } from '@shapeshiftoss/utils';
-import { getMidgardUrl, getNativeFee, getNativePrecision, getPoolAssetId, isNativeAsset, thorService, } from '../index.js';
-export const getOutboundFeeInSellAssetThorBaseUnit = (runePerAsset, swapperName) => {
-    return bn(getNativeFee(swapperName)).dividedBy(runePerAsset);
+import { convertBasisPointsToDecimalPercentage, convertPrecision } from '@shapeshiftoss/utils';
+import { getMidgardUrl, getNativeFee, getNativePrecision, getPoolAssetId, getSwapperNativeAssetId, isNativeAsset, thorService, } from '../index.js';
+// Convert native fee to sell asset's native precision before dividing by `assetPrice`.
+// MAYA's CACAO is 10-dec but pool assets are 8-dec — skip this and the result is 100x off.
+export const getOutboundFeeSellAssetThorBaseUnit = (runePerAsset, sellAssetId, swapperName) => {
+    const nativeFeeSellAssetThorBaseUnit = convertPrecision({
+        value: getNativeFee(swapperName),
+        inputExponent: getNativePrecision(getSwapperNativeAssetId(swapperName), swapperName),
+        outputExponent: getNativePrecision(sellAssetId, swapperName),
+    });
+    return nativeFeeSellAssetThorBaseUnit.dividedBy(runePerAsset);
 };
-export const getExpectedAffiliateFeeSellAssetThorUnit = (sellAmountCryptoBaseUnit, sellAsset, affiliateBps, swapperName) => {
-    const sellAmountThorUnit = convertPrecision({
+export const getExpectedAffiliateFeeSellAssetThorBaseUnit = (sellAmountCryptoBaseUnit, sellAsset, affiliateBps, swapperName) => {
+    const sellAmountThorBaseUnit = convertPrecision({
         value: sellAmountCryptoBaseUnit,
         inputExponent: sellAsset.precision,
         outputExponent: getNativePrecision(sellAsset.assetId, swapperName),
     });
     const affiliatePercent = convertBasisPointsToDecimalPercentage(affiliateBps);
-    return sellAmountThorUnit.times(affiliatePercent);
+    return sellAmountThorBaseUnit.times(affiliatePercent);
 };
 // don't apply an affiliate fee if it's below the outbound fee for the inbound pool
 export const getThresholdedAffiliateBps = async ({ sellAsset, affiliateBps, sellAmountCryptoBaseUnit, config, swapperName, }) => {
     const midgardUrl = getMidgardUrl(config, swapperName);
-    const outboundFeeSellAssetThorUnit = await (async () => {
+    const outboundFeeSellAssetThorBaseUnit = await (async () => {
         if (isNativeAsset(sellAsset.assetId, swapperName))
             return getNativeFee(swapperName);
         const sellPoolId = getPoolAssetId({ assetId: sellAsset.assetId, swapperName });
@@ -24,11 +31,11 @@ export const getThresholdedAffiliateBps = async ({ sellAsset, affiliateBps, sell
         if (res.isErr())
             throw res.unwrapErr();
         const pool = res.unwrap().data;
-        // calculate the rune outbound fee denominated in the sell asset, in native units
-        return getOutboundFeeInSellAssetThorBaseUnit(pool.assetPrice, swapperName);
+        // calculate the rune outbound fee denominated in the sell asset, in thor base units
+        return getOutboundFeeSellAssetThorBaseUnit(pool.assetPrice, sellAsset.assetId, swapperName);
     })();
-    // calculate the expected affiliate fee, in native units
-    const expectedAffiliateFeeSellAssetThorUnit = getExpectedAffiliateFeeSellAssetThorUnit(sellAmountCryptoBaseUnit, sellAsset, affiliateBps, swapperName);
-    const isAffiliateFeeBelowOutboundFee = expectedAffiliateFeeSellAssetThorUnit.lte(outboundFeeSellAssetThorUnit);
+    // calculate the expected affiliate fee, in thor base units
+    const expectedAffiliateFeeSellAssetThorBaseUnit = getExpectedAffiliateFeeSellAssetThorBaseUnit(sellAmountCryptoBaseUnit, sellAsset, affiliateBps, swapperName);
+    const isAffiliateFeeBelowOutboundFee = expectedAffiliateFeeSellAssetThorBaseUnit.lte(outboundFeeSellAssetThorBaseUnit);
     return isAffiliateFeeBelowOutboundFee ? '0' : affiliateBps;
 };

package/dist/esm/thorchain-utils/getThresholdedAffiliateBps/getThresholdedAffiliateBps.test.js

@@ -5,7 +5,7 @@ import { describe, expect, it, vi } from 'vitest';
 import { ETH } from '../../swappers/utils/test-data/index.js';
 import { SwapperName } from '../../types.js';
 import { thorService } from '../service.js';
-import { getExpectedAffiliateFeeSellAssetThorUnit, getOutboundFeeInSellAssetThorBaseUnit, getThresholdedAffiliateBps, } from './getThresholdedAffiliateBps.js';
+import { getExpectedAffiliateFeeSellAssetThorBaseUnit, getOutboundFeeSellAssetThorBaseUnit, getThresholdedAffiliateBps, } from './getThresholdedAffiliateBps.js';
 const mockedThorService = vi.mocked(thorService);
 const mocks = vi.hoisted(() => ({
     get: vi.fn(),
@@ -24,18 +24,24 @@ vi.mock('../service', () => {
         thorService: mockAxios.default.create(),
     };
 });
-describe('getOutboundFeeInSellAssetThorBaseUnit', () => {
+describe('getOutboundFeeSellAssetThorBaseUnit', () => {
     it('should return 0.02 rune denominated in the target asset, in thor units', () => {
         const assetPricePrecision = '4.00000'; // 1 token is 4x as valuable as 1 rune
-        expect(getOutboundFeeInSellAssetThorBaseUnit(assetPricePrecision, SwapperName.Thorchain).toNumber()).toEqual(Number(thorchain.NATIVE_FEE) / 4);
+        expect(getOutboundFeeSellAssetThorBaseUnit(assetPricePrecision, ETH.assetId, SwapperName.Thorchain).toNumber()).toEqual(Number(thorchain.NATIVE_FEE) / 4);
+    });
+    it('should scale CACAO 10-dec native fee down to non-CACAO 8-dec sell asset precision on MAYA', () => {
+        // 1 eth = 100 cacao, NATIVE_FEE = 2e9 (10-dec CACAO = 0.2 CACAO)
+        // 0.2 CACAO / 100 (CACAO/ETH) = 0.002 ETH = 200_000 at 8-dec ETH
+        const assetPrice = '100';
+        expect(getOutboundFeeSellAssetThorBaseUnit(assetPrice, ETH.assetId, SwapperName.Mayachain).toNumber()).toEqual(200_000);
     });
 });
-describe('getExpectedAffiliateFeeSellAssetThorUnit', () => {
+describe('getExpectedAffiliateFeeSellAssetThorBaseUnit', () => {
     it('should return the correct affiliate fee in thor base units', () => {
         const sellAmountCryptoBaseUnit = '1000000000000000000'; // 1 eth
         const affiliateBps = '35';
         const sellAsset = ETH;
-        const result = getExpectedAffiliateFeeSellAssetThorUnit(sellAmountCryptoBaseUnit, sellAsset, affiliateBps, SwapperName.Thorchain);
+        const result = getExpectedAffiliateFeeSellAssetThorBaseUnit(sellAmountCryptoBaseUnit, sellAsset, affiliateBps, SwapperName.Thorchain);
         const expectation = bn('100000000').times('0.0035').toFixed(0);
         expect(result.toFixed(0)).toEqual(expectation);
     });
@@ -43,7 +49,7 @@ describe('getExpectedAffiliateFeeSellAssetThorUnit', () => {
         const sellAmountCryptoBaseUnit = '1000000000000000000'; // 1 eth
         const affiliateBps = '0';
         const sellAsset = ETH;
-        const result = getExpectedAffiliateFeeSellAssetThorUnit(sellAmountCryptoBaseUnit, sellAsset, affiliateBps, SwapperName.Thorchain);
+        const result = getExpectedAffiliateFeeSellAssetThorBaseUnit(sellAmountCryptoBaseUnit, sellAsset, affiliateBps, SwapperName.Thorchain);
         const expectation = '0';
         expect(result.toFixed(0)).toEqual(expectation);
     });

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

@@ -23,6 +23,7 @@ export declare const getDaemonUrl: (config: SwapperConfig, swapperName: SwapperN
 export declare const getMidgardUrl: (config: SwapperConfig, swapperName: SwapperName) => string;
 export declare const isNativeAsset: (assetId: AssetId, swapperName: SwapperName) => boolean;
 export declare const getNativePrecision: (assetId: AssetId, swapperName: SwapperName) => 8 | 10;
+export declare const getSwapperNativeAssetId: (swapperName: SwapperName) => AssetId;
 export declare const getNativeFee: (swapperName: SwapperName) => "2000000" | "2000000000";
 export declare const getAffiliate: (swapperName: SwapperName) => "ss" | "ssmaya";
 export declare const getPoolAssetId: ({ assetId, swapperName, }: {

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

@@ -1,4 +1,4 @@
-import { mayachainAssetId, mayachainChainId, thorchainChainId } from '@shapeshiftoss/caip';
+import { mayachainAssetId, mayachainChainId, thorchainAssetId, thorchainChainId, } from '@shapeshiftoss/caip';
 import * as adapters from '@shapeshiftoss/chain-adapters';
 import { assetIdToMayaPoolAssetId, CACAO_PRECISION, isCacao, MAYACHAIN_AFFILIATE_NAME, MAYACHAIN_PRECISION, MAYACHAIN_STREAM_SWAP_SOURCE, } from '../swappers/MayachainSwapper/index.js';
 import { assetIdToThorPoolAssetId, isRune, THORCHAIN_AFFILIATE_NAME, THORCHAIN_LONGTAIL_STREAMING_SWAP_SOURCE, THORCHAIN_LONGTAIL_SWAP_SOURCE, THORCHAIN_PRECISION, THORCHAIN_STREAM_SWAP_SOURCE, } from '../swappers/ThorchainSwapper/index.js';
@@ -69,6 +69,16 @@ export const getNativePrecision = (assetId, swapperName) => {
             throw new Error(`Invalid swapper: ${swapperName}`);
     }
 };
+export const getSwapperNativeAssetId = (swapperName) => {
+    switch (swapperName) {
+        case SwapperName.Thorchain:
+            return thorchainAssetId;
+        case SwapperName.Mayachain:
+            return mayachainAssetId;
+        default:
+            throw new Error(`Invalid swapper: ${swapperName}`);
+    }
+};
 export const getNativeFee = (swapperName) => {
     switch (swapperName) {
         case SwapperName.Thorchain:

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

@@ -1,2 +1,2 @@
 import type { ThorNodeTxSchema } from './types.js';
-export declare const parseThorBuyTxHash: (sellTxId: string, latestOutTx: ThorNodeTxSchema | undefined, nativeChain: "THOR" | "MAYA") => string | undefined;
+export declare const parseThorBuyTxHash: (sellTxId: string, latestOutTx: ThorNodeTxSchema | undefined, nativeChain: 'THOR' | 'MAYA') => string | undefined;

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

@@ -1,5 +1,5 @@
 export declare const thorService: {
-    get: <T = any>(url: string, config?: import("axios").AxiosRequestConfig<any>) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T>, import("../index.js").SwapErrorRight>>;
-    post: <T = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any>) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T>, import("../index.js").SwapErrorRight>>;
-    delete: <T = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any>) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T>, import("../index.js").SwapErrorRight>>;
+    get: <T = any>(url: string, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T, any, {}>, import("../index.js").SwapErrorRight>>;
+    post: <T_1 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_1, any, {}>, import("../index.js").SwapErrorRight>>;
+    delete: <T_2 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_2, any, {}>, import("../index.js").SwapErrorRight>>;
 };

package/dist/esm/tron-utils/getTronTransactionFees.d.ts

@@ -1,2 +1,2 @@
 import type { GetUnsignedTronTransactionArgs } from '../types.js';
-export declare const getTronTransactionFees: ({ tradeQuote, stepIndex, }: Pick<GetUnsignedTronTransactionArgs, "tradeQuote" | "stepIndex">) => Promise<string>;
+export declare const getTronTransactionFees: ({ tradeQuote, stepIndex, }: Pick<GetUnsignedTronTransactionArgs, 'tradeQuote' | 'stepIndex'>) => Promise<string>;

package/dist/esm/types.d.ts

@@ -327,6 +327,12 @@ export type TradeQuoteStep = {
     thorchainSpecific?: {
         maxStreamingQuantity?: number;
     };
+    thorchainTransactionMetadata?: {
+        to: string;
+        data?: string;
+        value?: string;
+        memo?: string;
+    };
     relayTransactionMetadata?: RelayTransactionMetadata;
     butterSwapTransactionMetadata?: {
         to: string;

package/dist/esm/utils/tenderly/storageSlots.js

@@ -23,39 +23,39 @@ export const getAllowanceStorageSlot = (ownerAddress, spenderAddress, allowanceS
 // USDC (BEP20 - BSC): balance at slot 1, allowance at slot 2
 export const KNOWN_BALANCE_SLOTS = {
     // USDT - Native Tether deployment (custom slot 2)
-    '0xdac17f958d2ee523a2206206994597c13d831ec7': 2, // USDT Ethereum
+    '0xdac17f958d2ee523a2206206994597c13d831ec7': 2,
     // Slot 51 pattern (L2GatewayToken + ERC20Upgradeable + storage gaps)
     // Various L2 tokens use this pattern with different implementations
-    '0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9': 51, // USDT Arbitrum (StandardArbERC20)
-    '0x912ce59144191c1204e64559fe8253a0e49e6548': 51, // ARB Arbitrum (StandardArbERC20)
-    '0x9702230a8ea53601f5cd2dc00fdbc13d4df4a8c7': 51, // USDT Avalanche (TransparentProxy)
-    '0x01bff41798a0bcf287b996046ca68b395dbc1071': 51, // USDT0 Optimism (LayerZero OFT - https://docs.usdt0.to)
+    '0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9': 51,
+    '0x912ce59144191c1204e64559fe8253a0e49e6548': 51,
+    '0x9702230a8ea53601f5cd2dc00fdbc13d4df4a8c7': 51,
+    '0x01bff41798a0bcf287b996046ca68b395dbc1071': 51,
     // Wormhole bridge pattern (slot 5)
-    '0xca7dec8550f43a5e46e3dfb95801f64280e75b27': 5, // SWEAT Arbitrum (Wormhole bridge)
+    '0xca7dec8550f43a5e46e3dfb95801f64280e75b27': 5,
     // USDT - BEP20 pattern (slot 1 - Binance-Peg token)
-    '0x55d398326f99059ff775485246999027b3197955': 1, // USDT BSC (confirmed)
+    '0x55d398326f99059ff775485246999027b3197955': 1,
     // USDT - xDai bridge pattern (slot 3)
-    '0x4ecaba5870353805a9f068101a40e0f32ed605c6': 3, // USDT Gnosis (confirmed)
+    '0x4ecaba5870353805a9f068101a40e0f32ed605c6': 3,
     // USDT - Standard ERC20 deployments (slot 0)
     // Polygon confirmed, Optimism bridged USDT (0x94b008aa...) also uses slot 0
     // USDC (Circle native deployments - all use slot 9)
-    '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48': 9, // USDC Ethereum
-    '0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e': 9, // USDC Avalanche
-    '0x0b2c639c533813f4aa9d7837caf62653d097ff85': 9, // USDC Optimism
-    '0x3c499c542cef5e3811e1192ce70d8cc03d5c3359': 9, // USDC Polygon
-    '0xaf88d065e77c8cc2239327c5edb3a432268e5831': 9, // USDC Arbitrum
-    '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913': 9, // USDC Base
+    '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48': 9,
+    '0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e': 9,
+    '0x0b2c639c533813f4aa9d7837caf62653d097ff85': 9,
+    '0x3c499c542cef5e3811e1192ce70d8cc03d5c3359': 9,
+    '0xaf88d065e77c8cc2239327c5edb3a432268e5831': 9,
+    '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913': 9,
     // USDC (BEP20 pattern on BSC - slot 1)
     '0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d': 1, // USDC BSC (BEP20)
 };
 export const KNOWN_ALLOWANCE_SLOTS = {
     // USDT allowance slots (explicit mapping for all non-standard implementations)
-    '0xdac17f958d2ee523a2206206994597c13d831ec7': 5, // USDT Ethereum (native Tether)
-    '0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9': 52, // USDT Arbitrum (StandardArbERC20)
-    '0x9702230a8ea53601f5cd2dc00fdbc13d4df4a8c7': 52, // USDT Avalanche (StandardArbERC20)
-    '0x01bff41798a0bcf287b996046ca68b395dbc1071': 52, // USDT0 Optimism (LayerZero OFT)
-    '0x55d398326f99059ff775485246999027b3197955': 2, // USDT BSC (BEP20)
-    '0x4ecaba5870353805a9f068101a40e0f32ed605c6': 4, // USDT Gnosis (xDai bridge)
+    '0xdac17f958d2ee523a2206206994597c13d831ec7': 5,
+    '0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9': 52,
+    '0x9702230a8ea53601f5cd2dc00fdbc13d4df4a8c7': 52,
+    '0x01bff41798a0bcf287b996046ca68b395dbc1071': 52,
+    '0x55d398326f99059ff775485246999027b3197955': 2,
+    '0x4ecaba5870353805a9f068101a40e0f32ed605c6': 4,
     // Note: Polygon and Optimism standard bridged USDT (0x94b008aa...) use slot 1 (fallback)
     // Note: SWEAT (slot 5) allowance auto-inferred to slot 6 via Wormhole pattern
     // USDC allowance slots (BSC uses BEP20 pattern, not Circle FiatToken)