@izi-noir/sdk 0.1.0 → 0.1.2

package/dist/{wasmInit-KV6DTj4J.d.ts → wasmInit-oOZwkgo_.d.ts}

@@ -1,5 +1,5 @@
-import { C as ChainId, a as CircuitMetadata, b as ChainMetadataFor, c as Chain, I as IziNoirConfig, d as IProvingSystem } from './IProvingSystem-D9TnEig0.js';
-import { P as ProofData, S as SolanaProofData, V as VerifyingKeyData } from './types-CaaigonG.js';
+import { b as ChainId, c as CircuitMetadata, d as ChainMetadataFor, N as Network, e as Chain, a as IziNoirConfig, I as IProvingSystem } from './IProvingSystem-D0X9Rp3W.js';
+import { P as ProofData, S as SolanaProofData, V as VerifyingKeyData, C as CompileResult } from './types-CxkI04bP.js';
 import { CompiledCircuit, InputMap } from '@noir-lang/types';
 
 /**
@@ -46,6 +46,70 @@ interface IChainFormatter<TChain extends ChainId = ChainId> {
  */
 type ChainProofDataFor<T extends ChainId> = T extends 'solana' ? SolanaProofData : ProofData;
 
+/**
+ * Solana types for IZI-NOIR SDK.
+ */
+/**
+ * Minimal wallet adapter interface compatible with @solana/wallet-adapter-react.
+ *
+ * This interface requires only the essential methods for deploying and verifying
+ * proofs on Solana, making it compatible with any wallet adapter implementation.
+ *
+ * @example
+ * ```typescript
+ * // Works with @solana/wallet-adapter-react
+ * const { publicKey, sendTransaction } = useWallet();
+ *
+ * await izi.deploy({ publicKey, sendTransaction });
+ * ```
+ */
+interface WalletAdapter {
+    /**
+     * The wallet's public key.
+     */
+    publicKey: {
+        toBase58(): string;
+        toBytes(): Uint8Array;
+    } | null;
+    /**
+     * Send a transaction to the network.
+     * This signature is compatible with @solana/wallet-adapter-react's sendTransaction.
+     *
+     * @param transaction - The transaction to send (web3.js Transaction type)
+     * @param connection - The Solana connection
+     * @param options - Optional send options
+     * @returns The transaction signature
+     */
+    sendTransaction: SendTransactionFunction;
+}
+/**
+ * Function type for sending transactions.
+ * Compatible with @solana/wallet-adapter-react.
+ */
+type SendTransactionFunction = (transaction: any, connection: any, options?: any) => Promise<string>;
+/**
+ * Result of a deploy operation.
+ */
+interface DeployResult {
+    /** The VK account address (base58) */
+    vkAccount: string;
+    /** Transaction signature */
+    signature: string;
+    /** Explorer URL for the transaction */
+    explorerUrl: string;
+}
+/**
+ * Result of an on-chain verification.
+ */
+interface VerifyOnChainResult {
+    /** Whether the proof was verified successfully */
+    verified: boolean;
+    /** Transaction signature */
+    signature: string;
+    /** Explorer URL for the transaction */
+    explorerUrl: string;
+}
+
 /**
  * Data needed to deploy a verifying key to Solana.
  * Use with SolanaTransactionBuilder or your own transaction logic.
@@ -88,12 +152,23 @@ declare class IziNoir {
     private readonly chain?;
     private _verifyingKey?;
     private _lastProof?;
+    private readonly _network;
+    private _vkAccount?;
     private constructor();
     /**
-     * Get the verifying key from the last proof generation.
-     * Only available after calling prove() with a chain configured.
+     * Get the verifying key.
+     * Available after calling compile() (for Arkworks/Sunspot providers with chain configured).
      */
     get vk(): VerifyingKeyData | undefined;
+    /**
+     * Get the deployed VK account address.
+     * Only available after calling deploy().
+     */
+    get vkAccount(): string | undefined;
+    /**
+     * Get the configured network.
+     */
+    get network(): Network;
     /**
      * Get the configured chain, if any.
      */
@@ -150,16 +225,30 @@ declare class IziNoir {
     getCompiledCircuit(): CompiledCircuit | null;
     /**
      * Compile Noir code into a circuit.
+     * Performs trusted setup (generates PK and VK) during compilation.
+     * After compile(), the verifying key is available via `this.vk`.
      *
      * @param noirCode - The Noir source code to compile
-     * @returns The compiled circuit
+     * @returns CompileResult with circuit and verifying key
+     *
+     * @example
+     * ```typescript
+     * const { circuit, verifyingKey } = await izi.compile(noirCode);
+     * console.log('VK:', izi.vk);  // Available immediately after compile
+     * ```
+     */
+    compile(noirCode: string): Promise<CompileResult>;
+    /**
+     * Extract verifying key from compiled circuit.
+     * Works for Arkworks circuits that have VK cached after setup.
      */
-    compile(noirCode: string): Promise<CompiledCircuit>;
+    private extractVerifyingKey;
     /**
      * Generate a proof for the given inputs.
+     * Uses the cached proving key from compile() for fast proof generation.
      *
-     * If a chain is configured, returns chain-formatted proof data and stores
-     * the verifying key in `this.vk`. Otherwise, returns raw proof data.
+     * If a chain is configured, returns chain-formatted proof data.
+     * Otherwise, returns raw proof data.
      *
      * @param inputs - The inputs (both public and private) for the circuit
      * @param circuit - Optional circuit to use (defaults to last compiled circuit)
@@ -170,15 +259,13 @@ declare class IziNoir {
      * ```typescript
      * // With chain configured - returns SolanaProofData
      * const izi = await IziNoir.init({ provider: Provider.Arkworks, chain: Chain.Solana });
-     * await izi.compile(noirCode);
+     * await izi.compile(noirCode);  // VK available after compile
      * const proof = await izi.prove({ expected: '100', secret: '10' });
-     * // proof is SolanaProofData, izi.vk is available
      *
      * // Offchain mode - returns ProofData
      * const iziOffchain = await IziNoir.init({ provider: Provider.Arkworks });
      * await iziOffchain.compile(noirCode);
      * const rawProof = await iziOffchain.prove({ expected: '100', secret: '10' });
-     * // rawProof is ProofData, iziOffchain.vk is undefined
      * ```
      */
     prove(inputs: InputMap, circuit?: CompiledCircuit): Promise<ProofData | SolanaProofData>;
@@ -246,6 +333,54 @@ declare class IziNoir {
         programId?: string;
         computeUnits?: number;
     }): SolanaDeployData;
+    /**
+     * Deploy the verifying key to Solana.
+     *
+     * This method handles the full deployment flow:
+     * 1. Generates a keypair for the VK account
+     * 2. Builds the init transaction
+     * 3. Sends and confirms the transaction
+     * 4. Stores the VK account address on the instance
+     *
+     * @param wallet - Wallet adapter with publicKey and sendTransaction
+     * @returns Deploy result with VK account address and transaction signature
+     * @throws Error if not in Solana chain mode or prove() hasn't been called
+     *
+     * @example
+     * ```typescript
+     * const izi = await IziNoir.init({
+     *   provider: Provider.Arkworks,
+     *   chain: Chain.Solana,
+     *   network: Network.Devnet
+     * });
+     *
+     * await izi.compile(noirCode);
+     * await izi.prove(inputs);
+     *
+     * // Deploy VK in one line
+     * const { vkAccount, signature } = await izi.deploy(wallet);
+     * console.log(`VK deployed at: ${vkAccount}`);
+     * ```
+     */
+    deploy(wallet: WalletAdapter): Promise<DeployResult>;
+    /**
+     * Verify the proof on-chain.
+     *
+     * @param wallet - Wallet adapter with publicKey and sendTransaction
+     * @param vkAccount - VK account address (optional if deploy() was called on this instance)
+     * @returns Verification result with transaction signature
+     * @throws Error if not in Solana chain mode or no VK account available
+     *
+     * @example
+     * ```typescript
+     * // After deploy()
+     * const { verified, signature } = await izi.verifyOnChain(wallet);
+     *
+     * // Or with explicit VK account
+     * const { verified } = await izi.verifyOnChain(wallet, 'VkAccountAddress...');
+     * ```
+     */
+    verifyOnChain(wallet: WalletAdapter, vkAccount?: string): Promise<VerifyOnChainResult>;
 }
 
 /**
@@ -279,4 +414,4 @@ declare function isWasmInitialized(): boolean;
  */
 declare function markWasmInitialized(): void;
 
-export { type ChainProofDataFor as C, type IChainFormatter as I, type SolanaDeployData as S, IziNoir as a, isWasmInitialized as b, initNoirWasm as i, markWasmInitialized as m };
+export { type ChainProofDataFor as C, type DeployResult as D, type IChainFormatter as I, type SolanaDeployData as S, type VerifyOnChainResult as V, type WalletAdapter as W, IziNoir as a, isWasmInitialized as b, initNoirWasm as i, markWasmInitialized as m };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izi-noir/sdk",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Write ZK circuits in JavaScript/TypeScript, generate Noir code and proofs automatically",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -29,7 +29,11 @@
       "import": "./dist/providers/solana.js"
     }
   },
-  "files": ["dist", "README.md", "LICENSE"],
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch",