@shapeshiftoss/swapper 17.6.3 → 17.6.5

package/dist/cjs/solana-utils/getUnsignedSolanaTransaction.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUnsignedSolanaTransaction = void 0;
+const utils_1 = require("@shapeshiftoss/utils");
+const JupiterSwapper_1 = require("../swappers/JupiterSwapper");
+const utils_2 = require("../utils");
+const getUnsignedSolanaTransaction = async ({ stepIndex, tradeQuote, from, assertGetSolanaChainAdapter, }) => {
+    if (!(0, utils_2.isExecutableTradeQuote)(tradeQuote))
+        throw new Error('Unable to execute a trade rate quote');
+    const step = (0, utils_2.getExecutableTradeStep)(tradeQuote, stepIndex);
+    const { accountNumber, solanaTransactionMetadata, sellAsset } = step;
+    const adapter = assertGetSolanaChainAdapter(sellAsset.chainId);
+    const { fast } = await adapter.getFeeData({
+        to: '',
+        value: '0',
+        chainSpecific: {
+            from,
+            addressLookupTableAccounts: solanaTransactionMetadata?.addressLookupTableAddresses,
+            instructions: solanaTransactionMetadata?.instructions,
+        },
+    });
+    const solanaInstructions = solanaTransactionMetadata?.instructions?.map(instruction => adapter.convertInstruction(instruction));
+    return adapter.buildSendApiTransaction({
+        from,
+        to: '',
+        value: '0',
+        accountNumber,
+        chainSpecific: {
+            addressLookupTableAccounts: solanaTransactionMetadata?.addressLookupTableAddresses,
+            instructions: solanaInstructions,
+            // As always, as relay uses jupiter under the hood, we need to add the compute unit safety margin
+            computeUnitLimit: (0, utils_1.bnOrZero)(fast.chainSpecific.computeUnits)
+                .times(JupiterSwapper_1.COMPUTE_UNIT_MARGIN_MULTIPLIER)
+                .toFixed(0),
+            computeUnitPrice: fast.chainSpecific.priorityFee,
+        },
+    });
+};
+exports.getUnsignedSolanaTransaction = getUnsignedSolanaTransaction;

package/dist/cjs/swapper.d.ts

@@ -0,0 +1,3 @@
+import type { GetTradeQuoteInputWithWallet, GetTradeRateInput, QuoteResult, RateResult, SwapperDeps, SwapperName } from './types';
+export declare const getTradeQuotes: (getTradeQuoteInput: GetTradeQuoteInputWithWallet, swapperName: SwapperName, deps: SwapperDeps) => Promise<QuoteResult | undefined>;
+export declare const getTradeRates: (getTradeRateInput: GetTradeRateInput, swapperName: SwapperName, deps: SwapperDeps, quoteTimeoutMs?: number) => Promise<RateResult | undefined>;

package/dist/cjs/swapper.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeRates = exports.getTradeQuotes = void 0;
+const utils_1 = require("@shapeshiftoss/utils");
+const constants_1 = require("./constants");
+const types_1 = require("./types");
+const utils_2 = require("./utils");
+const getTradeQuotes = async (getTradeQuoteInput, swapperName, deps) => {
+    if ((0, utils_1.bnOrZero)(getTradeQuoteInput.affiliateBps).lt(0))
+        return;
+    if (getTradeQuoteInput.sellAmountIncludingProtocolFeesCryptoBaseUnit === '0')
+        return;
+    const swapper = constants_1.swappers[swapperName];
+    if (swapper === undefined)
+        return;
+    try {
+        const quote = await (0, utils_1.timeoutMonadic)(swapper.getTradeQuote(getTradeQuoteInput, deps), constants_1.QUOTE_TIMEOUT_MS, constants_1.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);
+    }
+};
+exports.getTradeQuotes = getTradeQuotes;
+const getTradeRates = async (getTradeRateInput, swapperName, deps, quoteTimeoutMs = constants_1.QUOTE_TIMEOUT_MS) => {
+    if ((0, utils_1.bnOrZero)(getTradeRateInput.affiliateBps).lt(0))
+        return;
+    if (getTradeRateInput.sellAmountIncludingProtocolFeesCryptoBaseUnit === '0')
+        return;
+    const swapper = constants_1.swappers[swapperName];
+    if (swapper === undefined)
+        return;
+    try {
+        const { timed, original } = (0, utils_1.timeoutMonadicWithOriginal)(swapper.getTradeRate(getTradeRateInput, deps), quoteTimeoutMs, (0, utils_2.makeSwapErrorRight)({
+            code: types_1.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);
+    }
+};
+exports.getTradeRates = getTradeRates;

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

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

package/dist/cjs/swappers/ArbitrumBridgeSwapper/ArbitrumBridgeSwapper.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arbitrumBridgeSwapper = void 0;
+const utils_1 = require("../../utils");
+exports.arbitrumBridgeSwapper = {
+    executeEvmTransaction: utils_1.executeEvmTransaction,
+};

package/dist/cjs/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';
+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/cjs/swappers/ArbitrumBridgeSwapper/endpoints.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arbitrumBridgeApi = exports.getParentToChildMessageDataFromParentTxHash = void 0;
+const sdk_1 = require("@arbitrum/sdk");
+const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const contracts_1 = require("@shapeshiftoss/contracts");
+const types_1 = require("@shapeshiftoss/types");
+const unchained_client_1 = require("@shapeshiftoss/unchained-client");
+const utils_1 = require("../../utils");
+const getTradeQuote_1 = require("./getTradeQuote/getTradeQuote");
+const getTradeRate_1 = require("./getTradeRate/getTradeRate");
+const fetchArbitrumBridgeSwap_1 = require("./utils/fetchArbitrumBridgeSwap");
+const helpers_1 = require("./utils/helpers");
+const tradeQuoteMetadata = new Map();
+// https://github.com/OffchainLabs/arbitrum-token-bridge/blob/d17c88ef3eef3f4ffc61a04d34d50406039f045d/packages/arb-token-bridge-ui/src/util/deposits/helpers.ts#L268
+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 sdk_1.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();
+};
+exports.getParentToChildMessageDataFromParentTxHash = getParentToChildMessageDataFromParentTxHash;
+exports.arbitrumBridgeApi = {
+    getTradeQuote: async (input, deps) => {
+        const tradeQuoteResult = await (0, getTradeQuote_1.getTradeQuote)(input, deps);
+        return tradeQuoteResult.map(tradeQuote => {
+            const id = tradeQuote.id;
+            const firstHop = (0, utils_1.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 (0, getTradeRate_1.getTradeRate)(input, deps);
+        return tradeRateResult.map(tradeRate => {
+            const id = tradeRate.id;
+            const firstHop = (0, utils_1.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 (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const { receiveAddress } = tradeQuote;
+        const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
+        const { accountNumber, buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = step;
+        const assertion = await (0, helpers_1.assertValidTrade)({ buyAsset, sellAsset });
+        if (assertion.isErr())
+            throw new Error(assertion.unwrapErr().message);
+        const swap = await (0, fetchArbitrumBridgeSwap_1.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 chain_adapters_1.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 (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const { receiveAddress } = tradeQuote;
+        const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
+        const { buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = step;
+        const assertion = await (0, helpers_1.assertValidTrade)({ buyAsset, sellAsset });
+        if (assertion.isErr())
+            throw new Error(assertion.unwrapErr().message);
+        const swap = await (0, fetchArbitrumBridgeSwap_1.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 chain_adapters_1.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 (0, utils_1.checkEvmSwapStatus)({
+            txHash,
+            chainId,
+            assertGetEvmChainAdapter,
+            address,
+            fetchIsSmartContractAddressQuery,
+        });
+        const isWithdraw = chainId === caip_1.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 === unchained_client_1.TxStatus.Pending || swapTxStatus.status === unchained_client_1.TxStatus.Unknown) {
+            return {
+                status: unchained_client_1.TxStatus.Pending,
+                buyTxHash: undefined,
+                message: 'Parent Tx Pending',
+            };
+        }
+        const parentProvider = (0, contracts_1.getEthersV5Provider)(types_1.KnownChainIds.EthereumMainnet);
+        const childProvider = (0, contracts_1.getEthersV5Provider)(types_1.KnownChainIds.ArbitrumMainnet);
+        const maybeParentToChildMessageData = await (0, exports.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 !== sdk_1.ParentToChildMessageStatus.REDEEMED)
+                    return;
+                return receipt.transactionHash;
+            }
+            else {
+                const msg = maybeParentToChildMsg;
+                const successfulRedeem = await msg.getSuccessfulRedeem();
+                if (successfulRedeem.status !== sdk_1.ParentToChildMessageStatus.REDEEMED)
+                    return;
+                return successfulRedeem.childTxReceipt.transactionHash;
+            }
+        })();
+        if (!maybeBuyTxHash) {
+            return {
+                status: unchained_client_1.TxStatus.Pending,
+                buyTxHash: maybeBuyTxHash,
+                message: 'Parent Tx confirmed, waiting for Child',
+            };
+        }
+        const childTxStatus = await (0, utils_1.checkEvmSwapStatus)({
+            txHash: maybeBuyTxHash,
+            chainId: caip_1.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 === unchained_client_1.TxStatus.Pending || childTxStatus.status === unchained_client_1.TxStatus.Unknown) {
+            return {
+                status: unchained_client_1.TxStatus.Pending,
+                buyTxHash: maybeBuyTxHash,
+                message: 'Child Tx Pending',
+            };
+        }
+        return {
+            status: unchained_client_1.TxStatus.Confirmed,
+            buyTxHash: maybeBuyTxHash,
+            message: undefined,
+        };
+    },
+};

package/dist/cjs/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';
+import type { ArbitrumBridgeTradeQuote, ArbitrumBridgeTradeRate } from '../types';
+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/cjs/swappers/ArbitrumBridgeSwapper/getTradeQuote/getTradeQuote.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeQuote = exports.getTradeQuoteWithWallet = exports.isArbitrumBridgeTradeQuoteOrRate = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const hdwallet_core_1 = require("@shapeshiftoss/hdwallet-core");
+const monads_1 = require("@sniptt/monads");
+const uuid_1 = require("uuid");
+const constants_1 = require("../../../constants");
+const types_1 = require("../../../types");
+const utils_1 = require("../../../utils");
+const fetchArbitrumBridgeSwap_1 = require("../utils/fetchArbitrumBridgeSwap");
+const helpers_1 = require("../utils/helpers");
+const isArbitrumBridgeTradeQuoteOrRate = (quote) => !!quote && 'direction' in quote;
+exports.isArbitrumBridgeTradeQuoteOrRate = isArbitrumBridgeTradeQuoteOrRate;
+const getTradeQuoteWithWallet = async (inputWithWallet, deps) => {
+    const { wallet, ...input } = inputWithWallet;
+    const supportsEIP1559 = (0, hdwallet_core_1.supportsETH)(wallet) && (await wallet.ethSupportsEIP1559());
+    return getTradeQuote({
+        ...input,
+        supportsEIP1559,
+    }, deps);
+};
+exports.getTradeQuoteWithWallet = getTradeQuoteWithWallet;
+async function getTradeQuote(input, { assertGetEvmChainAdapter }) {
+    const { chainId, sellAsset, buyAsset, accountNumber, supportsEIP1559, receiveAddress, sellAmountIncludingProtocolFeesCryptoBaseUnit, sendAddress, } = input;
+    const assertion = await (0, helpers_1.assertValidTrade)({ buyAsset, sellAsset });
+    if (assertion.isErr())
+        return (0, monads_1.Err)(assertion.unwrapErr());
+    const isDeposit = sellAsset.chainId === caip_1.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 (0, fetchArbitrumBridgeSwap_1.fetchArbitrumBridgeQuote)(args);
+        const buyAmountBeforeFeesCryptoBaseUnit = sellAmountIncludingProtocolFeesCryptoBaseUnit;
+        const buyAmountAfterFeesCryptoBaseUnit = sellAmountIncludingProtocolFeesCryptoBaseUnit;
+        return (0, monads_1.Ok)({
+            id: (0, uuid_1.v4)(),
+            quoteOrRate: 'quote',
+            receiveAddress,
+            affiliateBps: '0',
+            rate,
+            slippageTolerancePercentageDecimal: (0, constants_1.getDefaultSlippageDecimalPercentageForSwapper)(types_1.SwapperName.ArbitrumBridge),
+            swapperName: types_1.SwapperName.ArbitrumBridge,
+            steps: [
+                {
+                    estimatedExecutionTimeMs,
+                    allowanceContract: swap.allowanceContract,
+                    rate,
+                    buyAsset,
+                    sellAsset,
+                    accountNumber,
+                    buyAmountBeforeFeesCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    feeData: {
+                        protocolFees: {},
+                        networkFeeCryptoBaseUnit: swap.networkFeeCryptoBaseUnit,
+                    },
+                    source: types_1.SwapperName.ArbitrumBridge,
+                },
+            ],
+            direction: isDeposit ? 'deposit' : 'withdrawal',
+        });
+    }
+    catch (err) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: '[ArbitrumBridge: tradeQuote] - failed to get fee data',
+            cause: err,
+            code: types_1.TradeQuoteError.NetworkFeeEstimationFailed,
+        }));
+    }
+}
+exports.getTradeQuote = getTradeQuote;

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

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

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

@@ -0,0 +1,4 @@
+import type { Result } from '@sniptt/monads';
+import type { GetEvmTradeRateInput, SwapErrorRight, SwapperDeps } from '../../../types';
+import type { ArbitrumBridgeTradeRate } from '../types';
+export declare function getTradeRate(input: GetEvmTradeRateInput, { assertGetEvmChainAdapter }: SwapperDeps): Promise<Result<ArbitrumBridgeTradeRate, SwapErrorRight>>;