@hula-privacy/mixer 0.1.0 → 0.3.0

package/src/merkle.ts

@@ -193,7 +193,9 @@ export async function fetchMerkleRoot(
 ): Promise<bigint> {
   const client = getRelayerClient(relayerUrl);
   const tree = await client.getTree(treeIndex);
-  return BigInt(tree.root);
+  // Handle hex strings with or without 0x prefix
+  const rootStr = tree.root.startsWith("0x") ? tree.root : `0x${tree.root}`;
+  return BigInt(rootStr);
 }
 
 /**

package/src/transaction.ts

@@ -189,6 +189,7 @@ export async function buildTransaction(
   };
 
   // Create encrypted notes for outputs with encryption keys
+  // Note: leafIndex is omitted to save space - recipient looks it up via commitment
   const encryptedNotes: Buffer[] = [];
   for (let i = 0; i < outputs.length; i++) {
     const output = outputs[i];
@@ -200,7 +201,7 @@ export async function buildTransaction(
           value: utxo.value,
           mintTokenAddress: utxo.mintTokenAddress,
           secret: utxo.secret,
-          leafIndex: utxo.leafIndex,
+          // leafIndex omitted - recipient queries relayer with computed commitment
         },
         output.encryptionPubKey
       );
@@ -217,7 +218,7 @@ export async function buildTransaction(
         value: changeUtxo.value,
         mintTokenAddress: changeUtxo.mintTokenAddress,
         secret: changeUtxo.secret,
-        leafIndex: changeUtxo.leafIndex,
+        // leafIndex omitted - we already know it locally
       },
       walletKeys.encryptionKeyPair.publicKey
     );
@@ -460,5 +461,3 @@ export function toAnchorPublicInputs(builtTx: BuiltTransaction): {
     fee: new BN(builtTx.publicInputs.fee.toString()),
   };
 }
-
-

package/src/types.ts

@@ -302,6 +302,8 @@ export interface HulaSDKConfig {
   rpcUrl: string;
   /** Relayer API endpoint */
   relayerUrl: string;
+  /** Program ID for the Hula Privacy program */
+  programId?: PublicKey;
   /** Path to circuit WASM file */
   circuitWasmPath?: string;
   /** Path to circuit zkey file */

package/src/utxo.ts

@@ -11,9 +11,11 @@ import {
   deserializeEncryptedNote,
   generateSpendingKey,
   hexToBytes,
+  pubkeyToBigInt,
 } from "./crypto";
 import { DOMAIN_NULLIFIER } from "./constants";
 import type { UTXO, WalletKeys, SerializableUTXO, NoteData } from "./types";
+import { PublicKey } from "@solana/web3.js";
 
 // ============================================================================
 // Commitment & Nullifier Computation
@@ -176,31 +178,42 @@ export function scanNotesForUTXOs(
       const decrypted = decryptNote(encryptedNote, walletKeys.encryptionKeyPair.secretKey);
       if (!decrypted) continue;
 
-      // Successfully decrypted - this is our UTXO
+      // Get the mint address from the note metadata
+      const mintAddress = note.mint;
+      const mintTokenAddress = pubkeyToBigInt(new PublicKey(mintAddress));
+
+      // Compute commitment to find the leafIndex
       const commitment = computeCommitment(
         decrypted.value,
-        decrypted.mintTokenAddress,
+        mintTokenAddress,
         walletKeys.owner,
         decrypted.secret
       );
 
-      // Verify commitment exists on-chain (optional but recommended)
+      // Find leafIndex by matching commitment in on-chain data
+      let foundLeafIndex: number | undefined;
       const treeCommitments = commitments.get(note.treeIndex);
       if (treeCommitments) {
-        const onChainCommitment = treeCommitments.get(decrypted.leafIndex);
-        if (onChainCommitment !== undefined && onChainCommitment !== commitment) {
-          console.warn(`Commitment mismatch for leaf ${decrypted.leafIndex} in tree ${note.treeIndex}`);
-          continue;
+        for (const [leafIndex, onChainCommitment] of treeCommitments.entries()) {
+          if (onChainCommitment === commitment) {
+            foundLeafIndex = leafIndex;
+            break;
+          }
         }
       }
 
+      if (foundLeafIndex === undefined) {
+        // Commitment not found on-chain yet - skip for now
+        continue;
+      }
+
       foundUTXOs.push({
         value: decrypted.value.toString(),
-        mintTokenAddress: decrypted.mintTokenAddress.toString(),
+        mintTokenAddress: mintTokenAddress.toString(),
         owner: walletKeys.owner.toString(),
         secret: decrypted.secret.toString(),
         commitment: commitment.toString(),
-        leafIndex: decrypted.leafIndex,
+        leafIndex: foundLeafIndex,
         treeIndex: note.treeIndex,
         mint: note.mint,
         spent: false,
@@ -261,8 +274,10 @@ export async function syncUTXOs(
     commitments
   );
 
+  const allUTXOs = [...newUTXOs, ...existingUTXOs];
+
   // Check which existing UTXOs have been spent
-  const unspentUTXOs = existingUTXOs.filter(u => !u.spent);
+  const unspentUTXOs = allUTXOs.filter(u => !u.spent);
   const nullifiersToCheck: string[] = [];
   const utxoByNullifier = new Map<string, string>();
 
@@ -273,7 +288,7 @@ export async function syncUTXOs(
       commitment,
       utxo.leafIndex
     );
-    const nullifierStr = nullifier.toString();
+    const nullifierStr = nullifier.toString(16).padStart(64, '0');
     nullifiersToCheck.push(nullifierStr);
     utxoByNullifier.set(nullifierStr, utxo.commitment); // Use commitment as ID
   }

package/src/wallet.ts

@@ -4,8 +4,13 @@
  * High-level wallet abstraction that manages keys, UTXOs, and syncing
  */
 
-import { PublicKey, Connection, Keypair, type TransactionInstruction } from "@solana/web3.js";
-import type { Program } from "@coral-xyz/anchor";
+import { PublicKey, Connection, Keypair, SystemProgram, ComputeBudgetProgram, Transaction, type TransactionInstruction } from "@solana/web3.js";
+import { AnchorProvider, Program, Wallet } from "@coral-xyz/anchor";
+import HulaPrivacyIdl from "./idl";
+
+// Compute budget for ZK proof verification (needs more than default 200k)
+const COMPUTE_UNITS = 400_000;
+const COMPUTE_UNIT_PRICE = 1; // microlamports per CU
 
 import {
   initPoseidon,
@@ -40,7 +45,9 @@ import type {
 export class HulaWallet {
   private connection: Connection;
   private relayerUrl: string;
+  private programId: PublicKey;
   private keys: WalletKeys;
+  private signer?: Keypair;
   private utxos: SerializableUTXO[] = [];
   private lastSyncedSlot: string = "0";
   private initialized: boolean = false;
@@ -48,11 +55,15 @@ export class HulaWallet {
   private constructor(
     connection: Connection,
     relayerUrl: string,
-    keys: WalletKeys
+    programId: PublicKey,
+    keys: WalletKeys,
+    signer?: Keypair
   ) {
     this.connection = connection;
     this.relayerUrl = relayerUrl;
+    this.programId = programId;
     this.keys = keys;
+    this.signer = signer;
   }
 
   /**
@@ -63,12 +74,38 @@ export class HulaWallet {
 
     const connection = new Connection(config.rpcUrl, "confirmed");
     const relayerUrl = config.relayerUrl;
+    const programId = config.programId ?? new PublicKey("tnJ9AAxNau3BRBTe7NzXpv8DeYyiogvGd8YPnCiuarA");
     setDefaultRelayerUrl(relayerUrl);
 
     const spendingKey = generateSpendingKey();
     const keys = deriveKeys(spendingKey);
 
-    const wallet = new HulaWallet(connection, relayerUrl, keys);
+    const wallet = new HulaWallet(connection, relayerUrl, programId, keys);
+    wallet.initialized = true;
+    return wallet;
+  }
+
+  /**
+   * Create a wallet from a Solana keypair
+   * 
+   * Derives the spending key deterministically from the keypair's secret key.
+   */
+  static async fromKeypair(
+    keypair: Keypair,
+    config: HulaSDKConfig
+  ): Promise<HulaWallet> {
+    await initPoseidon();
+
+    const connection = new Connection(config.rpcUrl, "confirmed");
+    const relayerUrl = config.relayerUrl;
+    const programId = config.programId ?? new PublicKey("tnJ9AAxNau3BRBTe7NzXpv8DeYyiogvGd8YPnCiuarA");
+    setDefaultRelayerUrl(relayerUrl);
+
+    // Derive spending key from keypair's secret key
+    const spendingKey = deriveSpendingKeyFromSignature(keypair.secretKey);
+    const keys = deriveKeys(spendingKey);
+
+    const wallet = new HulaWallet(connection, relayerUrl, programId, keys, keypair);
     wallet.initialized = true;
     return wallet;
   }
@@ -84,11 +121,12 @@ export class HulaWallet {
 
     const connection = new Connection(config.rpcUrl, "confirmed");
     const relayerUrl = config.relayerUrl;
+    const programId = config.programId ?? new PublicKey("tnJ9AAxNau3BRBTe7NzXpv8DeYyiogvGd8YPnCiuarA");
     setDefaultRelayerUrl(relayerUrl);
 
     const keys = deriveKeys(spendingKey);
 
-    const wallet = new HulaWallet(connection, relayerUrl, keys);
+    const wallet = new HulaWallet(connection, relayerUrl, programId, keys);
     wallet.initialized = true;
     return wallet;
   }
@@ -106,12 +144,13 @@ export class HulaWallet {
 
     const connection = new Connection(config.rpcUrl, "confirmed");
     const relayerUrl = config.relayerUrl;
+    const programId = config.programId ?? new PublicKey("tnJ9AAxNau3BRBTe7NzXpv8DeYyiogvGd8YPnCiuarA");
     setDefaultRelayerUrl(relayerUrl);
 
     const spendingKey = deriveSpendingKeyFromSignature(signature);
     const keys = deriveKeys(spendingKey);
 
-    const wallet = new HulaWallet(connection, relayerUrl, keys);
+    const wallet = new HulaWallet(connection, relayerUrl, programId, keys);
     wallet.initialized = true;
     return wallet;
   }
@@ -130,12 +169,19 @@ export class HulaWallet {
   /**
    * Get wallet's owner hash as hex string
    */
-  get ownerHex(): string {
-    return this.keys.owner.toString(16).padStart(64, "0");
+  getOwnerHash(): string {
+    return "0x" + this.keys.owner.toString(16).padStart(64, "0");
+  }
+
+  /**
+   * Get wallet's encryption public key as hex string
+   */
+  getEncryptionPublicKey(): string {
+    return "0x" + Buffer.from(this.keys.encryptionKeyPair.publicKey).toString("hex");
   }
 
   /**
-   * Get wallet's encryption public key
+   * Get wallet's encryption public key as bytes
    */
   get encryptionPublicKey(): Uint8Array {
     return this.keys.encryptionKeyPair.publicKey;
@@ -155,6 +201,27 @@ export class HulaWallet {
     return this.keys;
   }
 
+  /**
+   * Get the connection
+   */
+  getConnection(): Connection {
+    return this.connection;
+  }
+
+  /**
+   * Get the signer keypair (if available)
+   */
+  getSigner(): Keypair | undefined {
+    return this.signer;
+  }
+
+  /**
+   * Set the signer keypair
+   */
+  setSigner(signer: Keypair): void {
+    this.signer = signer;
+  }
+
   // ============================================================================
   // UTXO Management
   // ============================================================================
@@ -259,15 +326,21 @@ export class HulaWallet {
 
   /**
    * Deposit tokens into the privacy pool
+   * 
+   * @param mint - Token mint address
+   * @param amount - Amount in raw token units
+   * @returns Transaction signature
    */
   async deposit(
     mint: PublicKey,
     amount: bigint
-  ): Promise<{
-    transaction: ReturnType<typeof buildTransaction> extends Promise<infer T> ? T : never;
-    instructions: TransactionInstruction[];
-  }> {
-    const tx = await buildTransaction(
+  ): Promise<string> {
+    if (!this.signer) {
+      throw new Error("No signer available. Use fromKeypair() or setSigner() to set a signer.");
+    }
+
+    // Build the transaction with ZK proof
+    const builtTx = await buildTransaction(
       {
         mint,
         depositAmount: amount,
@@ -277,36 +350,76 @@ export class HulaWallet {
       this.relayerUrl
     );
 
+    // Build accounts and pre-instructions
     const { accounts, preInstructions, inputTreeIndex } = buildTransactionAccounts(
-      tx,
-      PublicKey.default, // Payer will be set by caller
+      builtTx,
+      this.signer.publicKey,
       mint,
       amount,
       0n
     );
 
-    return { transaction: tx, instructions: preInstructions };
+    // Add compute budget instructions for ZK proof verification
+    const allPreInstructions = [
+      ComputeBudgetProgram.setComputeUnitLimit({ units: COMPUTE_UNITS }),
+      ComputeBudgetProgram.setComputeUnitPrice({ microLamports: COMPUTE_UNIT_PRICE }),
+      ...preInstructions,
+    ];
+
+    // Setup Anchor program
+    const wallet = new Wallet(this.signer);
+    const provider = new AnchorProvider(this.connection, wallet, { commitment: "confirmed" });
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const program = new Program(HulaPrivacyIdl as any, provider);
+
+    // Convert public inputs to Anchor format
+    const publicInputs = toAnchorPublicInputs(builtTx);
+
+    // Submit the transaction
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const signature = await (program.methods as any)
+      .transact(
+        inputTreeIndex,
+        Array.from(builtTx.proof),
+        publicInputs,
+        builtTx.encryptedNotes
+      )
+      .accounts(accounts)
+      .preInstructions(allPreInstructions)
+      .signers([this.signer])
+      .rpc();
+
+    return signature;
   }
 
   /**
-   * Transfer tokens privately
+   * Transfer tokens privately to another user
+   * 
+   * @param mint - Token mint address
+   * @param amount - Amount in raw token units
+   * @param recipientOwner - Recipient's owner hash (bigint)
+   * @param recipientEncryptionPubKey - Recipient's encryption public key
+   * @returns Transaction signature
    */
   async transfer(
     mint: PublicKey,
     amount: bigint,
     recipientOwner: bigint,
     recipientEncryptionPubKey: Uint8Array
-  ): Promise<{
-    transaction: ReturnType<typeof buildTransaction> extends Promise<infer T> ? T : never;
-    instructions: TransactionInstruction[];
-  }> {
+  ): Promise<string> {
+    if (!this.signer) {
+      throw new Error("No signer available. Use fromKeypair() or setSigner() to set a signer.");
+    }
+
     const mintBigInt = pubkeyToBigInt(mint);
     const unspent = this.getUnspentUTXOs().filter(
       u => u.mintTokenAddress === mintBigInt
     );
     const inputUtxos = selectUTXOs(unspent, amount, mintBigInt);
 
-    const tx = await buildTransaction(
+    // Build the transaction with ZK proof
+    const builtTx = await buildTransaction(
       {
         mint,
         inputUtxos,
@@ -322,35 +435,83 @@ export class HulaWallet {
       this.relayerUrl
     );
 
-    const { preInstructions } = buildTransactionAccounts(
-      tx,
-      PublicKey.default,
+    // Build accounts and pre-instructions
+    const { accounts, preInstructions, inputTreeIndex } = buildTransactionAccounts(
+      builtTx,
+      this.signer.publicKey,
       mint,
       0n,
       0n
     );
 
-    return { transaction: tx, instructions: preInstructions };
+    // Add compute budget instructions for ZK proof verification
+    const allPreInstructions = [
+      ComputeBudgetProgram.setComputeUnitLimit({ units: COMPUTE_UNITS }),
+      ComputeBudgetProgram.setComputeUnitPrice({ microLamports: COMPUTE_UNIT_PRICE }),
+      ...preInstructions,
+    ];
+
+    // Setup Anchor program
+    const wallet = new Wallet(this.signer);
+    const provider = new AnchorProvider(this.connection, wallet, { commitment: "confirmed" });
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const program = new Program(HulaPrivacyIdl as any, provider);
+
+    // Convert public inputs to Anchor format
+    const publicInputs = toAnchorPublicInputs(builtTx);
+
+    // Submit the transaction
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const signature = await (program.methods as any)
+      .transact(
+        inputTreeIndex,
+        Array.from(builtTx.proof),
+        publicInputs,
+        builtTx.encryptedNotes
+      )
+      .accounts(accounts)
+      .preInstructions(allPreInstructions)
+      .signers([this.signer])
+      .rpc();
+
+    // Mark input UTXOs as spent locally
+    for (const utxo of inputUtxos) {
+      const serialized = this.utxos.find(u => u.commitment === utxo.commitment.toString());
+      if (serialized) {
+        serialized.spent = true;
+        serialized.spentTx = signature;
+      }
+    }
+
+    return signature;
   }
 
   /**
    * Withdraw tokens from the privacy pool to a public address
+   * 
+   * @param mint - Token mint address
+   * @param amount - Amount in raw token units
+   * @param recipient - Public key to receive the tokens
+   * @returns Transaction signature
    */
   async withdraw(
     mint: PublicKey,
     amount: bigint,
     recipient: PublicKey
-  ): Promise<{
-    transaction: ReturnType<typeof buildTransaction> extends Promise<infer T> ? T : never;
-    instructions: TransactionInstruction[];
-  }> {
+  ): Promise<string> {
+    if (!this.signer) {
+      throw new Error("No signer available. Use fromKeypair() or setSigner() to set a signer.");
+    }
+
     const mintBigInt = pubkeyToBigInt(mint);
     const unspent = this.getUnspentUTXOs().filter(
       u => u.mintTokenAddress === mintBigInt
     );
     const inputUtxos = selectUTXOs(unspent, amount, mintBigInt);
 
-    const tx = await buildTransaction(
+    // Build the transaction with ZK proof
+    const builtTx = await buildTransaction(
       {
         mint,
         inputUtxos,
@@ -361,16 +522,57 @@ export class HulaWallet {
       this.relayerUrl
     );
 
-    const { preInstructions } = buildTransactionAccounts(
-      tx,
-      PublicKey.default,
+    // Build accounts and pre-instructions
+    const { accounts, preInstructions, inputTreeIndex } = buildTransactionAccounts(
+      builtTx,
+      this.signer.publicKey,
       mint,
       0n,
       amount,
       recipient
     );
 
-    return { transaction: tx, instructions: preInstructions };
+    // Add compute budget instructions for ZK proof verification
+    const allPreInstructions = [
+      ComputeBudgetProgram.setComputeUnitLimit({ units: COMPUTE_UNITS }),
+      ComputeBudgetProgram.setComputeUnitPrice({ microLamports: COMPUTE_UNIT_PRICE }),
+      ...preInstructions,
+    ];
+
+    // Setup Anchor program
+    const wallet = new Wallet(this.signer);
+    const provider = new AnchorProvider(this.connection, wallet, { commitment: "confirmed" });
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const program = new Program(HulaPrivacyIdl as any, provider);
+
+    // Convert public inputs to Anchor format
+    const publicInputs = toAnchorPublicInputs(builtTx);
+
+    // Submit the transaction
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const signature = await (program.methods as any)
+      .transact(
+        inputTreeIndex,
+        Array.from(builtTx.proof),
+        publicInputs,
+        builtTx.encryptedNotes
+      )
+      .accounts(accounts)
+      .preInstructions(allPreInstructions)
+      .signers([this.signer])
+      .rpc();
+
+    // Mark input UTXOs as spent locally
+    for (const utxo of inputUtxos) {
+      const serialized = this.utxos.find(u => u.commitment === utxo.commitment.toString());
+      if (serialized) {
+        serialized.spent = true;
+        serialized.spentTx = signature;
+      }
+    }
+
+    return signature;
   }
 
   /**