@shapeshiftoss/swapper 17.6.6-alpha.1 → 17.6.6

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

@@ -1,498 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTrade = 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 web3_js_1 = require("@solana/web3.js");
-const axios_1 = __importDefault(require("axios"));
-const viem_1 = require("viem");
-const types_1 = require("../../../types");
-const utils_2 = require("../../../utils");
-const tenderly_1 = require("../../../utils/tenderly");
-const helpers_1 = require("../../utils/helpers/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 types_2 = require("../utils/types");
-const fetchRelayTrade_1 = require("./fetchRelayTrade");
-const getRelayDefaultUserAddress_1 = require("./getRelayDefaultUserAddress");
-const getRelayPsbtRelayer_1 = require("./getRelayPsbtRelayer");
-async function getTrade({ input, deps, relayChainMap, }) {
-    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, accountNumber, affiliateBps, xpub, } = input;
-    const slippageToleranceBps = input.slippageTolerancePercentageDecimal
-        ? (0, utils_1.convertDecimalPercentageToBasisPoints)(input.slippageTolerancePercentageDecimal).toFixed()
-        : undefined;
-    const sellRelayChainId = relayChainMap[sellAsset.chainId];
-    const buyRelayChainId = relayChainMap[buyAsset.chainId];
-    if (!(0, chain_adapters_1.isEvmChainId)(sellAsset.chainId) &&
-        sellAsset.chainId !== caip_1.btcChainId &&
-        sellAsset.chainId !== caip_1.solanaChainId) {
-        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
-            message: `asset '${sellAsset.name}' on chainId '${sellAsset.chainId}' not supported`,
-            code: types_1.TradeQuoteError.UnsupportedTradePair,
-        }));
-    }
-    if (!(0, chain_adapters_1.isEvmChainId)(buyAsset.chainId) &&
-        buyAsset.chainId !== caip_1.btcChainId &&
-        buyAsset.chainId !== caip_1.solanaChainId) {
-        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
-            message: `asset '${buyAsset.name}' on chainId '${buyAsset.chainId}' not supported`,
-            code: types_1.TradeQuoteError.UnsupportedTradePair,
-        }));
-    }
-    if (sellRelayChainId === undefined) {
-        return (0, monads_1.Err)((0, utils_2.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_2.makeSwapErrorRight)({
-            message: `asset '${buyAsset.name}' on chainId '${buyAsset.chainId}' not supported`,
-            code: types_1.TradeQuoteError.UnsupportedTradePair,
-        }));
-    }
-    const sendAddress = (() => {
-        // We absolutely need to use the default user address for BTC swaps
-        // or relay quote endpoint will fail at estimation time because we don't necessarily
-        // send an address with enough funds but use multiple UTXOs to fund the swap
-        if (sellAsset.chainId === caip_1.btcChainId) {
-            return (0, getRelayDefaultUserAddress_1.getRelayDefaultUserAddress)(sellAsset.chainId);
-        }
-        if (input.quoteOrRate === 'rate') {
-            if (input.sendAddress)
-                return input.sendAddress;
-            return (0, getRelayDefaultUserAddress_1.getRelayDefaultUserAddress)(sellAsset.chainId);
-        }
-        return input.sendAddress;
-    })();
-    const recipient = (() => {
-        if (input.quoteOrRate === 'rate') {
-            if (input.receiveAddress)
-                return input.receiveAddress;
-            return (0, getRelayDefaultUserAddress_1.getRelayDefaultUserAddress)(buyAsset.chainId);
-        }
-        return input.receiveAddress;
-    })();
-    const refundTo = (() => {
-        if (input.quoteOrRate === 'rate') {
-            if (input.sendAddress)
-                return input.sendAddress;
-            return (0, getRelayDefaultUserAddress_1.getRelayDefaultUserAddress)(sellAsset.chainId);
-        }
-        if (!input.sendAddress)
-            throw new Error('Send address is required for refund');
-        return input.sendAddress;
-    })();
-    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 { 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,
-        }));
-    }
-    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 convertSolanaInstruction = (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),
-    });
-    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;
-        }
-        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';
-    })();
-    const networkFeeCryptoBaseUnit = await (async () => {
-        if (sellAsset.chainId === caip_1.btcChainId) {
-            const firstStep = swapSteps[0];
-            if (!firstStep)
-                throw new Error('Relay quote step contains no items');
-            const selectedItem = firstStep.items?.[0];
-            if (!selectedItem)
-                throw new Error('Relay quote step contains no items');
-            if (!selectedItem.data)
-                throw new Error('Relay quote step contains no data');
-            if (!(0, types_2.isRelayQuoteUtxoItemData)(selectedItem.data))
-                throw new Error('Relay BTC quote step contains no psbt');
-            if (!selectedItem.data.psbt)
-                throw new Error('Relay BTC quote step contains no psbt');
-            const relayer = (0, getRelayPsbtRelayer_1.getRelayPsbtRelayer)(selectedItem.data.psbt, sellAmountIncludingProtocolFeesCryptoBaseUnit);
-            if (!relayer)
-                throw new Error('Relay BTC quote step contains no relayer');
-            const getFeeDataInput = {
-                to: relayer,
-                value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                chainSpecific: {
-                    pubkey: xpub ?? (0, getRelayDefaultUserAddress_1.getRelayDefaultUserAddress)(sellAsset.chainId),
-                    opReturnData: firstStep.requestId,
-                },
-                sendMax: false,
-            };
-            const adapter = deps.assertGetUtxoChainAdapter(sellAsset.chainId);
-            const feeData = await adapter.getFeeData(getFeeDataInput);
-            return feeData.fast.txFee;
-        }
-        // Use Tenderly simulation with state overrides for EVM chains
-        if ((0, chain_adapters_1.isEvmChainId)(sellAsset.chainId)) {
-            const firstStep = swapSteps[0];
-            const selectedItem = firstStep?.items?.[0];
-            if (selectedItem?.data && (0, types_2.isRelayQuoteEvmItemData)(selectedItem.data)) {
-                try {
-                    const tenderlySimulation = await (0, tenderly_1.simulateWithStateOverrides)({
-                        chainId: sellAsset.chainId,
-                        // NOTE: zeroAddress is here purely for the purpose of satisfying the type sistem
-                        // That should never happen
-                        from: (0, viem_1.getAddress)(sendAddress ?? viem_1.zeroAddress),
-                        to: (0, viem_1.getAddress)(selectedItem.data.to ?? viem_1.zeroAddress),
-                        data: (selectedItem.data.data ?? '0x'),
-                        value: selectedItem.data.value ?? '0',
-                        sellAsset,
-                    }, {
-                        apiKey: deps.config.VITE_TENDERLY_API_KEY,
-                        accountSlug: deps.config.VITE_TENDERLY_ACCOUNT_SLUG,
-                        projectSlug: deps.config.VITE_TENDERLY_PROJECT_SLUG,
-                    });
-                    if (tenderlySimulation.success) {
-                        // Use Tenderly's gas estimate instead of Relay's
-                        const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
-                        const { average } = await adapter.getGasFeeData();
-                        const supportsEIP1559 = 'maxFeePerGas' in average;
-                        const tenderlyNetworkFee = chain_adapters_1.evm.calcNetworkFeeCryptoBaseUnit({
-                            ...average,
-                            supportsEIP1559,
-                            gasLimit: tenderlySimulation.gasLimit.toString(),
-                        });
-                        return tenderlyNetworkFee;
-                    }
-                }
-                catch (error) {
-                    // Silently fall through to use Relay's gas estimate
-                }
-            }
-        }
-        // Fallback to Relay's gas amount
-        return quote.fees.gas.amount;
-    })();
-    const steps = swapSteps.map((quoteStep) => {
-        const selectedItem = quoteStep.items?.[0];
-        if (!selectedItem)
-            throw new Error('Relay quote step contains no items');
-        // Add back relayer service and gas fees (relayer is including both) since they are downsides
-        // And add appFees
-        const buyAmountBeforeFeesCryptoBaseUnit = (0, utils_1.bnOrZero)(currencyOut.amount)
-            .plus(relayerFeesBuyAssetCryptoBaseUnit)
-            .plus(appFeesBaseUnit)
-            .toFixed();
-        const { allowanceContract, relayTransactionMetadata, solanaTransactionMetadata } = (() => {
-            if (!selectedItem.data)
-                throw new Error('Relay quote step contains no data');
-            if ((0, types_2.isRelayQuoteUtxoItemData)(selectedItem.data)) {
-                if (!selectedItem.data.psbt)
-                    throw new Error('Relay BTC quote step contains no psbt');
-                const relayer = (0, getRelayPsbtRelayer_1.getRelayPsbtRelayer)(selectedItem.data.psbt, sellAmountIncludingProtocolFeesCryptoBaseUnit);
-                return {
-                    allowanceContract: '',
-                    relayTransactionMetadata: {
-                        from: sendAddress,
-                        psbt: selectedItem.data.psbt,
-                        opReturnData: quoteStep.requestId,
-                        to: relayer,
-                        relayId: quote.steps[0].requestId,
-                    },
-                    solanaTransactionMetadata: undefined,
-                };
-            }
-            if ((0, types_2.isRelayQuoteEvmItemData)(selectedItem.data)) {
-                return {
-                    allowanceContract: selectedItem.data?.to ?? '',
-                    relayTransactionMetadata: {
-                        from: sendAddress,
-                        to: selectedItem.data?.to,
-                        value: selectedItem.data?.value,
-                        data: selectedItem.data?.data,
-                        // gas is not documented in the relay docs but refers to gasLimit
-                        gasLimit: selectedItem.data?.gas,
-                        chainId: Number((0, caip_1.fromChainId)(sellAsset.chainId).chainReference),
-                        relayId: quote.steps[0].requestId,
-                    },
-                    solanaTransactionMetadata: undefined,
-                };
-            }
-            if ((0, types_2.isRelayQuoteSolanaItemData)(selectedItem.data)) {
-                return {
-                    allowanceContract: '',
-                    solanaTransactionMetadata: {
-                        addressLookupTableAddresses: selectedItem.data?.addressLookupTableAddresses,
-                        instructions: selectedItem.data?.instructions?.map(convertSolanaInstruction),
-                    },
-                    relayTransactionMetadata: {
-                        relayId: quote.steps[0].requestId,
-                    },
-                };
-            }
-            throw new Error('Relay quote step contains no data');
-        })();
-        return {
-            allowanceContract,
-            rate,
-            buyAmountBeforeFeesCryptoBaseUnit,
-            buyAmountAfterFeesCryptoBaseUnit,
-            sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            buyAsset,
-            sellAsset,
-            accountNumber,
-            feeData: {
-                networkFeeCryptoBaseUnit,
-                protocolFees: {
-                    [protocolAssetId]: {
-                        amountCryptoBaseUnit: quote.fees.relayer.amount,
-                        asset: protocolAsset,
-                        requiresBalance: false,
-                    },
-                    ...appFeesAsProtocolFee,
-                },
-            },
-            source: types_1.SwapperName.Relay,
-            estimatedExecutionTimeMs: timeEstimate * 1000,
-            solanaTransactionMetadata,
-            relayTransactionMetadata,
-        };
-    });
-    const baseQuoteOrRate = {
-        id: quote.steps[0].requestId,
-        rate,
-        swapperName: types_1.SwapperName.Relay,
-        affiliateBps,
-        slippageTolerancePercentageDecimal,
-    };
-    if (input.quoteOrRate === 'quote') {
-        // ts is drunk, this is defined as we are under the quote umbrella but extra safety doesn't hurt
-        if (!receiveAddress) {
-            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
-                message: 'Receive address is required for quote',
-            }));
-        }
-        const tradeQuote = {
-            ...baseQuoteOrRate,
-            steps: steps,
-            receiveAddress,
-            quoteOrRate: 'quote',
-        };
-        return (0, monads_1.Ok)([tradeQuote]);
-    }
-    const tradeRate = {
-        ...baseQuoteOrRate,
-        steps: steps,
-        receiveAddress,
-        quoteOrRate: 'rate',
-    };
-    return (0, monads_1.Ok)([tradeRate]);
-}
-exports.getTrade = getTrade;

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

@@ -1,11 +0,0 @@
-import type { Result } from '@sniptt/monads';
-import type { AxiosResponse } from 'axios';
-import type { SwapErrorRight, SwapperConfig } from '../../../types';
-import type { RelayQuote } from './types';
-type NotifyTransactionIndexingParams = {
-    requestId: string;
-    chainId: string;
-    tx: string;
-};
-export declare const notifyTransactionIndexing: (params: NotifyTransactionIndexingParams, config: SwapperConfig) => Promise<Result<AxiosResponse<RelayQuote, any>, SwapErrorRight>>;
-export {};

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

@@ -1,8 +0,0 @@
-"use strict";
-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);
-};
-exports.notifyTransactionIndexing = notifyTransactionIndexing;

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

@@ -1,5 +0,0 @@
-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>>;
-};

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

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.relayService = void 0;
-const utils_1 = require("../../../utils");
-const maxAgeMillis = 15 * 1000;
-const cachedUrls = [];
-const axiosConfig = {
-    timeout: 10000,
-    headers: {
-        Accept: 'application/json',
-        'Content-Type': 'application/json',
-    },
-};
-const relayServiceBase = (0, utils_1.createCache)(maxAgeMillis, cachedUrls, axiosConfig);
-exports.relayService = (0, utils_1.makeSwapperAxiosServiceMonadic)(relayServiceBase);

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

@@ -1,6 +0,0 @@
-import type { AssetId } from '@shapeshiftoss/caip';
-import type { Asset } from '@shapeshiftoss/types';
-import type { Result } from '@sniptt/monads';
-import type { SwapErrorRight } from '../../../types';
-import type { RelayToken } from './types';
-export declare const relayTokenToAsset: (relayToken: RelayToken, assets: Partial<Record<AssetId, Asset>>) => Result<Asset, SwapErrorRight>;

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

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.relayTokenToAsset = void 0;
-const monads_1 = require("@sniptt/monads");
-const utils_1 = require("../../../utils");
-const relayTokenToAssetId_1 = require("./relayTokenToAssetId");
-const relayTokenToAsset = (relayToken, assets) => {
-    const assetId = (0, relayTokenToAssetId_1.relayTokenToAssetId)(relayToken);
-    const maybeAsset = assets[assetId];
-    if (maybeAsset)
-        return (0, monads_1.Ok)(maybeAsset);
-    return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
-        message: 'Unknown relay token',
-    }));
-};
-exports.relayTokenToAsset = relayTokenToAsset;

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

@@ -1,3 +0,0 @@
-import type { AssetId } from '@shapeshiftoss/caip';
-import type { RelayToken } from './types';
-export declare const relayTokenToAssetId: (relayToken: RelayToken) => AssetId;

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

@@ -1,95 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.relayTokenToAssetId = void 0;
-const caip_1 = require("@shapeshiftoss/caip");
-const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
-const constant_1 = require("../constant");
-const relayTokenToAssetId = (relayToken) => {
-    const chainId = constant_1.relayChainIdToChainId[relayToken.chainId];
-    const { chainReference } = (0, caip_1.fromChainId)(chainId);
-    const isNativeAsset = (() => {
-        if ((0, chain_adapters_1.isEvmChainId)(chainId)) {
-            return relayToken.address === constant_1.DEFAULT_RELAY_EVM_TOKEN_ADDRESS;
-        }
-        if (chainId === caip_1.btcChainId) {
-            return relayToken.address === constant_1.RELAY_BTC_TOKEN_ADDRESS;
-        }
-        if (chainId === caip_1.solanaChainId) {
-            return relayToken.address === constant_1.RELAY_SOLANA_TOKEN_ADDRESS;
-        }
-        return false;
-    })();
-    const { assetReference, assetNamespace } = (() => {
-        if (!isNativeAsset) {
-            const assetNamespace = (() => {
-                switch (true) {
-                    case (0, chain_adapters_1.isEvmChainId)(chainId):
-                        return caip_1.ASSET_NAMESPACE.erc20;
-                    case caip_1.CHAIN_REFERENCE.SolanaMainnet === chainReference:
-                        return caip_1.ASSET_NAMESPACE.splToken;
-                    default:
-                        throw Error(`chainReference '${chainReference}' not supported`);
-                }
-            })();
-            return {
-                assetReference: relayToken.address,
-                assetNamespace,
-            };
-        }
-        switch (chainReference) {
-            case caip_1.CHAIN_REFERENCE.EthereumMainnet:
-                return {
-                    assetReference: caip_1.ASSET_REFERENCE.Ethereum,
-                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
-                };
-            case caip_1.CHAIN_REFERENCE.AvalancheCChain:
-                return {
-                    assetReference: caip_1.ASSET_REFERENCE.AvalancheC,
-                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
-                };
-            case caip_1.CHAIN_REFERENCE.OptimismMainnet:
-                return {
-                    assetReference: caip_1.ASSET_REFERENCE.Optimism,
-                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
-                };
-            case caip_1.CHAIN_REFERENCE.PolygonMainnet:
-                return {
-                    assetReference: caip_1.ASSET_REFERENCE.Polygon,
-                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
-                };
-            case caip_1.CHAIN_REFERENCE.GnosisMainnet:
-                return {
-                    assetReference: caip_1.ASSET_REFERENCE.Gnosis,
-                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
-                };
-            case caip_1.CHAIN_REFERENCE.ArbitrumMainnet:
-                return {
-                    assetReference: caip_1.ASSET_REFERENCE.Arbitrum,
-                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
-                };
-            case caip_1.CHAIN_REFERENCE.BaseMainnet:
-                return {
-                    assetReference: caip_1.ASSET_REFERENCE.Base,
-                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
-                };
-            case caip_1.CHAIN_REFERENCE.BitcoinMainnet:
-                return {
-                    assetReference: caip_1.ASSET_REFERENCE.Bitcoin,
-                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
-                };
-            case caip_1.CHAIN_REFERENCE.SolanaMainnet:
-                return {
-                    assetReference: caip_1.ASSET_REFERENCE.Solana,
-                    assetNamespace: caip_1.ASSET_NAMESPACE.slip44,
-                };
-            default:
-                throw Error(`chainId '${relayToken.chainId}' not supported`);
-        }
-    })();
-    return (0, caip_1.toAssetId)({
-        chainId,
-        assetNamespace,
-        assetReference,
-    });
-};
-exports.relayTokenToAssetId = relayTokenToAssetId;