@imtbl/sdk 1.39.2 → 1.39.3-alpha.1

package/dist/index.js

@@ -34,6 +34,7 @@ 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 +162,7 @@ const flattenProperties$1 = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION$1 = '1.39.2';
+const SDK_VERSION$1 = '1.39.3-alpha.1';
 const getFrameParentDomain$1 = () => {
     if (isNode$1()) {
         return '';
@@ -14188,7 +14189,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$2 = { 'x-sdk-version': 'ts-immutable-sdk-1.39.2' };
+const defaultHeaders$2 = { 'x-sdk-version': 'ts-immutable-sdk-1.39.3-alpha.1' };
 const createConfig$1 = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -14260,7 +14261,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders$1 = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-1.39.2',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-1.39.3-alpha.1',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -14734,7 +14735,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.39.2' };
+const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.39.3-alpha.1' };
 /**
  * @dev use createImmutableXConfiguration instead
  */
@@ -14775,7 +14776,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     coreContractAddress,
     registrationContractAddress,
     registrationV4ContractAddress,
-    sdkVersion: 'ts-immutable-sdk-1.39.2',
+    sdkVersion: 'ts-immutable-sdk-1.39.3-alpha.1',
     baseConfig,
 });
 const production = ({ baseConfig }) => createImmutableXConfiguration({
@@ -26278,12 +26279,12 @@ function assertOptions$1(options, schema, allowUnknown) {
   }
 }
 
-var validator$1 = {
+var validator$2 = {
   assertOptions: assertOptions$1,
   validators: validators$1$1
 };
 
-const validators$2 = validator$1.validators;
+const validators$2 = validator$2.validators;
 
 /**
  * Create a new instance of Axios
@@ -26324,7 +26325,7 @@ let Axios$2 = class Axios {
     const {transitional, paramsSerializer, headers} = config;
 
     if (transitional !== undefined) {
-      validator$1.assertOptions(transitional, {
+      validator$2.assertOptions(transitional, {
         silentJSONParsing: validators$2.transitional(validators$2.boolean),
         forcedJSONParsing: validators$2.transitional(validators$2.boolean),
         clarifyTimeoutError: validators$2.transitional(validators$2.boolean)
@@ -26337,7 +26338,7 @@ let Axios$2 = class Axios {
           serialize: paramsSerializer
         };
       } else {
-        validator$1.assertOptions(paramsSerializer, {
+        validator$2.assertOptions(paramsSerializer, {
           encode: validators$2.function,
           serialize: validators$2.function
         }, true);
@@ -35056,12 +35057,12 @@ function assertOptions(options, schema, allowUnknown) {
   }
 }
 
-var validator = {
+var validator$1 = {
   assertOptions,
   validators: validators$1
 };
 
-const validators = validator.validators;
+const validators = validator$1.validators;
 
 /**
  * Create a new instance of Axios
@@ -35102,7 +35103,7 @@ class Axios {
     const {transitional, paramsSerializer, headers} = config;
 
     if (transitional !== undefined) {
-      validator.assertOptions(transitional, {
+      validator$1.assertOptions(transitional, {
         silentJSONParsing: validators.transitional(validators.boolean),
         forcedJSONParsing: validators.transitional(validators.boolean),
         clarifyTimeoutError: validators.transitional(validators.boolean)
@@ -35115,7 +35116,7 @@ class Axios {
           serialize: paramsSerializer
         };
       } else {
-        validator.assertOptions(paramsSerializer, {
+        validator$1.assertOptions(paramsSerializer, {
           encode: validators.function,
           serialize: validators.function
         }, true);
@@ -60874,7 +60875,7 @@ const flattenProperties = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION = '1.39.2';
+const SDK_VERSION = '1.39.3-alpha.1';
 const getFrameParentDomain = () => {
     if (isNode()) {
         return '';
@@ -66167,7 +66168,7 @@ const IMMUTABLE_ZKVEM_GAS_OVERRIDES = {
     maxPriorityFeePerGas: BigNumber$1.from(10e9),
 };
 
-const SDK_VERSION_MARKER = '1.39.2';
+const SDK_VERSION_MARKER = '1.39.3-alpha.1';
 // This SDK version is replaced by the `yarn build` command ran on the root level
 const globalPackageVersion = () => SDK_VERSION_MARKER;
 
@@ -71924,4 +71925,613 @@ var x = /*#__PURE__*/Object.freeze({
     starkEcOrder: starkEcOrder
 });
 
-export { blockchain_data as blockchainData, checkout, config, orderbook, passport, x };
+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 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 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);
+                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) => {
+    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) => { },
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    others: async (..._args) => { }
+};
+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 init(body, this.baseConfig.environment, {
+            zkevmMintRequestUpdated: async (event) => {
+                await processMint(this.persistence, event, this.logger);
+                otherHandlers.zkevmMintRequestUpdated(event);
+            },
+            others: otherHandlers.others
+        });
+    }
+}
+
+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 };