@lightprotocol/stateless.js 0.1.0-alpha.0

package/dist/umd/index.js

@@ -0,0 +1,4027 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@coral-xyz/anchor'), require('@solana/web3.js'), require('tweetnacl'), require('@coral-xyz/anchor/dist/cjs/utils/bytes'), require('buffer'), require('@noble/hashes/sha3'), require('@lightprotocol/hasher.rs'), require('axios'), require('superstruct')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@coral-xyz/anchor', '@solana/web3.js', 'tweetnacl', '@coral-xyz/anchor/dist/cjs/utils/bytes', 'buffer', '@noble/hashes/sha3', '@lightprotocol/hasher.rs', 'axios', 'superstruct'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global["@lightprotocol/stateless"] = global["@lightprotocol/stateless"] || {}, global["@lightprotocol/stateless"].js = {}), global.anchor, global.web3.js, global.tweetnacl, global.bytes, global.buffer, global.sha3, global.hasher_rs, global.axios, global.superstruct));
+})(this, (function (exports, anchor, web3_js, tweetnacl, bytes, buffer, sha3, hasher_rs, axios, superstruct) { 'use strict';
+
+    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 {
+        constructor(keypair, url, commitment) {
+            this.signTransaction = async (tx) => {
+                await tx.sign([this._keypair]);
+                return tx;
+            };
+            this.sendTransaction = async (transaction) => {
+                const signature = await this._connection.sendTransaction(transaction);
+                return signature;
+            };
+            this.signAllTransactions = async (transactions) => {
+                const signedTxs = await Promise.all(transactions.map(async (tx) => {
+                    return await this.signTransaction(tx);
+                }));
+                return signedTxs;
+            };
+            this.signMessage = async (message) => {
+                return tweetnacl.sign.detached(message, this._keypair.secretKey);
+            };
+            this.sendAndConfirmTransaction = async (transaction, signers = []) => {
+                const response = await web3_js.sendAndConfirmTransaction(this._connection, transaction, [this._keypair, ...signers], {
+                    commitment: this._commitment,
+                });
+                return response;
+            };
+            this._publicKey = keypair.publicKey;
+            this._keypair = keypair;
+            this._connection = new web3_js.Connection(url);
+            this._url = url;
+            this._commitment = commitment;
+        }
+    }
+
+    // // 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 anchor.BN('21888242871839275222246405745257275088548364400416034343698204186575808495617');
+    // TODO: implement properly
+    const noopProgram = 'noopb9bkMVfRPU8AsbpTUg8AQkHtKwMYZiFUjNRtMmV';
+    const lightProgram = '5WzvRtu7LABotw1SUEpguJiKU27LRGsiCnF5FH6VV7yP';
+    const accountCompressionProgram = // also: merkletree program
+     '5QPEJ5zDsVou9FQS3KCauKswM3VwBEBu4dpL9xTqkWwN';
+    const getRegisteredProgramPda = () => new web3_js.PublicKey('ytwwVWhQUMoTKdirKmvEW5xCRVr4B2dJZnToiHtE2L2'); // TODO: better labelling. gov authority pda
+    const getPspAccountCompressionAuthority = () => web3_js.PublicKey.findProgramAddressSync([
+        buffer.Buffer.from('cpi_authority'),
+        new web3_js.PublicKey(accountCompressionProgram).toBytes(),
+    ], new web3_js.PublicKey(
+    // TODO: can add check to ensure its consistent with the idl
+    '6UqiSPd2mRCTTwkzhcs1M6DGYsqHWd5jiPueX3LwDMXQ'))[0];
+    const defaultStaticAccounts = () => [
+        new web3_js.PublicKey(getRegisteredProgramPda()),
+        new web3_js.PublicKey(noopProgram),
+        new web3_js.PublicKey(accountCompressionProgram),
+        new web3_js.PublicKey(getPspAccountCompressionAuthority()),
+    ];
+    const defaultStaticAccountsStruct = () => {
+        return {
+            registeredProgramPda: new web3_js.PublicKey(getRegisteredProgramPda()),
+            noopProgram: new web3_js.PublicKey(noopProgram),
+            accountCompressionProgram: new web3_js.PublicKey(accountCompressionProgram),
+            pspAccountCompressionAuthority: new web3_js.PublicKey(getPspAccountCompressionAuthority()),
+            cpiSignatureAccount: null,
+        };
+    };
+    const defaultTestStateTreeAccounts = () => {
+        return {
+            nullifierQueue: new web3_js.PublicKey(nullifierQueuePubkey),
+            merkleTree: new web3_js.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 anchor.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 anchor.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(bytes.bs58.decode(number));
+        }
+        const bigintNumber = new anchor.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$1 = buffer.Buffer.from(bigintNumber.toString(16), 'hex');
+        // Ensure the buffer is 32 bytes. If not, pad it with leading zeros.
+        if (buffer$1.length < pad) {
+            const padding = buffer.Buffer.alloc(pad - buffer$1.length);
+            buffer$1 = buffer.Buffer.concat([padding, buffer$1], pad);
+        }
+        return bytes.bs58.encode(buffer$1);
+    }
+    /** Convert Base58 string to <254-bit Solana Public key*/
+    function bigint254ToPublicKey(bigintNumber) {
+        const paddedBase58 = encodeBN254toBase58(bigintNumber);
+        return new web3_js.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 (undefined) {
+        //@ts-ignore
+        const { it, expect, describe } = undefined;
+        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.Buffer.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(web3_js.PublicKey);
+            });
+        });
+        describe('PublicKeyToBigint254 function', () => {
+            it('should convert a PublicKey to a BN254', () => {
+                const publicKey = web3_js.PublicKey.unique();
+                const bigint = PublicKeyToBN254(publicKey);
+                expect(bigint).toBeInstanceOf(anchor.BN);
+            });
+        });
+    }
+
+    const createCompressedAccount = (owner, lamports, data, address) => ({
+        owner,
+        lamports: lamports !== null && lamports !== void 0 ? lamports : bn(0),
+        address: address !== null && address !== void 0 ? address : null,
+        data: data !== null && data !== void 0 ? data : null,
+    });
+    const createCompressedAccountWithMerkleContext = (merkleContext, owner, lamports, data, address) => (Object.assign(Object.assign({}, createCompressedAccount(owner, lamports, data, address)), merkleContext));
+    const createMerkleContext = (merkleTree, nullifierQueue, hash, // TODO: BN254,
+    leafIndex) => ({
+        merkleTree,
+        nullifierQueue,
+        hash,
+        leafIndex,
+    });
+    //@ts-ignore
+    if (undefined) {
+        //@ts-ignore
+        const { it, expect, describe } = undefined;
+        describe('createCompressedAccount function', () => {
+            it('should create a compressed account with default values', () => {
+                const owner = web3_js.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 = web3_js.PublicKey.unique();
+                const lamports = bn(100);
+                const data = {
+                    discriminator: [0],
+                    data: Buffer.from(new Uint8Array([1, 2, 3])),
+                    dataHash: [0],
+                };
+                const address = web3_js.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 = web3_js.PublicKey.unique();
+                const merkleTree = web3_js.PublicKey.unique();
+                const nullifierQueue = web3_js.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 = web3_js.PublicKey.unique();
+                const nullifierQueue = web3_js.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 web3_js.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.Buffer.concat([
+                bytes,
+                buffer.Buffer.from([bumpSeed]),
+            ]);
+            const hash = sha3.keccak_256(inputWithBumpSeed);
+            if (hash.length !== 32) {
+                throw new Error('Invalid hash length');
+            }
+            hash[0] = 0;
+            hash[1] = 0;
+            if (isSmallerThanBn254FieldSizeLe(buffer.Buffer.from(hash))) {
+                return [buffer.Buffer.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 (undefined) {
+        //@ts-ignore
+        const { it, expect, describe } = undefined;
+        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.Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex');
+                expect(isSmallerThanBn254FieldSizeLe(buf)).toBe(true);
+            });
+            it('should return false for a large number', () => {
+                const buf = buffer.Buffer.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.Buffer.from(bytes));
+                expect(Array.from(result[0])).toEqual(refResult);
+            });
+            it('should return a valid value for initial buffer', async () => {
+                const buf = buffer.Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex');
+                const result = await hashToBn254FieldSizeLe(buf);
+                expect(result).not.toBeNull();
+                if (result) {
+                    expect(result[0]).toBeInstanceOf(buffer.Buffer);
+                    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.Buffer.from('fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe', 'hex');
+                const result = await hashToBn254FieldSizeLe(buf);
+                expect(result).not.toBeNull();
+                if (result) {
+                    expect(result[1]).toBeLessThanOrEqual(255);
+                    expect(result[0]).toBeInstanceOf(buffer.Buffer);
+                    // 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.Buffer.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.Buffer.from([0]))).toEqual('0');
+            });
+            it("should convert buffer [1] to '1'", () => {
+                expect(bufToDecStr(buffer.Buffer.from([1]))).toEqual('1');
+            });
+            it("should convert buffer [1, 0] to '256'", () => {
+                expect(bufToDecStr(buffer.Buffer.from([1, 0]))).toEqual('256');
+            });
+            it("should convert buffer [1, 1] to '257'", () => {
+                expect(bufToDecStr(buffer.Buffer.from([1, 1]))).toEqual('257');
+            });
+            it("should convert buffer [7, 91, 205, 21] to '123456789'", () => {
+                expect(bufToDecStr(buffer.Buffer.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 (undefined) {
+        //@ts-ignore
+        const { it, expect, describe } = undefined;
+        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 === null || confirmOptions === void 0 ? void 0 : confirmOptions.commitment);
+        const transactionConfirmationStrategy0 = {
+            signature: txId,
+            blockhash,
+            lastValidBlockHeight,
+        };
+        await rpc.confirmTransaction(transactionConfirmationStrategy0, (confirmOptions === null || confirmOptions === void 0 ? void 0 : 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 web3_js.TransactionMessage({
+            payerKey: payer.publicKey,
+            recentBlockhash: blockhash,
+            instructions,
+        }).compileToV0Message();
+        const tx = new web3_js.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 (undefined) {
+        //@ts-ignore
+        const { describe, it, expect } = undefined;
+        // Inline unit tests for padOutputStateMerkleTrees function
+        describe('padOutputStateMerkleTrees', () => {
+            const treeA = web3_js.PublicKey.unique();
+            const treeB = web3_js.PublicKey.unique();
+            const treeC = web3_js.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 = bytes.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(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 anchor.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 anchor.BN(bYElement.slice(0, 32), 32, 'be'), new anchor.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 anchor.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 anchor.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 anchor.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 (undefined) {
+        //@ts-ignore
+        const { it, expect, describe } = undefined;
+        // 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 = superstruct.coerce(superstruct.instance(web3_js.PublicKey), superstruct.string(), value => new web3_js.PublicKey(value));
+    /**
+     * @internal
+     */
+    // TODO: use a BN254 class here for the 1st parameter
+    const BN254FromString = superstruct.coerce(superstruct.instance(anchor.BN), superstruct.string(), value => {
+        return createBN254(value, 'base58');
+    });
+    const BNFromInt = superstruct.coerce(superstruct.instance(anchor.BN), superstruct.number(), value => bn(value));
+    const BNFromBase10String = superstruct.coerce(superstruct.instance(anchor.BN), superstruct.string(), value => bn(value));
+    /**
+     * @internal
+     */
+    const Base64EncodedCompressedAccountDataResult = superstruct.coerce(superstruct.nullable(superstruct.string()), superstruct.string(), value => (value === '' ? null : value));
+    /**
+     * @internal
+     */
+    function createRpcResult(result) {
+        return superstruct.union([
+            superstruct.type({
+                jsonrpc: superstruct.literal('2.0'),
+                id: superstruct.string(),
+                result,
+            }),
+            superstruct.type({
+                jsonrpc: superstruct.literal('2.0'),
+                id: superstruct.string(),
+                error: superstruct.type({
+                    code: superstruct.unknown(),
+                    message: superstruct.string(),
+                    data: superstruct.nullable(superstruct.any()),
+                }),
+            }),
+        ]);
+    }
+    /**
+     * @internal
+     */
+    const UnknownRpcResult = createRpcResult(superstruct.unknown());
+    /**
+     * @internal
+     */
+    function jsonRpcResult(schema) {
+        return superstruct.coerce(createRpcResult(schema), UnknownRpcResult, value => {
+            if ('error' in value) {
+                return value;
+            }
+            else {
+                return Object.assign(Object.assign({}, value), { result: superstruct.create(value.result, schema) });
+            }
+        });
+    }
+    /**
+     * @internal
+     */
+    function jsonRpcResultAndContext(value) {
+        return jsonRpcResult(superstruct.type({
+            context: superstruct.type({
+                slot: superstruct.number(),
+            }),
+            value,
+        }));
+    }
+    /**
+     * @internal
+     */
+    /// Compressed Account With Merkle Context
+    const CompressedAccountResult = superstruct.type({
+        hash: BN254FromString,
+        address: superstruct.nullable(PublicKeyFromString),
+        data: Base64EncodedCompressedAccountDataResult,
+        dataHash: superstruct.nullable(BN254FromString),
+        discriminator: BNFromInt,
+        owner: PublicKeyFromString,
+        lamports: BNFromInt,
+        tree: superstruct.nullable(PublicKeyFromString), // TODO: should not be nullable
+        seq: superstruct.nullable(BNFromInt),
+        slotUpdated: BNFromInt,
+        leafIndex: superstruct.number(),
+    });
+    /**
+     * @internal
+     */
+    /// TODO: update: delegatedAmount, state, programOwner/tokenOwner, data includes the values?, no closeAuth!
+    const CompressedTokenAccountResult = superstruct.type({
+        address: superstruct.nullable(PublicKeyFromString), // TODO: why is this here
+        amount: BNFromBase10String, // why string
+        delegate: superstruct.nullable(PublicKeyFromString),
+        closeAuthority: superstruct.nullable(PublicKeyFromString), // TODO: remove
+        isNative: superstruct.boolean(),
+        frozen: superstruct.boolean(),
+        mint: PublicKeyFromString,
+        owner: PublicKeyFromString, // owner or user?
+        //
+        hash: BN254FromString,
+        data: Base64EncodedCompressedAccountDataResult,
+        dataHash: superstruct.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: superstruct.number(),
+    });
+    /**
+     * @internal
+     */
+    const MultipleCompressedAccountsResult = superstruct.type({
+        items: superstruct.array(CompressedAccountResult),
+    });
+    /**
+     * @internal
+     */
+    const CompressedAccountsByOwnerResult = superstruct.type({
+        items: superstruct.array(CompressedAccountResult),
+        // cursor: array(number()), // paginated
+    });
+    /**
+     * @internal
+     */
+    const CompressedTokenAccountsByOwnerOrDelegateResult = superstruct.type({
+        items: superstruct.array(CompressedTokenAccountResult),
+        // cursor: array(number()), // paginated TODO: add cursor to photon / docs update
+    });
+    /**
+     * @internal
+     */
+    const SlotResult = superstruct.number();
+    /**
+     * @internal
+     */
+    const HealthResult = superstruct.string();
+    /**
+     * @internal
+     */
+    const MerkeProofResult = superstruct.type({
+        hash: BN254FromString,
+        merkleTree: PublicKeyFromString,
+        leafIndex: superstruct.number(),
+        proof: superstruct.array(BN254FromString),
+    });
+    /**
+     * @internal
+     */
+    const MultipleMerkleProofsResult = superstruct.array(MerkeProofResult);
+    /**
+     * @internal
+     */
+    const BalanceResult = BNFromInt;
+    /// TODO: we need to add: tree, nullifierQueue, leafIndex, rootIndex
+    const AccountProofResult = superstruct.type({
+        hash: superstruct.array(superstruct.number()),
+        root: superstruct.array(superstruct.number()),
+        proof: superstruct.array(superstruct.array(superstruct.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 web3_js.Connection {
+        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 = superstruct.create(unsafeRes, jsonRpcResultAndContext(superstruct.nullable(CompressedAccountResult)));
+            if ('error' in res) {
+                throw new web3_js.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 = superstruct.create(unsafeRes, jsonRpcResultAndContext(BalanceResult));
+            if ('error' in res) {
+                throw new web3_js.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 = superstruct.create(unsafeRes, jsonRpcResultAndContext(MerkeProofResult));
+            if ('error' in res) {
+                throw new web3_js.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 = superstruct.create(unsafeRes, jsonRpcResultAndContext(MultipleCompressedAccountsResult));
+            if ('error' in res) {
+                throw new web3_js.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 = superstruct.create(unsafeRes, jsonRpcResultAndContext(superstruct.array(MerkeProofResult)));
+            if ('error' in res) {
+                throw new web3_js.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 = superstruct.create(unsafeRes, jsonRpcResultAndContext(CompressedAccountsByOwnerResult));
+            if ('error' in res) {
+                throw new web3_js.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 = superstruct.create(unsafeRes, jsonRpcResult(HealthResult));
+            if ('error' in res) {
+                throw new web3_js.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 = superstruct.create(unsafeRes, jsonRpcResult(SlotResult));
+            if ('error' in res) {
+                throw new web3_js.SolanaJSONRPCError(res.error, 'failed to get slot');
+            }
+            return res.result;
+        }
+        async getCompressedTokenAccountsByOwner(owner, options) {
+            var _a;
+            const unsafeRes = await rpcRequest(this.compressionApiEndpoint, 'getCompressedTokenAccountsByOwner', { owner: owner.toBase58(), mint: (_a = options === null || options === void 0 ? void 0 : options.mint) === null || _a === void 0 ? void 0 : _a.toBase58() });
+            const res = superstruct.create(unsafeRes, jsonRpcResultAndContext(CompressedTokenAccountsByOwnerOrDelegateResult));
+            if ('error' in res) {
+                throw new web3_js.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 web3_js.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 anchor.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 {
+        /**
+         * 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);
+            this.log = false;
+            const { merkleTreeAddress, nullifierQueueAddress, depth, log } = testRpcConfig !== null && testRpcConfig !== void 0 ? testRpcConfig : {};
+            const { merkleTree, nullifierQueue, merkleTreeHeight } = defaultTestStateTreeAccounts();
+            this.lightWasm = hasher;
+            this.merkleTreeAddress = merkleTreeAddress !== null && merkleTreeAddress !== void 0 ? merkleTreeAddress : merkleTree;
+            this.nullifierQueueAddress = nullifierQueueAddress !== null && nullifierQueueAddress !== void 0 ? nullifierQueueAddress : nullifierQueue;
+            this.depth = depth !== null && depth !== void 0 ? depth : merkleTreeHeight;
+            this.log = log !== null && log !== void 0 ? 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 web3_js.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 hasher_rs.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 web3_js.Keypair.fromSeed(seed);
+    }
+    //@ts-ignore
+    if (undefined) {
+        //@ts-ignore
+        const { describe, it, expect } = undefined;
+        describe('getTestKeypair', () => {
+            it('should generate a keypair with a specific counter', () => {
+                const keypair = getTestKeypair(10);
+                expect(keypair).toBeInstanceOf(web3_js.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() { }
+        static get program() {
+            if (!this._program) {
+                this.initializeProgram();
+            }
+            return this._program;
+        }
+        /**
+         * @internal
+         * Cwct1kQLwJm8Z3HetLu8m4SXkhD6FZ5fXbJQCxTxPnGY
+         */
+        static deriveCompressedSolPda() {
+            const seeds = [COMPRESSED_SOL_PDA_SEED];
+            const [address, _] = web3_js.PublicKey.findProgramAddressSync(seeds, this.programId);
+            return address;
+        }
+        /**
+         * Initializes the program statically if not already initialized.
+         */
+        static initializeProgram() {
+            if (!this._program) {
+                const mockKeypair = web3_js.Keypair.generate();
+                const mockConnection = new web3_js.Connection('http://127.0.0.1:8899', 'confirmed');
+                const mockProvider = new anchor.AnchorProvider(mockConnection, useWallet(mockKeypair), {
+                    commitment: 'confirmed',
+                    preflightCommitment: 'confirmed',
+                });
+                anchor.setProvider(mockProvider);
+                this._program = new anchor.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(Object.assign(Object.assign({}, defaultStaticAccountsStruct()), { signer: payer, invokingProgram: this.programId, compressedSolPda: null, compressionRecipient: null, systemProgram: null }))
+                .remainingAccounts(remainingAccountMetas)
+                .instruction();
+            const instructions = [
+                web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }),
+                instruction,
+            ];
+            return instructions;
+        }
+        /**
+         * Initialize the compressed sol pda
+         */
+        static async initCompressedSolPda(feePayer) {
+            const accounts = {
+                feePayer,
+                compressedSolPda: this.deriveCompressedSolPda(),
+                systemProgram: web3_js.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(Object.assign(Object.assign({}, defaultStaticAccountsStruct()), { signer: payer, invokingProgram: this.programId, compressedSolPda: this.deriveCompressedSolPda(), compressionRecipient: null, systemProgram: web3_js.SystemProgram.programId }))
+                .remainingAccounts(remainingAccountMetas)
+                .instruction();
+            const instructions = [
+                web3_js.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(Object.assign(Object.assign({}, defaultStaticAccountsStruct()), { signer: payer, invokingProgram: this.programId, compressedSolPda: this.deriveCompressedSolPda(), compressionRecipient: toAddress, systemProgram: web3_js.SystemProgram.programId }))
+                .remainingAccounts(remainingAccountMetas)
+                .instruction();
+            const instructions = [
+                web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }),
+                instruction,
+            ];
+            return instructions;
+        }
+    }
+    /**
+     * Public key that identifies the CompressedPda program
+     */
+    LightSystemProgram.programId = new web3_js.PublicKey(
+    // TODO: can add check to ensure its consistent with the idl
+    '6UqiSPd2mRCTTwkzhcs1M6DGYsqHWd5jiPueX3LwDMXQ');
+    LightSystemProgram._program = null;
+    // /**
+    //  * @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
+    exports.UtxoErrorCode = void 0;
+    (function (UtxoErrorCode) {
+        UtxoErrorCode["NEGATIVE_LAMPORTS"] = "NEGATIVE_LAMPORTS";
+        UtxoErrorCode["NOT_U64"] = "NOT_U64";
+        UtxoErrorCode["BLINDING_EXCEEDS_FIELD_SIZE"] = "BLINDING_EXCEEDS_FIELD_SIZE";
+    })(exports.UtxoErrorCode || (exports.UtxoErrorCode = {}));
+    exports.SelectInUtxosErrorCode = void 0;
+    (function (SelectInUtxosErrorCode) {
+        SelectInUtxosErrorCode["FAILED_TO_FIND_UTXO_COMBINATION"] = "FAILED_TO_FIND_UTXO_COMBINATION";
+        SelectInUtxosErrorCode["INVALID_NUMBER_OF_IN_UTXOS"] = "INVALID_NUMBER_OF_IN_UTXOS";
+    })(exports.SelectInUtxosErrorCode || (exports.SelectInUtxosErrorCode = {}));
+    exports.CreateUtxoErrorCode = void 0;
+    (function (CreateUtxoErrorCode) {
+        CreateUtxoErrorCode["OWNER_UNDEFINED"] = "OWNER_UNDEFINED";
+        CreateUtxoErrorCode["INVALID_OUTPUT_UTXO_LENGTH"] = "INVALID_OUTPUT_UTXO_LENGTH";
+        CreateUtxoErrorCode["UTXO_DATA_UNDEFINED"] = "UTXO_DATA_UNDEFINED";
+    })(exports.CreateUtxoErrorCode || (exports.CreateUtxoErrorCode = {}));
+    exports.RpcErrorCode = void 0;
+    (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";
+    })(exports.RpcErrorCode || (exports.RpcErrorCode = {}));
+    exports.LookupTableErrorCode = void 0;
+    (function (LookupTableErrorCode) {
+        LookupTableErrorCode["LOOK_UP_TABLE_UNDEFINED"] = "LOOK_UP_TABLE_UNDEFINED";
+        LookupTableErrorCode["LOOK_UP_TABLE_NOT_INITIALIZED"] = "LOOK_UP_TABLE_NOT_INITIALIZED";
+    })(exports.LookupTableErrorCode || (exports.LookupTableErrorCode = {}));
+    exports.HashErrorCode = void 0;
+    (function (HashErrorCode) {
+        HashErrorCode["NO_POSEIDON_HASHER_PROVIDED"] = "NO_POSEIDON_HASHER_PROVIDED";
+    })(exports.HashErrorCode || (exports.HashErrorCode = {}));
+    exports.ProofErrorCode = void 0;
+    (function (ProofErrorCode) {
+        ProofErrorCode["INVALID_PROOF"] = "INVALID_PROOF";
+        ProofErrorCode["PROOF_INPUT_UNDEFINED"] = "PROOF_INPUT_UNDEFINED";
+        ProofErrorCode["PROOF_GENERATION_FAILED"] = "PROOF_GENERATION_FAILED";
+    })(exports.ProofErrorCode || (exports.ProofErrorCode = {}));
+    exports.MerkleTreeErrorCode = void 0;
+    (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";
+    })(exports.MerkleTreeErrorCode || (exports.MerkleTreeErrorCode = {}));
+    exports.UtilsErrorCode = void 0;
+    (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";
+    })(exports.UtilsErrorCode || (exports.UtilsErrorCode = {}));
+    class MetaError extends Error {
+        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 {
+    }
+
+    exports.ALICE = ALICE;
+    exports.AccountCompressionIDL = IDL$2;
+    exports.AccountProofResult = AccountProofResult;
+    exports.BOB = BOB;
+    exports.BalanceResult = BalanceResult;
+    exports.CHARLIE = CHARLIE;
+    exports.CompressedAccountResult = CompressedAccountResult;
+    exports.CompressedAccountsByOwnerResult = CompressedAccountsByOwnerResult;
+    exports.CompressedTokenAccountResult = CompressedTokenAccountResult;
+    exports.CompressedTokenAccountsByOwnerOrDelegateResult = CompressedTokenAccountsByOwnerOrDelegateResult;
+    exports.CreateUtxoError = CreateUtxoError;
+    exports.DAVE = DAVE;
+    exports.DEFAULT_MERKLE_TREE_HEIGHT = DEFAULT_MERKLE_TREE_HEIGHT;
+    exports.DEFAULT_MERKLE_TREE_ROOTS = DEFAULT_MERKLE_TREE_ROOTS;
+    exports.DEFAULT_ZERO = DEFAULT_ZERO;
+    exports.FIELD_SIZE = FIELD_SIZE;
+    exports.HashError = HashError;
+    exports.HealthResult = HealthResult;
+    exports.LightIDL = IDL$1;
+    exports.LightSystemProgram = LightSystemProgram;
+    exports.LookupTableError = LookupTableError;
+    exports.MerkeProofResult = MerkeProofResult;
+    exports.MerkleTree = MerkleTree;
+    exports.MerkleTreeError = MerkleTreeError;
+    exports.MultipleCompressedAccountsResult = MultipleCompressedAccountsResult;
+    exports.MultipleMerkleProofsResult = MultipleMerkleProofsResult;
+    exports.ProofError = ProofError;
+    exports.PspCompressedPdaIDL = IDL$3;
+    exports.PublicKeyToBN254 = PublicKeyToBN254;
+    exports.Rpc = Rpc;
+    exports.RpcError = RpcError;
+    exports.SelectInUtxosError = SelectInUtxosError;
+    exports.SlotResult = SlotResult;
+    exports.TRANSACTION_MERKLE_TREE_ROLLOVER_THRESHOLD = TRANSACTION_MERKLE_TREE_ROLLOVER_THRESHOLD;
+    exports.TestRpc = TestRpc;
+    exports.UTXO_MERGE_MAXIMUM = UTXO_MERGE_MAXIMUM;
+    exports.UTXO_MERGE_THRESHOLD = UTXO_MERGE_THRESHOLD;
+    exports.UserRegistryIDL = IDL;
+    exports.UtilsError = UtilsError;
+    exports.UtxoError = UtxoError;
+    exports.accountCompressionProgram = accountCompressionProgram;
+    exports.airdropSol = airdropSol;
+    exports.bigint254ToPublicKey = bigint254ToPublicKey;
+    exports.bn = bn;
+    exports.bufToDecStr = bufToDecStr;
+    exports.buildAndSignTx = buildAndSignTx;
+    exports.byteArrayToKeypair = byteArrayToKeypair;
+    exports.checkValidityProofShape = checkValidityProofShape;
+    exports.compressLamports = compressLamports;
+    exports.confirmConfig = confirmConfig;
+    exports.confirmTransaction = confirmTransaction;
+    exports.confirmTx = confirmTx;
+    exports.createBN254 = createBN254;
+    exports.createCompressedAccount = createCompressedAccount;
+    exports.createCompressedAccountWithMerkleContext = createCompressedAccountWithMerkleContext;
+    exports.createMerkleContext = createMerkleContext;
+    exports.createRpc = createRpc;
+    exports.createRpcResult = createRpcResult;
+    exports.decompressLamports = decompressLamports;
+    exports.dedupeSigner = dedupeSigner;
+    exports.defaultStaticAccounts = defaultStaticAccounts;
+    exports.defaultStaticAccountsStruct = defaultStaticAccountsStruct;
+    exports.defaultTestStateTreeAccounts = defaultTestStateTreeAccounts;
+    exports.encodeBN254toBase58 = encodeBN254toBase58;
+    exports.getConnection = getConnection;
+    exports.getIndexOrAdd = getIndexOrAdd;
+    exports.getPspAccountCompressionAuthority = getPspAccountCompressionAuthority;
+    exports.getRegisteredProgramPda = getRegisteredProgramPda;
+    exports.getTestKeypair = getTestKeypair;
+    exports.getTestRpc = getTestRpc;
+    exports.hashToBn254FieldSizeLe = hashToBn254FieldSizeLe;
+    exports.initSolOmnibusAccount = initSolOmnibusAccount;
+    exports.jsonRpcResult = jsonRpcResult;
+    exports.jsonRpcResultAndContext = jsonRpcResultAndContext;
+    exports.lightProgram = lightProgram;
+    exports.merkletreePubkey = merkletreePubkey;
+    exports.negateAndCompressProof = negateAndCompressProof;
+    exports.newAccountWithLamports = newAccountWithLamports;
+    exports.noopProgram = noopProgram;
+    exports.nullifierQueuePubkey = nullifierQueuePubkey;
+    exports.packCompressedAccounts = packCompressedAccounts;
+    exports.padOutputStateMerkleTrees = padOutputStateMerkleTrees;
+    exports.parseEvents = parseEvents;
+    exports.parsePublicTransactionEventWithIdl = parsePublicTransactionEventWithIdl;
+    exports.pipe = pipe;
+    exports.placeholderValidityProof = placeholderValidityProof;
+    exports.proofFromJsonStruct = proofFromJsonStruct;
+    exports.pushUniqueItems = pushUniqueItems;
+    exports.sendAndConfirmTx = sendAndConfirmTx;
+    exports.sleep = sleep;
+    exports.sumUpLamports = sumUpLamports;
+    exports.toArray = toArray;
+    exports.toCamelCase = toCamelCase;
+    exports.useWallet = useWallet;
+    exports.validateSameOwner = validateSameOwner;
+    exports.validateSufficientBalance = validateSufficientBalance;
+
+}));