@imtbl/sdk 1.35.2-alpha → 1.35.3

package/dist/minting_backend.js

@@ -1,447 +0,0 @@
-const mintingPersistence$1 = (client) => ({
-    recordMint: async (request) => {
-        const r = await client.query(`
-      INSERT INTO im_assets (asset_id, contract_address, owner_address, metadata) 
-      VALUES ($1, $2, $3, $4) ON CONFLICT (asset_id) DO NOTHING;
-      `, [request.asset_id, request.contract_address, request.owner_address, request.metadata]);
-        if (r.rowCount === 0) {
-            throw new Error('Duplicated mint');
-        }
-    },
-    getNextBatchForSubmission: async (limit) => {
-        const res = await client.query(`
-      UPDATE im_assets SET minting_status = 'submitting' WHERE minting_status IS NULL and id in (
-          select id from im_assets where minting_status is null limit $1 for update skip locked
-      ) returning *;
-    `, [limit]);
-        return res.rows;
-    },
-    updateMintingStatusToSubmitted: async (ids) => {
-        await client.query(`
-              UPDATE im_assets SET minting_status = $2 WHERE id = ANY($1);
-            `, [ids, 'submitted']);
-    },
-    syncMintingStatus: async (submittedMintRequest) => {
-        // doing a upsert just in case the row has not been created yet
-        await client.query(`
-      INSERT INTO im_assets (
-        asset_id, 
-        contract_address, 
-        owner_address, 
-        token_id, 
-        minting_status, 
-        metadata_id, 
-        last_imtbl_zkevm_mint_request_updated_id, 
-        error
-      ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) ON CONFLICT (asset_id, contract_address)
-      DO UPDATE SET 
-        owner_address = $3,
-        token_id = $4,
-        minting_status = $5,
-        metadata_id = $6,
-        last_imtbl_zkevm_mint_request_updated_id = $7,
-        error = $8
-      where (
-        im_assets.last_imtbl_zkevm_mint_request_updated_id < $7 OR 
-        im_assets.last_imtbl_zkevm_mint_request_updated_id is null
-      );
-      `, [
-            submittedMintRequest.assetId,
-            submittedMintRequest.contractAddress,
-            submittedMintRequest.ownerAddress,
-            submittedMintRequest.tokenId,
-            submittedMintRequest.status,
-            submittedMintRequest.metadataId,
-            submittedMintRequest.imtblZkevmMintRequestUpdatedId,
-            submittedMintRequest.error
-        ]);
-    },
-    markAsConflict: async (assetIds, contractAddress) => {
-        await client.query(`
-      UPDATE im_assets 
-      SET minting_status = 'conflicting' 
-      WHERE asset_id = ANY($1) 
-        AND contract_address = $2;
-            `, [assetIds, contractAddress]);
-    },
-    resetMintingStatus: async (ids) => {
-        await client.query(`
-            UPDATE im_assets SET minting_status = null WHERE id = ANY($1);
-            `, [ids]);
-    },
-    markForRetry: async (ids) => {
-        await client.query(`
-      UPDATE im_assets 
-      SET minting_status = null, tried_count = tried_count + 1 WHERE id = ANY($1);
-      `, [ids]);
-    },
-    updateMintingStatusToSubmissionFailed: async (ids) => {
-        await client.query(`
-      UPDATE im_assets SET minting_status = 'submission_failed' WHERE id = ANY($1);
-    `, [ids]);
-    },
-    getMintingRequest: async (contractAddress, referenceId) => {
-        const res = await client.query(`
-      SELECT * FROM im_assets WHERE contract_address = $1 and asset_id = $2;
-    `, [contractAddress, referenceId]);
-        return res.rows[0] || null;
-    }
-});
-
-// client is a PrismaClient instance. it needs to be generated with
-// additional schema defined inside (TODO: point to repo) file.
-const mintingPersistence = (client) => ({
-    recordMint: async (request) => {
-        const result = await client.imAssets.upsert({
-            where: {
-                im_assets_uindex: {
-                    assetId: request.asset_id, contractAddress: request.contract_address
-                }
-            },
-            update: {},
-            create: {
-                assetId: request.asset_id,
-                contractAddress: request.contract_address,
-                ownerAddress: request.owner_address,
-                metadata: JSON.stringify(request.metadata), // Serialize JSON metadata
-            },
-        });
-        // Since upsert does not throw on update and does not tell directly if it updated or inserted,
-        // we need to add additional logic to handle this if "result" does not provide enough info.
-        if (!result) {
-            throw new Error('Duplicated mint');
-        }
-    },
-    // WARNING: this is NOT concurrency safe. Please only call this method one at a time.
-    getNextBatchForSubmission: async (limit) => {
-        const assets = await client.imAssets.findMany({
-            where: {
-                mintingStatus: null
-            },
-            take: limit
-        });
-        const assetIds = assets.map((asset) => asset.id);
-        await client.imAssets.updateMany({
-            where: {
-                id: {
-                    in: assetIds
-                }
-            },
-            data: {
-                mintingStatus: 'submitting'
-            }
-        });
-        const updatedAssets = await client.imAssets.findMany({
-            where: {
-                id: {
-                    in: assetIds
-                }
-            }
-        });
-        return updatedAssets.map((asset) => ({
-            id: asset.id,
-            contract_address: asset.contractAddress,
-            wallet_address: asset.ownerAddress,
-            asset_id: asset.assetId,
-            metadata: asset.metadata ? JSON.parse(asset.metadata) : null,
-            owner_address: asset.ownerAddress,
-            tried_count: asset.triedCount,
-        }));
-    },
-    updateMintingStatusToSubmitted: async (ids) => {
-        await client.imAssets.updateMany({
-            where: {
-                id: {
-                    in: ids
-                }
-            },
-            data: {
-                mintingStatus: 'submitted'
-            }
-        });
-    },
-    syncMintingStatus: async (submittedMintRequest) => {
-        // First, attempt to retrieve the existing asset
-        const existingAsset = await client.imAssets.findUnique({
-            where: {
-                im_assets_uindex: {
-                    assetId: submittedMintRequest.assetId,
-                    contractAddress: submittedMintRequest.contractAddress,
-                },
-            }
-        });
-        // Check if the asset exists and the condition for updating is met
-        if (existingAsset && (existingAsset.lastImtblZkevmMintRequestUpdatedId === null
-            || existingAsset.lastImtblZkevmMintRequestUpdatedId < submittedMintRequest.imtblZkevmMintRequestUpdatedId)) {
-            // Perform update if the existing record's lastImtblZkevmMintRequestUpdatedId is less than the new one or is null
-            await client.imAssets.update({
-                where: {
-                    im_assets_uindex: {
-                        assetId: submittedMintRequest.assetId,
-                        contractAddress: submittedMintRequest.contractAddress,
-                    },
-                },
-                data: {
-                    ownerAddress: submittedMintRequest.ownerAddress,
-                    tokenId: submittedMintRequest.tokenId,
-                    mintingStatus: submittedMintRequest.status,
-                    metadataId: submittedMintRequest.metadataId,
-                    lastImtblZkevmMintRequestUpdatedId: submittedMintRequest.imtblZkevmMintRequestUpdatedId,
-                    error: submittedMintRequest.error,
-                }
-            });
-        }
-        else if (!existingAsset) {
-            // Perform insert if no existing record is found
-            await client.imAssets.create({
-                data: {
-                    assetId: submittedMintRequest.assetId,
-                    contractAddress: submittedMintRequest.contractAddress,
-                    ownerAddress: submittedMintRequest.ownerAddress,
-                    tokenId: submittedMintRequest.tokenId,
-                    mintingStatus: submittedMintRequest.status,
-                    metadataId: submittedMintRequest.metadataId,
-                    lastImtblZkevmMintRequestUpdatedId: submittedMintRequest.imtblZkevmMintRequestUpdatedId,
-                    error: submittedMintRequest.error,
-                }
-            });
-        }
-        // If existing asset does not meet the update condition, do nothing
-    },
-    updateMintingStatusToSubmissionFailed: async (ids) => {
-        await client.imAssets.updateMany({
-            where: {
-                id: {
-                    in: ids
-                }
-            },
-            data: {
-                mintingStatus: 'submission_failed'
-            }
-        });
-    },
-    markAsConflict: async (assetIds, contractAddress) => {
-        await client.imAssets.updateMany({
-            where: {
-                assetId: {
-                    in: assetIds // Targets assets where assetId is in the provided list
-                },
-                contractAddress // Additional condition for contract address
-            },
-            data: {
-                mintingStatus: 'conflicting' // Set the new status
-            }
-        });
-    },
-    resetMintingStatus: async (ids) => {
-        await client.imAssets.updateMany({
-            where: {
-                id: {
-                    in: ids // Condition to match ids
-                }
-            },
-            data: {
-                mintingStatus: null // Setting minting_status to null
-            }
-        });
-    },
-    // this method is not concurrency safe
-    markForRetry: async (ids) => {
-        // Retrieve the current values of tried_count for the specified ids
-        const assets = await client.imAssets.findMany({
-            where: {
-                id: {
-                    in: ids
-                }
-            },
-            select: {
-                id: true,
-                triedCount: true // Assuming the field is named triedCount
-            }
-        });
-        // Update each asset with the new tried_count and nullify minting_status
-        for (const asset of assets) {
-            await client.imAssets.update({
-                where: {
-                    id: asset.id
-                },
-                data: {
-                    mintingStatus: null,
-                    triedCount: asset.triedCount + 1
-                }
-            });
-        }
-    },
-    getMintingRequest: async (contractAddress, referenceId) => {
-        // Retrieve the asset from the database based on contract_address and asset_id
-        const asset = await client.imAssets.findFirst({
-            where: {
-                contractAddress,
-                assetId: referenceId
-            }
-        });
-        if (!asset) {
-            return null;
-        }
-        return {
-            asset_id: asset.assetId,
-            contract_address: asset.contractAddress,
-            id: asset.id,
-            metadata: asset.metadata ? JSON.parse(asset.metadata) : null,
-            owner_address: asset.ownerAddress,
-            tried_count: asset.triedCount,
-            wallet_address: asset.ownerAddress
-        };
-    }
-});
-
-// TODO: expose metrics
-//       - submitting status count, conflicting status count
-//       - failed events count
-const recordMint = async (mintingPersistence, mintRequest) => {
-    mintingPersistence.recordMint(mintRequest);
-};
-const defaultMintingDelay = 1000;
-// This function can be called in different node process and will run in parallel to mint assets.
-// Each process will NOT mint the same asset.
-// Monitor your database to see if parallel processes are saturating the database CPU and triggering excessive vacuuming.
-// default batch size will be treated as 100 when it exceeds 100 because minting API has a limit of 100 assets per request.
-const submitMintingRequests = async (mintingPersistence, blockchainDataSDKClient, { defaultBatchSize = 1000, chainName = 'imtbl-zkevm-testnet', maxNumberOfTries = 3, }, logger = console) => {
-    let mintingResponse;
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-        await new Promise((resolve) => {
-            setTimeout(resolve, defaultMintingDelay);
-        });
-        let batchSize = Math.min(mintingResponse?.imx_remaining_mint_requests
-            ? parseInt(mintingResponse.imx_remaining_mint_requests, 10)
-            : defaultBatchSize, defaultBatchSize);
-        if (batchSize === 0
-            && mintingResponse
-            && new Date(mintingResponse.imx_mint_requests_limit_reset) > new Date()) {
-            logger.info(`minting limit reached, waiting for reset at ${mintingResponse?.imx_mint_requests_limit_reset}`);
-            continue;
-        }
-        if (batchSize === 0) {
-            logger.info(`minting limit has been reset, use default batch size: ${defaultBatchSize}`);
-            mintingResponse = undefined;
-            batchSize = defaultBatchSize;
-        }
-        // get mints to be submitted
-        const pendingMints = await mintingPersistence.getNextBatchForSubmission(batchSize);
-        if (pendingMints.length === 0) {
-            logger.info('no assets to mint');
-            continue;
-        }
-        // chunk assets by every 100 assets. every chunk should all be for the same contract address.
-        const chunkedAssets = pendingMints.sort((a, b) => (a.contract_address > b.contract_address ? 1 : -1)).reduce((acc, row) => {
-            if (acc.length === 0) {
-                return [{ contractAddress: row.contract_address, assets: [row] }];
-            }
-            const lastBatch = acc[acc.length - 1];
-            if (lastBatch.contractAddress === row.contract_address && lastBatch.assets.length < 100) {
-                return [...acc.slice(0, -1), { ...lastBatch, assets: [...lastBatch.assets, row] }];
-            }
-            return [...acc, { contractAddress: row.contract_address, assets: [row] }];
-        }, []);
-        // submit minting request for each contract address in parallel
-        const mintingResults = await Promise.allSettled(chunkedAssets.map(async ({ contractAddress, assets }) => {
-            const mintingRequest = {
-                chainName,
-                contractAddress,
-                createMintRequestRequest: {
-                    assets: assets.map((row) => ({
-                        reference_id: row.asset_id,
-                        owner_address: row.owner_address,
-                        metadata: row.metadata,
-                    })),
-                },
-            };
-            try {
-                const response = await blockchainDataSDKClient.createMintRequest(mintingRequest);
-                logger.info(`mintingResponse: ${JSON.stringify(response, null, 2)}`);
-                // update minting status to submitted
-                await mintingPersistence.updateMintingStatusToSubmitted(assets.map(({ id }) => id));
-                return response;
-            }
-            catch (e) {
-                logger.error(e);
-                if (e.code === 'CONFLICT_ERROR'
-                    && e.details?.id === 'reference_id') {
-                    try {
-                        // mark the assets as conflicting, so that we don't send them again.
-                        await mintingPersistence.markAsConflict(e.details.values, contractAddress);
-                        // remove non conflicting assets status so that they can be retried.
-                        await mintingPersistence.resetMintingStatus(assets
-                            .map(({ id }) => id)
-                            .filter((id) => !e.details.values.includes(id)));
-                    }
-                    catch (e2) {
-                        logger.error(e2);
-                    }
-                }
-                else {
-                    // separate assets into "need to be retied" and "exceeded max number of tries."
-                    const { assetsToRetry, assetsExceededMaxNumberOfTries } = assets.reduce((acc, { tried_count = 0, id }) => {
-                        if (tried_count < maxNumberOfTries) {
-                            acc.assetsToRetry.push(id);
-                        }
-                        else {
-                            acc.assetsExceededMaxNumberOfTries.push(id);
-                        }
-                        return acc;
-                    }, {
-                        assetsToRetry: [],
-                        assetsExceededMaxNumberOfTries: [],
-                    });
-                    // remove all assets status so that they can be retried.
-                    await mintingPersistence.markForRetry(assetsToRetry);
-                    // mark assets that have exceeded the max number of tries as submission_failed
-                    await mintingPersistence.updateMintingStatusToSubmissionFailed(assetsExceededMaxNumberOfTries);
-                }
-                return e;
-            }
-        }));
-        mintingResponse = mintingResults
-            .reverse()
-            .find((r) => r.status === 'fulfilled')?.value;
-    }
-};
-const processMint = async (mintingPersistence, event, logger = console) => {
-    if (event.event_name !== 'imtbl_zkevm_mint_request_updated') {
-        logger.info(`${event.event_name} is not imtbl_zkevm_mint_request_updated, skip.`);
-        return;
-    }
-    const referenceId = event.data.reference_id;
-    if (!referenceId) {
-        throw new Error('reference_id not found in webhook event');
-    }
-    const contractAddress = event.data.contract_address;
-    if (!contractAddress) {
-        throw new Error('contract_address not found in webhook event');
-    }
-    if (event.data.status === 'failed') {
-        logger.error(`mint failed: ${JSON.stringify(event.data, null, 2)}`);
-    }
-    const mintReq = await mintingPersistence.getMintingRequest(contractAddress, referenceId);
-    if (!mintReq) {
-        logger.info(`minting request not found in the database, ${JSON.stringify(event.data)}`);
-    }
-    const ownerAddress = mintReq?.wallet_address || event.data.owner_address;
-    if (!ownerAddress) {
-        logger.error('owner_address missing');
-        throw new Error('owner_address missing');
-    }
-    await mintingPersistence.syncMintingStatus({
-        tokenId: event.data.token_id,
-        status: event.data.status,
-        assetId: referenceId,
-        contractAddress,
-        ownerAddress,
-        metadataId: event.data.metadata_id,
-        imtblZkevmMintRequestUpdatedId: event.event_id,
-        error: event.data.error ? JSON.stringify(event.data.error) : null,
-    });
-};
-
-export { mintingPersistence$1 as mintingPersistencePg, mintingPersistence as mintingPersistencePrismaSqlite, processMint, recordMint, submitMintingRequests };

package/dist/webhook.d.ts

@@ -1,11 +0,0 @@
-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 };