@imtbl/minting-backend 2.0.0-alpha.0

package/dist/index.cjs

@@ -0,0 +1,618 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/index.ts
+var _blockchaindata = require('@imtbl/blockchain-data');
+var _webhook = require('@imtbl/webhook');
+var _metrics = require('@imtbl/metrics');
+
+// src/analytics/index.ts
+
+var moduleName = "minting_backend_sdk";
+var trackInitializePersistencePG = () => {
+  try {
+    _metrics.track.call(void 0, moduleName, "initializePersistencePG");
+  } catch (e3) {
+  }
+};
+var trackInitializePersistencePrismaSqlite = () => {
+  try {
+    _metrics.track.call(void 0, moduleName, "initializePersistencePrismaSqlite");
+  } catch (e4) {
+  }
+};
+var trackSubmitMintingRequests = () => {
+  try {
+    _metrics.track.call(void 0, moduleName, "submitMintingRequests");
+  } catch (e5) {
+  }
+};
+var trackProcessMint = () => {
+  try {
+    _metrics.track.call(void 0, moduleName, "processMint");
+  } catch (e6) {
+  }
+};
+var trackRecordMint = () => {
+  try {
+    _metrics.track.call(void 0, moduleName, "recordMint");
+  } catch (e7) {
+  }
+};
+var trackError = (error) => {
+  try {
+    _metrics.track.call(void 0, moduleName, "error", {
+      name: error.name,
+      message: error.message
+    });
+  } catch (e8) {
+  }
+};
+var trackUncaughtException = (error, origin) => {
+  try {
+    _metrics.track.call(void 0, moduleName, "error", {
+      name: error.name,
+      message: error.message,
+      origin
+    });
+  } catch (e9) {
+  }
+};
+
+// src/persistence/pg/postgres.ts
+var mintingPersistence = (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(`
+      WITH limited_assets AS (
+        SELECT id 
+        FROM im_assets 
+        WHERE minting_status IS NULL 
+        LIMIT $1 
+        FOR UPDATE SKIP LOCKED
+      )
+      UPDATE im_assets 
+        SET minting_status = 'submitting' 
+      WHERE minting_status IS NULL 
+        AND id IN (SELECT id FROM limited_assets)
+      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) => {
+      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;
+    }
+  };
+};
+
+// src/persistence/prismaSqlite/sqlite.ts
+var mintingPersistence2 = (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: {},
+        // Do nothing on conflict
+        create: {
+          assetId: request.asset_id,
+          contractAddress: request.contract_address,
+          ownerAddress: request.owner_address,
+          metadata: JSON.stringify(request.metadata),
+          // Serialize JSON metadata
+          amount: request.amount || null,
+          tokenId: request.token_id || null
+        }
+      });
+      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) => {
+      const existingAsset = await client.imAssets.findUnique({
+        where: {
+          im_assets_uindex: {
+            assetId: submittedMintRequest.assetId,
+            contractAddress: submittedMintRequest.contractAddress
+          }
+        }
+      });
+      if (existingAsset && (existingAsset.lastImtblZkevmMintRequestUpdatedId === null || existingAsset.lastImtblZkevmMintRequestUpdatedId < submittedMintRequest.imtblZkevmMintRequestUpdatedId)) {
+        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) {
+        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
+          }
+        });
+      }
+    },
+    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) => {
+      const assets = await client.imAssets.findMany({
+        where: {
+          id: {
+            in: ids
+          }
+        },
+        select: {
+          id: true,
+          triedCount: true
+          // Assuming the field is named triedCount
+        }
+      });
+      for (const asset of assets) {
+        await client.imAssets.update({
+          where: {
+            id: asset.id
+          },
+          data: {
+            mintingStatus: null,
+            triedCount: asset.triedCount + 1
+          }
+        });
+      }
+    },
+    getMintingRequest: async (contractAddress, referenceId) => {
+      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
+      };
+    }
+  };
+};
+
+// src/minting.ts
+var recordMint = async (mintingPersistence3, mintRequest) => {
+  trackRecordMint();
+  mintingPersistence3.recordMint(mintRequest);
+};
+var defaultMintingDelay = 1e3;
+var submitMintingRequests = async (mintingPersistence3, blockchainDataSDKClient, {
+  defaultBatchSize = 1e3,
+  chainName = "imtbl-zkevm-testnet",
+  maxNumberOfTries = 3
+}, logger = console, maxLoops = Infinity) => {
+  trackSubmitMintingRequests();
+  let mintingResponse;
+  let numberOfLoops = 0;
+  while (numberOfLoops++ < maxLoops) {
+    await new Promise((resolve) => {
+      setTimeout(resolve, defaultMintingDelay);
+    });
+    let batchSize = Math.min(
+      _optionalChain([mintingResponse, 'optionalAccess', _ => _.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) > /* @__PURE__ */ new Date()) {
+      logger.info(
+        `minting limit reached, waiting for reset at ${_optionalChain([mintingResponse, 'optionalAccess', _2 => _2.imx_mint_requests_limit_reset])}`
+      );
+      continue;
+    }
+    if (batchSize === 0) {
+      logger.info(
+        `minting limit has been reset, use default batch size: ${defaultBatchSize}`
+      );
+      mintingResponse = void 0;
+      batchSize = defaultBatchSize;
+    }
+    const pendingMints = await mintingPersistence3.getNextBatchForSubmission(
+      batchSize
+    );
+    if (pendingMints.length === 0) {
+      logger.info("no assets to mint");
+      continue;
+    }
+    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] }];
+    }, []);
+    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)}`
+            );
+            await mintingPersistence3.updateMintingStatusToSubmitted(
+              assets.map(({ id }) => id)
+            );
+            return response;
+          } catch (e) {
+            logger.error(e);
+            trackError(e);
+            if (e.code === "CONFLICT_ERROR" && _optionalChain([e, 'access', _3 => _3.details, 'optionalAccess', _4 => _4.id]) === "reference_id") {
+              try {
+                await mintingPersistence3.markAsConflict(
+                  e.details.values,
+                  contractAddress
+                );
+                await mintingPersistence3.resetMintingStatus(
+                  assets.map(({ id }) => id).filter((id) => !e.details.values.includes(id))
+                );
+              } catch (e2) {
+                logger.error(e2);
+                trackError(e);
+              }
+            } else {
+              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: []
+                }
+              );
+              await mintingPersistence3.markForRetry(
+                assetsToRetry
+              );
+              await mintingPersistence3.updateMintingStatusToSubmissionFailed(
+                assetsExceededMaxNumberOfTries
+              );
+            }
+            return e;
+          }
+        }
+      )
+    );
+    mintingResponse = _optionalChain([mintingResults, 'access', _5 => _5.reverse, 'call', _6 => _6(), 'access', _7 => _7.find, 'call', _8 => _8(
+      (r) => r.status === "fulfilled"
+    ), 'optionalAccess', _9 => _9.value]);
+  }
+};
+var processMint = async (mintingPersistence3, 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 mintingPersistence3.getMintingRequest(
+    contractAddress,
+    referenceId
+  );
+  if (!mintReq) {
+    logger.info(
+      `minting request not found in the database, ${JSON.stringify(event.data)}`
+    );
+  }
+  const ownerAddress = _optionalChain([mintReq, 'optionalAccess', _10 => _10.wallet_address]) || event.data.owner_address;
+  if (!ownerAddress) {
+    logger.error("owner_address missing");
+    throw new Error("owner_address missing");
+  }
+  await mintingPersistence3.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
+  });
+};
+
+// src/index.ts
+var noopHandlers = {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  zkevmMintRequestUpdated: async (event) => {
+  }
+};
+var MintingBackendModule = class {
+  
+  
+  
+  
+  constructor(config) {
+    this.baseConfig = config.baseConfig;
+    this.persistence = config.persistence;
+    this.logger = config.logger || console;
+    this.blockchainDataClient = new (0, _blockchaindata.BlockchainData)({
+      baseConfig: config.baseConfig
+    });
+    _metrics.setEnvironment.call(void 0, this.baseConfig.environment);
+    if (this.baseConfig.publishableKey) {
+      _metrics.setPublishableApiKey.call(void 0, 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 _webhook.handle.call(void 0, 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 (e10) {
+  }
+}
+
+
+
+
+
+
+
+exports.MintingBackendModule = MintingBackendModule; exports.mintingPersistencePg = mintingPersistence; exports.mintingPersistencePrismaSqlite = mintingPersistence2; exports.processMint = processMint; exports.recordMint = recordMint; exports.submitMintingRequests = submitMintingRequests;