@shapeshiftoss/swapper 17.6.6 → 17.6.8

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

@@ -0,0 +1,192 @@
+import { evm, isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import BigNumber from 'bignumber.js';
+import { getSolanaTransactionFees } from '../../solana-utils/getSolanaTransactionFees.js';
+import { getUnsignedSolanaTransaction } from '../../solana-utils/getUnsignedSolanaTransaction.js';
+import { getTronTransactionFees } from '../../tron-utils/getTronTransactionFees.js';
+import { getUnsignedTronTransaction } from '../../tron-utils/getUnsignedTronTransaction.js';
+import { checkSafeTransactionStatus, getExecutableTradeStep, isExecutableTradeQuote, } from '../../utils.js';
+import { chainIdToRelayChainId } from './constant.js';
+import { getTradeQuote } from './getTradeQuote/getTradeQuote.js';
+import { getTradeRate } from './getTradeRate/getTradeRate.js';
+import { getLatestRelayStatusMessage } from './utils/getLatestRelayStatusMessage.js';
+import { notifyTransactionIndexing } from './utils/notifyTransactionIndexing.js';
+import { relayService } from './utils/relayService.js';
+// Keep track of the trades we already notified the relay indexer about
+const txIndexingMap = new Map();
+export const relayApi = {
+    getTradeQuote: (input, deps) => getTradeQuote(input, deps, chainIdToRelayChainId),
+    getTradeRate: (input, deps) => getTradeRate(input, deps, chainIdToRelayChainId),
+    getEvmTransactionFees: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = 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 evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
+        return feeData.networkFeeCryptoBaseUnit;
+    },
+    getUnsignedEvmTransaction: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = 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 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.max(gasLimitFromApi ?? '0', feeData.gasLimit).toFixed(),
+        });
+        return unsignedTx;
+    },
+    getUnsignedUtxoTransaction: async ({ stepIndex, tradeQuote, xpub, accountType, assertGetUtxoChainAdapter, }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = 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 (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = 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,
+    getUnsignedSolanaTransaction,
+    getTronTransactionFees,
+    getUnsignedTronTransaction,
+    checkTradeStatus: async ({ swap, txHash, chainId, address, config, fetchIsSmartContractAddressQuery, assertGetEvmChainAdapter, }) => {
+        const maybeSafeTransactionStatus = await 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) &&
+            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 notifyTransactionIndexing({
+                requestId: swap.metadata.relayTransactionMetadata.relayId,
+                chainId: chainIdToRelayChainId[chainId].toString(),
+                tx: JSON.stringify(relayTxParam),
+            }, config);
+            txIndexingMap.set(swap.id, true);
+        }
+        const maybeStatusResponse = await relayService.get(`${config.VITE_RELAY_API_URL}/intents/status/v2?requestId=${swap.metadata.relayTransactionMetadata.relayId}`);
+        if (maybeStatusResponse.isErr()) {
+            return {
+                buyTxHash: undefined,
+                status: TxStatus.Unknown,
+                message: undefined,
+            };
+        }
+        const { data: statusResponse } = maybeStatusResponse.unwrap();
+        const status = (() => {
+            switch (statusResponse.status) {
+                case 'success':
+                    return TxStatus.Confirmed;
+                case 'pending':
+                    return TxStatus.Pending;
+                case 'failed':
+                case 'refund':
+                    return TxStatus.Failed;
+                default:
+                    return 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: getLatestRelayStatusMessage(statusResponse),
+        };
+    },
+};

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

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

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 '../../../types.js';
+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/v2`, 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,17 @@
+import { btcAssetId, fromAssetId, isAssetReference, solAssetId, tronAssetId, } from '@shapeshiftoss/caip';
+import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
+import { DEFAULT_RELAY_EVM_TOKEN_ADDRESS, RELAY_BTC_TOKEN_ADDRESS, RELAY_SOLANA_TOKEN_ADDRESS, RELAY_TRON_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 (asset.assetId === tronAssetId)
+        return RELAY_TRON_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" | "TLsV52sRDL79HXGGm9yzwKibb6BeruhUzy";

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

@@ -0,0 +1,14 @@
+import { btcChainId, solanaChainId, tronChainId } from '@shapeshiftoss/caip';
+import { DEFAULT_RELAY_BTC_USER_ADDRESS, DEFAULT_RELAY_EVM_USER_ADDRESS, DEFAULT_RELAY_SOLANA_USER_ADDRESS, DEFAULT_RELAY_TRON_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;
+        case tronChainId:
+            return DEFAULT_RELAY_TRON_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(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>>;