@imtbl/sdk 1.33.0 → 1.34.0-alpha

package/dist/index.js

@@ -33,6 +33,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();
@@ -160,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.33.0';
+const SDK_VERSION$1 = '1.34.0-alpha';
 const getFrameParentDomain$1 = () => {
     if (isNode$1()) {
         return '';
@@ -14187,7 +14188,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$2 = { 'x-sdk-version': 'ts-immutable-sdk-1.33.0' };
+const defaultHeaders$2 = { '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');
@@ -14259,7 +14260,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders$1 = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-1.33.0',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-1.34.0-alpha',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -14733,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.33.0' };
+const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.34.0-alpha' };
 /**
  * @dev use createImmutableXConfiguration instead
  */
@@ -14772,7 +14773,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({
@@ -23594,12 +23595,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
@@ -23640,7 +23641,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)
@@ -23653,7 +23654,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);
@@ -32246,12 +32247,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
@@ -32292,7 +32293,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)
@@ -32305,7 +32306,7 @@ class Axios {
           serialize: paramsSerializer
         };
       } else {
-        validator.assertOptions(paramsSerializer, {
+        validator$1.assertOptions(paramsSerializer, {
           encode: validators.function,
           serialize: validators.function
         }, true);
@@ -57934,7 +57935,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 '';
@@ -63156,7 +63157,7 @@ const IMMUTABLE_ZKVEM_GAS_OVERRIDES = {
     maxPriorityFeePerGas: BigNumber$1.from(10e9),
 };
 
-const SDK_VERSION_MARKER = '1.33.0';
+const SDK_VERSION_MARKER = '1.34.0-alpha';
 // This SDK version is replaced by the `yarn build` command ran on the root level
 const globalPackageVersion = () => SDK_VERSION_MARKER;
 
@@ -68686,4 +68687,316 @@ var x = /*#__PURE__*/Object.freeze({
     sandbox: sandbox
 });
 
-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 (!msg.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
+});
+
+/* 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,
+    });
+};
+
+var minting_backend = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    mintingPersistencePg: mintingPersistence,
+    processMint: processMint,
+    recordMint: recordMint,
+    submitMintingRequests: submitMintingRequests
+});
+
+export { blockchain_data as blockchainData, checkout, config, minting_backend as mintingBackend, orderbook, passport, webhook, x };