@voidifydao/sdk 1.0.0

package/dist/substream/server/server.js

@@ -0,0 +1,216 @@
+import express from "express";
+import cors from "cors";
+import Database from "better-sqlite3";
+import { SQLiteEventStore, SQLiteProjectionStore, } from "../../substream/database/sqlite.js";
+import { EventListener } from "./event-listener.js";
+import { chainEventToWire } from "../../substream/chain/events.js";
+import { createSubstreamRuntime, } from "../../substream/runtime.js";
+import { substreamLogger as logger } from "../../utils/logger.js";
+export class HttpServer {
+    runtime;
+    app;
+    server = null;
+    host;
+    port;
+    constructor(runtime, config) {
+        this.runtime = runtime;
+        this.port = config.port;
+        this.host = config.host || "0.0.0.0";
+        this.app = express();
+        this.setupMiddleware();
+        this.setupRoutes();
+    }
+    setupMiddleware() {
+        this.app.use(cors());
+        this.app.use(express.json());
+        this.app.use((req, _res, next) => {
+            logger.info({ method: req.method, path: req.path }, "HTTP request");
+            next();
+        });
+    }
+    setupRoutes() {
+        this.app.get("/health", this.handleHealth.bind(this));
+        this.app.get("/api/events/:scopeType/:scopeKey", this.handleGetEvents.bind(this));
+        this.app.use((_req, res) => {
+            res.status(404).json({ error: "Not found" });
+        });
+        this.app.use((err, req, res, _next) => {
+            logger.error({ err, method: req.method, path: req.path }, "unhandled express error");
+            res.status(500).json({ error: "Internal server error" });
+        });
+    }
+    async handleHealth(_req, res) {
+        res.json({
+            status: "ok",
+            timestamp: Date.now(),
+        });
+    }
+    async handleGetEvents(req, res) {
+        try {
+            const scope = this.parseScope(req, res);
+            if (!scope)
+                return;
+            const afterIndex = this.parseAfterIndex(req, res);
+            if (afterIndex === false)
+                return;
+            await this.runtime.syncLocal(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,
+            });
+        }
+        catch (error) {
+            logger.error({ err: error, params: req.params }, "fetch chain events failed");
+            res.status(500).json({ error: "Failed to fetch events" });
+        }
+    }
+    parseScope(req, res) {
+        const scopeType = String(req.params.scopeType);
+        const scopeKey = String(req.params.scopeKey);
+        const scope = this.runtime.registry.parseScope(scopeType, scopeKey);
+        if (!scope) {
+            res.status(400).json({ error: "Invalid scopeType parameter" });
+            return null;
+        }
+        return scope;
+    }
+    parseAfterIndex(req, res) {
+        const raw = req.query.after_index;
+        if (raw === undefined)
+            return null;
+        if (Array.isArray(raw)) {
+            res.status(400).json({ error: "Invalid after_index parameter" });
+            return false;
+        }
+        try {
+            return BigInt(String(raw));
+        }
+        catch {
+            res.status(400).json({ error: "Invalid after_index parameter" });
+            return false;
+        }
+    }
+    async start() {
+        await this.runtime.initialize();
+        return new Promise((resolve, reject) => {
+            try {
+                this.server = this.app.listen(this.port, this.host, () => {
+                    logger.info({ address: this.getAddress() }, "HTTP server listening");
+                    resolve();
+                });
+                this.server.on("error", (error) => {
+                    reject(error);
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    async stop() {
+        return new Promise((resolve, reject) => {
+            if (!this.server) {
+                resolve();
+                return;
+            }
+            this.server.close((error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    logger.info("HTTP server stopped");
+                    this.server = null;
+                    resolve();
+                }
+            });
+        });
+    }
+    getAddress() {
+        return `http://${this.host}:${this.port}`;
+    }
+}
+export class SubstreamService {
+    ctx;
+    options;
+    database;
+    eventListener;
+    httpServer;
+    program;
+    runtime;
+    isRunning = false;
+    constructor(ctx, options) {
+        this.ctx = ctx;
+        this.options = options;
+        this.database = new Database(options.dbPath);
+        const stores = {
+            events: new SQLiteEventStore(this.database),
+            projections: new SQLiteProjectionStore(this.database),
+        };
+        this.runtime = createSubstreamRuntime(ctx, stores, { mode: "local" });
+        this.program = this.runtime.voidify.program;
+        this.eventListener = new EventListener(this.program);
+        this.httpServer = new HttpServer(this.runtime, {
+            port: options.port,
+            host: options.host,
+        });
+    }
+    async start() {
+        if (this.isRunning) {
+            throw new Error("Service is already running");
+        }
+        try {
+            logger.info({ dbPath: this.options.dbPath }, "initializing database");
+            await this.runtime.initialize();
+            logger.info("starting event listeners");
+            await this.startEventListeners();
+            await this.httpServer.start();
+            this.isRunning = true;
+            logger.info("service ready");
+        }
+        catch (error) {
+            await this.cleanup();
+            throw error;
+        }
+    }
+    async stop() {
+        if (!this.isRunning) {
+            return;
+        }
+        await this.cleanup();
+        this.isRunning = false;
+        logger.info("service stopped");
+    }
+    async startEventListeners() {
+        for (const liveEvent of this.runtime.registry.liveEvents()) {
+            this.eventListener.registerHandler(liveEvent.eventName, async (event, signature, slot) => {
+                const record = await liveEvent.toRecord({
+                    ctx: this.ctx,
+                    voidify: this.runtime.voidify,
+                    event,
+                    signature,
+                    slot,
+                });
+                await this.runtime.applyLiveRecord(record, record);
+            });
+        }
+    }
+    async cleanup() {
+        try {
+            this.eventListener.removeAllListeners();
+            await this.httpServer.stop();
+            this.database.close();
+        }
+        catch (error) {
+            logger.error({ err: error }, "cleanup error");
+        }
+    }
+}

package/dist/substream/types.d.ts

@@ -0,0 +1,94 @@
+export type EventScopeType = string;
+export interface EventScope {
+    scopeType: EventScopeType;
+    scopeKey: string;
+}
+export type ChainEventPayload = Record<string, unknown>;
+export interface ChainEventRecord extends EventScope {
+    eventName: string;
+    eventIndex: bigint;
+    signature: string;
+    slot: number | null;
+    blockTime: number | null;
+    address: string;
+    payload: ChainEventPayload;
+    createdAt: number;
+}
+export interface ChainEventWire extends Omit<ChainEventRecord, "eventIndex"> {
+    eventIndex: string;
+}
+export interface DepositRecord {
+    denomination: bigint;
+    depositor: string;
+    commitment: string;
+    index: number;
+    timestamp: number;
+    signature: string;
+}
+export interface RelayerRecord {
+    relayerPubkey: string;
+    name: string;
+    url: string;
+    feeBps: number;
+    stakeAmount: bigint;
+    isActive: boolean;
+    totalWithdrawals: number;
+    totalSolEarned: bigint;
+    totalTokenDeducted: bigint;
+    lastUpdated: number;
+}
+export interface EventCursor {
+    scopeType: EventScopeType;
+    scopeKey: string;
+    lastIndex: bigint | null;
+    lastSignature: string | null;
+    lastSyncAt: number;
+}
+export type ApplyOutcome = {
+    kind: "applied";
+    cursor: bigint;
+} | {
+    kind: "duplicate";
+    cursor: bigint;
+} | {
+    kind: "gap";
+    expected: bigint;
+    got: bigint;
+};
+export interface EventStore {
+    initialize(): Promise<void>;
+    apply(scope: EventScope, event: ChainEventRecord): Promise<ApplyOutcome>;
+    applyBatch(scope: EventScope, events: ChainEventRecord[]): Promise<ApplyOutcome>;
+    list(scope: EventScope, opts?: {
+        offset?: number;
+        limit?: number;
+    }): Promise<ChainEventRecord[]>;
+    getAfter(scope: EventScope, afterIndex?: bigint): Promise<ChainEventRecord[]>;
+    count(scope: EventScope): Promise<number>;
+    getCursor(scope: EventScope): Promise<EventCursor | null>;
+}
+export interface EventProjection {
+    id: string;
+    matches(event: ChainEventRecord): boolean;
+    apply(events: ChainEventRecord[]): Promise<void>;
+}
+export type ProjectionStateValue = Record<string, unknown>;
+export interface ProjectionStateRecord {
+    projectionId: string;
+    key: string;
+    value: ProjectionStateValue;
+    updatedAt: number;
+    lastEventIndex: bigint | null;
+}
+export interface ProjectionStore {
+    initialize(): Promise<void>;
+    get(projectionId: string, key: string): Promise<ProjectionStateRecord | null>;
+    put(record: ProjectionStateRecord): Promise<void>;
+    list(projectionId: string): Promise<ProjectionStateRecord[]>;
+    clear(projectionId: string): Promise<void>;
+}
+export interface SubstreamStores {
+    events: EventStore;
+    projections: ProjectionStore;
+}
+export type SubstreamRepos = SubstreamStores;

package/dist/substream/types.js

@@ -0,0 +1 @@
+export {};

package/dist/types/errors.d.ts

@@ -0,0 +1 @@
+export declare function mapOnChainError(errorMsg: string): string;

package/dist/types/errors.js

@@ -0,0 +1,16 @@
+export function mapOnChainError(errorMsg) {
+    if (errorMsg.includes("UnknownRoot") || errorMsg.includes("6005")) {
+        return "Merkle root not in history, please confirm deposit is confirmed";
+    }
+    if (errorMsg.includes("Unauthorized") || errorMsg.includes("6006")) {
+        return "Unauthorized to perform this operation";
+    }
+    if (errorMsg.includes("InvalidProof") || errorMsg.includes("6000")) {
+        return "Zero-knowledge proof is invalid, please check deposit note";
+    }
+    if (errorMsg.includes("AccountAlreadyInUse") ||
+        errorMsg.includes("custom program error: 0x0")) {
+        return "This deposit note has already been used";
+    }
+    return errorMsg;
+}

package/dist/types/events.d.ts

@@ -0,0 +1,13 @@
+import type { IdlEvents } from "@coral-xyz/anchor";
+import type { Voidify } from "../idl/voidify/idl.js";
+export type VoidifyEventMap = IdlEvents<Voidify>;
+export type VoidifyEventName = keyof VoidifyEventMap;
+export type DepositEvent = VoidifyEventMap["depositEvent"];
+export type WithdrawalEvent = VoidifyEventMap["withdrawalEvent"];
+export type DirectWithdrawalEvent = VoidifyEventMap["directWithdrawalEvent"];
+export type RelayerRegisteredEvent = VoidifyEventMap["relayerRegisteredEvent"];
+export type RelayerUnregisteredEvent = VoidifyEventMap["relayerUnregisteredEvent"];
+export type RelayerDeactivatedEvent = VoidifyEventMap["relayerDeactivatedEvent"];
+export type RelayerSlashedEvent = VoidifyEventMap["relayerSlashedEvent"];
+export type RelayerUpdatedEvent = VoidifyEventMap["relayerUpdatedEvent"];
+export type RelayerActivatedEvent = VoidifyEventMap["relayerActivatedEvent"];

package/dist/types/events.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1 @@
+export * from "./errors.js";

package/dist/utils/amount.d.ts

@@ -0,0 +1,4 @@
+import BN from "bn.js";
+export declare function parseUnits(input: string, decimals: number): bigint;
+export declare function formatUnits(value: bigint, decimals: number): string;
+export declare function toBN(value: bigint): BN;

package/dist/utils/amount.js

@@ -0,0 +1,41 @@
+import BN from "bn.js";
+const VALID_NUMBER_RE = /^[0-9]+(\.[0-9]+)?$/;
+export function parseUnits(input, decimals) {
+    if (typeof input !== "string") {
+        throw new Error(`parseUnits: expected string, got ${typeof input}`);
+    }
+    if (!Number.isInteger(decimals) || decimals < 0) {
+        throw new Error(`parseUnits: invalid decimals ${decimals}`);
+    }
+    if (!VALID_NUMBER_RE.test(input)) {
+        throw new Error(`parseUnits: invalid number format "${input}"`);
+    }
+    const [intPart, fracPart = ""] = input.split(".");
+    if (intPart.length > 1 && intPart.startsWith("0")) {
+        throw new Error(`parseUnits: leading zeros not allowed "${input}"`);
+    }
+    if (fracPart.length > decimals) {
+        throw new Error(`parseUnits: too many fractional digits in "${input}" for ${decimals} decimals`);
+    }
+    const padded = fracPart.padEnd(decimals, "0");
+    const combined = (intPart + padded).replace(/^0+/, "") || "0";
+    return BigInt(combined);
+}
+export function formatUnits(value, decimals) {
+    if (typeof value !== "bigint") {
+        throw new Error(`formatUnits: expected bigint, got ${typeof value}`);
+    }
+    if (!Number.isInteger(decimals) || decimals < 0) {
+        throw new Error(`formatUnits: invalid decimals ${decimals}`);
+    }
+    const negative = value < 0n;
+    const abs = negative ? -value : value;
+    const padded = abs.toString().padStart(decimals + 1, "0");
+    const intPart = padded.slice(0, padded.length - decimals);
+    const fracPart = padded.slice(padded.length - decimals).replace(/0+$/, "");
+    const result = fracPart.length > 0 ? `${intPart}.${fracPart}` : intPart;
+    return negative ? `-${result}` : result;
+}
+export function toBN(value) {
+    return new BN(value.toString());
+}

package/dist/utils/anchor-events.d.ts

@@ -0,0 +1,13 @@
+import type BN from "bn.js";
+export declare function toBigInt(v: BN | bigint | number | string): bigint;
+export type DecodedEvent<M, K extends keyof M = keyof M> = K extends keyof M ? {
+    name: K;
+    data: M[K];
+} : never;
+export declare function parseEventsFromLogs<M>(logs: string[], coder: {
+    decode: (data: string) => {
+        name: string;
+        data: unknown;
+    } | null;
+}): DecodedEvent<M>[];
+export declare function findEventByName<M, K extends keyof M & string>(events: DecodedEvent<M>[], name: K): M[K] | null;

package/dist/utils/anchor-events.js

@@ -0,0 +1,28 @@
+export function toBigInt(v) {
+    if (typeof v === "bigint")
+        return v;
+    if (typeof v === "number")
+        return BigInt(v);
+    if (typeof v === "string")
+        return BigInt(v);
+    return BigInt(v.toString());
+}
+export function parseEventsFromLogs(logs, coder) {
+    const events = [];
+    for (const log of logs) {
+        if (!log.includes("Program data:"))
+            continue;
+        const encoded = log.split("Program data: ")[1];
+        const decoded = coder.decode(encoded);
+        if (decoded)
+            events.push(decoded);
+    }
+    return events;
+}
+export function findEventByName(events, name) {
+    for (const e of events) {
+        if (e.name === name)
+            return e.data;
+    }
+    return null;
+}

package/dist/utils/bytes.d.ts

@@ -0,0 +1,10 @@
+import { PublicKey } from "@solana/web3.js";
+export declare const bigIntToBytes: (bigInt: bigint, length?: number) => Buffer;
+export declare function bytesToBigInt(bytes: Uint8Array | Buffer): bigint;
+export declare function bytesToHex(bytes: Uint8Array | Buffer): string;
+export declare function hexToBytes(hex: string): Buffer;
+export declare function generateRandomFieldElement(): bigint;
+export declare function publicKeyToLoHi(publicKey: PublicKey): {
+    lo: bigint;
+    hi: bigint;
+};

package/dist/utils/bytes.js

@@ -0,0 +1,29 @@
+export const bigIntToBytes = (bigInt, length = 32) => {
+    const hexString = bigInt.toString(16).padStart(length * 2, "0");
+    return Buffer.from(hexString, "hex");
+};
+export function bytesToBigInt(bytes) {
+    const hex = bytesToHex(bytes);
+    return BigInt("0x" + hex);
+}
+export function bytesToHex(bytes) {
+    return Buffer.from(bytes).toString("hex");
+}
+export function hexToBytes(hex) {
+    const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+    return Buffer.from(cleanHex, "hex");
+}
+export function generateRandomFieldElement() {
+    const randomBytes = new Uint8Array(31);
+    crypto.getRandomValues(randomBytes);
+    const hex = Array.from(randomBytes)
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+    return BigInt("0x" + hex);
+}
+export function publicKeyToLoHi(publicKey) {
+    const bytes = publicKey.toBytes();
+    const hi = BigInt("0x" + Buffer.from(bytes.slice(0, 16)).toString("hex"));
+    const lo = BigInt("0x" + Buffer.from(bytes.slice(16, 32)).toString("hex"));
+    return { lo, hi };
+}

package/dist/utils/idl-seed.d.ts

@@ -0,0 +1,17 @@
+type IdlSeed = {
+    kind: string;
+    value?: number[];
+};
+type IdlAccount = {
+    pda?: {
+        seeds?: IdlSeed[];
+    };
+};
+type IdlInstruction = {
+    accounts?: IdlAccount[];
+};
+type IdlLike = {
+    instructions?: IdlInstruction[];
+};
+export declare function getConstSeed(idl: IdlLike, name: string): Buffer;
+export {};

package/dist/utils/idl-seed.js

@@ -0,0 +1,15 @@
+export function getConstSeed(idl, name) {
+    const target = Buffer.from(name);
+    for (const ix of idl.instructions ?? []) {
+        for (const acct of ix.accounts ?? []) {
+            for (const seed of acct.pda?.seeds ?? []) {
+                if (seed.kind === "const" && seed.value) {
+                    const buf = Buffer.from(seed.value);
+                    if (buf.equals(target))
+                        return buf;
+                }
+            }
+        }
+    }
+    throw new Error(`const PDA seed "${name}" not found in IDL`);
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./bytes.js";
+export * from "./tx.js";

package/dist/utils/index.js

@@ -0,0 +1,2 @@
+export * from "./bytes.js";
+export * from "./tx.js";

package/dist/utils/logger.d.ts

@@ -0,0 +1,3 @@
+import pino from "pino";
+export declare const substreamLogger: pino.Logger<never, boolean>;
+export declare const relayerLogger: pino.Logger<never, boolean>;

package/dist/utils/logger.js

@@ -0,0 +1,19 @@
+import pino from "pino";
+const isProduction = process.env.NODE_ENV === "production";
+const logger = pino({
+    level: process.env.LOG_LEVEL || "info",
+    ...(isProduction
+        ? {}
+        : {
+            transport: {
+                target: "pino-pretty",
+                options: {
+                    colorize: true,
+                    translateTime: "SYS:yyyy-mm-dd HH:MM:ss.l",
+                    ignore: "pid,hostname",
+                },
+            },
+        }),
+});
+export const substreamLogger = logger.child({ module: "substream" });
+export const relayerLogger = logger.child({ module: "relayer" });

package/dist/utils/note.d.ts

@@ -0,0 +1,19 @@
+export declare class NoteError extends Error {
+    constructor(message: string);
+}
+export declare const TOKEN_DECIMALS: Record<string, number>;
+export declare class Note {
+    readonly token: string;
+    readonly amount: string;
+    readonly amountRaw: bigint;
+    readonly nullifier: string;
+    readonly secret: string;
+    readonly commitment: string;
+    readonly nullifierHash: string;
+    private constructor();
+    static generate(uiAmount: string, token?: string): Promise<Note>;
+    static deserialize(noteString: string): Promise<Note>;
+    serialize(): string;
+    verify(commitment: string): Promise<boolean>;
+    private static computeHashes;
+}

package/dist/utils/note.js

@@ -0,0 +1,83 @@
+import { generateRandomFieldElement } from "../utils/bytes.js";
+import { parseUnits, formatUnits } from "../utils/amount.js";
+export class NoteError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "NoteError";
+    }
+}
+export const TOKEN_DECIMALS = {
+    SOL: 9,
+};
+function decimalsForToken(token) {
+    const d = TOKEN_DECIMALS[token];
+    if (d === undefined) {
+        throw new NoteError(`Unknown token "${token}" — add to TOKEN_DECIMALS`);
+    }
+    return d;
+}
+export class Note {
+    token;
+    amount;
+    amountRaw;
+    nullifier;
+    secret;
+    commitment;
+    nullifierHash;
+    constructor(token, amount, amountRaw, nullifier, secret, commitment, nullifierHash) {
+        this.token = token;
+        this.amount = amount;
+        this.amountRaw = amountRaw;
+        this.nullifier = nullifier;
+        this.secret = secret;
+        this.commitment = commitment;
+        this.nullifierHash = nullifierHash;
+    }
+    static async generate(uiAmount, token = "SOL") {
+        const decimals = decimalsForToken(token);
+        const amountRaw = parseUnits(uiAmount, decimals);
+        const normalized = formatUnits(amountRaw, decimals);
+        const nullifier = generateRandomFieldElement();
+        const secret = generateRandomFieldElement();
+        const { commitment, nullifierHash } = await Note.computeHashes(nullifier, secret, amountRaw);
+        return new Note(token, normalized, amountRaw, nullifier.toString(), secret.toString(), commitment, nullifierHash);
+    }
+    static async deserialize(noteString) {
+        const parts = noteString.split("-");
+        if (parts.length !== 5) {
+            throw new NoteError(`Invalid note format: expected 5 parts, got ${parts.length}`);
+        }
+        const [prefix, token, uiAmount, nullifierStr, secretStr] = parts;
+        if (prefix !== "voidify") {
+            throw new NoteError(`Invalid prefix: expected 'voidify', got '${prefix}'`);
+        }
+        const decimals = decimalsForToken(token);
+        const amountRaw = parseUnits(uiAmount, decimals);
+        const normalized = formatUnits(amountRaw, decimals);
+        const nullifier = BigInt(nullifierStr);
+        const secret = BigInt(secretStr);
+        const { commitment, nullifierHash } = await Note.computeHashes(nullifier, secret, amountRaw);
+        return new Note(token, normalized, amountRaw, nullifier.toString(), secret.toString(), commitment, nullifierHash);
+    }
+    serialize() {
+        return `voidify-${this.token}-${this.amount}-${this.nullifier}-${this.secret}`;
+    }
+    async verify(commitment) {
+        const { commitment: computedCommitment, nullifierHash } = await Note.computeHashes(BigInt(this.nullifier), BigInt(this.secret), this.amountRaw);
+        if (commitment !== undefined) {
+            return commitment === computedCommitment;
+        }
+        return (computedCommitment === this.commitment &&
+            nullifierHash === this.nullifierHash);
+    }
+    static async computeHashes(nullifier, secret, amount) {
+        const { buildPoseidon } = await import("circomlibjs");
+        const poseidon = await buildPoseidon();
+        const commitment = poseidon([nullifier, secret, amount]);
+        const nullifierHash = poseidon([nullifier]);
+        return {
+            commitment: poseidon.F.toString(commitment),
+            nullifierHash: poseidon.F.toString(nullifierHash),
+        };
+    }
+}

package/dist/utils/proof.d.ts

@@ -0,0 +1,11 @@
+import { PublicKey } from "@solana/web3.js";
+export declare function generateMerkleProof(commitment: string, commitments: string[]): Promise<{
+    pathElements: import("fixed-merkle-tree").Element[];
+    pathIndices: number[];
+    root: import("fixed-merkle-tree").Element;
+}>;
+export declare function generateProof(nullifier: string, secret: string, amount: string, commitment: string, nullifierHash: string, recipient: PublicKey, relayer: PublicKey, fee: BigInt, refund: BigInt, commitments: string[], wasmPath: string, zkeyPath: string): Promise<{
+    root: import("fixed-merkle-tree").Element;
+    proof: import("snarkjs").Groth16Proof;
+}>;
+export declare const proofToBytes: (proof: any) => Promise<number[]>;