@imtbl/sdk 0.14.0-alpha → 0.14.0-alpha.2

package/dist/checkout_sdk.d.ts

@@ -11524,6 +11524,7 @@ declare enum CheckoutErrorType {
     CONNECT_PROVIDER_ERROR = "CONNECT_PROVIDER_ERROR",
     GET_BALANCE_ERROR = "GET_BALANCE_ERROR",
     GET_ERC20_BALANCE_ERROR = "GET_ERC20_BALANCE_ERROR",
+    GET_ERC721_BALANCE_ERROR = "GET_ERC721_BALANCE_ERROR",
     GET_NETWORK_INFO_ERROR = "GET_NETWORK_INFO_ERROR",
     METAMASK_PROVIDER_ERROR = "METAMASK_PROVIDER_ERROR",
     CHAIN_NOT_SUPPORTED_ERROR = "CHAIN_NOT_SUPPORTED_ERROR",
@@ -11535,6 +11536,7 @@ declare enum CheckoutErrorType {
     UNPREDICTABLE_GAS_LIMIT = "UNPREDICTABLE_GAS_LIMIT",
     INVALID_GAS_ESTIMATE_TYPE = "INVALID_GAS_ESTIMATE_TYPE",
     UNSUPPORTED_TOKEN_TYPE_ERROR = "UNSUPPORTED_TOKEN_TYPE_ERROR",
+    UNSUPPORTED_BALANCE_REQUIREMENT_ERROR = "UNSUPPORTED_BALANCE_REQUIREMENT_ERROR",
     GET_ORDER_LISTING_ERROR = "GET_ORDER_LISTING_ERROR",
     SWITCH_NETWORK_UNSUPPORTED = "SWITCH_NETWORK_UNSUPPORTED",
     GET_ERC20_ALLOWANCE_ERROR = "GET_ERC20_ALLOWANCE_ERROR",

package/dist/checkout_sdk.js

@@ -16176,6 +16176,67 @@ var ActionType;
     ActionType["SIGNABLE"] = "SIGNABLE";
 })(ActionType || (ActionType = {}));
 
+function mapFromOpenApiOrder(order) {
+    const buyItems = order.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 = order.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: order.id,
+        accountAddress: order.account_address,
+        buy: buyItems,
+        sell: sellItems,
+        fees: order.fees.map((fee) => ({
+            amount: fee.amount,
+            recipient: fee.recipient,
+            type: fee.fee_type,
+        })),
+        chain: order.chain,
+        createTime: order.create_time,
+        endTime: order.end_time,
+        protocolData: {
+            counter: order.protocol_data.counter,
+            orderType: order.protocol_data.order_type,
+            seaportAddress: order.protocol_data.seaport_address,
+            seaportVersion: order.protocol_data.seaport_version,
+            zoneAddress: order.protocol_data.zone_address,
+        },
+        salt: order.salt,
+        signature: order.signature,
+        startTime: order.start_time,
+        status: order.status,
+        updateTime: order.update_time,
+    };
+}
+function mapFromOpenApiPage(page) {
+    return {
+        nextCursor: page.next_cursor,
+        previousCursor: page.previous_cursor,
+    };
+}
+
 /* eslint-disable */
 // TODO: Resolve these from seaport-js.
 // There is some bundling issue that is preventing this from working
@@ -16405,7 +16466,17 @@ class Seaport {
             buildTransaction: prepareTransaction(fulfilOrderAction.transactionMethods),
             purpose: TransactionPurpose.FULFILL_ORDER,
         });
-        return { actions: fulfillmentActions };
+        // Expirtaion bytes in SIP7 extra data [21:29]
+        // In hex string -> [21 * 2 + 2 (0x) : 29 * 2]
+        // In JS slice (start, end_inclusive), (44,60)
+        // 8 bytes uint64 epoch time in seconds
+        const expirationHex = extraData.slice(44, 60);
+        const expirationInSeconds = parseInt(expirationHex, 16);
+        return {
+            actions: fulfillmentActions,
+            expiration: (new Date(expirationInSeconds * 1000)).toISOString(),
+            order: mapFromOpenApiOrder(order),
+        };
     }
     async cancelOrder(order, account) {
         const { orderComponents } = this.mapImmutableOrderToSeaportOrderComponents(order);
@@ -16525,7 +16596,7 @@ class ImmutableApiClient {
                 ],
                 fees: makerFee ? [{
                         amount: makerFee.amount,
-                        fee_type: makerFee.type,
+                        fee_type: FeeType.MAKER_MARKETPLACE,
                         recipient: makerFee.recipient,
                     }] : [],
                 end_time: new Date(parseInt(`${orderComponents.endTime.toString()}000`, 10)).toISOString(),
@@ -16653,8 +16724,11 @@ class Orderbook {
      * @param {string} listingId - The listingId to find.
      * @return {ListingResult} The returned order result.
      */
-    getListing(listingId) {
-        return this.apiClient.getListing(listingId);
+    async getListing(listingId) {
+        const apiListing = await this.apiClient.getListing(listingId);
+        return {
+            result: mapFromOpenApiOrder(apiListing.result),
+        };
     }
     /**
      * List orders. This method is used to get a list of orders filtered by conditions specified
@@ -16662,8 +16736,12 @@ class Orderbook {
      * @param {ListListingsParams} listOrderParams - Filtering, ordering and page parameters.
      * @return {ListListingsResult} The paged orders.
      */
-    listListings(listOrderParams) {
-        return this.apiClient.listListings(listOrderParams);
+    async listListings(listOrderParams) {
+        const apiListings = await this.apiClient.listListings(listOrderParams);
+        return {
+            page: mapFromOpenApiPage(apiListings.page),
+            result: apiListings.result.map(mapFromOpenApiOrder),
+        };
     }
     /**
      * Get required transactions and messages for signing prior to creating a listing
@@ -16685,8 +16763,20 @@ class Orderbook {
      * @param {CreateListingParams} createListingParams - create an order with the given params.
      * @return {ListingResult} The result of the order created in the Immutable services.
      */
-    createListing(createListingParams) {
-        return this.apiClient.createListing(createListingParams);
+    async createListing(createListingParams) {
+        const makerFee = createListingParams.makerFee
+            ? {
+                ...createListingParams.makerFee,
+                type: FeeType.MAKER_MARKETPLACE,
+            }
+            : undefined;
+        const apiListingResponse = await this.apiClient.createListing({
+            ...createListingParams,
+            makerFee,
+        });
+        return {
+            result: mapFromOpenApiOrder(apiListingResponse.result),
+        };
     }
     /**
      * Get unsigned transactions that can be submitted to fulfil an open order. If the approval
@@ -16703,7 +16793,7 @@ class Orderbook {
                 fee: takerFee
                     ? {
                         amount: takerFee.amount,
-                        fee_type: takerFee.type,
+                        fee_type: FeeType.TAKER_MARKETPLACE,
                         recipient: takerFee.recipient,
                     }
                     : undefined,
@@ -16848,6 +16938,8 @@ const $e768639828688ca3$export$44dde05038008549 = {
 
 
 const $d85ad1457a3f1a83$export$7d3a9eeba384fa59 = "development";
+const $d85ad1457a3f1a83$export$b80040cb173ba6e9 = "0x0000000000000000000000000000000000001010";
+const $d85ad1457a3f1a83$export$903389470ba9433c = 18;
 const $d85ad1457a3f1a83$export$161d4a74df65fc08 = {
     [$d85ad1457a3f1a83$export$7d3a9eeba384fa59]: "https://checkout-api.dev.immutable.com",
     [(Environment$1).SANDBOX]: "https://checkout-api.sandbox.immutable.com",
@@ -17130,6 +17222,25 @@ const $d85ad1457a3f1a83$export$8b8be7a2a654f23e = [
         payable: false,
         stateMutability: "view",
         type: "function"
+    },
+    {
+        inputs: [
+            {
+                internalType: "uint256",
+                name: "tokenId",
+                type: "uint256"
+            }
+        ],
+        name: "ownerOf",
+        outputs: [
+            {
+                internalType: "address",
+                name: "",
+                type: "address"
+            }
+        ],
+        stateMutability: "view",
+        type: "function"
     }
 ];
 
@@ -17171,6 +17282,7 @@ var $4b58188d47aafe8d$export$5d3b0ad129b9b98e;
     CheckoutErrorType["CONNECT_PROVIDER_ERROR"] = "CONNECT_PROVIDER_ERROR";
     CheckoutErrorType["GET_BALANCE_ERROR"] = "GET_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";
     CheckoutErrorType["METAMASK_PROVIDER_ERROR"] = "METAMASK_PROVIDER_ERROR";
     CheckoutErrorType["CHAIN_NOT_SUPPORTED_ERROR"] = "CHAIN_NOT_SUPPORTED_ERROR";
@@ -17182,6 +17294,7 @@ var $4b58188d47aafe8d$export$5d3b0ad129b9b98e;
     CheckoutErrorType["UNPREDICTABLE_GAS_LIMIT"] = "UNPREDICTABLE_GAS_LIMIT";
     CheckoutErrorType["INVALID_GAS_ESTIMATE_TYPE"] = "INVALID_GAS_ESTIMATE_TYPE";
     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["SWITCH_NETWORK_UNSUPPORTED"] = "SWITCH_NETWORK_UNSUPPORTED";
     CheckoutErrorType["GET_ERC20_ALLOWANCE_ERROR"] = "GET_ERC20_ALLOWANCE_ERROR";
@@ -17403,39 +17516,48 @@ const $1564e43dde50bb61$export$df96cd8d56be0ab1 = async (config, web3Provider, w
 async function $1564e43dde50bb61$export$60e0fe116a0e6ed0(web3Provider, walletAddress, contractAddress) {
     return await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
         const contract = new (Contract$1)(contractAddress, JSON.stringify(($d85ad1457a3f1a83$export$db5daa1b5156ccfe)), web3Provider);
-        const name = await contract.name();
-        const symbol = await contract.symbol();
-        const balance = await contract.balanceOf(walletAddress);
-        const decimals = await contract.decimals();
-        const formattedBalance = (utils).formatUnits(balance, decimals);
-        return {
-            balance: balance,
-            formattedBalance: formattedBalance,
-            token: {
-                name: name,
-                symbol: symbol,
-                decimals: decimals,
-                address: contractAddress
-            }
-        };
+        return Promise.all([
+            contract.name(),
+            contract.symbol(),
+            contract.balanceOf(walletAddress),
+            contract.decimals()
+        ]).then(([name, symbol, balance, decimals])=>{
+            const formattedBalance = (utils).formatUnits(balance, decimals);
+            return {
+                balance: balance,
+                formattedBalance: formattedBalance,
+                token: {
+                    name: name,
+                    symbol: symbol,
+                    decimals: decimals,
+                    address: contractAddress
+                }
+            };
+        });
     }, {
         type: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_ERC20_BALANCE_ERROR
     });
 }
-const $1564e43dde50bb61$export$fee49741664a4d7e = async (config, web3Provider, walletAddress, chainId)=>{
-    const tokenList = await ($efe60cea83bfc4e8$export$473cec51305fdae8)(config, {
-        type: ($08d5ddc39acd6833$export$fd9b17d87f4121d2).ALL,
-        chainId: chainId
-    });
+const $1564e43dde50bb61$export$a3238cee431627c6 = async (config, web3Provider, walletAddress, tokens)=>{
     const allBalancePromises = [];
-    allBalancePromises.push($1564e43dde50bb61$export$df96cd8d56be0ab1(config, web3Provider, walletAddress));
-    tokenList.tokens.forEach((token)=>token.address && allBalancePromises.push($1564e43dde50bb61$export$60e0fe116a0e6ed0(web3Provider, walletAddress, token.address)));
+    tokens.forEach((token)=>{
+        // Check for NATIVE token
+        if (!token.address || token.address === ($d85ad1457a3f1a83$export$b80040cb173ba6e9)) allBalancePromises.push($1564e43dde50bb61$export$df96cd8d56be0ab1(config, web3Provider, walletAddress));
+        else allBalancePromises.push($1564e43dde50bb61$export$60e0fe116a0e6ed0(web3Provider, walletAddress, token.address));
+    });
     const balanceResults = await Promise.allSettled(allBalancePromises);
-    const getBalanceResults = balanceResults.filter((result)=>result.status === "fulfilled").map((fulfilledResult)=>fulfilledResult.value);
+    const balances = balanceResults.filter((result)=>result.status === "fulfilled").map((fulfilledResult)=>fulfilledResult.value);
     return {
-        balances: getBalanceResults
+        balances: balances
     };
 };
+const $1564e43dde50bb61$export$fee49741664a4d7e = async (config, web3Provider, walletAddress, chainId)=>{
+    const { tokens: tokens } = await ($efe60cea83bfc4e8$export$473cec51305fdae8)(config, {
+        type: ($08d5ddc39acd6833$export$fd9b17d87f4121d2).ALL,
+        chainId: chainId
+    });
+    return await $1564e43dde50bb61$export$a3238cee431627c6(config, web3Provider, walletAddress, tokens);
+};
 
 
 
@@ -18184,6 +18306,278 @@ const $35c3fc7013888ba5$export$be546c525d418988 = async (provider, ownerAddress,
 
 
 
+/* eslint-disable arrow-body-style */ 
+
+
+
+
+
+const $aa6caea9a60d18c7$export$f4d35754ad350071 = (itemRequirements)=>{
+    const aggregatedMap = new Map();
+    const aggregatedItemRequirements = [];
+    itemRequirements.forEach((itemRequirement)=>{
+        const { type: type } = itemRequirement;
+        if (type !== ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE) {
+            aggregatedItemRequirements.push(itemRequirement);
+            return;
+        }
+        const { amount: amount } = itemRequirement;
+        const aggregateItem = aggregatedMap.get(type);
+        if (aggregateItem && aggregateItem.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE) aggregateItem.amount = (BigNumber$1).from(aggregateItem.amount).add(amount);
+        else aggregatedMap.set(type, {
+            ...itemRequirement
+        });
+    });
+    return aggregatedItemRequirements.concat(Array.from(aggregatedMap.values()));
+};
+const $aa6caea9a60d18c7$export$b8de545554d50911 = (itemRequirements)=>{
+    const aggregatedMap = new Map();
+    const aggregatedItemRequirements = [];
+    itemRequirements.forEach((itemRequirement)=>{
+        const { type: type } = itemRequirement;
+        if (type !== ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20) {
+            aggregatedItemRequirements.push(itemRequirement);
+            return;
+        }
+        const { contractAddress: contractAddress, amount: amount } = itemRequirement;
+        const key = `${contractAddress}`;
+        const aggregateItem = aggregatedMap.get(key);
+        if (aggregateItem && aggregateItem.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20) aggregateItem.amount = (BigNumber$1).from(aggregateItem.amount).add(amount);
+        else aggregatedMap.set(key, {
+            ...itemRequirement
+        });
+    });
+    return aggregatedItemRequirements.concat(Array.from(aggregatedMap.values()));
+};
+const $aa6caea9a60d18c7$export$74fbc29ef48b4f31 = (itemRequirements)=>{
+    const aggregatedMap = new Map();
+    const aggregatedItemRequirements = [];
+    itemRequirements.forEach((itemRequirement)=>{
+        const { type: type } = itemRequirement;
+        if (type !== ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721) {
+            aggregatedItemRequirements.push(itemRequirement);
+            return;
+        }
+        const { contractAddress: contractAddress, id: id } = itemRequirement;
+        const key = `${contractAddress}${id}`;
+        const aggregateItem = aggregatedMap.get(key);
+        if (!aggregateItem) aggregatedMap.set(key, {
+            ...itemRequirement
+        });
+    });
+    return aggregatedItemRequirements.concat(Array.from(aggregatedMap.values()));
+};
+const $aa6caea9a60d18c7$export$f96d1c819a615a64 = (itemRequirements)=>$aa6caea9a60d18c7$export$74fbc29ef48b4f31($aa6caea9a60d18c7$export$b8de545554d50911($aa6caea9a60d18c7$export$f4d35754ad350071(itemRequirements)));
+
+
+/* eslint-disable arrow-body-style */ 
+
+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
+        };
+    });
+const $73d2282a108cc7e2$export$9b757e40b19984c3 = (itemRequirement, balances)=>{
+    const requiredBalance = (BigNumber$1).from(1);
+    // Find the requirements related balance
+    const itemBalanceResult = balances.find((balance)=>{
+        const balanceERC721Result = balance;
+        return balanceERC721Result.contractAddress === itemRequirement.contractAddress && balanceERC721Result.id === itemRequirement.id;
+    });
+    // Calculate the balance delta
+    const sufficient = requiredBalance.isNegative() || requiredBalance.isZero() || (itemBalanceResult?.balance.gte(requiredBalance) ?? false);
+    const delta = requiredBalance.sub(itemBalanceResult?.balance ?? (BigNumber$1).from(0));
+    let erc721BalanceResult = itemBalanceResult;
+    if (!erc721BalanceResult) erc721BalanceResult = {
+        balance: (BigNumber$1).from(0),
+        formattedBalance: "0",
+        contractAddress: itemRequirement.contractAddress,
+        id: itemRequirement.id
+    };
+    return {
+        sufficient: sufficient,
+        type: itemRequirement.type,
+        delta: {
+            balance: delta,
+            formattedBalance: delta.toString()
+        },
+        current: erc721BalanceResult,
+        required: {
+            ...erc721BalanceResult,
+            balance: (BigNumber$1).from(1),
+            formattedBalance: "1"
+        }
+    };
+};
+const $73d2282a108cc7e2$export$6ab9757fda54db7e = (itemRequirement, balances)=>{
+    let itemBalanceResult;
+    // Get the requirements related balance
+    if (itemRequirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20) itemBalanceResult = balances.find((balance)=>{
+        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);
+    });
+    // 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 decimals = ($d85ad1457a3f1a83$export$903389470ba9433c);
+    if (itemBalanceResult) decimals = itemBalanceResult.token?.decimals ?? ($d85ad1457a3f1a83$export$903389470ba9433c);
+    let tokenBalanceResult = itemBalanceResult;
+    if (itemRequirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE) {
+        // No token balance so mark as zero native
+        if (!tokenBalanceResult) tokenBalanceResult = {
+            balance: (BigNumber$1).from(0),
+            formattedBalance: "0",
+            token: {
+                name: "IMX",
+                symbol: "IMX",
+                decimals: ($d85ad1457a3f1a83$export$903389470ba9433c),
+                address: ($d85ad1457a3f1a83$export$b80040cb173ba6e9)
+            }
+        };
+        return {
+            sufficient: sufficient,
+            type: ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE,
+            delta: {
+                balance: delta,
+                formattedBalance: (utils).formatUnits(delta, decimals)
+            },
+            current: tokenBalanceResult,
+            required: {
+                ...tokenBalanceResult,
+                balance: (BigNumber$1).from(itemRequirement.amount),
+                formattedBalance: (utils).formatUnits(itemRequirement.amount, decimals)
+            }
+        };
+    }
+    // No token balance so mark as zero
+    if (!tokenBalanceResult) tokenBalanceResult = {
+        balance: (BigNumber$1).from(0),
+        formattedBalance: "0",
+        token: {
+            address: itemRequirement.contractAddress
+        }
+    };
+    return {
+        sufficient: sufficient,
+        type: ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20,
+        delta: {
+            balance: delta,
+            formattedBalance: (utils).formatUnits(delta, decimals)
+        },
+        current: tokenBalanceResult,
+        required: {
+            ...tokenBalanceResult,
+            balance: (BigNumber$1).from(itemRequirement.amount),
+            formattedBalance: (utils).formatUnits(itemRequirement.amount, decimals)
+        }
+    };
+};
+
+
+/**
+ * Gets the balances for all NATIVE and ERC20 balance requirements.
+ */ const $beb896e098e41faf$var$getTokenBalances = async (config, provider, ownerAddress, itemRequirements)=>{
+    let tokenBalances = [];
+    try {
+        const tokenList = (0, $73d2282a108cc7e2$export$ed7929b58bab85da)(itemRequirements);
+        const { balances: balances } = await (0, $1564e43dde50bb61$export$a3238cee431627c6)(config, provider, ownerAddress, tokenList);
+        tokenBalances = [
+            ...balances.map((balance)=>balance)
+        ];
+    } catch (error) {
+        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Failed to get balances", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_BALANCE_ERROR);
+    }
+    return tokenBalances;
+};
+/**
+ * Gets the balances for all ERC721 balance requirements.
+ */ const $beb896e098e41faf$var$getERC721Balances = async (provider, ownerAddress, itemRequirements)=>{
+    const erc721Balances = [];
+    // 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));
+    });
+    try {
+        // Convert ERC721 ownership into a balance result
+        const erc721Owners = await Promise.all(erc721OwnershipPromises.values());
+        const erc721OwnersPromiseIds = Array.from(erc721OwnershipPromises.keys());
+        erc721Owners.forEach((erc721OwnerAddress, index)=>{
+            const itemRequirement = erc721s.get(erc721OwnersPromiseIds[index]);
+            let itemCount = 0;
+            if (itemRequirement && ownerAddress === erc721OwnerAddress) itemCount = 1;
+            erc721Balances.push({
+                balance: (0, BigNumber$1).from(itemCount),
+                formattedBalance: itemCount.toString(),
+                contractAddress: itemRequirement.contractAddress,
+                id: itemRequirement.id
+            });
+        });
+    } catch (error) {
+        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Failed to get ERC721 balances", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_ERC721_BALANCE_ERROR);
+    }
+    return erc721Balances;
+};
+const $beb896e098e41faf$export$ddfc885f43c3cb6e = async (config, provider, ownerAddress, itemRequirements)=>{
+    const aggregatedItems = ($aa6caea9a60d18c7$export$f96d1c819a615a64)(itemRequirements);
+    if (aggregatedItems.filter((itemRequirement)=>{
+        return itemRequirement.type !== ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721 && itemRequirement.type !== ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20 && itemRequirement.type !== ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE;
+    }).length > 0) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Unsupported item requirement balance check", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).UNSUPPORTED_BALANCE_REQUIREMENT_ERROR);
+    // Get all ERC20 and NATIVE balances
+    const currentBalances = [];
+    const tokenItemRequirements = aggregatedItems.filter((itemRequirement)=>itemRequirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20 || itemRequirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE);
+    if (tokenItemRequirements.length > 0) currentBalances.push($beb896e098e41faf$var$getTokenBalances(config, provider, ownerAddress, aggregatedItems));
+    // Get all ERC721 balances
+    const erc721ItemRequirements = aggregatedItems.filter((itemRequirement)=>itemRequirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721);
+    if (erc721ItemRequirements.length > 0) currentBalances.push($beb896e098e41faf$var$getERC721Balances(provider, ownerAddress, aggregatedItems));
+    // Wait for all balances and calculate the requirements
+    const balanceRequirements = await Promise.all(currentBalances).then((balances)=>{
+        const requirements = [];
+        if (balances.length > 1 || tokenItemRequirements.length > 0) {
+            const tokenBalances = balances[0];
+            tokenItemRequirements.forEach((tokenItemRequirement)=>{
+                requirements.push(($73d2282a108cc7e2$export$6ab9757fda54db7e)(tokenItemRequirement, tokenBalances));
+            });
+            if (erc721ItemRequirements.length > 0) {
+                const erc721Balances = balances[1];
+                erc721ItemRequirements.forEach((erc721ItemRequirement)=>{
+                    requirements.push(($73d2282a108cc7e2$export$9b757e40b19984c3)(erc721ItemRequirement, erc721Balances));
+                });
+            }
+        } else if (erc721ItemRequirements.length > 0) {
+            // Only erc721
+            const erc721Balances = balances[0];
+            erc721ItemRequirements.forEach((erc721ItemRequirement)=>{
+                requirements.push(($73d2282a108cc7e2$export$9b757e40b19984c3)(erc721ItemRequirement, erc721Balances));
+            });
+        }
+        return requirements;
+    });
+    const sufficient = balanceRequirements.reduce((acc, balanceRequirement)=>{
+        return acc && balanceRequirement.sufficient;
+    }, true);
+    return {
+        sufficient: sufficient,
+        itemRequirements: balanceRequirements
+    };
+};
+
+
+
+
 
 
 
@@ -18240,7 +18634,7 @@ const $7d1bfafb81e64d74$export$3a4140bd9e983e4e = async (provider, insufficientI
 };
 
 
-const $0e7419077c373b24$export$9e073f9ada8c81e6 = async (provider, itemRequirements, transactionOrGasAmount)=>{
+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();
@@ -18259,6 +18653,9 @@ const $0e7419077c373b24$export$9e073f9ada8c81e6 = async (provider, itemRequireme
     }
     // 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: [
@@ -18356,13 +18753,13 @@ const $64863c39386de592$export$7f8e2b98eca5a7f0 = async (config, provider, order
     let type = ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE;
     let contractAddress = "";
     const buyArray = order.result.buy;
-    if (buyArray.length > 0) switch(buyArray[0].item_type){
+    if (buyArray.length > 0) switch(buyArray[0].type){
         case "NATIVE":
             type = ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE;
             break;
         case "ERC20":
             type = ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20;
-            contractAddress = buyArray[0].contract_address;
+            contractAddress = buyArray[0].contractAddress;
             break;
         default:
             throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Purchasing token type is unsupported", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).UNSUPPORTED_TOKEN_TYPE_ERROR, {
@@ -18370,7 +18767,7 @@ const $64863c39386de592$export$7f8e2b98eca5a7f0 = async (config, provider, order
             });
     }
     buyArray.forEach((item)=>{
-        if (item.item_type !== ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721) amount = amount.add((BigNumber$1).from(item.start_amount));
+        if (item.type !== ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721) amount = amount.add((BigNumber$1).from(item.amount));
     });
     const feeArray = order.result.fees;
     feeArray.forEach((item)=>{
@@ -18379,7 +18776,7 @@ const $64863c39386de592$export$7f8e2b98eca5a7f0 = async (config, provider, order
     const itemRequirements = [
         $64863c39386de592$export$4249179755829904(type, contractAddress, amount, spenderAddress)
     ];
-    await ($0e7419077c373b24$export$9e073f9ada8c81e6)(provider, itemRequirements, $64863c39386de592$export$8f2ff92ab8657f0b(gasLimit, unsignedTransaction));
+    await ($0e7419077c373b24$export$9e073f9ada8c81e6)(config, provider, itemRequirements, $64863c39386de592$export$8f2ff92ab8657f0b(gasLimit, unsignedTransaction));
     return {
         itemRequirements: itemRequirements,
         gasToken: {
@@ -18548,7 +18945,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);
-        await $0e7419077c373b24$export$9e073f9ada8c81e6(web3Provider, params.itemRequirements, params.transactionOrGasAmount);
+        await $0e7419077c373b24$export$9e073f9ada8c81e6(this.config, web3Provider, params.itemRequirements, params.transactionOrGasAmount);
     }
     /**
    * Checks if the given object is a Web3 provider.

package/dist/checkout_widgets.js

@@ -4,7 +4,7 @@ import { useEffect } from 'react';
 function $parcel$export(e, n, v, s) {
   Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
 }
-const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.14.0-alpha";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.14.0-alpha.2";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;
 

package/dist/immutablex_client.js

@@ -16,7 +16,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.14.0-alpha',
+    sdkVersion: 'ts-immutable-sdk-0.14.0-alpha.2',
 });
 /**
  * Sets `sdkVersion` at the time of build