@swarm-tips/client 0.0.0 → 0.1.0

package/dist/shillbot/switchboard.js

@@ -0,0 +1,205 @@
+import * as anchor from "@coral-xyz/anchor";
+import { Buffer } from "buffer";
+import { OracleJob } from "@switchboard-xyz/common/protos";
+import { ComputeBudgetProgram, Keypair, PublicKey, Secp256k1Program, SystemProgram, TransactionInstruction, TransactionMessage, VersionedTransaction, } from "@solana/web3.js";
+import { buildInstruction } from "./index.js";
+const ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
+const SPL_TOKEN_PROGRAM_ID = new PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+const SOL_NATIVE_MINT = new PublicKey("So11111111111111111111111111111111111111112");
+const SYSVAR_SLOT_HASHES = new PublicKey("SysvarS1otHashes111111111111111111111111111");
+const SYSVAR_INSTRUCTIONS = new PublicKey("Sysvar1nstructions1111111111111111111111111");
+const SWITCHBOARD_PROGRAMS = {
+    mainnet: new PublicKey("SBondMDrcV3K4kxZR1HNVT7osZxAHVHgYXL5Ze1oMUv"),
+    devnet: new PublicKey("Aio4gaXjXzJNVLtzwtNVmSqGKpANtXhybbkhtAC94ji2"),
+};
+const CROSSBAR_URL = "https://crossbar.switchboard.xyz";
+const SWITCHBOARD_GATEWAY_API_VERSION = "1.0.0";
+const anchorRuntime = anchor.default ?? anchor;
+async function jsonResponse(response, description) {
+    if (!response.ok) {
+        throw new Error(`${description} failed with HTTP ${response.status}`);
+    }
+    return (await response.json());
+}
+function encodeOracleJob(job) {
+    const encoded = OracleJob.encodeDelimited(OracleJob.fromObject(job)).finish();
+    return Buffer.from(encoded).toString("base64");
+}
+async function fetchConsensus(network, jobs, maxVariance, minResponses, taskId) {
+    const gateways = await jsonResponse(await fetch(`${CROSSBAR_URL}/gateways?network=${network}`), "Switchboard gateway discovery");
+    const gateway = gateways[0];
+    if (!gateway)
+        throw new Error(`no Switchboard gateways for ${network}`);
+    return jsonResponse(await fetch(`${gateway.replace(/\/$/, "")}/gateway/api/v1/fetch_signatures_consensus`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            api_version: SWITCHBOARD_GATEWAY_API_VERSION,
+            recent_hash: "",
+            signature_scheme: "Secp256k1",
+            hash_scheme: "Sha256",
+            feed_requests: [
+                {
+                    jobs_b64_encoded: jobs.map(encodeOracleJob),
+                    max_variance: Math.floor(maxVariance * 1e9),
+                    min_responses: minResponses,
+                },
+            ],
+            num_oracles: 1,
+            use_timestamp: false,
+            use_ed25519: false,
+            variable_overrides: { TASK_ID: taskId },
+        }),
+    }), "Switchboard consensus request");
+}
+function writeUInt16LE(value) {
+    if (!Number.isInteger(value) || value < 0 || value > 0xffff) {
+        throw new Error(`invalid secp256k1 offset: ${value}`);
+    }
+    const bytes = new Uint8Array(2);
+    new DataView(bytes.buffer).setUint16(0, value, true);
+    return bytes;
+}
+/** Build Solana's compact multi-signature secp256k1 verification instruction. */
+export function buildSecp256k1Instruction(signatures, instructionIndex) {
+    if (signatures.length === 0) {
+        throw new Error("Switchboard returned no secp256k1 signatures");
+    }
+    if (!Number.isInteger(instructionIndex) || instructionIndex < 0 || instructionIndex > 0xff) {
+        throw new Error("invalid secp256k1 instruction index");
+    }
+    const sorted = [...signatures].sort((a, b) => a.oracleIdx - b.oracleIdx);
+    const message = sorted[0].message;
+    if (sorted.some((signature) => !Buffer.from(signature.message).equals(Buffer.from(message)))) {
+        throw new Error("all Switchboard signatures must share one message");
+    }
+    for (const signature of sorted) {
+        if (signature.signature.length !== 64)
+            throw new Error("invalid secp256k1 signature length");
+        if (signature.ethAddress.length !== 20)
+            throw new Error("invalid secp256k1 address length");
+        if (!Number.isInteger(signature.recoveryId) || signature.recoveryId < 0 || signature.recoveryId > 0xff) {
+            throw new Error("invalid secp256k1 recovery id");
+        }
+    }
+    const offsetsSize = 1 + sorted.length * 11;
+    const signatureBlockSize = 64 + 1 + 20;
+    const messageOffset = offsetsSize + sorted.length * signatureBlockSize;
+    const data = new Uint8Array(messageOffset + message.length);
+    data[0] = sorted.length;
+    let blockOffset = offsetsSize;
+    sorted.forEach((signature, index) => {
+        const offset = 1 + index * 11;
+        data.set(writeUInt16LE(blockOffset), offset);
+        data[offset + 2] = instructionIndex;
+        data.set(writeUInt16LE(blockOffset + 65), offset + 3);
+        data[offset + 5] = instructionIndex;
+        data.set(writeUInt16LE(messageOffset), offset + 6);
+        data.set(writeUInt16LE(message.length), offset + 8);
+        data[offset + 10] = instructionIndex;
+        data.set(signature.signature, blockOffset);
+        data[blockOffset + 64] = signature.recoveryId;
+        data.set(signature.ethAddress, blockOffset + 65);
+        blockOffset += signatureBlockSize;
+    });
+    data.set(message, messageOffset);
+    return new TransactionInstruction({
+        programId: Secp256k1Program.programId,
+        keys: [],
+        data: Buffer.from(data),
+    });
+}
+function associatedTokenAddress(mint, owner) {
+    return PublicKey.findProgramAddressSync([owner.toBuffer(), SPL_TOKEN_PROGRAM_ID.toBuffer(), mint.toBuffer()], ASSOCIATED_TOKEN_PROGRAM_ID)[0];
+}
+/**
+ * Fetch Switchboard consensus with the task-id variable override and build the
+ * exact v0 bundle: bounded compute budget, secp256k1 proof, feed update, then
+ * Shillbot verify. The returned transaction is unsigned.
+ */
+export async function buildSwitchboardCrankAndVerify(request) {
+    const switchboardProgramId = SWITCHBOARD_PROGRAMS[request.network];
+    const dummy = Keypair.generate();
+    const provider = new anchorRuntime.AnchorProvider(request.connection, new anchorRuntime.Wallet(dummy), { commitment: "confirmed" });
+    const idl = await anchorRuntime.Program.fetchIdl(switchboardProgramId, provider);
+    if (!idl)
+        throw new Error("failed to fetch Switchboard IDL");
+    const program = new anchorRuntime.Program(idl, provider);
+    const switchboardAccounts = program.account;
+    const feedData = (await switchboardAccounts.pullFeedAccountData.fetch(request.feed));
+    const feedHashHex = Buffer.from(feedData.feedHash).toString("hex");
+    const crossbar = (await fetch(`https://crossbar.switchboard.xyz/fetch/${feedHashHex}`).then((response) => response.json()));
+    const jobs = crossbar.jobs ?? [];
+    if (jobs.length === 0)
+        throw new Error(`no Switchboard jobs for feed ${feedHashHex}`);
+    const response = await fetchConsensus(request.network, jobs, feedData.maxVariance.toNumber() / 1e9, feedData.minResponses, request.taskId);
+    if (!response.oracle_responses?.length) {
+        throw new Error("Switchboard gateway returned no oracle responses");
+    }
+    const compute = [
+        ComputeBudgetProgram.setComputeUnitLimit({ units: 400_000 }),
+        ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 10_000 }),
+    ];
+    const secp = buildSecp256k1Instruction(response.oracle_responses.map((oracle, oracleIdx) => ({
+        ethAddress: Buffer.from(oracle.eth_address, "hex"),
+        signature: Buffer.from(oracle.signature, "base64"),
+        message: Buffer.from(oracle.checksum, "base64"),
+        recoveryId: oracle.recovery_id,
+        oracleIdx,
+    })), compute.length);
+    const queuePubkey = feedData.queue;
+    const oraclePubkeys = response.oracle_responses.map((oracle) => new PublicKey(Buffer.from(oracle.oracle_pubkey, "hex")));
+    const oracleStats = oraclePubkeys.map((oracle) => PublicKey.findProgramAddressSync([Buffer.from("OracleStats"), oracle.toBuffer()], switchboardProgramId)[0]);
+    const feeds = response.median_responses.map((median) => median.feed_hash === feedHashHex ? request.feed : PublicKey.default);
+    const submit = program.instruction.pullFeedSubmitResponseConsensus({
+        slot: new anchorRuntime.BN(response.slot),
+        values: response.median_responses.map((median) => new anchorRuntime.BN(median.value)),
+    }, {
+        accounts: {
+            queue: queuePubkey,
+            programState: PublicKey.findProgramAddressSync([Buffer.from("STATE")], switchboardProgramId)[0],
+            recentSlothashes: SYSVAR_SLOT_HASHES,
+            payer: request.payer,
+            systemProgram: SystemProgram.programId,
+            rewardVault: associatedTokenAddress(SOL_NATIVE_MINT, queuePubkey),
+            tokenProgram: SPL_TOKEN_PROGRAM_ID,
+            tokenMint: SOL_NATIVE_MINT,
+            ixSysvar: SYSVAR_INSTRUCTIONS,
+        },
+        remainingAccounts: [
+            ...feeds.map((pubkey) => ({
+                pubkey,
+                isSigner: false,
+                isWritable: true,
+            })),
+            ...oraclePubkeys.map((pubkey) => ({
+                pubkey,
+                isSigner: false,
+                isWritable: false,
+            })),
+            ...oracleStats.map((pubkey) => ({
+                pubkey,
+                isSigner: false,
+                isWritable: true,
+            })),
+        ],
+    });
+    const verify = buildInstruction({
+        action: "verify",
+        wallet: request.payer.toBase58(),
+        network: request.network,
+        recentBlockhash: PublicKey.default.toBase58(),
+        taskPda: request.taskPda.toBase58(),
+        switchboardFeed: request.feed.toBase58(),
+        compositeScore: request.compositeScore.toString(),
+        verificationHash: Buffer.from(request.verificationHash).toString("hex"),
+        crankInstructions: [],
+    });
+    const { blockhash } = await request.connection.getLatestBlockhash("confirmed");
+    const message = new TransactionMessage({
+        payerKey: request.payer,
+        recentBlockhash: blockhash,
+        instructions: [...compute, secp, submit, verify],
+    }).compileToV0Message();
+    return new VersionedTransaction(message);
+}

package/dist/vow/decoders/extension.d.ts

@@ -0,0 +1,62 @@
+/**
+ * extension-registry `Extension` account decoder — the mund-creanc-witer
+ * obligation edge (extender vouches for recipient, backed by a bonded SOL
+ * stake). Mirrors `programs/extension-registry/src/state/extension.rs` exactly.
+ *
+ * Unlike Shillbot's `Task`, an `Extension` has NO on-chain state enum: the
+ * account exists only while the vouch is LIVE. Both terminal transitions
+ * close it — `withdraw_extension` (extender reclaims bond) and
+ * `default_extension` (slash to treasury) — emitting `ExtensionWithdrawn` /
+ * `ExtensionDefaulted` events. So a present account is always "active"; a closed
+ * one is terminal (the verifier returns `account_closed`), exactly mirroring a
+ * finalized Task. The durable terminal history is the event stream, not an
+ * account.
+ *
+ * NB: this exposes a typed decoder + discriminator/state helpers for downstream
+ * consumers (the web-position indexer, an extension-aware verifier). It is NOT a
+ * drop-in `ProtocolHandler`: that interface's `DecodedAccount` is Task-shaped
+ * (task_id, composite_score, content hashes…), and `verify.ts` step 5 compares
+ * those Task fields directly. Verifying an Extension *attestation* end-to-end
+ * therefore needs the verifier's field-equality core generalized per
+ * account_kind (and matching wire fields) — a deliberate change beyond this
+ * decoder, tracked separately.
+ *
+ * Body offsets (after the 8-byte Anchor discriminator):
+ *
+ *   off  size  field
+ *     0    32  extender        (Pubkey)
+ *    32    32  recipient       (Pubkey)
+ *    64     1  extension_type  (u8)
+ *    65     8  bond_lamports   (u64 LE)
+ *    73     8  created_at      (i64 LE, unix seconds)
+ *    81     1  bump
+ *    82    16  _reserved       (skipped)
+ *
+ * Body = 98 bytes; full account (with discriminator) = 106 = `Extension::SPACE`.
+ */
+export interface ExtensionRecord {
+    extender: string;
+    recipient: string;
+    extension_type: number;
+    bond_lamports: bigint;
+    created_at: bigint;
+    bump: number;
+}
+/** The Anchor account name (→ discriminator `sha256("account:Extension")[0..8]`). */
+export declare const EXTENSION_ACCOUNT_KIND = "Extension";
+/** Minimum body length carrying every decoded field (through `bump`). */
+export declare const EXTENSION_MIN_BODY_LEN = 82;
+/** A live Extension has no state byte — existence == active. */
+export declare const EXTENSION_ACTIVE_STATE = "active";
+/**
+ * Decode an `Extension` account body (the bytes AFTER the 8-byte discriminator).
+ * Throws on the wrong `accountKind` or a body too short for the decoded fields.
+ */
+export declare function decodeExtension(data: Uint8Array, accountKind: string): ExtensionRecord;
+/**
+ * Extension-type discriminant → name. Mirrors the taxonomy in
+ * `programs/extension-registry/src/constants.rs`. MVP records only
+ * CapabilityValidation (0); the rest are reserved for weaker-verifiability
+ * handling. Returns `null` for unknown discriminants.
+ */
+export declare function resolveExtensionType(extensionType: number): string | null;

package/dist/vow/decoders/extension.js

@@ -0,0 +1,48 @@
+import { PublicKey } from "@solana/web3.js";
+/** The Anchor account name (→ discriminator `sha256("account:Extension")[0..8]`). */
+export const EXTENSION_ACCOUNT_KIND = "Extension";
+/** Minimum body length carrying every decoded field (through `bump`). */
+export const EXTENSION_MIN_BODY_LEN = 82;
+/** A live Extension has no state byte — existence == active. */
+export const EXTENSION_ACTIVE_STATE = "active";
+/**
+ * Decode an `Extension` account body (the bytes AFTER the 8-byte discriminator).
+ * Throws on the wrong `accountKind` or a body too short for the decoded fields.
+ */
+export function decodeExtension(data, accountKind) {
+    if (accountKind !== EXTENSION_ACCOUNT_KIND) {
+        throw new Error(`decodeExtension only handles account_kind="Extension", got "${accountKind}"`);
+    }
+    if (data.length < EXTENSION_MIN_BODY_LEN) {
+        throw new Error(`Extension body too short: ${data.length} bytes (need >= ${EXTENSION_MIN_BODY_LEN})`);
+    }
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    return {
+        extender: new PublicKey(data.slice(0, 32)).toBase58(),
+        recipient: new PublicKey(data.slice(32, 64)).toBase58(),
+        extension_type: data[64],
+        bond_lamports: view.getBigUint64(65, true),
+        created_at: view.getBigInt64(73, true),
+        bump: data[81],
+    };
+}
+/**
+ * Extension-type discriminant → name. Mirrors the taxonomy in
+ * `programs/extension-registry/src/constants.rs`. MVP records only
+ * CapabilityValidation (0); the rest are reserved for weaker-verifiability
+ * handling. Returns `null` for unknown discriminants.
+ */
+export function resolveExtensionType(extensionType) {
+    switch (extensionType) {
+        case 0:
+            return "capability_validation";
+        case 1:
+            return "mentorship";
+        case 2:
+            return "sponsorship";
+        case 3:
+            return "validation";
+        default:
+            return null;
+    }
+}

package/dist/vow/decoders/shillbot.d.ts

@@ -0,0 +1,59 @@
+import type { AccountDecoder, ProtocolHandler, StateResolver } from "../types.js";
+/**
+ * Shillbot Task account decoder (post-#12 layout).
+ *
+ * Accepts the on-chain Task account body — i.e. the bytes AFTER the
+ * 8-byte Anchor discriminator. Layout mirrors
+ * `programs/shillbot/src/state/task.rs::Task` exactly. Only the
+ * fields the VOW verifier needs are decoded; the rest of the body
+ * (escrow_lamports, deadlines, overrides, _reserved, bump) is
+ * skipped via byte offsets.
+ *
+ * Field offsets within the body (post-discriminator):
+ *
+ *   off  size  field
+ *     0     8  task_id            (u64 LE)
+ *     8    32  client             (Pubkey)
+ *    40    32  agent              (Pubkey)
+ *    72     1  state              (TaskState u8)
+ *    73     1  platform           (u8)
+ *    74     8  escrow_lamports    (u64 LE)         skipped
+ *    82    32  content_hash       (sha256)
+ *   114    32  content_id_hash    (sha256)
+ *   146    16  task_nonce         (skipped)
+ *   162     8  composite_score    (u64 LE)
+ *   170     8  payment_amount     (skipped)
+ *   178     8  fee_amount         (skipped)
+ *   186     8  deadline           (skipped)
+ *   194     8  submit_margin      (skipped)
+ *   202     8  claim_buffer       (skipped)
+ *   210     8  created_at         (skipped)
+ *   218     8  submitted_at       (skipped)
+ *   226     8  verified_at        (i64 LE)
+ *   234     8  challenge_deadline (skipped)
+ *   242    12  three u32 overrides (skipped)
+ *   254    32  verification_hash  (sha256)
+ *   286     1  requires_approval  (skipped; D1 — carved from _reserved)
+ *   287     1  verification_kind  (skipped; 2026-07-07 — carved from _reserved)
+ *   288    18  _reserved          (skipped)
+ *   306     1  bump               (skipped)
+ *   307    32  payout_to          (skipped; C2 — appended after bump)
+ *
+ * Total body = 339 bytes. With the 8-byte discriminator, the full
+ * account is 347 bytes (matches `Task::SPACE`); pre-C2 accounts are 315
+ * bytes until `migrate_task` reallocs them — the decoder only reads
+ * fields below offset 286, so both sizes decode identically.
+ */
+export declare const decodeShillbotTask: AccountDecoder;
+/**
+ * Shillbot TaskState enum → lowercase name. Mirrors
+ * `programs/shillbot/src/state/task.rs::TaskState` discriminants
+ * exactly. `Approved = 7` was appended in Phase 3 blocker #3a.
+ */
+export declare const resolveShillbotState: StateResolver;
+/** Shillbot's "states valid for attestation" policy, per `docs/specs/vow-v1.md`
+ *  §6 capture window: only Verified is attestable. Finalize closes the on-chain
+ *  account, so post-finalize the attestation is permanently unverifiable. */
+export declare const shillbotValidStates: (accountKind: string) => readonly string[];
+/** Convenience bundle for callers that just want the canonical Shillbot triple. */
+export declare const shillbotProtocol: ProtocolHandler;

package/dist/vow/decoders/shillbot.js

@@ -0,0 +1,130 @@
+import { PublicKey } from "@solana/web3.js";
+/**
+ * Shillbot Task account decoder (post-#12 layout).
+ *
+ * Accepts the on-chain Task account body — i.e. the bytes AFTER the
+ * 8-byte Anchor discriminator. Layout mirrors
+ * `programs/shillbot/src/state/task.rs::Task` exactly. Only the
+ * fields the VOW verifier needs are decoded; the rest of the body
+ * (escrow_lamports, deadlines, overrides, _reserved, bump) is
+ * skipped via byte offsets.
+ *
+ * Field offsets within the body (post-discriminator):
+ *
+ *   off  size  field
+ *     0     8  task_id            (u64 LE)
+ *     8    32  client             (Pubkey)
+ *    40    32  agent              (Pubkey)
+ *    72     1  state              (TaskState u8)
+ *    73     1  platform           (u8)
+ *    74     8  escrow_lamports    (u64 LE)         skipped
+ *    82    32  content_hash       (sha256)
+ *   114    32  content_id_hash    (sha256)
+ *   146    16  task_nonce         (skipped)
+ *   162     8  composite_score    (u64 LE)
+ *   170     8  payment_amount     (skipped)
+ *   178     8  fee_amount         (skipped)
+ *   186     8  deadline           (skipped)
+ *   194     8  submit_margin      (skipped)
+ *   202     8  claim_buffer       (skipped)
+ *   210     8  created_at         (skipped)
+ *   218     8  submitted_at       (skipped)
+ *   226     8  verified_at        (i64 LE)
+ *   234     8  challenge_deadline (skipped)
+ *   242    12  three u32 overrides (skipped)
+ *   254    32  verification_hash  (sha256)
+ *   286     1  requires_approval  (skipped; D1 — carved from _reserved)
+ *   287     1  verification_kind  (skipped; 2026-07-07 — carved from _reserved)
+ *   288    18  _reserved          (skipped)
+ *   306     1  bump               (skipped)
+ *   307    32  payout_to          (skipped; C2 — appended after bump)
+ *
+ * Total body = 339 bytes. With the 8-byte discriminator, the full
+ * account is 347 bytes (matches `Task::SPACE`); pre-C2 accounts are 315
+ * bytes until `migrate_task` reallocs them — the decoder only reads
+ * fields below offset 286, so both sizes decode identically.
+ */
+export const decodeShillbotTask = (data, accountKind) => {
+    if (accountKind !== "Task") {
+        throw new Error(`decodeShillbotTask only handles account_kind="Task", got "${accountKind}"`);
+    }
+    if (data.length < 286) {
+        throw new Error(`Shillbot Task body too short: ${data.length} bytes (need >= 286 for the VOW-relevant fields)`);
+    }
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const task_id = view.getBigUint64(0, /* littleEndian */ true);
+    const client = new PublicKey(data.slice(8, 40)).toBase58();
+    const agent = new PublicKey(data.slice(40, 72)).toBase58();
+    const state = data[72];
+    // platform is at offset 73 but unused by the verifier (the wire
+    // format carries it directly; verifier's field-equality check
+    // covers it via the v1 §4 step 5 platform comparison done by the
+    // caller, not here).
+    const content_hash = bytesToHex(data.slice(82, 114));
+    const content_id_hash = bytesToHex(data.slice(114, 146));
+    const composite_score = view.getBigUint64(162, true);
+    const verified_at = view.getBigInt64(226, true);
+    const verification_hash = bytesToHex(data.slice(254, 286));
+    const decoded = {
+        task_id,
+        client,
+        agent,
+        state,
+        composite_score,
+        verified_at,
+        verification_hash,
+        content_hash,
+        content_id_hash,
+    };
+    return decoded;
+};
+/**
+ * Shillbot TaskState enum → lowercase name. Mirrors
+ * `programs/shillbot/src/state/task.rs::TaskState` discriminants
+ * exactly. `Approved = 7` was appended in Phase 3 blocker #3a.
+ */
+export const resolveShillbotState = (state, accountKind) => {
+    if (accountKind !== "Task")
+        return null;
+    switch (state) {
+        case 0:
+            return "open";
+        case 1:
+            return "claimed";
+        case 2:
+            return "submitted";
+        case 3:
+            return "verified";
+        case 4:
+            return "finalized";
+        case 5:
+            return "disputed";
+        case 6:
+            return "resolved";
+        case 7:
+            return "approved";
+        default:
+            return null;
+    }
+};
+/** Shillbot's "states valid for attestation" policy, per `docs/specs/vow-v1.md`
+ *  §6 capture window: only Verified is attestable. Finalize closes the on-chain
+ *  account, so post-finalize the attestation is permanently unverifiable. */
+export const shillbotValidStates = (accountKind) => {
+    if (accountKind !== "Task")
+        return [];
+    return ["verified"];
+};
+/** Convenience bundle for callers that just want the canonical Shillbot triple. */
+export const shillbotProtocol = {
+    decode: decodeShillbotTask,
+    resolveState: resolveShillbotState,
+    validStates: shillbotValidStates,
+};
+function bytesToHex(b) {
+    let s = "";
+    for (let i = 0; i < b.length; i++) {
+        s += b[i].toString(16).padStart(2, "0");
+    }
+    return s;
+}

package/dist/vow/discriminator.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Anchor account discriminator: sha256("account:" + name)[0..8].
+ *
+ * Used by step 4 of the verification protocol — the first 8 bytes of
+ * the on-chain account data MUST equal this for the named
+ * `account_kind` under the named `program_id`. Anchor accounts derive
+ * their discriminator deterministically from the struct name; the
+ * verifier reproduces it without needing the protocol's IDL.
+ */
+export declare function anchorDiscriminator(accountKind: string): Uint8Array;
+/** Constant-time byte equality. */
+export declare function bytesEqual(a: Uint8Array, b: Uint8Array): boolean;

package/dist/vow/discriminator.js

@@ -0,0 +1,25 @@
+import { sha256 } from "js-sha256";
+/**
+ * Anchor account discriminator: sha256("account:" + name)[0..8].
+ *
+ * Used by step 4 of the verification protocol — the first 8 bytes of
+ * the on-chain account data MUST equal this for the named
+ * `account_kind` under the named `program_id`. Anchor accounts derive
+ * their discriminator deterministically from the struct name; the
+ * verifier reproduces it without needing the protocol's IDL.
+ */
+export function anchorDiscriminator(accountKind) {
+    const preimage = `account:${accountKind}`;
+    const hash = sha256.array(preimage);
+    return new Uint8Array(hash.slice(0, 8));
+}
+/** Constant-time byte equality. */
+export function bytesEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    let diff = 0;
+    for (let i = 0; i < a.length; i++) {
+        diff |= a[i] ^ b[i];
+    }
+    return diff === 0;
+}

package/dist/vow/index.d.ts

@@ -0,0 +1,7 @@
+export type { VowV1Attestation, AasV1Attestation, AccountDecoder, DecodedAccount, FailureReason, ProtocolHandler, StateResolver, Verdict, } from "./types.js";
+export { anchorDiscriminator, bytesEqual } from "./discriminator.js";
+export { checkSchema, asV1 } from "./schema.js";
+export { verifyV1, verifyV1Schema, verifyV1OnChain } from "./verify.js";
+export { decodeShillbotTask, resolveShillbotState, shillbotProtocol, } from "./decoders/shillbot.js";
+export type { ExtensionRecord } from "./decoders/extension.js";
+export { decodeExtension, resolveExtensionType, EXTENSION_ACCOUNT_KIND, EXTENSION_MIN_BODY_LEN, EXTENSION_ACTIVE_STATE, } from "./decoders/extension.js";

package/dist/vow/index.js

@@ -0,0 +1,5 @@
+export { anchorDiscriminator, bytesEqual } from "./discriminator.js";
+export { checkSchema, asV1 } from "./schema.js";
+export { verifyV1, verifyV1Schema, verifyV1OnChain } from "./verify.js";
+export { decodeShillbotTask, resolveShillbotState, shillbotProtocol, } from "./decoders/shillbot.js";
+export { decodeExtension, resolveExtensionType, EXTENSION_ACCOUNT_KIND, EXTENSION_MIN_BODY_LEN, EXTENSION_ACTIVE_STATE, } from "./decoders/extension.js";

package/dist/vow/schema.d.ts

@@ -0,0 +1,14 @@
+import type { AasV1Attestation, FailureReason } from "./types.js";
+/**
+ * Step 1 — schema check. Implements the well-formed-per-type table
+ * from `docs/specs/vow-v1.md` §4. Returns the first failure reason
+ * encountered, or null if the schema check passes.
+ *
+ * Pure — no RPC, no I/O.
+ */
+export declare function checkSchema(input: unknown): FailureReason | null;
+/**
+ * Once `checkSchema` passes, narrow the input to `AasV1Attestation`.
+ * Pure runtime cast — no defensive checks (those already ran).
+ */
+export declare function asV1(a: unknown): AasV1Attestation;