@shapeshiftoss/swapper 17.7.3 → 18.1.0

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

@@ -0,0 +1,183 @@
+"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,
+        },
+    });
+};
+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>>;

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

@@ -1,86 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTradeQuote = exports.getTradeQuoteWithWallet = exports.isArbitrumBridgeTradeQuoteOrRate = void 0;
-const caip_1 = require("@shapeshiftoss/caip");
+exports.getTradeQuote = exports.getTradeQuoteWithWallet = void 0;
 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 getArbitrumBridgeStepData_1 = require("../utils/getArbitrumBridgeStepData");
+const getArbitrumBridgeTradeContext_1 = require("../utils/getArbitrumBridgeTradeContext");
 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);
+    const maybeQuotes = await (0, exports.getTradeQuote)({ ...input, supportsEIP1559 }, deps);
+    return maybeQuotes.map(quotes => quotes[0]);
 };
 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,
-        }));
-    }
-}
+const getTradeQuote = async (input, deps) => {
+    const { accountNumber } = input;
+    const maybeAddresses = (0, utils_1.assertQuoteAddresses)(input);
+    if (maybeAddresses.isErr())
+        return (0, monads_1.Err)(maybeAddresses.unwrapErr());
+    const { sendAddress, receiveAddress } = maybeAddresses.unwrap();
+    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: 'quote',
+        input,
+        from: sendAddress,
+        receiveAddress,
+    });
+    if (maybeStepData.isErr())
+        return (0, monads_1.Err)(maybeStepData.unwrapErr());
+    const { transactionData, networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeQuote = {
+        ...tradeCommon,
+        quoteOrRate: 'quote',
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                transactionData,
+                feeData: { protocolFees: {}, networkFeeCryptoBaseUnit },
+            },
+        ],
+    };
+    return (0, monads_1.Ok)([tradeQuote]);
+};
 exports.getTradeQuote = getTradeQuote;

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

@@ -1,4 +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>>;
+import type { SwapErrorRight, SwapperDeps, TradeRate } from '../../../types';
+import type { ArbitrumBridgeTradeRateInput } from '../types';
+export declare const getTradeRate: (input: ArbitrumBridgeTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate[], SwapErrorRight>>;