@develit-services/blockchain 0.8.2 → 0.8.3

package/dist/export/workflows.cjs

@@ -1,38 +1,57 @@
 'use strict';
 
 const backendSdk = require('@develit-io/backend-sdk');
-const drizzle = require('../shared/blockchain.DN735AwB.cjs');
+const blockchain = require('../shared/blockchain.BUbQBxqd.cjs');
 const drizzleOrm = require('drizzle-orm');
 const cloudflare_workers = require('cloudflare:workers');
 const cloudflare_workflows = require('cloudflare:workflows');
 const d1 = require('drizzle-orm/d1');
-const viem = require('viem');
-const chains = require('viem/chains');
-require('../shared/blockchain.BBvwu2_7.cjs');
+require('../shared/blockchain.CbmnjjFl.cjs');
 require('drizzle-orm/sqlite-core');
+require('../shared/blockchain.Cjq9eH7Z.cjs');
+require('zod');
+require('viem');
+require('viem/accounts');
+
+const updateAddressLastSyncBlockCommand = (db, {
+  lastSyncBlock,
+  addressId
+}) => {
+  const command = db.update(blockchain.tables.address).set({
+    lastSyncBlock
+  }).where(drizzleOrm.eq(blockchain.tables.address.id, addressId)).returning();
+  return {
+    command
+  };
+};
 
 const updateAddressLastSyncCommand = (db, {
   lastSyncAt,
   addressId,
   lastSyncMetadata
 }) => {
-  const command = db.update(drizzle.tables.address).set({
+  const command = db.update(blockchain.tables.address).set({
     lastSyncAt,
     lastSyncMetadata
-  }).where(drizzleOrm.eq(drizzle.tables.address.id, addressId)).returning();
+  }).where(drizzleOrm.eq(blockchain.tables.address.id, addressId)).returning();
   return {
     command
   };
 };
 
 const getAddressById = async (db, id) => {
-  const address = await db.select().from(drizzle.tables.address).where(drizzleOrm.eq(drizzle.tables.address.id, id)).get();
+  const address = await db.select().from(blockchain.tables.address).where(drizzleOrm.eq(blockchain.tables.address.id, id)).get();
   return address;
 };
 
+const getContractAddresses = async (db, { connector }) => {
+  const addresses = await db.select().from(blockchain.tables.tokens).where(drizzleOrm.eq(blockchain.tables.tokens.connector, connector)).all();
+  return addresses;
+};
+
 const createTransactionCommand = (db, { transaction }) => {
   const id = backendSdk.uuidv4();
-  const command = db.insert(drizzle.tables.transaction).values({ ...transaction, id }).returning();
+  const command = db.insert(blockchain.tables.transaction).values({ ...transaction, id }).returning();
   return { command };
 };
 
@@ -48,7 +67,7 @@ function pushToQueue(queue, message) {
 class BlockchainSyncAddressTransactions extends cloudflare_workers.WorkflowEntrypoint {
   async run(event, step) {
     const { addressId } = event.payload;
-    const db = d1.drizzle(this.env.BLOCKCHAIN_D1, { schema: drizzle.tables });
+    const db = d1.drizzle(this.env.BLOCKCHAIN_D1, { schema: blockchain.tables });
     if (!addressId) {
       throw new cloudflare_workflows.NonRetryableError(`Haven't obtained addressId to load.`);
     }
@@ -64,7 +83,9 @@ class BlockchainSyncAddressTransactions extends cloudflare_workers.WorkflowEntry
         return address2;
       });
       if (!address.lastSyncAt) {
-        throw new Error(`lastSyncedAt is not set for address: ${address}`);
+        throw new cloudflare_workflows.NonRetryableError(
+          `lastSyncedAt is not set for address: ${address}`
+        );
       }
       const transactions = await step.do(
         "fetch address transactions",
@@ -73,86 +94,63 @@ class BlockchainSyncAddressTransactions extends cloudflare_workers.WorkflowEntry
           timeout: "30 seconds"
         },
         async () => {
-          const rpcUrl = (await this.env.SECRETS_STORE.get({
-            secretName: "BLOCKCHAIN_SERVICE_RPC_URL"
-          })).data?.secretValue || "";
-          const client = viem.createPublicClient({
-            chain: chains.gnosisChiado,
-            transport: viem.http(rpcUrl)
+          const tokens = await getContractAddresses(db, {
+            connector: address.connector
           });
-          const currentBlock = await client.getBlockNumber();
-          const estimatedBlocksPerInterval = Math.ceil(
-            address.syncIntervalS * 1.5 / 5
-          );
-          const blocksToScan = Math.min(estimatedBlocksPerInterval, 1e3);
-          const startBlock = currentBlock - BigInt(blocksToScan);
-          const endBlock = currentBlock;
-          const lastSyncedTimestamp = address.lastSyncAt || 0;
-          const allTransactions = [];
-          for (let blockNum = startBlock; blockNum <= endBlock; blockNum++) {
-            const block = await client.getBlock({
-              blockNumber: blockNum,
-              includeTransactions: true
-            });
-            const blockTimestamp = Number(block.timestamp);
-            const lastSyncedTimestampNum = typeof lastSyncedTimestamp === "number" ? lastSyncedTimestamp : Number(lastSyncedTimestamp);
-            if (blockTimestamp <= lastSyncedTimestampNum) {
-              continue;
-            }
-            for (const tx of block.transactions) {
-              if (typeof tx === "string" || !tx.to) continue;
-              if (tx.from.toLowerCase() === address.number.toLowerCase()) {
-                const receipt = await client.getTransactionReceipt({
-                  hash: tx.hash
-                });
-                allTransactions.push({
-                  hash: tx.hash,
-                  from: tx.from,
-                  to: tx.to,
-                  value: tx.value.toString(),
-                  blockNumber: block.number.toString(),
-                  blockHash: block.hash,
-                  gasUsed: receipt.gasUsed.toString(),
-                  gasPrice: tx.gasPrice?.toString() ?? "",
-                  timestamp: blockTimestamp,
-                  status: receipt.status
-                });
-              }
-            }
+          if (!tokens || tokens.length === 0) {
+            throw new cloudflare_workflows.NonRetryableError(
+              `No contract addresses found for connector: ${address.connector}`
+            );
           }
-          return allTransactions;
+          const connector = await blockchain.initiateConnector({
+            chain: address.connector,
+            env: this.env,
+            tokens,
+            connectedAddresses: [
+              {
+                id: address.id,
+                number: address.number,
+                connector: address.connector
+              }
+            ]
+          });
+          return await connector.getAllAddressTransactions({
+            address: address.number,
+            filter: { fromBlock: address.lastSyncBlock }
+          });
         }
       );
-      if (transactions.length > 0) {
+      if (transactions.transactions.length > 0) {
         await step.do(
           "process new transactions and update lastSyncAt",
           async () => {
-            const createCommands = transactions.map(
+            const createCommands = transactions.transactions.map(
               (tx) => createTransactionCommand(db, { transaction: tx }).command
             );
-            const eventsToEmit = transactions.map(
-              (tx) => ({
-                eventType: "BLOCKCHAIN_TRANSACTION",
-                blockchainTransaction: {
-                  address: address.number,
-                  hash: tx.hash,
-                  from: tx.from,
-                  to: tx.to,
-                  value: tx.value,
-                  blockNumber: tx.blockNumber,
-                  blockHash: tx.blockHash,
-                  gasUsed: tx.gasUsed,
-                  gasPrice: tx.gasPrice,
-                  timestamp: tx.timestamp,
-                  status: tx.status
-                },
-                metadata: {
-                  correlationId: backendSdk.uuidv4(),
-                  entityId: backendSdk.uuidv4(),
-                  timestamp: (/* @__PURE__ */ new Date()).toDateString()
-                }
-              })
-            );
+            const eventsToEmit = transactions.transactions.map((tx) => ({
+              eventType: "BLOCKCHAIN_TRANSACTION",
+              blockchainTransaction: {
+                address: address.number,
+                hash: tx.hash,
+                from: tx.from,
+                to: tx.to,
+                value: tx.value,
+                blockNumber: tx.blockNumber,
+                blockHash: tx.blockHash,
+                gasUsed: tx.gasUsed,
+                gasPrice: tx.gasPrice,
+                timestamp: tx.timestamp,
+                status: tx.status,
+                decimals: tx.decimals,
+                connector: address.connector,
+                ticker: tx.ticker
+              },
+              metadata: {
+                correlationId: backendSdk.uuidv4(),
+                entityId: backendSdk.uuidv4(),
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              }
+            }));
             const lastSyncMetadata = {
               eventsEmitted: eventsToEmit.length
             };
@@ -161,9 +159,17 @@ class BlockchainSyncAddressTransactions extends cloudflare_workers.WorkflowEntry
               lastSyncAt: now,
               lastSyncMetadata
             }).command;
+            const updateLastSyncBlockCommand = updateAddressLastSyncBlockCommand(db, {
+              addressId: address.id,
+              lastSyncBlock: transactions.latestBlock
+            }).command;
             if (eventsToEmit.length) {
               await db.batch(
-                backendSdk.asNonEmpty([updateLastSyncCommand, ...createCommands])
+                backendSdk.asNonEmpty([
+                  updateLastSyncCommand,
+                  updateLastSyncBlockCommand,
+                  ...createCommands
+                ])
               );
               await pushToQueue(
                 this.env.QUEUE_BUS_QUEUE,

package/dist/export/workflows.mjs

@@ -1,13 +1,27 @@
 import { uuidv4, asNonEmpty } from '@develit-io/backend-sdk';
-import { t as tables } from '../shared/blockchain.0tUJ62WT.mjs';
+import { t as tables, i as initiateConnector } from '../shared/blockchain.BhDiNGPI.mjs';
 import { eq } from 'drizzle-orm';
 import { WorkflowEntrypoint } from 'cloudflare:workers';
 import { NonRetryableError } from 'cloudflare:workflows';
 import { drizzle } from 'drizzle-orm/d1';
-import { createPublicClient, http } from 'viem';
-import { gnosisChiado } from 'viem/chains';
-import '../shared/blockchain._wwKu1qP.mjs';
+import '../shared/blockchain._nv3VxNA.mjs';
 import 'drizzle-orm/sqlite-core';
+import '../shared/blockchain.CKh8Fs7w.mjs';
+import 'zod';
+import 'viem';
+import 'viem/accounts';
+
+const updateAddressLastSyncBlockCommand = (db, {
+  lastSyncBlock,
+  addressId
+}) => {
+  const command = db.update(tables.address).set({
+    lastSyncBlock
+  }).where(eq(tables.address.id, addressId)).returning();
+  return {
+    command
+  };
+};
 
 const updateAddressLastSyncCommand = (db, {
   lastSyncAt,
@@ -28,6 +42,11 @@ const getAddressById = async (db, id) => {
   return address;
 };
 
+const getContractAddresses = async (db, { connector }) => {
+  const addresses = await db.select().from(tables.tokens).where(eq(tables.tokens.connector, connector)).all();
+  return addresses;
+};
+
 const createTransactionCommand = (db, { transaction }) => {
   const id = uuidv4();
   const command = db.insert(tables.transaction).values({ ...transaction, id }).returning();
@@ -62,7 +81,9 @@ class BlockchainSyncAddressTransactions extends WorkflowEntrypoint {
         return address2;
       });
       if (!address.lastSyncAt) {
-        throw new Error(`lastSyncedAt is not set for address: ${address}`);
+        throw new NonRetryableError(
+          `lastSyncedAt is not set for address: ${address}`
+        );
       }
       const transactions = await step.do(
         "fetch address transactions",
@@ -71,86 +92,63 @@ class BlockchainSyncAddressTransactions extends WorkflowEntrypoint {
           timeout: "30 seconds"
         },
         async () => {
-          const rpcUrl = (await this.env.SECRETS_STORE.get({
-            secretName: "BLOCKCHAIN_SERVICE_RPC_URL"
-          })).data?.secretValue || "";
-          const client = createPublicClient({
-            chain: gnosisChiado,
-            transport: http(rpcUrl)
+          const tokens = await getContractAddresses(db, {
+            connector: address.connector
           });
-          const currentBlock = await client.getBlockNumber();
-          const estimatedBlocksPerInterval = Math.ceil(
-            address.syncIntervalS * 1.5 / 5
-          );
-          const blocksToScan = Math.min(estimatedBlocksPerInterval, 1e3);
-          const startBlock = currentBlock - BigInt(blocksToScan);
-          const endBlock = currentBlock;
-          const lastSyncedTimestamp = address.lastSyncAt || 0;
-          const allTransactions = [];
-          for (let blockNum = startBlock; blockNum <= endBlock; blockNum++) {
-            const block = await client.getBlock({
-              blockNumber: blockNum,
-              includeTransactions: true
-            });
-            const blockTimestamp = Number(block.timestamp);
-            const lastSyncedTimestampNum = typeof lastSyncedTimestamp === "number" ? lastSyncedTimestamp : Number(lastSyncedTimestamp);
-            if (blockTimestamp <= lastSyncedTimestampNum) {
-              continue;
-            }
-            for (const tx of block.transactions) {
-              if (typeof tx === "string" || !tx.to) continue;
-              if (tx.from.toLowerCase() === address.number.toLowerCase()) {
-                const receipt = await client.getTransactionReceipt({
-                  hash: tx.hash
-                });
-                allTransactions.push({
-                  hash: tx.hash,
-                  from: tx.from,
-                  to: tx.to,
-                  value: tx.value.toString(),
-                  blockNumber: block.number.toString(),
-                  blockHash: block.hash,
-                  gasUsed: receipt.gasUsed.toString(),
-                  gasPrice: tx.gasPrice?.toString() ?? "",
-                  timestamp: blockTimestamp,
-                  status: receipt.status
-                });
-              }
-            }
+          if (!tokens || tokens.length === 0) {
+            throw new NonRetryableError(
+              `No contract addresses found for connector: ${address.connector}`
+            );
           }
-          return allTransactions;
+          const connector = await initiateConnector({
+            chain: address.connector,
+            env: this.env,
+            tokens,
+            connectedAddresses: [
+              {
+                id: address.id,
+                number: address.number,
+                connector: address.connector
+              }
+            ]
+          });
+          return await connector.getAllAddressTransactions({
+            address: address.number,
+            filter: { fromBlock: address.lastSyncBlock }
+          });
         }
       );
-      if (transactions.length > 0) {
+      if (transactions.transactions.length > 0) {
         await step.do(
           "process new transactions and update lastSyncAt",
           async () => {
-            const createCommands = transactions.map(
+            const createCommands = transactions.transactions.map(
               (tx) => createTransactionCommand(db, { transaction: tx }).command
             );
-            const eventsToEmit = transactions.map(
-              (tx) => ({
-                eventType: "BLOCKCHAIN_TRANSACTION",
-                blockchainTransaction: {
-                  address: address.number,
-                  hash: tx.hash,
-                  from: tx.from,
-                  to: tx.to,
-                  value: tx.value,
-                  blockNumber: tx.blockNumber,
-                  blockHash: tx.blockHash,
-                  gasUsed: tx.gasUsed,
-                  gasPrice: tx.gasPrice,
-                  timestamp: tx.timestamp,
-                  status: tx.status
-                },
-                metadata: {
-                  correlationId: uuidv4(),
-                  entityId: uuidv4(),
-                  timestamp: (/* @__PURE__ */ new Date()).toDateString()
-                }
-              })
-            );
+            const eventsToEmit = transactions.transactions.map((tx) => ({
+              eventType: "BLOCKCHAIN_TRANSACTION",
+              blockchainTransaction: {
+                address: address.number,
+                hash: tx.hash,
+                from: tx.from,
+                to: tx.to,
+                value: tx.value,
+                blockNumber: tx.blockNumber,
+                blockHash: tx.blockHash,
+                gasUsed: tx.gasUsed,
+                gasPrice: tx.gasPrice,
+                timestamp: tx.timestamp,
+                status: tx.status,
+                decimals: tx.decimals,
+                connector: address.connector,
+                ticker: tx.ticker
+              },
+              metadata: {
+                correlationId: uuidv4(),
+                entityId: uuidv4(),
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              }
+            }));
             const lastSyncMetadata = {
               eventsEmitted: eventsToEmit.length
             };
@@ -159,9 +157,17 @@ class BlockchainSyncAddressTransactions extends WorkflowEntrypoint {
               lastSyncAt: now,
               lastSyncMetadata
             }).command;
+            const updateLastSyncBlockCommand = updateAddressLastSyncBlockCommand(db, {
+              addressId: address.id,
+              lastSyncBlock: transactions.latestBlock
+            }).command;
             if (eventsToEmit.length) {
               await db.batch(
-                asNonEmpty([updateLastSyncCommand, ...createCommands])
+                asNonEmpty([
+                  updateLastSyncCommand,
+                  updateLastSyncBlockCommand,
+                  ...createCommands
+                ])
               );
               await pushToQueue(
                 this.env.QUEUE_BUS_QUEUE,

package/dist/shared/{blockchain.5Ld6uEay.d.ts → blockchain.7cRY-udH.d.ts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { s as schema } from './blockchain.Cx60lJ0c.js';
+import { s as schema } from './blockchain.DUhjXgba.js';
 
 declare const getBlockInputSchema: z.ZodObject<{
     chain: z.ZodEnum<{