import { createPhotonRpc, deriveAddress, deriveAddressSeed } from '@cascade-fyi/compression-kit';
import { address } from '@solana/kit';

// 1. Create RPC client
const rpc = createPhotonRpc('https://mainnet.helius-rpc.com/?api-key=YOUR_KEY');

// 2. Query compressed accounts
const ownerAddress = address('YOUR_WALLET_ADDRESS');
const accounts = await rpc.getCompressedAccountsByOwner(ownerAddress);

// 3. Derive a compressed account address
const programId = address('YOUR_PROGRAM_ID');
const seed = deriveAddressSeed([new TextEncoder().encode('my-seed')], programId);
const compressedAddress = deriveAddress(seed);

import { createPhotonRpc } from '@cascade-fyi/compression-kit';

const rpc = createPhotonRpc('https://mainnet.helius-rpc.com/?api-key=YOUR_KEY');

// Get all compressed accounts for an owner
const accounts = await rpc.getCompressedAccountsByOwner(ownerAddress);

// Get compressed token accounts
const tokenAccounts = await rpc.getCompressedTokenAccountsByOwner(ownerAddress, {
  mint: mintAddress,
});

// Get a specific compressed account by hash
const account = await rpc.getCompressedAccount(accountHash);

import {
  deriveAddressSeed,
  deriveAddress,
  deriveAddressSeedV2,
  deriveAddressV2,
  getDefaultAddressTreeInfo,
} from '@cascade-fyi/compression-kit';

// V1 Address derivation (mainnet)
const seedV1 = deriveAddressSeed([Buffer.from('my-seed')], programId);
const addressV1 = deriveAddress(seedV1);

// V2 Address derivation (devnet, more efficient)
const seedV2 = deriveAddressSeedV2([Buffer.from('my-seed')]);
const treeInfo = getDefaultAddressTreeInfo();
const addressV2 = deriveAddressV2(seedV2, treeInfo.tree, programId);

import { createPhotonRpc } from '@cascade-fyi/compression-kit';

const rpc = createPhotonRpc('https://mainnet.helius-rpc.com/?api-key=YOUR_KEY');

// Get proof for existing accounts (update/close operations)
const proof = await rpc.getValidityProof({
  hashes: [{ hash: accountHash, tree: treeAddress, queue: queueAddress }],
});

// Get proof for new addresses (create operations)
const newAddressProof = await rpc.getValidityProof({
  newAddresses: [{ address: newAddress, tree: addressTree, queue: addressQueue }],
});

import {
  PackedAccounts,
  createSystemAccountConfig,
  getLightSystemAccountMetas,
} from '@cascade-fyi/compression-kit';

// Create packed accounts helper
const packedAccounts = new PackedAccounts();

// Add Light system accounts
const systemConfig = createSystemAccountConfig(programId);
packedAccounts.addSystemAccounts(getLightSystemAccountMetas(systemConfig));

// Add tree accounts and get indices
const treeIndex = packedAccounts.insertOrGet(treeAddress);

// Convert to account metas for instruction
const { remainingAccounts } = packedAccounts.toAccountMetas();

import {
  createBN254,
  bn254FromBytes,
  bn254ToBytes,
  bn254Add,
  isSmallerThanFieldSize,
} from '@cascade-fyi/compression-kit';

// Create field element from bigint
const element = createBN254(123456789n);

// Convert from/to bytes
const bytes = bn254ToBytes(element);
const restored = bn254FromBytes(bytes);

// Field arithmetic
const sum = bn254Add(element1, element2);

// Validate field size
if (isSmallerThanFieldSize(someBytes)) {
  // Safe to use as BN254
}

import { importEd25519PublicKey } from '@cascade-fyi/compression-kit';
import { verifySignature, signatureBytes } from '@solana/kit';

// Import Ed25519 public key for signature verification
const pubkeyBytes = new Uint8Array(32); // your public key
const cryptoKey = await importEd25519PublicKey(pubkeyBytes);

// Use with Web Crypto API
const isValid = await verifySignature(cryptoKey, signatureBytes(sig), message);

import {
  MERKLE_TREE_PUBKEY,      // V1 State tree (mainnet)
  NULLIFIER_QUEUE_PUBKEY,  // V1 Nullifier queue (mainnet)
  ADDRESS_TREE,            // V1 Address tree
  BATCH_MERKLE_TREE_1,     // V2 Batch tree (devnet)
  defaultTestStateTreeAccounts, // Local testing
} from '@cascade-fyi/compression-kit';