import * as Keccak256 from "@voltaire/crypto/Keccak256";

// For string input, use hashString
const hash = Keccak256.hashString("hello");
// For Uint8Array input, use hash
const hash2 = Keccak256.hash(new Uint8Array([1, 2, 3]));
// For hex input, use hashHex
Keccak256.hashHex("0x1234");

import * as SHA256 from "@voltaire/crypto/SHA256";

const hash = SHA256.hash(data);
SHA256.hashHex(data);

import * as Blake2 from "@voltaire/crypto/Blake2";

Blake2.hash(data, { digestLength: 32 });
Blake2.f(rounds, h, m, t, f);  // Blake2f compression function

import * as Ripemd160 from "@voltaire/crypto/Ripemd160";

const hash = Ripemd160.hash(data);

import * as Secp256k1 from "@voltaire/crypto/Secp256k1";

// Sign message hash
const signature = Secp256k1.sign(messageHash, privateKey);

// Verify signature
const valid = Secp256k1.verify(signature, messageHash, publicKey);

// Recover public key from signature
const pubkey = Secp256k1.recover(signature, messageHash, recoveryId);

// Key operations
const pubkey = Secp256k1.derivePublicKey(privateKey);
const compressed = Secp256k1.compressPublicKey(pubkey);
const uncompressed = Secp256k1.decompressPublicKey(compressed);

import * as Ed25519 from "@voltaire/crypto/Ed25519";

const signature = Ed25519.sign(message, privateKey);
const valid = Ed25519.verify(signature, message, publicKey);
const pubkey = Ed25519.getPublicKey(privateKey);

import * as P256 from "@voltaire/crypto/P256";

const signature = P256.sign(hash, privateKey);
const valid = P256.verify(signature, hash, publicKey);

import * as BN254 from "@voltaire/crypto/BN254";

// G1 operations
const sum = BN254.g1Add(p1, p2);
const product = BN254.g1Mul(point, scalar);

// G2 operations
const g2Sum = BN254.g2Add(p1, p2);
const g2Product = BN254.g2Mul(point, scalar);

// Pairing check
const valid = BN254.pairing(g1Points, g2Points);

// Via precompiles (no direct TS API yet)
import { execute } from "@voltaire/evm/precompiles";

// G1 operations via precompile
const result = execute(0x0B, g1AddInput);  // BLS12_G1_ADD

import * as KZG from "@voltaire/crypto/KZG";

// Blob to commitment
const commitment = KZG.blobToCommitment(blob);

// Compute proof
const proof = KZG.computeProof(blob, z);

// Verify proof
const valid = KZG.verifyProof(commitment, z, y, proof);

// Batch verification
const valid = KZG.verifyBlobProof(blob, commitment, proof);

import * as EIP712 from "@voltaire/crypto/EIP712";

const domain = {
  name: "MyContract",
  version: "1",
  chainId: 1n,
  verifyingContract: "0x...",
};

const types = {
  Person: [
    { name: "name", type: "string" },
    { name: "wallet", type: "address" },
  ],
};

const message = {
  name: "Alice",
  wallet: "0x...",
};

// Hash typed data
const hash = EIP712.hashTypedData({ domain, types, primaryType: "Person", message });

// Sign
const signature = EIP712.signTypedData({ domain, types, primaryType: "Person", message, privateKey });

import * as AesGcm from "@voltaire/crypto/AesGcm";

// Encrypt
const { ciphertext, tag } = AesGcm.encrypt(plaintext, key, nonce);

// Decrypt
const plaintext = AesGcm.decrypt(ciphertext, key, nonce, tag);

import * as X25519 from "@voltaire/crypto/X25519";

// Generate key pair
const { publicKey, privateKey } = X25519.generateKeyPair();

// Compute shared secret
const sharedSecret = X25519.sharedSecret(myPrivateKey, theirPublicKey);

import * as Bip39 from "@voltaire/crypto/Bip39";

// Generate mnemonic
const mnemonic = Bip39.generateMnemonic(128);  // 12 words

// Validate
const valid = Bip39.validateMnemonic(mnemonic);

// To seed
const seed = Bip39.mnemonicToSeed(mnemonic, passphrase);

import * as HDWallet from "@voltaire/crypto/HDWallet";

// From seed
const master = HDWallet.fromSeed(seed);

// Derive path
const account = HDWallet.derive(master, "m/44'/60'/0'/0/0");

// Get keys
const privateKey = HDWallet.privateKey(account);
const publicKey = HDWallet.publicKey(account);
const address = HDWallet.address(account);

// cpu_features.zig
const features = cpu_features.detect();
if (features.sha) {
    // Use SHA-NI instructions
}
if (features.aes) {
    // Use AES-NI instructions
}

// modexp.zig
const result = modexp.calculate(base, exp, mod);