@imtbl/sdk 1.40.0-alpha.2 → 1.40.0

package/dist/index.js

@@ -34,7 +34,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();
@@ -162,7 +161,7 @@ const flattenProperties$1 = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION$1 = '1.40.0-alpha.2';
+const SDK_VERSION$1 = '1.40.0';
 const getFrameParentDomain$1 = () => {
     if (isNode$1()) {
         return '';
@@ -14189,7 +14188,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$2 = { 'x-sdk-version': 'ts-immutable-sdk-1.40.0-alpha.2' };
+const defaultHeaders$2 = { 'x-sdk-version': 'ts-immutable-sdk-1.40.0' };
 const createConfig$1 = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -14261,7 +14260,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders$1 = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-1.40.0-alpha.2',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-1.40.0',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -14735,7 +14734,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.40.0-alpha.2' };
+const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.40.0' };
 /**
  * @dev use createImmutableXConfiguration instead
  */
@@ -14776,7 +14775,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     coreContractAddress,
     registrationContractAddress,
     registrationV4ContractAddress,
-    sdkVersion: 'ts-immutable-sdk-1.40.0-alpha.2',
+    sdkVersion: 'ts-immutable-sdk-1.40.0',
     baseConfig,
 });
 const production = ({ baseConfig }) => createImmutableXConfiguration({
@@ -26279,12 +26278,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
@@ -26325,7 +26324,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)
@@ -26338,7 +26337,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);
@@ -35107,12 +35106,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
@@ -35153,7 +35152,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)
@@ -35166,7 +35165,7 @@ class Axios {
           serialize: paramsSerializer
         };
       } else {
-        validator$1.assertOptions(paramsSerializer, {
+        validator.assertOptions(paramsSerializer, {
           encode: validators.function,
           serialize: validators.function
         }, true);
@@ -60925,7 +60924,7 @@ const flattenProperties = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION = '1.40.0-alpha.2';
+const SDK_VERSION = '1.40.0';
 const getFrameParentDomain = () => {
     if (isNode()) {
         return '';
@@ -66243,7 +66242,7 @@ const IMMUTABLE_ZKVEM_GAS_OVERRIDES = {
     maxPriorityFeePerGas: BigNumber$1.from(10e9),
 };
 
-const SDK_VERSION_MARKER = '1.40.0-alpha.2';
+const SDK_VERSION_MARKER = '1.40.0';
 // This SDK version is replaced by the `yarn build` command ran on the root level
 const globalPackageVersion = () => SDK_VERSION_MARKER;
 
@@ -72003,743 +72002,4 @@ var x = /*#__PURE__*/Object.freeze({
     starkEcOrder: starkEcOrder
 });
 
-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:'
-};
-/**
- * handle will validate webhook message origin and verify signature of the message and calls corresponding handlers passed in.
- * @param body The request body to a webhook endpoint in json string or js object form.
- * @param env The Immutable environment the webhook is set up for.
- * @param handlers The optional handlers object for different events. The `all` handler will be triggered for all event types.
- * @returns The event object from the webhook message after validation and verification.
- */
-const handle = 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);
-        });
-    });
-    const event = JSON.parse(msg.Message);
-    if (msg.Type === 'Notification') {
-        switch (event.event_name) {
-            case 'imtbl_zkevm_mint_request_updated':
-                if (handlers?.zkevmMintRequestUpdated) {
-                    await handlers?.zkevmMintRequestUpdated(event);
-                }
-                break;
-            case 'imtbl_zkevm_activity_mint':
-                if (handlers?.zkEvmActivityMint) {
-                    await handlers?.zkEvmActivityMint(event);
-                }
-                break;
-            case 'imtbl_zkevm_activity_burn':
-                if (handlers?.zkEvmActivityBurn) {
-                    await handlers?.zkEvmActivityBurn(event);
-                }
-                break;
-            case 'imtbl_zkevm_activity_transfer':
-                if (handlers?.zkEvmActivityTransfer) {
-                    await handlers?.zkEvmActivityTransfer(event);
-                }
-                break;
-            case 'imtbl_zkevm_activity_sale':
-                if (handlers?.zkEvmActivitySale) {
-                    await handlers?.zkEvmActivitySale(event);
-                }
-                break;
-            case 'imtbl_zkevm_activity_deposit':
-                if (handlers?.zkEvmActivityDeposit) {
-                    await handlers?.zkEvmActivityDeposit(event);
-                }
-                break;
-            case 'imtbl_zkevm_activity_withdrawal':
-                if (handlers?.zkEvmActivityWithdrawal) {
-                    await handlers?.zkEvmActivityWithdrawal(event);
-                }
-                break;
-            case 'imtbl_zkevm_collection_updated':
-                if (handlers?.zkEvmCollectionUpdated) {
-                    await handlers?.zkEvmCollectionUpdated(event);
-                }
-                break;
-            case 'imtbl_zkevm_nft_updated':
-                if (handlers?.zkEvmNftUpdated) {
-                    await handlers?.zkEvmNftUpdated(event);
-                }
-                break;
-            case 'imtbl_zkevm_metadata_updated':
-                if (handlers?.zkEvmMetadataUpdated) {
-                    await handlers?.zkEvmMetadataUpdated(event);
-                }
-                break;
-            case 'imtbl_zkevm_token_updated':
-                if (handlers?.zkEvmTokenUpdated) {
-                    await handlers?.zkEvmTokenUpdated(event);
-                }
-                break;
-            case 'imtbl_zkevm_order_updated':
-                if (handlers?.zkEvmOrderUpdated) {
-                    await handlers?.zkEvmOrderUpdated(event);
-                }
-                break;
-            case 'imtbl_zkevm_trade_created':
-                if (handlers?.zkEvmTradeCreated) {
-                    await handlers?.zkEvmTradeCreated(event);
-                }
-                break;
-            case 'imtbl_x_nft_created':
-                if (handlers?.xNftCreated) {
-                    await handlers?.xNftCreated(event);
-                }
-                break;
-            case 'imtbl_x_nft_updated':
-                if (handlers?.xNftUpdated) {
-                    await handlers?.xNftUpdated(event);
-                }
-                break;
-            case 'imtbl_x_order_accepted':
-                if (handlers?.xOrderAccepted) {
-                    await handlers?.xOrderAccepted(event);
-                }
-                break;
-            case 'imtbl_x_order_filled':
-                if (handlers?.xOrderFilled) {
-                    await handlers?.xOrderFilled(event);
-                }
-                break;
-            case 'imtbl_x_order_cancelled':
-                if (handlers?.xOrderCancelled) {
-                    await handlers?.xOrderCancelled(event);
-                }
-                break;
-            case 'imtbl_x_transfer_created':
-                if (handlers?.xTransferCreated) {
-                    await handlers?.xTransferCreated(event);
-                }
-                break;
-        }
-        if (handlers?.all) {
-            await handlers?.all(event);
-        }
-    }
-    return event;
-};
-
-var webhook = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    handle: handle
-});
-
-const moduleName = 'minting_backend_sdk';
-const trackInitializePersistencePG = () => {
-    try {
-        track(moduleName, 'initializePersistencePG');
-    }
-    catch {
-        // ignore
-    }
-};
-const trackInitializePersistencePrismaSqlite = () => {
-    try {
-        track(moduleName, 'initializePersistencePrismaSqlite');
-    }
-    catch {
-        // ignore
-    }
-};
-const trackSubmitMintingRequests = () => {
-    try {
-        track(moduleName, 'submitMintingRequests');
-    }
-    catch {
-        // ignore
-    }
-};
-const trackProcessMint = () => {
-    try {
-        track(moduleName, 'processMint');
-    }
-    catch {
-        // ignore
-    }
-};
-const trackRecordMint = () => {
-    try {
-        track(moduleName, 'recordMint');
-    }
-    catch {
-        // ignore
-    }
-};
-const trackError = (error) => {
-    try {
-        track(moduleName, 'error', {
-            name: error.name,
-            message: error.message
-        });
-    }
-    catch {
-        // ignore
-    }
-};
-const trackUncaughtException = (error, origin) => {
-    try {
-        track(moduleName, 'error', {
-            name: error.name,
-            message: error.message,
-            origin,
-        });
-    }
-    catch {
-        // ignore
-    }
-};
-
-const mintingPersistence$1 = (client) => {
-    trackInitializePersistencePG();
-    return {
-        recordMint: async (request) => {
-            const r = await client.query(`
-        INSERT INTO im_assets (asset_id, contract_address, owner_address, metadata, amount, token_id) 
-        VALUES ($1, $2, $3, $4, $5, $6) ON CONFLICT (asset_id, contract_address) DO NOTHING;
-        `, [
-                request.asset_id, request.contract_address, request.owner_address,
-                request.metadata, request.amount, request.token_id
-            ]);
-            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,
-          amount
-        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9) 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,
-                submittedMintRequest.amount
-            ]);
-        },
-        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;
-        }
-    };
-};
-
-/* eslint-disable no-await-in-loop */
-/* eslint-disable @typescript-eslint/naming-convention */
-// client is a PrismaClient instance. it needs to be generated with
-// additional schema defined inside (TODO: point to repo) file.
-const mintingPersistence = (client) => {
-    trackInitializePersistencePrismaSqlite();
-    return {
-        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),
-                    amount: request.amount || null,
-                    tokenId: request.token_id || null,
-                },
-            });
-            // 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,
-                amount: asset.amount || null,
-                token_id: asset.tokenId || null,
-            }));
-        },
-        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,
-                        amount: submittedMintRequest.amount || null
-                    }
-                });
-            }
-            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,
-                        amount: submittedMintRequest.amount || null
-                    }
-                });
-            }
-            // 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,
-                amount: asset.amount || null
-            };
-        }
-    };
-};
-
-// TODO: expose metrics
-//       - submitting status count, conflicting status count
-//       - failed events count
-const recordMint = async (mintingPersistence, mintRequest) => {
-    trackRecordMint();
-    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) => {
-    trackSubmitMintingRequests();
-    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,
-                        token_id: row.token_id,
-                        amount: row.amount ? `${row.amount}` : null,
-                    })),
-                },
-            };
-            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);
-                trackError(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);
-                        trackError(e);
-                    }
-                }
-                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) => {
-    trackProcessMint();
-    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,
-        amount: event.data.amount || null,
-    });
-};
-
-const noopHandlers = {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    zkevmMintRequestUpdated: async (event) => { }
-};
-class MintingBackendModule {
-    baseConfig;
-    persistence;
-    blockchainDataClient;
-    logger;
-    constructor(config) {
-        this.baseConfig = config.baseConfig;
-        this.persistence = config.persistence;
-        this.logger = config.logger || console;
-        this.blockchainDataClient = new BlockchainData({
-            baseConfig: config.baseConfig
-        });
-        setEnvironment(this.baseConfig.environment);
-        if (this.baseConfig.publishableKey) {
-            setPublishableApiKey(this.baseConfig.publishableKey);
-        }
-    }
-    async recordMint(mintRequest) {
-        await recordMint(this.persistence, mintRequest);
-    }
-    async submitMintingRequests(config) {
-        await submitMintingRequests(this.persistence, this.blockchainDataClient, config);
-    }
-    async processMint(body, otherHandlers = noopHandlers) {
-        await handle(body, this.baseConfig.environment, {
-            zkevmMintRequestUpdated: async (event) => {
-                await processMint(this.persistence, event, this.logger);
-                if (otherHandlers.zkevmMintRequestUpdated) {
-                    otherHandlers.zkevmMintRequestUpdated(event);
-                }
-            }
-        });
-    }
-}
-if (typeof process !== 'undefined' && process.on) {
-    try {
-        process.on('uncaughtExceptionMonitor', trackUncaughtException);
-    }
-    catch {
-        // ignore
-    }
-}
-
-var minting_backend = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    MintingBackendModule: MintingBackendModule,
-    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 };