@imtbl/sdk 1.33.0 → 1.34.0-alpha

package/dist/minting_backend.js

@@ -0,0 +1,260 @@
+/* eslint-disable no-console */
+/* eslint-disable global-require */
+let optionalPackage = null;
+let pgClient = null;
+try {
+    optionalPackage = require('pg');
+    pgClient = new optionalPackage.Pool({
+        user: process.env.PG_USER || 'postgres',
+        host: process.env.PG_HOST || 'localhost',
+        database: process.env.PG_DB_NAME || 'nullus',
+        password: process.env.PG_PASSWORD || 'postgres',
+        port: parseInt(process.env.PG_PORT || '5432', 10) || 5432,
+    });
+}
+catch (error) {
+    console.error('pg is not installed. Please install it by running `npm install pg`');
+    optionalPackage = null;
+}
+const client = pgClient;
+
+const mintingPersistence = {
+    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) and contract_address = $2;
+            `, [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];
+    }
+};
+
+// 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
+            ? 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,
+    });
+};
+
+export { mintingPersistence as mintingPersistencePg, processMint, recordMint, submitMintingRequests };

package/dist/orderbook.js

@@ -132,7 +132,7 @@ const flattenProperties = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION = '1.33.0';
+const SDK_VERSION = '1.34.0-alpha';
 const getFrameParentDomain = () => {
     if (isNode()) {
         return '';

package/dist/passport.js

@@ -11459,7 +11459,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-1.33.0' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-1.34.0-alpha' };
 const createConfig$1 = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -11638,7 +11638,7 @@ const flattenProperties = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION = '1.33.0';
+const SDK_VERSION = '1.34.0-alpha';
 const getFrameParentDomain = () => {
     if (isNode()) {
         return '';
@@ -12028,7 +12028,7 @@ const addKeysToHeadersOverride = (baseConfig, overrides) => {
 /* eslint-disable @typescript-eslint/naming-convention */
 class ApiConfiguration extends index$2.Configuration {
 }
-const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.33.0' };
+const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.34.0-alpha' };
 /**
  * @dev use createImmutableXConfiguration instead
  */
@@ -12067,7 +12067,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-1.33.0',
+    sdkVersion: 'ts-immutable-sdk-1.34.0-alpha',
     baseConfig,
 });
 const production = ({ baseConfig }) => createImmutableXConfiguration({

package/dist/webhook.d.ts

@@ -0,0 +1,11 @@
+declare enum Environment {
+    PRODUCTION = "production",
+    SANDBOX = "sandbox"
+}
+
+declare const init: (body: string | Record<string, unknown>, env: Environment, handlers: {
+    zkevmMintRequestUpdated: (event: any) => Promise<void>;
+    others?: ((event: any) => Promise<void>) | undefined;
+}) => Promise<void>;
+
+export { init };