@shapeshiftoss/swapper 17.6.6-alpha.0 → 17.6.6

package/dist/esm/swapper.js

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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