@voidifydao/sdk 1.0.0 → 2.0.1

package/dist/substream/runtime.js

@@ -14,6 +14,8 @@ export class SubstreamRuntime {
     mode;
     timeout;
     healthCacheMs;
+    syncInFlight = new Map();
+    syncStatuses = new Map();
     healthState = null;
     initialized = false;
     constructor(ctx, stores, config, modules) {
@@ -47,19 +49,19 @@ export class SubstreamRuntime {
         }
         return module.createClientApi(this);
     }
-    async sync(scope) {
+    async sync(scope, options) {
         const mode = await this.resolveMode();
         if (mode === "local") {
-            await this.syncLocal(scope);
+            await this.syncLocal(scope, options);
             return;
         }
         try {
-            await this.syncRemote(scope);
+            await this.syncRemote(scope, options);
         }
         catch (error) {
             if (this.mode === "auto") {
                 this.healthState = { ok: false, checkedAt: Date.now() };
-                await this.syncLocal(scope);
+                await this.syncLocal(scope, options);
                 return;
             }
             const message = error instanceof Error ? error.message : String(error);
@@ -68,8 +70,24 @@ export class SubstreamRuntime {
             });
         }
     }
-    async syncLocal(scope) {
-        await this.syncer.checkAndSync(this.registry.createStream(this.ctx, this.voidify, scope));
+    async syncLocal(scope, options) {
+        await this.runScopedSync(scope, "local", options, (run) => this.syncer.checkAndSync(this.registry.createStream(this.ctx, this.voidify, scope), run));
+    }
+    syncLocalInBackground(scope) {
+        const key = this.syncKey(scope, "local");
+        const running = this.syncInFlight.get(key);
+        if (!running) {
+            this.setSyncStatus(scope, "local", {
+                phase: "checking",
+                running: true,
+                progress: null,
+                error: null,
+                startedAt: Date.now(),
+                completedAt: null,
+            });
+            void this.syncLocal(scope).catch(() => undefined);
+        }
+        return this.getSyncStatus(scope, "local");
     }
     async applyLiveEvent(eventScope) {
         await this.syncLocal(eventScope);
@@ -86,6 +104,17 @@ export class SubstreamRuntime {
         const events = await this.events.getAfter(scope);
         await projection.apply(events.filter((event) => projection.matches(event)));
     }
+    getSyncStatus(scope, mode = "local") {
+        const status = this.ensureSyncStatus(scope, mode);
+        if (status.running && !this.syncInFlight.has(this.syncKey(scope, mode))) {
+            return this.setSyncStatus(scope, mode, {
+                phase: status.error ? "failed" : "complete",
+                running: false,
+                completedAt: status.completedAt ?? Date.now(),
+            });
+        }
+        return status;
+    }
     get baseUrl() {
         const s = this.ctx.substream;
         if (s.type === "local") {
@@ -126,10 +155,22 @@ export class SubstreamRuntime {
             return false;
         }
     }
-    async syncRemote(scope) {
-        const cursor = await this.events.getCursor(scope);
-        const afterIndex = cursor?.lastIndex ?? null;
-        const events = await this.fetchRemoteEvents(scope, afterIndex);
+    async syncRemote(scope, options) {
+        await this.runScopedSync(scope, "remote", options, async () => {
+            const cursor = await this.events.getCursor(scope);
+            const afterIndex = cursor?.lastIndex ?? null;
+            const response = await this.fetchRemoteEvents(scope, afterIndex, "background");
+            await this.applyRemoteEvents(scope, response.events, afterIndex);
+            if (response.syncStatus?.running) {
+                await this.waitForRemoteSync(scope, options);
+                const nextCursor = await this.events.getCursor(scope);
+                const nextAfterIndex = nextCursor?.lastIndex ?? null;
+                const nextResponse = await this.fetchRemoteEvents(scope, nextAfterIndex, "skip");
+                await this.applyRemoteEvents(scope, nextResponse.events, nextAfterIndex);
+            }
+        });
+    }
+    async applyRemoteEvents(scope, events, afterIndex) {
         const newEvents = events.filter((event) => afterIndex === null || event.eventIndex > afterIndex);
         if (newEvents.length === 0)
             return;
@@ -139,25 +180,184 @@ export class SubstreamRuntime {
         }
         await this.projectionRegistry.apply(newEvents);
     }
-    async fetchRemoteEvents(scope, afterIndex) {
+    async runScopedSync(scope, mode, options, task) {
+        const key = this.syncKey(scope, mode);
+        const running = this.syncInFlight.get(key);
+        if (running) {
+            options?.reporter?.update(this.ensureSyncStatus(scope, mode));
+            await running;
+            options?.reporter?.update(this.ensureSyncStatus(scope, mode));
+            return;
+        }
+        const pending = Promise.resolve().then(async () => {
+            options?.reporter?.update(await this.updateSyncStatus(scope, mode, {
+                phase: "checking",
+                running: true,
+                progress: null,
+                cursor: await this.events.getCursor(scope),
+                error: null,
+                startedAt: Date.now(),
+                completedAt: null,
+            }));
+            await task({
+                updateProgress: (progress) => {
+                    void this.updateSyncStatus(scope, mode, {
+                        phase: "syncing",
+                        running: true,
+                        progress,
+                    }).then((status) => options?.reporter?.update(status));
+                },
+            });
+            options?.reporter?.update(await this.updateSyncStatus(scope, mode, {
+                phase: "complete",
+                running: false,
+                cursor: await this.events.getCursor(scope),
+                completedAt: Date.now(),
+            }));
+        });
+        this.syncInFlight.set(key, pending);
+        try {
+            options?.reporter?.update(this.ensureSyncStatus(scope, mode));
+            await pending;
+            options?.reporter?.update(this.ensureSyncStatus(scope, mode));
+        }
+        catch (error) {
+            await this.updateSyncStatus(scope, mode, {
+                phase: "failed",
+                running: false,
+                error: error instanceof Error ? error.message : String(error),
+                cursor: await this.events.getCursor(scope),
+                completedAt: Date.now(),
+            });
+            options?.reporter?.update(this.ensureSyncStatus(scope, mode));
+            throw error;
+        }
+        finally {
+            if (this.syncInFlight.get(key) === pending) {
+                this.syncInFlight.delete(key);
+            }
+        }
+    }
+    syncKey(scope, mode) {
+        return `${mode}:${scope.scopeType}:${scope.scopeKey}`;
+    }
+    ensureSyncStatus(scope, mode) {
+        const key = this.syncKey(scope, mode);
+        const status = this.syncStatuses.get(key);
+        if (status)
+            return status;
+        const initial = {
+            ...scope,
+            mode,
+            phase: "idle",
+            running: false,
+            progress: null,
+            cursor: null,
+            error: null,
+            startedAt: null,
+            updatedAt: Date.now(),
+            completedAt: null,
+        };
+        this.syncStatuses.set(key, initial);
+        return initial;
+    }
+    setSyncStatus(scope, mode, patch) {
+        const current = this.ensureSyncStatus(scope, mode);
+        const next = {
+            ...current,
+            ...patch,
+            updatedAt: Date.now(),
+        };
+        this.syncStatuses.set(this.syncKey(scope, mode), next);
+        return next;
+    }
+    async updateSyncStatus(scope, mode, patch) {
+        return this.setSyncStatus(scope, mode, patch);
+    }
+    async waitForRemoteSync(scope, options) {
+        while (true) {
+            await this.sleep(1000);
+            const status = await this.fetchRemoteSyncStatus(scope);
+            options?.reporter?.update(await this.updateSyncStatus(scope, "remote", {
+                phase: status.phase,
+                running: status.running,
+                progress: status.progress,
+                error: status.error,
+                startedAt: status.startedAt,
+                completedAt: status.completedAt,
+            }));
+            if (!status.running) {
+                if (status.error)
+                    throw new Error(status.error);
+                return;
+            }
+        }
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async fetchRemoteEvents(scope, afterIndex, syncMode = false) {
+        const url = this.remoteEventsUrl(scope, afterIndex, syncMode);
+        let response = await this.fetchWithTimeout(url);
+        if (!response.ok && syncMode) {
+            response = await this.fetchWithTimeout(this.remoteEventsUrl(scope, afterIndex, false));
+        }
+        if (!response.ok) {
+            throw new Error(`Failed to fetch events: ${response.statusText}`);
+        }
+        const data = (await response.json());
+        return {
+            events: data.events.map(chainEventFromWire),
+            syncStatus: data.syncStatus ? syncStatusFromWire(data.syncStatus) : null,
+        };
+    }
+    remoteEventsUrl(scope, afterIndex, syncMode = false) {
         const params = new URLSearchParams();
         if (afterIndex !== null && afterIndex !== undefined) {
             params.set("after_index", afterIndex.toString());
         }
+        if (syncMode) {
+            params.set("sync", syncMode);
+        }
         const query = params.toString();
-        const url = `${this.baseUrl}/api/events/${scope.scopeType}/${scope.scopeKey}` +
-            (query ? `?${query}` : "");
+        return (`${this.baseUrl}/api/events/${scope.scopeType}/${scope.scopeKey}` +
+            (query ? `?${query}` : ""));
+    }
+    fetchWithTimeout(url) {
+        return fetch(url, {
+            method: "GET",
+            signal: AbortSignal.timeout(this.timeout),
+        });
+    }
+    async fetchRemoteSyncStatus(scope) {
+        const url = `${this.baseUrl}/api/sync/${scope.scopeType}/${scope.scopeKey}/status`;
         const response = await fetch(url, {
             method: "GET",
             signal: AbortSignal.timeout(this.timeout),
         });
         if (!response.ok) {
-            throw new Error(`Failed to fetch events: ${response.statusText}`);
+            throw new Error(`Failed to fetch sync status: ${response.statusText}`);
         }
-        const data = (await response.json());
-        return data.events.map(chainEventFromWire);
+        return syncStatusFromWire((await response.json()));
     }
 }
+function cursorFromWire(cursor) {
+    if (!cursor)
+        return null;
+    return {
+        scopeType: cursor.scopeType,
+        scopeKey: cursor.scopeKey,
+        lastIndex: cursor.lastIndex === null ? null : BigInt(cursor.lastIndex),
+        lastSignature: cursor.lastSignature,
+        lastSyncAt: cursor.lastSyncAt,
+    };
+}
+function syncStatusFromWire(status) {
+    return {
+        ...status,
+        cursor: cursorFromWire(status.cursor),
+    };
+}
 export function createSubstreamRuntime(ctx, stores, config, modules) {
     return new SubstreamRuntime(ctx, stores, config, modules);
 }

package/dist/substream/server/server.d.ts

@@ -20,6 +20,8 @@ export declare class HttpServer {
     private setupRoutes;
     private handleHealth;
     private handleGetEvents;
+    private handleGetSyncStatus;
+    private syncAndGetStatus;
     private parseScope;
     private parseAfterIndex;
     start(): Promise<void>;

package/dist/substream/server/server.js

@@ -31,6 +31,7 @@ export class HttpServer {
     setupRoutes() {
         this.app.get("/health", this.handleHealth.bind(this));
         this.app.get("/api/events/:scopeType/:scopeKey", this.handleGetEvents.bind(this));
+        this.app.get("/api/sync/:scopeType/:scopeKey/status", this.handleGetSyncStatus.bind(this));
         this.app.use((_req, res) => {
             res.status(404).json({ error: "Not found" });
         });
@@ -53,19 +54,19 @@ export class HttpServer {
             const afterIndex = this.parseAfterIndex(req, res);
             if (afterIndex === false)
                 return;
-            await this.runtime.syncLocal(scope);
+            const syncMode = req.query.sync;
+            const syncStatus = syncMode === "skip"
+                ? this.runtime.getSyncStatus(scope, "local")
+                : syncMode === "background"
+                    ? this.runtime.syncLocalInBackground(scope)
+                    : await this.syncAndGetStatus(scope);
             const events = await this.runtime.events.getAfter(scope, afterIndex === null ? undefined : afterIndex);
             const cursor = await this.runtime.events.getCursor(scope);
             res.json({
                 events: events.map(chainEventToWire),
                 total: events.length,
-                cursor: cursor
-                    ? {
-                        lastIndex: cursor.lastIndex === null ? null : cursor.lastIndex.toString(),
-                        lastSignature: cursor.lastSignature,
-                        lastSyncAt: cursor.lastSyncAt,
-                    }
-                    : null,
+                cursor: cursorToWire(cursor),
+                syncStatus: syncStatusToWire(syncStatus),
             });
         }
         catch (error) {
@@ -73,6 +74,22 @@ export class HttpServer {
             res.status(500).json({ error: "Failed to fetch events" });
         }
     }
+    async handleGetSyncStatus(req, res) {
+        try {
+            const scope = this.parseScope(req, res);
+            if (!scope)
+                return;
+            res.json(syncStatusToWire(this.runtime.getSyncStatus(scope, "local")));
+        }
+        catch (error) {
+            logger.error({ err: error, params: req.params }, "fetch sync status failed");
+            res.status(500).json({ error: "Failed to fetch sync status" });
+        }
+    }
+    async syncAndGetStatus(scope) {
+        await this.runtime.syncLocal(scope);
+        return this.runtime.getSyncStatus(scope, "local");
+    }
     parseScope(req, res) {
         const scopeType = String(req.params.scopeType);
         const scopeKey = String(req.params.scopeKey);
@@ -138,6 +155,23 @@ export class HttpServer {
         return `http://${this.host}:${this.port}`;
     }
 }
+function cursorToWire(cursor) {
+    return cursor
+        ? {
+            scopeType: cursor.scopeType,
+            scopeKey: cursor.scopeKey,
+            lastIndex: cursor.lastIndex === null ? null : cursor.lastIndex.toString(),
+            lastSignature: cursor.lastSignature,
+            lastSyncAt: cursor.lastSyncAt,
+        }
+        : null;
+}
+function syncStatusToWire(status) {
+    return {
+        ...status,
+        cursor: cursorToWire(status.cursor),
+    };
+}
 export class SubstreamService {
     ctx;
     options;

package/dist/substream/types.d.ts

@@ -44,6 +44,26 @@ export interface EventCursor {
     lastSignature: string | null;
     lastSyncAt: number;
 }
+export interface SyncProgress {
+    current: number;
+    total: number;
+    signature: string;
+}
+export type SyncPhase = "idle" | "checking" | "syncing" | "complete" | "failed";
+export interface SyncStatus extends EventScope {
+    mode: "local" | "remote";
+    phase: SyncPhase;
+    running: boolean;
+    progress: SyncProgress | null;
+    cursor: EventCursor | null;
+    error: string | null;
+    startedAt: number | null;
+    updatedAt: number;
+    completedAt: number | null;
+}
+export interface SyncStatusReporter {
+    update(status: SyncStatus): void;
+}
 export type ApplyOutcome = {
     kind: "applied";
     cursor: bigint;
@@ -84,6 +104,7 @@ export interface ProjectionStore {
     initialize(): Promise<void>;
     get(projectionId: string, key: string): Promise<ProjectionStateRecord | null>;
     put(record: ProjectionStateRecord): Promise<void>;
+    delete(projectionId: string, key: string): Promise<void>;
     list(projectionId: string): Promise<ProjectionStateRecord[]>;
     clear(projectionId: string): Promise<void>;
 }

package/dist/types/index.d.ts

@@ -1,3 +1,2 @@
 import type { VersionedTransaction } from "@solana/web3.js";
-export * from "./errors.js";
 export type SignReturn<S> = S extends false ? VersionedTransaction : string;

package/dist/types/index.js

@@ -1 +1 @@
-export * from "./errors.js";
+export {};

package/dist/voidify/deposit.d.ts

@@ -1,10 +1,12 @@
 import { TransactionInstruction } from "@solana/web3.js";
 import { Context } from "../context.js";
 import type { DepositRecord } from "../substream/types.js";
+import type { ChainSyncOptions } from "../substream/chain/index.js";
 export declare function depositIx(ctx: Context, commitment: string, denomination: bigint): Promise<TransactionInstruction[]>;
 export declare const deposit: <S extends boolean = true>(ctx: Context, commitment: string, denomination: bigint, sign?: S | undefined) => Promise<import("../index.js").SignReturn<S>>;
 export declare function listDeposits(ctx: Context, denomination: bigint, options?: {
     offset?: number;
     limit?: number;
     output?: string;
+    sync?: ChainSyncOptions;
 }): Promise<DepositRecord[]>;

package/dist/voidify/deposit.js

@@ -26,7 +26,7 @@ export async function listDeposits(ctx, denomination, options) {
     const client = new SubstreamCliClient(ctx);
     await client.init();
     const depositModule = client.module("deposit");
-    await depositModule.sync(denomination);
+    await depositModule.sync(denomination, options?.sync);
     const deposits = await depositModule.list(denomination, {
         offset: options?.offset,
         limit: options?.limit,

package/dist/voidify/program.d.ts

@@ -6,7 +6,6 @@ export declare class VoidifyProgram {
     private _program;
     private _programId;
     static readonly SEEDS: {
-        readonly CORE_CONFIG: Buffer<ArrayBufferLike>;
         readonly STAKE_CONFIG: Buffer<ArrayBufferLike>;
         readonly TREASURY_CONFIG: Buffer<ArrayBufferLike>;
         readonly ORACLE_CONFIG: Buffer<ArrayBufferLike>;
@@ -17,12 +16,10 @@ export declare class VoidifyProgram {
         readonly RELAYER_CONFIG: Buffer<ArrayBufferLike>;
         readonly RELAYER_EVENT_COUNTER: Buffer<ArrayBufferLike>;
     };
-    static readonly BPF_LOADER_UPGRADEABLE_PROGRAM_ID: PublicKey;
     constructor(connection: Connection, programId: PublicKey);
     get program(): Program<Voidify>;
     get programId(): PublicKey;
     get rpcConnection(): Connection;
-    coreConfig(): PublicKey;
     stakeConfig(): PublicKey;
     treasuryConfig(): PublicKey;
     oracleConfig(): PublicKey;
@@ -32,5 +29,4 @@ export declare class VoidifyProgram {
     nullifier(nullifierHash: Uint8Array): PublicKey;
     relayerConfig(relayerPubkey: PublicKey): PublicKey;
     relayerEventCounter(): PublicKey;
-    programData(): PublicKey;
 }

package/dist/voidify/program.js

@@ -7,7 +7,6 @@ export class VoidifyProgram {
     _program = null;
     _programId;
     static SEEDS = {
-        CORE_CONFIG: getConstSeed(idl, "core_config"),
         STAKE_CONFIG: getConstSeed(idl, "stake_config"),
         TREASURY_CONFIG: getConstSeed(idl, "treasury_config"),
         ORACLE_CONFIG: getConstSeed(idl, "oracle_config"),
@@ -18,7 +17,6 @@ export class VoidifyProgram {
         RELAYER_CONFIG: getConstSeed(idl, "relayer_config"),
         RELAYER_EVENT_COUNTER: getConstSeed(idl, "relayer_event_counter"),
     };
-    static BPF_LOADER_UPGRADEABLE_PROGRAM_ID = new PublicKey("BPFLoaderUpgradeab1e11111111111111111111111");
     constructor(connection, programId) {
         this.connection = connection;
         this._programId = programId;
@@ -38,10 +36,6 @@ export class VoidifyProgram {
     get rpcConnection() {
         return this.connection;
     }
-    coreConfig() {
-        const [pda] = PublicKey.findProgramAddressSync([VoidifyProgram.SEEDS.CORE_CONFIG], this._programId);
-        return pda;
-    }
     stakeConfig() {
         const [pda] = PublicKey.findProgramAddressSync([VoidifyProgram.SEEDS.STAKE_CONFIG], this._programId);
         return pda;
@@ -80,8 +74,4 @@ export class VoidifyProgram {
         const [pda] = PublicKey.findProgramAddressSync([VoidifyProgram.SEEDS.RELAYER_EVENT_COUNTER], this._programId);
         return pda;
     }
-    programData() {
-        const [pda] = PublicKey.findProgramAddressSync([this._programId.toBuffer()], VoidifyProgram.BPF_LOADER_UPGRADEABLE_PROGRAM_ID);
-        return pda;
-    }
 }

package/dist/voidify/relayer/list.d.ts

@@ -1,5 +1,7 @@
 import { Context } from "../../context.js";
 import type { RelayerRecord } from "../../substream/types.js";
+import type { ChainSyncOptions } from "../../substream/chain/index.js";
 export declare function listRelayers(ctx: Context, pubkey?: string, options?: {
     output?: string;
+    sync?: ChainSyncOptions;
 }): Promise<RelayerRecord[] | RelayerRecord | null>;

package/dist/voidify/relayer/list.js

@@ -3,7 +3,7 @@ export async function listRelayers(ctx, pubkey, options) {
     const client = new SubstreamCliClient(ctx);
     await client.init();
     const relayerModule = client.module("relayer");
-    await relayerModule.sync();
+    await relayerModule.sync(options?.sync);
     const result = pubkey
         ? await relayerModule.get(pubkey)
         : await relayerModule.list();

package/dist/voidify/withdraw.d.ts

@@ -1,16 +1,21 @@
 import { PublicKey, TransactionInstruction } from "@solana/web3.js";
 import { Context } from "../context.js";
 import { Note } from "../utils/note.js";
+import type { ChainSyncOptions } from "../substream/chain/index.js";
 export declare function directWithdrawIx(ctx: Context, proof: Uint8Array, root: Uint8Array, nullifierHash: Uint8Array, recipient: string, fee: bigint, treasury: bigint, denomination: bigint): Promise<TransactionInstruction[]>;
 export declare function withdrawIx(ctx: Context, proof: Uint8Array, root: Uint8Array, nullifierHash: Uint8Array, recipient: string, relayer: string, fee: bigint, treasury: bigint, switchboardQuote: PublicKey, denomination: bigint): Promise<TransactionInstruction[]>;
 export interface WithdrawArtifact {
     withdrawData: string;
     relayerUrl: string;
 }
+export interface WithdrawSyncOptions {
+    depositSync?: ChainSyncOptions;
+    relayerSync?: ChainSyncOptions;
+}
 export declare function validateNote(ctx: Context, note_str: string): Promise<{
     note: Note;
 }>;
-export declare function prepareWithdraw(ctx: Context, note_str: string, recipient: string, relayer: string): Promise<WithdrawArtifact>;
+export declare function prepareWithdraw(ctx: Context, note_str: string, recipient?: string, relayerName?: string, options?: WithdrawSyncOptions, sendRpc?: boolean): Promise<WithdrawArtifact>;
 export declare function submitWithdrawToRelayer(artifact: WithdrawArtifact): Promise<string>;
-export declare function withdraw(ctx: Context, note_str: string, recipient: string, relayer: string, _dryRun: boolean): Promise<string>;
+export declare function withdraw(ctx: Context, note_str: string, recipient?: string, relayerName?: string, options?: WithdrawSyncOptions, sendRpc?: boolean): Promise<string>;
 export declare function directWithdraw(ctx: Context, note_str: string, recipient: string): Promise<string>;