@lightprotocol/compressed-token 0.1.3 → 0.3.0

package/dist/es/browser/index.js

@@ -1,24 +1,18 @@
-import { getIndexOrAdd, bn, padOutputStateMerkleTrees, useWallet, confirmConfig, defaultStaticAccountsStruct, toArray, LightSystemProgram, sumUpLamports, validateSufficientBalance, validateSameOwner, dedupeSigner, buildAndSignTx, sendAndConfirmTx, defaultTestStateTreeAccounts } from '@lightprotocol/stateless.js';
-import { utils, AnchorProvider, setProvider, Program } from '@coral-xyz/anchor';
-import { PublicKey, TransactionInstruction, Keypair, Connection, SystemProgram, ComputeBudgetProgram } from '@solana/web3.js';
+import { getIndexOrAdd, padOutputStateMerkleTrees, bn, useWallet, confirmConfig, defaultStaticAccountsStruct, toArray, LightSystemProgram, defaultTestStateTreeAccounts, sumUpLamports, validateSufficientBalance, validateSameOwner, dedupeSigner, buildAndSignTx, sendAndConfirmTx } from '@lightprotocol/stateless.js';
+import { PublicKey, TransactionInstruction, SystemProgram, Transaction, sendAndConfirmTransaction, Keypair, Connection, ComputeBudgetProgram } from '@solana/web3.js';
+import { AnchorProvider, setProvider, Program } from '@coral-xyz/anchor';
 
 const IDL = {
-    version: '0.3.0',
+    version: '0.4.0',
     name: 'light_compressed_token',
-    constants: [
-        {
-            name: 'PROGRAM_ID',
-            type: 'string',
-            value: '"9sixVEthz2kMSKfeApZXHwuboT6DZuT6crAYJTciUCqE"',
-        },
-    ],
     instructions: [
         {
             name: 'createMint',
             docs: [
-                'This instruction expects a mint account to be created in a separate token program instruction',
-                'with token authority as mint authority.',
-                'This instruction creates a token pool account for that mint owned by token authority.',
+                'This instruction expects a mint account to be created in a separate',
+                'token program instruction with token authority as mint authority. This',
+                'instruction creates a token pool account for that mint owned by token',
+                'authority.',
             ],
             accounts: [
                 {
@@ -26,11 +20,6 @@ const IDL = {
                     isMut: true,
                     isSigner: true,
                 },
-                {
-                    name: 'authority',
-                    isMut: true,
-                    isSigner: true,
-                },
                 {
                     name: 'tokenPoolPda',
                     isMut: true,
@@ -46,11 +35,6 @@ const IDL = {
                     isMut: true,
                     isSigner: false,
                 },
-                {
-                    name: 'mintAuthorityPda',
-                    isMut: true,
-                    isSigner: false,
-                },
                 {
                     name: 'tokenProgram',
                     isMut: false,
@@ -66,6 +50,12 @@ const IDL = {
         },
         {
             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',
@@ -74,12 +64,12 @@ const IDL = {
                 },
                 {
                     name: 'authority',
-                    isMut: true,
+                    isMut: false,
                     isSigner: true,
                 },
                 {
-                    name: 'mintAuthorityPda',
-                    isMut: true,
+                    name: 'cpiAuthorityPda',
+                    isMut: false,
                     isSigner: false,
                 },
                 {
@@ -98,13 +88,13 @@ const IDL = {
                     isSigner: false,
                 },
                 {
-                    name: 'compressedPdaProgram',
+                    name: 'lightSystemProgram',
                     isMut: false,
                     isSigner: false,
                 },
                 {
                     name: 'registeredProgramPda',
-                    isMut: true,
+                    isMut: false,
                     isSigner: false,
                 },
                 {
@@ -114,7 +104,7 @@ const IDL = {
                 },
                 {
                     name: 'accountCompressionAuthority',
-                    isMut: true,
+                    isMut: false,
                     isSigner: false,
                 },
                 {
@@ -132,6 +122,11 @@ const IDL = {
                     isMut: false,
                     isSigner: false,
                 },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
             ],
             args: [
                 {
@@ -153,7 +148,7 @@ const IDL = {
             accounts: [
                 {
                     name: 'feePayer',
-                    isMut: false,
+                    isMut: true,
                     isSigner: true,
                 },
                 {
@@ -167,7 +162,7 @@ const IDL = {
                     isSigner: false,
                 },
                 {
-                    name: 'compressedPdaProgram',
+                    name: 'lightSystemProgram',
                     isMut: false,
                     isSigner: false,
                 },
@@ -203,7 +198,7 @@ const IDL = {
                     isOptional: true,
                 },
                 {
-                    name: 'decompressTokenAccount',
+                    name: 'compressOrDecompressTokenAccount',
                     isMut: true,
                     isSigner: false,
                     isOptional: true,
@@ -214,86 +209,476 @@ const IDL = {
                     isSigner: false,
                     isOptional: true,
                 },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
             ],
             args: [
                 {
                     name: 'inputs',
                     type: 'bytes',
                 },
+            ],
+        },
+        {
+            name: 'approve',
+            accounts: [
                 {
-                    name: 'cpiContext',
-                    type: {
-                        option: {
-                            defined: 'CompressedCpiContext',
-                        },
-                    },
+                    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',
                 },
             ],
         },
-    ],
-    types: [
         {
-            name: 'CompressedAccountWithMerkleContext',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'compressedAccount',
-                        type: {
-                            defined: 'CompressedAccount',
-                        },
-                    },
-                    {
-                        name: 'merkleTreePubkeyIndex',
-                        type: 'u8',
-                    },
-                    {
-                        name: 'nullifierQueuePubkeyIndex',
-                        type: 'u8',
-                    },
-                    {
-                        name: 'leafIndex',
-                        type: 'u32',
-                    },
-                ],
-            },
+            name: '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: 'MerkleContext',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'merkleTreePubkey',
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'nullifierQueuePubkey',
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'leafIndex',
-                        type: 'u32',
-                    },
-                ],
-            },
+            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: 'PackedMerkleContext',
-            type: {
+            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: 'merkleTreePubkeyIndex',
-                        type: 'u8',
+                        name: 'registeredProgramId',
+                        type: 'publicKey',
                     },
                     {
-                        name: 'nullifierQueuePubkeyIndex',
-                        type: 'u8',
+                        name: 'groupAuthorityPda',
+                        type: 'publicKey',
                     },
+                ],
+            },
+        },
+    ],
+    types: [
+        {
+            name: 'AccessMetadata',
+            type: {
+                kind: 'struct',
+                fields: [
                     {
-                        name: 'leafIndex',
-                        type: 'u32',
+                        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',
                     },
                 ],
             },
@@ -356,56 +741,81 @@ const IDL = {
         },
         {
             name: 'CompressedCpiContext',
-            docs: ['To spend multiple compressed'],
             type: {
                 kind: 'struct',
                 fields: [
                     {
-                        name: 'cpiSignatureAccountIndex',
-                        docs: [
-                            'index of the output state Merkle tree that will be used to store cpi signatures',
-                            'The transaction will fail if this index is not consistent in your transaction.',
-                        ],
+                        name: 'setContext',
+                        type: 'bool',
+                    },
+                    {
+                        name: 'cpiContextAccountIndex',
                         type: 'u8',
                     },
+                ],
+            },
+        },
+        {
+            name: 'CompressedProof',
+            type: {
+                kind: 'struct',
+                fields: [
                     {
-                        name: 'execute',
-                        docs: [
-                            'The final cpi of your program needs to set execute to true.',
-                            'Execute compressed transaction will verify the proof and execute the transaction if this is true.',
-                            'If this is false the transaction will be stored in the cpi signature account.',
-                        ],
-                        type: 'bool',
+                        name: 'a',
+                        type: {
+                            array: ['u8', 32],
+                        },
+                    },
+                    {
+                        name: 'b',
+                        type: {
+                            array: ['u8', 64],
+                        },
+                    },
+                    {
+                        name: 'c',
+                        type: {
+                            array: ['u8', 32],
+                        },
                     },
                 ],
             },
         },
         {
-            name: 'PublicTransactionEvent',
+            name: 'CompressedTokenInstructionDataTransfer',
             type: {
                 kind: 'struct',
                 fields: [
                     {
-                        name: 'inputCompressedAccountHashes',
+                        name: 'proof',
                         type: {
-                            vec: {
-                                array: ['u8', 32],
+                            option: {
+                                defined: 'CompressedProof',
                             },
                         },
                     },
                     {
-                        name: 'outputCompressedAccountHashes',
+                        name: 'mint',
+                        type: 'publicKey',
+                    },
+                    {
+                        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: {
-                                array: ['u8', 32],
+                            option: {
+                                defined: 'DelegatedTransfer',
                             },
                         },
                     },
                     {
-                        name: 'inputCompressedAccounts',
+                        name: 'inputTokenDataWithContext',
                         type: {
                             vec: {
-                                defined: 'CompressedAccountWithMerkleContext',
+                                defined: 'InputTokenDataWithContext',
                             },
                         },
                     },
@@ -413,53 +823,83 @@ const IDL = {
                         name: 'outputCompressedAccounts',
                         type: {
                             vec: {
-                                defined: 'CompressedAccount',
+                                defined: 'PackedTokenTransferOutputData',
                             },
                         },
                     },
                     {
-                        name: 'outputStateMerkleTreeAccountIndices',
-                        type: 'bytes',
+                        name: 'isCompress',
+                        type: 'bool',
                     },
                     {
-                        name: 'outputLeafIndices',
+                        name: 'compressOrDecompressAmount',
                         type: {
-                            vec: 'u32',
+                            option: 'u64',
                         },
                     },
                     {
-                        name: 'relayFee',
+                        name: 'cpiContext',
                         type: {
-                            option: 'u64',
+                            option: {
+                                defined: 'CompressedCpiContext',
+                            },
                         },
                     },
+                ],
+            },
+        },
+        {
+            name: 'DelegatedTransfer',
+            type: {
+                kind: 'struct',
+                fields: [
                     {
-                        name: 'isCompress',
-                        type: 'bool',
+                        name: 'owner',
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'delegateChangeAccountIndex',
+                        type: 'u8',
+                    },
+                ],
+            },
+        },
+        {
+            name: 'InputTokenDataWithContext',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'amount',
+                        type: 'u64',
                     },
                     {
-                        name: 'compressionLamports',
+                        name: 'delegateIndex',
                         type: {
-                            option: 'u64',
+                            option: 'u8',
                         },
                     },
                     {
-                        name: 'pubkeyArray',
+                        name: 'isNative',
                         type: {
-                            vec: 'publicKey',
+                            option: 'u64',
                         },
                     },
                     {
-                        name: 'message',
+                        name: 'merkleContext',
                         type: {
-                            option: 'bytes',
+                            defined: 'PackedMerkleContext',
                         },
                     },
+                    {
+                        name: 'rootIndex',
+                        type: 'u16',
+                    },
                 ],
             },
         },
         {
-            name: 'InstructionDataTransfer',
+            name: 'InstructionDataInvoke',
             type: {
                 kind: 'struct',
                 fields: [
@@ -471,6 +911,28 @@ const IDL = {
                             },
                         },
                     },
+                    {
+                        name: 'inputCompressedAccountsWithMerkleContext',
+                        type: {
+                            vec: {
+                                defined: 'PackedCompressedAccountWithMerkleContext',
+                            },
+                        },
+                    },
+                    {
+                        name: 'outputCompressedAccounts',
+                        type: {
+                            vec: {
+                                defined: 'OutputCompressedAccountWithPackedContext',
+                            },
+                        },
+                    },
+                    {
+                        name: 'relayFee',
+                        type: {
+                            option: 'u64',
+                        },
+                    },
                     {
                         name: 'newAddressParams',
                         type: {
@@ -480,33 +942,54 @@ const IDL = {
                         },
                     },
                     {
-                        name: 'inputRootIndices',
+                        name: 'compressOrDecompressLamports',
                         type: {
-                            vec: 'u16',
+                            option: 'u64',
                         },
                     },
                     {
-                        name: 'inputCompressedAccountsWithMerkleContext',
+                        name: 'isCompress',
+                        type: 'bool',
+                    },
+                ],
+            },
+        },
+        {
+            name: 'InstructionDataInvokeCpi',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'proof',
+                        type: {
+                            option: {
+                                defined: 'CompressedProof',
+                            },
+                        },
+                    },
+                    {
+                        name: 'newAddressParams',
                         type: {
                             vec: {
-                                defined: 'CompressedAccountWithMerkleContext',
+                                defined: 'NewAddressParamsPacked',
                             },
                         },
                     },
                     {
-                        name: 'outputCompressedAccounts',
+                        name: 'inputCompressedAccountsWithMerkleContext',
                         type: {
                             vec: {
-                                defined: 'CompressedAccount',
+                                defined: 'PackedCompressedAccountWithMerkleContext',
                             },
                         },
                     },
                     {
-                        name: 'outputStateMerkleTreeAccountIndices',
-                        docs: [
-                            'The indices of the accounts in the output state merkle tree.',
-                        ],
-                        type: 'bytes',
+                        name: 'outputCompressedAccounts',
+                        type: {
+                            vec: {
+                                defined: 'OutputCompressedAccountWithPackedContext',
+                            },
+                        },
                     },
                     {
                         name: 'relayFee',
@@ -515,22 +998,72 @@ const IDL = {
                         },
                     },
                     {
-                        name: 'compressionLamports',
+                        name: 'compressOrDecompressLamports',
                         type: {
                             option: 'u64',
                         },
                     },
                     {
-                        name: 'isCompress',
-                        type: 'bool',
+                        name: 'isCompress',
+                        type: 'bool',
+                    },
+                    {
+                        name: 'signerSeeds',
+                        type: {
+                            vec: 'bytes',
+                        },
+                    },
+                    {
+                        name: 'cpiContext',
+                        type: {
+                            option: {
+                                defined: 'CompressedCpiContext',
+                            },
+                        },
+                    },
+                ],
+            },
+        },
+        {
+            name: 'MerkleTreeMetadata',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'accessMetadata',
+                        type: {
+                            defined: 'AccessMetadata',
+                        },
+                    },
+                    {
+                        name: 'rolloverMetadata',
+                        type: {
+                            defined: 'RolloverMetadata',
+                        },
+                    },
+                    {
+                        name: 'associatedQueue',
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'nextMerkleTree',
+                        type: 'publicKey',
+                    },
+                ],
+            },
+        },
+        {
+            name: 'MerkleTreeSequenceNumber',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'pubkey',
+                        type: 'publicKey',
                     },
                     {
-                        name: 'signerSeeds',
-                        type: {
-                            option: {
-                                vec: 'bytes',
-                            },
-                        },
+                        name: 'seq',
+                        type: 'u64',
                     },
                 ],
             },
@@ -562,84 +1095,55 @@ const IDL = {
             },
         },
         {
-            name: 'NewAddressParams',
+            name: 'OutputCompressedAccountWithPackedContext',
             type: {
                 kind: 'struct',
                 fields: [
                     {
-                        name: 'seed',
+                        name: 'compressedAccount',
                         type: {
-                            array: ['u8', 32],
+                            defined: 'CompressedAccount',
                         },
                     },
                     {
-                        name: 'addressQueuePubkey',
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'addressMerkleTreePubkey',
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'addressMerkleTreeRootIndex',
-                        type: 'u16',
+                        name: 'merkleTreeIndex',
+                        type: 'u8',
                     },
                 ],
             },
         },
         {
-            name: 'CompressedProof',
+            name: 'PackedCompressedAccountWithMerkleContext',
             type: {
                 kind: 'struct',
                 fields: [
                     {
-                        name: 'a',
+                        name: 'compressedAccount',
                         type: {
-                            array: ['u8', 32],
+                            defined: 'CompressedAccount',
                         },
                     },
                     {
-                        name: 'b',
+                        name: 'merkleContext',
                         type: {
-                            array: ['u8', 64],
+                            defined: 'PackedMerkleContext',
                         },
                     },
                     {
-                        name: 'c',
-                        type: {
-                            array: ['u8', 32],
-                        },
+                        name: 'rootIndex',
+                        docs: [
+                            'Index of root used in inclusion validity proof.',
+                        ],
+                        type: 'u16',
                     },
                 ],
             },
         },
         {
-            name: 'InputTokenDataWithContext',
+            name: 'PackedMerkleContext',
             type: {
                 kind: 'struct',
                 fields: [
-                    {
-                        name: 'amount',
-                        type: 'u64',
-                    },
-                    {
-                        name: 'delegateIndex',
-                        type: {
-                            option: 'u8',
-                        },
-                    },
-                    {
-                        name: 'delegatedAmount',
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                    {
-                        name: 'isNative',
-                        type: {
-                            option: 'u64',
-                        },
-                    },
                     {
                         name: 'merkleTreePubkeyIndex',
                         type: 'u8',
@@ -656,37 +1160,49 @@ const IDL = {
             },
         },
         {
-            name: 'CompressedTokenInstructionDataTransfer',
+            name: 'PackedTokenTransferOutputData',
             type: {
                 kind: 'struct',
                 fields: [
                     {
-                        name: 'proof',
-                        type: {
-                            option: {
-                                defined: 'CompressedProof',
-                            },
-                        },
+                        name: 'owner',
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'amount',
+                        type: 'u64',
                     },
                     {
-                        name: 'rootIndices',
+                        name: 'lamports',
                         type: {
-                            vec: 'u16',
+                            option: 'u64',
                         },
                     },
                     {
-                        name: 'mint',
-                        type: 'publicKey',
+                        name: 'merkleTreeIndex',
+                        type: 'u8',
                     },
+                ],
+            },
+        },
+        {
+            name: 'PublicTransactionEvent',
+            type: {
+                kind: 'struct',
+                fields: [
                     {
-                        name: 'signerIsDelegate',
-                        type: 'bool',
+                        name: 'inputCompressedAccountHashes',
+                        type: {
+                            vec: {
+                                array: ['u8', 32],
+                            },
+                        },
                     },
                     {
-                        name: 'inputTokenDataWithContext',
+                        name: 'outputCompressedAccountHashes',
                         type: {
                             vec: {
-                                defined: 'InputTokenDataWithContext',
+                                array: ['u8', 32],
                             },
                         },
                     },
@@ -694,227 +1210,152 @@ const IDL = {
                         name: 'outputCompressedAccounts',
                         type: {
                             vec: {
-                                defined: 'TokenTransferOutputData',
+                                defined: 'OutputCompressedAccountWithPackedContext',
                             },
                         },
                     },
                     {
-                        name: 'outputStateMerkleTreeAccountIndices',
-                        type: 'bytes',
-                    },
-                    {
-                        name: 'isCompress',
-                        type: 'bool',
-                    },
-                    {
-                        name: 'compressionAmount',
+                        name: 'outputLeafIndices',
                         type: {
-                            option: 'u64',
+                            vec: 'u32',
                         },
                     },
-                ],
-            },
-        },
-        {
-            name: 'TokenTransferOutputData',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'owner',
-                        type: 'publicKey',
-                    },
                     {
-                        name: 'amount',
-                        type: 'u64',
+                        name: 'sequenceNumbers',
+                        type: {
+                            vec: {
+                                defined: 'MerkleTreeSequenceNumber',
+                            },
+                        },
                     },
                     {
-                        name: 'lamports',
+                        name: 'relayFee',
                         type: {
                             option: 'u64',
                         },
                     },
-                ],
-            },
-        },
-        {
-            name: 'TokenData',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'mint',
-                        docs: ['The mint associated with this account'],
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'owner',
-                        docs: ['The owner of this account.'],
-                        type: 'publicKey',
-                    },
                     {
-                        name: 'amount',
-                        docs: ['The amount of tokens this account holds.'],
-                        type: 'u64',
+                        name: 'isCompress',
+                        type: 'bool',
                     },
                     {
-                        name: 'delegate',
-                        docs: [
-                            'If `delegate` is `Some` then `delegated_amount` represents',
-                            'the amount authorized by the delegate',
-                        ],
+                        name: 'compressOrDecompressLamports',
                         type: {
-                            option: 'publicKey',
+                            option: 'u64',
                         },
                     },
                     {
-                        name: 'state',
-                        docs: ["The account's state"],
+                        name: 'pubkeyArray',
                         type: {
-                            defined: 'AccountState',
+                            vec: 'publicKey',
                         },
                     },
                     {
-                        name: 'isNative',
-                        docs: [
-                            '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.',
-                        ],
+                        name: 'message',
                         type: {
-                            option: 'u64',
+                            option: 'bytes',
                         },
                     },
-                    {
-                        name: 'delegatedAmount',
-                        docs: ['The amount delegated'],
-                        type: 'u64',
-                    },
                 ],
             },
         },
         {
-            name: 'TokenDataClient',
+            name: 'RolloverMetadata',
             type: {
                 kind: 'struct',
                 fields: [
                     {
-                        name: 'mint',
-                        docs: ['The mint associated with this account'],
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'owner',
-                        docs: ['The owner of this account.'],
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'amount',
-                        docs: ['The amount of tokens this account holds.'],
+                        name: 'index',
+                        docs: ['Unique index.'],
                         type: 'u64',
                     },
                     {
-                        name: 'delegate',
+                        name: 'rolloverFee',
                         docs: [
-                            'If `delegate` is `Some` then `delegated_amount` represents',
-                            'the amount authorized by the delegate',
+                            '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: {
-                            option: 'publicKey',
-                        },
-                    },
-                    {
-                        name: 'state',
-                        docs: ["The account's state"],
-                        type: 'u8',
+                        type: 'u64',
                     },
                     {
-                        name: 'isNative',
+                        name: 'rolloverThreshold',
                         docs: [
-                            '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.',
+                            'The threshold in percentage points when the account should be rolled over (95 corresponds to 95% filled).',
                         ],
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                    {
-                        name: 'delegatedAmount',
-                        docs: ['The amount delegated'],
                         type: 'u64',
                     },
-                ],
-            },
-        },
-        {
-            name: 'AccountState',
-            type: {
-                kind: 'enum',
-                variants: [
                     {
-                        name: 'Uninitialized',
+                        name: 'networkFee',
+                        docs: ['Tip for maintaining the account.'],
+                        type: 'u64',
                     },
                     {
-                        name: 'Initialized',
+                        name: 'rolledoverSlot',
+                        docs: [
+                            'The slot when the account was rolled over, a rolled over account should not be written to.',
+                        ],
+                        type: 'u64',
                     },
                     {
-                        name: 'Frozen',
+                        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',
                     },
                 ],
-            },
-        },
-        {
-            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: 'TokenData',
+            type: {
+                kind: 'struct',
+                fields: [
                     {
-                        name: 'DecompressRecipientUndefinedForDecompress',
+                        name: 'mint',
+                        docs: ['The mint associated with this account'],
+                        type: 'publicKey',
                     },
                     {
-                        name: 'CompressedPdaUndefinedForDecompress',
+                        name: 'owner',
+                        docs: ['The owner of this account.'],
+                        type: 'publicKey',
                     },
                     {
-                        name: 'DeCompressAmountUndefinedForDecompress',
+                        name: 'amount',
+                        docs: ['The amount of tokens this account holds.'],
+                        type: 'u64',
                     },
                     {
-                        name: 'CompressedPdaUndefinedForCompress',
+                        name: 'delegate',
+                        docs: [
+                            'If `delegate` is `Some` then `delegated_amount` represents',
+                            'the amount authorized by the delegate',
+                        ],
+                        type: {
+                            option: 'publicKey',
+                        },
                     },
                     {
-                        name: 'DeCompressAmountUndefinedForCompress',
+                        name: 'state',
+                        docs: ["The account's state"],
+                        type: {
+                            defined: 'AccountState',
+                        },
                     },
                     {
-                        name: 'DelegateUndefined',
+                        name: 'isNative',
+                        docs: [
+                            '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.',
+                        ],
+                        type: {
+                            option: 'u64',
+                        },
                     },
                 ],
             },
@@ -923,13 +1364,108 @@ const IDL = {
     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',
         },
     ],
 };
@@ -939,7 +1475,7 @@ const IDL = {
  * Packs Compressed Token Accounts.
  */
 function packCompressedTokenAccounts(params) {
-    const { inputCompressedTokenAccounts, outputCompressedAccountsLength, outputStateTrees, remainingAccounts = [], } = params;
+    const { inputCompressedTokenAccounts, outputStateTrees, remainingAccounts = [], rootIndices, tokenTransferOutputs, } = params;
     const _remainingAccounts = remainingAccounts.slice();
     let delegateIndex = null;
     if (inputCompressedTokenAccounts.length > 0 &&
@@ -950,27 +1486,34 @@ function packCompressedTokenAccounts(params) {
     /// Currently just packs 'delegate' to pubkeyArray
     const packedInputTokenData = [];
     /// pack inputs
-    inputCompressedTokenAccounts.forEach((account) => {
+    inputCompressedTokenAccounts.forEach((account, index) => {
         const merkleTreePubkeyIndex = getIndexOrAdd(_remainingAccounts, account.compressedAccount.merkleTree);
         const nullifierQueuePubkeyIndex = getIndexOrAdd(_remainingAccounts, account.compressedAccount.nullifierQueue);
         packedInputTokenData.push({
             amount: account.parsed.amount,
             delegateIndex,
-            delegatedAmount: account.parsed.delegatedAmount.eq(bn(0))
-                ? null
-                : account.parsed.delegatedAmount,
             isNative: account.parsed.isNative,
-            merkleTreePubkeyIndex,
-            nullifierQueuePubkeyIndex,
-            leafIndex: account.compressedAccount.leafIndex,
+            merkleContext: {
+                merkleTreePubkeyIndex,
+                nullifierQueuePubkeyIndex,
+                leafIndex: account.compressedAccount.leafIndex,
+            },
+            rootIndex: rootIndices[index],
         });
     });
     /// pack output state trees
-    const paddedOutputStateMerkleTrees = padOutputStateMerkleTrees(outputStateTrees, outputCompressedAccountsLength, inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
-    const outputStateMerkleTreeIndices = [];
-    paddedOutputStateMerkleTrees.forEach(account => {
-        const indexMerkleTree = getIndexOrAdd(_remainingAccounts, account);
-        outputStateMerkleTreeIndices.push(indexMerkleTree);
+    const paddedOutputStateMerkleTrees = padOutputStateMerkleTrees(outputStateTrees, tokenTransferOutputs.length, inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
+    const packedOutputTokenData = [];
+    paddedOutputStateMerkleTrees.forEach((account, index) => {
+        const merkleTreeIndex = getIndexOrAdd(_remainingAccounts, account);
+        packedOutputTokenData.push({
+            owner: tokenTransferOutputs[index].owner,
+            amount: tokenTransferOutputs[index].amount,
+            lamports: tokenTransferOutputs[index].lamports?.eq(bn(0))
+                ? null
+                : tokenTransferOutputs[index].lamports,
+            merkleTreeIndex,
+        });
     });
     // to meta
     const remainingAccountMetas = _remainingAccounts.map((account) => ({
@@ -980,14 +1523,13 @@ function packCompressedTokenAccounts(params) {
     }));
     return {
         inputTokenDataWithContext: packedInputTokenData,
-        outputStateMerkleTreeIndices,
         remainingAccountMetas,
+        packedOutputTokenData,
     };
 }
 
 const POOL_SEED = Buffer.from('pool');
 const CPI_AUTHORITY_SEED = Buffer.from('cpi_authority');
-const MINT_AUTHORITY_SEED = utils.bytes.utf8.encode('mint_authority_pda');
 const SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE = 1461600;
 
 /** Address of the SPL Token program */
@@ -995,7 +1537,7 @@ const TOKEN_PROGRAM_ID = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ
 /** Address of the SPL Token 2022 program */
 new PublicKey('TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb');
 /** Address of the SPL Associated Token Account program */
-new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
+const ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
 /** Address of the special mint for wrapped native SOL in spl-token */
 new PublicKey('So11111111111111111111111111111111111111112');
 /** Address of the special mint for wrapped native SOL in spl-token-2022 */
@@ -5424,6 +5966,62 @@ const publicKey = (property) => {
     return publicKeyLayout;
 };
 
+/** Base class for errors */
+class TokenError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+/** Thrown if an account is not found at the expected address */
+class TokenAccountNotFoundError extends TokenError {
+    constructor() {
+        super(...arguments);
+        this.name = 'TokenAccountNotFoundError';
+    }
+}
+/** Thrown if a program state account is not a valid Account */
+class TokenInvalidAccountError extends TokenError {
+    constructor() {
+        super(...arguments);
+        this.name = 'TokenInvalidAccountError';
+    }
+}
+/** Thrown if a program state account is not owned by the expected token program */
+class TokenInvalidAccountOwnerError extends TokenError {
+    constructor() {
+        super(...arguments);
+        this.name = 'TokenInvalidAccountOwnerError';
+    }
+}
+/** Thrown if the byte length of an program state account doesn't match the expected size */
+class TokenInvalidAccountSizeError extends TokenError {
+    constructor() {
+        super(...arguments);
+        this.name = 'TokenInvalidAccountSizeError';
+    }
+}
+/** Thrown if the mint of a token account doesn't match the expected mint */
+class TokenInvalidMintError extends TokenError {
+    constructor() {
+        super(...arguments);
+        this.name = 'TokenInvalidMintError';
+    }
+}
+/** Thrown if the owner of a token account doesn't match the expected owner */
+class TokenInvalidOwnerError extends TokenError {
+    constructor() {
+        super(...arguments);
+        this.name = 'TokenInvalidOwnerError';
+    }
+}
+/** Thrown if the owner of a token account is a PDA (Program Derived Address) */
+class TokenOwnerOffCurveError extends TokenError {
+    constructor() {
+        super(...arguments);
+        this.name = 'TokenOwnerOffCurveError';
+    }
+}
+
 /** Instructions defined by the program */
 var TokenInstruction;
 (function (TokenInstruction) {
@@ -5463,6 +6061,10 @@ var TokenInstruction;
     TokenInstruction[TokenInstruction["InterestBearingMintExtension"] = 33] = "InterestBearingMintExtension";
     TokenInstruction[TokenInstruction["CpiGuardExtension"] = 34] = "CpiGuardExtension";
     TokenInstruction[TokenInstruction["InitializePermanentDelegate"] = 35] = "InitializePermanentDelegate";
+    TokenInstruction[TokenInstruction["TransferHookExtension"] = 36] = "TransferHookExtension";
+    // ConfidentialTransferFeeExtension = 37,
+    // WithdrawalExcessLamports = 38,
+    TokenInstruction[TokenInstruction["MetadataPointerExtension"] = 39] = "MetadataPointerExtension";
 })(TokenInstruction || (TokenInstruction = {}));
 
 /** @internal */
@@ -5510,6 +6112,112 @@ function createApproveInstruction(account, delegate, owner, amount, multiSigners
     return new TransactionInstruction({ keys, programId, data });
 }
 
+var AccountType;
+(function (AccountType) {
+    AccountType[AccountType["Uninitialized"] = 0] = "Uninitialized";
+    AccountType[AccountType["Mint"] = 1] = "Mint";
+    AccountType[AccountType["Account"] = 2] = "Account";
+})(AccountType || (AccountType = {}));
+const ACCOUNT_TYPE_SIZE = 1;
+
+/** Buffer layout for de/serializing a multisig */
+const MultisigLayout = struct([
+    u8('m'),
+    u8('n'),
+    bool('isInitialized'),
+    publicKey('signer1'),
+    publicKey('signer2'),
+    publicKey('signer3'),
+    publicKey('signer4'),
+    publicKey('signer5'),
+    publicKey('signer6'),
+    publicKey('signer7'),
+    publicKey('signer8'),
+    publicKey('signer9'),
+    publicKey('signer10'),
+    publicKey('signer11'),
+]);
+/** Byte length of a multisig */
+const MULTISIG_SIZE = MultisigLayout.span;
+
+/** Token account state as stored by the program */
+var AccountState;
+(function (AccountState) {
+    AccountState[AccountState["Uninitialized"] = 0] = "Uninitialized";
+    AccountState[AccountState["Initialized"] = 1] = "Initialized";
+    AccountState[AccountState["Frozen"] = 2] = "Frozen";
+})(AccountState || (AccountState = {}));
+/** Buffer layout for de/serializing a token account */
+const AccountLayout = struct([
+    publicKey('mint'),
+    publicKey('owner'),
+    u64('amount'),
+    u32('delegateOption'),
+    publicKey('delegate'),
+    u8('state'),
+    u32('isNativeOption'),
+    u64('isNative'),
+    u64('delegatedAmount'),
+    u32('closeAuthorityOption'),
+    publicKey('closeAuthority'),
+]);
+/** Byte length of a token account */
+const ACCOUNT_SIZE = AccountLayout.span;
+/**
+ * Retrieve information about a token account
+ *
+ * @param connection Connection to use
+ * @param address    Token account
+ * @param commitment Desired level of commitment for querying the state
+ * @param programId  SPL Token program account
+ *
+ * @return Token account information
+ */
+async function getAccount(connection, address, commitment, programId = TOKEN_PROGRAM_ID) {
+    const info = await connection.getAccountInfo(address, commitment);
+    return unpackAccount(address, info, programId);
+}
+/**
+ * Unpack a token account
+ *
+ * @param address   Token account
+ * @param info      Token account data
+ * @param programId SPL Token program account
+ *
+ * @return Unpacked token account
+ */
+function unpackAccount(address, info, programId = TOKEN_PROGRAM_ID) {
+    if (!info)
+        throw new TokenAccountNotFoundError();
+    if (!info.owner.equals(programId))
+        throw new TokenInvalidAccountOwnerError();
+    if (info.data.length < ACCOUNT_SIZE)
+        throw new TokenInvalidAccountSizeError();
+    const rawAccount = AccountLayout.decode(info.data.slice(0, ACCOUNT_SIZE));
+    let tlvData = Buffer.alloc(0);
+    if (info.data.length > ACCOUNT_SIZE) {
+        if (info.data.length === MULTISIG_SIZE)
+            throw new TokenInvalidAccountSizeError();
+        if (info.data[ACCOUNT_SIZE] != AccountType.Account)
+            throw new TokenInvalidAccountError();
+        tlvData = info.data.slice(ACCOUNT_SIZE + ACCOUNT_TYPE_SIZE);
+    }
+    return {
+        address,
+        mint: rawAccount.mint,
+        owner: rawAccount.owner,
+        amount: rawAccount.amount,
+        delegate: rawAccount.delegateOption ? rawAccount.delegate : null,
+        delegatedAmount: rawAccount.delegatedAmount,
+        isInitialized: rawAccount.state !== AccountState.Uninitialized,
+        isFrozen: rawAccount.state === AccountState.Frozen,
+        isNative: !!rawAccount.isNativeOption,
+        rentExemptReserve: rawAccount.isNativeOption ? rawAccount.isNative : null,
+        closeAuthority: rawAccount.closeAuthorityOption ? rawAccount.closeAuthority : null,
+        tlvData,
+    };
+}
+
 /** Buffer layout for de/serializing a mint */
 const MintLayout = struct([
     u32('mintAuthorityOption'),
@@ -5522,6 +6230,54 @@ const MintLayout = struct([
 ]);
 /** Byte length of a mint */
 const MINT_SIZE = MintLayout.span;
+/**
+ * Get the address of the associated token account for a given mint and owner
+ *
+ * @param mint                     Token mint account
+ * @param owner                    Owner of the new account
+ * @param allowOwnerOffCurve       Allow the owner account to be a PDA (Program Derived Address)
+ * @param programId                SPL Token program account
+ * @param associatedTokenProgramId SPL Associated Token program account
+ *
+ * @return Address of the associated token account
+ */
+function getAssociatedTokenAddressSync(mint, owner, allowOwnerOffCurve = false, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {
+    if (!allowOwnerOffCurve && !PublicKey.isOnCurve(owner.toBuffer()))
+        throw new TokenOwnerOffCurveError();
+    const [address] = PublicKey.findProgramAddressSync([owner.toBuffer(), programId.toBuffer(), mint.toBuffer()], associatedTokenProgramId);
+    return address;
+}
+
+/**
+ * Construct a CreateAssociatedTokenAccount instruction
+ *
+ * @param payer                    Payer of the initialization fees
+ * @param associatedToken          New associated token account
+ * @param owner                    Owner of the new account
+ * @param mint                     Token mint account
+ * @param programId                SPL Token program account
+ * @param associatedTokenProgramId SPL Associated Token program account
+ *
+ * @return Instruction to add to a transaction
+ */
+function createAssociatedTokenAccountInstruction(payer, associatedToken, owner, mint, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {
+    return buildAssociatedTokenAccountInstruction(payer, associatedToken, owner, mint, Buffer.alloc(0), programId, associatedTokenProgramId);
+}
+function buildAssociatedTokenAccountInstruction(payer, associatedToken, owner, mint, instructionData, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {
+    const keys = [
+        { pubkey: payer, isSigner: true, isWritable: true },
+        { pubkey: associatedToken, isSigner: false, isWritable: true },
+        { pubkey: owner, isSigner: false, isWritable: false },
+        { pubkey: mint, isSigner: false, isWritable: false },
+        { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        { pubkey: programId, isSigner: false, isWritable: false },
+    ];
+    return new TransactionInstruction({
+        keys,
+        programId: associatedTokenProgramId,
+        data: instructionData,
+    });
+}
 
 /** TODO: docs */
 const initializeMint2InstructionData = struct([
@@ -5555,9 +6311,93 @@ function createInitializeMint2Instruction(mint, decimals, mintAuthority, freezeA
     return new TransactionInstruction({ keys, programId, data });
 }
 
+/**
+ * Retrieve the associated token account, or create it if it doesn't exist
+ *
+ * @param connection               Connection to use
+ * @param payer                    Payer of the transaction and initialization fees
+ * @param mint                     Mint associated with the account to set or verify
+ * @param owner                    Owner of the account to set or verify
+ * @param allowOwnerOffCurve       Allow the owner account to be a PDA (Program Derived Address)
+ * @param commitment               Desired level of commitment for querying the state
+ * @param confirmOptions           Options for confirming the transaction
+ * @param programId                SPL Token program account
+ * @param associatedTokenProgramId SPL Associated Token program account
+ *
+ * @return Address of the new associated token account
+ */
+async function getOrCreateAssociatedTokenAccount(connection, payer, mint, owner, allowOwnerOffCurve = false, commitment, confirmOptions, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {
+    const associatedToken = getAssociatedTokenAddressSync(mint, owner, allowOwnerOffCurve, programId, associatedTokenProgramId);
+    // This is the optimal logic, considering TX fee, client-side computation, RPC roundtrips and guaranteed idempotent.
+    // Sadly we can't do this atomically.
+    let account;
+    try {
+        account = await getAccount(connection, associatedToken, commitment, programId);
+    }
+    catch (error) {
+        // TokenAccountNotFoundError can be possible if the associated address has already received some lamports,
+        // becoming a system account. Assuming program derived addressing is safe, this is the only case for the
+        // TokenInvalidAccountOwnerError in this code path.
+        if (error instanceof TokenAccountNotFoundError || error instanceof TokenInvalidAccountOwnerError) {
+            // As this isn't atomic, it's possible others can create associated accounts meanwhile.
+            try {
+                const transaction = new Transaction().add(createAssociatedTokenAccountInstruction(payer.publicKey, associatedToken, owner, mint, programId, associatedTokenProgramId));
+                await sendAndConfirmTransaction(connection, transaction, [payer], confirmOptions);
+            }
+            catch (error) {
+                // Ignore all errors; for now there is no API-compatible way to selectively ignore the expected
+                // instruction error if the associated account exists already.
+            }
+            // Now this should always succeed
+            account = await getAccount(connection, associatedToken, commitment, programId);
+        }
+        else {
+            throw error;
+        }
+    }
+    if (!account.mint.equals(mint))
+        throw new TokenInvalidMintError();
+    if (!account.owner.equals(owner))
+        throw new TokenInvalidOwnerError();
+    return account;
+}
+
+/** TODO: docs */
+const mintToInstructionData = struct([u8('instruction'), u64('amount')]);
+/**
+ * Construct a MintTo instruction
+ *
+ * @param mint         Public key of the mint
+ * @param destination  Address of the token account to mint to
+ * @param authority    The mint authority
+ * @param amount       Amount to mint
+ * @param multiSigners Signing accounts if `authority` is a multisig
+ * @param programId    SPL Token program account
+ *
+ * @return Instruction to add to a transaction
+ */
+function createMintToInstruction(mint, destination, authority, amount, multiSigners = [], programId = TOKEN_PROGRAM_ID) {
+    const keys = addSigners([
+        { pubkey: mint, isSigner: false, isWritable: true },
+        { pubkey: destination, isSigner: false, isWritable: true },
+    ], authority, multiSigners);
+    const data = Buffer.alloc(mintToInstructionData.span);
+    mintToInstructionData.encode({
+        instruction: TokenInstruction.MintTo,
+        amount: BigInt(amount),
+    }, data);
+    return new TransactionInstruction({ keys, programId, data });
+}
+
+/**
+ * Sum up the token amounts of the compressed token accounts
+ */
 const sumUpTokenAmount = (accounts) => {
     return accounts.reduce((acc, account) => acc.add(account.parsed.amount), bn(0));
 };
+/**
+ * Validate that all the compressed token accounts are owned by the same owner.
+ */
 const validateSameTokenOwner = (accounts) => {
     const owner = accounts[0].parsed.owner;
     accounts.forEach(acc => {
@@ -5566,12 +6406,23 @@ const validateSameTokenOwner = (accounts) => {
         }
     });
 };
-const parseInputTokenData = (inputCompressedTokenAccounts) => {
-    const mint = inputCompressedTokenAccounts[0].parsed.mint;
-    const currentOwner = inputCompressedTokenAccounts[0].parsed.owner;
-    const delegate = inputCompressedTokenAccounts[0].parsed.delegate;
+/**
+ * Parse compressed token accounts to get the mint, current owner and delegate.
+ */
+const parseTokenData = (compressedTokenAccounts) => {
+    const mint = compressedTokenAccounts[0].parsed.mint;
+    const currentOwner = compressedTokenAccounts[0].parsed.owner;
+    const delegate = compressedTokenAccounts[0].parsed.delegate;
     return { mint, currentOwner, delegate };
 };
+/**
+ * Create the output state for a transfer transaction.
+ * @param inputCompressedTokenAccounts  Input state
+ * @param toAddress                     Recipient address
+ * @param amount                        Amount of tokens to transfer
+ * @returns                             Output token data for the transfer
+ *                                      instruction
+ */
 function createTransferOutputState(inputCompressedTokenAccounts, toAddress, amount) {
     amount = bn(amount);
     const inputAmount = sumUpTokenAmount(inputCompressedTokenAccounts);
@@ -5604,6 +6455,13 @@ function createTransferOutputState(inputCompressedTokenAccounts, toAddress, amou
     ];
     return outputCompressedAccounts;
 }
+/**
+ * Create the output state for a compress transaction.
+ * @param inputCompressedTokenAccounts  Input state
+ * @param amount                        Amount of tokens to compress
+ * @returns                             Output token data for the compress
+ *                                      instruction
+ */
 function createDecompressOutputState(inputCompressedTokenAccounts, amount) {
     amount = bn(amount);
     const inputLamports = sumUpLamports(inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
@@ -5633,10 +6491,9 @@ class CompressedTokenProgram {
     /**
      * Public key that identifies the CompressedPda program
      */
-    static programId = new PublicKey(
-    // TODO: can add check to ensure its consistent with the idl
-    '9sixVEthz2kMSKfeApZXHwuboT6DZuT6crAYJTciUCqE');
+    static programId = new PublicKey('HXVfQ44ATEi9WBKLSCCwM54KokdkzqXci9xCQ7ST9SYN');
     static _program = null;
+    /** @internal */
     static get program() {
         if (!this._program) {
             this.initializeProgram();
@@ -5644,12 +6501,14 @@ class CompressedTokenProgram {
         return this._program;
     }
     /**
+     * @internal
      * Initializes the program statically if not already initialized.
      */
     static initializeProgram() {
         if (!this._program) {
-            /// We can use a mock connection because we're using the program only for
-            /// serde and building instructions, not for interacting with the network.
+            /// Note: We can use a mock connection because we're using the
+            /// program only for serde and building instructions, not for
+            /// interacting with the network.
             const mockKeypair = Keypair.generate();
             const mockConnection = new Connection('http://127.0.0.1:8899', 'confirmed');
             const mockProvider = new AnchorProvider(mockConnection, useWallet(mockKeypair), confirmConfig);
@@ -5658,11 +6517,6 @@ class CompressedTokenProgram {
         }
     }
     /** @internal */
-    static deriveMintAuthorityPda = (authority, mint) => {
-        const [pubkey] = PublicKey.findProgramAddressSync([MINT_AUTHORITY_SEED, authority.toBuffer(), mint.toBuffer()], this.programId);
-        return pubkey;
-    };
-    /** @internal */
     static deriveTokenPoolPda(mint) {
         const seeds = [POOL_SEED, mint.toBuffer()];
         const [address, _] = PublicKey.findProgramAddressSync(seeds, this.programId);
@@ -5673,8 +6527,12 @@ class CompressedTokenProgram {
         const [address, _] = PublicKey.findProgramAddressSync([CPI_AUTHORITY_SEED], this.programId);
         return address;
     }
+    /**
+     * Construct createMint instruction for compressed tokens
+     */
     static async createMint(params) {
         const { mint, authority, feePayer, rentExemptBalance } = params;
+        /// Create and initialize SPL Mint account
         const createMintAccountInstruction = SystemProgram.createAccount({
             fromPubkey: feePayer,
             lamports: rentExemptBalance,
@@ -5682,212 +6540,266 @@ class CompressedTokenProgram {
             programId: TOKEN_PROGRAM_ID,
             space: MINT_SIZE,
         });
-        const mintAuthorityPda = this.deriveMintAuthorityPda(authority, mint);
-        const initializeMintInstruction = createInitializeMint2Instruction(mint, params.decimals, mintAuthorityPda, params.freezeAuthority, TOKEN_PROGRAM_ID);
-        const fundAuthorityPdaInstruction = SystemProgram.transfer({
-            fromPubkey: feePayer,
-            toPubkey: mintAuthorityPda,
-            lamports: rentExemptBalance, // TODO: check that this is the right PDA size
+        const initializeMintInstruction = createInitializeMint2Instruction(mint, params.decimals, authority, params.freezeAuthority, TOKEN_PROGRAM_ID);
+        const ix = await this.registerMint({
+            feePayer,
+            mint,
         });
+        return [createMintAccountInstruction, initializeMintInstruction, ix];
+    }
+    /**
+     * Enable compression for an existing SPL mint, creating an omnibus account.
+     * For new mints, use `CompressedTokenProgram.createMint`.
+     */
+    static async registerMint(params) {
+        const { mint, feePayer } = params;
         const tokenPoolPda = this.deriveTokenPoolPda(mint);
         const ix = await this.program.methods
             .createMint()
             .accounts({
             mint,
             feePayer,
-            authority,
             tokenPoolPda,
             systemProgram: SystemProgram.programId,
-            mintAuthorityPda,
             tokenProgram: TOKEN_PROGRAM_ID,
             cpiAuthorityPda: this.deriveCpiAuthorityPda,
         })
             .instruction();
-        return [
-            createMintAccountInstruction,
-            initializeMintInstruction,
-            fundAuthorityPdaInstruction,
-            ix,
-        ];
+        return ix;
     }
+    /**
+     * Construct mintTo instruction for compressed tokens
+     */
     static async mintTo(params) {
         const systemKeys = defaultStaticAccountsStruct();
         const { mint, feePayer, authority, merkleTree, toPubkey, amount } = params;
         const tokenPoolPda = this.deriveTokenPoolPda(mint);
-        const mintAuthorityPda = this.deriveMintAuthorityPda(authority, mint);
         const amounts = toArray(amount).map(amount => bn(amount));
         const toPubkeys = toArray(toPubkey);
-        const ix = await this.program.methods
+        const instruction = await this.program.methods
             .mintTo(toPubkeys, amounts)
             .accounts({
             feePayer,
             authority,
-            mintAuthorityPda,
+            cpiAuthorityPda: this.deriveCpiAuthorityPda,
             mint,
             tokenPoolPda,
             tokenProgram: TOKEN_PROGRAM_ID,
-            compressedPdaProgram: LightSystemProgram.programId,
+            lightSystemProgram: LightSystemProgram.programId,
             registeredProgramPda: systemKeys.registeredProgramPda,
             noopProgram: systemKeys.noopProgram,
             accountCompressionAuthority: systemKeys.accountCompressionAuthority,
             accountCompressionProgram: systemKeys.accountCompressionProgram,
-            merkleTree,
+            merkleTree: merkleTree ?? defaultTestStateTreeAccounts().merkleTree,
             selfProgram: this.programId,
         })
             .instruction();
-        return ix;
+        return instruction;
+    }
+    /// TODO: add compressBatch functionality for batch minting
+    /**
+     * Mint tokens from registed SPL mint account to a compressed account
+     */
+    static async approveAndMintTo(params) {
+        const { mint, feePayer, authorityTokenAccount, authority, merkleTree, toPubkey, } = params;
+        const amount = BigInt(params.amount.toString());
+        /// 1. Mint to existing ATA of mintAuthority.
+        const splMintToInstruction = createMintToInstruction(mint, authorityTokenAccount, authority, amount);
+        /// 2. Compress from mint authority ATA to recipient compressed account
+        const [approveInstruction, compressInstruction] = await this.compress({
+            payer: feePayer,
+            owner: authority,
+            source: authorityTokenAccount,
+            toAddress: toPubkey,
+            mint,
+            amount: params.amount,
+            outputStateTree: merkleTree,
+        });
+        return [splMintToInstruction, approveInstruction, compressInstruction];
     }
+    /**
+     * Construct transfer instruction for compressed tokens
+     */
     static async transfer(params) {
         const { payer, inputCompressedTokenAccounts, recentInputStateRootIndices, recentValidityProof, amount, outputStateTrees, toAddress, } = params;
-        const outputCompressedAccounts = createTransferOutputState(inputCompressedTokenAccounts, toAddress, amount);
-        /// Pack
-        const { inputTokenDataWithContext, outputStateMerkleTreeIndices, remainingAccountMetas, } = packCompressedTokenAccounts({
+        const tokenTransferOutputs = createTransferOutputState(inputCompressedTokenAccounts, toAddress, amount);
+        const { inputTokenDataWithContext, packedOutputTokenData, remainingAccountMetas, } = packCompressedTokenAccounts({
             inputCompressedTokenAccounts,
-            outputCompressedAccountsLength: outputCompressedAccounts.length,
             outputStateTrees,
+            rootIndices: recentInputStateRootIndices,
+            tokenTransferOutputs,
         });
-        const { mint, currentOwner } = parseInputTokenData(inputCompressedTokenAccounts);
+        const { mint, currentOwner } = parseTokenData(inputCompressedTokenAccounts);
         const data = {
             proof: recentValidityProof,
-            rootIndices: recentInputStateRootIndices,
             mint,
-            signerIsDelegate: false, // TODO: implement
+            delegatedTransfer: null, // TODO: implement
             inputTokenDataWithContext,
-            outputCompressedAccounts,
-            outputStateMerkleTreeAccountIndices: Buffer$1.from(outputStateMerkleTreeIndices),
-            compressionAmount: null,
+            outputCompressedAccounts: packedOutputTokenData,
+            compressOrDecompressAmount: null,
             isCompress: false,
+            cpiContext: null,
         };
         const encodedData = this.program.coder.types.encode('CompressedTokenInstructionDataTransfer', data);
         const { accountCompressionAuthority, noopProgram, registeredProgramPda, accountCompressionProgram, } = defaultStaticAccountsStruct();
         const instruction = await this.program.methods
-            .transfer(encodedData, null)
+            .transfer(encodedData)
             .accounts({
             feePayer: payer,
             authority: currentOwner,
             cpiAuthorityPda: this.deriveCpiAuthorityPda,
-            compressedPdaProgram: LightSystemProgram.programId,
+            lightSystemProgram: LightSystemProgram.programId,
             registeredProgramPda: registeredProgramPda,
             noopProgram: noopProgram,
             accountCompressionAuthority: accountCompressionAuthority,
             accountCompressionProgram: accountCompressionProgram,
             selfProgram: this.programId,
             tokenPoolPda: null,
-            decompressTokenAccount: null,
+            compressOrDecompressTokenAccount: null,
             tokenProgram: null,
         })
             .remainingAccounts(remainingAccountMetas)
             .instruction();
-        return [
-            ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }),
-            instruction,
-        ];
+        return instruction;
     }
+    /**
+     * Construct approve and compress instructions
+     * @returns [approveInstruction, compressInstruction]
+     */
     static async compress(params) {
         const { payer, owner, source, toAddress, mint, outputStateTree } = params;
         const amount = bn(params.amount);
-        const outputCompressedAccounts = [
+        const tokenTransferOutputs = [
             {
                 owner: toAddress,
                 amount,
                 lamports: bn(0),
             },
         ];
-        /// Pack
-        const { inputTokenDataWithContext, outputStateMerkleTreeIndices, remainingAccountMetas, } = packCompressedTokenAccounts({
+        const { inputTokenDataWithContext, packedOutputTokenData, remainingAccountMetas, } = packCompressedTokenAccounts({
             inputCompressedTokenAccounts: [],
-            outputCompressedAccountsLength: outputCompressedAccounts.length,
-            outputStateTrees: [outputStateTree],
+            outputStateTrees: outputStateTree,
+            rootIndices: [],
+            tokenTransferOutputs,
         });
         const data = {
             proof: null,
-            rootIndices: [],
             mint,
-            signerIsDelegate: false, // TODO: implement
+            delegatedTransfer: null, // TODO: implement
             inputTokenDataWithContext,
-            outputCompressedAccounts,
-            outputStateMerkleTreeAccountIndices: Buffer$1.from(outputStateMerkleTreeIndices),
-            compressionAmount: amount,
+            outputCompressedAccounts: packedOutputTokenData,
+            compressOrDecompressAmount: amount,
             isCompress: true,
+            cpiContext: null,
         };
         const encodedData = this.program.coder.types.encode('CompressedTokenInstructionDataTransfer', data);
         const { accountCompressionAuthority, noopProgram, registeredProgramPda, accountCompressionProgram, } = defaultStaticAccountsStruct();
-        /// TODO: add support for multiSigners
-        /// TODO: validate that we don't need approveChecked
         const approveInstruction = createApproveInstruction(source, this.deriveCpiAuthorityPda, owner, BigInt(amount.toString()));
         const instruction = await this.program.methods
-            .transfer(encodedData, null)
+            .transfer(encodedData)
             .accounts({
             feePayer: payer,
             authority: owner,
             cpiAuthorityPda: this.deriveCpiAuthorityPda,
-            compressedPdaProgram: LightSystemProgram.programId,
+            lightSystemProgram: LightSystemProgram.programId,
             registeredProgramPda: registeredProgramPda,
             noopProgram: noopProgram,
             accountCompressionAuthority: accountCompressionAuthority,
             accountCompressionProgram: accountCompressionProgram,
             selfProgram: this.programId,
             tokenPoolPda: this.deriveTokenPoolPda(mint),
-            decompressTokenAccount: source, // token
+            compressOrDecompressTokenAccount: source, // token
             tokenProgram: TOKEN_PROGRAM_ID,
         })
             .remainingAccounts(remainingAccountMetas)
             .instruction();
-        return [
-            ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }),
-            approveInstruction,
-            instruction,
-        ];
+        return [approveInstruction, instruction];
     }
+    /**
+     * Construct decompress instruction
+     */
     static async decompress(params) {
         const { payer, inputCompressedTokenAccounts, toAddress, outputStateTree, recentValidityProof, recentInputStateRootIndices, } = params;
         const amount = bn(params.amount);
         const tokenTransferOutputs = createDecompressOutputState(inputCompressedTokenAccounts, amount);
         /// Pack
-        const { inputTokenDataWithContext, outputStateMerkleTreeIndices, remainingAccountMetas, } = packCompressedTokenAccounts({
+        const { inputTokenDataWithContext, packedOutputTokenData, remainingAccountMetas, } = packCompressedTokenAccounts({
             inputCompressedTokenAccounts,
-            outputCompressedAccountsLength: tokenTransferOutputs.length,
-            outputStateTrees: [outputStateTree],
+            outputStateTrees: outputStateTree,
+            rootIndices: recentInputStateRootIndices,
+            tokenTransferOutputs: tokenTransferOutputs,
         });
-        const { mint, currentOwner } = parseInputTokenData(inputCompressedTokenAccounts);
+        const { mint, currentOwner } = parseTokenData(inputCompressedTokenAccounts);
         const data = {
             proof: recentValidityProof,
-            rootIndices: recentInputStateRootIndices,
             mint,
-            signerIsDelegate: false, // TODO: implement
+            delegatedTransfer: null, // TODO: implement
             inputTokenDataWithContext,
-            outputCompressedAccounts: tokenTransferOutputs,
-            outputStateMerkleTreeAccountIndices: Buffer$1.from(outputStateMerkleTreeIndices),
-            compressionAmount: amount,
+            outputCompressedAccounts: packedOutputTokenData,
+            compressOrDecompressAmount: amount,
             isCompress: false,
+            cpiContext: null,
         };
         const encodedData = this.program.coder.types.encode('CompressedTokenInstructionDataTransfer', data);
         const { accountCompressionAuthority, noopProgram, registeredProgramPda, accountCompressionProgram, } = defaultStaticAccountsStruct();
         const instruction = await this.program.methods
-            .transfer(encodedData, null)
+            .transfer(encodedData)
             .accounts({
             feePayer: payer,
             authority: currentOwner,
             cpiAuthorityPda: this.deriveCpiAuthorityPda,
-            compressedPdaProgram: LightSystemProgram.programId,
+            lightSystemProgram: LightSystemProgram.programId,
             registeredProgramPda: registeredProgramPda,
             noopProgram: noopProgram,
             accountCompressionAuthority: accountCompressionAuthority,
             accountCompressionProgram: accountCompressionProgram,
             selfProgram: this.programId,
             tokenPoolPda: this.deriveTokenPoolPda(mint),
-            decompressTokenAccount: toAddress, // token
+            compressOrDecompressTokenAccount: toAddress,
             tokenProgram: TOKEN_PROGRAM_ID,
         })
             .remainingAccounts(remainingAccountMetas)
             .instruction();
-        return [
-            ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }),
-            instruction,
-        ];
+        return instruction;
     }
 }
 
+/**
+ * Mint compressed tokens to a solana address from an external mint authority
+ *
+ * @param rpc            Rpc to use
+ * @param payer          Payer of the transaction fees
+ * @param mint           Mint for the account
+ * @param destination    Address of the account to mint to
+ * @param authority      Minting authority
+ * @param amount         Amount to mint
+ * @param merkleTree     State tree account that the compressed tokens should be
+ *                       part of. Defaults to the default state tree account.
+ * @param confirmOptions Options for confirming the transaction
+ *
+ * @return Signature of the confirmed transaction
+ */
+async function approveAndMintTo(rpc, payer, mint, destination, authority, amount, merkleTree, confirmOptions) {
+    const authorityTokenAccount = await getOrCreateAssociatedTokenAccount(rpc, payer, mint, authority.publicKey);
+    const ixs = await CompressedTokenProgram.approveAndMintTo({
+        feePayer: payer.publicKey,
+        mint,
+        authority: authority.publicKey,
+        authorityTokenAccount: authorityTokenAccount.address,
+        amount,
+        toPubkey: destination,
+        merkleTree,
+    });
+    const { blockhash } = await rpc.getLatestBlockhash();
+    const additionalSigners = dedupeSigner(payer, [authority]);
+    const tx = buildAndSignTx([
+        ComputeBudgetProgram.setComputeUnitLimit({ units: 1_000_000 }),
+        ...ixs,
+    ], payer, blockhash, additionalSigners);
+    const txId = await sendAndConfirmTx(rpc, tx, confirmOptions);
+    return txId;
+}
+
 /**
  * Compress SPL tokens
  *
@@ -5906,9 +6818,9 @@ class CompressedTokenProgram {
  *
  * @return Signature of the confirmed transaction
  */
-async function compress(rpc, payer, mint, amount, owner, sourceTokenAccount, toAddress, merkleTree = defaultTestStateTreeAccounts().merkleTree, confirmOptions) {
+async function compress(rpc, payer, mint, amount, owner, sourceTokenAccount, toAddress, merkleTree, confirmOptions) {
     amount = bn(amount);
-    const ixs = await CompressedTokenProgram.compress({
+    const [approveIx, compressIx] = await CompressedTokenProgram.compress({
         payer: payer.publicKey,
         owner: owner.publicKey,
         source: sourceTokenAccount,
@@ -5919,7 +6831,13 @@ async function compress(rpc, payer, mint, amount, owner, sourceTokenAccount, toA
     });
     const blockhashCtx = await rpc.getLatestBlockhash();
     const additionalSigners = dedupeSigner(payer, [owner]);
-    const signedTx = buildAndSignTx(ixs, payer, blockhashCtx.blockhash, additionalSigners);
+    const signedTx = buildAndSignTx([
+        ComputeBudgetProgram.setComputeUnitLimit({
+            units: 1_000_000,
+        }),
+        approveIx,
+        compressIx,
+    ], payer, blockhashCtx.blockhash, additionalSigners);
     const txId = await sendAndConfirmTx(rpc, signedTx, confirmOptions, blockhashCtx);
     return txId;
 }
@@ -5934,7 +6852,8 @@ async function compress(rpc, payer, mint, amount, owner, sourceTokenAccount, toA
  * @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
  *
  *
@@ -5942,14 +6861,14 @@ async function compress(rpc, payer, mint, amount, owner, sourceTokenAccount, toA
  */
 async function transfer(rpc, payer, mint, amount, owner, toAddress, 
 /// TODO: allow multiple
-merkleTree = defaultTestStateTreeAccounts().merkleTree, confirmOptions) {
+merkleTree, confirmOptions) {
     amount = bn(amount);
     const compressedTokenAccounts = await rpc.getCompressedTokenAccountsByOwner(owner.publicKey, {
         mint,
     });
     const [inputAccounts] = selectMinCompressedTokenAccountsForTransfer(compressedTokenAccounts, amount);
     const proof = await rpc.getValidityProof(inputAccounts.map(account => bn(account.compressedAccount.hash)));
-    const ixs = await CompressedTokenProgram.transfer({
+    const ix = await CompressedTokenProgram.transfer({
         payer: payer.publicKey,
         inputCompressedTokenAccounts: inputAccounts,
         toAddress,
@@ -5960,7 +6879,7 @@ merkleTree = defaultTestStateTreeAccounts().merkleTree, confirmOptions) {
     });
     const { blockhash } = await rpc.getLatestBlockhash();
     const additionalSigners = dedupeSigner(payer, [owner]);
-    const signedTx = buildAndSignTx(ixs, payer, blockhash, additionalSigners);
+    const signedTx = buildAndSignTx([ComputeBudgetProgram.setComputeUnitLimit({ units: 1_000_000 }), ix], payer, blockhash, additionalSigners);
     const txId = await sendAndConfirmTx(rpc, signedTx, confirmOptions);
     return txId;
 }
@@ -6013,7 +6932,7 @@ function selectMinCompressedTokenAccountsForTransfer(accounts, transferAmount) {
  */
 async function decompress(rpc, payer, mint, amount, owner, toAddress, 
 /// TODO: allow multiple
-merkleTree = defaultTestStateTreeAccounts().merkleTree, confirmOptions) {
+merkleTree, confirmOptions) {
     amount = bn(amount);
     const compressedTokenAccounts = await rpc.getCompressedTokenAccountsByOwner(owner.publicKey, {
         mint,
@@ -6021,7 +6940,7 @@ merkleTree = defaultTestStateTreeAccounts().merkleTree, confirmOptions) {
     /// TODO: consider using a different selection algorithm
     const [inputAccounts] = selectMinCompressedTokenAccountsForTransfer(compressedTokenAccounts, amount);
     const proof = await rpc.getValidityProof(inputAccounts.map(account => bn(account.compressedAccount.hash)));
-    const ixs = await CompressedTokenProgram.decompress({
+    const ix = await CompressedTokenProgram.decompress({
         payer: payer.publicKey,
         inputCompressedTokenAccounts: inputAccounts,
         toAddress, // TODO: add explicit check that it is a token account
@@ -6032,7 +6951,7 @@ merkleTree = defaultTestStateTreeAccounts().merkleTree, confirmOptions) {
     });
     const { blockhash } = await rpc.getLatestBlockhash();
     const additionalSigners = dedupeSigner(payer, [owner]);
-    const signedTx = buildAndSignTx(ixs, payer, blockhash, additionalSigners);
+    const signedTx = buildAndSignTx([ComputeBudgetProgram.setComputeUnitLimit({ units: 1_000_000 }), ix], payer, blockhash, additionalSigners);
     const txId = await sendAndConfirmTx(rpc, signedTx, confirmOptions);
     return txId;
 }
@@ -6042,7 +6961,7 @@ merkleTree = defaultTestStateTreeAccounts().merkleTree, confirmOptions) {
  *
  * @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
@@ -6055,12 +6974,12 @@ async function createMint(rpc, payer, mintAuthority, decimals, keypair = Keypair
         feePayer: payer.publicKey,
         mint: keypair.publicKey,
         decimals,
-        authority: mintAuthority.publicKey,
+        authority: mintAuthority,
         freezeAuthority: null, // TODO: add feature
         rentExemptBalance,
     });
     const { blockhash } = await rpc.getLatestBlockhash();
-    const additionalSigners = dedupeSigner(payer, [mintAuthority, keypair]);
+    const additionalSigners = dedupeSigner(payer, [keypair]);
     const tx = buildAndSignTx(ixs, payer, blockhash, additionalSigners);
     const txId = await sendAndConfirmTx(rpc, tx, confirmOptions);
     return { mint: keypair.publicKey, transactionSignature: txId };
@@ -6081,8 +7000,7 @@ async function createMint(rpc, payer, mintAuthority, decimals, keypair = Keypair
  *
  * @return Signature of the confirmed transaction
  */
-async function mintTo(rpc, payer, mint, destination, authority, amount, merkleTree = defaultTestStateTreeAccounts().merkleTree, // DEFAULT IF NOT PROVIDED
-confirmOptions) {
+async function mintTo(rpc, payer, mint, destination, authority, amount, merkleTree, confirmOptions) {
     const additionalSigners = dedupeSigner(payer, [authority]);
     const ix = await CompressedTokenProgram.mintTo({
         feePayer: payer.publicKey,
@@ -6093,10 +7011,32 @@ confirmOptions) {
         merkleTree,
     });
     const { blockhash } = await rpc.getLatestBlockhash();
-    const tx = buildAndSignTx([ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }), ix], payer, blockhash, additionalSigners);
+    const tx = buildAndSignTx([ComputeBudgetProgram.setComputeUnitLimit({ units: 1_000_000 }), ix], payer, blockhash, additionalSigners);
+    const txId = await sendAndConfirmTx(rpc, tx, confirmOptions);
+    return txId;
+}
+
+/**
+ * Register an existing mint with the CompressedToken program
+ *
+ * @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 mintAddress     Address of the existing mint
+ * @param confirmOptions  Options for confirming the transaction
+ *
+ * @return transaction signature
+ */
+async function registerMint(rpc, payer, mintAddress, confirmOptions) {
+    const ix = await CompressedTokenProgram.registerMint({
+        feePayer: payer.publicKey,
+        mint: mintAddress,
+    });
+    const { blockhash } = await rpc.getLatestBlockhash();
+    const tx = buildAndSignTx([ix], payer, blockhash);
     const txId = await sendAndConfirmTx(rpc, tx, confirmOptions);
     return txId;
 }
 
-export { CPI_AUTHORITY_SEED, CompressedTokenProgram, IDL, MINT_AUTHORITY_SEED, POOL_SEED, SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE, compress, createDecompressOutputState, createMint, createTransferOutputState, decompress, mintTo, packCompressedTokenAccounts, parseInputTokenData, selectMinCompressedTokenAccountsForTransfer, sumUpTokenAmount, transfer, validateSameTokenOwner };
+export { CPI_AUTHORITY_SEED, CompressedTokenProgram, IDL, POOL_SEED, SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE, approveAndMintTo, compress, createDecompressOutputState, createMint, createTransferOutputState, decompress, mintTo, packCompressedTokenAccounts, parseTokenData, registerMint, selectMinCompressedTokenAccountsForTransfer, sumUpTokenAmount, transfer, validateSameTokenOwner };
 //# sourceMappingURL=index.js.map