@useaccord/sdk 0.1.0

package/dist/methods/voting.d.ts

@@ -0,0 +1,227 @@
+/**
+ * voting.ts — commit-reveal voting + finalization cranks (ADR-0010) with
+ * scalar u64 votes (ADR-0025).
+ *
+ * The load-bearing client-side cryptography lives here: the commit hash
+ *   `sha256(vote_le[8] ‖ salt[32] ‖ juror_pubkey[32])`
+ * where `vote_le` is the vote's 8-byte little-endian encoding — votes are
+ * `u64` on the wire (option index for `Plurality`, fixed-point scalar in
+ * settlement-mint base units for `Median`). The on-chain `reveal`
+ * recomputes this via `solana_program::hash::hashv` (instructions/reveal.rs:
+ * `hashv(&[&vote.to_le_bytes(), &salt, juror_key.as_ref()])`) and checks it
+ * against the stored commitment. Mismatching the byte order or lengths here
+ * silently breaks every dispute, so `commitHash` is unit-tested against a
+ * hardcoded digest vector.
+ *
+ * Four instructions are orchestrated:
+ *   - {@link commit}         juror commits `hash(vote, salt, juror)`.
+ *   - {@link reveal}         juror reveals `{vote, salt}` (chain re-derives hash).
+ *   - {@link finalizeRound}  permissionless crank: tally (plurality or median) → RoundResolved.
+ *   - {@link finalizeDispute} permissionless crank: settles economics, writes ruling.
+ *
+ * As in dispute.ts, the module is pure facade orchestration over a typed
+ * {@link AccordVotingClient} seam that Foundation wires to the Codama-generated
+ * Kit client. Kit is imported type-only (erased at runtime); the PDA helper
+ * lazy-imports Kit so the unit tests load zero runtime deps.
+ *
+ * Sources of truth:
+ *   - commit/reveal/finalize_*: programs/accord/src/instructions/{commit,reveal,finalize_round,finalize_dispute}.rs
+ *   - Round struct + seeds:     programs/accord/src/state.rs (Round, SEED_ROUND)
+ */
+import type { Address, Instruction } from "@solana/kit";
+/**
+ * No-reveal sentinel: `u64::MAX` marks "not revealed" in `Round.reveals` and
+ * "not set" in `Round.result` (ADR-0025; was `u8::MAX` before scalar votes).
+ * Both aggregation modes reject it as an actual vote on-chain.
+ */
+export declare const NO_VOTE = 18446744073709551615n;
+/**
+ * Shared accounts every voting instruction takes (juror or cranker signs).
+ *
+ * `commit`/`reveal`/`finalizeRound`/`finalizeDispute` use only the first four.
+ * The `stakingToken`/`jurorTokenAccount`/`vault` fields are vestigial: pre
+ * ADR-0020 `reveal` paid a fee on reveal; that credit now happens in
+ * `finalize_round`. The adapter ignores them and the chain doesn't ask.
+ * `tokenProgram` is a fixed constant.
+ */
+export interface VotingAccounts {
+    /** Commit/reveal: the drawn juror. finalize_*: any cranker. Always a signer. */
+    signer: Address;
+    subaccord: Address;
+    dispute: Address;
+    round: Address;
+    /** @deprecated vestigial — reveal no longer moves tokens (ADR-0020). */
+    stakingToken?: Address;
+    /** @deprecated vestigial — reveal no longer moves tokens (ADR-0020). */
+    jurorTokenAccount?: Address;
+    /** @deprecated vestigial — reveal no longer moves tokens (ADR-0020). */
+    vault?: Address;
+}
+/** A juror's vote + salt (the reveal preimage). */
+export interface VoteArgs {
+    /**
+     * The vote, `u64` on the wire (ADR-0025): an option index for `Plurality`
+     * disputes or a scaled scalar for `Median` (see {@link encodeScalarVote}).
+     */
+    vote: bigint;
+    /** 32-byte random salt — secret until reveal. */
+    salt: Uint8Array;
+}
+/**
+ * Compute the commit hash `sha256(vote_le[8] ‖ salt[32] ‖ juror_pubkey[32])`.
+ *
+ * Bit-for-bit compatible with the on-chain `reveal` check
+ * (instructions/reveal.rs): `hashv(&[&vote.to_le_bytes(), &salt,
+ * juror_key.as_ref()]).to_bytes()` — the vote is hashed as 8-byte
+ * little-endian (ADR-0025), so the preimage is 72 bytes.
+ *
+ * Uses the Web Crypto API (`globalThis.crypto.subtle`): zero-dependency,
+ * available in Node ≥ 18 and all browsers. `jurorBytes` is the juror's 32-byte
+ * pubkey encoding (Kit's `getAddressEncoder().encode(juror)`).
+ */
+export declare function commitHash(vote: bigint, salt: Uint8Array, jurorBytes: Uint8Array): Promise<Uint8Array>;
+/**
+ * Validate an option-index vote for `Plurality` disputes: `vote <
+ * num_options` (instructions/reveal.rs). `Median` scalars carry no
+ * client-side range beyond the u64 fit checked in {@link commitHash} and the
+ * facades. Pure.
+ */
+export declare function assertValidVote(vote: bigint, numOptions: number): void;
+/** Validate the salt is 32 bytes. Pure. */
+export declare function assertValidSalt(salt: Uint8Array): void;
+/**
+ * Encode a human-readable scalar vote (ADR-0025 `Median` disputes) as the
+ * u64 base-unit bigint the wire takes: `input · 10^decimals`. Accepts plain
+ * decimal strings (`"123"`, `"123.45"`); rejects anything else (sign,
+ * exponent, separators, empty string) and fractions longer than `decimals`.
+ * The `u64` fit is enforced downstream ({@link commitHash} / the facades).
+ * Inverse of {@link decodeScalarVote}.
+ */
+export declare function encodeScalarVote(input: string, decimals?: number): bigint;
+/**
+ * Decode a u64 base-unit vote back to a plain decimal string (inverse of
+ * {@link encodeScalarVote}): `123450000n` → `"123.45"` at the default 6
+ * decimals. Trailing fraction zeros are trimmed; a zero fraction collapses
+ * to the integer form. Pure.
+ */
+export declare function decodeScalarVote(vote: bigint, decimals?: number): string;
+/**
+ * Build the Round PDA seed bytes (state.rs:2124):
+ *   `["round", dispute.key(), &current_round.to_le_bytes()]`.
+ *
+ * `roundIdx` is `u32` little-endian (4 bytes). Pure + deterministic.
+ */
+export declare function roundSeeds(disputeBytes: Uint8Array, roundIdx: number): Uint8Array[];
+/** Derive the canonical Round PDA. Kit lazy-imported. */
+export declare function findRoundPda(programAddress: Address, dispute: Address, roundIdx: number): Promise<{
+    address: Address;
+    bump: number;
+}>;
+/**
+ * Seam to the Codama-generated Kit client (ADR-0010). Foundation provides the
+ * concrete adapter; voting.ts stays orchestration-only, so it is parallel-safe
+ * under fleet dispatch and compile-verifiable before the generator lands.
+ */
+export interface AccordVotingClient {
+    buildCommit(input: {
+        programId: Address;
+        accounts: VotingAccounts;
+        commitment: Uint8Array;
+    }): Instruction;
+    buildReveal(input: {
+        programId: Address;
+        accounts: VotingAccounts;
+        vote: bigint;
+        salt: Uint8Array;
+    }): Instruction;
+    buildFinalizeRound(input: {
+        programId: Address;
+        accounts: VotingAccounts;
+        remainingAccounts?: Address[];
+    }): Instruction;
+    buildFinalizeDispute(input: {
+        programId: Address;
+        accounts: VotingAccounts;
+        /** remaining_accounts: drawn JurorStake PDAs (+ AppealBond PDAs). */
+        remainingAccounts: Address[];
+    }): Instruction;
+    /** `redraw` (ADR-0021) — see {@link redraw}. */
+    buildRedraw(input: {
+        programId: Address;
+        accounts: RedrawAccounts;
+        remainingAccounts?: Address[];
+    }): Instruction;
+    /** Encode a juror Address to its 32-byte pubkey (Kit `getAddressEncoder`). */
+    encodeAddress(address: Address): Uint8Array;
+}
+/**
+ * Build a `commit` instruction: compute `commitHash(vote, salt, juror)` and
+ * hand the 32-byte commitment to the chain (instructions/commit.rs). The
+ * juror must be drawn into the round and inside the commit window; those
+ * gates are enforced on-chain. Returns the instruction + the computed
+ * commitment (for local bookkeeping / indexing).
+ */
+export declare function commit(client: AccordVotingClient, programId: Address, accounts: VotingAccounts, args: VoteArgs): Promise<{
+    instruction: Instruction;
+    commitment: Uint8Array;
+}>;
+/**
+ * Build a `reveal` instruction with `{vote, salt}` (instructions/reveal.rs).
+ * The chain recomputes `hash(vote_le ‖ salt ‖ juror)` and checks it equals
+ * the stored commitment — so `args` MUST be the exact pair used in
+ * {@link commit}.
+ */
+export declare function reveal(client: AccordVotingClient, programId: Address, accounts: VotingAccounts, args: VoteArgs): Instruction;
+/**
+ * Build the permissionless `finalize_round` crank
+ * (instructions/finalize_round.rs). After the reveal window elapses, anyone
+ * can advance the dispute to `RoundResolved` with the tally winner written
+ * to `round.result` (plurality option or median scalar, ADR-0025).
+ * ADR-0020: credits
+ * `fees_earned` to each revealer — pass the panel's JurorStake PDAs as
+ * `remainingAccounts` when `fee_per_juror > 0`.
+ */
+export declare function finalizeRound(client: AccordVotingClient, programId: Address, accounts: VotingAccounts, remainingAccounts?: Address[]): Instruction;
+/**
+ * Build the permissionless `finalize_dispute` crank
+ * (instructions/finalize_dispute.rs). After the appeal window elapses,
+ * anyone can settle the final round: slash incoherent
+ * jurors, redistribute the pool, decrement `active_draws`, and write
+ * `final_ruling` (transition to `Final`).
+ *
+ * `remainingAccounts` = the drawn `JurorStake` PDAs (panel), followed by one
+ * `AppealBond` PDA per prior appeal (`current_round` of them). With no appeals
+ * this collapses to just the juror stakes.
+ */
+export declare function finalizeDispute(client: AccordVotingClient, programId: Address, accounts: VotingAccounts, remainingAccounts: Address[]): Instruction;
+/**
+ * Accounts for `redraw` (lib.rs). The Fail branch refunds the filer from
+ * `feeVault`, so it carries the filer's `feeToken` ATA + the vault (validated
+ * but unused on the Redraw branch).
+ */
+export interface RedrawAccounts {
+    /** Permissionless cranker. */
+    caller: Address;
+    subaccord: Address;
+    dispute: Address;
+    /** The shortfall round (`dispute.current_round`). */
+    round: Address;
+    feeToken: Address;
+    /** Filer's `feeToken` ATA — refund destination on exhaustion. */
+    filerTokenAccount: Address;
+    feeVault: Address;
+    tokenProgram: Address;
+}
+/**
+ * Build the permissionless `redraw` crank (lib.rs, ADR-0021). Only callable
+ * from `RedrawEligible`. Slashes no-shows into `stake_delta`, bumps
+ * `round.draw_attempt` (orthogonal to `round_idx` — same panel size, no appeal
+ * consumed), clears the round → `Created`; on `draw_attempt + 1 ≥
+ * max_draw_attempts` → `Failed` (filer `fee_paid` refunded, slashes stand).
+ *
+ * `remainingAccounts` = the round's drawn `JurorStake` PDAs (panel); on the Fail
+ * branch additionally prior-round `Round` PDAs + their `JurorStake` PDAs + the
+ * dispute's `AppealBond` PDAs (same layout as `cancel_dispute`).
+ */
+export declare function redraw(client: AccordVotingClient, programId: Address, accounts: RedrawAccounts, remainingAccounts?: Address[]): Instruction;
+//# sourceMappingURL=voting.d.ts.map

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

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

package/dist/methods/vrf.d.ts

@@ -0,0 +1,143 @@
+/**
+ * vrf.ts — VRF request + per-seat draw choreography (ADR-0009 §2 + ADR-0012).
+ *
+ *   1. request_vrf          — CPI into the magicblock VRF oracle (one-shot).
+ *   2. commit_vrf_callback  — oracle calls back; sets `dispute.committed_vrf`
+ *                             AND atomically freezes `dispute.frozen_root`.
+ *   3. draw_seat(seat, mem) — submit one seat's membership against the frozen
+ *                             root. One tx per seat (1232B can't hold N proofs).
+ *
+ * The VRF result is committed ONCE and immutable. The frozen root is the live
+ * accumulator root captured atomically at callback time — all N draw_seat txs
+ * (and every appeal round) select against the SAME root.
+ *
+ * The chain is a dumb verifier: per seat `i`, it derives
+ *   vrf_seed = sha256(committed_vrf ‖ dispute ‖ round_idx_le4 ‖ draw_attempt_le4)
+ *   r_i      = u64_le(sha256(vrf_seed ‖ seat_le4 ‖ retry_le4)[0..8]) % frozen_total_stake
+ * and checks the submitted leaf's reconstructed prefix ranges contains `r_i`.
+ * `draw_attempt` (ADR-0021) is orthogonal to `round_idx`: a shortfall redraw
+ * increments it to re-seed the panel at the same size (no appeal consumed).
+ * Deterministic collision re-roll (sampling without replacement) is computed
+ * client-side to match the chain — bean accord-tzo0.
+ *
+ * Sources of truth:
+ *   - request_vrf / commit_vrf_callback / draw_seat: lib.rs
+ *   - sortition criterion: ADR-0009 §2 (subtree-sum form, ADR-0012)
+ */
+import type { Address, Instruction } from "@solana/kit";
+import { type LeafClaim, type MSTNode, type MerkleAccumulator } from "./mst.js";
+/**
+ * `vrf_seed = sha256(committed_vrf ‖ dispute ‖ round_idx_le4 ‖ draw_attempt_le4)`
+ * (lib.rs draw_seat, ADR-0021). Binds the committed VRF to this dispute + round
+ * + redraw attempt. `drawAttempt` defaults to 0 (the initial draw); a shortfall
+ * redraw bumps it so the same panel size yields fresh seats.
+ */
+export declare function vrfSeed(committedVrf: Uint8Array, disputeBytes: Uint8Array, roundIdx: number, drawAttempt?: number): Promise<Uint8Array>;
+/**
+ * Derive the sortition point for a single seat at a given retry:
+ * `r_i = u64_le(sha256(vrf_seed ‖ seat_le4 ‖ retry_le4)[0..8]) % frozen_total_stake`.
+ * `retry` defaults to 0 (the common case — no collision). The on-chain
+ * `draw_seat` includes the same retry counter in its sortition hash and verifies
+ * that every prior retry (0..retries) genuinely collided with an already-drawn
+ * juror (bean accord-tzo0).
+ */
+export declare function seatSlot(committedVrf: Uint8Array, disputeBytes: Uint8Array, roundIdx: number, seat: number, frozenTotalStake: bigint, retry?: number, drawAttempt?: number): Promise<bigint>;
+/**
+ * Find the leaf in `tree` whose sortition range `[prefix, prefix+stake)`
+ * contains `slot`, and return it with its index + proof. Returns `null` if the
+ * slot lands in a zero-stake gap (no eligible leaf).
+ */
+export declare function findLeafForSlot(tree: MerkleAccumulator, slot: bigint): Promise<{
+    leaf: LeafClaim;
+    index: number;
+    proof: MSTNode[];
+} | null>;
+/**
+ * Resolve a single seat using the deterministic collision re-roll algorithm
+ * (bean accord-tzo0). Iterates `retry = 0, 1, 2, …` computing
+ * `r_i = sha256(seed ‖ seat ‖ retry) % total_stake`; the first retry whose
+ * selected leaf is NOT in `alreadyDrawn` is the terminal. Returns the leaf,
+ * proof, and the `retries` count the cranker must submit to `draw_seat`.
+ *
+ * The on-chain verifier independently confirms every prior retry collided — so
+ * there is exactly one valid (leaf, retries) pair per seat. No caller choice.
+ */
+export declare function resolveSeat(committedVrf: Uint8Array, disputeBytes: Uint8Array, roundIdx: number, seat: number, tree: MerkleAccumulator, alreadyDrawn: Uint8Array[], maxRetries?: number, drawAttempt?: number): Promise<{
+    leaf: LeafClaim;
+    index: number;
+    proof: MSTNode[];
+    retries: number;
+}>;
+/** Verify a seat's membership reconstructs to the frozen root (client-side precheck). */
+export declare function verifySeat(leaf: LeafClaim, index: number, proof: MSTNode[], frozenRoot: Uint8Array, frozenTotalStake: bigint): Promise<boolean>;
+/** Accounts for `request_vrf` / `draw_seat` (the cranker signs). */
+export interface VrfDrawAccounts {
+    caller: Address;
+    subaccord: Address;
+    dispute: Address;
+}
+/** Extra accounts `request_vrf` needs for the VRF oracle CPI. */
+export interface RequestVrfExtras {
+    /** magicblock VRF oracle queue account. */
+    oracleQueue: Address;
+    /** Accord program-identity PDA (CPI authority for the VRF oracle). */
+    programIdentity: Address;
+}
+/**
+ * One seat's resolved membership: the leaf `(juror, stake)` at `index` plus its
+ * accumulator proof, the juror's `JurorStake` PDA (remaining_accounts[0]), and
+ * the deterministic collision re-roll count (bean accord-tzo0).
+ */
+export interface SeatMembership {
+    leaf: LeafClaim;
+    index: number;
+    proof: MSTNode[];
+    jurorStake: Address;
+    /** Number of sortition retries (collisions) before this leaf was selected. */
+    retries: number;
+}
+/**
+ * Seam to the Codama-generated Kit client + Dispute fetcher. Foundation wires
+ * the concrete adapter; vrf.ts stays orchestration-only.
+ */
+export interface AccordVrfClient {
+    buildRequestVrf(input: {
+        programId: Address;
+        accounts: VrfDrawAccounts;
+        extras: RequestVrfExtras;
+    }): Instruction;
+    buildDrawSeat(input: {
+        programId: Address;
+        accounts: VrfDrawAccounts;
+        /** Round PDA — `init_if_needed` by draw_seat (`["round", dispute, current_round]`). */
+        roundPda: Address;
+        seat: number;
+        /** Sortition collision re-roll count (bean accord-tzo0). */
+        retries: number;
+        leaf: LeafClaim;
+        proof: MSTNode[];
+        index: number;
+        jurorStake: Address;
+    }): Instruction;
+    /** Read `committed_vrf` from a Dispute; `null` until the oracle callback lands. */
+    fetchCommittedVrf(dispute: Address): Promise<Uint8Array | null>;
+}
+/** Build `request_vrf`. One-shot; triggers the oracle callback (freezes the root). */
+export declare function requestVrf(client: AccordVrfClient, programId: Address, accounts: VrfDrawAccounts, extras: RequestVrfExtras): Instruction;
+/**
+ * Poll a Dispute's `committed_vrf` until the oracle callback lands (or
+ * `timeoutMs` elapses). Returns the 32-byte randomness. Use between
+ * {@link requestVrf} and {@link drawSeat}.
+ */
+export declare function awaitCommittedVrf(client: AccordVrfClient, dispute: Address, opts?: {
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+}): Promise<Uint8Array>;
+/**
+ * Build `draw_seat` for one seat (lib.rs). Pass the pre-resolved `seat` +
+ * membership (from {@link resolveSeat}) and the juror's `JurorStake` PDA. The
+ * round is `init_if_needed` on-chain and persists across the N seat txs.
+ * `membership.retries` carries the deterministic collision re-roll count.
+ */
+export declare function drawSeat(client: AccordVrfClient, programId: Address, accounts: VrfDrawAccounts, roundPda: Address, seat: number, membership: SeatMembership): Instruction;
+//# sourceMappingURL=vrf.d.ts.map

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

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

package/dist/methods.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Bound orchestration namespace — the eight Accord method groups, pre-bound to
+ * a concrete {@link AccordAdapter} + the canonical program id.
+ *
+ * Each entry forwards to the pure orchestration function in `src/methods/*.ts`,
+ * injecting the adapter as the `client` argument. The pure crypto helpers
+ * (`buildMst`, `resolvePanel`, `commitHash`, `appealCost`, …) are NOT bound
+ * here — they take no client, so import them directly from `@useaccord/sdk`.
+ *
+ * @see ADR-0010
+ */
+import type { Address, Instruction, TransactionSigner } from "@solana/kit";
+import { type CreateDisputeAccounts, type CreateDisputeArgs } from "./methods/dispute.js";
+import { type CreateSubaccordArgs, type UpdatePayload } from "./methods/lifecycle.js";
+import type { MSTNode } from "./methods/mst.js";
+import { type StakingAccounts, type WithdrawFeesAccounts, type PruneJurorAccounts } from "./methods/staking.js";
+import { type CancelDisputeAccounts, type SettleRoundAccounts } from "./methods/settlement.js";
+import { type SeatMembership, type RequestVrfExtras, type VrfDrawAccounts } from "./methods/vrf.js";
+import { type RedrawAccounts, type VoteArgs, type VotingAccounts } from "./methods/voting.js";
+import { type AppealAccounts, type ClaimRefundAccounts } from "./methods/appeal.js";
+import type { AccordAdapter } from "./adapter.js";
+/** Bound method groups returned by `accord.methods`. */
+export interface AccordMethods {
+    createDispute(accounts: CreateDisputeAccounts, args: CreateDisputeArgs): Promise<{
+        instruction: Instruction;
+        dispute: Address;
+        bump: number;
+    }>;
+    getRuling(dispute: Address): Promise<bigint | null>;
+    createSubaccord(creator: Address, args: CreateSubaccordArgs): Promise<{
+        instruction: Instruction;
+        subaccord: Address;
+        bump: number;
+    }>;
+    proposeSubaccordUpdate(authority: Address, subaccord: Address, nonce: bigint, payload: UpdatePayload): Promise<{
+        instruction: Instruction;
+        pendingUpdate: Address;
+    }>;
+    getUpdateExecuteAfterSlot(pendingUpdate: Address): Promise<bigint | null>;
+    executeSubaccordUpdate(caller: Address, subaccord: Address, pendingUpdate: Address): Instruction;
+    initializePause(authority: Address): Promise<{
+        instruction: Instruction;
+        accordState: Address;
+    }>;
+    pause(authority: Address, accordState: Address): Instruction;
+    proposeUnpause(authority: Address, accordState: Address): Instruction;
+    executeUnpause(caller: Address, accordState: Address): Instruction;
+    stake(accounts: StakingAccounts, amount: bigint, path: MSTNode[], attestation?: Address): Instruction;
+    requestWithdraw(accounts: StakingAccounts, amount: bigint, path: MSTNode[]): Instruction;
+    withdraw(accounts: StakingAccounts): Instruction;
+    reconcileStake(accounts: StakingAccounts, path: MSTNode[]): Instruction;
+    withdrawFees(accounts: WithdrawFeesAccounts): Instruction;
+    pruneJuror(accounts: PruneJurorAccounts, path: MSTNode[], attestation: Address): Instruction;
+    settleRound(accounts: SettleRoundAccounts, roundIdx: number, remainingAccounts: Address[]): Instruction;
+    cancelDispute(accounts: CancelDisputeAccounts, remainingAccounts: Address[]): Instruction;
+    requestVrf(accounts: VrfDrawAccounts, extras: RequestVrfExtras): Instruction;
+    awaitCommittedVrf(dispute: Address, opts?: {
+        pollIntervalMs?: number;
+        timeoutMs?: number;
+    }): Promise<Uint8Array>;
+    drawSeat(accounts: VrfDrawAccounts, roundPda: Address, seat: number, membership: SeatMembership): Instruction;
+    commit(accounts: VotingAccounts, args: VoteArgs): Promise<{
+        instruction: Instruction;
+        commitment: Uint8Array;
+    }>;
+    reveal(accounts: VotingAccounts, args: VoteArgs): Instruction;
+    finalizeRound(accounts: VotingAccounts, remainingAccounts?: Address[]): Instruction;
+    finalizeDispute(accounts: VotingAccounts, remainingAccounts: Address[]): Instruction;
+    redraw(accounts: RedrawAccounts, remainingAccounts?: Address[]): Instruction;
+    appeal(accounts: AppealAccounts, newEvidenceHash: Uint8Array): Instruction;
+    claimAppealRefund(accounts: ClaimRefundAccounts, roundIdx: number): Instruction;
+}
+/**
+ * Build the bound method namespace. `signer` is accepted so future per-call
+ * signer overrides can route through the facade; today the adapter uses the
+ * facade's wallet.
+ */
+export declare function createAccordMethods(adapter: AccordAdapter, programId?: Address, _signer?: TransactionSigner): AccordMethods;
+//# sourceMappingURL=methods.d.ts.map

package/dist/methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods.d.ts","sourceRoot":"","sources":["../src/methods.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAE3E,OAAO,EAGL,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACvB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EASL,KAAK,mBAAmB,EACxB,KAAK,aAAa,EACnB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAOL,KAAK,eAAe,EACpB,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACxB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAGL,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EACzB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAIL,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAML,KAAK,cAAc,EACnB,KAAK,QAAQ,EACb,KAAK,cAAc,EACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAGL,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACzB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAGlD,wDAAwD;AACxD,MAAM,WAAW,aAAa;IAE5B,aAAa,CACX,QAAQ,EAAE,qBAAqB,EAC/B,IAAI,EAAE,iBAAiB,GACtB,OAAO,CAAC;QAAE,WAAW,EAAE,WAAW,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACzE,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAGpD,eAAe,CACb,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,mBAAmB,GACxB,OAAO,CAAC;QAAE,WAAW,EAAE,WAAW,CAAC;QAAC,SAAS,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3E,sBAAsB,CACpB,SAAS,EAAE,OAAO,EAClB,SAAS,EAAE,OAAO,EAClB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC;QAAE,WAAW,EAAE,WAAW,CAAC;QAAC,aAAa,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IACjE,yBAAyB,CAAC,aAAa,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC1E,sBAAsB,CACpB,MAAM,EAAE,OAAO,EACf,SAAS,EAAE,OAAO,EAClB,aAAa,EAAE,OAAO,GACrB,WAAW,CAAC;IACf,eAAe,CACb,SAAS,EAAE,OAAO,GACjB,OAAO,CAAC;QAAE,WAAW,EAAE,WAAW,CAAC;QAAC,WAAW,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAC/D,KAAK,CAAC,SAAS,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,GAAG,WAAW,CAAC;IAC7D,cAAc,CAAC,SAAS,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,GAAG,WAAW,CAAC;IACtE,cAAc,CAAC,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,GAAG,WAAW,CAAC;IAGnE,KAAK,CACH,QAAQ,EAAE,eAAe,EACzB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,OAAO,EAAE,EACf,WAAW,CAAC,EAAE,OAAO,GACpB,WAAW,CAAC;IACf,eAAe,CACb,QAAQ,EAAE,eAAe,EACzB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,OAAO,EAAE,GACd,WAAW,CAAC;IACf,QAAQ,CAAC,QAAQ,EAAE,eAAe,GAAG,WAAW,CAAC;IACjD,cAAc,CAAC,QAAQ,EAAE,eAAe,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,WAAW,CAAC;IACxE,YAAY,CAAC,QAAQ,EAAE,oBAAoB,GAAG,WAAW,CAAC;IAC1D,UAAU,CACR,QAAQ,EAAE,kBAAkB,EAC5B,IAAI,EAAE,OAAO,EAAE,EACf,WAAW,EAAE,OAAO,GACnB,WAAW,CAAC;IAGf,WAAW,CACT,QAAQ,EAAE,mBAAmB,EAC7B,QAAQ,EAAE,MAAM,EAChB,iBAAiB,EAAE,OAAO,EAAE,GAC3B,WAAW,CAAC;IACf,aAAa,CACX,QAAQ,EAAE,qBAAqB,EAC/B,iBAAiB,EAAE,OAAO,EAAE,GAC3B,WAAW,CAAC;IAGf,UAAU,CAAC,QAAQ,EAAE,eAAe,EAAE,MAAM,EAAE,gBAAgB,GAAG,WAAW,CAAC;IAC7E,iBAAiB,CACf,OAAO,EAAE,OAAO,EAChB,IAAI,CAAC,EAAE;QAAE,cAAc,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GACrD,OAAO,CAAC,UAAU,CAAC,CAAC;IACvB,QAAQ,CACN,QAAQ,EAAE,eAAe,EACzB,QAAQ,EAAE,OAAO,EACjB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,cAAc,GACzB,WAAW,CAAC;IAGf,MAAM,CACJ,QAAQ,EAAE,cAAc,EACxB,IAAI,EAAE,QAAQ,GACb,OAAO,CAAC;QAAE,WAAW,EAAE,WAAW,CAAC;QAAC,UAAU,EAAE,UAAU,CAAA;KAAE,CAAC,CAAC;IACjE,MAAM,CAAC,QAAQ,EAAE,cAAc,EAAE,IAAI,EAAE,QAAQ,GAAG,WAAW,CAAC;IAC9D,aAAa,CACX,QAAQ,EAAE,cAAc,EACxB,iBAAiB,CAAC,EAAE,OAAO,EAAE,GAC5B,WAAW,CAAC;IACf,eAAe,CACb,QAAQ,EAAE,cAAc,EACxB,iBAAiB,EAAE,OAAO,EAAE,GAC3B,WAAW,CAAC;IACf,MAAM,CACJ,QAAQ,EAAE,cAAc,EACxB,iBAAiB,CAAC,EAAE,OAAO,EAAE,GAC5B,WAAW,CAAC;IAGf,MAAM,CAAC,QAAQ,EAAE,cAAc,EAAE,eAAe,EAAE,UAAU,GAAG,WAAW,CAAC;IAC3E,iBAAiB,CACf,QAAQ,EAAE,mBAAmB,EAC7B,QAAQ,EAAE,MAAM,GACf,WAAW,CAAC;CAChB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,aAAa,EACtB,SAAS,GAAE,OAA2B,EAGtC,OAAO,CAAC,EAAE,iBAAiB,GAC1B,aAAa,CAsFf"}

package/dist/pda.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Canonical PDA derivations for every Accord account.
+ *
+ * Seeds sourced from `programs/accord/src/state.rs` + `constants.rs`:
+ *   SEED_SUBACCORD = "subaccord"   SEED_DISPUTE = "dispute"
+ *   SEED_JUROR_STAKE = "stake"     SEED_ROUND = "round"
+ *   SEED_PENDING_UPDATE = "update" SEED_APPEAL_BOND = "bond"
+ *   SEED_ACCORD_STATE = "state"
+ *
+ * Five of seven PDAs are emitted by Codama into `./generated/pdas/` and
+ * re-exported here unchanged. `Round` is hand-written because its on-chain seeds
+ * reference `dispute.key()` (a runtime address, not a static field) — Codama
+ * cannot encode that statically, so it omits it.
+ *
+ * ADR-0012: the `Snapshot` PDA is gone (snapshot layer deleted).
+ *
+ * Every function returns `ProgramDerivedAddress` = `{ address: Address; bump: number }`.
+ *
+ * @see ADR-0010
+ */
+import { type Address, type ProgramDerivedAddress } from "@solana/kit";
+export declare const ACCORD_PROGRAM_ID: Address<"cordhVoshqRV6kzGBmM89A66wuusJGsDCvLMHPLyKed">;
+export { findAppealBondPda, type AppealBondSeeds, } from "./generated/pdas/appealBond";
+export { findDisputePda, type DisputeSeeds } from "./generated/pdas/dispute";
+export { findJurorStakePda, type JurorStakeSeeds, } from "./generated/pdas/jurorStake";
+export { findAccordStatePda } from "./generated/pdas/accordState";
+export { findPendingUpdatePda, type PendingUpdateSeeds, } from "./generated/pdas/pendingUpdate";
+export { findSubaccordPda, type SubaccordSeeds, } from "./generated/pdas/subaccord";
+export { findProgramIdentityPda, } from "./generated/pdas/programIdentity";
+export type RoundSeeds = {
+    dispute: Address;
+    roundIdx: number;
+};
+export declare function findRoundPda(seeds: RoundSeeds, config?: {
+    programAddress?: Address;
+}): Promise<ProgramDerivedAddress>;
+//# sourceMappingURL=pda.d.ts.map

package/dist/pda.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pda.d.ts","sourceRoot":"","sources":["../src/pda.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAKL,KAAK,OAAO,EACZ,KAAK,qBAAqB,EAC3B,MAAM,aAAa,CAAC;AAIrB,eAAO,MAAM,iBAAiB,EACqB,OAAO,CAAC,6CAA6C,CAAC,CAAC;AAI1G,OAAO,EACL,iBAAiB,EACjB,KAAK,eAAe,GACrB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,cAAc,EAAE,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7E,OAAO,EACL,iBAAiB,EACjB,KAAK,eAAe,GACrB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EACL,oBAAoB,EACpB,KAAK,kBAAkB,GACxB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,gBAAgB,EAChB,KAAK,cAAc,GACpB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,sBAAsB,GACvB,MAAM,kCAAkC,CAAC;AAS1C,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAsB,YAAY,CAChC,KAAK,EAAE,UAAU,EACjB,MAAM,GAAE;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAO,GACxC,OAAO,CAAC,qBAAqB,CAAC,CAUhC"}

package/dist/queries.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Typed `getProgramAccounts` query wrappers.
+ *
+ * Each function encapsulates the discriminator + memcmp construction so the
+ * caller never touches raw bytes. Returns typed `Account<T>[]` with the
+ * account address preserved (needed for deep links, PDA navigation, etc.).
+ *
+ * @see ADR-0010
+ */
+import { type Account, type Commitment, type GetProgramAccountsApi, type Rpc } from "@solana/kit";
+import { type Dispute } from "./generated/accounts/dispute.js";
+import { type PendingUpdate } from "./generated/accounts/pendingUpdate.js";
+export type QueryConfig = {
+    commitment?: Commitment;
+    abortSignal?: AbortSignal;
+};
+/**
+ * Fetch every Dispute account on-chain, decoded and typed.
+ * Filters by the 8-byte account discriminator at offset 0.
+ */
+export declare function findAllDisputes(rpc: Rpc<GetProgramAccountsApi>, config?: QueryConfig): Promise<Account<Dispute>[]>;
+/**
+ * Fetch every PendingUpdate account on-chain, decoded and typed.
+ * Filters by the 8-byte account discriminator at offset 0.
+ */
+export declare function findAllPendingUpdates(rpc: Rpc<GetProgramAccountsApi>, config?: QueryConfig): Promise<Account<PendingUpdate>[]>;
+//# sourceMappingURL=queries.d.ts.map

package/dist/queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../src/queries.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,KAAK,OAAO,EAGZ,KAAK,UAAU,EACf,KAAK,qBAAqB,EAG1B,KAAK,GAAG,EACT,MAAM,aAAa,CAAC;AAErB,OAAO,EAGL,KAAK,OAAO,EACb,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAGL,KAAK,aAAa,EACnB,MAAM,uCAAuC,CAAC;AAG/C,MAAM,MAAM,WAAW,GAAG;IACxB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B,CAAC;AAOF;;;GAGG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,GAAG,CAAC,qBAAqB,CAAC,EAC/B,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAoB7B;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,GAAG,CAAC,qBAAqB,CAAC,EAC/B,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,CAAC,CAoBnC"}

package/dist/query.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Typed `getProgramAccounts` wrappers — bulk reads that hide discriminator +
+ * memcmp-offset construction from the caller. Each function returns fully
+ * decoded `Account<T>[]`; no raw bytes, no memcmp offsets, no decoders leak.
+ *
+ * Filters match the 8-byte Anchor discriminator at offset 0 plus an optional
+ * 32-byte `Address` field. Offsets below are fixed by the generated struct
+ * layouts (see `./generated/accounts/*.ts`); the round-trip in `query.test.ts`
+ * fails if they ever drift.
+ *
+ * Accepts a raw Kit `Rpc<GetProgramAccountsApi>` — the same `rpc` the facade
+ * (`Accord.rpc`) or a bare `createSolanaRpc(...)` exposes.
+ *
+ * @see ADR-0010
+ */
+import { type Account, type Address, type GetProgramAccountsApi, type Rpc } from "@solana/kit";
+import { type Dispute, type JurorStake, type Subaccord } from "./generated/accounts/index.js";
+/** All Subaccords on the Accord program (discriminator-only filter). */
+export declare function findAllSubaccords(rpc: Rpc<GetProgramAccountsApi>): Promise<Account<Subaccord>[]>;
+/** Every JurorStake on the Accord program (global browse / aggregation). */
+export declare function findAllJurorStakes(rpc: Rpc<GetProgramAccountsApi>): Promise<Account<JurorStake>[]>;
+/** Every JurorStake for a Subaccord (draw pool / accumulator rebuild). */
+export declare function findJurorStakesBySubaccord(rpc: Rpc<GetProgramAccountsApi>, subaccord: Address): Promise<Account<JurorStake>[]>;
+/** Every JurorStake owned by a juror across all Subaccords. */
+export declare function findJurorStakesByJuror(rpc: Rpc<GetProgramAccountsApi>, juror: Address): Promise<Account<JurorStake>[]>;
+/** Every Dispute filed under a Subaccord. */
+export declare function findDisputesBySubaccord(rpc: Rpc<GetProgramAccountsApi>, subaccord: Address): Promise<Account<Dispute>[]>;
+/** Every Dispute filed by a given filer. */
+export declare function findDisputesByFiler(rpc: Rpc<GetProgramAccountsApi>, filer: Address): Promise<Account<Dispute>[]>;
+//# sourceMappingURL=query.d.ts.map

package/dist/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAIL,KAAK,OAAO,EACZ,KAAK,OAAO,EAEZ,KAAK,qBAAqB,EAG1B,KAAK,GAAG,EACT,MAAM,aAAa,CAAC;AAGrB,OAAO,EAOL,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,KAAK,SAAS,EACf,MAAM,+BAA+B,CAAC;AAsEvC,wEAAwE;AACxE,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,GAAG,CAAC,qBAAqB,CAAC,GAC9B,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,CAM/B;AAED,4EAA4E;AAC5E,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,GAAG,CAAC,qBAAqB,CAAC,GAC9B,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC,CAMhC;AAED,0EAA0E;AAC1E,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,GAAG,CAAC,qBAAqB,CAAC,EAC/B,SAAS,EAAE,OAAO,GACjB,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC,CAShC;AAED,+DAA+D;AAC/D,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,GAAG,CAAC,qBAAqB,CAAC,EAC/B,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC,CAShC;AAED,6CAA6C;AAC7C,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,GAAG,CAAC,qBAAqB,CAAC,EAC/B,SAAS,EAAE,OAAO,GACjB,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAS7B;AAED,4CAA4C;AAC5C,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,GAAG,CAAC,qBAAqB,CAAC,EAC/B,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAS7B"}

package/dist/token.d.ts

@@ -0,0 +1,24 @@
+/**
+ * SPL Token + Associated Token Account (ATA) derivation.
+ *
+ * Single source of truth for the canonical ATA address used across fee and
+ * collateral flows (ADR-0020). `@solana/kit` v7 does not export the SPL
+ * program ids, so they live here. Hand-rolled (no `@solana/spl-token`
+ * dependency) to keep the jest e2e suite free of the web3.js v1 `uuid` break —
+ * matches the on-chain `create_associated_token_account` layout:
+ * `ATA_PROGRAM ‖ [owner, TOKEN_PROGRAM, mint]`.
+ *
+ * @see ADR-0020
+ */
+import { type Address } from "@solana/kit";
+/** SPL Token program id (not exported by @solana/kit v7). */
+export declare const TOKEN_PROGRAM_ADDRESS: Address;
+/** SPL Associated Token Account program id (not exported by @solana/kit v7). */
+export declare const ASSOCIATED_TOKEN_PROGRAM_ADDRESS: Address;
+/**
+ * Derive the canonical Associated Token Account (ATA) address for `mint`
+ * owned by `owner`. Argument order follows `@solana/spl-token`'s
+ * `getAssociatedTokenAddress(mint, owner, …)`.
+ */
+export declare function findAssociatedTokenAddress(mint: Address, owner: Address): Promise<Address>;
+//# sourceMappingURL=token.d.ts.map

package/dist/token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["../src/token.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAGL,KAAK,OAAO,EACb,MAAM,aAAa,CAAC;AAErB,6DAA6D;AAC7D,eAAO,MAAM,qBAAqB,EACiB,OAAO,CAAC;AAE3D,gFAAgF;AAChF,eAAO,MAAM,gCAAgC,EACO,OAAO,CAAC;AAE5D;;;;GAIG;AACH,wBAAsB,0BAA0B,CAC9C,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,OAAO,CAAC,CAOlB"}

package/dist/types.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Domain types for the Accord.
+ *
+ * Re-exports the Codama-generated type modules (DisputeState, UpdatePayload,
+ * LeafClaim, MSTNode) which are sourced directly from
+ * `programs/accord/src/state.rs`. No hand-written duplicates — the generated
+ * tree is the single source of truth for on-chain shapes.
+ *
+ * ADR-0012: `SnapshotStatus` / `FraudProof` are gone (snapshot layer deleted);
+ * `LeafClaim` carries only `(juror, stake)` — the cumulative-from-left prefix
+ * used for sortition is reconstructed from the authenticated sibling sums.
+ */
+export { DisputeState, getDisputeStateDecoder, getDisputeStateEncoder, } from "./generated/types/disputeState.js";
+export { Aggregation, type AggregationArgs, getAggregationCodec, } from "./generated/types/aggregation.js";
+export { ShortfallPolicy, type ShortfallPolicyArgs, getShortfallPolicyCodec, } from "./generated/types/shortfallPolicy.js";
+export { type UpdatePayload, getUpdatePayloadCodec, } from "./generated/types/updatePayload.js";
+export { type LeafClaim as LeafClaimIdl, getLeafClaimCodec, } from "./generated/types/leafClaim.js";
+export { type MSTNode as MSTNodeIdl, getMSTNodeCodec, } from "./generated/types/mSTNode.js";
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EACL,YAAY,EACZ,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,mCAAmC,CAAC;AAE3C,OAAO,EACL,WAAW,EACX,KAAK,eAAe,EACpB,mBAAmB,GACpB,MAAM,kCAAkC,CAAC;AAE1C,OAAO,EACL,eAAe,EACf,KAAK,mBAAmB,EACxB,uBAAuB,GACxB,MAAM,sCAAsC,CAAC;AAE9C,OAAO,EACL,KAAK,aAAa,EAClB,qBAAqB,GACtB,MAAM,oCAAoC,CAAC;AAE5C,OAAO,EACL,KAAK,SAAS,IAAI,YAAY,EAC9B,iBAAiB,GAClB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,KAAK,OAAO,IAAI,UAAU,EAC1B,eAAe,GAChB,MAAM,8BAA8B,CAAC"}