@lightprotocol/stateless.js 0.17.2-alpha.1 → 0.18.0

package/dist/types/index.d.ts

@@ -197,6 +197,14 @@ declare const ALICE: Keypair;
 declare const BOB: Keypair;
 declare const CHARLIE: Keypair;
 declare const DAVE: Keypair;
+/**
+ * Deep comparison of two objects. Handles BN comparison correctly.
+ *
+ * @param ref - The reference object to compare.
+ * @param val - The value object to compare.
+ * @returns True if the objects are deeply equal, false otherwise.
+ */
+declare function deepEqual(ref: any, val: any): boolean;
 /**
  * Create a new account and airdrop lamports to it
  *
@@ -272,11 +280,16 @@ interface CompressedAccountData {
     data: Buffer$1;
     dataHash: number[];
 }
+interface MerkleTreeSequenceNumber {
+    pubkey: PublicKey;
+    seq: BN;
+}
 interface PublicTransactionEvent {
     inputCompressedAccountHashes: number[][];
     outputCompressedAccountHashes: number[][];
     outputCompressedAccounts: OutputCompressedAccountWithPackedContext[];
     outputLeafIndices: number[];
+    sequenceNumbers: MerkleTreeSequenceNumber[];
     relayFee: BN | null;
     isCompress: boolean;
     compressOrDecompressLamports: BN | null;
@@ -342,13 +355,6 @@ declare const createCompressedAccount: (owner: PublicKey, lamports?: BN, data?:
 declare const createCompressedAccountWithMerkleContext: (merkleContext: MerkleContext, owner: PublicKey, lamports?: BN, data?: CompressedAccountData, address?: number[]) => CompressedAccountWithMerkleContext;
 declare const createMerkleContext: (merkleTree: PublicKey, nullifierQueue: PublicKey, hash: number[], leafIndex: number) => MerkleContext;
 
-declare class BaseRpc {
-    private getCancellationPromise;
-    private getTransactionConfirmationPromise;
-    private confirmTransactionUsingBlockHeightExceedanceStrategy;
-    private confirmTransactionUsingDurableNonceStrategy;
-    private confirmTransactionUsingLegacyTimeoutStrategy;
-}
 interface LatestNonVotingSignatures {
     context: {
         slot: number;
@@ -2516,7 +2522,7 @@ type DecompressParams = {
      */
     outputStateTree?: PublicKey;
 };
-declare class LightSystemProgram {
+declare class LightSystemProgram$1 {
     /**
      * @internal
      */
@@ -2593,6 +2599,7 @@ declare function decodePublicTransactionEvent(buffer: Buffer$1): PublicTransacti
 
 declare const FIELD_SIZE: BN;
 declare const HIGHEST_ADDRESS_PLUS_ONE: BN;
+declare const INVOKE_DISCRIMINATOR: Buffer$1;
 declare const noopProgram = "noopb9bkMVfRPU8AsbpTUg8AQkHtKwMYZiFUjNRtMmV";
 declare const lightProgram = "SySTEM1eSU2p4BGQfQpimFEWWSC1XDFeun3Nqzz3rT7";
 declare const accountCompressionProgram = "compr6CUsB5m2jS4Y3831ztGSTnDpnKJTKS95d64XVq";
@@ -2727,4 +2734,1020 @@ declare class MerkleTreeError extends MetaError {
 declare class UtilsError extends MetaError {
 }
 
-export { ADDRESS_QUEUE_ROLLOVER_FEE, ADDRESS_TREE_NETWORK_FEE, ALICE, AccountProofResult, type AddressWithTree, type BN254, BOB, BalanceResult, BaseRpc, CHARLIE, type ClientSubscriptionId, type CompressedAccount, type CompressedAccountData, CompressedAccountLayout, CompressedAccountResult, type CompressedAccountWithMerkleContext, CompressedAccountsByOwnerResult, type CompressedMintTokenHolders, CompressedMintTokenHoldersResult, type CompressedProof, type CompressedProofWithContext, CompressedTokenAccountResult, CompressedTokenAccountsByOwnerOrDelegateResult, type CompressedTransaction, CompressedTransactionResult, type CompressionApiInterface, CreateUtxoError, CreateUtxoErrorCode, DAVE, DEFAULT_MERKLE_TREE_HEIGHT, DEFAULT_MERKLE_TREE_ROOTS, DEFAULT_ZERO, type EventWithParsedTokenTlvData, FIELD_SIZE, type GetCompressedAccountConfig, type GetCompressedAccountsByOwnerConfig, type GetCompressedAccountsConfig, type GetCompressedAccountsFilter, type GetCompressedTokenAccountsByOwnerOrDelegateOptions, HIGHEST_ADDRESS_PLUS_ONE, HashError, HashErrorCode, type HashWithTree, HealthResult, type HexBatchInputsForProver, type HexInputsForProver, IndexedArray, IndexedElement, IndexedElementBundle, type InputTokenDataWithContext, type InstructionDataInvoke, InstructionDataInvokeLayout, type LatestNonVotingSignatures, type LatestNonVotingSignaturesPaginated, LatestNonVotingSignaturesResult, LatestNonVotingSignaturesResultPaginated, LightSystemProgram, type LightWasm, LookupTableError, LookupTableErrorCode, MerkeProofResult, type MerkleContext, MerkleContextLayout, type MerkleContextWithMerkleProof, type MerkleContextWithNewAddressProof, MerkleTree, MerkleTreeError, MerkleTreeErrorCode, MultipleCompressedAccountsResult, MultipleMerkleProofsResult, NativeBalanceResult, type NewAddressParams, NewAddressParamsLayout, type NewAddressParamsPacked, NewAddressProofResult, type NonInclusionJsonStruct, type NonInclusionMerkleProofInputs, type OutputCompressedAccountWithPackedContext, type PackedCompressedAccountWithMerkleContext, type PackedMerkleContext, type PaginatedOptions, type ParsedTokenAccount, ProofError, ProofErrorCode, type PublicTransactionEvent, PublicTransactionEventLayout, type QueueIndex, Rpc, RpcError, RpcErrorCode, type RpcResult, type RpcResultError, type RpcResultSuccess, STATE_MERKLE_TREE_NETWORK_FEE, STATE_MERKLE_TREE_ROLLOVER_FEE, SelectInUtxosError, SelectInUtxosErrorCode, SignatureListResult, SignatureListWithCursorResult, type SignatureWithMetadata, SlotResult, TRANSACTION_MERKLE_TREE_ROLLOVER_THRESHOLD, TestRpc, type TestRpcConfig, type TokenBalance, TokenBalanceListResult, TokenBalanceListResultV2, TokenBalanceResult, type TokenData$1 as TokenData, TokenDataLayout, TokenDataResult, UTXO_MERGE_MAXIMUM, UTXO_MERGE_THRESHOLD, UtilsError, UtilsErrorCode, UtxoError, UtxoErrorCode, ValidityProofResult, type WithContext, type WithCursor, type WithRpcContext, accountCompressionProgram, addressQueue, addressTree, airdropSol, bn, bufToDecStr, buildAndSignTx, buildTx, byteArrayToKeypair, calculateComputeUnitPrice, checkValidityProofShape, compress, confirmConfig, confirmTransaction, confirmTx, convertMerkleProofsWithContextToHex, convertNonInclusionMerkleProofInputsToHex, createAccount, createAccountWithLamports, createBN254, createCompressedAccount, createCompressedAccountWithMerkleContext, createMerkleContext, createRpc, createRpcResult, decodeInstructionDataInvoke, decodePublicTransactionEvent, decompress, dedupeSigner, defaultStaticAccounts, defaultStaticAccountsStruct, defaultTestStateTreeAccounts, deriveAddress, deriveAddressSeed, encodeBN254toBase58, encodeInstructionDataInvoke, encodePublicTransactionEvent, getAccountCompressionAuthority, getCompressedTokenAccountByHashTest, getCompressedTokenAccounts, getCompressedTokenAccountsByDelegateTest, getCompressedTokenAccountsByOwnerTest, getConnection, getIndexOrAdd, getParsedEvents, getPublicInputHash, getRegisteredProgramPda, getTestKeypair, getTestRpc, hashToBn254FieldSizeBe, hashvToBn254FieldSizeBe, invokeAccountsLayout, type invokeAccountsLayoutParams, jsonRpcResult, jsonRpcResultAndContext, lightProgram, merkletreePubkey, negateAndCompressProof, newAccountWithLamports, noopProgram, nullifierQueuePubkey, packCompressedAccounts, packNewAddressParams, padOutputStateMerkleTrees, parseAccountData, parseEvents, parsePublicTransactionEventWithIdl, parseTokenLayoutWithIdl, pipe, placeholderValidityProof, proofFromJsonStruct, proverRequest, pushUniqueItems, rpcRequest, selectMinCompressedSolAccountsForTransfer, sendAndConfirmTx, sleep, sumUpLamports, toAccountMetas, toArray, toCamelCase, toHex, toUnixTimestamp, transfer, validateSameOwner, validateSufficientBalance };
+type LightSystemProgram = {
+    version: '1.2.0';
+    name: 'light_system_program';
+    constants: [
+        {
+            name: 'SOL_POOL_PDA_SEED';
+            type: 'bytes';
+            value: '[115, 111, 108, 95, 112, 111, 111, 108, 95, 112, 100, 97]';
+        }
+    ];
+    instructions: [
+        {
+            name: 'initCpiContextAccount';
+            accounts: [
+                {
+                    name: 'feePayer';
+                    isMut: true;
+                    isSigner: true;
+                },
+                {
+                    name: 'cpiContextAccount';
+                    isMut: true;
+                    isSigner: false;
+                },
+                {
+                    name: 'associatedMerkleTree';
+                    isMut: false;
+                    isSigner: false;
+                }
+            ];
+            args: [];
+        },
+        {
+            name: 'invoke';
+            accounts: [
+                {
+                    name: 'feePayer';
+                    isMut: true;
+                    isSigner: true;
+                    docs: [
+                        'Fee payer needs to be mutable to pay rollover and protocol fees.'
+                    ];
+                },
+                {
+                    name: 'authority';
+                    isMut: false;
+                    isSigner: true;
+                },
+                {
+                    name: 'registeredProgramPda';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'noopProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'accountCompressionAuthority';
+                    isMut: false;
+                    isSigner: false;
+                    docs: [
+                        'This pda is used to invoke the account compression program.'
+                    ];
+                },
+                {
+                    name: 'accountCompressionProgram';
+                    isMut: false;
+                    isSigner: false;
+                    docs: ['Merkle trees.'];
+                },
+                {
+                    name: 'solPoolPda';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                    docs: [
+                        'Sol pool pda is used to store the native sol that has been compressed.',
+                        "It's only required when compressing or decompressing sol."
+                    ];
+                },
+                {
+                    name: 'decompressionRecipient';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                    docs: [
+                        'Only needs to be provided for decompression as a recipient for the',
+                        'decompressed sol.',
+                        'Compressed sol originate from authority.'
+                    ];
+                },
+                {
+                    name: 'systemProgram';
+                    isMut: false;
+                    isSigner: false;
+                }
+            ];
+            args: [
+                {
+                    name: 'inputs';
+                    type: 'bytes';
+                }
+            ];
+        },
+        {
+            name: 'invokeCpi';
+            accounts: [
+                {
+                    name: 'feePayer';
+                    isMut: true;
+                    isSigner: true;
+                    docs: [
+                        'Fee payer needs to be mutable to pay rollover and protocol fees.'
+                    ];
+                },
+                {
+                    name: 'authority';
+                    isMut: false;
+                    isSigner: true;
+                },
+                {
+                    name: 'registeredProgramPda';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'noopProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'accountCompressionAuthority';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'accountCompressionProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'invokingProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'solPoolPda';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                },
+                {
+                    name: 'decompressionRecipient';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                },
+                {
+                    name: 'systemProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'cpiContextAccount';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                }
+            ];
+            args: [
+                {
+                    name: 'inputs';
+                    type: 'bytes';
+                }
+            ];
+        },
+        {
+            name: 'invokeCpiWithReadOnly';
+            accounts: [
+                {
+                    name: 'feePayer';
+                    isMut: true;
+                    isSigner: true;
+                    docs: [
+                        'Fee payer needs to be mutable to pay rollover and protocol fees.'
+                    ];
+                },
+                {
+                    name: 'authority';
+                    isMut: false;
+                    isSigner: true;
+                },
+                {
+                    name: 'registeredProgramPda';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'noopProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'accountCompressionAuthority';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'accountCompressionProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'invokingProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'solPoolPda';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                },
+                {
+                    name: 'decompressionRecipient';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                },
+                {
+                    name: 'systemProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'cpiContextAccount';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                }
+            ];
+            args: [
+                {
+                    name: 'inputs';
+                    type: 'bytes';
+                }
+            ];
+        },
+        {
+            name: 'stubIdlBuild';
+            docs: [
+                'This function is a stub to allow Anchor to include the input types in',
+                'the IDL. It should not be included in production builds nor be called in',
+                'practice.'
+            ];
+            accounts: [
+                {
+                    name: 'feePayer';
+                    isMut: true;
+                    isSigner: true;
+                    docs: [
+                        'Fee payer needs to be mutable to pay rollover and protocol fees.'
+                    ];
+                },
+                {
+                    name: 'authority';
+                    isMut: false;
+                    isSigner: true;
+                },
+                {
+                    name: 'registeredProgramPda';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'noopProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'accountCompressionAuthority';
+                    isMut: false;
+                    isSigner: false;
+                    docs: [
+                        'This pda is used to invoke the account compression program.'
+                    ];
+                },
+                {
+                    name: 'accountCompressionProgram';
+                    isMut: false;
+                    isSigner: false;
+                    docs: ['Merkle trees.'];
+                },
+                {
+                    name: 'solPoolPda';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                    docs: [
+                        'Sol pool pda is used to store the native sol that has been compressed.',
+                        "It's only required when compressing or decompressing sol."
+                    ];
+                },
+                {
+                    name: 'decompressionRecipient';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                    docs: [
+                        'Only needs to be provided for decompression as a recipient for the',
+                        'decompressed sol.',
+                        'Compressed sol originate from authority.'
+                    ];
+                },
+                {
+                    name: 'systemProgram';
+                    isMut: false;
+                    isSigner: false;
+                }
+            ];
+            args: [
+                {
+                    name: 'inputs1';
+                    type: {
+                        defined: 'InstructionDataInvoke';
+                    };
+                },
+                {
+                    name: 'inputs2';
+                    type: {
+                        defined: 'InstructionDataInvokeCpi';
+                    };
+                },
+                {
+                    name: 'inputs3';
+                    type: {
+                        defined: 'PublicTransactionEvent';
+                    };
+                }
+            ];
+        }
+    ];
+    accounts: [
+        {
+            name: 'cpiContextAccount';
+            docs: [
+                'Collects instruction data without executing a compressed transaction.',
+                'Signer checks are performed on instruction data.',
+                'Collected instruction data is combined with the instruction data of the executing cpi,',
+                'and executed as a single transaction.',
+                'This enables to use input compressed accounts that are owned by multiple programs,',
+                'with one zero-knowledge proof.'
+            ];
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'feePayer';
+                        type: 'publicKey';
+                    },
+                    {
+                        name: 'associatedMerkleTree';
+                        type: 'publicKey';
+                    },
+                    {
+                        name: 'context';
+                        type: {
+                            vec: {
+                                defined: 'InstructionDataInvokeCpi';
+                            };
+                        };
+                    }
+                ];
+            };
+        }
+    ];
+    types: [
+        {
+            name: 'InstructionDataInvoke';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'proof';
+                        type: {
+                            option: {
+                                defined: 'CompressedProof';
+                            };
+                        };
+                    },
+                    {
+                        name: 'inputCompressedAccountsWithMerkleContext';
+                        type: {
+                            vec: {
+                                defined: 'PackedCompressedAccountWithMerkleContext';
+                            };
+                        };
+                    },
+                    {
+                        name: 'outputCompressedAccounts';
+                        type: {
+                            vec: {
+                                defined: 'OutputCompressedAccountWithPackedContext';
+                            };
+                        };
+                    },
+                    {
+                        name: 'relayFee';
+                        type: {
+                            option: 'u64';
+                        };
+                    },
+                    {
+                        name: 'newAddressParams';
+                        type: {
+                            vec: {
+                                defined: 'NewAddressParamsPacked';
+                            };
+                        };
+                    },
+                    {
+                        name: 'compressOrDecompressLamports';
+                        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: 'OutputCompressedAccountWithPackedContext';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'compressedAccount';
+                        type: {
+                            defined: 'CompressedAccount';
+                        };
+                    },
+                    {
+                        name: 'merkleTreeIndex';
+                        type: 'u8';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'CompressedProof';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'a';
+                        type: {
+                            array: ['u8', 32];
+                        };
+                    },
+                    {
+                        name: 'b';
+                        type: {
+                            array: ['u8', 64];
+                        };
+                    },
+                    {
+                        name: 'c';
+                        type: {
+                            array: ['u8', 32];
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: 'InstructionDataInvokeCpi';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'proof';
+                        type: {
+                            option: {
+                                defined: 'CompressedProof';
+                            };
+                        };
+                    },
+                    {
+                        name: 'newAddressParams';
+                        type: {
+                            vec: {
+                                defined: 'NewAddressParamsPacked';
+                            };
+                        };
+                    },
+                    {
+                        name: 'inputCompressedAccountsWithMerkleContext';
+                        type: {
+                            vec: {
+                                defined: 'PackedCompressedAccountWithMerkleContext';
+                            };
+                        };
+                    },
+                    {
+                        name: 'outputCompressedAccounts';
+                        type: {
+                            vec: {
+                                defined: 'OutputCompressedAccountWithPackedContext';
+                            };
+                        };
+                    },
+                    {
+                        name: 'relayFee';
+                        type: {
+                            option: 'u64';
+                        };
+                    },
+                    {
+                        name: 'compressOrDecompressLamports';
+                        type: {
+                            option: 'u64';
+                        };
+                    },
+                    {
+                        name: 'isCompress';
+                        type: 'bool';
+                    },
+                    {
+                        name: 'cpiContext';
+                        type: {
+                            option: {
+                                defined: 'CompressedCpiContext';
+                            };
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: 'CompressedCpiContext';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'setContext';
+                        docs: [
+                            'Is set by the program that is invoking the CPI to signal that is should',
+                            'set the cpi context.'
+                        ];
+                        type: 'bool';
+                    },
+                    {
+                        name: 'firstSetContext';
+                        docs: [
+                            'Is set to wipe the cpi context since someone could have set it before',
+                            'with unrelated data.'
+                        ];
+                        type: 'bool';
+                    },
+                    {
+                        name: 'cpiContextAccountIndex';
+                        docs: [
+                            'Index of cpi context account in remaining accounts.'
+                        ];
+                        type: 'u8';
+                    }
+                ];
+            };
+        },
+        {
+            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: 'PackedCompressedAccountWithMerkleContext';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'compressedAccount';
+                        type: {
+                            defined: 'CompressedAccount';
+                        };
+                    },
+                    {
+                        name: 'merkleContext';
+                        type: {
+                            defined: 'PackedMerkleContext';
+                        };
+                    },
+                    {
+                        name: 'rootIndex';
+                        docs: [
+                            'Index of root used in inclusion validity proof.'
+                        ];
+                        type: 'u16';
+                    },
+                    {
+                        name: 'readOnly';
+                        docs: [
+                            'Placeholder to mark accounts read-only unimplemented set to false.'
+                        ];
+                        type: 'bool';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'PackedMerkleContext';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'merkleTreePubkeyIndex';
+                        type: 'u8';
+                    },
+                    {
+                        name: 'nullifierQueuePubkeyIndex';
+                        type: 'u8';
+                    },
+                    {
+                        name: 'leafIndex';
+                        type: 'u32';
+                    },
+                    {
+                        name: 'queueIndex';
+                        type: {
+                            option: {
+                                defined: 'QueueIndex';
+                            };
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: 'QueueIndex';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'queueId';
+                        docs: ['Id of queue in queue account.'];
+                        type: 'u8';
+                    },
+                    {
+                        name: 'index';
+                        docs: ['Index of compressed account hash in queue.'];
+                        type: 'u16';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'MerkleTreeSequenceNumber';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'pubkey';
+                        type: 'publicKey';
+                    },
+                    {
+                        name: 'seq';
+                        type: 'u64';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'PublicTransactionEvent';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'inputCompressedAccountHashes';
+                        type: {
+                            vec: {
+                                array: ['u8', 32];
+                            };
+                        };
+                    },
+                    {
+                        name: 'outputCompressedAccountHashes';
+                        type: {
+                            vec: {
+                                array: ['u8', 32];
+                            };
+                        };
+                    },
+                    {
+                        name: 'outputCompressedAccounts';
+                        type: {
+                            vec: {
+                                defined: 'OutputCompressedAccountWithPackedContext';
+                            };
+                        };
+                    },
+                    {
+                        name: 'outputLeafIndices';
+                        type: {
+                            vec: 'u32';
+                        };
+                    },
+                    {
+                        name: 'sequenceNumbers';
+                        type: {
+                            vec: {
+                                defined: 'MerkleTreeSequenceNumber';
+                            };
+                        };
+                    },
+                    {
+                        name: 'relayFee';
+                        type: {
+                            option: 'u64';
+                        };
+                    },
+                    {
+                        name: 'isCompress';
+                        type: 'bool';
+                    },
+                    {
+                        name: 'compressOrDecompressLamports';
+                        type: {
+                            option: 'u64';
+                        };
+                    },
+                    {
+                        name: 'pubkeyArray';
+                        type: {
+                            vec: 'publicKey';
+                        };
+                    },
+                    {
+                        name: 'message';
+                        type: {
+                            option: 'bytes';
+                        };
+                    }
+                ];
+            };
+        }
+    ];
+    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: 'InvalidAddress';
+            msg: 'InvalidAddress';
+        },
+        {
+            code: 6007;
+            name: 'DeriveAddressError';
+            msg: 'DeriveAddressError';
+        },
+        {
+            code: 6008;
+            name: 'CompressedSolPdaUndefinedForCompressSol';
+            msg: 'CompressedSolPdaUndefinedForCompressSol';
+        },
+        {
+            code: 6009;
+            name: 'DeCompressLamportsUndefinedForCompressSol';
+            msg: 'DeCompressLamportsUndefinedForCompressSol';
+        },
+        {
+            code: 6010;
+            name: 'CompressedSolPdaUndefinedForDecompressSol';
+            msg: 'CompressedSolPdaUndefinedForDecompressSol';
+        },
+        {
+            code: 6011;
+            name: 'DeCompressLamportsUndefinedForDecompressSol';
+            msg: 'DeCompressLamportsUndefinedForDecompressSol';
+        },
+        {
+            code: 6012;
+            name: 'DecompressRecipientUndefinedForDecompressSol';
+            msg: 'DecompressRecipientUndefinedForDecompressSol';
+        },
+        {
+            code: 6013;
+            name: 'WriteAccessCheckFailed';
+            msg: 'WriteAccessCheckFailed';
+        },
+        {
+            code: 6014;
+            name: 'InvokingProgramNotProvided';
+            msg: 'InvokingProgramNotProvided';
+        },
+        {
+            code: 6015;
+            name: 'InvalidCapacity';
+            msg: 'InvalidCapacity';
+        },
+        {
+            code: 6016;
+            name: 'InvalidMerkleTreeOwner';
+            msg: 'InvalidMerkleTreeOwner';
+        },
+        {
+            code: 6017;
+            name: 'ProofIsNone';
+            msg: 'ProofIsNone';
+        },
+        {
+            code: 6018;
+            name: 'ProofIsSome';
+            msg: 'Proof is some but no input compressed accounts or new addresses provided.';
+        },
+        {
+            code: 6019;
+            name: 'EmptyInputs';
+            msg: 'EmptyInputs';
+        },
+        {
+            code: 6020;
+            name: 'CpiContextAccountUndefined';
+            msg: 'CpiContextAccountUndefined';
+        },
+        {
+            code: 6021;
+            name: 'CpiContextEmpty';
+            msg: 'CpiContextEmpty';
+        },
+        {
+            code: 6022;
+            name: 'CpiContextMissing';
+            msg: 'CpiContextMissing';
+        },
+        {
+            code: 6023;
+            name: 'DecompressionRecipientDefined';
+            msg: 'DecompressionRecipientDefined';
+        },
+        {
+            code: 6024;
+            name: 'SolPoolPdaDefined';
+            msg: 'SolPoolPdaDefined';
+        },
+        {
+            code: 6025;
+            name: 'AppendStateFailed';
+            msg: 'AppendStateFailed';
+        },
+        {
+            code: 6026;
+            name: 'InstructionNotCallable';
+            msg: 'The instruction is not callable';
+        },
+        {
+            code: 6027;
+            name: 'CpiContextFeePayerMismatch';
+            msg: 'CpiContextFeePayerMismatch';
+        },
+        {
+            code: 6028;
+            name: 'CpiContextAssociatedMerkleTreeMismatch';
+            msg: 'CpiContextAssociatedMerkleTreeMismatch';
+        },
+        {
+            code: 6029;
+            name: 'NoInputs';
+            msg: 'NoInputs';
+        },
+        {
+            code: 6030;
+            name: 'InputMerkleTreeIndicesNotInOrder';
+            msg: 'Input merkle tree indices are not in ascending order.';
+        },
+        {
+            code: 6031;
+            name: 'OutputMerkleTreeIndicesNotInOrder';
+            msg: 'Output merkle tree indices are not in ascending order.';
+        },
+        {
+            code: 6032;
+            name: 'OutputMerkleTreeNotUnique';
+        },
+        {
+            code: 6033;
+            name: 'DataFieldUndefined';
+        },
+        {
+            code: 6034;
+            name: 'ReadOnlyAddressAlreadyExists';
+        },
+        {
+            code: 6035;
+            name: 'ReadOnlyAccountDoesNotExist';
+        },
+        {
+            code: 6036;
+            name: 'HashChainInputsLenghtInconsistent';
+        },
+        {
+            code: 6037;
+            name: 'InvalidAddressTreeHeight';
+        }
+    ];
+};
+declare const IDL: LightSystemProgram;
+
+export { ADDRESS_QUEUE_ROLLOVER_FEE, ADDRESS_TREE_NETWORK_FEE, ALICE, AccountProofResult, type AddressWithTree, type BN254, BOB, BalanceResult, CHARLIE, type ClientSubscriptionId, type CompressedAccount, type CompressedAccountData, CompressedAccountLayout, CompressedAccountResult, type CompressedAccountWithMerkleContext, CompressedAccountsByOwnerResult, type CompressedMintTokenHolders, CompressedMintTokenHoldersResult, type CompressedProof, type CompressedProofWithContext, CompressedTokenAccountResult, CompressedTokenAccountsByOwnerOrDelegateResult, type CompressedTransaction, CompressedTransactionResult, type CompressionApiInterface, CreateUtxoError, CreateUtxoErrorCode, DAVE, DEFAULT_MERKLE_TREE_HEIGHT, DEFAULT_MERKLE_TREE_ROOTS, DEFAULT_ZERO, type EventWithParsedTokenTlvData, FIELD_SIZE, type GetCompressedAccountConfig, type GetCompressedAccountsByOwnerConfig, type GetCompressedAccountsConfig, type GetCompressedAccountsFilter, type GetCompressedTokenAccountsByOwnerOrDelegateOptions, HIGHEST_ADDRESS_PLUS_ONE, HashError, HashErrorCode, type HashWithTree, HealthResult, type HexBatchInputsForProver, type HexInputsForProver, IDL, INVOKE_DISCRIMINATOR, IndexedArray, IndexedElement, IndexedElementBundle, type InputTokenDataWithContext, type InstructionDataInvoke, InstructionDataInvokeLayout, type LatestNonVotingSignatures, type LatestNonVotingSignaturesPaginated, LatestNonVotingSignaturesResult, LatestNonVotingSignaturesResultPaginated, LightSystemProgram$1 as LightSystemProgram, type LightSystemProgram as LightSystemProgramIDL, type LightWasm, LookupTableError, LookupTableErrorCode, MerkeProofResult, type MerkleContext, MerkleContextLayout, type MerkleContextWithMerkleProof, type MerkleContextWithNewAddressProof, MerkleTree, MerkleTreeError, MerkleTreeErrorCode, type MerkleTreeSequenceNumber, MultipleCompressedAccountsResult, MultipleMerkleProofsResult, NativeBalanceResult, type NewAddressParams, NewAddressParamsLayout, type NewAddressParamsPacked, NewAddressProofResult, type NonInclusionJsonStruct, type NonInclusionMerkleProofInputs, type OutputCompressedAccountWithPackedContext, type PackedCompressedAccountWithMerkleContext, type PackedMerkleContext, type PaginatedOptions, type ParsedTokenAccount, ProofError, ProofErrorCode, type PublicTransactionEvent, PublicTransactionEventLayout, type QueueIndex, Rpc, RpcError, RpcErrorCode, type RpcResult, type RpcResultError, type RpcResultSuccess, STATE_MERKLE_TREE_NETWORK_FEE, STATE_MERKLE_TREE_ROLLOVER_FEE, SelectInUtxosError, SelectInUtxosErrorCode, SignatureListResult, SignatureListWithCursorResult, type SignatureWithMetadata, SlotResult, TRANSACTION_MERKLE_TREE_ROLLOVER_THRESHOLD, TestRpc, type TestRpcConfig, type TokenBalance, TokenBalanceListResult, TokenBalanceListResultV2, TokenBalanceResult, type TokenData$1 as TokenData, TokenDataLayout, TokenDataResult, UTXO_MERGE_MAXIMUM, UTXO_MERGE_THRESHOLD, UtilsError, UtilsErrorCode, UtxoError, UtxoErrorCode, ValidityProofResult, type WithContext, type WithCursor, type WithRpcContext, accountCompressionProgram, addressQueue, addressTree, airdropSol, bn, bufToDecStr, buildAndSignTx, buildTx, byteArrayToKeypair, calculateComputeUnitPrice, checkValidityProofShape, compress, confirmConfig, confirmTransaction, confirmTx, convertMerkleProofsWithContextToHex, convertNonInclusionMerkleProofInputsToHex, createAccount, createAccountWithLamports, createBN254, createCompressedAccount, createCompressedAccountWithMerkleContext, createMerkleContext, createRpc, createRpcResult, decodeInstructionDataInvoke, decodePublicTransactionEvent, decompress, dedupeSigner, deepEqual, defaultStaticAccounts, defaultStaticAccountsStruct, defaultTestStateTreeAccounts, deriveAddress, deriveAddressSeed, encodeBN254toBase58, encodeInstructionDataInvoke, encodePublicTransactionEvent, getAccountCompressionAuthority, getCompressedTokenAccountByHashTest, getCompressedTokenAccounts, getCompressedTokenAccountsByDelegateTest, getCompressedTokenAccountsByOwnerTest, getConnection, getIndexOrAdd, getParsedEvents, getPublicInputHash, getRegisteredProgramPda, getTestKeypair, getTestRpc, hashToBn254FieldSizeBe, hashvToBn254FieldSizeBe, invokeAccountsLayout, type invokeAccountsLayoutParams, jsonRpcResult, jsonRpcResultAndContext, lightProgram, merkletreePubkey, negateAndCompressProof, newAccountWithLamports, noopProgram, nullifierQueuePubkey, packCompressedAccounts, packNewAddressParams, padOutputStateMerkleTrees, parseAccountData, parseEvents, parsePublicTransactionEventWithIdl, parseTokenLayoutWithIdl, pipe, placeholderValidityProof, proofFromJsonStruct, proverRequest, pushUniqueItems, rpcRequest, selectMinCompressedSolAccountsForTransfer, sendAndConfirmTx, sleep, sumUpLamports, toAccountMetas, toArray, toCamelCase, toHex, toUnixTimestamp, transfer, validateSameOwner, validateSufficientBalance };