@voidifydao/sdk 1.0.0

package/dist/idl/voidify-staking/idl.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Program IDL in camelCase format in order to be used in JS/TS.
+ *
+ * Note that this is only a type helper and is not the actual IDL. The original
+ * IDL can be found at `target/idl/voidify_staking.json`.
+ */
+export type VoidifyStaking = {
+    "address": "";
+    "metadata": {
+        "name": "voidifyStaking";
+        "version": "1.0.1";
+        "spec": "0.1.0";
+    };
+    "instructions": [
+        {
+            "name": "notifyRewardAmount";
+            "discriminator": [
+                228,
+                154,
+                113,
+                244,
+                155,
+                76,
+                153,
+                136
+            ];
+            "accounts": [
+                {
+                    "name": "caller";
+                    "signer": true;
+                },
+                {
+                    "name": "stakingState";
+                    "writable": true;
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const";
+                                "value": [
+                                    115,
+                                    116,
+                                    97,
+                                    107,
+                                    105,
+                                    110,
+                                    103,
+                                    95,
+                                    115,
+                                    116,
+                                    97,
+                                    116,
+                                    101
+                                ];
+                            }
+                        ];
+                    };
+                },
+                {
+                    "name": "rewardVault";
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const";
+                                "value": [
+                                    114,
+                                    101,
+                                    119,
+                                    97,
+                                    114,
+                                    100,
+                                    95,
+                                    118,
+                                    97,
+                                    117,
+                                    108,
+                                    116
+                                ];
+                            }
+                        ];
+                    };
+                },
+                {
+                    "name": "tokenProgram";
+                    "address": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+                }
+            ];
+            "args": [];
+        }
+    ];
+    "accounts": [];
+    "events": [];
+    "types": [];
+};

package/dist/idl/voidify-staking/idl.js

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

package/dist/idl/voidify-staking/idl.json

@@ -0,0 +1,87 @@
+{
+    "address": "3K12np4CKy8WbQim78trY6Pdii8wHQiWpQ4dMdsCKXYo",
+    "metadata": {
+        "name": "voidify_staking",
+        "version": "1.0.1",
+        "spec": "0.1.0"
+    },
+    "instructions": [
+        {
+            "name": "",
+            "discriminator": [
+                228,
+                154,
+                113,
+                244,
+                155,
+                76,
+                153,
+                136
+            ],
+            "accounts": [
+                {
+                    "name": "caller",
+                    "signer": true
+                },
+                {
+                    "name": "staking_state",
+                    "writable": true,
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const",
+                                "value": [
+                                    115,
+                                    116,
+                                    97,
+                                    107,
+                                    105,
+                                    110,
+                                    103,
+                                    95,
+                                    115,
+                                    116,
+                                    97,
+                                    116,
+                                    101
+                                ]
+                            }
+                        ]
+                    }
+                },
+                {
+                    "name": "reward_vault",
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const",
+                                "value": [
+                                    114,
+                                    101,
+                                    119,
+                                    97,
+                                    114,
+                                    100,
+                                    95,
+                                    118,
+                                    97,
+                                    117,
+                                    108,
+                                    116
+                                ]
+                            }
+                        ]
+                    }
+                },
+                {
+                    "name": "token_program",
+                    "address": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+                }
+            ],
+            "args": []
+        }
+    ],
+    "accounts": [],
+    "events": [],
+    "types": []
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export { Context } from "./context.js";
+export type { SubstreamConfig, SubstreamMode } from "./context.js";
+export * as voidify from "./voidify/index.js";
+export * as staking from "./staking/index.js";
+export { VoidifyProgram } from "./voidify/program.js";
+export { VoidifyStakingProgram } from "./staking/program.js";
+export type { WithdrawArtifact } from "./voidify/withdraw.js";
+export { SubstreamCliClient } from "./substream/client.js";
+export type { SubstreamCliConfig, EventsApiResponse, CursorWire, } from "./substream/client.js";
+export { makeIndexedDBStores } from "./substream/database/indexeddb.js";
+export type { DepositModuleApi, RelayerModuleApi, } from "./substream/modules/index.js";
+export type { DepositRecord, RelayerRecord, EventCursor, ApplyOutcome, ChainEventRecord, ChainEventWire, EventScope, EventStore, EventProjection, ProjectionStateRecord, ProjectionStateValue, ProjectionStore, SubstreamRepos, SubstreamStores, } from "./substream/types.js";
+export { Note, TOKEN_DECIMALS } from "./utils/note.js";
+export { parseUnits, formatUnits, toBN } from "./utils/amount.js";
+export type { Voidify } from "./idl/voidify/idl.js";
+export * from "./types/index.js";
+export type { RelayerInfo, WithdrawRequestBody, WithdrawResponse, } from "./relayer/types.js";

package/dist/index.js

@@ -0,0 +1,10 @@
+export { Context } from "./context.js";
+export * as voidify from "./voidify/index.js";
+export * as staking from "./staking/index.js";
+export { VoidifyProgram } from "./voidify/program.js";
+export { VoidifyStakingProgram } from "./staking/program.js";
+export { SubstreamCliClient } from "./substream/client.js";
+export { makeIndexedDBStores } from "./substream/database/indexeddb.js";
+export { Note, TOKEN_DECIMALS } from "./utils/note.js";
+export { parseUnits, formatUnits, toBN } from "./utils/amount.js";
+export * from "./types/index.js";

package/dist/relayer/server/index.d.ts

@@ -0,0 +1,6 @@
+import { Context } from "../../context.js";
+export declare function startRelayer(ctx: Context, config: {
+    port: number;
+    host: string;
+    feedId: string;
+}): Promise<string>;

package/dist/relayer/server/index.js

@@ -0,0 +1,32 @@
+import { RelayerHttpServer } from "../../relayer/server/server.js";
+import { relayerLogger as logger } from "../../utils/logger.js";
+export async function startRelayer(ctx, config) {
+    process.on("unhandledRejection", (reason) => {
+        logger.error({ reason }, "unhandledRejection");
+    });
+    process.on("uncaughtException", (err) => {
+        logger.error({ err }, "uncaughtException");
+        process.exit(1);
+    });
+    logger.info({
+        relayer: ctx.publicKey.toBase58(),
+        host: config.host,
+        port: config.port,
+    }, "Starting Relayer service");
+    const server = new RelayerHttpServer(ctx, config);
+    await server.start();
+    const shutdown = async (sig) => {
+        logger.info({ sig }, "shutting down relayer");
+        try {
+            await server.stop();
+        }
+        catch (err) {
+            logger.error({ err }, "relayer stop failed");
+        }
+        process.exit(0);
+    };
+    process.on("SIGINT", () => void shutdown("SIGINT"));
+    process.on("SIGTERM", () => void shutdown("SIGTERM"));
+    await new Promise(() => { });
+    return `http://${config.host}:${config.port}`;
+}

package/dist/relayer/server/server.d.ts

@@ -0,0 +1,24 @@
+import { Context } from "../../context.js";
+export interface RelayerServerConfig {
+    port: number;
+    host?: string;
+    feedId: string;
+}
+export declare class RelayerHttpServer {
+    private ctx;
+    private app;
+    private server;
+    private readonly host;
+    private readonly port;
+    private readonly feedId;
+    constructor(ctx: Context, config: RelayerServerConfig);
+    private setupMiddleware;
+    private setupRoutes;
+    private handleHealth;
+    private handleWithdraw;
+    private validateWithdrawRequest;
+    private getSwitchboardQuote;
+    getAddress(): string;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/relayer/server/server.js

@@ -0,0 +1,158 @@
+import express from "express";
+import cors from "cors";
+import { updateQuote } from "./switchboard.js";
+import { withdrawIx } from "../../voidify/withdraw.js";
+import { notifyRewardAmountIx } from "../../staking/commands.js";
+import { signAndSend } from "../../utils/tx.js";
+import { relayerLogger as logger } from "../../utils/logger.js";
+export class RelayerHttpServer {
+    ctx;
+    app;
+    server = null;
+    host;
+    port;
+    feedId;
+    constructor(ctx, config) {
+        this.ctx = ctx;
+        this.port = config.port;
+        this.host = config.host || "0.0.0.0";
+        this.feedId = config.feedId;
+        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.post("/api/relay/withdraw", this.handleWithdraw.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(),
+            relayer: this.ctx.publicKey.toBase58(),
+        });
+    }
+    async handleWithdraw(req, res) {
+        try {
+            const body = req.body;
+            const validationError = this.validateWithdrawRequest(body);
+            if (validationError) {
+                res.status(400).json({
+                    success: false,
+                    error: validationError,
+                });
+                return;
+            }
+            await updateQuote(this.ctx, this.feedId);
+            const switchboardQuote = await this.getSwitchboardQuote();
+            const ixs = await withdrawIx(this.ctx, new Uint8Array(body.proof), new Uint8Array(body.root), new Uint8Array(body.nullifierHash), body.recipient, this.ctx.publicKey.toBase58(), BigInt(body.fee), BigInt(body.treasury), switchboardQuote, BigInt(body.amount));
+            if (this.ctx.hasStakingProgramId()) {
+                const notifyIxs = await notifyRewardAmountIx(this.ctx, this.ctx.publicKey);
+                ixs.push(...notifyIxs);
+            }
+            const signature = await signAndSend(this.ctx, ixs);
+            logger.info({ signature }, "withdraw submitted");
+            res.json({
+                success: true,
+                signature,
+            });
+        }
+        catch (error) {
+            logger.error({ error }, "Failed to withdraw");
+            res.status(500).json({
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    validateWithdrawRequest(body) {
+        if (!body.proof ||
+            !Array.isArray(body.proof) ||
+            body.proof.length !== 256) {
+            return "Invalid proof: must be an array of 256 bytes";
+        }
+        if (!body.root || !Array.isArray(body.root) || body.root.length !== 32) {
+            return "Invalid root: must be an array of 32 bytes";
+        }
+        if (!body.nullifierHash ||
+            !Array.isArray(body.nullifierHash) ||
+            body.nullifierHash.length !== 32) {
+            return "Invalid nullifierHash: must be an array of 32 bytes";
+        }
+        if (!body.recipient || typeof body.recipient !== "string") {
+            return "Invalid recipient: must be a string";
+        }
+        for (const field of ["fee", "treasury", "amount"]) {
+            const value = body[field];
+            if (value === undefined || value === null) {
+                return `Missing ${field}`;
+            }
+            try {
+                if (BigInt(value) < 0n) {
+                    return `Invalid ${field}: must be non-negative`;
+                }
+            }
+            catch {
+                return `Invalid ${field}: not a valid integer`;
+            }
+        }
+        return null;
+    }
+    async getSwitchboardQuote() {
+        const sb = await import("@switchboard-xyz/on-demand");
+        const queue = await sb.Queue.loadDefault(await sb.AnchorUtils.loadProgramFromConnection(this.ctx.connection));
+        const [quotePDA] = sb.OracleQuote.getCanonicalPubkey(queue.pubkey, [
+            this.feedId,
+        ]);
+        return quotePDA;
+    }
+    getAddress() {
+        return `http://${this.host}:${this.port}`;
+    }
+    async start() {
+        return new Promise((resolve, reject) => {
+            this.server = this.app.listen(this.port, this.host, (error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    logger.info({ address: this.getAddress() }, "HTTP server listening");
+                    resolve();
+                }
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve, reject) => {
+            if (this.server) {
+                this.server.close((error) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        logger.info("HTTP server stopped");
+                        resolve();
+                    }
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+}

package/dist/relayer/server/switchboard.d.ts

@@ -0,0 +1,2 @@
+import { Context } from "../../context.js";
+export declare function updateQuote(ctx: Context, feedID: string): Promise<void>;

package/dist/relayer/server/switchboard.js

@@ -0,0 +1,42 @@
+import * as sb from "@switchboard-xyz/on-demand";
+import { CrossbarClient } from "@switchboard-xyz/common";
+import { signAndSend } from "../../utils/tx.js";
+import { VoidifyProgram } from "../../voidify/program.js";
+async function getQuoteSlot(ctx, quotePDA) {
+    try {
+        const signatures = await ctx.connection.getSignaturesForAddress(quotePDA, {
+            limit: 1,
+        });
+        return signatures.length ? signatures[0].slot : 0;
+    }
+    catch (error) {
+        throw new Error("Failed to fetch quote slot from chain", {
+            cause: error,
+        });
+    }
+}
+export async function updateQuote(ctx, feedID) {
+    const voidifyProgram = new VoidifyProgram(ctx.connection, ctx.programId);
+    const oracleConfig = await voidifyProgram.program.account.oracleConfig.fetch(voidifyProgram.oracleConfig());
+    const maxPriceAgeSlots = (BigInt(oracleConfig.maxPriceAgeSecs.toString()) * 1000n) / 400n;
+    const queue = await sb.Queue.loadDefault(await sb.AnchorUtils.loadProgramFromConnection(ctx.connection));
+    const crossbar = CrossbarClient.default();
+    const currentSlot = await ctx.connection.getSlot("confirmed");
+    const [quotePDA] = sb.OracleQuote.getCanonicalPubkey(queue.pubkey, [feedID]);
+    const quoteSlot = await getQuoteSlot(ctx, quotePDA);
+    if (BigInt(currentSlot - quoteSlot) >= maxPriceAgeSlots) {
+        const ixs = await queue.fetchManagedUpdateIxs(crossbar, [feedID], {
+            variableOverrides: {},
+            instructionIdx: 0,
+            payer: ctx.publicKey,
+        });
+        const tx = await sb.asV0Tx({
+            connection: ctx.connection,
+            ixs: ixs,
+            payer: ctx.publicKey,
+            computeUnitPrice: 20_000,
+            computeUnitLimitMultiple: 1.1,
+        });
+        await signAndSend(ctx, tx);
+    }
+}

package/dist/relayer/types.d.ts

@@ -0,0 +1,21 @@
+export interface WithdrawRequestBody {
+    proof: number[];
+    root: number[];
+    nullifierHash: number[];
+    recipient: string;
+    amount: string;
+    fee: string;
+    treasury: string;
+}
+export interface WithdrawResponse {
+    success: boolean;
+    signature?: string;
+    error?: string;
+}
+export interface RelayerInfo {
+    publicKey: string;
+    stakeAmount: string;
+    feeBps: number;
+    url: string;
+    isActive: boolean;
+}

package/dist/relayer/types.js

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

package/dist/staking/commands.d.ts

@@ -0,0 +1,3 @@
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { Context } from "../context.js";
+export declare function notifyRewardAmountIx(ctx: Context, caller?: PublicKey): Promise<TransactionInstruction[]>;

package/dist/staking/commands.js

@@ -0,0 +1,13 @@
+import { VoidifyStakingProgram } from "./program.js";
+export async function notifyRewardAmountIx(ctx, caller) {
+    const staking = new VoidifyStakingProgram(ctx.connection, ctx.stakingProgramId);
+    const ix = await staking.program.methods
+        .notifyRewardAmount()
+        .accountsPartial({
+        caller: caller ?? ctx.publicKey,
+        stakingState: staking.stakingState(),
+        rewardVault: staking.rewardVault(),
+    })
+        .instruction();
+    return [ix];
+}

package/dist/staking/index.d.ts

@@ -0,0 +1,2 @@
+export { VoidifyStakingProgram } from "./program.js";
+export * from "./commands.js";

package/dist/staking/index.js

@@ -0,0 +1,2 @@
+export { VoidifyStakingProgram } from "./program.js";
+export * from "./commands.js";

package/dist/staking/program.d.ts

@@ -0,0 +1,18 @@
+import { Program } from "@coral-xyz/anchor";
+import { Connection, PublicKey } from "@solana/web3.js";
+import type { VoidifyStaking } from "../idl/voidify-staking/idl.js";
+export declare class VoidifyStakingProgram {
+    private connection;
+    private _program;
+    private _programId;
+    static readonly SEEDS: {
+        readonly STAKING_STATE: Buffer<ArrayBufferLike>;
+        readonly REWARD_VAULT: Buffer<ArrayBufferLike>;
+    };
+    constructor(connection: Connection, programId: PublicKey);
+    get program(): Program<VoidifyStaking>;
+    get programId(): PublicKey;
+    get rpcConnection(): Connection;
+    stakingState(): PublicKey;
+    rewardVault(): PublicKey;
+}

package/dist/staking/program.js

@@ -0,0 +1,40 @@
+import { Program } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+import idl from "../idl/voidify-staking/idl.json" with { type: "json" };
+import { getConstSeed } from "../utils/idl-seed.js";
+export class VoidifyStakingProgram {
+    connection;
+    _program = null;
+    _programId;
+    static SEEDS = {
+        STAKING_STATE: getConstSeed(idl, "staking_state"),
+        REWARD_VAULT: getConstSeed(idl, "reward_vault"),
+    };
+    constructor(connection, programId) {
+        this.connection = connection;
+        this._programId = programId;
+    }
+    get program() {
+        if (!this._program) {
+            idl["address"] = this._programId.toBase58();
+            this._program = new Program(idl, {
+                connection: this.connection,
+            });
+        }
+        return this._program;
+    }
+    get programId() {
+        return this._programId;
+    }
+    get rpcConnection() {
+        return this.connection;
+    }
+    stakingState() {
+        const [pda] = PublicKey.findProgramAddressSync([VoidifyStakingProgram.SEEDS.STAKING_STATE], this._programId);
+        return pda;
+    }
+    rewardVault() {
+        const [pda] = PublicKey.findProgramAddressSync([VoidifyStakingProgram.SEEDS.REWARD_VAULT], this._programId);
+        return pda;
+    }
+}

package/dist/substream/chain/events.d.ts

@@ -0,0 +1,4 @@
+import type { ChainEventPayload, ChainEventRecord, ChainEventWire } from "../../substream/types.js";
+export declare function chainEventToWire(event: ChainEventRecord): ChainEventWire;
+export declare function chainEventFromWire(wire: ChainEventWire): ChainEventRecord;
+export declare function normalizePayload(value: unknown): ChainEventPayload;

package/dist/substream/chain/events.js

@@ -0,0 +1,50 @@
+export function chainEventToWire(event) {
+    return { ...event, eventIndex: event.eventIndex.toString() };
+}
+export function chainEventFromWire(wire) {
+    return { ...wire, eventIndex: BigInt(wire.eventIndex) };
+}
+export function normalizePayload(value) {
+    if (!value || typeof value !== "object")
+        return {};
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+        out[key] = normalizeValue(item);
+    }
+    return out;
+}
+function normalizeValue(value) {
+    if (typeof value === "bigint")
+        return value.toString();
+    if (typeof value === "number" || typeof value === "string")
+        return value;
+    if (typeof value === "boolean" || value === null || value === undefined) {
+        return value ?? null;
+    }
+    if (Array.isArray(value))
+        return value.map((v) => normalizeValue(v));
+    if (value instanceof Uint8Array) {
+        return Array.from(value)
+            .map((item) => item.toString(16).padStart(2, "0"))
+            .join("");
+    }
+    if (typeof value === "object" &&
+        "toBase58" in value &&
+        typeof value.toBase58 === "function") {
+        return value.toBase58();
+    }
+    if (typeof value === "object" &&
+        "toString" in value &&
+        typeof value.toString === "function" &&
+        value.constructor?.name === "BN") {
+        return value.toString();
+    }
+    if (typeof value === "object") {
+        const out = {};
+        for (const [key, item] of Object.entries(value)) {
+            out[key] = normalizeValue(item);
+        }
+        return out;
+    }
+    return String(value);
+}