@lightprotocol/stateless.js 0.20.8 → 0.21.0

package/dist/cjs/node/index.d.ts

@@ -2,10 +2,10 @@ export * from './actions';
 export * from './instruction';
 export * from './programs';
 export * from './state';
+export * from './test-helpers';
 export * from './utils';
 export * from './constants';
 export * from './errors';
+export { LightSystemProgram as LightSystemProgramIDL, IDL } from './idl';
 export * from './rpc-interface';
 export * from './rpc';
-export * from './test-helpers';
-export { LightSystemProgram as LightSystemProgramIDL, IDL } from './idl';

package/dist/cjs/node/instruction/pack-compressed-accounts.d.ts

@@ -1,5 +1,5 @@
 import { AccountMeta, PublicKey } from '@solana/web3.js';
-import { ActiveTreeBundle, CompressedAccount, OutputCompressedAccountWithPackedContext, PackedCompressedAccountWithMerkleContext } from '../state';
+import { CompressedAccount, OutputCompressedAccountWithPackedContext, PackedCompressedAccountWithMerkleContext, StateTreeInfo } from '../state';
 import { CompressedAccountWithMerkleContext } from '../state/compressed-account';
 /**
  * @internal Finds the index of a PublicKey in an array, or adds it if not
@@ -19,20 +19,10 @@ export declare function getIndexOrAdd(accountsArray: PublicKey[], key: PublicKey
  *                                                  outputCompressedAccounts.
  * @param numberOfOutputCompressedAccounts          The number of output
  *                                                  compressed accounts.
- * @param inputCompressedAccountsWithMerkleContext  The input compressed
- *                                                  accounts with merkle
- *                                                  context.
- * @param activeTreeBundles                         Optional active tree bundles
- *                                                  to be used as fallback for
- *                                                  padding. Prioritizes ones
- *                                                  that are explicitly passed
- *                                                  via outputStateMerkleTrees
- *                                                  or
- *                                                  inputCompressedAccountsWithMerkleContext.
  *
  * @returns Padded output state trees.
  */
-export declare function padOutputStateMerkleTrees(outputStateMerkleTrees: PublicKey[] | PublicKey | undefined, numberOfOutputCompressedAccounts: number, inputCompressedAccountsWithMerkleContext: CompressedAccountWithMerkleContext[], activeTreeBundles?: ActiveTreeBundle[]): PublicKey[];
+export declare function padOutputStateMerkleTrees(outputStateMerkleTrees: PublicKey, numberOfOutputCompressedAccounts: number): PublicKey[];
 export declare function toAccountMetas(remainingAccounts: PublicKey[]): AccountMeta[];
 /**
  * Packs Compressed Accounts.
@@ -45,22 +35,14 @@ export declare function toAccountMetas(remainingAccounts: PublicKey[]): AccountM
  *                                          input state. The expiry is tied to
  *                                          the proof.
  * @param outputCompressedAccounts          Ix output state to be created
- * @param outputStateMerkleTrees            Optional output state trees to be
- *                                          inserted into the output state.
- *                                          Defaults to the 0th state tree of
- *                                          the input state. Gets padded to the
- *                                          length of outputCompressedAccounts.
- *
- * @param activeTreeBundles                 Optional active tree bundles to be
- *                                          used as fallback for padding.
- *                                          Prioritizes ones that are explicitly
- *                                          passed via outputStateMerkleTrees or
- *                                          inputCompressedAccountsWithMerkleContext.
+ * @param outputStateTreeInfo               The output state tree info. Gets
+ *                                          padded to the length of
+ *                                          outputCompressedAccounts.
  *
  * @param remainingAccounts                 Optional existing array of accounts
  *                                          to append to.
  **/
-export declare function packCompressedAccounts(inputCompressedAccounts: CompressedAccountWithMerkleContext[], inputStateRootIndices: number[], outputCompressedAccounts: CompressedAccount[], outputStateMerkleTrees?: PublicKey[] | PublicKey, remainingAccounts?: PublicKey[], activeTreeBundles?: ActiveTreeBundle[]): {
+export declare function packCompressedAccounts(inputCompressedAccounts: CompressedAccountWithMerkleContext[], inputStateRootIndices: number[], outputCompressedAccounts: CompressedAccount[], outputStateTreeInfo?: StateTreeInfo, remainingAccounts?: PublicKey[]): {
     packedInputCompressedAccounts: PackedCompressedAccountWithMerkleContext[];
     packedOutputCompressedAccounts: OutputCompressedAccountWithPackedContext[];
     remainingAccounts: PublicKey[];

package/dist/cjs/node/programs/layout.d.ts

@@ -11,14 +11,41 @@ export declare const InstructionDataInvokeCpiLayout: Layout<InstructionDataInvok
 export declare function decodeInstructionDataInvoke(buffer: Buffer): InstructionDataInvoke;
 export declare function decodeInstructionDataInvokeCpi(buffer: Buffer): InstructionDataInvokeCpi;
 export type invokeAccountsLayoutParams = {
+    /**
+     * Fee payer.
+     */
     feePayer: PublicKey;
+    /**
+     * Authority.
+     */
     authority: PublicKey;
+    /**
+     * The registered program pda
+     */
     registeredProgramPda: PublicKey;
+    /**
+     * Noop program.
+     */
     noopProgram: PublicKey;
+    /**
+     * Account compression authority.
+     */
     accountCompressionAuthority: PublicKey;
+    /**
+     * Account compression program.
+     */
     accountCompressionProgram: PublicKey;
+    /**
+     * Solana pool pda. Some() if compression or decompression is done.
+     */
     solPoolPda: PublicKey | null;
+    /**
+     * Decompression recipient.
+     */
     decompressionRecipient: PublicKey | null;
+    /**
+     * Solana system program.
+     */
     systemProgram: PublicKey;
 };
 export declare const invokeAccountsLayout: (accounts: invokeAccountsLayoutParams) => AccountMeta[];

package/dist/cjs/node/programs/system.d.ts

@@ -1,6 +1,6 @@
 import BN from 'bn.js';
 import { PublicKey, TransactionInstruction } from '@solana/web3.js';
-import { CompressedAccount, CompressedAccountWithMerkleContext, CompressedProof } from '../state';
+import { CompressedAccount, CompressedAccountWithMerkleContext, ValidityProof, StateTreeInfo } from '../state';
 import { NewAddressParams } from '../utils';
 export declare const sumUpLamports: (accounts: CompressedAccountWithMerkleContext[]) => BN;
 /**
@@ -12,21 +12,24 @@ type CreateAccountWithSeedParams = {
      */
     payer: PublicKey;
     /**
-     * Address params for the new compressed account
+     * Address params for the new compressed account.
      */
     newAddressParams: NewAddressParams;
+    /**
+     * Address of the new compressed account
+     */
     newAddress: number[];
     /**
      * Recent validity proof proving that there's no existing compressed account
      * registered with newAccountAddress
      */
-    recentValidityProof: CompressedProof;
+    recentValidityProof: ValidityProof;
     /**
      * State tree pubkey. Defaults to a public state tree if unspecified.
      */
-    outputStateTree?: PublicKey;
+    outputStateTreeInfo?: StateTreeInfo;
     /**
-     * Public key of the program to assign as the owner of the created account
+     * Public key of the program to assign as the owner of the created account.
      */
     programId?: PublicKey;
     /**
@@ -57,11 +60,11 @@ type TransferParams = {
      */
     inputCompressedAccounts: CompressedAccountWithMerkleContext[];
     /**
-     * Recipient address
+     * Recipient address.
      */
     toAddress: PublicKey;
     /**
-     * amount of lamports to transfer.
+     * Amount of lamports to transfer.
      */
     lamports: number | BN;
     /**
@@ -75,13 +78,7 @@ type TransferParams = {
      * The recent validity proof for state inclusion of the input state. It
      * expires after n slots.
      */
-    recentValidityProof: CompressedProof;
-    /**
-     * The state trees that the tx output should be inserted into. This can be a
-     * single PublicKey or an array of PublicKey. Defaults to the 0th state tree
-     * of input state.
-     */
-    outputStateTrees?: PublicKey[] | PublicKey;
+    recentValidityProof: ValidityProof;
 };
 /**
  * Defines the parameters for the transfer method
@@ -103,7 +100,7 @@ type CompressParams = {
      * The state tree that the tx output should be inserted into. Defaults to a
      * public state tree if unspecified.
      */
-    outputStateTree?: PublicKey;
+    outputStateTreeInfo: StateTreeInfo;
 };
 /**
  * Defines the parameters for the transfer method
@@ -136,13 +133,7 @@ type DecompressParams = {
      * The recent validity proof for state inclusion of the input state. It
      * expires after n slots.
      */
-    recentValidityProof: CompressedProof;
-    /**
-     * The state trees that the tx output should be inserted into. This can be a
-     * single PublicKey or an array of PublicKey. Defaults to the 0th state tree
-     * of input state.
-     */
-    outputStateTree?: PublicKey;
+    recentValidityProof: ValidityProof;
 };
 export declare class LightSystemProgram {
     /**
@@ -150,7 +141,7 @@ export declare class LightSystemProgram {
      */
     constructor();
     /**
-     * Public key that identifies the CompressedPda program
+     * The LightSystemProgram program ID.
      */
     static programId: PublicKey;
     /**
@@ -171,22 +162,22 @@ export declare class LightSystemProgram {
      *
      * TODO: support transfer of lamports to the new account.
      */
-    static createAccount({ payer, newAddressParams, newAddress, recentValidityProof, outputStateTree, inputCompressedAccounts, inputStateRootIndices, lamports, }: CreateAccountWithSeedParams): Promise<TransactionInstruction>;
+    static createAccount({ payer, newAddressParams, newAddress, recentValidityProof, outputStateTreeInfo, inputCompressedAccounts, inputStateRootIndices, lamports, }: CreateAccountWithSeedParams): Promise<TransactionInstruction>;
     /**
      * Creates a transaction instruction that transfers compressed lamports from
      * one owner to another.
      */
-    static transfer({ payer, inputCompressedAccounts, toAddress, lamports, recentInputStateRootIndices, recentValidityProof, outputStateTrees, }: TransferParams): Promise<TransactionInstruction>;
+    static transfer({ payer, inputCompressedAccounts, toAddress, lamports, recentInputStateRootIndices, recentValidityProof, }: TransferParams): Promise<TransactionInstruction>;
     /**
      * Creates a transaction instruction that transfers compressed lamports from
      * one owner to another.
      */
-    static compress({ payer, toAddress, lamports, outputStateTree, }: CompressParams): Promise<TransactionInstruction>;
+    static compress({ payer, toAddress, lamports, outputStateTreeInfo, }: CompressParams): Promise<TransactionInstruction>;
     /**
      * Creates a transaction instruction that transfers compressed lamports from
      * one owner to another.
      */
-    static decompress({ payer, inputCompressedAccounts, toAddress, lamports, recentInputStateRootIndices, recentValidityProof, outputStateTree, }: DecompressParams): Promise<TransactionInstruction>;
+    static decompress({ payer, inputCompressedAccounts, toAddress, lamports, recentInputStateRootIndices, recentValidityProof, }: DecompressParams): Promise<TransactionInstruction>;
 }
 /**
  * Selects the minimal number of compressed SOL accounts for a transfer.

package/dist/cjs/node/rpc-interface.d.ts

@@ -1,6 +1,6 @@
 import { PublicKey, MemcmpFilter, DataSlice } from '@solana/web3.js';
 import { Struct } from 'superstruct';
-import { BN254, CompressedProof, CompressedAccountWithMerkleContext, MerkleContextWithMerkleProof, TokenData } from './state';
+import { BN254, ValidityProof, CompressedAccountWithMerkleContext, MerkleContextWithMerkleProof, TokenData, StateTreeInfo, AddressTreeInfo, CompressedProof } from './state';
 import BN from 'bn.js';
 export interface LatestNonVotingSignatures {
     context: {
@@ -43,6 +43,32 @@ export interface SignatureWithMetadata {
     signature: string;
     slot: number;
 }
+/**
+ * Account hash and associated state tree info.
+ */
+export interface HashWithTreeInfo {
+    /**
+     * Account hash.
+     */
+    hash: BN254;
+    /**
+     * State tree info.
+     */
+    stateTreeInfo: StateTreeInfo;
+}
+/**
+ * Address and associated address tree info.
+ */
+export interface AddressWithTreeInfo {
+    /**
+     * Address.
+     */
+    address: BN254;
+    /**
+     * Address tree info.
+     */
+    addressTreeInfo: AddressTreeInfo;
+}
 export interface HashWithTree {
     hash: BN254;
     tree: PublicKey;
@@ -53,6 +79,10 @@ export interface AddressWithTree {
     tree: PublicKey;
     queue: PublicKey;
 }
+export interface AddressWithTreeInfo {
+    address: BN254;
+    treeInfo: AddressTreeInfo;
+}
 export interface CompressedTransaction {
     compressionInfo: {
         closedAccounts: {
@@ -85,6 +115,41 @@ export interface HexInputsForProver {
     pathElements: string[];
     leaf: string;
 }
+/**
+ * Validity proof with context.
+ *
+ * You can request proofs via `rpc.getValidityProof` or
+ * `rpc.getValidityProofV0`.
+ */
+export type ValidityProofWithContext = {
+    /**
+     * Validity proof.
+     */
+    compressedProof: ValidityProof;
+    /**
+     * Roots.
+     */
+    roots: BN[];
+    /**
+     * Root indices.
+     */
+    rootIndices: number[];
+    /**
+     * Leaf indices.
+     */
+    leafIndices: number[];
+    /**
+     * Leaves.
+     */
+    leaves: BN[];
+    /**
+     * Tree infos.
+     */
+    treeInfos: StateTreeInfo[];
+};
+/**
+ * @deprecated use {@link ValidityProofWithContext} instead
+ */
 export type CompressedProofWithContext = {
     compressedProof: CompressedProof;
     roots: BN[];
@@ -168,12 +233,12 @@ export declare const CompressedAccountResult: Struct<{
         dataHash: BN;
         discriminator: BN;
     } | null;
+    lamports: BN;
+    tree: PublicKey;
     address: number[] | null;
     hash: BN;
-    lamports: BN;
     owner: PublicKey;
     leafIndex: number;
-    tree: PublicKey;
     seq: BN | null;
     slotCreated: BN;
 }, {
@@ -225,12 +290,12 @@ export declare const CompressedTokenAccountResult: Struct<{
             dataHash: BN;
             discriminator: BN;
         } | null;
+        lamports: BN;
+        tree: PublicKey;
         address: number[] | null;
         hash: BN;
-        lamports: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         seq: BN | null;
         slotCreated: BN;
     };
@@ -254,12 +319,12 @@ export declare const CompressedTokenAccountResult: Struct<{
             dataHash: BN;
             discriminator: BN;
         } | null;
+        lamports: BN;
+        tree: PublicKey;
         address: number[] | null;
         hash: BN;
-        lamports: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         seq: BN | null;
         slotCreated: BN;
     }, {
@@ -292,12 +357,12 @@ export declare const MultipleCompressedAccountsResult: Struct<{
             dataHash: BN;
             discriminator: BN;
         } | null;
+        lamports: BN;
+        tree: PublicKey;
         address: number[] | null;
         hash: BN;
-        lamports: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         seq: BN | null;
         slotCreated: BN;
     }[];
@@ -308,12 +373,12 @@ export declare const MultipleCompressedAccountsResult: Struct<{
             dataHash: BN;
             discriminator: BN;
         } | null;
+        lamports: BN;
+        tree: PublicKey;
         address: number[] | null;
         hash: BN;
-        lamports: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         seq: BN | null;
         slotCreated: BN;
     }[], Struct<{
@@ -322,12 +387,12 @@ export declare const MultipleCompressedAccountsResult: Struct<{
             dataHash: BN;
             discriminator: BN;
         } | null;
+        lamports: BN;
+        tree: PublicKey;
         address: number[] | null;
         hash: BN;
-        lamports: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         seq: BN | null;
         slotCreated: BN;
     }, {
@@ -360,12 +425,12 @@ export declare const CompressedAccountsByOwnerResult: Struct<{
             dataHash: BN;
             discriminator: BN;
         } | null;
+        lamports: BN;
+        tree: PublicKey;
         address: number[] | null;
         hash: BN;
-        lamports: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         seq: BN | null;
         slotCreated: BN;
     }[];
@@ -377,12 +442,12 @@ export declare const CompressedAccountsByOwnerResult: Struct<{
             dataHash: BN;
             discriminator: BN;
         } | null;
+        lamports: BN;
+        tree: PublicKey;
         address: number[] | null;
         hash: BN;
-        lamports: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         seq: BN | null;
         slotCreated: BN;
     }[], Struct<{
@@ -391,12 +456,12 @@ export declare const CompressedAccountsByOwnerResult: Struct<{
             dataHash: BN;
             discriminator: BN;
         } | null;
+        lamports: BN;
+        tree: PublicKey;
         address: number[] | null;
         hash: BN;
-        lamports: BN;
         owner: PublicKey;
         leafIndex: number;
-        tree: PublicKey;
         seq: BN | null;
         slotCreated: BN;
     }, {
@@ -438,12 +503,12 @@ export declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
                 dataHash: BN;
                 discriminator: BN;
             } | null;
+            lamports: BN;
+            tree: PublicKey;
             address: number[] | null;
             hash: BN;
-            lamports: BN;
             owner: PublicKey;
             leafIndex: number;
-            tree: PublicKey;
             seq: BN | null;
             slotCreated: BN;
         };
@@ -464,12 +529,12 @@ export declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
                 dataHash: BN;
                 discriminator: BN;
             } | null;
+            lamports: BN;
+            tree: PublicKey;
             address: number[] | null;
             hash: BN;
-            lamports: BN;
             owner: PublicKey;
             leafIndex: number;
-            tree: PublicKey;
             seq: BN | null;
             slotCreated: BN;
         };
@@ -487,12 +552,12 @@ export declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
                 dataHash: BN;
                 discriminator: BN;
             } | null;
+            lamports: BN;
+            tree: PublicKey;
             address: number[] | null;
             hash: BN;
-            lamports: BN;
             owner: PublicKey;
             leafIndex: number;
-            tree: PublicKey;
             seq: BN | null;
             slotCreated: BN;
         };
@@ -516,12 +581,12 @@ export declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
                 dataHash: BN;
                 discriminator: BN;
             } | null;
+            lamports: BN;
+            tree: PublicKey;
             address: number[] | null;
             hash: BN;
-            lamports: BN;
             owner: PublicKey;
             leafIndex: number;
-            tree: PublicKey;
             seq: BN | null;
             slotCreated: BN;
         }, {
@@ -841,12 +906,12 @@ export declare const CompressedTransactionResult: Struct<{
                     dataHash: BN;
                     discriminator: BN;
                 } | null;
+                lamports: BN;
+                tree: PublicKey;
                 address: number[] | null;
                 hash: BN;
-                lamports: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -865,12 +930,12 @@ export declare const CompressedTransactionResult: Struct<{
                     dataHash: BN;
                     discriminator: BN;
                 } | null;
+                lamports: BN;
+                tree: PublicKey;
                 address: number[] | null;
                 hash: BN;
-                lamports: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -893,12 +958,12 @@ export declare const CompressedTransactionResult: Struct<{
                     dataHash: BN;
                     discriminator: BN;
                 } | null;
+                lamports: BN;
+                tree: PublicKey;
                 address: number[] | null;
                 hash: BN;
-                lamports: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -917,12 +982,12 @@ export declare const CompressedTransactionResult: Struct<{
                     dataHash: BN;
                     discriminator: BN;
                 } | null;
+                lamports: BN;
+                tree: PublicKey;
                 address: number[] | null;
                 hash: BN;
-                lamports: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -942,12 +1007,12 @@ export declare const CompressedTransactionResult: Struct<{
                     dataHash: BN;
                     discriminator: BN;
                 } | null;
+                lamports: BN;
+                tree: PublicKey;
                 address: number[] | null;
                 hash: BN;
-                lamports: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -965,12 +1030,12 @@ export declare const CompressedTransactionResult: Struct<{
                     dataHash: BN;
                     discriminator: BN;
                 } | null;
+                lamports: BN;
+                tree: PublicKey;
                 address: number[] | null;
                 hash: BN;
-                lamports: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -988,12 +1053,12 @@ export declare const CompressedTransactionResult: Struct<{
                     dataHash: BN;
                     discriminator: BN;
                 } | null;
+                lamports: BN;
+                tree: PublicKey;
                 address: number[] | null;
                 hash: BN;
-                lamports: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             }, {
@@ -1036,12 +1101,12 @@ export declare const CompressedTransactionResult: Struct<{
                     dataHash: BN;
                     discriminator: BN;
                 } | null;
+                lamports: BN;
+                tree: PublicKey;
                 address: number[] | null;
                 hash: BN;
-                lamports: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -1059,12 +1124,12 @@ export declare const CompressedTransactionResult: Struct<{
                     dataHash: BN;
                     discriminator: BN;
                 } | null;
+                lamports: BN;
+                tree: PublicKey;
                 address: number[] | null;
                 hash: BN;
-                lamports: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             };
@@ -1082,12 +1147,12 @@ export declare const CompressedTransactionResult: Struct<{
                     dataHash: BN;
                     discriminator: BN;
                 } | null;
+                lamports: BN;
+                tree: PublicKey;
                 address: number[] | null;
                 hash: BN;
-                lamports: BN;
                 owner: PublicKey;
                 leafIndex: number;
-                tree: PublicKey;
                 seq: BN | null;
                 slotCreated: BN;
             }, {
@@ -1133,9 +1198,9 @@ export interface CompressionApiInterface {
     getCompressedAccountProof(hash: BN254): Promise<MerkleContextWithMerkleProof>;
     getMultipleCompressedAccounts(hashes: BN254[]): Promise<CompressedAccountWithMerkleContext[]>;
     getMultipleCompressedAccountProofs(hashes: BN254[]): Promise<MerkleContextWithMerkleProof[]>;
-    getValidityProof(hashes: BN254[], newAddresses: BN254[]): Promise<CompressedProofWithContext>;
-    getValidityProofV0(hashes: HashWithTree[], newAddresses: AddressWithTree[]): Promise<CompressedProofWithContext>;
-    getValidityProofAndRpcContext(hashes: HashWithTree[], newAddresses: AddressWithTree[]): Promise<WithContext<CompressedProofWithContext>>;
+    getValidityProof(hashes: BN254[], newAddresses: BN254[]): Promise<ValidityProofWithContext>;
+    getValidityProofV0(hashes: HashWithTree[], newAddresses: AddressWithTree[]): Promise<ValidityProofWithContext>;
+    getValidityProofAndRpcContext(hashes: HashWithTree[], newAddresses: AddressWithTree[]): Promise<WithContext<ValidityProofWithContext>>;
     getCompressedAccountsByOwner(owner: PublicKey, config?: GetCompressedAccountsByOwnerConfig): Promise<WithCursor<CompressedAccountWithMerkleContext[]>>;
     getCompressedMintTokenHolders(mint: PublicKey, options?: PaginatedOptions): Promise<WithContext<WithCursor<CompressedMintTokenHolders[]>>>;
     getCompressedTokenAccountsByOwner(publicKey: PublicKey, options: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<ParsedTokenAccount[]>>;