@cypher-zk/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,507 @@
+import { i as Cypher, C as CypherClient, j as ComputationResult, k as CircuitName } from './client-CO5-Gpyu.js';
+export { A as ACCOUNT_DISCRIMINATOR_SIZE, l as ALL_CIRCUITS, m as ALL_EVENT_NAMES, n as AdminClaimRemainingParams, o as AwaitComputationOptions, B as BPS_DENOMINATOR, p as BetPlacedEvent, q as CIRCUITS, r as CLUSTERS, s as CREATOR_BOND, a as CancelMarketParams, c as ClaimInputs, t as ClaimParams, b as ClaimResult, u as ClusterConfig, v as ClusterName, w as CreateMarketMultiParams, e as CreateMarketParams, d as CreateMarketResult, x as CreatorWithdrawnEvent, y as CypherClientOptions, h as CypherEvent, z as CypherEventName, D as DEFAULT_CLAIM_PERIOD_SECS, F as DEFAULT_REFUND_PERIOD_SECS, H as DEFAULT_RESOLUTION_WINDOW_SECS, E as EncryptedPositionAccount, I as EventCallback, J as EventSubscription, G as GlobalStateAccount, K as INIT_COMP_DEF_INSTRUCTIONS, L as InitCompDefMethodName, N as InitCompDefParams, O as InitializeParams, Q as KNOWN_MINTS, T as LpPositionAccount, U as MAX_LP_FEE_BPS, V as MAX_OUTCOMES_MULTI, W as MAX_PROTOCOL_FEE_BPS, X as MAX_QUESTION_BYTES, Y as MIN_BET_USDC, Z as MIN_OUTCOMES_MULTI, M as MarketAccount, _ as MarketCancelledEvent, $ as MarketCategory, a0 as MarketCategoryValue, a1 as MarketCreatedEvent, a2 as MarketResolvedEvent, a3 as MarketState, a4 as MarketStateValue, a5 as MarketType, a6 as MarketTypeValue, a7 as ODDS_SCALE, a8 as PROGRAM_ID, a9 as PayoutClaimedEvent, f as PlaceBetInputs, P as PlaceBetResult, aa as PlacePrivateBetParams, ab as PollEventsOptions, ac as PolledEvent, ad as RefundClaimedEvent, g as ResolveMarketInputs, ae as ResolveMarketParams, R as ResolveMarketResult, S as SubscribeOptions, af as UpdateAcceptedMintParams, ag as UserCryptoKeypair, ah as Wallet, ai as WithdrawCreatorFundsParams, aj as adminClaimRemainingIx, ak as awaitComputation, al as buildAllInitCompDefIx, am as cancelMarketAction, an as cancelMarketIx, ao as claimPayoutAction, ap as claimPayoutMultiIx, aq as claimPayoutYesnoIx, ar as claimRefundAction, as as claimRefundMultiIx, at as claimRefundYesnoIx, au as compDefOffsetBytes, av as compDefOffsetU32, aw as createCipher, ax as createMarketAction, ay as createMarketIx, az as createMarketMultiAction, aA as createMarketMultiIx, aB as createUserKeypair, aC as deriveSharedSecret, aD as fetchAllMarkets, aE as fetchGlobalState, aF as fetchLpPosition, aG as fetchLpPositionsByProvider, aH as fetchMarket, aI as fetchMarketsByCreator, aJ as fetchMarketsByState, aK as fetchMxePublicKey, aL as fetchPosition, aM as fetchPositionsForMarket, aN as fetchUserPositions, aO as freshNonce, aP as initCompDefIx, aQ as initializeIx, aR as keypairToWallet, aS as leBytesToBigInt, aT as onBetPlaced, aU as onCreatorWithdrawn, aV as onMarketCancelled, aW as onMarketCreated, aX as onMarketResolved, aY as onPayoutClaimed, aZ as onRefundClaimed, a_ as parseLogs, a$ as parseLogsFor, b0 as placeBetAction, b1 as placePrivateBetMultiIx, b2 as placePrivateBetYesnoIx, b3 as pollEvents, b4 as randomComputationOffset, b5 as readonlyWallet, b6 as resolveMarketAction, b7 as resolveMarketMultiIx, b8 as resolveMarketYesnoIx, b9 as subscribeAll, ba as subscribeEvent, bb as updateAcceptedMintIx, bc as withdrawCreatorFundsAction, bd as withdrawCreatorFundsIx } from './client-CO5-Gpyu.js';
+import { GetProgramAccountsFilter, PublicKey, Signer, ConfirmOptions, TransactionInstruction } from '@solana/web3.js';
+import { BN } from '@anchor-lang/core';
+import { RescueCipher } from '@arcium-hq/client';
+export { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync } from '@solana/spl-token';
+
+declare const IDL: Cypher;
+declare const IDL_PROGRAM_ID: "cyphPe923pnPGVXJL3a3P7t2W9mJsagBcg1oeauoh2B";
+
+/** Filter matching the 8-byte Anchor discriminator of `accountName`. */
+declare function discriminatorFilter(accountName: string): GetProgramAccountsFilter;
+declare const marketFilters: {
+    discriminator: () => GetProgramAccountsFilter;
+    byCreator: (creator: PublicKey) => GetProgramAccountsFilter;
+    byResolver: (resolver: PublicKey) => GetProgramAccountsFilter;
+    byState: (state: number) => GetProgramAccountsFilter;
+    byCategory: (category: number) => GetProgramAccountsFilter;
+    byMarketType: (mt: number) => GetProgramAccountsFilter;
+};
+declare const positionFilters: {
+    discriminator: () => GetProgramAccountsFilter;
+    byUser: (user: PublicKey) => GetProgramAccountsFilter;
+    byMarket: (market: PublicKey) => GetProgramAccountsFilter;
+};
+declare const lpPositionFilters: {
+    discriminator: () => GetProgramAccountsFilter;
+    byProvider: (lpProvider: PublicKey) => GetProgramAccountsFilter;
+    byMarket: (market: PublicKey) => GetProgramAccountsFilter;
+};
+
+/**
+ * Hard-coded byte offsets (post-discriminator) for memcmp filters on every
+ * `getProgramAccounts` query the SDK runs.
+ *
+ * These mirror the field order in `cypher-main/programs/cypher_main/src/states.rs`.
+ * `accounts/filter.test.ts` recomputes them dynamically from the synced IDL
+ * type layout and asserts equality — so if a contributor reorders a field
+ * upstream, the SDK build fails on the next `bun run sync:idl`.
+ *
+ * Offsets here are *relative to the account body*. Helpers in `filter.ts`
+ * add `ACCOUNT_DISCRIMINATOR_SIZE` (8) when emitting memcmp filters.
+ */
+declare const MARKET_OFFSETS: {
+    readonly marketId: 0;
+    readonly question: 8;
+    readonly questionLen: 208;
+    readonly marketType: 209;
+    readonly numOutcomes: 210;
+    readonly category: 211;
+    readonly creator: 212;
+    readonly resolver: 244;
+    readonly creatorBond: 276;
+    readonly bondWithdrawn: 284;
+    readonly totalBetsCount: 285;
+    readonly encryptedPool0: 293;
+    readonly encryptedPool1: 325;
+    readonly encryptedPool2: 357;
+    readonly encryptedPool3: 389;
+    readonly mxeNonce: 421;
+    readonly revealedPool0: 437;
+    readonly revealedPool1: 445;
+    readonly revealedPool2: 453;
+    readonly revealedPool3: 461;
+    readonly state: 469;
+    readonly outcome: 470;
+    readonly pendingOutcome: 471;
+    readonly closeTime: 472;
+    readonly resolutionTime: 480;
+    readonly payoutRatio: 488;
+    readonly accumulatedLpFees: 496;
+    readonly accumulatedProtocolFees: 504;
+    readonly minBet: 512;
+    readonly totalPayoutsClaimed: 520;
+    readonly totalRefundsClaimed: 528;
+    readonly adminClaimedRemaining: 536;
+    readonly resolutionDeadline: 537;
+    readonly claimDeadline: 545;
+    readonly refundDeadline: 553;
+    readonly bump: 561;
+    readonly vaultBump: 562;
+};
+declare const ENCRYPTED_POSITION_OFFSETS: {
+    readonly user: 0;
+    readonly market: 32;
+    readonly encryptedAmount: 64;
+    readonly encryptedSide: 96;
+    readonly userPubkey: 128;
+    readonly nonce: 160;
+    readonly entryOdds: 176;
+    readonly netAmount: 184;
+    readonly claimed: 192;
+    readonly bump: 193;
+};
+declare const LP_POSITION_OFFSETS: {
+    readonly lpProvider: 0;
+    readonly market: 32;
+    readonly liquidityProvided: 64;
+    readonly feesEarned: 72;
+    readonly feesClaimed: 80;
+    readonly feesClaimedAmount: 81;
+    readonly bump: 89;
+};
+declare const GLOBAL_STATE_OFFSETS: {
+    readonly marketCounter: 0;
+    readonly protocolFeeRate: 8;
+    readonly lpFeeRate: 10;
+    readonly protocolTreasury: 12;
+    readonly acceptedMint: 44;
+    readonly admin: 76;
+    readonly bump: 108;
+};
+
+/** Address Lookup Table program ID — required by `init_*_comp_def` ixs. */
+declare const ADDRESS_LOOKUP_TABLE_PROGRAM_ID: PublicKey;
+/** Convert `bigint | number | BN` → `BN`. Idempotent. */
+declare function toBN(v: bigint | number | BN): BN;
+/** The default ATA derivation for `(owner, mint)`. */
+declare function userAta(owner: PublicKey, mint: PublicKey): PublicKey;
+
+interface SendIxOptions {
+    /** Additional Keypair signers (most flows only need the wallet's signer). */
+    signers?: Signer[];
+    /** Anchor confirmation options override. */
+    confirmOptions?: ConfirmOptions;
+}
+/**
+ * Wrap a single instruction in a legacy `Transaction`, sign with the
+ * provider's wallet (plus any extra `signers`), and send via the Anchor
+ * provider. Returns the confirmed signature.
+ *
+ * Errors are reshaped through `parseCypherError` so the caller gets a
+ * `ParsedCypherError` (when the program rejected the call) instead of
+ * Anchor's nested error objects.
+ */
+declare function sendIx(client: CypherClient, ix: TransactionInstruction, opts?: SendIxOptions): Promise<string>;
+/**
+ * Send an instruction that queues an Arcium computation, then block until
+ * the MPC nodes finalize the callback. Returns both the queue tx
+ * signature and the computation finalization details.
+ *
+ * Used by every action that touches the bet / resolve / claim path.
+ */
+declare function sendIxAndAwaitArcium(client: CypherClient, ix: TransactionInstruction, params: {
+    computationOffset: bigint;
+    timeoutMs?: number;
+    signers?: Signer[];
+    confirmOptions?: ConfirmOptions;
+}): Promise<{
+    signature: string;
+    computation: ComputationResult;
+}>;
+
+/**
+ * A user's plaintext bet input as the circuits expect it.
+ *
+ * `amount` is the **net** stake (after on-chain protocol + LP fee) — the
+ * circuit asserts equality with the on-chain `net_amount` argument, so a
+ * caller who encrypts the gross bet will see the queue succeed and the
+ * callback hard-zero their stake (see audit finding H-1 / the
+ * `net_amount_plaintext` checks in `encrypted-ixs/src/lib.rs`).
+ */
+interface BetInput {
+    /** Net stake in micro-USDC. Must equal `bet_amount - protocol_fee - lp_fee`. */
+    amount: bigint;
+    /** Outcome index: 0 / 1 for YesNo, 0..3 for MultiOutcome. */
+    side: number;
+}
+/** Plaintext input to the refund circuit — the user's original net stake. */
+interface RefundInput {
+    amount: bigint;
+}
+/** Encrypted form of a `BetInput`, ready for the queue instruction. */
+interface EncryptedBetInput {
+    /** 32-byte ciphertext for `amount`. */
+    encryptedAmount: Uint8Array;
+    /** 32-byte ciphertext for `side`. */
+    encryptedSide: Uint8Array;
+    /** 16-byte nonce used for *both* ciphertexts (CTR mode, single message). */
+    nonceBytes: Uint8Array;
+    /** Same nonce as a `u128` `bigint` — the form the on-chain ix takes. */
+    nonce: bigint;
+}
+/** Encrypted form of a `RefundInput` (single scalar — only the amount is private). */
+interface EncryptedRefundInput {
+    encryptedAmount: Uint8Array;
+    nonceBytes: Uint8Array;
+    nonce: bigint;
+}
+/**
+ * Encrypt `(amount, side)` as a single Rescue message with one nonce.
+ *
+ * Returns **two separate 32-byte ciphertexts** — they are *not*
+ * concatenated. Each scalar maps to its own ciphertext per the Arcium
+ * SKILL.md gotcha ("Combined ciphertext arrays"): the on-chain ix expects
+ * `encrypted_amount: [u8; 32]` and `encrypted_side: [u8; 32]` as
+ * independent arguments.
+ *
+ * The caller is responsible for picking a fresh nonce per call — pass
+ * `nonceBytes` if you want to control it, otherwise a 16-byte random
+ * nonce is generated.
+ */
+declare function encryptBetInput(input: BetInput, cipher: RescueCipher, nonceBytes?: Uint8Array): EncryptedBetInput;
+/**
+ * Encrypt the refund input — a single scalar (the user's net stake).
+ *
+ * The refund circuit decrypts the amount and caps it to the on-chain
+ * `net_amount_plaintext` argument before transferring, so the caller
+ * must pass the same `amount` the on-chain `EncryptedPosition.net_amount`
+ * already records.
+ */
+declare function encryptRefundInput(input: RefundInput, cipher: RescueCipher, nonceBytes?: Uint8Array): EncryptedRefundInput;
+/**
+ * Decrypt a previously-encrypted `BetInput` — used by the SDK consumer
+ * who held onto their x25519 private key and wants to display the stake +
+ * side after fetching their `EncryptedPosition` from chain.
+ *
+ * The caller must hand the same 16-byte nonce the original encrypt used;
+ * it lives on `EncryptedPosition.nonce` (a `u128`) so call
+ * `bigIntToLeBytes(position.nonce, 16)` to round-trip.
+ */
+declare function decryptBetInput(encrypted: {
+    encryptedAmount: Uint8Array;
+    encryptedSide: Uint8Array;
+}, cipher: RescueCipher, nonceBytes: Uint8Array): BetInput;
+/** Round-trip helper: bigint → 16-byte LE Uint8Array (for u128 nonces). */
+declare function bigIntToLeBytes(value: bigint, byteLength: number): Uint8Array;
+
+/**
+ * PDA derivation helpers for every account the Cypher program creates.
+ *
+ * Seeds mirror `programs/cypher_main/src/lib.rs` exactly — verified
+ * against the synced IDL in `pda.test.ts`. Always call these helpers
+ * rather than re-deriving inline; on-chain seed changes will then show
+ * up in one place.
+ *
+ * Every helper accepts an optional `programId` argument so callers can
+ * derive against a non-default deployment (e.g., the `arcium localnet`
+ * harness occasionally redeploys under a fresh keypair).
+ */
+/** Accepts bigint, number, or any BN-like (anything with .toString → u64 string). */
+type U64Like = bigint | number | {
+    toString(): string;
+};
+/** `[b"global_state"]` — singleton config PDA. */
+declare function globalStatePda(programId?: PublicKey): [PublicKey, number];
+/** `[b"market", market_id u64 LE]` — one per market. Accepts BN-like. */
+declare function marketPda(marketId: U64Like, programId?: PublicKey): [PublicKey, number];
+/** `[b"market_vault", market]` — PDA-owned SPL token account holding stakes. */
+declare function marketVaultPda(market: PublicKey, programId?: PublicKey): [PublicKey, number];
+/** `[b"position", market, user]` — encrypted bet position per user per market. */
+declare function positionPda(market: PublicKey, user: PublicKey, programId?: PublicKey): [PublicKey, number];
+/** `[b"lp-position", market, creator]` — bond + LP fee accounting. */
+declare function lpPositionPda(market: PublicKey, creator: PublicKey, programId?: PublicKey): [PublicKey, number];
+/**
+ * `[b"ArciumSignerAccount"]` — Arcium-side signer PDA used as the queue-time
+ * CPI authority for callback verification. The seed literal is dictated by
+ * the Arcium macro `derive_sign_pda!()`; see arcium SKILL.md.
+ */
+declare function arciumSignerPda(programId?: PublicKey): [PublicKey, number];
+
+/**
+ * Snapshot of the on-chain fee configuration the user needs to compute
+ * exact pre-trade values without a `getAccountInfo` round-trip.
+ *
+ * Populate `protocolFeeRateBps` / `lpFeeRateBps` from `GlobalState`.
+ */
+interface FeeRates {
+    /** Protocol fee in basis points (max 100 = 1%). */
+    protocolFeeRateBps: number;
+    /** LP fee in basis points (max 500 = 5%). */
+    lpFeeRateBps: number;
+}
+/**
+ * Breakdown of the on-chain math applied to a bet of `amount` micro-USDC.
+ *
+ * Mirrors the program exactly (see `place_private_bet_yesno` in
+ * `cypher-main/programs/cypher_main/src/lib.rs`):
+ *
+ *   protocolFee = floor(amount * protocolFeeRateBps / 10_000)
+ *   lpFee       = floor(amount * lpFeeRateBps       / 10_000)
+ *   netAmount   = amount - protocolFee - lpFee
+ *
+ * The circuit asserts `netAmount` matches what the client encrypted, so
+ * surfacing it here is critical for UX previews and equally critical for
+ * the place-bet action helper that gets built in a later phase.
+ */
+interface FeeBreakdown {
+    /** Original bet, unchanged (just echoed back for symmetry). */
+    amount: bigint;
+    /** Protocol fee that leaves the market vault → treasury. */
+    protocolFee: bigint;
+    /** LP fee credited to `market.accumulated_lp_fees`. */
+    lpFee: bigint;
+    /**
+     * Net stake that ends up in the encrypted position and is shielded
+     * by the circuit (`net_amount_plaintext` argument to the bet circuit).
+     */
+    netAmount: bigint;
+}
+/**
+ * Compute the fee split for a single bet, matching on-chain math exactly.
+ *
+ * Uses `bigint` end-to-end to mirror Solana's `u64` overflow semantics.
+ * Throws if any value would exceed `u64`.
+ */
+declare function computeFees(amount: bigint, rates: FeeRates): FeeBreakdown;
+/**
+ * Returns `true` if `amount` satisfies `market.min_bet` *and* leaves a
+ * non-zero `netAmount` after fees. The on-chain check is just the first
+ * half — but a bet that nets to zero would create a useless position, so
+ * we surface the stronger condition here.
+ */
+declare function isBetAmountValid(amount: bigint, rates: FeeRates, minBet?: bigint): boolean;
+
+/**
+ * High-level lifecycle phase of a market — what action (if any) is
+ * available *right now* to which user.
+ *
+ * Mirrors the on-chain require!() guards across the program so a frontend
+ * doesn't have to keep them in sync separately.
+ */
+type MarketPhase = 
+/** Market is open for bets (state=Active, now < close_time). */
+"betting"
+/** Bets closed, resolver may submit an outcome (now in resolution window). */
+ | "awaitingResolve"
+/** Resolved + within claim window → winners can claim payouts. */
+ | "claimable"
+/** Unresolved + past resolution deadline → bettors can claim refunds. */
+ | "refundable"
+/** Resolution claim period expired; admin sweep eligible. */
+ | "expired"
+/** Creator cancelled before any bets were placed. */
+ | "cancelled";
+/**
+ * The fields off `Market` the deadline math depends on. Kept as a minimal
+ * interface so callers can pass either a fully-decoded `Market` account or
+ * a hand-built record (e.g., from a draft create-market form).
+ */
+interface MarketDeadlineInputs {
+    state: number;
+    closeTime: bigint;
+    resolutionDeadline: bigint;
+    claimDeadline: bigint;
+    refundDeadline: bigint;
+    totalBetsCount?: bigint;
+}
+/**
+ * Compute the phase of `market` at `nowSec` (defaults to wall-clock now).
+ *
+ * Returns one of the `MarketPhase` literals — see its docs for what each
+ * means. Pure: no chain access.
+ */
+declare function marketPhase(market: MarketDeadlineInputs, nowSec?: bigint): MarketPhase;
+/**
+ * For a draft market with only `closeTime` decided, derive the four
+ * deadlines the program will set on creation (`resolution_deadline`,
+ * `claim_deadline` / `refund_deadline` are zeroed at create-time and
+ * filled in on resolve, but this helper projects the intended values so a
+ * UI can preview them).
+ */
+declare function projectDeadlines(closeTime: bigint): {
+    closeTime: bigint;
+    resolutionDeadline: bigint;
+    projectedClaimDeadline: bigint;
+    projectedRefundDeadline: bigint;
+};
+/**
+ * Returns `true` iff `closeTime` is at least 60 seconds in the future.
+ *
+ * The on-chain check is `close_time > now`, but a 60-second cushion makes
+ * the dapp robust against clock skew between the user, the RPC, and the
+ * validator.
+ */
+declare function isValidCloseTime(closeTime: bigint, nowSec?: bigint): boolean;
+
+/**
+ * Numeric error codes as declared by the `#[error_code] pub enum CypherError`
+ * block in `cypher-main/programs/cypher_main/src/lib.rs`. Synced via the
+ * shared IDL — any new error in the contract automatically becomes a new
+ * entry on this map as long as `bun run sync:idl` is rerun.
+ *
+ * Codes start at Anchor's default `6000` offset.
+ */
+declare const CypherErrorCode: {
+    readonly MarketNotActive: 6000;
+    readonly MarketClosed: 6001;
+    readonly MarketStillOpen: 6002;
+    readonly AlreadyResolved: 6003;
+    readonly NotResolved: 6004;
+    readonly UnauthorizedResolver: 6005;
+    readonly UnauthorizedAdmin: 6006;
+    readonly AlreadyClaimed: 6007;
+    readonly PositionLost: 6008;
+    readonly BetTooSmall: 6009;
+    readonly InsufficientVaultBalance: 6010;
+    readonly NoFeesToClaim: 6011;
+    readonly LiquidityTooLow: 6012;
+    readonly InvalidCloseTime: 6013;
+    readonly EmptyQuestion: 6014;
+    readonly QuestionTooLong: 6015;
+    readonly Overflow: 6016;
+    readonly InvalidOutcome: 6017;
+    readonly InvalidFeeRate: 6018;
+    readonly InvalidTreasury: 6019;
+    readonly BondAlreadyWithdrawn: 6020;
+    readonly NotMarketCreator: 6021;
+    readonly MarketHasBets: 6022;
+    readonly ResolutionDeadlinePassed: 6023;
+    readonly MarketNotUnresolved: 6024;
+    readonly ResolutionDeadlineNotReached: 6025;
+    readonly ClaimPeriodExpired: 6026;
+    readonly RefundPeriodExpired: 6027;
+    readonly AbortedComputation: 6028;
+    readonly ComputationVerificationFailed: 6029;
+    readonly CannotWithdrawFromUnresolved: 6030;
+    readonly AdminAlreadyClaimed: 6031;
+    readonly WrongMarketType: 6032;
+    readonly WrongMint: 6033;
+    readonly NotAcceptedMint: 6034;
+    readonly InvalidCategory: 6035;
+};
+type CypherErrorName = keyof typeof CypherErrorCode;
+type CypherErrorCodeValue = (typeof CypherErrorCode)[keyof typeof CypherErrorCode];
+/** Human-readable description for every code, sourced from the IDL `msg`. */
+declare const CYPHER_ERROR_MESSAGES: Readonly<Record<CypherErrorName, string>>;
+/** Look up a Cypher error name by its numeric code. */
+declare function cypherErrorName(code: number): CypherErrorName | undefined;
+/** Structured result of parsing an Anchor error. */
+interface ParsedCypherError {
+    code: CypherErrorCodeValue;
+    name: CypherErrorName;
+    msg: string;
+}
+/**
+ * Walk a thrown value and extract a CypherError if one is present.
+ *
+ * Anchor wraps program errors several different ways depending on whether
+ * the call went through `.rpc()`, `.simulate()`, or a raw transaction
+ * send; this helper handles every shape we've seen in the wild:
+ *
+ *   - Direct `AnchorError` instances with `.error.errorCode.number`.
+ *   - Plain `Error.message` strings that contain `custom program error: 0xNNNN`.
+ *   - `SendTransactionError.logs` containing the same log line.
+ *
+ * Returns `null` if the input is not a Cypher error (e.g., a network
+ * timeout or a different program's error).
+ */
+declare function parseCypherError(input: unknown): ParsedCypherError | null;
+
+/**
+ * The bundle of Arcium-side accounts every `queue_*` Anchor instruction
+ * expects. Each field corresponds to one entry in the on-chain
+ * `#[queue_computation_accounts(...)]` macro in `cypher-main/src/lib.rs`.
+ *
+ * Naming matches the Anchor account context fields in cypher-main so
+ * spread-into-`.accountsPartial(...)` works cleanly.
+ */
+interface ArciumQueueAccounts {
+    /** The per-computation PDA derived from `(clusterOffset, computationOffset)`. */
+    computationAccount: PublicKey;
+    /** Cluster PDA on the chosen Arcium cluster. */
+    clusterAccount: PublicKey;
+    /** MXE PDA for the Cypher program — the on-chain metadata holder. */
+    mxeAccount: PublicKey;
+    /** Mempool that buffers computations before assignment to executors. */
+    mempoolAccount: PublicKey;
+    /** Currently-executing pool on the cluster. */
+    executingPool: PublicKey;
+    /** Comp-def PDA holding the compiled circuit bytecode + verifier key. */
+    compDefAccount: PublicKey;
+    /** Shared Arcium fee-pool PDA. */
+    poolAccount: PublicKey;
+    /** Shared Arcium clock PDA — used to enforce monotonic ordering. */
+    clockAccount: PublicKey;
+    /** Cypher program-side signer PDA (`b"ArciumSignerAccount"`). */
+    signPdaAccount: PublicKey;
+    /** Arcium executable program ID — included for the program CPI. */
+    arciumProgram: PublicKey;
+    /** v0 lookup table containing the MXE's heavy accounts. */
+    addressLookupTable: PublicKey;
+}
+/**
+ * Derive every Arcium account the Cypher program expects for a single
+ * `queue_*` invocation. Pure: only reads from the `client` config and a
+ * caller-supplied `computationOffset`.
+ *
+ * `computationOffset` is the random u64 the caller picks per request —
+ * the on-chain `place_private_bet_*`, `resolve_market_*`, `claim_*`
+ * instructions all take it as their first argument and use it as the PDA
+ * seed for the computation account.
+ */
+declare function buildArciumQueueAccounts(client: CypherClient, params: {
+    circuit: CircuitName;
+    computationOffset: bigint | BN;
+    /** Lookup table address; if omitted, derived from the MXE account. */
+    addressLookupTable?: PublicKey;
+    /** Optional MXE LUT offset slot — needed only if you pre-fetched the MXE. */
+    lutOffsetSlot?: BN;
+}): ArciumQueueAccounts;
+declare function fetchMxeLookupTable(client: CypherClient): Promise<{
+    lut: PublicKey;
+    slot: BN;
+}>;
+
+export { ADDRESS_LOOKUP_TABLE_PROGRAM_ID, type ArciumQueueAccounts, type BetInput, CYPHER_ERROR_MESSAGES, CircuitName, ComputationResult, Cypher, CypherClient, CypherErrorCode, type CypherErrorCodeValue, type CypherErrorName, ENCRYPTED_POSITION_OFFSETS, type EncryptedBetInput, type EncryptedRefundInput, type FeeBreakdown, type FeeRates, GLOBAL_STATE_OFFSETS, IDL, IDL_PROGRAM_ID, LP_POSITION_OFFSETS, MARKET_OFFSETS, type MarketDeadlineInputs, type MarketPhase, type ParsedCypherError, type RefundInput, type SendIxOptions, arciumSignerPda, bigIntToLeBytes, buildArciumQueueAccounts, computeFees, cypherErrorName, decryptBetInput, discriminatorFilter, encryptBetInput, encryptRefundInput, fetchMxeLookupTable, globalStatePda, isBetAmountValid, isValidCloseTime, lpPositionFilters, lpPositionPda, marketFilters, marketPda, marketPhase, marketVaultPda, parseCypherError, positionFilters, positionPda, projectDeadlines, sendIx, sendIxAndAwaitArcium, toBN, userAta };