@shapeshiftoss/swapper 17.8.0 → 19.0.0

package/dist/esm/swappers/AcrossSwapper/utils/getAcrossTradeContext.js

@@ -0,0 +1,177 @@
+import { solanaChainId } from '@shapeshiftoss/caip';
+import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import { BigAmount, bnOrZero, chainIdToFeeAssetId, convertPrecision, isTreasuryChainId, } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import axios from 'axios';
+import { zeroAddress } from 'viem';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils/index.js';
+import { buildAffiliateFee } from '../../../utils/affiliateFee.js';
+import { getTreasuryAddressFromChainId, normalizeEpochToMs } from '../../../utils/helpers.js';
+import { acrossChainIdToChainId, acrossErrorCodeToTradeQuoteError } from '../constant.js';
+import { fetchAcrossTrade } from './fetchAcrossTrade.js';
+import { assertValidTrade, getAcrossAssetAddress } from './helpers.js';
+import { isAcrossError } from './types.js';
+export const getAcrossTradeContext = async ({ input, deps, depositor, recipient, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const assertion = assertValidTrade({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const { sellAcrossChainId, buyAcrossChainId } = assertion.unwrap();
+    const isSolanaRoute = sellAsset.chainId === solanaChainId || buyAsset.chainId === solanaChainId;
+    const appFee = (() => {
+        if (isSolanaRoute)
+            return;
+        if (!isTreasuryChainId(buyAsset.chainId))
+            return;
+        const bps = bnOrZero(affiliateBps);
+        if (!bps.isFinite() || bps.lte(0))
+            return;
+        return bps.div(10000).toNumber();
+    })();
+    const appFeeRecipient = (() => {
+        if (appFee === undefined)
+            return;
+        try {
+            return getTreasuryAddressFromChainId(buyAsset.chainId).toLowerCase();
+        }
+        catch (e) {
+            console.error(`[getAcrossTradeContext] Failed to get treasury address for chainId ${buyAsset.chainId}, affiliate fee will not be applied`, e);
+        }
+    })();
+    const slippage = input.slippageTolerancePercentageDecimal ?? 'auto';
+    const integratorId = deps.config.VITE_ACROSS_INTEGRATOR_ID || undefined;
+    const maybeQuote = await fetchAcrossTrade({
+        tradeType: 'exactInput',
+        amount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        inputToken: getAcrossAssetAddress(sellAsset.assetId),
+        outputToken: getAcrossAssetAddress(buyAsset.assetId),
+        originChainId: sellAcrossChainId,
+        destinationChainId: buyAcrossChainId,
+        depositor,
+        recipient,
+        appFee,
+        appFeeRecipient,
+        integratorId,
+        slippage,
+    }, deps.config);
+    if (maybeQuote.isErr()) {
+        const error = maybeQuote.unwrapErr();
+        if (!axios.isAxiosError(error.cause)) {
+            return Err(makeSwapErrorRight({ message: 'Unknown error', code: TradeQuoteError.UnknownError }));
+        }
+        const acrossError = error.cause?.response?.data;
+        if (!isAcrossError(acrossError)) {
+            return Err(makeSwapErrorRight({ message: 'Unknown error', code: TradeQuoteError.UnknownError }));
+        }
+        const tradeQuoteErrorCode = acrossErrorCodeToTradeQuoteError[acrossError.code];
+        return Err(makeSwapErrorRight({
+            message: acrossError.message,
+            code: tradeQuoteErrorCode ?? TradeQuoteError.UnknownError,
+        }));
+    }
+    const { data: quote } = maybeQuote.unwrap();
+    const buyAmountAfterFeesCryptoBaseUnit = quote.expectedOutputAmount;
+    const rate = getInputOutputRate({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const bridgeFeeAmount = quote.fees.total.amount;
+    const bridgeFeeAsset = quote.fees.total.token;
+    const buyAssetAcrossAddress = getAcrossAssetAddress(buyAsset.assetId);
+    const isBridgeFeeInBuyAsset = bridgeFeeAsset.chainId === buyAcrossChainId &&
+        (bridgeFeeAsset.address === buyAssetAcrossAddress ||
+            (isEvmChainId(buyAsset.chainId) &&
+                bridgeFeeAsset.address.toLowerCase() === buyAssetAcrossAddress.toLowerCase()));
+    const buyAmountBeforeFeesCryptoBaseUnit = (() => {
+        if (!isBridgeFeeInBuyAsset)
+            return buyAmountAfterFeesCryptoBaseUnit;
+        const bridgeFeeInBuyAssetPrecision = BigAmount.fromBaseUnit({
+            value: convertPrecision({
+                value: bridgeFeeAmount,
+                inputExponent: bridgeFeeAsset.decimals,
+                outputExponent: buyAsset.precision,
+            }).toFixed(0),
+            precision: buyAsset.precision,
+        });
+        return BigAmount.fromBaseUnit({
+            value: buyAmountAfterFeesCryptoBaseUnit,
+            precision: buyAsset.precision,
+        })
+            .plus(bridgeFeeInBuyAssetPrecision)
+            .toBaseUnit();
+    })();
+    // Build protocol fee asset ID — Across returns its own numeric chain IDs, convert to CAIP
+    const bridgeFeeAssetCaipChainId = acrossChainIdToChainId[bridgeFeeAsset.chainId.toString()];
+    const bridgeFeeAssetId = (() => {
+        if (!bridgeFeeAssetCaipChainId)
+            return;
+        const isNativeFeeAsset = (() => {
+            if (bridgeFeeAssetCaipChainId === solanaChainId) {
+                return (bridgeFeeAsset.address === 'So11111111111111111111111111111111111111112' ||
+                    bridgeFeeAsset.address === zeroAddress);
+            }
+            return bridgeFeeAsset.address === zeroAddress;
+        })();
+        if (isNativeFeeAsset)
+            return chainIdToFeeAssetId(bridgeFeeAssetCaipChainId);
+        const tokenStandard = bridgeFeeAssetCaipChainId.startsWith('solana') ? 'token' : 'erc20';
+        return `${bridgeFeeAssetCaipChainId}/${tokenStandard}:${bridgeFeeAsset.address}`;
+    })();
+    const allowanceContract = isEvmChainId(sellAsset.chainId) ? quote.checks.allowance.spender : '';
+    const protocolFees = bridgeFeeAssetId
+        ? {
+            [bridgeFeeAssetId]: {
+                amountCryptoBaseUnit: bridgeFeeAmount,
+                asset: {
+                    symbol: bridgeFeeAsset.symbol,
+                    chainId: bridgeFeeAssetCaipChainId,
+                    precision: bridgeFeeAsset.decimals,
+                },
+                requiresBalance: false,
+            },
+        }
+        : {};
+    return Ok({
+        tradeCommon: {
+            id: quote.id,
+            rate,
+            swapperName: SwapperName.Across,
+            affiliateBps,
+            slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+        },
+        stepCommon: {
+            allowanceContract,
+            rate,
+            buyAmountBeforeFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAsset,
+            sellAsset,
+            source: SwapperName.Across,
+            estimatedExecutionTimeMs: quote.expectedFillTime * 1000,
+            affiliateFee: appFee !== undefined && appFeeRecipient !== undefined
+                ? buildAffiliateFee({
+                    strategy: 'buy_asset',
+                    affiliateBps,
+                    sellAsset,
+                    buyAsset,
+                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                })
+                : undefined,
+        },
+        protocolFees,
+        stepDataArgs: {
+            swapTx: quote.swapTx,
+            sellAsset,
+            from: depositor,
+            spenderAddress: allowanceContract,
+            fallbackNetworkFeeCryptoBaseUnit: quote.fees.originGas.amount,
+            deps,
+        },
+        deadline: normalizeEpochToMs(quote.quoteExpiryTimestamp),
+    });
+};

package/dist/esm/swappers/AcrossSwapper/utils/helpers.d.ts

@@ -0,0 +1,12 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types.js';
+export declare const getAcrossAssetAddress: (assetId: string) => string;
+export declare const getDefaultUserAddress: (chainId: string) => string;
+export declare const assertValidTrade: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Result<{
+    sellAcrossChainId: number;
+    buyAcrossChainId: number;
+}, SwapErrorRight>;

package/dist/esm/swappers/AcrossSwapper/utils/helpers.js

@@ -0,0 +1,52 @@
+import { fromAssetId, isAssetReference, solanaChainId, usdcOnSolanaAssetId, } from '@shapeshiftoss/caip';
+import { Err, Ok } from '@sniptt/monads';
+import { zeroAddress } from 'viem';
+import { TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
+import { isNativeEvmAsset } from '../../../utils/helpers.js';
+import { ACROSS_SOLANA_TOKEN_ADDRESS, chainIdToAcrossChainId, DEFAULT_ACROSS_EVM_TOKEN_ADDRESS, DEFAULT_ACROSS_EVM_USER_ADDRESS, DEFAULT_ACROSS_SOLANA_USER_ADDRESS, } from '../constant.js';
+export const getAcrossAssetAddress = (assetId) => {
+    if (isNativeEvmAsset(assetId))
+        return DEFAULT_ACROSS_EVM_TOKEN_ADDRESS;
+    const { chainId, assetReference } = fromAssetId(assetId);
+    if (chainId === solanaChainId && !isAssetReference(assetReference))
+        return assetReference;
+    if (chainId === solanaChainId)
+        return ACROSS_SOLANA_TOKEN_ADDRESS;
+    return isAssetReference(assetReference) ? zeroAddress : assetReference;
+};
+export const getDefaultUserAddress = (chainId) => {
+    if (chainId === solanaChainId)
+        return DEFAULT_ACROSS_SOLANA_USER_ADDRESS;
+    return DEFAULT_ACROSS_EVM_USER_ADDRESS;
+};
+export const assertValidTrade = ({ sellAsset, buyAsset, }) => {
+    if (sellAsset.chainId === buyAsset.chainId) {
+        return Err(makeSwapErrorRight({
+            message: 'Across does not support same-chain swaps',
+            code: TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    const sellAcrossChainId = chainIdToAcrossChainId[sellAsset.chainId];
+    const buyAcrossChainId = chainIdToAcrossChainId[buyAsset.chainId];
+    if (sellAcrossChainId === undefined) {
+        return Err(makeSwapErrorRight({
+            message: `Sell asset chain '${sellAsset.chainId}' not supported by Across`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    if (buyAcrossChainId === undefined) {
+        return Err(makeSwapErrorRight({
+            message: `Buy asset chain '${buyAsset.chainId}' not supported by Across`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    // Across only supports USDC as the bridgeable token on Solana destinations
+    if (buyAsset.chainId === solanaChainId && buyAsset.assetId !== usdcOnSolanaAssetId) {
+        return Err(makeSwapErrorRight({
+            message: 'Across only supports USDC as destination token on Solana',
+            code: TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    return Ok({ sellAcrossChainId, buyAcrossChainId });
+};

package/dist/esm/swappers/AcrossSwapper/utils/types.d.ts

@@ -1,25 +1,6 @@
-import type { Asset } from '@shapeshiftoss/types';
-export type AcrossTradeBaseParams = {
-    buyAsset: Asset;
-    sellAsset: Asset;
-    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
-    affiliateBps: string;
-};
-export type AcrossTradeInputParams<T extends 'rate' | 'quote'> = AcrossTradeBaseParams & {
-    quoteOrRate: T;
-    receiveAddress: T extends 'rate' ? string | undefined : string;
-    sendAddress: T extends 'rate' ? undefined : string;
-    accountNumber: T extends 'rate' ? undefined : number;
-    slippageTolerancePercentageDecimal?: string;
-};
-export type AcrossTransactionMetadata = {
-    to: string;
-    data: string;
-    value: string;
-    gasLimit?: string;
-    ecosystem: 'evm' | 'svm';
-    quoteId: string;
-};
+import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput, GetSolanaTradeQuoteInput, GetSolanaTradeRateInput } from '../../../types.js';
+export type AcrossTradeQuoteInput = GetEvmTradeQuoteInput | GetSolanaTradeQuoteInput;
+export type AcrossTradeRateInput = GetEvmTradeRateInput | GetSolanaTradeRateInput;
 export type AcrossTokenInfo = {
     address: string;
     decimals: number;

package/dist/esm/swappers/ArbitrumBridgeSwapper/ArbitrumBridgeSwapper.js

@@ -1,4 +1,4 @@
-import { executeEvmTransaction } from '../../utils.js';
+import { executeEvmTransaction } from '../../utils/index.js';
 export const arbitrumBridgeSwapper = {
     executeEvmTransaction,
 };

package/dist/esm/swappers/ArbitrumBridgeSwapper/endpoints.d.ts

@@ -1,13 +1,2 @@
-import type { ParentToChildMessageReader, ParentToChildMessageReaderClassic } from '@arbitrum/sdk';
-import type { ethers as ethersv5 } from 'ethers5';
 import type { SwapperApi } from '../../types.js';
-export declare const getParentToChildMessageDataFromParentTxHash: ({ depositTxId, parentProvider, childProvider, isClassic, }: {
-    depositTxId: string;
-    parentProvider: ethersv5.providers.JsonRpcProvider;
-    childProvider: ethersv5.providers.JsonRpcProvider;
-    isClassic?: boolean | undefined;
-}) => Promise<{
-    isClassic?: boolean | undefined;
-    parentToChildMsg?: ParentToChildMessageReaderClassic | ParentToChildMessageReader | undefined;
-} | undefined>;
 export declare const arbitrumBridgeApi: SwapperApi;

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

@@ -1,155 +1,18 @@
-import { ParentToChildMessageStatus, ParentTransactionReceipt } from '@arbitrum/sdk';
+import { ParentToChildMessageStatus } from '@arbitrum/sdk';
 import { arbitrumChainId } from '@shapeshiftoss/caip';
-import { evm } from '@shapeshiftoss/chain-adapters';
 import { getEthersV5Provider } from '@shapeshiftoss/contracts';
 import { KnownChainIds } from '@shapeshiftoss/types';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
-import { checkEvmSwapStatus, getExecutableTradeStep, getHopByIndex, isExecutableTradeQuote, } from '../../utils.js';
+import { checkEvmSwapStatus } from '../../utils/index.js';
+import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
 import { getTradeQuote } from './getTradeQuote/getTradeQuote.js';
 import { getTradeRate } from './getTradeRate/getTradeRate.js';
-import { fetchArbitrumBridgeQuote } from './utils/fetchArbitrumBridgeSwap.js';
-import { assertValidTrade } from './utils/helpers.js';
-const tradeQuoteMetadata = new Map();
-// https://github.com/OffchainLabs/arbitrum-token-bridge/blob/d17c88ef3eef3f4ffc61a04d34d50406039f045d/packages/arb-token-bridge-ui/src/util/deposits/helpers.ts#L268
-export const getParentToChildMessageDataFromParentTxHash = async ({ depositTxId, parentProvider, childProvider, isClassic, // optional: if we already know if tx is classic (eg. through subgraph) then no need to re-check in this fn
- }) => {
-    // fetch Parent transaction receipt
-    const depositTxReceipt = await parentProvider.getTransactionReceipt(depositTxId);
-    if (!depositTxReceipt)
-        return;
-    const parentTxReceipt = new ParentTransactionReceipt(depositTxReceipt);
-    // classic (pre-nitro) handling
-    const getClassicDepositMessage = async () => {
-        const [parentToChildMsg] = await parentTxReceipt.getParentToChildMessagesClassic(childProvider);
-        return {
-            isClassic: true,
-            parentToChildMsg,
-        };
-    };
-    // post-nitro handling
-    const getNitroDepositMessage = async () => {
-        const [parentToChildMsg] = await parentTxReceipt.getParentToChildMessages(childProvider);
-        return {
-            isClassic: false,
-            parentToChildMsg,
-        };
-    };
-    // if it is unknown whether the transaction isClassic or not, fetch the result
-    const safeIsClassic = isClassic ?? (await parentTxReceipt.isClassic(childProvider));
-    if (safeIsClassic) {
-        // classic (pre-nitro) deposit - both eth + token
-        return getClassicDepositMessage();
-    }
-    // post-nitro deposit - both eth + token
-    return getNitroDepositMessage();
-};
+import { getParentToChildMessageDataFromParentTxHash } from './utils/helpers.js';
 export const arbitrumBridgeApi = {
-    getTradeQuote: async (input, deps) => {
-        const tradeQuoteResult = await getTradeQuote(input, deps);
-        return tradeQuoteResult.map(tradeQuote => {
-            const id = tradeQuote.id;
-            const firstHop = getHopByIndex(tradeQuote, 0);
-            if (!firstHop) {
-                console.error('No first hop found in trade quote');
-                return [];
-            }
-            tradeQuoteMetadata.set(id, {
-                sellAssetId: firstHop.sellAsset.assetId,
-                chainId: firstHop.sellAsset.chainId,
-            });
-            return [tradeQuote];
-        });
-    },
-    getTradeRate: async (input, deps) => {
-        const tradeRateResult = await getTradeRate(input, deps);
-        return tradeRateResult.map(tradeRate => {
-            const id = tradeRate.id;
-            const firstHop = getHopByIndex(tradeRate, 0);
-            if (!firstHop) {
-                console.error('No first hop found in trade rate');
-                return [];
-            }
-            tradeQuoteMetadata.set(id, {
-                sellAssetId: firstHop.sellAsset.assetId,
-                chainId: firstHop.sellAsset.chainId,
-            });
-            return [tradeRate];
-        });
-    },
-    getUnsignedEvmTransaction: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const { receiveAddress } = tradeQuote;
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { accountNumber, buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = step;
-        const assertion = await assertValidTrade({ buyAsset, sellAsset });
-        if (assertion.isErr())
-            throw new Error(assertion.unwrapErr().message);
-        const swap = await fetchArbitrumBridgeQuote({
-            chainId: sellAsset.chainId,
-            supportsEIP1559,
-            buyAsset,
-            receiveAddress,
-            sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            sellAsset,
-            sendAddress: from,
-            assertGetEvmChainAdapter,
-        });
-        const { request } = swap;
-        if (!request)
-            throw new Error('No request data found');
-        const { txRequest: { data, value, to }, } = request;
-        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-        const feeData = await evm.getFees({
-            adapter,
-            data: data.toString(),
-            to,
-            value: value.toString(),
-            from,
-            supportsEIP1559,
-        });
-        return adapter.buildCustomApiTx({
-            accountNumber,
-            data: data.toString(),
-            from,
-            to,
-            value: value.toString(),
-            ...feeData,
-        });
-    },
-    getEvmTransactionFees: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const { receiveAddress } = tradeQuote;
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = step;
-        const assertion = await assertValidTrade({ buyAsset, sellAsset });
-        if (assertion.isErr())
-            throw new Error(assertion.unwrapErr().message);
-        const swap = await fetchArbitrumBridgeQuote({
-            chainId: sellAsset.chainId,
-            supportsEIP1559,
-            buyAsset,
-            receiveAddress,
-            sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            sellAsset,
-            sendAddress: from,
-            assertGetEvmChainAdapter,
-        });
-        const { request } = swap;
-        if (!request)
-            throw new Error('No request data found');
-        const { txRequest: { data, value, to }, } = request;
-        const { networkFeeCryptoBaseUnit } = await evm.getFees({
-            adapter: assertGetEvmChainAdapter(sellAsset.chainId),
-            data: data.toString(),
-            to,
-            value: value.toString(),
-            from,
-            supportsEIP1559,
-        });
-        return networkFeeCryptoBaseUnit;
-    },
+    getTradeQuote: (input, deps) => getTradeQuote(input, deps),
+    getTradeRate: (input, deps) => getTradeRate(input, deps),
+    getUnsignedEvmTransaction,
+    getEvmTransactionFees,
     checkTradeStatus: async ({ txHash, chainId, assertGetEvmChainAdapter, address, fetchIsSmartContractAddressQuery, }) => {
         const swapTxStatus = await checkEvmSwapStatus({
             txHash,

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

@@ -1,6 +1,5 @@
 import type { Result } from '@sniptt/monads';
-import type { GetEvmTradeQuoteInputBase, GetEvmTradeQuoteInputWithWallet, SwapErrorRight, SwapperDeps, TradeQuote, TradeRate } from '../../../types.js';
-import type { ArbitrumBridgeTradeQuote, ArbitrumBridgeTradeRate } from '../types.js';
-export declare const isArbitrumBridgeTradeQuoteOrRate: (quote: TradeQuote | TradeRate | undefined) => quote is ArbitrumBridgeTradeQuote | ArbitrumBridgeTradeRate;
-export declare const getTradeQuoteWithWallet: (inputWithWallet: GetEvmTradeQuoteInputWithWallet, deps: SwapperDeps) => Promise<Result<ArbitrumBridgeTradeQuote, SwapErrorRight>>;
-export declare function getTradeQuote(input: GetEvmTradeQuoteInputBase, { assertGetEvmChainAdapter }: SwapperDeps): Promise<Result<ArbitrumBridgeTradeQuote, SwapErrorRight>>;
+import type { GetEvmTradeQuoteInputWithWallet, SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types.js';
+import type { ArbitrumBridgeTradeQuoteInput } from '../types.js';
+export declare const getTradeQuoteWithWallet: (inputWithWallet: GetEvmTradeQuoteInputWithWallet, deps: SwapperDeps) => Promise<Result<TradeQuote, SwapErrorRight>>;
+export declare const getTradeQuote: (input: ArbitrumBridgeTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote[], SwapErrorRight>>;

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

@@ -1,80 +1,48 @@
-import { ethChainId } from '@shapeshiftoss/caip';
 import { supportsETH } from '@shapeshiftoss/hdwallet-core';
 import { Err, Ok } from '@sniptt/monads';
-import { v4 as uuid } from 'uuid';
-import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
-import { SwapperName, TradeQuoteError } from '../../../types.js';
-import { makeSwapErrorRight } from '../../../utils.js';
-import { fetchArbitrumBridgeQuote } from '../utils/fetchArbitrumBridgeSwap.js';
-import { assertValidTrade } from '../utils/helpers.js';
-export const isArbitrumBridgeTradeQuoteOrRate = (quote) => !!quote && 'direction' in quote;
+import { assertQuoteAddresses } from '../../../utils/index.js';
+import { FALLBACK_QUOTE_DEADLINE_MS } from '../../../utils/helpers.js';
+import { getArbitrumBridgeStepData } from '../utils/getArbitrumBridgeStepData.js';
+import { getArbitrumBridgeTradeContext } from '../utils/getArbitrumBridgeTradeContext.js';
 export const getTradeQuoteWithWallet = async (inputWithWallet, deps) => {
     const { wallet, ...input } = inputWithWallet;
     const supportsEIP1559 = supportsETH(wallet) && (await wallet.ethSupportsEIP1559());
-    return getTradeQuote({
-        ...input,
-        supportsEIP1559,
-    }, deps);
+    const maybeQuotes = await getTradeQuote({ ...input, supportsEIP1559 }, deps);
+    return maybeQuotes.map(quotes => quotes[0]);
+};
+export const getTradeQuote = async (input, deps) => {
+    const { accountNumber } = input;
+    const maybeAddresses = assertQuoteAddresses(input);
+    if (maybeAddresses.isErr())
+        return Err(maybeAddresses.unwrapErr());
+    const { sendAddress, receiveAddress } = maybeAddresses.unwrap();
+    const maybeContext = await getArbitrumBridgeTradeContext({ input, deps });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getArbitrumBridgeStepData({
+        ...stepDataArgs,
+        type: 'quote',
+        input,
+        from: sendAddress,
+        receiveAddress,
+    });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { transactionData, networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeQuote = {
+        ...tradeCommon,
+        quoteOrRate: 'quote',
+        deadline: Date.now() + FALLBACK_QUOTE_DEADLINE_MS,
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                transactionData,
+                feeData: { protocolFees: {}, networkFeeCryptoBaseUnit },
+            },
+        ],
+    };
+    return Ok([tradeQuote]);
 };
-export async function getTradeQuote(input, { assertGetEvmChainAdapter }) {
-    const { chainId, sellAsset, buyAsset, accountNumber, supportsEIP1559, receiveAddress, sellAmountIncludingProtocolFeesCryptoBaseUnit, sendAddress, } = input;
-    const assertion = await assertValidTrade({ buyAsset, sellAsset });
-    if (assertion.isErr())
-        return Err(assertion.unwrapErr());
-    const isDeposit = sellAsset.chainId === ethChainId;
-    // 15 minutes for deposits, 7 days for withdrawals
-    const estimatedExecutionTimeMs = isDeposit ? 15 * 60 * 1000 : 7 * 24 * 60 * 60 * 1000;
-    // 1/1 when bridging on Arbitrum bridge
-    const rate = '1';
-    try {
-        const args = {
-            supportsEIP1559: Boolean(supportsEIP1559),
-            chainId,
-            buyAsset,
-            sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            sellAsset,
-            sendAddress,
-            receiveAddress,
-            assertGetEvmChainAdapter,
-            quoteOrRate: 'quote',
-        };
-        const swap = await fetchArbitrumBridgeQuote(args);
-        const buyAmountBeforeFeesCryptoBaseUnit = sellAmountIncludingProtocolFeesCryptoBaseUnit;
-        const buyAmountAfterFeesCryptoBaseUnit = sellAmountIncludingProtocolFeesCryptoBaseUnit;
-        return Ok({
-            id: uuid(),
-            quoteOrRate: 'quote',
-            receiveAddress,
-            affiliateBps: '0',
-            rate,
-            slippageTolerancePercentageDecimal: getDefaultSlippageDecimalPercentageForSwapper(SwapperName.ArbitrumBridge),
-            swapperName: SwapperName.ArbitrumBridge,
-            steps: [
-                {
-                    estimatedExecutionTimeMs,
-                    allowanceContract: swap.allowanceContract,
-                    rate,
-                    buyAsset,
-                    sellAsset,
-                    accountNumber,
-                    buyAmountBeforeFeesCryptoBaseUnit,
-                    buyAmountAfterFeesCryptoBaseUnit,
-                    sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                    feeData: {
-                        protocolFees: {},
-                        networkFeeCryptoBaseUnit: swap.networkFeeCryptoBaseUnit,
-                    },
-                    source: SwapperName.ArbitrumBridge,
-                },
-            ],
-            direction: isDeposit ? 'deposit' : 'withdrawal',
-        });
-    }
-    catch (err) {
-        return Err(makeSwapErrorRight({
-            message: '[ArbitrumBridge: tradeQuote] - failed to get fee data',
-            cause: err,
-            code: TradeQuoteError.NetworkFeeEstimationFailed,
-        }));
-    }
-}

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

@@ -1,4 +1,4 @@
 import type { Result } from '@sniptt/monads';
-import type { GetEvmTradeRateInput, SwapErrorRight, SwapperDeps } from '../../../types.js';
-import type { ArbitrumBridgeTradeRate } from '../types.js';
-export declare function getTradeRate(input: GetEvmTradeRateInput, { assertGetEvmChainAdapter }: SwapperDeps): Promise<Result<ArbitrumBridgeTradeRate, SwapErrorRight>>;
+import type { SwapErrorRight, SwapperDeps, TradeRate } from '../../../types.js';
+import type { ArbitrumBridgeTradeRateInput } from '../types.js';
+export declare const getTradeRate: (input: ArbitrumBridgeTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate[], SwapErrorRight>>;