@lightprotocol/compressed-token 0.1.3 → 0.3.0

package/dist/cjs/node/index.cjs

@@ -1,29 +1,21 @@
 'use strict';
 
 var stateless_js = require('@lightprotocol/stateless.js');
-var anchor = require('@coral-xyz/anchor');
 var web3_js = require('@solana/web3.js');
+var anchor = require('@coral-xyz/anchor');
 var require$$0 = require('buffer');
-var require$$0$2 = require('fs');
-var require$$0$1 = require('path');
 
 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: [
                 {
@@ -31,11 +23,6 @@ const IDL = {
                     isMut: true,
                     isSigner: true,
                 },
-                {
-                    name: 'authority',
-                    isMut: true,
-                    isSigner: true,
-                },
                 {
                     name: 'tokenPoolPda',
                     isMut: true,
@@ -51,11 +38,6 @@ const IDL = {
                     isMut: true,
                     isSigner: false,
                 },
-                {
-                    name: 'mintAuthorityPda',
-                    isMut: true,
-                    isSigner: false,
-                },
                 {
                     name: 'tokenProgram',
                     isMut: false,
@@ -71,6 +53,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',
@@ -79,12 +67,12 @@ const IDL = {
                 },
                 {
                     name: 'authority',
-                    isMut: true,
+                    isMut: false,
                     isSigner: true,
                 },
                 {
-                    name: 'mintAuthorityPda',
-                    isMut: true,
+                    name: 'cpiAuthorityPda',
+                    isMut: false,
                     isSigner: false,
                 },
                 {
@@ -103,13 +91,13 @@ const IDL = {
                     isSigner: false,
                 },
                 {
-                    name: 'compressedPdaProgram',
+                    name: 'lightSystemProgram',
                     isMut: false,
                     isSigner: false,
                 },
                 {
                     name: 'registeredProgramPda',
-                    isMut: true,
+                    isMut: false,
                     isSigner: false,
                 },
                 {
@@ -119,7 +107,7 @@ const IDL = {
                 },
                 {
                     name: 'accountCompressionAuthority',
-                    isMut: true,
+                    isMut: false,
                     isSigner: false,
                 },
                 {
@@ -137,6 +125,11 @@ const IDL = {
                     isMut: false,
                     isSigner: false,
                 },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
             ],
             args: [
                 {
@@ -146,19 +139,418 @@ const IDL = {
                     },
                 },
                 {
-                    name: 'amounts',
-                    type: {
-                        vec: 'u64',
-                    },
+                    name: 'amounts',
+                    type: {
+                        vec: 'u64',
+                    },
+                },
+            ],
+        },
+        {
+            name: 'transfer',
+            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: 'inputs',
+                    type: 'bytes',
+                },
+            ],
+        },
+        {
+            name: 'approve',
+            accounts: [
+                {
+                    name: 'feePayer',
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: 'authority',
+                    isMut: false,
+                    isSigner: true,
+                },
+                {
+                    name: 'cpiAuthorityPda',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'lightSystemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'registeredProgramPda',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'noopProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'accountCompressionAuthority',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'accountCompressionProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'selfProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'inputs',
+                    type: 'bytes',
+                },
+            ],
+        },
+        {
+            name: '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: 'freeze',
+            accounts: [
+                {
+                    name: 'feePayer',
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: 'authority',
+                    isMut: false,
+                    isSigner: true,
+                },
+                {
+                    name: 'cpiAuthorityPda',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'lightSystemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'registeredProgramPda',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'noopProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'accountCompressionAuthority',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'accountCompressionProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'selfProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'mint',
+                    isMut: false,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'inputs',
+                    type: 'bytes',
+                },
+            ],
+        },
+        {
+            name: 'thaw',
+            accounts: [
+                {
+                    name: 'feePayer',
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: 'authority',
+                    isMut: false,
+                    isSigner: true,
+                },
+                {
+                    name: 'cpiAuthorityPda',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'lightSystemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'registeredProgramPda',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'noopProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'accountCompressionAuthority',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'accountCompressionProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'selfProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'mint',
+                    isMut: false,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'inputs',
+                    type: 'bytes',
+                },
+            ],
+        },
+        {
+            name: 'burn',
+            accounts: [
+                {
+                    name: 'feePayer',
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: 'authority',
+                    isMut: false,
+                    isSigner: true,
+                },
+                {
+                    name: 'cpiAuthorityPda',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'lightSystemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'registeredProgramPda',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'noopProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'accountCompressionAuthority',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'accountCompressionProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'selfProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'inputs',
+                    type: 'bytes',
                 },
             ],
         },
         {
-            name: 'transfer',
+            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: false,
+                    isMut: true,
                     isSigner: true,
                 },
                 {
@@ -172,7 +564,7 @@ const IDL = {
                     isSigner: false,
                 },
                 {
-                    name: 'compressedPdaProgram',
+                    name: 'lightSystemProgram',
                     isMut: false,
                     isSigner: false,
                 },
@@ -208,7 +600,7 @@ const IDL = {
                     isOptional: true,
                 },
                 {
-                    name: 'decompressTokenAccount',
+                    name: 'compressOrDecompressTokenAccount',
                     isMut: true,
                     isSigner: false,
                     isOptional: true,
@@ -219,86 +611,77 @@ const IDL = {
                     isSigner: false,
                     isOptional: true,
                 },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
             ],
             args: [
                 {
-                    name: 'inputs',
-                    type: 'bytes',
+                    name: 'inputs1',
+                    type: {
+                        defined: 'CompressedTokenInstructionDataTransfer',
+                    },
                 },
                 {
-                    name: 'cpiContext',
+                    name: 'inputs2',
                     type: {
-                        option: {
-                            defined: 'CompressedCpiContext',
-                        },
+                        defined: 'TokenData',
                     },
                 },
             ],
         },
     ],
-    types: [
+    accounts: [
         {
-            name: 'CompressedAccountWithMerkleContext',
+            name: 'RegisteredProgram',
             type: {
                 kind: 'struct',
                 fields: [
                     {
-                        name: 'compressedAccount',
-                        type: {
-                            defined: 'CompressedAccount',
-                        },
-                    },
-                    {
-                        name: 'merkleTreePubkeyIndex',
-                        type: 'u8',
-                    },
-                    {
-                        name: 'nullifierQueuePubkeyIndex',
-                        type: 'u8',
+                        name: 'registeredProgramId',
+                        type: 'publicKey',
                     },
                     {
-                        name: 'leafIndex',
-                        type: 'u32',
+                        name: 'groupAuthorityPda',
+                        type: 'publicKey',
                     },
                 ],
             },
         },
+    ],
+    types: [
         {
-            name: 'MerkleContext',
+            name: 'AccessMetadata',
             type: {
                 kind: 'struct',
                 fields: [
                     {
-                        name: 'merkleTreePubkey',
+                        name: 'owner',
+                        docs: ['Owner of the Merkle tree.'],
                         type: 'publicKey',
                     },
                     {
-                        name: 'nullifierQueuePubkey',
+                        name: 'programOwner',
+                        docs: [
+                            'Delegate of the Merkle tree. This will be used for program owned Merkle trees.',
+                        ],
                         type: 'publicKey',
                     },
-                    {
-                        name: 'leafIndex',
-                        type: 'u32',
-                    },
                 ],
             },
         },
         {
-            name: 'PackedMerkleContext',
+            name: 'AccountState',
             type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'merkleTreePubkeyIndex',
-                        type: 'u8',
-                    },
+                kind: 'enum',
+                variants: [
                     {
-                        name: 'nullifierQueuePubkeyIndex',
-                        type: 'u8',
+                        name: 'Initialized',
                     },
                     {
-                        name: 'leafIndex',
-                        type: 'u32',
+                        name: 'Frozen',
                     },
                 ],
             },
@@ -361,56 +744,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: 'a',
+                        type: {
+                            array: ['u8', 32],
+                        },
+                    },
                     {
-                        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: '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',
                             },
                         },
                     },
@@ -418,53 +826,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: 'owner',
+                        type: 'publicKey',
+                    },
                     {
-                        name: 'isCompress',
-                        type: 'bool',
+                        name: 'delegateChangeAccountIndex',
+                        type: 'u8',
                     },
+                ],
+            },
+        },
+        {
+            name: 'InputTokenDataWithContext',
+            type: {
+                kind: 'struct',
+                fields: [
                     {
-                        name: 'compressionLamports',
+                        name: 'amount',
+                        type: 'u64',
+                    },
+                    {
+                        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: [
@@ -476,6 +914,28 @@ const IDL = {
                             },
                         },
                     },
+                    {
+                        name: 'inputCompressedAccountsWithMerkleContext',
+                        type: {
+                            vec: {
+                                defined: 'PackedCompressedAccountWithMerkleContext',
+                            },
+                        },
+                    },
+                    {
+                        name: 'outputCompressedAccounts',
+                        type: {
+                            vec: {
+                                defined: 'OutputCompressedAccountWithPackedContext',
+                            },
+                        },
+                    },
+                    {
+                        name: 'relayFee',
+                        type: {
+                            option: 'u64',
+                        },
+                    },
                     {
                         name: 'newAddressParams',
                         type: {
@@ -485,16 +945,44 @@ const IDL = {
                         },
                     },
                     {
-                        name: 'inputRootIndices',
+                        name: 'compressOrDecompressLamports',
+                        type: {
+                            option: 'u64',
+                        },
+                    },
+                    {
+                        name: 'isCompress',
+                        type: 'bool',
+                    },
+                ],
+            },
+        },
+        {
+            name: 'InstructionDataInvokeCpi',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'proof',
+                        type: {
+                            option: {
+                                defined: 'CompressedProof',
+                            },
+                        },
+                    },
+                    {
+                        name: 'newAddressParams',
                         type: {
-                            vec: 'u16',
+                            vec: {
+                                defined: 'NewAddressParamsPacked',
+                            },
                         },
                     },
                     {
                         name: 'inputCompressedAccountsWithMerkleContext',
                         type: {
                             vec: {
-                                defined: 'CompressedAccountWithMerkleContext',
+                                defined: 'PackedCompressedAccountWithMerkleContext',
                             },
                         },
                     },
@@ -502,40 +990,83 @@ const IDL = {
                         name: 'outputCompressedAccounts',
                         type: {
                             vec: {
-                                defined: 'CompressedAccount',
+                                defined: 'OutputCompressedAccountWithPackedContext',
                             },
                         },
                     },
                     {
-                        name: 'outputStateMerkleTreeAccountIndices',
-                        docs: [
-                            'The indices of the accounts in the output state merkle tree.',
-                        ],
-                        type: 'bytes',
+                        name: 'relayFee',
+                        type: {
+                            option: 'u64',
+                        },
                     },
                     {
-                        name: 'relayFee',
+                        name: 'compressOrDecompressLamports',
                         type: {
                             option: 'u64',
                         },
                     },
                     {
-                        name: 'compressionLamports',
-                        type: {
-                            option: 'u64',
-                        },
+                        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: 'isCompress',
-                        type: 'bool',
+                        name: 'pubkey',
+                        type: 'publicKey',
                     },
                     {
-                        name: 'signerSeeds',
-                        type: {
-                            option: {
-                                vec: 'bytes',
-                            },
-                        },
+                        name: 'seq',
+                        type: 'u64',
                     },
                 ],
             },
@@ -567,84 +1098,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',
@@ -661,37 +1163,49 @@ const IDL = {
             },
         },
         {
-            name: 'CompressedTokenInstructionDataTransfer',
+            name: 'PackedTokenTransferOutputData',
             type: {
                 kind: 'struct',
                 fields: [
                     {
-                        name: 'proof',
-                        type: {
-                            option: {
-                                defined: 'CompressedProof',
-                            },
-                        },
+                        name: 'owner',
+                        type: 'publicKey',
                     },
                     {
-                        name: 'rootIndices',
+                        name: 'amount',
+                        type: 'u64',
+                    },
+                    {
+                        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],
                             },
                         },
                     },
@@ -699,108 +1213,106 @@ const IDL = {
                         name: 'outputCompressedAccounts',
                         type: {
                             vec: {
-                                defined: 'TokenTransferOutputData',
+                                defined: 'OutputCompressedAccountWithPackedContext',
                             },
                         },
                     },
                     {
-                        name: 'outputStateMerkleTreeAccountIndices',
-                        type: 'bytes',
+                        name: 'outputLeafIndices',
+                        type: {
+                            vec: 'u32',
+                        },
                     },
                     {
-                        name: 'isCompress',
-                        type: 'bool',
+                        name: 'sequenceNumbers',
+                        type: {
+                            vec: {
+                                defined: 'MerkleTreeSequenceNumber',
+                            },
+                        },
                     },
                     {
-                        name: 'compressionAmount',
+                        name: 'relayFee',
                         type: {
                             option: 'u64',
                         },
                     },
-                ],
-            },
-        },
-        {
-            name: 'TokenTransferOutputData',
-            type: {
-                kind: 'struct',
-                fields: [
                     {
-                        name: 'owner',
-                        type: 'publicKey',
+                        name: 'isCompress',
+                        type: 'bool',
                     },
                     {
-                        name: 'amount',
-                        type: 'u64',
+                        name: 'compressOrDecompressLamports',
+                        type: {
+                            option: 'u64',
+                        },
                     },
                     {
-                        name: 'lamports',
+                        name: 'pubkeyArray',
                         type: {
-                            option: 'u64',
+                            vec: 'publicKey',
+                        },
+                    },
+                    {
+                        name: 'message',
+                        type: {
+                            option: 'bytes',
                         },
                     },
                 ],
             },
         },
         {
-            name: 'TokenData',
+            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: 'index',
+                        docs: ['Unique index.'],
+                        type: 'u64',
                     },
                     {
-                        name: 'amount',
-                        docs: ['The amount of tokens this account holds.'],
+                        name: 'rolloverFee',
+                        docs: [
+                            'This fee is used for rent for the next account.',
+                            'It accumulates in the account so that once the corresponding Merkle tree account is full it can be rolled over',
+                        ],
                         type: 'u64',
                     },
                     {
-                        name: 'delegate',
+                        name: 'rolloverThreshold',
                         docs: [
-                            'If `delegate` is `Some` then `delegated_amount` represents',
-                            'the amount authorized by the delegate',
+                            'The threshold in percentage points when the account should be rolled over (95 corresponds to 95% filled).',
                         ],
-                        type: {
-                            option: 'publicKey',
-                        },
+                        type: 'u64',
                     },
                     {
-                        name: 'state',
-                        docs: ["The account's state"],
-                        type: {
-                            defined: 'AccountState',
-                        },
+                        name: 'networkFee',
+                        docs: ['Tip for maintaining the account.'],
+                        type: 'u64',
                     },
                     {
-                        name: 'isNative',
+                        name: 'rolledoverSlot',
                         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 slot when the account was rolled over, a rolled over account should not be written to.',
                         ],
-                        type: {
-                            option: 'u64',
-                        },
+                        type: 'u64',
                     },
                     {
-                        name: 'delegatedAmount',
-                        docs: ['The amount delegated'],
+                        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: 'TokenDataClient',
+            name: 'TokenData',
             type: {
                 kind: 'struct',
                 fields: [
@@ -832,7 +1344,9 @@ const IDL = {
                     {
                         name: 'state',
                         docs: ["The account's state"],
-                        type: 'u8',
+                        type: {
+                            defined: 'AccountState',
+                        },
                     },
                     {
                         name: 'isNative',
@@ -846,95 +1360,115 @@ const IDL = {
                             option: 'u64',
                         },
                     },
-                    {
-                        name: 'delegatedAmount',
-                        docs: ['The amount delegated'],
-                        type: 'u64',
-                    },
                 ],
             },
         },
+    ],
+    errors: [
         {
-            name: 'AccountState',
-            type: {
-                kind: 'enum',
-                variants: [
-                    {
-                        name: 'Uninitialized',
-                    },
-                    {
-                        name: 'Initialized',
-                    },
-                    {
-                        name: 'Frozen',
-                    },
-                ],
-            },
+            code: 6000,
+            name: 'PublicKeyAmountMissmatch',
+            msg: 'public keys and amounts must be of same length',
         },
         {
-            name: 'ErrorCode',
-            type: {
-                kind: 'enum',
-                variants: [
-                    {
-                        name: 'PublicKeyAmountMissmatch',
-                    },
-                    {
-                        name: 'MissingNewAuthorityPda',
-                    },
-                    {
-                        name: 'SignerCheckFailed',
-                    },
-                    {
-                        name: 'MintCheckFailed',
-                    },
-                    {
-                        name: 'ComputeInputSumFailed',
-                    },
-                    {
-                        name: 'ComputeOutputSumFailed',
-                    },
-                    {
-                        name: 'ComputeCompressSumFailed',
-                    },
-                    {
-                        name: 'ComputeDecompressSumFailed',
-                    },
-                    {
-                        name: 'SumCheckFailed',
-                    },
-                    {
-                        name: 'DecompressRecipientUndefinedForDecompress',
-                    },
-                    {
-                        name: 'CompressedPdaUndefinedForDecompress',
-                    },
-                    {
-                        name: 'DeCompressAmountUndefinedForDecompress',
-                    },
-                    {
-                        name: 'CompressedPdaUndefinedForCompress',
-                    },
-                    {
-                        name: 'DeCompressAmountUndefinedForCompress',
-                    },
-                    {
-                        name: 'DelegateUndefined',
-                    },
-                ],
-            },
+            code: 6001,
+            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',
         },
-    ],
-    errors: [
         {
-            code: 6000,
-            name: 'SignerCheckFailed',
-            msg: 'Signer check failed',
+            code: 6007,
+            name: 'DecompressRecipientUndefinedForDecompress',
+            msg: 'DecompressRecipientUndefinedForDecompress',
         },
         {
-            code: 6001,
-            name: 'CreateTransferInstructionFailed',
-            msg: 'Create transfer instruction failed',
+            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',
         },
     ],
 };
@@ -944,7 +1478,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 &&
@@ -955,27 +1489,35 @@ function packCompressedTokenAccounts(params) {
     /// Currently just packs 'delegate' to pubkeyArray
     const packedInputTokenData = [];
     /// pack inputs
-    inputCompressedTokenAccounts.forEach((account) => {
+    inputCompressedTokenAccounts.forEach((account, index) => {
         const merkleTreePubkeyIndex = stateless_js.getIndexOrAdd(_remainingAccounts, account.compressedAccount.merkleTree);
         const nullifierQueuePubkeyIndex = stateless_js.getIndexOrAdd(_remainingAccounts, account.compressedAccount.nullifierQueue);
         packedInputTokenData.push({
             amount: account.parsed.amount,
             delegateIndex,
-            delegatedAmount: account.parsed.delegatedAmount.eq(stateless_js.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 = stateless_js.padOutputStateMerkleTrees(outputStateTrees, outputCompressedAccountsLength, inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
-    const outputStateMerkleTreeIndices = [];
-    paddedOutputStateMerkleTrees.forEach(account => {
-        const indexMerkleTree = stateless_js.getIndexOrAdd(_remainingAccounts, account);
-        outputStateMerkleTreeIndices.push(indexMerkleTree);
+    const paddedOutputStateMerkleTrees = stateless_js.padOutputStateMerkleTrees(outputStateTrees, tokenTransferOutputs.length, inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
+    const packedOutputTokenData = [];
+    paddedOutputStateMerkleTrees.forEach((account, index) => {
+        var _a;
+        const merkleTreeIndex = stateless_js.getIndexOrAdd(_remainingAccounts, account);
+        packedOutputTokenData.push({
+            owner: tokenTransferOutputs[index].owner,
+            amount: tokenTransferOutputs[index].amount,
+            lamports: ((_a = tokenTransferOutputs[index].lamports) === null || _a === void 0 ? void 0 : _a.eq(stateless_js.bn(0)))
+                ? null
+                : tokenTransferOutputs[index].lamports,
+            merkleTreeIndex,
+        });
     });
     // to meta
     const remainingAccountMetas = _remainingAccounts.map((account) => ({
@@ -985,14 +1527,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 = anchor.utils.bytes.utf8.encode('mint_authority_pda');
 const SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE = 1461600;
 
 /** Address of the SPL Token program */
@@ -1000,7 +1541,7 @@ const TOKEN_PROGRAM_ID = new web3_js.PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf
 /** Address of the SPL Token 2022 program */
 new web3_js.PublicKey('TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb');
 /** Address of the SPL Associated Token Account program */
-new web3_js.PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
+const ASSOCIATED_TOKEN_PROGRAM_ID = new web3_js.PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
 /** Address of the special mint for wrapped native SOL in spl-token */
 new web3_js.PublicKey('So11111111111111111111111111111111111111112');
 /** Address of the special mint for wrapped native SOL in spl-token-2022 */
@@ -3295,334 +3836,16 @@ const encodeDecode = (layout) => {
     return { decode, encode };
 };
 
-var node = {};
-
-function commonjsRequire(path) {
-	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
-}
-
-var bindings = {exports: {}};
-
-var fileUriToPath_1;
-var hasRequiredFileUriToPath;
-
-function requireFileUriToPath () {
-	if (hasRequiredFileUriToPath) return fileUriToPath_1;
-	hasRequiredFileUriToPath = 1;
-	/**
-	 * Module dependencies.
-	 */
-
-	var sep = require$$0$1.sep || '/';
-
-	/**
-	 * Module exports.
-	 */
-
-	fileUriToPath_1 = fileUriToPath;
-
-	/**
-	 * File URI to Path function.
-	 *
-	 * @param {String} uri
-	 * @return {String} path
-	 * @api public
-	 */
-
-	function fileUriToPath (uri) {
-	  if ('string' != typeof uri ||
-	      uri.length <= 7 ||
-	      'file://' != uri.substring(0, 7)) {
-	    throw new TypeError('must pass in a file:// URI to convert to a file path');
-	  }
-
-	  var rest = decodeURI(uri.substring(7));
-	  var firstSlash = rest.indexOf('/');
-	  var host = rest.substring(0, firstSlash);
-	  var path = rest.substring(firstSlash + 1);
-
-	  // 2.  Scheme Definition
-	  // As a special case, <host> can be the string "localhost" or the empty
-	  // string; this is interpreted as "the machine from which the URL is
-	  // being interpreted".
-	  if ('localhost' == host) host = '';
-
-	  if (host) {
-	    host = sep + sep + host;
-	  }
-
-	  // 3.2  Drives, drive letters, mount points, file system root
-	  // Drive letters are mapped into the top of a file URI in various ways,
-	  // depending on the implementation; some applications substitute
-	  // vertical bar ("|") for the colon after the drive letter, yielding
-	  // "file:///c|/tmp/test.txt".  In some cases, the colon is left
-	  // unchanged, as in "file:///c:/tmp/test.txt".  In other cases, the
-	  // colon is simply omitted, as in "file:///c/tmp/test.txt".
-	  path = path.replace(/^(.+)\|/, '$1:');
-
-	  // for Windows, we need to invert the path separators from what a URI uses
-	  if (sep == '\\') {
-	    path = path.replace(/\//g, '\\');
-	  }
-
-	  if (/^.+\:/.test(path)) ; else {
-	    // unix path…
-	    path = sep + path;
-	  }
-
-	  return host + path;
-	}
-	return fileUriToPath_1;
-}
-
-/**
- * Module dependencies.
- */
-
-var hasRequiredBindings;
-
-function requireBindings () {
-	if (hasRequiredBindings) return bindings.exports;
-	hasRequiredBindings = 1;
-	(function (module, exports) {
-		var fs = require$$0$2,
-		  path = require$$0$1,
-		  fileURLToPath = requireFileUriToPath(),
-		  join = path.join,
-		  dirname = path.dirname,
-		  exists =
-		    (fs.accessSync &&
-		      function(path) {
-		        try {
-		          fs.accessSync(path);
-		        } catch (e) {
-		          return false;
-		        }
-		        return true;
-		      }) ||
-		    fs.existsSync ||
-		    path.existsSync,
-		  defaults = {
-		    arrow: process.env.NODE_BINDINGS_ARROW || ' → ',
-		    compiled: process.env.NODE_BINDINGS_COMPILED_DIR || 'compiled',
-		    platform: process.platform,
-		    arch: process.arch,
-		    nodePreGyp:
-		      'node-v' +
-		      process.versions.modules +
-		      '-' +
-		      process.platform +
-		      '-' +
-		      process.arch,
-		    version: process.versions.node,
-		    bindings: 'bindings.node',
-		    try: [
-		      // node-gyp's linked version in the "build" dir
-		      ['module_root', 'build', 'bindings'],
-		      // node-waf and gyp_addon (a.k.a node-gyp)
-		      ['module_root', 'build', 'Debug', 'bindings'],
-		      ['module_root', 'build', 'Release', 'bindings'],
-		      // Debug files, for development (legacy behavior, remove for node v0.9)
-		      ['module_root', 'out', 'Debug', 'bindings'],
-		      ['module_root', 'Debug', 'bindings'],
-		      // Release files, but manually compiled (legacy behavior, remove for node v0.9)
-		      ['module_root', 'out', 'Release', 'bindings'],
-		      ['module_root', 'Release', 'bindings'],
-		      // Legacy from node-waf, node <= 0.4.x
-		      ['module_root', 'build', 'default', 'bindings'],
-		      // Production "Release" buildtype binary (meh...)
-		      ['module_root', 'compiled', 'version', 'platform', 'arch', 'bindings'],
-		      // node-qbs builds
-		      ['module_root', 'addon-build', 'release', 'install-root', 'bindings'],
-		      ['module_root', 'addon-build', 'debug', 'install-root', 'bindings'],
-		      ['module_root', 'addon-build', 'default', 'install-root', 'bindings'],
-		      // node-pre-gyp path ./lib/binding/{node_abi}-{platform}-{arch}
-		      ['module_root', 'lib', 'binding', 'nodePreGyp', 'bindings']
-		    ]
-		  };
-
-		/**
-		 * The main `bindings()` function loads the compiled bindings for a given module.
-		 * It uses V8's Error API to determine the parent filename that this function is
-		 * being invoked from, which is then used to find the root directory.
-		 */
-
-		function bindings(opts) {
-		  // Argument surgery
-		  if (typeof opts == 'string') {
-		    opts = { bindings: opts };
-		  } else if (!opts) {
-		    opts = {};
-		  }
-
-		  // maps `defaults` onto `opts` object
-		  Object.keys(defaults).map(function(i) {
-		    if (!(i in opts)) opts[i] = defaults[i];
-		  });
-
-		  // Get the module root
-		  if (!opts.module_root) {
-		    opts.module_root = exports.getRoot(exports.getFileName());
-		  }
-
-		  // Ensure the given bindings name ends with .node
-		  if (path.extname(opts.bindings) != '.node') {
-		    opts.bindings += '.node';
-		  }
-
-		  // https://github.com/webpack/webpack/issues/4175#issuecomment-342931035
-		  var requireFunc =
-		    typeof __webpack_require__ === 'function'
-		      ? __non_webpack_require__
-		      : commonjsRequire;
-
-		  var tries = [],
-		    i = 0,
-		    l = opts.try.length,
-		    n,
-		    b,
-		    err;
-
-		  for (; i < l; i++) {
-		    n = join.apply(
-		      null,
-		      opts.try[i].map(function(p) {
-		        return opts[p] || p;
-		      })
-		    );
-		    tries.push(n);
-		    try {
-		      b = opts.path ? requireFunc.resolve(n) : requireFunc(n);
-		      if (!opts.path) {
-		        b.path = n;
-		      }
-		      return b;
-		    } catch (e) {
-		      if (e.code !== 'MODULE_NOT_FOUND' &&
-		          e.code !== 'QUALIFIED_PATH_RESOLUTION_FAILED' &&
-		          !/not find/i.test(e.message)) {
-		        throw e;
-		      }
-		    }
-		  }
+var browser = {};
 
-		  err = new Error(
-		    'Could not locate the bindings file. Tried:\n' +
-		      tries
-		        .map(function(a) {
-		          return opts.arrow + a;
-		        })
-		        .join('\n')
-		  );
-		  err.tries = tries;
-		  throw err;
-		}
-		module.exports = exports = bindings;
-
-		/**
-		 * Gets the filename of the JavaScript file that invokes this function.
-		 * Used to help find the root directory of a module.
-		 * Optionally accepts an filename argument to skip when searching for the invoking filename
-		 */
-
-		exports.getFileName = function getFileName(calling_file) {
-		  var origPST = Error.prepareStackTrace,
-		    origSTL = Error.stackTraceLimit,
-		    dummy = {},
-		    fileName;
-
-		  Error.stackTraceLimit = 10;
-
-		  Error.prepareStackTrace = function(e, st) {
-		    for (var i = 0, l = st.length; i < l; i++) {
-		      fileName = st[i].getFileName();
-		      if (fileName !== __filename) {
-		        if (calling_file) {
-		          if (fileName !== calling_file) {
-		            return;
-		          }
-		        } else {
-		          return;
-		        }
-		      }
-		    }
-		  };
-
-		  // run the 'prepareStackTrace' function above
-		  Error.captureStackTrace(dummy);
-		  dummy.stack;
-
-		  // cleanup
-		  Error.prepareStackTrace = origPST;
-		  Error.stackTraceLimit = origSTL;
-
-		  // handle filename that starts with "file://"
-		  var fileSchema = 'file://';
-		  if (fileName.indexOf(fileSchema) === 0) {
-		    fileName = fileURLToPath(fileName);
-		  }
-
-		  return fileName;
-		};
-
-		/**
-		 * Gets the root directory of a module, given an arbitrary filename
-		 * somewhere in the module tree. The "root directory" is the directory
-		 * containing the `package.json` file.
-		 *
-		 *   In:  /home/nate/node-native-module/lib/index.js
-		 *   Out: /home/nate/node-native-module
-		 */
-
-		exports.getRoot = function getRoot(file) {
-		  var dir = dirname(file),
-		    prev;
-		  while (true) {
-		    if (dir === '.') {
-		      // Avoids an infinite loop in rare cases, like the REPL
-		      dir = process.cwd();
-		    }
-		    if (
-		      exists(join(dir, 'package.json')) ||
-		      exists(join(dir, 'node_modules'))
-		    ) {
-		      // Found the 'package.json' file or 'node_modules' dir; we're done
-		      return dir;
-		    }
-		    if (prev === dir) {
-		      // Got to the top
-		      throw new Error(
-		        'Could not find module root given file: "' +
-		          file +
-		          '". Do you have a `package.json` file? '
-		      );
-		    }
-		    // Try the parent dir next
-		    prev = dir;
-		    dir = join(dir, '..');
-		  }
-		}; 
-	} (bindings, bindings.exports));
-	return bindings.exports;
-}
-
-Object.defineProperty(node, "__esModule", { value: true });
-let converter;
-{
-    try {
-        converter = requireBindings()('bigint_buffer');
-    }
-    catch (e) {
-        console.warn('bigint: Failed to load bindings, pure JS will be used (try npm run rebuild?)');
-    }
-}
+Object.defineProperty(browser, "__esModule", { value: true });
 /**
  * Convert a little-endian buffer into a BigInt.
  * @param buf The little-endian buffer to convert
  * @returns A BigInt with the little-endian representation of buf.
  */
 function toBigIntLE(buf) {
-    if (converter === undefined) {
+    {
         const reversed = Buffer.from(buf);
         reversed.reverse();
         const hex = reversed.toString('hex');
@@ -3631,25 +3854,23 @@ function toBigIntLE(buf) {
         }
         return BigInt(`0x${hex}`);
     }
-    return converter.toBigInt(buf, false);
 }
-var toBigIntLE_1 = node.toBigIntLE = toBigIntLE;
+var toBigIntLE_1 = browser.toBigIntLE = toBigIntLE;
 /**
  * Convert a big-endian buffer into a BigInt
  * @param buf The big-endian buffer to convert.
  * @returns A BigInt with the big-endian representation of buf.
  */
 function toBigIntBE(buf) {
-    if (converter === undefined) {
+    {
         const hex = buf.toString('hex');
         if (hex.length === 0) {
             return BigInt(0);
         }
         return BigInt(`0x${hex}`);
     }
-    return converter.toBigInt(buf, true);
 }
-node.toBigIntBE = toBigIntBE;
+browser.toBigIntBE = toBigIntBE;
 /**
  * Convert a BigInt to a little-endian buffer.
  * @param num   The BigInt to convert.
@@ -3657,16 +3878,14 @@ node.toBigIntBE = toBigIntBE;
  * @returns A little-endian buffer representation of num.
  */
 function toBufferLE(num, width) {
-    if (converter === undefined) {
+    {
         const hex = num.toString(16);
         const buffer = Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
         buffer.reverse();
         return buffer;
     }
-    // Allocation is done here, since it is slower using napi in C
-    return converter.fromBigInt(num, Buffer.allocUnsafe(width), false);
 }
-var toBufferLE_1 = node.toBufferLE = toBufferLE;
+var toBufferLE_1 = browser.toBufferLE = toBufferLE;
 /**
  * Convert a BigInt to a big-endian buffer.
  * @param num   The BigInt to convert.
@@ -3674,13 +3893,12 @@ var toBufferLE_1 = node.toBufferLE = toBufferLE;
  * @returns A big-endian buffer representation of num.
  */
 function toBufferBE(num, width) {
-    if (converter === undefined) {
+    {
         const hex = num.toString(16);
         return Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
     }
-    return converter.fromBigInt(num, Buffer.allocUnsafe(width), true);
 }
-node.toBufferBE = toBufferBE;
+browser.toBufferBE = toBufferBE;
 
 const bigInt = (length) => (property) => {
     const layout = blob(length, property);
@@ -3728,6 +3946,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) {
@@ -3767,6 +4041,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 */
@@ -3814,6 +4092,112 @@ function createApproveInstruction(account, delegate, owner, amount, multiSigners
     return new web3_js.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'),
@@ -3826,6 +4210,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 && !web3_js.PublicKey.isOnCurve(owner.toBuffer()))
+        throw new TokenOwnerOffCurveError();
+    const [address] = web3_js.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: web3_js.SystemProgram.programId, isSigner: false, isWritable: false },
+        { pubkey: programId, isSigner: false, isWritable: false },
+    ];
+    return new web3_js.TransactionInstruction({
+        keys,
+        programId: associatedTokenProgramId,
+        data: instructionData,
+    });
+}
 
 /** TODO: docs */
 const initializeMint2InstructionData = struct([
@@ -3859,10 +4291,93 @@ function createInitializeMint2Instruction(mint, decimals, mintAuthority, freezeA
     return new web3_js.TransactionInstruction({ keys, programId, data });
 }
 
-var _a;
+/**
+ * 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 web3_js.Transaction().add(createAssociatedTokenAccountInstruction(payer.publicKey, associatedToken, owner, mint, programId, associatedTokenProgramId));
+                await web3_js.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 web3_js.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), stateless_js.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 => {
@@ -3871,12 +4386,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 = stateless_js.bn(amount);
     const inputAmount = sumUpTokenAmount(inputCompressedTokenAccounts);
@@ -3909,6 +4435,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 = stateless_js.bn(amount);
     const inputLamports = stateless_js.sumUpLamports(inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
@@ -3935,6 +4468,7 @@ class CompressedTokenProgram {
      * @internal
      */
     constructor() { }
+    /** @internal */
     static get program() {
         if (!this._program) {
             this.initializeProgram();
@@ -3942,12 +4476,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 = web3_js.Keypair.generate();
             const mockConnection = new web3_js.Connection('http://127.0.0.1:8899', 'confirmed');
             const mockProvider = new anchor.AnchorProvider(mockConnection, stateless_js.useWallet(mockKeypair), stateless_js.confirmConfig);
@@ -3966,8 +4502,12 @@ class CompressedTokenProgram {
         const [address, _] = web3_js.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 = web3_js.SystemProgram.createAccount({
             fromPubkey: feePayer,
             lamports: rentExemptBalance,
@@ -3975,224 +4515,270 @@ 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 = web3_js.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: web3_js.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 = stateless_js.defaultStaticAccountsStruct();
         const { mint, feePayer, authority, merkleTree, toPubkey, amount } = params;
         const tokenPoolPda = this.deriveTokenPoolPda(mint);
-        const mintAuthorityPda = this.deriveMintAuthorityPda(authority, mint);
         const amounts = stateless_js.toArray(amount).map(amount => stateless_js.bn(amount));
         const toPubkeys = stateless_js.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: stateless_js.LightSystemProgram.programId,
+            lightSystemProgram: stateless_js.LightSystemProgram.programId,
             registeredProgramPda: systemKeys.registeredProgramPda,
             noopProgram: systemKeys.noopProgram,
             accountCompressionAuthority: systemKeys.accountCompressionAuthority,
             accountCompressionProgram: systemKeys.accountCompressionProgram,
-            merkleTree,
+            merkleTree: merkleTree !== null && merkleTree !== void 0 ? merkleTree : stateless_js.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: require$$0.Buffer.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, } = stateless_js.defaultStaticAccountsStruct();
         const instruction = await this.program.methods
-            .transfer(encodedData, null)
+            .transfer(encodedData)
             .accounts({
             feePayer: payer,
             authority: currentOwner,
             cpiAuthorityPda: this.deriveCpiAuthorityPda,
-            compressedPdaProgram: stateless_js.LightSystemProgram.programId,
+            lightSystemProgram: stateless_js.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 [
-            web3_js.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 = stateless_js.bn(params.amount);
-        const outputCompressedAccounts = [
+        const tokenTransferOutputs = [
             {
                 owner: toAddress,
                 amount,
                 lamports: stateless_js.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: require$$0.Buffer.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, } = stateless_js.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: stateless_js.LightSystemProgram.programId,
+            lightSystemProgram: stateless_js.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 [
-            web3_js.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 = stateless_js.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: require$$0.Buffer.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, } = stateless_js.defaultStaticAccountsStruct();
         const instruction = await this.program.methods
-            .transfer(encodedData, null)
+            .transfer(encodedData)
             .accounts({
             feePayer: payer,
             authority: currentOwner,
             cpiAuthorityPda: this.deriveCpiAuthorityPda,
-            compressedPdaProgram: stateless_js.LightSystemProgram.programId,
+            lightSystemProgram: stateless_js.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 [
-            web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }),
-            instruction,
-        ];
+        return instruction;
     }
 }
-_a = CompressedTokenProgram;
 /**
  * Public key that identifies the CompressedPda program
  */
-CompressedTokenProgram.programId = new web3_js.PublicKey(
-// TODO: can add check to ensure its consistent with the idl
-'9sixVEthz2kMSKfeApZXHwuboT6DZuT6crAYJTciUCqE');
+CompressedTokenProgram.programId = new web3_js.PublicKey('HXVfQ44ATEi9WBKLSCCwM54KokdkzqXci9xCQ7ST9SYN');
 CompressedTokenProgram._program = null;
-/** @internal */
-CompressedTokenProgram.deriveMintAuthorityPda = (authority, mint) => {
-    const [pubkey] = web3_js.PublicKey.findProgramAddressSync([MINT_AUTHORITY_SEED, authority.toBuffer(), mint.toBuffer()], _a.programId);
-    return pubkey;
-};
+
+/**
+ * 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 = stateless_js.dedupeSigner(payer, [authority]);
+    const tx = stateless_js.buildAndSignTx([
+        web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }),
+        ...ixs,
+    ], payer, blockhash, additionalSigners);
+    const txId = await stateless_js.sendAndConfirmTx(rpc, tx, confirmOptions);
+    return txId;
+}
 
 /**
  * Compress SPL tokens
@@ -4212,9 +4798,9 @@ CompressedTokenProgram.deriveMintAuthorityPda = (authority, mint) => {
  *
  * @return Signature of the confirmed transaction
  */
-async function compress(rpc, payer, mint, amount, owner, sourceTokenAccount, toAddress, merkleTree = stateless_js.defaultTestStateTreeAccounts().merkleTree, confirmOptions) {
+async function compress(rpc, payer, mint, amount, owner, sourceTokenAccount, toAddress, merkleTree, confirmOptions) {
     amount = stateless_js.bn(amount);
-    const ixs = await CompressedTokenProgram.compress({
+    const [approveIx, compressIx] = await CompressedTokenProgram.compress({
         payer: payer.publicKey,
         owner: owner.publicKey,
         source: sourceTokenAccount,
@@ -4225,7 +4811,13 @@ async function compress(rpc, payer, mint, amount, owner, sourceTokenAccount, toA
     });
     const blockhashCtx = await rpc.getLatestBlockhash();
     const additionalSigners = stateless_js.dedupeSigner(payer, [owner]);
-    const signedTx = stateless_js.buildAndSignTx(ixs, payer, blockhashCtx.blockhash, additionalSigners);
+    const signedTx = stateless_js.buildAndSignTx([
+        web3_js.ComputeBudgetProgram.setComputeUnitLimit({
+            units: 1000000,
+        }),
+        approveIx,
+        compressIx,
+    ], payer, blockhashCtx.blockhash, additionalSigners);
     const txId = await stateless_js.sendAndConfirmTx(rpc, signedTx, confirmOptions, blockhashCtx);
     return txId;
 }
@@ -4240,7 +4832,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
  *
  *
@@ -4248,14 +4841,14 @@ async function compress(rpc, payer, mint, amount, owner, sourceTokenAccount, toA
  */
 async function transfer(rpc, payer, mint, amount, owner, toAddress, 
 /// TODO: allow multiple
-merkleTree = stateless_js.defaultTestStateTreeAccounts().merkleTree, confirmOptions) {
+merkleTree, confirmOptions) {
     amount = stateless_js.bn(amount);
     const compressedTokenAccounts = await rpc.getCompressedTokenAccountsByOwner(owner.publicKey, {
         mint,
     });
     const [inputAccounts] = selectMinCompressedTokenAccountsForTransfer(compressedTokenAccounts, amount);
     const proof = await rpc.getValidityProof(inputAccounts.map(account => stateless_js.bn(account.compressedAccount.hash)));
-    const ixs = await CompressedTokenProgram.transfer({
+    const ix = await CompressedTokenProgram.transfer({
         payer: payer.publicKey,
         inputCompressedTokenAccounts: inputAccounts,
         toAddress,
@@ -4266,7 +4859,7 @@ merkleTree = stateless_js.defaultTestStateTreeAccounts().merkleTree, confirmOpti
     });
     const { blockhash } = await rpc.getLatestBlockhash();
     const additionalSigners = stateless_js.dedupeSigner(payer, [owner]);
-    const signedTx = stateless_js.buildAndSignTx(ixs, payer, blockhash, additionalSigners);
+    const signedTx = stateless_js.buildAndSignTx([web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }), ix], payer, blockhash, additionalSigners);
     const txId = await stateless_js.sendAndConfirmTx(rpc, signedTx, confirmOptions);
     return txId;
 }
@@ -4319,7 +4912,7 @@ function selectMinCompressedTokenAccountsForTransfer(accounts, transferAmount) {
  */
 async function decompress(rpc, payer, mint, amount, owner, toAddress, 
 /// TODO: allow multiple
-merkleTree = stateless_js.defaultTestStateTreeAccounts().merkleTree, confirmOptions) {
+merkleTree, confirmOptions) {
     amount = stateless_js.bn(amount);
     const compressedTokenAccounts = await rpc.getCompressedTokenAccountsByOwner(owner.publicKey, {
         mint,
@@ -4327,7 +4920,7 @@ merkleTree = stateless_js.defaultTestStateTreeAccounts().merkleTree, confirmOpti
     /// TODO: consider using a different selection algorithm
     const [inputAccounts] = selectMinCompressedTokenAccountsForTransfer(compressedTokenAccounts, amount);
     const proof = await rpc.getValidityProof(inputAccounts.map(account => stateless_js.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
@@ -4338,7 +4931,7 @@ merkleTree = stateless_js.defaultTestStateTreeAccounts().merkleTree, confirmOpti
     });
     const { blockhash } = await rpc.getLatestBlockhash();
     const additionalSigners = stateless_js.dedupeSigner(payer, [owner]);
-    const signedTx = stateless_js.buildAndSignTx(ixs, payer, blockhash, additionalSigners);
+    const signedTx = stateless_js.buildAndSignTx([web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }), ix], payer, blockhash, additionalSigners);
     const txId = await stateless_js.sendAndConfirmTx(rpc, signedTx, confirmOptions);
     return txId;
 }
@@ -4348,7 +4941,7 @@ merkleTree = stateless_js.defaultTestStateTreeAccounts().merkleTree, confirmOpti
  *
  * @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
@@ -4361,12 +4954,12 @@ async function createMint(rpc, payer, mintAuthority, decimals, keypair = web3_js
         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 = stateless_js.dedupeSigner(payer, [mintAuthority, keypair]);
+    const additionalSigners = stateless_js.dedupeSigner(payer, [keypair]);
     const tx = stateless_js.buildAndSignTx(ixs, payer, blockhash, additionalSigners);
     const txId = await stateless_js.sendAndConfirmTx(rpc, tx, confirmOptions);
     return { mint: keypair.publicKey, transactionSignature: txId };
@@ -4387,8 +4980,7 @@ async function createMint(rpc, payer, mintAuthority, decimals, keypair = web3_js
  *
  * @return Signature of the confirmed transaction
  */
-async function mintTo(rpc, payer, mint, destination, authority, amount, merkleTree = stateless_js.defaultTestStateTreeAccounts().merkleTree, // DEFAULT IF NOT PROVIDED
-confirmOptions) {
+async function mintTo(rpc, payer, mint, destination, authority, amount, merkleTree, confirmOptions) {
     const additionalSigners = stateless_js.dedupeSigner(payer, [authority]);
     const ix = await CompressedTokenProgram.mintTo({
         feePayer: payer.publicKey,
@@ -4404,12 +4996,34 @@ 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 = stateless_js.buildAndSignTx([ix], payer, blockhash);
+    const txId = await stateless_js.sendAndConfirmTx(rpc, tx, confirmOptions);
+    return txId;
+}
+
 exports.CPI_AUTHORITY_SEED = CPI_AUTHORITY_SEED;
 exports.CompressedTokenProgram = CompressedTokenProgram;
 exports.IDL = IDL;
-exports.MINT_AUTHORITY_SEED = MINT_AUTHORITY_SEED;
 exports.POOL_SEED = POOL_SEED;
 exports.SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE = SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE;
+exports.approveAndMintTo = approveAndMintTo;
 exports.compress = compress;
 exports.createDecompressOutputState = createDecompressOutputState;
 exports.createMint = createMint;
@@ -4417,7 +5031,8 @@ exports.createTransferOutputState = createTransferOutputState;
 exports.decompress = decompress;
 exports.mintTo = mintTo;
 exports.packCompressedTokenAccounts = packCompressedTokenAccounts;
-exports.parseInputTokenData = parseInputTokenData;
+exports.parseTokenData = parseTokenData;
+exports.registerMint = registerMint;
 exports.selectMinCompressedTokenAccountsForTransfer = selectMinCompressedTokenAccountsForTransfer;
 exports.sumUpTokenAmount = sumUpTokenAmount;
 exports.transfer = transfer;