@imtbl/sdk 1.35.2-alpha → 1.35.3

package/dist/index.js

@@ -33,7 +33,6 @@ import { keccak256 as keccak256$3 } from '@ethersproject/solidity';
 import { SwapRouter, PaymentsExtended } from '@uniswap/router-sdk';
 import { parseUnits as parseUnits$1 } from '@ethersproject/units';
 import { BigNumber as BigNumber$2 } from '@ethersproject/bignumber';
-import MessageValidator from 'sns-validator';
 
 const isNode$1 = () => typeof window === 'undefined';
 const isBrowser$1 = () => !isNode$1();
@@ -161,7 +160,7 @@ const flattenProperties$1 = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION$1 = '1.35.2-alpha';
+const SDK_VERSION$1 = '1.35.3';
 const getFrameParentDomain$1 = () => {
     if (isNode$1()) {
         return '';
@@ -14188,7 +14187,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$2 = { 'x-sdk-version': 'ts-immutable-sdk-1.35.2-alpha' };
+const defaultHeaders$2 = { 'x-sdk-version': 'ts-immutable-sdk-1.35.3' };
 const createConfig$1 = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -14260,7 +14259,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders$1 = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-1.35.2-alpha',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-1.35.3',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -14734,7 +14733,7 @@ var blockchain_data = /*#__PURE__*/Object.freeze({
 /* eslint-disable @typescript-eslint/naming-convention */
 class ApiConfiguration extends index$2.Configuration {
 }
-const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.35.2-alpha' };
+const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.35.3' };
 /**
  * @dev use createImmutableXConfiguration instead
  */
@@ -14773,7 +14772,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-1.35.2-alpha',
+    sdkVersion: 'ts-immutable-sdk-1.35.3',
     baseConfig,
 });
 const production = ({ baseConfig }) => createImmutableXConfiguration({
@@ -23595,12 +23594,12 @@ function assertOptions$1(options, schema, allowUnknown) {
   }
 }
 
-var validator$2 = {
+var validator$1 = {
   assertOptions: assertOptions$1,
   validators: validators$1$1
 };
 
-const validators$2 = validator$2.validators;
+const validators$2 = validator$1.validators;
 
 /**
  * Create a new instance of Axios
@@ -23641,7 +23640,7 @@ let Axios$2 = class Axios {
     const {transitional, paramsSerializer, headers} = config;
 
     if (transitional !== undefined) {
-      validator$2.assertOptions(transitional, {
+      validator$1.assertOptions(transitional, {
         silentJSONParsing: validators$2.transitional(validators$2.boolean),
         forcedJSONParsing: validators$2.transitional(validators$2.boolean),
         clarifyTimeoutError: validators$2.transitional(validators$2.boolean)
@@ -23654,7 +23653,7 @@ let Axios$2 = class Axios {
           serialize: paramsSerializer
         };
       } else {
-        validator$2.assertOptions(paramsSerializer, {
+        validator$1.assertOptions(paramsSerializer, {
           encode: validators$2.function,
           serialize: validators$2.function
         }, true);
@@ -25388,7 +25387,7 @@ async function exchangeTransfer$1({ user, starkSigner, request, exchangesApi, })
 
 const ERC721$1 = 'ERC721';
 async function createOrder$1({ starkSigner, user, request, ordersApi, guardianClient, }) {
-    return withPassportError(guardianClient.withDefaultConfirmationScreenTask(async () => {
+    return withPassportError(async () => {
         const { ethAddress } = user.imx;
         const amountSell = request.sell.type === ERC721$1 ? '1' : request.sell.amount;
         const amountBuy = request.buy.type === ERC721$1 ? '1' : request.buy.amount;
@@ -25434,10 +25433,10 @@ async function createOrder$1({ starkSigner, user, request, ordersApi, guardianCl
         return {
             ...createOrderResponse.data,
         };
-    }), PassportErrorType.CREATE_ORDER_ERROR);
+    }, PassportErrorType.CREATE_ORDER_ERROR);
 }
 async function cancelOrder$1({ user, starkSigner, request, ordersApi, guardianClient, }) {
-    return withPassportError(guardianClient.withDefaultConfirmationScreenTask(async () => {
+    return withPassportError(async () => {
         const getSignableCancelOrderRequest = {
             order_id: request.order_id,
         };
@@ -25464,7 +25463,7 @@ async function cancelOrder$1({ user, starkSigner, request, ordersApi, guardianCl
             order_id: cancelOrderResponse.data.order_id,
             status: cancelOrderResponse.data.status,
         };
-    }), PassportErrorType.CANCEL_ORDER_ERROR);
+    }, PassportErrorType.CANCEL_ORDER_ERROR);
 }
 
 async function registerPassport({ ethSigner, starkSigner, imxApiClients }, authorization) {
@@ -25496,7 +25495,7 @@ async function registerPassport({ ethSigner, starkSigner, imxApiClients }, autho
 }
 
 async function createTrade$1({ request, tradesApi, user, starkSigner, guardianClient, }) {
-    return withPassportError(guardianClient.withDefaultConfirmationScreenTask(async () => {
+    return withPassportError(async () => {
         const { ethAddress } = user.imx;
         const getSignableTradeRequest = {
             expiration_timestamp: request.expiration_timestamp,
@@ -25537,12 +25536,12 @@ async function createTrade$1({ request, tradesApi, user, starkSigner, guardianCl
             headers,
         });
         return createTradeResponse;
-    }), PassportErrorType.CREATE_TRADE_ERROR);
+    }, PassportErrorType.CREATE_TRADE_ERROR);
 }
 
 const ERC721 = 'ERC721';
 async function transfer$1({ request, transfersApi, starkSigner, user, guardianClient, }) {
-    return withPassportError(guardianClient.withDefaultConfirmationScreenTask(async () => {
+    return withPassportError(async () => {
         const transferAmount = request.type === ERC721 ? '1' : request.amount;
         const getSignableTransferRequest = {
             sender: user.imx.ethAddress,
@@ -25584,11 +25583,10 @@ async function transfer$1({ request, transfersApi, starkSigner, user, guardianCl
             time: responseData.time,
             transfer_id: responseData.transfer_id,
         };
-    }), PassportErrorType.TRANSFER_ERROR);
+    }, PassportErrorType.TRANSFER_ERROR);
 }
 async function batchNftTransfer({ user, starkSigner, request, transfersApi, guardianClient, }) {
-    // eslint-disable-next-line function-paren-newline
-    return withPassportError(guardianClient.withConfirmationScreenTask({ width: 480, height: 784 })(async () => {
+    return withPassportError(async () => {
         const { ethAddress } = user.imx;
         const signableRequests = request.map((nftTransfer) => ({
             amount: '1',
@@ -25632,7 +25630,7 @@ async function batchNftTransfer({ user, starkSigner, request, transfersApi, guar
         return {
             transfer_ids: response?.data.transfer_ids,
         };
-    }), PassportErrorType.TRANSFER_ERROR);
+    }, PassportErrorType.TRANSFER_ERROR);
 }
 
 const POLL_INTERVAL = 1 * 1000; // every 1 second
@@ -25783,14 +25781,16 @@ class PassportImxProvider {
         };
     }
     async transfer(request) {
-        const { user, starkSigner } = await this.#getRegisteredImxUserAndSigners();
-        return transfer$1({
-            request,
-            user,
-            starkSigner,
-            transfersApi: this.immutableXClient.transfersApi,
-            guardianClient: this.guardianClient,
-        });
+        return (this.guardianClient.withDefaultConfirmationScreenTask(async () => {
+            const { user, starkSigner } = await this.#getRegisteredImxUserAndSigners();
+            return transfer$1({
+                request,
+                user,
+                starkSigner,
+                transfersApi: this.immutableXClient.transfersApi,
+                guardianClient: this.guardianClient,
+            });
+        })());
     }
     async registerOffchain() {
         const [user, signers] = await Promise.all([
@@ -25808,44 +25808,52 @@ class PassportImxProvider {
         throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
     async createOrder(request) {
-        const { user, starkSigner } = await this.#getRegisteredImxUserAndSigners();
-        return createOrder$1({
-            request,
-            user,
-            starkSigner,
-            ordersApi: this.immutableXClient.ordersApi,
-            guardianClient: this.guardianClient,
-        });
+        return this.guardianClient.withDefaultConfirmationScreenTask(async () => {
+            const { user, starkSigner } = await this.#getRegisteredImxUserAndSigners();
+            return createOrder$1({
+                request,
+                user,
+                starkSigner,
+                ordersApi: this.immutableXClient.ordersApi,
+                guardianClient: this.guardianClient,
+            });
+        })();
     }
     async cancelOrder(request) {
-        const { user, starkSigner } = await this.#getRegisteredImxUserAndSigners();
-        return cancelOrder$1({
-            request,
-            user,
-            starkSigner,
-            ordersApi: this.immutableXClient.ordersApi,
-            guardianClient: this.guardianClient,
-        });
+        return this.guardianClient.withDefaultConfirmationScreenTask(async () => {
+            const { user, starkSigner } = await this.#getRegisteredImxUserAndSigners();
+            return cancelOrder$1({
+                request,
+                user,
+                starkSigner,
+                ordersApi: this.immutableXClient.ordersApi,
+                guardianClient: this.guardianClient,
+            });
+        })();
     }
     async createTrade(request) {
-        const { user, starkSigner } = await this.#getRegisteredImxUserAndSigners();
-        return createTrade$1({
-            request,
-            user,
-            starkSigner,
-            tradesApi: this.immutableXClient.tradesApi,
-            guardianClient: this.guardianClient,
-        });
+        return this.guardianClient.withDefaultConfirmationScreenTask(async () => {
+            const { user, starkSigner } = await this.#getRegisteredImxUserAndSigners();
+            return createTrade$1({
+                request,
+                user,
+                starkSigner,
+                tradesApi: this.immutableXClient.tradesApi,
+                guardianClient: this.guardianClient,
+            });
+        })();
     }
     async batchNftTransfer(request) {
-        const { user, starkSigner } = await this.#getRegisteredImxUserAndSigners();
-        return batchNftTransfer({
-            request,
-            user,
-            starkSigner,
-            transfersApi: this.immutableXClient.transfersApi,
-            guardianClient: this.guardianClient,
-        });
+        return this.guardianClient.withConfirmationScreenTask({ width: 480, height: 784 })(async () => {
+            const { user, starkSigner } = await this.#getRegisteredImxUserAndSigners();
+            return batchNftTransfer({
+                request,
+                user,
+                starkSigner,
+                transfersApi: this.immutableXClient.transfersApi,
+                guardianClient: this.guardianClient,
+            });
+        })();
     }
     async exchangeTransfer(request) {
         const { user, starkSigner } = await this.#getRegisteredImxUserAndSigners();
@@ -32307,12 +32315,12 @@ function assertOptions(options, schema, allowUnknown) {
   }
 }
 
-var validator$1 = {
+var validator = {
   assertOptions,
   validators: validators$1
 };
 
-const validators = validator$1.validators;
+const validators = validator.validators;
 
 /**
  * Create a new instance of Axios
@@ -32353,7 +32361,7 @@ class Axios {
     const {transitional, paramsSerializer, headers} = config;
 
     if (transitional !== undefined) {
-      validator$1.assertOptions(transitional, {
+      validator.assertOptions(transitional, {
         silentJSONParsing: validators.transitional(validators.boolean),
         forcedJSONParsing: validators.transitional(validators.boolean),
         clarifyTimeoutError: validators.transitional(validators.boolean)
@@ -32366,7 +32374,7 @@ class Axios {
           serialize: paramsSerializer
         };
       } else {
-        validator$1.assertOptions(paramsSerializer, {
+        validator.assertOptions(paramsSerializer, {
           encode: validators.function,
           serialize: validators.function
         }, true);
@@ -58091,7 +58099,7 @@ const flattenProperties = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION = '1.35.2-alpha';
+const SDK_VERSION = '1.35.3';
 const getFrameParentDomain = () => {
     if (isNode()) {
         return '';
@@ -63384,7 +63392,7 @@ const IMMUTABLE_ZKVEM_GAS_OVERRIDES = {
     maxPriorityFeePerGas: BigNumber$1.from(10e9),
 };
 
-const SDK_VERSION_MARKER = '1.35.2-alpha';
+const SDK_VERSION_MARKER = '1.35.3';
 // This SDK version is replaced by the `yarn build` command ran on the root level
 const globalPackageVersion = () => SDK_VERSION_MARKER;
 
@@ -67131,22 +67139,23 @@ const sell = async (config, provider, orders) => {
         decimals = await measureAsyncExecution(config, 'Time to get decimals of token contract for the buy token', buyTokenContract.decimals());
     }
     const buyTokenOrNative = getBuyToken(buyToken, decimals);
+    const sellTokenHasType = 'type' in sellToken;
     try {
         const walletAddress = await measureAsyncExecution(config, 'Time to get the address from the provider', provider.getSigner().getAddress());
         orderbook = createOrderbookInstance(config);
         const { seaportContractAddress } = orderbook.config();
         spenderAddress = seaportContractAddress;
-        const sellItem = sellToken.type === ItemType.ERC721
+        const sellItem = sellTokenHasType && sellToken.type === ItemType.ERC1155
             ? {
-                type: sellToken.type,
+                type: ItemType.ERC1155,
                 contractAddress: sellToken.collectionAddress,
                 tokenId: sellToken.id,
+                amount: sellToken.amount,
             }
             : {
-                type: sellToken.type,
+                type: ItemType.ERC721,
                 contractAddress: sellToken.collectionAddress,
                 tokenId: sellToken.id,
-                amount: sellToken.amount,
             };
         listing = await measureAsyncExecution(config, 'Time to prepare the listing from the orderbook', orderbook.prepareListing({
             makerAddress: walletAddress,
@@ -67162,11 +67171,15 @@ const sell = async (config, provider, orders) => {
             collectionAddress: sellToken.collectionAddress,
         });
     }
-    const itemRequirements = [
-        sellToken.type === ItemType.ERC721
-            ? getERC721Requirement(sellToken.id, sellToken.collectionAddress, spenderAddress)
-            : getERC1155Requirement(sellToken.id, sellToken.collectionAddress, spenderAddress, sellToken.amount),
-    ];
+    const itemRequirements = [];
+    if (sellTokenHasType && sellToken.type === ItemType.ERC1155) {
+        const erc1155ItemRequirement = getERC1155Requirement(sellToken.id, sellToken.collectionAddress, spenderAddress, sellToken.amount);
+        itemRequirements.push(erc1155ItemRequirement);
+    }
+    else {
+        const erc721ItemRequirement = getERC721Requirement(sellToken.id, sellToken.collectionAddress, spenderAddress);
+        itemRequirements.push(erc721ItemRequirement);
+    }
     let smartCheckoutResult;
     const isPassport = provider.provider?.isPassport;
     if (!isPassport) {
@@ -69045,504 +69058,4 @@ var x = /*#__PURE__*/Object.freeze({
     sandbox: sandbox
 });
 
-const validator = new MessageValidator();
-const allowedTopicArnPrefix = {
-    [Environment$1.PRODUCTION]: 'arn:aws:sns:us-east-2:362750628221:',
-    [Environment$1.SANDBOX]: 'arn:aws:sns:us-east-2:783421985614:'
-};
-const init = async (body, env, handlers) => {
-    const msg = await new Promise((resolve, reject) => {
-        validator.validate(body, (err, message) => {
-            if (err) {
-                return reject(err);
-            }
-            // check for topic arn prefix
-            if (!message.TopicArn.startsWith(allowedTopicArnPrefix[env])) {
-                throw new Error('Invalid topic arn');
-            }
-            if (message?.Type === 'SubscriptionConfirmation') {
-                fetch(message.SubscribeURL).then(() => {
-                    resolve(message);
-                }).catch((e) => {
-                    reject(e);
-                });
-            }
-            return resolve(message);
-        });
-    });
-    if (msg.Type === 'Notification') {
-        const event = JSON.parse(msg.Message);
-        switch (event.event_name) {
-            case 'imtbl_zkevm_mint_request_updated':
-                await handlers.zkevmMintRequestUpdated(event);
-                break;
-            default:
-                if (handlers.others) {
-                    await handlers.others(event);
-                }
-                break;
-        }
-    }
-};
-
-var webhook = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    init: init
-});
-
-const mintingPersistence$1 = (client) => ({
-    recordMint: async (request) => {
-        const r = await client.query(`
-      INSERT INTO im_assets (asset_id, contract_address, owner_address, metadata) 
-      VALUES ($1, $2, $3, $4) ON CONFLICT (asset_id) DO NOTHING;
-      `, [request.asset_id, request.contract_address, request.owner_address, request.metadata]);
-        if (r.rowCount === 0) {
-            throw new Error('Duplicated mint');
-        }
-    },
-    getNextBatchForSubmission: async (limit) => {
-        const res = await client.query(`
-      UPDATE im_assets SET minting_status = 'submitting' WHERE minting_status IS NULL and id in (
-          select id from im_assets where minting_status is null limit $1 for update skip locked
-      ) returning *;
-    `, [limit]);
-        return res.rows;
-    },
-    updateMintingStatusToSubmitted: async (ids) => {
-        await client.query(`
-              UPDATE im_assets SET minting_status = $2 WHERE id = ANY($1);
-            `, [ids, 'submitted']);
-    },
-    syncMintingStatus: async (submittedMintRequest) => {
-        // doing a upsert just in case the row has not been created yet
-        await client.query(`
-      INSERT INTO im_assets (
-        asset_id, 
-        contract_address, 
-        owner_address, 
-        token_id, 
-        minting_status, 
-        metadata_id, 
-        last_imtbl_zkevm_mint_request_updated_id, 
-        error
-      ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) ON CONFLICT (asset_id, contract_address)
-      DO UPDATE SET 
-        owner_address = $3,
-        token_id = $4,
-        minting_status = $5,
-        metadata_id = $6,
-        last_imtbl_zkevm_mint_request_updated_id = $7,
-        error = $8
-      where (
-        im_assets.last_imtbl_zkevm_mint_request_updated_id < $7 OR 
-        im_assets.last_imtbl_zkevm_mint_request_updated_id is null
-      );
-      `, [
-            submittedMintRequest.assetId,
-            submittedMintRequest.contractAddress,
-            submittedMintRequest.ownerAddress,
-            submittedMintRequest.tokenId,
-            submittedMintRequest.status,
-            submittedMintRequest.metadataId,
-            submittedMintRequest.imtblZkevmMintRequestUpdatedId,
-            submittedMintRequest.error
-        ]);
-    },
-    markAsConflict: async (assetIds, contractAddress) => {
-        await client.query(`
-      UPDATE im_assets 
-      SET minting_status = 'conflicting' 
-      WHERE asset_id = ANY($1) 
-        AND contract_address = $2;
-            `, [assetIds, contractAddress]);
-    },
-    resetMintingStatus: async (ids) => {
-        await client.query(`
-            UPDATE im_assets SET minting_status = null WHERE id = ANY($1);
-            `, [ids]);
-    },
-    markForRetry: async (ids) => {
-        await client.query(`
-      UPDATE im_assets 
-      SET minting_status = null, tried_count = tried_count + 1 WHERE id = ANY($1);
-      `, [ids]);
-    },
-    updateMintingStatusToSubmissionFailed: async (ids) => {
-        await client.query(`
-      UPDATE im_assets SET minting_status = 'submission_failed' WHERE id = ANY($1);
-    `, [ids]);
-    },
-    getMintingRequest: async (contractAddress, referenceId) => {
-        const res = await client.query(`
-      SELECT * FROM im_assets WHERE contract_address = $1 and asset_id = $2;
-    `, [contractAddress, referenceId]);
-        return res.rows[0] || null;
-    }
-});
-
-// client is a PrismaClient instance. it needs to be generated with
-// additional schema defined inside (TODO: point to repo) file.
-const mintingPersistence = (client) => ({
-    recordMint: async (request) => {
-        const result = await client.imAssets.upsert({
-            where: {
-                im_assets_uindex: {
-                    assetId: request.asset_id, contractAddress: request.contract_address
-                }
-            },
-            update: {},
-            create: {
-                assetId: request.asset_id,
-                contractAddress: request.contract_address,
-                ownerAddress: request.owner_address,
-                metadata: JSON.stringify(request.metadata), // Serialize JSON metadata
-            },
-        });
-        // Since upsert does not throw on update and does not tell directly if it updated or inserted,
-        // we need to add additional logic to handle this if "result" does not provide enough info.
-        if (!result) {
-            throw new Error('Duplicated mint');
-        }
-    },
-    // WARNING: this is NOT concurrency safe. Please only call this method one at a time.
-    getNextBatchForSubmission: async (limit) => {
-        const assets = await client.imAssets.findMany({
-            where: {
-                mintingStatus: null
-            },
-            take: limit
-        });
-        const assetIds = assets.map((asset) => asset.id);
-        await client.imAssets.updateMany({
-            where: {
-                id: {
-                    in: assetIds
-                }
-            },
-            data: {
-                mintingStatus: 'submitting'
-            }
-        });
-        const updatedAssets = await client.imAssets.findMany({
-            where: {
-                id: {
-                    in: assetIds
-                }
-            }
-        });
-        return updatedAssets.map((asset) => ({
-            id: asset.id,
-            contract_address: asset.contractAddress,
-            wallet_address: asset.ownerAddress,
-            asset_id: asset.assetId,
-            metadata: asset.metadata ? JSON.parse(asset.metadata) : null,
-            owner_address: asset.ownerAddress,
-            tried_count: asset.triedCount,
-        }));
-    },
-    updateMintingStatusToSubmitted: async (ids) => {
-        await client.imAssets.updateMany({
-            where: {
-                id: {
-                    in: ids
-                }
-            },
-            data: {
-                mintingStatus: 'submitted'
-            }
-        });
-    },
-    syncMintingStatus: async (submittedMintRequest) => {
-        // First, attempt to retrieve the existing asset
-        const existingAsset = await client.imAssets.findUnique({
-            where: {
-                im_assets_uindex: {
-                    assetId: submittedMintRequest.assetId,
-                    contractAddress: submittedMintRequest.contractAddress,
-                },
-            }
-        });
-        // Check if the asset exists and the condition for updating is met
-        if (existingAsset && (existingAsset.lastImtblZkevmMintRequestUpdatedId === null
-            || existingAsset.lastImtblZkevmMintRequestUpdatedId < submittedMintRequest.imtblZkevmMintRequestUpdatedId)) {
-            // Perform update if the existing record's lastImtblZkevmMintRequestUpdatedId is less than the new one or is null
-            await client.imAssets.update({
-                where: {
-                    im_assets_uindex: {
-                        assetId: submittedMintRequest.assetId,
-                        contractAddress: submittedMintRequest.contractAddress,
-                    },
-                },
-                data: {
-                    ownerAddress: submittedMintRequest.ownerAddress,
-                    tokenId: submittedMintRequest.tokenId,
-                    mintingStatus: submittedMintRequest.status,
-                    metadataId: submittedMintRequest.metadataId,
-                    lastImtblZkevmMintRequestUpdatedId: submittedMintRequest.imtblZkevmMintRequestUpdatedId,
-                    error: submittedMintRequest.error,
-                }
-            });
-        }
-        else if (!existingAsset) {
-            // Perform insert if no existing record is found
-            await client.imAssets.create({
-                data: {
-                    assetId: submittedMintRequest.assetId,
-                    contractAddress: submittedMintRequest.contractAddress,
-                    ownerAddress: submittedMintRequest.ownerAddress,
-                    tokenId: submittedMintRequest.tokenId,
-                    mintingStatus: submittedMintRequest.status,
-                    metadataId: submittedMintRequest.metadataId,
-                    lastImtblZkevmMintRequestUpdatedId: submittedMintRequest.imtblZkevmMintRequestUpdatedId,
-                    error: submittedMintRequest.error,
-                }
-            });
-        }
-        // If existing asset does not meet the update condition, do nothing
-    },
-    updateMintingStatusToSubmissionFailed: async (ids) => {
-        await client.imAssets.updateMany({
-            where: {
-                id: {
-                    in: ids
-                }
-            },
-            data: {
-                mintingStatus: 'submission_failed'
-            }
-        });
-    },
-    markAsConflict: async (assetIds, contractAddress) => {
-        await client.imAssets.updateMany({
-            where: {
-                assetId: {
-                    in: assetIds // Targets assets where assetId is in the provided list
-                },
-                contractAddress // Additional condition for contract address
-            },
-            data: {
-                mintingStatus: 'conflicting' // Set the new status
-            }
-        });
-    },
-    resetMintingStatus: async (ids) => {
-        await client.imAssets.updateMany({
-            where: {
-                id: {
-                    in: ids // Condition to match ids
-                }
-            },
-            data: {
-                mintingStatus: null // Setting minting_status to null
-            }
-        });
-    },
-    // this method is not concurrency safe
-    markForRetry: async (ids) => {
-        // Retrieve the current values of tried_count for the specified ids
-        const assets = await client.imAssets.findMany({
-            where: {
-                id: {
-                    in: ids
-                }
-            },
-            select: {
-                id: true,
-                triedCount: true // Assuming the field is named triedCount
-            }
-        });
-        // Update each asset with the new tried_count and nullify minting_status
-        for (const asset of assets) {
-            await client.imAssets.update({
-                where: {
-                    id: asset.id
-                },
-                data: {
-                    mintingStatus: null,
-                    triedCount: asset.triedCount + 1
-                }
-            });
-        }
-    },
-    getMintingRequest: async (contractAddress, referenceId) => {
-        // Retrieve the asset from the database based on contract_address and asset_id
-        const asset = await client.imAssets.findFirst({
-            where: {
-                contractAddress,
-                assetId: referenceId
-            }
-        });
-        if (!asset) {
-            return null;
-        }
-        return {
-            asset_id: asset.assetId,
-            contract_address: asset.contractAddress,
-            id: asset.id,
-            metadata: asset.metadata ? JSON.parse(asset.metadata) : null,
-            owner_address: asset.ownerAddress,
-            tried_count: asset.triedCount,
-            wallet_address: asset.ownerAddress
-        };
-    }
-});
-
-// TODO: expose metrics
-//       - submitting status count, conflicting status count
-//       - failed events count
-const recordMint = async (mintingPersistence, mintRequest) => {
-    mintingPersistence.recordMint(mintRequest);
-};
-const defaultMintingDelay = 1000;
-// This function can be called in different node process and will run in parallel to mint assets.
-// Each process will NOT mint the same asset.
-// Monitor your database to see if parallel processes are saturating the database CPU and triggering excessive vacuuming.
-// default batch size will be treated as 100 when it exceeds 100 because minting API has a limit of 100 assets per request.
-const submitMintingRequests = async (mintingPersistence, blockchainDataSDKClient, { defaultBatchSize = 1000, chainName = 'imtbl-zkevm-testnet', maxNumberOfTries = 3, }, logger = console) => {
-    let mintingResponse;
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-        await new Promise((resolve) => {
-            setTimeout(resolve, defaultMintingDelay);
-        });
-        let batchSize = Math.min(mintingResponse?.imx_remaining_mint_requests
-            ? parseInt(mintingResponse.imx_remaining_mint_requests, 10)
-            : defaultBatchSize, defaultBatchSize);
-        if (batchSize === 0
-            && mintingResponse
-            && new Date(mintingResponse.imx_mint_requests_limit_reset) > new Date()) {
-            logger.info(`minting limit reached, waiting for reset at ${mintingResponse?.imx_mint_requests_limit_reset}`);
-            continue;
-        }
-        if (batchSize === 0) {
-            logger.info(`minting limit has been reset, use default batch size: ${defaultBatchSize}`);
-            mintingResponse = undefined;
-            batchSize = defaultBatchSize;
-        }
-        // get mints to be submitted
-        const pendingMints = await mintingPersistence.getNextBatchForSubmission(batchSize);
-        if (pendingMints.length === 0) {
-            logger.info('no assets to mint');
-            continue;
-        }
-        // chunk assets by every 100 assets. every chunk should all be for the same contract address.
-        const chunkedAssets = pendingMints.sort((a, b) => (a.contract_address > b.contract_address ? 1 : -1)).reduce((acc, row) => {
-            if (acc.length === 0) {
-                return [{ contractAddress: row.contract_address, assets: [row] }];
-            }
-            const lastBatch = acc[acc.length - 1];
-            if (lastBatch.contractAddress === row.contract_address && lastBatch.assets.length < 100) {
-                return [...acc.slice(0, -1), { ...lastBatch, assets: [...lastBatch.assets, row] }];
-            }
-            return [...acc, { contractAddress: row.contract_address, assets: [row] }];
-        }, []);
-        // submit minting request for each contract address in parallel
-        const mintingResults = await Promise.allSettled(chunkedAssets.map(async ({ contractAddress, assets }) => {
-            const mintingRequest = {
-                chainName,
-                contractAddress,
-                createMintRequestRequest: {
-                    assets: assets.map((row) => ({
-                        reference_id: row.asset_id,
-                        owner_address: row.owner_address,
-                        metadata: row.metadata,
-                    })),
-                },
-            };
-            try {
-                const response = await blockchainDataSDKClient.createMintRequest(mintingRequest);
-                logger.info(`mintingResponse: ${JSON.stringify(response, null, 2)}`);
-                // update minting status to submitted
-                await mintingPersistence.updateMintingStatusToSubmitted(assets.map(({ id }) => id));
-                return response;
-            }
-            catch (e) {
-                logger.error(e);
-                if (e.code === 'CONFLICT_ERROR'
-                    && e.details?.id === 'reference_id') {
-                    try {
-                        // mark the assets as conflicting, so that we don't send them again.
-                        await mintingPersistence.markAsConflict(e.details.values, contractAddress);
-                        // remove non conflicting assets status so that they can be retried.
-                        await mintingPersistence.resetMintingStatus(assets
-                            .map(({ id }) => id)
-                            .filter((id) => !e.details.values.includes(id)));
-                    }
-                    catch (e2) {
-                        logger.error(e2);
-                    }
-                }
-                else {
-                    // separate assets into "need to be retied" and "exceeded max number of tries."
-                    const { assetsToRetry, assetsExceededMaxNumberOfTries } = assets.reduce((acc, { tried_count = 0, id }) => {
-                        if (tried_count < maxNumberOfTries) {
-                            acc.assetsToRetry.push(id);
-                        }
-                        else {
-                            acc.assetsExceededMaxNumberOfTries.push(id);
-                        }
-                        return acc;
-                    }, {
-                        assetsToRetry: [],
-                        assetsExceededMaxNumberOfTries: [],
-                    });
-                    // remove all assets status so that they can be retried.
-                    await mintingPersistence.markForRetry(assetsToRetry);
-                    // mark assets that have exceeded the max number of tries as submission_failed
-                    await mintingPersistence.updateMintingStatusToSubmissionFailed(assetsExceededMaxNumberOfTries);
-                }
-                return e;
-            }
-        }));
-        mintingResponse = mintingResults
-            .reverse()
-            .find((r) => r.status === 'fulfilled')?.value;
-    }
-};
-const processMint = async (mintingPersistence, event, logger = console) => {
-    if (event.event_name !== 'imtbl_zkevm_mint_request_updated') {
-        logger.info(`${event.event_name} is not imtbl_zkevm_mint_request_updated, skip.`);
-        return;
-    }
-    const referenceId = event.data.reference_id;
-    if (!referenceId) {
-        throw new Error('reference_id not found in webhook event');
-    }
-    const contractAddress = event.data.contract_address;
-    if (!contractAddress) {
-        throw new Error('contract_address not found in webhook event');
-    }
-    if (event.data.status === 'failed') {
-        logger.error(`mint failed: ${JSON.stringify(event.data, null, 2)}`);
-    }
-    const mintReq = await mintingPersistence.getMintingRequest(contractAddress, referenceId);
-    if (!mintReq) {
-        logger.info(`minting request not found in the database, ${JSON.stringify(event.data)}`);
-    }
-    const ownerAddress = mintReq?.wallet_address || event.data.owner_address;
-    if (!ownerAddress) {
-        logger.error('owner_address missing');
-        throw new Error('owner_address missing');
-    }
-    await mintingPersistence.syncMintingStatus({
-        tokenId: event.data.token_id,
-        status: event.data.status,
-        assetId: referenceId,
-        contractAddress,
-        ownerAddress,
-        metadataId: event.data.metadata_id,
-        imtblZkevmMintRequestUpdatedId: event.event_id,
-        error: event.data.error ? JSON.stringify(event.data.error) : null,
-    });
-};
-
-var minting_backend = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    mintingPersistencePg: mintingPersistence$1,
-    mintingPersistencePrismaSqlite: mintingPersistence,
-    processMint: processMint,
-    recordMint: recordMint,
-    submitMintingRequests: submitMintingRequests
-});
-
-export { blockchain_data as blockchainData, checkout, config, minting_backend as mintingBackend, orderbook, passport, webhook, x };
+export { blockchain_data as blockchainData, checkout, config, orderbook, passport, x };