@cascade-fyi/compression-kit 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1653 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let bs58 = require("bs58");
+bs58 = __toESM(bs58);
+let _solana_kit = require("@solana/kit");
+let _noble_hashes_sha3_js = require("@noble/hashes/sha3.js");
+
+//#region src/state/types.ts
+/**
+* Tree type enum matching the on-chain representation.
+*/
+let TreeType = /* @__PURE__ */ function(TreeType$1) {
+	/** v1 state merkle tree */
+	TreeType$1[TreeType$1["StateV1"] = 1] = "StateV1";
+	/** v1 address merkle tree */
+	TreeType$1[TreeType$1["AddressV1"] = 2] = "AddressV1";
+	/** v2 state merkle tree */
+	TreeType$1[TreeType$1["StateV2"] = 3] = "StateV2";
+	/** v2 address merkle tree */
+	TreeType$1[TreeType$1["AddressV2"] = 4] = "AddressV2";
+	return TreeType$1;
+}({});
+
+//#endregion
+//#region src/constants.ts
+/**
+* Light Protocol constants using Solana Kit patterns.
+*
+* Uses:
+* - Address type (branded string) instead of PublicKey
+* - Native bigint instead of BN.js
+*/
+let VERSION = /* @__PURE__ */ function(VERSION$1) {
+	VERSION$1["V1"] = "V1";
+	VERSION$1["V2"] = "V2";
+	return VERSION$1;
+}({});
+/**
+* Feature flags for protocol versioning.
+* @internal
+*/
+const featureFlags = {
+	version: VERSION.V1,
+	isV2: () => featureFlags.version === VERSION.V2
+};
+/**
+* Returns versioned endpoint name.
+* @example versionedEndpoint('getCompressedAccount') -> 'getCompressedAccountV2' (if V2)
+*/
+const versionedEndpoint = (base) => featureFlags.isV2() ? `${base}V2` : base;
+/**
+* BN254 prime field size.
+* All hashes must be less than this value for ZK circuit compatibility.
+*/
+const FIELD_SIZE = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+/**
+* Highest address plus one (used for address validation).
+*/
+const HIGHEST_ADDRESS_PLUS_ONE = 452312848583266388373324160190187140051835877600158453279131187530910662655n;
+/** Light System Program ID */
+const LIGHT_SYSTEM_PROGRAM = (0, _solana_kit.address)("SySTEM1eSU2p4BGQfQpimFEWWSC1XDFeun3Nqzz3rT7");
+/** Account Compression Program ID */
+const ACCOUNT_COMPRESSION_PROGRAM = (0, _solana_kit.address)("compr6CUsB5m2jS4Y3831ztGSTnDpnKJTKS95d64XVq");
+/** Noop Program ID (for logging) */
+const NOOP_PROGRAM = (0, _solana_kit.address)("noopb9bkMVfRPU8AsbpTUg8AQkHtKwMYZiFUjNRtMmV");
+/** Compressed Token Program ID */
+const COMPRESSED_TOKEN_PROGRAM = (0, _solana_kit.address)("cTokenmWW8bLPjZEBAUgYy3zKxQZW6VKi7bqNFEVv3m");
+/** Registered Program PDA (constant) */
+const REGISTERED_PROGRAM_PDA = (0, _solana_kit.address)("35hkDgaAKwMCaxRz2ocSZ6NaUrtKkyNqU6c4RV3tYJRh");
+const INVOKE_DISCRIMINATOR = new Uint8Array([
+	26,
+	16,
+	169,
+	7,
+	21,
+	202,
+	242,
+	25
+]);
+const INVOKE_CPI_DISCRIMINATOR = new Uint8Array([
+	49,
+	212,
+	191,
+	129,
+	39,
+	194,
+	43,
+	196
+]);
+const INVOKE_CPI_WITH_READ_ONLY_DISCRIMINATOR = new Uint8Array([
+	86,
+	47,
+	163,
+	166,
+	21,
+	223,
+	92,
+	8
+]);
+const INVOKE_CPI_WITH_ACCOUNT_INFO_DISCRIMINATOR = new Uint8Array([
+	228,
+	34,
+	128,
+	84,
+	47,
+	139,
+	86,
+	240
+]);
+const INSERT_INTO_QUEUES_DISCRIMINATOR = new Uint8Array([
+	180,
+	143,
+	159,
+	153,
+	35,
+	46,
+	248,
+	163
+]);
+const COMPUTE_BUDGET_PATTERN = new Uint8Array([
+	2,
+	64,
+	66,
+	15,
+	0
+]);
+/** Mainnet state tree lookup table */
+const STATE_TREE_LOOKUP_TABLE_MAINNET = (0, _solana_kit.address)("7i86eQs3GSqHjN47WdWLTCGMW6gde1q96G2EVnUyK2st");
+/** Mainnet nullified state tree lookup table */
+const NULLIFIED_STATE_TREE_LOOKUP_TABLE_MAINNET = (0, _solana_kit.address)("H9QD4u1fG7KmkAzn2tDXhheushxFe1EcrjGGyEFXeMqT");
+/** Devnet state tree lookup table */
+const STATE_TREE_LOOKUP_TABLE_DEVNET = (0, _solana_kit.address)("Dk9mNkbiZXJZ4By8DfSP6HEE4ojZzRvucwpawLeuwq8q");
+/** Devnet nullified state tree lookup table */
+const NULLIFIED_STATE_TREE_LOOKUP_TABLE_DEVNET = (0, _solana_kit.address)("AXbHzp1NgjLvpfnD6JRTTovXZ7APUCdtWZFCRr5tCxse");
+/**
+* Returns default state tree lookup tables for each network.
+*/
+function defaultStateTreeLookupTables() {
+	return {
+		mainnet: [{
+			stateTreeLookupTable: STATE_TREE_LOOKUP_TABLE_MAINNET,
+			nullifyLookupTable: NULLIFIED_STATE_TREE_LOOKUP_TABLE_MAINNET
+		}],
+		devnet: [{
+			stateTreeLookupTable: STATE_TREE_LOOKUP_TABLE_DEVNET,
+			nullifyLookupTable: NULLIFIED_STATE_TREE_LOOKUP_TABLE_DEVNET
+		}]
+	};
+}
+const MERKLE_TREE_PUBKEY = (0, _solana_kit.address)("smt1NamzXdq4AMqS2fS2F1i5KTYPZRhoHgWx38d8WsT");
+const NULLIFIER_QUEUE_PUBKEY = (0, _solana_kit.address)("nfq1NvQDJ2GEgnS8zt9prAe8rjjpAW1zFkrvZoBR148");
+const CPI_CONTEXT_PUBKEY = (0, _solana_kit.address)("cpi1uHzrEhBG733DoEJNgHCyRS3XmmyVNZx5fonubE4");
+const MERKLE_TREE_2_PUBKEY = (0, _solana_kit.address)("smt2rJAFdyJJupwMKAqTNAJwvjhmiZ4JYGZmbVRw1Ho");
+const NULLIFIER_QUEUE_2_PUBKEY = (0, _solana_kit.address)("nfq2hgS7NYemXsFaFUCe3EMXSDSfnZnAe27jC6aPP1X");
+const CPI_CONTEXT_2_PUBKEY = (0, _solana_kit.address)("cpi2cdhkH5roePvcudTgUL8ppEBfTay1desGh8G8QxK");
+const ADDRESS_TREE = (0, _solana_kit.address)("amt1Ayt45jfbdw5YSo7iz6WZxUmnZsQTYXy82hVwyC2");
+const ADDRESS_QUEUE = (0, _solana_kit.address)("aq1S9z4reTSQAdgWHGD2zDaS39sjGrAxbR31vxJ2F4F");
+const BATCH_MERKLE_TREE_1 = (0, _solana_kit.address)("bmt1LryLZUMmF7ZtqESaw7wifBXLfXHQYoE4GAmrahU");
+const BATCH_QUEUE_1 = (0, _solana_kit.address)("oq1na8gojfdUhsfCpyjNt6h4JaDWtHf1yQj4koBWfto");
+const BATCH_CPI_CONTEXT_1 = (0, _solana_kit.address)("cpi15BoVPKgEPw5o8wc2T816GE7b378nMXnhH3Xbq4y");
+const BATCH_MERKLE_TREE_2 = (0, _solana_kit.address)("bmt2UxoBxB9xWev4BkLvkGdapsz6sZGkzViPNph7VFi");
+const BATCH_QUEUE_2 = (0, _solana_kit.address)("oq2UkeMsJLfXt2QHzim242SUi3nvjJs8Pn7Eac9H9vg");
+const BATCH_CPI_CONTEXT_2 = (0, _solana_kit.address)("cpi2yGapXUR3As5SjnHBAVvmApNiLsbeZpF3euWnW6B");
+const BATCH_ADDRESS_TREE = (0, _solana_kit.address)("amt2kaJA14v3urZbZvnc5v2np8jqvc4Z8zDep5wbtzx");
+const TEST_BATCH_ADDRESS_TREE = (0, _solana_kit.address)("EzKE84aVTkCUhDHLELqyJaq1Y7UVVmqxXqZjVHwHY3rK");
+const DEFAULT_MERKLE_TREE_HEIGHT = 26;
+const DEFAULT_MERKLE_TREE_ROOTS = 2800;
+/** Threshold for UTXO merging (per asset) */
+const UTXO_MERGE_THRESHOLD = 20;
+const UTXO_MERGE_MAXIMUM = 10;
+/** Tree rollover threshold (95% capacity) */
+const TRANSACTION_MERKLE_TREE_ROLLOVER_THRESHOLD = BigInt(Math.floor(2 ** DEFAULT_MERKLE_TREE_HEIGHT * .95));
+/** Fee per output compressed account (for tree rollover) */
+const STATE_MERKLE_TREE_ROLLOVER_FEE = featureFlags.isV2() ? 1n : 300n;
+/** Fee per new address (for address tree rollover) */
+const ADDRESS_QUEUE_ROLLOVER_FEE = 392n;
+/** Network fee for nullifying compressed accounts */
+const STATE_MERKLE_TREE_NETWORK_FEE = 5000n;
+/** V1 network fee per new address */
+const ADDRESS_TREE_NETWORK_FEE_V1 = 5000n;
+/** V2 network fee per new address */
+const ADDRESS_TREE_NETWORK_FEE_V2 = 10000n;
+/**
+* Derives the account compression authority PDA.
+*/
+async function getAccountCompressionAuthority() {
+	const [pda] = await (0, _solana_kit.getProgramDerivedAddress)({
+		programAddress: LIGHT_SYSTEM_PROGRAM,
+		seeds: [new TextEncoder().encode("cpi_authority")]
+	});
+	return pda;
+}
+/**
+* Returns static accounts needed for Light System Program calls.
+*/
+async function defaultStaticAccounts() {
+	return [
+		REGISTERED_PROGRAM_PDA,
+		NOOP_PROGRAM,
+		ACCOUNT_COMPRESSION_PROGRAM,
+		await getAccountCompressionAuthority()
+	];
+}
+/**
+* Check if URL is localhost/localnet.
+* @internal
+*/
+function isLocalTest(url) {
+	return url.includes("localhost") || url.includes("127.0.0.1");
+}
+/**
+* Returns default test state tree accounts for localnet.
+*/
+function defaultTestStateTreeAccounts() {
+	return {
+		nullifierQueue: NULLIFIER_QUEUE_PUBKEY,
+		merkleTree: MERKLE_TREE_PUBKEY,
+		merkleTreeHeight: DEFAULT_MERKLE_TREE_HEIGHT,
+		addressTree: ADDRESS_TREE,
+		addressQueue: ADDRESS_QUEUE
+	};
+}
+/**
+* Returns active state tree infos for localnet testing.
+* @internal
+*/
+function localTestActiveStateTreeInfos() {
+	const v1Trees = [{
+		tree: MERKLE_TREE_PUBKEY,
+		queue: NULLIFIER_QUEUE_PUBKEY,
+		cpiContext: CPI_CONTEXT_PUBKEY,
+		treeType: TreeType.StateV1,
+		nextTreeInfo: null
+	}, {
+		tree: MERKLE_TREE_2_PUBKEY,
+		queue: NULLIFIER_QUEUE_2_PUBKEY,
+		cpiContext: CPI_CONTEXT_2_PUBKEY,
+		treeType: TreeType.StateV1,
+		nextTreeInfo: null
+	}];
+	if (!featureFlags.isV2()) return v1Trees;
+	return [
+		...v1Trees,
+		{
+			tree: BATCH_MERKLE_TREE_1,
+			queue: BATCH_QUEUE_1,
+			cpiContext: BATCH_CPI_CONTEXT_1,
+			treeType: TreeType.StateV2,
+			nextTreeInfo: null
+		},
+		{
+			tree: BATCH_MERKLE_TREE_2,
+			queue: BATCH_QUEUE_2,
+			cpiContext: BATCH_CPI_CONTEXT_2,
+			treeType: TreeType.StateV2,
+			nextTreeInfo: null
+		},
+		{
+			tree: BATCH_ADDRESS_TREE,
+			queue: BATCH_ADDRESS_TREE,
+			treeType: TreeType.AddressV2,
+			nextTreeInfo: null
+		}
+	];
+}
+/**
+* Returns default address tree info.
+*/
+function getDefaultAddressTreeInfo() {
+	if (featureFlags.isV2()) return {
+		tree: BATCH_ADDRESS_TREE,
+		queue: BATCH_ADDRESS_TREE,
+		treeType: TreeType.AddressV2,
+		nextTreeInfo: null
+	};
+	return {
+		tree: ADDRESS_TREE,
+		queue: ADDRESS_QUEUE,
+		treeType: TreeType.AddressV1,
+		nextTreeInfo: null
+	};
+}
+
+//#endregion
+//#region src/errors.ts
+/**
+* Error types for Light Protocol stateless operations.
+*/
+let UtxoErrorCode = /* @__PURE__ */ function(UtxoErrorCode$1) {
+	UtxoErrorCode$1["NEGATIVE_LAMPORTS"] = "NEGATIVE_LAMPORTS";
+	UtxoErrorCode$1["NOT_U64"] = "NOT_U64";
+	UtxoErrorCode$1["BLINDING_EXCEEDS_FIELD_SIZE"] = "BLINDING_EXCEEDS_FIELD_SIZE";
+	return UtxoErrorCode$1;
+}({});
+let SelectInUtxosErrorCode = /* @__PURE__ */ function(SelectInUtxosErrorCode$1) {
+	SelectInUtxosErrorCode$1["FAILED_TO_FIND_UTXO_COMBINATION"] = "FAILED_TO_FIND_UTXO_COMBINATION";
+	SelectInUtxosErrorCode$1["INVALID_NUMBER_OF_IN_UTXOS"] = "INVALID_NUMBER_OF_IN_UTXOS";
+	return SelectInUtxosErrorCode$1;
+}({});
+let CreateUtxoErrorCode = /* @__PURE__ */ function(CreateUtxoErrorCode$1) {
+	CreateUtxoErrorCode$1["OWNER_UNDEFINED"] = "OWNER_UNDEFINED";
+	CreateUtxoErrorCode$1["INVALID_OUTPUT_UTXO_LENGTH"] = "INVALID_OUTPUT_UTXO_LENGTH";
+	CreateUtxoErrorCode$1["UTXO_DATA_UNDEFINED"] = "UTXO_DATA_UNDEFINED";
+	return CreateUtxoErrorCode$1;
+}({});
+let RpcErrorCode = /* @__PURE__ */ function(RpcErrorCode$1) {
+	RpcErrorCode$1["CONNECTION_UNDEFINED"] = "CONNECTION_UNDEFINED";
+	RpcErrorCode$1["RPC_PUBKEY_UNDEFINED"] = "RPC_PUBKEY_UNDEFINED";
+	RpcErrorCode$1["RPC_METHOD_NOT_IMPLEMENTED"] = "RPC_METHOD_NOT_IMPLEMENTED";
+	RpcErrorCode$1["RPC_INVALID"] = "RPC_INVALID";
+	return RpcErrorCode$1;
+}({});
+let LookupTableErrorCode = /* @__PURE__ */ function(LookupTableErrorCode$1) {
+	LookupTableErrorCode$1["LOOK_UP_TABLE_UNDEFINED"] = "LOOK_UP_TABLE_UNDEFINED";
+	LookupTableErrorCode$1["LOOK_UP_TABLE_NOT_INITIALIZED"] = "LOOK_UP_TABLE_NOT_INITIALIZED";
+	return LookupTableErrorCode$1;
+}({});
+let HashErrorCode = /* @__PURE__ */ function(HashErrorCode$1) {
+	HashErrorCode$1["NO_POSEIDON_HASHER_PROVIDED"] = "NO_POSEIDON_HASHER_PROVIDED";
+	return HashErrorCode$1;
+}({});
+let ProofErrorCode = /* @__PURE__ */ function(ProofErrorCode$1) {
+	ProofErrorCode$1["INVALID_PROOF"] = "INVALID_PROOF";
+	ProofErrorCode$1["PROOF_INPUT_UNDEFINED"] = "PROOF_INPUT_UNDEFINED";
+	ProofErrorCode$1["PROOF_GENERATION_FAILED"] = "PROOF_GENERATION_FAILED";
+	return ProofErrorCode$1;
+}({});
+let MerkleTreeErrorCode = /* @__PURE__ */ function(MerkleTreeErrorCode$1) {
+	MerkleTreeErrorCode$1["MERKLE_TREE_NOT_INITIALIZED"] = "MERKLE_TREE_NOT_INITIALIZED";
+	MerkleTreeErrorCode$1["SOL_MERKLE_TREE_UNDEFINED"] = "SOL_MERKLE_TREE_UNDEFINED";
+	MerkleTreeErrorCode$1["MERKLE_TREE_UNDEFINED"] = "MERKLE_TREE_UNDEFINED";
+	MerkleTreeErrorCode$1["INPUT_UTXO_NOT_INSERTED_IN_MERKLE_TREE"] = "INPUT_UTXO_NOT_INSERTED_IN_MERKLE_TREE";
+	MerkleTreeErrorCode$1["MERKLE_TREE_INDEX_UNDEFINED"] = "MERKLE_TREE_INDEX_UNDEFINED";
+	MerkleTreeErrorCode$1["MERKLE_TREE_SET_SPACE_UNDEFINED"] = "MERKLE_TREE_SET_SPACE_UNDEFINED";
+	return MerkleTreeErrorCode$1;
+}({});
+let UtilsErrorCode = /* @__PURE__ */ function(UtilsErrorCode$1) {
+	UtilsErrorCode$1["ACCOUNT_NAME_UNDEFINED_IN_IDL"] = "ACCOUNT_NAME_UNDEFINED_IN_IDL";
+	UtilsErrorCode$1["PROPERTY_UNDEFINED"] = "PROPERTY_UNDEFINED";
+	UtilsErrorCode$1["LOOK_UP_TABLE_CREATION_FAILED"] = "LOOK_UP_TABLE_CREATION_FAILED";
+	UtilsErrorCode$1["UNSUPPORTED_ARCHITECTURE"] = "UNSUPPORTED_ARCHITECTURE";
+	UtilsErrorCode$1["UNSUPPORTED_PLATFORM"] = "UNSUPPORTED_PLATFORM";
+	UtilsErrorCode$1["ACCOUNTS_UNDEFINED"] = "ACCOUNTS_UNDEFINED";
+	UtilsErrorCode$1["INVALID_NUMBER"] = "INVALID_NUMBER";
+	return UtilsErrorCode$1;
+}({});
+let BN254ErrorCode = /* @__PURE__ */ function(BN254ErrorCode$1) {
+	BN254ErrorCode$1["VALUE_TOO_LARGE"] = "VALUE_TOO_LARGE";
+	BN254ErrorCode$1["INVALID_BASE58"] = "INVALID_BASE58";
+	return BN254ErrorCode$1;
+}({});
+/**
+* Base error class for Light Protocol errors.
+*/
+var LightError = class extends Error {
+	constructor(code, functionName, codeMessage) {
+		super(`${code}: ${codeMessage ?? ""}`);
+		this.name = this.constructor.name;
+		this.code = code;
+		this.functionName = functionName;
+		this.codeMessage = codeMessage;
+	}
+};
+var UtxoError = class extends LightError {};
+var SelectInUtxosError = class extends LightError {};
+var CreateUtxoError = class extends LightError {};
+var RpcError = class extends LightError {};
+var LookupTableError = class extends LightError {};
+var HashError = class extends LightError {};
+var ProofError = class extends LightError {};
+var MerkleTreeError = class extends LightError {};
+var UtilsError = class extends LightError {};
+var BN254Error = class extends LightError {};
+function createUtxoError(code, functionName, message) {
+	return new UtxoError(code, functionName, message);
+}
+function createRpcError(code, functionName, message) {
+	return new RpcError(code, functionName, message);
+}
+function createProofError(code, functionName, message) {
+	return new ProofError(code, functionName, message);
+}
+function createBN254Error(code, functionName, message) {
+	return new BN254Error(code, functionName, message);
+}
+
+//#endregion
+//#region src/state/bn254.ts
+/**
+* BN254 field element utilities using native bigint.
+*
+* BN254 is the elliptic curve used by Light Protocol's ZK proofs.
+* All hashes must be less than the field modulus (~2^254) for circuit compatibility.
+*
+* This module replaces BN.js with native bigint for:
+* - Better performance
+* - No Node.js Buffer dependency
+* - Edge/browser compatibility
+*/
+/**
+* Check if a bigint is within the BN254 field.
+*/
+function isBN254(value) {
+	return value >= 0n && value < FIELD_SIZE;
+}
+/**
+* Assert that a bigint is within the BN254 field.
+* @throws BN254Error if value is out of range
+*/
+function assertIsBN254(value) {
+	if (!isBN254(value)) throw createBN254Error(BN254ErrorCode.VALUE_TOO_LARGE, "assertIsBN254", `Value ${value} exceeds BN254 field size`);
+}
+/**
+* Enforce BN254 field size constraint.
+* @throws BN254Error if value is out of range
+*/
+function enforceFieldSize(value) {
+	assertIsBN254(value);
+	return value;
+}
+/**
+* Create a BN254 field element from various input types.
+*
+* @param input - Number, string, bigint, or byte array
+* @param base - Optional base for string parsing: 10, 16, 'hex', or 'base58'
+* @returns BN254 field element
+* @throws BN254Error if value exceeds field size
+*/
+function createBN254(input, base) {
+	let value;
+	if (base === "base58") {
+		if (typeof input !== "string") throw createBN254Error(BN254ErrorCode.INVALID_BASE58, "createBN254", "Base58 input must be a string");
+		value = bytesToBigIntBE(bs58.default.decode(input));
+	} else if (typeof input === "bigint") value = input;
+	else if (typeof input === "number") value = BigInt(input);
+	else if (typeof input === "string") if (base === "hex" || base === 16) {
+		const cleanHex = input.startsWith("0x") ? input.slice(2) : input;
+		value = BigInt(`0x${cleanHex}`);
+	} else value = BigInt(input);
+	else if (input instanceof Uint8Array || Array.isArray(input)) value = bytesToBigIntBE(input instanceof Uint8Array ? input : new Uint8Array(input));
+	else throw createBN254Error(BN254ErrorCode.VALUE_TOO_LARGE, "createBN254", `Unsupported input type: ${typeof input}`);
+	return enforceFieldSize(value);
+}
+/**
+* Create a BN254 from a 32-byte array (big-endian).
+*/
+function bn254FromBytes(bytes) {
+	if (bytes.length !== 32) throw createBN254Error(BN254ErrorCode.VALUE_TOO_LARGE, "bn254FromBytes", `Expected 32 bytes, got ${bytes.length}`);
+	return createBN254(bytes);
+}
+/**
+* Convert a BN254 field element to a base58 string.
+*/
+function encodeBN254toBase58(value) {
+	const bytes = bigIntToBytesBE(value, 32);
+	return bs58.default.encode(bytes);
+}
+/**
+* Convert a BN254 field element to a hex string (with 0x prefix).
+*/
+function encodeBN254toHex(value) {
+	return `0x${value.toString(16).padStart(64, "0")}`;
+}
+/**
+* Convert a BN254 field element to a 32-byte array (big-endian).
+*/
+function bn254ToBytes(value) {
+	return bigIntToBytesBE(value, 32);
+}
+/**
+* Convert a BN254 field element to a decimal string.
+*/
+function bn254ToDecimalString(value) {
+	return value.toString(10);
+}
+/**
+* Convert bytes to bigint (big-endian).
+*/
+function bytesToBigIntBE(bytes) {
+	let result = 0n;
+	for (const byte of bytes) result = result << 8n | BigInt(byte);
+	return result;
+}
+/**
+* Convert bytes to bigint (little-endian).
+*/
+function bytesToBigIntLE(bytes) {
+	let result = 0n;
+	for (let i = bytes.length - 1; i >= 0; i--) result = result << 8n | BigInt(bytes[i]);
+	return result;
+}
+/**
+* Convert bigint to bytes (big-endian).
+*/
+function bigIntToBytesBE(value, length) {
+	const bytes = new Uint8Array(length);
+	let remaining = value;
+	for (let i = length - 1; i >= 0; i--) {
+		bytes[i] = Number(remaining & 255n);
+		remaining >>= 8n;
+	}
+	return bytes;
+}
+/**
+* Convert bigint to bytes (little-endian).
+*/
+function bigIntToBytesLE(value, length) {
+	const bytes = new Uint8Array(length);
+	let remaining = value;
+	for (let i = 0; i < length; i++) {
+		bytes[i] = Number(remaining & 255n);
+		remaining >>= 8n;
+	}
+	return bytes;
+}
+/**
+* Add two BN254 values with modular reduction.
+*/
+function bn254Add(a, b) {
+	return (a + b) % FIELD_SIZE;
+}
+/**
+* Subtract two BN254 values with modular reduction.
+*/
+function bn254Sub(a, b) {
+	const result = (a - b) % FIELD_SIZE;
+	return result < 0n ? result + FIELD_SIZE : result;
+}
+/**
+* Multiply two BN254 values with modular reduction.
+*/
+function bn254Mul(a, b) {
+	return a * b % FIELD_SIZE;
+}
+/**
+* Check if a value is smaller than the BN254 field size (big-endian bytes).
+*/
+function isSmallerThanFieldSize(bytes) {
+	return bytesToBigIntBE(bytes) < FIELD_SIZE;
+}
+
+//#endregion
+//#region src/utils/conversion.ts
+/**
+* Conversion and hashing utilities for Light Protocol.
+*
+* Uses @noble/hashes for Keccak256 - pure JS, works in all environments.
+*/
+/**
+* Hash multiple byte arrays with Keccak256 and truncate to BN254 field size.
+*
+* This is the primary hash function used by Light Protocol. It:
+* 1. Concatenates all input arrays
+* 2. Hashes with Keccak256
+* 3. Sets the first byte to 0 to ensure the result fits in BN254 field
+*
+* @param inputs - Array of byte arrays to hash
+* @returns 32-byte hash that fits in BN254 field
+*/
+function hashvToBn254FieldSizeBe(inputs) {
+	const hasher = _noble_hashes_sha3_js.keccak_256.create();
+	for (const input of inputs) hasher.update(input);
+	const hash = hasher.digest();
+	hash[0] = 0;
+	return hash;
+}
+/**
+* Hash multiple byte arrays with Keccak256, appending 0xFF bump seed.
+*
+* This variant appends a 255 bump seed before hashing, matching the
+* on-chain behavior for certain hash derivations.
+*
+* @param inputs - Array of byte arrays to hash
+* @returns 32-byte hash that fits in BN254 field
+*/
+function hashvToBn254FieldSizeBeWithBump(inputs) {
+	const hasher = _noble_hashes_sha3_js.keccak_256.create();
+	for (const input of inputs) hasher.update(input);
+	hasher.update(new Uint8Array([255]));
+	const hash = hasher.digest();
+	hash[0] = 0;
+	return hash;
+}
+/**
+* Hash bytes with Keccak256 and find a valid bump seed.
+*
+* @deprecated Use hashvToBn254FieldSizeBe instead.
+*
+* This function iterates through bump seeds (255 down to 0) to find one
+* that produces a hash smaller than the BN254 field size. This is the
+* legacy approach - the simpler truncation method is now preferred.
+*
+* @param bytes - Bytes to hash
+* @returns Tuple of [hash, bumpSeed] or null if no valid bump found
+*/
+function hashToBn254FieldSizeBe(bytes) {
+	let bumpSeed = 255;
+	while (bumpSeed >= 0) {
+		const inputWithBump = new Uint8Array(bytes.length + 1);
+		inputWithBump.set(bytes);
+		inputWithBump[bytes.length] = bumpSeed;
+		const hash = (0, _noble_hashes_sha3_js.keccak_256)(inputWithBump);
+		if (hash.length !== 32) throw new Error("Invalid hash length");
+		hash[0] = 0;
+		if (isSmallerThanFieldSize(hash)) return [hash, bumpSeed];
+		bumpSeed--;
+	}
+	return null;
+}
+/**
+* Convert hex string to bytes.
+*/
+function hexToBytes(hex) {
+	const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+	if (cleanHex.length % 2 !== 0) throw new Error("Invalid hex string length");
+	const bytes = new Uint8Array(cleanHex.length / 2);
+	for (let i = 0; i < bytes.length; i++) bytes[i] = parseInt(cleanHex.slice(i * 2, i * 2 + 2), 16);
+	return bytes;
+}
+/**
+* Convert bytes to hex string (no 0x prefix).
+*/
+function bytesToHex(bytes) {
+	return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+/**
+* Convert bigint to hex string with 0x prefix.
+*/
+function toHex(value) {
+	return `0x${value.toString(16)}`;
+}
+/**
+* Ensure value is an array.
+*/
+function toArray(value) {
+	return Array.isArray(value) ? value : [value];
+}
+/**
+* Merge bytes arrays into one.
+*/
+function mergeBytes(arrays) {
+	const totalLength = arrays.reduce((acc, arr) => acc + arr.length, 0);
+	const result = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const arr of arrays) {
+		result.set(arr, offset);
+		offset += arr.length;
+	}
+	return result;
+}
+/**
+* Compare two byte arrays for equality.
+*/
+function bytesEqual(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+/**
+* Pad bytes to a fixed length (right-pad with zeros).
+*/
+function padBytes(bytes, length) {
+	if (bytes.length >= length) return bytes;
+	const result = new Uint8Array(length);
+	result.set(bytes);
+	return result;
+}
+/**
+* Push unique items to an array.
+* Mutates the array in place.
+*/
+function pushUniqueItems(items, target) {
+	for (const item of items) if (!target.includes(item)) target.push(item);
+}
+/**
+* Convert bytes to decimal string (for ZK circuit compatibility).
+*/
+function bytesToDecimalString(bytes) {
+	return bytesToBigIntBE(bytes).toString(10);
+}
+/**
+* Validate that a hash value is within BN254 field size.
+*/
+function validateBN254Hash(hash) {
+	if (hash.length !== 32) return false;
+	return isSmallerThanFieldSize(hash);
+}
+/**
+* Assert hash is valid BN254 field element.
+*/
+function assertValidBN254Hash(hash) {
+	if (!validateBN254Hash(hash)) throw new Error(`Invalid BN254 hash: must be 32 bytes and less than field size`);
+}
+
+//#endregion
+//#region src/utils/address.ts
+/**
+* Address derivation utilities for Light Protocol.
+*
+* Light Protocol uses a custom address derivation scheme that produces
+* addresses within the BN254 field for ZK circuit compatibility.
+*/
+/**
+* Derive an address seed from seeds and program ID.
+*
+* This combines the program ID with user-provided seeds and hashes
+* them to produce a 32-byte seed suitable for address derivation.
+*
+* @param seeds - User-provided seed bytes
+* @param programId - The program ID that "owns" this address
+* @returns 32-byte address seed
+*/
+function deriveAddressSeed(seeds, programId) {
+	const encoder = (0, _solana_kit.getAddressEncoder)();
+	return hashvToBn254FieldSizeBe([Uint8Array.from(encoder.encode(programId)), ...seeds]);
+}
+/**
+* Derive a compressed account address from a seed and address tree.
+*
+* @param seed - 32-byte seed (typically from deriveAddressSeed)
+* @param addressMerkleTreePubkey - The address tree to derive from
+* @returns Derived address as a Solana Address
+*
+* @example
+* ```typescript
+* import { deriveAddressSeed, deriveAddress } from '@cascade-fyi/compression-kit';
+* import { address } from '@solana/kit';
+*
+* const programId = address('YourProgramId...');
+* const seed = deriveAddressSeed([new TextEncoder().encode('my-seed')], programId);
+* const compressedAddress = deriveAddress(seed);
+* ```
+*/
+function deriveAddress(seed, addressMerkleTreePubkey) {
+	if (seed.length !== 32) throw new Error("Seed length must be 32 bytes");
+	const treePubkey = addressMerkleTreePubkey ?? defaultTestStateTreeAccounts().addressTree;
+	const encoder = (0, _solana_kit.getAddressEncoder)();
+	const hashResult = hashToBn254FieldSizeBe(mergeBytes([Uint8Array.from(encoder.encode(treePubkey)), seed]));
+	if (hashResult === null) throw new Error("DeriveAddressError: Failed to find valid bump seed");
+	const [hash] = hashResult;
+	return (0, _solana_kit.address)(bs58.default.encode(hash));
+}
+/**
+* Derive address seed using V2 method (no program ID in combined seeds).
+*
+* @param seeds - Seeds to hash together
+* @returns 32-byte address seed
+*/
+function deriveAddressSeedV2(seeds) {
+	return hashvToBn254FieldSizeBeWithBump(seeds);
+}
+/**
+* Derive address using V2 method (matches Rust derive_address_from_seed).
+*
+* @param addressSeed - 32-byte address seed
+* @param addressMerkleTreePubkey - Address tree pubkey
+* @param programId - Program ID
+* @returns Derived address
+*/
+function deriveAddressV2(addressSeed, addressMerkleTreePubkey, programId) {
+	if (addressSeed.length !== 32) throw new Error("Address seed length must be 32 bytes");
+	const encoder = (0, _solana_kit.getAddressEncoder)();
+	const hash = hashvToBn254FieldSizeBeWithBump([
+		addressSeed,
+		Uint8Array.from(encoder.encode(addressMerkleTreePubkey)),
+		Uint8Array.from(encoder.encode(programId))
+	]);
+	return (0, _solana_kit.address)(bs58.default.encode(hash));
+}
+/**
+* Get the index of an address in an array, adding it if not present.
+*/
+function getIndexOrAdd(accounts, pubkey) {
+	const existingIndex = accounts.indexOf(pubkey);
+	if (existingIndex !== -1) return existingIndex;
+	accounts.push(pubkey);
+	return accounts.length - 1;
+}
+/**
+* Pack new address params for instruction data.
+*
+* Converts NewAddressParams to NewAddressParamsPacked by replacing
+* pubkeys with their indices in the remaining accounts array.
+*
+* @param newAddressParams - Array of new address parameters
+* @param remainingAccounts - Existing remaining accounts (will be modified)
+* @returns Packed params and updated remaining accounts
+*/
+function packNewAddressParams(newAddressParams, remainingAccounts) {
+	const accounts = [...remainingAccounts];
+	const newAddressParamsPacked = newAddressParams.map((params) => ({
+		seed: params.seed,
+		addressMerkleTreeRootIndex: params.addressMerkleTreeRootIndex,
+		addressMerkleTreeAccountIndex: 0,
+		addressQueueAccountIndex: 0
+	}));
+	for (let i = 0; i < newAddressParams.length; i++) newAddressParamsPacked[i].addressMerkleTreeAccountIndex = getIndexOrAdd(accounts, newAddressParams[i].addressMerkleTreePubkey);
+	for (let i = 0; i < newAddressParams.length; i++) newAddressParamsPacked[i].addressQueueAccountIndex = getIndexOrAdd(accounts, newAddressParams[i].addressQueuePubkey);
+	return {
+		newAddressParamsPacked,
+		remainingAccounts: accounts
+	};
+}
+/**
+* Convert an address to bytes.
+*/
+function addressToBytes(addr) {
+	const encoder = (0, _solana_kit.getAddressEncoder)();
+	return Uint8Array.from(encoder.encode(addr));
+}
+/**
+* Convert bytes to an address.
+*
+* Note: This performs base58 encoding on the bytes. The bytes should
+* be a valid 32-byte representation of an address.
+*/
+function bytesToAddress(bytes) {
+	if (bytes.length !== 32) throw new Error("Address must be 32 bytes");
+	return (0, _solana_kit.address)(bs58.default.encode(bytes));
+}
+
+//#endregion
+//#region src/utils/instruction.ts
+/**
+* Instruction building utilities for Light Protocol.
+*
+* Uses Solana Kit patterns:
+* - AccountMeta with Address and AccountRole
+* - Pure data objects instead of classes where possible
+*/
+/**
+* Create a basic system account config.
+*/
+function createSystemAccountConfig(selfProgram) {
+	return { selfProgram };
+}
+/**
+* Create a system account config with CPI context.
+*/
+function createSystemAccountConfigWithCpi(selfProgram, cpiContext) {
+	return {
+		selfProgram,
+		cpiContext
+	};
+}
+/**
+* Derive the CPI signer PDA for a program.
+*/
+async function getCpiSignerPda(selfProgram) {
+	const [pda] = await (0, _solana_kit.getProgramDerivedAddress)({
+		programAddress: selfProgram,
+		seeds: [new TextEncoder().encode("cpi_authority")]
+	});
+	return pda;
+}
+/**
+* Derive the account compression authority PDA.
+*/
+async function getAccountCompressionAuthority$1() {
+	const [pda] = await (0, _solana_kit.getProgramDerivedAddress)({
+		programAddress: LIGHT_SYSTEM_PROGRAM,
+		seeds: [new TextEncoder().encode("cpi_authority")]
+	});
+	return pda;
+}
+/**
+* Get the system program address.
+*/
+function getSystemProgram() {
+	return "11111111111111111111111111111111";
+}
+/**
+* Build Light System account metas (V1 layout).
+*
+* @param config - System account configuration
+* @returns Array of account metas for Light System Program
+*
+* @example
+* ```typescript
+* import { getLightSystemAccountMetas, createSystemAccountConfig } from '@cascade-fyi/compression-kit';
+* import { address } from '@solana/kit';
+*
+* const programId = address('YourProgramId...');
+* const config = createSystemAccountConfig(programId);
+* const metas = await getLightSystemAccountMetas(config);
+* ```
+*/
+async function getLightSystemAccountMetas(config) {
+	const cpiSigner = await getCpiSignerPda(config.selfProgram);
+	const compressionAuthority = await getAccountCompressionAuthority$1();
+	const metas = [
+		{
+			address: LIGHT_SYSTEM_PROGRAM,
+			role: _solana_kit.AccountRole.READONLY
+		},
+		{
+			address: cpiSigner,
+			role: _solana_kit.AccountRole.READONLY
+		},
+		{
+			address: REGISTERED_PROGRAM_PDA,
+			role: _solana_kit.AccountRole.READONLY
+		},
+		{
+			address: NOOP_PROGRAM,
+			role: _solana_kit.AccountRole.READONLY
+		},
+		{
+			address: compressionAuthority,
+			role: _solana_kit.AccountRole.READONLY
+		},
+		{
+			address: ACCOUNT_COMPRESSION_PROGRAM,
+			role: _solana_kit.AccountRole.READONLY
+		},
+		{
+			address: config.selfProgram,
+			role: _solana_kit.AccountRole.READONLY
+		}
+	];
+	if (config.solPoolPda) metas.push({
+		address: config.solPoolPda,
+		role: _solana_kit.AccountRole.WRITABLE
+	});
+	if (config.solCompressionRecipient) metas.push({
+		address: config.solCompressionRecipient,
+		role: _solana_kit.AccountRole.WRITABLE
+	});
+	metas.push({
+		address: getSystemProgram(),
+		role: _solana_kit.AccountRole.READONLY
+	});
+	if (config.cpiContext) metas.push({
+		address: config.cpiContext,
+		role: _solana_kit.AccountRole.WRITABLE
+	});
+	return metas;
+}
+/**
+* Build Light System account metas (V2 layout - no noop program).
+*/
+async function getLightSystemAccountMetasV2(config) {
+	const cpiSigner = await getCpiSignerPda(config.selfProgram);
+	const compressionAuthority = await getAccountCompressionAuthority$1();
+	const metas = [
+		{
+			address: LIGHT_SYSTEM_PROGRAM,
+			role: _solana_kit.AccountRole.READONLY
+		},
+		{
+			address: cpiSigner,
+			role: _solana_kit.AccountRole.READONLY
+		},
+		{
+			address: REGISTERED_PROGRAM_PDA,
+			role: _solana_kit.AccountRole.READONLY
+		},
+		{
+			address: compressionAuthority,
+			role: _solana_kit.AccountRole.READONLY
+		},
+		{
+			address: ACCOUNT_COMPRESSION_PROGRAM,
+			role: _solana_kit.AccountRole.READONLY
+		},
+		{
+			address: getSystemProgram(),
+			role: _solana_kit.AccountRole.READONLY
+		}
+	];
+	if (config.solPoolPda) metas.push({
+		address: config.solPoolPda,
+		role: _solana_kit.AccountRole.WRITABLE
+	});
+	if (config.solCompressionRecipient) metas.push({
+		address: config.solCompressionRecipient,
+		role: _solana_kit.AccountRole.WRITABLE
+	});
+	if (config.cpiContext) metas.push({
+		address: config.cpiContext,
+		role: _solana_kit.AccountRole.WRITABLE
+	});
+	return metas;
+}
+/**
+* Helper class for building remaining accounts for Light Protocol instructions.
+*
+* Manages three categories of accounts:
+* 1. Pre-accounts: Signers and other accounts that come first
+* 2. System accounts: Light System Program static accounts
+* 3. Packed accounts: Dynamic accounts indexed by pubkey
+*/
+var PackedAccounts = class PackedAccounts {
+	constructor() {
+		this.preAccounts = [];
+		this.systemAccounts = [];
+		this.nextIndex = 0;
+		this.accountMap = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Create a new PackedAccounts with system accounts (V1 layout).
+	*/
+	static async newWithSystemAccounts(config) {
+		const instance = new PackedAccounts();
+		await instance.addSystemAccounts(config);
+		return instance;
+	}
+	/**
+	* Create a new PackedAccounts with system accounts (V2 layout).
+	*/
+	static async newWithSystemAccountsV2(config) {
+		const instance = new PackedAccounts();
+		await instance.addSystemAccountsV2(config);
+		return instance;
+	}
+	/**
+	* Add a signer to pre-accounts (readonly).
+	*/
+	addPreAccountsSigner(pubkey) {
+		this.preAccounts.push({
+			address: pubkey,
+			role: _solana_kit.AccountRole.READONLY_SIGNER
+		});
+	}
+	/**
+	* Add a writable signer to pre-accounts.
+	*/
+	addPreAccountsSignerMut(pubkey) {
+		this.preAccounts.push({
+			address: pubkey,
+			role: _solana_kit.AccountRole.WRITABLE_SIGNER
+		});
+	}
+	/**
+	* Add an account meta to pre-accounts.
+	*/
+	addPreAccountsMeta(accountMeta) {
+		this.preAccounts.push(accountMeta);
+	}
+	/**
+	* Add system accounts (V1 layout).
+	*/
+	async addSystemAccounts(config) {
+		const metas = await getLightSystemAccountMetas(config);
+		this.systemAccounts.push(...metas);
+	}
+	/**
+	* Add system accounts (V2 layout).
+	*/
+	async addSystemAccountsV2(config) {
+		const metas = await getLightSystemAccountMetasV2(config);
+		this.systemAccounts.push(...metas);
+	}
+	/**
+	* Insert or get index for a writable account.
+	*/
+	insertOrGet(pubkey) {
+		return this.insertOrGetConfig(pubkey, false, true);
+	}
+	/**
+	* Insert or get index for a readonly account.
+	*/
+	insertOrGetReadOnly(pubkey) {
+		return this.insertOrGetConfig(pubkey, false, false);
+	}
+	/**
+	* Insert or get index with full configuration.
+	*/
+	insertOrGetConfig(pubkey, isSigner, isWritable) {
+		const key = pubkey;
+		const existing = this.accountMap.get(key);
+		if (existing) return existing[0];
+		const index = this.nextIndex++;
+		let role;
+		if (isSigner && isWritable) role = _solana_kit.AccountRole.WRITABLE_SIGNER;
+		else if (isSigner) role = _solana_kit.AccountRole.READONLY_SIGNER;
+		else if (isWritable) role = _solana_kit.AccountRole.WRITABLE;
+		else role = _solana_kit.AccountRole.READONLY;
+		const meta = {
+			address: pubkey,
+			role
+		};
+		this.accountMap.set(key, [index, meta]);
+		return index;
+	}
+	/**
+	* Get packed accounts sorted by insertion order.
+	*/
+	getPackedAccountMetas() {
+		const entries = Array.from(this.accountMap.entries());
+		entries.sort((a, b) => a[1][0] - b[1][0]);
+		return entries.map(([, [, meta]]) => meta);
+	}
+	/**
+	* Get offsets for system and packed accounts.
+	*/
+	getOffsets() {
+		const systemStart = this.preAccounts.length;
+		return [systemStart, systemStart + this.systemAccounts.length];
+	}
+	/**
+	* Build final remaining accounts array with offsets.
+	*/
+	toAccountMetas() {
+		const packed = this.getPackedAccountMetas();
+		const [systemStart, packedStart] = this.getOffsets();
+		return {
+			remainingAccounts: [
+				...this.preAccounts,
+				...this.systemAccounts,
+				...packed
+			],
+			systemStart,
+			packedStart
+		};
+	}
+};
+
+//#endregion
+//#region src/rpc.ts
+let requestId = 0n;
+/**
+* Light Protocol Photon RPC client.
+*
+* Provides methods for querying compressed accounts, requesting validity proofs,
+* and other indexer operations.
+*/
+var PhotonRpc = class {
+	constructor(endpoint, headers) {
+		this.endpoint = endpoint;
+		this.headers = {
+			"Content-Type": "application/json",
+			Accept: "application/json",
+			...headers
+		};
+	}
+	/**
+	* Make a JSON-RPC request to the Photon indexer.
+	*/
+	async request(method, params) {
+		const body = {
+			jsonrpc: "2.0",
+			id: (++requestId).toString(),
+			method,
+			params
+		};
+		const response = await fetch(this.endpoint, {
+			method: "POST",
+			headers: this.headers,
+			body: JSON.stringify(body)
+		});
+		if (!response.ok) throw createRpcError(RpcErrorCode.RPC_INVALID, "request", `HTTP ${response.status}: ${response.statusText}`);
+		const json = await response.json();
+		if (json.error) throw createRpcError(RpcErrorCode.RPC_INVALID, method, `${json.error.code}: ${json.error.message}`);
+		return json.result;
+	}
+	/**
+	* Request with context wrapper.
+	*/
+	async requestWithContext(method, params) {
+		return this.request(method, params);
+	}
+	/**
+	* Get indexer health status.
+	*/
+	async getIndexerHealth() {
+		return this.request("getIndexerHealth", {});
+	}
+	/**
+	* Get current indexer slot.
+	*/
+	async getIndexerSlot() {
+		return this.request("getIndexerSlot", {});
+	}
+	/**
+	* Get a single compressed account by address or hash.
+	*/
+	async getCompressedAccount(addressOrHash) {
+		const method = versionedEndpoint("getCompressedAccount");
+		const params = {};
+		if (addressOrHash.address) params.address = addressOrHash.address;
+		if (addressOrHash.hash !== void 0) params.hash = encodeBN254(addressOrHash.hash);
+		const result = await this.requestWithContext(method, params);
+		if (!result.value) return null;
+		return parseCompressedAccount(result.value);
+	}
+	/**
+	* Get multiple compressed accounts by hashes.
+	*/
+	async getMultipleCompressedAccounts(hashes) {
+		const method = versionedEndpoint("getMultipleCompressedAccounts");
+		const params = { hashes: hashes.map(encodeBN254) };
+		return (await this.requestWithContext(method, params)).value.items.map(parseCompressedAccount);
+	}
+	/**
+	* Get compressed accounts by owner.
+	*/
+	async getCompressedAccountsByOwner(owner, config) {
+		const method = versionedEndpoint("getCompressedAccountsByOwner");
+		const params = {
+			owner,
+			cursor: config?.cursor,
+			limit: config?.limit
+		};
+		const result = await this.requestWithContext(method, params);
+		return {
+			items: result.value.items.map(parseCompressedAccount),
+			cursor: result.value.cursor
+		};
+	}
+	/**
+	* Get compressed SOL balance by owner.
+	*/
+	async getCompressedBalanceByOwner(owner) {
+		const method = versionedEndpoint("getCompressedBalanceByOwner");
+		const result = await this.requestWithContext(method, { owner });
+		return BigInt(result.value);
+	}
+	/**
+	* Get merkle proof for a compressed account.
+	*/
+	async getCompressedAccountProof(hash) {
+		const method = versionedEndpoint("getCompressedAccountProof");
+		const params = { hash: encodeBN254(hash) };
+		return parseMerkleProof((await this.requestWithContext(method, params)).value);
+	}
+	/**
+	* Get merkle proofs for multiple compressed accounts.
+	*/
+	async getMultipleCompressedAccountProofs(hashes) {
+		const method = versionedEndpoint("getMultipleCompressedAccountProofs");
+		const params = { hashes: hashes.map(encodeBN254) };
+		return (await this.requestWithContext(method, params)).value.map(parseMerkleProof);
+	}
+	/**
+	* Get validity proof for compressed accounts and/or new addresses.
+	*
+	* This is the main method for obtaining ZK proofs needed to use
+	* compressed accounts in transactions.
+	*/
+	async getValidityProof(hashes, newAddresses) {
+		const method = versionedEndpoint("getValidityProof");
+		const params = {
+			hashes: hashes.map((h) => ({
+				hash: encodeBN254(h.hash),
+				tree: h.stateTreeInfo.tree,
+				queue: h.stateTreeInfo.queue
+			})),
+			newAddresses: newAddresses.map((a) => ({
+				address: encodeBN254(a.address),
+				tree: a.addressTreeInfo.tree,
+				queue: a.addressTreeInfo.queue
+			}))
+		};
+		return parseValidityProof((await this.requestWithContext(method, params)).value);
+	}
+	/**
+	* Get compressed token accounts by owner.
+	*/
+	async getCompressedTokenAccountsByOwner(owner, config) {
+		const method = versionedEndpoint("getCompressedTokenAccountsByOwner");
+		const params = {
+			owner,
+			mint: config?.mint,
+			cursor: config?.cursor,
+			limit: config?.limit
+		};
+		const result = await this.requestWithContext(method, params);
+		return {
+			items: result.value.items.map(parseTokenAccount),
+			cursor: result.value.cursor
+		};
+	}
+	/**
+	* Get compressed token balances by owner.
+	*/
+	async getCompressedTokenBalancesByOwner(owner, config) {
+		const method = versionedEndpoint("getCompressedTokenBalancesByOwner");
+		const params = {
+			owner,
+			mint: config?.mint,
+			cursor: config?.cursor,
+			limit: config?.limit
+		};
+		const result = await this.requestWithContext(method, params);
+		return {
+			items: result.value.items.map((item) => ({
+				balance: BigInt(item.balance),
+				mint: (0, _solana_kit.address)(item.mint)
+			})),
+			cursor: result.value.cursor
+		};
+	}
+	/**
+	* Get compression signatures for an account hash.
+	*/
+	async getCompressionSignaturesForAccount(hash) {
+		const method = "getCompressionSignaturesForAccount";
+		const params = { hash: encodeBN254(hash) };
+		return (await this.requestWithContext(method, params)).value.items;
+	}
+	/**
+	* Get compression signatures for an address.
+	*/
+	async getCompressionSignaturesForAddress(addr, options) {
+		const method = "getCompressionSignaturesForAddress";
+		const params = {
+			address: addr,
+			cursor: options?.cursor,
+			limit: options?.limit
+		};
+		const result = await this.requestWithContext(method, params);
+		return {
+			items: result.value.items,
+			cursor: result.value.cursor
+		};
+	}
+	/**
+	* Get compression signatures for an owner.
+	*/
+	async getCompressionSignaturesForOwner(owner, options) {
+		const method = "getCompressionSignaturesForOwner";
+		const params = {
+			owner,
+			cursor: options?.cursor,
+			limit: options?.limit
+		};
+		const result = await this.requestWithContext(method, params);
+		return {
+			items: result.value.items,
+			cursor: result.value.cursor
+		};
+	}
+	/**
+	* Get latest non-voting signatures (compression transactions).
+	*/
+	async getLatestCompressionSignatures(cursor, limit) {
+		const method = "getLatestCompressionSignatures";
+		const params = {
+			cursor,
+			limit
+		};
+		const result = await this.requestWithContext(method, params);
+		return {
+			items: result.value.items,
+			cursor: result.value.cursor
+		};
+	}
+};
+/**
+* Encode BN254 to base58 string for RPC params.
+*/
+function encodeBN254(value) {
+	const bytes = new Uint8Array(32);
+	let remaining = value;
+	for (let i = 31; i >= 0; i--) {
+		bytes[i] = Number(remaining & 255n);
+		remaining >>= 8n;
+	}
+	return bs58.default.encode(bytes);
+}
+function parseCompressedAccount(raw) {
+	const treeInfo = parseTreeInfo(raw);
+	return {
+		owner: (0, _solana_kit.address)(raw.owner),
+		lamports: BigInt(raw.lamports),
+		address: raw.address ? base58ToBytes(raw.address) : null,
+		data: raw.data ? {
+			discriminator: hexToBytes$1(raw.data.discriminator),
+			data: base64ToBytes(raw.data.data),
+			dataHash: base58ToBytes(raw.data.dataHash)
+		} : null,
+		treeInfo,
+		hash: createBN254(raw.hash, "base58"),
+		leafIndex: raw.leafIndex,
+		proveByIndex: raw.proveByIndex ?? false,
+		readOnly: false
+	};
+}
+function parseTreeInfo(raw) {
+	if (featureFlags.isV2() && "merkleContext" in raw && raw.merkleContext) {
+		const ctx = raw.merkleContext;
+		return {
+			tree: (0, _solana_kit.address)(ctx.tree),
+			queue: (0, _solana_kit.address)(ctx.queue),
+			treeType: ctx.treeType,
+			cpiContext: ctx.cpiContext ? (0, _solana_kit.address)(ctx.cpiContext) : void 0,
+			nextTreeInfo: null
+		};
+	}
+	if ("treeContext" in raw && raw.treeContext) {
+		const ctx = raw.treeContext;
+		return {
+			tree: (0, _solana_kit.address)(ctx.tree),
+			queue: (0, _solana_kit.address)(ctx.queue),
+			treeType: ctx.treeType,
+			cpiContext: ctx.cpiContext ? (0, _solana_kit.address)(ctx.cpiContext) : void 0,
+			nextTreeInfo: null
+		};
+	}
+	const tree = "tree" in raw && raw.tree ? raw.tree : "merkleTree" in raw ? raw.merkleTree ?? "" : "";
+	return {
+		tree: (0, _solana_kit.address)(tree),
+		queue: (0, _solana_kit.address)(tree),
+		treeType: 1,
+		nextTreeInfo: null
+	};
+}
+function parseMerkleProof(raw) {
+	return {
+		treeInfo: parseTreeInfo(raw),
+		hash: createBN254(raw.hash, "base58"),
+		leafIndex: raw.leafIndex,
+		proveByIndex: raw.proveByIndex ?? false,
+		merkleProof: raw.proof.map((p) => createBN254(p, "base58")),
+		rootIndex: raw.rootSeq,
+		root: createBN254(raw.root, "base58")
+	};
+}
+function parseValidityProof(raw) {
+	const proof = raw.compressedProof ? {
+		a: new Uint8Array(raw.compressedProof.a),
+		b: new Uint8Array(raw.compressedProof.b),
+		c: new Uint8Array(raw.compressedProof.c)
+	} : null;
+	if (raw.accounts) return {
+		compressedProof: proof,
+		roots: raw.accounts.map((a) => createBN254(a.root, "base58")),
+		rootIndices: raw.accounts.map((a) => a.rootIndex.rootIndex),
+		leafIndices: raw.accounts.map((a) => a.leafIndex),
+		leaves: raw.accounts.map((a) => createBN254(a.hash, "base58")),
+		treeInfos: raw.accounts.map((a) => ({
+			tree: (0, _solana_kit.address)(a.merkleContext.tree),
+			queue: (0, _solana_kit.address)(a.merkleContext.queue),
+			treeType: a.merkleContext.treeType,
+			nextTreeInfo: null
+		})),
+		proveByIndices: raw.accounts.map((a) => a.rootIndex.proveByIndex)
+	};
+	return {
+		compressedProof: proof,
+		roots: raw.roots.map((r) => createBN254(r, "base58")),
+		rootIndices: raw.rootIndices,
+		leafIndices: raw.leafIndices,
+		leaves: raw.leaves.map((l) => createBN254(l, "base58")),
+		treeInfos: (raw.merkleTrees ?? []).map((t) => ({
+			tree: (0, _solana_kit.address)(t),
+			queue: (0, _solana_kit.address)(t),
+			treeType: 1,
+			nextTreeInfo: null
+		})),
+		proveByIndices: raw.leafIndices.map(() => false)
+	};
+}
+function parseTokenAccount(raw) {
+	return {
+		compressedAccount: parseCompressedAccount(raw.account),
+		parsed: {
+			mint: (0, _solana_kit.address)(raw.tokenData.mint),
+			owner: (0, _solana_kit.address)(raw.tokenData.owner),
+			amount: BigInt(raw.tokenData.amount),
+			delegate: raw.tokenData.delegate ? (0, _solana_kit.address)(raw.tokenData.delegate) : null,
+			state: raw.tokenData.state === "initialized" ? 1 : 0,
+			tlv: null
+		}
+	};
+}
+function base58ToBytes(value) {
+	return bs58.default.decode(value);
+}
+function base64ToBytes(value) {
+	const binary = atob(value);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes;
+}
+function hexToBytes$1(hex) {
+	const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+	const bytes = new Uint8Array(cleanHex.length / 2);
+	for (let i = 0; i < bytes.length; i++) bytes[i] = parseInt(cleanHex.slice(i * 2, i * 2 + 2), 16);
+	return bytes;
+}
+/**
+* Create a Photon RPC client.
+*
+* @param endpoint - Photon indexer URL (e.g., "https://zk-testnet.helius.dev:8784")
+* @param headers - Optional additional headers
+* @returns PhotonRpc instance
+*
+* @example
+* ```typescript
+* import { createPhotonRpc } from '@cascade-fyi/compression-kit';
+*
+* const rpc = createPhotonRpc('https://mainnet.helius-rpc.com/?api-key=YOUR_KEY');
+* const accounts = await rpc.getCompressedAccountsByOwner(ownerAddress);
+* ```
+*/
+function createPhotonRpc(endpoint, headers) {
+	return new PhotonRpc(endpoint, headers);
+}
+
+//#endregion
+exports.ACCOUNT_COMPRESSION_PROGRAM = ACCOUNT_COMPRESSION_PROGRAM;
+exports.ADDRESS_QUEUE = ADDRESS_QUEUE;
+exports.ADDRESS_QUEUE_ROLLOVER_FEE = ADDRESS_QUEUE_ROLLOVER_FEE;
+exports.ADDRESS_TREE = ADDRESS_TREE;
+exports.ADDRESS_TREE_NETWORK_FEE_V1 = ADDRESS_TREE_NETWORK_FEE_V1;
+exports.ADDRESS_TREE_NETWORK_FEE_V2 = ADDRESS_TREE_NETWORK_FEE_V2;
+exports.BATCH_ADDRESS_TREE = BATCH_ADDRESS_TREE;
+exports.BATCH_CPI_CONTEXT_1 = BATCH_CPI_CONTEXT_1;
+exports.BATCH_CPI_CONTEXT_2 = BATCH_CPI_CONTEXT_2;
+exports.BATCH_MERKLE_TREE_1 = BATCH_MERKLE_TREE_1;
+exports.BATCH_MERKLE_TREE_2 = BATCH_MERKLE_TREE_2;
+exports.BATCH_QUEUE_1 = BATCH_QUEUE_1;
+exports.BATCH_QUEUE_2 = BATCH_QUEUE_2;
+exports.BN254Error = BN254Error;
+exports.BN254ErrorCode = BN254ErrorCode;
+exports.COMPRESSED_TOKEN_PROGRAM = COMPRESSED_TOKEN_PROGRAM;
+exports.COMPUTE_BUDGET_PATTERN = COMPUTE_BUDGET_PATTERN;
+exports.CPI_CONTEXT_2_PUBKEY = CPI_CONTEXT_2_PUBKEY;
+exports.CPI_CONTEXT_PUBKEY = CPI_CONTEXT_PUBKEY;
+exports.CreateUtxoError = CreateUtxoError;
+exports.CreateUtxoErrorCode = CreateUtxoErrorCode;
+exports.DEFAULT_MERKLE_TREE_HEIGHT = DEFAULT_MERKLE_TREE_HEIGHT;
+exports.DEFAULT_MERKLE_TREE_ROOTS = DEFAULT_MERKLE_TREE_ROOTS;
+exports.FIELD_SIZE = FIELD_SIZE;
+exports.HIGHEST_ADDRESS_PLUS_ONE = HIGHEST_ADDRESS_PLUS_ONE;
+exports.HashError = HashError;
+exports.HashErrorCode = HashErrorCode;
+exports.INSERT_INTO_QUEUES_DISCRIMINATOR = INSERT_INTO_QUEUES_DISCRIMINATOR;
+exports.INVOKE_CPI_DISCRIMINATOR = INVOKE_CPI_DISCRIMINATOR;
+exports.INVOKE_CPI_WITH_ACCOUNT_INFO_DISCRIMINATOR = INVOKE_CPI_WITH_ACCOUNT_INFO_DISCRIMINATOR;
+exports.INVOKE_CPI_WITH_READ_ONLY_DISCRIMINATOR = INVOKE_CPI_WITH_READ_ONLY_DISCRIMINATOR;
+exports.INVOKE_DISCRIMINATOR = INVOKE_DISCRIMINATOR;
+exports.LIGHT_SYSTEM_PROGRAM = LIGHT_SYSTEM_PROGRAM;
+exports.LookupTableError = LookupTableError;
+exports.LookupTableErrorCode = LookupTableErrorCode;
+exports.MERKLE_TREE_2_PUBKEY = MERKLE_TREE_2_PUBKEY;
+exports.MERKLE_TREE_PUBKEY = MERKLE_TREE_PUBKEY;
+exports.MerkleTreeError = MerkleTreeError;
+exports.MerkleTreeErrorCode = MerkleTreeErrorCode;
+exports.NOOP_PROGRAM = NOOP_PROGRAM;
+exports.NULLIFIED_STATE_TREE_LOOKUP_TABLE_DEVNET = NULLIFIED_STATE_TREE_LOOKUP_TABLE_DEVNET;
+exports.NULLIFIED_STATE_TREE_LOOKUP_TABLE_MAINNET = NULLIFIED_STATE_TREE_LOOKUP_TABLE_MAINNET;
+exports.NULLIFIER_QUEUE_2_PUBKEY = NULLIFIER_QUEUE_2_PUBKEY;
+exports.NULLIFIER_QUEUE_PUBKEY = NULLIFIER_QUEUE_PUBKEY;
+exports.PackedAccounts = PackedAccounts;
+exports.PhotonRpc = PhotonRpc;
+exports.ProofError = ProofError;
+exports.ProofErrorCode = ProofErrorCode;
+exports.REGISTERED_PROGRAM_PDA = REGISTERED_PROGRAM_PDA;
+exports.RpcError = RpcError;
+exports.RpcErrorCode = RpcErrorCode;
+exports.STATE_MERKLE_TREE_NETWORK_FEE = STATE_MERKLE_TREE_NETWORK_FEE;
+exports.STATE_MERKLE_TREE_ROLLOVER_FEE = STATE_MERKLE_TREE_ROLLOVER_FEE;
+exports.STATE_TREE_LOOKUP_TABLE_DEVNET = STATE_TREE_LOOKUP_TABLE_DEVNET;
+exports.STATE_TREE_LOOKUP_TABLE_MAINNET = STATE_TREE_LOOKUP_TABLE_MAINNET;
+exports.SelectInUtxosError = SelectInUtxosError;
+exports.SelectInUtxosErrorCode = SelectInUtxosErrorCode;
+exports.TEST_BATCH_ADDRESS_TREE = TEST_BATCH_ADDRESS_TREE;
+exports.TRANSACTION_MERKLE_TREE_ROLLOVER_THRESHOLD = TRANSACTION_MERKLE_TREE_ROLLOVER_THRESHOLD;
+exports.TreeType = TreeType;
+exports.UTXO_MERGE_MAXIMUM = UTXO_MERGE_MAXIMUM;
+exports.UTXO_MERGE_THRESHOLD = UTXO_MERGE_THRESHOLD;
+exports.UtilsError = UtilsError;
+exports.UtilsErrorCode = UtilsErrorCode;
+exports.UtxoError = UtxoError;
+exports.UtxoErrorCode = UtxoErrorCode;
+exports.VERSION = VERSION;
+exports.addressToBytes = addressToBytes;
+exports.assertIsBN254 = assertIsBN254;
+exports.assertValidBN254Hash = assertValidBN254Hash;
+exports.bigIntToBytesBE = bigIntToBytesBE;
+exports.bigIntToBytesLE = bigIntToBytesLE;
+exports.bn254Add = bn254Add;
+exports.bn254FromBytes = bn254FromBytes;
+exports.bn254Mul = bn254Mul;
+exports.bn254Sub = bn254Sub;
+exports.bn254ToBytes = bn254ToBytes;
+exports.bn254ToDecimalString = bn254ToDecimalString;
+exports.bytesEqual = bytesEqual;
+exports.bytesToAddress = bytesToAddress;
+exports.bytesToBigIntBE = bytesToBigIntBE;
+exports.bytesToBigIntLE = bytesToBigIntLE;
+exports.bytesToDecimalString = bytesToDecimalString;
+exports.bytesToHex = bytesToHex;
+exports.createBN254 = createBN254;
+exports.createBN254Error = createBN254Error;
+exports.createPhotonRpc = createPhotonRpc;
+exports.createProofError = createProofError;
+exports.createRpcError = createRpcError;
+exports.createSystemAccountConfig = createSystemAccountConfig;
+exports.createSystemAccountConfigWithCpi = createSystemAccountConfigWithCpi;
+exports.createUtxoError = createUtxoError;
+exports.defaultStateTreeLookupTables = defaultStateTreeLookupTables;
+exports.defaultStaticAccounts = defaultStaticAccounts;
+exports.defaultTestStateTreeAccounts = defaultTestStateTreeAccounts;
+exports.deriveAddress = deriveAddress;
+exports.deriveAddressSeed = deriveAddressSeed;
+exports.deriveAddressSeedV2 = deriveAddressSeedV2;
+exports.deriveAddressV2 = deriveAddressV2;
+exports.encodeBN254toBase58 = encodeBN254toBase58;
+exports.encodeBN254toHex = encodeBN254toHex;
+exports.featureFlags = featureFlags;
+exports.getAccountCompressionAuthority = getAccountCompressionAuthority;
+exports.getCompressionAuthority = getAccountCompressionAuthority$1;
+exports.getCpiSignerPda = getCpiSignerPda;
+exports.getDefaultAddressTreeInfo = getDefaultAddressTreeInfo;
+exports.getIndexOrAdd = getIndexOrAdd;
+exports.getLightSystemAccountMetas = getLightSystemAccountMetas;
+exports.getLightSystemAccountMetasV2 = getLightSystemAccountMetasV2;
+exports.getSystemProgram = getSystemProgram;
+exports.hashToBn254FieldSizeBe = hashToBn254FieldSizeBe;
+exports.hashvToBn254FieldSizeBe = hashvToBn254FieldSizeBe;
+exports.hashvToBn254FieldSizeBeWithBump = hashvToBn254FieldSizeBeWithBump;
+exports.hexToBytes = hexToBytes;
+exports.isBN254 = isBN254;
+exports.isLocalTest = isLocalTest;
+exports.isSmallerThanFieldSize = isSmallerThanFieldSize;
+exports.localTestActiveStateTreeInfos = localTestActiveStateTreeInfos;
+exports.mergeBytes = mergeBytes;
+exports.packNewAddressParams = packNewAddressParams;
+exports.padBytes = padBytes;
+exports.pushUniqueItems = pushUniqueItems;
+exports.toArray = toArray;
+exports.toHex = toHex;
+exports.validateBN254Hash = validateBN254Hash;
+exports.versionedEndpoint = versionedEndpoint;