@imtbl/sdk 0.14.0-alpha.1 → 0.15.0-alpha

package/dist/index.js

@@ -2398,7 +2398,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.14.0-alpha.1' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.15.0-alpha' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -2458,7 +2458,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.14.0-alpha.1',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.15.0-alpha',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -2730,7 +2730,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.14.0-alpha.1',
+    sdkVersion: 'ts-immutable-sdk-0.15.0-alpha',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -9506,6 +9506,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
@@ -9735,7 +9796,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);
@@ -9853,11 +9924,11 @@ class ImmutableApiClient {
                         contract_address: orderComponents.consideration[0].token,
                     },
                 ],
-                fees: makerFee ? [{
-                        amount: makerFee.amount,
-                        fee_type: FeeType.MAKER_MARKETPLACE,
-                        recipient: makerFee.recipient,
-                    }] : [],
+                fee: makerFee ? {
+                    amount: makerFee.amount,
+                    fee_type: FeeType.MAKER_MARKETPLACE,
+                    recipient: makerFee.recipient,
+                } : undefined,
                 end_time: new Date(parseInt(`${orderComponents.endTime.toString()}000`, 10)).toISOString(),
                 protocol_data: {
                     order_type: ProtocolData.order_type.FULL_RESTRICTED,
@@ -9924,67 +9995,6 @@ function getOrderbookConfig(environment) {
     }
 }
 
-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,
-    };
-}
-
 class SeaportLibFactory {
     defaultSeaportContractAddress;
     provider;
@@ -26917,6 +26927,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",
@@ -27199,6 +27211,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"
     }
 ];
 
@@ -27240,6 +27271,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";
@@ -27251,6 +27283,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";
@@ -27472,39 +27505,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$1).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$1).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);
+};
 
 
 
@@ -28253,6 +28295,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$1).formatUnits(delta, decimals)
+            },
+            current: tokenBalanceResult,
+            required: {
+                ...tokenBalanceResult,
+                balance: (BigNumber$1).from(itemRequirement.amount),
+                formattedBalance: (utils$1).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$1).formatUnits(delta, decimals)
+        },
+        current: tokenBalanceResult,
+        required: {
+            ...tokenBalanceResult,
+            balance: (BigNumber$1).from(itemRequirement.amount),
+            formattedBalance: (utils$1).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
+    };
+};
+
+
+
+
 
 
 
@@ -28309,7 +28623,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();
@@ -28328,6 +28642,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: [
@@ -28448,7 +28765,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: {
@@ -28617,7 +28934,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.
@@ -28656,7 +28973,7 @@ var checkout_sdk = /*#__PURE__*/Object.freeze({
 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.1";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.15.0-alpha";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;
 

package/dist/orderbook.d.ts

@@ -811,7 +811,10 @@ type CreateListingRequestBody = {
      * Buy item for listing should either be NATIVE or ERC20 item
      */
     buy: Array<Item>;
-    fees: Array<Fee$1>;
+    /**
+     * The maker marketplace fee
+     */
+    fee?: Fee$1;
     /**
      * Time after which the Order is considered expired
      */
@@ -1101,6 +1104,12 @@ interface SignableAction {
 type Action = TransactionAction | SignableAction;
 interface FulfillOrderResponse {
     actions: Action[];
+    /**
+     * User MUST submit the fulfillment transaction before the expiration
+     * Submitting after the expiration will result in a on chain revert
+     */
+    expiration: string;
+    order: Order;
 }
 interface CancelOrderResponse {
     unsignedCancelOrderTransaction: PopulatedTransaction;