@voidifydao/sdk 1.0.0 → 2.0.0

package/README.md

@@ -0,0 +1,105 @@
+# Voidify SDK
+
+[English](README.md) | [中文](docs/README.zh-CN.md) | [Русский](docs/README.ru.md) | [日本語](docs/README.ja.md)
+
+`@voidifydao/sdk` is the Voidify SDK and CLI for deposits, private notes, relayer withdrawals, relayer services, and indexed protocol activity on Solana.
+
+## Install
+
+As a library:
+
+```sh
+npm install @voidifydao/sdk
+```
+
+As a command-line tool:
+
+```sh
+npm install -g @voidifydao/sdk
+voidify --help
+```
+
+## CLI Setup
+
+Generate a JSON configuration file, then fill in that same file:
+
+```sh
+voidify config init --type default --path ./voidify.json
+voidify -c ./voidify.json config set programId YOUR_VOIDIFY_PROGRAM_ID
+voidify -c ./voidify.json config set keypair.path /absolute/path/to/solana-keypair.json
+```
+
+For withdrawal proof generation, download the proof artifacts from the
+[Voidify ceremony record v1.0.0 release](https://github.com/VoidifyCommunity/voidify-ceremony-record/releases/tag/v1.0.0).
+Extract `withdraw.wasm` and `withdraw.zkey`, then place them at the
+`proof.wasmPath` and `proof.zkeyPath` paths in the generated config.
+
+All following commands use the generated `./voidify.json` file through `-c`.
+
+## CLI Commands
+
+Generate a private note:
+
+```sh
+voidify -c ./voidify.json note gen 1
+```
+
+Deposit `1 SOL`. If `--commitment` is omitted, a new note is generated and printed:
+
+```sh
+voidify -c ./voidify.json deposit 1
+```
+
+List deposits in a pool:
+
+```sh
+voidify -c ./voidify.json deposit list 1
+```
+
+Withdraw through an automatically selected healthy relayer:
+
+```sh
+voidify -c ./voidify.json withdraw "YOUR_PRIVATE_NOTE" --recipient RECIPIENT_SOLANA_ADDRESS
+```
+
+Choose a relayer by name:
+
+```sh
+voidify -c ./voidify.json withdraw "YOUR_PRIVATE_NOTE" --recipient RECIPIENT_SOLANA_ADDRESS --relayer RELAYER_NAME
+```
+
+> Keep your private note secure. Anyone with the note can withdraw the deposit, and a lost note cannot be recovered.
+
+## Run a Relayer
+
+Generate a relayer JSON configuration, fill in that file, then use it for relayer commands:
+
+```sh
+voidify config init --type relayer --path ./relayer.json
+voidify -c ./relayer.json relayer start
+```
+
+## SDK Usage
+
+```ts
+import { Context, Note, voidify } from "@voidifydao/sdk";
+import { Keypair, PublicKey } from "@solana/web3.js";
+
+const wallet = Keypair.generate();
+const ctx = new Context({
+  rpcUrl: "https://api.mainnet-beta.solana.com",
+  programId: new PublicKey("YOUR_VOIDIFY_PROGRAM_ID"),
+  wallet,
+});
+
+const note = await Note.generate("1");
+const signature = await voidify.deposit(
+  ctx,
+  note.commitment,
+  1_000_000_000n,
+);
+
+console.log(note.serialize(), signature);
+```
+
+The package also exports withdrawal helpers, relayer types, `VoidifyProgram`, substream clients and stores, and amount/note utilities.

package/dist/cli/config/init.js

@@ -13,7 +13,6 @@ export function buildTemplate(type) {
             return {
                 rpcUrl: defaults.rpcUrl,
                 programId: REQUIRED("voidify program ID"),
-                stakingProgramId: null,
                 keypair: fileKeypairPlaceholder("user keypair"),
                 substream: { ...defaults.substream },
                 proof: { ...defaults.proof },
@@ -22,7 +21,6 @@ export function buildTemplate(type) {
             return {
                 rpcUrl: defaults.rpcUrl,
                 programId: REQUIRED("voidify program ID"),
-                stakingProgramId: null,
                 keypair: fileKeypairPlaceholder("relayer keypair"),
                 relayerServer: { ...defaults.relayerServer },
             };
@@ -37,7 +35,6 @@ export function buildTemplate(type) {
             return {
                 rpcUrl: defaults.rpcUrl,
                 programId: REQUIRED("voidify program ID"),
-                stakingProgramId: null,
                 keypair: fileKeypairPlaceholder("keypair for this config"),
                 substream: { ...defaults.substream },
                 proof: { ...defaults.proof },
@@ -53,7 +50,6 @@ export function postInitHint(type) {
                 "Next steps:",
                 "  - programId      <- voidify main program",
                 "  - keypair.path   <- your keypair JSON file path",
-                "  - stakingProgramId <- optional staking program ID",
                 "  (substream / proof already use defaults; no changes needed)",
                 "",
                 "Applicable commands: deposit / withdraw / note.",
@@ -63,8 +59,7 @@ export function postInitHint(type) {
                 "Next steps:",
                 "  - programId                  <- voidify main program",
                 "  - keypair.path               <- keypair for the relayer service itself",
-                "  - relayerServer.feedId       <- Switchboard on-demand feed ID",
-                "  - stakingProgramId           <- optional staking program ID",
+                "  - relayerServer.feedId       ← Switchboard on-demand feed ID",
                 "",
                 "Applicable commands: relayer start / relayer list.",
             ].join("\n");
@@ -80,7 +75,6 @@ export function postInitHint(type) {
             return [
                 "Next steps: full template; fill in values as needed.",
                 "  required: programId, keypair.path, relayerServer.feedId",
-                "  optional: stakingProgramId",
                 "",
                 "Reminder: one config should use one keypair. Create separate config files and switch with -c when roles differ.",
             ].join("\n");

package/dist/cli/config/loader.js

@@ -6,7 +6,6 @@ export function defaultUserConfigPath() {
     return path.join(defaultUserConfigDir(), "config.json");
 }
 const OPTIONAL_KEYS = [
-    "stakingProgramId",
     "keypair",
     "keypair.type",
     "keypair.path",

package/dist/cli/config/types.d.ts

@@ -20,7 +20,6 @@ export type SubstreamSource = {
 export interface VoidifyConfig {
     rpcUrl: string;
     programId: string;
-    stakingProgramId?: string | null;
     keypair?: KeypairSource | null;
     substream?: SubstreamSource | null;
     proof?: {

package/dist/cli/deposit.js

@@ -3,27 +3,66 @@ import { deposit, listDeposits } from "../voidify/deposit.js";
 import { parseUnits } from "../utils/amount.js";
 import { Note } from "../utils/note.js";
 import { createServiceContext, SOL_DECIMALS, } from "../cli/helpers.js";
+import { createCliProgressBar } from "../cli/progress.js";
 export function registerDepositCommands(program) {
     const depositCommand = new Command("deposit")
         .enablePositionalOptions()
+        .argument("<amount>", "Deposit amount in UI units, such as 1 for 1 SOL")
         .description("Deposit commands");
+    depositCommand.option("-c, --commitment <string>", "Commitment generated by the note gen command; if omitted, a new one is generated and printed");
     depositCommand
-        .command("submit")
-        .option("-c, --commitment <string>", "Commitment generated by the note gen command; if omitted, a new one is generated and printed")
-        .requiredOption("-a, --amount <amount>", "Deposit amount in UI units, such as 1 for 1 SOL")
-        .action(async (options) => {
+        .command("list <amount>")
+        .description("List records for a denomination pool, using UI units such as 1 for 1 SOL")
+        .option("--offset <number>", "Pagination offset")
+        .option("--limit <number>", "Page size")
+        .option("-o, --output <file>", "Write output to a file")
+        .action(async (amount, options) => {
+        try {
+            const ctx = await createServiceContext(program.opts());
+            const progress = createCliProgressBar("Sync deposits");
+            const deposits = await (async () => {
+                try {
+                    return await listDeposits(ctx, parseUnits(amount, SOL_DECIMALS), {
+                        offset: options.offset !== undefined
+                            ? parseInt(options.offset)
+                            : undefined,
+                        limit: options.limit !== undefined
+                            ? parseInt(options.limit)
+                            : undefined,
+                        output: options.output,
+                        sync: { reporter: progress },
+                    });
+                }
+                finally {
+                    progress.finish();
+                }
+            })();
+            if (!options.output) {
+                console.log("Deposit records:", deposits);
+            }
+        }
+        catch (error) {
+            console.error("List deposits failed:", error);
+            process.exit(1);
+        }
+    });
+    depositCommand.action(async (amount, options) => {
+        if (!amount) {
+            depositCommand.help({ error: true });
+            return;
+        }
         try {
             const ctx = await createServiceContext(program.opts());
             let commitment = options.commitment;
             if (!commitment) {
-                const note = await Note.generate(options.amount);
+                const note = await Note.generate(amount);
                 commitment = note.commitment;
                 console.log("Note generated:", {
                     note: note.serialize(),
                     commitment: note.commitment,
                 });
             }
-            const txSignature = await deposit(ctx, commitment, parseUnits(options.amount, SOL_DECIMALS));
+            const txSignature = await deposit(ctx, commitment, parseUnits(amount, SOL_DECIMALS));
             console.log("Transaction successful:", { txSignature });
         }
         catch (error) {
@@ -31,28 +70,5 @@ export function registerDepositCommands(program) {
             process.exit(1);
         }
     });
-    depositCommand
-        .command("list <amount>")
-        .description("List records for a denomination pool, using UI units such as 1 for 1 SOL")
-        .option("--offset <number>", "Pagination offset")
-        .option("--limit <number>", "Page size")
-        .option("-o, --output <file>", "Write output to a file")
-        .action(async (amount, options) => {
-        try {
-            const ctx = await createServiceContext(program.opts());
-            const deposits = await listDeposits(ctx, parseUnits(amount, SOL_DECIMALS), {
-                offset: options.offset !== undefined
-                    ? parseInt(options.offset)
-                    : undefined,
-                limit: options.limit !== undefined ? parseInt(options.limit) : undefined,
-                output: options.output,
-            });
-            console.log("Deposit records:", deposits);
-        }
-        catch (error) {
-            console.error("List deposits failed:", error);
-            process.exit(1);
-        }
-    });
     program.addCommand(depositCommand);
 }

package/dist/cli/helpers.js

@@ -39,9 +39,6 @@ export async function contextFromConfig(cfg, cliKeypairPath) {
     return new Context({
         rpcUrl: cfg.rpcUrl,
         programId: cfg.programId ? new PublicKey(cfg.programId) : undefined,
-        stakingProgramId: cfg.stakingProgramId
-            ? new PublicKey(cfg.stakingProgramId)
-            : undefined,
         wallet: keypair,
         substream,
         wasmPath: cfg.proof ? expandHome(cfg.proof.wasmPath) : undefined,

package/dist/cli/progress.d.ts

@@ -0,0 +1,5 @@
+import type { SyncStatusReporter } from "../substream/types.js";
+export interface CliProgressBar extends SyncStatusReporter {
+    finish(): void;
+}
+export declare function createCliProgressBar(label: string): CliProgressBar;

package/dist/cli/progress.js

@@ -0,0 +1,37 @@
+export function createCliProgressBar(label) {
+    if (!process.stderr.isTTY) {
+        return {
+            update() { },
+            finish() { },
+        };
+    }
+    let started = false;
+    let lastLength = 0;
+    function render(status) {
+        const progress = status.progress;
+        if (!progress)
+            return;
+        const width = 28;
+        const ratio = progress.total > 0 ? progress.current / progress.total : 1;
+        const complete = Math.min(width, Math.floor(ratio * width));
+        const bar = `${"#".repeat(complete)}${"-".repeat(width - complete)}`;
+        const percent = Math.floor(ratio * 100)
+            .toString()
+            .padStart(3, " ");
+        const text = `${label} [${bar}] ${percent}% ${progress.current}/${progress.total}`;
+        const padding = " ".repeat(Math.max(0, lastLength - text.length));
+        process.stderr.write(`\r${text}${padding}`);
+        started = true;
+        lastLength = text.length;
+    }
+    return {
+        update: render,
+        finish() {
+            if (!started)
+                return;
+            process.stderr.write("\n");
+            started = false;
+            lastLength = 0;
+        },
+    };
+}

package/dist/cli/relayer.js

@@ -2,21 +2,30 @@ import { Command } from "commander";
 import { startRelayer } from "../relayer/server/index.js";
 import { listRelayers } from "../voidify/relayer/list.js";
 import { createServiceContext, contextFromConfig, loadCliConfig, } from "../cli/helpers.js";
+import { createCliProgressBar } from "../cli/progress.js";
 export function registerRelayerCommands(program) {
     const relayerCommand = new Command("relayer")
         .enablePositionalOptions()
         .description("Relayer commands");
     relayerCommand
-        .command("list")
-        .description("List relayer information; with --pubkey, returns only that relayer")
-        .option("--pubkey <pubkey>", "Specific relayer public key")
+        .command("list [pubkey]")
+        .description("List relayer information for a specific relayer")
         .option("-o, --output <file>", "Write output to a file")
-        .action(async (options) => {
+        .action(async (pubkey, options) => {
         try {
             const ctx = await createServiceContext(program.opts());
-            const relayers = await listRelayers(ctx, options.pubkey, {
-                output: options.output,
-            });
+            const progress = createCliProgressBar("Sync relayers");
+            const relayers = await (async () => {
+                try {
+                    return await listRelayers(ctx, pubkey, {
+                        output: options.output,
+                        sync: { reporter: progress },
+                    });
+                }
+                finally {
+                    progress.finish();
+                }
+            })();
             console.log("Relayer records:", relayers);
         }
         catch (error) {

package/dist/cli/withdraw.js

@@ -1,17 +1,31 @@
 import { withdraw } from "../voidify/withdraw.js";
 import { createServiceContext } from "../cli/helpers.js";
+import { createCliProgressBar } from "../cli/progress.js";
 export function registerWithdrawCommands(program) {
     program
         .command("withdraw")
         .description("Withdraw through a relayer")
-        .requiredOption("--note <string>", "Note generated when depositing")
-        .requiredOption("--recipient <pubkey>", "Recipient address")
-        .requiredOption("--relayer <pubkey>", "Relayer address")
-        .option("--dry", "Dry run: print withdraw information without generating a proof")
-        .action(async (options) => {
+        .argument("<note>", "Note generated when depositing")
+        .option("--recipient <pubkey>", "Recipient address")
+        .option("--relayer <name>", "Relayer name")
+        .option("--send-rpc", "Send this client's RPC URL to the relayer for this withdraw request")
+        .action(async (note, options) => {
         try {
             const ctx = await createServiceContext(program.opts());
-            const result = await withdraw(ctx, options.note, options.recipient, options.relayer, options.dry ?? false);
+            const depositProgress = createCliProgressBar("Sync deposits");
+            const relayerProgress = createCliProgressBar("Sync relayers");
+            const result = await (async () => {
+                try {
+                    return await withdraw(ctx, note, options.recipient, options.relayer, {
+                        depositSync: { reporter: depositProgress },
+                        relayerSync: { reporter: relayerProgress },
+                    }, options.sendRpc ?? false);
+                }
+                finally {
+                    depositProgress.finish();
+                    relayerProgress.finish();
+                }
+            })();
             console.log("Withdraw successful:", { txSignature: result });
             process.exit(0);
         }

package/dist/context.d.ts

@@ -17,7 +17,6 @@ export type SubstreamConfig = {
 export interface ContextOptions {
     rpcUrl?: string;
     programId?: PublicKey;
-    stakingProgramId?: PublicKey;
     wallet?: anchor.Wallet | Keypair | null;
     substream?: SubstreamConfig;
     wasmPath?: string;
@@ -27,17 +26,15 @@ export declare class Context {
     private readonly _rpcUrl;
     private readonly _connection;
     private readonly _programId;
-    private readonly _stakingProgramId;
     private readonly _substream;
     private readonly _wasmPath;
     private readonly _zkeyPath;
     readonly wallet: anchor.Wallet | null;
     constructor(opts?: ContextOptions);
+    withRpcUrl(rpcUrl: string): Context;
     get rpcUrl(): string;
     get connection(): Connection;
     get programId(): PublicKey;
-    get stakingProgramId(): PublicKey;
-    hasStakingProgramId(): boolean;
     get substream(): SubstreamConfig;
     get wasmPath(): string;
     get zkeyPath(): string;

package/dist/context.js

@@ -4,7 +4,6 @@ export class Context {
     _rpcUrl;
     _connection;
     _programId;
-    _stakingProgramId;
     _substream;
     _wasmPath;
     _zkeyPath;
@@ -12,10 +11,12 @@ export class Context {
     constructor(opts = {}) {
         this._rpcUrl = opts.rpcUrl ?? null;
         this._connection = opts.rpcUrl
-            ? new Connection(opts.rpcUrl, "confirmed")
+            ? new Connection(opts.rpcUrl, {
+                commitment: "confirmed",
+                disableRetryOnRateLimit: true,
+            })
             : null;
         this._programId = opts.programId ?? null;
-        this._stakingProgramId = opts.stakingProgramId ?? null;
         this._substream = opts.substream ?? null;
         this._wasmPath = opts.wasmPath ?? null;
         this._zkeyPath = opts.zkeyPath ?? null;
@@ -23,6 +24,16 @@ export class Context {
         this.wallet =
             w === null ? null : w instanceof Keypair ? new anchor.Wallet(w) : w;
     }
+    withRpcUrl(rpcUrl) {
+        return new Context({
+            rpcUrl,
+            programId: this._programId ?? undefined,
+            wallet: this.wallet,
+            substream: this._substream ?? undefined,
+            wasmPath: this._wasmPath ?? undefined,
+            zkeyPath: this._zkeyPath ?? undefined,
+        });
+    }
     get rpcUrl() {
         if (!this._rpcUrl) {
             throw new Error("rpcUrl is required for this operation");
@@ -41,15 +52,6 @@ export class Context {
         }
         return this._programId;
     }
-    get stakingProgramId() {
-        if (!this._stakingProgramId) {
-            throw new Error("stakingProgramId is required for this operation");
-        }
-        return this._stakingProgramId;
-    }
-    hasStakingProgramId() {
-        return this._stakingProgramId !== null;
-    }
     get substream() {
         if (!this._substream) {
             throw new Error("substream config is required for this operation");

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

@@ -8,7 +8,7 @@ export type Voidify = {
     "address": "";
     "metadata": {
         "name": "voidify";
-        "version": "1.0.1";
+        "version": "2.0.0";
         "spec": "0.1.0";
     };
     "instructions": [

package/dist/idl/voidify/idl.json

@@ -2,7 +2,7 @@
     "address": "",
     "metadata": {
         "name": "voidify",
-        "version": "1.0.1",
+        "version": "2.0.0",
         "spec": "0.1.0"
     },
     "instructions": [

package/dist/index.d.ts

@@ -1,15 +1,14 @@
 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 type { ChainSyncOptions } from "./substream/chain/index.js";
+export type { DepositRecord, RelayerRecord, EventCursor, SyncProgress, SyncPhase, SyncStatus, SyncStatusReporter, 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";

package/dist/index.js

@@ -1,8 +1,6 @@
 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";

package/dist/relayer/server/server.js

@@ -2,7 +2,6 @@ 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 {
@@ -58,14 +57,13 @@ export class RelayerHttpServer {
                 });
                 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);
+            const requestCtx = body.rpcUrl
+                ? this.ctx.withRpcUrl(body.rpcUrl)
+                : this.ctx;
+            await updateQuote(requestCtx, this.feedId);
+            const switchboardQuote = await this.getSwitchboardQuote(requestCtx);
+            const ixs = await withdrawIx(requestCtx, new Uint8Array(body.proof), new Uint8Array(body.root), new Uint8Array(body.nullifierHash), body.recipient, requestCtx.publicKey.toBase58(), BigInt(body.fee), BigInt(body.treasury), switchboardQuote, BigInt(body.amount));
+            const signature = await signAndSend(requestCtx, ixs);
             logger.info({ signature }, "withdraw submitted");
             res.json({
                 success: true,
@@ -73,10 +71,11 @@ export class RelayerHttpServer {
             });
         }
         catch (error) {
-            logger.error({ error }, "Failed to withdraw");
+            let error_msg = error instanceof Error ? error.message : String(error);
+            logger.error({ error_msg }, "Failed to withdraw");
             res.status(500).json({
                 success: false,
-                error: error instanceof Error ? error.message : String(error),
+                error: error_msg,
             });
         }
     }
@@ -97,6 +96,23 @@ export class RelayerHttpServer {
         if (!body.recipient || typeof body.recipient !== "string") {
             return "Invalid recipient: must be a string";
         }
+        if (body.rpcUrl !== undefined) {
+            if (typeof body.rpcUrl !== "string") {
+                return "Invalid rpcUrl: must be a string";
+            }
+            if (body.rpcUrl.length > 2048) {
+                return "Invalid rpcUrl: too long";
+            }
+            try {
+                const parsed = new URL(body.rpcUrl);
+                if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+                    return "Invalid rpcUrl: must use http or https";
+                }
+            }
+            catch {
+                return "Invalid rpcUrl: not a valid URL";
+            }
+        }
         for (const field of ["fee", "treasury", "amount"]) {
             const value = body[field];
             if (value === undefined || value === null) {
@@ -113,9 +129,9 @@ export class RelayerHttpServer {
         }
         return null;
     }
-    async getSwitchboardQuote() {
+    async getSwitchboardQuote(ctx) {
         const sb = await import("@switchboard-xyz/on-demand");
-        const queue = await sb.Queue.loadDefault(await sb.AnchorUtils.loadProgramFromConnection(this.ctx.connection));
+        const queue = await sb.Queue.loadDefault(await sb.AnchorUtils.loadProgramFromConnection(ctx.connection));
         const [quotePDA] = sb.OracleQuote.getCanonicalPubkey(queue.pubkey, [
             this.feedId,
         ]);