@voidifydao/sdk 1.0.0

package/dist/substream/database/sqlite.js

@@ -0,0 +1,275 @@
+import Database from "better-sqlite3";
+function ensureCursorsTable(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS cursors (
+      scope_type TEXT NOT NULL,
+      scope_key TEXT NOT NULL,
+      last_index INTEGER,
+      last_signature TEXT,
+      last_sync_at INTEGER NOT NULL,
+      PRIMARY KEY (scope_type, scope_key)
+    )
+  `);
+}
+function readCursorSync(db, scope) {
+    const row = db
+        .prepare(`SELECT scope_type, scope_key, last_index, last_signature, last_sync_at
+       FROM cursors WHERE scope_type = ? AND scope_key = ?`)
+        .get(scope.scopeType, scope.scopeKey);
+    if (!row)
+        return null;
+    return {
+        scopeType: row.scope_type,
+        scopeKey: row.scope_key,
+        lastIndex: row.last_index === null ? null : BigInt(row.last_index),
+        lastSignature: row.last_signature,
+        lastSyncAt: row.last_sync_at,
+    };
+}
+function writeCursorSync(db, scope, event, lastSyncAt) {
+    db.prepare(`INSERT INTO cursors (scope_type, scope_key, last_index, last_signature, last_sync_at)
+     VALUES (?, ?, ?, ?, ?)
+     ON CONFLICT(scope_type, scope_key) DO UPDATE SET
+       last_index = excluded.last_index,
+       last_signature = excluded.last_signature,
+       last_sync_at = excluded.last_sync_at`).run(scope.scopeType, scope.scopeKey, eventIndexToNumber(event.eventIndex), event.signature, lastSyncAt);
+}
+function guardEvent(cursor, eventIndex) {
+    const last = cursor?.lastIndex ?? -1n;
+    if (eventIndex <= last)
+        return "duplicate";
+    if (eventIndex > last + 1n) {
+        return { kind: "gap", expected: last + 1n, got: eventIndex };
+    }
+    return "applied";
+}
+export class SQLiteEventStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async initialize() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        scope_type TEXT NOT NULL,
+        scope_key TEXT NOT NULL,
+        event_name TEXT NOT NULL,
+        event_index INTEGER NOT NULL,
+        signature TEXT NOT NULL,
+        slot INTEGER,
+        block_time INTEGER,
+        address TEXT NOT NULL,
+        payload_json TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        UNIQUE(scope_type, scope_key, event_index)
+      );
+      CREATE INDEX IF NOT EXISTS idx_events_scope_index
+        ON events(scope_type, scope_key, event_index);
+      CREATE INDEX IF NOT EXISTS idx_events_name ON events(event_name);
+      CREATE INDEX IF NOT EXISTS idx_events_signature ON events(signature);
+      CREATE INDEX IF NOT EXISTS idx_events_address ON events(address);
+    `);
+        ensureCursorsTable(this.db);
+    }
+    async apply(scope, event) {
+        return this.applyBatch(scope, [event]);
+    }
+    async applyBatch(scope, events) {
+        if (events.length === 0) {
+            const cursor = await this.getCursor(scope);
+            return { kind: "applied", cursor: cursor?.lastIndex ?? -1n };
+        }
+        class GapError extends Error {
+            outcome;
+            constructor(outcome) {
+                super("gap");
+                this.outcome = outcome;
+            }
+        }
+        const sorted = [...events].sort(compareEvents);
+        const tx = this.db.transaction(() => {
+            let cursor = readCursorSync(this.db, scope);
+            let last = {
+                kind: "applied",
+                cursor: cursor?.lastIndex ?? -1n,
+            };
+            for (const event of sorted) {
+                const guard = guardEvent(cursor, event.eventIndex);
+                if (typeof guard !== "string")
+                    throw new GapError(guard);
+                if (guard === "duplicate") {
+                    last = { kind: "duplicate", cursor: cursor?.lastIndex ?? -1n };
+                    continue;
+                }
+                insertEventSync(this.db, event);
+                const now = Date.now();
+                writeCursorSync(this.db, scope, event, now);
+                cursor = {
+                    scopeType: scope.scopeType,
+                    scopeKey: scope.scopeKey,
+                    lastIndex: event.eventIndex,
+                    lastSignature: event.signature,
+                    lastSyncAt: now,
+                };
+                last = { kind: "applied", cursor: event.eventIndex };
+            }
+            return last;
+        });
+        try {
+            return tx();
+        }
+        catch (error) {
+            if (error instanceof GapError)
+                return error.outcome;
+            throw new Error("Failed to apply chain events", { cause: error });
+        }
+    }
+    async list(scope, opts) {
+        let query = `
+      SELECT * FROM events
+      WHERE scope_type = ? AND scope_key = ?
+      ORDER BY event_index DESC
+    `;
+        const params = [scope.scopeType, scope.scopeKey];
+        const { offset, limit } = opts ?? {};
+        if (limit !== undefined) {
+            query += " LIMIT ?";
+            params.push(limit);
+            if (offset !== undefined && offset > 0) {
+                query += " OFFSET ?";
+                params.push(offset);
+            }
+        }
+        else if (offset !== undefined && offset > 0) {
+            query += " LIMIT -1 OFFSET ?";
+            params.push(offset);
+        }
+        const rows = this.db.prepare(query).all(...params);
+        return rows.map(rowToEvent);
+    }
+    async getAfter(scope, afterIndex) {
+        let query = `
+      SELECT * FROM events
+      WHERE scope_type = ? AND scope_key = ?
+    `;
+        const params = [scope.scopeType, scope.scopeKey];
+        if (afterIndex !== undefined) {
+            query += " AND event_index > ?";
+            params.push(eventIndexToNumber(afterIndex));
+        }
+        query += " ORDER BY event_index ASC";
+        const rows = this.db.prepare(query).all(...params);
+        return rows.map(rowToEvent);
+    }
+    async count(scope) {
+        const row = this.db
+            .prepare(`SELECT COUNT(*) as count FROM events
+         WHERE scope_type = ? AND scope_key = ?`)
+            .get(scope.scopeType, scope.scopeKey);
+        return row?.count ?? 0;
+    }
+    async getCursor(scope) {
+        return readCursorSync(this.db, scope);
+    }
+}
+function insertEventSync(db, event) {
+    db.prepare(`INSERT INTO events
+     (scope_type, scope_key, event_name, event_index,
+      signature, slot, block_time, address, payload_json, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(event.scopeType, event.scopeKey, event.eventName, eventIndexToNumber(event.eventIndex), event.signature, event.slot, event.blockTime, event.address, JSON.stringify(event.payload), event.createdAt);
+}
+function rowToEvent(row) {
+    return {
+        scopeType: row.scope_type,
+        scopeKey: row.scope_key,
+        eventName: row.event_name,
+        eventIndex: BigInt(row.event_index),
+        signature: row.signature,
+        slot: row.slot ?? null,
+        blockTime: row.block_time ?? null,
+        address: row.address,
+        payload: JSON.parse(row.payload_json),
+        createdAt: row.created_at,
+    };
+}
+function eventIndexToNumber(eventIndex) {
+    if (eventIndex < 0n || eventIndex > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new RangeError(`Event index ${eventIndex.toString()} is outside the safe integer range`);
+    }
+    return Number(eventIndex);
+}
+function compareEvents(a, b) {
+    return a.eventIndex < b.eventIndex ? -1 : a.eventIndex > b.eventIndex ? 1 : 0;
+}
+export class SQLiteProjectionStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async initialize() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS projection_states (
+        projection_id TEXT NOT NULL,
+        entity_key TEXT NOT NULL,
+        value_json TEXT NOT NULL,
+        updated_at INTEGER NOT NULL,
+        last_event_index INTEGER,
+        PRIMARY KEY (projection_id, entity_key)
+      );
+      CREATE INDEX IF NOT EXISTS idx_projection_states_projection
+        ON projection_states(projection_id);
+    `);
+    }
+    async get(projectionId, key) {
+        const row = this.db
+            .prepare(`SELECT * FROM projection_states
+         WHERE projection_id = ? AND entity_key = ?`)
+            .get(projectionId, key);
+        return row ? rowToProjectionState(row) : null;
+    }
+    async put(record) {
+        this.db
+            .prepare(`INSERT INTO projection_states
+         (projection_id, entity_key, value_json, updated_at, last_event_index)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(projection_id, entity_key) DO UPDATE SET
+          value_json = excluded.value_json,
+          updated_at = excluded.updated_at,
+          last_event_index = excluded.last_event_index`)
+            .run(record.projectionId, record.key, JSON.stringify(record.value), record.updatedAt, record.lastEventIndex === null
+            ? null
+            : eventIndexToNumber(record.lastEventIndex));
+    }
+    async list(projectionId) {
+        const rows = this.db
+            .prepare(`SELECT * FROM projection_states
+         WHERE projection_id = ?
+         ORDER BY entity_key ASC`)
+            .all(projectionId);
+        return rows.map(rowToProjectionState);
+    }
+    async clear(projectionId) {
+        this.db
+            .prepare("DELETE FROM projection_states WHERE projection_id = ?")
+            .run(projectionId);
+    }
+}
+function rowToProjectionState(row) {
+    return {
+        projectionId: row.projection_id,
+        key: row.entity_key,
+        value: JSON.parse(row.value_json),
+        updatedAt: row.updated_at,
+        lastEventIndex: row.last_event_index === null ? null : BigInt(row.last_event_index),
+    };
+}
+export function makeSQLiteStores(path, _programId) {
+    const db = new Database(path && path.length > 0 ? path : ":memory:");
+    const events = new SQLiteEventStore(db);
+    const projections = new SQLiteProjectionStore(db);
+    return {
+        events,
+        projections,
+    };
+}

package/dist/substream/modules/deposit.d.ts

@@ -0,0 +1,14 @@
+import type { DepositRecord, EventCursor, EventScope } from "../../substream/types.js";
+import type { SubstreamModule } from "../../substream/chain/registry.js";
+export interface DepositModuleApi {
+    sync(denomination: bigint): Promise<void>;
+    list(denomination: bigint, opts?: {
+        offset?: number;
+        limit?: number;
+    }): Promise<DepositRecord[]>;
+    getAfter(denomination: bigint, afterIndex?: bigint): Promise<DepositRecord[]>;
+    count(denomination: bigint): Promise<number>;
+    getCursor(denomination: bigint): Promise<EventCursor | null>;
+}
+export declare function depositScope(denomination: bigint): EventScope;
+export declare const depositModule: SubstreamModule;

package/dist/substream/modules/deposit.js

@@ -0,0 +1,123 @@
+import { toBigInt } from "../../utils/anchor-events.js";
+import { bytesToBigInt, bytesToHex } from "../../utils/bytes.js";
+import { parseEventsFromLogs } from "../../utils/anchor-events.js";
+import { syncTransactions } from "../../substream/chain/utils.js";
+export function depositScope(denomination) {
+    return { scopeType: "deposit", scopeKey: denomination.toString() };
+}
+export const depositModule = {
+    id: "deposit",
+    scopeType: "deposit",
+    parseScopeKey(scopeKey) {
+        try {
+            return depositScope(BigInt(scopeKey));
+        }
+        catch {
+            return null;
+        }
+    },
+    createStream(ctx, voidify, scope) {
+        return createDepositStream(ctx, voidify, BigInt(scope.scopeKey));
+    },
+    liveEvents: [
+        {
+            eventName: "depositEvent",
+            async toRecord({ voidify, event, signature, slot }) {
+                const deposit = event;
+                return depositEventToChainEvent({
+                    event: deposit,
+                    signature,
+                    slot,
+                    address: voidify.pool(BigInt(String(deposit.denomination))),
+                });
+            },
+        },
+    ],
+    createClientApi(runtime) {
+        return {
+            async sync(denomination) {
+                await runtime.sync(depositScope(denomination));
+            },
+            async list(denomination, opts) {
+                const rows = await runtime.events.list(depositScope(denomination), opts);
+                return rows.map(depositRecordFromEvent);
+            },
+            async getAfter(denomination, afterIndex) {
+                const rows = await runtime.events.getAfter(depositScope(denomination), afterIndex);
+                return rows.map(depositRecordFromEvent);
+            },
+            async count(denomination) {
+                return runtime.events.count(depositScope(denomination));
+            },
+            async getCursor(denomination) {
+                return runtime.events.getCursor(depositScope(denomination));
+            },
+        };
+    },
+};
+function createDepositStream(ctx, voidify, denomination) {
+    const address = voidify.pool(denomination);
+    return {
+        id: "deposit",
+        scope: depositScope(denomination),
+        address,
+        getChainLastIndex: async () => {
+            const poolAccount = await voidify.program.account.pool.fetch(address);
+            return BigInt(poolAccount.merkleTree.nextIndex) - 1n;
+        },
+        collect: async (lastSignature) => {
+            const transactions = await syncTransactions(ctx.connection, address, lastSignature);
+            const records = [];
+            for (const tx of transactions) {
+                const decoded = parseEventsFromLogs(tx.logs, voidify.program.coder.events);
+                for (const item of decoded) {
+                    if (item.name !== "depositEvent")
+                        continue;
+                    records.push(depositEventToChainEvent({
+                        event: item.data,
+                        signature: tx.signature,
+                        slot: tx.slot,
+                        blockTime: tx.blockTime,
+                        address,
+                    }));
+                }
+            }
+            return records;
+        },
+    };
+}
+function depositEventToChainEvent(args) {
+    const event = args.event;
+    const denomination = toBigInt(event.denomination);
+    const index = Number(event.index);
+    const commitmentBytes = Uint8Array.from(event.commitment);
+    const payload = {
+        denomination: denomination.toString(),
+        depositor: event.depositor.toString(),
+        commitment: bytesToBigInt(commitmentBytes).toString(),
+        commitmentHex: bytesToHex(commitmentBytes),
+        index,
+        timestamp: toBigInt(event.timestamp).toString(),
+    };
+    return {
+        ...depositScope(denomination),
+        eventName: "depositEvent",
+        eventIndex: BigInt(index),
+        signature: args.signature,
+        slot: args.slot ?? null,
+        blockTime: args.blockTime ?? null,
+        address: args.address.toBase58(),
+        payload,
+        createdAt: Date.now(),
+    };
+}
+function depositRecordFromEvent(event) {
+    return {
+        denomination: BigInt(String(event.payload.denomination)),
+        depositor: String(event.payload.depositor),
+        commitment: String(event.payload.commitment),
+        index: Number(event.payload.index),
+        timestamp: Number(BigInt(String(event.payload.timestamp))),
+        signature: event.signature,
+    };
+}

package/dist/substream/modules/index.d.ts

@@ -0,0 +1,11 @@
+import { SubstreamModuleRegistry } from "../../substream/chain/registry.js";
+import { type DepositModuleApi } from "./deposit.js";
+import { type RelayerModuleApi } from "./relayer.js";
+export interface BuiltinSubstreamModuleApis {
+    deposit: DepositModuleApi;
+    relayer: RelayerModuleApi;
+}
+export declare const substreamModules: readonly [import("../../substream/chain/registry.js").SubstreamModule, import("../../substream/chain/registry.js").SubstreamModule];
+export declare function createSubstreamRegistry(): SubstreamModuleRegistry;
+export type { DepositModuleApi } from "./deposit.js";
+export type { RelayerModuleApi } from "./relayer.js";

package/dist/substream/modules/index.js

@@ -0,0 +1,7 @@
+import { SubstreamModuleRegistry } from "../../substream/chain/registry.js";
+import { depositModule } from "./deposit.js";
+import { relayerModule } from "./relayer.js";
+export const substreamModules = [depositModule, relayerModule];
+export function createSubstreamRegistry() {
+    return new SubstreamModuleRegistry([...substreamModules]);
+}

package/dist/substream/modules/relayer.d.ts

@@ -0,0 +1,10 @@
+import type { EventScope, RelayerRecord } from "../../substream/types.js";
+import type { SubstreamModule } from "../../substream/chain/registry.js";
+export interface RelayerModuleApi {
+    sync(): Promise<void>;
+    list(): Promise<RelayerRecord[]>;
+    get(pubkey: string): Promise<RelayerRecord | null>;
+    rebuild(): Promise<void>;
+}
+export declare const RELAYER_SCOPE: EventScope;
+export declare const relayerModule: SubstreamModule;