@develit-services/blockchain 0.8.1 → 0.8.3

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.Bq5JL2Nn.d.cts → blockchain.7cRY-udH.d.ts}

@@ -1,11 +1,20 @@
 import { z } from 'zod';
-import { s as schema } from './blockchain.Cx60lJ0c.cjs';
+import { s as schema } from './blockchain.DUhjXgba.js';
 
 declare const getBlockInputSchema: z.ZodObject<{
+    chain: z.ZodEnum<{
+        ARBITRUM: "ARBITRUM";
+        AVALANCHE: "AVALANCHE";
+        BASE: "BASE";
+        ETHEREUM: "ETHEREUM";
+        GNOSIS: "GNOSIS";
+        OPTIMISM: "OPTIMISM";
+        SCROLL: "SCROLL";
+    }>;
     blockTag: z.ZodOptional<z.ZodEnum<{
+        pending: "pending";
         latest: "latest";
         earliest: "earliest";
-        pending: "pending";
         safe: "safe";
         finalized: "finalized";
     }>>;
@@ -50,7 +59,26 @@ interface GetBlockInput extends z.infer<typeof getBlockInputSchema> {
 }
 type GetBlockOutput = z.infer<typeof getBlockOutputSchema>;
 
+declare const chainSchema: z.ZodEnum<{
+    ARBITRUM: "ARBITRUM";
+    AVALANCHE: "AVALANCHE";
+    BASE: "BASE";
+    ETHEREUM: "ETHEREUM";
+    GNOSIS: "GNOSIS";
+    OPTIMISM: "OPTIMISM";
+    SCROLL: "SCROLL";
+}>;
+type Chain = z.infer<typeof chainSchema>;
 declare const getTransactionInputSchema: z.ZodObject<{
+    chain: z.ZodEnum<{
+        ARBITRUM: "ARBITRUM";
+        AVALANCHE: "AVALANCHE";
+        BASE: "BASE";
+        ETHEREUM: "ETHEREUM";
+        GNOSIS: "GNOSIS";
+        OPTIMISM: "OPTIMISM";
+        SCROLL: "SCROLL";
+    }>;
     txHash: z.ZodString;
 }, z.core.$strip>;
 declare const getTransactionOutputSchema: z.ZodObject<{
@@ -65,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>;
@@ -106,5 +134,5 @@ type SyncAddressOutput = z.infer<typeof syncAddressOutputSchema>;
 
 declare const tables: typeof schema;
 
-export { getBlockOutputSchema as e, getTransactionInputSchema as f, getBlockInputSchema as g, getTransactionOutputSchema as h, syncAddressOutputSchema as i, syncAddressInputSchema as s, tables as t };
-export type { GetTransactionInput as G, SyncAddressInput as S, SyncAddressOutput as a, GetTransactionOutput as b, GetBlockInput as c, GetBlockOutput as d };
+export { chainSchema as e, getBlockOutputSchema as f, getBlockInputSchema as g, getTransactionInputSchema as h, getTransactionOutputSchema as i, syncAddressOutputSchema as j, syncAddressInputSchema as s, tables as t };
+export type { Chain as C, GetTransactionInput as G, SyncAddressInput as S, SyncAddressOutput as a, GetTransactionOutput as b, GetBlockInput as c, GetBlockOutput as d };

package/dist/shared/blockchain.BUbQBxqd.cjs

@@ -0,0 +1,335 @@
+'use strict';
+
+const database_schema = require('./blockchain.CbmnjjFl.cjs');
+require('drizzle-orm');
+const backendSdk = require('@develit-io/backend-sdk');
+const viem = require('viem');
+const accounts = require('viem/accounts');
+
+const tables = database_schema.schema;
+
+class IBlockchainConnector {
+}
+
+const TRANSFER_EVENT_ABI = [
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      { indexed: true, name: "from", type: "address" },
+      { indexed: true, name: "to", type: "address" },
+      { indexed: false, name: "value", type: "uint256" }
+    ]
+  }
+];
+const ERC20_TRANSFER_ABI = [
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  }
+];
+class EvmConnector extends IBlockchainConnector {
+  constructor(config) {
+    super();
+    this.client = null;
+    this.rpcUrl = config.RPC_URL;
+    this.tokens = config.tokens;
+    this.connectedAddresses = config.connectedAddresses;
+    this.resolveCredentials = config.resolveCredentials;
+  }
+  createClient() {
+    if (!this.client) {
+      this.client = viem.createPublicClient({
+        transport: viem.http(this.rpcUrl)
+      });
+    }
+    return this.client;
+  }
+  async getTransaction(txHash) {
+    const client = this.createClient();
+    const [tx, txError] = await backendSdk.useResult(
+      client.getTransaction({ hash: txHash })
+    );
+    if (txError || !tx) {
+      throw backendSdk.createInternalError(txError);
+    }
+    let status = "pending";
+    let gasUsed = null;
+    let timestamp = null;
+    if (tx.blockNumber) {
+      const [receipt, receiptError] = await backendSdk.useResult(
+        client.getTransactionReceipt({ hash: txHash })
+      );
+      if (receiptError || !receipt) {
+        throw backendSdk.createInternalError(receiptError);
+      }
+      const [block, blockError] = await backendSdk.useResult(
+        client.getBlock({ blockNumber: tx.blockNumber })
+      );
+      if (blockError || !block) {
+        throw backendSdk.createInternalError(blockError);
+      }
+      status = receipt.status === "success" ? "success" : "reverted";
+      gasUsed = receipt.gasUsed.toString();
+      timestamp = Number(block.timestamp) * 1e3;
+    }
+    return {
+      hash: tx.hash,
+      from: tx.from,
+      to: tx.to,
+      value: tx.value.toString(),
+      blockNumber: tx.blockNumber?.toString() ?? null,
+      blockHash: tx.blockHash ?? null,
+      gasPrice: tx.gasPrice?.toString() ?? null,
+      gas: tx.gas.toString(),
+      nonce: tx.nonce,
+      transactionIndex: tx.transactionIndex,
+      status,
+      gasUsed,
+      timestamp
+    };
+  }
+  async getTransactionReceipt(txHash) {
+    const client = this.createClient();
+    const [receipt, error] = await backendSdk.useResult(
+      client.getTransactionReceipt({ hash: txHash })
+    );
+    if (error || !receipt) {
+      throw backendSdk.createInternalError(error);
+    }
+    return receipt;
+  }
+  async getBlock({
+    blockHash,
+    blockNumber,
+    blockTag
+  }) {
+    const client = this.createClient();
+    const [block, error] = await backendSdk.useResult(
+      blockHash !== void 0 ? client.getBlock({ blockHash }) : blockNumber !== void 0 ? client.getBlock({ blockNumber }) : client.getBlock({ blockTag: blockTag ?? "finalized" })
+    );
+    if (error || !block) {
+      throw error;
+    }
+    return block;
+  }
+  async getAllAddressTransactions({
+    address,
+    filter
+  }) {
+    const client = this.createClient();
+    const latestBlock = await client.getBlockNumber();
+    const transactions = [];
+    const allTransactionsFromContracts = await Promise.all(
+      this.tokens.map(async (token) => {
+        const events = await client.getContractEvents({
+          abi: TRANSFER_EVENT_ABI,
+          address: token.smartContractAddress,
+          eventName: "Transfer",
+          args: {
+            to: address
+          },
+          fromBlock: filter.fromBlock ?? latestBlock - 900n,
+          toBlock: "latest"
+        });
+        return { events, token };
+      })
+    );
+    for (const { events, token } of allTransactionsFromContracts) {
+      for (const tx of events) {
+        const [receipt, block] = await Promise.all([
+          client.getTransactionReceipt({ hash: tx.transactionHash }),
+          client.getBlock({ blockNumber: tx.blockNumber })
+        ]);
+        transactions.push({
+          hash: tx.transactionHash,
+          from: tx.args.from ?? "",
+          to: tx.args.to ?? "",
+          value: (tx.args.value ?? 0n).toString(),
+          blockNumber: tx.blockNumber.toString(),
+          blockHash: tx.blockHash,
+          gasUsed: receipt.gasUsed.toString(),
+          gasPrice: receipt.effectiveGasPrice?.toString() ?? "",
+          timestamp: Number(block.timestamp),
+          status: receipt.status,
+          decimals: token.decimals,
+          connector: this.connectorKey,
+          ticker: token.ticker
+        });
+      }
+    }
+    return { transactions, latestBlock };
+  }
+  async sendTransaction({
+    from,
+    to,
+    value,
+    token
+  }) {
+    const address = this.connectedAddresses.find(
+      (a) => a.number.toLowerCase() === from.toLowerCase()
+    );
+    if (!address) {
+      throw backendSdk.createInternalError(null, {
+        message: `Address not found: ${from}`
+      });
+    }
+    if (!this.resolveCredentials) {
+      throw backendSdk.createInternalError(null, {
+        message: `Credentials resolver not provided`
+      });
+    }
+    const credentials = await this.resolveCredentials(address.id);
+    if (!credentials) {
+      throw backendSdk.createInternalError(null, {
+        message: `No private key found for address: ${from}`
+      });
+    }
+    const account = accounts.privateKeyToAccount(credentials.value);
+    const walletClient = viem.createWalletClient({
+      account,
+      transport: viem.http(this.rpcUrl)
+    });
+    let hash;
+    if (token) {
+      const data = viem.encodeFunctionData({
+        abi: ERC20_TRANSFER_ABI,
+        functionName: "transfer",
+        args: [to, viem.parseUnits(value, token.decimals)]
+      });
+      hash = await walletClient.sendTransaction({
+        chain: null,
+        to: token.smartContractAddress,
+        data
+      });
+    } else {
+      hash = await walletClient.sendTransaction({
+        chain: null,
+        to,
+        value: BigInt(value)
+      });
+    }
+    return { hash };
+  }
+}
+
+class ArbitrumConnector extends EvmConnector {
+  constructor(config) {
+    super(config);
+    this.connectorKey = "ARBITRUM";
+  }
+}
+
+class AvalancheConnector extends EvmConnector {
+  constructor(config) {
+    super(config);
+    this.connectorKey = "AVALANCHE";
+  }
+}
+
+class BaseConnector extends EvmConnector {
+  constructor(config) {
+    super(config);
+    this.connectorKey = "BASE";
+  }
+}
+
+class EthereumConnector extends EvmConnector {
+  constructor(config) {
+    super(config);
+    this.connectorKey = "ETHEREUM";
+  }
+}
+
+class GnosisConnector extends EvmConnector {
+  constructor(config) {
+    super(config);
+    this.connectorKey = "GNOSIS";
+  }
+}
+
+class OptimismConnector extends EvmConnector {
+  constructor(config) {
+    super(config);
+    this.connectorKey = "OPTIMISM";
+  }
+}
+
+class ScrollConnector extends EvmConnector {
+  constructor(config) {
+    super(config);
+    this.connectorKey = "SCROLL";
+  }
+}
+
+const initiateConnector = async ({
+  chain,
+  env,
+  tokens,
+  connectedAddresses,
+  resolveCredentials
+}) => {
+  const getRpcUrl = async (secretName) => (await env.SECRETS_STORE.get({ secretName })).data?.secretValue || "";
+  switch (chain) {
+    case "ETHEREUM":
+      return new EthereumConnector({
+        RPC_URL: await getRpcUrl("BLOCKCHAIN_SERVICE_ETHEREUM_RPC_URL"),
+        tokens,
+        connectedAddresses,
+        resolveCredentials
+      });
+    case "ARBITRUM":
+      return new ArbitrumConnector({
+        RPC_URL: await getRpcUrl("BLOCKCHAIN_SERVICE_ARBITRUM_RPC_URL"),
+        tokens,
+        connectedAddresses,
+        resolveCredentials
+      });
+    case "AVALANCHE":
+      return new AvalancheConnector({
+        RPC_URL: await getRpcUrl("BLOCKCHAIN_SERVICE_AVALANCHE_RPC_URL"),
+        tokens,
+        connectedAddresses,
+        resolveCredentials
+      });
+    case "BASE":
+      return new BaseConnector({
+        RPC_URL: await getRpcUrl("BLOCKCHAIN_SERVICE_BASE_RPC_URL"),
+        tokens,
+        connectedAddresses,
+        resolveCredentials
+      });
+    case "GNOSIS":
+      return new GnosisConnector({
+        RPC_URL: await getRpcUrl("BLOCKCHAIN_SERVICE_GNOSIS_RPC_URL"),
+        tokens,
+        connectedAddresses,
+        resolveCredentials
+      });
+    case "OPTIMISM":
+      return new OptimismConnector({
+        RPC_URL: await getRpcUrl("BLOCKCHAIN_SERVICE_OPTIMISM_RPC_URL"),
+        tokens,
+        connectedAddresses,
+        resolveCredentials
+      });
+    case "SCROLL":
+      return new ScrollConnector({
+        RPC_URL: await getRpcUrl("BLOCKCHAIN_SERVICE_SCROLL_RPC_URL"),
+        tokens,
+        connectedAddresses,
+        resolveCredentials
+      });
+    default:
+      throw new Error(`Unsupported chain: ${chain}`);
+  }
+};
+
+exports.initiateConnector = initiateConnector;
+exports.tables = tables;