@useaccord/sdk 0.5.1 → 0.6.0

package/dist/index.js

@@ -7003,7 +7003,10 @@ function createAccordAdapter(accord) {
         },
         { programAddress: input.programId }
       );
-      return appendRemaining(ix, [input.jurorStake]);
+      return appendRemaining(ix, [
+        input.jurorStake,
+        ...input.attestation ? [{ address: input.attestation, isWritable: false }] : []
+      ]);
     },
     async fetchCommittedVrf(dispute) {
       const m = await accord.client.accord.accounts.dispute.fetchMaybe(dispute);
@@ -7830,7 +7833,7 @@ function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 __name(sleep, "sleep");
-function drawSeat(client, programId, accounts, roundPda, seat, membership) {
+function drawSeat(client, programId, accounts, roundPda, seat, membership, attestation) {
   return client.buildDrawSeat({
     programId,
     accounts,
@@ -7840,7 +7843,8 @@ function drawSeat(client, programId, accounts, roundPda, seat, membership) {
     leaf: membership.leaf,
     proof: membership.proof,
     index: membership.index,
-    jurorStake: membership.jurorStake
+    jurorStake: membership.jurorStake,
+    attestation
   });
 }
 __name(drawSeat, "drawSeat");
@@ -8072,7 +8076,7 @@ function createAccordMethods(adapter, programId = ACCORD_PROGRAM_ID, _signer) {
     // vrf + per-seat draw
     requestVrf: /* @__PURE__ */ __name((accounts, extras) => requestVrf(adapter, programId, accounts, extras), "requestVrf"),
     awaitCommittedVrf: /* @__PURE__ */ __name((dispute, opts) => awaitCommittedVrf(adapter, dispute, opts), "awaitCommittedVrf"),
-    drawSeat: /* @__PURE__ */ __name((accounts, roundPda, seat, membership) => drawSeat(adapter, programId, accounts, roundPda, seat, membership), "drawSeat"),
+    drawSeat: /* @__PURE__ */ __name((accounts, roundPda, seat, membership, attestation) => drawSeat(adapter, programId, accounts, roundPda, seat, membership, attestation), "drawSeat"),
     // voting
     commit: /* @__PURE__ */ __name((accounts, args) => commit(adapter, programId, accounts, args), "commit"),
     reveal: /* @__PURE__ */ __name((accounts, args) => reveal(adapter, programId, accounts, args), "reveal"),
@@ -8099,7 +8103,7 @@ var Accord = class {
     this.rpc = createSolanaRpc(config.endpoint);
     this.signer = config.signer;
     this.client = accordProgram()(
-      this.rpc
+      { rpc: this.rpc }
     );
   }
   /**
@@ -8271,255 +8275,340 @@ function findDisputesByFiler(rpc, filer) {
 }
 __name(findDisputesByFiler, "findDisputesByFiler");
 
+// src/sas.ts
+import {
+  getBase58Decoder as getBase58Decoder2,
+  getBase64Encoder as getBase64Encoder2,
+  getAddressDecoder as getAddressDecoder12
+} from "@solana/kit";
+var SAS_PROGRAM_ID = "22zoJMtdu4tQc2PzL74ZUT7FrwgB1Udec8DdW4yw4BdG";
+var SAS_ATTESTATION_DISCRIMINATOR = 2;
+var DISC_OFF = 0;
+var NONCE_OFF = 1;
+var CREDENTIAL_OFF = 33;
+var SCHEMA_OFF = 65;
+var DATA_LEN_OFF = 97;
+var DATA_OFF = 101;
+var WALLET_OFF = DATA_OFF;
+var WALLET_W = 32;
+var SIGNER_W = 32;
+var EXPIRY_W = 8;
+var SAS_ATTESTATION_MIN_LEN = DATA_OFF + WALLET_W + SIGNER_W + EXPIRY_W;
+function decodeSasAttestation(bytes) {
+  const u8 = bytes;
+  if (u8.length < SAS_ATTESTATION_MIN_LEN) {
+    throw new Error(
+      `SasAttestationMalformed: ${u8.length} < ${SAS_ATTESTATION_MIN_LEN} bytes`
+    );
+  }
+  if (u8[DISC_OFF] !== SAS_ATTESTATION_DISCRIMINATOR) {
+    throw new Error(
+      `SasAttestationMalformed: discriminator ${u8[DISC_OFF]} != ${SAS_ATTESTATION_DISCRIMINATOR}`
+    );
+  }
+  const dv = new DataView(u8.buffer, u8.byteOffset, u8.byteLength);
+  const dataLen = dv.getUint32(DATA_LEN_OFF, true);
+  if (dataLen < WALLET_W) {
+    throw new Error(
+      `SasAttestationMalformed: data_len ${dataLen} < ${WALLET_W} (no wallet binding)`
+    );
+  }
+  const signerOff = DATA_OFF + dataLen;
+  const expiryOff = signerOff + SIGNER_W;
+  if (u8.length < expiryOff + EXPIRY_W) {
+    throw new Error(`SasAttestationMalformed: truncated expiry tail`);
+  }
+  const addressDecoder = getAddressDecoder12();
+  return {
+    nonce: u8.slice(NONCE_OFF, NONCE_OFF + WALLET_W),
+    credential: addressDecoder.decode(
+      u8.subarray(CREDENTIAL_OFF, CREDENTIAL_OFF + WALLET_W)
+    ),
+    schema: addressDecoder.decode(
+      u8.subarray(SCHEMA_OFF, SCHEMA_OFF + WALLET_W)
+    ),
+    wallet: addressDecoder.decode(
+      u8.subarray(WALLET_OFF, WALLET_OFF + WALLET_W)
+    ),
+    signer: addressDecoder.decode(u8.subarray(signerOff, signerOff + SIGNER_W)),
+    expiry: dv.getBigInt64(expiryOff, true)
+  };
+}
+__name(decodeSasAttestation, "decodeSasAttestation");
+async function findSasAttestations(rpc, filters = {}) {
+  const base582 = getBase58Decoder2();
+  const memcmp = [
+    {
+      memcmp: {
+        offset: 0n,
+        // Single discriminator byte at offset 0 (SAS uses u8, not Anchor's
+        // 8). Kit's base58 decoder yields plain `string`; brand it like
+        // query.ts does for the filter's `bytes` field.
+        bytes: base582.decode(
+          new Uint8Array([SAS_ATTESTATION_DISCRIMINATOR])
+        ),
+        encoding: "base58"
+      }
+    }
+  ];
+  if (filters.credential !== void 0) {
+    memcmp.push(addressFilter(BigInt(CREDENTIAL_OFF), filters.credential));
+  }
+  if (filters.schema !== void 0) {
+    memcmp.push(addressFilter(BigInt(SCHEMA_OFF), filters.schema));
+  }
+  if (filters.wallet !== void 0) {
+    memcmp.push(addressFilter(BigInt(WALLET_OFF), filters.wallet));
+  }
+  const accountInfos = await rpc.getProgramAccounts(SAS_PROGRAM_ID, { encoding: "base64", filters: memcmp }).send();
+  const base64 = getBase64Encoder2();
+  const out = [];
+  for (const info of accountInfos) {
+    try {
+      const [data] = info.account.data;
+      out.push({
+        ...info.account,
+        address: info.pubkey,
+        programAddress: SAS_PROGRAM_ID,
+        data: decodeSasAttestation(base64.encode(data))
+      });
+    } catch {
+    }
+  }
+  return out;
+}
+__name(findSasAttestations, "findSasAttestations");
+
+// src/generated/errors/accord.ts
+import {
+  isProgramError
+} from "@solana/kit";
+var ACCORD_ERROR__UNAUTHORIZED = 6e3;
+var ACCORD_ERROR__SUBACCORD_MISMATCH = 6001;
+var ACCORD_ERROR__IMMUTABLE_SUBACCORD = 6002;
+var ACCORD_ERROR__TIMELOCK_NOT_ELAPSED = 6003;
+var ACCORD_ERROR__NO_PENDING_UPDATE = 6004;
+var ACCORD_ERROR__NOT_PAUSE_AUTHORITY = 6005;
+var ACCORD_ERROR__ALREADY_PAUSED = 6006;
+var ACCORD_ERROR__NOT_PAUSED = 6007;
+var ACCORD_ERROR__NO_PENDING_UNPAUSE = 6008;
+var ACCORD_ERROR__UNPAUSE_TIMELOCK_NOT_ELAPSED = 6009;
+var ACCORD_ERROR__PROGRAM_PAUSED = 6010;
+var ACCORD_ERROR__INSUFFICIENT_STAKE = 6011;
+var ACCORD_ERROR__STAKE_LOCKED = 6012;
+var ACCORD_ERROR__INVALID_AMOUNT = 6013;
+var ACCORD_ERROR__WITHDRAWAL_TOO_EARLY = 6014;
+var ACCORD_ERROR__NO_PENDING_WITHDRAWAL = 6015;
+var ACCORD_ERROR__INSUFFICIENT_BALANCE = 6016;
+var ACCORD_ERROR__PENDING_SETTLEMENT = 6017;
+var ACCORD_ERROR__WITHDRAWAL_PENDING = 6018;
+var ACCORD_ERROR__INSUFFICIENT_JURORS = 6019;
+var ACCORD_ERROR__INVALID_OPTIONS = 6020;
+var ACCORD_ERROR__INVALID_STATE = 6021;
+var ACCORD_ERROR__FEE_MISMATCH = 6022;
+var ACCORD_ERROR__INVALID_MERKLE_PATH = 6023;
+var ACCORD_ERROR__TREE_FULL = 6024;
+var ACCORD_ERROR__DUPLICATE_JUROR = 6025;
+var ACCORD_ERROR__INVALID_MEMBERSHIP_PROOF = 6026;
+var ACCORD_ERROR__INVALID_PANEL_SIZE = 6027;
+var ACCORD_ERROR__INFLATED_STAKE = 6028;
+var ACCORD_ERROR__SORTITION_MISMATCH = 6029;
+var ACCORD_ERROR__VRF_ALREADY_COMMITTED = 6030;
+var ACCORD_ERROR__VRF_NOT_COMMITTED = 6031;
+var ACCORD_ERROR__COMMIT_ALREADY_EXISTS = 6032;
+var ACCORD_ERROR__COMMIT_MISSING = 6033;
+var ACCORD_ERROR__REVEAL_MISMATCH = 6034;
+var ACCORD_ERROR__COMMIT_WINDOW_CLOSED = 6035;
+var ACCORD_ERROR__REVEAL_WINDOW_CLOSED = 6036;
+var ACCORD_ERROR__NOT_DRAWN_JUROR = 6037;
+var ACCORD_ERROR__INVALID_VOTE = 6038;
+var ACCORD_ERROR__ALREADY_REVEALED = 6039;
+var ACCORD_ERROR__APPEAL_WINDOW_OPEN = 6040;
+var ACCORD_ERROR__MAX_APPEALS_REACHED = 6041;
+var ACCORD_ERROR__MAX_APPEALS_LIMIT_EXCEEDED = 6042;
+var ACCORD_ERROR__APPEAL_WINDOW_CLOSED = 6043;
+var ACCORD_ERROR__APPEAL_WINDOW_TOO_SHORT = 6044;
+var ACCORD_ERROR__ROUND_NOT_FINALIZABLE = 6045;
+var ACCORD_ERROR__DISPUTE_NOT_FINAL = 6046;
+var ACCORD_ERROR__ARITHMETIC_OVERFLOW = 6047;
+var ACCORD_ERROR__ROUND_ALREADY_SETTLED = 6048;
+var ACCORD_ERROR__ROUND_NOT_SETTLABLE = 6049;
+var ACCORD_ERROR__DISPUTE_FAILED = 6050;
+var ACCORD_ERROR__CANCEL_TOO_EARLY = 6051;
+var ACCORD_ERROR__MAX_RETRIES_EXCEEDED = 6052;
+var ACCORD_ERROR__NO_FEES_EARNED = 6053;
+var ACCORD_ERROR__NOT_REDRAW_ELIGIBLE = 6054;
+var ACCORD_ERROR__MAX_DRAW_ATTEMPTS_LIMIT_EXCEEDED = 6055;
+var ACCORD_ERROR__INVALID_THRESHOLD = 6056;
+var ACCORD_ERROR__ATTESTATION_MISSING = 6057;
+var ACCORD_ERROR__ATTESTATION_BINDING_PARTIAL = 6058;
+var ACCORD_ERROR__ATTESTATION_MALFORMED = 6059;
+var ACCORD_ERROR__ATTESTATION_MISMATCH = 6060;
+var ACCORD_ERROR__ATTESTATION_SUBJECT_MISMATCH = 6061;
+var ACCORD_ERROR__ATTESTATION_EXPIRED = 6062;
+var ACCORD_ERROR__ATTESTATION_NOT_EXPIRED = 6063;
+var ACCORD_ERROR__SLOT_NOT_DRAINED = 6064;
+var ACCORD_ERROR__SLOT_ALREADY_RECLAIMED = 6065;
+var ACCORD_ERROR__FREE_LIST_HEAD_MISMATCH = 6066;
+var ACCORD_ERROR__SLOT_AWAITING_RECYCLE = 6067;
+var ACCORD_ERROR__EVEN_JURY_SIZE = 6068;
+var ACCORD_ERROR__LADDER_EXCEEDS_MAX_JURORS = 6069;
+var ACCORD_ERROR__FEE_DOMINATES_SLASH = 6070;
+var accordErrorMessages;
+if (process.env["NODE_ENV"] !== "production") {
+  accordErrorMessages = {
+    [ACCORD_ERROR__ALREADY_PAUSED]: `Program is already paused.`,
+    [ACCORD_ERROR__ALREADY_REVEALED]: `Juror has already revealed.`,
+    [ACCORD_ERROR__APPEAL_WINDOW_CLOSED]: `Appeal window has closed; the dispute can only be finalized.`,
+    [ACCORD_ERROR__APPEAL_WINDOW_OPEN]: `Appeal window has not elapsed yet.`,
+    [ACCORD_ERROR__APPEAL_WINDOW_TOO_SHORT]: `Appeal window is below the per-Subaccord floor (MIN_APPEAL_WINDOW_SECS).`,
+    [ACCORD_ERROR__ARITHMETIC_OVERFLOW]: `Arithmetic overflow.`,
+    [ACCORD_ERROR__ATTESTATION_BINDING_PARTIAL]: `Credential and schema must be set together (both-or-neither).`,
+    [ACCORD_ERROR__ATTESTATION_EXPIRED]: `Attestation has expired or will expire before the dispute lifecycle completes.`,
+    [ACCORD_ERROR__ATTESTATION_MALFORMED]: `Attestation account is malformed (wrong owner, discriminator, or too short).`,
+    [ACCORD_ERROR__ATTESTATION_MISMATCH]: `Attestation credential or schema does not match the Subaccord binding.`,
+    [ACCORD_ERROR__ATTESTATION_MISSING]: `Subaccord is credential-gated but no attestation account was provided.`,
+    [ACCORD_ERROR__ATTESTATION_NOT_EXPIRED]: `Attestation has not expired; prune_juror requires an actually-expired credential.`,
+    [ACCORD_ERROR__ATTESTATION_SUBJECT_MISMATCH]: `Attestation subject wallet does not match the juror.`,
+    [ACCORD_ERROR__CANCEL_TOO_EARLY]: `Dispute has not exceeded its stage timeout; cancel_dispute is not yet available.`,
+    [ACCORD_ERROR__COMMIT_ALREADY_EXISTS]: `Juror has already committed.`,
+    [ACCORD_ERROR__COMMIT_MISSING]: `No commit to reveal for this Juror.`,
+    [ACCORD_ERROR__COMMIT_WINDOW_CLOSED]: `Commit window is closed.`,
+    [ACCORD_ERROR__DISPUTE_FAILED]: `Dispute is in terminal Failed state.`,
+    [ACCORD_ERROR__DISPUTE_NOT_FINAL]: `Dispute is not in a finalizable state.`,
+    [ACCORD_ERROR__DUPLICATE_JUROR]: `Draw selected a duplicate Juror.`,
+    [ACCORD_ERROR__EVEN_JURY_SIZE]: `Round-1 jury size (min_jury_size) must be odd (tie avoidance).`,
+    [ACCORD_ERROR__FEE_DOMINATES_SLASH]: `Same-mint pool is fee-dominated: alpha_bps\xB7min_stake/10_000 must cover MIN_SLASH_FEE_RATIO\xB7fee_per_juror.`,
+    [ACCORD_ERROR__FEE_MISMATCH]: `Tendered fee does not match the required round-1 dispute fee (min_jury_size * fee_per_juror).`,
+    [ACCORD_ERROR__FREE_LIST_HEAD_MISMATCH]: `Provided freed-slot account does not match the free-list head.`,
+    [ACCORD_ERROR__IMMUTABLE_SUBACCORD]: `Subaccord is immutable (authority == default).`,
+    [ACCORD_ERROR__INFLATED_STAKE]: `Drawn juror's live stake is below the accumulator leaf's claim (inflation guard, ADR-0012).`,
+    [ACCORD_ERROR__INSUFFICIENT_BALANCE]: `Withdrawal exceeds the Juror's free stake (amount - slash_reserve).`,
+    [ACCORD_ERROR__INSUFFICIENT_JURORS]: `Subaccord has fewer active distinct stakers than the required panel size.`,
+    [ACCORD_ERROR__INSUFFICIENT_STAKE]: `Staked amount is below the Subaccord minimum.`,
+    [ACCORD_ERROR__INVALID_AMOUNT]: `Amount must be greater than zero.`,
+    [ACCORD_ERROR__INVALID_MEMBERSHIP_PROOF]: `Juror Merkle membership/weight proof is invalid.`,
+    [ACCORD_ERROR__INVALID_MERKLE_PATH]: `Accumulator Merkle path does not authenticate against the stored root.`,
+    [ACCORD_ERROR__INVALID_OPTIONS]: `Dispute options are invalid (need 2..=MAX_OPTIONS).`,
+    [ACCORD_ERROR__INVALID_PANEL_SIZE]: `Number of juror memberships does not match the required panel size.`,
+    [ACCORD_ERROR__INVALID_STATE]: `Dispute is not in the required state for this instruction.`,
+    [ACCORD_ERROR__INVALID_THRESHOLD]: `Basis-point value out of range (must be <= 10_000; reveal threshold or alpha).`,
+    [ACCORD_ERROR__INVALID_VOTE]: `Revealed vote index is out of range.`,
+    [ACCORD_ERROR__LADDER_EXCEEDS_MAX_JURORS]: `The appeal ladder (min_jury_size, max_appeals) exceeds MAX_JURORS at its top round.`,
+    [ACCORD_ERROR__MAX_APPEALS_LIMIT_EXCEEDED]: `Subaccord max_appeals exceeds the program ceiling.`,
+    [ACCORD_ERROR__MAX_APPEALS_REACHED]: `Maximum appeals reached for this dispute.`,
+    [ACCORD_ERROR__MAX_DRAW_ATTEMPTS_LIMIT_EXCEEDED]: `Subaccord max_draw_attempts exceeds the program ceiling.`,
+    [ACCORD_ERROR__MAX_RETRIES_EXCEEDED]: `Sortition retries exceeded the on-chain bound; the pool may be too concentrated.`,
+    [ACCORD_ERROR__NO_FEES_EARNED]: `Juror has no earned fees to withdraw.`,
+    [ACCORD_ERROR__NO_PENDING_UNPAUSE]: `No pending unpause to execute.`,
+    [ACCORD_ERROR__NO_PENDING_UPDATE]: `No pending update to execute.`,
+    [ACCORD_ERROR__NO_PENDING_WITHDRAWAL]: `No pending withdrawal to execute.`,
+    [ACCORD_ERROR__NOT_DRAWN_JUROR]: `Signer is not a drawn Juror for this round.`,
+    [ACCORD_ERROR__NOT_PAUSE_AUTHORITY]: `Signer is not the pause authority.`,
+    [ACCORD_ERROR__NOT_PAUSED]: `Program is not paused.`,
+    [ACCORD_ERROR__NOT_REDRAW_ELIGIBLE]: `Dispute is not in RedrawEligible state; redraw is not available.`,
+    [ACCORD_ERROR__PENDING_SETTLEMENT]: `Settle pending reward/slash first: call reconcile_stake before request_withdraw.`,
+    [ACCORD_ERROR__PROGRAM_PAUSED]: `Program is paused; this instruction is halted.`,
+    [ACCORD_ERROR__REVEAL_MISMATCH]: `Reveal does not match the committed hash.`,
+    [ACCORD_ERROR__REVEAL_WINDOW_CLOSED]: `Reveal window is closed.`,
+    [ACCORD_ERROR__ROUND_ALREADY_SETTLED]: `Round has already been settled.`,
+    [ACCORD_ERROR__ROUND_NOT_FINALIZABLE]: `Round cannot be finalized yet (window not elapsed).`,
+    [ACCORD_ERROR__ROUND_NOT_SETTLABLE]: `Round index out of range for settlement (must be < current_round).`,
+    [ACCORD_ERROR__SLOT_ALREADY_RECLAIMED]: `JurorStake slot is already on the free list (next_free != MAX).`,
+    [ACCORD_ERROR__SLOT_AWAITING_RECYCLE]: `Juror's tree slot was reclaimed and sits mid-free-list; retry once the slots ahead of it are recycled.`,
+    [ACCORD_ERROR__SLOT_NOT_DRAINED]: `JurorStake is not fully drained (staked, active_draws, stake_delta, or fees_earned > 0).`,
+    [ACCORD_ERROR__SORTITION_MISMATCH]: `Submitted membership does not match the VRF-derived sortition selection (ADR-0009).`,
+    [ACCORD_ERROR__STAKE_LOCKED]: `Cannot unstake while active_draws > 0 (stake is frozen until drawn disputes settle).`,
+    [ACCORD_ERROR__SUBACCORD_MISMATCH]: `Dispute does not belong to this Subaccord (cross-pool substitution rejected).`,
+    [ACCORD_ERROR__TIMELOCK_NOT_ELAPSED]: `Timelock has not elapsed yet.`,
+    [ACCORD_ERROR__TREE_FULL]: `Accumulator tree is full (no free leaf within the configured depth).`,
+    [ACCORD_ERROR__UNAUTHORIZED]: `Signer is not the Subaccord authority.`,
+    [ACCORD_ERROR__UNPAUSE_TIMELOCK_NOT_ELAPSED]: `Unpause timelock has not elapsed yet.`,
+    [ACCORD_ERROR__VRF_ALREADY_COMMITTED]: `VRF result already committed for this dispute.`,
+    [ACCORD_ERROR__VRF_NOT_COMMITTED]: `No VRF result committed for this dispute; the root is not yet frozen.`,
+    [ACCORD_ERROR__WITHDRAWAL_PENDING]: `A withdrawal is already pending \u2014 complete it via withdraw before requesting another.`,
+    [ACCORD_ERROR__WITHDRAWAL_TOO_EARLY]: `Withdrawal timelock has not elapsed yet.`
+  };
+}
+
 // src/errors.ts
 var ACCORD_ERROR_CODE_OFFSET = 6e3;
 function err(code, name, message) {
   return { code, name, message };
 }
 __name(err, "err");
-var BASE = ACCORD_ERROR_CODE_OFFSET;
 var AccordErrors = {
-  // --- authority / timelock (ADR-0005) ---
-  Unauthorized: err(
-    BASE + 0,
-    "Unauthorized",
-    "Signer is not the Subaccord authority."
-  ),
-  ImmutableSubaccord: err(
-    BASE + 1,
-    "ImmutableSubaccord",
-    "Subaccord is immutable (authority == default)."
-  ),
-  TimelockNotElapsed: err(
-    BASE + 2,
-    "TimelockNotElapsed",
-    "Timelock has not elapsed yet."
-  ),
-  NoPendingUpdate: err(
-    BASE + 3,
-    "NoPendingUpdate",
-    "No pending update to execute."
-  ),
-  // --- circuit breaker (ADR-0007) ---
-  NotPauseAuthority: err(
-    BASE + 4,
-    "NotPauseAuthority",
-    "Signer is not the pause authority."
-  ),
-  AlreadyPaused: err(BASE + 5, "AlreadyPaused", "Program is already paused."),
-  NotPaused: err(BASE + 6, "NotPaused", "Program is not paused."),
-  NoPendingUnpause: err(
-    BASE + 7,
-    "NoPendingUnpause",
-    "No pending unpause to execute."
-  ),
-  UnpauseTimelockNotElapsed: err(
-    BASE + 8,
-    "UnpauseTimelockNotElapsed",
-    "Unpause timelock has not elapsed yet."
-  ),
-  ProgramPaused: err(
-    BASE + 9,
-    "ProgramPaused",
-    "Program is paused; this instruction is halted."
-  ),
-  // --- staking ---
-  InsufficientStake: err(
-    BASE + 10,
-    "InsufficientStake",
-    "Staked amount is below the Subaccord minimum."
-  ),
-  StakeLocked: err(
-    BASE + 11,
-    "StakeLocked",
-    "Cannot unstake while active_draws > 0 (stake is frozen until drawn disputes settle)."
-  ),
-  InvalidAmount: err(
-    BASE + 12,
-    "InvalidAmount",
-    "Amount must be greater than zero."
-  ),
-  InsufficientBalance: err(
-    BASE + 13,
-    "InsufficientBalance",
-    "Withdrawal exceeds the Juror's staked balance."
-  ),
-  // --- dispute intake ---
-  InsufficientJurors: err(
-    BASE + 14,
-    "InsufficientJurors",
-    "Subaccord has fewer active distinct stakers than the required panel size."
-  ),
-  InvalidOptions: err(
-    BASE + 15,
-    "InvalidOptions",
-    "Dispute options are invalid (need 2..=MAX_OPTIONS)."
-  ),
-  InvalidState: err(
-    BASE + 16,
-    "InvalidState",
-    "Dispute is not in the required state for this instruction."
-  ),
-  FeeMismatch: err(
-    BASE + 17,
-    "FeeMismatch",
-    "Tendered fee does not match the required round-1 dispute fee (min_jury_size * fee_per_juror)."
-  ),
-  // --- accumulator (ADR-0012) ---
-  InvalidMerklePath: err(
-    BASE + 18,
-    "InvalidMerklePath",
-    "Accumulator Merkle path does not authenticate against the stored root."
-  ),
-  TreeFull: err(
-    BASE + 19,
-    "TreeFull",
-    "Accumulator tree is full (no free leaf within the configured depth)."
-  ),
-  // --- draw ---
-  DuplicateJuror: err(
-    BASE + 20,
-    "DuplicateJuror",
-    "Draw selected a duplicate Juror."
-  ),
-  InvalidMembershipProof: err(
-    BASE + 21,
-    "InvalidMembershipProof",
-    "Juror Merkle membership/weight proof is invalid."
-  ),
-  InvalidPanelSize: err(
-    BASE + 22,
-    "InvalidPanelSize",
-    "Number of juror memberships does not match the required panel size."
-  ),
-  InflatedStake: err(
-    BASE + 23,
-    "InflatedStake",
-    "Drawn juror's live stake is below the accumulator leaf's claim (inflation guard, ADR-0012)."
-  ),
-  SortitionMismatch: err(
-    BASE + 24,
-    "SortitionMismatch",
-    "Submitted membership does not match the VRF-derived sortition selection (ADR-0009)."
-  ),
-  VrfAlreadyCommitted: err(
-    BASE + 25,
-    "VrfAlreadyCommitted",
-    "VRF result already committed for this dispute."
-  ),
-  VrfNotCommitted: err(
-    BASE + 26,
-    "VrfNotCommitted",
-    "No VRF result committed for this dispute; the root is not yet frozen."
-  ),
-  // --- voting ---
-  CommitAlreadyExists: err(
-    BASE + 27,
-    "CommitAlreadyExists",
-    "Juror has already committed."
-  ),
-  CommitMissing: err(
-    BASE + 28,
-    "CommitMissing",
-    "No commit to reveal for this Juror."
-  ),
-  RevealMismatch: err(
-    BASE + 29,
-    "RevealMismatch",
-    "Reveal does not match the committed hash."
-  ),
-  CommitWindowClosed: err(
-    BASE + 30,
-    "CommitWindowClosed",
-    "Commit window is closed."
-  ),
-  RevealWindowClosed: err(
-    BASE + 31,
-    "RevealWindowClosed",
-    "Reveal window is closed."
-  ),
-  NotDrawnJuror: err(
-    BASE + 32,
-    "NotDrawnJuror",
-    "Signer is not a drawn Juror for this round."
-  ),
-  InvalidVote: err(
-    BASE + 33,
-    "InvalidVote",
-    "Revealed vote index is out of range."
-  ),
-  AlreadyRevealed: err(
-    BASE + 34,
-    "AlreadyRevealed",
-    "Juror has already revealed."
-  ),
-  // --- finalization ---
-  AppealWindowOpen: err(
-    BASE + 35,
-    "AppealWindowOpen",
-    "Appeal window has not elapsed yet."
-  ),
-  // --- appeals (ADR-0004) ---
-  MaxAppealsReached: err(
-    BASE + 36,
-    "MaxAppealsReached",
-    "Maximum appeals reached for this dispute."
-  ),
-  MaxAppealsLimitExceeded: err(
-    BASE + 37,
-    "MaxAppealsLimitExceeded",
-    "Subaccord max_appeals exceeds the program ceiling."
-  ),
-  AppealWindowClosed: err(
-    BASE + 38,
-    "AppealWindowClosed",
-    "Appeal window has closed; the dispute can only be finalized."
-  ),
-  // --- finalization ---
-  RoundNotFinalizable: err(
-    BASE + 39,
-    "RoundNotFinalizable",
-    "Round cannot be finalized yet (window not elapsed)."
-  ),
-  DisputeNotFinal: err(
-    BASE + 40,
-    "DisputeNotFinal",
-    "Dispute is not in a finalizable state."
-  ),
-  // --- arithmetic ---
-  ArithmeticOverflow: err(
-    BASE + 41,
-    "ArithmeticOverflow",
-    "Arithmetic overflow."
-  ),
-  // --- multi-round settlement (CONCEPT-REVIEW Ugly 5 / accord-r6ti) ---
-  RoundAlreadySettled: err(
-    BASE + 42,
-    "RoundAlreadySettled",
-    "Round has already been settled."
-  ),
-  RoundNotSettlable: err(
-    BASE + 43,
-    "RoundNotSettlable",
-    "Round index out of range for settlement (must be < current_round)."
-  ),
-  // --- cancel / Failed state (Ugly 4) ---
-  DisputeFailed: err(
-    BASE + 44,
-    "DisputeFailed",
-    "Dispute is in terminal Failed state."
-  ),
-  CancelTooEarly: err(
-    BASE + 45,
-    "CancelTooEarly",
-    "Dispute has not exceeded its stage timeout; cancel_dispute is not yet available."
-  ),
-  // --- draw (bean accord-tzo0) ---
-  MaxRetriesExceeded: err(
-    BASE + 46,
-    "MaxRetriesExceeded",
-    "Sortition retries exceeded the on-chain bound; the pool may be too concentrated."
-  )
+  Unauthorized: err(ACCORD_ERROR__UNAUTHORIZED, "Unauthorized", "Signer is not the Subaccord authority."),
+  SubaccordMismatch: err(ACCORD_ERROR__SUBACCORD_MISMATCH, "SubaccordMismatch", "Dispute does not belong to this Subaccord (cross-pool substitution rejected)."),
+  ImmutableSubaccord: err(ACCORD_ERROR__IMMUTABLE_SUBACCORD, "ImmutableSubaccord", "Subaccord is immutable (authority == default)."),
+  TimelockNotElapsed: err(ACCORD_ERROR__TIMELOCK_NOT_ELAPSED, "TimelockNotElapsed", "Timelock has not elapsed yet."),
+  NoPendingUpdate: err(ACCORD_ERROR__NO_PENDING_UPDATE, "NoPendingUpdate", "No pending update to execute."),
+  NotPauseAuthority: err(ACCORD_ERROR__NOT_PAUSE_AUTHORITY, "NotPauseAuthority", "Signer is not the pause authority."),
+  AlreadyPaused: err(ACCORD_ERROR__ALREADY_PAUSED, "AlreadyPaused", "Program is already paused."),
+  NotPaused: err(ACCORD_ERROR__NOT_PAUSED, "NotPaused", "Program is not paused."),
+  NoPendingUnpause: err(ACCORD_ERROR__NO_PENDING_UNPAUSE, "NoPendingUnpause", "No pending unpause to execute."),
+  UnpauseTimelockNotElapsed: err(ACCORD_ERROR__UNPAUSE_TIMELOCK_NOT_ELAPSED, "UnpauseTimelockNotElapsed", "Unpause timelock has not elapsed yet."),
+  ProgramPaused: err(ACCORD_ERROR__PROGRAM_PAUSED, "ProgramPaused", "Program is paused; this instruction is halted."),
+  InsufficientStake: err(ACCORD_ERROR__INSUFFICIENT_STAKE, "InsufficientStake", "Staked amount is below the Subaccord minimum."),
+  StakeLocked: err(ACCORD_ERROR__STAKE_LOCKED, "StakeLocked", "Cannot unstake while active_draws > 0 (stake is frozen until drawn disputes settle)."),
+  InvalidAmount: err(ACCORD_ERROR__INVALID_AMOUNT, "InvalidAmount", "Amount must be greater than zero."),
+  WithdrawalTooEarly: err(ACCORD_ERROR__WITHDRAWAL_TOO_EARLY, "WithdrawalTooEarly", "Withdrawal timelock has not elapsed yet."),
+  NoPendingWithdrawal: err(ACCORD_ERROR__NO_PENDING_WITHDRAWAL, "NoPendingWithdrawal", "No pending withdrawal to execute."),
+  InsufficientBalance: err(ACCORD_ERROR__INSUFFICIENT_BALANCE, "InsufficientBalance", "Withdrawal exceeds the Juror's free stake (amount - slash_reserve)."),
+  PendingSettlement: err(ACCORD_ERROR__PENDING_SETTLEMENT, "PendingSettlement", "Settle pending reward/slash first: call reconcile_stake before request_withdraw."),
+  WithdrawalPending: err(ACCORD_ERROR__WITHDRAWAL_PENDING, "WithdrawalPending", "A withdrawal is already pending \u2014 complete it via withdraw before requesting another."),
+  InsufficientJurors: err(ACCORD_ERROR__INSUFFICIENT_JURORS, "InsufficientJurors", "Subaccord has fewer active distinct stakers than the required panel size."),
+  InvalidOptions: err(ACCORD_ERROR__INVALID_OPTIONS, "InvalidOptions", "Dispute options are invalid (need 2..=MAX_OPTIONS)."),
+  InvalidState: err(ACCORD_ERROR__INVALID_STATE, "InvalidState", "Dispute is not in the required state for this instruction."),
+  FeeMismatch: err(ACCORD_ERROR__FEE_MISMATCH, "FeeMismatch", "Tendered fee does not match the required round-1 dispute fee (min_jury_size * fee_per_juror)."),
+  InvalidMerklePath: err(ACCORD_ERROR__INVALID_MERKLE_PATH, "InvalidMerklePath", "Accumulator Merkle path does not authenticate against the stored root."),
+  TreeFull: err(ACCORD_ERROR__TREE_FULL, "TreeFull", "Accumulator tree is full (no free leaf within the configured depth)."),
+  DuplicateJuror: err(ACCORD_ERROR__DUPLICATE_JUROR, "DuplicateJuror", "Draw selected a duplicate Juror."),
+  InvalidMembershipProof: err(ACCORD_ERROR__INVALID_MEMBERSHIP_PROOF, "InvalidMembershipProof", "Juror Merkle membership/weight proof is invalid."),
+  InvalidPanelSize: err(ACCORD_ERROR__INVALID_PANEL_SIZE, "InvalidPanelSize", "Number of juror memberships does not match the required panel size."),
+  InflatedStake: err(ACCORD_ERROR__INFLATED_STAKE, "InflatedStake", "Drawn juror's live stake is below the accumulator leaf's claim (inflation guard, ADR-0012)."),
+  SortitionMismatch: err(ACCORD_ERROR__SORTITION_MISMATCH, "SortitionMismatch", "Submitted membership does not match the VRF-derived sortition selection (ADR-0009)."),
+  VrfAlreadyCommitted: err(ACCORD_ERROR__VRF_ALREADY_COMMITTED, "VrfAlreadyCommitted", "VRF result already committed for this dispute."),
+  VrfNotCommitted: err(ACCORD_ERROR__VRF_NOT_COMMITTED, "VrfNotCommitted", "No VRF result committed for this dispute; the root is not yet frozen."),
+  CommitAlreadyExists: err(ACCORD_ERROR__COMMIT_ALREADY_EXISTS, "CommitAlreadyExists", "Juror has already committed."),
+  CommitMissing: err(ACCORD_ERROR__COMMIT_MISSING, "CommitMissing", "No commit to reveal for this Juror."),
+  RevealMismatch: err(ACCORD_ERROR__REVEAL_MISMATCH, "RevealMismatch", "Reveal does not match the committed hash."),
+  CommitWindowClosed: err(ACCORD_ERROR__COMMIT_WINDOW_CLOSED, "CommitWindowClosed", "Commit window is closed."),
+  RevealWindowClosed: err(ACCORD_ERROR__REVEAL_WINDOW_CLOSED, "RevealWindowClosed", "Reveal window is closed."),
+  NotDrawnJuror: err(ACCORD_ERROR__NOT_DRAWN_JUROR, "NotDrawnJuror", "Signer is not a drawn Juror for this round."),
+  InvalidVote: err(ACCORD_ERROR__INVALID_VOTE, "InvalidVote", "Revealed vote index is out of range."),
+  AlreadyRevealed: err(ACCORD_ERROR__ALREADY_REVEALED, "AlreadyRevealed", "Juror has already revealed."),
+  AppealWindowOpen: err(ACCORD_ERROR__APPEAL_WINDOW_OPEN, "AppealWindowOpen", "Appeal window has not elapsed yet."),
+  MaxAppealsReached: err(ACCORD_ERROR__MAX_APPEALS_REACHED, "MaxAppealsReached", "Maximum appeals reached for this dispute."),
+  MaxAppealsLimitExceeded: err(ACCORD_ERROR__MAX_APPEALS_LIMIT_EXCEEDED, "MaxAppealsLimitExceeded", "Subaccord max_appeals exceeds the program ceiling."),
+  AppealWindowClosed: err(ACCORD_ERROR__APPEAL_WINDOW_CLOSED, "AppealWindowClosed", "Appeal window has closed; the dispute can only be finalized."),
+  AppealWindowTooShort: err(ACCORD_ERROR__APPEAL_WINDOW_TOO_SHORT, "AppealWindowTooShort", "Appeal window is below the per-Subaccord floor (MIN_APPEAL_WINDOW_SECS)."),
+  RoundNotFinalizable: err(ACCORD_ERROR__ROUND_NOT_FINALIZABLE, "RoundNotFinalizable", "Round cannot be finalized yet (window not elapsed)."),
+  DisputeNotFinal: err(ACCORD_ERROR__DISPUTE_NOT_FINAL, "DisputeNotFinal", "Dispute is not in a finalizable state."),
+  ArithmeticOverflow: err(ACCORD_ERROR__ARITHMETIC_OVERFLOW, "ArithmeticOverflow", "Arithmetic overflow."),
+  RoundAlreadySettled: err(ACCORD_ERROR__ROUND_ALREADY_SETTLED, "RoundAlreadySettled", "Round has already been settled."),
+  RoundNotSettlable: err(ACCORD_ERROR__ROUND_NOT_SETTLABLE, "RoundNotSettlable", "Round index out of range for settlement (must be < current_round)."),
+  DisputeFailed: err(ACCORD_ERROR__DISPUTE_FAILED, "DisputeFailed", "Dispute is in terminal Failed state."),
+  CancelTooEarly: err(ACCORD_ERROR__CANCEL_TOO_EARLY, "CancelTooEarly", "Dispute has not exceeded its stage timeout; cancel_dispute is not yet available."),
+  MaxRetriesExceeded: err(ACCORD_ERROR__MAX_RETRIES_EXCEEDED, "MaxRetriesExceeded", "Sortition retries exceeded the on-chain bound; the pool may be too concentrated."),
+  NoFeesEarned: err(ACCORD_ERROR__NO_FEES_EARNED, "NoFeesEarned", "Juror has no earned fees to withdraw."),
+  NotRedrawEligible: err(ACCORD_ERROR__NOT_REDRAW_ELIGIBLE, "NotRedrawEligible", "Dispute is not in RedrawEligible state; redraw is not available."),
+  MaxDrawAttemptsLimitExceeded: err(ACCORD_ERROR__MAX_DRAW_ATTEMPTS_LIMIT_EXCEEDED, "MaxDrawAttemptsLimitExceeded", "Subaccord max_draw_attempts exceeds the program ceiling."),
+  InvalidThreshold: err(ACCORD_ERROR__INVALID_THRESHOLD, "InvalidThreshold", "Basis-point value out of range (must be <= 10_000; reveal threshold or alpha)."),
+  AttestationMissing: err(ACCORD_ERROR__ATTESTATION_MISSING, "AttestationMissing", "Subaccord is credential-gated but no attestation account was provided."),
+  AttestationBindingPartial: err(ACCORD_ERROR__ATTESTATION_BINDING_PARTIAL, "AttestationBindingPartial", "Credential and schema must be set together (both-or-neither)."),
+  AttestationMalformed: err(ACCORD_ERROR__ATTESTATION_MALFORMED, "AttestationMalformed", "Attestation account is malformed (wrong owner, discriminator, or too short)."),
+  AttestationMismatch: err(ACCORD_ERROR__ATTESTATION_MISMATCH, "AttestationMismatch", "Attestation credential or schema does not match the Subaccord binding."),
+  AttestationSubjectMismatch: err(ACCORD_ERROR__ATTESTATION_SUBJECT_MISMATCH, "AttestationSubjectMismatch", "Attestation subject wallet does not match the juror."),
+  AttestationExpired: err(ACCORD_ERROR__ATTESTATION_EXPIRED, "AttestationExpired", "Attestation has expired or will expire before the dispute lifecycle completes."),
+  AttestationNotExpired: err(ACCORD_ERROR__ATTESTATION_NOT_EXPIRED, "AttestationNotExpired", "Attestation has not expired; prune_juror requires an actually-expired credential."),
+  SlotNotDrained: err(ACCORD_ERROR__SLOT_NOT_DRAINED, "SlotNotDrained", "JurorStake is not fully drained (staked, active_draws, stake_delta, or fees_earned > 0)."),
+  SlotAlreadyReclaimed: err(ACCORD_ERROR__SLOT_ALREADY_RECLAIMED, "SlotAlreadyReclaimed", "JurorStake slot is already on the free list (next_free != MAX)."),
+  FreeListHeadMismatch: err(ACCORD_ERROR__FREE_LIST_HEAD_MISMATCH, "FreeListHeadMismatch", "Provided freed-slot account does not match the free-list head."),
+  SlotAwaitingRecycle: err(ACCORD_ERROR__SLOT_AWAITING_RECYCLE, "SlotAwaitingRecycle", "Juror's tree slot was reclaimed and sits mid-free-list; retry once the slots ahead of it are recycled."),
+  EvenJurySize: err(ACCORD_ERROR__EVEN_JURY_SIZE, "EvenJurySize", "Round-1 jury size (min_jury_size) must be odd (tie avoidance)."),
+  LadderExceedsMaxJurors: err(ACCORD_ERROR__LADDER_EXCEEDS_MAX_JURORS, "LadderExceedsMaxJurors", "The appeal ladder (min_jury_size, max_appeals) exceeds MAX_JURORS at its top round."),
+  FeeDominatesSlash: err(ACCORD_ERROR__FEE_DOMINATES_SLASH, "FeeDominatesSlash", "Same-mint pool is fee-dominated: alpha_bps\xB7min_stake/10_000 must cover MIN_SLASH_FEE_RATIO\xB7fee_per_juror.")
 };
 
 // src/methods/stakeFlow.ts
@@ -8611,6 +8700,7 @@ __name(disputePhase, "disputePhase");
 
 // src/queries.ts
 import {
+  getAddressEncoder as getAddressEncoder35,
   parseBase64RpcAccount
 } from "@solana/kit";
 function discriminatorToBase64(d) {
@@ -8655,6 +8745,45 @@ async function findAllPendingUpdates(rpc, config) {
   );
 }
 __name(findAllPendingUpdates, "findAllPendingUpdates");
+var SAS_PROGRAM_ID2 = "22zoJMtdu4tQc2PzL74ZUT7FrwgB1Udec8DdW4yw4BdG";
+var SAS_CREDENTIAL_OFFSET = 33;
+var SAS_SCHEMA_OFFSET = 65;
+var SAS_WALLET_OFFSET = 101;
+function addressToBase64(a) {
+  return btoa(String.fromCharCode(...getAddressEncoder35().encode(a)));
+}
+__name(addressToBase64, "addressToBase64");
+async function findSasAttestation(rpc, binding, config) {
+  const found = await rpc.getProgramAccounts(SAS_PROGRAM_ID2, {
+    encoding: "base64",
+    filters: [
+      {
+        memcmp: {
+          bytes: addressToBase64(binding.credential),
+          offset: BigInt(SAS_CREDENTIAL_OFFSET),
+          encoding: "base64"
+        }
+      },
+      {
+        memcmp: {
+          bytes: addressToBase64(binding.schema),
+          offset: BigInt(SAS_SCHEMA_OFFSET),
+          encoding: "base64"
+        }
+      },
+      {
+        memcmp: {
+          bytes: addressToBase64(binding.juror),
+          offset: BigInt(SAS_WALLET_OFFSET),
+          encoding: "base64"
+        }
+      }
+    ],
+    commitment: config?.commitment
+  }).send();
+  return found.length > 0 ? found[0].pubkey : null;
+}
+__name(findSasAttestation, "findSasAttestation");
 
 // src/domain.ts
 import { sha256 as sha2563 } from "@noble/hashes/sha256";
@@ -8807,6 +8936,9 @@ export {
   NO_RULING,
   NO_VOTE,
   ROUND_DISCRIMINATOR,
+  SAS_ATTESTATION_DISCRIMINATOR,
+  SAS_ATTESTATION_MIN_LEN,
+  SAS_PROGRAM_ID,
   SDK_NAME,
   SDK_VERSION,
   SUBACCORD_DISCRIMINATOR,
@@ -8851,6 +8983,7 @@ export {
   createAccordMethods,
   createDispute,
   createSubaccord,
+  decodeSasAttestation,
   decodeScalarVote,
   disputePhase,
   disputeSeeds,
@@ -8901,6 +9034,8 @@ export {
   findPendingUpdatePda,
   findProgramIdentityPda,
   findRoundPda2 as findRoundPda,
+  findSasAttestation,
+  findSasAttestations,
   findSubaccordPda,
   getAccordStateDecoder,
   getAggregationCodec,