@shapeshiftoss/swapper 17.8.0 → 19.0.0

package/dist/cjs/swappers/RelaySwapper/utils/getRelayStepData.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelayStepData = exports.RELAY_SOLANA_COMPUTE_BUDGET = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const utils_2 = require("../../../utils");
+const evm_1 = require("../../../utils/evm");
+const solana_1 = require("../../../utils/solana");
+const utxo_1 = require("../../../utils/utxo");
+const getRelayPsbtRelayer_1 = require("./getRelayPsbtRelayer");
+const helpers_1 = require("./helpers");
+const types_1 = require("./types");
+// Bridge-out deposits measure constant compute consumption, but same-chain routes swap through
+// Jupiter where pool state moving between simulation and landing (CLMM tick crossings) measured
+// ~4% drift on a live route; 1.4 matches Jupiter's dynamicComputeUnitLimit margin
+exports.RELAY_SOLANA_COMPUTE_BUDGET = { marginMultiplier: 1.4 };
+async function getRelayStepData({ data, sellAsset, sellAmountCryptoBaseUnit, spenderAddress, orderId, from, xpub, type, input, fallbackNetworkFeeCryptoBaseUnit, deps, }) {
+    if (!data)
+        return (0, monads_1.Err)((0, utils_2.makeTradeStepBuildFailedErr)('getRelayStepData'));
+    const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
+    if ((0, types_1.isRelayQuoteEvmItemData)(data)) {
+        const { data: callData, gas: relayGasLimit, to, value: _value } = data;
+        if (!to)
+            return (0, monads_1.Err)((0, utils_2.makeTradeStepBuildFailedErr)('getRelayStepData'));
+        if (!callData)
+            return (0, monads_1.Err)((0, utils_2.makeTradeStepBuildFailedErr)('getRelayStepData'));
+        const value = (0, utils_1.isToken)(sellAsset.assetId) ? '0' : _value;
+        if (typeof value !== 'string')
+            return (0, monads_1.Err)((0, utils_2.makeTradeStepBuildFailedErr)('getRelayStepData'));
+        const transactionData = {
+            type: 'evm',
+            chainId: Number((0, caip_1.fromChainId)(sellAsset.chainId).chainReference),
+            to,
+            value,
+            data: callData,
+            gasLimit: (0, utils_1.bnOrZero)(relayGasLimit).gt(0) ? relayGasLimit : undefined,
+        };
+        const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+        const stateOverride = {
+            sellAsset,
+            sellAmountCryptoBaseUnit,
+            spenderAddress,
+        };
+        if (type === 'rate') {
+            const networkFeeCryptoBaseUnit = await (async () => {
+                try {
+                    return await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+                        adapter,
+                        transactionData,
+                        from,
+                        supportsEIP1559,
+                        stateOverride,
+                    });
+                }
+                catch {
+                    return fallbackNetworkFeeCryptoBaseUnit;
+                }
+            })();
+            const stepData = { networkFeeCryptoBaseUnit };
+            return (0, monads_1.Ok)(stepData);
+        }
+        // Execution needs the same fee data, so estimation failure fails the quote
+        try {
+            const networkFeeCryptoBaseUnit = await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+                adapter,
+                transactionData,
+                from,
+                supportsEIP1559,
+                stateOverride,
+            });
+            const stepData = { transactionData, networkFeeCryptoBaseUnit };
+            return (0, monads_1.Ok)(stepData);
+        }
+        catch (error) {
+            return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getRelayStepData', error));
+        }
+    }
+    if ((0, types_1.isRelayQuoteUtxoItemData)(data)) {
+        if (!data.psbt)
+            return (0, monads_1.Err)((0, utils_2.makeTradeStepBuildFailedErr)('getRelayStepData'));
+        const relayer = (0, getRelayPsbtRelayer_1.getRelayPsbtRelayer)(data.psbt, sellAmountCryptoBaseUnit);
+        if (!relayer)
+            return (0, monads_1.Err)((0, utils_2.makeTradeStepBuildFailedErr)('getRelayStepData'));
+        if (!orderId)
+            return (0, monads_1.Err)((0, utils_2.makeTradeStepBuildFailedErr)('getRelayStepData'));
+        const estimate = () => (0, utxo_1.getUtxoNetworkFeeCryptoBaseUnit)({
+            adapter: deps.assertGetUtxoChainAdapter(sellAsset.chainId),
+            pubkey: xpub,
+            to: relayer,
+            value: sellAmountCryptoBaseUnit,
+            opReturnData: orderId,
+        });
+        if (type === 'rate') {
+            const networkFeeCryptoBaseUnit = await (async () => {
+                try {
+                    const { networkFeeCryptoBaseUnit } = await estimate();
+                    return networkFeeCryptoBaseUnit;
+                }
+                catch {
+                    return fallbackNetworkFeeCryptoBaseUnit;
+                }
+            })();
+            const stepData = { networkFeeCryptoBaseUnit };
+            return (0, monads_1.Ok)(stepData);
+        }
+        try {
+            const { networkFeeCryptoBaseUnit } = await estimate();
+            const stepData = {
+                transactionData: {
+                    type: 'utxo',
+                    to: relayer,
+                    opReturnData: orderId,
+                    value: sellAmountCryptoBaseUnit,
+                },
+                networkFeeCryptoBaseUnit,
+            };
+            return (0, monads_1.Ok)(stepData);
+        }
+        catch (error) {
+            return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getRelayStepData', error));
+        }
+    }
+    if ((0, types_1.isRelayQuoteSolanaItemData)(data)) {
+        const adapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
+        const instructions = (0, solana_1.omitComputeBudgetInstructions)(data.instructions?.map(helpers_1.convertRelaySolanaInstruction) ?? []);
+        const addressLookupTableAddresses = data.addressLookupTableAddresses ?? [];
+        if (type === 'rate') {
+            // No placeholder estimation for provider built routes - best effort with provider fee fallback
+            const networkFeeCryptoBaseUnit = await (async () => {
+                try {
+                    const { networkFeeCryptoBaseUnit } = await (0, solana_1.getSolanaNetworkFeeCryptoBaseUnit)({
+                        adapter,
+                        from,
+                        instructions,
+                        addressLookupTableAddresses,
+                        tokenId: (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId),
+                    });
+                    return networkFeeCryptoBaseUnit;
+                }
+                catch {
+                    return fallbackNetworkFeeCryptoBaseUnit;
+                }
+            })();
+            const stepData = { networkFeeCryptoBaseUnit };
+            return (0, monads_1.Ok)(stepData);
+        }
+        try {
+            const { networkFeeCryptoBaseUnit, feeData, includeComputeBudget } = await (0, solana_1.getSolanaNetworkFeeCryptoBaseUnit)({
+                adapter,
+                from,
+                instructions,
+                addressLookupTableAddresses,
+                tokenId: (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId),
+            });
+            const stepData = {
+                transactionData: {
+                    type: 'solana_instructions',
+                    instructions: (0, solana_1.withComputeUnitLimit)({
+                        instructions,
+                        computeUnits: feeData.chainSpecific.computeUnits,
+                        includeComputeBudget,
+                        computeBudget: exports.RELAY_SOLANA_COMPUTE_BUDGET,
+                    }),
+                    addressLookupTableAddresses,
+                },
+                networkFeeCryptoBaseUnit,
+            };
+            return (0, monads_1.Ok)(stepData);
+        }
+        catch (error) {
+            return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getRelayStepData', error));
+        }
+    }
+    if ((0, types_1.isRelayQuoteTronItemData)(data)) {
+        const contractAddress = data.parameter?.contract_address;
+        const tronCallData = data.parameter?.data;
+        const isTronToken = (0, utils_1.isToken)(sellAsset.assetId);
+        if (isTronToken && !contractAddress)
+            return (0, monads_1.Err)((0, utils_2.makeTradeStepBuildFailedErr)('getRelayStepData'));
+        if (isTronToken && !tronCallData)
+            return (0, monads_1.Err)((0, utils_2.makeTradeStepBuildFailedErr)('getRelayStepData'));
+        if (type === 'rate') {
+            const stepData = {
+                networkFeeCryptoBaseUnit: fallbackNetworkFeeCryptoBaseUnit,
+            };
+            return (0, monads_1.Ok)(stepData);
+        }
+        const stepData = {
+            relayTransactionMetadata: { to: contractAddress, data: tronCallData },
+            networkFeeCryptoBaseUnit: fallbackNetworkFeeCryptoBaseUnit,
+        };
+        return (0, monads_1.Ok)(stepData);
+    }
+    return (0, monads_1.Err)((0, utils_2.makeTradeStepBuildFailedErr)('getRelayStepData'));
+}
+exports.getRelayStepData = getRelayStepData;

package/dist/cjs/swappers/RelaySwapper/utils/getRelayTradeContext.d.ts

@@ -0,0 +1,22 @@
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types';
+import type { chainIdToRelayChainId as relayChainMapImplementation } from '../constant';
+import type { GetRelayStepDataArgs } from './getRelayStepData';
+import type { RelayQuoteItem, RelayTradeQuoteInput, RelayTradeRateInput } from './types';
+type RelayTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData' | 'allowanceContract'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    relayStepInputs: {
+        data: RelayQuoteItem['data'];
+        allowanceContract: string;
+    }[];
+    stepDataArgs: Omit<GetRelayStepDataArgs, 'type' | 'input' | 'data' | 'spenderAddress'>;
+    relayId: string;
+};
+export declare const getRelayTradeContext: ({ input, deps, relayChainMap, }: {
+    input: RelayTradeQuoteInput | RelayTradeRateInput;
+    deps: SwapperDeps;
+    relayChainMap: typeof relayChainMapImplementation;
+}) => Promise<Result<RelayTradeContext, SwapErrorRight>>;
+export {};

package/dist/cjs/swappers/RelaySwapper/utils/getRelayTradeContext.js

@@ -0,0 +1,310 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelayTradeContext = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const axios_1 = __importDefault(require("axios"));
+const viem_1 = require("viem");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const affiliateFee_1 = require("../../../utils/affiliateFee");
+const helpers_1 = require("../../../utils/helpers");
+const constant_1 = require("../constant");
+const getRelayAssetAddress_1 = require("../utils/getRelayAssetAddress");
+const relayTokenToAsset_1 = require("../utils/relayTokenToAsset");
+const relayTokenToAssetId_1 = require("../utils/relayTokenToAssetId");
+const fetchRelayTrade_1 = require("./fetchRelayTrade");
+const helpers_2 = require("./helpers");
+const types_2 = require("./types");
+const getRelayTradeContext = async ({ input, deps, relayChainMap, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const xpub = 'xpub' in input ? input.xpub : undefined;
+    const slippageToleranceBps = input.slippageTolerancePercentageDecimal
+        ? (0, utils_1.convertDecimalPercentageToBasisPoints)(input.slippageTolerancePercentageDecimal).toFixed()
+        : undefined;
+    const assertion = (0, helpers_2.assertValidTrade)({ sellAsset, buyAsset, relayChainMap });
+    if (assertion.isErr())
+        return (0, monads_1.Err)(assertion.unwrapErr());
+    const { sellRelayChainId, buyRelayChainId } = assertion.unwrap();
+    const { sendAddress, recipient, refundTo } = (0, helpers_2.resolveRelayAddresses)({
+        input,
+        sellChainId: sellAsset.chainId,
+        buyChainId: buyAsset.chainId,
+    });
+    const maybeQuote = await (0, fetchRelayTrade_1.fetchRelayTrade)({
+        originChainId: sellRelayChainId,
+        originCurrency: (0, getRelayAssetAddress_1.getRelayAssetAddress)(sellAsset),
+        destinationChainId: buyRelayChainId,
+        destinationCurrency: (0, getRelayAssetAddress_1.getRelayAssetAddress)(buyAsset),
+        tradeType: 'EXACT_INPUT',
+        amount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        recipient,
+        user: sendAddress,
+        refundTo,
+        slippageTolerance: slippageToleranceBps,
+        refundOnOrigin: true,
+        referrer: 'shapeshift',
+        appFees: [
+            {
+                // Relay expects a BASE EVM address for affiliate fees
+                recipient: utils_1.DAO_TREASURY_BASE,
+                fee: affiliateBps,
+            },
+        ],
+    }, deps.config);
+    if (maybeQuote.isErr()) {
+        const error = maybeQuote.unwrapErr();
+        if (!axios_1.default.isAxiosError(error.cause)) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({ message: 'Unknown error', code: types_1.TradeQuoteError.UnknownError }));
+        }
+        const relayError = error.cause?.response?.data;
+        if (!(0, types_2.isRelayError)(relayError)) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({ message: 'Unknown error', code: types_1.TradeQuoteError.UnknownError }));
+        }
+        const tradeQuoteErrorCode = constant_1.relayErrorCodeToTradeQuoteError[relayError.errorCode];
+        if (tradeQuoteErrorCode) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({ message: relayError.message, code: tradeQuoteErrorCode }));
+        }
+        // Fallback for unmapped error codes (shouldn't happen, but prevents crashes)
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: relayError.message || 'Unknown Relay error',
+            code: types_1.TradeQuoteError.UnknownError,
+        }));
+    }
+    const { data: quote } = maybeQuote.unwrap();
+    const orderId = quote.protocol?.v2?.orderId;
+    if (!orderId && sellAsset.chainId === caip_1.btcChainId) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'Relay quote missing protocol.v2.orderId',
+            code: types_1.TradeQuoteError.UnknownError,
+        }));
+    }
+    const { slippageTolerance, currencyOut, timeEstimate } = quote.details;
+    const buyAmountAfterFeesCryptoBaseUnit = currencyOut.amount;
+    const rate = (0, utils_2.getInputOutputRate)({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const { currency: relayToken } = currencyOut;
+    const swapSteps = quote.steps.filter(step => step.id !== 'approve');
+    if (swapSteps.length >= constant_1.MAXIMUM_SUPPORTED_RELAY_STEPS) {
+        deps.mixPanel?.track(types_1.MixPanelEvent.RelayMultiHop);
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `Relay quote with ${swapSteps.length} swap steps not supported (maximum ${constant_1.MAXIMUM_SUPPORTED_RELAY_STEPS})`,
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    const swapStepsContainsMultipleItems = swapSteps.some(step => step.items?.length && step.items.length > 1);
+    // It's uncommon but can happen, log it to mixpanel to ensure we will investigate if it happens too much in the future
+    if (swapStepsContainsMultipleItems) {
+        deps.mixPanel?.track(types_1.MixPanelEvent.RelayStepMultipleItems);
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `Relay quote with step containing multiple items not supported`,
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    if (swapSteps.some(step => !step.items?.[0])) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({ message: 'Relay quote step contains no items' }));
+    }
+    const slippageTolerancePercentageDecimal = (() => {
+        if (input.slippageTolerancePercentageDecimal)
+            return input.slippageTolerancePercentageDecimal;
+        const destinationSlippageTolerancePercentageDecimal = (0, utils_1.bnOrZero)(slippageTolerance.destination.percent);
+        if (destinationSlippageTolerancePercentageDecimal.gt(0)) {
+            return (0, utils_1.convertBasisPointsToPercentage)(destinationSlippageTolerancePercentageDecimal).toFixed();
+        }
+        const originSlippageTolerancePercentageDecimal = (0, utils_1.bnOrZero)(slippageTolerance.origin.percent);
+        return (0, utils_1.convertBasisPointsToPercentage)(originSlippageTolerancePercentageDecimal).toFixed();
+    })();
+    const protocolAssetId = (0, relayTokenToAssetId_1.relayTokenToAssetId)(relayToken);
+    const maybeProtocolAsset = (0, relayTokenToAsset_1.relayTokenToAsset)(relayToken, deps.assetsById);
+    if (maybeProtocolAsset.isErr())
+        return (0, monads_1.Err)(maybeProtocolAsset.unwrapErr());
+    const protocolAsset = maybeProtocolAsset.unwrap();
+    const isCrossChain = sellAsset.chainId !== buyAsset.chainId;
+    const maybeAppFeesAsset = (() => {
+        // @TODO: when implementing fees, find if solana to solana assets are always showing empty app fees even if
+        // affiliate bps are set, if we remove this the quote fetching will fail because relayTokenToAsset will throw
+        if (sellAsset.chainId === caip_1.solanaChainId &&
+            buyAsset.chainId === caip_1.solanaChainId &&
+            quote.fees.app.currency.address === viem_1.zeroAddress) {
+            return (0, monads_1.Ok)(undefined);
+        }
+        return (0, relayTokenToAsset_1.relayTokenToAsset)(quote.fees.app.currency, deps.assetsById);
+    })();
+    const isNativeCurrencyInput = (() => {
+        if (maybeAppFeesAsset.isErr())
+            return false;
+        const appFeesAsset = maybeAppFeesAsset.unwrap();
+        if (!appFeesAsset)
+            return false;
+        if ((0, chain_adapters_1.isEvmChainId)(sellAsset.chainId)) {
+            return (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId) && sellAsset.chainId === appFeesAsset.chainId;
+        }
+        if (sellAsset.chainId === caip_1.btcChainId)
+            return sellAsset.assetId === appFeesAsset.assetId;
+        if (sellAsset.chainId === caip_1.solanaChainId)
+            return sellAsset.assetId === appFeesAsset.assetId;
+        if (sellAsset.chainId === caip_1.tronChainId)
+            return sellAsset.assetId === appFeesAsset.assetId;
+        return false;
+    })();
+    const appFeesBaseUnit = (() => {
+        if (maybeAppFeesAsset.isErr())
+            return '0';
+        const appFeesAsset = maybeAppFeesAsset.unwrap();
+        if (!appFeesAsset)
+            return '0';
+        // For cross-chain: always add back app fees
+        // For same-chain: only add back if input is native currency
+        if (isCrossChain || isNativeCurrencyInput) {
+            if (buyAsset.assetId === appFeesAsset.assetId) {
+                return quote.fees.app.amount;
+            }
+            // if fee is in sell asset, convert to buy asset
+            if (appFeesAsset.assetId === sellAsset.assetId) {
+                return (0, utils_1.convertPrecision)({
+                    value: quote.fees.app.amount,
+                    inputExponent: appFeesAsset.precision,
+                    outputExponent: buyAsset.precision,
+                })
+                    .times(rate)
+                    .toFixed(0);
+            }
+            // If fee is in a different asset, convert to buy asset
+            const feeAmountUsd = quote.fees.app.amountUsd;
+            const buyAssetUsd = currencyOut.amountUsd;
+            if (feeAmountUsd && buyAssetUsd && buyAmountAfterFeesCryptoBaseUnit) {
+                // Calculate the rate: (buyAssetAmount / buyAssetUsd) gives us "buy asset per USD"
+                // Then multiply by feeAmountUsd to get the equivalent buy asset amount
+                const buyAssetCryptoBaseUnitPerUsd = (0, utils_1.bnOrZero)(buyAmountAfterFeesCryptoBaseUnit).div(buyAssetUsd);
+                const appFeesCryptoBaseUnit = (0, utils_1.bnOrZero)(feeAmountUsd).times(buyAssetCryptoBaseUnitPerUsd);
+                return appFeesCryptoBaseUnit.toFixed(0);
+            }
+            return '0';
+        }
+        // cross-chain or same-chain with native currency as input are not applicable
+        return '0';
+    })();
+    // If same chain and not sellAsset as native currency, convert to protocol fee as native value is sent as well as erc20 tokens
+    // This is a edge case we never encountered before and it's more convenient to consider it as protocol fee as quickwin
+    const appFeesAsProtocolFee = (() => {
+        if (sellAsset.chainId !== buyAsset.chainId)
+            return {};
+        if (maybeAppFeesAsset.isErr())
+            return {};
+        const appFeesAsset = maybeAppFeesAsset.unwrap();
+        if (!appFeesAsset || isNativeCurrencyInput)
+            return {};
+        return {
+            [appFeesAsset.assetId]: {
+                amountCryptoBaseUnit: quote.fees.app.amount,
+                asset: appFeesAsset,
+                requiresBalance: false,
+            },
+        };
+    })();
+    const relayerFeeRelayToken = quote.fees.relayer.currency;
+    const maybeRelayerFeesAsset = (0, relayTokenToAsset_1.relayTokenToAsset)(relayerFeeRelayToken, deps.assetsById);
+    if (maybeRelayerFeesAsset.isErr()) {
+        return (0, monads_1.Err)(maybeRelayerFeesAsset.unwrapErr());
+    }
+    const relayerFeesAsset = maybeRelayerFeesAsset.unwrap();
+    const relayerFeesBuyAssetCryptoBaseUnit = (() => {
+        const relayerFeeAmount = quote.fees.relayer.amount;
+        // If fee is already in buy asset, return as is
+        if (relayerFeesAsset.assetId === buyAsset.assetId) {
+            return relayerFeeAmount;
+        }
+        // if fee is in sell asset, convert to buy asset
+        if (relayerFeesAsset.assetId === sellAsset.assetId) {
+            return (0, utils_1.convertPrecision)({
+                value: relayerFeeAmount,
+                inputExponent: relayerFeesAsset.precision,
+                outputExponent: buyAsset.precision,
+            })
+                .times(rate)
+                .toFixed(0);
+        }
+        // If fee is in a different asset, convert to buy asset
+        const feeAmountUsd = quote.fees.relayer.amountUsd;
+        const buyAssetUsd = currencyOut.amountUsd;
+        const buyAssetAmountBaseUnit = currencyOut.amount;
+        if (feeAmountUsd && buyAssetUsd && buyAssetAmountBaseUnit) {
+            // Calculate the rate: (buyAssetAmount / buyAssetUsd) gives us "buy asset per USD"
+            // Then multiply by feeAmountUsd to get the equivalent buy asset amount
+            const buyAssetCryptoBaseUnitPerUsd = (0, utils_1.bnOrZero)(buyAssetAmountBaseUnit).div(buyAssetUsd);
+            const buyAssetFeesCryptoBaseUnit = (0, utils_1.bnOrZero)(feeAmountUsd).times(buyAssetCryptoBaseUnitPerUsd);
+            return buyAssetFeesCryptoBaseUnit.toFixed(0);
+        }
+        return '0';
+    })();
+    // Add back relayer service and gas fees (relayer is including both) since they are downsides,
+    // and add appFees — these are quote-level and identical across every step
+    const buyAmountBeforeFeesCryptoBaseUnit = (0, utils_1.bnOrZero)(currencyOut.amount)
+        .plus(relayerFeesBuyAssetCryptoBaseUnit)
+        .plus(appFeesBaseUnit)
+        .toFixed();
+    const relayId = quote.steps[0].requestId;
+    const relayStepInputs = swapSteps.map(step => {
+        const data = step.items?.[0]?.data;
+        return { data, allowanceContract: (0, helpers_2.getRelayAllowanceContract)(data) };
+    });
+    return (0, monads_1.Ok)({
+        tradeCommon: {
+            id: relayId,
+            rate,
+            swapperName: types_1.SwapperName.Relay,
+            affiliateBps,
+            slippageTolerancePercentageDecimal,
+        },
+        stepCommon: {
+            rate,
+            buyAmountBeforeFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAsset,
+            sellAsset,
+            source: types_1.SwapperName.Relay,
+            estimatedExecutionTimeMs: timeEstimate * 1000,
+            affiliateFee: (0, affiliateFee_1.buildAffiliateFee)({
+                strategy: 'fixed_asset',
+                affiliateBps,
+                sellAsset,
+                buyAsset,
+                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                fixedAssetId: (0, utils_1.chainIdToFeeAssetId)(caip_1.baseChainId),
+                fixedAsset: deps.assetsById[(0, utils_1.chainIdToFeeAssetId)(caip_1.baseChainId)],
+                isEstimate: true,
+            }),
+        },
+        protocolFees: {
+            [protocolAssetId]: {
+                amountCryptoBaseUnit: quote.fees.relayer.amount,
+                asset: protocolAsset,
+                requiresBalance: false,
+            },
+            ...appFeesAsProtocolFee,
+        },
+        relayStepInputs,
+        stepDataArgs: {
+            sellAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            orderId,
+            from: sendAddress,
+            xpub,
+            fallbackNetworkFeeCryptoBaseUnit: quote.fees.gas.amount,
+            deps,
+        },
+        relayId,
+    });
+};
+exports.getRelayTradeContext = getRelayTradeContext;

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

@@ -0,0 +1,26 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { TransactionInstruction } from '@solana/web3.js';
+import type { SwapErrorRight } from '../../../types';
+import type { chainIdToRelayChainId as relayChainMapImplementation } from '../constant';
+import type { RelayQuoteItem, RelaySolanaInstruction, RelayTradeQuoteInput, RelayTradeRateInput } from './types';
+export declare const assertValidTrade: ({ sellAsset, buyAsset, relayChainMap, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+    relayChainMap: typeof relayChainMapImplementation;
+}) => Result<{
+    sellRelayChainId: number;
+    buyRelayChainId: number;
+}, SwapErrorRight>;
+export declare const resolveRelayAddresses: ({ input, sellChainId, buyChainId, }: {
+    input: RelayTradeQuoteInput | RelayTradeRateInput;
+    sellChainId: ChainId;
+    buyChainId: ChainId;
+}) => {
+    sendAddress: string;
+    recipient: string;
+    refundTo: string;
+};
+export declare const getRelayAllowanceContract: (data: RelayQuoteItem['data']) => string;
+export declare const convertRelaySolanaInstruction: (instruction: RelaySolanaInstruction) => TransactionInstruction;

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertRelaySolanaInstruction = exports.getRelayAllowanceContract = exports.resolveRelayAddresses = exports.assertValidTrade = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const monads_1 = require("@sniptt/monads");
+const web3_js_1 = require("@solana/web3.js");
+const types_1 = require("../../../types");
+const utils_1 = require("../../../utils");
+const getRelayDefaultUserAddress_1 = require("./getRelayDefaultUserAddress");
+const types_2 = require("./types");
+const isSupportedRelayChainId = (chainId) => (0, chain_adapters_1.isEvmChainId)(chainId) ||
+    chainId === caip_1.btcChainId ||
+    chainId === caip_1.solanaChainId ||
+    chainId === caip_1.tronChainId;
+const assertValidTrade = ({ sellAsset, buyAsset, relayChainMap, }) => {
+    if (!isSupportedRelayChainId(sellAsset.chainId)) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `asset '${sellAsset.name}' on chainId '${sellAsset.chainId}' not supported`,
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    if (!isSupportedRelayChainId(buyAsset.chainId)) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `asset '${buyAsset.name}' on chainId '${buyAsset.chainId}' not supported`,
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    const sellRelayChainId = relayChainMap[sellAsset.chainId];
+    const buyRelayChainId = relayChainMap[buyAsset.chainId];
+    if (sellRelayChainId === undefined) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `asset '${sellAsset.name}' on chainId '${sellAsset.chainId}' not supported`,
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    if (buyRelayChainId === undefined) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `asset '${buyAsset.name}' on chainId '${buyAsset.chainId}' not supported`,
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    return (0, monads_1.Ok)({ sellRelayChainId, buyRelayChainId });
+};
+exports.assertValidTrade = assertValidTrade;
+// BTC swaps must use the default user address for the fetch — a real address may not hold enough in a
+// single UTXO (the swap is funded from multiple UTXOs), so relay's estimation would fail. Rates default
+// every unset address; quotes carry the real ones (guarded upstream) so the `?? default` is inert there,
+// except refundTo which keeps the real send address even for BTC quotes.
+const resolveRelayAddresses = ({ input, sellChainId, buyChainId, }) => {
+    const sendAddress = sellChainId === caip_1.btcChainId
+        ? (0, getRelayDefaultUserAddress_1.getRelayDefaultUserAddress)(sellChainId)
+        : input.sendAddress ?? (0, getRelayDefaultUserAddress_1.getRelayDefaultUserAddress)(sellChainId);
+    const recipient = input.receiveAddress ?? (0, getRelayDefaultUserAddress_1.getRelayDefaultUserAddress)(buyChainId);
+    const refundTo = input.sendAddress ?? (0, getRelayDefaultUserAddress_1.getRelayDefaultUserAddress)(sellChainId);
+    return { sendAddress, recipient, refundTo };
+};
+exports.resolveRelayAddresses = resolveRelayAddresses;
+// The spender to approve: EVM routes approve the router (data.to); Tron approves the token contract;
+// UTXO/Solana need no allowance. Derived from the provider route, not the built transactionData.
+const getRelayAllowanceContract = (data) => {
+    if (!data)
+        return '';
+    if ((0, types_2.isRelayQuoteEvmItemData)(data))
+        return data.to ?? '';
+    if ((0, types_2.isRelayQuoteTronItemData)(data))
+        return data.parameter?.contract_address ?? '';
+    return '';
+};
+exports.getRelayAllowanceContract = getRelayAllowanceContract;
+const convertRelaySolanaInstruction = (instruction) => ({
+    ...instruction,
+    keys: instruction.keys.map(account => ({
+        ...account,
+        pubkey: new web3_js_1.PublicKey(account.pubkey),
+    })),
+    data: Buffer.from(instruction.data, 'hex'),
+    programId: new web3_js_1.PublicKey(instruction.programId),
+});
+exports.convertRelaySolanaInstruction = convertRelaySolanaInstruction;

package/dist/cjs/swappers/RelaySwapper/utils/notifyTransactionIndexing.js

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.notifyTransactionIndexing = void 0;
 const relayService_1 = require("./relayService");
 const notifyTransactionIndexing = async (params, config) => {
-    return await relayService_1.relayService.post(`${config.VITE_RELAY_API_URL}/transactions/single`, params);
+    return await relayService_1.relayService.post(`${config.VITE_RELAY_API_URL}/transactions/single`, params, (0, relayService_1.getRelayRequestConfig)(config));
 };
 exports.notifyTransactionIndexing = notifyTransactionIndexing;

package/dist/cjs/swappers/RelaySwapper/utils/relayService.d.ts

@@ -1,5 +1,8 @@
+import type { AxiosRequestConfig } from 'axios';
+import type { SwapperConfig } from '../../../types';
 export declare const relayService: {
-    get: <T = any>(url: string, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T, any, {}>, import("../../..").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("../../..").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("../../..").SwapErrorRight>>;
+    get: <T = any>(url: string, config?: AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T, any, {}>, import("../../../types").SwapErrorRight>>;
+    post: <T_1 = any>(url: string, data: any, config?: AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_1, any, {}>, import("../../../types").SwapErrorRight>>;
+    delete: <T_2 = any>(url: string, data: any, config?: AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_2, any, {}>, import("../../../types").SwapErrorRight>>;
 };
+export declare const getRelayRequestConfig: (config: SwapperConfig) => AxiosRequestConfig | undefined;