@shapeshiftoss/swapper 17.6.6 → 17.6.8

package/dist/esm/swapper.js

@@ -0,0 +1,51 @@
+import { bnOrZero, timeoutMonadic, timeoutMonadicWithOriginal } from '@shapeshiftoss/utils';
+import { QUOTE_TIMEOUT_ERROR, QUOTE_TIMEOUT_MS, swappers } from './constants.js';
+import { TradeQuoteError } from './types.js';
+import { makeSwapErrorRight } from './utils.js';
+export const getTradeQuotes = async (getTradeQuoteInput, swapperName, deps) => {
+    if (bnOrZero(getTradeQuoteInput.affiliateBps).lt(0))
+        return;
+    if (getTradeQuoteInput.sellAmountIncludingProtocolFeesCryptoBaseUnit === '0')
+        return;
+    const swapper = swappers[swapperName];
+    if (swapper === undefined)
+        return;
+    try {
+        const quote = await timeoutMonadic(swapper.getTradeQuote(getTradeQuoteInput, deps), QUOTE_TIMEOUT_MS, QUOTE_TIMEOUT_ERROR);
+        return {
+            ...quote,
+            swapperName,
+        };
+    }
+    catch (e) {
+        // This should never happen but it may - we should be using monadic error handling all the way through swapper call stack
+        // in case this logs an error from a rejected promise, it means we throw somewhere and forgot to handle errors the monadic way
+        console.error('Unhandled error. Use monadic error handling: ', e);
+    }
+};
+export const getTradeRates = async (getTradeRateInput, swapperName, deps, quoteTimeoutMs = QUOTE_TIMEOUT_MS) => {
+    if (bnOrZero(getTradeRateInput.affiliateBps).lt(0))
+        return;
+    if (getTradeRateInput.sellAmountIncludingProtocolFeesCryptoBaseUnit === '0')
+        return;
+    const swapper = swappers[swapperName];
+    if (swapper === undefined)
+        return;
+    try {
+        const { timed, original } = timeoutMonadicWithOriginal(swapper.getTradeRate(getTradeRateInput, deps), quoteTimeoutMs, makeSwapErrorRight({
+            code: TradeQuoteError.Timeout,
+            message: `quote timed out after ${quoteTimeoutMs / 1000}s`,
+        }));
+        const quote = await timed;
+        return {
+            ...quote,
+            fallback: original,
+            swapperName,
+        };
+    }
+    catch (e) {
+        // This should never happen but it may - we should be using monadic error handling all the way through swapper call stack
+        // in case this logs an error from a rejected promise, it means we throw somewhere and forgot to handle errors the monadic way
+        console.error('Unhandled error. Use monadic error handling: ', e);
+    }
+};

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

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

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

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

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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,234 @@
+import { ParentToChildMessageStatus, ParentTransactionReceipt } 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 { 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();
+};
+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;
+    },
+    checkTradeStatus: async ({ txHash, chainId, assertGetEvmChainAdapter, address, fetchIsSmartContractAddressQuery, }) => {
+        const swapTxStatus = await checkEvmSwapStatus({
+            txHash,
+            chainId,
+            assertGetEvmChainAdapter,
+            address,
+            fetchIsSmartContractAddressQuery,
+        });
+        const isWithdraw = chainId === arbitrumChainId;
+        if (isWithdraw) {
+            // We don't want to be polling for 7 days for Arb Child -> Parent, that's not very realistic for users.
+            // We simply return success when the Child Tx is confirmed, meaning the trade will show "complete" almost instantly
+            // and will handle the whole 7 days thing (that the user should've already been warned about with an ack before previewing)
+            // at confirm step
+            return {
+                ...swapTxStatus,
+                // Note, we don't care about the buyTxHash here, since it will be available... in 7 days.
+                buyTxHash: undefined,
+            };
+        }
+        if (swapTxStatus.status === TxStatus.Pending || swapTxStatus.status === TxStatus.Unknown) {
+            return {
+                status: TxStatus.Pending,
+                buyTxHash: undefined,
+                message: 'Parent Tx Pending',
+            };
+        }
+        const parentProvider = getEthersV5Provider(KnownChainIds.EthereumMainnet);
+        const childProvider = getEthersV5Provider(KnownChainIds.ArbitrumMainnet);
+        const maybeParentToChildMessageData = await getParentToChildMessageDataFromParentTxHash({
+            depositTxId: txHash,
+            parentProvider,
+            childProvider,
+        });
+        const maybeParentToChildMsg = maybeParentToChildMessageData?.parentToChildMsg;
+        const maybeBuyTxHash = await (async () => {
+            if (!maybeParentToChildMsg)
+                return;
+            if (maybeParentToChildMessageData?.isClassic) {
+                const msg = maybeParentToChildMsg;
+                const receipt = await msg.getRetryableCreationReceipt();
+                if (receipt?.status !== ParentToChildMessageStatus.REDEEMED)
+                    return;
+                return receipt.transactionHash;
+            }
+            else {
+                const msg = maybeParentToChildMsg;
+                const successfulRedeem = await msg.getSuccessfulRedeem();
+                if (successfulRedeem.status !== ParentToChildMessageStatus.REDEEMED)
+                    return;
+                return successfulRedeem.childTxReceipt.transactionHash;
+            }
+        })();
+        if (!maybeBuyTxHash) {
+            return {
+                status: TxStatus.Pending,
+                buyTxHash: maybeBuyTxHash,
+                message: 'Parent Tx confirmed, waiting for Child',
+            };
+        }
+        const childTxStatus = await checkEvmSwapStatus({
+            txHash: maybeBuyTxHash,
+            chainId: arbitrumChainId,
+            assertGetEvmChainAdapter,
+            address,
+            fetchIsSmartContractAddressQuery,
+        });
+        // i.e Unknown is perfectly valid since ETH deposits Child Txids are available immediately deterministically, but will only be in the mempool after ~10mn
+        if (childTxStatus.status === TxStatus.Pending || childTxStatus.status === TxStatus.Unknown) {
+            return {
+                status: TxStatus.Pending,
+                buyTxHash: maybeBuyTxHash,
+                message: 'Child Tx Pending',
+            };
+        }
+        return {
+            status: TxStatus.Confirmed,
+            buyTxHash: maybeBuyTxHash,
+            message: undefined,
+        };
+    },
+};

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

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

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

@@ -0,0 +1,80 @@
+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;
+export const getTradeQuoteWithWallet = async (inputWithWallet, deps) => {
+    const { wallet, ...input } = inputWithWallet;
+    const supportsEIP1559 = supportsETH(wallet) && (await wallet.ethSupportsEIP1559());
+    return getTradeQuote({
+        ...input,
+        supportsEIP1559,
+    }, deps);
+};
+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/getTradeQuote/getTradeQuote.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,172 @@
+import { Erc20Bridger, EthBridger } from '@arbitrum/sdk';
+import { ethAssetId, ethChainId } from '@shapeshiftoss/caip';
+import { describe, expect, it, vi } from 'vitest';
+import { SwapperName } from '../../../types.js';
+import { BTC, ETH, ETH_ARBITRUM, FOX_ARBITRUM, FOX_MAINNET } from '../../utils/test-data/assets.js';
+import { getTradeQuote } from './getTradeQuote.js';
+vi.mock('@arbitrum/sdk', () => ({
+    Erc20Bridger: vi.fn(),
+    EthBridger: vi.fn(),
+    getArbitrumNetwork: vi.fn().mockResolvedValue({ chainID: 42161 }),
+}));
+vi.mock('@shapeshiftoss/chain-adapters', async () => {
+    const actual = await vi.importActual('@shapeshiftoss/chain-adapters');
+    return {
+        ...actual,
+        evm: {
+            getFees: vi.fn().mockResolvedValue({ networkFeeCryptoBaseUnit: '42' }),
+        },
+    };
+});
+describe('getTradeQuote', () => {
+    const mockAdapter = {
+        getGasFeeData: vi.fn().mockResolvedValue({
+            average: { gasPrice: '42', maxFeePerGas: '42' },
+        }),
+    };
+    const mockAdapterEth = Object.assign({}, mockAdapter, {
+        getFeeAssetId: () => ethAssetId,
+    });
+    const assertGetEvmChainAdapter = () => mockAdapterEth;
+    const commonInput = {
+        allowMultiHop: false,
+        chainId: ethChainId,
+        sellAsset: ETH,
+        buyAsset: ETH_ARBITRUM,
+        accountNumber: 0,
+        affiliateBps: '0',
+        supportsEIP1559: true,
+        receiveAddress: '0xfauxmes',
+        sellAmountIncludingProtocolFeesCryptoBaseUnit: '1000000000000000000',
+        sendAddress: '0xfauxmes',
+    };
+    it('returns a correct ETH deposit quote', async () => {
+        const ethBridgerMock = {
+            getDepositToRequest: vi.fn().mockResolvedValue({
+                txRequest: {
+                    data: '0x',
+                    to: '0x',
+                    value: '0',
+                    from: '0x',
+                },
+            }),
+        };
+        vi.mocked(EthBridger).mockReturnValue(ethBridgerMock);
+        const maybeQuote = await getTradeQuote(commonInput, {
+            assertGetEvmChainAdapter,
+            getEthersV5Provider: vi.fn(),
+        });
+        expect(maybeQuote.isOk()).toBe(true);
+        const quote = maybeQuote.unwrap();
+        expect(quote.receiveAddress).toBe(commonInput.receiveAddress);
+        expect(quote.rate).toBe('1');
+        expect(quote.steps[0].allowanceContract).toBe('0x0');
+        expect(quote.steps[0].source).toBe(SwapperName.ArbitrumBridge);
+    });
+    it('returns a correct ETH withdraw quote', async () => {
+        const ethBridgerMock = {
+            getWithdrawalRequest: vi.fn().mockResolvedValue({
+                txRequest: {
+                    data: '0x',
+                    to: '0x',
+                    value: '0',
+                    from: '0x',
+                },
+            }),
+        };
+        vi.mocked(EthBridger).mockReturnValue(ethBridgerMock);
+        const withdrawInput = {
+            ...commonInput,
+            sellAsset: ETH_ARBITRUM,
+            buyAsset: ETH,
+        };
+        const maybeQuote = await getTradeQuote(withdrawInput, {
+            assertGetEvmChainAdapter,
+            getEthersV5Provider: vi.fn(),
+        });
+        expect(maybeQuote.isOk()).toBe(true);
+        const quote = maybeQuote.unwrap();
+        expect(quote.receiveAddress).toBe(withdrawInput.receiveAddress);
+        expect(quote.rate).toBe('1');
+        expect(quote.steps[0].allowanceContract).toBe('0x0');
+        expect(quote.steps[0].source).toBe(SwapperName.ArbitrumBridge);
+    });
+    it('returns a correct ERC20 deposit quote', async () => {
+        const Erc20BridgerMock = {
+            getDepositRequest: vi.fn().mockResolvedValue({
+                txRequest: {
+                    data: '0x',
+                    to: '0x',
+                    value: '0',
+                    from: '0x',
+                },
+            }),
+            getChildErc20Address: vi.fn().mockResolvedValue('0xf929de51d91c77e42f5090069e0ad7a09e513c73'),
+            getParentErc20Address: vi
+                .fn()
+                .mockResolvedValue('0xc770eefad204b5180df6a14ee197d99d808ee52d'),
+            getParentGatewayAddress: vi
+                .fn()
+                .mockResolvedValue('0x0c66f315542fdec1d312c415b14eef614b0910ef'),
+        };
+        vi.mocked(Erc20Bridger).mockReturnValue(Erc20BridgerMock);
+        const erc20DepositInput = {
+            ...commonInput,
+            sellAsset: FOX_MAINNET,
+            buyAsset: FOX_ARBITRUM,
+        };
+        const maybeQuote = await getTradeQuote(erc20DepositInput, {
+            assertGetEvmChainAdapter,
+            getEthersV5Provider: vi.fn(),
+        });
+        expect(maybeQuote.isOk()).toBe(true);
+        const quote = maybeQuote.unwrap();
+        expect(quote.receiveAddress).toBe(erc20DepositInput.receiveAddress);
+        expect(quote.rate).toBe('1');
+        expect(quote.steps[0].allowanceContract).toBe('0x0c66f315542fdec1d312c415b14eef614b0910ef');
+        expect(quote.steps[0].source).toBe(SwapperName.ArbitrumBridge);
+    });
+    it('returns a correct ERC20 withdraw quote', async () => {
+        const Erc20BridgerMock = {
+            getWithdrawalRequest: vi.fn().mockResolvedValue({
+                txRequest: {
+                    data: '0x',
+                    to: '0x',
+                    value: '0',
+                    from: '0x',
+                },
+            }),
+            getChildErc20Address: vi.fn().mockResolvedValue('0xf929de51d91c77e42f5090069e0ad7a09e513c73'),
+            getParentErc20Address: vi
+                .fn()
+                .mockResolvedValue('0xc770eefad204b5180df6a14ee197d99d808ee52d'),
+            getParentGatewayAddress: vi
+                .fn()
+                .mockResolvedValue('0x0c66f315542fdec1d312c415b14eef614b0910ef'),
+        };
+        vi.mocked(Erc20Bridger).mockReturnValue(Erc20BridgerMock);
+        const erc20WithdrawInput = {
+            ...commonInput,
+            sellAsset: FOX_ARBITRUM,
+            buyAsset: FOX_MAINNET,
+        };
+        const maybeQuote = await getTradeQuote(erc20WithdrawInput, {
+            assertGetEvmChainAdapter,
+            getEthersV5Provider: vi.fn(),
+        });
+        expect(maybeQuote.isOk()).toBe(true);
+        const quote = maybeQuote.unwrap();
+        expect(quote.receiveAddress).toBe(erc20WithdrawInput.receiveAddress);
+        expect(quote.rate).toBe('1');
+        expect(quote.steps[0].allowanceContract).toBe('0x0');
+        expect(quote.steps[0].source).toBe(SwapperName.ArbitrumBridge);
+    });
+    it('returns an error monad if non-EVM chain IDs are used', async () => {
+        const result = await getTradeQuote({ ...commonInput, sellAsset: BTC }, {
+            assertGetEvmChainAdapter,
+            getEthersV5Provider: vi.fn(),
+        });
+        expect(result.isErr()).toBe(true);
+        expect(result.unwrapErr().message).toBe('[ArbitrumBridge: assertValidTrade] - unsupported chainId');
+    });
+});

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

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

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

@@ -0,0 +1,71 @@
+import { ethChainId } from '@shapeshiftoss/caip';
+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 { fetchArbitrumBridgePrice } from '../utils/fetchArbitrumBridgeSwap.js';
+import { assertValidTrade } from '../utils/helpers.js';
+export async function getTradeRate(input, { assertGetEvmChainAdapter }) {
+    const { chainId, sellAsset, buyAsset, supportsEIP1559, receiveAddress, sellAmountIncludingProtocolFeesCryptoBaseUnit, sendAddress, accountNumber, } = 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,
+            chainId,
+            buyAsset,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            sellAsset,
+            sendAddress,
+            receiveAddress,
+            assertGetEvmChainAdapter,
+            quoteOrRate: 'rate',
+        };
+        const swap = await fetchArbitrumBridgePrice(args);
+        const buyAmountBeforeFeesCryptoBaseUnit = sellAmountIncludingProtocolFeesCryptoBaseUnit;
+        const buyAmountAfterFeesCryptoBaseUnit = sellAmountIncludingProtocolFeesCryptoBaseUnit;
+        return Ok({
+            id: uuid(),
+            quoteOrRate: 'rate',
+            accountNumber: undefined,
+            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/index.d.ts

@@ -0,0 +1,2 @@
+export * from './endpoints.js';
+export * from './getTradeQuote/getTradeQuote.js';

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

@@ -0,0 +1,2 @@
+export * from './endpoints.js';
+export * from './getTradeQuote/getTradeQuote.js';

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

@@ -0,0 +1,13 @@
+import type { TradeQuote, TradeRate } from '../../types.js';
+export declare enum BRIDGE_TYPE {
+    ETH_DEPOSIT = "ETH Deposit",
+    ERC20_DEPOSIT = "ERC20 Deposit",
+    ETH_WITHDRAWAL = "ETH Withdrawal",
+    ERC20_WITHDRAWAL = "ERC20 Withdrawal"
+}
+type ArbitrumBridgeSpecificMetadata = {
+    direction: 'deposit' | 'withdrawal';
+};
+export type ArbitrumBridgeTradeQuote = TradeQuote & ArbitrumBridgeSpecificMetadata;
+export type ArbitrumBridgeTradeRate = TradeRate & ArbitrumBridgeSpecificMetadata;
+export {};