@imtbl/sdk 0.16.0-alpha.1 → 0.17.0

package/dist/checkout_sdk.js

@@ -2,9 +2,8 @@ import { ethers, ContractFactory, utils, Contract as Contract$1, BigNumber as Bi
 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';
@@ -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,6 +15018,212 @@ startTokenIn = tokenIn) => {
     return routes;
 };
 
+/**
+ * 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);
+    }
+    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);
+    }
+    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 = tokenAmount.value.sub(allowance);
+    if (requiredAmount.isNegative() || requiredAmount.isZero()) {
+        throw new AlreadyApprovedError(tokenAmount.toString(), tokenAmount.token.address, spenderAddress);
+    }
+    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;
@@ -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,
@@ -16977,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 = {}));
 
 
 /**
@@ -17024,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";
@@ -17074,13 +17090,25 @@ 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"
 };
+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]: "https://explorer.testnet.immutable.com"
+    [($0472f23319457bfb$export$c06e1e7429de6283).IMTBL_ZKEVM_TESTNET]: {
+        url: "https://explorer.testnet.immutable.com",
+        nativeToken: $d85ad1457a3f1a83$var$ZKEVM_NATIVE_TOKEN
+    }
 };
 const $d85ad1457a3f1a83$export$6f24f3cef7d501c4 = new Map([
     [
@@ -17109,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
         }
     ]
 ]);
@@ -17145,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
         }
     ]
 ]);
@@ -17181,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
         }
     ]
 ]);
@@ -17430,10 +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;
@@ -17639,6 +17657,7 @@ 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;
@@ -17662,7 +17681,14 @@ class $fd8a8472dcc3ec2b$export$ef140a6b05dfc786 {
    * @param ttl cache TTL
    */ constructor(params){
         this.chainId = params.chainId;
-        this.url = ($d85ad1457a3f1a83$export$fc55ed5a42b458ba)[this.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;
     }
@@ -17675,14 +17701,14 @@ class $fd8a8472dcc3ec2b$export$ef140a6b05dfc786 {
    * @param err error to evaluate
    */ static isBlockscoutError = (err)=>"code" in err;
     /**
-   * getAddressTokens fetches the list of tokens (by type) owned by the wallet address.
+   * getTokensByWalletAddress fetches the list of tokens (by type) owned by the wallet address.
    * @param walletAddress wallet address
-   * @param tokenType token types
-   * @param nextPage parameters for the next page, to be provided along side walletAddress and tokenType
+   * @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 getAddressTokens(params) {
+   */ async getTokensByWalletAddress(params) {
         try {
-            let url = `${this.url}/api/v2/addresses/${params.walletAddress}/tokens?type=${params.tokenType.join(",")}`;
+            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);
@@ -17692,8 +17718,51 @@ class $fd8a8472dcc3ec2b$export$ef140a6b05dfc786 {
                 code: response.status,
                 message: response.statusText
             });
-            this.setCache(url, response);
-            return Promise.resolve(response.data);
+            // 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";
@@ -17771,16 +17840,14 @@ const $1564e43dde50bb61$export$8c978679845804d4 = async (walletAddress, chainId,
     });
     // Hold the items in an array for post-fetching processing
     const items = [];
-    const tokenType = [
-        ($887a00f8f72d61f0$export$5bd1ea2b3d18210).ERC20
-    ];
+    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.getAddressTokens({
+            resp = await $1564e43dde50bb61$var$blockscoutClient.getTokensByWalletAddress({
                 walletAddress: walletAddress,
                 tokenType: tokenType,
                 nextPage: resp?.next_page_params
@@ -17788,7 +17855,15 @@ const $1564e43dde50bb61$export$8c978679845804d4 = async (walletAddress, chainId,
             items.push(...resp.items);
         }while (resp.next_page_params);
     } catch (err) {
-        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(err.message || "InternalServerError", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_INDEXER_BALANCE_ERROR, 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)=>{
@@ -17818,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
     };
@@ -17839,6 +17914,9 @@ const $1564e43dde50bb61$export$fee49741664a4d7e = async (config, web3Provider, w
         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);
 };
 
@@ -18174,6 +18252,9 @@ class $4013c5c91bb535f6$export$4823433c4a67bbc6 {
     // Environment.DEVELOPMENT
     isDevelopment = false;
     isProduction;
+    isOnRampEnabled;
+    isSwapEnabled;
+    isBridgeEnabled;
     remote;
     environment;
     networkMap;
@@ -18182,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,
@@ -18293,6 +18377,7 @@ async function $2e7bf45a7c9a9570$export$942c8de7174809fc(params, readOnlyProvide
 
 
 
+
 const $ddc6bcd0896481e5$export$2fbfa41a4de56a89 = (erc20allowances, erc721allowances)=>{
     const aggregatedAllowances = [];
     if (!erc20allowances.sufficient) {
@@ -18940,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 = [];
@@ -18970,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:
@@ -18993,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,
@@ -19029,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 = "";
@@ -19062,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
         }
     };
 };
@@ -19081,13 +19500,16 @@ const $64863c39386de592$export$7f8e2b98eca5a7f0 = async (config, provider, order
 
 
 
+
+
+
 const $9085b221b72ac69e$export$af768ccdf17d5c04 = (id, contractAddress, spenderAddress)=>({
         type: ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721,
         id: id,
         contractAddress: contractAddress,
         spenderAddress: spenderAddress
     });
-const $9085b221b72ac69e$export$d2da5a4d143c85e5 = (buyToken)=>{
+const $9085b221b72ac69e$export$586d02673c66d423 = (buyToken)=>{
     if (buyToken.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE) return {
         type: ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE,
         amount: buyToken.amount.toString()
@@ -19109,7 +19531,7 @@ const $9085b221b72ac69e$export$e761f9e0703de895 = async (config, provider, id, c
         spenderAddress = seaportContractAddress;
         listing = await orderbook.prepareListing({
             makerAddress: walletAddress,
-            buy: $9085b221b72ac69e$export$d2da5a4d143c85e5(buyToken),
+            buy: $9085b221b72ac69e$export$586d02673c66d423(buyToken),
             sell: {
                 type: (0, $4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721,
                 contractAddress: contractAddress,
@@ -19126,8 +19548,6 @@ const $9085b221b72ac69e$export$e761f9e0703de895 = async (config, provider, id, c
     const itemRequirements = [
         $9085b221b72ac69e$export$af768ccdf17d5c04(id, contractAddress, spenderAddress)
     ];
-    // eslint-disable-next-line no-console
-    console.log(listing); // TODO: Get order signature, provider.getSigner()._signTypedData to sign
     const smartCheckoutResult = await ($0e7419077c373b24$export$9e073f9ada8c81e6)(config, provider, itemRequirements, {
         type: ($4b58188d47aafe8d$export$65c64e46348ee3c1).GAS,
         gasToken: {
@@ -19135,14 +19555,55 @@ const $9085b221b72ac69e$export$e761f9e0703de895 = async (config, provider, id, c
             limit: (BigNumber$1).from((constants).estimatedFulfillmentGasGwei)
         }
     });
-    // eslint-disable-next-line no-console
-    console.log("transactionRequirements", smartCheckoutResult);
+    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 {
-        itemRequirements: itemRequirements,
-        gasToken: {
-            type: ($4b58188d47aafe8d$export$537fa3efd10ed435).NATIVE,
-            limit: (BigNumber$1).from((constants).estimatedFulfillmentGasGwei)
-        },
+        id: id,
+        collectionAddress: contractAddress,
         smartCheckoutResult: smartCheckoutResult
     };
 };
@@ -19153,24 +19614,6 @@ const $9085b221b72ac69e$export$e761f9e0703de895 = async (config, provider, id, c
 
 
 
-
-
-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 $a8cb37a3fc8eb863$var$SANDBOX_CONFIGURATION = {
     baseConfig: {
         environment: (Environment$1).SANDBOX
@@ -19309,6 +19752,16 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
         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) {
@@ -19316,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);
     }
     /**