@permissionless-technologies/upp-sdk 0.1.0

package/dist/chunk-OQDSHMXU.js

@@ -0,0 +1,1002 @@
+import { createAutoAdapter } from './chunk-XV72HNHN.js';
+import { keccak256, toHex } from 'viem';
+
+async function computeSearchTag(sdk, masterViewingSecret, masterViewingPubKey, ephemeralPubkey, debug = false) {
+  const dvk = await sdk.deriveDecryptionViewingKey(
+    masterViewingSecret,
+    masterViewingPubKey,
+    ephemeralPubkey.x
+  );
+  const viewingSharedSecret = await sdk.computeSharedSecret(dvk, ephemeralPubkey);
+  const searchTagHash = await sdk.poseidon([viewingSharedSecret.x, 0n]);
+  const searchTag = searchTagHash & (1n << 64n) - 1n;
+  if (debug) {
+    console.log(`[computeSearchTag] viewingSharedSecret.x: ${viewingSharedSecret.x}`);
+    console.log(`[computeSearchTag] searchTagHash: ${searchTagHash}`);
+    console.log(`[computeSearchTag] searchTag (lower 64 bits): ${searchTag}`);
+  }
+  return searchTag;
+}
+async function matchesSearchTag(eventSearchTag, sdk, masterViewingSecret, masterViewingPubKey, ephemeralPubkey, debug = false) {
+  const expectedTag = await computeSearchTag(
+    sdk,
+    masterViewingSecret,
+    masterViewingPubKey,
+    ephemeralPubkey,
+    debug
+  );
+  if (debug) {
+    console.log(`[matchesSearchTag] eventSearchTag: ${eventSearchTag}, expectedTag: ${expectedTag}, match: ${eventSearchTag === expectedTag}`);
+  }
+  return eventSearchTag === expectedTag;
+}
+async function tryDecryptNote(sdk, keys, ephemeralPubkey, encryptedNote, expectedCommitment, debug = false) {
+  try {
+    const dvk = await sdk.deriveDecryptionViewingKey(
+      keys.masterViewingSecret,
+      keys.masterViewingPubKey,
+      ephemeralPubkey.x
+    );
+    const viewingSharedSecret = await sdk.computeSharedSecret(dvk, ephemeralPubkey);
+    const keyMaterial = keccak256(toHex(viewingSharedSecret.x, { size: 32 }));
+    const keyBytes = hexToBytes(keyMaterial);
+    const cryptoKey = await crypto.subtle.importKey(
+      "raw",
+      keyBytes.buffer.slice(keyBytes.byteOffset, keyBytes.byteOffset + keyBytes.byteLength),
+      { name: "AES-GCM", length: 256 },
+      false,
+      ["decrypt"]
+    );
+    const encryptedBytes = hexToBytes(encryptedNote);
+    const nonce = encryptedBytes.slice(0, 12);
+    const ciphertext = encryptedBytes.slice(12);
+    const plaintext = await crypto.subtle.decrypt({ name: "AES-GCM", iv: nonce }, cryptoKey, ciphertext);
+    const plaintextBytes = new Uint8Array(plaintext);
+    if (debug) {
+      console.log(`[tryDecryptNote] Decrypted plaintext length: ${plaintextBytes.length} bytes`);
+    }
+    const amount = bytesToBigint(plaintextBytes.slice(0, 32));
+    const blinding = bytesToBigint(plaintextBytes.slice(32, 64));
+    const origin = bytesToBigint(plaintextBytes.slice(64, 84));
+    const token = bytesToBigint(plaintextBytes.slice(84, 104));
+    const spendingSharedSecret = await sdk.computeSharedSecret(keys.spendingSecret, ephemeralPubkey);
+    const stealthScalar = await sdk.poseidon([spendingSharedSecret.x, spendingSharedSecret.y]);
+    const stealthOffset = await sdk.privateToPublic(stealthScalar);
+    const oneTimePubkey = await sdk.addPoints(keys.spendingPubkey, stealthOffset);
+    const subOrder = await sdk.getSubOrder();
+    const oneTimeSecret = (keys.spendingSecret + stealthScalar) % subOrder;
+    const computedCommitment = await sdk.poseidon([
+      amount,
+      oneTimePubkey.x,
+      oneTimePubkey.y,
+      blinding,
+      origin,
+      token
+    ]);
+    if (debug) {
+      console.log(`[tryDecryptNote] Decrypted values:`);
+      console.log(`  amount: ${amount}`);
+      console.log(`  blinding: ${blinding}`);
+      console.log(`  origin: 0x${origin.toString(16).padStart(40, "0")}`);
+      console.log(`  token: 0x${token.toString(16).padStart(40, "0")}`);
+      console.log(`  oneTimePubkey.x: ${oneTimePubkey.x}`);
+      console.log(`  oneTimePubkey.y: ${oneTimePubkey.y}`);
+      console.log(`  computedCommitment: ${computedCommitment}`);
+      console.log(`  expectedCommitment: ${expectedCommitment}`);
+      console.log(`  match: ${computedCommitment === expectedCommitment}`);
+    }
+    if (computedCommitment !== expectedCommitment) {
+      if (debug) {
+        console.log(`[tryDecryptNote] Commitment mismatch - not our note`);
+      }
+      return null;
+    }
+    return { amount, blinding, oneTimeSecret, oneTimePubkey, origin, token };
+  } catch (e) {
+    if (debug) {
+      console.log(`[tryDecryptNote] Decryption exception:`, e instanceof Error ? e.message : e);
+      console.log(`[tryDecryptNote]   encryptedNote hex length: ${encryptedNote.length} chars = ${(encryptedNote.length - 2) / 2} bytes`);
+    }
+    return null;
+  }
+}
+function unpackNoteData(packed, debug = false) {
+  try {
+    const bytes = hexToBytes(packed);
+    if (bytes.length < 100) {
+      if (debug) {
+        console.log(`[unpackNoteData] Packed data too short: ${bytes.length} bytes`);
+      }
+      return null;
+    }
+    const searchTag = bytesToBigint(bytes.slice(0, 8));
+    const ephemeralPubkeyX = bytesToBigint(bytes.slice(8, 40));
+    const ephemeralPubkeyY = bytesToBigint(bytes.slice(40, 72));
+    const encryptedNote = "0x" + Array.from(bytes.slice(72)).map((b) => b.toString(16).padStart(2, "0")).join("");
+    if (debug) {
+      console.log(`[unpackNoteData] Total packed bytes: ${bytes.length}, header: 72, encryptedNote: ${bytes.length - 72}`);
+      console.log(`[unpackNoteData] searchTag=${searchTag}, ephemeralPubkeyX=${ephemeralPubkeyX}`);
+    }
+    return { searchTag, ephemeralPubkeyX, ephemeralPubkeyY, encryptedNote };
+  } catch (e) {
+    if (debug) {
+      console.log(`[unpackNoteData] Failed to unpack:`, e);
+    }
+    return null;
+  }
+}
+function hexToBytes(hex) {
+  const h = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(h.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(h.substr(i * 2, 2), 16);
+  }
+  return bytes;
+}
+function bytesToBigint(bytes) {
+  let result = 0n;
+  for (let i = 0; i < bytes.length; i++) {
+    const byte = bytes[i];
+    if (byte !== void 0) {
+      result = result << 8n | BigInt(byte);
+    }
+  }
+  return result;
+}
+var DEFAULT_BATCH_SIZE = 200;
+var MIN_BATCH_SIZE = 50;
+var MAX_BATCH_SIZE = 2e3;
+var BATCH_DELAY_MS = 100;
+var DEFAULT_LIVE_SYNC_INTERVAL_MS = 3e4;
+var DEFAULT_REQUESTS_PER_SECOND = 20;
+var DEFAULT_MAX_CONCURRENT = 10;
+var STORAGE_KEY_SYNC = "sync";
+var STORAGE_KEY_NOTES = "notes";
+var STORAGE_KEY_NULLIFIERS = "nullifiers";
+var COMMITMENT_INSERTED_EVENT = {
+  type: "event",
+  name: "CommitmentInserted",
+  inputs: [
+    { indexed: true, name: "commitment", type: "bytes32" },
+    { indexed: false, name: "leafIndex", type: "uint256" },
+    { indexed: false, name: "timestamp", type: "uint256" }
+  ]
+};
+var STEALTH_TRANSACT_EVENT = {
+  type: "event",
+  name: "StealthTransact",
+  inputs: [
+    { indexed: true, name: "commitment", type: "bytes32" },
+    { indexed: true, name: "searchTag", type: "uint64" },
+    { indexed: false, name: "ephemeralPubkeyX", type: "uint256" },
+    { indexed: false, name: "ephemeralPubkeyY", type: "uint256" },
+    { indexed: false, name: "encryptedNote", type: "bytes" }
+  ]
+};
+var SHIELDED_EVENT = {
+  type: "event",
+  name: "Shielded",
+  inputs: [
+    { indexed: true, name: "token", type: "address" },
+    { indexed: true, name: "depositor", type: "address" },
+    { indexed: true, name: "commitment", type: "bytes32" },
+    { indexed: false, name: "leafIndex", type: "uint256" },
+    { indexed: false, name: "encryptedNote", type: "bytes" }
+  ]
+};
+var TRANSFERRED_EVENT = {
+  type: "event",
+  name: "Transferred",
+  inputs: [
+    { indexed: true, name: "nullifier", type: "bytes32" },
+    { indexed: true, name: "outputCommitment1", type: "bytes32" },
+    { indexed: true, name: "outputCommitment2", type: "bytes32" },
+    { indexed: false, name: "encryptedNote1", type: "bytes" },
+    { indexed: false, name: "encryptedNote2", type: "bytes" }
+  ]
+};
+var NULLIFIED_EVENT = {
+  type: "event",
+  name: "Nullified",
+  inputs: [{ indexed: true, name: "nullifier", type: "bytes32" }]
+};
+var WITHDRAWN_EVENT = {
+  type: "event",
+  name: "Withdrawn",
+  inputs: [
+    { indexed: true, name: "token", type: "address" },
+    { indexed: true, name: "recipient", type: "address" },
+    { indexed: true, name: "nullifier", type: "bytes32" },
+    { indexed: false, name: "amount", type: "uint256" },
+    { indexed: false, name: "isRagequit", type: "bool" }
+  ]
+};
+var RateLimiter = class {
+  tokens;
+  maxTokens;
+  refillRate;
+  // tokens per ms
+  lastRefill;
+  activeRequests;
+  maxConcurrent;
+  queue = [];
+  constructor(requestsPerSecond, maxConcurrent) {
+    this.maxTokens = requestsPerSecond;
+    this.tokens = requestsPerSecond;
+    this.refillRate = requestsPerSecond / 1e3;
+    this.lastRefill = Date.now();
+    this.activeRequests = 0;
+    this.maxConcurrent = maxConcurrent;
+  }
+  /**
+   * Refill tokens based on time elapsed
+   */
+  refill() {
+    const now = Date.now();
+    const elapsed = now - this.lastRefill;
+    this.tokens = Math.min(this.maxTokens, this.tokens + elapsed * this.refillRate);
+    this.lastRefill = now;
+  }
+  /**
+   * Try to process queued requests
+   */
+  processQueue() {
+    while (this.queue.length > 0 && this.activeRequests < this.maxConcurrent) {
+      this.refill();
+      if (this.tokens >= 1) {
+        this.tokens -= 1;
+        this.activeRequests++;
+        const resolve = this.queue.shift();
+        resolve?.();
+      } else {
+        break;
+      }
+    }
+  }
+  /**
+   * Acquire a token (wait if necessary)
+   */
+  async acquire() {
+    return new Promise((resolve) => {
+      this.refill();
+      if (this.tokens >= 1 && this.activeRequests < this.maxConcurrent) {
+        this.tokens -= 1;
+        this.activeRequests++;
+        resolve();
+        return;
+      }
+      this.queue.push(resolve);
+      const waitTime = this.tokens < 1 ? Math.ceil((1 - this.tokens) / this.refillRate) : 10;
+      setTimeout(() => this.processQueue(), waitTime);
+    });
+  }
+  /**
+   * Release a token (call after request completes)
+   */
+  release() {
+    this.activeRequests = Math.max(0, this.activeRequests - 1);
+    this.processQueue();
+  }
+  /**
+   * Execute a function with rate limiting
+   */
+  async execute(fn) {
+    await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+};
+var sdkPromise = null;
+async function loadSDK() {
+  if (!sdkPromise) {
+    sdkPromise = import('./index.js');
+  }
+  return sdkPromise;
+}
+var RpcIndexer = class {
+  client;
+  contractAddress;
+  chainId;
+  storage;
+  spendingSecret;
+  spendingPubkey;
+  masterViewingSecret;
+  masterViewingPubKey;
+  // Adaptive batching state
+  batchSize;
+  minBatchSize;
+  batchDelayMs;
+  // In-memory cache
+  notes = [];
+  nullifiers = /* @__PURE__ */ new Set();
+  lastBlock = 0;
+  initialized = false;
+  // Initial starting block (fallback if no saved state)
+  initialFromBlock;
+  // Live sync state
+  liveSyncInterval = null;
+  liveSyncConfig = null;
+  // Rate limiter for RPC requests
+  rateLimiter;
+  constructor(config) {
+    this.client = config.client;
+    this.contractAddress = config.contractAddress;
+    this.chainId = config.chainId;
+    this.spendingSecret = config.spendingSecret;
+    this.spendingPubkey = config.spendingPubkey;
+    this.masterViewingSecret = config.masterViewingSecret;
+    this.masterViewingPubKey = config.masterViewingPubKey;
+    this.batchSize = config.batchSize ?? DEFAULT_BATCH_SIZE;
+    this.minBatchSize = config.minBatchSize ?? MIN_BATCH_SIZE;
+    this.batchDelayMs = config.batchDelayMs ?? BATCH_DELAY_MS;
+    this.initialFromBlock = config.fromBlock ?? 0;
+    const accountPrefix = `${config.chainId}_${config.contractAddress.slice(2, 10)}_${toHex(config.spendingPubkey.x).slice(2, 12)}`;
+    this.storage = config.storage ?? createAutoAdapter(accountPrefix);
+    this.rateLimiter = new RateLimiter(DEFAULT_REQUESTS_PER_SECOND, DEFAULT_MAX_CONCURRENT);
+  }
+  /**
+   * Initialize from storage
+   */
+  async init() {
+    if (this.initialized) return;
+    const syncState = await this.storage.get(STORAGE_KEY_SYNC);
+    if (syncState && syncState.chainId === this.chainId && syncState.contractAddress === this.contractAddress) {
+      this.lastBlock = syncState.lastBlock;
+    } else {
+      this.lastBlock = this.initialFromBlock;
+    }
+    const serializedNotes = await this.storage.get(STORAGE_KEY_NOTES);
+    if (serializedNotes) {
+      this.notes = serializedNotes.map(deserializeNote);
+    }
+    const nullifiers = await this.storage.get(STORAGE_KEY_NULLIFIERS);
+    if (nullifiers) {
+      this.nullifiers = new Set(nullifiers.map((n) => n.toLowerCase()));
+    }
+    this.initialized = true;
+    if (this.notes.length > 0 && this.nullifiers.size > 0) {
+      await this.checkNotesAgainstNullifiers();
+    }
+  }
+  /**
+   * Check all notes against known nullifiers and mark spent ones
+   */
+  async checkNotesAgainstNullifiers() {
+    const sdk = await loadSDK();
+    let spentCount = 0;
+    console.log(`[Indexer] checkNotesAgainstNullifiers: ${this.notes.length} notes, ${this.nullifiers.size} nullifiers in set`);
+    if (this.nullifiers.size > 0) {
+      console.log(`[Indexer] Known nullifiers:`);
+      for (const n of this.nullifiers) {
+        console.log(`  ${n}`);
+      }
+    }
+    for (const note of this.notes) {
+      if (note.status === "spent") continue;
+      try {
+        const nullifier = await sdk.poseidon([
+          BigInt(note.oneTimeSecret),
+          BigInt(note.leafIndex),
+          BigInt(note.commitment)
+        ]);
+        const nullifierHex = toHex(nullifier, { size: 32 }).toLowerCase();
+        const isSpent = this.nullifiers.has(nullifierHex);
+        console.log(`[Indexer] Note ${note.commitment.slice(0, 18)}... leafIndex=${note.leafIndex} \u2192 nullifier=${nullifierHex.slice(0, 18)}... \u2192 ${isSpent ? "SPENT" : "unspent"}`);
+        if (isSpent) {
+          note.status = "spent";
+          spentCount++;
+        }
+      } catch (e) {
+        console.error(`[Indexer] Error computing nullifier for note:`, e);
+      }
+    }
+    if (spentCount > 0) {
+      console.log(`[Indexer] Marked ${spentCount} notes as spent based on nullifiers`);
+      await this.persist();
+    }
+    return spentCount;
+  }
+  /**
+   * Persist current state to storage
+   */
+  async persist() {
+    const syncState = {
+      lastBlock: this.lastBlock,
+      chainId: this.chainId,
+      contractAddress: this.contractAddress,
+      lastSyncTimestamp: Date.now()
+    };
+    await Promise.all([
+      this.storage.set(STORAGE_KEY_SYNC, syncState),
+      this.storage.set(STORAGE_KEY_NOTES, this.notes.map(serializeNote)),
+      this.storage.set(STORAGE_KEY_NULLIFIERS, Array.from(this.nullifiers))
+    ]);
+  }
+  /**
+   * Sync notes from blockchain
+   *
+   * @param config - Optional sync configuration
+   */
+  async sync(config) {
+    const startTime = Date.now();
+    await this.init();
+    const errors = [];
+    let newNotesCount = 0;
+    let spentNotesCount = 0;
+    const debug = config?.debug ?? false;
+    const useSearchTagFiltering = config?.useSearchTagFiltering ?? false;
+    try {
+      const currentBlock = Number(await this.client.getBlockNumber());
+      const fromBlock = this.lastBlock > 0 ? this.lastBlock + 1 : this.initialFromBlock;
+      if (fromBlock > currentBlock) {
+        return {
+          newNotesCount: 0,
+          spentNotesCount: 0,
+          lastBlock: this.lastBlock,
+          durationMs: Date.now() - startTime
+        };
+      }
+      const reportProgress = (currentBlock_, eventsProcessed2, notesFound, eventsSkipped2) => {
+        if (config?.onProgress) {
+          const totalBlocks = currentBlock - fromBlock + 1;
+          const processedBlocks = currentBlock_ - fromBlock + 1;
+          config.onProgress({
+            currentBlock: currentBlock_,
+            targetBlock: currentBlock,
+            eventsProcessed: eventsProcessed2,
+            notesFound,
+            percent: Math.round(processedBlocks / totalBlocks * 100),
+            eventsSkipped: eventsSkipped2
+          });
+        }
+      };
+      const commitmentMap = /* @__PURE__ */ new Map();
+      const stealthEvents = [];
+      const newNullifiers = [];
+      let currentBatchSize = this.batchSize;
+      let batchStart = fromBlock;
+      while (batchStart <= currentBlock) {
+        const batchEnd = Math.min(batchStart + currentBatchSize - 1, currentBlock);
+        try {
+          const [commitmentLogs, stealthLogs, shieldedLogs, transferredLogs, nullifiedLogs, withdrawnLogs] = await Promise.all([
+            this.rateLimiter.execute(
+              () => this.client.getLogs({
+                address: this.contractAddress,
+                event: COMMITMENT_INSERTED_EVENT,
+                fromBlock: BigInt(batchStart),
+                toBlock: BigInt(batchEnd)
+              })
+            ),
+            this.rateLimiter.execute(
+              () => this.client.getLogs({
+                address: this.contractAddress,
+                event: STEALTH_TRANSACT_EVENT,
+                fromBlock: BigInt(batchStart),
+                toBlock: BigInt(batchEnd)
+              })
+            ),
+            this.rateLimiter.execute(
+              () => this.client.getLogs({
+                address: this.contractAddress,
+                event: SHIELDED_EVENT,
+                fromBlock: BigInt(batchStart),
+                toBlock: BigInt(batchEnd)
+              })
+            ),
+            this.rateLimiter.execute(
+              () => this.client.getLogs({
+                address: this.contractAddress,
+                event: TRANSFERRED_EVENT,
+                fromBlock: BigInt(batchStart),
+                toBlock: BigInt(batchEnd)
+              })
+            ),
+            this.rateLimiter.execute(
+              () => this.client.getLogs({
+                address: this.contractAddress,
+                event: NULLIFIED_EVENT,
+                fromBlock: BigInt(batchStart),
+                toBlock: BigInt(batchEnd)
+              })
+            ),
+            this.rateLimiter.execute(
+              () => this.client.getLogs({
+                address: this.contractAddress,
+                event: WITHDRAWN_EVENT,
+                fromBlock: BigInt(batchStart),
+                toBlock: BigInt(batchEnd)
+              })
+            )
+          ]);
+          for (const log of commitmentLogs) {
+            const commitment = log.args.commitment.toLowerCase();
+            commitmentMap.set(commitment, {
+              leafIndex: Number(log.args.leafIndex),
+              timestamp: Number(log.args.timestamp),
+              blockNumber: Number(log.blockNumber)
+            });
+          }
+          for (const log of stealthLogs) {
+            const args = log.args;
+            stealthEvents.push({
+              commitment: args.commitment.toLowerCase(),
+              ephemeralPubkeyX: args.ephemeralPubkeyX,
+              ephemeralPubkeyY: args.ephemeralPubkeyY,
+              encryptedNote: args.encryptedNote,
+              txHash: log.transactionHash,
+              blockNumber: Number(log.blockNumber),
+              searchTag: args.searchTag
+            });
+          }
+          for (const log of shieldedLogs) {
+            const args = log.args;
+            const unpacked = unpackNoteData(args.encryptedNote);
+            if (unpacked) {
+              stealthEvents.push({
+                commitment: args.commitment.toLowerCase(),
+                ephemeralPubkeyX: unpacked.ephemeralPubkeyX,
+                ephemeralPubkeyY: unpacked.ephemeralPubkeyY,
+                encryptedNote: unpacked.encryptedNote,
+                txHash: log.transactionHash,
+                blockNumber: Number(log.blockNumber),
+                searchTag: unpacked.searchTag
+              });
+              commitmentMap.set(args.commitment.toLowerCase(), {
+                leafIndex: Number(args.leafIndex),
+                timestamp: Math.floor(Date.now() / 1e3),
+                blockNumber: Number(log.blockNumber)
+              });
+            }
+          }
+          for (const log of transferredLogs) {
+            const args = log.args;
+            const unpacked1 = unpackNoteData(args.encryptedNote1);
+            if (unpacked1) {
+              stealthEvents.push({
+                commitment: args.outputCommitment1.toLowerCase(),
+                ephemeralPubkeyX: unpacked1.ephemeralPubkeyX,
+                ephemeralPubkeyY: unpacked1.ephemeralPubkeyY,
+                encryptedNote: unpacked1.encryptedNote,
+                txHash: log.transactionHash,
+                blockNumber: Number(log.blockNumber),
+                searchTag: unpacked1.searchTag
+              });
+            }
+            const unpacked2 = unpackNoteData(args.encryptedNote2);
+            if (unpacked2) {
+              stealthEvents.push({
+                commitment: args.outputCommitment2.toLowerCase(),
+                ephemeralPubkeyX: unpacked2.ephemeralPubkeyX,
+                ephemeralPubkeyY: unpacked2.ephemeralPubkeyY,
+                encryptedNote: unpacked2.encryptedNote,
+                txHash: log.transactionHash,
+                blockNumber: Number(log.blockNumber),
+                searchTag: unpacked2.searchTag
+              });
+            }
+          }
+          for (const log of nullifiedLogs) {
+            const nullifier = log.args.nullifier.toLowerCase();
+            newNullifiers.push(nullifier);
+          }
+          for (const log of transferredLogs) {
+            const args = log.args;
+            if (args.nullifier) {
+              newNullifiers.push(args.nullifier.toLowerCase());
+            }
+          }
+          if (withdrawnLogs.length > 0) {
+            console.log(`[Indexer] Found ${withdrawnLogs.length} Withdrawn events in batch`);
+          }
+          for (const log of withdrawnLogs) {
+            const args = log.args;
+            if (args.nullifier) {
+              const nullifierLower = args.nullifier.toLowerCase();
+              console.log(`[Indexer] Withdrawn event nullifier: ${nullifierLower}`);
+              newNullifiers.push(nullifierLower);
+            }
+          }
+          if (currentBatchSize < MAX_BATCH_SIZE) {
+            currentBatchSize = Math.min(currentBatchSize * 2, MAX_BATCH_SIZE);
+          }
+          reportProgress(batchEnd, stealthEvents.length, 0, 0);
+          batchStart = batchEnd + 1;
+          if (batchStart <= currentBlock) {
+            await sleep(this.batchDelayMs);
+          }
+        } catch (e) {
+          if (isRateLimitError(e)) {
+            currentBatchSize = Math.max(Math.floor(currentBatchSize / 2), this.minBatchSize);
+            errors.push(`Rate limited at block ${batchStart}, reducing batch size to ${currentBatchSize}`);
+            await sleep(1e3);
+            continue;
+          }
+          throw e;
+        }
+      }
+      this.batchSize = currentBatchSize;
+      console.log(`[Indexer] Processing ${newNullifiers.length} new nullifiers`);
+      for (const nullifier of newNullifiers) {
+        if (!this.nullifiers.has(nullifier.toLowerCase())) {
+          this.nullifiers.add(nullifier.toLowerCase());
+        }
+      }
+      console.log(`[Indexer] Total nullifiers in set: ${this.nullifiers.size}`);
+      const sdk = await loadSDK();
+      const existingCommitmentsMap = new Map(this.notes.map((n) => [n.commitment.toLowerCase(), n]));
+      console.log(`[Indexer] Sync: blocks ${fromBlock} to ${currentBlock} (${currentBlock - fromBlock + 1} blocks)`);
+      console.log(`[Indexer] Found: ${stealthEvents.length} stealth events, ${commitmentMap.size} commitment events`);
+      console.log(`[Indexer] Search tag filtering: ${useSearchTagFiltering ? "ENABLED" : "DISABLED"}`);
+      if (debug) {
+        console.log(`[Indexer] Existing notes in memory: ${this.notes.length}`);
+        console.log(`[Indexer] masterViewingPubKey: x=${this.masterViewingPubKey.x}, y=${this.masterViewingPubKey.y}`);
+      }
+      let eventsSkipped = 0;
+      let eventsProcessed = 0;
+      for (const event of stealthEvents) {
+        const commitmentLower = event.commitment.toLowerCase();
+        const existingNote = existingCommitmentsMap.get(commitmentLower);
+        if (existingNote && existingNote.status === "confirmed") {
+          continue;
+        }
+        if (existingNote && existingNote.status === "pending") {
+          const info = commitmentMap.get(commitmentLower);
+          existingNote.status = "confirmed";
+          existingNote.leafIndex = info?.leafIndex ?? existingNote.leafIndex;
+          existingNote.blockNumber = info?.blockNumber ?? event.blockNumber;
+          existingNote.timestamp = info?.timestamp ?? existingNote.timestamp;
+          newNotesCount++;
+          continue;
+        }
+        if (useSearchTagFiltering && event.searchTag !== void 0) {
+          const ephemeralPubkey = { x: event.ephemeralPubkeyX, y: event.ephemeralPubkeyY };
+          const shouldLogDetails = debug && eventsSkipped + eventsProcessed < 3;
+          if (shouldLogDetails) {
+            console.log(`[Indexer] Checking event searchTag=${event.searchTag}`);
+            console.log(`[Indexer]   ephemeralPubkey: x=${ephemeralPubkey.x}, y=${ephemeralPubkey.y}`);
+          }
+          const matches = await matchesSearchTag(
+            event.searchTag,
+            sdk,
+            this.masterViewingSecret,
+            this.masterViewingPubKey,
+            ephemeralPubkey,
+            shouldLogDetails
+            // Pass debug flag
+          );
+          if (!matches) {
+            eventsSkipped++;
+            continue;
+          }
+          if (debug) {
+            console.log(`[Indexer] \u2713 Search tag MATCHED for commitment ${event.commitment.slice(0, 18)}...`);
+          }
+        }
+        eventsProcessed++;
+        try {
+          if (debug) {
+            console.log(`[Indexer] Trying to decrypt event commitment: ${event.commitment}`);
+            console.log(`[Indexer]   Encrypted note length: ${(event.encryptedNote.length - 2) / 2} bytes`);
+          }
+          const decrypted = await tryDecryptNote2(
+            sdk,
+            this.spendingSecret,
+            this.spendingPubkey,
+            this.masterViewingSecret,
+            this.masterViewingPubKey,
+            { x: event.ephemeralPubkeyX, y: event.ephemeralPubkeyY },
+            event.encryptedNote,
+            BigInt(event.commitment)
+          );
+          if (decrypted) {
+            if (debug) {
+              console.log(`[Indexer] \u2713 Decryption SUCCESS for commitment ${event.commitment.slice(0, 18)}...`);
+              console.log(`[Indexer]   Amount: ${decrypted.amount}, Origin: 0x${decrypted.origin.toString(16)}, Token: 0x${decrypted.token.toString(16)}`);
+            }
+            const info = commitmentMap.get(event.commitment.toLowerCase());
+            const note = {
+              amount: decrypted.amount,
+              blinding: decrypted.blinding,
+              commitment: event.commitment.toLowerCase(),
+              oneTimeSecret: toHex(decrypted.oneTimeSecret, { size: 32 }),
+              oneTimePubkeyX: toHex(decrypted.oneTimePubkey.x, { size: 32 }),
+              oneTimePubkeyY: toHex(decrypted.oneTimePubkey.y, { size: 32 }),
+              leafIndex: info?.leafIndex ?? 0,
+              txHash: event.txHash,
+              status: "confirmed",
+              blockNumber: info?.blockNumber ?? event.blockNumber,
+              timestamp: info?.timestamp ?? Math.floor(Date.now() / 1e3),
+              origin: "0x" + decrypted.origin.toString(16).padStart(40, "0"),
+              token: "0x" + decrypted.token.toString(16).padStart(40, "0"),
+              ephemeralX: toHex(event.ephemeralPubkeyX, { size: 32 }),
+              ephemeralY: toHex(event.ephemeralPubkeyY, { size: 32 })
+            };
+            this.notes.push(note);
+            existingCommitmentsMap.set(note.commitment.toLowerCase(), note);
+            newNotesCount++;
+          }
+        } catch (decryptErr) {
+          if (debug) {
+            console.log(`[Indexer] \u2717 Decryption FAILED for commitment ${event.commitment.slice(0, 18)}...`, decryptErr);
+          }
+        }
+      }
+      if (stealthEvents.length > 0) {
+        console.log(`[Indexer] Result: ${eventsSkipped} skipped by search tag, ${eventsProcessed} processed, ${newNotesCount} notes found`);
+      }
+      reportProgress(currentBlock, eventsProcessed, newNotesCount, eventsSkipped);
+      spentNotesCount = await this.checkNotesAgainstNullifiers();
+      this.lastBlock = currentBlock;
+      await this.persist();
+      if (newNotesCount > 0 && this.liveSyncConfig?.onNewNotes) {
+        const newNotes = this.notes.slice(-newNotesCount);
+        this.liveSyncConfig.onNewNotes(newNotes);
+      }
+      return {
+        newNotesCount,
+        spentNotesCount,
+        lastBlock: this.lastBlock,
+        durationMs: Date.now() - startTime,
+        errors: errors.length > 0 ? errors : void 0
+      };
+    } catch (e) {
+      const error = e instanceof Error ? e : new Error(String(e));
+      if (this.liveSyncConfig?.onError) {
+        this.liveSyncConfig.onError(error);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get total balance of unspent notes
+   */
+  getBalance(token) {
+    const unspent = this.getUnspentNotes();
+    const filtered = token ? unspent.filter((n) => n.token === token) : unspent;
+    return filtered.reduce((sum, n) => sum + n.amount, 0n);
+  }
+  /**
+   * Get all notes matching filters
+   */
+  getNotes(filters) {
+    let result = [...this.notes];
+    if (filters?.status) {
+      const statuses = Array.isArray(filters.status) ? filters.status : [filters.status];
+      result = result.filter((n) => statuses.includes(n.status));
+    }
+    if (filters?.token) {
+      result = result.filter((n) => n.token === filters.token);
+    }
+    if (filters?.minAmount !== void 0) {
+      result = result.filter((n) => n.amount >= filters.minAmount);
+    }
+    if (filters?.maxAmount !== void 0) {
+      result = result.filter((n) => n.amount <= filters.maxAmount);
+    }
+    return result;
+  }
+  /**
+   * Get unspent notes
+   */
+  getUnspentNotes() {
+    return this.notes.filter((n) => n.status !== "spent");
+  }
+  /**
+   * Get the last synced block number
+   */
+  getLastBlock() {
+    return this.lastBlock;
+  }
+  /**
+   * Mark a note as spent
+   */
+  markSpent(commitment) {
+    const note = this.notes.find((n) => n.commitment.toLowerCase() === commitment.toLowerCase());
+    if (note) {
+      note.status = "spent";
+      this.persist().catch(console.error);
+    }
+  }
+  /**
+   * Add a note directly
+   */
+  addNote(note) {
+    if (this.notes.some((n) => n.commitment.toLowerCase() === note.commitment.toLowerCase())) {
+      return;
+    }
+    this.notes.push(note);
+    this.persist().catch(console.error);
+  }
+  /**
+   * Start live sync
+   */
+  startLiveSync(config) {
+    if (this.liveSyncInterval) {
+      this.stopLiveSync();
+    }
+    this.liveSyncConfig = config ?? {};
+    const intervalMs = config?.intervalMs ?? DEFAULT_LIVE_SYNC_INTERVAL_MS;
+    this.liveSyncInterval = setInterval(() => {
+      this.sync().catch((e) => {
+        if (config?.onError) {
+          config.onError(e instanceof Error ? e : new Error(String(e)));
+        }
+      });
+    }, intervalMs);
+    this.sync().catch((e) => {
+      if (config?.onError) {
+        config.onError(e instanceof Error ? e : new Error(String(e)));
+      }
+    });
+  }
+  /**
+   * Stop live sync
+   */
+  stopLiveSync() {
+    if (this.liveSyncInterval) {
+      clearInterval(this.liveSyncInterval);
+      this.liveSyncInterval = null;
+    }
+    this.liveSyncConfig = null;
+  }
+  /**
+   * Check if live sync is running
+   */
+  isLiveSyncing() {
+    return this.liveSyncInterval !== null;
+  }
+  /**
+   * Clear all indexed data
+   */
+  async clear() {
+    this.notes = [];
+    this.nullifiers.clear();
+    this.lastBlock = 0;
+    await this.storage.clear();
+  }
+  /**
+   * Export current state
+   */
+  async exportState() {
+    await this.init();
+    return {
+      sync: {
+        lastBlock: this.lastBlock,
+        chainId: this.chainId,
+        contractAddress: this.contractAddress,
+        lastSyncTimestamp: Date.now()
+      },
+      notes: this.notes.map(serializeNote),
+      nullifiers: Array.from(this.nullifiers)
+    };
+  }
+  /**
+   * Import state
+   */
+  async importState(state) {
+    if (state.sync.chainId !== this.chainId || state.sync.contractAddress !== this.contractAddress) {
+      throw new Error("State does not match indexer configuration");
+    }
+    this.lastBlock = state.sync.lastBlock;
+    this.notes = state.notes.map(deserializeNote);
+    this.nullifiers = new Set(state.nullifiers.map((n) => n.toLowerCase()));
+    this.initialized = true;
+    await this.persist();
+  }
+};
+function makeRpcIndexer(config) {
+  return new RpcIndexer(config);
+}
+async function tryDecryptNote2(sdk, spendingSecret, spendingPubkey, masterViewingSecret, masterViewingPubKey, ephemeralPubkey, encryptedNote, expectedCommitment) {
+  try {
+    const dvk = await sdk.deriveDecryptionViewingKey(masterViewingSecret, masterViewingPubKey, ephemeralPubkey.x);
+    const viewingSharedSecret = await sdk.computeSharedSecret(dvk, ephemeralPubkey);
+    const keyMaterial = keccak256(toHex(viewingSharedSecret.x, { size: 32 }));
+    const keyBytes = hexToBytes(keyMaterial);
+    const cryptoKey = await crypto.subtle.importKey(
+      "raw",
+      keyBytes.buffer.slice(keyBytes.byteOffset, keyBytes.byteOffset + keyBytes.byteLength),
+      { name: "AES-GCM", length: 256 },
+      false,
+      ["decrypt"]
+    );
+    const encryptedBytes = hexToBytes(encryptedNote);
+    const nonce = encryptedBytes.slice(0, 12);
+    const ciphertext = encryptedBytes.slice(12);
+    const plaintext = await crypto.subtle.decrypt({ name: "AES-GCM", iv: nonce }, cryptoKey, ciphertext);
+    const plaintextBytes = new Uint8Array(plaintext);
+    console.log(`[tryDecryptNote] Decrypted plaintext length: ${plaintextBytes.length} bytes`);
+    const amount = bytesToBigint(plaintextBytes.slice(0, 32));
+    const blinding = bytesToBigint(plaintextBytes.slice(32, 64));
+    const origin = bytesToBigint(plaintextBytes.slice(64, 84));
+    const token = bytesToBigint(plaintextBytes.slice(84, 104));
+    const spendingSharedSecret = await sdk.computeSharedSecret(spendingSecret, ephemeralPubkey);
+    const stealthScalar = await sdk.poseidon([spendingSharedSecret.x, spendingSharedSecret.y]);
+    const stealthOffset = await sdk.privateToPublic(stealthScalar);
+    const oneTimePubkey = await sdk.addPoints(spendingPubkey, stealthOffset);
+    const subOrder = await sdk.getSubOrder();
+    const oneTimeSecret = (spendingSecret + stealthScalar) % subOrder;
+    const computedCommitment = await sdk.poseidon([
+      amount,
+      oneTimePubkey.x,
+      oneTimePubkey.y,
+      blinding,
+      origin,
+      token
+    ]);
+    console.log(`[tryDecryptNote] Decrypted values:`);
+    console.log(`  amount: ${amount}`);
+    console.log(`  blinding: ${blinding}`);
+    console.log(`  origin: 0x${origin.toString(16).padStart(40, "0")}`);
+    console.log(`  token: 0x${token.toString(16).padStart(40, "0")}`);
+    console.log(`  oneTimePubkey.x: ${oneTimePubkey.x}`);
+    console.log(`  oneTimePubkey.y: ${oneTimePubkey.y}`);
+    console.log(`  computedCommitment: ${computedCommitment}`);
+    console.log(`  expectedCommitment: ${expectedCommitment}`);
+    console.log(`  match: ${computedCommitment === expectedCommitment}`);
+    if (computedCommitment !== expectedCommitment) {
+      console.log(`[tryDecryptNote] Commitment mismatch - not our note`);
+      return null;
+    }
+    return { amount, blinding, oneTimeSecret, oneTimePubkey, origin, token };
+  } catch (e) {
+    console.log(`[tryDecryptNote] Decryption exception:`, e instanceof Error ? e.message : e);
+    console.log(`[tryDecryptNote]   encryptedNote hex length: ${encryptedNote.length} chars = ${(encryptedNote.length - 2) / 2} bytes`);
+    return null;
+  }
+}
+function serializeNote(note) {
+  return {
+    amount: note.amount.toString(),
+    blinding: note.blinding.toString(),
+    commitment: note.commitment,
+    oneTimeSecret: note.oneTimeSecret,
+    oneTimePubkeyX: note.oneTimePubkeyX,
+    oneTimePubkeyY: note.oneTimePubkeyY,
+    leafIndex: note.leafIndex,
+    txHash: note.txHash,
+    status: note.status,
+    blockNumber: note.blockNumber,
+    timestamp: note.timestamp,
+    origin: note.origin,
+    token: note.token,
+    ephemeralX: note.ephemeralX,
+    ephemeralY: note.ephemeralY
+  };
+}
+function deserializeNote(note) {
+  return {
+    amount: BigInt(note.amount),
+    blinding: BigInt(note.blinding),
+    commitment: note.commitment,
+    oneTimeSecret: note.oneTimeSecret,
+    oneTimePubkeyX: note.oneTimePubkeyX,
+    oneTimePubkeyY: note.oneTimePubkeyY,
+    leafIndex: note.leafIndex,
+    txHash: note.txHash,
+    status: note.status,
+    blockNumber: note.blockNumber,
+    timestamp: note.timestamp,
+    origin: note.origin,
+    token: note.token,
+    ephemeralX: note.ephemeralX,
+    ephemeralY: note.ephemeralY
+  };
+}
+function isRateLimitError(e) {
+  if (e instanceof Error) {
+    const message = e.message.toLowerCase();
+    return message.includes("rate limit") || message.includes("too many requests") || message.includes("429") || message.includes("exceeded");
+  }
+  return false;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export { computeSearchTag, makeRpcIndexer, matchesSearchTag, tryDecryptNote, unpackNoteData };
+//# sourceMappingURL=chunk-OQDSHMXU.js.map
+//# sourceMappingURL=chunk-OQDSHMXU.js.map