@develit-services/blockchain 0.6.2 → 0.7.1

package/dist/database/schema.cjs

@@ -1,9 +1,10 @@
 'use strict';
 
-const database_schema = require('../shared/blockchain.JxC5JMLI.cjs');
+const database_schema = require('../shared/blockchain.BBvwu2_7.cjs');
 require('@develit-io/backend-sdk');
 require('drizzle-orm/sqlite-core');
 
 
 
 exports.address = database_schema.address;
+exports.transaction = database_schema.transaction;

package/dist/database/schema.d.cts

@@ -1,2 +1,2 @@
-export { a as address } from '../shared/blockchain.f4eN2PFQ.cjs';
+export { a as address, t as transaction } from '../shared/blockchain.Cx60lJ0c.cjs';
 import 'drizzle-orm/sqlite-core';

package/dist/database/schema.d.mts

@@ -1,2 +1,2 @@
-export { a as address } from '../shared/blockchain.f4eN2PFQ.mjs';
+export { a as address, t as transaction } from '../shared/blockchain.Cx60lJ0c.mjs';
 import 'drizzle-orm/sqlite-core';

package/dist/database/schema.d.ts

@@ -1,2 +1,2 @@
-export { a as address } from '../shared/blockchain.f4eN2PFQ.js';
+export { a as address, t as transaction } from '../shared/blockchain.Cx60lJ0c.js';
 import 'drizzle-orm/sqlite-core';

package/dist/database/schema.mjs

@@ -1,3 +1,3 @@
-export { a as address } from '../shared/blockchain.DmhmTTL_.mjs';
+export { a as address, t as transaction } from '../shared/blockchain._wwKu1qP.mjs';
 import '@develit-io/backend-sdk';
 import 'drizzle-orm/sqlite-core';

package/dist/export/worker.cjs

@@ -3,15 +3,89 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 const backendSdk = require('@develit-io/backend-sdk');
-const database_schema = require('../shared/blockchain.JxC5JMLI.cjs');
-require('drizzle-orm');
-const syncAddress = require('../shared/blockchain.D63utaAU.cjs');
+const viem = require('viem');
+const drizzle = require('../shared/blockchain.DN735AwB.cjs');
+const syncAddress = require('../shared/blockchain.B49xpPZ0.cjs');
 const cloudflare_workers = require('cloudflare:workers');
 const d1 = require('drizzle-orm/d1');
+require('../shared/blockchain.BBvwu2_7.cjs');
 require('drizzle-orm/sqlite-core');
+require('drizzle-orm');
 require('zod');
 
-const tables = database_schema.schema;
+class IBlockchainConnector {
+}
+
+class AlchemyConnector extends IBlockchainConnector {
+  constructor(config) {
+    super();
+    this.connectorKey = "ALCHEMY";
+    this.client = null;
+    this.rpcUrl = config.rpcUrl;
+  }
+  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;
+  }
+}
 
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -28,20 +102,36 @@ let BlockchainServiceBase = class extends backendSdk.develitWorker(
 ) {
   constructor(ctx, env) {
     super(ctx, env);
-    this.db = d1.drizzle(this.env.BLOCKCHAIN_D1, { schema: tables });
+    this.db = d1.drizzle(this.env.BLOCKCHAIN_D1, { schema: drizzle.tables });
   }
   async syncAddress(input) {
     return this.handleAction(
       { data: input, schema: syncAddress.syncAddressInputSchema },
       { successMessage: "Address sync workflow started" },
       async ({ addressId }) => {
-        await this.env.SYNC_ADDRESS_TRANSACTIONS_WORKFLOW.create({
+        const instance = await this.env.SYNC_ADDRESS_TRANSACTIONS_WORKFLOW.create({
           id: addressId,
           params: {
             addressId
           }
         });
-        return {};
+        return {
+          instanceId: instance.id,
+          details: await instance.status()
+        };
+      }
+    );
+  }
+  async getTransaction(input) {
+    return this.handleAction(
+      { data: input, schema: syncAddress.getTransactionInputSchema },
+      { successMessage: "Transaction retrieved successfully." },
+      async ({ txHash }) => {
+        const rpcUrl = (await this.env.SECRETS_STORE.get({
+          secretName: "BLOCKCHAIN_SERVICE_RPC_URL"
+        })).data?.secretValue || "";
+        const connector = new AlchemyConnector({ rpcUrl });
+        return connector.getTransaction(txHash);
       }
     );
   }
@@ -49,6 +139,9 @@ let BlockchainServiceBase = class extends backendSdk.develitWorker(
 __decorateClass([
   backendSdk.action("sync-address")
 ], BlockchainServiceBase.prototype, "syncAddress", 1);
+__decorateClass([
+  backendSdk.action("get-transaction")
+], BlockchainServiceBase.prototype, "getTransaction", 1);
 BlockchainServiceBase = __decorateClass([
   backendSdk.service("blockchain")
 ], BlockchainServiceBase);

package/dist/export/worker.d.cts

@@ -1,19 +1,18 @@
 import * as _develit_io_backend_sdk from '@develit-io/backend-sdk';
 import { IRPCResponse } from '@develit-io/backend-sdk';
-import { s as schema } from '../shared/blockchain.f4eN2PFQ.cjs';
-import { S as SyncAddressInput, a as SyncAddressOutput } from '../shared/blockchain.QCUmm8Hp.cjs';
+import { t as tables, S as SyncAddressInput, a as SyncAddressOutput, G as GetTransactionInput, b as GetTransactionOutput } from '../shared/blockchain.DbsOmkkX.cjs';
 import { WorkerEntrypoint } from 'cloudflare:workers';
 import { DrizzleD1Database } from 'drizzle-orm/d1';
-import 'drizzle-orm/sqlite-core';
 import 'zod';
-
-declare const tables: typeof schema;
+import '../shared/blockchain.Cx60lJ0c.cjs';
+import 'drizzle-orm/sqlite-core';
 
 declare const BlockchainServiceBase_base: (abstract new (ctx: ExecutionContext, env: BlockchainEnv) => WorkerEntrypoint<BlockchainEnv, {}>) & (abstract new (...args: any[]) => _develit_io_backend_sdk.DevelitWorkerMethods);
 declare class BlockchainServiceBase extends BlockchainServiceBase_base {
     readonly db: DrizzleD1Database<typeof tables>;
     constructor(ctx: ExecutionContext, env: BlockchainEnv);
     syncAddress(input: SyncAddressInput): Promise<IRPCResponse<SyncAddressOutput>>;
+    getTransaction(input: GetTransactionInput): Promise<IRPCResponse<GetTransactionOutput>>;
 }
 declare function defineBlockchainService(): new (ctx: ExecutionContext, env: BlockchainEnv) => BlockchainServiceBase;
 

package/dist/export/worker.d.mts

@@ -1,19 +1,18 @@
 import * as _develit_io_backend_sdk from '@develit-io/backend-sdk';
 import { IRPCResponse } from '@develit-io/backend-sdk';
-import { s as schema } from '../shared/blockchain.f4eN2PFQ.mjs';
-import { S as SyncAddressInput, a as SyncAddressOutput } from '../shared/blockchain.QCUmm8Hp.mjs';
+import { t as tables, S as SyncAddressInput, a as SyncAddressOutput, G as GetTransactionInput, b as GetTransactionOutput } from '../shared/blockchain.BDDFE27V.mjs';
 import { WorkerEntrypoint } from 'cloudflare:workers';
 import { DrizzleD1Database } from 'drizzle-orm/d1';
-import 'drizzle-orm/sqlite-core';
 import 'zod';
-
-declare const tables: typeof schema;
+import '../shared/blockchain.Cx60lJ0c.mjs';
+import 'drizzle-orm/sqlite-core';
 
 declare const BlockchainServiceBase_base: (abstract new (ctx: ExecutionContext, env: BlockchainEnv) => WorkerEntrypoint<BlockchainEnv, {}>) & (abstract new (...args: any[]) => _develit_io_backend_sdk.DevelitWorkerMethods);
 declare class BlockchainServiceBase extends BlockchainServiceBase_base {
     readonly db: DrizzleD1Database<typeof tables>;
     constructor(ctx: ExecutionContext, env: BlockchainEnv);
     syncAddress(input: SyncAddressInput): Promise<IRPCResponse<SyncAddressOutput>>;
+    getTransaction(input: GetTransactionInput): Promise<IRPCResponse<GetTransactionOutput>>;
 }
 declare function defineBlockchainService(): new (ctx: ExecutionContext, env: BlockchainEnv) => BlockchainServiceBase;
 

package/dist/export/worker.d.ts

@@ -1,19 +1,18 @@
 import * as _develit_io_backend_sdk from '@develit-io/backend-sdk';
 import { IRPCResponse } from '@develit-io/backend-sdk';
-import { s as schema } from '../shared/blockchain.f4eN2PFQ.js';
-import { S as SyncAddressInput, a as SyncAddressOutput } from '../shared/blockchain.QCUmm8Hp.js';
+import { t as tables, S as SyncAddressInput, a as SyncAddressOutput, G as GetTransactionInput, b as GetTransactionOutput } from '../shared/blockchain.4Hzh__vM.js';
 import { WorkerEntrypoint } from 'cloudflare:workers';
 import { DrizzleD1Database } from 'drizzle-orm/d1';
-import 'drizzle-orm/sqlite-core';
 import 'zod';
-
-declare const tables: typeof schema;
+import '../shared/blockchain.Cx60lJ0c.js';
+import 'drizzle-orm/sqlite-core';
 
 declare const BlockchainServiceBase_base: (abstract new (ctx: ExecutionContext, env: BlockchainEnv) => WorkerEntrypoint<BlockchainEnv, {}>) & (abstract new (...args: any[]) => _develit_io_backend_sdk.DevelitWorkerMethods);
 declare class BlockchainServiceBase extends BlockchainServiceBase_base {
     readonly db: DrizzleD1Database<typeof tables>;
     constructor(ctx: ExecutionContext, env: BlockchainEnv);
     syncAddress(input: SyncAddressInput): Promise<IRPCResponse<SyncAddressOutput>>;
+    getTransaction(input: GetTransactionInput): Promise<IRPCResponse<GetTransactionOutput>>;
 }
 declare function defineBlockchainService(): new (ctx: ExecutionContext, env: BlockchainEnv) => BlockchainServiceBase;
 

package/dist/export/worker.mjs

@@ -1,13 +1,87 @@
-import { develitWorker, action, service } from '@develit-io/backend-sdk';
-import { s as schema } from '../shared/blockchain.DmhmTTL_.mjs';
-import 'drizzle-orm';
-import { s as syncAddressInputSchema } from '../shared/blockchain.55Jm5hWs.mjs';
+import { useResult, createInternalError, develitWorker, action, service } from '@develit-io/backend-sdk';
+import { createPublicClient, http } from 'viem';
+import { t as tables } from '../shared/blockchain.0tUJ62WT.mjs';
+import { s as syncAddressInputSchema, g as getTransactionInputSchema } from '../shared/blockchain.B_Tqqlia.mjs';
 import { WorkerEntrypoint } from 'cloudflare:workers';
 import { drizzle } from 'drizzle-orm/d1';
+import '../shared/blockchain._wwKu1qP.mjs';
 import 'drizzle-orm/sqlite-core';
+import 'drizzle-orm';
 import 'zod';
 
-const tables = schema;
+class IBlockchainConnector {
+}
+
+class AlchemyConnector extends IBlockchainConnector {
+  constructor(config) {
+    super();
+    this.connectorKey = "ALCHEMY";
+    this.client = null;
+    this.rpcUrl = config.rpcUrl;
+  }
+  createClient() {
+    if (!this.client) {
+      this.client = createPublicClient({
+        transport: http(this.rpcUrl)
+      });
+    }
+    return this.client;
+  }
+  async getTransaction(txHash) {
+    const client = this.createClient();
+    const [tx, txError] = await useResult(
+      client.getTransaction({ hash: txHash })
+    );
+    if (txError || !tx) {
+      throw createInternalError(txError);
+    }
+    let status = "pending";
+    let gasUsed = null;
+    let timestamp = null;
+    if (tx.blockNumber) {
+      const [receipt, receiptError] = await useResult(
+        client.getTransactionReceipt({ hash: txHash })
+      );
+      if (receiptError || !receipt) {
+        throw createInternalError(receiptError);
+      }
+      const [block, blockError] = await useResult(
+        client.getBlock({ blockNumber: tx.blockNumber })
+      );
+      if (blockError || !block) {
+        throw 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 useResult(
+      client.getTransactionReceipt({ hash: txHash })
+    );
+    if (error || !receipt) {
+      throw createInternalError(error);
+    }
+    return receipt;
+  }
+}
 
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -31,13 +105,29 @@ let BlockchainServiceBase = class extends develitWorker(
       { data: input, schema: syncAddressInputSchema },
       { successMessage: "Address sync workflow started" },
       async ({ addressId }) => {
-        await this.env.SYNC_ADDRESS_TRANSACTIONS_WORKFLOW.create({
+        const instance = await this.env.SYNC_ADDRESS_TRANSACTIONS_WORKFLOW.create({
           id: addressId,
           params: {
             addressId
           }
         });
-        return {};
+        return {
+          instanceId: instance.id,
+          details: await instance.status()
+        };
+      }
+    );
+  }
+  async getTransaction(input) {
+    return this.handleAction(
+      { data: input, schema: getTransactionInputSchema },
+      { successMessage: "Transaction retrieved successfully." },
+      async ({ txHash }) => {
+        const rpcUrl = (await this.env.SECRETS_STORE.get({
+          secretName: "BLOCKCHAIN_SERVICE_RPC_URL"
+        })).data?.secretValue || "";
+        const connector = new AlchemyConnector({ rpcUrl });
+        return connector.getTransaction(txHash);
       }
     );
   }
@@ -45,6 +135,9 @@ let BlockchainServiceBase = class extends develitWorker(
 __decorateClass([
   action("sync-address")
 ], BlockchainServiceBase.prototype, "syncAddress", 1);
+__decorateClass([
+  action("get-transaction")
+], BlockchainServiceBase.prototype, "getTransaction", 1);
 BlockchainServiceBase = __decorateClass([
   service("blockchain")
 ], BlockchainServiceBase);

package/dist/export/workflows.cjs

@@ -1,42 +1,61 @@
 'use strict';
 
+const backendSdk = require('@develit-io/backend-sdk');
+const drizzle = require('../shared/blockchain.DN735AwB.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('drizzle-orm/sqlite-core');
 
-const TEST_ADDRESSES = {
-  "faucet-1": {
-    id: "faucet-1",
-    address: "0xc959483dba39aa9e78757139af0e9a2edeb3f42d",
-    blockchain: "ethereum",
-    network: "sepolia",
-    syncIntervalS: 60,
-    lastSyncedBlock: null
-  },
-  "faucet-2": {
-    id: "faucet-2",
-    address: "0x1f885520b7bd528e46b390040f12e753dce43004",
-    blockchain: "ethereum",
-    network: "sepolia",
-    syncIntervalS: 90,
-    lastSyncedBlock: null
-  },
-  "vitalik-test": {
-    id: "vitalik-test",
-    address: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
-    blockchain: "ethereum",
-    network: "sepolia",
-    syncIntervalS: 120,
-    lastSyncedBlock: null
-  }
+const updateAddressLastSyncCommand = (db, {
+  lastSyncAt,
+  addressId,
+  lastSyncMetadata
+}) => {
+  const command = db.update(drizzle.tables.address).set({
+    lastSyncAt,
+    lastSyncMetadata
+  }).where(drizzleOrm.eq(drizzle.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();
+  return address;
+};
+
+const createTransactionCommand = (db, { transaction }) => {
+  const id = backendSdk.uuidv4();
+  const command = db.insert(drizzle.tables.transaction).values({ ...transaction, id }).returning();
+  return { command };
 };
+
+function pushToQueue(queue, message) {
+  if (!Array.isArray(message)) return queue.send(message, { contentType: "v8" });
+  return queue.sendBatch(
+    message.map((m) => ({
+      body: m,
+      contentType: "v8"
+    }))
+  );
+}
 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 });
+    if (!addressId) {
+      throw new cloudflare_workflows.NonRetryableError(`Haven't obtained addressId to load.`);
+    }
     while (true) {
+      const now = /* @__PURE__ */ new Date();
       const address = await step.do("load address", async () => {
-        const address2 = TEST_ADDRESSES[addressId];
+        const address2 = await getAddressById(db, addressId);
         if (!address2) {
           throw new cloudflare_workflows.NonRetryableError(
             `Blockchain address not found: ${addressId}.`
@@ -44,32 +63,45 @@ class BlockchainSyncAddressTransactions extends cloudflare_workers.WorkflowEntry
         }
         return address2;
       });
-      await step.do(
+      if (!address.lastSyncAt) {
+        throw new Error(`lastSyncedAt is not set for address: ${address}`);
+      }
+      const transactions = await step.do(
         "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.sepolia,
-            transport: viem.http()
+            chain: chains.gnosisChiado,
+            transport: viem.http(rpcUrl)
           });
           const currentBlock = await client.getBlockNumber();
-          const startBlock = address.lastSyncedBlock ? BigInt(address.lastSyncedBlock) + BigInt(1) : currentBlock - BigInt(10);
-          const endBlock = currentBlock;
-          console.log(
-            `\u{1F50D} Scanning blocks ${startBlock} to ${endBlock} for address ${address.address}`
+          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") continue;
-              if (tx.from.toLowerCase() === address.address.toLowerCase() || tx.to?.toLowerCase() === address.address.toLowerCase()) {
+              if (typeof tx === "string" || !tx.to) continue;
+              if (tx.from.toLowerCase() === address.number.toLowerCase()) {
                 const receipt = await client.getTransactionReceipt({
                   hash: tx.hash
                 });
@@ -81,23 +113,70 @@ class BlockchainSyncAddressTransactions extends cloudflare_workers.WorkflowEntry
                   blockNumber: block.number.toString(),
                   blockHash: block.hash,
                   gasUsed: receipt.gasUsed.toString(),
-                  gasPrice: tx.gasPrice?.toString(),
-                  timestamp: Number(block.timestamp),
-                  status: receipt.status === "success" ? "success" : "reverted"
+                  gasPrice: tx.gasPrice?.toString() ?? "",
+                  timestamp: blockTimestamp,
+                  status: receipt.status
                 });
               }
             }
           }
-          console.log(`\u2705 Sync complete for ${address.address}`);
-          console.log(`   Found ${allTransactions.length} transactions`);
-          console.log(`   Blocks scanned: ${startBlock} to ${endBlock}`);
-          if (allTransactions.length > 0) {
-            console.log("Transactions:");
-            console.log(JSON.stringify(allTransactions));
-          }
           return allTransactions;
         }
       );
+      if (transactions.length > 0) {
+        await step.do(
+          "process new transactions and update lastSyncAt",
+          async () => {
+            const createCommands = 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 lastSyncMetadata = {
+              eventsEmitted: eventsToEmit.length
+            };
+            const updateLastSyncCommand = updateAddressLastSyncCommand(db, {
+              addressId: address.id,
+              lastSyncAt: now,
+              lastSyncMetadata
+            }).command;
+            if (eventsToEmit.length) {
+              await db.batch(
+                backendSdk.asNonEmpty([updateLastSyncCommand, ...createCommands])
+              );
+              await pushToQueue(
+                this.env.QUEUE_BUS_QUEUE,
+                eventsToEmit
+              );
+            }
+            return {
+              ...lastSyncMetadata,
+              newLastSyncAt: now
+            };
+          }
+        );
+      }
       await step.sleep(
         "sleep until next sync",
         `${address.syncIntervalS} seconds`