@cypher-zk/sdk 0.1.0 → 0.2.0

package/README.md

@@ -28,11 +28,11 @@ bun add @cypher-zk/sdk
 
 ### Peer dependencies
 
-| Package | Required for |
-| --- | --- |
-| `react` ^18/^19 | `@cypher-zk/sdk/react` hooks only |
+| Package                    | Required for                      |
+| -------------------------- | --------------------------------- |
+| `react` ^18/^19            | `@cypher-zk/sdk/react` hooks only |
 | `@tanstack/react-query` ^5 | `@cypher-zk/sdk/react` hooks only |
-| `typescript` ^5 | Type checking |
+| `typescript` ^5            | Type checking                     |
 
 ## Quick Start
 
@@ -69,7 +69,7 @@ const result = await client.actions.placeBet({
   user: wallet.publicKey,
   marketId: 0n,
   marketType: MarketType.YesNo,
-  side: 0,               // 0=YES, 1=NO
+  side: 0, // 0=YES, 1=NO
   amountUsdc: 5_000_000n, // $5 USDC (6 decimals)
 });
 
@@ -152,14 +152,16 @@ function MarketView() {
       <h1>{market?.question}</h1>
       <button
         disabled={isPending}
-        onClick={() => placeBet({
-          payer: wallet.publicKey,
-          user: wallet.publicKey,
-          marketId: 0n,
-          marketType: 0,
-          side: 0,
-          amountUsdc: 1_000_000n,
-        })}
+        onClick={() =>
+          placeBet({
+            payer: wallet.publicKey,
+            user: wallet.publicKey,
+            marketId: 0n,
+            marketType: 0,
+            side: 0,
+            amountUsdc: 1_000_000n,
+          })
+        }
       >
         Bet YES ($1)
       </button>
@@ -170,19 +172,19 @@ function MarketView() {
 
 ### Available Hooks
 
-| Hook | Type | Description |
-| --- | --- | --- |
-| `useGlobalState()` | Query | Protocol config (fees, mint, admin) |
-| `useMarket(id)` | Query | Single market by ID |
-| `useMarkets(filter?)` | Query | All/filtered markets |
-| `useUserPositions(user)` | Query | User's bet positions |
-| `usePlaceBet()` | Mutation | End-to-end private bet |
-| `useResolveMarket()` | Mutation | Resolve a market |
-| `useClaimPayout()` | Mutation | Claim winning payout |
-| `useClaimRefund()` | Mutation | Claim refund on unresolved market |
-| `useCreateMarket()` | Mutation | Create a new market |
-| `useCancelMarket()` | Mutation | Cancel a zero-bet market |
-| `useMarketEvents()` | Subscription | Live event stream |
+| Hook                     | Type         | Description                         |
+| ------------------------ | ------------ | ----------------------------------- |
+| `useGlobalState()`       | Query        | Protocol config (fees, mint, admin) |
+| `useMarket(id)`          | Query        | Single market by ID                 |
+| `useMarkets(filter?)`    | Query        | All/filtered markets                |
+| `useUserPositions(user)` | Query        | User's bet positions                |
+| `usePlaceBet()`          | Mutation     | End-to-end private bet              |
+| `useResolveMarket()`     | Mutation     | Resolve a market                    |
+| `useClaimPayout()`       | Mutation     | Claim winning payout                |
+| `useClaimRefund()`       | Mutation     | Claim refund on unresolved market   |
+| `useCreateMarket()`      | Mutation     | Create a new market                 |
+| `useCancelMarket()`      | Mutation     | Cancel a zero-bet market            |
+| `useMarketEvents()`      | Subscription | Live event stream                   |
 
 ## Architecture
 
@@ -220,11 +222,11 @@ cypher-sdk/
 
 The SDK is **cluster-agnostic** — it reads `GlobalState.accepted_mint` on-chain at runtime:
 
-| Cluster | Accepted Mint | Arcium Cluster Offset |
-| --- | --- | --- |
-| `devnet` | CSDC (`8AF9BABN…`) | `456` |
-| `mainnet` | USDC (`EPjFWdd5…`) | TBD |
-| `localnet` | CSDC (same as devnet) | `1116522022` |
+| Cluster    | Accepted Mint         | Arcium Cluster Offset |
+| ---------- | --------------------- | --------------------- |
+| `devnet`   | CSDC (`8AF9BABN…`)    | `456`                 |
+| `mainnet`  | USDC (`EPjFWdd5…`)    | TBD                   |
+| `localnet` | CSDC (same as devnet) | `1116522022`          |
 
 Override cluster detection:
 
@@ -234,7 +236,8 @@ const client = new CypherClient({ connection, wallet, cluster: "devnet" });
 
 // Fully custom
 const client = new CypherClient({
-  connection, wallet,
+  connection,
+  wallet,
   cluster: {
     name: "devnet",
     rpc: "https://my-helius-rpc.com",

package/dist/{client-CO5-Gpyu.d.ts → client-hOLBWshA.d.ts}

@@ -1,4 +1,4 @@
-import { PublicKey, Transaction, VersionedTransaction, Keypair, TransactionInstruction, Finality, Connection, Commitment, ConfirmOptions } from '@solana/web3.js';
+import { PublicKey, Transaction, VersionedTransaction, Keypair, TransactionInstruction, Finality, Signer, ConfirmOptions, Connection, Commitment } from '@solana/web3.js';
 import { BN, AnchorProvider, Program } from '@anchor-lang/core';
 import { RescueCipher } from '@arcium-hq/client';
 
@@ -92,23 +92,11 @@ type CypherEventName = CypherEvent["name"];
  * completeness assertions in tests.
  */
 declare const ALL_EVENT_NAMES: ReadonlySet<CypherEventName>;
-/**
- * Decode raw Solana program logs into typed Cypher events.
- *
- * @param logs Array of strings from a transaction's `meta.logMessages`.
- * @returns Typed events found in the logs (may be empty).
- *
- * @example
- * ```ts
- * const txInfo = await connection.getTransaction(sig, { commitment: "confirmed" });
- * const events = parseLogs(txInfo.meta?.logMessages ?? []);
- * for (const evt of events) {
- *   if (evt.name === "BetPlacedEvent") console.log(evt.data.entryOdds);
- * }
- * ```
- */
 declare function parseLogs(logs: string[]): CypherEvent[];
-declare function parseLogsFor(logs: string[], name: CypherEventName): any[];
+type DataFor$1<N extends CypherEventName> = N extends CypherEventName ? Extract<CypherEvent, {
+    name: N;
+}>["data"] : never;
+declare function parseLogsFor<N extends CypherEventName>(logs: string[], name: N): Array<DataFor$1<N>>;
 
 /**
  * Cypher program ID. Sourced from the synced IDL so it can never drift
@@ -5961,6 +5949,62 @@ declare function awaitComputation(client: CypherClient, computationOffset: bigin
  */
 declare function randomComputationOffset(): bigint;
 
+/**
+ * Lifecycle stages that an end-to-end action passes through. Surfaces via
+ * the optional `onProgress` callback on every multi-step action helper so
+ * frontends can render fine-grained progress UI ("Encrypting your bet…",
+ * "Submitting transaction…", "Waiting for MPC nodes…", "Confirmed!").
+ */
+type ActionStage = "validating" | "fetching-state" | "encrypting" | "submitting" | "awaiting-callback" | "refetching" | "done";
+/**
+ * Progress event payload. The shape stays minimal on purpose — frontends
+ * typically map `stage` to a copy string and use `signature` /
+ * `computationOffset` as the "we've reached the chain" handoff for any
+ * progress-bar logic.
+ */
+interface ActionProgressEvent {
+    stage: ActionStage;
+    /** Optional human-friendly message — populated for noteworthy stages. */
+    message?: string;
+    /** Signature once the queue tx lands ("submitting" → "awaiting-callback"). */
+    signature?: string;
+    /** Random u64 used for the Arcium computation, available after submit. */
+    computationOffset?: bigint;
+}
+type ProgressCallback = (event: ActionProgressEvent) => void;
+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;
+}>;
+
 /**
  * Result returned by the `createMarket` action.
  *
@@ -5977,10 +6021,12 @@ interface CreateMarketResult {
 /** Create a YES/NO market end-to-end. */
 declare function createMarketAction(client: CypherClient, inputs: Omit<CreateMarketParams, "expectedMarketId" | "acceptedMint"> & {
     acceptedMint?: PublicKey;
+    onProgress?: ProgressCallback;
 }): Promise<CreateMarketResult>;
 /** Create a multi-outcome market (2–4 outcomes) end-to-end. */
 declare function createMarketMultiAction(client: CypherClient, inputs: Omit<CreateMarketMultiParams, "expectedMarketId" | "acceptedMint"> & {
     acceptedMint?: PublicKey;
+    onProgress?: ProgressCallback;
 }): Promise<CreateMarketResult>;
 /** Cancel a market that has no bets. Returns the post-cancel `Market`. */
 declare function cancelMarketAction(client: CypherClient, inputs: Omit<CancelMarketParams, "acceptedMint"> & {
@@ -6063,6 +6109,13 @@ interface PlaceBetInputs {
     computationOffset?: bigint;
     /** Override timeout for the Arcium finalization wait. */
     timeoutMs?: number;
+    /**
+     * Optional fine-grained progress callback. Fires with stage events the
+     * action passes through (validating → fetching-state → encrypting →
+     * submitting → awaiting-callback → refetching → done). Use this to
+     * drive multi-step UI ("Encrypting…", "Awaiting MPC nodes…", etc.).
+     */
+    onProgress?: ProgressCallback;
 }
 interface PlaceBetResult {
     signature: string;
@@ -6106,6 +6159,8 @@ interface ResolveMarketInputs {
     outcomeValue: number;
     computationOffset?: bigint;
     timeoutMs?: number;
+    /** Optional progress callback (validating → submitting → awaiting-callback → done). */
+    onProgress?: ProgressCallback;
 }
 interface ResolveMarketResult {
     signature: string;
@@ -6129,6 +6184,8 @@ interface ClaimInputs {
     marketId: bigint | number;
     computationOffset?: bigint;
     timeoutMs?: number;
+    /** Optional progress callback (validating → submitting → awaiting-callback → done). */
+    onProgress?: ProgressCallback;
 }
 interface ClaimResult {
     signature: string;
@@ -6174,12 +6231,19 @@ interface EventSubscription {
  * ```
  */
 declare function subscribeAll(connection: Connection, callback: (event: CypherEvent) => void, opts?: SubscribeOptions): EventSubscription;
+/** Distributive helper — picks the `data` payload type for a given event name. */
+type DataFor<N extends CypherEventName> = N extends CypherEventName ? Extract<CypherEvent, {
+    name: N;
+}>["data"] : never;
 /**
  * Subscribe to a specific named event. The callback only fires for
  * events whose name matches — other events from the same tx are
  * silently dropped.
+ *
+ * Generic over `N extends CypherEventName` so the `data` parameter is
+ * narrowed to the matching event's payload type at the callsite.
  */
-declare function subscribeEvent(connection: Connection, name: CypherEventName, callback: EventCallback<any>, opts?: SubscribeOptions): EventSubscription;
+declare function subscribeEvent<N extends CypherEventName>(connection: Connection, name: N, callback: EventCallback<DataFor<N>>, opts?: SubscribeOptions): EventSubscription;
 
 /** Subscribe to `MarketCreatedEvent` emissions. */
 declare function onMarketCreated(connection: Connection, callback: EventCallback<MarketCreatedEvent>, opts?: SubscribeOptions): EventSubscription;
@@ -6351,8 +6415,13 @@ declare class CypherClient {
     readonly events: {
         /** Subscribe to all Cypher program events. */
         subscribeAll: (callback: (event: CypherEvent) => void, opts?: SubscribeOptions) => EventSubscription;
-        /** Subscribe to a specific event by name. */
-        subscribe: (name: CypherEventName, callback: (data: any, raw: CypherEvent) => void, opts?: SubscribeOptions) => EventSubscription;
+        /**
+         * Subscribe to a specific event by name. The `data` callback parameter
+         * is narrowed to the matching event's payload type via the generic.
+         */
+        subscribe: <N extends CypherEventName>(name: N, callback: (data: Extract<CypherEvent, {
+            name: N;
+        }>["data"], raw: CypherEvent) => void, opts?: SubscribeOptions) => EventSubscription;
         /** Convenience: subscribe to MarketCreatedEvent. */
         onMarketCreated: (callback: (data: MarketCreatedEvent) => void, opts?: SubscribeOptions) => EventSubscription;
         /** Convenience: subscribe to BetPlacedEvent. */
@@ -6411,4 +6480,4 @@ declare class CypherClient {
     constructor(opts: CypherClientOptions);
 }
 
-export { MarketCategory as $, ACCOUNT_DISCRIMINATOR_SIZE as A, BPS_DENOMINATOR as B, CypherClient as C, DEFAULT_CLAIM_PERIOD_SECS as D, type EncryptedPositionAccount as E, DEFAULT_REFUND_PERIOD_SECS as F, type GlobalStateAccount as G, DEFAULT_RESOLUTION_WINDOW_SECS as H, type EventCallback as I, type EventSubscription as J, INIT_COMP_DEF_INSTRUCTIONS as K, type InitCompDefMethodName as L, type MarketAccount as M, type InitCompDefParams as N, type InitializeParams as O, type PlaceBetResult as P, KNOWN_MINTS as Q, type ResolveMarketResult as R, type SubscribeOptions as S, type LpPositionAccount as T, MAX_LP_FEE_BPS as U, MAX_OUTCOMES_MULTI as V, MAX_PROTOCOL_FEE_BPS as W, MAX_QUESTION_BYTES as X, MIN_BET_USDC as Y, MIN_OUTCOMES_MULTI as Z, type MarketCancelledEvent as _, type CancelMarketParams as a, parseLogsFor as a$, type MarketCategoryValue as a0, type MarketCreatedEvent as a1, type MarketResolvedEvent as a2, MarketState as a3, type MarketStateValue as a4, MarketType as a5, type MarketTypeValue as a6, ODDS_SCALE as a7, PROGRAM_ID as a8, type PayoutClaimedEvent as a9, createMarketMultiIx as aA, createUserKeypair as aB, deriveSharedSecret as aC, fetchAllMarkets as aD, fetchGlobalState as aE, fetchLpPosition as aF, fetchLpPositionsByProvider as aG, fetchMarket as aH, fetchMarketsByCreator as aI, fetchMarketsByState as aJ, fetchMxePublicKey as aK, fetchPosition as aL, fetchPositionsForMarket as aM, fetchUserPositions as aN, freshNonce as aO, initCompDefIx as aP, initializeIx as aQ, keypairToWallet as aR, leBytesToBigInt as aS, onBetPlaced as aT, onCreatorWithdrawn as aU, onMarketCancelled as aV, onMarketCreated as aW, onMarketResolved as aX, onPayoutClaimed as aY, onRefundClaimed as aZ, parseLogs as a_, type PlacePrivateBetParams as aa, type PollEventsOptions as ab, type PolledEvent as ac, type RefundClaimedEvent as ad, type ResolveMarketParams as ae, type UpdateAcceptedMintParams as af, type UserCryptoKeypair as ag, type Wallet as ah, type WithdrawCreatorFundsParams as ai, adminClaimRemainingIx as aj, awaitComputation as ak, buildAllInitCompDefIx as al, cancelMarketAction as am, cancelMarketIx as an, claimPayoutAction as ao, claimPayoutMultiIx as ap, claimPayoutYesnoIx as aq, claimRefundAction as ar, claimRefundMultiIx as as, claimRefundYesnoIx as at, compDefOffsetBytes as au, compDefOffsetU32 as av, createCipher as aw, createMarketAction as ax, createMarketIx as ay, createMarketMultiAction as az, type ClaimResult as b, placeBetAction as b0, placePrivateBetMultiIx as b1, placePrivateBetYesnoIx as b2, pollEvents as b3, randomComputationOffset as b4, readonlyWallet as b5, resolveMarketAction as b6, resolveMarketMultiIx as b7, resolveMarketYesnoIx as b8, subscribeAll as b9, subscribeEvent as ba, updateAcceptedMintIx as bb, withdrawCreatorFundsAction as bc, withdrawCreatorFundsIx as bd, type ClaimInputs as c, type CreateMarketResult as d, type CreateMarketParams as e, type PlaceBetInputs as f, type ResolveMarketInputs as g, type CypherEvent as h, type Cypher as i, type ComputationResult as j, type CircuitName as k, ALL_CIRCUITS as l, ALL_EVENT_NAMES as m, type AdminClaimRemainingParams as n, type AwaitComputationOptions as o, type BetPlacedEvent as p, CIRCUITS as q, CLUSTERS as r, CREATOR_BOND as s, type ClaimParams as t, type ClusterConfig as u, type ClusterName as v, type CreateMarketMultiParams as w, type CreatorWithdrawnEvent as x, type CypherClientOptions as y, type CypherEventName as z };
+export { MIN_OUTCOMES_MULTI as $, ACCOUNT_DISCRIMINATOR_SIZE as A, BPS_DENOMINATOR as B, CypherClient as C, type CypherClientOptions as D, type EncryptedPositionAccount as E, type CypherEventName as F, type GlobalStateAccount as G, DEFAULT_CLAIM_PERIOD_SECS as H, DEFAULT_REFUND_PERIOD_SECS as I, DEFAULT_RESOLUTION_WINDOW_SECS as J, type EventCallback as K, type EventSubscription as L, type MarketAccount as M, INIT_COMP_DEF_INSTRUCTIONS as N, type InitCompDefMethodName as O, type PlaceBetResult as P, type InitCompDefParams as Q, type ResolveMarketResult as R, type SubscribeOptions as S, type InitializeParams as T, KNOWN_MINTS as U, type LpPositionAccount as V, MAX_LP_FEE_BPS as W, MAX_OUTCOMES_MULTI as X, MAX_PROTOCOL_FEE_BPS as Y, MAX_QUESTION_BYTES as Z, MIN_BET_USDC as _, type CancelMarketParams as a, onMarketResolved as a$, type MarketCancelledEvent as a0, MarketCategory as a1, type MarketCategoryValue as a2, type MarketCreatedEvent as a3, type MarketResolvedEvent as a4, MarketState as a5, type MarketStateValue as a6, MarketType as a7, type MarketTypeValue as a8, ODDS_SCALE as a9, createCipher as aA, createMarketAction as aB, createMarketIx as aC, createMarketMultiAction as aD, createMarketMultiIx as aE, createUserKeypair as aF, deriveSharedSecret as aG, fetchAllMarkets as aH, fetchGlobalState as aI, fetchLpPosition as aJ, fetchLpPositionsByProvider as aK, fetchMarket as aL, fetchMarketsByCreator as aM, fetchMarketsByState as aN, fetchMxePublicKey as aO, fetchPosition as aP, fetchPositionsForMarket as aQ, fetchUserPositions as aR, freshNonce as aS, initCompDefIx as aT, initializeIx as aU, keypairToWallet as aV, leBytesToBigInt as aW, onBetPlaced as aX, onCreatorWithdrawn as aY, onMarketCancelled as aZ, onMarketCreated as a_, PROGRAM_ID as aa, type PayoutClaimedEvent as ab, type PlacePrivateBetParams as ac, type PollEventsOptions as ad, type PolledEvent as ae, type ProgressCallback as af, type RefundClaimedEvent as ag, type ResolveMarketParams as ah, type SendIxOptions as ai, type UpdateAcceptedMintParams as aj, type UserCryptoKeypair as ak, type Wallet as al, type WithdrawCreatorFundsParams as am, adminClaimRemainingIx as an, awaitComputation as ao, buildAllInitCompDefIx as ap, cancelMarketAction as aq, cancelMarketIx as ar, claimPayoutAction as as, claimPayoutMultiIx as at, claimPayoutYesnoIx as au, claimRefundAction as av, claimRefundMultiIx as aw, claimRefundYesnoIx as ax, compDefOffsetBytes as ay, compDefOffsetU32 as az, type ClaimResult as b, onPayoutClaimed as b0, onRefundClaimed as b1, parseLogs as b2, parseLogsFor as b3, placeBetAction as b4, placePrivateBetMultiIx as b5, placePrivateBetYesnoIx as b6, pollEvents as b7, randomComputationOffset as b8, readonlyWallet as b9, resolveMarketAction as ba, resolveMarketMultiIx as bb, resolveMarketYesnoIx as bc, sendIx as bd, sendIxAndAwaitArcium as be, subscribeAll as bf, subscribeEvent as bg, updateAcceptedMintIx as bh, withdrawCreatorFundsAction as bi, withdrawCreatorFundsIx as bj, type ClaimInputs as c, type CreateMarketResult as d, type CreateMarketParams as e, type PlaceBetInputs as f, type ResolveMarketInputs as g, type CypherEvent as h, type Cypher as i, type CircuitName as j, ALL_CIRCUITS as k, ALL_EVENT_NAMES as l, type ActionProgressEvent as m, type ActionStage as n, type AdminClaimRemainingParams as o, type AwaitComputationOptions as p, type BetPlacedEvent as q, CIRCUITS as r, CLUSTERS as s, CREATOR_BOND as t, type ClaimParams as u, type ClusterConfig as v, type ClusterName as w, type ComputationResult as x, type CreateMarketMultiParams as y, type CreatorWithdrawnEvent as z };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-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 { i as Cypher, C as CypherClient, j as CircuitName } from './client-hOLBWshA.js';
+export { A as ACCOUNT_DISCRIMINATOR_SIZE, k as ALL_CIRCUITS, l as ALL_EVENT_NAMES, m as ActionProgressEvent, n as ActionStage, o as AdminClaimRemainingParams, p as AwaitComputationOptions, B as BPS_DENOMINATOR, q as BetPlacedEvent, r as CIRCUITS, s as CLUSTERS, t as CREATOR_BOND, a as CancelMarketParams, c as ClaimInputs, u as ClaimParams, b as ClaimResult, v as ClusterConfig, w as ClusterName, x as ComputationResult, y as CreateMarketMultiParams, e as CreateMarketParams, d as CreateMarketResult, z as CreatorWithdrawnEvent, D as CypherClientOptions, h as CypherEvent, F as CypherEventName, H as DEFAULT_CLAIM_PERIOD_SECS, I as DEFAULT_REFUND_PERIOD_SECS, J as DEFAULT_RESOLUTION_WINDOW_SECS, E as EncryptedPositionAccount, K as EventCallback, L as EventSubscription, G as GlobalStateAccount, N as INIT_COMP_DEF_INSTRUCTIONS, O as InitCompDefMethodName, Q as InitCompDefParams, T as InitializeParams, U as KNOWN_MINTS, V as LpPositionAccount, W as MAX_LP_FEE_BPS, X as MAX_OUTCOMES_MULTI, Y as MAX_PROTOCOL_FEE_BPS, Z as MAX_QUESTION_BYTES, _ as MIN_BET_USDC, $ as MIN_OUTCOMES_MULTI, M as MarketAccount, a0 as MarketCancelledEvent, a1 as MarketCategory, a2 as MarketCategoryValue, a3 as MarketCreatedEvent, a4 as MarketResolvedEvent, a5 as MarketState, a6 as MarketStateValue, a7 as MarketType, a8 as MarketTypeValue, a9 as ODDS_SCALE, aa as PROGRAM_ID, ab as PayoutClaimedEvent, f as PlaceBetInputs, P as PlaceBetResult, ac as PlacePrivateBetParams, ad as PollEventsOptions, ae as PolledEvent, af as ProgressCallback, ag as RefundClaimedEvent, g as ResolveMarketInputs, ah as ResolveMarketParams, R as ResolveMarketResult, ai as SendIxOptions, S as SubscribeOptions, aj as UpdateAcceptedMintParams, ak as UserCryptoKeypair, al as Wallet, am as WithdrawCreatorFundsParams, an as adminClaimRemainingIx, ao as awaitComputation, ap as buildAllInitCompDefIx, aq as cancelMarketAction, ar as cancelMarketIx, as as claimPayoutAction, at as claimPayoutMultiIx, au as claimPayoutYesnoIx, av as claimRefundAction, aw as claimRefundMultiIx, ax as claimRefundYesnoIx, ay as compDefOffsetBytes, az as compDefOffsetU32, aA as createCipher, aB as createMarketAction, aC as createMarketIx, aD as createMarketMultiAction, aE as createMarketMultiIx, aF as createUserKeypair, aG as deriveSharedSecret, aH as fetchAllMarkets, aI as fetchGlobalState, aJ as fetchLpPosition, aK as fetchLpPositionsByProvider, aL as fetchMarket, aM as fetchMarketsByCreator, aN as fetchMarketsByState, aO as fetchMxePublicKey, aP as fetchPosition, aQ as fetchPositionsForMarket, aR as fetchUserPositions, aS as freshNonce, aT as initCompDefIx, aU as initializeIx, aV as keypairToWallet, aW as leBytesToBigInt, aX as onBetPlaced, aY as onCreatorWithdrawn, aZ as onMarketCancelled, a_ as onMarketCreated, a$ as onMarketResolved, b0 as onPayoutClaimed, b1 as onRefundClaimed, b2 as parseLogs, b3 as parseLogsFor, b4 as placeBetAction, b5 as placePrivateBetMultiIx, b6 as placePrivateBetYesnoIx, b7 as pollEvents, b8 as randomComputationOffset, b9 as readonlyWallet, ba as resolveMarketAction, bb as resolveMarketMultiIx, bc as resolveMarketYesnoIx, bd as sendIx, be as sendIxAndAwaitArcium, bf as subscribeAll, bg as subscribeEvent, bh as updateAcceptedMintIx, bi as withdrawCreatorFundsAction, bj as withdrawCreatorFundsIx } from './client-hOLBWshA.js';
+import { GetProgramAccountsFilter, PublicKey } 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';
@@ -118,39 +118,6 @@ 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.
  *
@@ -504,4 +471,4 @@ declare function fetchMxeLookupTable(client: CypherClient): Promise<{
     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 };
+export { ADDRESS_LOOKUP_TABLE_PROGRAM_ID, type ArciumQueueAccounts, type BetInput, CYPHER_ERROR_MESSAGES, CircuitName, 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, arciumSignerPda, bigIntToLeBytes, buildArciumQueueAccounts, computeFees, cypherErrorName, decryptBetInput, discriminatorFilter, encryptBetInput, encryptRefundInput, fetchMxeLookupTable, globalStatePda, isBetAmountValid, isValidCloseTime, lpPositionFilters, lpPositionPda, marketFilters, marketPda, marketPhase, marketVaultPda, parseCypherError, positionFilters, positionPda, projectDeadlines, toBN, userAta };

package/dist/index.js

@@ -2986,6 +2986,13 @@ function randomComputationOffset() {
 }
 
 // src/actions/common.ts
+function emitProgress(cb, stage, extra) {
+  if (!cb) return;
+  try {
+    cb({ stage, ...extra });
+  } catch {
+  }
+}
 async function sendIx(client, ix, opts = {}) {
   const tx = new Transaction().add(ix);
   try {
@@ -3023,11 +3030,15 @@ function rethrowCypher(err) {
 
 // src/actions/createMarket.ts
 async function createMarketCommon(client, inputs) {
+  emitProgress(inputs.onProgress, "validating", {
+    message: "Validating market draft"
+  });
   if (!isValidCloseTime(BigInt(inputs.closeTime))) {
     throw new Error(
       "createMarket: closeTime must be at least 60 seconds in the future"
     );
   }
+  emitProgress(inputs.onProgress, "fetching-state");
   const gs = await client.globalState.fetch({ refresh: true });
   const acceptedMint = inputs.acceptedMint ?? gs.acceptedMint;
   const expectedMarketId = gs.marketCounter;
@@ -3040,9 +3051,14 @@ async function createMarketCommon(client, inputs) {
     acceptedMint,
     expectedMarketId
   });
+  emitProgress(inputs.onProgress, "submitting", {
+    message: "Submitting create-market transaction"
+  });
   const signature = await sendIx(client, ix);
+  emitProgress(inputs.onProgress, "refetching");
   const [marketPdaKey] = marketPda(expectedMarketId, client.programId);
   const market = await client.markets.fetchByPda(marketPdaKey);
+  emitProgress(inputs.onProgress, "done", { signature });
   return {
     signature,
     marketId: expectedMarketId,
@@ -3171,6 +3187,9 @@ function bigIntToLeBytes(value, byteLength) {
 
 // src/actions/placeBet.ts
 async function placeBetAction(client, inputs) {
+  emitProgress(inputs.onProgress, "validating", {
+    message: "Validating bet inputs"
+  });
   const market = await client.markets.fetch(inputs.marketId);
   if (!market) {
     throw new Error(`placeBet: market ${inputs.marketId} not found`);
@@ -3187,6 +3206,9 @@ async function placeBetAction(client, inputs) {
   if (grossAmount < MIN_BET_USDC) {
     throw new Error(`placeBet: amount ${grossAmount} < protocol MIN_BET_USDC`);
   }
+  emitProgress(inputs.onProgress, "fetching-state", {
+    message: "Fetching protocol state"
+  });
   const gs = await client.globalState.fetch();
   const { netAmount } = computeFees(grossAmount, {
     protocolFeeRateBps: gs.protocolFeeRate,
@@ -3203,6 +3225,9 @@ async function placeBetAction(client, inputs) {
     );
   }
   const { lut } = await fetchMxeLookupTable(client);
+  emitProgress(inputs.onProgress, "encrypting", {
+    message: "Encrypting your bet"
+  });
   const userKeypair = inputs.userKeypair ?? createUserKeypair();
   const cipher = createCipher(userKeypair.privateKey, mxePubkey);
   const encrypted = encryptBetInput({ amount: netAmount, side: inputs.side }, cipher);
@@ -3223,12 +3248,31 @@ async function placeBetAction(client, inputs) {
     nonce: encrypted.nonce,
     addressLookupTable: lut
   });
-  const { signature, computation } = await sendIxAndAwaitArcium(client, ix, {
-    computationOffset,
+  emitProgress(inputs.onProgress, "submitting", {
+    message: "Submitting transaction",
+    computationOffset
+  });
+  const signature = await sendIx(client, ix);
+  emitProgress(inputs.onProgress, "awaiting-callback", {
+    message: "Waiting for Arcium MPC nodes to finalize",
+    signature,
+    computationOffset
+  });
+  const computation = await awaitComputation(client, computationOffset, {
     timeoutMs: inputs.timeoutMs
   });
+  emitProgress(inputs.onProgress, "refetching", {
+    message: "Refreshing position",
+    signature,
+    computationOffset
+  });
   const [marketPdaKey] = marketPda(inputs.marketId, client.programId);
   const position = await client.positions.fetch(marketPdaKey, inputs.user);
+  emitProgress(inputs.onProgress, "done", {
+    message: "Bet placed",
+    signature,
+    computationOffset
+  });
   return {
     signature,
     computation,
@@ -3251,6 +3295,9 @@ function validateSide(side, marketType, numOutcomes) {
 
 // src/actions/resolveMarket.ts
 async function resolveMarketAction(client, inputs) {
+  emitProgress(inputs.onProgress, "validating", {
+    message: "Validating resolve inputs"
+  });
   const market = await client.markets.fetch(inputs.marketId);
   if (!market) throw new Error(`resolveMarket: market ${inputs.marketId} not found`);
   if (market.state === MarketState.Resolved) {
@@ -3260,6 +3307,7 @@ async function resolveMarketAction(client, inputs) {
     throw new Error("resolveMarket: market was cancelled");
   }
   validateOutcome(inputs.outcomeValue, market.marketType, market.numOutcomes);
+  emitProgress(inputs.onProgress, "fetching-state");
   const { lut } = await fetchMxeLookupTable(client);
   const computationOffset = inputs.computationOffset ?? randomComputationOffset();
   const isMulti = market.marketType === MarketType.MultiOutcome;
@@ -3272,17 +3320,29 @@ async function resolveMarketAction(client, inputs) {
     outcomeValue: inputs.outcomeValue,
     addressLookupTable: lut
   });
-  const { signature, computation } = await sendIxAndAwaitArcium(client, ix, {
-    computationOffset,
+  emitProgress(inputs.onProgress, "submitting", {
+    message: "Submitting resolve transaction",
+    computationOffset
+  });
+  const signature = await sendIx(client, ix);
+  emitProgress(inputs.onProgress, "awaiting-callback", {
+    message: "Waiting for MPC nodes to reveal the outcome",
+    signature,
+    computationOffset
+  });
+  const computation = await awaitComputation(client, computationOffset, {
     timeoutMs: inputs.timeoutMs
   });
+  emitProgress(inputs.onProgress, "refetching");
   const [pda] = marketPda(inputs.marketId, client.programId);
-  return {
+  const out = {
     signature,
     computation,
     computationOffset,
     market: await client.markets.fetchByPda(pda)
   };
+  emitProgress(inputs.onProgress, "done", { signature, computationOffset });
+  return out;
 }
 function validateOutcome(outcome, marketType, numOutcomes) {
   if (!Number.isInteger(outcome) || outcome < 0) {
@@ -3298,6 +3358,9 @@ function validateOutcome(outcome, marketType, numOutcomes) {
 
 // src/actions/claim.ts
 async function commonClaim(client, inputs, flavor) {
+  emitProgress(inputs.onProgress, "validating", {
+    message: `Validating claim${cap(flavor)} inputs`
+  });
   const market = await client.markets.fetch(inputs.marketId);
   if (!market) throw new Error(`claim${cap(flavor)}: market not found`);
   const [pda] = marketPda(inputs.marketId, client.programId);
@@ -3324,6 +3387,7 @@ async function commonClaim(client, inputs, flavor) {
   if (flavor === "payout" && market.state !== MarketState.Resolved) {
     throw new Error("claimPayout: market is not resolved");
   }
+  emitProgress(inputs.onProgress, "fetching-state");
   const { acceptedMint } = await client.globalState.fetch();
   const { lut } = await fetchMxeLookupTable(client);
   const computationOffset = inputs.computationOffset ?? randomComputationOffset();
@@ -3337,17 +3401,29 @@ async function commonClaim(client, inputs, flavor) {
     computationOffset,
     addressLookupTable: lut
   });
-  const { signature, computation } = await sendIxAndAwaitArcium(client, ix, {
-    computationOffset,
+  emitProgress(inputs.onProgress, "submitting", {
+    message: `Submitting ${flavor} claim`,
+    computationOffset
+  });
+  const signature = await sendIx(client, ix);
+  emitProgress(inputs.onProgress, "awaiting-callback", {
+    message: "Waiting for MPC nodes to compute and disburse",
+    signature,
+    computationOffset
+  });
+  const computation = await awaitComputation(client, computationOffset, {
     timeoutMs: inputs.timeoutMs
   });
-  return {
+  emitProgress(inputs.onProgress, "refetching");
+  const out = {
     signature,
     computation,
     computationOffset,
     position: await client.positions.fetch(pda, inputs.user),
     market: await client.markets.fetchByPda(pda)
   };
+  emitProgress(inputs.onProgress, "done", { signature, computationOffset });
+  return out;
 }
 function claimPayoutAction(client, inputs) {
   return commonClaim(client, inputs, "payout");
@@ -3376,16 +3452,49 @@ function getParser() {
   }
   return _parser;
 }
+function camelizeKey(k) {
+  return k.replace(/_([a-z0-9])/g, (_m, c) => c.toUpperCase());
+}
+function normalizeValue(v) {
+  if (v == null) return v;
+  if (typeof v === "object" && "toString" in v && "toArrayLike" in v) {
+    return BigInt(v.toString());
+  }
+  if (Array.isArray(v) && v.length > 0 && typeof v[0] === "number") {
+    return Uint8Array.from(v);
+  }
+  return v;
+}
+function camelizeObject(obj) {
+  if (obj == null || typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj;
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    out[camelizeKey(k)] = normalizeValue(v);
+  }
+  return out;
+}
 function parseLogs(logs) {
   const parser = getParser();
   const results = [];
   for (const event of parser.parseLogs(logs)) {
-    results.push(event);
+    const camelized = {
+      name: event.name,
+      data: camelizeObject(event.data)
+    };
+    results.push(camelized);
   }
   return results;
 }
+function parseLogsForRaw(logs, name) {
+  const out = [];
+  for (const e of parseLogs(logs)) {
+    if (e.name === name) out.push(e.data);
+  }
+  return out;
+}
 function parseLogsFor(logs, name) {
-  return parseLogs(logs).filter((e) => e.name === name).map((e) => e.data);
+  return parseLogsForRaw(logs, name);
 }
 
 // src/events/subscribe.ts
@@ -3562,7 +3671,16 @@ var CypherClient = class {
     };
     this.events = {
       subscribeAll: (cb, opts2) => subscribeAll(this.connection, cb, opts2),
-      subscribe: (name, cb, opts2) => subscribeEvent(this.connection, name, cb, opts2),
+      // Cast the whole wiring through `unknown` to bridge the generic
+      // signature — TS can't see through `Extract<>` when `N` is bound
+      // outside its own generic scope. The external client.events.subscribe
+      // field still narrows the callback payload via its own <N> generic.
+      subscribe: ((name, cb, opts2) => subscribeEvent(
+        this.connection,
+        name,
+        cb,
+        opts2
+      )),
       onMarketCreated: (cb, opts2) => onMarketCreated(this.connection, cb, opts2),
       onBetPlaced: (cb, opts2) => onBetPlaced(this.connection, cb, opts2),
       onMarketResolved: (cb, opts2) => onMarketResolved(this.connection, cb, opts2),