@shapeshiftoss/swapper 17.6.6 → 17.6.8

package/dist/esm/swappers/ArbitrumBridgeSwapper/types.js

@@ -0,0 +1,7 @@
+export var BRIDGE_TYPE;
+(function (BRIDGE_TYPE) {
+    BRIDGE_TYPE["ETH_DEPOSIT"] = "ETH Deposit";
+    BRIDGE_TYPE["ERC20_DEPOSIT"] = "ERC20 Deposit";
+    BRIDGE_TYPE["ETH_WITHDRAWAL"] = "ETH Withdrawal";
+    BRIDGE_TYPE["ERC20_WITHDRAWAL"] = "ERC20 Withdrawal";
+})(BRIDGE_TYPE || (BRIDGE_TYPE = {}));

package/dist/esm/swappers/ArbitrumBridgeSwapper/utils/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const BRIDGE_TYPE_TO_FALLBACK_GAS_LIMIT: {
+    "ETH Deposit": BigNumber;
+    "ERC20 Deposit": BigNumber;
+    "ETH Withdrawal": BigNumber;
+    "ERC20 Withdrawal": BigNumber;
+};

package/dist/esm/swappers/ArbitrumBridgeSwapper/utils/constants.js

@@ -0,0 +1,30 @@
+import { bn } from '@shapeshiftoss/utils';
+import { BRIDGE_TYPE } from '../types.js';
+// Broad estimate calculated by looking at a couple of different ERC-20 deposits
+// https://github.com/OffchainLabs/arbitrum-token-bridge/blob/d17c88ef3eef3f4ffc61a04d34d50406039f045d/packages/arb-token-bridge-ui/src/util/TokenDepositUtils.ts#L45-L51
+const fallbackErc20DepositGasLimit = bn(240_000);
+// Broad estimate calculated by looking at a couple of different ERC-20 withdraws
+// https://arbiscan.io/tx/0xf27939d382abcb0cce5c202489db457a6cc0d0dd8062468543400c3bf321148f
+// https://arbiscan.io/tx/0xa4639374806ecc1e9de7beafbab2567c078483b84b708e862bfbd84fbc2fc1da
+// https://arbiscan.io/tx/0xb6c3bce7999b2ae4bbe51a64bc7ab370d21ce9bf6807b805239acbf4c244a6db
+// https://arbiscan.io/tx/0x878aa224a65d831c931192550b3d8fe114fa81660c1af8369c0e2ebea682dd5b
+// https://arbiscan.io/tx/0xf293bd64f9dabddaffc4c8b97f2a602d4e9f77565f5d24018a0f70a95c1ecd38
+const fallbackErc20WithdrawGasLimit = bn(350_000);
+// Actually extremely accurate estimate calculated by looking at a couple of different ETH deposits - gas limit is around 100-100.05k
+// https://etherscan.io/tx/0x31f7860fdb79c76d0301b9197f4e00ed2432170f1be38288f87838ce1184643a
+// https://etherscan.io/tx/0x933c1b625824abeae6f15b4667e22caa3dc14be4929ae62310e2fbf1d39c7d8b
+// https://etherscan.io/tx/0x695090931bb09e60fd378210a0c204ebb01cc137ff00e576074c79a41cc4fa80
+// https://etherscan.io/tx/0xaaef3d2391e4b07f6f0a7524dadde735d4a9822efc2a611e5e8dd5e2708438cc
+const fallbackEthDepositGasLimit = bn(100_000);
+// Broad estimate calculated by looking at a couple of different ETH withdraws
+const fallbackEthWithdrawGasLimit = bn(115_000);
+// https://arbiscan.io/tx/0x641f1c0bacced5896e35aa505abe03076323e769e959aa0f7b9c9cd63d1741dd
+// https://arbiscan.io/tx/0x060f503fa97b137d4298a6adb87cdae83030e1a43ee265b7d52e3b92493acd62
+// https://arbiscan.io/tx/0x162efc48dffb5f7d8c6b454c6df42b4739edb70d2427a311538a0927c5ccdddc
+// https://arbiscan.io/tx/0x51e76bc14ffa7a14d13732459ecd1c8fd3211bfb717ac2eb3de4d40fda8a9c4b
+export const BRIDGE_TYPE_TO_FALLBACK_GAS_LIMIT = {
+    [BRIDGE_TYPE.ETH_DEPOSIT]: fallbackEthDepositGasLimit,
+    [BRIDGE_TYPE.ERC20_DEPOSIT]: fallbackErc20DepositGasLimit,
+    [BRIDGE_TYPE.ETH_WITHDRAWAL]: fallbackEthWithdrawGasLimit,
+    [BRIDGE_TYPE.ERC20_WITHDRAWAL]: fallbackErc20WithdrawGasLimit,
+};

package/dist/esm/swappers/ArbitrumBridgeSwapper/utils/fetchArbitrumBridgeSwap.d.ts

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

package/dist/esm/swappers/ArbitrumBridgeSwapper/utils/fetchArbitrumBridgeSwap.js

@@ -0,0 +1,143 @@
+import { Erc20Bridger, EthBridger, getArbitrumNetwork } from '@arbitrum/sdk';
+import { ethAssetId, ethChainId, fromAssetId } from '@shapeshiftoss/caip';
+import { getEthersV5Provider } from '@shapeshiftoss/contracts';
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { assertUnreachable } from '@shapeshiftoss/utils';
+import { BigNumber } from 'ethers5';
+import { arbitrum } from 'viem/chains';
+import { BRIDGE_TYPE } from '../types.js';
+import { getNetworkFeeOrFallbackCryptoBaseUnit } from './helpers.js';
+const fetchArbitrumBridgeSwap = async ({ chainId, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset, sendAddress, receiveAddress, supportsEIP1559, assertGetEvmChainAdapter, quoteOrRate, }) => {
+    if (quoteOrRate === 'quote' && !receiveAddress)
+        throw new Error('receiveAddress is required for Arbitrum Bridge quotes');
+    if (quoteOrRate === 'quote' && !sendAddress)
+        throw new Error('sendAddress is required for Arbitrum Bridge quotes');
+    const adapter = assertGetEvmChainAdapter(chainId);
+    const l2Network = await getArbitrumNetwork(arbitrum.id);
+    const isDeposit = sellAsset.chainId === ethChainId;
+    const isEthBridge = isDeposit ? sellAsset.assetId === ethAssetId : buyAsset.assetId === ethAssetId;
+    const bridgeType = (() => {
+        if (isDeposit) {
+            return isEthBridge ? BRIDGE_TYPE.ETH_DEPOSIT : BRIDGE_TYPE.ERC20_DEPOSIT;
+        }
+        return isEthBridge ? BRIDGE_TYPE.ETH_WITHDRAWAL : BRIDGE_TYPE.ERC20_WITHDRAWAL;
+    })();
+    const parentProvider = getEthersV5Provider(KnownChainIds.EthereumMainnet);
+    const childProvider = getEthersV5Provider(KnownChainIds.ArbitrumMainnet);
+    switch (bridgeType) {
+        case BRIDGE_TYPE.ETH_DEPOSIT: {
+            const bridger = new EthBridger(l2Network);
+            const maybeRequest = quoteOrRate === 'quote'
+                ? await bridger
+                    .getDepositToRequest({
+                    parentProvider,
+                    childProvider,
+                    amount: BigNumber.from(sellAmountIncludingProtocolFeesCryptoBaseUnit),
+                    // This is actually guarded against in if `(quoteOrRate === 'quote' && !sendAddress)` above
+                    from: sendAddress ?? '',
+                    // This is actually guarded against in if `(quoteOrRate === 'quote' && !receiveAddress)` above
+                    destinationAddress: receiveAddress ?? '',
+                })
+                    .catch(e => {
+                    console.error('Error getting ETH deposit request', e);
+                    return undefined;
+                })
+                : undefined;
+            const networkFeeCryptoBaseUnit = await getNetworkFeeOrFallbackCryptoBaseUnit({
+                maybeRequest,
+                bridgeType,
+                supportsEIP1559,
+                adapter,
+            });
+            return { request: maybeRequest, networkFeeCryptoBaseUnit, allowanceContract: '0x0' };
+        }
+        case BRIDGE_TYPE.ETH_WITHDRAWAL: {
+            const bridger = new EthBridger(l2Network);
+            const maybeRequest = quoteOrRate === 'quote'
+                ? await bridger
+                    .getWithdrawalRequest({
+                    amount: BigNumber.from(sellAmountIncludingProtocolFeesCryptoBaseUnit),
+                    // This is actually guarded against in if `(quoteOrRate === 'quote' && !sendAddress)` above
+                    from: sendAddress ?? '',
+                    // This is actually guarded against in if `(quoteOrRate === 'quote' && !receiveAddress)` above
+                    destinationAddress: receiveAddress ?? '',
+                })
+                    .catch(e => {
+                    console.error('Error getting ETH withdraw request', e);
+                    return undefined;
+                })
+                : undefined;
+            const networkFeeCryptoBaseUnit = await getNetworkFeeOrFallbackCryptoBaseUnit({
+                maybeRequest,
+                bridgeType,
+                supportsEIP1559,
+                adapter,
+            });
+            return { request: maybeRequest, networkFeeCryptoBaseUnit, allowanceContract: '0x0' };
+        }
+        case BRIDGE_TYPE.ERC20_DEPOSIT: {
+            const bridger = new Erc20Bridger(l2Network);
+            const erc20ParentAddress = fromAssetId(sellAsset.assetId).assetReference;
+            const allowanceContract = await bridger.getParentGatewayAddress(erc20ParentAddress, parentProvider);
+            const maybeRequest = quoteOrRate === 'quote'
+                ? await bridger
+                    .getDepositRequest({
+                    amount: BigNumber.from(sellAmountIncludingProtocolFeesCryptoBaseUnit),
+                    parentProvider,
+                    childProvider,
+                    erc20ParentAddress,
+                    // This is actually guarded against in if `(quoteOrRate === 'quote' && !sendAddress)` above
+                    from: sendAddress ?? '',
+                    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: BigNumber.from(30) },
+                    },
+                })
+                    .catch(e => {
+                    console.error('Error getting ERC20 deposit request', e);
+                    return undefined;
+                })
+                : undefined;
+            const networkFeeCryptoBaseUnit = await getNetworkFeeOrFallbackCryptoBaseUnit({
+                maybeRequest,
+                bridgeType,
+                supportsEIP1559,
+                adapter,
+            });
+            return { request: maybeRequest, networkFeeCryptoBaseUnit, allowanceContract };
+        }
+        case BRIDGE_TYPE.ERC20_WITHDRAWAL: {
+            const bridger = new Erc20Bridger(l2Network);
+            const erc20ParentAddress = fromAssetId(buyAsset.assetId).assetReference;
+            const maybeRequest = quoteOrRate === 'quote'
+                ? await bridger
+                    .getWithdrawalRequest({
+                    amount: BigNumber.from(sellAmountIncludingProtocolFeesCryptoBaseUnit),
+                    erc20ParentAddress,
+                    // This is actually guarded against in if `(quoteOrRate === 'quote' && !sendAddress)` above
+                    from: sendAddress ?? '',
+                    // This is actually guarded against in if `(quoteOrRate === 'quote' && !receiveAddress)` above
+                    destinationAddress: receiveAddress ?? '',
+                })
+                    .catch(e => {
+                    console.error('Error getting ERC20 withdraw request', e);
+                    return undefined;
+                })
+                : undefined;
+            const networkFeeCryptoBaseUnit = await getNetworkFeeOrFallbackCryptoBaseUnit({
+                maybeRequest,
+                bridgeType,
+                supportsEIP1559,
+                adapter,
+            });
+            return { request: maybeRequest, networkFeeCryptoBaseUnit, allowanceContract: '0x0' };
+        }
+        default:
+            return assertUnreachable(bridgeType);
+    }
+};
+export const fetchArbitrumBridgePrice = (args) => fetchArbitrumBridgeSwap({ ...args, quoteOrRate: 'rate' });
+export const fetchArbitrumBridgeQuote = (args) => fetchArbitrumBridgeSwap({ ...args, quoteOrRate: 'quote' });

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

@@ -0,0 +1,16 @@
+import type { ChildToParentTransactionRequest, ParentToChildTransactionRequest } from '@arbitrum/sdk';
+import type { EvmChainAdapter } from '@shapeshiftoss/chain-adapters';
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads/build';
+import type { SwapErrorRight } from '../../../types.js';
+import type { BRIDGE_TYPE } from '../types.js';
+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;
+    bridgeType: BRIDGE_TYPE;
+    supportsEIP1559: boolean;
+    adapter: EvmChainAdapter;
+}) => Promise<string>;

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

@@ -0,0 +1,95 @@
+import { Erc20Bridger, getArbitrumNetwork } from '@arbitrum/sdk';
+import { arbitrumAssetId, ethAssetId, ethChainId, fromAssetId } from '@shapeshiftoss/caip';
+import { evm } from '@shapeshiftoss/chain-adapters';
+import { getEthersV5Provider } from '@shapeshiftoss/contracts';
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { Err, Ok } from '@sniptt/monads/build';
+import { getAddress, isAddressEqual } from 'viem';
+import { arbitrum } from 'viem/chains';
+import { TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils.js';
+import { BRIDGE_TYPE_TO_FALLBACK_GAS_LIMIT } from './constants.js';
+import { arbitrumBridgeSupportedChainIds } from './types.js';
+export const assertValidTrade = async ({ buyAsset, sellAsset, }) => {
+    if (!arbitrumBridgeSupportedChainIds.includes(sellAsset.chainId) ||
+        !arbitrumBridgeSupportedChainIds.includes(buyAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: `[ArbitrumBridge: assertValidTrade] - unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { buyAsset, sellAsset },
+        }));
+    }
+    if (buyAsset.chainId === sellAsset.chainId) {
+        return Err(makeSwapErrorRight({
+            message: `[ArbitrumBridge: assertValidTrade] - both assets must be on different chainIds`,
+            code: TradeQuoteError.UnsupportedTradePair,
+            details: { buyAsset, sellAsset },
+        }));
+    }
+    const isDeposit = sellAsset.chainId === ethChainId;
+    const isEthBridge = isDeposit
+        ? sellAsset.assetId === ethAssetId
+        : sellAsset.assetId === arbitrumAssetId;
+    const isTokenBridge = !isEthBridge;
+    if (isEthBridge) {
+        const isInvalidPair = isDeposit
+            ? buyAsset.assetId !== arbitrumAssetId
+            : buyAsset.assetId !== ethAssetId;
+        if (isInvalidPair) {
+            return Err(makeSwapErrorRight({
+                message: `[ArbitrumBridge: tradeQuote] - Invalid ETH bridge pair`,
+                code: TradeQuoteError.UnsupportedTradePair,
+                details: { buyAsset, sellAsset },
+            }));
+        }
+    }
+    if (isTokenBridge) {
+        const childNetwork = await getArbitrumNetwork(arbitrum.id);
+        const bridger = new Erc20Bridger(childNetwork);
+        const erc20ParentAddress = fromAssetId((isDeposit ? sellAsset : buyAsset).assetId).assetReference;
+        const erc20ChildAddress = fromAssetId((isDeposit ? buyAsset : sellAsset).assetId).assetReference;
+        const parentProvider = getEthersV5Provider(KnownChainIds.EthereumMainnet);
+        const childProvider = getEthersV5Provider(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);
+        if (!isAddressEqual(getAddress(arbitrumBridgeErc20ParentAddress), getAddress(erc20ParentAddress))) {
+            return Err(makeSwapErrorRight({
+                message: `[ArbitrumBridge: tradeQuote] - Invalid Parent ERC20 address: ${erc20ParentAddress}`,
+                code: TradeQuoteError.UnsupportedTradePair,
+            }));
+        }
+        if (!isAddressEqual(getAddress(arbitrumBridgeErc20ChildAddress), getAddress(erc20ChildAddress))) {
+            return Err(makeSwapErrorRight({
+                message: `[ArbitrumBridge: tradeQuote] - Invalid Child ERC20 address: ${erc20ChildAddress}`,
+                code: TradeQuoteError.UnsupportedTradePair,
+            }));
+        }
+    }
+    return Ok(true);
+};
+export const getNetworkFeeOrFallbackCryptoBaseUnit = async ({ maybeRequest, bridgeType, supportsEIP1559, adapter, }) => {
+    // Fallback fees
+    if (!maybeRequest) {
+        const { average } = await adapter.getGasFeeData();
+        const { gasPrice, maxFeePerGas } = average;
+        const fallbackGasLimit = BRIDGE_TYPE_TO_FALLBACK_GAS_LIMIT[bridgeType];
+        // eip1559 fees
+        if (supportsEIP1559 && maxFeePerGas) {
+            return fallbackGasLimit.times(maxFeePerGas).toFixed();
+        }
+        // legacy fees
+        return fallbackGasLimit.times(gasPrice).toFixed();
+    }
+    // Actual fees
+    const feeData = await 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;
+};

package/dist/esm/swappers/ArbitrumBridgeSwapper/utils/types.d.ts

@@ -0,0 +1,3 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export declare const arbitrumBridgeSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.ArbitrumMainnet];
+export type ArbitrumBridgeSupportedChainId = (typeof arbitrumBridgeSupportedChainIds)[number];

package/dist/esm/swappers/ArbitrumBridgeSwapper/utils/types.js

@@ -0,0 +1,5 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export const arbitrumBridgeSupportedChainIds = [
+    KnownChainIds.EthereumMainnet,
+    KnownChainIds.ArbitrumMainnet,
+];

package/dist/esm/swappers/AvnuSwapper/AvnuSwapper.d.ts

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

package/dist/esm/swappers/AvnuSwapper/AvnuSwapper.js

@@ -0,0 +1,4 @@
+import { executeStarknetTransaction } from '../../index.js';
+export const avnuSwapper = {
+    executeStarknetTransaction,
+};

package/dist/esm/swappers/AvnuSwapper/endpoints.d.ts

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

package/dist/esm/swappers/AvnuSwapper/endpoints.js

@@ -0,0 +1,178 @@
+import { quoteToCalls } from '@avnu/avnu-sdk';
+import { toAddressNList } from '@shapeshiftoss/chain-adapters';
+import { CallData, hash, num } from 'starknet';
+import { checkStarknetSwapStatus, createDefaultStatusResponse, getExecutableTradeStep, isExecutableTradeQuote, } from '../../utils.js';
+import { getTradeQuote } from './swapperApi/getTradeQuote.js';
+import { getTradeRate } from './swapperApi/getTradeRate.js';
+export const avnuApi = {
+    getTradeQuote,
+    getTradeRate: (input, deps) => {
+        return getTradeRate(input, deps);
+    },
+    getUnsignedStarknetTransaction: async ({ stepIndex, tradeQuote, from, slippageTolerancePercentageDecimal, assertGetStarknetChainAdapter, }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { accountNumber, sellAsset, avnuSpecific } = step;
+        if (!avnuSpecific)
+            throw new Error('avnuSpecific is required');
+        if (!avnuSpecific.quoteId)
+            throw new Error('quoteId is required in avnuSpecific');
+        const adapter = assertGetStarknetChainAdapter(sellAsset.chainId);
+        // Convert slippage from decimal percentage string to number for AVNU format (e.g., "0.01" = 1%)
+        const slippage = slippageTolerancePercentageDecimal
+            ? parseFloat(slippageTolerancePercentageDecimal)
+            : 0.01;
+        // Get the swap calls from AVNU SDK
+        const { calls: avnuCalls } = await quoteToCalls({
+            quoteId: avnuSpecific.quoteId,
+            slippage,
+            takerAddress: from,
+        });
+        // Build the full invoke transaction calldata from AVNU calls
+        // Format: [call_array_length, contract1, selector1, calldata_len1, ...calldata1, ...]
+        const fullCalldata = [avnuCalls.length.toString()];
+        for (const call of avnuCalls) {
+            const rawCalldata = call.calldata ?? [];
+            const calldataArray = Array.isArray(rawCalldata) ? rawCalldata : CallData.compile(rawCalldata);
+            const selector = hash.getSelectorFromName(call.entrypoint);
+            fullCalldata.push(call.contractAddress, selector, calldataArray.length.toString(), ...calldataArray.map(cd => cd.toString()));
+        }
+        // Format calldata for RPC (convert numbers to hex)
+        const formattedCalldata = fullCalldata.map(data => {
+            if (!data.startsWith('0x')) {
+                return num.toHex(data);
+            }
+            return data;
+        });
+        // Get nonce using adapter method (checks deployment status and returns appropriate nonce)
+        const chainIdHex = await adapter.getStarknetProvider().getChainId();
+        const nonce = await adapter.getNonce(from);
+        // Estimate fees for the multi-call swap transaction
+        const version = '0x3';
+        const estimateTx = {
+            type: 'INVOKE',
+            version,
+            sender_address: from,
+            calldata: formattedCalldata,
+            signature: [],
+            nonce,
+            resource_bounds: {
+                l1_gas: { max_amount: '0x186a0', max_price_per_unit: '0x5f5e100' },
+                l2_gas: { max_amount: '0x0', max_price_per_unit: '0x0' },
+                l1_data_gas: { max_amount: '0x186a0', max_price_per_unit: '0x1' },
+            },
+            tip: '0x0',
+            paymaster_data: [],
+            account_deployment_data: [],
+            nonce_data_availability_mode: 'L1',
+            fee_data_availability_mode: 'L1',
+        };
+        const estimateResponse = await adapter
+            .getStarknetProvider()
+            .fetch('starknet_estimateFee', [[estimateTx], ['SKIP_VALIDATE'], 'latest']);
+        const estimateResult = await estimateResponse.json();
+        if (estimateResult.error) {
+            throw new Error(`Fee estimation failed: ${JSON.stringify(estimateResult.error)}`);
+        }
+        const feeEstimate = estimateResult.result?.[0];
+        if (!feeEstimate) {
+            throw new Error('Fee estimation failed: no estimate returned');
+        }
+        // Calculate resource bounds with buffer (5x gas amount, 2x gas price)
+        const l1GasConsumed = feeEstimate.l1_gas_consumed
+            ? BigInt(feeEstimate.l1_gas_consumed)
+            : BigInt('0x186a0');
+        const l1GasPrice = feeEstimate.l1_gas_price
+            ? BigInt(feeEstimate.l1_gas_price)
+            : BigInt('0x5f5e100');
+        const l2GasConsumed = feeEstimate.l2_gas_consumed
+            ? BigInt(feeEstimate.l2_gas_consumed)
+            : BigInt('0x0');
+        const l2GasPrice = feeEstimate.l2_gas_price ? BigInt(feeEstimate.l2_gas_price) : BigInt('0x0');
+        const l1DataGasConsumed = feeEstimate.l1_data_gas_consumed
+            ? BigInt(feeEstimate.l1_data_gas_consumed)
+            : BigInt('0x186a0');
+        const l1DataGasPrice = feeEstimate.l1_data_gas_price
+            ? BigInt(feeEstimate.l1_data_gas_price)
+            : BigInt('0x1');
+        const resourceBounds = {
+            l1_gas: {
+                max_amount: (l1GasConsumed * BigInt(500)) / BigInt(100),
+                max_price_per_unit: (l1GasPrice * BigInt(200)) / BigInt(100),
+            },
+            l2_gas: {
+                max_amount: (l2GasConsumed * BigInt(500)) / BigInt(100),
+                max_price_per_unit: (l2GasPrice * BigInt(200)) / BigInt(100),
+            },
+            l1_data_gas: {
+                max_amount: (l1DataGasConsumed * BigInt(500)) / BigInt(100),
+                max_price_per_unit: (l1DataGasPrice * BigInt(200)) / BigInt(100),
+            },
+        };
+        // Calculate transaction hash for signing
+        const invokeHashInputs = {
+            senderAddress: from,
+            version,
+            compiledCalldata: formattedCalldata,
+            chainId: chainIdHex,
+            nonce,
+            nonceDataAvailabilityMode: 0,
+            feeDataAvailabilityMode: 0,
+            resourceBounds: {
+                l1_gas: {
+                    max_amount: resourceBounds.l1_gas.max_amount,
+                    max_price_per_unit: resourceBounds.l1_gas.max_price_per_unit,
+                },
+                l2_gas: {
+                    max_amount: resourceBounds.l2_gas.max_amount,
+                    max_price_per_unit: resourceBounds.l2_gas.max_price_per_unit,
+                },
+                l1_data_gas: {
+                    max_amount: resourceBounds.l1_data_gas.max_amount,
+                    max_price_per_unit: resourceBounds.l1_data_gas.max_price_per_unit,
+                },
+            },
+            tip: '0x0',
+            paymasterData: [],
+            accountDeploymentData: [],
+        };
+        const txHash = hash.calculateInvokeTransactionHash(invokeHashInputs);
+        // Return transaction ready for signing
+        return {
+            addressNList: toAddressNList(adapter.getBip44Params({ accountNumber })),
+            txHash,
+            _txDetails: {
+                fromAddress: from,
+                calldata: formattedCalldata,
+                nonce,
+                version,
+                resourceBounds,
+                chainId: chainIdHex,
+                nonceDataAvailabilityMode: 0,
+                feeDataAvailabilityMode: 0,
+                tip: '0x0',
+                paymasterData: [],
+                accountDeploymentData: [],
+            },
+        };
+    },
+    getStarknetTransactionFees: ({ tradeQuote, stepIndex }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        if (!step.feeData.networkFeeCryptoBaseUnit) {
+            throw new Error('Missing network fee in quote');
+        }
+        return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit);
+    },
+    checkTradeStatus: ({ swap, assertGetStarknetChainAdapter }) => {
+        if (!swap?.sellTxHash) {
+            return Promise.resolve(createDefaultStatusResponse());
+        }
+        return checkStarknetSwapStatus({
+            txHash: swap.sellTxHash,
+            assertGetStarknetChainAdapter,
+        });
+    },
+};

package/dist/esm/swappers/AvnuSwapper/index.d.ts

@@ -0,0 +1 @@
+export { AVNU_SUPPORTED_CHAIN_IDS } from './utils/constants.js';

package/dist/esm/swappers/AvnuSwapper/index.js

@@ -0,0 +1 @@
+export { AVNU_SUPPORTED_CHAIN_IDS } from './utils/constants.js';

package/dist/esm/swappers/AvnuSwapper/swapperApi/getTradeQuote.d.ts

@@ -0,0 +1,3 @@
+import type { Result } from '@sniptt/monads';
+import type { CommonTradeQuoteInput, SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types.js';
+export declare const getTradeQuote: (input: CommonTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote[], SwapErrorRight>>;