@shapeshiftoss/swapper 17.6.3 → 17.6.5

package/dist/cjs/swappers/RelaySwapper/constant.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relayErrorCodeToTradeQuoteError = exports.MAXIMUM_SUPPORTED_RELAY_STEPS = exports.DEFAULT_RELAY_SOLANA_USER_ADDRESS = exports.DEFAULT_RELAY_BTC_USER_ADDRESS = exports.DEFAULT_RELAY_EVM_USER_ADDRESS = exports.RELAY_SOLANA_TOKEN_ADDRESS = exports.RELAY_BTC_TOKEN_ADDRESS = exports.DEFAULT_RELAY_EVM_TOKEN_ADDRESS = exports.relayChainIdToChainId = exports.RelayStatusMessage = exports.chainIdToRelayChainId = exports.relaySupportedChainIds = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const types_1 = require("@shapeshiftoss/types");
+const invert_1 = __importDefault(require("lodash/invert"));
+const viem_1 = require("viem");
+const chains_1 = require("viem/chains");
+const types_2 = require("../../types");
+const types_3 = require("./utils/types");
+exports.relaySupportedChainIds = [
+    types_1.KnownChainIds.EthereumMainnet,
+    types_1.KnownChainIds.ArbitrumMainnet,
+    types_1.KnownChainIds.BaseMainnet,
+    types_1.KnownChainIds.OptimismMainnet,
+    types_1.KnownChainIds.PolygonMainnet,
+    types_1.KnownChainIds.GnosisMainnet,
+    types_1.KnownChainIds.AvalancheMainnet,
+    types_1.KnownChainIds.BitcoinMainnet,
+    types_1.KnownChainIds.SolanaMainnet,
+    types_1.KnownChainIds.BnbSmartChainMainnet,
+];
+exports.chainIdToRelayChainId = {
+    // https://docs.relay.link/resources/supported-chains
+    [caip_1.btcChainId]: 8253038,
+    [caip_1.ethChainId]: chains_1.mainnet.id,
+    [caip_1.arbitrumChainId]: chains_1.arbitrum.id,
+    [caip_1.baseChainId]: chains_1.base.id,
+    [caip_1.optimismChainId]: chains_1.optimism.id,
+    [caip_1.polygonChainId]: chains_1.polygon.id,
+    // https://docs.relay.link/resources/supported-chains
+    [caip_1.solanaChainId]: 792703809,
+    [caip_1.gnosisChainId]: chains_1.gnosis.id,
+    [caip_1.avalancheChainId]: chains_1.avalanche.id,
+    [caip_1.bscChainId]: chains_1.bsc.id,
+};
+var RelayStatusMessage;
+(function (RelayStatusMessage) {
+    RelayStatusMessage["WaitingForDeposit"] = "Waiting for deposit...";
+    RelayStatusMessage["DepositDetected"] = "Deposit detected, processing swap...";
+    RelayStatusMessage["Retrying"] = "Taking a bit longer than usual to find a route, hang tight...";
+    RelayStatusMessage["SwapComplete"] = "Swap complete";
+    RelayStatusMessage["SwapFailed"] = "Swap failed";
+})(RelayStatusMessage || (exports.RelayStatusMessage = RelayStatusMessage = {}));
+exports.relayChainIdToChainId = (0, invert_1.default)(exports.chainIdToRelayChainId);
+exports.DEFAULT_RELAY_EVM_TOKEN_ADDRESS = viem_1.zeroAddress;
+exports.RELAY_BTC_TOKEN_ADDRESS = 'bc1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqmql8k8';
+exports.RELAY_SOLANA_TOKEN_ADDRESS = '11111111111111111111111111111111';
+exports.DEFAULT_RELAY_EVM_USER_ADDRESS = '0x000000000000000000000000000000000000dead';
+exports.DEFAULT_RELAY_BTC_USER_ADDRESS = 'bc1q4vxn43l44h30nkluqfxd9eckf45vr2awz38lwa';
+exports.DEFAULT_RELAY_SOLANA_USER_ADDRESS = 'CbKGgVKLJFb8bBrf58DnAkdryX6ubewVytn7X957YwNr';
+exports.MAXIMUM_SUPPORTED_RELAY_STEPS = 2;
+exports.relayErrorCodeToTradeQuoteError = {
+    [types_3.RelayErrorCode.AmountTooLow]: types_2.TradeQuoteError.SellAmountBelowMinimum,
+    [types_3.RelayErrorCode.Erc20RouterAddressNotFound]: types_2.TradeQuoteError.UnsupportedTradePair,
+    [types_3.RelayErrorCode.ExtraTransactionsNotSupported]: types_2.TradeQuoteError.UnsupportedTradePair,
+    [types_3.RelayErrorCode.InsufficientFunds]: types_2.TradeQuoteError.SellAmountBelowTradeFee,
+    [types_3.RelayErrorCode.InsufficientLiquidity]: types_2.TradeQuoteError.SellAmountBelowTradeFee,
+    [types_3.RelayErrorCode.InvalidAddress]: types_2.TradeQuoteError.UnsupportedTradePair,
+    [types_3.RelayErrorCode.InvalidExtraTransactions]: types_2.TradeQuoteError.UnsupportedTradePair,
+    [types_3.RelayErrorCode.NoQuotes]: types_2.TradeQuoteError.NoRouteFound,
+    [types_3.RelayErrorCode.NoSwapRoutesFound]: types_2.TradeQuoteError.NoRouteFound,
+    [types_3.RelayErrorCode.UnsupportedRoute]: types_2.TradeQuoteError.UnsupportedTradePair,
+    [types_3.RelayErrorCode.UnsupportedExecutionType]: types_2.TradeQuoteError.UnknownError,
+    [types_3.RelayErrorCode.UserRecipientMismatch]: types_2.TradeQuoteError.UnknownError,
+    [types_3.RelayErrorCode.PermitFailed]: types_2.TradeQuoteError.UnknownError,
+    [types_3.RelayErrorCode.SwapImpactTooHigh]: types_2.TradeQuoteError.UnknownError,
+    [types_3.RelayErrorCode.SwapQuoteFailed]: types_2.TradeQuoteError.UnknownError,
+    [types_3.RelayErrorCode.Unauthorized]: types_2.TradeQuoteError.UnknownError,
+    [types_3.RelayErrorCode.UnknownError]: types_2.TradeQuoteError.UnknownError,
+    [types_3.RelayErrorCode.UnsupportedChain]: types_2.TradeQuoteError.UnknownError,
+    [types_3.RelayErrorCode.UnsupportedCurrency]: types_2.TradeQuoteError.UnknownError,
+};

package/dist/cjs/swappers/RelaySwapper/endpoints.d.ts

@@ -0,0 +1,2 @@
+import type { SwapperApi } from '../../types';
+export declare const relayApi: SwapperApi;

package/dist/cjs/swappers/RelaySwapper/endpoints.js

@@ -0,0 +1,194 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relayApi = void 0;
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const unchained_client_1 = require("@shapeshiftoss/unchained-client");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const getSolanaTransactionFees_1 = require("../../solana-utils/getSolanaTransactionFees");
+const getUnsignedSolanaTransaction_1 = require("../../solana-utils/getUnsignedSolanaTransaction");
+const utils_1 = require("../../utils");
+const constant_1 = require("./constant");
+const getTradeQuote_1 = require("./getTradeQuote/getTradeQuote");
+const getTradeRate_1 = require("./getTradeRate/getTradeRate");
+const getLatestRelayStatusMessage_1 = require("./utils/getLatestRelayStatusMessage");
+const notifyTransactionIndexing_1 = require("./utils/notifyTransactionIndexing");
+const relayService_1 = require("./utils/relayService");
+// Keep track of the trades we already notified the relay indexer about
+const txIndexingMap = new Map();
+exports.relayApi = {
+    getTradeQuote: (input, deps) => (0, getTradeQuote_1.getTradeQuote)(input, deps, constant_1.chainIdToRelayChainId),
+    getTradeRate: (input, deps) => (0, getTradeRate_1.getTradeRate)(input, deps, constant_1.chainIdToRelayChainId),
+    getEvmTransactionFees: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
+        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
+        const { relayTransactionMetadata, sellAsset } = step;
+        if (!relayTransactionMetadata)
+            throw Error('Missing relay transaction metadata');
+        const { to, value, data } = relayTransactionMetadata;
+        if (to === undefined || value === undefined || data === undefined) {
+            const undefinedRequiredValues = [to, value, data].filter(value => value === undefined);
+            throw Error('undefined required values in transactionRequest', {
+                cause: {
+                    undefinedRequiredValues,
+                },
+            });
+        }
+        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
+        const feeData = await chain_adapters_1.evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
+        return feeData.networkFeeCryptoBaseUnit;
+    },
+    getUnsignedEvmTransaction: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
+        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
+        const { accountNumber, relayTransactionMetadata, sellAsset } = step;
+        if (!relayTransactionMetadata)
+            throw Error('Transaction metadata is required');
+        const { to, value, data, gasLimit: gasLimitFromApi } = relayTransactionMetadata;
+        if (to === undefined || value === undefined || data === undefined) {
+            const undefinedRequiredValues = [to, value, data].filter(value => value === undefined);
+            throw Error('undefined required values in swap step', {
+                cause: {
+                    undefinedRequiredValues,
+                },
+            });
+        }
+        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
+        const feeData = await chain_adapters_1.evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
+        const unsignedTx = await adapter.buildCustomApiTx({
+            accountNumber,
+            data,
+            from,
+            to,
+            value,
+            ...feeData,
+            // Use the higher amount of the node or the API, as the node doesn't always provide enough gas padding for total gas used.
+            gasLimit: bignumber_js_1.default.max(gasLimitFromApi ?? '0', feeData.gasLimit).toFixed(),
+        });
+        return unsignedTx;
+    },
+    getUnsignedUtxoTransaction: async ({ stepIndex, tradeQuote, xpub, accountType, assertGetUtxoChainAdapter, }) => {
+        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
+        const { accountNumber, sellAsset, relayTransactionMetadata } = step;
+        if (!relayTransactionMetadata)
+            throw new Error('Missing relay transaction metadata');
+        const { to, opReturnData } = relayTransactionMetadata;
+        if (!to)
+            throw new Error('Missing transaction destination');
+        if (!opReturnData)
+            throw new Error('Missing opReturnData');
+        const adapter = assertGetUtxoChainAdapter(sellAsset.chainId);
+        const { fast } = await adapter.getFeeData({
+            to,
+            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            chainSpecific: { pubkey: xpub, opReturnData },
+            sendMax: false,
+        });
+        return assertGetUtxoChainAdapter(sellAsset.chainId).buildSendApiTransaction({
+            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            xpub,
+            to,
+            accountNumber,
+            chainSpecific: {
+                accountType,
+                opReturnData,
+                satoshiPerByte: fast.chainSpecific.satoshiPerByte,
+            },
+        });
+    },
+    getUtxoTransactionFees: async ({ stepIndex, tradeQuote, xpub, assertGetUtxoChainAdapter }) => {
+        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
+        const { sellAsset, relayTransactionMetadata } = step;
+        if (!relayTransactionMetadata?.psbt)
+            throw new Error('Missing psbt');
+        const { to, opReturnData } = relayTransactionMetadata;
+        if (!to)
+            throw new Error('Missing transaction destination');
+        if (!opReturnData)
+            throw new Error('Missing opReturnData');
+        const adapter = assertGetUtxoChainAdapter(sellAsset.chainId);
+        const { fast } = await adapter.getFeeData({
+            to,
+            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            chainSpecific: { pubkey: xpub, opReturnData },
+            sendMax: false,
+        });
+        return fast.txFee;
+    },
+    getSolanaTransactionFees: getSolanaTransactionFees_1.getSolanaTransactionFees,
+    getUnsignedSolanaTransaction: getUnsignedSolanaTransaction_1.getUnsignedSolanaTransaction,
+    checkTradeStatus: async ({ swap, txHash, chainId, address, config, fetchIsSmartContractAddressQuery, assertGetEvmChainAdapter, }) => {
+        const maybeSafeTransactionStatus = await (0, utils_1.checkSafeTransactionStatus)({
+            txHash,
+            chainId,
+            assertGetEvmChainAdapter,
+            address,
+            fetchIsSmartContractAddressQuery,
+        });
+        if (!swap?.metadata.relayTransactionMetadata)
+            throw new Error('Missing swap metadata');
+        if (maybeSafeTransactionStatus) {
+            // return any safe transaction status that has not yet executed on chain (no buyTxHash)
+            if (!maybeSafeTransactionStatus.buyTxHash)
+                return maybeSafeTransactionStatus;
+            // The safe buyTxHash is the on chain transaction hash (not the safe transaction hash).
+            // Mutate txHash and continue with regular status check flow.
+            txHash = maybeSafeTransactionStatus.buyTxHash;
+        }
+        if (swap.metadata.relayTransactionMetadata &&
+            !txIndexingMap.has(swap.id) &&
+            (0, chain_adapters_1.isEvmChainId)(chainId)) {
+            const relayTxParam = {
+                ...swap.metadata.relayTransactionMetadata,
+                txHash,
+            };
+            // We don't need to handle the response here, we just want to notify the relay indexer
+            await (0, notifyTransactionIndexing_1.notifyTransactionIndexing)({
+                requestId: swap.metadata.relayTransactionMetadata.relayId,
+                chainId: constant_1.chainIdToRelayChainId[chainId].toString(),
+                tx: JSON.stringify(relayTxParam),
+            }, config);
+            txIndexingMap.set(swap.id, true);
+        }
+        const maybeStatusResponse = await relayService_1.relayService.get(`${config.VITE_RELAY_API_URL}/intents/status/v2?requestId=${swap.metadata.relayTransactionMetadata.relayId}`);
+        if (maybeStatusResponse.isErr()) {
+            return {
+                buyTxHash: undefined,
+                status: unchained_client_1.TxStatus.Unknown,
+                message: undefined,
+            };
+        }
+        const { data: statusResponse } = maybeStatusResponse.unwrap();
+        const status = (() => {
+            switch (statusResponse.status) {
+                case 'success':
+                    return unchained_client_1.TxStatus.Confirmed;
+                case 'pending':
+                    return unchained_client_1.TxStatus.Pending;
+                case 'failed':
+                case 'refund':
+                    return unchained_client_1.TxStatus.Failed;
+                default:
+                    return unchained_client_1.TxStatus.Unknown;
+            }
+        })();
+        // Relay refers to in Txs as "inTxHashes" but to out Txs as simply "txHashes" when they really mean "outTxHashes"
+        // One thing to note is that for same-chain Txs, there is no "out Tx" per se since the in Tx *is* the out Tx
+        const outTxHashes = statusResponse.txHashes;
+        const isSameChainSwap = statusResponse.destinationChainId === statusResponse.originChainId;
+        const buyTxHash = isSameChainSwap ? txHash : outTxHashes?.[0];
+        return {
+            status,
+            buyTxHash,
+            message: (0, getLatestRelayStatusMessage_1.getLatestRelayStatusMessage)(statusResponse),
+        };
+    },
+};

package/dist/cjs/swappers/RelaySwapper/getTradeQuote/getTradeQuote.d.ts

@@ -0,0 +1,4 @@
+import type { Result } from '@sniptt/monads';
+import type { CommonTradeQuoteInput, SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types';
+import type { chainIdToRelayChainId as relayChainMapImplementation } from '../constant';
+export declare const getTradeQuote: (input: CommonTradeQuoteInput, deps: SwapperDeps, relayChainMap: typeof relayChainMapImplementation) => Promise<Result<TradeQuote[], SwapErrorRight>>;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeQuote = void 0;
+const monads_1 = require("@sniptt/monads");
+const utils_1 = require("../../../utils");
+const getTrade_1 = require("../utils/getTrade");
+const getTradeQuote = async (input, deps, relayChainMap) => {
+    if (!input.sendAddress) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: 'sendAddress is required',
+        }));
+    }
+    if (!input.receiveAddress) {
+        return (0, monads_1.Err)((0, utils_1.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 (0, getTrade_1.getTrade)({ input: args, deps, relayChainMap });
+    return quotesResult;
+};
+exports.getTradeQuote = getTradeQuote;

package/dist/cjs/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';
+export declare const getTradeRate: (input: GetTradeRateInput, deps: SwapperDeps, relayChainMap: Record<ChainId, number>) => Promise<Result<TradeRate[], SwapErrorRight>>;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeRate = void 0;
+const getTrade_1 = require("../utils/getTrade");
+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 (0, getTrade_1.getTrade)({ input: args, deps, relayChainMap });
+    return ratesResult;
+};
+exports.getTradeRate = getTradeRate;

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./RelaySwapper"), exports);

package/dist/cjs/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';
+export declare const fetchRelayTrade: <T extends "rate" | "quote">(params: RelayFetchQuoteParams<T>, config: SwapperConfig) => Promise<Result<AxiosResponse<RelayQuote, any>, SwapErrorRight>>;

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchRelayTrade = void 0;
+const relayService_1 = require("./relayService");
+const fetchRelayTrade = async (params, config) => {
+    return await relayService_1.relayService.post(`${config.VITE_RELAY_API_URL}/quote`, params);
+};
+exports.fetchRelayTrade = fetchRelayTrade;

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

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

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLatestRelayStatusMessage = void 0;
+const constant_1 = require("../constant");
+const getLatestRelayStatusMessage = (status) => {
+    const { status: statusValue } = status;
+    switch (true) {
+        case statusValue === 'waiting':
+            return constant_1.RelayStatusMessage.WaitingForDeposit;
+        case statusValue === 'delayed':
+            return constant_1.RelayStatusMessage.Retrying;
+        case statusValue === 'pending':
+            return constant_1.RelayStatusMessage.DepositDetected;
+        case statusValue === 'success':
+            return constant_1.RelayStatusMessage.SwapComplete;
+        case statusValue === 'failed':
+            return constant_1.RelayStatusMessage.SwapFailed;
+        default:
+            return 'Unknown status';
+    }
+};
+exports.getLatestRelayStatusMessage = getLatestRelayStatusMessage;

package/dist/cjs/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/cjs/swappers/RelaySwapper/utils/getRelayAssetAddress.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelayAssetAddress = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const helpers_1 = require("../../utils/helpers/helpers");
+const constant_1 = require("../constant");
+const getRelayAssetAddress = (asset) => {
+    if (asset.assetId === caip_1.btcAssetId)
+        return constant_1.RELAY_BTC_TOKEN_ADDRESS;
+    if (asset.assetId === caip_1.solAssetId)
+        return constant_1.RELAY_SOLANA_TOKEN_ADDRESS;
+    if ((0, helpers_1.isNativeEvmAsset)(asset.assetId))
+        return constant_1.DEFAULT_RELAY_EVM_TOKEN_ADDRESS;
+    const { assetReference } = (0, caip_1.fromAssetId)(asset.assetId);
+    return (0, caip_1.isAssetReference)(assetReference)
+        ? constant_1.DEFAULT_RELAY_EVM_TOKEN_ADDRESS
+        : assetReference;
+};
+exports.getRelayAssetAddress = getRelayAssetAddress;

package/dist/cjs/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/cjs/swappers/RelaySwapper/utils/getRelayDefaultUserAddress.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelayDefaultUserAddress = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const constant_1 = require("../constant");
+const getRelayDefaultUserAddress = (chainId) => {
+    switch (chainId) {
+        case caip_1.btcChainId:
+            return constant_1.DEFAULT_RELAY_BTC_USER_ADDRESS;
+        case caip_1.solanaChainId:
+            return constant_1.DEFAULT_RELAY_SOLANA_USER_ADDRESS;
+        default:
+            return constant_1.DEFAULT_RELAY_EVM_USER_ADDRESS;
+    }
+};
+exports.getRelayDefaultUserAddress = getRelayDefaultUserAddress;

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

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

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

@@ -0,0 +1,47 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelayPsbtRelayer = void 0;
+const bitcoin = __importStar(require("@shapeshiftoss/bitcoinjs-lib"));
+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);
+        }
+    }
+};
+exports.getRelayPsbtRelayer = getRelayPsbtRelayer;

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

@@ -0,0 +1,14 @@
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight, SwapperDeps, TradeQuote, TradeRate } from '../../../types';
+import type { chainIdToRelayChainId as relayChainMapImplementation } from '../constant';
+import type { RelayTradeInputParams } from '../utils/types';
+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>>;