@useaccord/sdk 0.1.0

package/dist/methods/mst.d.ts

@@ -0,0 +1,100 @@
+/**
+ * mst.ts — subtree-sum stake accumulator builder (ADR-0012).
+ *
+ * Replaces the ADR-0009 cumulative-from-left snapshot MST. The on-chain
+ * program maintains only the root (`Subaccord.root_hash` + `total_stake`);
+ * the full tree lives off-chain (indexers). This module is the byte-exact
+ * reference the chain verifies against:
+ *
+ *   leaf = H(juror[32] ‖ stake_le[8])
+ *   node = H(left_hash[32] ‖ left_sum_le[8] ‖ right_hash[32] ‖ right_sum_le[8])
+ *   node.sum = left_sum + right_sum
+ *
+ * Sums are bound into node hashes, so stake-weighted ranges are
+ * cryptographically authenticated (CONCEPT-REVIEW Bad 5, fixed by
+ * construction). A one-leaf change touches only that leaf's ancestors →
+ * O(log N) updates via {@link proofFor}.
+ *
+ * Sortition uses the cumulative-from-left prefix (sum of left-sibling subtree
+ * sums on right-branch levels), reconstructed from the authenticated path:
+ * the selected leaf's range is `[prefix, prefix + stake)`.
+ *
+ * Sources of truth:
+ *   - on-chain helpers: programs/accord/src/lib.rs (mst_leaf_hash, mst_node_hash,
+ *     empty_tree_root, verify_and_recompute, verify_membership_and_prefix)
+ *   - state: LeafClaim / MSTNode in programs/accord/src/state.rs
+ *
+ * @see ADR-0012
+ */
+/** A subtree-sum proof element: the sibling subtree's hash + total stake. */
+export interface MSTNode {
+    siblingHash: Uint8Array;
+    siblingSum: bigint;
+}
+/** A leaf of the accumulator: `(juror, stake)`. */
+export interface LeafClaim {
+    juror: Uint8Array;
+    stake: bigint;
+}
+/**
+ * Internal cache of all hash/sum levels. `levels[0]` = leaf hashes,
+ * `levels[d]` = root. Stored so `proofFor` is O(log N) instead of O(N).
+ */
+interface LevelCache {
+    hashes: Uint8Array[][];
+    sums: bigint[][];
+}
+/** A built accumulator: leaves + the canonical root. */
+export interface MerkleAccumulator {
+    /** Fixed tree depth (bounds the pool at 2^depth). */
+    depth: number;
+    /** Index → leaf. Empty slots hold the all-zero leaf `(default, 0)`. */
+    leaves: LeafClaim[];
+    rootHash: Uint8Array;
+    rootSum: bigint;
+    /** Opaque cache — don't inspect; use {@link proofFor}. */
+    _levels?: LevelCache;
+}
+/** Maximum depth the SDK accepts. The on-chain program allows up to 31, but
+ * `buildAccumulator` hashes `2^depth` leaves — impractical beyond 20 in a
+ * browser. Deeper pools should use a dedicated indexer for proofs. */
+export declare const MAX_SDK_DEPTH = 20;
+/** Leaf hash `H(juror ‖ stake_le)` (lib.rs mst_leaf_hash). */
+export declare function leafHash(juror: Uint8Array, stake: bigint): Promise<Uint8Array>;
+/** Root hash of an all-zero tree at `depth` (lib.rs empty_tree_root). */
+export declare function emptyRoot(depth: number): Promise<Uint8Array>;
+/**
+ * Build a depth-`depth` accumulator from `leaves` (index = position), padding
+ * the remaining `2^depth` slots with zero leaves. Returns the canonical root
+ * the on-chain program would hold after these stakes (the audit property: an
+ * off-chain rebuild from `JurorStake` via `getProgramAccounts` reproduces it).
+ *
+ * Caches all intermediate hash levels so {@link proofFor} is O(log N).
+ */
+export declare function buildAccumulator(leaves: LeafClaim[], depth: number): Promise<MerkleAccumulator>;
+/**
+ * The client-supplied Merkle path for `index` (sibling hash + sum per level,
+ * leaf → root). Used by `stake`/`requestWithdraw`/`reconcileStake`
+ * (verify-and-recompute) and by `draw_seat` (membership + sortition prefix).
+ *
+ * O(log N) — reads siblings from the cached levels built by
+ * {@link buildAccumulator}. Falls back to O(N) rehash if the cache is absent
+ * (e.g. the accumulator was constructed by hand without `_levels`).
+ */
+export declare function proofFor(tree: MerkleAccumulator, index: number): Promise<MSTNode[]>;
+/** Reconstruct the path root from a leaf (for off-chain audit / debugging). */
+export declare function recomputeRoot(leaf: LeafClaim, index: number, path: MSTNode[]): Promise<{
+    hash: Uint8Array;
+    sum: bigint;
+}>;
+/**
+ * Verify `leaf` at `index` authenticates against `(rootHash, rootSum)` and
+ * return the cumulative-from-left prefix (lib.rs verify_membership_and_prefix).
+ * The leaf's sortition range is `[prefix, prefix + stake)`.
+ */
+export declare function verifyMembership(leaf: LeafClaim, index: number, path: MSTNode[], rootHash: Uint8Array, rootSum: bigint): Promise<{
+    ok: boolean;
+    prefix: bigint;
+}>;
+export {};
+//# sourceMappingURL=mst.d.ts.map

package/dist/methods/mst.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mst.d.ts","sourceRoot":"","sources":["../../src/methods/mst.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAOH,6EAA6E;AAC7E,MAAM,WAAW,OAAO;IACtB,WAAW,EAAE,UAAU,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,mDAAmD;AACnD,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,UAAU,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,UAAU,UAAU;IAClB,MAAM,EAAE,UAAU,EAAE,EAAE,CAAC;IACvB,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC;CAClB;AAED,wDAAwD;AACxD,MAAM,WAAW,iBAAiB;IAChC,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAC;IACd,uEAAuE;IACvE,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,QAAQ,EAAE,UAAU,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,OAAO,CAAC,EAAE,UAAU,CAAC;CACtB;AAED;;sEAEsE;AACtE,eAAO,MAAM,aAAa,KAAK,CAAC;AAwBhC,8DAA8D;AAC9D,wBAAsB,QAAQ,CAC5B,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,UAAU,CAAC,CAGrB;AAYD,yEAAyE;AACzE,wBAAsB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAMlE;AAMD;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,SAAS,EAAE,EACnB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,iBAAiB,CAAC,CAgD5B;AAMD;;;;;;;;GAQG;AACH,wBAAsB,QAAQ,CAC5B,IAAI,EAAE,iBAAiB,EACvB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,OAAO,EAAE,CAAC,CA4CpB;AAED,+EAA+E;AAC/E,wBAAsB,aAAa,CACjC,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,OAAO,EAAE,GACd,OAAO,CAAC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAe5C;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,OAAO,EAAE,EACf,QAAQ,EAAE,UAAU,EACpB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAY1C"}

package/dist/methods/settlement.d.ts

@@ -0,0 +1,69 @@
+/**
+ * settlement.ts — per-round settlement crank + dispute cancellation.
+ *
+ * `settle_round` is the permissionless per-round crank that settles a single
+ * round's economics (slashing incoherent jurors + redistributing the pool) once
+ * revealed. `cancel_dispute` refunds the filer's fee when a round fails to
+ * reach a ruling within its timeout window — a permissionless timeout exit.
+ *
+ * Same ADR-0010 facade pattern: pure orchestration over a typed
+ * {@link AccordSettlementClient} seam; Kit type-only; `remainingAccounts`
+ * carry the JurorStake / Round / AppealBond PDAs the handlers mutate.
+ *
+ * Sources of truth:
+ *   - settle_round:  programs/accord/src/lib.rs (1291)
+ *   - cancel_dispute: programs/accord/src/lib.rs (1539)
+ */
+import type { Address, Instruction } from "@solana/kit";
+/** Accounts for `settle_round`. */
+export interface SettleRoundAccounts {
+    /** Any caller (permissionless crank). Signer. */
+    caller: Address;
+    subaccord: Address;
+    dispute: Address;
+    round: Address;
+}
+/** Accounts for `cancel_dispute`. */
+export interface CancelDisputeAccounts {
+    /** Any caller (permissionless crank). Signer. */
+    caller: Address;
+    subaccord: Address;
+    dispute: Address;
+    feeToken: Address;
+    /** Filer's ATA — refund destination (owner checked on-chain). */
+    filerTokenAccount: Address;
+    feeVault: Address;
+}
+/**
+ * Seam to the Codama-generated Kit client (ADR-0010). Foundation wires the
+ * concrete adapter; settlement.ts stays orchestration-only.
+ */
+export interface AccordSettlementClient {
+    buildSettleRound(input: {
+        programId: Address;
+        accounts: SettleRoundAccounts;
+        roundIdx: number;
+        /** remaining_accounts: drawn JurorStake PDAs the crank mutates. */
+        remainingAccounts: Address[];
+    }): Instruction;
+    buildCancelDispute(input: {
+        programId: Address;
+        accounts: CancelDisputeAccounts;
+        /** remaining_accounts: Round + JurorStake + AppealBond PDAs. */
+        remainingAccounts: Address[];
+    }): Instruction;
+}
+/**
+ * Build the permissionless `settle_round` crank (lib.rs:1291). Settles one
+ * round's economics after reveal — slashing incoherent jurors, redistributing
+ * the pool. `roundIdx` selects the round; `remainingAccounts` are the drawn
+ * JurorStake PDAs for that round (writable, mutated for slashes/rewards).
+ */
+export declare function settleRound(client: AccordSettlementClient, programId: Address, accounts: SettleRoundAccounts, roundIdx: number, remainingAccounts: Address[]): Instruction;
+/**
+ * Build the permissionless `cancel_dispute` crank (lib.rs:1539). Refunds the
+ * filer's fee when a round times out without a ruling. `remainingAccounts`
+ * carries the Round + JurorStake + AppealBond PDAs the handler closes/refunds.
+ */
+export declare function cancelDispute(client: AccordSettlementClient, programId: Address, accounts: CancelDisputeAccounts, remainingAccounts: Address[]): Instruction;
+//# sourceMappingURL=settlement.d.ts.map

package/dist/methods/settlement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settlement.d.ts","sourceRoot":"","sources":["../../src/methods/settlement.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAExD,mCAAmC;AACnC,MAAM,WAAW,mBAAmB;IAClC,iDAAiD;IACjD,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,qCAAqC;AACrC,MAAM,WAAW,qBAAqB;IACpC,iDAAiD;IACjD,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,iEAAiE;IACjE,iBAAiB,EAAE,OAAO,CAAC;IAC3B,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACrC,gBAAgB,CAAC,KAAK,EAAE;QACtB,SAAS,EAAE,OAAO,CAAC;QACnB,QAAQ,EAAE,mBAAmB,CAAC;QAC9B,QAAQ,EAAE,MAAM,CAAC;QACjB,mEAAmE;QACnE,iBAAiB,EAAE,OAAO,EAAE,CAAC;KAC9B,GAAG,WAAW,CAAC;IAChB,kBAAkB,CAAC,KAAK,EAAE;QACxB,SAAS,EAAE,OAAO,CAAC;QACnB,QAAQ,EAAE,qBAAqB,CAAC;QAChC,gEAAgE;QAChE,iBAAiB,EAAE,OAAO,EAAE,CAAC;KAC9B,GAAG,WAAW,CAAC;CACjB;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,sBAAsB,EAC9B,SAAS,EAAE,OAAO,EAClB,QAAQ,EAAE,mBAAmB,EAC7B,QAAQ,EAAE,MAAM,EAChB,iBAAiB,EAAE,OAAO,EAAE,GAC3B,WAAW,CAUb;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,sBAAsB,EAC9B,SAAS,EAAE,OAAO,EAClB,QAAQ,EAAE,qBAAqB,EAC/B,iBAAiB,EAAE,OAAO,EAAE,GAC3B,WAAW,CAMb"}

package/dist/methods/stakeFlow.d.ts

@@ -0,0 +1,65 @@
+/**
+ * stakeFlow.ts — MST accumulator proof orchestration for stake / unstake.
+ *
+ * This is the domain logic the `/juror/stake` route executes after fetching
+ * a Subaccord + all its JurorStake accounts:
+ *
+ *   1. Sort JurorStake leaves by `treeIndex` (canonical append-only order).
+ *   2. Build `LeafClaim[]` at each juror's canonical position.
+ *   3. `buildAccumulator(leafClaims, depth)` — rebuild the canonical tree.
+ *   4. Verify `accumulator.rootHash === subaccord.rootHash` — a mismatch
+ *      means the local data is stale (race with a concurrent stake/unstake).
+ *   5. Determine the juror's leaf index:
+ *        - Existing staker → their assigned `treeIndex`.
+ *        - New staker → `subaccord.nextIndex` (the next free leaf).
+ *   6. `proofFor(accumulator, index)` — the Merkle path passed to `stake` /
+ *      `requestWithdraw` / `reconcileStake`.
+ *
+ * Pure — no chain access. Takes already-fetched typed data so it's testable
+ * without a validator.
+ *
+ * Sources of truth:
+ *   - on-chain stake/requestWithdraw: programs/accord/src/lib.rs
+ *   - accumulator builder: ./mst.ts (ADR-0012)
+ *   - e2e flow reference: tests/src/staking.spec.ts (TreeTracker)
+ */
+import { type Address } from "@solana/kit";
+import { type MerkleAccumulator, type MSTNode } from "./mst.js";
+/** The Subaccord fields the proof builder needs. */
+export interface SubaccordAccumulatorView {
+    /** On-chain accumulator root (state.rs `root_hash`). */
+    rootHash: Uint8Array;
+    /** Next free leaf index (state.rs `next_index`). */
+    nextIndex: number;
+    /** Fixed tree depth (state.rs `depth`). */
+    depth: number;
+}
+/** A JurorStake leaf needed for the accumulator. */
+export interface JurorStakeLeaf {
+    juror: Address;
+    /** Canonical collateral (`staked`, not `staked + stakeDelta`). */
+    staked: bigint;
+    /** Leaf position assigned at first stake (state.rs `tree_index`). */
+    treeIndex: number;
+}
+/** Result of proof computation for stake / unstake. */
+export interface StakeProofResult {
+    /** The Merkle path to pass to `stake` / `requestWithdraw` / `reconcileStake`. */
+    path: MSTNode[];
+    /** The leaf index the proof authenticates. */
+    index: number;
+    /** The root-verified accumulator (for audit / sortition prefix). */
+    accumulator: MerkleAccumulator;
+    /** `true` if this juror has never staked (proof for `nextIndex`). */
+    isNewStaker: boolean;
+}
+/**
+ * Build the MST accumulator proof for a stake or unstake operation.
+ *
+ * @param subaccord    The on-chain accumulator state (rootHash, nextIndex, depth).
+ * @param jurorStakes  All JurorStake accounts for this Subaccord (any order).
+ * @param juror        The staking juror's address.
+ * @throws if the rebuilt root does not match the on-chain root (stale data).
+ */
+export declare function prepareStakeProof(subaccord: SubaccordAccumulatorView, jurorStakes: readonly JurorStakeLeaf[], juror: Address): Promise<StakeProofResult>;
+//# sourceMappingURL=stakeFlow.d.ts.map

package/dist/methods/stakeFlow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stakeFlow.d.ts","sourceRoot":"","sources":["../../src/methods/stakeFlow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAqB,KAAK,OAAO,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,EAIL,KAAK,iBAAiB,EACtB,KAAK,OAAO,EACb,MAAM,UAAU,CAAC;AAElB,oDAAoD;AACpD,MAAM,WAAW,wBAAwB;IACvC,wDAAwD;IACxD,QAAQ,EAAE,UAAU,CAAC;IACrB,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAC;IAClB,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAC;CACf;AAED,oDAAoD;AACpD,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,OAAO,CAAC;IACf,kEAAkE;IAClE,MAAM,EAAE,MAAM,CAAC;IACf,qEAAqE;IACrE,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,uDAAuD;AACvD,MAAM,WAAW,gBAAgB;IAC/B,iFAAiF;IACjF,IAAI,EAAE,OAAO,EAAE,CAAC;IAChB,8CAA8C;IAC9C,KAAK,EAAE,MAAM,CAAC;IACd,oEAAoE;IACpE,WAAW,EAAE,iBAAiB,CAAC;IAC/B,qEAAqE;IACrE,WAAW,EAAE,OAAO,CAAC;CACtB;AAOD;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,wBAAwB,EACnC,WAAW,EAAE,SAAS,cAAc,EAAE,EACtC,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,gBAAgB,CAAC,CA+C3B"}

package/dist/methods/staking.d.ts

@@ -0,0 +1,220 @@
+/**
+ * staking.ts — Juror capital stake / unstake + the `active_draws` guard.
+ *
+ * `unstake` is blocked on-chain while a juror is drawn into any open dispute
+ * (`JurorStake.active_draws > 0` → `StakeLocked`, lib.rs:272) — stake is frozen
+ * until every drawn dispute settles (ADR-0003). The facade surfaces this as a
+ * typed pre-check ({@link canUnstake} / {@link assertCanUnstake}) so a client
+ * rejects the unstake BEFORE building or sending the transaction (matches the
+ * on-chain error; test-matrix row 4).
+ *
+ * `stake` SPL-transfers `amount` of the Subaccord's staking token from the
+ * juror's ATA into the Subaccord PDA's vault ATA (lazily created on first
+ * stake). Reverts while the circuit breaker is paused (ADR-0007).
+ *
+ * Same ADR-0010 facade pattern: pure orchestration over a typed
+ * {@link AccordStakingClient} seam; Kit type-only; PDA lazy.
+ *
+ * Sources of truth:
+ *   - stake / unstake handlers: programs/accord/src/lib.rs (206-324)
+ *   - Stake / Unstake accounts: programs/accord/src/lib.rs (1716-1798)
+ *   - JurorStake struct + seeds: programs/accord/src/state.rs (60-70)
+ */
+import { type Address, type Instruction } from "@solana/kit";
+import type { MSTNode } from "./mst.js";
+/** The decoded JurorStake fields the guard + caller need. */
+export interface JurorStakeView {
+    juror: Address;
+    /** Collateral (stake_token, ADR-0020). */
+    staked: bigint;
+    /** Aggregate earned fees (fee_token, ADR-0020). Withdrawable via `withdrawFees`. */
+    feesEarned: bigint;
+    /** Disputes this juror is currently drawn into; >0 blocks unstake. */
+    activeDraws: number;
+}
+/**
+ * Typed unstake guard result. `ok === false` ⇒ do not build the tx; the
+ * `reason` matches the on-chain error class (StakeLocked / InvalidAmount /
+ * InsufficientBalance).
+ */
+export interface UnstakeGuard {
+    ok: boolean;
+    reason?: "StakeLocked" | "InvalidAmount" | "InsufficientBalance";
+}
+/**
+ * Pre-flight the `unstake` against the juror's live stake. Mirrors the three
+ * on-chain requires (lib.rs:270-277): `amount > 0`, `active_draws == 0`,
+ * `amount ≤ staked`. Pure — no chain access.
+ */
+export declare function canUnstake(stake: JurorStakeView, amount: bigint): UnstakeGuard;
+/** Throw a typed `Error` if the unstake would revert on-chain. */
+export declare function assertCanUnstake(stake: JurorStakeView, amount: bigint): void;
+/** Validate a stake/unstake `amount` is a positive u64 (lib.rs:208 / 270). */
+export declare function assertValidAmount(amount: bigint): void;
+/** JurorStake PDA seeds (state.rs:1732): `["stake", subaccord, juror]`. */
+export declare function jurorStakeSeeds(subaccordBytes: Uint8Array, jurorBytes: Uint8Array): Uint8Array[];
+/** Derive the canonical JurorStake PDA. */
+export declare function findJurorStakePda(programAddress: Address, subaccord: Address, juror: Address): Promise<{
+    address: Address;
+    bump: number;
+}>;
+/** Accounts shared by `stake` / `unstake` (the juror signs). */
+export interface StakingAccounts {
+    juror: Address;
+    subaccord: Address;
+    /** `stake` only — the ADR-0007 circuit breaker (unstake is never halted). */
+    accordState?: Address;
+    jurorStake: Address;
+    stakingToken: Address;
+    /** Juror's ATA of the staking token (source on stake, dest on unstake). */
+    jurorTokenAccount: Address;
+    /** Subaccord PDA's stake_vault ATA (dest on stake, source on unstake). */
+    stakeVault: Address;
+}
+/**
+ * Seam to the Codama-generated Kit client + JurorStake fetcher. Foundation
+ * wires the concrete adapter; staking.ts stays orchestration-only.
+ *
+ * ADR-0012: `stake`/`unstake` take a client-supplied accumulator `path`
+ * (sibling hash + sum per level). The chain verifies it against the stored
+ * root and recomputes a new canonical root — O(log N). A wrong path reverts;
+ * build it via `proofFor(tree, jurorIndex)` from `./mst.js`.
+ */
+export interface AccordStakingClient {
+    buildStake(input: {
+        programId: Address;
+        accounts: StakingAccounts;
+        amount: bigint;
+        path: MSTNode[];
+        attestation?: Address;
+    }): Instruction;
+    buildRequestWithdraw(input: {
+        programId: Address;
+        accounts: StakingAccounts;
+        amount: bigint;
+        path: MSTNode[];
+    }): Instruction;
+    buildWithdraw(input: {
+        programId: Address;
+        accounts: StakingAccounts;
+    }): Instruction;
+    buildReconcileStake(input: {
+        programId: Address;
+        accounts: StakingAccounts;
+        path: MSTNode[];
+    }): Instruction;
+    buildReclaimSlot(input: {
+        programId: Address;
+        accounts: {
+            subaccord: Address;
+            jurorStake: Address;
+        };
+        path: MSTNode[];
+    }): Instruction;
+    /** Fetch the decoded JurorStake fields the guard needs. */
+    fetchJurorStake(jurorStake: Address): Promise<JurorStakeView | null>;
+    /** Build `withdraw_fees` (ADR-0020). */
+    buildWithdrawFees(input: {
+        programId: Address;
+        accounts: WithdrawFeesAccounts;
+    }): Instruction;
+    /**
+     * Build `prune_juror` (PROG-ATTESTATION) — permissionless crank that evicts
+     * an expired juror's stake from a credential-gated Subaccord. The cranker
+     * signs; the expired `juror` does not. `attestation` is appended as
+     * `remaining_accounts[0]` (read-only).
+     */
+    buildPruneJuror(input: {
+        programId: Address;
+        accounts: PruneJurorAccounts;
+        path: MSTNode[];
+        attestation: Address;
+    }): Instruction;
+}
+/** Build `stake` (lib.rs). SPL-transfers `amount` into the vault.
+ * RECLAIM-LEAF: when `freedSlotAccount` is provided, the stake pops from the
+ * free list (the freed JurorStake is appended as a remaining account). */
+export declare function stake(client: AccordStakingClient, programId: Address, accounts: StakingAccounts, amount: bigint, path: MSTNode[], 
+/** PROG-ATTESTATION: juror SAS attestation (required on credential-gated Subaccords). */
+attestation?: Address, 
+/** RECLAIM-LEAF: freed JurorStake PDA to pop from the free list when staking into a recycled slot. */
+freedSlotAccount?: Address): Instruction;
+/**
+ * Build `request_withdraw` (lib.rs) — phase 1 of the two-phase withdraw
+ * (REVIEW #5). Ledger-only: subtracts `amount` from `JurorStake.amount`, banks
+ * it in `pending_withdrawal`, and recomputes the accumulator root. No tokens
+ * move; no `active_draws` gate (the lock is enforced at `withdraw`). Allowed
+ * while paused. `path` is the juror's accumulator proof (ADR-0012).
+ *
+ * Precondition: `settlementDelta == 0` — call `reconcileStake` first when the
+ * juror has a pending reward/slash. DRY with `reconcileStake` (the delta fold
+ * lives in one place); withdraw only ever reads the canonical `amount`.
+ */
+export declare function requestWithdraw(client: AccordStakingClient, programId: Address, accounts: StakingAccounts, amount: bigint, path: MSTNode[]): Instruction;
+/**
+ * Build `withdraw` (lib.rs:407) — phase 2 of the two-phase withdraw. Moves the
+ * banked `pending_withdrawal` from the vault to the juror's ATA. On-chain gates:
+ * `WITHDRAWAL_DELAY` elapsed since `request_withdraw` AND `active_draws == 0`.
+ * No args — reads `pending_withdrawal` from `JurorStake`.
+ */
+export declare function withdraw(client: AccordStakingClient, programId: Address, accounts: StakingAccounts): Instruction;
+/**
+ * Build `reconcile_stake` (lib.rs:460) — permissionless crank (REVIEW #4) that
+ * folds a juror's `settlement_delta` into their canonical `amount` and updates
+ * the accumulator root via a Merkle proof. After reconcile, the ledger and the
+ * accumulator agree again. No tokens move; any caller may trigger it. `path` is
+ * the juror's accumulator proof (ADR-0012).
+ */
+export declare function reconcileStake(client: AccordStakingClient, programId: Address, accounts: StakingAccounts, path: MSTNode[]): Instruction;
+/**
+ * Build `reclaim_slot` (RECLAIM-LEAF) — permissionless crank that pushes a
+ * fully-drained JurorStake's `tree_index` onto the free list, blanking the
+ * leaf identity to `(default, 0)`. This recycles the tree slot for reuse by a
+ * new staker. No tokens move; any caller may trigger it. `path` is the juror's
+ * accumulator proof (ADR-0012).
+ *
+ * Preconditions: the juror must be fully drained (`staked == 0`,
+ * `active_draws == 0`, `stake_delta == 0`, `fees_earned == 0`).
+ */
+export declare function reclaimSlot(client: AccordStakingClient, programId: Address, accounts: {
+    subaccord: Address;
+    jurorStake: Address;
+}, path: MSTNode[]): Instruction;
+/** Accounts for `withdraw_fees` (ADR-0020). */
+export interface WithdrawFeesAccounts {
+    juror: Address;
+    subaccord: Address;
+    jurorStake: Address;
+    feeToken: Address;
+    /** Juror's ATA of the fee token (withdraw destination). */
+    jurorFeeTokenAccount: Address;
+    /** Subaccord PDA's fee_vault ATA (withdraw source). */
+    feeVault: Address;
+}
+/**
+ * Accounts for `prune_juror` (PROG-ATTESTATION). `caller` is the cranker
+ * (signer = the adapter's wallet); `juror` is the EXPIRED juror being pruned
+ * (NOT a signer — read-only on chain). Mirrors the on-chain `PruneJuror` struct
+ * (lib.rs).
+ */
+export interface PruneJurorAccounts {
+    caller: Address;
+    juror: Address;
+    subaccord: Address;
+    jurorStake: Address;
+}
+/**
+ * Build `withdraw_fees` (ADR-0020). Per-juror: pulls aggregate `fees_earned`
+ * from the Subaccord's `fee_vault` → the juror's `fee_token` ATA. No
+ * `active_draws` gate, no timelock — earned fees are not at-risk capital.
+ */
+export declare function withdrawFees(client: AccordStakingClient, programId: Address, accounts: WithdrawFeesAccounts): Instruction;
+/**
+ * Build `prune_juror` (PROG-ATTESTATION) — permissionless crank. Evicts an
+ * expired juror's `JurorStake` from a credential-gated Subaccord and recomputes
+ * the accumulator root via `path`. The cranker (`caller`) signs; the expired
+ * `juror` does NOT. `attestation` is the expired juror's SAS attestation,
+ * passed as `remaining_accounts[0]` (read-only) so the handler can revoke it.
+ */
+export declare function pruneJuror(client: AccordStakingClient, programId: Address, accounts: PruneJurorAccounts, path: MSTNode[], attestation: Address): Instruction;
+//# sourceMappingURL=staking.d.ts.map

package/dist/methods/staking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staking.d.ts","sourceRoot":"","sources":["../../src/methods/staking.ts"],"names":[],"mappings":"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"}