@shapeshiftoss/swapper 17.8.0 → 18.1.0

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

@@ -1,75 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTradeRate = void 0;
-const caip_1 = require("@shapeshiftoss/caip");
 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");
-async function getTradeRate(input, { assertGetEvmChainAdapter }) {
-    const { chainId, sellAsset, buyAsset, supportsEIP1559, receiveAddress, sellAmountIncludingProtocolFeesCryptoBaseUnit, sendAddress, accountNumber, } = 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,
-            chainId,
-            buyAsset,
-            sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            sellAsset,
-            sendAddress,
-            receiveAddress,
-            assertGetEvmChainAdapter,
-            quoteOrRate: 'rate',
-        };
-        const swap = await (0, fetchArbitrumBridgeSwap_1.fetchArbitrumBridgePrice)(args);
-        const buyAmountBeforeFeesCryptoBaseUnit = sellAmountIncludingProtocolFeesCryptoBaseUnit;
-        const buyAmountAfterFeesCryptoBaseUnit = sellAmountIncludingProtocolFeesCryptoBaseUnit;
-        return (0, monads_1.Ok)({
-            id: (0, uuid_1.v4)(),
-            quoteOrRate: 'rate',
-            accountNumber: undefined,
-            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,
-        }));
-    }
-}
+const getArbitrumBridgeStepData_1 = require("../utils/getArbitrumBridgeStepData");
+const getArbitrumBridgeTradeContext_1 = require("../utils/getArbitrumBridgeTradeContext");
+const getTradeRate = async (input, deps) => {
+    const { accountNumber, receiveAddress } = input;
+    const maybeContext = await (0, getArbitrumBridgeTradeContext_1.getArbitrumBridgeTradeContext)({ input, deps });
+    if (maybeContext.isErr())
+        return (0, monads_1.Err)(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await (0, getArbitrumBridgeStepData_1.getArbitrumBridgeStepData)({ ...stepDataArgs, type: 'rate', input });
+    if (maybeStepData.isErr())
+        return (0, monads_1.Err)(maybeStepData.unwrapErr());
+    const { networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeRate = {
+        ...tradeCommon,
+        quoteOrRate: 'rate',
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                feeData: { protocolFees: {}, networkFeeCryptoBaseUnit },
+            },
+        ],
+    };
+    return (0, monads_1.Ok)([tradeRate]);
+};
 exports.getTradeRate = getTradeRate;

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

@@ -1,2 +1,4 @@
 export * from './endpoints';
 export * from './getTradeQuote/getTradeQuote';
+export { isArbitrumBridgeWithdrawal } from './utils/helpers';
+export { arbitrumBridgeSwapper } from './ArbitrumBridgeSwapper';

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

@@ -14,5 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.arbitrumBridgeSwapper = exports.isArbitrumBridgeWithdrawal = void 0;
 __exportStar(require("./endpoints"), exports);
 __exportStar(require("./getTradeQuote/getTradeQuote"), exports);
+var helpers_1 = require("./utils/helpers");
+Object.defineProperty(exports, "isArbitrumBridgeWithdrawal", { enumerable: true, get: function () { return helpers_1.isArbitrumBridgeWithdrawal; } });
+var ArbitrumBridgeSwapper_1 = require("./ArbitrumBridgeSwapper");
+Object.defineProperty(exports, "arbitrumBridgeSwapper", { enumerable: true, get: function () { return ArbitrumBridgeSwapper_1.arbitrumBridgeSwapper; } });

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

@@ -1,13 +1,9 @@
-import type { TradeQuote, TradeRate } from '../../types';
+import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput } from '../../types';
+export type ArbitrumBridgeTradeQuoteInput = GetEvmTradeQuoteInput;
+export type ArbitrumBridgeTradeRateInput = GetEvmTradeRateInput;
 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 {};

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

@@ -0,0 +1,27 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types';
+import type { BRIDGE_TYPE } from '../types';
+type BaseArgs = {
+    bridgeType: BRIDGE_TYPE;
+    sellAmountCryptoBaseUnit: string;
+    buyAsset: Asset;
+    spenderAddress: string;
+};
+export type GetArbitrumBridgeStepDataArgs = StepDataArgs<BaseArgs, unknown, {
+    receiveAddress: string;
+}>;
+type ArbitrumBridgeRateStepData = {
+    networkFeeCryptoBaseUnit: string;
+};
+type ArbitrumBridgeQuoteStepData = {
+    transactionData: TxBuildData;
+    networkFeeCryptoBaseUnit: string;
+};
+export declare function getArbitrumBridgeStepData(args: Extract<GetArbitrumBridgeStepDataArgs, {
+    type: 'rate';
+}>): Promise<Result<ArbitrumBridgeRateStepData, SwapErrorRight>>;
+export declare function getArbitrumBridgeStepData(args: Extract<GetArbitrumBridgeStepDataArgs, {
+    type: 'quote';
+}>): Promise<Result<ArbitrumBridgeQuoteStepData, SwapErrorRight>>;
+export {};

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArbitrumBridgeStepData = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const monads_1 = require("@sniptt/monads");
+const utils_1 = require("../../../utils");
+const evm_1 = require("../../../utils/evm");
+const constants_1 = require("./constants");
+const helpers_1 = require("./helpers");
+async function getArbitrumBridgeStepData(args) {
+    const { input, deps, bridgeType, sellAmountCryptoBaseUnit, sellAsset, buyAsset, spenderAddress } = args;
+    const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+    const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
+    const fallbackGasLimit = constants_1.BRIDGE_TYPE_TO_FALLBACK_GAS_LIMIT[bridgeType].toFixed(0);
+    if (args.type === 'rate') {
+        const networkFeeCryptoBaseUnit = await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+            adapter,
+            supportsEIP1559,
+            gasLimit: fallbackGasLimit,
+        });
+        const stepData = { networkFeeCryptoBaseUnit };
+        return (0, monads_1.Ok)(stepData);
+    }
+    const { from, receiveAddress } = args;
+    const request = await (0, helpers_1.buildArbitrumBridgeRequest)({
+        bridgeType,
+        sellAmountCryptoBaseUnit,
+        from,
+        receiveAddress,
+        sellAsset,
+        buyAsset,
+    });
+    if (!request)
+        return (0, monads_1.Err)((0, utils_1.makeTradeStepBuildFailedErr)('getArbitrumBridgeStepData', undefined));
+    const { to, data, value } = request.txRequest;
+    const transactionData = {
+        type: 'evm',
+        chainId: Number((0, caip_1.fromChainId)(sellAsset.chainId).chainReference),
+        to,
+        data: data.toString(),
+        value: value.toString(),
+    };
+    try {
+        const networkFeeCryptoBaseUnit = await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+            adapter,
+            transactionData,
+            from,
+            supportsEIP1559,
+            stateOverride: {
+                sellAsset,
+                sellAmountCryptoBaseUnit,
+                spenderAddress,
+            },
+        });
+        const stepData = { transactionData, networkFeeCryptoBaseUnit };
+        return (0, monads_1.Ok)(stepData);
+    }
+    catch (error) {
+        return (0, monads_1.Err)((0, utils_1.makeNetworkFeeEstimationFailedErr)('getArbitrumBridgeStepData', error));
+    }
+}
+exports.getArbitrumBridgeStepData = getArbitrumBridgeStepData;

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

@@ -0,0 +1,13 @@
+import type { Result } from '@sniptt/monads';
+import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types';
+import type { GetArbitrumBridgeStepDataArgs } from './getArbitrumBridgeStepData';
+type ArbitrumBridgeTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    stepDataArgs: Omit<GetArbitrumBridgeStepDataArgs, 'type' | 'input' | 'from' | 'receiveAddress'>;
+};
+export declare const getArbitrumBridgeTradeContext: ({ input, deps, }: {
+    input: GetEvmTradeQuoteInput | GetEvmTradeRateInput;
+    deps: SwapperDeps;
+}) => Promise<Result<ArbitrumBridgeTradeContext, SwapErrorRight>>;
+export {};

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArbitrumBridgeTradeContext = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const monads_1 = require("@sniptt/monads");
+const uuid_1 = require("uuid");
+const constants_1 = require("../../../constants");
+const types_1 = require("../../../types");
+const helpers_1 = require("./helpers");
+const getArbitrumBridgeTradeContext = async ({ input, deps, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = 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';
+    const bridgeType = (0, helpers_1.getArbitrumBridgeType)({ sellAsset, buyAsset });
+    const allowanceContract = await (0, helpers_1.getArbitrumBridgeAllowanceContract)({ bridgeType, sellAsset });
+    return (0, monads_1.Ok)({
+        tradeCommon: {
+            id: (0, uuid_1.v4)(),
+            rate,
+            swapperName: types_1.SwapperName.ArbitrumBridge,
+            affiliateBps: '0',
+            slippageTolerancePercentageDecimal: (0, constants_1.getDefaultSlippageDecimalPercentageForSwapper)(types_1.SwapperName.ArbitrumBridge),
+        },
+        stepCommon: {
+            allowanceContract,
+            rate,
+            buyAmountBeforeFeesCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAsset,
+            sellAsset,
+            source: types_1.SwapperName.ArbitrumBridge,
+            estimatedExecutionTimeMs,
+        },
+        stepDataArgs: {
+            bridgeType,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAsset,
+            sellAsset,
+            spenderAddress: allowanceContract,
+            deps,
+        },
+    });
+};
+exports.getArbitrumBridgeTradeContext = getArbitrumBridgeTradeContext;

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

@@ -1,16 +1,36 @@
-import type { ChildToParentTransactionRequest, ParentToChildTransactionRequest } from '@arbitrum/sdk';
-import type { EvmChainAdapter } from '@shapeshiftoss/chain-adapters';
+import type { ChildToParentTransactionRequest, ParentToChildMessageReader, ParentToChildMessageReaderClassic, ParentToChildTransactionRequest } from '@arbitrum/sdk';
 import type { Asset } from '@shapeshiftoss/types';
 import type { Result } from '@sniptt/monads/build';
-import type { SwapErrorRight } from '../../../types';
-import type { BRIDGE_TYPE } from '../types';
+import type { ethers as ethersv5 } from 'ethers5';
+import type { SwapErrorRight, TradeQuote, TradeRate } from '../../../types';
+import { BRIDGE_TYPE } from '../types';
+export declare const isArbitrumBridgeWithdrawal: (quote: TradeQuote | TradeRate | undefined) => boolean;
+export declare const getArbitrumBridgeType: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => BRIDGE_TYPE;
 export declare const assertValidTrade: ({ buyAsset, sellAsset, }: {
     buyAsset: Asset;
     sellAsset: Asset;
 }) => Promise<Result<boolean, SwapErrorRight>>;
-export declare const getNetworkFeeOrFallbackCryptoBaseUnit: ({ maybeRequest, bridgeType, supportsEIP1559, adapter, }: {
-    maybeRequest: ParentToChildTransactionRequest | ChildToParentTransactionRequest | undefined;
+export declare const getArbitrumBridgeAllowanceContract: ({ bridgeType, sellAsset, }: {
     bridgeType: BRIDGE_TYPE;
-    supportsEIP1559: boolean;
-    adapter: EvmChainAdapter;
+    sellAsset: Asset;
 }) => Promise<string>;
+export declare const buildArbitrumBridgeRequest: ({ bridgeType, sellAmountCryptoBaseUnit, from, receiveAddress, sellAsset, buyAsset, }: {
+    bridgeType: BRIDGE_TYPE;
+    sellAmountCryptoBaseUnit: string;
+    from: string;
+    receiveAddress: string;
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Promise<Omit<ParentToChildTransactionRequest | ChildToParentTransactionRequest, 'retryableData'> | undefined>;
+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>;

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

@@ -1,29 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNetworkFeeOrFallbackCryptoBaseUnit = exports.assertValidTrade = void 0;
+exports.getParentToChildMessageDataFromParentTxHash = exports.buildArbitrumBridgeRequest = exports.getArbitrumBridgeAllowanceContract = exports.assertValidTrade = exports.getArbitrumBridgeType = exports.isArbitrumBridgeWithdrawal = 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 utils_1 = require("@shapeshiftoss/utils");
 const build_1 = require("@sniptt/monads/build");
+const ethers5_1 = require("ethers5");
 const viem_1 = require("viem");
 const chains_1 = require("viem/chains");
 const types_2 = require("../../../types");
-const utils_1 = require("../../../utils");
-const constants_1 = require("./constants");
-const types_3 = require("./types");
+const utils_2 = require("../../../utils");
+const types_3 = require("../types");
+const types_4 = require("./types");
+const isArbitrumBridgeWithdrawal = (quote) => {
+    // withdrawal = selling from Arbitrum (deposit = selling from Ethereum to Arbitrum)
+    return (quote?.swapperName === types_2.SwapperName.ArbitrumBridge &&
+        quote.steps[0]?.sellAsset.chainId === caip_1.arbitrumChainId);
+};
+exports.isArbitrumBridgeWithdrawal = isArbitrumBridgeWithdrawal;
+const getArbitrumBridgeType = ({ sellAsset, buyAsset, }) => {
+    const isDeposit = sellAsset.chainId === caip_1.ethChainId;
+    const isEthBridge = isDeposit ? sellAsset.assetId === caip_1.ethAssetId : buyAsset.assetId === caip_1.ethAssetId;
+    if (isDeposit)
+        return isEthBridge ? types_3.BRIDGE_TYPE.ETH_DEPOSIT : types_3.BRIDGE_TYPE.ERC20_DEPOSIT;
+    return isEthBridge ? types_3.BRIDGE_TYPE.ETH_WITHDRAWAL : types_3.BRIDGE_TYPE.ERC20_WITHDRAWAL;
+};
+exports.getArbitrumBridgeType = getArbitrumBridgeType;
 const assertValidTrade = async ({ buyAsset, sellAsset, }) => {
-    if (!types_3.arbitrumBridgeSupportedChainIds.includes(sellAsset.chainId) ||
-        !types_3.arbitrumBridgeSupportedChainIds.includes(buyAsset.chainId)) {
-        return (0, build_1.Err)((0, utils_1.makeSwapErrorRight)({
+    if (!types_4.arbitrumBridgeSupportedChainIds.includes(sellAsset.chainId) ||
+        !types_4.arbitrumBridgeSupportedChainIds.includes(buyAsset.chainId)) {
+        return (0, build_1.Err)((0, utils_2.makeSwapErrorRight)({
             message: `[ArbitrumBridge: assertValidTrade] - unsupported chainId`,
             code: types_2.TradeQuoteError.UnsupportedChain,
             details: { buyAsset, sellAsset },
         }));
     }
     if (buyAsset.chainId === sellAsset.chainId) {
-        return (0, build_1.Err)((0, utils_1.makeSwapErrorRight)({
+        return (0, build_1.Err)((0, utils_2.makeSwapErrorRight)({
             message: `[ArbitrumBridge: assertValidTrade] - both assets must be on different chainIds`,
             code: types_2.TradeQuoteError.UnsupportedTradePair,
             details: { buyAsset, sellAsset },
@@ -39,7 +54,7 @@ const assertValidTrade = async ({ buyAsset, sellAsset, }) => {
             ? buyAsset.assetId !== caip_1.arbitrumAssetId
             : buyAsset.assetId !== caip_1.ethAssetId;
         if (isInvalidPair) {
-            return (0, build_1.Err)((0, utils_1.makeSwapErrorRight)({
+            return (0, build_1.Err)((0, utils_2.makeSwapErrorRight)({
                 message: `[ArbitrumBridge: tradeQuote] - Invalid ETH bridge pair`,
                 code: types_2.TradeQuoteError.UnsupportedTradePair,
                 details: { buyAsset, sellAsset },
@@ -55,16 +70,27 @@ const assertValidTrade = async ({ buyAsset, sellAsset, }) => {
         const childProvider = (0, contracts_1.getEthersV5Provider)(types_1.KnownChainIds.ArbitrumMainnet);
         // Since our related assets list isn't exhaustive and won't cut it to determine the Parent <-> Child mapping, we double check that the bridge is valid
         // by checking against Arbitrum bridge's own mappings, which uses different sources (Coingecko, Gemini, Uni and its own lists at the time of writing)
-        const arbitrumBridgeErc20ChildAddress = await bridger.getChildErc20Address(erc20ParentAddress, parentProvider);
-        const arbitrumBridgeErc20ParentAddress = await bridger.getParentErc20Address(erc20ChildAddress, childProvider);
+        // Tokens that aren't gateway-registered revert these lookups (e.g. native circle USDC has no
+        // l1Address()) - the bridge can't move them, so a lookup failure is an unsupported pair
+        const [arbitrumBridgeErc20ChildAddress, arbitrumBridgeErc20ParentAddress] = await Promise.all([
+            bridger.getChildErc20Address(erc20ParentAddress, parentProvider),
+            bridger.getParentErc20Address(erc20ChildAddress, childProvider),
+        ]).catch(() => [undefined, undefined]);
+        if (!arbitrumBridgeErc20ChildAddress || !arbitrumBridgeErc20ParentAddress) {
+            return (0, build_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: `[ArbitrumBridge: tradeQuote] - Token is not registered with the arbitrum bridge`,
+                code: types_2.TradeQuoteError.UnsupportedTradePair,
+                details: { buyAsset, sellAsset },
+            }));
+        }
         if (!(0, viem_1.isAddressEqual)((0, viem_1.getAddress)(arbitrumBridgeErc20ParentAddress), (0, viem_1.getAddress)(erc20ParentAddress))) {
-            return (0, build_1.Err)((0, utils_1.makeSwapErrorRight)({
+            return (0, build_1.Err)((0, utils_2.makeSwapErrorRight)({
                 message: `[ArbitrumBridge: tradeQuote] - Invalid Parent ERC20 address: ${erc20ParentAddress}`,
                 code: types_2.TradeQuoteError.UnsupportedTradePair,
             }));
         }
         if (!(0, viem_1.isAddressEqual)((0, viem_1.getAddress)(arbitrumBridgeErc20ChildAddress), (0, viem_1.getAddress)(erc20ChildAddress))) {
-            return (0, build_1.Err)((0, utils_1.makeSwapErrorRight)({
+            return (0, build_1.Err)((0, utils_2.makeSwapErrorRight)({
                 message: `[ArbitrumBridge: tradeQuote] - Invalid Child ERC20 address: ${erc20ChildAddress}`,
                 code: types_2.TradeQuoteError.UnsupportedTradePair,
             }));
@@ -73,28 +99,123 @@ const assertValidTrade = async ({ buyAsset, sellAsset, }) => {
     return (0, build_1.Ok)(true);
 };
 exports.assertValidTrade = assertValidTrade;
-const getNetworkFeeOrFallbackCryptoBaseUnit = async ({ maybeRequest, bridgeType, supportsEIP1559, adapter, }) => {
-    // Fallback fees
-    if (!maybeRequest) {
-        const { average } = await adapter.getGasFeeData();
-        const { gasPrice, maxFeePerGas } = average;
-        const fallbackGasLimit = constants_1.BRIDGE_TYPE_TO_FALLBACK_GAS_LIMIT[bridgeType];
-        // eip1559 fees
-        if (supportsEIP1559 && maxFeePerGas) {
-            return fallbackGasLimit.times(maxFeePerGas).toFixed();
+// ERC20 deposits approve the Parent gateway; everything else needs no approval
+const getArbitrumBridgeAllowanceContract = ({ bridgeType, sellAsset, }) => {
+    if (bridgeType !== types_3.BRIDGE_TYPE.ERC20_DEPOSIT)
+        return Promise.resolve('');
+    const l2Network = (0, sdk_1.getArbitrumNetwork)(chains_1.arbitrum.id);
+    const bridger = new sdk_1.Erc20Bridger(l2Network);
+    const erc20ParentAddress = (0, caip_1.fromAssetId)(sellAsset.assetId).assetReference;
+    const parentProvider = (0, contracts_1.getEthersV5Provider)(types_1.KnownChainIds.EthereumMainnet);
+    return bridger.getParentGatewayAddress(erc20ParentAddress, parentProvider);
+};
+exports.getArbitrumBridgeAllowanceContract = getArbitrumBridgeAllowanceContract;
+// Builds the executable bridge request via the Arbitrum SDK. The retryable estimation runs on the
+// child node, so this builds before approval - only our own L1 fee estimation reverts pre-approval
+const buildArbitrumBridgeRequest = ({ bridgeType, sellAmountCryptoBaseUnit, from, receiveAddress, sellAsset, buyAsset, }) => {
+    const l2Network = (0, sdk_1.getArbitrumNetwork)(chains_1.arbitrum.id);
+    const parentProvider = (0, contracts_1.getEthersV5Provider)(types_1.KnownChainIds.EthereumMainnet);
+    const childProvider = (0, contracts_1.getEthersV5Provider)(types_1.KnownChainIds.ArbitrumMainnet);
+    const amount = ethers5_1.BigNumber.from(sellAmountCryptoBaseUnit);
+    switch (bridgeType) {
+        case types_3.BRIDGE_TYPE.ETH_DEPOSIT: {
+            const bridger = new sdk_1.EthBridger(l2Network);
+            return bridger
+                .getDepositToRequest({
+                parentProvider,
+                childProvider,
+                amount,
+                from,
+                destinationAddress: receiveAddress,
+            })
+                .catch(e => {
+                console.error('Error getting ETH deposit request', e);
+                return undefined;
+            });
+        }
+        case types_3.BRIDGE_TYPE.ETH_WITHDRAWAL: {
+            const bridger = new sdk_1.EthBridger(l2Network);
+            return bridger
+                .getWithdrawalRequest({ amount, from, destinationAddress: receiveAddress })
+                .catch(e => {
+                console.error('Error getting ETH withdraw request', e);
+                return undefined;
+            });
+        }
+        case types_3.BRIDGE_TYPE.ERC20_DEPOSIT: {
+            const bridger = new sdk_1.Erc20Bridger(l2Network);
+            const erc20ParentAddress = (0, caip_1.fromAssetId)(sellAsset.assetId).assetReference;
+            return bridger
+                .getDepositRequest({
+                amount,
+                parentProvider,
+                childProvider,
+                erc20ParentAddress,
+                from,
+                destinationAddress: receiveAddress,
+                retryableGasOverrides: {
+                    // https://github.com/OffchainLabs/arbitrum-token-bridge/blob/d17c88ef3eef3f4ffc61a04d34d50406039f045d/packages/arb-token-bridge-ui/src/util/TokenDepositUtils.ts#L159
+                    // the gas limit may vary by about 20k due to SSTORE (zero vs nonzero)
+                    // the 30% gas limit increase should cover the difference
+                    gasLimit: { percentIncrease: ethers5_1.BigNumber.from(30) },
+                },
+            })
+                .catch(e => {
+                console.error('Error getting ERC20 deposit request', e);
+                return undefined;
+            });
         }
-        // legacy fees
-        return fallbackGasLimit.times(gasPrice).toFixed();
+        case types_3.BRIDGE_TYPE.ERC20_WITHDRAWAL: {
+            const bridger = new sdk_1.Erc20Bridger(l2Network);
+            const erc20ParentAddress = (0, caip_1.fromAssetId)(buyAsset.assetId).assetReference;
+            return bridger
+                .getWithdrawalRequest({
+                amount,
+                erc20ParentAddress,
+                from,
+                destinationAddress: receiveAddress,
+            })
+                .catch(e => {
+                console.error('Error getting ERC20 withdraw request', e);
+                return undefined;
+            });
+        }
+        default:
+            return (0, utils_1.assertUnreachable)(bridgeType);
+    }
+};
+exports.buildArbitrumBridgeRequest = buildArbitrumBridgeRequest;
+// 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();
     }
-    // Actual fees
-    const feeData = await chain_adapters_1.evm.getFees({
-        adapter,
-        data: maybeRequest.txRequest.data.toString(),
-        to: maybeRequest.txRequest.to,
-        value: maybeRequest.txRequest.value.toString(),
-        from: maybeRequest.txRequest.from,
-        supportsEIP1559,
-    });
-    return feeData.networkFeeCryptoBaseUnit;
+    // post-nitro deposit - both eth + token
+    return getNitroDepositMessage();
 };
-exports.getNetworkFeeOrFallbackCryptoBaseUnit = getNetworkFeeOrFallbackCryptoBaseUnit;
+exports.getParentToChildMessageDataFromParentTxHash = getParentToChildMessageDataFromParentTxHash;