@imtbl/sdk 0.16.0 → 0.17.1

package/dist/checkout_sdk.js

@@ -1,13 +1,12 @@
 import { ethers, ContractFactory, utils, Contract as Contract$1, BigNumber as BigNumber$1, providers, constants as constants$1 } from 'ethers';
 import { Web3Provider, JsonRpcProvider } from '@ethersproject/providers';
+import $7v2Z6$axios, { HttpStatusCode } from 'axios';
 import $7v2Z6$metamaskdetectprovider from '@metamask/detect-provider';
-import { TradeType, Token, Percent, CurrencyAmount } from '@uniswap/sdk-core';
+import { TradeType, Token, CurrencyAmount, Percent } from '@uniswap/sdk-core';
 import assert from 'assert';
-import { BigNumber as BigNumber$2 } from '@ethersproject/bignumber';
 import { FeeAmount, Route, SwapQuoter, Pool, Trade, toHex as toHex$1, encodeRouteToPath } from '@uniswap/v3-sdk';
 import { keccak256 as keccak256$1 } from '@ethersproject/solidity';
 import { SwapRouter } from '@uniswap/router-sdk';
-import axios from 'axios';
 import FormData from 'form-data';
 import { Seaport as Seaport$1 } from '@opensea/seaport-js';
 
@@ -12492,38 +12491,6 @@ class AlreadyApprovedError extends ExchangeError {
     }
 }
 
-/**
- * Determines whether or not the chain supports EIP-1559 by checking for the existence
- * of {@link FeeData.maxFeePerGas} and {@link FeeData.maxPriorityFeePerGas}
- *
- * @param {FeeData} fee - The fee data for the chain
- */
-const doesChainSupportEIP1559 = (fee) => {
-    const supportsEIP1559 = !!fee.maxFeePerGas && !!fee.maxPriorityFeePerGas;
-    return supportsEIP1559;
-};
-/**
- * Fetch the current gas price estimate. Supports both EIP-1559 and non-EIP1559 chains
- * @param {JsonRpcProvider} provider - The JSON RPC provider used to fetch fee data
- * @returns {BigNumber | null} - The gas price in the smallest denomination of the chain's currency,
- * or null if no gas price is available
- */
-const fetchGasPrice = async (provider) => {
-    const feeData = await provider.getFeeData().catch(() => null);
-    if (!feeData) {
-        return null;
-    }
-    return doesChainSupportEIP1559(feeData) ? feeData.maxFeePerGas.add(feeData.maxPriorityFeePerGas) : feeData.gasPrice;
-};
-/**
- * Calculate the gas fee from the gas price and gas units used for the transaction
- *
- * @param {BigNumber} gasPriceInWei - The price of gas in wei
- * @param {BigNumber} gasUsed - The total gas units that will be used for the transaction
- * @returns - The cost of the transaction in the gas token's smallest denomination (e.g. WEI)
- */
-const calculateGasFee = (gasPriceInWei, gasUsed) => gasUsed.mul(gasPriceInWei);
-
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
@@ -12759,179 +12726,6 @@ class ERC20__factory {
     }
 }
 
-/**
- * Get the amount of an ERC20 token that needs to be approved by
- * checking the existing allowance for the spender
- *
- * @param provider - The provider to use for the call
- * @param ownerAddress - The address of the owner of the token
- * @param tokenAmount  - The amount of the token to approve
- * @param spenderAddress - The address of the spender
- * @returns - The amount of the token that needs to be approved
- */
-const getERC20AmountToApprove = async (provider, ownerAddress, tokenAddress, tokenAmount, spenderAddress) => {
-    // create an instance of the ERC20 token contract
-    const erc20Contract = ERC20__factory.connect(tokenAddress, provider);
-    // get the allowance for the token spender
-    // minimum is 0 - no allowance
-    let allowance;
-    try {
-        allowance = await erc20Contract.allowance(ownerAddress, spenderAddress);
-    }
-    catch (e) {
-        const message = e instanceof Error ? e.message : 'Unknown Error';
-        throw new ApproveError(`failed to get allowance: ${message}`);
-    }
-    // get the amount that needs to be approved
-    const requiredAmount = BigNumber$2.from(tokenAmount).sub(allowance);
-    if (requiredAmount.isNegative() || requiredAmount.isZero()) {
-        throw new AlreadyApprovedError(tokenAmount.toString(), tokenAddress, spenderAddress);
-    }
-    return requiredAmount;
-};
-/**
- * Get an unsigned ERC20 approve transaction
- *
- * @param ownerAddress - The address of the owner of the token
- * @param tokenAmount - The amount of the token to approve
- * @param spenderAddress - The address of the spender
- * @returns - The unsigned ERC20 approve transaction
- */
-const getUnsignedERC20ApproveTransaction = (ownerAddress, tokenAddress, tokenAmount, spenderAddress) => {
-    if (ownerAddress === spenderAddress) {
-        throw new ApproveError('owner and spender addresses are the same');
-    }
-    const erc20Contract = ERC20__factory.createInterface();
-    const callData = erc20Contract.encodeFunctionData('approve', [spenderAddress, tokenAmount]);
-    return {
-        data: callData,
-        to: tokenAddress,
-        value: 0,
-        from: ownerAddress,
-    };
-};
-const prepareApproval = (tradeType, amountSpecified, amountWithSlippage, routingContracts, secondaryFees) => {
-    const amount = tradeType === TradeType.EXACT_INPUT ? amountSpecified : amountWithSlippage;
-    const spender = secondaryFees.length === 0
-        ? routingContracts.peripheryRouterAddress
-        : routingContracts.secondaryFeeAddress;
-    return { spender, amount };
-};
-/**
- * Get an unsigned approval transaction if needed
- *
- * @param provider The provider to use for the call
- * @param ownerAddress The address of the owner of the token
- * @param tokenAddress The address of the token to approve
- * @param tokenAmount The amount of the token to approve
- * @param spenderAddress The address of the spender
- * @returns The unsigned ERC20 approve transaction, or null if no approval is needed
- */
-const getApproveTransaction = async (provider, ownerAddress, tokenAddress, tokenAmount, spenderAddress) => {
-    let amountToApprove;
-    try {
-        amountToApprove = await getERC20AmountToApprove(provider, ownerAddress, tokenAddress, BigNumber$2.from(tokenAmount), spenderAddress);
-    }
-    catch (e) {
-        if (e instanceof AlreadyApprovedError) {
-            // already approved for the required amount, nothing to do
-            return null;
-        }
-        throw e;
-    }
-    return getUnsignedERC20ApproveTransaction(ownerAddress, tokenAddress, amountToApprove, spenderAddress);
-};
-async function getApproveGasEstimate(provider, ownerAddress, spenderAddress, tokenAddress) {
-    const erc20Contract = ERC20__factory.connect(tokenAddress, provider);
-    return await erc20Contract.estimateGas.approve(spenderAddress, ethers.constants.MaxUint256, {
-        from: ownerAddress,
-    });
-}
-const getApproval = async (nativeToken, provider, ownerAddress, tokenAddress, preparedApproval, gasPrice) => {
-    const approveTransaction = await getApproveTransaction(provider, ownerAddress, tokenAddress, preparedApproval.amount, preparedApproval.spender);
-    if (!approveTransaction) {
-        return null;
-    }
-    const gasEstimate = await getApproveGasEstimate(provider, ownerAddress, preparedApproval.spender, tokenAddress);
-    const gasFeeEstimate = gasPrice ? {
-        token: nativeToken,
-        value: calculateGasFee(gasPrice, gasEstimate),
-    } : null;
-    return {
-        transaction: approveTransaction,
-        gasFeeEstimate,
-    };
-};
-
-// slippageToPercent takes the slippage as a percentage (e.g. 0.1) and
-// converts it to the Uniswap equivalent type
-const slippageToFraction = (slippage) => {
-    // If we receive a whole number, we can return slippage/100
-    const noDecimals = slippage.toString().split('.').length === 1;
-    if (noDecimals) {
-        return new Percent(slippage, 100);
-    }
-    // Divide the slippage number by 100 to get the decimal
-    const slippageDecimal = slippage / 100;
-    // Split into two parts by the decimal place
-    const parts = slippageDecimal.toString().split('.');
-    // Get the numerator by adding the two parts together
-    const numerator = parts[0] + parts[1];
-    // Get the denominator by multiplying decimals^10
-    const denominator = 10 ** parts[1].length;
-    return new Percent(numerator, denominator);
-};
-
-function getQuoteAmountFromTradeType(tradeInfo) {
-    if (tradeInfo.tradeType === TradeType.EXACT_INPUT) {
-        return tradeInfo.amountOut;
-    }
-    return tradeInfo.amountIn;
-}
-function applySlippage(tradeType, amount, slippage) {
-    const slippageTolerance = slippageToFraction(slippage);
-    const slippagePlusOne = slippageTolerance.add(1);
-    const maybeInverted = tradeType === TradeType.EXACT_INPUT ? slippagePlusOne.invert() : slippagePlusOne;
-    const amountWithSlippage = maybeInverted.multiply(amount.toString()).quotient;
-    return ethers.BigNumber.from(amountWithSlippage.toString());
-}
-function prepareUserQuote(otherToken, tradeInfo, slippage, fees) {
-    const quote = getQuoteAmountFromTradeType(tradeInfo);
-    const amountWithSlippage = applySlippage(tradeInfo.tradeType, quote.value, slippage);
-    return {
-        amount: quote,
-        amountWithMaxSlippage: {
-            token: otherToken,
-            value: amountWithSlippage,
-        },
-        slippage,
-        fees: fees.withAmounts(),
-    };
-}
-function getOurQuoteReqAmount(amount, fees, tradeType) {
-    if (tradeType === TradeType.EXACT_OUTPUT) {
-        // For an exact output swap, we do not need to subtract fees from the given amount
-        return amount;
-    }
-    fees.addAmount(amount);
-    return fees.amountLessFees();
-}
-
-// 0.1% default slippage
-const DEFAULT_SLIPPAGE = 0.1;
-// 15 minutes from the current Unix time
-const DEFAULT_DEADLINE = Math.floor(Date.now() / 1000) + 60 * 15;
-// most swaps will be able to resolve with 2 hops
-const DEFAULT_MAX_HOPS = 2;
-// after 10 hops, it is very unlikely a route will be available
-const MAX_MAX_HOPS = 10;
-// a max hop of 1 will require a direct swap with no intermediary pools
-const MIN_MAX_HOPS = 1;
-// precision used to calculate percentage from basis points
-const BASIS_POINT_PRECISION = 10000;
-// 10% maximum secondary fee
-const MAX_SECONDARY_FEE_BASIS_POINTS = 10000;
-
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
@@ -15224,40 +15018,246 @@ startTokenIn = tokenIn) => {
     return routes;
 };
 
-class Fees {
-    secondaryFees;
-    amount;
-    constructor(secondaryFees, token) {
-        this.secondaryFees = secondaryFees;
-        this.amount = newAmount(BigNumber$1.from(0), token);
-    }
-    addAmount(amount) {
-        this.amount = addAmount(this.amount, amount);
+/**
+ * Determines whether or not the chain supports EIP-1559 by checking for the existence
+ * of {@link FeeData.maxFeePerGas} and {@link FeeData.maxPriorityFeePerGas}
+ *
+ * @param {FeeData} fee - The fee data for the chain
+ */
+const doesChainSupportEIP1559 = (fee) => {
+    const supportsEIP1559 = !!fee.maxFeePerGas && !!fee.maxPriorityFeePerGas;
+    return supportsEIP1559;
+};
+/**
+ * Fetch the current gas price estimate. Supports both EIP-1559 and non-EIP1559 chains
+ * @param {JsonRpcProvider} provider - The JSON RPC provider used to fetch fee data
+ * @returns {Amount | null} - The gas price in the smallest denomination of the chain's currency,
+ * or null if no gas price is available
+ */
+const fetchGasPrice = async (provider, nativeToken) => {
+    const feeData = await provider.getFeeData().catch(() => null);
+    if (!feeData)
+        return null;
+    if (doesChainSupportEIP1559(feeData)) {
+        return newAmount(feeData.maxFeePerGas.add(feeData.maxPriorityFeePerGas), nativeToken);
     }
-    amountWithFeesApplied() {
-        return addAmount(this.amount, this.total());
+    return feeData.gasPrice ? newAmount(feeData.gasPrice, nativeToken) : null;
+};
+/**
+ * Calculate the gas fee from the gas price and gas units used for the transaction
+ *
+ * @param {Amount} gasPriceInWei - The price of gas
+ * @param {BigNumber} gasUsed - The total gas units that will be used for the transaction
+ * @returns - The cost of the transaction in the gas token's smallest denomination (e.g. WEI)
+ */
+const calculateGasFee = (gasPrice, gasEstimate) => 
+// eslint-disable-next-line implicit-arrow-linebreak
+newAmount(gasEstimate.mul(gasPrice.value), gasPrice.token);
+
+/**
+ * Get the amount of an ERC20 token that needs to be approved by
+ * checking the existing allowance for the spender
+ *
+ * @param provider - The provider to use for the call
+ * @param ownerAddress - The address of the owner of the token
+ * @param tokenAmount  - The amount of the token to approve
+ * @param spenderAddress - The address of the spender
+ * @returns - The amount of the token that needs to be approved
+ */
+const getERC20AmountToApprove = async (provider, ownerAddress, tokenAmount, spenderAddress) => {
+    // create an instance of the ERC20 token contract
+    const erc20Contract = ERC20__factory.connect(tokenAmount.token.address, provider);
+    // get the allowance for the token spender
+    // minimum is 0 - no allowance
+    let allowance;
+    try {
+        allowance = await erc20Contract.allowance(ownerAddress, spenderAddress);
     }
-    amountLessFees() {
-        return subtractAmount(this.amount, this.total());
+    catch (e) {
+        const message = e instanceof Error ? e.message : 'Unknown Error';
+        throw new ApproveError(`failed to get allowance: ${message}`);
     }
-    withAmounts() {
-        return this.secondaryFees.map((fee) => {
-            const feeAmount = this.amount.value
-                .mul(fee.basisPoints)
-                .div(BASIS_POINT_PRECISION);
-            return {
-                ...fee,
-                amount: newAmount(feeAmount, this.amount.token),
-            };
-        });
+    // get the amount that needs to be approved
+    const requiredAmount = tokenAmount.value.sub(allowance);
+    if (requiredAmount.isNegative() || requiredAmount.isZero()) {
+        throw new AlreadyApprovedError(tokenAmount.toString(), tokenAmount.token.address, spenderAddress);
     }
-    total() {
-        let totalFees = newAmount(BigNumber$1.from(0), this.amount.token);
-        for (const fee of this.secondaryFees) {
-            const feeAmount = this.amount.value
-                .mul(fee.basisPoints)
-                .div(BASIS_POINT_PRECISION);
-            totalFees = addAmount(totalFees, newAmount(feeAmount, this.amount.token));
+    return newAmount(requiredAmount, tokenAmount.token);
+};
+/**
+ * Get an unsigned ERC20 approve transaction
+ *
+ * @param ownerAddress - The address of the owner of the token
+ * @param tokenAmount - The amount of the token to approve
+ * @param spenderAddress - The address of the spender
+ * @returns - The unsigned ERC20 approve transaction
+ */
+const getUnsignedERC20ApproveTransaction = (ownerAddress, tokenAmount, spenderAddress) => {
+    if (ownerAddress === spenderAddress) {
+        throw new ApproveError('owner and spender addresses are the same');
+    }
+    const erc20Contract = ERC20__factory.createInterface();
+    const callData = erc20Contract.encodeFunctionData('approve', [spenderAddress, tokenAmount.value]);
+    return {
+        data: callData,
+        to: tokenAmount.token.address,
+        value: 0,
+        from: ownerAddress,
+    };
+};
+const prepareApproval = (tradeType, amountSpecified, amountWithSlippage, routingContracts, secondaryFees) => {
+    const amountOfTokenIn = tradeType === TradeType.EXACT_INPUT ? amountSpecified : amountWithSlippage;
+    const spender = secondaryFees.length === 0
+        ? routingContracts.peripheryRouterAddress
+        : routingContracts.secondaryFeeAddress;
+    return { spender, amount: amountOfTokenIn };
+};
+/**
+ * Get an unsigned approval transaction if needed
+ *
+ * @param provider The provider to use for the call
+ * @param ownerAddress The address of the owner of the token
+ * @param tokenAddress The address of the token to approve
+ * @param tokenAmount The amount of the token to approve
+ * @param spenderAddress The address of the spender
+ * @returns The unsigned ERC20 approve transaction, or null if no approval is needed
+ */
+const getApproveTransaction = async (provider, ownerAddress, tokenAmount, spenderAddress) => {
+    let amountToApprove;
+    try {
+        amountToApprove = await getERC20AmountToApprove(provider, ownerAddress, tokenAmount, spenderAddress);
+    }
+    catch (e) {
+        if (e instanceof AlreadyApprovedError) {
+            // already approved for the required amount, nothing to do
+            return null;
+        }
+        throw e;
+    }
+    return getUnsignedERC20ApproveTransaction(ownerAddress, amountToApprove, spenderAddress);
+};
+async function getApproveGasEstimate(provider, ownerAddress, spenderAddress, tokenAddress) {
+    const erc20Contract = ERC20__factory.connect(tokenAddress, provider);
+    return await erc20Contract.estimateGas.approve(spenderAddress, ethers.constants.MaxUint256, {
+        from: ownerAddress,
+    });
+}
+const getApproval = async (provider, ownerAddress, preparedApproval, gasPrice) => {
+    const approveTransaction = await getApproveTransaction(provider, ownerAddress, preparedApproval.amount, preparedApproval.spender);
+    if (!approveTransaction) {
+        return null;
+    }
+    const gasEstimate = await getApproveGasEstimate(provider, ownerAddress, preparedApproval.spender, preparedApproval.amount.token.address);
+    const gasFeeEstimate = gasPrice ? calculateGasFee(gasPrice, gasEstimate) : null;
+    return {
+        transaction: approveTransaction,
+        gasFeeEstimate,
+    };
+};
+
+// slippageToPercent takes the slippage as a percentage (e.g. 0.1) and
+// converts it to the Uniswap equivalent type
+const slippageToFraction = (slippage) => {
+    // If we receive a whole number, we can return slippage/100
+    const noDecimals = slippage.toString().split('.').length === 1;
+    if (noDecimals) {
+        return new Percent(slippage, 100);
+    }
+    // Divide the slippage number by 100 to get the decimal
+    const slippageDecimal = slippage / 100;
+    // Split into two parts by the decimal place
+    const parts = slippageDecimal.toString().split('.');
+    // Get the numerator by adding the two parts together
+    const numerator = parts[0] + parts[1];
+    // Get the denominator by multiplying decimals^10
+    const denominator = 10 ** parts[1].length;
+    return new Percent(numerator, denominator);
+};
+
+function getQuoteAmountFromTradeType(tradeInfo) {
+    if (tradeInfo.tradeType === TradeType.EXACT_INPUT) {
+        return tradeInfo.amountOut;
+    }
+    return tradeInfo.amountIn;
+}
+function applySlippage(tradeType, amount, slippage) {
+    const slippageTolerance = slippageToFraction(slippage);
+    const slippagePlusOne = slippageTolerance.add(1);
+    const maybeInverted = tradeType === TradeType.EXACT_INPUT ? slippagePlusOne.invert() : slippagePlusOne;
+    const amountWithSlippage = maybeInverted.multiply(amount.toString()).quotient;
+    return ethers.BigNumber.from(amountWithSlippage.toString());
+}
+function prepareUserQuote(otherToken, tradeInfo, slippage, fees) {
+    const quote = getQuoteAmountFromTradeType(tradeInfo);
+    const amountWithSlippage = applySlippage(tradeInfo.tradeType, quote.value, slippage);
+    return {
+        amount: quote,
+        amountWithMaxSlippage: {
+            token: otherToken,
+            value: amountWithSlippage,
+        },
+        slippage,
+        fees: fees.withAmounts(),
+    };
+}
+function getOurQuoteReqAmount(amount, fees, tradeType) {
+    if (tradeType === TradeType.EXACT_OUTPUT) {
+        // For an exact output swap, we do not need to subtract fees from the given amount
+        return amount;
+    }
+    fees.addAmount(amount);
+    return fees.amountLessFees();
+}
+
+// 0.1% default slippage
+const DEFAULT_SLIPPAGE = 0.1;
+// 15 minutes from the current Unix time
+const DEFAULT_DEADLINE = Math.floor(Date.now() / 1000) + 60 * 15;
+// most swaps will be able to resolve with 2 hops
+const DEFAULT_MAX_HOPS = 2;
+// after 10 hops, it is very unlikely a route will be available
+const MAX_MAX_HOPS = 10;
+// a max hop of 1 will require a direct swap with no intermediary pools
+const MIN_MAX_HOPS = 1;
+// precision used to calculate percentage from basis points
+const BASIS_POINT_PRECISION = 10000;
+// 10% maximum secondary fee
+const MAX_SECONDARY_FEE_BASIS_POINTS = 10000;
+
+class Fees {
+    secondaryFees;
+    amount;
+    constructor(secondaryFees, token) {
+        this.secondaryFees = secondaryFees;
+        this.amount = newAmount(BigNumber$1.from(0), token);
+    }
+    addAmount(amount) {
+        this.amount = addAmount(this.amount, amount);
+    }
+    amountWithFeesApplied() {
+        return addAmount(this.amount, this.total());
+    }
+    amountLessFees() {
+        return subtractAmount(this.amount, this.total());
+    }
+    withAmounts() {
+        return this.secondaryFees.map((fee) => {
+            const feeAmount = this.amount.value
+                .mul(fee.basisPoints)
+                .div(BASIS_POINT_PRECISION);
+            return {
+                ...fee,
+                amount: newAmount(feeAmount, this.amount.token),
+            };
+        });
+    }
+    total() {
+        let totalFees = newAmount(BigNumber$1.from(0), this.amount.token);
+        for (const fee of this.secondaryFees) {
+            const feeAmount = this.amount.value
+                .mul(fee.basisPoints)
+                .div(BASIS_POINT_PRECISION);
+            totalFees = addAmount(totalFees, newAmount(feeAmount, this.amount.token));
         }
         return totalFees;
     }
@@ -15371,13 +15371,10 @@ function createSwapParameters(adjustedQuote, fromAddress, slippage, deadline, se
     }
     return createSwapCallParametersWithFees(uncheckedTrade, fromAddress, options, secondaryFees);
 }
-function getSwap(nativeToken, adjustedQuote, fromAddress, slippage, deadline, peripheryRouterAddress, secondaryFeesAddress, gasPrice, secondaryFees) {
+function getSwap(adjustedQuote, fromAddress, slippage, deadline, peripheryRouterAddress, secondaryFeesAddress, gasPrice, secondaryFees) {
     const calldata = createSwapParameters(adjustedQuote, fromAddress, slippage, deadline, secondaryFees);
     // TODO: Add additional gas fee estimates for secondary fees
-    const gasFeeEstimate = gasPrice ? {
-        token: nativeToken,
-        value: calculateGasFee(gasPrice, adjustedQuote.gasEstimate),
-    } : null;
+    const gasFeeEstimate = gasPrice ? calculateGasFee(gasPrice, adjustedQuote.gasEstimate) : null;
     return {
         transaction: {
             data: calldata,
@@ -15561,14 +15558,14 @@ class Exchange {
         // get quote and gas details
         const [ourQuote, gasPrice] = await Promise.all([
             this.router.findOptimalRoute(ourQuoteReqAmount, otherToken, tradeType, maxHops),
-            fetchGasPrice(this.provider),
+            fetchGasPrice(this.provider, this.nativeToken),
         ]);
         const adjustedQuote = prepareSwap(ourQuote, amountSpecified, fees);
-        const swap = getSwap(this.nativeToken, adjustedQuote, fromAddress, slippagePercent, deadline, this.router.routingContracts.peripheryRouterAddress, this.router.routingContracts.secondaryFeeAddress, gasPrice, secondaryFees);
+        const swap = getSwap(adjustedQuote, fromAddress, slippagePercent, deadline, this.router.routingContracts.peripheryRouterAddress, this.router.routingContracts.secondaryFeeAddress, gasPrice, secondaryFees);
         const userQuote = prepareUserQuote(otherToken, adjustedQuote, slippagePercent, fees);
-        const preparedApproval = prepareApproval(tradeType, amount, userQuote.amountWithMaxSlippage.value, this.router.routingContracts, secondaryFees);
-        // we always use the tokenIn address because we are always selling the tokenIn
-        const approval = await getApproval(this.nativeToken, this.provider, fromAddress, tokenInAddress, preparedApproval, gasPrice);
+        const preparedApproval = prepareApproval(tradeType, amountSpecified, userQuote.amountWithMaxSlippage, this.router.routingContracts, secondaryFees);
+        // preparedApproval always uses the tokenIn address because we are always selling the tokenIn
+        const approval = await getApproval(this.provider, fromAddress, preparedApproval, gasPrice);
         return {
             approval,
             swap,
@@ -15888,7 +15885,7 @@ const getRequestBody = (options) => {
     return undefined;
 };
 const sendRequest = async (config, options, url, body, formData, headers, onCancel) => {
-    const source = axios.CancelToken.source();
+    const source = $7v2Z6$axios.CancelToken.source();
     const requestConfig = {
         url,
         headers,
@@ -15899,7 +15896,7 @@ const sendRequest = async (config, options, url, body, formData, headers, onCanc
     };
     onCancel(() => source.cancel('The user aborted a request.'));
     try {
-        return await axios.request(requestConfig);
+        return await $7v2Z6$axios.request(requestConfig);
     }
     catch (error) {
         const axiosError = error;
@@ -16093,6 +16090,54 @@ class OrdersService {
             },
         });
     }
+    /**
+     * List all trades
+     * List all trades
+     * @returns ListTradeResult OK response.
+     * @throws ApiError
+     */
+    listTrades({ chainName, accountAddress, pageSize, sortBy, sortDirection, pageCursor, }) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/v1/chains/{chain_name}/trades',
+            path: {
+                'chain_name': chainName,
+            },
+            query: {
+                'account_address': accountAddress,
+                'page_size': pageSize,
+                'sort_by': sortBy,
+                'sort_direction': sortDirection,
+                'page_cursor': pageCursor,
+            },
+            errors: {
+                400: `Bad Request (400)`,
+                404: `The specified resource was not found (404)`,
+                500: `Internal Server Error (500)`,
+            },
+        });
+    }
+    /**
+     * Get a single trade by ID
+     * Get a single trade by ID
+     * @returns TradeResult OK response.
+     * @throws ApiError
+     */
+    getTrade({ chainName, tradeId, }) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/v1/chains/{chain_name}/trades/{trade_id}',
+            path: {
+                'chain_name': chainName,
+                'trade_id': tradeId,
+            },
+            errors: {
+                400: `Bad Request (400)`,
+                404: `The specified resource was not found (404)`,
+                500: `Internal Server Error (500)`,
+            },
+        });
+    }
 }
 
 class OrderBookClient {
@@ -16229,6 +16274,57 @@ function mapFromOpenApiOrder(order) {
         updateTime: order.update_time,
     };
 }
+function mapFromOpenApiTrade(trade) {
+    const buyItems = trade.buy.map((item) => {
+        if (item.item_type === 'ERC20') {
+            return {
+                type: 'ERC20',
+                contractAddress: item.contract_address,
+                amount: item.start_amount,
+            };
+        }
+        if (item.item_type === 'NATIVE') {
+            return {
+                type: 'NATIVE',
+                amount: item.start_amount,
+            };
+        }
+        throw new Error('Buy items must be either ERC20 or NATIVE');
+    });
+    const sellItems = trade.sell.map((item) => {
+        if (item.item_type === 'ERC721') {
+            return {
+                type: 'ERC721',
+                contractAddress: item.contract_address,
+                tokenId: item.token_id,
+            };
+        }
+        throw new Error('Sell items must ERC721');
+    });
+    return {
+        id: trade.id,
+        orderId: trade.order_id,
+        buy: buyItems,
+        sell: sellItems,
+        buyerFees: trade.buyer_fees.map((fee) => ({
+            amount: fee.amount,
+            recipient: fee.recipient,
+            type: fee.fee_type,
+        })),
+        chain: trade.chain,
+        indexedAt: trade.indexed_at,
+        blockchainMetadata: {
+            blockNumber: trade.blockchain_metadata.block_number,
+            logIndex: trade.blockchain_metadata.log_index,
+            transactionHash: trade.blockchain_metadata.transaction_hash,
+            transactionIndex: trade.blockchain_metadata.transaction_index,
+        },
+        buyerAddress: trade.buyer_address,
+        makerAddress: trade.maker_address,
+        sellerAddress: trade.seller_address,
+        takerAddress: trade.taker_address,
+    };
+}
 function mapFromOpenApiPage(page) {
     return {
         nextCursor: page.next_cursor,
@@ -16558,12 +16654,24 @@ class ImmutableApiClient {
             listingId,
         });
     }
+    async getTrade(tradeId) {
+        return this.orderbookService.getTrade({
+            chainName: this.chainName,
+            tradeId,
+        });
+    }
     async listListings(listOrderParams) {
         return this.orderbookService.listListings({
             chainName: this.chainName,
             ...listOrderParams,
         });
     }
+    async listTrades(listTradesParams) {
+        return this.orderbookService.listTrades({
+            chainName: this.chainName,
+            ...listTradesParams,
+        });
+    }
     async createListing({ orderHash, orderComponents, orderSignature, makerFee, }) {
         if (orderComponents.offer.length !== 1) {
             throw new Error('Only one item can be listed at a time');
@@ -16729,6 +16837,17 @@ class Orderbook {
             result: mapFromOpenApiOrder(apiListing.result),
         };
     }
+    /**
+     * Get a trade by ID
+     * @param {string} tradeId - The tradeId to find.
+     * @return {TradeResult} The returned order result.
+     */
+    async getTrade(tradeId) {
+        const apiListing = await this.apiClient.getTrade(tradeId);
+        return {
+            result: mapFromOpenApiTrade(apiListing.result),
+        };
+    }
     /**
      * List orders. This method is used to get a list of orders filtered by conditions specified
      * in the params object.
@@ -16742,6 +16861,19 @@ class Orderbook {
             result: apiListings.result.map(mapFromOpenApiOrder),
         };
     }
+    /**
+     * List trades. This method is used to get a list of trades filtered by conditions specified
+     * in the params object
+     * @param {ListTradesParams} listTradesParams - Filtering, ordering and page parameters.
+     * @return {ListTradesResult} The paged trades.
+     */
+    async listTrades(listTradesParams) {
+        const apiListings = await this.apiClient.listTrades(listTradesParams);
+        return {
+            page: mapFromOpenApiPage(apiListings.page),
+            result: apiListings.result.map(mapFromOpenApiTrade),
+        };
+    }
     /**
      * Get required transactions and messages for signing prior to creating a listing
      * through the createListing method
@@ -16842,6 +16974,18 @@ const constants = {
 
 
 
+var $aa144554f9ef124b$export$226b052ecb8ca80;
+(function(BuyStatusType) {
+    BuyStatusType["SUCCESS"] = "SUCCESS";
+    BuyStatusType["FAILED"] = "FAILED";
+})($aa144554f9ef124b$export$226b052ecb8ca80 || ($aa144554f9ef124b$export$226b052ecb8ca80 = {}));
+
+
+var $1e6b81bbd98b3a91$export$c0189a8c30039654;
+(function(CancelStatusType) {
+    CancelStatusType["SUCCESS"] = "SUCCESS";
+    CancelStatusType["FAILED"] = "FAILED";
+})($1e6b81bbd98b3a91$export$c0189a8c30039654 || ($1e6b81bbd98b3a91$export$c0189a8c30039654 = {}));
 
 
 /**
@@ -16889,6 +17033,13 @@ var $a47e48dd2c04791b$export$1f05a55fe0680cc7;
 
 
 
+var $c2874b006e92b115$export$a9780122aaa0801a;
+(function(SellStatusType) {
+    SellStatusType["SUCCESS"] = "SUCCESS";
+    SellStatusType["FAILED"] = "FAILED";
+})($c2874b006e92b115$export$a9780122aaa0801a || ($c2874b006e92b115$export$a9780122aaa0801a = {}));
+
+
 var $08d5ddc39acd6833$export$fd9b17d87f4121d2;
 (function(TokenFilterTypes) {
     TokenFilterTypes["ALL"] = "all";
@@ -16939,14 +17090,26 @@ const $e768639828688ca3$export$44dde05038008549 = {
 const $d85ad1457a3f1a83$export$7d3a9eeba384fa59 = "development";
 const $d85ad1457a3f1a83$export$b80040cb173ba6e9 = "0x0000000000000000000000000000000000001010";
 const $d85ad1457a3f1a83$export$903389470ba9433c = 18;
+const $d85ad1457a3f1a83$var$ZKEVM_NATIVE_TOKEN = {
+    name: "IMX",
+    symbol: "IMX",
+    decimals: $d85ad1457a3f1a83$export$903389470ba9433c,
+    address: $d85ad1457a3f1a83$export$b80040cb173ba6e9
+};
 const $d85ad1457a3f1a83$export$161d4a74df65fc08 = {
     [$d85ad1457a3f1a83$export$7d3a9eeba384fa59]: "https://checkout-api.dev.immutable.com",
     [(Environment$1).SANDBOX]: "https://checkout-api.sandbox.immutable.com",
     [(Environment$1).PRODUCTION]: "https://checkout-api.immutable.com"
 };
-({
-    [($0472f23319457bfb$export$c06e1e7429de6283).IMTBL_ZKEVM_TESTNET]: "https://explorer.testnet.immutable.com"
-});
+const $d85ad1457a3f1a83$export$72176e2233d7d5d = true;
+const $d85ad1457a3f1a83$export$566b5975cc83d6b4 = true;
+const $d85ad1457a3f1a83$export$261cde2078dba35b = true;
+const $d85ad1457a3f1a83$export$fc55ed5a42b458ba = {
+    [($0472f23319457bfb$export$c06e1e7429de6283).IMTBL_ZKEVM_TESTNET]: {
+        url: "https://explorer.testnet.immutable.com",
+        nativeToken: $d85ad1457a3f1a83$var$ZKEVM_NATIVE_TOKEN
+    }
+};
 const $d85ad1457a3f1a83$export$6f24f3cef7d501c4 = new Map([
     [
         ($0472f23319457bfb$export$c06e1e7429de6283).ETHEREUM,
@@ -16974,12 +17137,7 @@ const $d85ad1457a3f1a83$export$6f24f3cef7d501c4 = new Map([
             rpcUrls: [
                 "https://rpc.immutable.com"
             ],
-            nativeCurrency: {
-                name: "IMX",
-                symbol: "IMX",
-                decimals: 18,
-                address: $d85ad1457a3f1a83$export$b80040cb173ba6e9
-            }
+            nativeCurrency: $d85ad1457a3f1a83$var$ZKEVM_NATIVE_TOKEN
         }
     ]
 ]);
@@ -17010,12 +17168,7 @@ const $d85ad1457a3f1a83$export$3e81fc0987227f10 = new Map([
             rpcUrls: [
                 "https://rpc.testnet.immutable.com"
             ],
-            nativeCurrency: {
-                name: "IMX",
-                symbol: "IMX",
-                decimals: 18,
-                address: $d85ad1457a3f1a83$export$b80040cb173ba6e9
-            }
+            nativeCurrency: $d85ad1457a3f1a83$var$ZKEVM_NATIVE_TOKEN
         }
     ]
 ]);
@@ -17046,12 +17199,7 @@ const $d85ad1457a3f1a83$export$3a9ebede6a150274 = new Map([
             rpcUrls: [
                 "https://rpc.dev.immutable.com"
             ],
-            nativeCurrency: {
-                name: "IMX",
-                symbol: "IMX",
-                decimals: 18,
-                address: $d85ad1457a3f1a83$export$b80040cb173ba6e9
-            }
+            nativeCurrency: $d85ad1457a3f1a83$var$ZKEVM_NATIVE_TOKEN
         }
     ]
 ]);
@@ -17279,6 +17427,7 @@ var $4b58188d47aafe8d$export$537fa3efd10ed435;
     CheckoutErrorType["DEFAULT_PROVIDER_ERROR"] = "DEFAULT_PROVIDER_ERROR";
     CheckoutErrorType["CONNECT_PROVIDER_ERROR"] = "CONNECT_PROVIDER_ERROR";
     CheckoutErrorType["GET_BALANCE_ERROR"] = "GET_BALANCE_ERROR";
+    CheckoutErrorType["GET_INDEXER_BALANCE_ERROR"] = "GET_INDEXER_BALANCE_ERROR";
     CheckoutErrorType["GET_ERC20_BALANCE_ERROR"] = "GET_ERC20_BALANCE_ERROR";
     CheckoutErrorType["GET_ERC721_BALANCE_ERROR"] = "GET_ERC721_BALANCE_ERROR";
     CheckoutErrorType["GET_NETWORK_INFO_ERROR"] = "GET_NETWORK_INFO_ERROR";
@@ -17294,9 +17443,15 @@ var $4b58188d47aafe8d$export$537fa3efd10ed435;
     CheckoutErrorType["UNSUPPORTED_TOKEN_TYPE_ERROR"] = "UNSUPPORTED_TOKEN_TYPE_ERROR";
     CheckoutErrorType["UNSUPPORTED_BALANCE_REQUIREMENT_ERROR"] = "UNSUPPORTED_BALANCE_REQUIREMENT_ERROR";
     CheckoutErrorType["GET_ORDER_LISTING_ERROR"] = "GET_ORDER_LISTING_ERROR";
+    CheckoutErrorType["CANCEL_ORDER_LISTING_ERROR"] = "CANCEL_ORDER_LISTING_ERROR";
+    CheckoutErrorType["PREPARE_ORDER_LISTING_ERROR"] = "PREPARE_ORDER_LISTING_ERROR";
+    CheckoutErrorType["CREATE_ORDER_LISTING_ERROR"] = "CREATE_ORDER_LISTING_ERROR";
     CheckoutErrorType["SWITCH_NETWORK_UNSUPPORTED"] = "SWITCH_NETWORK_UNSUPPORTED";
     CheckoutErrorType["GET_ERC20_ALLOWANCE_ERROR"] = "GET_ERC20_ALLOWANCE_ERROR";
     CheckoutErrorType["GET_ERC721_ALLOWANCE_ERROR"] = "GET_ERC721_ALLOWANCE_ERROR";
+    CheckoutErrorType["EXECUTE_APPROVAL_TRANSACTION_ERROR"] = "EXECUTE_APPROVAL_TRANSACTION_ERROR";
+    CheckoutErrorType["EXECUTE_FULFILMENT_TRANSACTION_ERROR"] = "EXECUTE_FULFILMENT_TRANSACTION_ERROR";
+    CheckoutErrorType["SIGN_MESSAGE_ERROR"] = "SIGN_MESSAGE_ERROR";
 })($a8bc256d81a5e2c1$export$e3dc0620abde7f5a || ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a = {}));
 class $a8bc256d81a5e2c1$export$b722478a3cbfa3bc extends Error {
     message;
@@ -17484,7 +17639,7 @@ const $efe60cea83bfc4e8$export$473cec51305fdae8 = async (config, { type: type =
         case ($08d5ddc39acd6833$export$fd9b17d87f4121d2).BRIDGE:
         case ($08d5ddc39acd6833$export$fd9b17d87f4121d2).ALL:
         default:
-            tokens = await config.remote.getTokens(chainId);
+            tokens = (await config.remote.getTokensConfig(chainId)).allowed;
     }
     if (!exclude || exclude?.length === 0) return {
         tokens: tokens
@@ -17497,6 +17652,141 @@ const $efe60cea83bfc4e8$export$473cec51305fdae8 = async (config, { type: type =
 
 
 
+
+
+const $fd8a8472dcc3ec2b$var$CACHE_DATA_TTL = 60; // seconds
+class $fd8a8472dcc3ec2b$export$ef140a6b05dfc786 {
+    url;
+    nativeToken;
+    ttl;
+    chainId;
+    cacheMap;
+    static async makeHttpRequest(url) {
+        return ($7v2Z6$axios).get(url);
+    }
+    setCache(key, data) {
+        this.cacheMap[key] = {
+            data: data,
+            ttl: new Date().getTime() + this.ttl * 1000
+        };
+    }
+    getCache(key) {
+        const d = this.cacheMap[key];
+        if (!d || d.ttl <= new Date().getTime()) return null;
+        return d.data;
+    }
+    /**
+   * Blockscout constructor
+   * @param chainId target chain
+   * @param ttl cache TTL
+   */ constructor(params){
+        this.chainId = params.chainId;
+        this.url = ($d85ad1457a3f1a83$export$fc55ed5a42b458ba)[this.chainId].url;
+        const native = ($d85ad1457a3f1a83$export$fc55ed5a42b458ba)[this.chainId].nativeToken;
+        this.nativeToken = {
+            address: native.address ?? "",
+            decimals: native.decimals.toString(),
+            name: native.name,
+            symbol: native.symbol
+        };
+        this.cacheMap = {};
+        this.ttl = params.ttl !== undefined ? params.ttl : $fd8a8472dcc3ec2b$var$CACHE_DATA_TTL;
+    }
+    /**
+   * isChainSupported verifies if the chain is supported by Blockscout
+   * @param chainId
+   */ static isChainSupported = (chainId)=>Boolean(($d85ad1457a3f1a83$export$fc55ed5a42b458ba)[chainId]);
+    /**
+   * isBlockscoutError verifies if the error is a Blockscout client error
+   * @param err error to evaluate
+   */ static isBlockscoutError = (err)=>"code" in err;
+    /**
+   * getTokensByWalletAddress fetches the list of tokens (by type) owned by the wallet address.
+   * @param walletAddress wallet address
+   * @param tokenType token type
+   * @param nextPage parameters for the next page, to be provided alongside walletAddress and tokenType
+   * @returns list of tokens given the wallet address and the token types
+   */ async getTokensByWalletAddress(params) {
+        try {
+            let url = `${this.url}/api/v2/addresses/${params.walletAddress}/tokens?type=${params.tokenType}`;
+            if (params.nextPage) url += `&${new URLSearchParams(params.nextPage)}`;
+            // Cache response data to prevent unnecessary requests
+            const cached = this.getCache(url);
+            if (cached && cached.status < 400) return Promise.resolve(cached.data);
+            const response = await $fd8a8472dcc3ec2b$export$ef140a6b05dfc786.makeHttpRequest(url);
+            if (response.status >= 400) return Promise.reject({
+                code: response.status,
+                message: response.statusText
+            });
+            // To get around an issue with native tokens being an ERC-20, there is the need
+            // to remove IMX from `resp` and add it back in using getNativeTokenByWalletAddress.
+            // This has affected some of the early wallets, and it might not be an issue in mainnet
+            // however, let's enforce it.
+            const data = {
+                items: response.data?.items?.filter((token)=>token.token.address && token.token.address !== this.nativeToken.address),
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                next_page_params: response.data?.next_page_params
+            };
+            this.setCache(url, data);
+            return Promise.resolve(data);
+        } catch (err) {
+            let code = (HttpStatusCode).InternalServerError;
+            let message = "InternalServerError";
+            if (($7v2Z6$axios).isAxiosError(err)) {
+                code = err.response?.status || code;
+                message = err.message;
+            }
+            return Promise.reject({
+                code: code,
+                message: message
+            });
+        }
+    }
+    /**
+   * getNativeTokenByWalletAddress fetches the native token owned by the wallet address.
+   * @param walletAddress wallet address
+   * @returns list of tokens given the wallet address and the token types
+   */ async getNativeTokenByWalletAddress(params) {
+        try {
+            const url = `${this.url}/api/v2/addresses/${params.walletAddress}`;
+            // Cache response data to prevent unnecessary requests
+            const cached = this.getCache(url);
+            if (cached && cached.status < 400) return Promise.resolve(cached.data);
+            const response = await $fd8a8472dcc3ec2b$export$ef140a6b05dfc786.makeHttpRequest(url);
+            if (response.status >= 400) return Promise.reject({
+                code: response.status,
+                message: response.statusText
+            });
+            const data = {
+                token: this.nativeToken,
+                value: response.data.coin_balance
+            };
+            this.setCache(url, data);
+            return Promise.resolve(data);
+        } catch (err) {
+            let code = (HttpStatusCode).InternalServerError;
+            let message = "InternalServerError";
+            if (($7v2Z6$axios).isAxiosError(err)) {
+                code = err.response?.status || code;
+                message = err.message;
+            }
+            return Promise.reject({
+                code: code,
+                message: message
+            });
+        }
+    }
+}
+
+
+/* eslint @typescript-eslint/naming-convention: off */ var $887a00f8f72d61f0$export$5bd1ea2b3d18210;
+(function(BlockscoutTokenType) {
+    BlockscoutTokenType["ERC20"] = "ERC-20";
+})($887a00f8f72d61f0$export$5bd1ea2b3d18210 || ($887a00f8f72d61f0$export$5bd1ea2b3d18210 = {}));
+
+
+
+
 const $1564e43dde50bb61$export$df96cd8d56be0ab1 = async (config, web3Provider, walletAddress)=>await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
         const networkInfo = await ($de192de6ef100f9f$export$79f13b4cfaaf0d09)(config, web3Provider);
         if (!networkInfo.isSupported) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`Chain:${networkInfo.chainId} is not a supported chain`, ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).CHAIN_NOT_SUPPORTED_ERROR, {
@@ -17536,6 +17826,65 @@ async function $1564e43dde50bb61$export$60e0fe116a0e6ed0(web3Provider, walletAdd
         type: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_ERC20_BALANCE_ERROR
     });
 }
+// Blockscout client singleton
+let $1564e43dde50bb61$var$blockscoutClient;
+const $1564e43dde50bb61$export$8c978679845804d4 = async (walletAddress, chainId, rename)=>{
+    // Shuffle the mapping of the tokens configuration so it is a hashmap
+    // for faster access to tokens config objects.
+    const mapRename = Object.assign({}, ...rename.map((t)=>({
+            [t.address || ""]: t
+        })));
+    // Ensure singleton is present and match the selected chain
+    if (!$1564e43dde50bb61$var$blockscoutClient || $1564e43dde50bb61$var$blockscoutClient.chainId !== chainId) $1564e43dde50bb61$var$blockscoutClient = new ($fd8a8472dcc3ec2b$export$ef140a6b05dfc786)({
+        chainId: chainId
+    });
+    // Hold the items in an array for post-fetching processing
+    const items = [];
+    const tokenType = ($887a00f8f72d61f0$export$5bd1ea2b3d18210).ERC20;
+    // Given that the widgets aren't yet designed to support pagination,
+    // fetch all the possible tokens associated to a given wallet address.
+    let resp;
+    try {
+        do {
+            // eslint-disable-next-line no-await-in-loop
+            resp = await $1564e43dde50bb61$var$blockscoutClient.getTokensByWalletAddress({
+                walletAddress: walletAddress,
+                tokenType: tokenType,
+                nextPage: resp?.next_page_params
+            });
+            items.push(...resp.items);
+        }while (resp.next_page_params);
+    } catch (err) {
+        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(err.message || "InternalServerError | getTokensByWalletAddress", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_INDEXER_BALANCE_ERROR, err);
+    }
+    try {
+        const respNative = await $1564e43dde50bb61$var$blockscoutClient.getNativeTokenByWalletAddress({
+            walletAddress: walletAddress
+        });
+        items.push(respNative);
+    } catch (err) {
+        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(err.message || "InternalServerError | getNativeTokenByWalletAddress", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_INDEXER_BALANCE_ERROR, err);
+    }
+    return {
+        balances: items.map((item)=>{
+            const tokenData = item.token || {};
+            const balance = (BigNumber$1).from(item.value);
+            const renamed = mapRename[tokenData.address] || {};
+            const token = {
+                ...tokenData,
+                name: renamed.name ?? tokenData.name,
+                symbol: renamed.symbol ?? tokenData.symbol,
+                decimals: parseInt(tokenData.decimals, 10)
+            };
+            const formattedBalance = (utils).formatUnits(item.value, token.decimals);
+            return {
+                balance: balance,
+                formattedBalance: formattedBalance,
+                token: token
+            };
+        })
+    };
+};
 const $1564e43dde50bb61$export$a3238cee431627c6 = async (config, web3Provider, walletAddress, tokens)=>{
     const allBalancePromises = [];
     tokens.forEach((token)=>{
@@ -17544,7 +17893,7 @@ const $1564e43dde50bb61$export$a3238cee431627c6 = async (config, web3Provider, w
         else allBalancePromises.push($1564e43dde50bb61$export$60e0fe116a0e6ed0(web3Provider, walletAddress, token.address));
     });
     const balanceResults = await Promise.allSettled(allBalancePromises);
-    const balances = balanceResults.filter((result)=>result.status === "fulfilled").map((fulfilledResult)=>fulfilledResult.value);
+    const balances = balanceResults.filter((result)=>result.status === "fulfilled").map((result)=>result.value);
     return {
         balances: balances
     };
@@ -17554,6 +17903,20 @@ const $1564e43dde50bb61$export$fee49741664a4d7e = async (config, web3Provider, w
         type: ($08d5ddc39acd6833$export$fd9b17d87f4121d2).ALL,
         chainId: chainId
     });
+    // In order to prevent unnecessary RPC calls
+    // let's use the Indexer if available for the
+    // given chain.
+    let flag = false;
+    try {
+        flag = (await config.remote.getTokensConfig(chainId)).blockscout || flag;
+    } catch (err) {
+        // eslint-disable-next-line no-console
+        console.error(err);
+    }
+    if (flag && ($fd8a8472dcc3ec2b$export$ef140a6b05dfc786).isChainSupported(chainId)) return await $1564e43dde50bb61$export$8c978679845804d4(walletAddress, chainId, tokens);
+    // This fallback to use ERC20s calls which is a best effort solution
+    // Fails in fetching data from the RCP calls might result in some
+    // missing data.
     return await $1564e43dde50bb61$export$a3238cee431627c6(config, web3Provider, walletAddress, tokens);
 };
 
@@ -17822,7 +18185,7 @@ class $a492ee374ae7b613$export$d902b56530cd5f87 {
     static async makeHttpRequest(url) {
         let response;
         try {
-            response = await (0, axios).get(url);
+            response = await (0, $7v2Z6$axios).get(url);
         } catch (error) {
             throw new Error(`Error fetching from api: ${error.message}`);
         }
@@ -17852,10 +18215,10 @@ class $a492ee374ae7b613$export$d902b56530cd5f87 {
         if (!key) return config;
         return config[key];
     }
-    async getTokens(chainId) {
+    async getTokensConfig(chainId) {
         const config = await this.loadConfigTokens();
-        if (!config) return [];
-        return config[chainId]?.allowed ?? [];
+        if (!config || !config[chainId]) return {};
+        return config[chainId] ?? [];
     }
 }
 
@@ -17889,6 +18252,9 @@ class $4013c5c91bb535f6$export$4823433c4a67bbc6 {
     // Environment.DEVELOPMENT
     isDevelopment = false;
     isProduction;
+    isOnRampEnabled;
+    isSwapEnabled;
+    isBridgeEnabled;
     remote;
     environment;
     networkMap;
@@ -17897,6 +18263,9 @@ class $4013c5c91bb535f6$export$4823433c4a67bbc6 {
         this.environment = config.baseConfig.environment;
         // Developer mode will super set any environment configuration
         this.isProduction = !this.isDevelopment && this.environment === (Environment$1).PRODUCTION;
+        this.isOnRampEnabled = config.isOnRampEnabled ?? ($d85ad1457a3f1a83$export$72176e2233d7d5d);
+        this.isSwapEnabled = config.isSwapEnabled ?? ($d85ad1457a3f1a83$export$566b5975cc83d6b4);
+        this.isBridgeEnabled = config.isBridgeEnabled ?? ($d85ad1457a3f1a83$export$261cde2078dba35b);
         this.networkMap = $4013c5c91bb535f6$var$networkMap(this.isProduction, this.isDevelopment);
         this.remote = new ($a492ee374ae7b613$export$d902b56530cd5f87)({
             isDevelopment: this.isDevelopment,
@@ -18008,6 +18377,7 @@ async function $2e7bf45a7c9a9570$export$942c8de7174809fc(params, readOnlyProvide
 
 
 
+
 const $ddc6bcd0896481e5$export$2fbfa41a4de56a89 = (erc20allowances, erc721allowances)=>{
     const aggregatedAllowances = [];
     if (!erc20allowances.sufficient) {
@@ -18178,7 +18548,9 @@ const $35c3fc7013888ba5$export$90366d6b714c6f69 = async (provider, ownerAddress,
         return await contract.isApprovedForAll(ownerAddress, spenderAddress);
     } catch (err) {
         throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Failed to check approval for all ERC721s of collection", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_ERC721_ALLOWANCE_ERROR, {
-            contractAddress: contractAddress
+            ownerAddress: ownerAddress,
+            contractAddress: contractAddress,
+            spenderAddress: spenderAddress
         });
     }
 };
@@ -18190,7 +18562,10 @@ const $35c3fc7013888ba5$export$ebb2a35f2b4cf5f6 = async (provider, ownerAddress,
         return transaction;
     } catch (err) {
         throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Failed to get the approval transaction for ERC721", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_ERC721_ALLOWANCE_ERROR, {
-            contractAddress: contractAddress
+            id: id.toString(),
+            contractAddress: contractAddress,
+            spenderAddress: spenderAddress,
+            ownerAddress: ownerAddress
         });
     }
 };
@@ -18200,6 +18575,7 @@ const $35c3fc7013888ba5$export$c4605a8dd415eeea = async (provider, contractAddre
         return await contract.getApproved(id);
     } catch (err) {
         throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Failed to get approved address for ERC721", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_ERC721_ALLOWANCE_ERROR, {
+            id: id.toString(),
             contractAddress: contractAddress
         });
     }
@@ -18649,6 +19025,164 @@ const $7d1bfafb81e64d74$export$3a4140bd9e983e4e = async (provider, insufficientI
 
 
 
+const $1fda5c40669a566d$export$1fac8e857d728583 = async ()=>true;
+const $1fda5c40669a566d$export$2e83e9eeaf217e20 = async ()=>true;
+
+
+const $7f2e17f026d4fc8d$var$isPassportProvider = (provider)=>(provider.provider?.isPassport === true) ?? false;
+const $7f2e17f026d4fc8d$export$f1ca3744c025ab81 = async (config, provider)=>{
+    const availableRoutingOptions = {
+        onRamp: config.isOnRampEnabled,
+        swap: config.isSwapEnabled,
+        bridge: config.isBridgeEnabled
+    };
+    // Geo-blocking checks
+    const geoBlockingChecks = [];
+    if (availableRoutingOptions.onRamp) geoBlockingChecks.push({
+        id: "onRamp",
+        promise: ($1fda5c40669a566d$export$1fac8e857d728583)()
+    });
+    if (availableRoutingOptions.swap) geoBlockingChecks.push({
+        id: "swap",
+        promise: ($1fda5c40669a566d$export$2e83e9eeaf217e20)()
+    });
+    if (geoBlockingChecks.length > 0) {
+        const promises = geoBlockingChecks.map((geoBlockingCheck)=>geoBlockingCheck.promise);
+        const geoBlockingStatus = await Promise.allSettled(promises);
+        geoBlockingStatus.forEach((result, index)=>{
+            const statusId = geoBlockingChecks[index].id;
+            availableRoutingOptions[statusId] = availableRoutingOptions[statusId] && result.status === "fulfilled" && !result.value;
+        });
+    }
+    // Bridge not available if passport provider
+    availableRoutingOptions.bridge = availableRoutingOptions.bridge && !$7f2e17f026d4fc8d$var$isPassportProvider(provider);
+    return availableRoutingOptions;
+};
+
+
+
+
+
+
+
+
+
+async function $0e0060cb42e136d2$export$339cb2be73677b30(config, existingReadOnlyProviders) {
+    if (config.isProduction && existingReadOnlyProviders?.has(($0472f23319457bfb$export$c06e1e7429de6283).ETHEREUM)) return existingReadOnlyProviders;
+    if (existingReadOnlyProviders?.has(($0472f23319457bfb$export$c06e1e7429de6283).SEPOLIA)) return existingReadOnlyProviders;
+    const readOnlyProviders = new Map();
+    const allowedNetworks = await $de192de6ef100f9f$export$3043f6442a9ef563(config, {
+        type: ($a47e48dd2c04791b$export$1f05a55fe0680cc7).ALL
+    });
+    allowedNetworks.networks.forEach((networkInfo)=>{
+        const rpcUrl = config.networkMap.get(networkInfo.chainId)?.rpcUrls[0];
+        const provider = new (JsonRpcProvider)(rpcUrl);
+        readOnlyProviders.set(networkInfo.chainId, provider);
+    });
+    return readOnlyProviders;
+}
+
+
+
+
+const $33acec7b4a26c053$export$23ddeb2642d2f9d = async (config, ownerAddress, availableRoutingOptions)=>{
+    const chainBalances = new Map();
+    const chainBalancePromises = new Map();
+    let readOnlyProviders = new Map();
+    let providerError;
+    try {
+        readOnlyProviders = await (0, $0e0060cb42e136d2$export$339cb2be73677b30)(config);
+    } catch (error) {
+        providerError = error;
+    }
+    if (readOnlyProviders.size === 0) {
+        const noProviderResult = {
+            success: false,
+            error: providerError || new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Provider failed", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_ERROR),
+            balances: []
+        };
+        chainBalances.set(($4013c5c91bb535f6$export$9b794d067cdd1af6)(config), noProviderResult);
+        chainBalances.set(($4013c5c91bb535f6$export$c9af4e4b001c6476)(config), noProviderResult);
+        return chainBalances;
+    }
+    // Only get L1 Balances if we can bridge
+    if (availableRoutingOptions.bridge) {
+        const chainId = ($4013c5c91bb535f6$export$9b794d067cdd1af6)(config);
+        if (readOnlyProviders.has(chainId)) chainBalancePromises.set(chainId, ($1564e43dde50bb61$export$fee49741664a4d7e)(config, readOnlyProviders.get(chainId), ownerAddress, chainId));
+        else chainBalances.set(($4013c5c91bb535f6$export$9b794d067cdd1af6)(config), {
+            success: false,
+            error: new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`No L1 provider available for ${chainId}`, ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_ERROR),
+            balances: []
+        });
+    }
+    const chainId = ($4013c5c91bb535f6$export$c9af4e4b001c6476)(config);
+    if (readOnlyProviders.has(chainId)) chainBalancePromises.set(chainId, ($1564e43dde50bb61$export$fee49741664a4d7e)(config, readOnlyProviders.get(chainId), ownerAddress, chainId));
+    else chainBalances.set(($4013c5c91bb535f6$export$c9af4e4b001c6476)(config), {
+        success: false,
+        error: new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`No L2 provider available for ${chainId}`, ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_ERROR),
+        balances: []
+    });
+    if (chainBalancePromises.size > 0) {
+        const chainIds = Array.from(chainBalancePromises.keys());
+        const balanceSettledResults = await Promise.allSettled(chainBalancePromises.values());
+        balanceSettledResults.forEach((balanceSettledResult, index)=>{
+            const balanceChainId = chainIds[index];
+            if (balanceSettledResult.status === "fulfilled") chainBalances.set(balanceChainId, {
+                success: true,
+                balances: balanceSettledResult.value.balances
+            });
+            else chainBalances.set(balanceChainId, {
+                success: false,
+                error: new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`Error getting ${chainId} balances`, ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_BALANCE_ERROR),
+                balances: []
+            });
+        });
+    }
+    return chainBalances;
+};
+
+
+const $c16168a9c28ae4fd$export$92606e71d0a264ff = async (config, ownerAddress, balanceRequirements, availableRoutingOptions)=>{
+    // eslint-disable-next-line no-console
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    await ($33acec7b4a26c053$export$23ddeb2642d2f9d)(config, ownerAddress, availableRoutingOptions);
+    // Get allowed tokens?
+    // Check bridging routes
+    // Check on-ramp routes
+    // Check swap routes
+    // > Could bridge first
+    // > Could on-ramp first
+    // > Could double swap
+    return {
+        availableOptions: [],
+        response: {
+            type: "ROUTES_FOUND",
+            message: "Routes found"
+        },
+        fundingRoutes: [
+            {
+                priority: 1,
+                steps: [
+                    {
+                        type: "bridge",
+                        chainId: 1,
+                        asset: {
+                            balance: (BigNumber$1).from(0),
+                            formattedBalance: "0",
+                            token: {
+                                name: "ETH",
+                                symbol: "ETH",
+                                decimals: 18
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+};
+
+
 const $0e7419077c373b24$export$4a2a19d99fef3b1b = (balanceCheckResult)=>{
     let sufficient = true;
     const transactionRequirements = [];
@@ -18679,12 +19213,123 @@ const $0e7419077c373b24$export$9e073f9ada8c81e6 = async (config, provider, itemR
         aggregatedItems = ($074f75878f618031$export$c804c9ade5c28607)(aggregatedItems);
     }
     const balanceRequirements = await ($beb896e098e41faf$export$ddfc885f43c3cb6e)(config, provider, ownerAddress, aggregatedItems);
+    // Determine which services are available
+    const availableRoutingOptions = await ($7f2e17f026d4fc8d$export$f1ca3744c025ab81)(config, provider);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    await ($c16168a9c28ae4fd$export$92606e71d0a264ff)(config, ownerAddress, balanceRequirements, availableRoutingOptions);
     return $0e7419077c373b24$export$4a2a19d99fef3b1b(balanceRequirements);
 };
 
 
 
 
+
+var $d855a5ba32004345$export$f51b97f3aaf2d5a8;
+(function(SignTransactionStatusType) {
+    SignTransactionStatusType["SUCCESS"] = "SUCCESS";
+    SignTransactionStatusType["FAILED"] = "FAILED";
+})($d855a5ba32004345$export$f51b97f3aaf2d5a8 || ($d855a5ba32004345$export$f51b97f3aaf2d5a8 = {}));
+
+
+const $25ac589234c10b67$export$19693ca396db083e = async (provider, approvalTransactions)=>{
+    let receipts = [];
+    try {
+        const response = await Promise.all(approvalTransactions.map((transaction)=>provider.getSigner().sendTransaction(transaction)));
+        receipts = await Promise.all(response.map((transaction)=>transaction.wait()));
+    } catch (err) {
+        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("An error occurred while executing the approval transaction", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).EXECUTE_APPROVAL_TRANSACTION_ERROR, {
+            message: err.message
+        });
+    }
+    for (const receipt of receipts){
+        if (receipt.status === 0) return {
+            type: ($d855a5ba32004345$export$f51b97f3aaf2d5a8).FAILED,
+            transactionHash: receipt.transactionHash,
+            reason: "Approval transaction failed and was reverted"
+        };
+    }
+    return {
+        type: ($d855a5ba32004345$export$f51b97f3aaf2d5a8).SUCCESS
+    };
+};
+const $25ac589234c10b67$export$2161274619257102 = async (provider, fulfilmentTransactions)=>{
+    let receipts = [];
+    try {
+        const response = await Promise.all(fulfilmentTransactions.map((transaction)=>provider.getSigner().sendTransaction(transaction)));
+        receipts = await Promise.all(response.map((transaction)=>transaction.wait()));
+    } catch (err) {
+        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("An error occurred while executing the fulfilment transaction", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).EXECUTE_FULFILMENT_TRANSACTION_ERROR, {
+            message: err.message
+        });
+    }
+    for (const receipt of receipts){
+        if (receipt.status === 0) return {
+            type: ($d855a5ba32004345$export$f51b97f3aaf2d5a8).FAILED,
+            transactionHash: receipt.transactionHash,
+            reason: "Fulfilment transaction failed and was reverted"
+        };
+    }
+    return {
+        type: ($d855a5ba32004345$export$f51b97f3aaf2d5a8).SUCCESS
+    };
+};
+const $25ac589234c10b67$export$1d9a7a8a40780de = async (provider, unsignedMessage)=>{
+    try {
+        // eslint-disable-next-line no-underscore-dangle
+        const signedMessage = await provider.getSigner()._signTypedData(unsignedMessage.unsignedMessage.domain, unsignedMessage.unsignedMessage.types, unsignedMessage.unsignedMessage.value);
+        return {
+            orderComponents: unsignedMessage.orderComponents,
+            orderHash: unsignedMessage.orderHash,
+            signedMessage: signedMessage
+        };
+    } catch (err) {
+        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("An error occurred while signing the message", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).SIGN_MESSAGE_ERROR, {
+            message: err.message
+        });
+    }
+};
+
+
+
+const $a7367d01c6e76b1c$export$b087719c36e0f2dc = async (actions)=>{
+    let approvalTransactions = [];
+    let fulfilmentTransactions = [];
+    const approvalPromises = [];
+    const fulfilmentPromises = [];
+    for (const action of actions){
+        if (action.type !== (ActionType).TRANSACTION) continue;
+        if (action.purpose === (TransactionPurpose).APPROVAL) approvalPromises.push(action.buildTransaction());
+        if (action.purpose === (TransactionPurpose).FULFILL_ORDER) fulfilmentPromises.push(action.buildTransaction());
+    }
+    approvalTransactions = await Promise.all(approvalPromises);
+    fulfilmentTransactions = await Promise.all(fulfilmentPromises);
+    return {
+        approvalTransactions: approvalTransactions,
+        fulfilmentTransactions: fulfilmentTransactions
+    };
+};
+const $a7367d01c6e76b1c$export$d62081fac18000c2 = (orderHash, orderComponents, actions)=>{
+    let unsignedMessage;
+    for (const action of actions){
+        if (action.type !== (ActionType).SIGNABLE) continue;
+        if (action.purpose === (SignablePurpose).CREATE_LISTING) unsignedMessage = {
+            domain: action.message.domain,
+            types: action.message.types,
+            value: action.message.value
+        };
+    }
+    if (!unsignedMessage) return undefined;
+    return {
+        orderHash: orderHash,
+        orderComponents: orderComponents,
+        unsignedMessage: unsignedMessage
+    };
+};
+
+
+
+
+
 const $64863c39386de592$export$4249179755829904 = (type, contractAddress, amount, spenderAddress)=>{
     switch(type){
         case ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20:
@@ -18702,17 +19347,10 @@ const $64863c39386de592$export$4249179755829904 = (type, contractAddress, amount
             };
     }
 };
-const $64863c39386de592$export$e0cb3ec5326d496b = async (actions)=>{
-    for (const action of actions){
-        if (action.type === (ActionType).TRANSACTION && action.purpose === (TransactionPurpose).FULFILL_ORDER) // eslint-disable-next-line no-await-in-loop
-        return await action.buildTransaction();
-    }
-    return undefined;
-};
-const $64863c39386de592$export$8f2ff92ab8657f0b = (gasLimit, transaction)=>{
-    if (transaction) return {
+const $64863c39386de592$export$8f2ff92ab8657f0b = (gasLimit, unsignedTransactions)=>{
+    if (unsignedTransactions.fulfilmentTransactions.length > 0) return {
         type: ($4b58188d47aafe8d$export$65c64e46348ee3c1).TRANSACTION,
-        transaction: transaction
+        transaction: unsignedTransactions.fulfilmentTransactions[0]
     };
     return {
         type: ($4b58188d47aafe8d$export$65c64e46348ee3c1).GAS,
@@ -18738,12 +19376,18 @@ const $64863c39386de592$export$7f8e2b98eca5a7f0 = async (config, provider, order
             message: err.message
         });
     }
-    let unsignedTransaction;
+    let unsignedTransactions = {
+        approvalTransactions: [],
+        fulfilmentTransactions: []
+    };
     try {
         const fulfillerAddress = await provider.getSigner().getAddress();
         const { actions: actions } = await orderbook.fulfillOrder(orderId, fulfillerAddress);
-        unsignedTransaction = await $64863c39386de592$export$e0cb3ec5326d496b(actions);
-    } catch  {}
+        unsignedTransactions = await (0, $a7367d01c6e76b1c$export$b087719c36e0f2dc)(actions);
+    } catch  {
+    // Silently ignore error as this is usually thrown if user does not have enough balance
+    // todo: if balance error - can we determine if its the balance error otherwise throw?
+    }
     let amount = (BigNumber$1).from("0");
     let type = ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE;
     let contractAddress = "";
@@ -18771,12 +19415,78 @@ const $64863c39386de592$export$7f8e2b98eca5a7f0 = async (config, provider, order
     const itemRequirements = [
         $64863c39386de592$export$4249179755829904(type, contractAddress, amount, spenderAddress)
     ];
-    await ($0e7419077c373b24$export$9e073f9ada8c81e6)(config, provider, itemRequirements, $64863c39386de592$export$8f2ff92ab8657f0b(gasLimit, unsignedTransaction));
+    const smartCheckoutResult = await ($0e7419077c373b24$export$9e073f9ada8c81e6)(config, provider, itemRequirements, $64863c39386de592$export$8f2ff92ab8657f0b(gasLimit, unsignedTransactions));
+    if (smartCheckoutResult.sufficient) {
+        const approvalResult = await ($25ac589234c10b67$export$19693ca396db083e)(provider, unsignedTransactions.approvalTransactions);
+        if (approvalResult.type === ($d855a5ba32004345$export$f51b97f3aaf2d5a8).FAILED) return {
+            smartCheckoutResult: smartCheckoutResult,
+            orderId: orderId,
+            status: {
+                type: ($aa144554f9ef124b$export$226b052ecb8ca80).FAILED,
+                transactionHash: approvalResult.transactionHash,
+                reason: approvalResult.reason
+            }
+        };
+        const fulfilmentResult = await ($25ac589234c10b67$export$2161274619257102)(provider, unsignedTransactions.fulfilmentTransactions);
+        if (fulfilmentResult.type === ($d855a5ba32004345$export$f51b97f3aaf2d5a8).FAILED) return {
+            smartCheckoutResult: smartCheckoutResult,
+            orderId: orderId,
+            status: {
+                type: ($aa144554f9ef124b$export$226b052ecb8ca80).FAILED,
+                transactionHash: fulfilmentResult.transactionHash,
+                reason: fulfilmentResult.reason
+            }
+        };
+        return {
+            smartCheckoutResult: smartCheckoutResult,
+            orderId: orderId,
+            status: {
+                type: ($aa144554f9ef124b$export$226b052ecb8ca80).SUCCESS
+            }
+        };
+    }
     return {
-        itemRequirements: itemRequirements,
-        gasToken: {
-            type: ($4b58188d47aafe8d$export$537fa3efd10ed435).NATIVE,
-            limit: (BigNumber$1).from(gasLimit)
+        smartCheckoutResult: smartCheckoutResult,
+        orderId: orderId
+    };
+};
+
+
+
+
+
+
+
+
+
+const $9c3db1bb9c8b69d3$export$70b61ad426ddbe54 = async (config, provider, orderId)=>{
+    let unsignedCancelOrderTransaction;
+    try {
+        const offererAddress = await provider.getSigner().getAddress();
+        const orderbook = await $67fc622a2b913d5f$export$c60ce6c6a92bc2ff(config);
+        const cancelOrderResponse = await orderbook.cancelOrder(orderId, offererAddress);
+        unsignedCancelOrderTransaction = cancelOrderResponse.unsignedCancelOrderTransaction;
+    } catch (err) {
+        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("An error occurred while cancelling the order listing", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).CANCEL_ORDER_LISTING_ERROR, {
+            orderId: orderId,
+            message: err.message
+        });
+    }
+    const result = await ($25ac589234c10b67$export$2161274619257102)(provider, [
+        unsignedCancelOrderTransaction
+    ]);
+    if (result.type === ($d855a5ba32004345$export$f51b97f3aaf2d5a8).FAILED) return {
+        orderId: orderId,
+        status: {
+            type: ($1e6b81bbd98b3a91$export$c0189a8c30039654).FAILED,
+            transactionHash: result.transactionHash,
+            reason: result.reason
+        }
+    };
+    return {
+        orderId: orderId,
+        status: {
+            type: ($1e6b81bbd98b3a91$export$c0189a8c30039654).SUCCESS
         }
     };
 };
@@ -18789,20 +19499,119 @@ const $64863c39386de592$export$7f8e2b98eca5a7f0 = async (config, provider, order
 
 
 
-async function $0e0060cb42e136d2$export$339cb2be73677b30(config, existingReadOnlyProviders) {
-    if (config.isProduction && existingReadOnlyProviders?.has(($0472f23319457bfb$export$c06e1e7429de6283).ETHEREUM)) return existingReadOnlyProviders;
-    if (existingReadOnlyProviders?.has(($0472f23319457bfb$export$c06e1e7429de6283).SEPOLIA)) return existingReadOnlyProviders;
-    const readOnlyProviders = new Map();
-    const allowedNetworks = await $de192de6ef100f9f$export$3043f6442a9ef563(config, {
-        type: ($a47e48dd2c04791b$export$1f05a55fe0680cc7).ALL
+
+
+
+
+const $9085b221b72ac69e$export$af768ccdf17d5c04 = (id, contractAddress, spenderAddress)=>({
+        type: ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721,
+        id: id,
+        contractAddress: contractAddress,
+        spenderAddress: spenderAddress
     });
-    allowedNetworks.networks.forEach((networkInfo)=>{
-        const rpcUrl = config.networkMap.get(networkInfo.chainId)?.rpcUrls[0];
-        const provider = new (JsonRpcProvider)(rpcUrl);
-        readOnlyProviders.set(networkInfo.chainId, provider);
+const $9085b221b72ac69e$export$586d02673c66d423 = (buyToken)=>{
+    if (buyToken.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE) return {
+        type: ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE,
+        amount: buyToken.amount.toString()
+    };
+    return {
+        type: ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20,
+        amount: buyToken.amount.toString(),
+        contractAddress: buyToken.contractAddress
+    };
+};
+const $9085b221b72ac69e$export$e761f9e0703de895 = async (config, provider, id, contractAddress, buyToken)=>{
+    let orderbook;
+    let listing;
+    let spenderAddress = "";
+    try {
+        const walletAddress = await provider.getSigner().getAddress();
+        orderbook = await $67fc622a2b913d5f$export$c60ce6c6a92bc2ff(config);
+        const { seaportContractAddress: seaportContractAddress } = orderbook.config();
+        spenderAddress = seaportContractAddress;
+        listing = await orderbook.prepareListing({
+            makerAddress: walletAddress,
+            buy: $9085b221b72ac69e$export$586d02673c66d423(buyToken),
+            sell: {
+                type: (0, $4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721,
+                contractAddress: contractAddress,
+                tokenId: id
+            }
+        });
+    } catch (err) {
+        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("An error occurred while preparing the listing", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PREPARE_ORDER_LISTING_ERROR, {
+            message: err.message,
+            id: id,
+            collectionAddress: contractAddress
+        });
+    }
+    const itemRequirements = [
+        $9085b221b72ac69e$export$af768ccdf17d5c04(id, contractAddress, spenderAddress)
+    ];
+    const smartCheckoutResult = await ($0e7419077c373b24$export$9e073f9ada8c81e6)(config, provider, itemRequirements, {
+        type: ($4b58188d47aafe8d$export$65c64e46348ee3c1).GAS,
+        gasToken: {
+            type: ($4b58188d47aafe8d$export$537fa3efd10ed435).NATIVE,
+            limit: (BigNumber$1).from((constants).estimatedFulfillmentGasGwei)
+        }
     });
-    return readOnlyProviders;
-}
+    if (smartCheckoutResult.sufficient) {
+        const unsignedMessage = ($a7367d01c6e76b1c$export$d62081fac18000c2)(listing.orderHash, listing.orderComponents, listing.actions);
+        if (!unsignedMessage) // For sell it is expected the orderbook will always return an unsigned message
+        // If for some reason it is missing then we cannot proceed with the create listing
+        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("The unsigned message is missing after preparing the listing", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).SIGN_MESSAGE_ERROR, {
+            id: id,
+            collectionAddress: contractAddress
+        });
+        const signedMessage = await ($25ac589234c10b67$export$1d9a7a8a40780de)(provider, unsignedMessage);
+        const unsignedTransactions = await ($a7367d01c6e76b1c$export$b087719c36e0f2dc)(listing.actions);
+        const approvalResult = await ($25ac589234c10b67$export$19693ca396db083e)(provider, unsignedTransactions.approvalTransactions);
+        if (approvalResult.type === ($d855a5ba32004345$export$f51b97f3aaf2d5a8).FAILED) return {
+            id: id,
+            collectionAddress: contractAddress,
+            smartCheckoutResult: smartCheckoutResult,
+            status: {
+                type: ($c2874b006e92b115$export$a9780122aaa0801a).FAILED,
+                transactionHash: approvalResult.transactionHash,
+                reason: approvalResult.reason
+            }
+        };
+        let orderId = "";
+        try {
+            const order = await orderbook.createListing({
+                orderComponents: signedMessage.orderComponents,
+                orderHash: signedMessage.orderHash,
+                orderSignature: signedMessage.signedMessage
+            });
+            orderId = order.result.id;
+        } catch (err) {
+            throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("An error occurred while creating the listing", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).CREATE_ORDER_LISTING_ERROR, {
+                message: err.message,
+                id: id,
+                collectionAddress: contractAddress
+            });
+        }
+        return {
+            id: id,
+            collectionAddress: contractAddress,
+            smartCheckoutResult: smartCheckoutResult,
+            status: {
+                type: ($c2874b006e92b115$export$a9780122aaa0801a).SUCCESS,
+                orderId: orderId
+            }
+        };
+    }
+    return {
+        id: id,
+        collectionAddress: contractAddress,
+        smartCheckoutResult: smartCheckoutResult
+    };
+};
+
+
+
+
+
 
 
 const $a8cb37a3fc8eb863$var$SANDBOX_CONFIGURATION = {
@@ -18933,6 +19742,26 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
         await $64863c39386de592$export$7f8e2b98eca5a7f0(this.config, web3Provider, params.orderId);
     }
     /**
+   * Determines the requirements for performing a sell.
+   * @param {SellParams} params - The parameters for the sell.
+  */ async sell(params) {
+        if (this.config.isProduction) throw new Error("This endpoint is not currently available.");
+        // eslint-disable-next-line no-console
+        console.warn("This endpoint is currently under construction.");
+        const web3Provider = await $bb88265fe45a0393$export$9e1fd9cc88c637a0(this.config, params.provider);
+        await $9085b221b72ac69e$export$e761f9e0703de895(this.config, web3Provider, params.id, params.collectionAddress, params.buyToken);
+    }
+    /**
+   * Cancels a sell.
+   * @param {CancelParams} params - The parameters for the cancel.
+   */ async cancel(params) {
+        if (this.config.isProduction) throw new Error("This endpoint is not currently available.");
+        // eslint-disable-next-line no-console
+        console.warn("This endpoint is currently under construction.");
+        const web3Provider = await $bb88265fe45a0393$export$9e1fd9cc88c637a0(this.config, params.provider);
+        await $9c3db1bb9c8b69d3$export$70b61ad426ddbe54(this.config, web3Provider, params.orderId);
+    }
+    /**
    * Determines the transaction requirements to complete a purchase.
    * @params {SmartCheckoutParams} params - The parameters for smart checkout.
    */ async smartCheckout(params) {
@@ -18940,6 +19769,7 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
         // eslint-disable-next-line no-console
         console.warn("This endpoint is currently under construction.");
         const web3Provider = await $bb88265fe45a0393$export$9e1fd9cc88c637a0(this.config, params.provider);
+        // console.log('Smart Checkout Params ::', params);
         await $0e7419077c373b24$export$9e073f9ada8c81e6(this.config, web3Provider, params.itemRequirements, params.transactionOrGasAmount);
     }
     /**