NixProtocol Documentation

import { generateStealthWallet, packNixId } from '@nixprotocol/stealth-wallet';

// Generate a complete stealth wallet
const wallet = generateStealthWallet();
console.log('Nix ID:', wallet.nixId);
// NIX_ABC123... (~75 chars, shareable payment address)

// Unpack to get components
const { evmAddress, bjjPublicKeyX, signBit } = unpackNixId(nixId);

import * as elgamal from '@nixprotocol/sdk/elgamal';

// Ciphertext structure
interface Ciphertext {
  C1: [bigint, bigint];  // g^r - randomness component
  C2: [bigint, bigint];  // h^r * g^m - message component
}

// Encrypt
const ct = elgamal.encrypt(1000n, publicKey);

// Decrypt
const value = elgamal.decrypt(ct, privateKey); // 1000n

// Homomorphic addition
const sum = elgamal.add(ct1, ct2);
// decrypt(sum) === decrypt(ct1) + decrypt(ct2)

// Register with ZK proof (~320k gas)
function register(
    uint256[2] calldata publicKey,
    bytes calldata proof
) external;

// Deposit ERC20 (~570k gas)
function deposit(address token, uint256 amount) external;

// Private transfer (~950k gas)
function privateTransfer(
    address token,
    address to,
    bytes calldata proof
) external;

// Withdraw (~800k gas)
function withdraw(address token, bytes calldata proof) external;

// Deposit creates commitment in Merkle tree
function deposit(uint256 commitment) external payable;

// Withdraw with ZK proof - UNLINKABLE to deposit
function withdraw(
    uint256 nullifierHash,
    uint256 recipient,
    uint256 amount,
    uint256[2] calldata pA,
    uint256[2][2] calldata pB,
    uint256[2] calldata pC
) external;

import { ethers } from 'ethers';
import { 
  generateKeyPair, 
  generateRegistrationProof,
  generateTransferProof,
  elgamal 
} from '@nixprotocol/sdk';
import { NixERC20__factory } from '@nixprotocol/contracts';

// Setup
const provider = new ethers.BrowserProvider(window.ethereum);
const signer = await provider.getSigner();
const nixERC20 = NixERC20__factory.connect(NIX_ERC20_ADDRESS, signer);

// Step 1: Generate keypair from wallet signature (deterministic)
const signature = await signer.signMessage("NixProtocol Key Derivation v1");
const keyPair = generateKeyPair(signature);

// Step 2: Register (one-time per address)
const isRegistered = await nixERC20.isRegistered(signer.address);
if (!isRegistered) {
  const regProof = await generateRegistrationProof(keyPair);
  const regTx = await nixERC20.register(keyPair.publicKey, regProof);
  await regTx.wait();
}

// Step 3: Deposit - convert public tokens to encrypted balance
const USDC_ADDRESS = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
const amount = ethers.parseUnits('100', 6); // 100 USDC

// First approve
const usdc = new ethers.Contract(USDC_ADDRESS, ['function approve(address,uint256)'], signer);
await (await usdc.approve(NIX_ERC20_ADDRESS, amount)).wait();

// Then deposit
const depositTx = await nixERC20.deposit(USDC_ADDRESS, amount);
await depositTx.wait();

// Step 4: Check encrypted balance
const encryptedBalance = await nixERC20.getEncryptedBalance(USDC_ADDRESS, signer.address);
const balance = elgamal.decrypt({
  C1: [encryptedBalance[0], encryptedBalance[1]],
  C2: [encryptedBalance[2], encryptedBalance[3]]
}, keyPair.privateKey);
console.log('Decrypted balance:', balance.toString()); // 100000000 (6 decimals)

// Step 5: Private transfer
const recipientPubKey = await nixERC20.getPublicKey(recipientAddress);
const transferAmount = ethers.parseUnits('25', 6);
const transferProof = await generateTransferProof({
  senderKeyPair: keyPair,
  recipientPublicKey: recipientPubKey,
  amount: transferAmount,
  currentBalance: balance,
  currentCiphertext: encryptedBalance
});

const transferTx = await nixERC20.privateTransfer(
  USDC_ADDRESS, 
  recipientAddress, 
  transferProof
);
await transferTx.wait();
console.log('Private transfer complete!');

interface INixERC20 {
  function register(uint256[2] calldata publicKey, bytes calldata proof) external;
  function deposit(address token, uint256 amount) external;
  function privateTransfer(address token, address to, bytes calldata proof) external;
  function withdraw(address token, bytes calldata proof) external;
  
  function getEncryptedBalance(address token, address user) 
    external view returns (uint256[4] memory ciphertext);
  function isRegistered(address user) external view returns (bool);
  function getPublicKey(address user) external view returns (uint256[2] memory);
}

interface INixPool {
  function deposit(uint256 commitment) external payable;
  function withdraw(
    uint256 nullifierHash,
    address recipient,
    uint256 amount,
    bytes calldata proof
  ) external;
  
  function getMerkleRoot() external view returns (uint256);
  function isSpent(uint256 nullifierHash) external view returns (bool);
}