// fheClient.ts — Core FHE operations
import type { FhevmInstance } from "@zama-fhe/relayer-sdk";

let fheInstance: FhevmInstance | null = null;

// Initialize once at app startup
export async function initFhevm(): Promise<FhevmInstance> {
  if (fheInstance) return fheInstance;

  // In the browser, RelayerSDK is loaded via CDN <script> tag
  const { initSDK, createInstance, SepoliaConfig } = window.RelayerSDK;
  await initSDK();

  fheInstance = await createInstance({
    ...SepoliaConfig,
    network: window.ethereum, // MetaMask EIP-1193 provider
  });

  return fheInstance;
}

// Encrypt a value for a specific contract + user
export async function encryptValue(
  contractAddress: string,
  userAddress: string,
  value: number,
  bitSize: 8 | 16 | 32 | 64 = 32
) {
  const instance = await initFhevm();
  const input = instance.createEncryptedInput(contractAddress, userAddress);

  // Choose bit-size matching the contract param type
  if (bitSize === 8) input.add8(value);
  else if (bitSize === 16) input.add16(value);
  else if (bitSize === 32) input.add32(value);
  else input.add64(value);

  const encrypted = input.encrypt();
  return {
    handles: encrypted.handles,       // Uint8Array[] — pass to contract
    inputProof: encrypted.inputProof, // Uint8Array — ZK proof
  };
}

// v0.9+: Public decrypt (for makePubliclyDecryptable values)
export async function publicDecryptHandles(handles: string[]) {
  const instance = await initFhevm();
  const result = await instance.publicDecrypt(handles);
  return {
    clearValues: result.clearValues,
    abiEncodedClearValues: result.abiEncodedClearValues,
    decryptionProof: result.decryptionProof,
  };
}

import { useState } from "react";
import { useAccount, useWriteContract } from "wagmi";
import { initFhevm, encryptVote } from "./fheClient";

function VoteButton({ sessionId }: { sessionId: number }) {
  const { address } = useAccount();
  const { writeContract } = useWriteContract();
  const [loading, setLoading] = useState(false);

  const handleVote = async (choice: 0 | 1) => {
    setLoading(true);
    try {
      // 1. Initialize FHE (cached after first call)
      const fheInstance = await initFhevm();

      // 2. Encrypt the vote
      const { handle, proof } = await encryptVote(
        fheInstance,
        CONTRACT_ADDRESS,
        address!,
        choice
      );

      // 3. Send the encrypted transaction
      await writeContract({
        address: CONTRACT_ADDRESS,
        abi: VOTING_ABI,
        functionName: "vote",
        args: [sessionId, handle, proof],
      });
    } catch (error) {
      console.error("Vote failed:", error);
    } finally {
      setLoading(false);
    }
  };

  return (
    <div>
      <button onClick={() => handleVote(1)} disabled={loading}>
        Vote YES
      </button>
      <button onClick={() => handleVote(0)} disabled={loading}>
        Vote NO
      </button>
    </div>
  );
}

contract ConfidentialVault is ZamaEthereumConfig {
    mapping(address => euint64) private balances;
    address public auditor;

    function deposit(externalEuint64 encAmount, bytes calldata proof) external {
        euint64 amount = FHE.fromExternal(encAmount, proof);

        if (!FHE.isInitialized(balances[msg.sender])) {
            balances[msg.sender] = FHE.asEuint64(0);
        }

        // FHE.add returns a NEW ciphertext — old permissions are gone!
        balances[msg.sender] = FHE.add(balances[msg.sender], amount);

        // ── ACL Matrix: grant permissions on the NEW value ──
        FHE.allowThis(balances[msg.sender]);       // Contract can use it
        FHE.allow(balances[msg.sender], msg.sender); // Owner can decrypt
        FHE.allow(balances[msg.sender], auditor);    // Auditor can view
    }
}

// UNSAFE: FHE.sub(balance, amount) wraps on underflow!

// SAFE: Guard with FHE.select
function safeSubtract(euint64 a, euint64 b) internal returns (euint64) {
    ebool sufficient = FHE.gte(a, b);
    euint64 result = FHE.sub(a, b);
    // If a < b, return 0 instead of wrapping
    return FHE.select(sufficient, result, FHE.asEuint64(0));
}

// SAFE: Conditional transfer (debit + credit atomically)
function conditionalTransfer(
    euint64 senderBal,
    euint64 receiverBal,
    euint64 amount
) internal returns (euint64 newSender, euint64 newReceiver) {
    ebool sufficient = FHE.gte(senderBal, amount);
    newSender = FHE.select(
        sufficient,
        FHE.sub(senderBal, amount),
        senderBal  // No change if insufficient
    );
    newReceiver = FHE.select(
        sufficient,
        FHE.add(receiverBal, amount),
        receiverBal  // No change if insufficient
    );
}