@shapeshiftoss/swapper 17.6.2 → 17.6.4

package/dist/esm/swappers/RelaySwapper/getTradeQuote/getTradeQuote.js

@@ -0,0 +1,28 @@
+import { Err } from '@sniptt/monads';
+import { makeSwapErrorRight } from '../../../utils.js';
+import { getTrade } from '../utils/getTrade.js';
+export const getTradeQuote = async (input, deps, relayChainMap) => {
+    if (!input.sendAddress) {
+        return Err(makeSwapErrorRight({
+            message: 'sendAddress is required',
+        }));
+    }
+    if (!input.receiveAddress) {
+        return Err(makeSwapErrorRight({
+            message: 'receiveAddress is required',
+        }));
+    }
+    const args = {
+        buyAsset: input.buyAsset,
+        receiveAddress: input.receiveAddress,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        sellAsset: input.sellAsset,
+        sendAddress: input.sendAddress,
+        quoteOrRate: 'quote',
+        accountNumber: input.accountNumber,
+        affiliateBps: input.affiliateBps,
+        xpub: 'xpub' in input ? input.xpub : undefined,
+    };
+    const quotesResult = await getTrade({ input: args, deps, relayChainMap });
+    return quotesResult;
+};

package/dist/esm/swappers/RelaySwapper/getTradeRate/getTradeRate.d.ts

@@ -0,0 +1,4 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+import type { Result } from '@sniptt/monads';
+import type { GetTradeRateInput, SwapErrorRight, SwapperDeps, TradeRate } from '../../../types.js';
+export declare const getTradeRate: (input: GetTradeRateInput, deps: SwapperDeps, relayChainMap: Record<ChainId, number>) => Promise<Result<TradeRate[], SwapErrorRight>>;

package/dist/esm/swappers/RelaySwapper/getTradeRate/getTradeRate.js

@@ -0,0 +1,16 @@
+import { getTrade } from '../utils/getTrade.js';
+export const getTradeRate = async (input, deps, relayChainMap) => {
+    const args = {
+        quoteOrRate: 'rate',
+        buyAsset: input.buyAsset,
+        receiveAddress: input.receiveAddress,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        sellAsset: input.sellAsset,
+        sendAddress: input.sendAddress,
+        accountNumber: input.accountNumber,
+        affiliateBps: input.affiliateBps,
+        xpub: 'xpub' in input ? input.xpub : undefined,
+    };
+    const ratesResult = await getTrade({ input: args, deps, relayChainMap });
+    return ratesResult;
+};

package/dist/esm/swappers/RelaySwapper/index.d.ts

@@ -0,0 +1 @@
+export * from './RelaySwapper.js';

package/dist/esm/swappers/RelaySwapper/index.js

@@ -0,0 +1 @@
+export * from './RelaySwapper.js';

package/dist/esm/swappers/RelaySwapper/utils/fetchRelayTrade.d.ts

@@ -0,0 +1,5 @@
+import type { Result } from '@sniptt/monads';
+import type { AxiosResponse } from 'axios';
+import type { SwapErrorRight, SwapperConfig } from 'packages/swapper/src/types';
+import type { RelayFetchQuoteParams, RelayQuote } from './types.js';
+export declare const fetchRelayTrade: <T extends "rate" | "quote">(params: RelayFetchQuoteParams<T>, config: SwapperConfig) => Promise<Result<AxiosResponse<RelayQuote, any>, SwapErrorRight>>;

package/dist/esm/swappers/RelaySwapper/utils/fetchRelayTrade.js

@@ -0,0 +1,4 @@
+import { relayService } from './relayService.js';
+export const fetchRelayTrade = async (params, config) => {
+    return await relayService.post(`${config.VITE_RELAY_API_URL}/quote`, params);
+};

package/dist/esm/swappers/RelaySwapper/utils/getLatestRelayStatusMessage.d.ts

@@ -0,0 +1,2 @@
+import type { RelayStatus } from './types.js';
+export declare const getLatestRelayStatusMessage: (status: RelayStatus) => string;

package/dist/esm/swappers/RelaySwapper/utils/getLatestRelayStatusMessage.js

@@ -0,0 +1,18 @@
+import { RelayStatusMessage } from '../constant.js';
+export const getLatestRelayStatusMessage = (status) => {
+    const { status: statusValue } = status;
+    switch (true) {
+        case statusValue === 'waiting':
+            return RelayStatusMessage.WaitingForDeposit;
+        case statusValue === 'delayed':
+            return RelayStatusMessage.Retrying;
+        case statusValue === 'pending':
+            return RelayStatusMessage.DepositDetected;
+        case statusValue === 'success':
+            return RelayStatusMessage.SwapComplete;
+        case statusValue === 'failed':
+            return RelayStatusMessage.SwapFailed;
+        default:
+            return 'Unknown status';
+    }
+};

package/dist/esm/swappers/RelaySwapper/utils/getRelayAssetAddress.d.ts

@@ -0,0 +1,3 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { Address } from 'viem';
+export declare const getRelayAssetAddress: (asset: Asset) => Address;

package/dist/esm/swappers/RelaySwapper/utils/getRelayAssetAddress.js

@@ -0,0 +1,15 @@
+import { btcAssetId, fromAssetId, isAssetReference, solAssetId } from '@shapeshiftoss/caip';
+import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
+import { DEFAULT_RELAY_EVM_TOKEN_ADDRESS, RELAY_BTC_TOKEN_ADDRESS, RELAY_SOLANA_TOKEN_ADDRESS, } from '../constant.js';
+export const getRelayAssetAddress = (asset) => {
+    if (asset.assetId === btcAssetId)
+        return RELAY_BTC_TOKEN_ADDRESS;
+    if (asset.assetId === solAssetId)
+        return RELAY_SOLANA_TOKEN_ADDRESS;
+    if (isNativeEvmAsset(asset.assetId))
+        return DEFAULT_RELAY_EVM_TOKEN_ADDRESS;
+    const { assetReference } = fromAssetId(asset.assetId);
+    return isAssetReference(assetReference)
+        ? DEFAULT_RELAY_EVM_TOKEN_ADDRESS
+        : assetReference;
+};

package/dist/esm/swappers/RelaySwapper/utils/getRelayDefaultUserAddress.d.ts

@@ -0,0 +1,2 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+export declare const getRelayDefaultUserAddress: (chainId: ChainId) => "0x000000000000000000000000000000000000dead" | "bc1q4vxn43l44h30nkluqfxd9eckf45vr2awz38lwa" | "CbKGgVKLJFb8bBrf58DnAkdryX6ubewVytn7X957YwNr";

package/dist/esm/swappers/RelaySwapper/utils/getRelayDefaultUserAddress.js

@@ -0,0 +1,12 @@
+import { btcChainId, solanaChainId } from '@shapeshiftoss/caip';
+import { DEFAULT_RELAY_BTC_USER_ADDRESS, DEFAULT_RELAY_EVM_USER_ADDRESS, DEFAULT_RELAY_SOLANA_USER_ADDRESS, } from '../constant.js';
+export const getRelayDefaultUserAddress = (chainId) => {
+    switch (chainId) {
+        case btcChainId:
+            return DEFAULT_RELAY_BTC_USER_ADDRESS;
+        case solanaChainId:
+            return DEFAULT_RELAY_SOLANA_USER_ADDRESS;
+        default:
+            return DEFAULT_RELAY_EVM_USER_ADDRESS;
+    }
+};

package/dist/esm/swappers/RelaySwapper/utils/getRelayPsbtRelayer.d.ts

@@ -0,0 +1 @@
+export declare const getRelayPsbtRelayer: (psbtHex: string, sellAmountCryptoBaseUnit: string) => string | undefined;

package/dist/esm/swappers/RelaySwapper/utils/getRelayPsbtRelayer.js

@@ -0,0 +1,20 @@
+import * as bitcoin from '@shapeshiftoss/bitcoinjs-lib';
+export const getRelayPsbtRelayer = (psbtHex, sellAmountCryptoBaseUnit) => {
+    const psbtBuffer = Buffer.from(psbtHex, 'hex');
+    const psbt = bitcoin.Psbt.fromBuffer(new Uint8Array(psbtBuffer));
+    const outputs = psbt.txOutputs;
+    for (let i = 0; i < outputs.length; i++) {
+        const output = outputs[i];
+        const script = output.script;
+        try {
+            const address = bitcoin.address.fromOutputScript(script);
+            // Assuming the destination address is the one with the exact amount of sellAmountCryptoBaseUnit
+            if (output.value === BigInt(sellAmountCryptoBaseUnit)) {
+                return address;
+            }
+        }
+        catch (e) {
+            console.error(`Could not extract address from output ${i}:`, e);
+        }
+    }
+};

package/dist/esm/swappers/RelaySwapper/utils/getTrade.d.ts

@@ -0,0 +1,14 @@
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight, SwapperDeps, TradeQuote, TradeRate } from '../../../types.js';
+import type { chainIdToRelayChainId as relayChainMapImplementation } from '../constant.js';
+import type { RelayTradeInputParams } from '../utils/types.js';
+export declare function getTrade(args: {
+    input: RelayTradeInputParams<'quote'>;
+    deps: SwapperDeps;
+    relayChainMap: typeof relayChainMapImplementation;
+}): Promise<Result<TradeQuote[], SwapErrorRight>>;
+export declare function getTrade(args: {
+    input: RelayTradeInputParams<'rate'>;
+    deps: SwapperDeps;
+    relayChainMap: typeof relayChainMapImplementation;
+}): Promise<Result<TradeRate[], SwapErrorRight>>;

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

@@ -0,0 +1,446 @@
+import { btcChainId, fromChainId, solanaChainId } from '@shapeshiftoss/caip';
+import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import { bnOrZero, convertBasisPointsToPercentage, convertDecimalPercentageToBasisPoints, convertPrecision, DAO_TREASURY_BASE, } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { PublicKey } from '@solana/web3.js';
+import axios from 'axios';
+import { zeroAddress } from 'viem';
+import { MixPanelEvent, SwapperName, TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
+import { MAXIMUM_SUPPORTED_RELAY_STEPS, relayErrorCodeToTradeQuoteError } from '../constant.js';
+import { getRelayAssetAddress } from '../utils/getRelayAssetAddress.js';
+import { relayTokenToAsset } from '../utils/relayTokenToAsset.js';
+import { relayTokenToAssetId } from '../utils/relayTokenToAssetId.js';
+import { isRelayError, isRelayQuoteEvmItemData, isRelayQuoteSolanaItemData, isRelayQuoteUtxoItemData, } from '../utils/types.js';
+import { fetchRelayTrade } from './fetchRelayTrade.js';
+import { getRelayDefaultUserAddress } from './getRelayDefaultUserAddress.js';
+import { getRelayPsbtRelayer } from './getRelayPsbtRelayer.js';
+export async function getTrade({ input, deps, relayChainMap, }) {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, accountNumber, affiliateBps, xpub, } = input;
+    const slippageToleranceBps = input.slippageTolerancePercentageDecimal
+        ? convertDecimalPercentageToBasisPoints(input.slippageTolerancePercentageDecimal).toFixed()
+        : undefined;
+    const sellRelayChainId = relayChainMap[sellAsset.chainId];
+    const buyRelayChainId = relayChainMap[buyAsset.chainId];
+    if (!isEvmChainId(sellAsset.chainId) &&
+        sellAsset.chainId !== btcChainId &&
+        sellAsset.chainId !== solanaChainId) {
+        return Err(makeSwapErrorRight({
+            message: `asset '${sellAsset.name}' on chainId '${sellAsset.chainId}' not supported`,
+            code: TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    if (!isEvmChainId(buyAsset.chainId) &&
+        buyAsset.chainId !== btcChainId &&
+        buyAsset.chainId !== solanaChainId) {
+        return Err(makeSwapErrorRight({
+            message: `asset '${buyAsset.name}' on chainId '${buyAsset.chainId}' not supported`,
+            code: TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    if (sellRelayChainId === undefined) {
+        return Err(makeSwapErrorRight({
+            message: `asset '${sellAsset.name}' on chainId '${sellAsset.chainId}' not supported`,
+            code: TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    if (buyRelayChainId === undefined) {
+        return Err(makeSwapErrorRight({
+            message: `asset '${buyAsset.name}' on chainId '${buyAsset.chainId}' not supported`,
+            code: 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 === btcChainId) {
+            return getRelayDefaultUserAddress(sellAsset.chainId);
+        }
+        if (input.quoteOrRate === 'rate') {
+            if (input.sendAddress)
+                return input.sendAddress;
+            return getRelayDefaultUserAddress(sellAsset.chainId);
+        }
+        return input.sendAddress;
+    })();
+    const recipient = (() => {
+        if (input.quoteOrRate === 'rate') {
+            if (input.receiveAddress)
+                return input.receiveAddress;
+            return getRelayDefaultUserAddress(buyAsset.chainId);
+        }
+        return input.receiveAddress;
+    })();
+    const refundTo = (() => {
+        if (input.quoteOrRate === 'rate') {
+            if (input.sendAddress)
+                return input.sendAddress;
+            return getRelayDefaultUserAddress(sellAsset.chainId);
+        }
+        if (!input.sendAddress)
+            throw new Error('Send address is required for refund');
+        return input.sendAddress;
+    })();
+    const maybeQuote = await fetchRelayTrade({
+        originChainId: sellRelayChainId,
+        originCurrency: getRelayAssetAddress(sellAsset),
+        destinationChainId: buyRelayChainId,
+        destinationCurrency: 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: DAO_TREASURY_BASE,
+                fee: affiliateBps,
+            },
+        ],
+    }, deps.config);
+    if (maybeQuote.isErr()) {
+        const error = maybeQuote.unwrapErr();
+        if (!axios.isAxiosError(error.cause)) {
+            return Err(makeSwapErrorRight({
+                message: 'Unknown error',
+                code: TradeQuoteError.UnknownError,
+            }));
+        }
+        const relayError = error.cause?.response?.data;
+        if (!isRelayError(relayError)) {
+            return Err(makeSwapErrorRight({
+                message: 'Unknown error',
+                code: TradeQuoteError.UnknownError,
+            }));
+        }
+        const tradeQuoteErrorCode = relayErrorCodeToTradeQuoteError[relayError.errorCode];
+        if (tradeQuoteErrorCode) {
+            return Err(makeSwapErrorRight({
+                message: relayError.message,
+                code: tradeQuoteErrorCode,
+            }));
+        }
+    }
+    const { data: quote } = maybeQuote.unwrap();
+    const { slippageTolerance, currencyOut, timeEstimate } = quote.details;
+    const buyAmountAfterFeesCryptoBaseUnit = currencyOut.amount;
+    const rate = getInputOutputRate({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const { currency: relayToken } = currencyOut;
+    const swapSteps = quote.steps.filter(step => step.id !== 'approve');
+    if (swapSteps.length >= MAXIMUM_SUPPORTED_RELAY_STEPS) {
+        deps.mixPanel?.track(MixPanelEvent.RelayMultiHop);
+        return Err(makeSwapErrorRight({
+            message: `Relay quote with ${swapSteps.length} swap steps not supported (maximum ${MAXIMUM_SUPPORTED_RELAY_STEPS})`,
+            code: 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(MixPanelEvent.RelayStepMultipleItems);
+        return Err(makeSwapErrorRight({
+            message: `Relay quote with step containing multiple items not supported`,
+            code: TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    const slippageTolerancePercentageDecimal = (() => {
+        if (input.slippageTolerancePercentageDecimal)
+            return input.slippageTolerancePercentageDecimal;
+        const destinationSlippageTolerancePercentageDecimal = bnOrZero(slippageTolerance.destination.percent);
+        if (destinationSlippageTolerancePercentageDecimal.gt(0)) {
+            return convertBasisPointsToPercentage(destinationSlippageTolerancePercentageDecimal).toFixed();
+        }
+        const originSlippageTolerancePercentageDecimal = bnOrZero(slippageTolerance.origin.percent);
+        return convertBasisPointsToPercentage(originSlippageTolerancePercentageDecimal).toFixed();
+    })();
+    const protocolAssetId = relayTokenToAssetId(relayToken);
+    const maybeProtocolAsset = relayTokenToAsset(relayToken, deps.assetsById);
+    if (maybeProtocolAsset.isErr()) {
+        return Err(maybeProtocolAsset.unwrapErr());
+    }
+    const protocolAsset = maybeProtocolAsset.unwrap();
+    const convertSolanaInstruction = (instruction) => ({
+        ...instruction,
+        keys: instruction.keys.map(account => ({
+            ...account,
+            pubkey: new PublicKey(account.pubkey),
+        })),
+        data: Buffer.from(instruction.data, 'hex'),
+        programId: new 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 === solanaChainId &&
+            buyAsset.chainId === solanaChainId &&
+            quote.fees.app.currency.address === zeroAddress) {
+            return Ok(undefined);
+        }
+        return relayTokenToAsset(quote.fees.app.currency, deps.assetsById);
+    })();
+    const isNativeCurrencyInput = (() => {
+        if (maybeAppFeesAsset.isErr())
+            return false;
+        const appFeesAsset = maybeAppFeesAsset.unwrap();
+        if (!appFeesAsset)
+            return false;
+        if (isEvmChainId(sellAsset.chainId)) {
+            return isNativeEvmAsset(sellAsset.assetId) && sellAsset.chainId === appFeesAsset.chainId;
+        }
+        if (sellAsset.chainId === btcChainId) {
+            return sellAsset.assetId === appFeesAsset.assetId;
+        }
+        if (sellAsset.chainId === 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 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 = bnOrZero(buyAmountAfterFeesCryptoBaseUnit).div(buyAssetUsd);
+                const appFeesCryptoBaseUnit = 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 = relayTokenToAsset(relayerFeeRelayToken, deps.assetsById);
+    if (maybeRelayerFeesAsset.isErr()) {
+        return 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 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 = bnOrZero(buyAssetAmountBaseUnit).div(buyAssetUsd);
+            const buyAssetFeesCryptoBaseUnit = bnOrZero(feeAmountUsd).times(buyAssetCryptoBaseUnitPerUsd);
+            return buyAssetFeesCryptoBaseUnit.toFixed(0);
+        }
+        return '0';
+    })();
+    const networkFeeCryptoBaseUnit = await (async () => {
+        if (sellAsset.chainId === 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 (!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 = 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 ?? getRelayDefaultUserAddress(sellAsset.chainId),
+                    opReturnData: firstStep.requestId,
+                },
+                sendMax: false,
+            };
+            const adapter = deps.assertGetUtxoChainAdapter(sellAsset.chainId);
+            const feeData = await adapter.getFeeData(getFeeDataInput);
+            return feeData.fast.txFee;
+        }
+        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 = 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 (isRelayQuoteUtxoItemData(selectedItem.data)) {
+                if (!selectedItem.data.psbt)
+                    throw new Error('Relay BTC quote step contains no psbt');
+                const relayer = 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 (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(fromChainId(sellAsset.chainId).chainReference),
+                        relayId: quote.steps[0].requestId,
+                    },
+                    solanaTransactionMetadata: undefined,
+                };
+            }
+            if (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: SwapperName.Relay,
+            estimatedExecutionTimeMs: timeEstimate * 1000,
+            solanaTransactionMetadata,
+            relayTransactionMetadata,
+        };
+    });
+    const baseQuoteOrRate = {
+        id: quote.steps[0].requestId,
+        rate,
+        swapperName: 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 Err(makeSwapErrorRight({
+                message: 'Receive address is required for quote',
+            }));
+        }
+        const tradeQuote = {
+            ...baseQuoteOrRate,
+            steps: steps,
+            receiveAddress,
+            quoteOrRate: 'quote',
+        };
+        return Ok([tradeQuote]);
+    }
+    const tradeRate = {
+        ...baseQuoteOrRate,
+        steps: steps,
+        receiveAddress,
+        quoteOrRate: 'rate',
+    };
+    return Ok([tradeRate]);
+}

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

@@ -0,0 +1,11 @@
+import type { Result } from '@sniptt/monads';
+import type { AxiosResponse } from 'axios';
+import type { SwapErrorRight, SwapperConfig } from 'packages/swapper/src/types';
+import type { RelayQuote } from './types.js';
+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/esm/swappers/RelaySwapper/utils/notifyTransactionIndexing.js

@@ -0,0 +1,4 @@
+import { relayService } from './relayService.js';
+export const notifyTransactionIndexing = async (params, config) => {
+    return await relayService.post(`${config.VITE_RELAY_API_URL}/transactions/single`, params);
+};

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

@@ -0,0 +1,5 @@
+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("../../../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/swappers/RelaySwapper/utils/relayService.js

@@ -0,0 +1,12 @@
+import { createCache, makeSwapperAxiosServiceMonadic } from '../../../utils.js';
+const maxAgeMillis = 15 * 1000;
+const cachedUrls = [];
+const axiosConfig = {
+    timeout: 10000,
+    headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+    },
+};
+const relayServiceBase = createCache(maxAgeMillis, cachedUrls, axiosConfig);
+export const relayService = makeSwapperAxiosServiceMonadic(relayServiceBase);