@swarm-tips/client 0.0.0 → 0.1.0

package/dist/shillbot/index.js

@@ -0,0 +1,327 @@
+import { Buffer } from "buffer";
+import { sha256 } from "js-sha256";
+import { BN, SHILLBOT_PROGRAM_ID, agentStatePda, buildShillbotInstruction, clientStatePda, globalStatePda, shillbotInstructionDiscriminator, taskPda, } from "../contracts/index.js";
+import bs58 from "bs58";
+import { PublicKey, Transaction, TransactionMessage, VersionedTransaction, } from "@solana/web3.js";
+export { COORDINATION_GAME_IDL, COORDINATION_GAME_PROGRAM_ID, SHILLBOT_IDL, SHILLBOT_PROGRAM_ID, agentStatePda, buildShillbotInstruction, clientStatePda, globalStatePda, shillbotInstructionDiscriminator, taskPda, } from "../contracts/index.js";
+export const SCHEMA_VERSION = "swarm.shillbot.transaction-intent/v1";
+export function buildInstruction(request) {
+    const wallet = new PublicKey(request.wallet);
+    if (request.action === "create") {
+        const nonce = BigInt(request.nonce);
+        return buildShillbotInstruction({
+            name: "create_task",
+            accounts: {
+                global_state: globalStatePda(),
+                task: taskPda(nonce, wallet),
+                client_state: clientStatePda(wallet),
+                client: wallet,
+            },
+            args: {
+                nonce: new BN(request.nonce),
+                escrow_lamports: new BN(request.escrowLamports),
+                content_hash: Array.from(Buffer.from(request.contentHash, "hex")),
+                deadline: new BN(request.deadline),
+                submit_margin: new BN(request.submitMargin),
+                claim_buffer: new BN(request.claimBuffer),
+                platform: request.platform,
+                attestation_delay_override: request.attestationDelayOverride,
+                challenge_window_override: request.challengeWindowOverride,
+                verification_timeout_override: request.verificationTimeoutOverride,
+                requires_approval: request.requiresApproval,
+                verification_kind: request.verificationKind,
+            },
+        });
+    }
+    const task = new PublicKey(request.taskPda);
+    if (request.action === "claim") {
+        return buildShillbotInstruction({
+            name: "claim_task",
+            accounts: {
+                task,
+                global_state: globalStatePda(),
+                agent_state: agentStatePda(wallet),
+                agent: wallet,
+            },
+        });
+    }
+    if (request.action === "submit") {
+        return buildShillbotInstruction({
+            name: "submit_work",
+            accounts: {
+                task,
+                global_state: globalStatePda(),
+                agent_state: agentStatePda(wallet),
+                agent: wallet,
+            },
+            args: { content_id: Buffer.from(request.contentId, "utf8") },
+        });
+    }
+    if (request.action === "approve") {
+        return buildShillbotInstruction({
+            name: "approve_task",
+            accounts: { task, client: wallet },
+        });
+    }
+    if (request.action === "verify") {
+        return buildShillbotInstruction({
+            name: "verify_task",
+            accounts: {
+                task,
+                global_state: globalStatePda(),
+                switchboard_feed: request.switchboardFeed,
+            },
+            args: {
+                composite_score: new BN(request.compositeScore),
+                verification_hash: Array.from(Buffer.from(request.verificationHash, "hex")),
+            },
+        });
+    }
+    const finalize = request;
+    return buildShillbotInstruction({
+        name: "finalize_task",
+        accounts: {
+            task,
+            global_state: globalStatePda(),
+            agent: finalize.agent,
+            client: finalize.client,
+            treasury: finalize.treasury,
+        },
+    });
+}
+function payoutInstruction(request) {
+    if (!request.payoutTo)
+        return undefined;
+    return buildShillbotInstruction({
+        name: "set_payout_to",
+        accounts: { task: request.taskPda, agent: request.wallet },
+        args: { payout_to: new PublicKey(request.payoutTo) },
+    });
+}
+function stable(value) {
+    if (Array.isArray(value))
+        return value.map(stable);
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .filter(([, child]) => child !== undefined)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, child]) => [key, stable(child)]));
+    }
+    return value;
+}
+export function intentDigest(intent) {
+    return sha256(JSON.stringify(stable(intent)));
+}
+function actionRisk(action) {
+    if (action === "create")
+        return "spend";
+    if (action === "approve")
+        return "escrow_control";
+    return "earn";
+}
+function serializeUnsigned(payer, blockhash, instructions, version) {
+    if (version === "v0") {
+        const message = new TransactionMessage({
+            payerKey: payer,
+            recentBlockhash: blockhash,
+            instructions,
+        }).compileToV0Message();
+        return Buffer.from(new VersionedTransaction(message).serialize()).toString("base64");
+    }
+    const tx = new Transaction({
+        feePayer: payer,
+        recentBlockhash: blockhash,
+    }).add(...instructions);
+    return tx
+        .serialize({ requireAllSignatures: false, verifySignatures: false })
+        .toString("base64");
+}
+export function buildTransaction(request) {
+    const lifecycle = buildInstruction(request);
+    const sponsor = request.action === "claim" || request.action === "submit"
+        ? request.sponsor
+        : undefined;
+    const payer = new PublicKey(sponsor ?? request.wallet);
+    const companions = request.action === "verify"
+        ? request.crankInstructions
+        : request.action === "claim"
+            ? [payoutInstruction(request)].filter((ix) => ix !== undefined)
+            : [];
+    // set_payout_to authorizes against task.agent, which claim_task establishes.
+    // Keep the two operations atomic, but execute the claim first.
+    const instructions = request.action === "claim"
+        ? [lifecycle, ...companions]
+        : [...companions, lifecycle];
+    const unsignedTx = serializeUnsigned(payer, request.recentBlockhash, instructions, request.version ?? (request.action === "verify" ? "v0" : "legacy"));
+    const task = lifecycle.keys[request.action === "create" ? 1 : 0].pubkey.toBase58();
+    const accounts = lifecycle.keys.map((key) => key.pubkey.toBase58());
+    const signers = [payer.toBase58()];
+    if (payer.toBase58() !== request.wallet)
+        signers.push(request.wallet);
+    const movements = request.action === "create"
+        ? [
+            {
+                asset: "SOL",
+                from: request.wallet,
+                to: task,
+                amount: request.escrowLamports,
+                condition: "escrow deposit",
+            },
+        ]
+        : request.action === "approve"
+            ? [
+                {
+                    asset: "escrow control",
+                    from: task,
+                    to: task,
+                    condition: "authorizes verification; no immediate transfer",
+                },
+            ]
+            : [];
+    const actionArguments = Object.fromEntries(Object.entries(request).filter(([key, value]) => ![
+        "action",
+        "wallet",
+        "network",
+        "recentBlockhash",
+        "version",
+        "sponsor",
+        "crankInstructions",
+    ].includes(key) &&
+        ["string", "number", "boolean"].includes(typeof value)));
+    const withoutDigest = {
+        version: SCHEMA_VERSION,
+        action: request.action,
+        network: request.network,
+        wallet: request.wallet,
+        task_pda: task,
+        program_id: SHILLBOT_PROGRAM_ID.toBase58(),
+        fee_payer: payer.toBase58(),
+        accounts,
+        signers,
+        movements,
+        risk: actionRisk(request.action),
+        arguments: actionArguments,
+    };
+    return {
+        unsigned_tx: unsignedTx,
+        transaction_intent: {
+            ...withoutDigest,
+            digest: intentDigest(withoutDigest),
+        },
+    };
+}
+export function inspectTransaction(encoded) {
+    const bytes = Buffer.from(encoded, "base64");
+    try {
+        const tx = VersionedTransaction.deserialize(bytes);
+        const keys = tx.message.staticAccountKeys;
+        return {
+            version: tx.version === "legacy" ? "legacy" : "v0",
+            fee_payer: keys[0].toBase58(),
+            signers: keys
+                .slice(0, tx.message.header.numRequiredSignatures)
+                .map((key) => key.toBase58()),
+            instructions: tx.message.compiledInstructions.map((ix) => ({
+                program_id: keys[ix.programIdIndex].toBase58(),
+                accounts: ix.accountKeyIndexes.map((index) => keys[index].toBase58()),
+                data_base64: Buffer.from(ix.data).toString("base64"),
+            })),
+        };
+    }
+    catch {
+        const tx = Transaction.from(bytes);
+        const message = tx.compileMessage();
+        return {
+            version: "legacy",
+            fee_payer: message.accountKeys[0].toBase58(),
+            signers: message.accountKeys
+                .slice(0, message.header.numRequiredSignatures)
+                .map((key) => key.toBase58()),
+            instructions: message.instructions.map((ix) => ({
+                program_id: message.accountKeys[ix.programIdIndex].toBase58(),
+                accounts: ix.accounts.map((index) => message.accountKeys[index].toBase58()),
+                data_base64: Buffer.from(bs58.decode(ix.data)).toString("base64"),
+            })),
+        };
+    }
+}
+export function verifyIntent(encoded, intent) {
+    const { digest: _digest, ...rest } = intent;
+    const expectedDigest = intentDigest(rest);
+    if (expectedDigest !== intent.digest)
+        throw new Error("intent digest mismatch");
+    const inspected = inspectTransaction(encoded);
+    if (inspected.fee_payer !== intent.fee_payer)
+        throw new Error("fee payer differs from intent");
+    if (!inspected.signers.includes(intent.wallet))
+        throw new Error("wallet is not a required signer");
+    const expectedDiscriminator = shillbotInstructionDiscriminator(intent.action === "submit" ? "submit_work" : `${intent.action}_task`);
+    const lifecycle = inspected.instructions.filter((ix) => ix.program_id === SHILLBOT_PROGRAM_ID.toBase58() &&
+        Buffer.from(ix.data_base64, "base64")
+            .subarray(0, 8)
+            .equals(expectedDiscriminator));
+    if (lifecycle.length !== 1)
+        throw new Error("expected exactly one Shillbot lifecycle instruction");
+    const shillbotInstructions = inspected.instructions.filter((ix) => ix.program_id === SHILLBOT_PROGRAM_ID.toBase58());
+    const payoutDiscriminator = shillbotInstructionDiscriminator("set_payout_to");
+    const companions = shillbotInstructions.filter((ix) => ix !== lifecycle[0]);
+    const lifecycleIndex = inspected.instructions.indexOf(lifecycle[0]);
+    if (intent.action === "claim" &&
+        companions.some((ix) => Buffer.from(ix.data_base64, "base64")
+            .subarray(0, 8)
+            .equals(payoutDiscriminator) &&
+            inspected.instructions.indexOf(ix) < lifecycleIndex)) {
+        throw new Error("payout route must follow claim");
+    }
+    if (companions.length >
+        (intent.action === "claim" && intent.arguments.payoutTo ? 1 : 0) ||
+        companions.some((ix) => intent.action !== "claim" ||
+            !Buffer.from(ix.data_base64, "base64")
+                .subarray(0, 8)
+                .equals(payoutDiscriminator) ||
+            ix.accounts.join(",") !== [intent.task_pda, intent.wallet].join(",") ||
+            Buffer.from(ix.data_base64, "base64").subarray(8).toString("hex") !==
+                new PublicKey(String(intent.arguments.payoutTo))
+                    .toBuffer()
+                    .toString("hex"))) {
+        throw new Error("unexpected Shillbot companion instruction");
+    }
+    if (lifecycle[0].accounts.join(",") !== intent.accounts.join(",")) {
+        throw new Error("lifecycle accounts differ from intent");
+    }
+    return inspected;
+}
+export async function signAndBroadcast(connection, encodedUnsigned, sign, confirmation) {
+    const raw = Buffer.from(encodedUnsigned, "base64");
+    let transaction;
+    try {
+        transaction = VersionedTransaction.deserialize(raw);
+    }
+    catch {
+        transaction = Transaction.from(raw);
+    }
+    const signed = await sign(transaction);
+    const wire = signed instanceof VersionedTransaction
+        ? signed.serialize()
+        : signed.serialize({
+            requireAllSignatures: true,
+            verifySignatures: true,
+        });
+    const signature = await connection.sendRawTransaction(wire);
+    if (confirmation) {
+        await connection.confirmTransaction({ signature, ...confirmation }, "confirmed");
+    }
+    else {
+        await connection.confirmTransaction(signature, "confirmed");
+    }
+    return signature;
+}
+// Convenience aliases keep exact action names easy to discover and call.
+export const buildCreate = (request) => buildTransaction({ ...request, action: "create" });
+export const buildClaim = (request) => buildTransaction({ ...request, action: "claim" });
+export const buildSubmit = (request) => buildTransaction({ ...request, action: "submit" });
+export const buildApprove = (request) => buildTransaction({ ...request, action: "approve" });
+export const buildVerify = (request) => buildTransaction({ ...request, action: "verify" });
+export const buildFinalize = (request) => buildTransaction({ ...request, action: "finalize" });
+export { buildSwitchboardCrankAndVerify } from "./switchboard.js";
+export * from "./payout-oracle.js";

package/dist/shillbot/payout-oracle.d.ts

@@ -0,0 +1,63 @@
+export declare const MAX_SCORE = 1000000;
+/** The terminal settlement path a task took. */
+export declare enum TaskOutcomeKind {
+    /** Challenge window elapsed unchallenged → finalize_task pays the agent. */
+    Finalized = 0,
+    /** Challenged, authority resolves agent-favor → payment + bond slashed to agent/treasury. */
+    ResolvedAgentWins = 1,
+    /** Challenged, authority resolves challenger-favor → escrow to client, bond returned. */
+    ResolvedChallengerWins = 2,
+    /** Disputed, permissionless liveness crank → pinned payment, bond un-slashed. */
+    DefaultResolved = 3,
+    /** Verification timeout / deadline → expire_task refunds the client in full. */
+    Expired = 4
+}
+export interface TaskScenario {
+    escrowLamports: bigint;
+    qualityThreshold: number;
+    protocolFeeBps: number;
+    compositeScore: number;
+    /** 0 = OracleMetrics (Switchboard), 1 = DeterministicAttested (score ∈ {0, MAX_SCORE}). */
+    verificationKind: 0 | 1;
+    /** Challenge bond = multiplier × escrow; bounded [2, 10] on-chain. */
+    challengeBondMultiplier: number;
+    /** Treasury share of a slashed bond, in basis points (e.g. 5000 = 50%). */
+    bondSlashTreasuryBps: number;
+    outcome: TaskOutcomeKind;
+}
+/** Realized escrow+bond distribution, EXCLUDING rent (the harness tolerates rent
+ *  on player accounts via `>=` and reconciles protocol accounts exactly). */
+export interface TaskPayout {
+    kind: TaskOutcomeKind;
+    agentLamports: bigint;
+    treasuryLamports: bigint;
+    /** Escrow returned to the client (remainder on payment, or full refund). */
+    clientLamports: bigint;
+    /** Bond returned to the challenger (0 when the bond was slashed away). */
+    challengerLamports: bigint;
+}
+export interface PaymentSplit {
+    payment: bigint;
+    fee: bigint;
+    remainder: bigint;
+}
+/**
+ * Mirror of `scoring.rs::compute_payment` (payment, fee) plus the escrow
+ * remainder. Floor division throughout, u128-safe via bigint. Throws on the
+ * same preconditions the program asserts (score/threshold ≤ MAX_SCORE).
+ */
+export declare function computePayment(compositeScore: number, qualityThreshold: number, escrowLamports: bigint, protocolFeeBps: number): PaymentSplit;
+/** Challenge bond = multiplier × escrow, bounded [2, 10] like the program. */
+export declare function computeChallengeBond(escrowLamports: bigint, multiplier: number): bigint;
+/** Treasury/agent split of a slashed bond, mirror of `resolve_challenge.rs::slash_bond`. */
+export declare function splitSlashedBond(bond: bigint, bondSlashTreasuryBps: number): {
+    treasuryShare: bigint;
+    agentShare: bigint;
+};
+/**
+ * The canonical payout derivation. Given a task scenario (its escrow, score,
+ * verification kind, and the terminal PATH it took), returns the exact
+ * escrow+bond distribution the on-chain program produces. Conserves value:
+ * escrow + bond is fully redistributed (asserted before return).
+ */
+export declare function deriveTaskOutcome(s: TaskScenario): TaskPayout;

package/dist/shillbot/payout-oracle.js

@@ -0,0 +1,172 @@
+// Task-outcome oracle — the canonical Shillbot payout matrix, in TypeScript.
+//
+// This is the off-chain test/tooling mirror of the on-chain payout logic that
+// three implementations must agree on (pinned by the golden vectors in
+// tests/fixtures/task-payout-vectors.json):
+//
+//   - programs/shillbot/src/scoring.rs           `compute_payment`
+//   - programs/shillbot/src/instructions/resolve_challenge.rs  `slash_bond`
+//   - evm/src/ShillbotEscrow.sol                 payment + bond split
+//
+// The combinatorial harness uses it as the single source of truth for "what
+// SHOULD this task pay out" so every scenario — Solana bankrun, Solana devnet,
+// EVM ShillbotEscrow, MCP-driven, browser-driven — asserts on-chain reality
+// against ONE expectation instead of re-deriving the formula per test. If this
+// drifts from the on-chain payout, the parity test + the combinatorial suites
+// fail.
+//
+// Unlike the coordination game (where the outcome is DERIVED from the realized
+// transcript), a Shillbot task's terminal PATH is a choice of which crank/
+// resolution ran — finalize vs challenge-resolution vs dispute-liveness default
+// vs expiry. The scenario carries that choice; the oracle computes the exact
+// lamport split it implies. Roles are explicit (client creates, agent claims),
+// so there is no FIFO "expected family" — the split is fully determined.
+export const MAX_SCORE = 1_000_000;
+/** The terminal settlement path a task took. */
+export var TaskOutcomeKind;
+(function (TaskOutcomeKind) {
+    /** Challenge window elapsed unchallenged → finalize_task pays the agent. */
+    TaskOutcomeKind[TaskOutcomeKind["Finalized"] = 0] = "Finalized";
+    /** Challenged, authority resolves agent-favor → payment + bond slashed to agent/treasury. */
+    TaskOutcomeKind[TaskOutcomeKind["ResolvedAgentWins"] = 1] = "ResolvedAgentWins";
+    /** Challenged, authority resolves challenger-favor → escrow to client, bond returned. */
+    TaskOutcomeKind[TaskOutcomeKind["ResolvedChallengerWins"] = 2] = "ResolvedChallengerWins";
+    /** Disputed, permissionless liveness crank → pinned payment, bond un-slashed. */
+    TaskOutcomeKind[TaskOutcomeKind["DefaultResolved"] = 3] = "DefaultResolved";
+    /** Verification timeout / deadline → expire_task refunds the client in full. */
+    TaskOutcomeKind[TaskOutcomeKind["Expired"] = 4] = "Expired";
+})(TaskOutcomeKind || (TaskOutcomeKind = {}));
+/**
+ * Mirror of `scoring.rs::compute_payment` (payment, fee) plus the escrow
+ * remainder. Floor division throughout, u128-safe via bigint. Throws on the
+ * same preconditions the program asserts (score/threshold ≤ MAX_SCORE).
+ */
+export function computePayment(compositeScore, qualityThreshold, escrowLamports, protocolFeeBps) {
+    if (compositeScore > MAX_SCORE) {
+        throw new Error(`score ${compositeScore} exceeds MAX_SCORE ${MAX_SCORE}`);
+    }
+    if (qualityThreshold > MAX_SCORE) {
+        throw new Error(`threshold ${qualityThreshold} exceeds MAX_SCORE ${MAX_SCORE}`);
+    }
+    if (escrowLamports < 0n)
+        throw new Error("escrow must be non-negative");
+    if (compositeScore < qualityThreshold) {
+        return { payment: 0n, fee: 0n, remainder: escrowLamports };
+    }
+    const scoreRange = MAX_SCORE - qualityThreshold;
+    // threshold == MAX_SCORE ⇒ no score can pay (division by zero guard).
+    if (scoreRange === 0) {
+        return { payment: 0n, fee: 0n, remainder: escrowLamports };
+    }
+    const scoreAbove = BigInt(compositeScore - qualityThreshold);
+    const gross = (escrowLamports * scoreAbove) / BigInt(scoreRange);
+    const fee = (gross * BigInt(protocolFeeBps)) / 10000n;
+    const payment = gross - fee;
+    const remainder = escrowLamports - payment - fee;
+    // Postcondition mirrors the program: payment + fee ≤ escrow.
+    if (payment + fee > escrowLamports) {
+        throw new Error("payment + fee exceeds escrow");
+    }
+    return { payment, fee, remainder };
+}
+/** Challenge bond = multiplier × escrow, bounded [2, 10] like the program. */
+export function computeChallengeBond(escrowLamports, multiplier) {
+    if (multiplier < 2 || multiplier > 10) {
+        throw new Error(`bond multiplier ${multiplier} out of [2, 10]`);
+    }
+    return escrowLamports * BigInt(multiplier);
+}
+/** Treasury/agent split of a slashed bond, mirror of `resolve_challenge.rs::slash_bond`. */
+export function splitSlashedBond(bond, bondSlashTreasuryBps) {
+    const treasuryShare = (bond * BigInt(bondSlashTreasuryBps)) / 10000n;
+    return { treasuryShare, agentShare: bond - treasuryShare };
+}
+/**
+ * The canonical payout derivation. Given a task scenario (its escrow, score,
+ * verification kind, and the terminal PATH it took), returns the exact
+ * escrow+bond distribution the on-chain program produces. Conserves value:
+ * escrow + bond is fully redistributed (asserted before return).
+ */
+export function deriveTaskOutcome(s) {
+    // Kind-1 (attested) enforces a binary score on-chain — surface a drift early.
+    if (s.verificationKind === 1 &&
+        s.compositeScore !== 0 &&
+        s.compositeScore !== MAX_SCORE) {
+        throw new Error(`attested (kind 1) score must be 0 or MAX_SCORE, got ${s.compositeScore}`);
+    }
+    const { payment, fee, remainder } = computePayment(s.compositeScore, s.qualityThreshold, s.escrowLamports, s.protocolFeeBps);
+    const bond = computeChallengeBond(s.escrowLamports, s.challengeBondMultiplier);
+    const payout = build(s.outcome, {
+        escrow: s.escrowLamports,
+        bond,
+        payment,
+        fee,
+        remainder,
+        bondSlashTreasuryBps: s.bondSlashTreasuryBps,
+    });
+    assertConserves(s.outcome, payout, s.escrowLamports, bond);
+    return payout;
+}
+function build(kind, p) {
+    switch (kind) {
+        case TaskOutcomeKind.Finalized:
+            return {
+                kind,
+                agentLamports: p.payment,
+                treasuryLamports: p.fee,
+                clientLamports: p.remainder,
+                challengerLamports: 0n,
+            };
+        case TaskOutcomeKind.ResolvedAgentWins: {
+            const { treasuryShare, agentShare } = splitSlashedBond(p.bond, p.bondSlashTreasuryBps);
+            return {
+                kind,
+                agentLamports: p.payment + agentShare,
+                treasuryLamports: p.fee + treasuryShare,
+                clientLamports: p.remainder,
+                challengerLamports: 0n,
+            };
+        }
+        case TaskOutcomeKind.ResolvedChallengerWins:
+            return {
+                kind,
+                agentLamports: 0n,
+                treasuryLamports: 0n,
+                clientLamports: p.escrow,
+                challengerLamports: p.bond,
+            };
+        case TaskOutcomeKind.DefaultResolved:
+            return {
+                kind,
+                agentLamports: p.payment,
+                treasuryLamports: p.fee,
+                clientLamports: p.remainder,
+                challengerLamports: p.bond,
+            };
+        case TaskOutcomeKind.Expired:
+            return {
+                kind,
+                agentLamports: 0n,
+                treasuryLamports: 0n,
+                clientLamports: p.escrow,
+                challengerLamports: 0n,
+            };
+        default:
+            throw new Error(`unknown TaskOutcomeKind ${kind}`);
+    }
+}
+/** Every path redistributes exactly (escrow) or (escrow + bond) of value. */
+function assertConserves(kind, o, escrow, bond) {
+    const total = o.agentLamports +
+        o.treasuryLamports +
+        o.clientLamports +
+        o.challengerLamports;
+    // A challenge occurred (bond posted) in every kind except Finalized/Expired.
+    const bondInPlay = kind === TaskOutcomeKind.ResolvedAgentWins ||
+        kind === TaskOutcomeKind.ResolvedChallengerWins ||
+        kind === TaskOutcomeKind.DefaultResolved;
+    const expected = bondInPlay ? escrow + bond : escrow;
+    if (total !== expected) {
+        throw new Error(`payout conservation broken for ${TaskOutcomeKind[kind]}: ${total} != ${expected}`);
+    }
+}

package/dist/shillbot/switchboard.d.ts

@@ -0,0 +1,27 @@
+import { Connection, PublicKey, TransactionInstruction, VersionedTransaction } from "@solana/web3.js";
+import { type Network } from "./index.js";
+export type SecpSignature = {
+    ethAddress: Uint8Array;
+    signature: Uint8Array;
+    message: Uint8Array;
+    recoveryId: number;
+    oracleIdx: number;
+};
+/** Build Solana's compact multi-signature secp256k1 verification instruction. */
+export declare function buildSecp256k1Instruction(signatures: readonly SecpSignature[], instructionIndex: number): TransactionInstruction;
+export interface SwitchboardVerifyRequest {
+    connection: Connection;
+    taskId: string;
+    payer: PublicKey;
+    taskPda: PublicKey;
+    feed: PublicKey;
+    compositeScore: bigint;
+    verificationHash: Uint8Array;
+    network: Network;
+}
+/**
+ * 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 declare function buildSwitchboardCrankAndVerify(request: SwitchboardVerifyRequest): Promise<VersionedTransaction>;