@lightprotocol/stateless.js 0.1.0-alpha.0

package/dist/es/index.js

@@ -0,0 +1,3988 @@
+import { BN, AnchorProvider, setProvider, Program } from '@coral-xyz/anchor';
+import { Connection, sendAndConfirmTransaction, PublicKey, Keypair, TransactionMessage, VersionedTransaction, SolanaJSONRPCError, ComputeBudgetProgram, SystemProgram } from '@solana/web3.js';
+import { sign } from 'tweetnacl';
+import { bs58 } from '@coral-xyz/anchor/dist/cjs/utils/bytes';
+import { Buffer as Buffer$1 } from 'buffer';
+import { keccak_256 } from '@noble/hashes/sha3';
+import { WasmFactory } from '@lightprotocol/hasher.rs';
+import axios from 'axios';
+import { coerce, instance, string, number, nullable, unknown, type, boolean, array, union, literal, any, create } from 'superstruct';
+
+const IDL$3 = {
+    version: '0.3.0',
+    name: 'psp_compressed_pda',
+    constants: [
+        {
+            name: 'COMPRESSED_SOL_PDA_SEED',
+            type: 'bytes',
+            value: '[99, 111, 109, 112, 114, 101, 115, 115, 101, 100, 95, 115, 111, 108, 95, 112, 100, 97]',
+        },
+    ],
+    instructions: [
+        {
+            name: 'initCompressSolPda',
+            docs: [
+                'Initializes the compressed sol pda.',
+                'This pda is used to store compressed sol for the protocol.',
+            ],
+            accounts: [
+                {
+                    name: 'feePayer',
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: 'compressedSolPda',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+            ],
+            args: [],
+        },
+        {
+            name: 'executeCompressedTransaction',
+            docs: [
+                'This function can be used to transfer sol and execute any other compressed transaction.',
+                'Instruction data is not optimized for space.',
+                'This method can be called by cpi so that instruction data can be compressed with a custom algorithm.',
+            ],
+            accounts: [
+                {
+                    name: 'signer',
+                    isMut: false,
+                    isSigner: true,
+                },
+                {
+                    name: 'registeredProgramPda',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'noopProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'pspAccountCompressionAuthority',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'accountCompressionProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'cpiSignatureAccount',
+                    isMut: false,
+                    isSigner: false,
+                    isOptional: true,
+                },
+                {
+                    name: 'invokingProgram',
+                    isMut: false,
+                    isSigner: false,
+                    isOptional: true,
+                },
+                {
+                    name: 'compressedSolPda',
+                    isMut: true,
+                    isSigner: false,
+                    isOptional: true,
+                },
+                {
+                    name: 'compressionRecipient',
+                    isMut: true,
+                    isSigner: false,
+                    isOptional: true,
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false,
+                    isOptional: true,
+                },
+            ],
+            args: [
+                {
+                    name: 'inputs',
+                    type: 'bytes',
+                },
+            ],
+            returns: {
+                defined: 'crate::event::PublicTransactionEvent',
+            },
+        },
+    ],
+    accounts: [
+        {
+            name: 'cpiSignatureAccount',
+            docs: [
+                'collects invocations without proofs',
+                'invocations are collected and processed when an invocation with a proof is received',
+            ],
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'slot',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'signatures',
+                        type: {
+                            vec: {
+                                defined: 'InstructionDataTransfer',
+                            },
+                        },
+                    },
+                ],
+            },
+        },
+        {
+            name: 'compressedSolPda',
+            type: {
+                kind: 'struct',
+                fields: [],
+            },
+        },
+    ],
+    types: [
+        {
+            name: 'CompressedAccountWithMerkleContext',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'compressedAccount',
+                        type: {
+                            defined: 'CompressedAccount',
+                        },
+                    },
+                    {
+                        name: 'merkleTreePubkeyIndex',
+                        type: 'u8',
+                    },
+                    {
+                        name: 'nullifierQueuePubkeyIndex',
+                        type: 'u8',
+                    },
+                    {
+                        name: 'leafIndex',
+                        type: 'u32',
+                    },
+                ],
+            },
+        },
+        {
+            name: 'CompressedAccount',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'owner',
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'lamports',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'address',
+                        type: {
+                            option: {
+                                array: ['u8', 32],
+                            },
+                        },
+                    },
+                    {
+                        name: 'data',
+                        type: {
+                            option: {
+                                defined: 'CompressedAccountData',
+                            },
+                        },
+                    },
+                ],
+            },
+        },
+        {
+            name: 'CompressedAccountData',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'discriminator',
+                        type: {
+                            array: ['u8', 8],
+                        },
+                    },
+                    {
+                        name: 'data',
+                        type: 'bytes',
+                    },
+                    {
+                        name: 'dataHash',
+                        type: {
+                            array: ['u8', 32],
+                        },
+                    },
+                ],
+            },
+        },
+        {
+            name: 'PublicTransactionEvent',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'inputCompressedAccountHashes',
+                        type: {
+                            vec: {
+                                array: ['u8', 32],
+                            },
+                        },
+                    },
+                    {
+                        name: 'outputCompressedAccountHashes',
+                        type: {
+                            vec: {
+                                array: ['u8', 32],
+                            },
+                        },
+                    },
+                    {
+                        name: 'inputCompressedAccounts',
+                        type: {
+                            vec: {
+                                defined: 'CompressedAccountWithMerkleContext',
+                            },
+                        },
+                    },
+                    {
+                        name: 'outputCompressedAccounts',
+                        type: {
+                            vec: {
+                                defined: 'CompressedAccount',
+                            },
+                        },
+                    },
+                    {
+                        name: 'outputStateMerkleTreeAccountIndices',
+                        type: 'bytes',
+                    },
+                    {
+                        name: 'outputLeafIndices',
+                        type: {
+                            vec: 'u32',
+                        },
+                    },
+                    {
+                        name: 'relayFee',
+                        type: {
+                            option: 'u64',
+                        },
+                    },
+                    {
+                        name: 'isCompress',
+                        type: 'bool',
+                    },
+                    {
+                        name: 'compressionLamports',
+                        type: {
+                            option: 'u64',
+                        },
+                    },
+                    {
+                        name: 'pubkeyArray',
+                        type: {
+                            vec: 'publicKey',
+                        },
+                    },
+                    {
+                        name: 'message',
+                        type: {
+                            option: 'bytes',
+                        },
+                    },
+                ],
+            },
+        },
+        {
+            name: 'InstructionDataTransfer',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'proof',
+                        type: {
+                            option: {
+                                defined: 'CompressedProof',
+                            },
+                        },
+                    },
+                    {
+                        name: 'newAddressParams',
+                        type: {
+                            vec: {
+                                defined: 'NewAddressParamsPacked',
+                            },
+                        },
+                    },
+                    {
+                        name: 'inputRootIndices',
+                        type: {
+                            vec: 'u16',
+                        },
+                    },
+                    {
+                        name: 'inputCompressedAccountsWithMerkleContext',
+                        type: {
+                            vec: {
+                                defined: 'CompressedAccountWithMerkleContext',
+                            },
+                        },
+                    },
+                    {
+                        name: 'outputCompressedAccounts',
+                        type: {
+                            vec: {
+                                defined: 'CompressedAccount',
+                            },
+                        },
+                    },
+                    {
+                        name: 'outputStateMerkleTreeAccountIndices',
+                        docs: [
+                            'The indices of the accounts in the output state merkle tree.',
+                        ],
+                        type: 'bytes',
+                    },
+                    {
+                        name: 'relayFee',
+                        type: {
+                            option: 'u64',
+                        },
+                    },
+                    {
+                        name: 'compressionLamports',
+                        type: {
+                            option: 'u64',
+                        },
+                    },
+                    {
+                        name: 'isCompress',
+                        type: 'bool',
+                    },
+                ],
+            },
+        },
+        {
+            name: 'NewAddressParamsPacked',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'seed',
+                        type: {
+                            array: ['u8', 32],
+                        },
+                    },
+                    {
+                        name: 'addressQueueAccountIndex',
+                        type: 'u8',
+                    },
+                    {
+                        name: 'addressMerkleTreeAccountIndex',
+                        type: 'u8',
+                    },
+                    {
+                        name: 'addressMerkleTreeRootIndex',
+                        type: 'u16',
+                    },
+                ],
+            },
+        },
+        {
+            name: 'NewAddressParams',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'seed',
+                        type: {
+                            array: ['u8', 32],
+                        },
+                    },
+                    {
+                        name: 'addressQueuePubkey',
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'addressMerkleTreePubkey',
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'addressMerkleTreeRootIndex',
+                        type: 'u16',
+                    },
+                ],
+            },
+        },
+        {
+            name: 'CompressedProof',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'a',
+                        type: {
+                            array: ['u8', 32],
+                        },
+                    },
+                    {
+                        name: 'b',
+                        type: {
+                            array: ['u8', 64],
+                        },
+                    },
+                    {
+                        name: 'c',
+                        type: {
+                            array: ['u8', 32],
+                        },
+                    },
+                ],
+            },
+        },
+    ],
+    errors: [
+        {
+            code: 6000,
+            name: 'SumCheckFailed',
+            msg: 'Sum check failed',
+        },
+        {
+            code: 6001,
+            name: 'SignerCheckFailed',
+            msg: 'Signer check failed',
+        },
+        {
+            code: 6002,
+            name: 'CpiSignerCheckFailed',
+            msg: 'Cpi signer check failed',
+        },
+        {
+            code: 6003,
+            name: 'ComputeInputSumFailed',
+            msg: 'Computing input sum failed.',
+        },
+        {
+            code: 6004,
+            name: 'ComputeOutputSumFailed',
+            msg: 'Computing output sum failed.',
+        },
+        {
+            code: 6005,
+            name: 'ComputeRpcSumFailed',
+            msg: 'Computing rpc sum failed.',
+        },
+        {
+            code: 6006,
+            name: 'InUtxosAlreadyAdded',
+            msg: 'InUtxosAlreadyAdded',
+        },
+        {
+            code: 6007,
+            name: 'NumberOfLeavesMissmatch',
+            msg: 'NumberOfLeavesMissmatch',
+        },
+        {
+            code: 6008,
+            name: 'MerkleTreePubkeysMissmatch',
+            msg: 'MerkleTreePubkeysMissmatch',
+        },
+        {
+            code: 6009,
+            name: 'NullifierArrayPubkeysMissmatch',
+            msg: 'NullifierArrayPubkeysMissmatch',
+        },
+        {
+            code: 6010,
+            name: 'InvalidNoopPubkey',
+            msg: 'InvalidNoopPubkey',
+        },
+        {
+            code: 6011,
+            name: 'InvalidPublicInputsLength',
+            msg: 'InvalidPublicInputsLength',
+        },
+        {
+            code: 6012,
+            name: 'DecompressG1Failed',
+            msg: 'Decompress G1 Failed',
+        },
+        {
+            code: 6013,
+            name: 'DecompressG2Failed',
+            msg: 'Decompress G2 Failed',
+        },
+        {
+            code: 6014,
+            name: 'CreateGroth16VerifierFailed',
+            msg: 'CreateGroth16VerifierFailed',
+        },
+        {
+            code: 6015,
+            name: 'ProofVerificationFailed',
+            msg: 'ProofVerificationFailed',
+        },
+        {
+            code: 6016,
+            name: 'PublicInputsTryIntoFailed',
+            msg: 'PublicInputsTryIntoFailed',
+        },
+        {
+            code: 6017,
+            name: 'CompressedAccountHashError',
+            msg: 'CompressedAccountHashError',
+        },
+        {
+            code: 6018,
+            name: 'InvalidAddress',
+            msg: 'InvalidAddress',
+        },
+        {
+            code: 6019,
+            name: 'InvalidAddressQueue',
+            msg: 'InvalidAddressQueue',
+        },
+        {
+            code: 6020,
+            name: 'InvalidNullifierQueue',
+            msg: 'InvalidNullifierQueue',
+        },
+        {
+            code: 6021,
+            name: 'DeriveAddressError',
+            msg: 'DeriveAddressError',
+        },
+        {
+            code: 6022,
+            name: 'CompressSolTransferFailed',
+            msg: 'CompressSolTransferFailed',
+        },
+        {
+            code: 6023,
+            name: 'CompressedSolPdaUndefinedForCompressSol',
+            msg: 'CompressedSolPdaUndefinedForCompressSol',
+        },
+        {
+            code: 6024,
+            name: 'DeCompressLamportsUndefinedForCompressSol',
+            msg: 'DeCompressLamportsUndefinedForCompressSol',
+        },
+        {
+            code: 6025,
+            name: 'CompressedSolPdaUndefinedForDecompressSol',
+            msg: 'CompressedSolPdaUndefinedForDecompressSol',
+        },
+        {
+            code: 6026,
+            name: 'DeCompressLamportsUndefinedForDecompressSol',
+            msg: 'DeCompressLamportsUndefinedForDecompressSol',
+        },
+        {
+            code: 6027,
+            name: 'DecompressRecipientUndefinedForDecompressSol',
+            msg: 'DecompressRecipientUndefinedForDecompressSol',
+        },
+        {
+            code: 6028,
+            name: 'LengthMismatch',
+            msg: 'LengthMismatch',
+        },
+        {
+            code: 6029,
+            name: 'DelegateUndefined',
+            msg: 'DelegateUndefined while delegated amount is defined',
+        },
+    ],
+};
+
+/// TODO: extract wallet into its own npm package
+/// Mock Solana web3 library
+class Wallet {
+    _publicKey;
+    _keypair;
+    _connection;
+    _url;
+    _commitment;
+    constructor(keypair, url, commitment) {
+        this._publicKey = keypair.publicKey;
+        this._keypair = keypair;
+        this._connection = new Connection(url);
+        this._url = url;
+        this._commitment = commitment;
+    }
+    signTransaction = async (tx) => {
+        await tx.sign([this._keypair]);
+        return tx;
+    };
+    sendTransaction = async (transaction) => {
+        const signature = await this._connection.sendTransaction(transaction);
+        return signature;
+    };
+    signAllTransactions = async (transactions) => {
+        const signedTxs = await Promise.all(transactions.map(async (tx) => {
+            return await this.signTransaction(tx);
+        }));
+        return signedTxs;
+    };
+    signMessage = async (message) => {
+        return sign.detached(message, this._keypair.secretKey);
+    };
+    sendAndConfirmTransaction = async (transaction, signers = []) => {
+        const response = await sendAndConfirmTransaction(this._connection, transaction, [this._keypair, ...signers], {
+            commitment: this._commitment,
+        });
+        return response;
+    };
+}
+
+// // TODO consider adding isNodeWallet
+const useWallet = (keypair, url = 'http://127.0.0.1:8899', commitment = 'confirmed') => {
+    url = url !== 'mock' ? url : 'http://127.0.0.1:8899';
+    const wallet = new Wallet(keypair, url, commitment);
+    return {
+        publicKey: wallet._publicKey,
+        sendAndConfirmTransaction: wallet.sendAndConfirmTransaction,
+        signMessage: wallet.signMessage,
+        signTransaction: wallet.signTransaction,
+        signAllTransactions: wallet.signAllTransactions,
+        sendTransaction: wallet.sendTransaction,
+    };
+};
+
+const FIELD_SIZE = new BN('21888242871839275222246405745257275088548364400416034343698204186575808495617');
+// TODO: implement properly
+const noopProgram = 'noopb9bkMVfRPU8AsbpTUg8AQkHtKwMYZiFUjNRtMmV';
+const lightProgram = '5WzvRtu7LABotw1SUEpguJiKU27LRGsiCnF5FH6VV7yP';
+const accountCompressionProgram = // also: merkletree program
+ '5QPEJ5zDsVou9FQS3KCauKswM3VwBEBu4dpL9xTqkWwN';
+const getRegisteredProgramPda = () => new PublicKey('ytwwVWhQUMoTKdirKmvEW5xCRVr4B2dJZnToiHtE2L2'); // TODO: better labelling. gov authority pda
+const getPspAccountCompressionAuthority = () => PublicKey.findProgramAddressSync([
+    Buffer$1.from('cpi_authority'),
+    new PublicKey(accountCompressionProgram).toBytes(),
+], new PublicKey(
+// TODO: can add check to ensure its consistent with the idl
+'6UqiSPd2mRCTTwkzhcs1M6DGYsqHWd5jiPueX3LwDMXQ'))[0];
+const defaultStaticAccounts = () => [
+    new PublicKey(getRegisteredProgramPda()),
+    new PublicKey(noopProgram),
+    new PublicKey(accountCompressionProgram),
+    new PublicKey(getPspAccountCompressionAuthority()),
+];
+const defaultStaticAccountsStruct = () => {
+    return {
+        registeredProgramPda: new PublicKey(getRegisteredProgramPda()),
+        noopProgram: new PublicKey(noopProgram),
+        accountCompressionProgram: new PublicKey(accountCompressionProgram),
+        pspAccountCompressionAuthority: new PublicKey(getPspAccountCompressionAuthority()),
+        cpiSignatureAccount: null,
+    };
+};
+const defaultTestStateTreeAccounts = () => {
+    return {
+        nullifierQueue: new PublicKey(nullifierQueuePubkey),
+        merkleTree: new PublicKey(merkletreePubkey),
+        merkleTreeHeight: DEFAULT_MERKLE_TREE_HEIGHT,
+    };
+};
+const nullifierQueuePubkey = '44J4oDXpjPAbzHCSc24q7NEiPekss4sAbLd8ka4gd9CZ'; // also called indexed_array
+const merkletreePubkey = '5bdFnXU47QjzGpzHfXnxcEi5WXyxzEAZzd1vrE39bf1W';
+const confirmConfig = {
+    commitment: 'confirmed',
+    preflightCommitment: 'confirmed',
+};
+const DEFAULT_MERKLE_TREE_HEIGHT = 26;
+const DEFAULT_MERKLE_TREE_ROOTS = 2800;
+/** Threshold (per asset) at which new in-UTXOs get merged, in order to reduce UTXO pool size */
+const UTXO_MERGE_THRESHOLD = 20;
+const UTXO_MERGE_MAXIMUM = 10;
+/**
+ * Treshold after which the currently used transaction Merkle tree is switched
+ * to the next one
+ */
+const TRANSACTION_MERKLE_TREE_ROLLOVER_THRESHOLD = new BN(Math.floor(2 ** DEFAULT_MERKLE_TREE_HEIGHT * 0.95));
+
+// TODO: consider implementing BN254 as wrapper class around _BN mirroring
+// PublicKey this would encapsulate our runtime checks and also enforce
+// typesafety at compile time
+const bn = (number, base, endian) => new BN(number, base, endian);
+/** Create a bigint instance with <254-bit max size and base58 capabilities */
+const createBN254 = (number, base) => {
+    if (base === 'base58') {
+        if (typeof number !== 'string')
+            throw new Error('Must be a base58 string');
+        return createBN254(bs58.decode(number));
+    }
+    const bigintNumber = new BN(number, base);
+    return enforceSize(bigintNumber);
+};
+/**
+ * Enforces a maximum size of <254 bits for bigint instances. This is necessary
+ * for compatibility with zk-SNARKs, where hashes must be less than the field
+ * modulus (~2^254).
+ */
+function enforceSize(bigintNumber) {
+    if (bigintNumber.gte(FIELD_SIZE)) {
+        throw new Error('Value is too large. Max <254 bits');
+    }
+    return bigintNumber;
+}
+/** Convert <254-bit bigint to Base58 string. Fills up to 32 bytes. */
+function encodeBN254toBase58(bigintNumber, pad = 32) {
+    let buffer = Buffer$1.from(bigintNumber.toString(16), 'hex');
+    // Ensure the buffer is 32 bytes. If not, pad it with leading zeros.
+    if (buffer.length < pad) {
+        const padding = Buffer$1.alloc(pad - buffer.length);
+        buffer = Buffer$1.concat([padding, buffer], pad);
+    }
+    return bs58.encode(buffer);
+}
+/** Convert Base58 string to <254-bit Solana Public key*/
+function bigint254ToPublicKey(bigintNumber) {
+    const paddedBase58 = encodeBN254toBase58(bigintNumber);
+    return new PublicKey(paddedBase58);
+}
+// FIXME: assumes <254 bit pubkey. just use consistent type (pubkey254)
+/** Convert Solana Public key to <254-bit bigint */
+function PublicKeyToBN254(publicKey) {
+    const buffer = publicKey.toBuffer();
+    // Remove leading zeros from the buffer
+    const trimmedBuffer = buffer.subarray(buffer.findIndex(byte => byte !== 0));
+    return createBN254(trimmedBuffer);
+}
+//@ts-ignore
+if (import.meta.vitest) {
+    //@ts-ignore
+    const { it, expect, describe } = import.meta.vitest;
+    describe('createBN254 function', () => {
+        it('should create a BN254 from a string', () => {
+            const bigint = createBN254('100');
+            expect(bigint.toNumber()).toBe(100);
+        });
+        it('should create a BN254 from a number', () => {
+            const bigint = createBN254(100);
+            expect(bigint.toNumber()).toBe(100);
+        });
+        it('should create a BN254 from a bigint', () => {
+            const bigint = createBN254(bn(100));
+            expect(bigint.toNumber()).toBe(100);
+        });
+        it('should create a BN254 from a Buffer', () => {
+            const bigint = createBN254(Buffer$1.from([100]));
+            expect(bigint.toNumber()).toBe(100);
+        });
+        it('should create a BN254 from a Uint8Array', () => {
+            const bigint = createBN254(new Uint8Array([100]));
+            expect(bigint.toNumber()).toBe(100);
+        });
+        it('should create a BN254 from a number[]', () => {
+            const bigint = createBN254([100]);
+            expect(bigint.toNumber()).toBe(100);
+        });
+        it('should create a BN254 from a base58 string', () => {
+            const bigint = createBN254('2j', 'base58');
+            expect(bigint.toNumber()).toBe(bn(100).toNumber());
+        });
+    });
+    describe('encodeBN254toBase58 function', () => {
+        it('should convert a BN254 to a base58 string, no pad', () => {
+            const bigint = createBN254('100');
+            const base58 = encodeBN254toBase58(bigint, 0);
+            expect(base58).toBe('2j');
+        });
+        it('should convert a BN254 to a base58 string, with pad', () => {
+            const bigint = createBN254('100');
+            const base58 = encodeBN254toBase58(bigint);
+            expect(base58).toBe('11111111111111111111111111111112j');
+        });
+        it('should throw an error for a value that is too large', () => {
+            expect(() => createBN254(FIELD_SIZE)).toThrow('Value is too large. Max <254 bits');
+        });
+    });
+    describe('bigint254ToPublicKey function', () => {
+        it('should convert a BN254 to a PublicKey', () => {
+            const bigint = createBN254('100');
+            const publicKey = bigint254ToPublicKey(bigint);
+            expect(publicKey).toBeInstanceOf(PublicKey);
+        });
+    });
+    describe('PublicKeyToBigint254 function', () => {
+        it('should convert a PublicKey to a BN254', () => {
+            const publicKey = PublicKey.unique();
+            const bigint = PublicKeyToBN254(publicKey);
+            expect(bigint).toBeInstanceOf(BN);
+        });
+    });
+}
+
+const createCompressedAccount = (owner, lamports, data, address) => ({
+    owner,
+    lamports: lamports ?? bn(0),
+    address: address ?? null,
+    data: data ?? null,
+});
+const createCompressedAccountWithMerkleContext = (merkleContext, owner, lamports, data, address) => ({
+    ...createCompressedAccount(owner, lamports, data, address),
+    ...merkleContext,
+});
+const createMerkleContext = (merkleTree, nullifierQueue, hash, // TODO: BN254,
+leafIndex) => ({
+    merkleTree,
+    nullifierQueue,
+    hash,
+    leafIndex,
+});
+//@ts-ignore
+if (import.meta.vitest) {
+    //@ts-ignore
+    const { it, expect, describe } = import.meta.vitest;
+    describe('createCompressedAccount function', () => {
+        it('should create a compressed account with default values', () => {
+            const owner = PublicKey.unique();
+            const account = createCompressedAccount(owner);
+            expect(account).toEqual({
+                owner,
+                lamports: bn(0),
+                address: null,
+                data: null,
+            });
+        });
+        it('should create a compressed account with provided values', () => {
+            const owner = PublicKey.unique();
+            const lamports = bn(100);
+            const data = {
+                discriminator: [0],
+                data: Buffer.from(new Uint8Array([1, 2, 3])),
+                dataHash: [0],
+            };
+            const address = PublicKey.unique();
+            const account = createCompressedAccount(owner, lamports, data, address);
+            expect(account).toEqual({
+                owner,
+                lamports,
+                address,
+                data,
+            });
+        });
+    });
+    describe('createCompressedAccountWithMerkleContext function', () => {
+        it('should create a compressed account with merkle context', () => {
+            const owner = PublicKey.unique();
+            const merkleTree = PublicKey.unique();
+            const nullifierQueue = PublicKey.unique();
+            const hash = new Array(32).fill(1);
+            const leafIndex = 0;
+            const merkleContext = createMerkleContext(merkleTree, nullifierQueue, hash, leafIndex);
+            const accountWithMerkleContext = createCompressedAccountWithMerkleContext(merkleContext, owner);
+            expect(accountWithMerkleContext).toEqual({
+                owner,
+                lamports: bn(0),
+                address: null,
+                data: null,
+                merkleTree,
+                nullifierQueue,
+                hash,
+                leafIndex,
+            });
+        });
+    });
+    describe('createMerkleContext function', () => {
+        it('should create a merkle context', () => {
+            const merkleTree = PublicKey.unique();
+            const nullifierQueue = PublicKey.unique();
+            const hash = new Array(32).fill(1);
+            const leafIndex = 0;
+            const merkleContext = createMerkleContext(merkleTree, nullifierQueue, hash, leafIndex);
+            expect(merkleContext).toEqual({
+                merkleTree,
+                nullifierQueue,
+                hash,
+                leafIndex,
+            });
+        });
+    });
+}
+
+function byteArrayToKeypair(byteArray) {
+    return Keypair.fromSecretKey(Uint8Array.from(byteArray));
+}
+const toArray = (value) => Array.isArray(value) ? value : [value];
+const bufToDecStr = (buf) => {
+    return createBN254(buf).toString();
+};
+function isSmallerThanBn254FieldSizeLe(bytes) {
+    const bigint = bn(bytes, undefined, 'le');
+    return bigint.lt(FIELD_SIZE);
+}
+async function hashToBn254FieldSizeLe(bytes) {
+    let bumpSeed = 255;
+    while (bumpSeed >= 0) {
+        const inputWithBumpSeed = Buffer$1.concat([
+            bytes,
+            Buffer$1.from([bumpSeed]),
+        ]);
+        const hash = keccak_256(inputWithBumpSeed);
+        if (hash.length !== 32) {
+            throw new Error('Invalid hash length');
+        }
+        hash[0] = 0;
+        hash[1] = 0;
+        if (isSmallerThanBn254FieldSizeLe(Buffer$1.from(hash))) {
+            return [Buffer$1.from(hash), bumpSeed];
+        }
+        bumpSeed -= 1;
+    }
+    return null;
+}
+/** Mutates array in place */
+function pushUniqueItems(items, map) {
+    items.forEach(item => {
+        if (!map.includes(item)) {
+            map.push(item);
+        }
+    });
+}
+function toCamelCase(obj) {
+    if (Array.isArray(obj)) {
+        return obj.map(v => toCamelCase(v));
+    }
+    else if (obj !== null && obj.constructor === Object) {
+        return Object.keys(obj).reduce((result, key) => {
+            const camelCaseKey = key.replace(/([-_][a-z])/gi, $1 => {
+                return $1.toUpperCase().replace('-', '').replace('_', '');
+            });
+            result[camelCaseKey] = toCamelCase(obj[key]);
+            return result;
+        }, {});
+    }
+    return obj;
+}
+// FIXME: check bundling and how to resolve the type error
+//@ts-ignore
+if (import.meta.vitest) {
+    //@ts-ignore
+    const { it, expect, describe } = import.meta.vitest;
+    describe('toArray function', () => {
+        it('should convert a single item to an array', () => {
+            expect(toArray(1)).toEqual([1]);
+        });
+        it('should leave an array unchanged', () => {
+            expect(toArray([1, 2, 3])).toEqual([1, 2, 3]);
+        });
+    });
+    describe('isSmallerThanBn254FieldSizeLe function', () => {
+        it('should return true for a small number', () => {
+            const buf = Buffer$1.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex');
+            expect(isSmallerThanBn254FieldSizeLe(buf)).toBe(true);
+        });
+        it('should return false for a large number', () => {
+            const buf = Buffer$1.from('6500000000000000000000000000000000000000000000000000000000000000', 'hex').reverse();
+            expect(isSmallerThanBn254FieldSizeLe(buf)).toBe(false);
+        });
+    });
+    describe('hashToBn254FieldSizeLe function', () => {
+        const bytes = [
+            131, 219, 249, 246, 221, 196, 33, 3, 114, 23, 121, 235, 18, 229, 71,
+            152, 39, 87, 169, 208, 143, 101, 43, 128, 245, 59, 22, 134, 182,
+            231, 116, 33,
+        ];
+        const refResult = [
+            0, 0, 138, 224, 71, 10, 16, 226, 30, 104, 100, 251, 232, 59, 50,
+            168, 21, 78, 218, 191, 159, 16, 119, 17, 30, 55, 194, 230, 138, 128,
+            18, 44,
+        ];
+        it('should return a valid value for initial buffer', async () => {
+            const result = await hashToBn254FieldSizeLe(Buffer$1.from(bytes));
+            expect(Array.from(result[0])).toEqual(refResult);
+        });
+        it('should return a valid value for initial buffer', async () => {
+            const buf = Buffer$1.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex');
+            const result = await hashToBn254FieldSizeLe(buf);
+            expect(result).not.toBeNull();
+            if (result) {
+                expect(result[0]).toBeInstanceOf(Buffer$1);
+                expect(result[1]).toBe(254);
+            }
+        });
+        it('should return a valid value for a buffer that can be hashed to a smaller value', async () => {
+            const buf = Buffer$1.from('fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe', 'hex');
+            const result = await hashToBn254FieldSizeLe(buf);
+            expect(result).not.toBeNull();
+            if (result) {
+                expect(result[1]).toBeLessThanOrEqual(255);
+                expect(result[0]).toBeInstanceOf(Buffer$1);
+                // Check if the hashed value is indeed smaller than the bn254 field size
+                expect(isSmallerThanBn254FieldSizeLe(result[0])).toBe(true);
+            }
+        });
+        it('should correctly hash the input buffer', async () => {
+            const buf = Buffer$1.from('deadbeef', 'hex');
+            const result = await hashToBn254FieldSizeLe(buf);
+            expect(result).not.toBeNull();
+            if (result) {
+                // Since the actual hash value depends on the crypto implementation and input,
+                // we cannot predict the exact output. However, we can check if the output is valid.
+                expect(result[0].length).toBe(32); // SHA-256 hash length
+                expect(result[1]).toBeLessThanOrEqual(255);
+                expect(isSmallerThanBn254FieldSizeLe(result[0])).toBe(true);
+            }
+        });
+    });
+    describe('pushUniqueItems function', () => {
+        it('should add unique items', () => {
+            const map = [1, 2, 3];
+            const itemsToAdd = [3, 4, 5];
+            pushUniqueItems(itemsToAdd, map);
+            expect(map).toEqual([1, 2, 3, 4, 5]);
+        });
+        it('should ignore duplicates', () => {
+            const map = [1, 2, 3];
+            const itemsToAdd = [1, 2, 3];
+            pushUniqueItems(itemsToAdd, map);
+            expect(map).toEqual([1, 2, 3]);
+        });
+        it('should handle empty arrays', () => {
+            const map = [];
+            const itemsToAdd = [];
+            pushUniqueItems(itemsToAdd, map);
+            expect(map).toEqual([]);
+        });
+    });
+    describe('bufToDecStr', () => {
+        it("should convert buffer [0] to '0'", () => {
+            expect(bufToDecStr(Buffer$1.from([0]))).toEqual('0');
+        });
+        it("should convert buffer [1] to '1'", () => {
+            expect(bufToDecStr(Buffer$1.from([1]))).toEqual('1');
+        });
+        it("should convert buffer [1, 0] to '256'", () => {
+            expect(bufToDecStr(Buffer$1.from([1, 0]))).toEqual('256');
+        });
+        it("should convert buffer [1, 1] to '257'", () => {
+            expect(bufToDecStr(Buffer$1.from([1, 1]))).toEqual('257');
+        });
+        it("should convert buffer [7, 91, 205, 21] to '123456789'", () => {
+            expect(bufToDecStr(Buffer$1.from([7, 91, 205, 21]))).toEqual('123456789');
+        });
+    });
+    describe('toCamelCase', () => {
+        it('should convert object keys to camelCase', () => {
+            const input = { test_key: 1, 'another-testKey': 2 };
+            const expected = { testKey: 1, anotherTestKey: 2 };
+            expect(toCamelCase(input)).toEqual(expected);
+        });
+        it('should handle arrays of objects', () => {
+            const input = [{ array_key: 3 }, { 'another_array-key': 4 }];
+            const expected = [{ arrayKey: 3 }, { anotherArrayKey: 4 }];
+            expect(toCamelCase(input)).toEqual(expected);
+        });
+        it('should return the input if it is neither an object nor an array', () => {
+            const input = 'testString';
+            expect(toCamelCase(input)).toBe(input);
+        });
+    });
+}
+
+/** pipe function */
+function pipe(initialFunction, ...functions) {
+    return (initialValue) => functions.reduce((currentValue, currentFunction) => currentFunction(currentValue), initialFunction(initialValue));
+}
+//@ts-ignore
+if (import.meta.vitest) {
+    //@ts-ignore
+    const { it, expect, describe } = import.meta.vitest;
+    describe('pipe', () => {
+        it('should return the result of applying all fns to the initial value', () => {
+            const addOne = (x) => x + 1;
+            const multiplyByTwo = (x) => x * 2;
+            const subtractThree = (x) => x - 3;
+            const addOneMultiplyByTwoSubtractThree = pipe(addOne, multiplyByTwo, subtractThree);
+            expect(addOneMultiplyByTwoSubtractThree(5)).toBe(9);
+        });
+    });
+}
+
+/** Sends a versioned transaction and confirms it. */
+async function sendAndConfirmTx(rpc, tx, confirmOptions) {
+    const txId = await rpc.sendTransaction(tx, confirmOptions);
+    const { blockhash, lastValidBlockHeight } = await rpc.getLatestBlockhash(confirmOptions?.commitment);
+    const transactionConfirmationStrategy0 = {
+        signature: txId,
+        blockhash,
+        lastValidBlockHeight,
+    };
+    await rpc.confirmTransaction(transactionConfirmationStrategy0, confirmOptions?.commitment || rpc.commitment || 'confirmed');
+    return txId;
+}
+/** @internal */
+async function confirmTx(rpc, txId, blockHashCtx) {
+    if (!blockHashCtx)
+        blockHashCtx = await rpc.getLatestBlockhash();
+    const transactionConfirmationStrategy = {
+        signature: txId,
+        blockhash: blockHashCtx.blockhash,
+        lastValidBlockHeight: blockHashCtx.lastValidBlockHeight,
+    };
+    const res = await rpc.confirmTransaction(transactionConfirmationStrategy, rpc.commitment || 'confirmed');
+    return res;
+}
+/**
+ * Builds a versioned Transaction from instructions and signs it.
+ *
+ * @param instructions        instructions to include in the transaction
+ * @param payer               payer of the transaction
+ * @param blockhash           recent blockhash to use in the transaction
+ * @param additionalSigners   non-feepayer signers to include in the transaction
+ */
+function buildAndSignTx(instructions, payer, blockhash, additionalSigners = []) {
+    if (additionalSigners.includes(payer))
+        throw new Error('payer must not be in additionalSigners');
+    const allSigners = [payer, ...additionalSigners];
+    const messageV0 = new TransactionMessage({
+        payerKey: payer.publicKey,
+        recentBlockhash: blockhash,
+        instructions,
+    }).compileToV0Message();
+    const tx = new VersionedTransaction(messageV0);
+    tx.sign(allSigners);
+    return tx;
+}
+
+// zzz
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function airdropSol({ connection, lamports, recipientPublicKey, }) {
+    const txHash = await connection.requestAirdrop(recipientPublicKey, lamports);
+    await confirmTransaction(connection, txHash);
+    return txHash;
+}
+async function confirmTransaction(connection, signature, confirmation = 'confirmed') {
+    const latestBlockHash = await connection.getLatestBlockhash(confirmation);
+    const strategy = {
+        signature: signature.toString(),
+        lastValidBlockHeight: latestBlockHash.lastValidBlockHeight,
+        blockhash: latestBlockHash.blockhash,
+    };
+    return await connection.confirmTransaction(strategy, confirmation);
+}
+
+const validateSufficientBalance = (balance) => {
+    if (balance.lt(bn(0))) {
+        throw new Error('Not enough balance for transfer');
+    }
+};
+const validateSameOwner = (compressedAccounts) => {
+    if (compressedAccounts.length === 0) {
+        throw new Error('No accounts provided for validation');
+    }
+    const zerothOwner = compressedAccounts[0].owner;
+    if (!compressedAccounts.every(account => account.owner.equals(zerothOwner))) {
+        throw new Error('All input accounts must have the same owner');
+    }
+};
+
+/**
+ * @internal Finds the index of a PublicKey in an array, or adds it if not
+ * present
+ * */
+function getIndexOrAdd(accountsArray, key) {
+    const index = accountsArray.findIndex(existingKey => existingKey.equals(key));
+    if (index === -1) {
+        accountsArray.push(key);
+        return accountsArray.length - 1;
+    }
+    return index;
+}
+/** @internal */
+function padOutputStateMerkleTrees(outputStateMerkleTrees, numberOfOutputCompressedAccounts, inputCompressedAccountsWithMerkleContext) {
+    if (numberOfOutputCompressedAccounts <= 0) {
+        return [];
+    }
+    /// Default: use the 0th state tree of input state for all output accounts
+    if (outputStateMerkleTrees === undefined) {
+        if (inputCompressedAccountsWithMerkleContext.length === 0) {
+            throw new Error('inputCompressedAccountsWithMerkleContext cannot be empty when outputStateMerkleTrees is undefined');
+        }
+        return new Array(numberOfOutputCompressedAccounts).fill(inputCompressedAccountsWithMerkleContext[0].merkleTree);
+        /// Align the number of output state trees with the number of output
+        /// accounts, and fill up with 0th output state tree
+    }
+    else {
+        /// Into array
+        const treesArray = toArray(outputStateMerkleTrees);
+        if (treesArray.length >= numberOfOutputCompressedAccounts) {
+            return treesArray.slice(0, numberOfOutputCompressedAccounts);
+        }
+        else {
+            return treesArray.concat(new Array(numberOfOutputCompressedAccounts - treesArray.length).fill(treesArray[0]));
+        }
+    }
+}
+// TODO: include owner and lamports in packing.
+/**
+ * Packs Compressed Accounts.
+ *
+ * Replaces PublicKey with index pointer to remaining accounts.
+ *
+ * @param inputCompressedAccounts           ix input state to be consumed
+ * @param numberOfOutputCompressedAccounts  ix ouput state to be created
+ * @param outputStateMerkleTrees            State trees that the output should
+ *                                          be inserted into. Defaults to the
+ *                                          0th state tree of the input state.
+ *                                          Gets padded to the length of
+ *                                          outputCompressedAccounts.
+ * @param remainingAccounts                 Optional existing array of accounts
+ *                                          to append to.
+ **/
+function packCompressedAccounts(inputCompressedAccounts, numberOfOutputCompressedAccounts, outputStateMerkleTrees, remainingAccounts = []) {
+    const _remainingAccounts = remainingAccounts.slice();
+    const packedInputCompressedAccounts = [];
+    /// input
+    inputCompressedAccounts.forEach(account => {
+        const merkleTreePubkeyIndex = getIndexOrAdd(_remainingAccounts, account.merkleTree);
+        const nullifierQueuePubkeyIndex = getIndexOrAdd(_remainingAccounts, account.nullifierQueue);
+        packedInputCompressedAccounts.push({
+            compressedAccount: {
+                owner: account.owner,
+                lamports: account.lamports,
+                address: account.address,
+                data: account.data,
+            },
+            merkleTreePubkeyIndex,
+            nullifierQueuePubkeyIndex,
+            leafIndex: account.leafIndex,
+        });
+    });
+    /// output
+    const paddedOutputStateMerkleTrees = padOutputStateMerkleTrees(outputStateMerkleTrees, numberOfOutputCompressedAccounts, inputCompressedAccounts);
+    const outputStateMerkleTreeIndices = [];
+    paddedOutputStateMerkleTrees.forEach(account => {
+        const indexMerkleTree = getIndexOrAdd(_remainingAccounts, account);
+        outputStateMerkleTreeIndices.push(indexMerkleTree);
+    });
+    /// to meta
+    const remainingAccountMetas = _remainingAccounts.map((account) => ({
+        pubkey: account,
+        isWritable: true,
+        isSigner: false,
+    }));
+    return {
+        packedInputCompressedAccounts,
+        outputStateMerkleTreeIndices,
+        remainingAccountMetas,
+    };
+}
+//@ts-ignore
+if (import.meta.vitest) {
+    //@ts-ignore
+    const { describe, it, expect } = import.meta.vitest;
+    // Inline unit tests for padOutputStateMerkleTrees function
+    describe('padOutputStateMerkleTrees', () => {
+        const treeA = PublicKey.unique();
+        const treeB = PublicKey.unique();
+        const treeC = PublicKey.unique();
+        const accA = { merkleTree: treeA };
+        const accB = { merkleTree: treeB };
+        it('should use the 0th state tree of input state if no output state trees are provided', () => {
+            const result = padOutputStateMerkleTrees(undefined, 3, [
+                accA,
+                accB,
+            ]);
+            expect(result).toEqual([treeA, treeA, treeA]);
+        });
+        it('should fill up with the first state tree if provided trees are less than required', () => {
+            const result = padOutputStateMerkleTrees([treeA, treeB], 5, []);
+            expect(result).toEqual([treeA, treeB, treeA, treeA, treeA]);
+        });
+        it('should remove extra trees if the number of output state trees is greater than the number of output accounts', () => {
+            const result = padOutputStateMerkleTrees([treeA, treeB, treeC], 2, []);
+            expect(result).toEqual([treeA, treeB]);
+        });
+        it('should return the same outputStateMerkleTrees if its length equals the number of output compressed accounts', () => {
+            const result = padOutputStateMerkleTrees([treeA, treeB, treeC], 3, []);
+            expect(result).toEqual([treeA, treeB, treeC]);
+        });
+    });
+}
+
+const parseEvents = (indexerEventsTransactions, deserializeFn) => {
+    const { noopProgram } = defaultStaticAccountsStruct();
+    const transactions = [];
+    indexerEventsTransactions.forEach(tx => {
+        if (!tx ||
+            !tx.meta ||
+            tx.meta.err ||
+            !tx.meta.innerInstructions ||
+            tx.meta.innerInstructions.length <= 0) {
+            return;
+        }
+        /// We only care about the very last inner instruction as it contains the
+        /// PublicTransactionEvent
+        tx.meta.innerInstructions.forEach(ix => {
+            if (ix.instructions.length > 0) {
+                const ixInner = ix.instructions[ix.instructions.length - 1];
+                // Type guard for partially parsed web3js types.
+                if ('data' in ixInner &&
+                    ixInner.data &&
+                    ixInner.programId.toBase58() === noopProgram.toBase58()) {
+                    const data = bs58.decode(ixInner.data);
+                    const decodedEvent = deserializeFn(data, tx);
+                    if (decodedEvent !== null && decodedEvent !== undefined) {
+                        transactions.push(decodedEvent);
+                    }
+                }
+            }
+        });
+    });
+    return transactions;
+};
+// TODO: make it type safe. have to reimplement the types from the IDL.
+const parsePublicTransactionEventWithIdl = (data) => {
+    const numericData = Buffer.from(data.map(byte => byte));
+    try {
+        return LightSystemProgram.program.coder.types.decode('PublicTransactionEvent', numericData);
+    }
+    catch (error) {
+        console.error('Error deserializing event:', error);
+        return null;
+    }
+};
+
+const DEFAULT_ZERO = '0';
+/**
+ * @callback hashFunction
+ * @param left Left leaf
+ * @param right Right leaf
+ */
+/**
+ * Merkle tree
+ */
+class MerkleTree {
+    /**
+     * Constructor
+     * @param {number} levels Number of levels in the tree
+     * @param {Array} [elements] Initial elements
+     * @param {Object} options
+     * @param {hashFunction} [options.hashFunction] Function used to hash 2 leaves
+     * @param [options.zeroElement] Value for non-existent leaves
+     */
+    levels;
+    capacity;
+    zeroElement;
+    _zeros;
+    _layers;
+    _lightWasm;
+    constructor(levels, lightWasm, elements = [], { zeroElement = DEFAULT_ZERO } = {}) {
+        this.levels = levels;
+        this.capacity = 2 ** levels;
+        this.zeroElement = zeroElement;
+        this._lightWasm = lightWasm;
+        if (elements.length > this.capacity) {
+            throw new Error('Tree is full');
+        }
+        this._zeros = [];
+        this._layers = [];
+        this._layers[0] = elements;
+        this._zeros[0] = this.zeroElement;
+        for (let i = 1; i <= levels; i++) {
+            this._zeros[i] = this._lightWasm.poseidonHashString([
+                this._zeros[i - 1],
+                this._zeros[i - 1],
+            ]);
+        }
+        this._rebuild();
+    }
+    _rebuild() {
+        for (let level = 1; level <= this.levels; level++) {
+            this._layers[level] = [];
+            for (let i = 0; i < Math.ceil(this._layers[level - 1].length / 2); i++) {
+                this._layers[level][i] = this._lightWasm.poseidonHashString([
+                    this._layers[level - 1][i * 2],
+                    i * 2 + 1 < this._layers[level - 1].length
+                        ? this._layers[level - 1][i * 2 + 1]
+                        : this._zeros[level - 1],
+                ]);
+            }
+        }
+    }
+    /**
+     * Get tree root
+     * @returns {*}
+     */
+    root() {
+        return this._layers[this.levels].length > 0
+            ? this._layers[this.levels][0]
+            : this._zeros[this.levels];
+    }
+    /**
+     * Insert new element into the tree
+     * @param element Element to insert
+     */
+    insert(element) {
+        if (this._layers[0].length >= this.capacity) {
+            throw new Error('Tree is full');
+        }
+        this.update(this._layers[0].length, element);
+    }
+    /**
+     * Insert multiple elements into the tree. Tree will be fully rebuilt during this operation.
+     * @param {Array} elements Elements to insert
+     */
+    bulkInsert(elements) {
+        if (this._layers[0].length + elements.length > this.capacity) {
+            throw new Error('Tree is full');
+        }
+        this._layers[0].push(...elements);
+        this._rebuild();
+    }
+    // TODO: update does not work debug
+    /**
+     * Change an element in the tree
+     * @param {number} index Index of element to change
+     * @param element Updated element value
+     */
+    update(index, element) {
+        // index 0 and 1 and element is the commitment hash
+        if (isNaN(Number(index)) ||
+            index < 0 ||
+            index > this._layers[0].length ||
+            index >= this.capacity) {
+            throw new Error('Insert index out of bounds: ' + index);
+        }
+        this._layers[0][index] = element;
+        for (let level = 1; level <= this.levels; level++) {
+            index >>= 1;
+            this._layers[level][index] = this._lightWasm.poseidonHashString([
+                this._layers[level - 1][index * 2],
+                index * 2 + 1 < this._layers[level - 1].length
+                    ? this._layers[level - 1][index * 2 + 1]
+                    : this._zeros[level - 1],
+            ]);
+        }
+    }
+    /**
+     * Get merkle path to a leaf
+     * @param {number} index Leaf index to generate path for
+     * @returns {{pathElements: number[], pathIndex: number[]}} An object containing adjacent elements and left-right index
+     */
+    path(index) {
+        if (isNaN(Number(index)) ||
+            index < 0 ||
+            index >= this._layers[0].length) {
+            throw new Error('Index out of bounds: ' + index);
+        }
+        const pathElements = [];
+        const pathIndices = [];
+        for (let level = 0; level < this.levels; level++) {
+            pathIndices[level] = index % 2;
+            pathElements[level] =
+                (index ^ 1) < this._layers[level].length
+                    ? this._layers[level][index ^ 1]
+                    : this._zeros[level];
+            index >>= 1;
+        }
+        return {
+            pathElements,
+            pathIndices,
+        };
+    }
+    /**
+     * Find an element in the tree
+     * @param element An element to find
+     * @param comparator A function that checks leaf value equality
+     * @returns {number} Index if element is found, otherwise -1
+     */
+    indexOf(element, comparator = null) {
+        if (comparator) {
+            return this._layers[0].findIndex((el) => comparator(element, el));
+        }
+        else {
+            return this._layers[0].indexOf(element);
+        }
+    }
+    /**
+     * Returns a copy of non-zero tree elements
+     * @returns {Object[]}
+     */
+    elements() {
+        return this._layers[0].slice();
+    }
+    /**
+     * Serialize entire tree state including intermediate layers into a plain object
+     * Deserializing it back will not require to recompute any hashes
+     * Elements are not converted to a plain type, this is responsibility of the caller
+     */
+    serialize() {
+        return {
+            levels: this.levels,
+            _zeros: this._zeros,
+            _layers: this._layers,
+        };
+    }
+    /**
+     * Deserialize data into a MerkleTree instance
+     * Make sure to provide the same hashFunction as was used in the source tree,
+     * otherwise the tree state will be invalid
+     *
+     * @param data
+     * @param hashFunction
+     * @returns {MerkleTree}
+     */
+    static deserialize(data, hashFunction) {
+        const instance = Object.assign(Object.create(this.prototype), data);
+        instance._hash = hashFunction;
+        instance.capacity = 2 ** instance.levels;
+        instance.zeroElement = instance._zeros[0];
+        return instance;
+    }
+}
+
+const placeholderValidityProof = () => ({
+    a: Array.from({ length: 32 }, (_, i) => i + 1),
+    b: Array.from({ length: 64 }, (_, i) => i + 1),
+    c: Array.from({ length: 32 }, (_, i) => i + 1),
+});
+const checkValidityProofShape = (proof) => {
+    if (proof.a.length !== 32 ||
+        proof.b.length !== 64 ||
+        proof.c.length !== 32) {
+        throw new Error('ValidityProof has invalid shape');
+    }
+};
+function proofFromJsonStruct(json) {
+    const proofAX = deserializeHexStringToBeBytes(json.ar[0]);
+    const proofAY = deserializeHexStringToBeBytes(json.ar[1]);
+    const proofA = new Uint8Array([...proofAX, ...proofAY]);
+    const proofBX0 = deserializeHexStringToBeBytes(json.bs[0][0]);
+    const proofBX1 = deserializeHexStringToBeBytes(json.bs[0][1]);
+    const proofBY0 = deserializeHexStringToBeBytes(json.bs[1][0]);
+    const proofBY1 = deserializeHexStringToBeBytes(json.bs[1][1]);
+    const proofB = new Uint8Array([
+        ...proofBX0,
+        ...proofBX1,
+        ...proofBY0,
+        ...proofBY1,
+    ]);
+    const proofCX = deserializeHexStringToBeBytes(json.krs[0]);
+    const proofCY = deserializeHexStringToBeBytes(json.krs[1]);
+    const proofC = new Uint8Array([...proofCX, ...proofCY]);
+    const proofABC = { a: proofA, b: proofB, c: proofC };
+    return proofABC;
+}
+// TODO: add unit test for negation
+// TODO: test if LE BE issue. unit test
+function negateAndCompressProof(proof) {
+    const proofA = proof.a;
+    const proofB = proof.b;
+    const proofC = proof.c;
+    const aXElement = proofA.slice(0, 32);
+    const aYElement = new BN(proofA.slice(32, 64), 32, 'be');
+    /// Negate
+    const proofAIsPositive = yElementIsPositiveG1(aYElement) ? false : true;
+    /// First byte of proofA is the bitmask
+    aXElement[0] = addBitmaskToByte(aXElement[0], proofAIsPositive);
+    const bXElement = proofB.slice(0, 64);
+    const bYElement = proofB.slice(64, 128);
+    const proofBIsPositive = yElementIsPositiveG2(new BN(bYElement.slice(0, 32), 32, 'be'), new BN(bYElement.slice(32, 64), 32, 'be'));
+    bXElement[0] = addBitmaskToByte(bXElement[0], proofBIsPositive);
+    const cXElement = proofC.slice(0, 32);
+    const cYElement = proofC.slice(32, 64);
+    const proofCIsPositive = yElementIsPositiveG1(new BN(cYElement, 32, 'be'));
+    cXElement[0] = addBitmaskToByte(cXElement[0], proofCIsPositive);
+    const compressedProof = {
+        a: Array.from(aXElement),
+        b: Array.from(bXElement),
+        c: Array.from(cXElement),
+    };
+    return compressedProof;
+}
+function deserializeHexStringToBeBytes(hexStr) {
+    // Using BN for simpler conversion from hex string to byte array
+    const bn = new BN(hexStr.startsWith('0x') ? hexStr.substring(2) : hexStr, 'hex');
+    return new Uint8Array(bn.toArray('be', 32));
+}
+function yElementIsPositiveG1(yElement) {
+    return yElement.lte(FIELD_SIZE.sub(yElement));
+}
+function yElementIsPositiveG2(yElement1, yElement2) {
+    const fieldMidpoint = FIELD_SIZE.div(new BN(2));
+    // Compare the first component of the y coordinate
+    if (yElement1.lt(fieldMidpoint)) {
+        return true;
+    }
+    else if (yElement1.gt(fieldMidpoint)) {
+        return false;
+    }
+    // If the first component is equal to the midpoint, compare the second component
+    return yElement2.lt(fieldMidpoint);
+}
+// bitmask compatible with solana altbn128 compression syscall and arkworks' implementation
+// https://github.com/arkworks-rs/algebra/blob/master/ff/src/fields/models/fp/mod.rs#L580
+// https://github.com/arkworks-rs/algebra/blob/master/serialize/src/flags.rs#L18
+// fn u8_bitmask(value: u8, inf: bool, neg: bool) -> u8 {
+//     let mut mask = 0;
+//     match self {
+//         inf => mask |= 1 << 6,
+//         neg => mask |= 1 << 7,
+//         _ => (),
+//     }
+//     mask
+// }
+function addBitmaskToByte(byte, yIsPositive) {
+    if (!yIsPositive) {
+        return (byte |= 1 << 7);
+    }
+    else {
+        return byte;
+    }
+}
+//@ts-ignore
+if (import.meta.vitest) {
+    //@ts-ignore
+    const { it, expect, describe } = import.meta.vitest;
+    // Unit test for addBitmaskToByte function
+    describe('addBitmaskToByte', () => {
+        it('should add a bitmask to the byte if yIsPositive is false', () => {
+            const byte = 0b00000000;
+            const yIsPositive = false;
+            const result = addBitmaskToByte(byte, yIsPositive);
+            expect(result).toBe(0b10000000); // 128 in binary, which is 1 << 7
+        });
+        it('should not modify the byte if yIsPositive is true', () => {
+            const byte = 0b00000000;
+            const yIsPositive = true;
+            const result = addBitmaskToByte(byte, yIsPositive);
+            expect(result).toBe(0b00000000);
+        });
+    });
+    describe('test prover server', () => {
+        const TEST_JSON = {
+            ar: [
+                '0x22bdaa3187d8fe294925a66fa0165a11bc9e07678fa2fc72402ebfd33d521c69',
+                '0x2d18ff780b69898b4cdd8d7b6ac72d077799399f0f45e52665426456f3903584',
+            ],
+            bs: [
+                [
+                    '0x138cc0962e49f76a701d2871d2799892c9782940095eb0429e979f336d2e162d',
+                    '0x2fe1bfbb15cbfb83d7e00ace23e45f890604003783eaf34affa35e0d6f4822bc',
+                ],
+                [
+                    '0x1a89264f82cc6e8ef1c696bea0b5803c28c0ba6ab61366bcb71e73a4135cae8d',
+                    '0xf778d857b3df01a4100265c9d014ce02d47425f0114685356165fa5ee3f3a26',
+                ],
+            ],
+            krs: [
+                '0x176b6ae9001f66832951e2d43a98a972667447bb1781f534b70cb010270dcdd3',
+                '0xb748d5fac1686db28d94c02250af7eb4f28dfdabc8983305c45bcbc6e163eeb',
+            ],
+        };
+        const COMPRESSED_PROOF_A = [
+            34, 189, 170, 49, 135, 216, 254, 41, 73, 37, 166, 111, 160, 22, 90,
+            17, 188, 158, 7, 103, 143, 162, 252, 114, 64, 46, 191, 211, 61, 82,
+            28, 105,
+        ];
+        const COMPRESSED_PROOF_B = [
+            147, 140, 192, 150, 46, 73, 247, 106, 112, 29, 40, 113, 210, 121,
+            152, 146, 201, 120, 41, 64, 9, 94, 176, 66, 158, 151, 159, 51, 109,
+            46, 22, 45, 47, 225, 191, 187, 21, 203, 251, 131, 215, 224, 10, 206,
+            35, 228, 95, 137, 6, 4, 0, 55, 131, 234, 243, 74, 255, 163, 94, 13,
+            111, 72, 34, 188,
+        ];
+        const COMPRESSED_PROOF_C = [
+            23, 107, 106, 233, 0, 31, 102, 131, 41, 81, 226, 212, 58, 152, 169,
+            114, 102, 116, 71, 187, 23, 129, 245, 52, 183, 12, 176, 16, 39, 13,
+            205, 211,
+        ];
+        it('should execute a compressed token mint', async () => {
+            const proof = proofFromJsonStruct(TEST_JSON);
+            const compressedProof = negateAndCompressProof(proof);
+            expect(compressedProof.a).toEqual(COMPRESSED_PROOF_A);
+            expect(compressedProof.b).toEqual(COMPRESSED_PROOF_B);
+            expect(compressedProof.c).toEqual(COMPRESSED_PROOF_C);
+        });
+    });
+    describe('Validity Proof Functions', () => {
+        describe('placeholderValidityProof', () => {
+            it('should create a validity proof with correct shape', () => {
+                const validityProof = placeholderValidityProof();
+                expect(validityProof.a.length).toBe(32);
+                expect(validityProof.b.length).toBe(64);
+                expect(validityProof.c.length).toBe(32);
+            });
+        });
+        describe('checkValidityProofShape', () => {
+            it('should not throw an error for valid proof shape', () => {
+                const validProof = {
+                    a: Array.from(new Uint8Array(32)),
+                    b: Array.from(new Uint8Array(64)),
+                    c: Array.from(new Uint8Array(32)),
+                };
+                expect(() => checkValidityProofShape(validProof)).not.toThrow();
+            });
+            it('should throw an error for an invalid proof', () => {
+                const invalidProof = {
+                    a: Array.from(new Uint8Array(31)), // incorrect length
+                    b: Array.from(new Uint8Array(64)),
+                    c: Array.from(new Uint8Array(32)),
+                };
+                expect(() => checkValidityProofShape(invalidProof)).toThrow('ValidityProof has invalid shape');
+            });
+        });
+    });
+}
+
+/**
+ * @internal
+ */
+const PublicKeyFromString = coerce(instance(PublicKey), string(), value => new PublicKey(value));
+/**
+ * @internal
+ */
+// TODO: use a BN254 class here for the 1st parameter
+const BN254FromString = coerce(instance(BN), string(), value => {
+    return createBN254(value, 'base58');
+});
+const BNFromInt = coerce(instance(BN), number(), value => bn(value));
+const BNFromBase10String = coerce(instance(BN), string(), value => bn(value));
+/**
+ * @internal
+ */
+const Base64EncodedCompressedAccountDataResult = coerce(nullable(string()), string(), value => (value === '' ? null : value));
+/**
+ * @internal
+ */
+function createRpcResult(result) {
+    return union([
+        type({
+            jsonrpc: literal('2.0'),
+            id: string(),
+            result,
+        }),
+        type({
+            jsonrpc: literal('2.0'),
+            id: string(),
+            error: type({
+                code: unknown(),
+                message: string(),
+                data: nullable(any()),
+            }),
+        }),
+    ]);
+}
+/**
+ * @internal
+ */
+const UnknownRpcResult = createRpcResult(unknown());
+/**
+ * @internal
+ */
+function jsonRpcResult(schema) {
+    return coerce(createRpcResult(schema), UnknownRpcResult, value => {
+        if ('error' in value) {
+            return value;
+        }
+        else {
+            return {
+                ...value,
+                result: create(value.result, schema),
+            };
+        }
+    });
+}
+/**
+ * @internal
+ */
+function jsonRpcResultAndContext(value) {
+    return jsonRpcResult(type({
+        context: type({
+            slot: number(),
+        }),
+        value,
+    }));
+}
+/**
+ * @internal
+ */
+/// Compressed Account With Merkle Context
+const CompressedAccountResult = type({
+    hash: BN254FromString,
+    address: nullable(PublicKeyFromString),
+    data: Base64EncodedCompressedAccountDataResult,
+    dataHash: nullable(BN254FromString),
+    discriminator: BNFromInt,
+    owner: PublicKeyFromString,
+    lamports: BNFromInt,
+    tree: nullable(PublicKeyFromString), // TODO: should not be nullable
+    seq: nullable(BNFromInt),
+    slotUpdated: BNFromInt,
+    leafIndex: number(),
+});
+/**
+ * @internal
+ */
+/// TODO: update: delegatedAmount, state, programOwner/tokenOwner, data includes the values?, no closeAuth!
+const CompressedTokenAccountResult = type({
+    address: nullable(PublicKeyFromString), // TODO: why is this here
+    amount: BNFromBase10String, // why string
+    delegate: nullable(PublicKeyFromString),
+    closeAuthority: nullable(PublicKeyFromString), // TODO: remove
+    isNative: boolean(),
+    frozen: boolean(),
+    mint: PublicKeyFromString,
+    owner: PublicKeyFromString, // owner or user?
+    //
+    hash: BN254FromString,
+    data: Base64EncodedCompressedAccountDataResult,
+    dataHash: nullable(BN254FromString),
+    discriminator: BNFromInt,
+    lamports: BNFromInt,
+    tree: PublicKeyFromString,
+    seq: BNFromInt,
+    // slotUpdated: BNFromInt, TODO: add owner (?): TODO: check whether this
+    // implicitly assumes tokenprogram as account owner
+    leafIndex: number(),
+});
+/**
+ * @internal
+ */
+const MultipleCompressedAccountsResult = type({
+    items: array(CompressedAccountResult),
+});
+/**
+ * @internal
+ */
+const CompressedAccountsByOwnerResult = type({
+    items: array(CompressedAccountResult),
+    // cursor: array(number()), // paginated
+});
+/**
+ * @internal
+ */
+const CompressedTokenAccountsByOwnerOrDelegateResult = type({
+    items: array(CompressedTokenAccountResult),
+    // cursor: array(number()), // paginated TODO: add cursor to photon / docs update
+});
+/**
+ * @internal
+ */
+const SlotResult = number();
+/**
+ * @internal
+ */
+const HealthResult = string();
+/**
+ * @internal
+ */
+const MerkeProofResult = type({
+    hash: BN254FromString,
+    merkleTree: PublicKeyFromString,
+    leafIndex: number(),
+    proof: array(BN254FromString),
+});
+/**
+ * @internal
+ */
+const MultipleMerkleProofsResult = array(MerkeProofResult);
+/**
+ * @internal
+ */
+const BalanceResult = BNFromInt;
+/// TODO: we need to add: tree, nullifierQueue, leafIndex, rootIndex
+const AccountProofResult = type({
+    hash: array(number()),
+    root: array(number()),
+    proof: array(array(number())),
+});
+
+function createRpc(endpointOrWeb3JsConnection = 'http://127.0.0.1:8899', compressionApiEndpoint = 'http://localhost:8784', config) {
+    if (typeof endpointOrWeb3JsConnection === 'string') {
+        return new Rpc(endpointOrWeb3JsConnection, compressionApiEndpoint, undefined, config);
+    }
+    return new Rpc(endpointOrWeb3JsConnection.rpcEndpoint, compressionApiEndpoint, undefined, config);
+}
+const rpcRequest = async (rpcEndpoint, method, params = [], // TODO: array?
+convertToCamelCase = true) => {
+    const body = JSON.stringify({
+        jsonrpc: '2.0',
+        id: 'test-account',
+        method: method,
+        params: params,
+    });
+    const response = await fetch(rpcEndpoint, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: body,
+    });
+    if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    if (convertToCamelCase) {
+        const res = await response.json();
+        return toCamelCase(res);
+    }
+    return await response.json();
+};
+const mockNullifierQueue = defaultTestStateTreeAccounts().nullifierQueue;
+class Rpc extends Connection {
+    /// TODO: can photon expose the default methods as well?
+    compressionApiEndpoint;
+    constructor(endpoint, compressionApiEndpoint, 
+    // TODO: implement
+    proverEndpoint, config) {
+        super(endpoint, config || 'confirmed');
+        this.compressionApiEndpoint = compressionApiEndpoint;
+    }
+    async getCompressedAccount(hash) {
+        const unsafeRes = await rpcRequest(this.compressionApiEndpoint, 'getCompressedAccount', { hash: encodeBN254toBase58(hash) });
+        const res = create(unsafeRes, jsonRpcResultAndContext(nullable(CompressedAccountResult)));
+        if ('error' in res) {
+            throw new SolanaJSONRPCError(res.error, `failed to get info for compressed account ${hash.toString()}`);
+        }
+        if (res.result.value === null) {
+            return null;
+        }
+        const item = res.result.value;
+        const account = createCompressedAccountWithMerkleContext(createMerkleContext(item.tree, mockNullifierQueue, item.hash.toArray(), item.leafIndex), item.owner, bn(item.lamports), 
+        // TODO: fix. add typesafety to the rest
+        item.data
+            ? {
+                discriminator: item.discriminator.toArray('le'),
+                data: Buffer.from(item.data, 'base64'),
+                dataHash: item.dataHash.toArray('le'), //FIXME: need to calculate the hash or return from server
+            }
+            : undefined, item.address || undefined);
+        return account;
+    }
+    async getCompressedBalance(hash) {
+        const unsafeRes = await rpcRequest(this.compressionApiEndpoint, 'getCompressedBalance', { hash: encodeBN254toBase58(hash) });
+        const res = create(unsafeRes, jsonRpcResultAndContext(BalanceResult));
+        if ('error' in res) {
+            throw new SolanaJSONRPCError(res.error, `failed to get balance for compressed account ${hash.toString()}`);
+        }
+        if (res.result.value === null) {
+            return null;
+        }
+        return bn(res.result.value);
+    }
+    /** Retrieve the merkle proof for a compressed account */
+    async getCompressedAccountProof(hash) {
+        const unsafeRes = await rpcRequest(this.compressionApiEndpoint, 'getCompressedAccountProof', encodeBN254toBase58(hash));
+        const res = create(unsafeRes, jsonRpcResultAndContext(MerkeProofResult));
+        if ('error' in res) {
+            throw new SolanaJSONRPCError(res.error, `failed to get proof for compressed account ${hash.toString()}`);
+        }
+        if (res.result.value === null) {
+            throw new Error(`failed to get proof for compressed account ${hash.toString()}`);
+        }
+        const value = {
+            hash: res.result.value.hash.toArray(),
+            merkleTree: res.result.value.merkleTree,
+            leafIndex: res.result.value.leafIndex,
+            merkleProof: res.result.value.proof,
+            nullifierQueue: mockNullifierQueue,
+            rootIndex: 0, // TODO: add root index
+        };
+        return value;
+    }
+    async getMultipleCompressedAccounts(hashes) {
+        const unsafeRes = await rpcRequest(this.compressionApiEndpoint, 'getMultipleCompressedAccounts', hashes.map(hash => encodeBN254toBase58(hash)));
+        const res = create(unsafeRes, jsonRpcResultAndContext(MultipleCompressedAccountsResult));
+        if ('error' in res) {
+            throw new SolanaJSONRPCError(res.error, `failed to get info for compressed accounts ${hashes.map(hash => encodeBN254toBase58(hash)).join(', ')}`);
+        }
+        if (res.result.value === null) {
+            return null;
+        }
+        const accounts = [];
+        res.result.value.items.map((item) => {
+            const account = createCompressedAccountWithMerkleContext(createMerkleContext(item.tree, mockNullifierQueue, item.hash.toArray(), item.leafIndex), item.owner, bn(item.lamports), item.data && {
+                /// TODO: validate whether we need to convert to 'le' here
+                discriminator: item.discriminator.toArray('le'),
+                data: Buffer.from(item.data, 'base64'),
+                dataHash: item.dataHash.toArray('le'), //FIXME: need to calculate the hash or return from server
+            }, item.address);
+            accounts.push(account);
+        });
+        return accounts;
+    }
+    /** Retrieve the merkle proof for a compressed account */
+    async getMultipleCompressedAccountProofs(hashes) {
+        const unsafeRes = await rpcRequest(this.compressionApiEndpoint, 'getMultipleCompressedAccountProofs', hashes.map(hash => encodeBN254toBase58(hash)));
+        const res = create(unsafeRes, jsonRpcResultAndContext(array(MerkeProofResult)));
+        if ('error' in res) {
+            throw new SolanaJSONRPCError(res.error, `failed to get proofs for compressed accounts ${hashes.map(hash => encodeBN254toBase58(hash)).join(', ')}`);
+        }
+        if (res.result.value === null) {
+            return null;
+        }
+        const merkleProofs = [];
+        res.result.value.map((proof) => {
+            const value = {
+                hash: proof.hash.toArray(), // FIXME
+                merkleTree: proof.merkleTree,
+                leafIndex: proof.leafIndex,
+                merkleProof: proof.proof.map((proof) => createBN254(proof)),
+                nullifierQueue: mockNullifierQueue,
+                rootIndex: 0, // TODO: add root index
+            };
+            merkleProofs.push(value);
+        });
+        return merkleProofs;
+    }
+    async getCompressedAccountsByOwner(owner) {
+        const unsafeRes = await rpcRequest(this.compressionApiEndpoint, 'getCompressedAccountsByOwner', { owner: owner.toBase58() });
+        const res = create(unsafeRes, jsonRpcResultAndContext(CompressedAccountsByOwnerResult));
+        if ('error' in res) {
+            throw new SolanaJSONRPCError(res.error, `failed to get info for compressed accounts owned by ${owner.toBase58()}`);
+        }
+        if (res.result.value === null) {
+            return [];
+        }
+        const accounts = [];
+        /// TODO: clean up. Make typesafe
+        res.result.value.items.map((item) => {
+            const account = createCompressedAccountWithMerkleContext(createMerkleContext(item.tree, mockNullifierQueue, item.hash.toArray(), item.leafIndex), item.owner, bn(item.lamports), item.data && {
+                discriminator: item.discriminator.toArray('le'),
+                data: Buffer.from(item.data, 'base64'),
+                dataHash: item.dataHash.toArray('le'), //FIXME: need to calculate the hash or return from server
+            }, item.address);
+            accounts.push(account);
+        });
+        return accounts;
+    }
+    /// TODO: Implement self
+    async getValidityProof(hashes) {
+        const rpc = await getTestRpc();
+        const proof = await rpc.getValidityProof(hashes);
+        return proof;
+    }
+    async getHealth() {
+        const unsafeRes = await rpcRequest(this.compressionApiEndpoint, 'getHealth');
+        const res = create(unsafeRes, jsonRpcResult(HealthResult));
+        if ('error' in res) {
+            throw new SolanaJSONRPCError(res.error, 'failed to get health');
+        }
+        return res.result;
+    }
+    /** TODO: use from Connection */
+    async getSlot() {
+        const unsafeRes = await rpcRequest(this.compressionApiEndpoint, 'getSlot');
+        const res = create(unsafeRes, jsonRpcResult(SlotResult));
+        if ('error' in res) {
+            throw new SolanaJSONRPCError(res.error, 'failed to get slot');
+        }
+        return res.result;
+    }
+    async getCompressedTokenAccountsByOwner(owner, options) {
+        const unsafeRes = await rpcRequest(this.compressionApiEndpoint, 'getCompressedTokenAccountsByOwner', { owner: owner.toBase58(), mint: options?.mint?.toBase58() });
+        const res = create(unsafeRes, jsonRpcResultAndContext(CompressedTokenAccountsByOwnerOrDelegateResult));
+        if ('error' in res) {
+            throw new SolanaJSONRPCError(res.error, `failed to get info for compressed accounts owned by ${owner.toBase58()}`);
+        }
+        if (res.result.value === null) {
+            throw new Error('not implemented. NULL result');
+        }
+        const accounts = [];
+        /// TODO: clean up. Make typesafe
+        res.result.value.items.map((item) => {
+            const account = createCompressedAccountWithMerkleContext(createMerkleContext(item.tree, mockNullifierQueue, item.hash.toArray(), item.leafIndex), new PublicKey('9sixVEthz2kMSKfeApZXHwuboT6DZuT6crAYJTciUCqE'), // TODO: photon should return programOwner
+            bn(item.lamports), item.data && {
+                discriminator: item.discriminator.toArray('le'),
+                data: Buffer.from(item.data, 'base64'),
+                dataHash: item.dataHash.toArray('le'), //FIXME: need to calculate the hash or return from server
+            }, item.address);
+            const tokenData = {
+                mint: item.mint,
+                owner: item.owner,
+                amount: item.amount,
+                delegate: item.delegate,
+                state: 1, // TODO: dynamic
+                isNative: null, // TODO: dynamic
+                delegatedAmount: bn(0), // TODO: dynamic
+            };
+            accounts.push({
+                compressedAccount: account,
+                parsed: tokenData,
+            });
+        });
+        /// TODO: consider custom sort. we're returning most recent first
+        /// because thats how our tests expect it currently
+        return accounts.sort((a, b) => b.compressedAccount.leafIndex - a.compressedAccount.leafIndex);
+    }
+    /// TODO: implement delegate
+    async getCompressedTokenAccountsByDelegate(delegate, options) {
+        throw new Error('Method not implemented.');
+    }
+    async getCompressedTokenAccountBalance(hash) {
+        throw new Error('Method not implemented.');
+    }
+}
+
+function toHex(bnString) {
+    return '0x' + new BN(bnString).toString(16);
+}
+/**
+ * Simple mock rpc for unit tests that simulates the compression rpc interface.
+ * Fetches, parses events and builds merkletree on-demand, i.e. it does not persist state.
+ * Constraints:
+ * - Can only index 1 merkletree
+ * - Can only index up to 1000 transactions
+ *
+ * For advanced testing use photon: https://github.com/helius-labs/photon
+ */
+class TestRpc extends Rpc {
+    merkleTreeAddress;
+    nullifierQueueAddress;
+    lightWasm;
+    depth;
+    log = false;
+    /**
+     * Instantiate a mock RPC simulating the compression rpc interface.
+     *
+     * @param endpoint              endpoint to the solana cluster (use for
+     *                              localnet only)
+     * @param hasher                light wasm hasher instance
+     * @param testRpcConfig         Config for the mock rpc
+     * @param proverEndpoint        Optional endpoint to the prover server.
+     *                              defaults to endpoint
+     * @param connectionConfig      Optional connection config
+     */
+    constructor(endpoint, hasher, proverEndpoint, testRpcConfig, connectionConfig) {
+        super(endpoint, proverEndpoint, connectionConfig);
+        const { merkleTreeAddress, nullifierQueueAddress, depth, log } = testRpcConfig ?? {};
+        const { merkleTree, nullifierQueue, merkleTreeHeight } = defaultTestStateTreeAccounts();
+        this.lightWasm = hasher;
+        this.merkleTreeAddress = merkleTreeAddress ?? merkleTree;
+        this.nullifierQueueAddress = nullifierQueueAddress ?? nullifierQueue;
+        this.depth = depth ?? merkleTreeHeight;
+        this.log = log ?? false;
+    }
+    /**
+     * @internal
+     * Returns newest first
+     * */
+    async getParsedEvents() {
+        const { noopProgram, accountCompressionProgram } = defaultStaticAccountsStruct();
+        /// Get raw transactions
+        const signatures = (await this.getConfirmedSignaturesForAddress2(accountCompressionProgram, undefined, 'confirmed')).map(s => s.signature);
+        const txs = await this.getParsedTransactions(signatures, {
+            maxSupportedTransactionVersion: 0,
+            commitment: 'confirmed',
+        });
+        /// Filter by NOOP program
+        const transactionEvents = txs.filter((tx) => {
+            if (!tx) {
+                return false;
+            }
+            const accountKeys = tx.transaction.message.accountKeys;
+            const hasSplNoopAddress = accountKeys.some((item) => {
+                const itemStr = typeof item === 'string'
+                    ? item
+                    : item.pubkey.toBase58();
+                return itemStr === noopProgram.toBase58();
+            });
+            return hasSplNoopAddress;
+        });
+        /// Parse events
+        const parsedEvents = parseEvents(transactionEvents, parsePublicTransactionEventWithIdl);
+        return parsedEvents;
+    }
+    /** Retrieve validity proof for compressed accounts */
+    async getValidityProof(compressedAccountHashes) {
+        /// rebuild tree
+        const events = await this.getParsedEvents().then(events => events.reverse());
+        const allLeaves = [];
+        const allLeafIndices = [];
+        for (const event of events) {
+            for (let index = 0; index < event.outputCompressedAccounts.length; index++) {
+                const hash = event.outputCompressedAccountHashes[index];
+                allLeaves.push(hash);
+                allLeafIndices.push(event.outputLeafIndices[index]);
+            }
+        }
+        const tree = new MerkleTree(this.depth, this.lightWasm, allLeaves.map(leaf => bn(leaf).toString()));
+        /// create merkle proofs
+        const leafIndices = compressedAccountHashes.map(compressedAccountHash => tree.indexOf(compressedAccountHash.toString()));
+        const hexPathElementsAll = leafIndices.map(leafIndex => {
+            const pathElements = tree.path(leafIndex).pathElements;
+            const hexPathElements = pathElements.map(value => toHex(value));
+            return hexPathElements;
+        });
+        const roots = new Array(compressedAccountHashes.length).fill(toHex(tree.root()));
+        const inputs = {
+            roots,
+            inPathIndices: leafIndices,
+            inPathElements: hexPathElementsAll,
+            leaves: compressedAccountHashes.map(compressedAccountHash => toHex(compressedAccountHash.toString())),
+        };
+        /// Validate
+        compressedAccountHashes.forEach((compressedAccountHash, index) => {
+            const leafIndex = leafIndices[index];
+            const computedHash = tree.elements()[leafIndex].toString();
+            if (computedHash !== compressedAccountHash.toString()) {
+                throw new Error(`Mismatch at index ${index}: expected ${compressedAccountHash.toString()}, got ${computedHash}`);
+            }
+        });
+        const inputsData = JSON.stringify(inputs);
+        let logMsg = '';
+        if (this.log) {
+            logMsg = `Proof generation for depth:${this.depth} n:${compressedAccountHashes.length}`;
+            console.time(logMsg);
+        }
+        // TODO: pass url into rpc constructor
+        const SERVER_URL = 'http://localhost:3001';
+        const INCLUSION_PROOF_URL = `${SERVER_URL}/inclusion`;
+        const response = await axios.post(INCLUSION_PROOF_URL, inputsData);
+        const parsed = proofFromJsonStruct(response.data);
+        const compressedProof = negateAndCompressProof(parsed);
+        if (this.log)
+            console.timeEnd(logMsg);
+        // TODO: in prover server, fix property names
+        const value = {
+            compressedProof,
+            roots: roots,
+            // TODO: temporary
+            rootIndices: leafIndices.map(_ => allLeafIndices.length),
+            leafIndices,
+            leaves: compressedAccountHashes,
+            merkleTree: this.merkleTreeAddress,
+            nullifierQueue: this.nullifierQueueAddress,
+        };
+        return value;
+    }
+}
+
+let c = 1;
+const ALICE = getTestKeypair(255);
+const BOB = getTestKeypair(254);
+const CHARLIE = getTestKeypair(253);
+const DAVE = getTestKeypair(252);
+async function newAccountWithLamports(rpc, lamports = 1000000000, counter = undefined) {
+    const account = getTestKeypair(counter);
+    const sig = await rpc.requestAirdrop(account.publicKey, lamports);
+    await confirmTx(rpc, sig);
+    return account;
+}
+function getConnection() {
+    const url = 'http://127.0.0.1:8899';
+    const connection = new Connection(url, 'confirmed');
+    return connection;
+}
+/**
+ * Returns a mock RPC instance for use in unit tests.
+ *
+ * @param endpoint                RPC endpoint URL. Defaults to
+ *                                'http://127.0.0.1:8899'.
+ * @param proverEndpoint          Prover server endpoint URL. Defaults to
+ *                                'http://localhost:3001'.
+ * @param lightWasm               Wasm hasher instance.
+ * @param merkleTreeAddress       Address of the merkle tree to index. Defaults
+ *                                to the public default test state tree.
+ * @param nullifierQueueAddress   Optional address of the associated nullifier
+ *                                queue.
+ * @param depth                   Depth of the merkle tree.
+ * @param log                     Log proof generation time.
+ */
+async function getTestRpc(endpoint = 'http://127.0.0.1:8899', proverEndpoint = 'http://localhost:3001', lightWasm, merkleTreeAddress, nullifierQueueAddress, depth, log = false) {
+    lightWasm = lightWasm || (await WasmFactory.getInstance());
+    const defaultAccounts = defaultTestStateTreeAccounts();
+    return new TestRpc(endpoint, lightWasm, proverEndpoint, {
+        merkleTreeAddress: merkleTreeAddress || defaultAccounts.merkleTree,
+        nullifierQueueAddress: nullifierQueueAddress || defaultAccounts.nullifierQueue,
+        depth: depth || defaultAccounts.merkleTreeHeight,
+        log,
+    });
+}
+/**
+ * For use in tests.
+ * Generate a unique keypair by passing in a counter <255. If no counter
+ * is supplied, it uses and increments a global counter.
+ */
+function getTestKeypair(counter = undefined) {
+    if (!counter) {
+        counter = c;
+        c++;
+    }
+    if (counter > 255) {
+        throw new Error('Counter must be <= 255');
+    }
+    const seed = new Uint8Array(32);
+    seed[0] = counter;
+    return Keypair.fromSeed(seed);
+}
+//@ts-ignore
+if (import.meta.vitest) {
+    //@ts-ignore
+    const { describe, it, expect } = import.meta.vitest;
+    describe('getTestKeypair', () => {
+        it('should generate a keypair with a specific counter', () => {
+            const keypair = getTestKeypair(10);
+            expect(keypair).toBeInstanceOf(Keypair);
+            expect(keypair.publicKey).toBeDefined();
+            expect(keypair.secretKey).toBeDefined();
+        });
+        it('should throw an error if counter is greater than 255', () => {
+            const testFn = () => getTestKeypair(256);
+            expect(testFn).toThrow('Counter must be <= 255');
+        });
+        it('should increment the global counter if no counter is provided', () => {
+            const initialKeypair = getTestKeypair();
+            const nextKeypair = getTestKeypair();
+            expect(initialKeypair).not.toEqual(nextKeypair);
+        });
+    });
+}
+
+const sumUpLamports = (accounts) => {
+    return accounts.reduce((acc, account) => acc.add(bn(account.lamports)), bn(0));
+};
+const COMPRESSED_SOL_PDA_SEED = Buffer.from('compressed_sol_pda');
+class LightSystemProgram {
+    /**
+     * @internal
+     */
+    constructor() { }
+    /**
+     * Public key that identifies the CompressedPda program
+     */
+    static programId = new PublicKey(
+    // TODO: can add check to ensure its consistent with the idl
+    '6UqiSPd2mRCTTwkzhcs1M6DGYsqHWd5jiPueX3LwDMXQ');
+    static _program = null;
+    static get program() {
+        if (!this._program) {
+            this.initializeProgram();
+        }
+        return this._program;
+    }
+    /**
+     * @internal
+     * Cwct1kQLwJm8Z3HetLu8m4SXkhD6FZ5fXbJQCxTxPnGY
+     */
+    static deriveCompressedSolPda() {
+        const seeds = [COMPRESSED_SOL_PDA_SEED];
+        const [address, _] = PublicKey.findProgramAddressSync(seeds, this.programId);
+        return address;
+    }
+    /**
+     * Initializes the program statically if not already initialized.
+     */
+    static initializeProgram() {
+        if (!this._program) {
+            const mockKeypair = Keypair.generate();
+            const mockConnection = new Connection('http://127.0.0.1:8899', 'confirmed');
+            const mockProvider = new AnchorProvider(mockConnection, useWallet(mockKeypair), {
+                commitment: 'confirmed',
+                preflightCommitment: 'confirmed',
+            });
+            setProvider(mockProvider);
+            this._program = new Program(IDL$3, this.programId, mockProvider);
+        }
+    }
+    static createTransferOutputState(inputCompressedAccounts, toAddress, lamports) {
+        lamports = bn(lamports);
+        const inputLamports = sumUpLamports(inputCompressedAccounts);
+        const changeLamports = inputLamports.sub(lamports);
+        validateSufficientBalance(changeLamports);
+        if (changeLamports.eq(bn(0))) {
+            return [createCompressedAccount(toAddress, lamports)];
+        }
+        validateSameOwner(inputCompressedAccounts);
+        const outputCompressedAccounts = [
+            createCompressedAccount(toAddress, lamports),
+            createCompressedAccount(inputCompressedAccounts[0].owner, changeLamports),
+        ];
+        return outputCompressedAccounts;
+    }
+    static createDecompressOutputState(inputCompressedAccounts, lamports) {
+        lamports = bn(lamports);
+        const inputLamports = sumUpLamports(inputCompressedAccounts);
+        const changeLamports = inputLamports.sub(lamports);
+        validateSufficientBalance(changeLamports);
+        /// lamports gets decompressed
+        if (changeLamports.eq(bn(0))) {
+            return [];
+        }
+        validateSameOwner(inputCompressedAccounts);
+        const outputCompressedAccounts = [
+            createCompressedAccount(inputCompressedAccounts[0].owner, changeLamports),
+        ];
+        return outputCompressedAccounts;
+    }
+    /**
+     * Creates a transaction instruction that transfers compressed lamports from
+     * one owner to another.
+     */
+    static async transfer(params) {
+        const { payer, recentValidityProof, recentInputStateRootIndices, inputCompressedAccounts, lamports, outputStateTrees, } = params;
+        /// Create output state
+        const outputCompressedAccounts = this.createTransferOutputState(inputCompressedAccounts, params.toAddress, lamports);
+        /// Pack accounts
+        const { packedInputCompressedAccounts, outputStateMerkleTreeIndices, remainingAccountMetas, } = packCompressedAccounts(inputCompressedAccounts, outputCompressedAccounts.length, outputStateTrees);
+        /// Encode instruction data
+        const data = this.program.coder.types.encode('InstructionDataTransfer', {
+            proof: recentValidityProof,
+            inputRootIndices: recentInputStateRootIndices,
+            /// TODO: here and on-chain: option<newAddressInputs> or similar.
+            newAddressParams: [],
+            inputCompressedAccountsWithMerkleContext: packedInputCompressedAccounts,
+            outputCompressedAccounts,
+            outputStateMerkleTreeAccountIndices: Buffer.from(outputStateMerkleTreeIndices),
+            relayFee: null,
+            compressionLamports: null,
+            isCompress: false,
+        });
+        /// Build anchor instruction
+        const instruction = await this.program.methods
+            .executeCompressedTransaction(data)
+            .accounts({
+            ...defaultStaticAccountsStruct(),
+            signer: payer,
+            invokingProgram: this.programId,
+            compressedSolPda: null,
+            compressionRecipient: null,
+            systemProgram: null,
+        })
+            .remainingAccounts(remainingAccountMetas)
+            .instruction();
+        const instructions = [
+            ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }),
+            instruction,
+        ];
+        return instructions;
+    }
+    /**
+     * Initialize the compressed sol pda
+     */
+    static async initCompressedSolPda(feePayer) {
+        const accounts = {
+            feePayer,
+            compressedSolPda: this.deriveCompressedSolPda(),
+            systemProgram: SystemProgram.programId,
+        };
+        const instruction = await this.program.methods
+            .initCompressSolPda()
+            .accounts(accounts)
+            .instruction();
+        return instruction;
+    }
+    /**
+     * Creates a transaction instruction that transfers compressed lamports from
+     * one owner to another.
+     */
+    // TODO: add support for non-fee-payer owner
+    static async compress(params) {
+        const { payer, outputStateTree, toAddress } = params;
+        /// Create output state
+        const lamports = bn(params.lamports);
+        const outputCompressedAccount = createCompressedAccount(toAddress, lamports);
+        /// Pack accounts
+        const { packedInputCompressedAccounts, outputStateMerkleTreeIndices, remainingAccountMetas, } = packCompressedAccounts([], 1, outputStateTree);
+        /// Encode instruction data
+        const data = this.program.coder.types.encode('InstructionDataTransfer', {
+            proof: placeholderValidityProof(),
+            inputRootIndices: [],
+            /// TODO: here and on-chain: option<newAddressInputs> or similar.
+            newAddressParams: [],
+            inputCompressedAccountsWithMerkleContext: packedInputCompressedAccounts,
+            outputCompressedAccounts: [outputCompressedAccount],
+            outputStateMerkleTreeAccountIndices: Buffer.from(new Uint8Array(outputStateMerkleTreeIndices)),
+            relayFee: null,
+            compressionLamports: lamports,
+            isCompress: true,
+        });
+        /// Build anchor instruction
+        const instruction = await this.program.methods
+            .executeCompressedTransaction(data)
+            .accounts({
+            ...defaultStaticAccountsStruct(),
+            signer: payer,
+            invokingProgram: this.programId,
+            compressedSolPda: this.deriveCompressedSolPda(),
+            compressionRecipient: null,
+            systemProgram: SystemProgram.programId,
+        })
+            .remainingAccounts(remainingAccountMetas)
+            .instruction();
+        const instructions = [
+            ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }),
+            instruction,
+        ];
+        return instructions;
+    }
+    /**
+     * Creates a transaction instruction that transfers compressed lamports from
+     * one owner to another.
+     */
+    /// TODO: add check that outputStateTree is provided or supplemented if change exists
+    static async decompress(params) {
+        const { payer, outputStateTree, toAddress } = params;
+        /// Create output state
+        const lamports = bn(params.lamports);
+        const outputCompressedAccounts = this.createDecompressOutputState(params.inputCompressedAccounts, lamports);
+        /// Pack accounts
+        const { packedInputCompressedAccounts, outputStateMerkleTreeIndices, remainingAccountMetas, } = packCompressedAccounts(params.inputCompressedAccounts, outputCompressedAccounts.length, outputStateTree);
+        /// Encode instruction data
+        const data = this.program.coder.types.encode('InstructionDataTransfer', {
+            proof: params.recentValidityProof,
+            inputRootIndices: params.recentInputStateRootIndices,
+            /// TODO: here and on-chain: option<newAddressInputs> or similar.
+            newAddressParams: [],
+            inputCompressedAccountsWithMerkleContext: packedInputCompressedAccounts,
+            outputCompressedAccounts: outputCompressedAccounts,
+            outputStateMerkleTreeAccountIndices: Buffer.from(new Uint8Array(outputStateMerkleTreeIndices)),
+            relayFee: null,
+            compressionLamports: lamports,
+            isCompress: false,
+        });
+        /// Build anchor instruction
+        const instruction = await this.program.methods
+            .executeCompressedTransaction(data)
+            .accounts({
+            ...defaultStaticAccountsStruct(),
+            signer: payer,
+            invokingProgram: this.programId,
+            compressedSolPda: this.deriveCompressedSolPda(),
+            compressionRecipient: toAddress,
+            systemProgram: SystemProgram.programId,
+        })
+            .remainingAccounts(remainingAccountMetas)
+            .instruction();
+        const instructions = [
+            ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }),
+            instruction,
+        ];
+        return instructions;
+    }
+}
+// /**
+//  * @internal
+//  *
+//  * Selects the minimal number of compressed accounts for a transfer
+//  * 1. Sorts the accounts by amount in descending order
+//  * 2. Accumulates the lamports amount until it is greater than or equal to the transfer
+//  *    amount
+//  */
+// function _selectMinCompressedAccountsForTransfer(
+//     compressedAccounts: (UtxoWithMerkleContext | UtxoWithMerkleProof)[],
+//     transferAmount: BN,
+// ): {
+//     selectedAccounts: (UtxoWithMerkleContext | UtxoWithMerkleProof)[];
+//     total: BN;
+// } {
+//     let accumulatedAmount = bn(0);
+//     const selectedAccounts: (UtxoWithMerkleContext | UtxoWithMerkleProof)[] =
+//         [];
+//     compressedAccounts.sort((a, b) =>
+//         Number(bn(b.lamports).sub(bn(a.lamports))),
+//     );
+//     for (const utxo of compressedAccounts) {
+//         if (accumulatedAmount.gte(bn(transferAmount))) break;
+//         accumulatedAmount = accumulatedAmount.add(bn(utxo.lamports));
+//         selectedAccounts.push(utxo);
+//     }
+//     if (accumulatedAmount.lt(bn(transferAmount))) {
+//         throw new Error('Not enough balance for transfer');
+//     }
+//     return { selectedAccounts, total: accumulatedAmount };
+// }
+
+/**
+ * Init the SOL omnibus account for Light
+ *
+ * @param rpc             RPC to use
+ * @param payer           Payer of the transaction and initialization fees
+ * @param lamports        Amount of lamports to compress
+ * @param toAddress       Address of the recipient compressed account
+ * @param outputStateTree Optional output state tree. Defaults to a current shared state tree.
+ * @param confirmOptions  Options for confirming the transaction
+ *
+ * @return Transaction signature
+ */
+/// TODO: add multisig support
+/// TODO: add support for payer != owner
+async function compressLamports(rpc, payer, lamports, toAddress, outputStateTree, confirmOptions) {
+    const { blockhash } = await rpc.getLatestBlockhash();
+    const ixs = await LightSystemProgram.compress({
+        payer: payer.publicKey,
+        toAddress,
+        lamports,
+        outputStateTree: outputStateTree
+            ? outputStateTree
+            : defaultTestStateTreeAccounts().merkleTree, // TODO: should fetch the current shared state tree
+    });
+    const tx = buildAndSignTx(ixs, payer, blockhash, []);
+    const txId = await sendAndConfirmTx(rpc, tx, confirmOptions);
+    return txId;
+}
+
+/**
+ * Init the SOL omnibus account for Light
+ *
+ * @param rpc             RPC to use
+ * @param payer           Payer of the transaction and initialization fees
+ * @param lamports        Amount of lamports to compress
+ * @param toAddress       Address of the recipient compressed account
+ * @param outputStateTree Optional output state tree. Defaults to a current shared state tree.
+ * @param confirmOptions  Options for confirming the transaction
+ *
+ * @return Transaction signature
+ */
+/// TODO: add multisig support
+/// TODO: add support for payer != owner
+async function decompressLamports(rpc, payer, lamports, recipient, outputStateTree, confirmOptions) {
+    /// TODO: use dynamic state tree and nullifier queue
+    const userCompressedAccountsWithMerkleContext = await rpc.getCompressedAccountsByOwner(payer.publicKey);
+    lamports = bn(lamports);
+    const inputLamports = sumUpLamports(userCompressedAccountsWithMerkleContext);
+    if (lamports.gt(inputLamports)) {
+        throw new Error(`Not enough compressed lamports. Expected ${lamports}, got ${inputLamports}`);
+    }
+    const proof = await rpc.getValidityProof(userCompressedAccountsWithMerkleContext.map(x => bn(x.hash)));
+    const { blockhash } = await rpc.getLatestBlockhash();
+    const ixs = await LightSystemProgram.decompress({
+        payer: payer.publicKey,
+        toAddress: recipient,
+        outputStateTree: outputStateTree,
+        inputCompressedAccounts: userCompressedAccountsWithMerkleContext,
+        recentValidityProof: proof.compressedProof,
+        recentInputStateRootIndices: proof.rootIndices,
+        lamports,
+    });
+    const tx = buildAndSignTx(ixs, payer, blockhash, []);
+    const txId = await sendAndConfirmTx(rpc, tx, confirmOptions);
+    return txId;
+}
+
+/** @internal remove signer from signers if part of signers */
+function dedupeSigner(signer, signers) {
+    if (signers.includes(signer)) {
+        return signers.filter(s => s.publicKey.toString() !== signer.publicKey.toString());
+    }
+    return signers;
+}
+
+/**
+ * Init the SOL omnibus account for Light
+ *
+ * @param rpc             RPC to use
+ * @param payer           Payer of the transaction and initialization fees
+ * @param initAuthority   Init authority.
+ * @param confirmOptions  Options for confirming the transaction
+ *
+ * @return Transaction signature
+ */
+/// TODO: add multisig support
+async function initSolOmnibusAccount(rpc, payer, initAuthority, confirmOptions) {
+    const { blockhash } = await rpc.getLatestBlockhash();
+    const additionalSigners = dedupeSigner(payer, initAuthority ? [initAuthority] : []);
+    const ix = await LightSystemProgram.initCompressedSolPda(initAuthority ? initAuthority.publicKey : payer.publicKey);
+    const tx = buildAndSignTx([ix], payer, blockhash, additionalSigners);
+    const txId = await sendAndConfirmTx(rpc, tx, confirmOptions);
+    return txId;
+}
+
+const IDL$2 = {
+    version: '0.3.1',
+    name: 'account_compression',
+    constants: [
+        {
+            name: 'GROUP_AUTHORITY_SEED',
+            type: 'bytes',
+            value: '[103, 114, 111, 117, 112, 95, 97, 117, 116, 104, 111, 114, 105, 116, 121]',
+        },
+        {
+            name: 'STATE_MERKLE_TREE_HEIGHT',
+            type: 'u64',
+            value: '26',
+        },
+        {
+            name: 'STATE_MERKLE_TREE_CHANGELOG',
+            type: 'u64',
+            value: '1400',
+        },
+        {
+            name: 'STATE_MERKLE_TREE_ROOTS',
+            type: 'u64',
+            value: '2400',
+        },
+        {
+            name: 'STATE_MERKLE_TREE_CANOPY_DEPTH',
+            type: 'u64',
+            value: '10',
+        },
+        {
+            name: 'STATE_INDEXED_ARRAY_INDICES',
+            type: 'u16',
+            value: '6857',
+        },
+        {
+            name: 'STATE_INDEXED_ARRAY_VALUES',
+            type: 'u16',
+            value: '4800',
+        },
+        {
+            name: 'STATE_INDEXED_ARRAY_SEQUENCE_THRESHOLD',
+            type: 'u64',
+            value: '2400',
+        },
+        {
+            name: 'ADDRESS_MERKLE_TREE_HEIGHT',
+            type: 'u64',
+            value: '26',
+        },
+        {
+            name: 'ADDRESS_MERKLE_TREE_CHANGELOG',
+            type: 'u64',
+            value: '1400',
+        },
+        {
+            name: 'ADDRESS_MERKLE_TREE_ROOTS',
+            type: 'u64',
+            value: '2400',
+        },
+        {
+            name: 'ADDRESS_MERKLE_TREE_CANOPY_DEPTH',
+            type: 'u64',
+            value: '10',
+        },
+        {
+            name: 'ADDRESS_QUEUE_INDICES',
+            type: 'u16',
+            value: '6857',
+        },
+        {
+            name: 'ADDRESS_QUEUE_VALUES',
+            type: 'u16',
+            value: '4800',
+        },
+        {
+            name: 'ADDRESS_QUEUE_SEQUENCE_THRESHOLD',
+            type: 'u64',
+            value: '2400',
+        },
+        {
+            name: 'PROGRAM_ID',
+            type: 'string',
+            value: '"5QPEJ5zDsVou9FQS3KCauKswM3VwBEBu4dpL9xTqkWwN"',
+        },
+    ],
+    instructions: [
+        {
+            name: 'initializeAddressQueue',
+            accounts: [
+                {
+                    name: 'authority',
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: 'queue',
+                    isMut: true,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'index',
+                    type: 'u64',
+                },
+                {
+                    name: 'owner',
+                    type: 'publicKey',
+                },
+                {
+                    name: 'delegate',
+                    type: {
+                        option: 'publicKey',
+                    },
+                },
+                {
+                    name: 'associatedMerkleTree',
+                    type: {
+                        option: 'publicKey',
+                    },
+                },
+                {
+                    name: 'capacityIndices',
+                    type: 'u16',
+                },
+                {
+                    name: 'capacityValues',
+                    type: 'u16',
+                },
+                {
+                    name: 'sequenceThreshold',
+                    type: 'u64',
+                },
+            ],
+        },
+        {
+            name: 'initializeAddressMerkleTree',
+            accounts: [
+                {
+                    name: 'authority',
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: 'merkleTree',
+                    isMut: true,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'index',
+                    type: 'u64',
+                },
+                {
+                    name: 'owner',
+                    type: 'publicKey',
+                },
+                {
+                    name: 'delegate',
+                    type: {
+                        option: 'publicKey',
+                    },
+                },
+                {
+                    name: 'height',
+                    type: 'u64',
+                },
+                {
+                    name: 'changelogSize',
+                    type: 'u64',
+                },
+                {
+                    name: 'rootsSize',
+                    type: 'u64',
+                },
+                {
+                    name: 'canopyDepth',
+                    type: 'u64',
+                },
+            ],
+        },
+        {
+            name: 'insertAddresses',
+            accounts: [
+                {
+                    name: 'authority',
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: 'registeredProgramPda',
+                    isMut: false,
+                    isSigner: false,
+                    isOptional: true,
+                },
+            ],
+            args: [
+                {
+                    name: 'addresses',
+                    type: {
+                        vec: {
+                            array: ['u8', 32],
+                        },
+                    },
+                },
+            ],
+        },
+        {
+            name: 'updateAddressMerkleTree',
+            accounts: [
+                {
+                    name: 'authority',
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: 'queue',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'merkleTree',
+                    isMut: true,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'changelogIndex',
+                    type: 'u16',
+                },
+                {
+                    name: 'value',
+                    type: {
+                        array: ['u8', 32],
+                    },
+                },
+                {
+                    name: 'nextIndex',
+                    type: 'u64',
+                },
+                {
+                    name: 'nextValue',
+                    type: {
+                        array: ['u8', 32],
+                    },
+                },
+                {
+                    name: 'lowAddressIndex',
+                    type: 'u64',
+                },
+                {
+                    name: 'lowAddressValue',
+                    type: {
+                        array: ['u8', 32],
+                    },
+                },
+                {
+                    name: 'lowAddressNextIndex',
+                    type: 'u64',
+                },
+                {
+                    name: 'lowAddressNextValue',
+                    type: {
+                        array: ['u8', 32],
+                    },
+                },
+                {
+                    name: 'lowAddressProof',
+                    type: {
+                        array: [
+                            {
+                                array: ['u8', 32],
+                            },
+                            16,
+                        ],
+                    },
+                },
+                {
+                    name: 'nextAddressProof',
+                    type: {
+                        array: ['u8', 128],
+                    },
+                },
+            ],
+        },
+        {
+            name: 'initializeGroupAuthority',
+            docs: [
+                'initialize group (a group can be used to give multiple programs acess to the same Merkle trees by registering the programs to the group)',
+            ],
+            accounts: [
+                {
+                    name: 'authority',
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: 'groupAuthority',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'seed',
+                    type: {
+                        array: ['u8', 32],
+                    },
+                },
+                {
+                    name: 'authority',
+                    type: 'publicKey',
+                },
+            ],
+        },
+        {
+            name: 'updateGroupAuthority',
+            accounts: [
+                {
+                    name: 'authority',
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: 'groupAuthority',
+                    isMut: true,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'authority',
+                    type: 'publicKey',
+                },
+            ],
+        },
+        {
+            name: 'registerProgramToGroup',
+            accounts: [
+                {
+                    name: 'authority',
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: 'registeredProgramPda',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'groupAuthorityPda',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'programId',
+                    type: 'publicKey',
+                },
+            ],
+        },
+        {
+            name: 'initializeStateMerkleTree',
+            docs: [
+                'Initializes a new Merkle tree from config bytes.',
+                'Index is an optional identifier and not checked by the program.',
+                'TODO: think the index over',
+            ],
+            accounts: [
+                {
+                    name: 'authority',
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: 'merkleTree',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'index',
+                    type: 'u64',
+                },
+                {
+                    name: 'owner',
+                    type: 'publicKey',
+                },
+                {
+                    name: 'delegate',
+                    type: {
+                        option: 'publicKey',
+                    },
+                },
+                {
+                    name: 'height',
+                    type: 'u64',
+                },
+                {
+                    name: 'changelogSize',
+                    type: 'u64',
+                },
+                {
+                    name: 'rootsSize',
+                    type: 'u64',
+                },
+                {
+                    name: 'canopyDepth',
+                    type: 'u64',
+                },
+                {
+                    name: 'associatedQueue',
+                    type: {
+                        option: 'publicKey',
+                    },
+                },
+            ],
+        },
+        {
+            name: 'appendLeavesToMerkleTrees',
+            accounts: [
+                {
+                    name: 'authority',
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: 'registeredProgramPda',
+                    isMut: false,
+                    isSigner: false,
+                    isOptional: true,
+                },
+                {
+                    name: 'logWrapper',
+                    isMut: false,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'leaves',
+                    type: {
+                        vec: {
+                            array: ['u8', 32],
+                        },
+                    },
+                },
+            ],
+        },
+        {
+            name: 'nullifyLeaves',
+            accounts: [
+                {
+                    name: 'authority',
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: 'registeredProgramPda',
+                    isMut: false,
+                    isSigner: false,
+                    isOptional: true,
+                },
+                {
+                    name: 'logWrapper',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'merkleTree',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'indexedArray',
+                    isMut: true,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'changeLogIndices',
+                    type: {
+                        vec: 'u64',
+                    },
+                },
+                {
+                    name: 'leavesQueueIndices',
+                    type: {
+                        vec: 'u16',
+                    },
+                },
+                {
+                    name: 'indices',
+                    type: {
+                        vec: 'u64',
+                    },
+                },
+                {
+                    name: 'proofs',
+                    type: {
+                        vec: {
+                            vec: {
+                                array: ['u8', 32],
+                            },
+                        },
+                    },
+                },
+            ],
+        },
+        {
+            name: 'initializeIndexedArray',
+            accounts: [
+                {
+                    name: 'authority',
+                    isMut: false,
+                    isSigner: true,
+                },
+                {
+                    name: 'indexedArray',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'index',
+                    type: 'u64',
+                },
+                {
+                    name: 'owner',
+                    type: 'publicKey',
+                },
+                {
+                    name: 'delegate',
+                    type: {
+                        option: 'publicKey',
+                    },
+                },
+                {
+                    name: 'associatedMerkleTree',
+                    type: {
+                        option: 'publicKey',
+                    },
+                },
+                {
+                    name: 'capacityIndices',
+                    type: 'u16',
+                },
+                {
+                    name: 'capacityValues',
+                    type: 'u16',
+                },
+                {
+                    name: 'sequenceThreshold',
+                    type: 'u64',
+                },
+            ],
+        },
+        {
+            name: 'insertIntoIndexedArrays',
+            accounts: [
+                {
+                    name: 'authority',
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: 'registeredProgramPda',
+                    isMut: false,
+                    isSigner: false,
+                    isOptional: true,
+                },
+            ],
+            args: [
+                {
+                    name: 'elements',
+                    type: {
+                        vec: {
+                            array: ['u8', 32],
+                        },
+                    },
+                },
+            ],
+        },
+    ],
+    accounts: [
+        {
+            name: 'groupAuthority',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'authority',
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'seed',
+                        type: {
+                            array: ['u8', 32],
+                        },
+                    },
+                ],
+            },
+        },
+        {
+            name: 'indexedArrayAccount',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'index',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'owner',
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'delegate',
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'associatedMerkleTree',
+                        type: 'publicKey',
+                    },
+                ],
+            },
+        },
+        {
+            name: 'registeredProgram',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'pubkey',
+                        type: 'publicKey',
+                    },
+                ],
+            },
+        },
+        {
+            name: 'addressQueueAccount',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'index',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'owner',
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'delegate',
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'associatedMerkleTree',
+                        type: 'publicKey',
+                    },
+                ],
+            },
+        },
+        {
+            name: 'addressMerkleTreeAccount',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'index',
+                        docs: ['Unique index.'],
+                        type: 'u64',
+                    },
+                    {
+                        name: 'nextMerkleTree',
+                        docs: ['Public key of the next Merkle tree.'],
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'owner',
+                        docs: ['Owner of the Merkle tree.'],
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'delegate',
+                        docs: [
+                            'Delegate of the Merkle tree. This will be used for program owned Merkle trees.',
+                        ],
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'merkleTreeStruct',
+                        type: {
+                            array: ['u8', 256],
+                        },
+                    },
+                    {
+                        name: 'merkleTreeFilledSubtrees',
+                        type: {
+                            array: ['u8', 832],
+                        },
+                    },
+                    {
+                        name: 'merkleTreeChangelog',
+                        type: {
+                            array: ['u8', 1220800],
+                        },
+                    },
+                    {
+                        name: 'merkleTreeRoots',
+                        type: {
+                            array: ['u8', 76800],
+                        },
+                    },
+                    {
+                        name: 'merkleTreeCanopy',
+                        type: {
+                            array: ['u8', 65472],
+                        },
+                    },
+                ],
+            },
+        },
+        {
+            name: 'stateMerkleTreeAccount',
+            docs: [
+                'Concurrent state Merkle tree used for public compressed transactions.',
+            ],
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'index',
+                        docs: ['Unique index.'],
+                        type: 'u64',
+                    },
+                    {
+                        name: 'nextMerkleTree',
+                        docs: ['Public key of the next Merkle tree.'],
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'owner',
+                        docs: ['Owner of the Merkle tree.'],
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'delegate',
+                        docs: [
+                            'Delegate of the Merkle tree. This will be used for program owned Merkle trees.',
+                        ],
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'associatedQueue',
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'stateMerkleTreeStruct',
+                        docs: ['Merkle tree for the transaction state.'],
+                        type: {
+                            array: ['u8', 256],
+                        },
+                    },
+                    {
+                        name: 'stateMerkleTreeFilledSubtrees',
+                        type: {
+                            array: ['u8', 832],
+                        },
+                    },
+                    {
+                        name: 'stateMerkleTreeChangelog',
+                        type: {
+                            array: ['u8', 1220800],
+                        },
+                    },
+                    {
+                        name: 'stateMerkleTreeRoots',
+                        type: {
+                            array: ['u8', 76800],
+                        },
+                    },
+                    {
+                        name: 'stateMerkleTreeCanopy',
+                        type: {
+                            array: ['u8', 65472],
+                        },
+                    },
+                ],
+            },
+        },
+    ],
+    errors: [
+        {
+            code: 6000,
+            name: 'AddressQueueInsert',
+            msg: 'Failed to insert an element into indexing queue',
+        },
+        {
+            code: 6001,
+            name: 'AddressQueueDequeue',
+            msg: 'Failed to dequeue an element from indexing queue',
+        },
+        {
+            code: 6002,
+            name: 'AddressMerkleTreeInitialize',
+            msg: 'Failed to initialize address Merkle tree',
+        },
+        {
+            code: 6003,
+            name: 'AddressMerkleTreeUpdate',
+            msg: 'Failed to update the address Merkle tree',
+        },
+        {
+            code: 6004,
+            name: 'InvalidIndex',
+            msg: 'No element found under the given index in the queue',
+        },
+        {
+            code: 6005,
+            name: 'BytesToBigint',
+            msg: 'Failed to convert bytes to big integer',
+        },
+        {
+            code: 6006,
+            name: 'IntegerOverflow',
+            msg: 'Integer overflow',
+        },
+        {
+            code: 6007,
+            name: 'InvalidAuthority',
+            msg: 'InvalidAuthority',
+        },
+        {
+            code: 6008,
+            name: 'InvalidVerifier',
+            msg: 'InvalidVerifier',
+        },
+        {
+            code: 6009,
+            name: 'NumberOfLeavesMismatch',
+            msg: 'Leaves <> remaining accounts missmatch. The number of remaining accounts must match the number of leaves.',
+        },
+        {
+            code: 6010,
+            name: 'InvalidNoopPubkey',
+            msg: 'Provided noop program public key is invalid',
+        },
+        {
+            code: 6011,
+            name: 'EventNoChangelogEntry',
+            msg: 'Emitting an event requires at least one changelog entry',
+        },
+        {
+            code: 6012,
+            name: 'NumberOfChangeLogIndicesMismatch',
+            msg: 'Number of change log indices mismatch',
+        },
+        {
+            code: 6013,
+            name: 'NumberOfIndicesMismatch',
+            msg: 'Number of indices mismatch',
+        },
+        {
+            code: 6014,
+            name: 'IndexOutOfBounds',
+            msg: 'IndexOutOfBounds',
+        },
+        {
+            code: 6015,
+            name: 'ElementAlreadyExists',
+            msg: 'ElementAlreadyExists',
+        },
+        {
+            code: 6016,
+            name: 'HashSetFull',
+            msg: 'HashSetFull',
+        },
+        {
+            code: 6017,
+            name: 'NumberOfProofsMismatch',
+            msg: 'NumberOfProofsMismatch',
+        },
+        {
+            code: 6018,
+            name: 'InvalidMerkleProof',
+            msg: 'InvalidMerkleProof',
+        },
+        {
+            code: 6019,
+            name: 'InvalidIndexedArray',
+            msg: 'InvalidIndexedArray',
+        },
+        {
+            code: 6020,
+            name: 'InvalidMerkleTree',
+            msg: 'InvalidMerkleTree',
+        },
+        {
+            code: 6021,
+            name: 'LeafNotFound',
+            msg: 'Could not find the leaf in the queue',
+        },
+    ],
+};
+
+const IDL$1 = {
+    version: '0.3.0',
+    name: 'light',
+    constants: [
+        {
+            name: 'AUTHORITY_PDA_SEED',
+            type: 'bytes',
+            value: '[97, 117, 116, 104, 111, 114, 105, 116, 121]',
+        },
+        {
+            name: 'CPI_AUTHORITY_PDA_SEED',
+            type: 'bytes',
+            value: '[99, 112, 105, 95, 97, 117, 116, 104, 111, 114, 105, 116, 121]',
+        },
+    ],
+    instructions: [
+        {
+            name: 'initializeGovernanceAuthority',
+            accounts: [
+                {
+                    name: 'authority',
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: 'authorityPda',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'authority',
+                    type: 'publicKey',
+                },
+                {
+                    name: 'rewards',
+                    type: {
+                        vec: 'u64',
+                    },
+                },
+                {
+                    name: 'bump',
+                    type: 'u8',
+                },
+            ],
+        },
+        {
+            name: 'updateGovernanceAuthorityReward',
+            accounts: [
+                {
+                    name: 'authority',
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: 'authorityPda',
+                    isMut: true,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'reward',
+                    type: 'u64',
+                },
+                {
+                    name: 'index',
+                    type: 'u64',
+                },
+            ],
+        },
+        {
+            name: 'updateGovernanceAuthority',
+            accounts: [
+                {
+                    name: 'authority',
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: 'authorityPda',
+                    isMut: true,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'bump',
+                    type: 'u8',
+                },
+                {
+                    name: 'newAuthority',
+                    type: 'publicKey',
+                },
+            ],
+        },
+        {
+            name: 'registerSystemProgram',
+            accounts: [
+                {
+                    name: 'authority',
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: 'authorityPda',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'cpiAuthority',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'groupPda',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'accountCompressionProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'registeredProgramPda',
+                    isMut: false,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'bump',
+                    type: 'u8',
+                },
+                {
+                    name: 'programId',
+                    type: 'publicKey',
+                },
+            ],
+        },
+    ],
+    accounts: [
+        {
+            name: 'lightGovernanceAuthority',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'authority',
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'bump',
+                        type: 'u8',
+                    },
+                    {
+                        name: 'padding',
+                        type: {
+                            array: ['u8', 7],
+                        },
+                    },
+                    {
+                        name: 'rewards',
+                        type: {
+                            vec: 'u64',
+                        },
+                    },
+                ],
+            },
+        },
+    ],
+    errors: [
+        {
+            code: 6000,
+            name: 'SumCheckFailed',
+            msg: 'Sum check failed',
+        },
+    ],
+};
+
+const IDL = {
+    version: '0.3.0',
+    name: 'user_registry',
+    instructions: [
+        {
+            name: 'initializeUserEntry',
+            accounts: [
+                {
+                    name: 'signer',
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'userEntry',
+                    isMut: true,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'lightPubkey',
+                    type: {
+                        array: ['u8', 32],
+                    },
+                },
+                {
+                    name: 'lightEncryptionPubkey',
+                    type: {
+                        array: ['u8', 32],
+                    },
+                },
+            ],
+        },
+    ],
+    accounts: [
+        {
+            name: 'userEntry',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'solanaPubkey',
+                        type: {
+                            array: ['u8', 32],
+                        },
+                    },
+                    {
+                        name: 'lightPubkey',
+                        type: {
+                            array: ['u8', 32],
+                        },
+                    },
+                    {
+                        name: 'lightEncryptionPubkey',
+                        type: {
+                            array: ['u8', 32],
+                        },
+                    },
+                ],
+            },
+        },
+    ],
+};
+
+// TODO: Clean up
+var UtxoErrorCode;
+(function (UtxoErrorCode) {
+    UtxoErrorCode["NEGATIVE_LAMPORTS"] = "NEGATIVE_LAMPORTS";
+    UtxoErrorCode["NOT_U64"] = "NOT_U64";
+    UtxoErrorCode["BLINDING_EXCEEDS_FIELD_SIZE"] = "BLINDING_EXCEEDS_FIELD_SIZE";
+})(UtxoErrorCode || (UtxoErrorCode = {}));
+var SelectInUtxosErrorCode;
+(function (SelectInUtxosErrorCode) {
+    SelectInUtxosErrorCode["FAILED_TO_FIND_UTXO_COMBINATION"] = "FAILED_TO_FIND_UTXO_COMBINATION";
+    SelectInUtxosErrorCode["INVALID_NUMBER_OF_IN_UTXOS"] = "INVALID_NUMBER_OF_IN_UTXOS";
+})(SelectInUtxosErrorCode || (SelectInUtxosErrorCode = {}));
+var CreateUtxoErrorCode;
+(function (CreateUtxoErrorCode) {
+    CreateUtxoErrorCode["OWNER_UNDEFINED"] = "OWNER_UNDEFINED";
+    CreateUtxoErrorCode["INVALID_OUTPUT_UTXO_LENGTH"] = "INVALID_OUTPUT_UTXO_LENGTH";
+    CreateUtxoErrorCode["UTXO_DATA_UNDEFINED"] = "UTXO_DATA_UNDEFINED";
+})(CreateUtxoErrorCode || (CreateUtxoErrorCode = {}));
+var RpcErrorCode;
+(function (RpcErrorCode) {
+    RpcErrorCode["CONNECTION_UNDEFINED"] = "CONNECTION_UNDEFINED";
+    RpcErrorCode["RPC_PUBKEY_UNDEFINED"] = "RPC_PUBKEY_UNDEFINED";
+    RpcErrorCode["RPC_METHOD_NOT_IMPLEMENTED"] = "RPC_METHOD_NOT_IMPLEMENTED";
+    RpcErrorCode["RPC_INVALID"] = "RPC_INVALID";
+})(RpcErrorCode || (RpcErrorCode = {}));
+var LookupTableErrorCode;
+(function (LookupTableErrorCode) {
+    LookupTableErrorCode["LOOK_UP_TABLE_UNDEFINED"] = "LOOK_UP_TABLE_UNDEFINED";
+    LookupTableErrorCode["LOOK_UP_TABLE_NOT_INITIALIZED"] = "LOOK_UP_TABLE_NOT_INITIALIZED";
+})(LookupTableErrorCode || (LookupTableErrorCode = {}));
+var HashErrorCode;
+(function (HashErrorCode) {
+    HashErrorCode["NO_POSEIDON_HASHER_PROVIDED"] = "NO_POSEIDON_HASHER_PROVIDED";
+})(HashErrorCode || (HashErrorCode = {}));
+var ProofErrorCode;
+(function (ProofErrorCode) {
+    ProofErrorCode["INVALID_PROOF"] = "INVALID_PROOF";
+    ProofErrorCode["PROOF_INPUT_UNDEFINED"] = "PROOF_INPUT_UNDEFINED";
+    ProofErrorCode["PROOF_GENERATION_FAILED"] = "PROOF_GENERATION_FAILED";
+})(ProofErrorCode || (ProofErrorCode = {}));
+var MerkleTreeErrorCode;
+(function (MerkleTreeErrorCode) {
+    MerkleTreeErrorCode["MERKLE_TREE_NOT_INITIALIZED"] = "MERKLE_TREE_NOT_INITIALIZED";
+    MerkleTreeErrorCode["SOL_MERKLE_TREE_UNDEFINED"] = "SOL_MERKLE_TREE_UNDEFINED";
+    MerkleTreeErrorCode["MERKLE_TREE_UNDEFINED"] = "MERKLE_TREE_UNDEFINED";
+    MerkleTreeErrorCode["INPUT_UTXO_NOT_INSERTED_IN_MERKLE_TREE"] = "INPUT_UTXO_NOT_INSERTED_IN_MERKLE_TREE";
+    MerkleTreeErrorCode["MERKLE_TREE_INDEX_UNDEFINED"] = "MERKLE_TREE_INDEX_UNDEFINED";
+    MerkleTreeErrorCode["MERKLE_TREE_SET_SPACE_UNDEFINED"] = "MERKLE_TREE_SET_SPACE_UNDEFINED";
+})(MerkleTreeErrorCode || (MerkleTreeErrorCode = {}));
+var UtilsErrorCode;
+(function (UtilsErrorCode) {
+    UtilsErrorCode["ACCOUNT_NAME_UNDEFINED_IN_IDL"] = "ACCOUNT_NAME_UNDEFINED_IN_IDL";
+    UtilsErrorCode["PROPERTY_UNDEFINED"] = "PROPERTY_UNDEFINED";
+    UtilsErrorCode["LOOK_UP_TABLE_CREATION_FAILED"] = "LOOK_UP_TABLE_CREATION_FAILED";
+    UtilsErrorCode["UNSUPPORTED_ARCHITECTURE"] = "UNSUPPORTED_ARCHITECTURE";
+    UtilsErrorCode["UNSUPPORTED_PLATFORM"] = "UNSUPPORTED_PLATFORM";
+    UtilsErrorCode["ACCOUNTS_UNDEFINED"] = "ACCOUNTS_UNDEFINED";
+    UtilsErrorCode["INVALID_NUMBER"] = "INVALID_NUMBER";
+})(UtilsErrorCode || (UtilsErrorCode = {}));
+class MetaError extends Error {
+    code;
+    functionName;
+    codeMessage;
+    constructor(code, functionName, codeMessage) {
+        super(`${code}: ${codeMessage}`);
+        this.code = code;
+        this.functionName = functionName;
+        this.codeMessage = codeMessage;
+    }
+}
+class UtxoError extends MetaError {
+}
+class SelectInUtxosError extends MetaError {
+}
+class CreateUtxoError extends MetaError {
+}
+class RpcError extends MetaError {
+}
+class LookupTableError extends MetaError {
+}
+class HashError extends MetaError {
+}
+class ProofError extends MetaError {
+}
+class MerkleTreeError extends MetaError {
+}
+class UtilsError extends MetaError {
+}
+
+export { ALICE, IDL$2 as AccountCompressionIDL, AccountProofResult, BOB, BalanceResult, CHARLIE, CompressedAccountResult, CompressedAccountsByOwnerResult, CompressedTokenAccountResult, CompressedTokenAccountsByOwnerOrDelegateResult, CreateUtxoError, CreateUtxoErrorCode, DAVE, DEFAULT_MERKLE_TREE_HEIGHT, DEFAULT_MERKLE_TREE_ROOTS, DEFAULT_ZERO, FIELD_SIZE, HashError, HashErrorCode, HealthResult, IDL$1 as LightIDL, LightSystemProgram, LookupTableError, LookupTableErrorCode, MerkeProofResult, MerkleTree, MerkleTreeError, MerkleTreeErrorCode, MultipleCompressedAccountsResult, MultipleMerkleProofsResult, ProofError, ProofErrorCode, IDL$3 as PspCompressedPdaIDL, PublicKeyToBN254, Rpc, RpcError, RpcErrorCode, SelectInUtxosError, SelectInUtxosErrorCode, SlotResult, TRANSACTION_MERKLE_TREE_ROLLOVER_THRESHOLD, TestRpc, UTXO_MERGE_MAXIMUM, UTXO_MERGE_THRESHOLD, IDL as UserRegistryIDL, UtilsError, UtilsErrorCode, UtxoError, UtxoErrorCode, accountCompressionProgram, airdropSol, bigint254ToPublicKey, bn, bufToDecStr, buildAndSignTx, byteArrayToKeypair, checkValidityProofShape, compressLamports, confirmConfig, confirmTransaction, confirmTx, createBN254, createCompressedAccount, createCompressedAccountWithMerkleContext, createMerkleContext, createRpc, createRpcResult, decompressLamports, dedupeSigner, defaultStaticAccounts, defaultStaticAccountsStruct, defaultTestStateTreeAccounts, encodeBN254toBase58, getConnection, getIndexOrAdd, getPspAccountCompressionAuthority, getRegisteredProgramPda, getTestKeypair, getTestRpc, hashToBn254FieldSizeLe, initSolOmnibusAccount, jsonRpcResult, jsonRpcResultAndContext, lightProgram, merkletreePubkey, negateAndCompressProof, newAccountWithLamports, noopProgram, nullifierQueuePubkey, packCompressedAccounts, padOutputStateMerkleTrees, parseEvents, parsePublicTransactionEventWithIdl, pipe, placeholderValidityProof, proofFromJsonStruct, pushUniqueItems, sendAndConfirmTx, sleep, sumUpLamports, toArray, toCamelCase, useWallet, validateSameOwner, validateSufficientBalance };