@imtbl/sdk 0.15.1-alpha → 0.16.0-alpha.1

package/dist/checkout_sdk.js

@@ -1,5 +1,6 @@
 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 assert from 'assert';
@@ -7,7 +8,6 @@ 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';
 
@@ -36,8 +36,7 @@ const ETH_MAINNET_CHAIN_ID = '1';
 /**
  * @constant {string} ZKEVM_DEVNET_CHAIN_ID - The chain ID for the zkEVM devnet (EIP-155 compatible format).
  */
-const ZKEVM_DEVNET_CHAIN_ID = '13433';
-/**
+const ZKEVM_DEVNET_CHAIN_ID = '13473';
 /**
  * @constant {string} ZKEVM_TESTNET_CHAIN_ID - The chain ID for the zkEVM testnet (EIP-155 compatible format).
  */
@@ -12318,10 +12317,10 @@ const SUPPORTED_BRIDGES_FOR_ENVIRONMENT = {
  */
 const CONTRACTS_FOR_BRIDGE = new Map()
     .set(ETH_SEPOLIA_TO_ZKEVM_DEVNET, {
-    rootChainERC20Predicate: '0xAC0f2096732D40096B3356AD76ba60a2f02366c8',
-    rootChainStateSender: '0xeA76fcCdD791A9c231CAda787ae7535c8a5E55B5',
-    rootChainCheckpointManager: '0x321A466aa78F5957C6E2375114915EcD14DAdE44',
-    rootChainExitHelper: '0x55cA8C418bbB0aC87414F9ea6FFC6a33860Cf967',
+    rootChainERC20Predicate: '0x75E468cF088F947B96422996132FbE71160F21F1',
+    rootChainStateSender: '0xbdC11416f01b122b7621855e61c99C7ED986F894',
+    rootChainCheckpointManager: '0x0721b564a96466b864A998D31846Ba409d21092B',
+    rootChainExitHelper: '0x0a2cb3f90aE65429E5c516af500F59d8fed51844',
     childChainERC20Predicate: '0x0000000000000000000000000000000000001004',
     childChainStateReceiver: '0x0000000000000000000000000000000000001001',
 })
@@ -15889,7 +15888,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,
@@ -15900,7 +15899,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;
@@ -16094,6 +16093,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 {
@@ -16230,6 +16277,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,
@@ -16559,12 +16657,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');
@@ -16730,6 +16840,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.
@@ -16743,6 +16864,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
@@ -16945,6 +17079,9 @@ const $d85ad1457a3f1a83$export$161d4a74df65fc08 = {
     [(Environment$1).SANDBOX]: "https://checkout-api.sandbox.immutable.com",
     [(Environment$1).PRODUCTION]: "https://checkout-api.immutable.com"
 };
+const $d85ad1457a3f1a83$export$fc55ed5a42b458ba = {
+    [($0472f23319457bfb$export$c06e1e7429de6283).IMTBL_ZKEVM_TESTNET]: "https://explorer.testnet.immutable.com"
+};
 const $d85ad1457a3f1a83$export$6f24f3cef7d501c4 = new Map([
     [
         ($0472f23319457bfb$export$c06e1e7429de6283).ETHEREUM,
@@ -17264,13 +17401,6 @@ var $4b58188d47aafe8d$export$537fa3efd10ed435;
     GasTokenType["NATIVE"] = "NATIVE";
     GasTokenType["ERC20"] = "ERC20";
 })($4b58188d47aafe8d$export$537fa3efd10ed435 || ($4b58188d47aafe8d$export$537fa3efd10ed435 = {}));
-var $4b58188d47aafe8d$export$5d3b0ad129b9b98e;
-(function(TransactionRequirementType) {
-    TransactionRequirementType["GAS"] = "GAS";
-    TransactionRequirementType["NATIVE"] = "NATIVE";
-    TransactionRequirementType["ERC20"] = "ERC20";
-    TransactionRequirementType["ERC721"] = "ERC721";
-})($4b58188d47aafe8d$export$5d3b0ad129b9b98e || ($4b58188d47aafe8d$export$5d3b0ad129b9b98e = {}));
 
 
 
@@ -17284,6 +17414,7 @@ var $4b58188d47aafe8d$export$5d3b0ad129b9b98e;
     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";
@@ -17299,6 +17430,7 @@ var $4b58188d47aafe8d$export$5d3b0ad129b9b98e;
     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["PREPARE_ORDER_LISTING_ERROR"] = "PREPARE_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";
@@ -17489,7 +17621,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
@@ -17502,6 +17634,90 @@ const $efe60cea83bfc4e8$export$473cec51305fdae8 = async (config, { type: type =
 
 
 
+
+
+const $fd8a8472dcc3ec2b$var$CACHE_DATA_TTL = 60; // seconds
+class $fd8a8472dcc3ec2b$export$ef140a6b05dfc786 {
+    url;
+    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];
+        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;
+    /**
+   * getAddressTokens 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
+   * @returns list of tokens given the wallet address and the token types
+   */ async getAddressTokens(params) {
+        try {
+            let url = `${this.url}/api/v2/addresses/${params.walletAddress}/tokens?type=${params.tokenType.join(",")}`;
+            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
+            });
+            this.setCache(url, response);
+            return Promise.resolve(response.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, {
@@ -17541,6 +17757,59 @@ 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.getAddressTokens({
+                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", ($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)=>{
@@ -17559,6 +17828,17 @@ 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);
     return await $1564e43dde50bb61$export$a3238cee431627c6(config, web3Provider, walletAddress, tokens);
 };
 
@@ -17724,13 +18004,19 @@ const $dbe95599a4661140$export$8e0e7ffc78696d30 = async (web3Provider, transacti
 
 
 
+const $dff2555fa96dda9a$var$doesChainSupportEIP1559 = (feeData)=>!!feeData.maxFeePerGas && !!feeData.maxPriorityFeePerGas;
+const $dff2555fa96dda9a$export$aa28f3111c524ec5 = (feeData)=>{
+    if ($dff2555fa96dda9a$var$doesChainSupportEIP1559(feeData)) return (BigNumber$1).from(feeData.maxFeePerGas).add((BigNumber$1).from(feeData.maxPriorityFeePerGas));
+    if (feeData.gasPrice) return (BigNumber$1).from(feeData.gasPrice);
+    return null;
+};
+
+
 const $570856c68db0bd36$var$GAS_LIMIT = 140000;
-const $570856c68db0bd36$var$doesChainSupportEIP1559 = (feeData)=>!!feeData.maxFeePerGas && !!feeData.maxPriorityFeePerGas;
-const $570856c68db0bd36$var$getGasPriceInWei = (feeData)=>$570856c68db0bd36$var$doesChainSupportEIP1559(feeData) ? (BigNumber$1).from(feeData.maxFeePerGas).add((BigNumber$1).from(feeData.maxPriorityFeePerGas)) : feeData.gasPrice && (BigNumber$1).from(feeData.gasPrice);
 const $570856c68db0bd36$var$getGasEstimates = async (provider)=>{
     const txnGasLimitInWei = $570856c68db0bd36$var$GAS_LIMIT; // todo: fetch gasLimit from bridgeSDK when they add new fn
     const feeData = await provider.getFeeData();
-    const gasPriceInWei = $570856c68db0bd36$var$getGasPriceInWei(feeData);
+    const gasPriceInWei = ($dff2555fa96dda9a$export$aa28f3111c524ec5)(feeData);
     if (!gasPriceInWei) return undefined;
     return gasPriceInWei.mul(txnGasLimitInWei);
 };
@@ -17821,7 +18107,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}`);
         }
@@ -17851,10 +18137,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] ?? [];
     }
 }
 
@@ -18007,8 +18293,6 @@ async function $2e7bf45a7c9a9570$export$942c8de7174809fc(params, readOnlyProvide
 
 
 
-
-
 const $ddc6bcd0896481e5$export$2fbfa41a4de56a89 = (erc20allowances, erc721allowances)=>{
     const aggregatedAllowances = [];
     if (!erc20allowances.sufficient) {
@@ -18179,7 +18463,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
         });
     }
 };
@@ -18191,7 +18477,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
         });
     }
 };
@@ -18201,6 +18490,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
         });
     }
@@ -18377,12 +18667,9 @@ const $aa6caea9a60d18c7$export$f96d1c819a615a64 = (itemRequirements)=>$aa6caea9a
 
 const $73d2282a108cc7e2$export$ed7929b58bab85da = (itemRequirements)=>itemRequirements.map((itemRequirement)=>{
         if (itemRequirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE) return {
-            name: "IMX",
-            symbol: "IMX",
             address: ($d85ad1457a3f1a83$export$b80040cb173ba6e9)
         };
         return {
-            name: itemRequirement.type,
             address: itemRequirement.contractAddress
         };
     });
@@ -18398,6 +18685,7 @@ const $73d2282a108cc7e2$export$9b757e40b19984c3 = (itemRequirement, balances)=>{
     const delta = requiredBalance.sub(itemBalanceResult?.balance ?? (BigNumber$1).from(0));
     let erc721BalanceResult = itemBalanceResult;
     if (!erc721BalanceResult) erc721BalanceResult = {
+        type: ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721,
         balance: (BigNumber$1).from(0),
         formattedBalance: "0",
         contractAddress: itemRequirement.contractAddress,
@@ -18405,7 +18693,7 @@ const $73d2282a108cc7e2$export$9b757e40b19984c3 = (itemRequirement, balances)=>{
     };
     return {
         sufficient: sufficient,
-        type: itemRequirement.type,
+        type: ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721,
         delta: {
             balance: delta,
             formattedBalance: delta.toString()
@@ -18425,23 +18713,30 @@ const $73d2282a108cc7e2$export$6ab9757fda54db7e = (itemRequirement, balances)=>{
         return balance.token?.address === itemRequirement.contractAddress;
     });
     else if (itemRequirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE) itemBalanceResult = balances.find((balance)=>{
-        return !("address" in balance.token) || balance.token?.address === ($d85ad1457a3f1a83$export$b80040cb173ba6e9);
+        return balance.token?.address === "" || balance.token?.address === ($d85ad1457a3f1a83$export$b80040cb173ba6e9);
     });
     // Calculate the balance delta
     const requiredBalance = itemRequirement.amount;
     const sufficient = requiredBalance.isNegative() || requiredBalance.isZero() || (itemBalanceResult?.balance.gte(requiredBalance) ?? false);
     const delta = requiredBalance.sub(itemBalanceResult?.balance ?? (BigNumber$1).from(0));
+    let name = "";
+    let symbol = "";
     let decimals = ($d85ad1457a3f1a83$export$903389470ba9433c);
-    if (itemBalanceResult) decimals = itemBalanceResult.token?.decimals ?? ($d85ad1457a3f1a83$export$903389470ba9433c);
+    if (itemBalanceResult) {
+        decimals = itemBalanceResult.token?.decimals ?? ($d85ad1457a3f1a83$export$903389470ba9433c);
+        name = itemBalanceResult.token.name;
+        symbol = itemBalanceResult.token.symbol;
+    }
     let tokenBalanceResult = itemBalanceResult;
     if (itemRequirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE) {
         // No token balance so mark as zero native
         if (!tokenBalanceResult) tokenBalanceResult = {
+            type: ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE,
             balance: (BigNumber$1).from(0),
             formattedBalance: "0",
             token: {
-                name: "IMX",
-                symbol: "IMX",
+                name: name,
+                symbol: symbol,
                 decimals: ($d85ad1457a3f1a83$export$903389470ba9433c),
                 address: ($d85ad1457a3f1a83$export$b80040cb173ba6e9)
             }
@@ -18453,9 +18748,13 @@ const $73d2282a108cc7e2$export$6ab9757fda54db7e = (itemRequirement, balances)=>{
                 balance: delta,
                 formattedBalance: (utils).formatUnits(delta, decimals)
             },
-            current: tokenBalanceResult,
+            current: {
+                ...tokenBalanceResult,
+                type: ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE
+            },
             required: {
                 ...tokenBalanceResult,
+                type: ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE,
                 balance: (BigNumber$1).from(itemRequirement.amount),
                 formattedBalance: (utils).formatUnits(itemRequirement.amount, decimals)
             }
@@ -18463,10 +18762,14 @@ const $73d2282a108cc7e2$export$6ab9757fda54db7e = (itemRequirement, balances)=>{
     }
     // No token balance so mark as zero
     if (!tokenBalanceResult) tokenBalanceResult = {
+        type: itemRequirement.type,
         balance: (BigNumber$1).from(0),
         formattedBalance: "0",
         token: {
-            address: itemRequirement.contractAddress
+            name: name,
+            symbol: symbol,
+            address: itemRequirement.contractAddress,
+            decimals: decimals
         }
     };
     return {
@@ -18508,11 +18811,11 @@ const $73d2282a108cc7e2$export$6ab9757fda54db7e = (itemRequirement, balances)=>{
     // Setup maps to be able to link data back to the associated promises
     const erc721s = new Map();
     const erc721OwnershipPromises = new Map();
-    itemRequirements.filter((itemRequirement)=>itemRequirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721).forEach((itemRequirement)=>{
-        const erc721Requirement = itemRequirement;
-        const contract = new (Contract$1)(erc721Requirement.contractAddress, JSON.stringify(($d85ad1457a3f1a83$export$8b8be7a2a654f23e)), provider);
-        erc721s.set(erc721Requirement.contractAddress, itemRequirement);
-        erc721OwnershipPromises.set(erc721Requirement.contractAddress, contract.ownerOf(erc721Requirement.id));
+    itemRequirements.forEach((itemRequirement)=>{
+        if (itemRequirement.type !== ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721) return;
+        const contract = new (Contract$1)(itemRequirement.contractAddress, JSON.stringify(($d85ad1457a3f1a83$export$8b8be7a2a654f23e)), provider);
+        erc721s.set(itemRequirement.contractAddress, itemRequirement);
+        erc721OwnershipPromises.set(itemRequirement.contractAddress, contract.ownerOf(itemRequirement.id));
     });
     try {
         // Convert ERC721 ownership into a balance result
@@ -18523,6 +18826,7 @@ const $73d2282a108cc7e2$export$6ab9757fda54db7e = (itemRequirement, balances)=>{
             let itemCount = 0;
             if (itemRequirement && ownerAddress === erc721OwnerAddress) itemCount = 1;
             erc721Balances.push({
+                type: (0, $4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721,
                 balance: (0, BigNumber$1).from(itemCount),
                 formattedBalance: itemCount.toString(),
                 contractAddress: itemRequirement.contractAddress,
@@ -18574,7 +18878,7 @@ const $beb896e098e41faf$export$ddfc885f43c3cb6e = async (config, provider, owner
     }, true);
     return {
         sufficient: sufficient,
-        itemRequirements: balanceRequirements
+        balanceRequirements: balanceRequirements
     };
 };
 
@@ -18585,12 +18889,7 @@ const $beb896e098e41faf$export$ddfc885f43c3cb6e = async (config, provider, owner
 
 
 
-const $7d1bfafb81e64d74$var$doesChainSupportEIP1559 = (feeData)=>!!feeData.maxFeePerGas && !!feeData.maxPriorityFeePerGas;
-const $7d1bfafb81e64d74$var$getGasPriceInWei = (feeData)=>{
-    if ($7d1bfafb81e64d74$var$doesChainSupportEIP1559(feeData)) return (BigNumber$1).from(feeData.maxFeePerGas).add((BigNumber$1).from(feeData.maxPriorityFeePerGas));
-    if (feeData.gasPrice) return (BigNumber$1).from(feeData.gasPrice);
-    return undefined;
-};
+
 const $7d1bfafb81e64d74$export$e0580ae1f48db848 = async (provider, transaction)=>{
     try {
         return await provider.estimateGas(transaction);
@@ -18623,9 +18922,11 @@ const $7d1bfafb81e64d74$export$3a4140bd9e983e4e = async (provider, insufficientI
     if (transactionOrGas.type === ($4b58188d47aafe8d$export$65c64e46348ee3c1).TRANSACTION) estimateGasPromises.push($7d1bfafb81e64d74$export$e0580ae1f48db848(provider, transactionOrGas.transaction));
     else {
         const feeData = await provider.getFeeData();
-        const gasPrice = $7d1bfafb81e64d74$var$getGasPriceInWei(feeData);
-        const gas = gasPrice?.mul(transactionOrGas.gasToken.limit);
-        if (gas) totalGas = totalGas.add(gas);
+        const gasPrice = ($dff2555fa96dda9a$export$aa28f3111c524ec5)(feeData);
+        if (gasPrice !== null) {
+            const gas = gasPrice?.mul(transactionOrGas.gasToken.limit);
+            if (gas) totalGas = totalGas.add(gas);
+        }
     }
     // Get the gas estimates for all the transactions and calculate the total gas
     const gasEstimatePromises = await Promise.all(estimateGasPromises);
@@ -18637,57 +18938,39 @@ const $7d1bfafb81e64d74$export$3a4140bd9e983e4e = async (provider, insufficientI
 };
 
 
+
+
+const $0e7419077c373b24$export$4a2a19d99fef3b1b = (balanceCheckResult)=>{
+    let sufficient = true;
+    const transactionRequirements = [];
+    for (const balance of balanceCheckResult.balanceRequirements){
+        if (!balance.sufficient) sufficient = false;
+        transactionRequirements.push({
+            type: balance.type,
+            sufficient: balance.sufficient,
+            required: balance.required,
+            current: balance.current,
+            delta: balance.delta
+        });
+    }
+    return {
+        sufficient: sufficient,
+        transactionRequirements: transactionRequirements
+    };
+};
 const $0e7419077c373b24$export$9e073f9ada8c81e6 = async (config, provider, itemRequirements, transactionOrGasAmount)=>{
-    // eslint-disable-next-line no-console
-    console.log(provider, itemRequirements, transactionOrGasAmount);
     const ownerAddress = await provider.getSigner().getAddress();
     let aggregatedItems = ($074f75878f618031$export$c804c9ade5c28607)(itemRequirements);
     const erc20Allowances = await ($fc8b338399d890f3$export$d93c00812189e36)(provider, ownerAddress, aggregatedItems);
     const erc721Allowances = await ($35c3fc7013888ba5$export$be546c525d418988)(provider, ownerAddress, aggregatedItems);
-    // eslint-disable-next-line no-console
-    console.log("ERC20 Allowances", erc20Allowances);
-    // eslint-disable-next-line no-console
-    console.log("ERC721 Allowances", erc721Allowances);
     const aggregatedAllowances = ($ddc6bcd0896481e5$export$2fbfa41a4de56a89)(erc20Allowances, erc721Allowances);
     const gasItem = await ($7d1bfafb81e64d74$export$3a4140bd9e983e4e)(provider, aggregatedAllowances, transactionOrGasAmount);
     if (gasItem !== null) {
         aggregatedItems.push(gasItem);
         aggregatedItems = ($074f75878f618031$export$c804c9ade5c28607)(aggregatedItems);
     }
-    // eslint-disable-next-line no-console
-    console.log("Aggregated Items", aggregatedItems);
     const balanceRequirements = await ($beb896e098e41faf$export$ddfc885f43c3cb6e)(config, provider, ownerAddress, aggregatedItems);
-    // eslint-disable-next-line no-console
-    console.log("Balance Requirements", balanceRequirements);
-    return {
-        sufficient: true,
-        transactionRequirements: [
-            {
-                type: ($4b58188d47aafe8d$export$5d3b0ad129b9b98e).GAS,
-                sufficient: true,
-                required: {
-                    balance: (BigNumber$1).from(0),
-                    formattedBalance: "0",
-                    token: {
-                        name: "IMX",
-                        symbol: "IMX",
-                        address: "0x0",
-                        decimals: 18
-                    }
-                },
-                current: {
-                    balance: (BigNumber$1).from(1),
-                    formattedBalance: "1",
-                    token: {
-                        name: "IMX",
-                        symbol: "IMX",
-                        address: "0x0",
-                        decimals: 18
-                    }
-                }
-            }
-        ]
-    };
+    return $0e7419077c373b24$export$4a2a19d99fef3b1b(balanceRequirements);
 };
 
 
@@ -18797,6 +19080,81 @@ 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)=>{
+    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$d2da5a4d143c85e5(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)
+    ];
+    // 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: {
+            type: ($4b58188d47aafe8d$export$537fa3efd10ed435).NATIVE,
+            limit: (BigNumber$1).from((constants).estimatedFulfillmentGasGwei)
+        }
+    });
+    // eslint-disable-next-line no-console
+    console.log("transactionRequirements", smartCheckoutResult);
+    return {
+        itemRequirements: itemRequirements,
+        gasToken: {
+            type: ($4b58188d47aafe8d$export$537fa3efd10ed435).NATIVE,
+            limit: (BigNumber$1).from((constants).estimatedFulfillmentGasGwei)
+        },
+        smartCheckoutResult: smartCheckoutResult
+    };
+};
+
+
+
+
+
+
+
+
+
 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;
@@ -18941,6 +19299,16 @@ 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);
+    }
+    /**
    * Determines the transaction requirements to complete a purchase.
    * @params {SmartCheckoutParams} params - The parameters for smart checkout.
    */ async smartCheckout(params) {