@develit-services/blockchain 0.8.2 → 0.8.4

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.JBv4ipVR.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.ZJPECySM.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 }).onConflictDoNothing().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.`);
     }
@@ -61,98 +80,86 @@ class BlockchainSyncAddressTransactions extends cloudflare_workers.WorkflowEntry
             `Blockchain address not found: ${addressId}.`
           );
         }
-        return address2;
+        return {
+          ...address2,
+          lastSyncBlock: address2.lastSyncBlock?.toString() ?? null
+        };
       });
       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",
+        `fetch address transactions`,
         {
           retries: { limit: 5, delay: 2e3, backoff: "constant" },
           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}`
+            );
+          }
+          const connector = await blockchain.initiateConnector({
+            chain: address.connector,
+            env: this.env,
+            tokens,
+            connectedAddresses: [
+              {
+                id: address.id,
+                number: address.number,
+                connector: address.connector
               }
+            ]
+          });
+          const result = await connector.getAllAddressTransactions({
+            address: address.number,
+            filter: {
+              fromBlock: address.lastSyncBlock ? BigInt(address.lastSyncBlock) : null
             }
-          }
-          return allTransactions;
+          });
+          return {
+            transactions: result.transactions,
+            latestBlock: result.latestBlock.toString()
+          };
         }
       );
-      if (transactions.length > 0) {
+      if (transactions.transactions.length > 0) {
         await step.do(
-          "process new transactions and update lastSyncAt",
+          `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 +168,17 @@ class BlockchainSyncAddressTransactions extends cloudflare_workers.WorkflowEntry
               lastSyncAt: now,
               lastSyncMetadata
             }).command;
+            const updateLastSyncBlockCommand = updateAddressLastSyncBlockCommand(db, {
+              addressId: address.id,
+              lastSyncBlock: BigInt(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,
@@ -178,7 +193,7 @@ class BlockchainSyncAddressTransactions extends cloudflare_workers.WorkflowEntry
         );
       }
       await step.sleep(
-        "sleep until next sync",
+        `sleep until next sync`,
         `${address.syncIntervalS} seconds`
       );
     }

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.wsLSmIaf.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.BKGlFbOW.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,9 +42,14 @@ 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();
+  const command = db.insert(tables.transaction).values({ ...transaction, id }).onConflictDoNothing().returning();
   return { command };
 };
 
@@ -59,98 +78,86 @@ class BlockchainSyncAddressTransactions extends WorkflowEntrypoint {
             `Blockchain address not found: ${addressId}.`
           );
         }
-        return address2;
+        return {
+          ...address2,
+          lastSyncBlock: address2.lastSyncBlock?.toString() ?? null
+        };
       });
       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",
+        `fetch address transactions`,
         {
           retries: { limit: 5, delay: 2e3, backoff: "constant" },
           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}`
+            );
+          }
+          const connector = await initiateConnector({
+            chain: address.connector,
+            env: this.env,
+            tokens,
+            connectedAddresses: [
+              {
+                id: address.id,
+                number: address.number,
+                connector: address.connector
               }
+            ]
+          });
+          const result = await connector.getAllAddressTransactions({
+            address: address.number,
+            filter: {
+              fromBlock: address.lastSyncBlock ? BigInt(address.lastSyncBlock) : null
             }
-          }
-          return allTransactions;
+          });
+          return {
+            transactions: result.transactions,
+            latestBlock: result.latestBlock.toString()
+          };
         }
       );
-      if (transactions.length > 0) {
+      if (transactions.transactions.length > 0) {
         await step.do(
-          "process new transactions and update lastSyncAt",
+          `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 +166,17 @@ class BlockchainSyncAddressTransactions extends WorkflowEntrypoint {
               lastSyncAt: now,
               lastSyncMetadata
             }).command;
+            const updateLastSyncBlockCommand = updateAddressLastSyncBlockCommand(db, {
+              addressId: address.id,
+              lastSyncBlock: BigInt(transactions.latestBlock)
+            }).command;
             if (eventsToEmit.length) {
               await db.batch(
-                asNonEmpty([updateLastSyncCommand, ...createCommands])
+                asNonEmpty([
+                  updateLastSyncCommand,
+                  updateLastSyncBlockCommand,
+                  ...createCommands
+                ])
               );
               await pushToQueue(
                 this.env.QUEUE_BUS_QUEUE,
@@ -176,7 +191,7 @@ class BlockchainSyncAddressTransactions extends WorkflowEntrypoint {
         );
       }
       await step.sleep(
-        "sleep until next sync",
+        `sleep until next sync`,
         `${address.syncIntervalS} seconds`
       );
     }

package/dist/shared/blockchain.BKGlFbOW.mjs

@@ -0,0 +1,68 @@
+import { base } from '@develit-io/backend-sdk';
+import { sqliteTable, text, integer, blob, uniqueIndex } from 'drizzle-orm/sqlite-core';
+import { a as CREDENTIALS_TYPES, C as CHAIN_KEYS } from './blockchain.CKh8Fs7w.mjs';
+
+const address = sqliteTable("address", {
+  ...base,
+  number: text("number").notNull(),
+  syncIntervalS: integer("sync_interval_s").notNull().default(600),
+  lastSyncBlock: blob("last_sync_block", { mode: "bigint" }),
+  lastSyncAt: integer("last_sync_at", { mode: "timestamp_ms" }),
+  lastSyncMetadata: text("last_sync_metadata", {
+    mode: "json"
+  }).$type(),
+  connector: text("connector").$type()
+});
+
+const addressCredentials = sqliteTable("address_credentials", {
+  ...base,
+  addressId: text("address_id").references(() => address.id, { onDelete: "restrict", onUpdate: "cascade" }).notNull(),
+  connector: text("connector", {
+    enum: CHAIN_KEYS
+  }).$type().notNull(),
+  type: text("type", {
+    enum: CREDENTIALS_TYPES
+  }).$type().notNull(),
+  value: text("value").notNull(),
+  expiresAt: integer("expires_at", { mode: "timestamp_ms" })
+});
+
+const tokens = sqliteTable("tokens", {
+  ...base,
+  smartContractAddress: text("smart_contract_address").$type().notNull(),
+  connector: text("connector").$type(),
+  ticker: text("ticker").notNull(),
+  decimals: integer("decimals").notNull(),
+  name: text("name")
+});
+
+const transaction = sqliteTable(
+  "transaction",
+  {
+    ...base,
+    hash: text("hash"),
+    from: text("from"),
+    to: text("to"),
+    value: text("value"),
+    blockNumber: text("block_number"),
+    blockHash: text("blockHash"),
+    gasUsed: text("gasUsed"),
+    gasPrice: text("gasPrice"),
+    timestamp: integer("timestamp"),
+    status: text("status"),
+    decimals: integer("decimals"),
+    connector: text("connector").$type(),
+    ticker: text("ticker")
+  },
+  (t) => [uniqueIndex("transaction_hash_unique").on(t.hash)]
+);
+
+const schema = {
+  __proto__: null,
+  address: address,
+  addressCredentials: addressCredentials,
+  tokens: tokens,
+  transaction: transaction
+};
+
+export { address as a, addressCredentials as b, transaction as c, schema as s, tokens as t };

package/dist/shared/{blockchain.CtIjPvX8.d.cts → blockchain.Br6esGv4.d.cts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { s as schema } from './blockchain.Cx60lJ0c.cjs';
+import { s as schema } from './blockchain.DUhjXgba.cjs';
 
 declare const getBlockInputSchema: z.ZodObject<{
     chain: z.ZodEnum<{
@@ -12,9 +12,9 @@ declare const getBlockInputSchema: z.ZodObject<{
         SCROLL: "SCROLL";
     }>;
     blockTag: z.ZodOptional<z.ZodEnum<{
-        pending: "pending";
         latest: "latest";
         earliest: "earliest";
+        pending: "pending";
         safe: "safe";
         finalized: "finalized";
     }>>;
@@ -93,9 +93,9 @@ declare const getTransactionOutputSchema: z.ZodObject<{
     nonce: z.ZodNumber;
     transactionIndex: z.ZodNullable<z.ZodNumber>;
     status: z.ZodEnum<{
+        pending: "pending";
         success: "success";
         reverted: "reverted";
-        pending: "pending";
     }>;
     gasUsed: z.ZodNullable<z.ZodString>;
     timestamp: z.ZodNullable<z.ZodNumber>;

package/dist/shared/{blockchain.DTJULMBV.mjs → blockchain.CKh8Fs7w.mjs}

@@ -1,6 +1,17 @@
 import { z } from 'zod';
 import { workflowInstanceStatusSchema } from '@develit-io/backend-sdk';
 
+const CHAIN_KEYS = [
+  "ARBITRUM",
+  "AVALANCHE",
+  "BASE",
+  "ETHEREUM",
+  "GNOSIS",
+  "OPTIMISM",
+  "SCROLL"
+];
+const CREDENTIALS_TYPES = ["PRIVATE_KEY"];
+
 const chainSchema = z.enum([
   "ARBITRUM",
   "AVALANCHE",
@@ -84,4 +95,4 @@ const syncAddressOutputSchema = z.object({
   details: workflowInstanceStatusSchema
 });
 
-export { getBlockOutputSchema as a, getTransactionInputSchema as b, chainSchema as c, getTransactionOutputSchema as d, syncAddressOutputSchema as e, getBlockInputSchema as g, syncAddressInputSchema as s };
+export { CHAIN_KEYS as C, CREDENTIALS_TYPES as a, getBlockOutputSchema as b, chainSchema as c, getTransactionInputSchema as d, getTransactionOutputSchema as e, syncAddressOutputSchema as f, getBlockInputSchema as g, syncAddressInputSchema as s };

package/dist/shared/{blockchain.BBjLLe8v.cjs → blockchain.Cjq9eH7Z.cjs}

@@ -3,6 +3,17 @@
 const zod = require('zod');
 const backendSdk = require('@develit-io/backend-sdk');
 
+const CHAIN_KEYS = [
+  "ARBITRUM",
+  "AVALANCHE",
+  "BASE",
+  "ETHEREUM",
+  "GNOSIS",
+  "OPTIMISM",
+  "SCROLL"
+];
+const CREDENTIALS_TYPES = ["PRIVATE_KEY"];
+
 const chainSchema = zod.z.enum([
   "ARBITRUM",
   "AVALANCHE",
@@ -86,6 +97,8 @@ const syncAddressOutputSchema = zod.z.object({
   details: backendSdk.workflowInstanceStatusSchema
 });
 
+exports.CHAIN_KEYS = CHAIN_KEYS;
+exports.CREDENTIALS_TYPES = CREDENTIALS_TYPES;
 exports.chainSchema = chainSchema;
 exports.getBlockInputSchema = getBlockInputSchema;
 exports.getBlockOutputSchema = getBlockOutputSchema;