@useaccord/sdk 0.1.0

package/dist/methods/appeal.d.ts

@@ -0,0 +1,131 @@
+/**
+ * appeal.ts — dispute appeal + bond refund (ADR-0004).
+ *
+ * `appeal` is permissionless: any appellant pays the new (larger) round's fee
+ * plus an equal bond, opening round `current_round + 1` with a `2N+1` panel
+ * and resetting the dispute to `Created` so snapshot→draw→vote reruns. The
+ * bond is custodied in a per-appeal `AppealBond` PDA keyed by the round it
+ * opened.
+ *
+ * `claim_appeal_refund` returns a FLIPPED bond to its appellant after
+ * `finalize_dispute` (no-flip bonds are folded into the coherent pool there).
+ * Idempotent: zeroing the bond on payout makes re-invocation a no-op.
+ *
+ * Client-side helpers mirror the on-chain appeal ladder (`panel_size_for_round`,
+ * lib.rs:2555) and cost math so the facade can quote a panel + fee before
+ * sending. Same ADR-0010 facade pattern: Kit type-only, PDA lazy.
+ *
+ * Sources of truth:
+ *   - appeal / claim_appeal_refund: lib.rs:1643 (appeal), :1772 (claim_appeal_refund)
+ *   - Appeal / ClaimAppealRefund accounts: lib.rs:3422 (Appeal), :3486 (ClaimAppealRefund)
+ *   - AppealBond struct + seeds: state.rs (174-193)  `["bond", dispute, round_idx]`
+ *   - appeal ladder: lib.rs:2553-2570, ADR-0004
+ */
+import { type Address, type Instruction } from "@solana/kit";
+export { MAX_JURORS, DEFAULT_APPEAL_WINDOW_SECS, panelSizeForRound, } from "../constants.js";
+/**
+ * Required panel size for round `roundIdx` — the appeal ladder
+ * `N_{k+1} = 2·N_k + 1` (closed form `(J+1)·2^k − 1`), capped at
+ * {@link MAX_JURORS}. Direct port of `panel_size_for_round` (lib.rs:2555).
+ * Returns `null` on overflow (round_idx ≥ 31).
+ *
+ * Re-exported from {@link ../constants.js} for module-internal use.
+ */
+/** Appeal cost breakdown for opening round `currentRound + 1` (lib.rs:1688-1695). */
+export interface AppealCost {
+    newRound: number;
+    panel: number;
+    /** New-round fee = panel · fee_per_juror. */
+    fee: bigint;
+    /** Bond == new-round fee (forfeited if no flip, returned if flipped). */
+    bond: bigint;
+    /** Appellant pays fee + bond up front. */
+    total: bigint;
+}
+/**
+ * Quote the panel + fee + bond for an appeal from `currentRound`. Mirrors
+ * lib.rs:1688-1695 (`panel_new = panel_size_for_round(J, current+1)`,
+ * `fee_new = panel_new · fee_per_juror`, `bond = fee_new`,
+ * `total = fee_new + bond`). Returns `null` if the panel math overflows.
+ */
+export declare function appealCost(currentRound: number, feePerJuror: bigint, minJurySize?: number): AppealCost | null;
+/** Gate: a fresh appeal requires `currentRound < maxAppeals` (lib.rs:1660). */
+export declare function canAppeal(currentRound: number, maxAppeals: number): boolean;
+/** AppealBond PDA seeds (state.rs:2286): `["bond", dispute, round_idx_le4]`. */
+export declare function appealBondSeeds(disputeBytes: Uint8Array, roundIdx: number): Uint8Array[];
+export declare function findAppealBondPda(programAddress: Address, dispute: Address, roundIdx: number): Promise<{
+    address: Address;
+    bump: number;
+}>;
+/** Accounts for `appeal`. */
+export interface AppealAccounts {
+    /** Any appellant (permissionless). Fee + bond payer. Signer. */
+    appellant: Address;
+    subaccord: Address;
+    accordState: Address;
+    dispute: Address;
+    /** The just-resolved round (`current_round`) — read for `prior_result`. */
+    round: Address;
+    /** AppealBond PDA for the NEW round (`["bond", dispute, current_round+1]`). */
+    appealBond: Address;
+    feeToken: Address;
+    appellantTokenAccount: Address;
+    feeVault: Address;
+}
+/** Accounts for `claim_appeal_refund`. */
+export interface ClaimRefundAccounts {
+    /** Any caller (permissionless crank). Signer. */
+    caller: Address;
+    subaccord: Address;
+    dispute: Address;
+    /** AppealBond PDA for `roundIdx` (the round the appeal opened). */
+    appealBond: Address;
+    feeToken: Address;
+    /** Appellant's ATA — sweep destination (owner checked on-chain). */
+    claimantTokenAccount: Address;
+    feeVault: Address;
+}
+/**
+ * Seam to the Codama-generated Kit client. Foundation wires the concrete
+ * adapter; appeal.ts stays orchestration-only.
+ */
+export interface AccordAppealClient {
+    buildAppeal(input: {
+        programId: Address;
+        accounts: AppealAccounts;
+        newEvidenceHash: Uint8Array;
+    }): Instruction;
+    buildClaimAppealRefund(input: {
+        programId: Address;
+        accounts: ClaimRefundAccounts;
+        roundIdx: number;
+    }): Instruction;
+}
+/**
+ * Validate a per-round evidence commitment is `[u8; 32]` (lib.rs appeal arg).
+ * The `[0u8; 32]` sentinel (no new evidence this round) is a legal value, so
+ * only the length is checked. Mirrors {@link assertValidEvidenceHash} in
+ * dispute.ts but is duplicated here to keep appeal.ts self-contained.
+ */
+export declare function assertValidNewEvidenceHash(newEvidenceHash: Uint8Array): void;
+/**
+ * Build `appeal` (lib.rs:1643). Opens `current_round + 1` with a `2N+1` panel;
+ * the appellant pays `fee_new + bond` (bond == fee_new). The AppealBond PDA is
+ * keyed by the round BEING appealed (`current_round`, pre-increment) — derive it
+ * via {@link findAppealBondPda} with `currentRound`.
+ *
+ * `newEvidenceHash` optionally introduces fresh evidence for the new round
+ * (stored at `evidence_hashes[current_round + 1]`); pass the `[0u8; 32]`
+ * sentinel (milestone accord-qp7c) to carry forward prior rounds' evidence
+ * without adding any.
+ */
+export declare function appeal(client: AccordAppealClient, programId: Address, accounts: AppealAccounts, newEvidenceHash: Uint8Array): Instruction;
+/**
+ * Build `claim_appeal_refund` (lib.rs:1772) for a specific appeal's bond.
+ * `roundIdx` is the round that was appealed (`current_round` at appeal time —
+ * the AppealBond PDA seed, pre-increment), selecting which bond to claim.
+ * Idempotent
+ * on-chain (the bond is zeroed on payout).
+ */
+export declare function claimAppealRefund(client: AccordAppealClient, programId: Address, accounts: ClaimRefundAccounts, roundIdx: number): Instruction;
+//# sourceMappingURL=appeal.d.ts.map

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

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

package/dist/methods/dispute.d.ts

@@ -0,0 +1,177 @@
+/**
+ * dispute.ts — the PRIMARY external surface of @useaccord/sdk.
+ *
+ * Two methods every Arbitrable integrates against:
+ *   - {@link createDispute} — files a Dispute (CPI from an Arbitrable program,
+ *   - {@link getRuling}    — lazy read of a dispute's `final_ruling`
+ *     (u64 with the `u64::MAX` no-ruling sentinel; `null` until the dispute
+ *     reaches `Final` — ADR-0025).
+ *
+ * Per ADR-0010 the SDK is two layers: a Codama-generated Kit client (drift-free
+ * instruction builders + account codecs) and a thin hand-written facade that
+ * owns domain logic. This module is the facade layer for dispute intake; it
+ * stays orchestration-only and consumes the generated client through the
+ * {@link AccordDisputeClient} seam, which the Foundation task wires to a real
+ * adapter. The domain logic that is NOT generated — PDA derivation, fee math,
+ * option validation — lives here and is unit-tested independently of the chain.
+ *
+ * Sources of truth:
+ *   - Instruction + accounts: programs/accord/src/lib.rs (create_dispute, get_ruling)
+ *   - Dispute struct + seeds: programs/accord/src/state.rs (Dispute, SEED_DISPUTE)
+ *   - v1 constants:           programs/accord/src/constants.rs (MAX_OPTIONS)
+ */
+import { type Address, type Instruction } from "@solana/kit";
+import { Aggregation } from "../types.js";
+export { MAX_OPTIONS } from "../constants.js";
+/** Accord program id (declare_id! in programs/accord/src/lib.rs). */
+export declare const ACCORD_PROGRAM_ID: Address;
+/**
+ * A 32-byte option label hash (one row of `Dispute.options`). The Arbitrable
+ * chooses these off-chain; the Accord only stores + tallies them.
+ */
+export type OptionHash = Uint8Array;
+/**
+ * Args for `create_dispute` (lib.rs:254). All amounts in the Subaccord's
+ * staking token.
+ */
+export interface CreateDisputeArgs {
+    /**
+     * Option label hashes, each 32 bytes. `Plurality`: 2..={@link MAX_OPTIONS}
+     * (see {@link assertValidOptions}). `Median` (ADR-0025): file with none —
+     * the vote is a u64 fixed-point scalar, not an index.
+     */
+    options: OptionHash[];
+    /** ADR-0006 on-chain evidence commitment (`[u8; 32]`). */
+    evidenceHash: Uint8Array;
+    /** Filer-chosen nonce → private dispute namespace. Dispute PDA = `["dispute", filer, nonce]`. */
+    nonce: bigint;
+    /** Total fee = `min_jury_size * fee_per_juror` (see {@link requiredFee}). Filer pays in full. */
+    fee: bigint;
+    /**
+     * Aggregation rule of the Subaccord being filed against — gates
+     * {@link CreateDisputeArgs.options} exactly like the on-chain handler
+     * (instructions/create_dispute.rs). Omit for `Plurality` (v1 default).
+     */
+    aggregation?: Aggregation;
+}
+/** Signer + token accounts the filer brings to `create_dispute`. */
+export interface CreateDisputeAccounts {
+    /** The Arbitrable (a program signer via CPI) or any wallet. Fee source + signer. */
+    filer: Address;
+    /**
+     * Data-free rent payer for the dispute `init` + fee_vault `init_if_needed`
+     * (the system program rejects lamport transfers from data-carrying accounts,
+     * so a PDA filer must not pay rent). Wallet filers pass themselves.
+     */
+    rentPayer: Address;
+    /** The Subaccord this dispute is filed against (fee/panel source). */
+    subaccord: Address;
+    /** The Subaccord's staking_token mint (fee currency). */
+    feeToken: Address;
+    /** Filer's ATA of the fee token (fee source). */
+    filerTokenAccount: Address;
+    /** Subaccord PDA's fee_vault ATA (fee sink, ADR-0020). */
+    feeVault: Address;
+    /** Circuit-breaker singleton PDA (`["state"]`); stake/create revert while paused. */
+    accordState: Address;
+}
+/** Result of preparing a `create_dispute`: the derived Dispute PDA + its instruction. */
+export interface CreateDisputeResult {
+    /** The initialized Dispute PDA (`["dispute", filer, nonce]`). */
+    dispute: Address;
+    /** Canonical bump stored on the account (state.rs: Dispute.bump). */
+    bump: number;
+    /** Unsigned instruction; the facade's wallet adapter signs + sends it. */
+    instruction: Instruction;
+}
+/** Minimal decoded view `getRuling` consumes (avoids duplicating the full Dispute shape). */
+export interface DisputeRulingView {
+    /**
+     * Winning value once `state == Final`: the option index for `Plurality`
+     * disputes, the final median (settlement-mint base units) for `Median`
+     * disputes (ADR-0025). `u64::MAX` ({@link NO_RULING}) → `null`.
+     */
+    finalRuling: bigint | null;
+}
+/**
+ * Dispute `final_ruling` no-ruling sentinel — `u64::MAX`. ADR-0025 widened
+ * the ruling from `Option<u8>` to a plain u64 (so `Median` disputes can carry
+ * a scalar verdict); the old `u8::MAX` (255) sentinel is gone. Stored until
+ * `finalize_dispute` writes the real value atomically with `state = Final`
+ * (state.rs: `Dispute::ruling`). Same value as voting's `NO_VOTE`.
+ */
+export declare const NO_RULING = 18446744073709551615n;
+/**
+ * Seam to the Codama-generated Kit client + typed fetcher (ADR-0010). The
+ * Foundation task provides a concrete adapter; dispute.ts stays pure
+ * orchestration over this interface, so it is parallel-safe under fleet
+ * dispatch and compile-verifiable before the generator lands.
+ */
+export interface AccordDisputeClient {
+    /** Build the `create_dispute` instruction (Anchor discriminator + Borsh args). */
+    buildCreateDispute(input: {
+        programId: Address;
+        accounts: CreateDisputeAccounts;
+        args: CreateDisputeArgs;
+        disputePda: Address;
+    }): Instruction;
+    /** Fetch + decode a Dispute account, or `null` if it does not exist yet. */
+    fetchDispute(address: Address): Promise<DisputeRulingView | null>;
+}
+/**
+ * Compute the required `create_dispute` round-1 fee. The panel is the
+ * Subaccord's `min_jury_size` (accord-9q3e; default 3), so the fee is
+ * `min_jury_size · fee_per_juror`. Mirrors lib.rs
+ * (`(sub.min_jury_size as u64).checked_mul(sub.fee_per_juror)`). Returns `null`
+ * on u64 overflow rather than throwing — callers surface a typed error.
+ */
+export declare function requiredFee(feePerJuror: bigint, minJurySize?: number): bigint | null;
+/**
+ * Validate `create_dispute` options against the Subaccord's aggregation rule
+ * (instructions/create_dispute.rs, ADR-0025). `Plurality` (default):
+ * `2..=MAX_OPTIONS` hashes, each `[u8; 32]`. `Median`: none — the vote is a
+ * u64 scalar, not an option index. Throws a typed `Error` on violation.
+ * Pure — no chain access.
+ */
+export declare function assertValidOptions(options: OptionHash[], aggregation?: Aggregation): void;
+/** Validate the evidence commitment is `[u8; 32]` (lib.rs:257 instruction arg). */
+export declare function assertValidEvidenceHash(evidenceHash: Uint8Array): void;
+/** Validate a `nonce` fits in a u64 (lib.rs:258 instruction arg). */
+export declare function assertValidNonce(nonce: bigint): void;
+/**
+ * Build the Dispute PDA seed bytes (state.rs:1872):
+ *   `["dispute", filer.key().as_ref(), &nonce.to_le_bytes()]`.
+ *
+ * `filerBytes` is the filer's 32-byte pubkey encoding (Kit's
+ * `getAddressEncoder().encode(filer)`). Pure + deterministic — the unit-test
+ * entry point; {@link findDisputePda} wraps it with Kit's resolver.
+ */
+export declare function disputeSeeds(filerBytes: Uint8Array, nonce: bigint): Uint8Array[];
+/**
+ * Derive the canonical Dispute PDA (`["dispute", filer, nonce.to_le()]`).
+ */
+export declare function findDisputePda(programAddress: Address, filer: Address, nonce: bigint): Promise<{
+    address: Address;
+    bump: number;
+}>;
+/**
+ * Prepare a `create_dispute`: validate args, derive the Dispute PDA, and build
+ * the instruction via the client seam. The caller (Accord facade) signs + sends
+ * `result.instruction` with its wallet adapter.
+ *
+ * On success the Dispute PDA is `init`-ialized (instructions/create_dispute.rs)
+ * and reads `state == Created`, `final_ruling == u64::MAX` ({@link NO_RULING}).
+ */
+export declare function createDispute(client: AccordDisputeClient, accounts: CreateDisputeAccounts, args: CreateDisputeArgs, programId?: Address): Promise<CreateDisputeResult>;
+/**
+ * Lazily read a dispute's final ruling. Returns the winning value once the
+ * dispute reaches `Final` — the option index for `Plurality` disputes, the
+ * final median in settlement-mint base units for `Median` disputes
+ * (ADR-0025) — or `null` beforehand; on-chain `final_ruling` holds the
+ * `u64::MAX` sentinel ({@link NO_RULING}) until then, and both the adapter
+ * and {@link getRuling} fold it to `null` (matches the on-chain `get_ruling`
+ * CPI entry, lib.rs:480 → `Dispute::ruling()`). Returns `null` if the
+ * Dispute account does not exist yet.
+ */
+export declare function getRuling(client: AccordDisputeClient, dispute: Address): Promise<bigint | null>;
+//# sourceMappingURL=dispute.d.ts.map

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

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

package/dist/methods/disputePhase.d.ts

@@ -0,0 +1,34 @@
+/**
+ * disputePhase.ts — dispute phase label + countdown for the juror dashboard.
+ *
+ * The juror dashboard (`/juror`) shows each active draw's current phase
+ * (Review / Commit / Reveal) with a countdown timer. The phase is derived
+ * from the Dispute's `state` enum + the Round's window deadlines
+ * (`reviewEnd`, `commitEnd`, `revealEnd`).
+ *
+ * Pure — no chain access. Takes already-fetched typed data.
+ */
+import { DisputeState } from "../generated/types/disputeState.js";
+/** The Round window deadlines the phase computation needs. */
+export interface RoundPhaseWindows {
+    reviewEnd: bigint;
+    commitEnd: bigint;
+    revealEnd: bigint;
+}
+/** Human-readable phase + remaining seconds (null = no active countdown). */
+export interface PhaseInfo {
+    phase: string;
+    /** Seconds remaining in the current window. `null` when past the deadline
+     *  or the state has no countdown. Negative = overdue (crank pending). */
+    countdownSecs: bigint | null;
+}
+/**
+ * Derive the juror-facing phase label + countdown for a dispute.
+ *
+ * @param state   The Dispute's `state` field.
+ * @param now     Current Unix timestamp (seconds).
+ * @param round   The current Round's window deadlines (required for
+ *                Review/Commit/Reveal; pass `undefined` if not yet drawn).
+ */
+export declare function disputePhase(state: DisputeState, now: bigint, round?: RoundPhaseWindows): PhaseInfo;
+//# sourceMappingURL=disputePhase.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"disputePhase.d.ts","sourceRoot":"","sources":["../../src/methods/disputePhase.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAElE,8DAA8D;AAC9D,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,6EAA6E;AAC7E,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd;6EACyE;IACzE,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,YAAY,EACnB,GAAG,EAAE,MAAM,EACX,KAAK,CAAC,EAAE,iBAAiB,GACxB,SAAS,CA0CX"}

package/dist/methods/lifecycle.d.ts

@@ -0,0 +1,228 @@
+/**
+ * lifecycle.ts — Subaccord lifecycle + circuit breaker (ADR-0005, ADR-0007).
+ *
+ * Seven instructions:
+ *   - {@link createSubaccord}          permissionless pool creation.
+ *   - {@link proposeSubaccordUpdate}   authority-gated; arms a 48h timelock.
+ *   - {@link executeSubaccordUpdate}   permissionless crank; lands post-timelock.
+ *   - {@link initializePause} / {@link pause} / {@link proposeUnpause} /
+ *     {@link executeUnpause}            the ADR-0007 circuit-breaker quartet.
+ *
+ * Client-side timelock awareness (ADR-0010 §4): `propose_subaccord_update`
+ * writes `execute_after_slot = slot + UPDATE_TIMELOCK_SLOTS` on-chain. The SDK
+ * cannot predict the exact landing slot, so the flow is: propose → read
+ * `execute_after_slot` back from the PendingUpdate account → wait until
+ * `canExecuteAt(executeAfterSlot, currentSlot)` → execute. The same shape backs
+ * the unpause timelock (`UNPAUSE_TIMELOCK_SLOTS`).
+ *
+ * Same ADR-0010 facade pattern as the other method modules: pure orchestration
+ * over a typed {@link AccordLifecycleClient} seam; Kit type-only; PDAs lazy.
+ *
+ * Sources of truth:
+ *   - instructions:  programs/accord/src/lib.rs (146-397, 77-144)
+ *   - accounts/PDAs: programs/accord/src/lib.rs (1693-1845, 1640-1690)
+ *   - constants:     programs/accord/src/constants.rs
+ *   - UpdatePayload: programs/accord/src/state.rs (254-266)
+ */
+import { type Address, type Instruction } from "@solana/kit";
+import type { Aggregation, ShortfallPolicy, UpdatePayload } from "../types.js";
+export { MAX_APPEALS, MAX_DRAW_ATTEMPTS, MAX_JURORS, MIN_APPEAL_WINDOW_SECS, UPDATE_TIMELOCK_SLOTS, UNPAUSE_TIMELOCK_SLOTS, } from "../constants.js";
+export { type ShortfallPolicy, type UpdatePayload } from "../types.js";
+/** Args for `create_subaccord` (lib.rs:146). `domain_ref`/`evidence_spec` immutable. */
+export interface CreateSubaccordArgs {
+    /** Immutable identity hash: the class of dispute this pool adjudicates. ≠ [0;32]. */
+    domainRef: Uint8Array;
+    /** Immutable evidence-format spec hash (ADR-0006). */
+    evidenceSpec: Uint8Array;
+    /** SPL mint juror capital is staked in (collateral, ADR-0002/0020). */
+    stakingToken: Address;
+    /** Compensation mint — fees + appeal bonds (ADR-0020). Distinct from stakingToken. */
+    feeToken: Address;
+    minStake: bigint;
+    /** Slash factor in bps (10% = 1000). */
+    alphaBps: number;
+    reviewWindow: bigint;
+    commitWindow: bigint;
+    revealWindow: bigint;
+    /** Appeal window after a round resolves before finality (ADR-0022). Per-
+     *  Subaccord, frozen onto `CaseTerms` at filing. ≥ {@link MIN_APPEAL_WINDOW_SECS}. */
+    appealWindow: bigint;
+    /** ≤ {@link MAX_APPEALS}; bounds the appeal ladder depth. The round-1 panel
+     *  size is per-Subaccord via {@link CreateSubaccordArgs.minJurySize}
+     *  (accord-9q3e); each appeal doubles+1. */
+    maxAppeals: number;
+    /** Round-1 juror panel size (accord-9q3e). Default 3 ({@link INITIAL_NUM_JURORS});
+     *  must be odd and the appeal ladder `(J+1)·2^maxAppeals − 1` must fit
+     *  {@link MAX_JURORS}. Set 1 + `maxAppeals = 0` for a single-juror pool.
+     *  Immutable on the Subaccord (not in {@link UpdatePayload}). */
+    minJurySize: number;
+    /** Per-Subaccord aggregation rule (ADR-0019). v1 = `Plurality`. */
+    aggregation: Aggregation;
+    feePerJuror: bigint;
+    /**
+     * Reveal-quorum fraction in bps (ADR-0021). A round is authoritative only if
+     * `reveal_count >= ceil(panel × bps / 10_000)`. Default 6_666 (2/3); the
+     * absolute commitment escalates per appeal for free via panel growth.
+     */
+    revealThresholdBps: number;
+    /** Shortfall policy (ADR-0021). v1 = `Redraw` (same-size redraw via `draw_attempt`). */
+    shortfallPolicy: ShortfallPolicy;
+    /**
+     * Same-size redraw cap per round before the dispute fails (ADR-0021).
+     * Orthogonal to {@link CreateSubaccordArgs.maxAppeals} (which bounds rounds).
+     */
+    maxDrawAttempts: number;
+    /**
+     * Coherence tolerance for `Median` pools, in bps of the final median
+     * (ADR-0025): a revealed vote is coherent iff
+     * `|vote − ruling| · 10_000 ≤ ruling · coherence_tol_bps`. `0` = exact
+     * match. Inert for `Plurality`. Immutable on the Subaccord (not in
+     * `UpdatePayload`); frozen onto `CaseTerms` at filing. Docs default 100
+     * (1% band) for `Median` pools; use `0` for `Plurality`-only pools.
+     */
+    coherenceTolBps: number;
+    /** `Pubkey::default()` => immutable Subaccord; else signs propose/execute. */
+    authority: Address;
+    /** ADR-0006 trusted re-encryption service. */
+    evidenceOperator: Address;
+    /**
+     * Fixed accumulator tree depth (ADR-0012). Bounds the juror pool at
+     * `2^depth`; the tree never grows a level during operation. Default 20.
+     */
+    depth: number;
+    /**
+     * PROG-ATTESTTION: optional credential gate. Omit (or set both to the default
+     * pubkey) ⇒ stake-only Subaccord (today's behaviour). Set both ⇒ jurors must
+     * hold a valid SAS attestation to stake/draw. Both-or-neither.
+     */
+    jurorCredential?: Address;
+    jurorSchema?: Address;
+}
+/** Subaccord PDA seeds (state.rs:1697): `["subaccord", creator, domain_ref]`. */
+export declare function subaccordSeeds(creatorBytes: Uint8Array, domainRef: Uint8Array): Uint8Array[];
+/** PendingUpdate PDA seeds (state.rs:1816): `["update", subaccord, nonce_le]`. */
+export declare function pendingUpdateSeeds(subaccordBytes: Uint8Array, nonce: bigint): Uint8Array[];
+/** AccordState PDA seeds (state.rs: `["state"]`). Singleton. */
+export declare function accordStateSeeds(): Uint8Array[];
+/** Validate `max_appeals ≤ MAX_APPEALS` (lib.rs). With a configurable round-1
+ * panel size (accord-9q3e), `maxAppeals` bounds the appeal ladder depth; the
+ * ladder must also fit `MAX_JURORS` — see {@link assertValidMinJurySize}. */
+export declare function assertValidMaxAppeals(maxAppeals: number): void;
+/** Validate `min_jury_size` is odd and the appeal ladder fits `MAX_JURORS`
+ * (lib.rs create_subaccord, accord-9q3e). The ladder top
+ * `(J+1)·2^maxAppeals − 1` must not exceed {@link MAX_JURORS} or panel growth
+ * would be silently truncated by the on-chain `.min()` cap. Throws on violation. */
+export declare function assertValidMinJurySize(minJurySize: number, maxAppeals: number): void;
+/** Validate `appeal_window ≥ MIN_APPEAL_WINDOW_SECS` (lib.rs, ADR-0022). A pool
+ * that wants no appeals sets `max_appeals == 0`; a 0 window is rejected. */
+export declare function assertValidAppealWindow(appealWindow: bigint): void;
+/** Validate `reveal_threshold_bps ≤ 10_000` (lib.rs, ADR-0021). */
+export declare function assertValidRevealThreshold(revealThresholdBps: number): void;
+/** Validate `1 ≤ max_draw_attempts ≤ MAX_DRAW_ATTEMPTS` (lib.rs, ADR-0021). */
+export declare function assertValidMaxDrawAttempts(maxDrawAttempts: number): void;
+/** Validate `coherence_tol_bps ≤ 10_000` (lib.rs create_subaccord, ADR-0025).
+ * Mirrors the on-chain `InvalidThreshold` gate — same bound as
+ * {@link assertValidRevealThreshold}. */
+export declare function assertValidCoherenceTol(coherenceTolBps: number): void;
+/** Reject the degenerate zero domain_ref (lib.rs:164 namespace squat guard). */
+export declare function assertValidRiskType(domainRef: Uint8Array): void;
+/** Timelock gate: may a pending update/unpause land at `currentSlot`? */
+export declare function canExecuteAt(executeAfterSlot: bigint, currentSlot: bigint): boolean;
+export declare function findSubaccordPda(programAddress: Address, creator: Address, domainRef: Uint8Array): Promise<{
+    address: Address;
+    bump: number;
+}>;
+export declare function findPendingUpdatePda(programAddress: Address, subaccord: Address, nonce: bigint): Promise<{
+    address: Address;
+    bump: number;
+}>;
+export declare function findAccordStatePdaWithBump(programAddress: Address): Promise<{
+    address: Address;
+    bump: number;
+}>;
+/**
+ * Seam to the Codama-generated Kit client + fetcher. Foundation wires the
+ * concrete adapter; lifecycle.ts stays orchestration-only.
+ */
+export interface AccordLifecycleClient {
+    buildCreateSubaccord(input: {
+        programId: Address;
+        creator: Address;
+        subaccordPda: Address;
+        args: CreateSubaccordArgs;
+    }): Instruction;
+    buildProposeSubaccordUpdate(input: {
+        programId: Address;
+        authority: Address;
+        subaccord: Address;
+        pendingUpdatePda: Address;
+        nonce: bigint;
+        payload: UpdatePayload;
+    }): Instruction;
+    buildExecuteSubaccordUpdate(input: {
+        programId: Address;
+        caller: Address;
+        subaccord: Address;
+        pendingUpdate: Address;
+    }): Instruction;
+    buildInitializePause(input: {
+        programId: Address;
+        authority: Address;
+        accordStatePda: Address;
+    }): Instruction;
+    buildPause(input: {
+        programId: Address;
+        authority: Address;
+        accordState: Address;
+    }): Instruction;
+    buildProposeUnpause(input: {
+        programId: Address;
+        authority: Address;
+        accordState: Address;
+    }): Instruction;
+    buildExecuteUnpause(input: {
+        programId: Address;
+        caller: Address;
+        accordState: Address;
+    }): Instruction;
+    /** Read `execute_after_slot` back from a PendingUpdate account (timelock flow). */
+    fetchPendingUpdateExecuteAfter(pendingUpdate: Address): Promise<bigint | null>;
+}
+/** Build `create_subaccord` (lib.rs:146). Permissionless; creator owns the namespace. */
+export declare function createSubaccord(client: AccordLifecycleClient, programId: Address, creator: Address, args: CreateSubaccordArgs): Promise<{
+    instruction: Instruction;
+    subaccord: Address;
+    bump: number;
+}>;
+/**
+ * Build `propose_subaccord_update` (lib.rs:331). Authority-gated; arms a 48h
+ * timelock. The adapter pins the data-free rent payer to its wallet signer
+ * (ADR-0028) — wallet authorities pay their own PendingUpdate rent; a PDA
+ * authority CPIs from its program with a crank caller as rent payer.
+ * The exact `execute_after_slot` is set on-chain from the landing
+ * slot — read it back via `fetchPendingUpdateExecuteAfter` and gate execution
+ * with `canExecuteAt`. Returns the derived PendingUpdate PDA.
+ */
+export declare function proposeSubaccordUpdate(client: AccordLifecycleClient, programId: Address, authority: Address, subaccord: Address, nonce: bigint, payload: UpdatePayload): Promise<{
+    instruction: Instruction;
+    pendingUpdate: Address;
+}>;
+/**
+ * Resolve the timelock for a pending update: read `execute_after_slot` back
+ * from the PendingUpdate account. Pair with {@link canExecuteAt}.
+ */
+export declare function getUpdateExecuteAfterSlot(client: AccordLifecycleClient, pendingUpdate: Address): Promise<bigint | null>;
+/** Build `execute_subaccord_update` (lib.rs:372). Permissionless; lands post-timelock. */
+export declare function executeSubaccordUpdate(client: AccordLifecycleClient, programId: Address, caller: Address, subaccord: Address, pendingUpdate: Address): Instruction;
+/** Build `initialize_pause` (lib.rs:77). One-time: sets the pause authority. */
+export declare function initializePause(client: AccordLifecycleClient, programId: Address, authority: Address): Promise<{
+    instruction: Instruction;
+    accordState: Address;
+}>;
+/** Build `pause` (lib.rs:86). Instant, authority-gated emergency freeze. */
+export declare function pause(client: AccordLifecycleClient, programId: Address, authority: Address, accordState: Address): Instruction;
+/** Build `propose_unpause` (lib.rs:102). Arms `UNPAUSE_TIMELOCK_SLOTS` notice. */
+export declare function proposeUnpause(client: AccordLifecycleClient, programId: Address, authority: Address, accordState: Address): Instruction;
+/** Build `execute_unpause` (lib.rs:120). Permissionless; lands post-timelock. */
+export declare function executeUnpause(client: AccordLifecycleClient, programId: Address, caller: Address, accordState: Address): Instruction;
+//# sourceMappingURL=lifecycle.d.ts.map

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

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