@shapeshiftoss/swapper 17.8.0 → 18.1.0

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

@@ -1,342 +0,0 @@
-import { fromAssetId, isAssetReference, solanaChainId, usdcOnSolanaAssetId, } from '@shapeshiftoss/caip';
-import { evm, isEvmChainId } from '@shapeshiftoss/chain-adapters';
-import { BigAmount, bnOrZero, chainIdToFeeAssetId, convertPrecision, isTreasuryChainId, } from '@shapeshiftoss/utils';
-import { Err, Ok } from '@sniptt/monads';
-import { AddressLookupTableAccount, ComputeBudgetProgram, PublicKey, TransactionMessage, VersionedTransaction, } from '@solana/web3.js';
-import axios from 'axios';
-import { zeroAddress } from 'viem';
-import { SwapperName, TradeQuoteError } from '../../../types.js';
-import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
-import { buildAffiliateFee } from '../../utils/affiliateFee.js';
-import { getTreasuryAddressFromChainId, isNativeEvmAsset } from '../../utils/helpers/helpers.js';
-import { ACROSS_SOLANA_TOKEN_ADDRESS, acrossChainIdToChainId, acrossErrorCodeToTradeQuoteError, chainIdToAcrossChainId, DEFAULT_ACROSS_EVM_TOKEN_ADDRESS, DEFAULT_ACROSS_EVM_USER_ADDRESS, DEFAULT_ACROSS_SOLANA_USER_ADDRESS, } from '../constant.js';
-import { fetchAcrossTrade } from './fetchAcrossTrade.js';
-import { isAcrossError } from './types.js';
-const getAcrossAssetAddress = (assetId) => {
-    if (isNativeEvmAsset(assetId))
-        return DEFAULT_ACROSS_EVM_TOKEN_ADDRESS;
-    const { chainId, assetReference } = fromAssetId(assetId);
-    if (chainId === solanaChainId && !isAssetReference(assetReference))
-        return assetReference;
-    if (chainId === solanaChainId)
-        return ACROSS_SOLANA_TOKEN_ADDRESS;
-    return isAssetReference(assetReference) ? zeroAddress : assetReference;
-};
-const getDefaultUserAddress = (chainId) => {
-    if (chainId === solanaChainId)
-        return DEFAULT_ACROSS_SOLANA_USER_ADDRESS;
-    return DEFAULT_ACROSS_EVM_USER_ADDRESS;
-};
-export async function getTrade({ input, deps, }) {
-    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
-    if (sellAsset.chainId === buyAsset.chainId) {
-        return Err(makeSwapErrorRight({
-            message: 'Across does not support same-chain swaps',
-            code: TradeQuoteError.UnsupportedTradePair,
-        }));
-    }
-    const sellAcrossChainId = chainIdToAcrossChainId[sellAsset.chainId];
-    const buyAcrossChainId = chainIdToAcrossChainId[buyAsset.chainId];
-    if (sellAcrossChainId === undefined) {
-        return Err(makeSwapErrorRight({
-            message: `Sell asset chain '${sellAsset.chainId}' not supported by Across`,
-            code: TradeQuoteError.UnsupportedChain,
-        }));
-    }
-    if (buyAcrossChainId === undefined) {
-        return Err(makeSwapErrorRight({
-            message: `Buy asset chain '${buyAsset.chainId}' not supported by Across`,
-            code: TradeQuoteError.UnsupportedChain,
-        }));
-    }
-    // Across only supports USDC as the bridgeable token on Solana destinations
-    if (buyAsset.chainId === solanaChainId && buyAsset.assetId !== usdcOnSolanaAssetId) {
-        return Err(makeSwapErrorRight({
-            message: 'Across only supports USDC as destination token on Solana',
-            code: TradeQuoteError.UnsupportedTradePair,
-        }));
-    }
-    const depositor = (() => {
-        if (input.quoteOrRate === 'rate') {
-            if (input.sendAddress)
-                return input.sendAddress;
-            return getDefaultUserAddress(sellAsset.chainId);
-        }
-        return input.sendAddress ?? getDefaultUserAddress(sellAsset.chainId);
-    })();
-    const recipient = (() => {
-        if (input.quoteOrRate === 'rate') {
-            if (input.receiveAddress)
-                return input.receiveAddress;
-            return getDefaultUserAddress(buyAsset.chainId);
-        }
-        return input.receiveAddress;
-    })();
-    const isSolanaRoute = sellAsset.chainId === solanaChainId || buyAsset.chainId === solanaChainId;
-    const appFee = (() => {
-        if (isSolanaRoute)
-            return undefined;
-        if (!isTreasuryChainId(buyAsset.chainId))
-            return undefined;
-        const bps = bnOrZero(affiliateBps);
-        if (!bps.isFinite() || bps.lte(0))
-            return undefined;
-        return bps.div(10000).toNumber();
-    })();
-    const appFeeRecipient = (() => {
-        if (appFee === undefined)
-            return undefined;
-        try {
-            return getTreasuryAddressFromChainId(buyAsset.chainId).toLowerCase();
-        }
-        catch (e) {
-            console.error(`[getTrade] Failed to get treasury address for chainId ${buyAsset.chainId}, affiliate fee will not be applied`, e);
-            return undefined;
-        }
-    })();
-    const slippage = input.slippageTolerancePercentageDecimal ?? 'auto';
-    const integratorId = deps.config.VITE_ACROSS_INTEGRATOR_ID || undefined;
-    const maybeQuote = await fetchAcrossTrade({
-        tradeType: 'exactInput',
-        amount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-        inputToken: getAcrossAssetAddress(sellAsset.assetId),
-        outputToken: getAcrossAssetAddress(buyAsset.assetId),
-        originChainId: sellAcrossChainId,
-        destinationChainId: buyAcrossChainId,
-        depositor,
-        recipient,
-        appFee,
-        appFeeRecipient,
-        integratorId,
-        slippage,
-    }, deps.config);
-    if (maybeQuote.isErr()) {
-        const error = maybeQuote.unwrapErr();
-        if (!axios.isAxiosError(error.cause)) {
-            return Err(makeSwapErrorRight({
-                message: 'Unknown error',
-                code: TradeQuoteError.UnknownError,
-            }));
-        }
-        const acrossError = error.cause?.response?.data;
-        if (!isAcrossError(acrossError)) {
-            return Err(makeSwapErrorRight({
-                message: 'Unknown error',
-                code: TradeQuoteError.UnknownError,
-            }));
-        }
-        const tradeQuoteErrorCode = acrossErrorCodeToTradeQuoteError[acrossError.code];
-        return Err(makeSwapErrorRight({
-            message: acrossError.message,
-            code: tradeQuoteErrorCode ?? TradeQuoteError.UnknownError,
-        }));
-    }
-    const { data: quote } = maybeQuote.unwrap();
-    const buyAmountAfterFeesCryptoBaseUnit = quote.expectedOutputAmount;
-    const rate = getInputOutputRate({
-        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-        sellAsset,
-        buyAsset,
-    });
-    const bridgeFeeAmount = quote.fees.total.amount;
-    const bridgeFeeAsset = quote.fees.total.token;
-    const buyAssetAcrossAddress = getAcrossAssetAddress(buyAsset.assetId);
-    const isBridgeFeeInBuyAsset = bridgeFeeAsset.chainId === buyAcrossChainId &&
-        (bridgeFeeAsset.address === buyAssetAcrossAddress ||
-            (isEvmChainId(buyAsset.chainId) &&
-                bridgeFeeAsset.address.toLowerCase() === buyAssetAcrossAddress.toLowerCase()));
-    const buyAmountBeforeFeesCryptoBaseUnit = (() => {
-        if (!isBridgeFeeInBuyAsset)
-            return buyAmountAfterFeesCryptoBaseUnit;
-        const bridgeFeeInBuyAssetPrecision = BigAmount.fromBaseUnit({
-            value: convertPrecision({
-                value: bridgeFeeAmount,
-                inputExponent: bridgeFeeAsset.decimals,
-                outputExponent: buyAsset.precision,
-            }).toFixed(0),
-            precision: buyAsset.precision,
-        });
-        return BigAmount.fromBaseUnit({
-            value: buyAmountAfterFeesCryptoBaseUnit,
-            precision: buyAsset.precision,
-        })
-            .plus(bridgeFeeInBuyAssetPrecision)
-            .toBaseUnit();
-    })();
-    const allowanceContract = isEvmChainId(sellAsset.chainId) ? quote.checks.allowance.spender : '';
-    const acrossTransactionMetadata = {
-        to: quote.swapTx.to,
-        data: quote.swapTx.data,
-        value: quote.swapTx.value ?? '0',
-        gasLimit: quote.swapTx.gas,
-        ecosystem: quote.swapTx.ecosystem,
-        quoteId: quote.id,
-    };
-    // For SVM transactions, decompile the pre-built base64 blob into instructions
-    // so getUnsignedSolanaTransaction can rebuild it at execution time
-    const maybeSolanaTransactionMetadata = await (async () => {
-        if (quote.swapTx.ecosystem !== 'svm')
-            return Ok(undefined);
-        try {
-            const txBytes = Buffer.from(quote.swapTx.data, 'base64');
-            const isOversized = txBytes.length > 1232;
-            const versionedTransaction = VersionedTransaction.deserialize(new Uint8Array(txBytes));
-            const adapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
-            const addressLookupTableAccountKeys = versionedTransaction.message.addressTableLookups.map(lookup => lookup.accountKey.toString());
-            const addressLookupTableAccountsInfos = await adapter.getAddressLookupTableAccounts(addressLookupTableAccountKeys);
-            const addressLookupTableAccounts = addressLookupTableAccountsInfos.map(info => new AddressLookupTableAccount({
-                key: new PublicKey(info.key),
-                state: AddressLookupTableAccount.deserialize(new Uint8Array(info.data)),
-            }));
-            const instructions = TransactionMessage.decompile(versionedTransaction.message, {
-                addressLookupTableAccounts,
-            }).instructions;
-            const computeBudgetProgramId = ComputeBudgetProgram.programId.toString();
-            const instructionsWithoutComputeBudget = instructions.filter(instruction => instruction.programId.toString() !== computeBudgetProgramId);
-            return Ok({
-                instructions: instructionsWithoutComputeBudget,
-                addressLookupTableAddresses: addressLookupTableAccountKeys,
-                isOversized,
-            });
-        }
-        catch (e) {
-            return Err(makeSwapErrorRight({
-                message: `[getTrade] Failed to decompile Solana transaction: ${e}`,
-                code: TradeQuoteError.UnknownError,
-            }));
-        }
-    })();
-    if (maybeSolanaTransactionMetadata.isErr())
-        return Err(maybeSolanaTransactionMetadata.unwrapErr());
-    const solanaTransactionMetadata = maybeSolanaTransactionMetadata.unwrap();
-    const networkFeeCryptoBaseUnit = await (async () => {
-        if (solanaTransactionMetadata) {
-            const adapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
-            const { fast } = await adapter.getFeeData({
-                to: '',
-                value: '0',
-                chainSpecific: {
-                    from: depositor,
-                    addressLookupTableAccounts: solanaTransactionMetadata.addressLookupTableAddresses,
-                    instructions: solanaTransactionMetadata.instructions,
-                },
-            });
-            return fast.txFee;
-        }
-        if (isEvmChainId(sellAsset.chainId)) {
-            const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
-            const { average } = await adapter.getGasFeeData();
-            const supportsEIP1559 = 'maxFeePerGas' in average;
-            if (bnOrZero(acrossTransactionMetadata.gasLimit).gt(0)) {
-                return evm.calcNetworkFeeCryptoBaseUnit({
-                    ...average,
-                    supportsEIP1559,
-                    gasLimit: acrossTransactionMetadata.gasLimit ?? '0',
-                });
-            }
-            try {
-                const feeData = await evm.getFees({
-                    adapter,
-                    data: acrossTransactionMetadata.data,
-                    to: acrossTransactionMetadata.to,
-                    value: acrossTransactionMetadata.value,
-                    from: depositor,
-                    supportsEIP1559,
-                });
-                return feeData.networkFeeCryptoBaseUnit;
-            }
-            catch {
-                return quote.fees.originGas.amount;
-            }
-        }
-        return quote.fees.originGas.amount;
-    })();
-    // Build protocol fee asset ID — Across returns its own numeric chain IDs, convert to CAIP
-    const bridgeFeeAssetCaipChainId = acrossChainIdToChainId[bridgeFeeAsset.chainId.toString()];
-    const bridgeFeeAssetId = (() => {
-        if (!bridgeFeeAssetCaipChainId)
-            return undefined;
-        const isNativeFeeAsset = (() => {
-            if (bridgeFeeAssetCaipChainId === solanaChainId) {
-                return (bridgeFeeAsset.address === 'So11111111111111111111111111111111111111112' ||
-                    bridgeFeeAsset.address === zeroAddress);
-            }
-            return bridgeFeeAsset.address === zeroAddress;
-        })();
-        if (isNativeFeeAsset)
-            return chainIdToFeeAssetId(bridgeFeeAssetCaipChainId);
-        const tokenStandard = bridgeFeeAssetCaipChainId.startsWith('solana') ? 'token' : 'erc20';
-        return `${bridgeFeeAssetCaipChainId}/${tokenStandard}:${bridgeFeeAsset.address}`;
-    })();
-    const accountNumber = input.accountNumber;
-    const step = {
-        allowanceContract,
-        rate,
-        buyAmountBeforeFeesCryptoBaseUnit,
-        buyAmountAfterFeesCryptoBaseUnit,
-        sellAmountIncludingProtocolFeesCryptoBaseUnit,
-        buyAsset,
-        sellAsset,
-        accountNumber,
-        feeData: {
-            networkFeeCryptoBaseUnit,
-            protocolFees: bridgeFeeAssetId
-                ? {
-                    [bridgeFeeAssetId]: {
-                        amountCryptoBaseUnit: bridgeFeeAmount,
-                        asset: {
-                            symbol: bridgeFeeAsset.symbol,
-                            chainId: bridgeFeeAssetCaipChainId,
-                            precision: bridgeFeeAsset.decimals,
-                        },
-                        requiresBalance: false,
-                    },
-                }
-                : {},
-        },
-        source: SwapperName.Across,
-        estimatedExecutionTimeMs: quote.expectedFillTime * 1000,
-        acrossTransactionMetadata,
-        solanaTransactionMetadata,
-        affiliateFee: appFee !== undefined && appFeeRecipient !== undefined
-            ? buildAffiliateFee({
-                strategy: 'buy_asset',
-                affiliateBps,
-                sellAsset,
-                buyAsset,
-                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-            })
-            : undefined,
-    };
-    const baseQuoteOrRate = {
-        id: quote.id,
-        rate,
-        swapperName: SwapperName.Across,
-        affiliateBps,
-        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
-    };
-    if (input.quoteOrRate === 'quote') {
-        if (!input.receiveAddress) {
-            return Err(makeSwapErrorRight({
-                message: 'Receive address is required for quote',
-                code: TradeQuoteError.InternalError,
-            }));
-        }
-        const tradeQuote = {
-            ...baseQuoteOrRate,
-            steps: [step],
-            receiveAddress: input.receiveAddress,
-            quoteOrRate: 'quote',
-        };
-        return Ok([tradeQuote]);
-    }
-    const tradeRate = {
-        ...baseQuoteOrRate,
-        steps: [step],
-        receiveAddress: recipient,
-        quoteOrRate: 'rate',
-    };
-    return Ok([tradeRate]);
-}

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

@@ -1,180 +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).mockImplementation(function () {
-            return 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).mockImplementation(function () {
-            return 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).mockImplementation(function () {
-            return 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).mockImplementation(function () {
-            return 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/utils/fetchArbitrumBridgeSwap.d.ts

@@ -1,35 +0,0 @@
-import type { ChildToParentTransactionRequest, ParentToChildTransactionRequest } from '@arbitrum/sdk/dist/lib/dataEntities/transactionRequest';
-import type { ChainId } from '@shapeshiftoss/caip';
-import type { EvmChainAdapter } from '@shapeshiftoss/chain-adapters';
-import type { Asset } from '@shapeshiftoss/types';
-type FetchArbitrumBridgePriceInput = {
-    supportsEIP1559: false;
-    chainId: ChainId;
-    buyAsset: Asset;
-    receiveAddress: string | undefined;
-    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
-    sellAsset: Asset;
-    sendAddress: undefined;
-    assertGetEvmChainAdapter: (chainId: ChainId) => EvmChainAdapter;
-};
-export type FetchArbitrumBridgeQuoteInput = {
-    supportsEIP1559: boolean;
-    chainId: ChainId;
-    buyAsset: Asset;
-    receiveAddress: string;
-    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
-    sellAsset: Asset;
-    sendAddress: string;
-    assertGetEvmChainAdapter: (chainId: ChainId) => EvmChainAdapter;
-};
-export declare const fetchArbitrumBridgePrice: (args: FetchArbitrumBridgePriceInput) => Promise<{
-    request: Omit<ParentToChildTransactionRequest | ChildToParentTransactionRequest, 'retryableData'> | undefined;
-    allowanceContract: string;
-    networkFeeCryptoBaseUnit: string;
-}>;
-export declare const fetchArbitrumBridgeQuote: (args: FetchArbitrumBridgeQuoteInput) => Promise<{
-    request: Omit<ParentToChildTransactionRequest | ChildToParentTransactionRequest, 'retryableData'> | undefined;
-    allowanceContract: string;
-    networkFeeCryptoBaseUnit: string;
-}>;
-export {};