@lightprotocol/compressed-token 0.2.0 → 0.3.1

package/dist/types/index.d.ts

@@ -1,17 +1,10 @@
-import { ParsedTokenAccount, InputTokenDataWithContext as InputTokenDataWithContext$1, CompressedProof, TokenTransferOutputData as TokenTransferOutputData$1, Rpc } from '@lightprotocol/stateless.js';
+import { CompressedProof, ParsedTokenAccount, TokenTransferOutputData as TokenTransferOutputData$1, InputTokenDataWithContext as InputTokenDataWithContext$1, Rpc } from '@lightprotocol/stateless.js';
 import { PublicKey, AccountMeta, TransactionInstruction, Signer, ConfirmOptions, TransactionSignature, Keypair } from '@solana/web3.js';
 import { BN, Program } from '@coral-xyz/anchor';
 
 type LightCompressedToken = {
-    version: '0.3.1';
+    version: '0.4.0';
     name: 'light_compressed_token';
-    constants: [
-        {
-            name: 'PROGRAM_ID';
-            type: 'string';
-            value: '"9sixVEthz2kMSKfeApZXHwuboT6DZuT6crAYJTciUCqE"';
-        }
-    ];
     instructions: [
         {
             name: 'createMint';
@@ -27,11 +20,6 @@ type LightCompressedToken = {
                     isMut: true;
                     isSigner: true;
                 },
-                {
-                    name: 'authority';
-                    isMut: true;
-                    isSigner: true;
-                },
                 {
                     name: 'tokenPoolPda';
                     isMut: true;
@@ -47,11 +35,6 @@ type LightCompressedToken = {
                     isMut: true;
                     isSigner: false;
                 },
-                {
-                    name: 'mintAuthorityPda';
-                    isMut: true;
-                    isSigner: false;
-                },
                 {
                     name: 'tokenProgram';
                     isMut: false;
@@ -67,6 +50,12 @@ type LightCompressedToken = {
         },
         {
             name: 'mintTo';
+            docs: [
+                'Mints tokens from an spl token mint to a list of compressed accounts.',
+                'Minted tokens are transferred to a pool account owned by the compressed',
+                'token program. The instruction creates one compressed output account for',
+                'every amount and pubkey input pair one output compressed account.'
+            ];
             accounts: [
                 {
                     name: 'feePayer';
@@ -75,12 +64,12 @@ type LightCompressedToken = {
                 },
                 {
                     name: 'authority';
-                    isMut: true;
+                    isMut: false;
                     isSigner: true;
                 },
                 {
-                    name: 'mintAuthorityPda';
-                    isMut: true;
+                    name: 'cpiAuthorityPda';
+                    isMut: false;
                     isSigner: false;
                 },
                 {
@@ -105,7 +94,7 @@ type LightCompressedToken = {
                 },
                 {
                     name: 'registeredProgramPda';
-                    isMut: true;
+                    isMut: false;
                     isSigner: false;
                 },
                 {
@@ -115,7 +104,7 @@ type LightCompressedToken = {
                 },
                 {
                     name: 'accountCompressionAuthority';
-                    isMut: true;
+                    isMut: false;
                     isSigner: false;
                 },
                 {
@@ -151,10 +140,6 @@ type LightCompressedToken = {
                     type: {
                         vec: 'u64';
                     };
-                },
-                {
-                    name: 'bump';
-                    type: 'u8';
                 }
             ];
         },
@@ -213,7 +198,7 @@ type LightCompressedToken = {
                     isOptional: true;
                 },
                 {
-                    name: 'decompressTokenAccount';
+                    name: 'compressOrDecompressTokenAccount';
                     isMut: true;
                     isSigner: false;
                     isOptional: true;
@@ -236,136 +221,546 @@ type LightCompressedToken = {
                     type: 'bytes';
                 }
             ];
-        }
-    ];
-    types: [
-        {
-            name: 'InstructionDataInvoke';
-            type: {
-                kind: 'struct';
-                fields: [
-                    {
-                        name: 'proof';
-                        type: {
-                            option: {
-                                defined: 'CompressedProof';
-                            };
-                        };
-                    },
-                    {
-                        name: 'inputRootIndices';
-                        type: {
-                            vec: 'u16';
-                        };
-                    },
-                    {
-                        name: 'inputCompressedAccountsWithMerkleContext';
-                        type: {
-                            vec: {
-                                defined: 'PackedCompressedAccountWithMerkleContext';
-                            };
-                        };
-                    },
-                    {
-                        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: 'newAddressParams';
-                        type: {
-                            vec: {
-                                defined: 'NewAddressParamsPacked';
-                            };
-                        };
-                    },
-                    {
-                        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: 'approve';
+            accounts: [
+                {
+                    name: 'feePayer';
+                    isMut: true;
+                    isSigner: true;
+                },
+                {
+                    name: 'authority';
+                    isMut: false;
+                    isSigner: true;
+                },
+                {
+                    name: 'cpiAuthorityPda';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'lightSystemProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    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: 'selfProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'systemProgram';
+                    isMut: false;
+                    isSigner: false;
+                }
+            ];
+            args: [
+                {
+                    name: 'inputs';
+                    type: 'bytes';
+                }
+            ];
         },
         {
-            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: 'revoke';
+            accounts: [
+                {
+                    name: 'feePayer';
+                    isMut: true;
+                    isSigner: true;
+                },
+                {
+                    name: 'authority';
+                    isMut: false;
+                    isSigner: true;
+                },
+                {
+                    name: 'cpiAuthorityPda';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'lightSystemProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    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: 'selfProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'systemProgram';
+                    isMut: false;
+                    isSigner: false;
+                }
+            ];
+            args: [
+                {
+                    name: 'inputs';
+                    type: 'bytes';
+                }
+            ];
         },
         {
-            name: 'CompressedProof';
-            type: {
-                kind: 'struct';
-                fields: [
-                    {
+            name: 'freeze';
+            accounts: [
+                {
+                    name: 'feePayer';
+                    isMut: true;
+                    isSigner: true;
+                },
+                {
+                    name: 'authority';
+                    isMut: false;
+                    isSigner: true;
+                },
+                {
+                    name: 'cpiAuthorityPda';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'lightSystemProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    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: 'selfProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'systemProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'mint';
+                    isMut: false;
+                    isSigner: false;
+                }
+            ];
+            args: [
+                {
+                    name: 'inputs';
+                    type: 'bytes';
+                }
+            ];
+        },
+        {
+            name: 'thaw';
+            accounts: [
+                {
+                    name: 'feePayer';
+                    isMut: true;
+                    isSigner: true;
+                },
+                {
+                    name: 'authority';
+                    isMut: false;
+                    isSigner: true;
+                },
+                {
+                    name: 'cpiAuthorityPda';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'lightSystemProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    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: 'selfProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'systemProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'mint';
+                    isMut: false;
+                    isSigner: false;
+                }
+            ];
+            args: [
+                {
+                    name: 'inputs';
+                    type: 'bytes';
+                }
+            ];
+        },
+        {
+            name: 'burn';
+            accounts: [
+                {
+                    name: 'feePayer';
+                    isMut: true;
+                    isSigner: true;
+                },
+                {
+                    name: 'authority';
+                    isMut: false;
+                    isSigner: true;
+                },
+                {
+                    name: 'cpiAuthorityPda';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'lightSystemProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    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: 'selfProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'systemProgram';
+                    isMut: false;
+                    isSigner: false;
+                }
+            ];
+            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;
+                },
+                {
+                    name: 'authority';
+                    isMut: false;
+                    isSigner: true;
+                },
+                {
+                    name: 'cpiAuthorityPda';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'lightSystemProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    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: 'selfProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'tokenPoolPda';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                },
+                {
+                    name: 'compressOrDecompressTokenAccount';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                },
+                {
+                    name: 'tokenProgram';
+                    isMut: false;
+                    isSigner: false;
+                    isOptional: true;
+                },
+                {
+                    name: 'systemProgram';
+                    isMut: false;
+                    isSigner: false;
+                }
+            ];
+            args: [
+                {
+                    name: 'inputs1';
+                    type: {
+                        defined: 'CompressedTokenInstructionDataTransfer';
+                    };
+                },
+                {
+                    name: 'inputs2';
+                    type: {
+                        defined: 'TokenData';
+                    };
+                }
+            ];
+        }
+    ];
+    accounts: [
+        {
+            name: 'RegisteredProgram';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'registeredProgramId';
+                        type: 'publicKey';
+                    },
+                    {
+                        name: 'groupAuthorityPda';
+                        type: 'publicKey';
+                    }
+                ];
+            };
+        }
+    ];
+    types: [
+        {
+            name: 'AccessMetadata';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'owner';
+                        docs: ['Owner of the Merkle tree.'];
+                        type: 'publicKey';
+                    },
+                    {
+                        name: 'programOwner';
+                        docs: [
+                            'Delegate of the Merkle tree. This will be used for program owned Merkle trees.'
+                        ];
+                        type: 'publicKey';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'AccountState';
+            type: {
+                kind: 'enum';
+                variants: [
+                    {
+                        name: 'Initialized';
+                    },
+                    {
+                        name: 'Frozen';
+                    }
+                ];
+            };
+        },
+        {
+            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: 'CompressedCpiContext';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'setContext';
+                        type: 'bool';
+                    },
+                    {
+                        name: 'cpiContextAccountIndex';
+                        type: 'u8';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'CompressedProof';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
                         name: 'a';
                         type: {
                             array: ['u8', 32];
@@ -387,7 +782,7 @@ type LightCompressedToken = {
             };
         },
         {
-            name: 'InstructionDataInvokeCpi';
+            name: 'CompressedTokenInstructionDataTransfer';
             type: {
                 kind: 'struct';
                 fields: [
@@ -400,24 +795,27 @@ type LightCompressedToken = {
                         };
                     },
                     {
-                        name: 'newAddressParams';
-                        type: {
-                            vec: {
-                                defined: 'NewAddressParamsPacked';
-                            };
-                        };
+                        name: 'mint';
+                        type: 'publicKey';
                     },
                     {
-                        name: 'inputRootIndices';
+                        name: 'delegatedTransfer';
+                        docs: [
+                            'If the signer is a delegate, the delegate index is index 0 of remaining accounts.',
+                            'owner = Some(owner) is the owner of the token account.',
+                            'Is set if the signer is delegate'
+                        ];
                         type: {
-                            vec: 'u16';
+                            option: {
+                                defined: 'DelegatedTransfer';
+                            };
                         };
                     },
                     {
-                        name: 'inputCompressedAccountsWithMerkleContext';
+                        name: 'inputTokenDataWithContext';
                         type: {
                             vec: {
-                                defined: 'PackedCompressedAccountWithMerkleContext';
+                                defined: 'InputTokenDataWithContext';
                             };
                         };
                     },
@@ -425,37 +823,18 @@ type LightCompressedToken = {
                         name: 'outputCompressedAccounts';
                         type: {
                             vec: {
-                                defined: 'CompressedAccount';
+                                defined: 'PackedTokenTransferOutputData';
                             };
                         };
                     },
-                    {
-                        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: 'signerSeeds';
+                        name: 'compressOrDecompressAmount';
                         type: {
-                            vec: 'bytes';
+                            option: 'u64';
                         };
                     },
                     {
@@ -470,111 +849,175 @@ type LightCompressedToken = {
             };
         },
         {
-            name: 'PackedCompressedAccountWithMerkleContext';
+            name: 'DelegatedTransfer';
             type: {
                 kind: 'struct';
                 fields: [
                     {
-                        name: 'compressedAccount';
-                        type: {
-                            defined: 'CompressedAccount';
-                        };
+                        name: 'owner';
+                        type: 'publicKey';
                     },
                     {
-                        name: 'merkleContext';
-                        type: {
-                            defined: 'PackedMerkleContext';
-                        };
+                        name: 'delegateChangeAccountIndex';
+                        type: 'u8';
                     }
                 ];
             };
         },
         {
-            name: 'CompressedAccountWithMerkleContext';
+            name: 'InputTokenDataWithContext';
             type: {
                 kind: 'struct';
                 fields: [
                     {
-                        name: 'compressedAccount';
+                        name: 'amount';
+                        type: 'u64';
+                    },
+                    {
+                        name: 'delegateIndex';
                         type: {
-                            defined: 'CompressedAccount';
+                            option: 'u8';
+                        };
+                    },
+                    {
+                        name: 'isNative';
+                        type: {
+                            option: 'u64';
                         };
                     },
                     {
                         name: 'merkleContext';
                         type: {
-                            defined: 'MerkleContext';
+                            defined: 'PackedMerkleContext';
                         };
+                    },
+                    {
+                        name: 'rootIndex';
+                        type: 'u16';
                     }
                 ];
             };
         },
         {
-            name: 'MerkleContext';
+            name: 'InstructionDataInvoke';
             type: {
                 kind: 'struct';
                 fields: [
                     {
-                        name: 'merkleTreePubkey';
-                        type: 'publicKey';
+                        name: 'proof';
+                        type: {
+                            option: {
+                                defined: 'CompressedProof';
+                            };
+                        };
                     },
                     {
-                        name: 'nullifierQueuePubkey';
-                        type: 'publicKey';
+                        name: 'inputCompressedAccountsWithMerkleContext';
+                        type: {
+                            vec: {
+                                defined: 'PackedCompressedAccountWithMerkleContext';
+                            };
+                        };
                     },
                     {
-                        name: 'leafIndex';
-                        type: 'u32';
-                    }
-                ];
-            };
-        },
-        {
-            name: 'PackedMerkleContext';
-            type: {
-                kind: 'struct';
-                fields: [
+                        name: 'outputCompressedAccounts';
+                        type: {
+                            vec: {
+                                defined: 'OutputCompressedAccountWithPackedContext';
+                            };
+                        };
+                    },
                     {
-                        name: 'merkleTreePubkeyIndex';
-                        type: 'u8';
+                        name: 'relayFee';
+                        type: {
+                            option: 'u64';
+                        };
                     },
                     {
-                        name: 'nullifierQueuePubkeyIndex';
-                        type: 'u8';
+                        name: 'newAddressParams';
+                        type: {
+                            vec: {
+                                defined: 'NewAddressParamsPacked';
+                            };
+                        };
                     },
                     {
-                        name: 'leafIndex';
-                        type: 'u32';
+                        name: 'compressOrDecompressLamports';
+                        type: {
+                            option: 'u64';
+                        };
+                    },
+                    {
+                        name: 'isCompress';
+                        type: 'bool';
                     }
                 ];
             };
         },
         {
-            name: 'CompressedAccount';
+            name: 'InstructionDataInvokeCpi';
             type: {
                 kind: 'struct';
                 fields: [
                     {
-                        name: 'owner';
-                        type: 'publicKey';
+                        name: 'proof';
+                        type: {
+                            option: {
+                                defined: 'CompressedProof';
+                            };
+                        };
                     },
                     {
-                        name: 'lamports';
-                        type: 'u64';
+                        name: 'newAddressParams';
+                        type: {
+                            vec: {
+                                defined: 'NewAddressParamsPacked';
+                            };
+                        };
                     },
                     {
-                        name: 'address';
+                        name: 'inputCompressedAccountsWithMerkleContext';
                         type: {
-                            option: {
-                                array: ['u8', 32];
+                            vec: {
+                                defined: 'PackedCompressedAccountWithMerkleContext';
                             };
                         };
                     },
                     {
-                        name: 'data';
+                        name: 'outputCompressedAccounts';
+                        type: {
+                            vec: {
+                                defined: 'OutputCompressedAccountWithPackedContext';
+                            };
+                        };
+                    },
+                    {
+                        name: 'relayFee';
+                        type: {
+                            option: 'u64';
+                        };
+                    },
+                    {
+                        name: 'compressOrDecompressLamports';
+                        type: {
+                            option: 'u64';
+                        };
+                    },
+                    {
+                        name: 'isCompress';
+                        type: 'bool';
+                    },
+                    {
+                        name: 'signerSeeds';
+                        type: {
+                            vec: 'bytes';
+                        };
+                    },
+                    {
+                        name: 'cpiContext';
                         type: {
                             option: {
-                                defined: 'CompressedAccountData';
+                                defined: 'CompressedCpiContext';
                             };
                         };
                     }
@@ -582,237 +1025,285 @@ type LightCompressedToken = {
             };
         },
         {
-            name: 'CompressedAccountData';
+            name: 'MerkleTreeMetadata';
             type: {
                 kind: 'struct';
                 fields: [
                     {
-                        name: 'discriminator';
+                        name: 'accessMetadata';
                         type: {
-                            array: ['u8', 8];
+                            defined: 'AccessMetadata';
                         };
                     },
                     {
-                        name: 'data';
-                        type: 'bytes';
-                    },
-                    {
-                        name: 'dataHash';
+                        name: 'rolloverMetadata';
                         type: {
-                            array: ['u8', 32];
+                            defined: 'RolloverMetadata';
                         };
+                    },
+                    {
+                        name: 'associatedQueue';
+                        type: 'publicKey';
+                    },
+                    {
+                        name: 'nextMerkleTree';
+                        type: 'publicKey';
                     }
                 ];
             };
         },
         {
-            name: 'PublicTransactionEvent';
+            name: 'MerkleTreeSequenceNumber';
             type: {
                 kind: 'struct';
                 fields: [
                     {
-                        name: 'inputCompressedAccountHashes';
-                        type: {
-                            vec: {
-                                array: ['u8', 32];
-                            };
-                        };
+                        name: 'pubkey';
+                        type: 'publicKey';
                     },
                     {
-                        name: 'outputCompressedAccountHashes';
-                        type: {
-                            vec: {
-                                array: ['u8', 32];
-                            };
-                        };
-                    },
+                        name: 'seq';
+                        type: 'u64';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'NewAddressParamsPacked';
+            type: {
+                kind: 'struct';
+                fields: [
                     {
-                        name: 'outputCompressedAccounts';
+                        name: 'seed';
                         type: {
-                            vec: {
-                                defined: 'CompressedAccount';
-                            };
+                            array: ['u8', 32];
                         };
                     },
                     {
-                        name: 'outputStateMerkleTreeAccountIndices';
-                        type: 'bytes';
+                        name: 'addressQueueAccountIndex';
+                        type: 'u8';
                     },
                     {
-                        name: 'outputLeafIndices';
-                        type: {
-                            vec: 'u32';
-                        };
+                        name: 'addressMerkleTreeAccountIndex';
+                        type: 'u8';
                     },
                     {
-                        name: 'relayFee';
+                        name: 'addressMerkleTreeRootIndex';
+                        type: 'u16';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'OutputCompressedAccountWithPackedContext';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'compressedAccount';
                         type: {
-                            option: 'u64';
+                            defined: 'CompressedAccount';
                         };
                     },
                     {
-                        name: 'isCompress';
-                        type: 'bool';
-                    },
+                        name: 'merkleTreeIndex';
+                        type: 'u8';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'PackedCompressedAccountWithMerkleContext';
+            type: {
+                kind: 'struct';
+                fields: [
                     {
-                        name: 'compressionLamports';
+                        name: 'compressedAccount';
                         type: {
-                            option: 'u64';
+                            defined: 'CompressedAccount';
                         };
                     },
                     {
-                        name: 'pubkeyArray';
+                        name: 'merkleContext';
                         type: {
-                            vec: 'publicKey';
+                            defined: 'PackedMerkleContext';
                         };
                     },
                     {
-                        name: 'message';
-                        type: {
-                            option: 'bytes';
-                        };
+                        name: 'rootIndex';
+                        docs: [
+                            'Index of root used in inclusion validity proof.'
+                        ];
+                        type: 'u16';
                     }
                 ];
             };
         },
         {
-            name: 'CompressedCpiContext';
+            name: 'PackedMerkleContext';
             type: {
                 kind: 'struct';
                 fields: [
                     {
-                        name: 'setContext';
-                        type: 'bool';
+                        name: 'merkleTreePubkeyIndex';
+                        type: 'u8';
                     },
                     {
-                        name: 'cpiContextAccountIndex';
+                        name: 'nullifierQueuePubkeyIndex';
                         type: 'u8';
+                    },
+                    {
+                        name: 'leafIndex';
+                        type: 'u32';
                     }
                 ];
             };
         },
         {
-            name: 'InputTokenDataWithContext';
+            name: 'PackedTokenTransferOutputData';
             type: {
                 kind: 'struct';
                 fields: [
                     {
-                        name: 'amount';
-                        type: 'u64';
-                    },
-                    {
-                        name: 'delegateIndex';
-                        type: {
-                            option: 'u8';
-                        };
+                        name: 'owner';
+                        type: 'publicKey';
                     },
                     {
-                        name: 'delegatedAmount';
-                        type: {
-                            option: 'u64';
-                        };
+                        name: 'amount';
+                        type: 'u64';
                     },
                     {
-                        name: 'isNative';
+                        name: 'lamports';
                         type: {
                             option: 'u64';
                         };
                     },
                     {
-                        name: 'merkleContext';
-                        type: {
-                            defined: 'PackedMerkleContext';
-                        };
+                        name: 'merkleTreeIndex';
+                        type: 'u8';
                     }
                 ];
             };
         },
         {
-            name: 'CompressedTokenInstructionDataTransfer';
+            name: 'PublicTransactionEvent';
             type: {
                 kind: 'struct';
                 fields: [
                     {
-                        name: 'proof';
+                        name: 'inputCompressedAccountHashes';
                         type: {
-                            option: {
-                                defined: 'CompressedProof';
+                            vec: {
+                                array: ['u8', 32];
                             };
                         };
                     },
                     {
-                        name: 'rootIndices';
+                        name: 'outputCompressedAccountHashes';
                         type: {
-                            vec: 'u16';
+                            vec: {
+                                array: ['u8', 32];
+                            };
                         };
                     },
                     {
-                        name: 'mint';
-                        type: 'publicKey';
-                    },
-                    {
-                        name: 'signerIsDelegate';
-                        type: 'bool';
-                    },
-                    {
-                        name: 'inputTokenDataWithContext';
+                        name: 'outputCompressedAccounts';
                         type: {
                             vec: {
-                                defined: 'InputTokenDataWithContext';
+                                defined: 'OutputCompressedAccountWithPackedContext';
                             };
                         };
                     },
                     {
-                        name: 'outputCompressedAccounts';
+                        name: 'outputLeafIndices';
+                        type: {
+                            vec: 'u32';
+                        };
+                    },
+                    {
+                        name: 'sequenceNumbers';
                         type: {
                             vec: {
-                                defined: 'TokenTransferOutputData';
+                                defined: 'MerkleTreeSequenceNumber';
                             };
                         };
                     },
                     {
-                        name: 'outputStateMerkleTreeAccountIndices';
-                        type: 'bytes';
+                        name: 'relayFee';
+                        type: {
+                            option: 'u64';
+                        };
                     },
                     {
                         name: 'isCompress';
                         type: 'bool';
                     },
                     {
-                        name: 'compressionAmount';
+                        name: 'compressOrDecompressLamports';
                         type: {
                             option: 'u64';
                         };
                     },
                     {
-                        name: 'cpiContext';
+                        name: 'pubkeyArray';
                         type: {
-                            option: {
-                                defined: 'CompressedCpiContext';
-                            };
+                            vec: 'publicKey';
+                        };
+                    },
+                    {
+                        name: 'message';
+                        type: {
+                            option: 'bytes';
                         };
                     }
                 ];
             };
         },
         {
-            name: 'TokenTransferOutputData';
+            name: 'RolloverMetadata';
             type: {
                 kind: 'struct';
                 fields: [
                     {
-                        name: 'owner';
-                        type: 'publicKey';
+                        name: 'index';
+                        docs: ['Unique index.'];
+                        type: 'u64';
                     },
                     {
-                        name: 'amount';
+                        name: 'rolloverFee';
+                        docs: [
+                            'This fee is used for rent for the next account.',
+                            'It accumulates in the account so that once the corresponding Merkle tree account is full it can be rolled over'
+                        ];
                         type: 'u64';
                     },
                     {
-                        name: 'lamports';
-                        type: {
-                            option: 'u64';
-                        };
+                        name: 'rolloverThreshold';
+                        docs: [
+                            'The threshold in percentage points when the account should be rolled over (95 corresponds to 95% filled).'
+                        ];
+                        type: 'u64';
+                    },
+                    {
+                        name: 'networkFee';
+                        docs: ['Tip for maintaining the account.'];
+                        type: 'u64';
+                    },
+                    {
+                        name: 'rolledoverSlot';
+                        docs: [
+                            'The slot when the account was rolled over, a rolled over account should not be written to.'
+                        ];
+                        type: 'u64';
+                    },
+                    {
+                        name: 'closeThreshold';
+                        docs: [
+                            'If current slot is greater than rolledover_slot + close_threshold and',
+                            "the account is empty it can be closed. No 'close' functionality has been",
+                            'implemented yet.'
+                        ];
+                        type: 'u64';
                     }
                 ];
             };
@@ -865,78 +1356,6 @@ type LightCompressedToken = {
                         type: {
                             option: 'u64';
                         };
-                    },
-                    {
-                        name: 'delegatedAmount';
-                        docs: ['The amount delegated'];
-                        type: 'u64';
-                    }
-                ];
-            };
-        },
-        {
-            name: 'AccountState';
-            type: {
-                kind: 'enum';
-                variants: [
-                    {
-                        name: 'Initialized';
-                    },
-                    {
-                        name: 'Frozen';
-                    }
-                ];
-            };
-        },
-        {
-            name: 'ErrorCode';
-            type: {
-                kind: 'enum';
-                variants: [
-                    {
-                        name: 'PublicKeyAmountMissmatch';
-                    },
-                    {
-                        name: 'MissingNewAuthorityPda';
-                    },
-                    {
-                        name: 'SignerCheckFailed';
-                    },
-                    {
-                        name: 'MintCheckFailed';
-                    },
-                    {
-                        name: 'ComputeInputSumFailed';
-                    },
-                    {
-                        name: 'ComputeOutputSumFailed';
-                    },
-                    {
-                        name: 'ComputeCompressSumFailed';
-                    },
-                    {
-                        name: 'ComputeDecompressSumFailed';
-                    },
-                    {
-                        name: 'SumCheckFailed';
-                    },
-                    {
-                        name: 'DecompressRecipientUndefinedForDecompress';
-                    },
-                    {
-                        name: 'CompressedPdaUndefinedForDecompress';
-                    },
-                    {
-                        name: 'DeCompressAmountUndefinedForDecompress';
-                    },
-                    {
-                        name: 'CompressedPdaUndefinedForCompress';
-                    },
-                    {
-                        name: 'DeCompressAmountUndefinedForCompress';
-                    },
-                    {
-                        name: 'DelegateUndefined';
                     }
                 ];
             };
@@ -945,23 +1364,237 @@ type LightCompressedToken = {
     errors: [
         {
             code: 6000;
-            name: 'SignerCheckFailed';
-            msg: 'Signer check failed';
+            name: 'PublicKeyAmountMissmatch';
+            msg: 'public keys and amounts must be of same length';
         },
         {
             code: 6001;
-            name: 'CreateTransferInstructionFailed';
-            msg: 'Create transfer instruction failed';
+            name: 'SignerCheckFailed';
+            msg: 'SignerCheckFailed';
+        },
+        {
+            code: 6002;
+            name: 'ComputeInputSumFailed';
+            msg: 'ComputeInputSumFailed';
+        },
+        {
+            code: 6003;
+            name: 'ComputeOutputSumFailed';
+            msg: 'ComputeOutputSumFailed';
+        },
+        {
+            code: 6004;
+            name: 'ComputeCompressSumFailed';
+            msg: 'ComputeCompressSumFailed';
+        },
+        {
+            code: 6005;
+            name: 'ComputeDecompressSumFailed';
+            msg: 'ComputeDecompressSumFailed';
+        },
+        {
+            code: 6006;
+            name: 'SumCheckFailed';
+            msg: 'SumCheckFailed';
+        },
+        {
+            code: 6007;
+            name: 'DecompressRecipientUndefinedForDecompress';
+            msg: 'DecompressRecipientUndefinedForDecompress';
+        },
+        {
+            code: 6008;
+            name: 'CompressedPdaUndefinedForDecompress';
+            msg: 'CompressedPdaUndefinedForDecompress';
+        },
+        {
+            code: 6009;
+            name: 'DeCompressAmountUndefinedForDecompress';
+            msg: 'DeCompressAmountUndefinedForDecompress';
+        },
+        {
+            code: 6010;
+            name: 'CompressedPdaUndefinedForCompress';
+            msg: 'CompressedPdaUndefinedForCompress';
+        },
+        {
+            code: 6011;
+            name: 'DeCompressAmountUndefinedForCompress';
+            msg: 'DeCompressAmountUndefinedForCompress';
+        },
+        {
+            code: 6012;
+            name: 'DelegateUndefined';
+            msg: 'DelegateUndefined while delegated amount is defined';
+        },
+        {
+            code: 6013;
+            name: 'DelegateSignerCheckFailed';
+            msg: 'DelegateSignerCheckFailed';
+        },
+        {
+            code: 6014;
+            name: 'SplTokenSupplyMismatch';
+            msg: 'SplTokenSupplyMismatch';
+        },
+        {
+            code: 6015;
+            name: 'HeapMemoryCheckFailed';
+            msg: 'HeapMemoryCheckFailed';
+        },
+        {
+            code: 6016;
+            name: 'InstructionNotCallable';
+            msg: 'The instruction is not callable';
+        },
+        {
+            code: 6017;
+            name: 'ArithmeticUnderflow';
+            msg: 'ArithmeticUnderflow';
+        },
+        {
+            code: 6018;
+            name: 'InvalidDelegate';
+            msg: 'InvalidDelegate';
+        },
+        {
+            code: 6019;
+            name: 'HashToFieldError';
+            msg: 'HashToFieldError';
+        },
+        {
+            code: 6020;
+            name: 'InvalidMint';
+            msg: 'InvalidMint';
         }
     ];
 };
-declare const IDL: LightCompressedToken;
+declare const IDL: LightCompressedToken;
+
+type TokenTransferOutputData = {
+    /**
+     * The owner of the output token account
+     */
+    owner: PublicKey;
+    /**
+     * The amount of tokens of the output token account
+     */
+    amount: BN;
+    /**
+     * lamports associated with the output token account
+     */
+    lamports: BN | null;
+};
+type PackedTokenTransferOutputData = {
+    /**
+     * The owner of the output token account
+     */
+    owner: PublicKey;
+    /**
+     * The amount of tokens of the output token account
+     */
+    amount: BN;
+    /**
+     * lamports associated with the output token account
+     */
+    lamports: BN | null;
+    /**
+     * Merkle tree pubkey index in remaining accounts
+     */
+    merkleTreeIndex: number;
+};
+type InputTokenDataWithContext = {
+    /**
+     * The amount of tokens to transfer
+     */
+    amount: BN;
+    /**
+     * Optional: The index of the delegate in remaining accounts
+     */
+    delegateIndex: number | null;
+    /**
+     * Optional: Whether the token is native (wSOL)
+     */
+    isNative: BN | null;
+    /**
+     * The index of the merkle tree address in remaining accounts
+     */
+    merkleTreePubkeyIndex: number;
+    /**
+     * The index of the nullifier queue address in remaining accounts
+     */
+    nullifierQueuePubkeyIndex: number;
+    /**
+     * The index of the leaf in the merkle tree
+     */
+    leafIndex: number;
+};
+type CompressedTokenInstructionDataInvoke = {
+    /**
+     * Validity proof
+     */
+    proof: CompressedProof | null;
+    /**
+     * The root indices of the transfer
+     */
+    rootIndices: number[];
+    /**
+     * The mint of the transfer
+     */
+    mint: PublicKey;
+    /**
+     * Whether the signer is a delegate
+     * TODO: implement delegated transfer struct
+     */
+    delegatedTransfer: null;
+    /**
+     * Input token data with packed merkle context
+     */
+    inputTokenDataWithContext: InputTokenDataWithContext[];
+    /**
+     * Data of the output token accounts
+     */
+    outputCompressedAccounts: TokenTransferOutputData[];
+    /**
+     * The indices of the output state merkle tree accounts in 'remaining
+     * accounts'
+     */
+    outputStateMerkleTreeAccountIndices: Buffer;
+};
+type TokenData = {
+    /**
+     * The mint associated with this account
+     */
+    mint: PublicKey;
+    /**
+     * The owner of this account
+     */
+    owner: PublicKey;
+    /**
+     * The amount of tokens this account holds
+     */
+    amount: BN;
+    /**
+     * If `delegate` is `Some` then `delegated_amount` represents the amount
+     * authorized by the delegate
+     */
+    delegate: PublicKey | null;
+    /**
+     * The account's state
+     */
+    state: number;
+    /**
+     * If is_some, this is a native token, and the value logs the rent-exempt
+     * reserve. An Account is required to be rent-exempt, so the value is used
+     * by the Processor to ensure that wrapped SOL accounts do not drop below
+     * this threshold.
+     */
+    isNative: BN | null;
+};
 
 type PackCompressedTokenAccountsParams = {
     /** Input state to be consumed */
     inputCompressedTokenAccounts: ParsedTokenAccount[];
-    /** Length of output compressed accounts */
-    outputCompressedAccountsLength: number;
     /**
      * 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
@@ -970,19 +1603,24 @@ type PackCompressedTokenAccountsParams = {
     outputStateTrees?: PublicKey[] | PublicKey;
     /** Optional remaining accounts to append to */
     remainingAccounts?: PublicKey[];
+    /**
+     *  Root indices that are used on-chain to fetch the correct root
+     *  from the state Merkle tree account for validity proof verification.
+     */
+    rootIndices: number[];
+    tokenTransferOutputs: TokenTransferOutputData$1[];
 };
 /**
  * Packs Compressed Token Accounts.
  */
 declare function packCompressedTokenAccounts(params: PackCompressedTokenAccountsParams): {
     inputTokenDataWithContext: InputTokenDataWithContext$1[];
-    outputStateMerkleTreeIndices: number[];
     remainingAccountMetas: AccountMeta[];
+    packedOutputTokenData: PackedTokenTransferOutputData[];
 };
 
 declare const POOL_SEED: Buffer;
 declare const CPI_AUTHORITY_SEED: Buffer;
-declare const MINT_AUTHORITY_SEED: Uint8Array;
 declare const SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE = 1461600;
 
 type CompressParams = {
@@ -1011,9 +1649,10 @@ type CompressParams = {
      */
     amount: number | BN;
     /**
-     * The state tree that the tx output should be inserted into.
+     * The state tree that the tx output should be inserted into. Defaults to a
+     * public state tree if unspecified.
      */
-    outputStateTree: PublicKey;
+    outputStateTree?: PublicKey;
 };
 type DecompressParams = {
     /**
@@ -1032,10 +1671,6 @@ type DecompressParams = {
      * amount of tokens to decompress.
      */
     amount: number | BN;
-    /**
-     * The state tree that the change tx output should be inserted into.
-     */
-    outputStateTree: PublicKey;
     /**
      * The recent state root indices of the input state. The expiry is tied to
      * the proof.
@@ -1046,6 +1681,11 @@ type DecompressParams = {
      * expires after n slots.
      */
     recentValidityProof: CompressedProof;
+    /**
+     * The state tree that the change tx output should be inserted into.
+     * Defaults to a public state tree if unspecified.
+     */
+    outputStateTree?: PublicKey;
 };
 type TransferParams = {
     /**
@@ -1086,35 +1726,60 @@ type TransferParams = {
  * Create Mint account for compressed Tokens
  */
 type CreateMintParams = {
-    /** Tx feepayer */
+    /**
+     * Tx feepayer
+     */
     feePayer: PublicKey;
-    /** Mint authority */
+    /**
+     * Mint authority
+     */
     authority: PublicKey;
-    /** Mint public key */
+    /**
+     * Mint public key
+     */
     mint: PublicKey;
-    /** Mint decimals */
+    /**
+     * Mint decimals
+     */
     decimals: number;
-    /** Optional: freeze authority */
+    /**
+     * Optional: freeze authority
+     */
     freezeAuthority: PublicKey | null;
-    /** lamport amount for mint account rent exemption */
+    /**
+     * lamport amount for mint account rent exemption
+     */
     rentExemptBalance: number;
 };
 /**
  * Create compressed token accounts
  */
 type MintToParams = {
-    /** Tx feepayer */
+    /**
+     * Tx feepayer
+     */
     feePayer: PublicKey;
-    /** Mint authority */
+    /**
+     * Mint authority
+     */
     authority: PublicKey;
-    /** Mint public key */
+    /**
+     * Mint public key
+     */
     mint: PublicKey;
-    /** The Solana Public Keys to mint to. Accepts batches */
+    /**
+     * The Solana Public Keys to mint to.
+     */
     toPubkey: PublicKey[] | PublicKey;
-    /** The amount of compressed tokens to mint. Accepts batches */
+    /**
+     * The amount of compressed tokens to mint.
+     */
     amount: BN | BN[] | number | number[];
-    /** Public key of the state tree to mint into. */
-    merkleTree: PublicKey;
+    /**
+     * Public key of the state tree to mint into. Defaults to a public state
+     * tree if unspecified.
+     */
+    merkleTree?: PublicKey;
 };
 /**
  * Register an existing SPL mint account to the compressed token program
@@ -1123,8 +1788,6 @@ type MintToParams = {
 type RegisterMintParams = {
     /** Tx feepayer */
     feePayer: PublicKey;
-    /** Mint authority */
-    authority: PublicKey;
     /** Mint public key */
     mint: PublicKey;
 };
@@ -1132,20 +1795,35 @@ type RegisterMintParams = {
  * Mint from existing SPL mint to compressed token accounts
  */
 type ApproveAndMintToParams = {
-    /** Tx feepayer */
+    /**
+     * Tx feepayer
+     */
     feePayer: PublicKey;
-    /** Mint authority */
+    /**
+     * Mint authority
+     */
     authority: PublicKey;
-    /** Mint authority (associated) token account */
+    /**
+     * Mint authority (associated) token account
+     */
     authorityTokenAccount: PublicKey;
-    /** Mint public key */
+    /**
+     * Mint public key
+     */
     mint: PublicKey;
-    /** The Solana Public Key to mint to. */
+    /**
+     * The Solana Public Key to mint to.
+     */
     toPubkey: PublicKey;
-    /** The amount of compressed tokens to mint. */
+    /**
+     * The amount of compressed tokens to mint.
+     */
     amount: BN | number;
-    /** Public key of the state tree to mint into. */
-    merkleTree: PublicKey;
+    /**
+     * Public key of the state tree to mint into. Defaults to a public state
+     * tree if unspecified.
+     */
+    merkleTree?: PublicKey;
 };
 /**
  * Sum up the token amounts of the compressed token accounts
@@ -1198,8 +1876,6 @@ declare class CompressedTokenProgram {
      */
     private static initializeProgram;
     /** @internal */
-    static deriveMintAuthorityPda: (authority: PublicKey, mint: PublicKey) => [PublicKey, number];
-    /** @internal */
     static deriveTokenPoolPda(mint: PublicKey): PublicKey;
     /** @internal */
     static get deriveCpiAuthorityPda(): PublicKey;
@@ -1211,7 +1887,7 @@ declare class CompressedTokenProgram {
      * Enable compression for an existing SPL mint, creating an omnibus account.
      * For new mints, use `CompressedTokenProgram.createMint`.
      */
-    static registerMint(params: RegisterMintParams): Promise<TransactionInstruction[]>;
+    static registerMint(params: RegisterMintParams): Promise<TransactionInstruction>;
     /**
      * Construct mintTo instruction for compressed tokens
      */
@@ -1235,116 +1911,6 @@ declare class CompressedTokenProgram {
     static decompress(params: DecompressParams): Promise<TransactionInstruction>;
 }
 
-type TokenTransferOutputData = {
-    /**
-     * The owner of the output token account
-     */
-    owner: PublicKey;
-    /**
-     * The amount of tokens of the output token account
-     */
-    amount: BN;
-    /**
-     * lamports associated with the output token account
-     */
-    lamports: BN | null;
-};
-type InputTokenDataWithContext = {
-    /**
-     * The amount of tokens to transfer
-     */
-    amount: BN;
-    /**
-     * Optional: The index of the delegate in remaining accounts
-     */
-    delegateIndex: number | null;
-    /**
-     * Optional: The amount of delegated tokens
-     */
-    delegatedAmount: BN | null;
-    /**
-     * Optional: Whether the token is native (wSOL)
-     */
-    isNative: BN | null;
-    /**
-     * The index of the merkle tree address in remaining accounts
-     */
-    merkleTreePubkeyIndex: number;
-    /**
-     * The index of the nullifier queue address in remaining accounts
-     */
-    nullifierQueuePubkeyIndex: number;
-    /**
-     * The index of the leaf in the merkle tree
-     */
-    leafIndex: number;
-};
-type CompressedTokenInstructionDataInvoke = {
-    /**
-     * Validity proof
-     */
-    proof: CompressedProof | null;
-    /**
-     * The root indices of the transfer
-     */
-    rootIndices: number[];
-    /**
-     * The mint of the transfer
-     */
-    mint: PublicKey;
-    /**
-     * Whether the signer is a delegate
-     */
-    signerIsDelegate: boolean;
-    /**
-     * Input token data with packed merkle context
-     */
-    inputTokenDataWithContext: InputTokenDataWithContext[];
-    /**
-     * Data of the output token accounts
-     */
-    outputCompressedAccounts: TokenTransferOutputData[];
-    /**
-     * The indices of the output state merkle tree accounts in 'remaining
-     * accounts'
-     */
-    outputStateMerkleTreeAccountIndices: Buffer;
-};
-type TokenData = {
-    /**
-     * The mint associated with this account
-     */
-    mint: PublicKey;
-    /**
-     * The owner of this account
-     */
-    owner: PublicKey;
-    /**
-     * The amount of tokens this account holds
-     */
-    amount: BN;
-    /**
-     * If `delegate` is `Some` then `delegated_amount` represents the amount
-     * authorized by the delegate
-     */
-    delegate: PublicKey | null;
-    /**
-     * The account's state
-     */
-    state: number;
-    /**
-     * If is_some, this is a native token, and the value logs the rent-exempt
-     * reserve. An Account is required to be rent-exempt, so the value is used
-     * by the Processor to ensure that wrapped SOL accounts do not drop below
-     * this threshold.
-     */
-    isNative: BN | null;
-    /**
-     * The amount delegated
-     */
-    delegatedAmount: BN;
-};
-
 /**
  * Mint compressed tokens to a solana address from an external mint authority
  *
@@ -1407,14 +1973,14 @@ declare function decompress(rpc: Rpc, payer: Signer, mint: PublicKey, amount: nu
  *
  * @param rpc             RPC to use
  * @param payer           Payer of the transaction and initialization fees
- * @param mintAuthority   Account or multisig that will control minting. Is signer.
+ * @param mintAuthority   Account or multisig that will control minting
  * @param decimals        Location of the decimal place
  * @param keypair         Optional keypair, defaulting to a new random one
  * @param confirmOptions  Options for confirming the transaction
  *
  * @return Address of the new mint and the transaction signature
  */
-declare function createMint(rpc: Rpc, payer: Signer, mintAuthority: Signer, decimals: number, keypair?: Keypair, confirmOptions?: ConfirmOptions): Promise<{
+declare function createMint(rpc: Rpc, payer: Signer, mintAuthority: PublicKey, decimals: number, keypair?: Keypair, confirmOptions?: ConfirmOptions): Promise<{
     mint: PublicKey;
     transactionSignature: TransactionSignature;
 }>;
@@ -1434,8 +2000,7 @@ declare function createMint(rpc: Rpc, payer: Signer, mintAuthority: Signer, deci
  *
  * @return Signature of the confirmed transaction
  */
-declare function mintTo(rpc: Rpc, payer: Signer, mint: PublicKey, destination: PublicKey, authority: Signer, amount: number | BN, merkleTree?: PublicKey, // DEFAULT IF NOT PROVIDED
-confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+declare function mintTo(rpc: Rpc, payer: Signer, mint: PublicKey, destination: PublicKey, authority: Signer, amount: number | BN, merkleTree?: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Register an existing mint with the CompressedToken program
@@ -1448,7 +2013,7 @@ confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
  *
  * @return transaction signature
  */
-declare function registerMint(rpc: Rpc, payer: Signer, mintAuthority: Signer, mintAddress: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+declare function registerMint(rpc: Rpc, payer: Signer, mintAddress: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
 /**
  * Transfer compressed tokens from one owner to another
@@ -1460,7 +2025,8 @@ declare function registerMint(rpc: Rpc, payer: Signer, mintAuthority: Signer, mi
  * @param owner          Owner of the compressed tokens
  * @param toAddress      Destination address of the recipient
  * @param merkleTree     State tree account that the compressed tokens should be
- *                       inserted into. Defaults to the default state tree account.
+ *                       inserted into. Defaults to the default state tree
+ *                       account.
  * @param confirmOptions Options for confirming the transaction
  *
  *
@@ -1480,4 +2046,4 @@ declare function selectMinCompressedTokenAccountsForTransfer(accounts: ParsedTok
     totalLamports: BN | null
 ];
 
-export { type ApproveAndMintToParams, CPI_AUTHORITY_SEED, type CompressedTokenInstructionDataInvoke, CompressedTokenProgram, type CreateMintParams, IDL, type InputTokenDataWithContext, type LightCompressedToken, MINT_AUTHORITY_SEED, type MintToParams, POOL_SEED, type PackCompressedTokenAccountsParams, type RegisterMintParams, SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE, type TokenData, type TokenTransferOutputData, type TransferParams, approveAndMintTo, compress, createDecompressOutputState, createMint, createTransferOutputState, decompress, mintTo, packCompressedTokenAccounts, parseTokenData, registerMint, selectMinCompressedTokenAccountsForTransfer, sumUpTokenAmount, transfer, validateSameTokenOwner };
+export { type ApproveAndMintToParams, CPI_AUTHORITY_SEED, type CompressedTokenInstructionDataInvoke, CompressedTokenProgram, type CreateMintParams, IDL, type InputTokenDataWithContext, type LightCompressedToken, type MintToParams, POOL_SEED, type PackCompressedTokenAccountsParams, type PackedTokenTransferOutputData, type RegisterMintParams, SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE, type TokenData, type TokenTransferOutputData, type TransferParams, approveAndMintTo, compress, createDecompressOutputState, createMint, createTransferOutputState, decompress, mintTo, packCompressedTokenAccounts, parseTokenData, registerMint, selectMinCompressedTokenAccountsForTransfer, sumUpTokenAmount, transfer, validateSameTokenOwner };