@verii/endpoints-event-processing 1.0.0-pre.1752076816

package/src/handlers/handle-coupons-burned-verification-event.js

@@ -0,0 +1,188 @@
+const { map, zip } = require('lodash/fp');
+const { initVerificationCoupon } = require('@verii/metadata-registration');
+
+const { batchOperations } = require('@verii/fineract-client');
+const { getDidAndAliases } = require('@verii/did-doc');
+
+const task = 'coupons-burned-verification';
+
+const { initDocumentFunctions, mapCouponBurned } = require('../helpers');
+
+const initReadEventsFromBlock = async (context) => {
+  const { config } = context;
+  const { pullBurnCouponEvents } = await initVerificationCoupon(
+    {
+      contractAddress: config.couponContractAddress,
+      rpcProvider: context.rpcProvider,
+    },
+    context
+  );
+
+  return async (block) => {
+    return pullBurnCouponEvents(block);
+  };
+};
+const syncBurnsWithFineract = async (
+  { burnerDidToBundleMap, organizationsMap, burnEvents },
+  context
+) => {
+  const { log } = context;
+  if (burnerDidToBundleMap.size === 0) {
+    return [];
+  }
+
+  const voucherQuantitiesToBurn = map((burnEvent) => {
+    const orgOfBurnEvent = organizationsMap.get(burnEvent.burnerDid);
+    return {
+      clientId: orgOfBurnEvent.ids.fineractClientId,
+      quantity: 1,
+      submittedOnDate: burnEvent.burnTime,
+    };
+  }, burnEvents);
+
+  log.info({ task, voucherQuantitiesToBurn });
+  const batchResponses = await batchOperations(
+    { clientVoucherBurns: voucherQuantitiesToBurn, transactionalBatch: false },
+    context
+  );
+
+  for (const [payload, batchResponse] of zip(
+    voucherQuantitiesToBurn,
+    batchResponses
+  )) {
+    if (batchResponse.statusCode >= 400)
+      log.warn({
+        code: 'failed-burn-sync',
+        batchResponse,
+        payload,
+      });
+  }
+
+  return batchResponses;
+};
+
+const writeBurnsToDatabase = async (
+  { burnerDidToBundleMap, organizationsMap },
+  context
+) => {
+  const { repos } = context;
+  if (burnerDidToBundleMap.size === 0) {
+    return [];
+  }
+  const now = new Date();
+  const burnedCouponsProms = [];
+  for (const [burnerDid, bundleToBurnsMap] of burnerDidToBundleMap.entries()) {
+    for (const [bundleId, count] of bundleToBurnsMap.entries()) {
+      const prom = async () => {
+        const purchase = await repos.purchases.findOne({
+          filter: {
+            'couponBundle.couponBundleId': bundleId,
+            $expr: { $lt: ['$couponBundle.used', '$couponBundle.quantity'] },
+          },
+        });
+
+        if (!purchase) return Promise.resolve();
+
+        await repos.purchases.collection().findOneAndUpdate(
+          { _id: purchase._id },
+          {
+            $inc: {
+              'couponBundle.used': count,
+            },
+          }
+        );
+
+        return repos.burnedCoupons.insert({
+          purchaseId: purchase.purchaseId,
+          used: count,
+          at: now,
+          clientId: organizationsMap.get(burnerDid)?.ids.brokerClientId,
+        });
+      };
+      burnedCouponsProms.push(prom());
+    }
+  }
+  return Promise.all(burnedCouponsProms);
+};
+
+const processEventGenerator = async ({ eventsCursor }, context) => {
+  const burnerDidToBundleMap = new Map();
+  let numberOfEventsRead = 0;
+  let burnEvents = [];
+  for await (const selectedEvents of eventsCursor()) {
+    const mappedEvents = map(
+      (evt) => mapCouponBurned(evt, context),
+      selectedEvents
+    );
+    burnEvents = [...burnEvents, ...mappedEvents];
+    numberOfEventsRead += selectedEvents.length;
+    for (const evt of mappedEvents) {
+      const { burnerDid, bundleIdHex: bundleId } = evt;
+      // eslint-disable-next-line max-depth
+      if (!burnerDidToBundleMap.has(burnerDid)) {
+        burnerDidToBundleMap.set(burnerDid, new Map());
+      }
+      const bundleToBurnsMap = burnerDidToBundleMap.get(burnerDid);
+      // eslint-disable-next-line max-depth
+      if (!bundleToBurnsMap.has(bundleId)) {
+        bundleToBurnsMap.set(bundleId, 0);
+      }
+      bundleToBurnsMap.set(bundleId, bundleToBurnsMap.get(bundleId) + 1);
+    }
+  }
+  return {
+    burnEvents,
+    numberOfEventsRead,
+    burnerDidToBundleMap,
+  };
+};
+
+const handleCouponsBurnedVerificationEvent = async (context) => {
+  const { log, repos } = context;
+  const { readLastSuccessfulBlock, writeLastSuccessfulBlock } =
+    initDocumentFunctions({ eventName: task }, context);
+
+  const readEventsFromBlock = await initReadEventsFromBlock(context);
+
+  const lastReadBlock = await readLastSuccessfulBlock();
+  log.info({ task, lastReadBlock });
+  const initialBlockNumber = lastReadBlock + 1;
+  const { eventsCursor, latestBlock } = await readEventsFromBlock(
+    initialBlockNumber
+  );
+
+  const { numberOfEventsRead, burnEvents, burnerDidToBundleMap } =
+    await processEventGenerator({ eventsCursor }, context);
+  log.info({
+    task,
+    lastReadBlock,
+    numberOfEventsRead,
+  });
+
+  const organizations = await repos.organizations.findByDids(
+    Array.from(burnerDidToBundleMap.keys())
+  );
+  const organizationsMap = new Map();
+  for (const organization of organizations) {
+    const ids = getDidAndAliases(organization?.didDoc);
+    for (const id of ids) {
+      organizationsMap.set(id, organization);
+    }
+  }
+
+  await writeBurnsToDatabase(
+    { burnerDidToBundleMap, organizationsMap },
+    context
+  );
+  await syncBurnsWithFineract(
+    { burnerDidToBundleMap, organizationsMap, burnEvents },
+    context
+  );
+
+  log.info({ task, latestBlock });
+  await writeLastSuccessfulBlock(latestBlock);
+};
+
+module.exports = {
+  handleCouponsBurnedVerificationEvent,
+};

package/src/handlers/handle-coupons-minted-logging-event.js

@@ -0,0 +1,73 @@
+const { map, forEach } = require('lodash/fp');
+const { toHexString } = require('@verii/blockchain-functions');
+const { initVerificationCoupon } = require('@verii/metadata-registration');
+const { initDocumentFunctions } = require('../helpers');
+
+const task = 'coupons-minted-logging';
+
+const mapEvent = (event) => ({
+  blockNumber: event.blockNumber,
+  blockHash: event.blockHash,
+  transactionIndex: event.transactionIndex,
+  transactionHash: event.transactionHash,
+  event: event.fragment.name,
+  owner: event.args[0],
+  bundleId: `${event.args[1]}`,
+  bundleIdHex: toHexString(event.args[1]),
+  expirationTime: new Date(Number(`${event.args[2]}`) * 1000),
+  quantity: `${event.args[3]}`,
+  eventTraceId: event.args[4],
+  ownerDid: event.args[5],
+});
+
+const initReadEventsFromBlock = async (context) => {
+  const { config } = context;
+  const { pullMintCouponBundleEvents } = await initVerificationCoupon(
+    {
+      contractAddress: config.couponContractAddress,
+      rpcProvider: context.rpcProvider,
+    },
+    context
+  );
+
+  return async (block) => {
+    return pullMintCouponBundleEvents(block);
+  };
+};
+
+const handleCouponsMintedLoggingEvent = async (context) => {
+  const { log } = context;
+  const { readLastSuccessfulBlock, writeLastSuccessfulBlock } =
+    initDocumentFunctions({ eventName: task }, context);
+
+  const readEventsFromBlock = await initReadEventsFromBlock(context);
+
+  const lastReadBlock = await readLastSuccessfulBlock();
+
+  log.info({ task, lastReadBlock });
+
+  const { eventsCursor, latestBlock } = await readEventsFromBlock(
+    lastReadBlock + 1
+  );
+  let numberOfEventsRead = 0;
+  for await (const events of eventsCursor()) {
+    numberOfEventsRead += events.length;
+    const mappedEvents = map(mapEvent, events);
+    forEach((event) => {
+      log.info(event);
+    }, mappedEvents);
+  }
+
+  log.info({
+    task,
+    lastReadBlock,
+    numberOfEventsRead,
+  });
+
+  log.info({ task, latestBlock });
+  await writeLastSuccessfulBlock(latestBlock);
+};
+
+module.exports = {
+  handleCouponsMintedLoggingEvent,
+};

package/src/handlers/handle-credential-issued-logging-event.js

@@ -0,0 +1,70 @@
+const { map, forEach } = require('lodash/fp');
+const { initMetadataRegistry } = require('@verii/metadata-registration');
+const { initDocumentFunctions, decodeIssuerVc } = require('../helpers');
+
+const task = 'credential-issued-logging';
+
+const mapEvent = (event) => ({
+  blockNumber: event.blockNumber,
+  blockHash: event.blockHash,
+  transactionIndex: event.transactionIndex,
+  transactionHash: event.transactionHash,
+  event: event.fragment.name,
+  sender: event.args[0],
+  issuerDid: decodeIssuerVc(event.args[1]),
+  listId: `${event.args[2]}`,
+  credentialType: event.args[3],
+  index: `${event.args[4]}`,
+  eventTraceId: event.args[5],
+  caoDid: event.args[6],
+});
+
+const initReadEventsFromBlock = async (context) => {
+  const { config } = context;
+  const { pullAddedCredentialMetadataEvents } = await initMetadataRegistry(
+    {
+      contractAddress: config.metadataRegistryContractAddress,
+      rpcProvider: context.rpcProvider,
+    },
+    context
+  );
+
+  return async (block) => {
+    return pullAddedCredentialMetadataEvents(block);
+  };
+};
+
+const handleCredentialIssuedLoggingEvent = async (context) => {
+  const { log } = context;
+  const { readLastSuccessfulBlock, writeLastSuccessfulBlock } =
+    initDocumentFunctions({ eventName: task }, context);
+
+  const readEventsFromBlock = await initReadEventsFromBlock(context);
+
+  const lastReadBlock = await readLastSuccessfulBlock();
+
+  log.info({ task, lastReadBlock });
+
+  const { eventsCursor, latestBlock } = await readEventsFromBlock(
+    lastReadBlock + 1
+  );
+  let numberOfEventsRead = 0;
+  for await (const events of eventsCursor()) {
+    numberOfEventsRead += events.length;
+    const mappedEvents = map(mapEvent, events);
+    forEach((event) => log.info(event), mappedEvents);
+  }
+
+  log.info({
+    task,
+    lastReadBlock,
+    numberOfEventsRead,
+  });
+
+  log.info({ task, latestBlock });
+  await writeLastSuccessfulBlock(latestBlock);
+};
+
+module.exports = {
+  handleCredentialIssuedLoggingEvent,
+};

package/src/handlers/handle-credential-issued-rewards-event.js

@@ -0,0 +1,218 @@
+const {
+  partition,
+  reduce,
+  map,
+  size,
+  isEmpty,
+  uniq,
+  flow,
+  find,
+} = require('lodash/fp');
+const { initMetadataRegistry } = require('@verii/metadata-registration');
+
+const { get2BytesHash } = require('@verii/crypto');
+const { batchTransferCredits } = require('@verii/fineract-client');
+
+const { getDidAndAliases } = require('@verii/did-doc');
+const { TransactionReasons } = require('../entities');
+const { decodeIssuerVc, initDocumentFunctions } = require('../helpers');
+
+const task = 'credential-issued-rewards';
+
+const initReadEventsFromBlock = async (context) => {
+  const { config } = context;
+  const { pullAddedCredentialMetadataEvents } = await initMetadataRegistry(
+    {
+      contractAddress: config.metadataRegistryContractAddress,
+      rpcProvider: context.rpcProvider,
+    },
+    context
+  );
+
+  return async (block) => {
+    return pullAddedCredentialMetadataEvents(block);
+  };
+};
+const executeTransfers = async (
+  { rewardsDictionary, organizations },
+  context
+) => {
+  const {
+    config: { vnfRewardDispersalAccountId },
+    log,
+  } = context;
+  if (isEmpty(rewardsDictionary)) {
+    return [];
+  }
+  const transfers = reduce(
+    (acc, nextOrganization) => {
+      const dids = getDidAndAliases(nextOrganization?.didDoc);
+      for (const id of dids) {
+        const caoKey = `${id}.caoReward`;
+        if (rewardsDictionary[caoKey]) {
+          acc.push({
+            fromAccount: vnfRewardDispersalAccountId,
+            toAccount: nextOrganization.ids.tokenAccountId,
+            amount: rewardsDictionary[caoKey],
+            description: TransactionReasons.CAO_ISSUING_REWARD,
+          });
+        }
+        const issuerKey = `${id}.issuerReward`;
+        if (rewardsDictionary[issuerKey]) {
+          acc.push({
+            fromAccount: vnfRewardDispersalAccountId,
+            toAccount: nextOrganization.ids.tokenAccountId,
+            amount: rewardsDictionary[issuerKey],
+            description: TransactionReasons.ISSUER_ISSUING_REWARD,
+          });
+        }
+      }
+
+      return acc;
+    },
+    [],
+    organizations
+  );
+
+  log.info({ task, transfers });
+
+  return batchTransferCredits({ transfers }, context);
+};
+
+const eventsToOrganizationTransactions = async (
+  { eventsCursor, credentialTypes },
+  context
+) => {
+  const {
+    config: { issuerRewardAmount, caoRewardAmount },
+  } = context;
+  const rewardsDictionary = {};
+  const dids = [];
+  const calcIssuerReward = (issuerKey) => {
+    const currentIssuerReward = rewardsDictionary[issuerKey] ?? 0;
+    return currentIssuerReward + issuerRewardAmount;
+  };
+
+  const calcCaoReward = (caoKey) => {
+    const currentCaoReward = rewardsDictionary[caoKey] ?? 0;
+    return currentCaoReward + caoRewardAmount;
+  };
+  let numberOfEventsRead = 0;
+  for await (const events of eventsCursor()) {
+    numberOfEventsRead += events.length;
+    const validEvents = getRewardableEvents(
+      { events, credentialTypes },
+      context
+    );
+    for (const { issuerKey, caoKey, issuerDid, caoDid } of validEvents) {
+      dids.push(issuerDid);
+      dids.push(caoDid);
+      rewardsDictionary[issuerKey] = calcIssuerReward(issuerKey);
+      rewardsDictionary[caoKey] = calcCaoReward(caoKey);
+    }
+  }
+  return { rewardsDictionary, numberOfEventsRead, dids: uniq(dids) };
+};
+
+const handleCredentialIssuedRewardsEvent = async (context) => {
+  const { log, repos } = context;
+  const credentialTypes = await getCredentialTypes(context);
+  const { readLastSuccessfulBlock, writeLastSuccessfulBlock } =
+    initDocumentFunctions({ eventName: task }, context);
+
+  const readEventsFromBlock = await initReadEventsFromBlock(context);
+
+  const lastReadBlock = await readLastSuccessfulBlock();
+  log.info({ task, lastReadBlock });
+  const { eventsCursor, latestBlock } = await readEventsFromBlock(
+    lastReadBlock + 1
+  );
+  const { rewardsDictionary, numberOfEventsRead, dids } =
+    await eventsToOrganizationTransactions(
+      { eventsCursor, credentialTypes },
+      context
+    );
+  log.info({
+    task,
+    lastReadBlock,
+    numberOfEventsRead,
+    rewardsDictionary,
+  });
+
+  const allOrganizations = await repos.organizations.findByDids(dids);
+
+  const [organizations, rejectedOrganizations] = partition(
+    'ids.tokenAccountId',
+    allOrganizations
+  );
+
+  const rejectOrgsCounts = size(rejectedOrganizations);
+  if (rejectOrgsCounts > 0) {
+    log.warn('organizations were rejected due to missing ids.tokenAccountId');
+    log.warn({
+      rejectedOrganizations: map('didDoc.id', rejectedOrganizations),
+    });
+  }
+
+  await executeTransfers({ rewardsDictionary, organizations }, context);
+
+  log.info({ task, latestBlock });
+  await writeLastSuccessfulBlock(latestBlock);
+};
+
+const getRewardableEvents = ({ events, credentialTypes }, context) => {
+  const [rewardableEvents, unRewardableEvents] = flow(
+    map(mapEvent),
+    partition(isRewardedEvent(credentialTypes))
+  )(events);
+  context.log.info({
+    rewardableEvents,
+    unRewardableEvents,
+    events,
+    credentialTypes,
+  });
+  return rewardableEvents;
+};
+
+const isRewardedEvent = (credentialTypes) => (event) => {
+  const issuerDid = decodeIssuerVc(event.args[1]);
+  const caoDid = event.args[6];
+  const credentialType = find((ct) => {
+    return ct.credentialType2BytesHash === event.credentialType2BytesHash;
+  }, credentialTypes);
+
+  return issuerDid != null && caoDid != null && credentialType?.layer1;
+};
+
+const mapEvent = (event) => {
+  const issuerDid = decodeIssuerVc(event.args[1]);
+  const caoDid = event.args[6];
+  const credentialType2BytesHash = event.args[3];
+  const issuerKey = `${issuerDid}.issuerReward`;
+  const caoKey = `${caoDid}.caoReward`;
+  return {
+    issuerDid,
+    caoDid,
+    issuerKey,
+    caoKey,
+    credentialType2BytesHash,
+    ...event,
+  };
+};
+
+const getCredentialTypes = async (context) => {
+  const { repos } = context;
+  const credentialTypes = await repos.credentialSchemas.find({});
+  return map(
+    ({ credentialType, layer1 }) => ({
+      credentialType,
+      credentialType2BytesHash: get2BytesHash(credentialType),
+      layer1,
+    }),
+    credentialTypes
+  );
+};
+
+module.exports = {
+  handleCredentialIssuedRewardsEvent,
+};

package/src/handlers/index.js

@@ -0,0 +1,7 @@
+module.exports = {
+  ...require('./handle-credential-issued-rewards-event'),
+  ...require('./handle-coupons-burned-verification-event'),
+  ...require('./handle-coupons-minted-logging-event'),
+  ...require('./handle-coupons-burned-logging-event'),
+  ...require('./handle-credential-issued-logging-event'),
+};

package/src/helpers/document-functions.js

@@ -0,0 +1,28 @@
+const { initReadDocument, initWriteDocument } = require('@verii/aws-clients');
+
+const initDocumentFunctions = ({ eventName }, context) => {
+  const readDocument = initReadDocument(context.config);
+  const writeDocument = initWriteDocument(context.config);
+  const readLastSuccessfulBlock = async () => {
+    const result = await readDocument(context.config.dynamoDbTableEventBlock, {
+      EventName: eventName,
+    });
+    context.log.info({ result });
+
+    if (!result || !result.Item) {
+      return -1;
+    }
+    return result.Item.BlockNumber;
+  };
+  const writeLastSuccessfulBlock = (blockNumber) =>
+    writeDocument(context.config.dynamoDbTableEventBlock, {
+      EventName: eventName,
+      BlockNumber: blockNumber,
+    });
+
+  return { readLastSuccessfulBlock, writeLastSuccessfulBlock };
+};
+
+module.exports = {
+  initDocumentFunctions,
+};

package/src/helpers/event-decoding.js

@@ -0,0 +1,20 @@
+const { jwtDecode } = require('@verii/jwt');
+
+const decodeBigIntToNumber = (bigInt) => Number(bigInt.hex);
+
+const decodeBigIntToDate = (bigInt) => new Date(Number(bigInt.hex) * 1000);
+
+const hexStringToUtfString = (hexString) =>
+  Buffer.from(hexString, 'hex').toString();
+
+const decodeIssuerVc = (issuerVc) => {
+  const { payload } = jwtDecode(hexStringToUtfString(issuerVc.slice(2)));
+
+  return payload?.iss;
+};
+
+module.exports = {
+  decodeBigIntToNumber,
+  decodeBigIntToDate,
+  decodeIssuerVc,
+};

package/src/helpers/index.js

@@ -0,0 +1,5 @@
+module.exports = {
+  ...require('./document-functions'),
+  ...require('./event-decoding'),
+  ...require('./map-coupon-burned'),
+};

package/src/helpers/map-coupon-burned.js

@@ -0,0 +1,32 @@
+const { toHexString, toNumber } = require('@verii/blockchain-functions');
+
+const mapCouponBurned = (evt, { log }) => {
+  const expirationTime = new Date(toNumber(evt.args[6]) * 1000);
+  let burnTime = new Date();
+  try {
+    burnTime = new Date(toNumber(evt.args[7]) * 1000);
+  } catch (err) {
+    log.info({ err });
+    log.info('burnTime not present on event');
+  }
+  return {
+    blockNumber: evt.blockNumber,
+    blockHash: evt.blockHash,
+    transactionIndex: evt.transactionIndex,
+    transactionHash: evt.transactionHash,
+    event: evt.fragment.name,
+    owner: evt.args[0],
+    bundleId: `${evt.args[1]}`,
+    bundleIdHex: evt.args[1] ? toHexString(evt.args[1]) : undefined,
+    eventTraceId: evt.args[2],
+    caoDid: evt.args[3],
+    burnerDid: evt.args[4],
+    balance: toNumber(evt.args[5]),
+    expirationTime,
+    burnTime,
+  };
+};
+
+module.exports = {
+  mapCouponBurned,
+};

package/src/index.js

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2025 Velocity Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/* eslint-disable global-require */
+module.exports = {
+  ...require('./event-processing-endpoints'),
+  ...require('./config/config'),
+};