@shapeshiftoss/swapper 17.8.0 → 19.0.0

package/dist/cjs/swappers/AcrossSwapper/utils/getAcrossStepData.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAcrossStepData = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const web3_js_1 = require("@solana/web3.js");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const evm_1 = require("../../../utils/evm");
+const solana_1 = require("../../../utils/solana");
+async function getAcrossStepData(args) {
+    const { swapTx, sellAsset, spenderAddress, from, type, input, fallbackNetworkFeeCryptoBaseUnit, deps, } = args;
+    const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
+    switch (swapTx.ecosystem) {
+        case 'evm': {
+            const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+            const transactionData = {
+                type: 'evm',
+                chainId: Number((0, caip_1.fromChainId)(sellAsset.chainId).chainReference),
+                to: swapTx.to,
+                data: swapTx.data,
+                value: swapTx.value ?? '0',
+                gasLimit: swapTx.gas,
+            };
+            const stateOverride = {
+                sellAsset,
+                sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                spenderAddress,
+            };
+            if (type === 'rate') {
+                const networkFeeCryptoBaseUnit = await (async () => {
+                    try {
+                        return await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+                            adapter,
+                            transactionData,
+                            from,
+                            supportsEIP1559,
+                            stateOverride,
+                        });
+                    }
+                    catch {
+                        return fallbackNetworkFeeCryptoBaseUnit;
+                    }
+                })();
+                const stepData = { networkFeeCryptoBaseUnit };
+                return (0, monads_1.Ok)(stepData);
+            }
+            try {
+                const networkFeeCryptoBaseUnit = await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+                    adapter,
+                    transactionData,
+                    from,
+                    supportsEIP1559,
+                    stateOverride,
+                });
+                const stepData = { transactionData, networkFeeCryptoBaseUnit };
+                return (0, monads_1.Ok)(stepData);
+            }
+            catch (error) {
+                return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getAcrossStepData', error));
+            }
+        }
+        case 'svm': {
+            try {
+                const txBytes = Buffer.from(swapTx.data, 'base64');
+                const versionedTransaction = web3_js_1.VersionedTransaction.deserialize(new Uint8Array(txBytes));
+                const adapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
+                const addressLookupTableAddresses = versionedTransaction.message.addressTableLookups.map(lookup => lookup.accountKey.toString());
+                const addressLookupTableAccountsInfos = await adapter.getAddressLookupTableAccounts(addressLookupTableAddresses);
+                const addressLookupTableAccounts = addressLookupTableAccountsInfos.map(info => new web3_js_1.AddressLookupTableAccount({
+                    key: new web3_js_1.PublicKey(info.key),
+                    state: web3_js_1.AddressLookupTableAccount.deserialize(new Uint8Array(info.data)),
+                }));
+                const instructions = web3_js_1.TransactionMessage.decompile(versionedTransaction.message, {
+                    addressLookupTableAccounts,
+                }).instructions;
+                if (type === 'rate') {
+                    // No placeholder estimation for provider built routes - best effort with provider fee fallback
+                    const networkFeeCryptoBaseUnit = await (async () => {
+                        try {
+                            const { networkFeeCryptoBaseUnit } = await (0, solana_1.getSolanaNetworkFeeCryptoBaseUnit)({
+                                adapter,
+                                from,
+                                instructions,
+                                addressLookupTableAddresses,
+                                tokenId: (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId),
+                            });
+                            return networkFeeCryptoBaseUnit;
+                        }
+                        catch {
+                            return fallbackNetworkFeeCryptoBaseUnit;
+                        }
+                    })();
+                    const stepData = { networkFeeCryptoBaseUnit };
+                    return (0, monads_1.Ok)(stepData);
+                }
+                try {
+                    const { networkFeeCryptoBaseUnit } = await (0, solana_1.getSolanaNetworkFeeCryptoBaseUnit)({
+                        adapter,
+                        from,
+                        instructions,
+                        addressLookupTableAddresses,
+                        tokenId: (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId),
+                    });
+                    // Across pre-signs the CCTP message event account slot and pins the blockhash, so the
+                    // tx is sealed - it must be co-signed and broadcast as-is, never decompiled and rebuilt
+                    // (the instructions above are estimation-only)
+                    const transactionData = {
+                        type: 'solana_serialized_tx',
+                        serializedTx: swapTx.data,
+                    };
+                    const stepData = { transactionData, networkFeeCryptoBaseUnit };
+                    return (0, monads_1.Ok)(stepData);
+                }
+                catch (e) {
+                    return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getAcrossStepData', e));
+                }
+            }
+            catch (e) {
+                // Rates degrade to the provider fee, quotes can't be built from an undecodable payload
+                if (type === 'rate') {
+                    const stepData = {
+                        networkFeeCryptoBaseUnit: fallbackNetworkFeeCryptoBaseUnit,
+                    };
+                    return (0, monads_1.Ok)(stepData);
+                }
+                return (0, monads_1.Err)((0, utils_2.makeTradeStepBuildFailedErr)('getAcrossStepData', e));
+            }
+        }
+        default: {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+                message: `[getAcrossStepData] unsupported ecosystem: ${swapTx.ecosystem}`,
+                code: types_1.TradeQuoteError.UnsupportedChain,
+            }));
+        }
+    }
+}
+exports.getAcrossStepData = getAcrossStepData;

package/dist/cjs/swappers/AcrossSwapper/utils/getAcrossTradeContext.d.ts

@@ -0,0 +1,18 @@
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types';
+import type { GetAcrossStepDataArgs } from './getAcrossStepData';
+import type { AcrossTradeQuoteInput, AcrossTradeRateInput } from './types';
+type AcrossTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    stepDataArgs: Omit<GetAcrossStepDataArgs, 'type' | 'input'>;
+    deadline: number;
+};
+export declare const getAcrossTradeContext: ({ input, deps, depositor, recipient, }: {
+    input: AcrossTradeQuoteInput | AcrossTradeRateInput;
+    deps: SwapperDeps;
+    depositor: string;
+    recipient: string;
+}) => Promise<Result<AcrossTradeContext, SwapErrorRight>>;
+export {};

package/dist/cjs/swappers/AcrossSwapper/utils/getAcrossTradeContext.js

@@ -0,0 +1,184 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAcrossTradeContext = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const axios_1 = __importDefault(require("axios"));
+const viem_1 = require("viem");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const affiliateFee_1 = require("../../../utils/affiliateFee");
+const helpers_1 = require("../../../utils/helpers");
+const constant_1 = require("../constant");
+const fetchAcrossTrade_1 = require("./fetchAcrossTrade");
+const helpers_2 = require("./helpers");
+const types_2 = require("./types");
+const getAcrossTradeContext = async ({ input, deps, depositor, recipient, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const assertion = (0, helpers_2.assertValidTrade)({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return (0, monads_1.Err)(assertion.unwrapErr());
+    const { sellAcrossChainId, buyAcrossChainId } = assertion.unwrap();
+    const isSolanaRoute = sellAsset.chainId === caip_1.solanaChainId || buyAsset.chainId === caip_1.solanaChainId;
+    const appFee = (() => {
+        if (isSolanaRoute)
+            return;
+        if (!(0, utils_1.isTreasuryChainId)(buyAsset.chainId))
+            return;
+        const bps = (0, utils_1.bnOrZero)(affiliateBps);
+        if (!bps.isFinite() || bps.lte(0))
+            return;
+        return bps.div(10000).toNumber();
+    })();
+    const appFeeRecipient = (() => {
+        if (appFee === undefined)
+            return;
+        try {
+            return (0, helpers_1.getTreasuryAddressFromChainId)(buyAsset.chainId).toLowerCase();
+        }
+        catch (e) {
+            console.error(`[getAcrossTradeContext] Failed to get treasury address for chainId ${buyAsset.chainId}, affiliate fee will not be applied`, e);
+        }
+    })();
+    const slippage = input.slippageTolerancePercentageDecimal ?? 'auto';
+    const integratorId = deps.config.VITE_ACROSS_INTEGRATOR_ID || undefined;
+    const maybeQuote = await (0, fetchAcrossTrade_1.fetchAcrossTrade)({
+        tradeType: 'exactInput',
+        amount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        inputToken: (0, helpers_2.getAcrossAssetAddress)(sellAsset.assetId),
+        outputToken: (0, helpers_2.getAcrossAssetAddress)(buyAsset.assetId),
+        originChainId: sellAcrossChainId,
+        destinationChainId: buyAcrossChainId,
+        depositor,
+        recipient,
+        appFee,
+        appFeeRecipient,
+        integratorId,
+        slippage,
+    }, deps.config);
+    if (maybeQuote.isErr()) {
+        const error = maybeQuote.unwrapErr();
+        if (!axios_1.default.isAxiosError(error.cause)) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({ message: 'Unknown error', code: types_1.TradeQuoteError.UnknownError }));
+        }
+        const acrossError = error.cause?.response?.data;
+        if (!(0, types_2.isAcrossError)(acrossError)) {
+            return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({ message: 'Unknown error', code: types_1.TradeQuoteError.UnknownError }));
+        }
+        const tradeQuoteErrorCode = constant_1.acrossErrorCodeToTradeQuoteError[acrossError.code];
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: acrossError.message,
+            code: tradeQuoteErrorCode ?? types_1.TradeQuoteError.UnknownError,
+        }));
+    }
+    const { data: quote } = maybeQuote.unwrap();
+    const buyAmountAfterFeesCryptoBaseUnit = quote.expectedOutputAmount;
+    const rate = (0, utils_2.getInputOutputRate)({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const bridgeFeeAmount = quote.fees.total.amount;
+    const bridgeFeeAsset = quote.fees.total.token;
+    const buyAssetAcrossAddress = (0, helpers_2.getAcrossAssetAddress)(buyAsset.assetId);
+    const isBridgeFeeInBuyAsset = bridgeFeeAsset.chainId === buyAcrossChainId &&
+        (bridgeFeeAsset.address === buyAssetAcrossAddress ||
+            ((0, chain_adapters_1.isEvmChainId)(buyAsset.chainId) &&
+                bridgeFeeAsset.address.toLowerCase() === buyAssetAcrossAddress.toLowerCase()));
+    const buyAmountBeforeFeesCryptoBaseUnit = (() => {
+        if (!isBridgeFeeInBuyAsset)
+            return buyAmountAfterFeesCryptoBaseUnit;
+        const bridgeFeeInBuyAssetPrecision = utils_1.BigAmount.fromBaseUnit({
+            value: (0, utils_1.convertPrecision)({
+                value: bridgeFeeAmount,
+                inputExponent: bridgeFeeAsset.decimals,
+                outputExponent: buyAsset.precision,
+            }).toFixed(0),
+            precision: buyAsset.precision,
+        });
+        return utils_1.BigAmount.fromBaseUnit({
+            value: buyAmountAfterFeesCryptoBaseUnit,
+            precision: buyAsset.precision,
+        })
+            .plus(bridgeFeeInBuyAssetPrecision)
+            .toBaseUnit();
+    })();
+    // Build protocol fee asset ID — Across returns its own numeric chain IDs, convert to CAIP
+    const bridgeFeeAssetCaipChainId = constant_1.acrossChainIdToChainId[bridgeFeeAsset.chainId.toString()];
+    const bridgeFeeAssetId = (() => {
+        if (!bridgeFeeAssetCaipChainId)
+            return;
+        const isNativeFeeAsset = (() => {
+            if (bridgeFeeAssetCaipChainId === caip_1.solanaChainId) {
+                return (bridgeFeeAsset.address === 'So11111111111111111111111111111111111111112' ||
+                    bridgeFeeAsset.address === viem_1.zeroAddress);
+            }
+            return bridgeFeeAsset.address === viem_1.zeroAddress;
+        })();
+        if (isNativeFeeAsset)
+            return (0, utils_1.chainIdToFeeAssetId)(bridgeFeeAssetCaipChainId);
+        const tokenStandard = bridgeFeeAssetCaipChainId.startsWith('solana') ? 'token' : 'erc20';
+        return `${bridgeFeeAssetCaipChainId}/${tokenStandard}:${bridgeFeeAsset.address}`;
+    })();
+    const allowanceContract = (0, chain_adapters_1.isEvmChainId)(sellAsset.chainId) ? quote.checks.allowance.spender : '';
+    const protocolFees = bridgeFeeAssetId
+        ? {
+            [bridgeFeeAssetId]: {
+                amountCryptoBaseUnit: bridgeFeeAmount,
+                asset: {
+                    symbol: bridgeFeeAsset.symbol,
+                    chainId: bridgeFeeAssetCaipChainId,
+                    precision: bridgeFeeAsset.decimals,
+                },
+                requiresBalance: false,
+            },
+        }
+        : {};
+    return (0, monads_1.Ok)({
+        tradeCommon: {
+            id: quote.id,
+            rate,
+            swapperName: types_1.SwapperName.Across,
+            affiliateBps,
+            slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+        },
+        stepCommon: {
+            allowanceContract,
+            rate,
+            buyAmountBeforeFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAsset,
+            sellAsset,
+            source: types_1.SwapperName.Across,
+            estimatedExecutionTimeMs: quote.expectedFillTime * 1000,
+            affiliateFee: appFee !== undefined && appFeeRecipient !== undefined
+                ? (0, affiliateFee_1.buildAffiliateFee)({
+                    strategy: 'buy_asset',
+                    affiliateBps,
+                    sellAsset,
+                    buyAsset,
+                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                })
+                : undefined,
+        },
+        protocolFees,
+        stepDataArgs: {
+            swapTx: quote.swapTx,
+            sellAsset,
+            from: depositor,
+            spenderAddress: allowanceContract,
+            fallbackNetworkFeeCryptoBaseUnit: quote.fees.originGas.amount,
+            deps,
+        },
+        deadline: (0, helpers_1.normalizeEpochToMs)(quote.quoteExpiryTimestamp),
+    });
+};
+exports.getAcrossTradeContext = getAcrossTradeContext;

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

@@ -0,0 +1,12 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types';
+export declare const getAcrossAssetAddress: (assetId: string) => string;
+export declare const getDefaultUserAddress: (chainId: string) => string;
+export declare const assertValidTrade: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Result<{
+    sellAcrossChainId: number;
+    buyAcrossChainId: number;
+}, SwapErrorRight>;

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertValidTrade = exports.getDefaultUserAddress = exports.getAcrossAssetAddress = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const monads_1 = require("@sniptt/monads");
+const viem_1 = require("viem");
+const types_1 = require("../../../types");
+const utils_1 = require("../../../utils");
+const helpers_1 = require("../../../utils/helpers");
+const constant_1 = require("../constant");
+const getAcrossAssetAddress = (assetId) => {
+    if ((0, helpers_1.isNativeEvmAsset)(assetId))
+        return constant_1.DEFAULT_ACROSS_EVM_TOKEN_ADDRESS;
+    const { chainId, assetReference } = (0, caip_1.fromAssetId)(assetId);
+    if (chainId === caip_1.solanaChainId && !(0, caip_1.isAssetReference)(assetReference))
+        return assetReference;
+    if (chainId === caip_1.solanaChainId)
+        return constant_1.ACROSS_SOLANA_TOKEN_ADDRESS;
+    return (0, caip_1.isAssetReference)(assetReference) ? viem_1.zeroAddress : assetReference;
+};
+exports.getAcrossAssetAddress = getAcrossAssetAddress;
+const getDefaultUserAddress = (chainId) => {
+    if (chainId === caip_1.solanaChainId)
+        return constant_1.DEFAULT_ACROSS_SOLANA_USER_ADDRESS;
+    return constant_1.DEFAULT_ACROSS_EVM_USER_ADDRESS;
+};
+exports.getDefaultUserAddress = getDefaultUserAddress;
+const assertValidTrade = ({ sellAsset, buyAsset, }) => {
+    if (sellAsset.chainId === buyAsset.chainId) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: 'Across does not support same-chain swaps',
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    const sellAcrossChainId = constant_1.chainIdToAcrossChainId[sellAsset.chainId];
+    const buyAcrossChainId = constant_1.chainIdToAcrossChainId[buyAsset.chainId];
+    if (sellAcrossChainId === undefined) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `Sell asset chain '${sellAsset.chainId}' not supported by Across`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    if (buyAcrossChainId === undefined) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `Buy asset chain '${buyAsset.chainId}' not supported by Across`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    // Across only supports USDC as the bridgeable token on Solana destinations
+    if (buyAsset.chainId === caip_1.solanaChainId && buyAsset.assetId !== caip_1.usdcOnSolanaAssetId) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: 'Across only supports USDC as destination token on Solana',
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    return (0, monads_1.Ok)({ sellAcrossChainId, buyAcrossChainId });
+};
+exports.assertValidTrade = assertValidTrade;

package/dist/cjs/swappers/AcrossSwapper/utils/types.d.ts

@@ -1,25 +1,6 @@
-import type { Asset } from '@shapeshiftoss/types';
-export type AcrossTradeBaseParams = {
-    buyAsset: Asset;
-    sellAsset: Asset;
-    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
-    affiliateBps: string;
-};
-export type AcrossTradeInputParams<T extends 'rate' | 'quote'> = AcrossTradeBaseParams & {
-    quoteOrRate: T;
-    receiveAddress: T extends 'rate' ? string | undefined : string;
-    sendAddress: T extends 'rate' ? undefined : string;
-    accountNumber: T extends 'rate' ? undefined : number;
-    slippageTolerancePercentageDecimal?: string;
-};
-export type AcrossTransactionMetadata = {
-    to: string;
-    data: string;
-    value: string;
-    gasLimit?: string;
-    ecosystem: 'evm' | 'svm';
-    quoteId: string;
-};
+import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput, GetSolanaTradeQuoteInput, GetSolanaTradeRateInput } from '../../../types';
+export type AcrossTradeQuoteInput = GetEvmTradeQuoteInput | GetSolanaTradeQuoteInput;
+export type AcrossTradeRateInput = GetEvmTradeRateInput | GetSolanaTradeRateInput;
 export type AcrossTokenInfo = {
     address: string;
     decimals: number;

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

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

@@ -1,159 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.arbitrumBridgeApi = exports.getParentToChildMessageDataFromParentTxHash = void 0;
+exports.arbitrumBridgeApi = 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 evm_1 = require("../../utils/evm");
 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;
-    },
+    getTradeQuote: (input, deps) => (0, getTradeQuote_1.getTradeQuote)(input, deps),
+    getTradeRate: (input, deps) => (0, getTradeRate_1.getTradeRate)(input, deps),
+    getUnsignedEvmTransaction: evm_1.getUnsignedEvmTransaction,
+    getEvmTransactionFees: evm_1.getEvmTransactionFees,
     checkTradeStatus: async ({ txHash, chainId, assertGetEvmChainAdapter, address, fetchIsSmartContractAddressQuery, }) => {
         const swapTxStatus = await (0, utils_1.checkEvmSwapStatus)({
             txHash,
@@ -183,7 +45,7 @@ exports.arbitrumBridgeApi = {
         }
         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)({
+        const maybeParentToChildMessageData = await (0, helpers_1.getParentToChildMessageDataFromParentTxHash)({
             depositTxId: txHash,
             parentProvider,
             childProvider,

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

@@ -1,6 +1,5 @@
 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>>;
+import type { GetEvmTradeQuoteInputWithWallet, SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types';
+import type { ArbitrumBridgeTradeQuoteInput } from '../types';
+export declare const getTradeQuoteWithWallet: (inputWithWallet: GetEvmTradeQuoteInputWithWallet, deps: SwapperDeps) => Promise<Result<TradeQuote, SwapErrorRight>>;
+export declare const getTradeQuote: (input: ArbitrumBridgeTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote[], SwapErrorRight>>;