@lightprotocol/compressed-token 0.1.2 → 0.2.0

package/dist/es/browser/index.js

@@ -1,9 +1,9 @@
 import { getIndexOrAdd, bn, padOutputStateMerkleTrees, useWallet, confirmConfig, defaultStaticAccountsStruct, toArray, LightSystemProgram, sumUpLamports, validateSufficientBalance, validateSameOwner, dedupeSigner, buildAndSignTx, sendAndConfirmTx, defaultTestStateTreeAccounts } from '@lightprotocol/stateless.js';
 import { utils, AnchorProvider, setProvider, Program } from '@coral-xyz/anchor';
-import { PublicKey, TransactionInstruction, Keypair, Connection, SystemProgram, ComputeBudgetProgram } from '@solana/web3.js';
+import { PublicKey, TransactionInstruction, SystemProgram, Transaction, sendAndConfirmTransaction, Keypair, Connection, ComputeBudgetProgram } from '@solana/web3.js';
 
 const IDL = {
-    version: '0.3.0',
+    version: '0.3.1',
     name: 'light_compressed_token',
     constants: [
         {
@@ -16,9 +16,10 @@ const IDL = {
         {
             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: [
                 {
@@ -98,7 +99,7 @@ const IDL = {
                     isSigner: false,
                 },
                 {
-                    name: 'compressedPdaProgram',
+                    name: 'lightSystemProgram',
                     isMut: false,
                     isSigner: false,
                 },
@@ -132,6 +133,11 @@ const IDL = {
                     isMut: false,
                     isSigner: false,
                 },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
             ],
             args: [
                 {
@@ -146,6 +152,10 @@ const IDL = {
                         vec: 'u64',
                     },
                 },
+                {
+                    name: 'bump',
+                    type: 'u8',
+                },
             ],
         },
         {
@@ -153,7 +163,7 @@ const IDL = {
             accounts: [
                 {
                     name: 'feePayer',
-                    isMut: false,
+                    isMut: true,
                     isSigner: true,
                 },
                 {
@@ -167,7 +177,7 @@ const IDL = {
                     isSigner: false,
                 },
                 {
-                    name: 'compressedPdaProgram',
+                    name: 'lightSystemProgram',
                     isMut: false,
                     isSigner: false,
                 },
@@ -214,139 +224,161 @@ const IDL = {
                     isSigner: false,
                     isOptional: true,
                 },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
             ],
             args: [
                 {
                     name: 'inputs',
                     type: 'bytes',
                 },
-                {
-                    name: 'cpiContext',
-                    type: {
-                        option: {
-                            defined: 'CompressedCpiContext',
-                        },
-                    },
-                },
             ],
         },
     ],
     types: [
         {
-            name: 'CompressedAccountWithMerkleContext',
+            name: 'InstructionDataInvoke',
             type: {
                 kind: 'struct',
                 fields: [
                     {
-                        name: 'compressedAccount',
+                        name: 'proof',
                         type: {
-                            defined: 'CompressedAccount',
+                            option: {
+                                defined: 'CompressedProof',
+                            },
                         },
                     },
                     {
-                        name: 'merkleTreePubkeyIndex',
-                        type: 'u8',
+                        name: 'inputRootIndices',
+                        type: {
+                            vec: 'u16',
+                        },
                     },
                     {
-                        name: 'nullifierQueuePubkeyIndex',
-                        type: 'u8',
+                        name: 'inputCompressedAccountsWithMerkleContext',
+                        type: {
+                            vec: {
+                                defined: 'PackedCompressedAccountWithMerkleContext',
+                            },
+                        },
                     },
                     {
-                        name: 'leafIndex',
-                        type: 'u32',
+                        name: 'outputCompressedAccounts',
+                        type: {
+                            vec: {
+                                defined: 'CompressedAccount',
+                            },
+                        },
                     },
-                ],
-            },
-        },
-        {
-            name: 'MerkleContext',
-            type: {
-                kind: 'struct',
-                fields: [
                     {
-                        name: 'merkleTreePubkey',
-                        type: 'publicKey',
+                        name: 'outputStateMerkleTreeAccountIndices',
+                        docs: [
+                            'The indices of the accounts in the output state merkle tree.',
+                        ],
+                        type: 'bytes',
                     },
                     {
-                        name: 'nullifierQueuePubkey',
-                        type: 'publicKey',
+                        name: 'relayFee',
+                        type: {
+                            option: 'u64',
+                        },
                     },
                     {
-                        name: 'leafIndex',
-                        type: 'u32',
+                        name: 'newAddressParams',
+                        type: {
+                            vec: {
+                                defined: 'NewAddressParamsPacked',
+                            },
+                        },
+                    },
+                    {
+                        name: 'compressionLamports',
+                        type: {
+                            option: 'u64',
+                        },
+                    },
+                    {
+                        name: 'isCompress',
+                        type: 'bool',
                     },
                 ],
             },
         },
         {
-            name: 'PackedMerkleContext',
+            name: 'NewAddressParamsPacked',
             type: {
                 kind: 'struct',
                 fields: [
                     {
-                        name: 'merkleTreePubkeyIndex',
+                        name: 'seed',
+                        type: {
+                            array: ['u8', 32],
+                        },
+                    },
+                    {
+                        name: 'addressQueueAccountIndex',
                         type: 'u8',
                     },
                     {
-                        name: 'nullifierQueuePubkeyIndex',
+                        name: 'addressMerkleTreeAccountIndex',
                         type: 'u8',
                     },
                     {
-                        name: 'leafIndex',
-                        type: 'u32',
+                        name: 'addressMerkleTreeRootIndex',
+                        type: 'u16',
                     },
                 ],
             },
         },
         {
-            name: 'CompressedAccount',
+            name: 'NewAddressParams',
             type: {
                 kind: 'struct',
                 fields: [
                     {
-                        name: 'owner',
-                        type: 'publicKey',
+                        name: 'seed',
+                        type: {
+                            array: ['u8', 32],
+                        },
                     },
                     {
-                        name: 'lamports',
-                        type: 'u64',
+                        name: 'addressQueuePubkey',
+                        type: 'publicKey',
                     },
                     {
-                        name: 'address',
-                        type: {
-                            option: {
-                                array: ['u8', 32],
-                            },
-                        },
+                        name: 'addressMerkleTreePubkey',
+                        type: 'publicKey',
                     },
                     {
-                        name: 'data',
-                        type: {
-                            option: {
-                                defined: 'CompressedAccountData',
-                            },
-                        },
+                        name: 'addressMerkleTreeRootIndex',
+                        type: 'u16',
                     },
                 ],
             },
         },
         {
-            name: 'CompressedAccountData',
+            name: 'CompressedProof',
             type: {
                 kind: 'struct',
                 fields: [
                     {
-                        name: 'discriminator',
+                        name: 'a',
                         type: {
-                            array: ['u8', 8],
+                            array: ['u8', 32],
                         },
                     },
                     {
-                        name: 'data',
-                        type: 'bytes',
+                        name: 'b',
+                        type: {
+                            array: ['u8', 64],
+                        },
                     },
                     {
-                        name: 'dataHash',
+                        name: 'c',
                         type: {
                             array: ['u8', 32],
                         },
@@ -355,57 +387,37 @@ const IDL = {
             },
         },
         {
-            name: 'CompressedCpiContext',
-            docs: ['To spend multiple compressed'],
+            name: 'InstructionDataInvokeCpi',
             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.',
-                        ],
-                        type: 'u8',
-                    },
-                    {
-                        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: 'proof',
+                        type: {
+                            option: {
+                                defined: 'CompressedProof',
+                            },
+                        },
                     },
-                ],
-            },
-        },
-        {
-            name: 'PublicTransactionEvent',
-            type: {
-                kind: 'struct',
-                fields: [
                     {
-                        name: 'inputCompressedAccountHashes',
+                        name: 'newAddressParams',
                         type: {
                             vec: {
-                                array: ['u8', 32],
+                                defined: 'NewAddressParamsPacked',
                             },
                         },
                     },
                     {
-                        name: 'outputCompressedAccountHashes',
+                        name: 'inputRootIndices',
                         type: {
-                            vec: {
-                                array: ['u8', 32],
-                            },
+                            vec: 'u16',
                         },
                     },
                     {
-                        name: 'inputCompressedAccounts',
+                        name: 'inputCompressedAccountsWithMerkleContext',
                         type: {
                             vec: {
-                                defined: 'CompressedAccountWithMerkleContext',
+                                defined: 'PackedCompressedAccountWithMerkleContext',
                             },
                         },
                     },
@@ -419,16 +431,19 @@ const IDL = {
                     },
                     {
                         name: 'outputStateMerkleTreeAccountIndices',
+                        docs: [
+                            'The indices of the accounts in the output state merkle tree.',
+                        ],
                         type: 'bytes',
                     },
                     {
-                        name: 'outputLeafIndices',
+                        name: 'relayFee',
                         type: {
-                            vec: 'u32',
+                            option: 'u64',
                         },
                     },
                     {
-                        name: 'relayFee',
+                        name: 'compressionLamports',
                         type: {
                             option: 'u64',
                         },
@@ -438,97 +453,128 @@ const IDL = {
                         type: 'bool',
                     },
                     {
-                        name: 'compressionLamports',
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                    {
-                        name: 'pubkeyArray',
+                        name: 'signerSeeds',
                         type: {
-                            vec: 'publicKey',
+                            vec: 'bytes',
                         },
                     },
                     {
-                        name: 'message',
+                        name: 'cpiContext',
                         type: {
-                            option: 'bytes',
+                            option: {
+                                defined: 'CompressedCpiContext',
+                            },
                         },
                     },
                 ],
             },
         },
         {
-            name: 'InstructionDataTransfer',
+            name: 'PackedCompressedAccountWithMerkleContext',
             type: {
                 kind: 'struct',
                 fields: [
                     {
-                        name: 'proof',
+                        name: 'compressedAccount',
                         type: {
-                            option: {
-                                defined: 'CompressedProof',
-                            },
+                            defined: 'CompressedAccount',
                         },
                     },
                     {
-                        name: 'newAddressParams',
+                        name: 'merkleContext',
                         type: {
-                            vec: {
-                                defined: 'NewAddressParamsPacked',
-                            },
+                            defined: 'PackedMerkleContext',
                         },
                     },
+                ],
+            },
+        },
+        {
+            name: 'CompressedAccountWithMerkleContext',
+            type: {
+                kind: 'struct',
+                fields: [
                     {
-                        name: 'inputRootIndices',
+                        name: 'compressedAccount',
                         type: {
-                            vec: 'u16',
+                            defined: 'CompressedAccount',
                         },
                     },
                     {
-                        name: 'inputCompressedAccountsWithMerkleContext',
+                        name: 'merkleContext',
                         type: {
-                            vec: {
-                                defined: 'CompressedAccountWithMerkleContext',
-                            },
+                            defined: 'MerkleContext',
                         },
                     },
+                ],
+            },
+        },
+        {
+            name: 'MerkleContext',
+            type: {
+                kind: 'struct',
+                fields: [
                     {
-                        name: 'outputCompressedAccounts',
-                        type: {
-                            vec: {
-                                defined: 'CompressedAccount',
-                            },
-                        },
+                        name: 'merkleTreePubkey',
+                        type: 'publicKey',
                     },
                     {
-                        name: 'outputStateMerkleTreeAccountIndices',
-                        docs: [
-                            'The indices of the accounts in the output state merkle tree.',
-                        ],
-                        type: 'bytes',
+                        name: 'nullifierQueuePubkey',
+                        type: 'publicKey',
                     },
                     {
-                        name: 'relayFee',
-                        type: {
-                            option: 'u64',
-                        },
+                        name: 'leafIndex',
+                        type: 'u32',
                     },
+                ],
+            },
+        },
+        {
+            name: 'PackedMerkleContext',
+            type: {
+                kind: 'struct',
+                fields: [
                     {
-                        name: 'compressionLamports',
-                        type: {
-                            option: 'u64',
-                        },
+                        name: 'merkleTreePubkeyIndex',
+                        type: 'u8',
                     },
                     {
-                        name: 'isCompress',
-                        type: 'bool',
+                        name: 'nullifierQueuePubkeyIndex',
+                        type: 'u8',
                     },
                     {
-                        name: 'signerSeeds',
+                        name: 'leafIndex',
+                        type: 'u32',
+                    },
+                ],
+            },
+        },
+        {
+            name: 'CompressedAccount',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'owner',
+                        type: 'publicKey',
+                    },
+                    {
+                        name: 'lamports',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'address',
+                        type: {
+                            option: {
+                                array: ['u8', 32],
+                            },
+                        },
+                    },
+                    {
+                        name: 'data',
                         type: {
                             option: {
-                                vec: 'bytes',
+                                defined: 'CompressedAccountData',
                             },
                         },
                     },
@@ -536,79 +582,111 @@ const IDL = {
             },
         },
         {
-            name: 'NewAddressParamsPacked',
+            name: 'CompressedAccountData',
             type: {
                 kind: 'struct',
                 fields: [
                     {
-                        name: 'seed',
+                        name: 'discriminator',
                         type: {
-                            array: ['u8', 32],
+                            array: ['u8', 8],
                         },
                     },
                     {
-                        name: 'addressQueueAccountIndex',
-                        type: 'u8',
-                    },
-                    {
-                        name: 'addressMerkleTreeAccountIndex',
-                        type: 'u8',
+                        name: 'data',
+                        type: 'bytes',
                     },
                     {
-                        name: 'addressMerkleTreeRootIndex',
-                        type: 'u16',
+                        name: 'dataHash',
+                        type: {
+                            array: ['u8', 32],
+                        },
                     },
                 ],
             },
         },
         {
-            name: 'NewAddressParams',
+            name: 'PublicTransactionEvent',
             type: {
                 kind: 'struct',
                 fields: [
                     {
-                        name: 'seed',
+                        name: 'inputCompressedAccountHashes',
                         type: {
-                            array: ['u8', 32],
+                            vec: {
+                                array: ['u8', 32],
+                            },
                         },
                     },
                     {
-                        name: 'addressQueuePubkey',
-                        type: 'publicKey',
+                        name: 'outputCompressedAccountHashes',
+                        type: {
+                            vec: {
+                                array: ['u8', 32],
+                            },
+                        },
                     },
                     {
-                        name: 'addressMerkleTreePubkey',
-                        type: 'publicKey',
+                        name: 'outputCompressedAccounts',
+                        type: {
+                            vec: {
+                                defined: 'CompressedAccount',
+                            },
+                        },
                     },
                     {
-                        name: 'addressMerkleTreeRootIndex',
-                        type: 'u16',
+                        name: 'outputStateMerkleTreeAccountIndices',
+                        type: 'bytes',
+                    },
+                    {
+                        name: 'outputLeafIndices',
+                        type: {
+                            vec: 'u32',
+                        },
+                    },
+                    {
+                        name: 'relayFee',
+                        type: {
+                            option: 'u64',
+                        },
+                    },
+                    {
+                        name: 'isCompress',
+                        type: 'bool',
+                    },
+                    {
+                        name: 'compressionLamports',
+                        type: {
+                            option: 'u64',
+                        },
+                    },
+                    {
+                        name: 'pubkeyArray',
+                        type: {
+                            vec: 'publicKey',
+                        },
+                    },
+                    {
+                        name: 'message',
+                        type: {
+                            option: 'bytes',
+                        },
                     },
                 ],
             },
         },
         {
-            name: 'CompressedProof',
+            name: 'CompressedCpiContext',
             type: {
                 kind: 'struct',
                 fields: [
                     {
-                        name: 'a',
-                        type: {
-                            array: ['u8', 32],
-                        },
-                    },
-                    {
-                        name: 'b',
-                        type: {
-                            array: ['u8', 64],
-                        },
+                        name: 'setContext',
+                        type: 'bool',
                     },
                     {
-                        name: 'c',
-                        type: {
-                            array: ['u8', 32],
-                        },
+                        name: 'cpiContextAccountIndex',
+                        type: 'u8',
                     },
                 ],
             },
@@ -641,16 +719,10 @@ const IDL = {
                         },
                     },
                     {
-                        name: 'merkleTreePubkeyIndex',
-                        type: 'u8',
-                    },
-                    {
-                        name: 'nullifierQueuePubkeyIndex',
-                        type: 'u8',
-                    },
-                    {
-                        name: 'leafIndex',
-                        type: 'u32',
+                        name: 'merkleContext',
+                        type: {
+                            defined: 'PackedMerkleContext',
+                        },
                     },
                 ],
             },
@@ -712,6 +784,14 @@ const IDL = {
                             option: 'u64',
                         },
                     },
+                    {
+                        name: 'cpiContext',
+                        type: {
+                            option: {
+                                defined: 'CompressedCpiContext',
+                            },
+                        },
+                    },
                 ],
             },
         },
@@ -794,69 +874,11 @@ const IDL = {
                 ],
             },
         },
-        {
-            name: 'TokenDataClient',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'mint',
-                        docs: ['The mint associated with this account'],
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'owner',
-                        docs: ['The owner of this account.'],
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'amount',
-                        docs: ['The amount of tokens this account holds.'],
-                        type: 'u64',
-                    },
-                    {
-                        name: 'delegate',
-                        docs: [
-                            'If `delegate` is `Some` then `delegated_amount` represents',
-                            'the amount authorized by the delegate',
-                        ],
-                        type: {
-                            option: 'publicKey',
-                        },
-                    },
-                    {
-                        name: 'state',
-                        docs: ["The account's state"],
-                        type: 'u8',
-                    },
-                    {
-                        name: 'isNative',
-                        docs: [
-                            'If is_some, this is a native token, and the value logs the rent-exempt',
-                            'reserve. An Account is required to be rent-exempt, so the value is',
-                            'used by the Processor to ensure that wrapped SOL accounts do not',
-                            'drop below this threshold.',
-                        ],
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                    {
-                        name: 'delegatedAmount',
-                        docs: ['The amount delegated'],
-                        type: 'u64',
-                    },
-                ],
-            },
-        },
         {
             name: 'AccountState',
             type: {
                 kind: 'enum',
                 variants: [
-                    {
-                        name: 'Uninitialized',
-                    },
                     {
                         name: 'Initialized',
                     },
@@ -960,9 +982,11 @@ function packCompressedTokenAccounts(params) {
                 ? null
                 : account.parsed.delegatedAmount,
             isNative: account.parsed.isNative,
-            merkleTreePubkeyIndex,
-            nullifierQueuePubkeyIndex,
-            leafIndex: account.compressedAccount.leafIndex,
+            merkleContext: {
+                merkleTreePubkeyIndex,
+                nullifierQueuePubkeyIndex,
+                leafIndex: account.compressedAccount.leafIndex,
+            },
         });
     });
     /// pack output state trees
@@ -995,7 +1019,7 @@ const TOKEN_PROGRAM_ID = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ
 /** Address of the SPL Token 2022 program */
 new PublicKey('TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb');
 /** Address of the SPL Associated Token Account program */
-new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
+const ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
 /** Address of the special mint for wrapped native SOL in spl-token */
 new PublicKey('So11111111111111111111111111111111111111112');
 /** Address of the special mint for wrapped native SOL in spl-token-2022 */
@@ -5424,6 +5448,62 @@ const publicKey = (property) => {
     return publicKeyLayout;
 };
 
+/** Base class for errors */
+class TokenError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+/** Thrown if an account is not found at the expected address */
+class TokenAccountNotFoundError extends TokenError {
+    constructor() {
+        super(...arguments);
+        this.name = 'TokenAccountNotFoundError';
+    }
+}
+/** Thrown if a program state account is not a valid Account */
+class TokenInvalidAccountError extends TokenError {
+    constructor() {
+        super(...arguments);
+        this.name = 'TokenInvalidAccountError';
+    }
+}
+/** Thrown if a program state account is not owned by the expected token program */
+class TokenInvalidAccountOwnerError extends TokenError {
+    constructor() {
+        super(...arguments);
+        this.name = 'TokenInvalidAccountOwnerError';
+    }
+}
+/** Thrown if the byte length of an program state account doesn't match the expected size */
+class TokenInvalidAccountSizeError extends TokenError {
+    constructor() {
+        super(...arguments);
+        this.name = 'TokenInvalidAccountSizeError';
+    }
+}
+/** Thrown if the mint of a token account doesn't match the expected mint */
+class TokenInvalidMintError extends TokenError {
+    constructor() {
+        super(...arguments);
+        this.name = 'TokenInvalidMintError';
+    }
+}
+/** Thrown if the owner of a token account doesn't match the expected owner */
+class TokenInvalidOwnerError extends TokenError {
+    constructor() {
+        super(...arguments);
+        this.name = 'TokenInvalidOwnerError';
+    }
+}
+/** Thrown if the owner of a token account is a PDA (Program Derived Address) */
+class TokenOwnerOffCurveError extends TokenError {
+    constructor() {
+        super(...arguments);
+        this.name = 'TokenOwnerOffCurveError';
+    }
+}
+
 /** Instructions defined by the program */
 var TokenInstruction;
 (function (TokenInstruction) {
@@ -5463,6 +5543,10 @@ var TokenInstruction;
     TokenInstruction[TokenInstruction["InterestBearingMintExtension"] = 33] = "InterestBearingMintExtension";
     TokenInstruction[TokenInstruction["CpiGuardExtension"] = 34] = "CpiGuardExtension";
     TokenInstruction[TokenInstruction["InitializePermanentDelegate"] = 35] = "InitializePermanentDelegate";
+    TokenInstruction[TokenInstruction["TransferHookExtension"] = 36] = "TransferHookExtension";
+    // ConfidentialTransferFeeExtension = 37,
+    // WithdrawalExcessLamports = 38,
+    TokenInstruction[TokenInstruction["MetadataPointerExtension"] = 39] = "MetadataPointerExtension";
 })(TokenInstruction || (TokenInstruction = {}));
 
 /** @internal */
@@ -5510,6 +5594,112 @@ function createApproveInstruction(account, delegate, owner, amount, multiSigners
     return new TransactionInstruction({ keys, programId, data });
 }
 
+var AccountType;
+(function (AccountType) {
+    AccountType[AccountType["Uninitialized"] = 0] = "Uninitialized";
+    AccountType[AccountType["Mint"] = 1] = "Mint";
+    AccountType[AccountType["Account"] = 2] = "Account";
+})(AccountType || (AccountType = {}));
+const ACCOUNT_TYPE_SIZE = 1;
+
+/** Buffer layout for de/serializing a multisig */
+const MultisigLayout = struct([
+    u8('m'),
+    u8('n'),
+    bool('isInitialized'),
+    publicKey('signer1'),
+    publicKey('signer2'),
+    publicKey('signer3'),
+    publicKey('signer4'),
+    publicKey('signer5'),
+    publicKey('signer6'),
+    publicKey('signer7'),
+    publicKey('signer8'),
+    publicKey('signer9'),
+    publicKey('signer10'),
+    publicKey('signer11'),
+]);
+/** Byte length of a multisig */
+const MULTISIG_SIZE = MultisigLayout.span;
+
+/** Token account state as stored by the program */
+var AccountState;
+(function (AccountState) {
+    AccountState[AccountState["Uninitialized"] = 0] = "Uninitialized";
+    AccountState[AccountState["Initialized"] = 1] = "Initialized";
+    AccountState[AccountState["Frozen"] = 2] = "Frozen";
+})(AccountState || (AccountState = {}));
+/** Buffer layout for de/serializing a token account */
+const AccountLayout = struct([
+    publicKey('mint'),
+    publicKey('owner'),
+    u64('amount'),
+    u32('delegateOption'),
+    publicKey('delegate'),
+    u8('state'),
+    u32('isNativeOption'),
+    u64('isNative'),
+    u64('delegatedAmount'),
+    u32('closeAuthorityOption'),
+    publicKey('closeAuthority'),
+]);
+/** Byte length of a token account */
+const ACCOUNT_SIZE = AccountLayout.span;
+/**
+ * Retrieve information about a token account
+ *
+ * @param connection Connection to use
+ * @param address    Token account
+ * @param commitment Desired level of commitment for querying the state
+ * @param programId  SPL Token program account
+ *
+ * @return Token account information
+ */
+async function getAccount(connection, address, commitment, programId = TOKEN_PROGRAM_ID) {
+    const info = await connection.getAccountInfo(address, commitment);
+    return unpackAccount(address, info, programId);
+}
+/**
+ * Unpack a token account
+ *
+ * @param address   Token account
+ * @param info      Token account data
+ * @param programId SPL Token program account
+ *
+ * @return Unpacked token account
+ */
+function unpackAccount(address, info, programId = TOKEN_PROGRAM_ID) {
+    if (!info)
+        throw new TokenAccountNotFoundError();
+    if (!info.owner.equals(programId))
+        throw new TokenInvalidAccountOwnerError();
+    if (info.data.length < ACCOUNT_SIZE)
+        throw new TokenInvalidAccountSizeError();
+    const rawAccount = AccountLayout.decode(info.data.slice(0, ACCOUNT_SIZE));
+    let tlvData = Buffer.alloc(0);
+    if (info.data.length > ACCOUNT_SIZE) {
+        if (info.data.length === MULTISIG_SIZE)
+            throw new TokenInvalidAccountSizeError();
+        if (info.data[ACCOUNT_SIZE] != AccountType.Account)
+            throw new TokenInvalidAccountError();
+        tlvData = info.data.slice(ACCOUNT_SIZE + ACCOUNT_TYPE_SIZE);
+    }
+    return {
+        address,
+        mint: rawAccount.mint,
+        owner: rawAccount.owner,
+        amount: rawAccount.amount,
+        delegate: rawAccount.delegateOption ? rawAccount.delegate : null,
+        delegatedAmount: rawAccount.delegatedAmount,
+        isInitialized: rawAccount.state !== AccountState.Uninitialized,
+        isFrozen: rawAccount.state === AccountState.Frozen,
+        isNative: !!rawAccount.isNativeOption,
+        rentExemptReserve: rawAccount.isNativeOption ? rawAccount.isNative : null,
+        closeAuthority: rawAccount.closeAuthorityOption ? rawAccount.closeAuthority : null,
+        tlvData,
+    };
+}
+
 /** Buffer layout for de/serializing a mint */
 const MintLayout = struct([
     u32('mintAuthorityOption'),
@@ -5522,6 +5712,54 @@ const MintLayout = struct([
 ]);
 /** Byte length of a mint */
 const MINT_SIZE = MintLayout.span;
+/**
+ * Get the address of the associated token account for a given mint and owner
+ *
+ * @param mint                     Token mint account
+ * @param owner                    Owner of the new account
+ * @param allowOwnerOffCurve       Allow the owner account to be a PDA (Program Derived Address)
+ * @param programId                SPL Token program account
+ * @param associatedTokenProgramId SPL Associated Token program account
+ *
+ * @return Address of the associated token account
+ */
+function getAssociatedTokenAddressSync(mint, owner, allowOwnerOffCurve = false, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {
+    if (!allowOwnerOffCurve && !PublicKey.isOnCurve(owner.toBuffer()))
+        throw new TokenOwnerOffCurveError();
+    const [address] = PublicKey.findProgramAddressSync([owner.toBuffer(), programId.toBuffer(), mint.toBuffer()], associatedTokenProgramId);
+    return address;
+}
+
+/**
+ * Construct a CreateAssociatedTokenAccount instruction
+ *
+ * @param payer                    Payer of the initialization fees
+ * @param associatedToken          New associated token account
+ * @param owner                    Owner of the new account
+ * @param mint                     Token mint account
+ * @param programId                SPL Token program account
+ * @param associatedTokenProgramId SPL Associated Token program account
+ *
+ * @return Instruction to add to a transaction
+ */
+function createAssociatedTokenAccountInstruction(payer, associatedToken, owner, mint, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {
+    return buildAssociatedTokenAccountInstruction(payer, associatedToken, owner, mint, Buffer.alloc(0), programId, associatedTokenProgramId);
+}
+function buildAssociatedTokenAccountInstruction(payer, associatedToken, owner, mint, instructionData, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {
+    const keys = [
+        { pubkey: payer, isSigner: true, isWritable: true },
+        { pubkey: associatedToken, isSigner: false, isWritable: true },
+        { pubkey: owner, isSigner: false, isWritable: false },
+        { pubkey: mint, isSigner: false, isWritable: false },
+        { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        { pubkey: programId, isSigner: false, isWritable: false },
+    ];
+    return new TransactionInstruction({
+        keys,
+        programId: associatedTokenProgramId,
+        data: instructionData,
+    });
+}
 
 /** TODO: docs */
 const initializeMint2InstructionData = struct([
@@ -5555,9 +5793,93 @@ function createInitializeMint2Instruction(mint, decimals, mintAuthority, freezeA
     return new TransactionInstruction({ keys, programId, data });
 }
 
+/**
+ * Retrieve the associated token account, or create it if it doesn't exist
+ *
+ * @param connection               Connection to use
+ * @param payer                    Payer of the transaction and initialization fees
+ * @param mint                     Mint associated with the account to set or verify
+ * @param owner                    Owner of the account to set or verify
+ * @param allowOwnerOffCurve       Allow the owner account to be a PDA (Program Derived Address)
+ * @param commitment               Desired level of commitment for querying the state
+ * @param confirmOptions           Options for confirming the transaction
+ * @param programId                SPL Token program account
+ * @param associatedTokenProgramId SPL Associated Token program account
+ *
+ * @return Address of the new associated token account
+ */
+async function getOrCreateAssociatedTokenAccount(connection, payer, mint, owner, allowOwnerOffCurve = false, commitment, confirmOptions, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) {
+    const associatedToken = getAssociatedTokenAddressSync(mint, owner, allowOwnerOffCurve, programId, associatedTokenProgramId);
+    // This is the optimal logic, considering TX fee, client-side computation, RPC roundtrips and guaranteed idempotent.
+    // Sadly we can't do this atomically.
+    let account;
+    try {
+        account = await getAccount(connection, associatedToken, commitment, programId);
+    }
+    catch (error) {
+        // TokenAccountNotFoundError can be possible if the associated address has already received some lamports,
+        // becoming a system account. Assuming program derived addressing is safe, this is the only case for the
+        // TokenInvalidAccountOwnerError in this code path.
+        if (error instanceof TokenAccountNotFoundError || error instanceof TokenInvalidAccountOwnerError) {
+            // As this isn't atomic, it's possible others can create associated accounts meanwhile.
+            try {
+                const transaction = new Transaction().add(createAssociatedTokenAccountInstruction(payer.publicKey, associatedToken, owner, mint, programId, associatedTokenProgramId));
+                await sendAndConfirmTransaction(connection, transaction, [payer], confirmOptions);
+            }
+            catch (error) {
+                // Ignore all errors; for now there is no API-compatible way to selectively ignore the expected
+                // instruction error if the associated account exists already.
+            }
+            // Now this should always succeed
+            account = await getAccount(connection, associatedToken, commitment, programId);
+        }
+        else {
+            throw error;
+        }
+    }
+    if (!account.mint.equals(mint))
+        throw new TokenInvalidMintError();
+    if (!account.owner.equals(owner))
+        throw new TokenInvalidOwnerError();
+    return account;
+}
+
+/** TODO: docs */
+const mintToInstructionData = struct([u8('instruction'), u64('amount')]);
+/**
+ * Construct a MintTo instruction
+ *
+ * @param mint         Public key of the mint
+ * @param destination  Address of the token account to mint to
+ * @param authority    The mint authority
+ * @param amount       Amount to mint
+ * @param multiSigners Signing accounts if `authority` is a multisig
+ * @param programId    SPL Token program account
+ *
+ * @return Instruction to add to a transaction
+ */
+function createMintToInstruction(mint, destination, authority, amount, multiSigners = [], programId = TOKEN_PROGRAM_ID) {
+    const keys = addSigners([
+        { pubkey: mint, isSigner: false, isWritable: true },
+        { pubkey: destination, isSigner: false, isWritable: true },
+    ], authority, multiSigners);
+    const data = Buffer.alloc(mintToInstructionData.span);
+    mintToInstructionData.encode({
+        instruction: TokenInstruction.MintTo,
+        amount: BigInt(amount),
+    }, data);
+    return new TransactionInstruction({ keys, programId, data });
+}
+
+/**
+ * Sum up the token amounts of the compressed token accounts
+ */
 const sumUpTokenAmount = (accounts) => {
     return accounts.reduce((acc, account) => acc.add(account.parsed.amount), bn(0));
 };
+/**
+ * Validate that all the compressed token accounts are owned by the same owner.
+ */
 const validateSameTokenOwner = (accounts) => {
     const owner = accounts[0].parsed.owner;
     accounts.forEach(acc => {
@@ -5566,12 +5888,23 @@ const validateSameTokenOwner = (accounts) => {
         }
     });
 };
-const parseInputTokenData = (inputCompressedTokenAccounts) => {
-    const mint = inputCompressedTokenAccounts[0].parsed.mint;
-    const currentOwner = inputCompressedTokenAccounts[0].parsed.owner;
-    const delegate = inputCompressedTokenAccounts[0].parsed.delegate;
+/**
+ * Parse compressed token accounts to get the mint, current owner and delegate.
+ */
+const parseTokenData = (compressedTokenAccounts) => {
+    const mint = compressedTokenAccounts[0].parsed.mint;
+    const currentOwner = compressedTokenAccounts[0].parsed.owner;
+    const delegate = compressedTokenAccounts[0].parsed.delegate;
     return { mint, currentOwner, delegate };
 };
+/**
+ * Create the output state for a transfer transaction.
+ * @param inputCompressedTokenAccounts  Input state
+ * @param toAddress                     Recipient address
+ * @param amount                        Amount of tokens to transfer
+ * @returns                             Output token data for the transfer
+ *                                      instruction
+ */
 function createTransferOutputState(inputCompressedTokenAccounts, toAddress, amount) {
     amount = bn(amount);
     const inputAmount = sumUpTokenAmount(inputCompressedTokenAccounts);
@@ -5604,6 +5937,13 @@ function createTransferOutputState(inputCompressedTokenAccounts, toAddress, amou
     ];
     return outputCompressedAccounts;
 }
+/**
+ * Create the output state for a compress transaction.
+ * @param inputCompressedTokenAccounts  Input state
+ * @param amount                        Amount of tokens to compress
+ * @returns                             Output token data for the compress
+ *                                      instruction
+ */
 function createDecompressOutputState(inputCompressedTokenAccounts, amount) {
     amount = bn(amount);
     const inputLamports = sumUpLamports(inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
@@ -5633,10 +5973,9 @@ class CompressedTokenProgram {
     /**
      * Public key that identifies the CompressedPda program
      */
-    static programId = new PublicKey(
-    // TODO: can add check to ensure its consistent with the idl
-    '9sixVEthz2kMSKfeApZXHwuboT6DZuT6crAYJTciUCqE');
+    static programId = new PublicKey('9sixVEthz2kMSKfeApZXHwuboT6DZuT6crAYJTciUCqE');
     static _program = null;
+    /** @internal */
     static get program() {
         if (!this._program) {
             this.initializeProgram();
@@ -5644,12 +5983,14 @@ class CompressedTokenProgram {
         return this._program;
     }
     /**
+     * @internal
      * Initializes the program statically if not already initialized.
      */
     static initializeProgram() {
         if (!this._program) {
-            /// We can use a mock connection because we're using the program only for
-            /// serde and building instructions, not for interacting with the network.
+            /// Note: We can use a mock connection because we're using the
+            /// program only for serde and building instructions, not for
+            /// interacting with the network.
             const mockKeypair = Keypair.generate();
             const mockConnection = new Connection('http://127.0.0.1:8899', 'confirmed');
             const mockProvider = new AnchorProvider(mockConnection, useWallet(mockKeypair), confirmConfig);
@@ -5659,8 +6000,7 @@ class CompressedTokenProgram {
     }
     /** @internal */
     static deriveMintAuthorityPda = (authority, mint) => {
-        const [pubkey] = PublicKey.findProgramAddressSync([MINT_AUTHORITY_SEED, authority.toBuffer(), mint.toBuffer()], this.programId);
-        return pubkey;
+        return PublicKey.findProgramAddressSync([MINT_AUTHORITY_SEED, authority.toBuffer(), mint.toBuffer()], this.programId);
     };
     /** @internal */
     static deriveTokenPoolPda(mint) {
@@ -5673,8 +6013,12 @@ class CompressedTokenProgram {
         const [address, _] = PublicKey.findProgramAddressSync([CPI_AUTHORITY_SEED], this.programId);
         return address;
     }
+    /**
+     * Construct createMint instruction for compressed tokens
+     */
     static async createMint(params) {
         const { mint, authority, feePayer, rentExemptBalance } = params;
+        /// Create and initialize SPL Mint account
         const createMintAccountInstruction = SystemProgram.createAccount({
             fromPubkey: feePayer,
             lamports: rentExemptBalance,
@@ -5682,14 +6026,17 @@ class CompressedTokenProgram {
             programId: TOKEN_PROGRAM_ID,
             space: MINT_SIZE,
         });
-        const mintAuthorityPda = this.deriveMintAuthorityPda(authority, mint);
+        const [mintAuthorityPda] = this.deriveMintAuthorityPda(authority, mint);
         const initializeMintInstruction = createInitializeMint2Instruction(mint, params.decimals, mintAuthorityPda, params.freezeAuthority, TOKEN_PROGRAM_ID);
+        /// Fund the mint authority PDA. The authority is system-owned in order
+        /// to natively mint compressed tokens.
         const fundAuthorityPdaInstruction = SystemProgram.transfer({
             fromPubkey: feePayer,
             toPubkey: mintAuthorityPda,
-            lamports: rentExemptBalance, // TODO: check that this is the right PDA size
+            lamports: rentExemptBalance,
         });
         const tokenPoolPda = this.deriveTokenPoolPda(mint);
+        /// Create omnibus compressed mint account
         const ix = await this.program.methods
             .createMint()
             .accounts({
@@ -5710,15 +6057,41 @@ class CompressedTokenProgram {
             ix,
         ];
     }
+    /**
+     * Enable compression for an existing SPL mint, creating an omnibus account.
+     * For new mints, use `CompressedTokenProgram.createMint`.
+     */
+    static async registerMint(params) {
+        const { mint, authority, feePayer } = params;
+        const [mintAuthorityPda] = this.deriveMintAuthorityPda(authority, mint);
+        const tokenPoolPda = this.deriveTokenPoolPda(mint);
+        const ix = await this.program.methods
+            .createMint()
+            .accounts({
+            mint,
+            feePayer,
+            authority,
+            tokenPoolPda,
+            systemProgram: SystemProgram.programId,
+            mintAuthorityPda,
+            tokenProgram: TOKEN_PROGRAM_ID,
+            cpiAuthorityPda: this.deriveCpiAuthorityPda,
+        })
+            .instruction();
+        return [ix];
+    }
+    /**
+     * Construct mintTo instruction for compressed tokens
+     */
     static async mintTo(params) {
         const systemKeys = defaultStaticAccountsStruct();
         const { mint, feePayer, authority, merkleTree, toPubkey, amount } = params;
         const tokenPoolPda = this.deriveTokenPoolPda(mint);
-        const mintAuthorityPda = this.deriveMintAuthorityPda(authority, mint);
+        const [mintAuthorityPda, bump] = this.deriveMintAuthorityPda(authority, mint);
         const amounts = toArray(amount).map(amount => bn(amount));
         const toPubkeys = toArray(toPubkey);
-        const ix = await this.program.methods
-            .mintTo(toPubkeys, amounts)
+        const instruction = await this.program.methods
+            .mintTo(toPubkeys, amounts, bump)
             .accounts({
             feePayer,
             authority,
@@ -5726,7 +6099,7 @@ class CompressedTokenProgram {
             mint,
             tokenPoolPda,
             tokenProgram: TOKEN_PROGRAM_ID,
-            compressedPdaProgram: LightSystemProgram.programId,
+            lightSystemProgram: LightSystemProgram.programId,
             registeredProgramPda: systemKeys.registeredProgramPda,
             noopProgram: systemKeys.noopProgram,
             accountCompressionAuthority: systemKeys.accountCompressionAuthority,
@@ -5735,18 +6108,43 @@ class CompressedTokenProgram {
             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 mint authority ATA
+        const splMintToInstruction = createMintToInstruction(mint, authorityTokenAccount, authority, amount);
+        /// 2. Compressed token program mintTo
+        const approveInstruction = createApproveInstruction(authorityTokenAccount, this.deriveCpiAuthorityPda, authority, amount);
+        /// 3. Compress from mint authority ATA to recipient compressed account
+        const ixs = await this.compress({
+            payer: feePayer,
+            owner: authority,
+            source: authorityTokenAccount,
+            toAddress: toPubkey,
+            mint,
+            amount: bn(amount.toString()),
+            outputStateTree: merkleTree,
+        });
+        return [splMintToInstruction, approveInstruction, ...ixs];
     }
+    /**
+     * 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({
             inputCompressedTokenAccounts,
             outputCompressedAccountsLength: outputCompressedAccounts.length,
             outputStateTrees,
         });
-        const { mint, currentOwner } = parseInputTokenData(inputCompressedTokenAccounts);
+        const { mint, currentOwner } = parseTokenData(inputCompressedTokenAccounts);
         const data = {
             proof: recentValidityProof,
             rootIndices: recentInputStateRootIndices,
@@ -5757,16 +6155,17 @@ class CompressedTokenProgram {
             outputStateMerkleTreeAccountIndices: Buffer$1.from(outputStateMerkleTreeIndices),
             compressionAmount: null,
             isCompress: false,
+            cpiContext: null,
         };
         const encodedData = this.program.coder.types.encode('CompressedTokenInstructionDataTransfer', data);
         const { accountCompressionAuthority, noopProgram, registeredProgramPda, accountCompressionProgram, } = defaultStaticAccountsStruct();
         const instruction = await this.program.methods
-            .transfer(encodedData, null)
+            .transfer(encodedData)
             .accounts({
             feePayer: payer,
             authority: currentOwner,
             cpiAuthorityPda: this.deriveCpiAuthorityPda,
-            compressedPdaProgram: LightSystemProgram.programId,
+            lightSystemProgram: LightSystemProgram.programId,
             registeredProgramPda: registeredProgramPda,
             noopProgram: noopProgram,
             accountCompressionAuthority: accountCompressionAuthority,
@@ -5778,11 +6177,12 @@ class CompressedTokenProgram {
         })
             .remainingAccounts(remainingAccountMetas)
             .instruction();
-        return [
-            ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }),
-            instruction,
-        ];
+        return instruction;
     }
+    /**
+     * Construct approve and compress instructions
+     * @returns [approveInstruction, compressInstruction]
+     */
     static async compress(params) {
         const { payer, owner, source, toAddress, mint, outputStateTree } = params;
         const amount = bn(params.amount);
@@ -5793,7 +6193,6 @@ class CompressedTokenProgram {
                 lamports: bn(0),
             },
         ];
-        /// Pack
         const { inputTokenDataWithContext, outputStateMerkleTreeIndices, remainingAccountMetas, } = packCompressedTokenAccounts({
             inputCompressedTokenAccounts: [],
             outputCompressedAccountsLength: outputCompressedAccounts.length,
@@ -5809,19 +6208,18 @@ class CompressedTokenProgram {
             outputStateMerkleTreeAccountIndices: Buffer$1.from(outputStateMerkleTreeIndices),
             compressionAmount: amount,
             isCompress: true,
+            cpiContext: null,
         };
         const encodedData = this.program.coder.types.encode('CompressedTokenInstructionDataTransfer', data);
         const { accountCompressionAuthority, noopProgram, registeredProgramPda, accountCompressionProgram, } = defaultStaticAccountsStruct();
-        /// TODO: add support for multiSigners
-        /// TODO: validate that we don't need approveChecked
         const approveInstruction = createApproveInstruction(source, this.deriveCpiAuthorityPda, owner, BigInt(amount.toString()));
         const instruction = await this.program.methods
-            .transfer(encodedData, null)
+            .transfer(encodedData)
             .accounts({
             feePayer: payer,
             authority: owner,
             cpiAuthorityPda: this.deriveCpiAuthorityPda,
-            compressedPdaProgram: LightSystemProgram.programId,
+            lightSystemProgram: LightSystemProgram.programId,
             registeredProgramPda: registeredProgramPda,
             noopProgram: noopProgram,
             accountCompressionAuthority: accountCompressionAuthority,
@@ -5833,12 +6231,11 @@ class CompressedTokenProgram {
         })
             .remainingAccounts(remainingAccountMetas)
             .instruction();
-        return [
-            ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }),
-            approveInstruction,
-            instruction,
-        ];
+        return [approveInstruction, instruction];
     }
+    /**
+     * Construct decompress instruction
+     */
     static async decompress(params) {
         const { payer, inputCompressedTokenAccounts, toAddress, outputStateTree, recentValidityProof, recentInputStateRootIndices, } = params;
         const amount = bn(params.amount);
@@ -5849,7 +6246,7 @@ class CompressedTokenProgram {
             outputCompressedAccountsLength: tokenTransferOutputs.length,
             outputStateTrees: [outputStateTree],
         });
-        const { mint, currentOwner } = parseInputTokenData(inputCompressedTokenAccounts);
+        const { mint, currentOwner } = parseTokenData(inputCompressedTokenAccounts);
         const data = {
             proof: recentValidityProof,
             rootIndices: recentInputStateRootIndices,
@@ -5860,34 +6257,68 @@ class CompressedTokenProgram {
             outputStateMerkleTreeAccountIndices: Buffer$1.from(outputStateMerkleTreeIndices),
             compressionAmount: amount,
             isCompress: false,
+            cpiContext: null,
         };
         const encodedData = this.program.coder.types.encode('CompressedTokenInstructionDataTransfer', data);
         const { accountCompressionAuthority, noopProgram, registeredProgramPda, accountCompressionProgram, } = defaultStaticAccountsStruct();
         const instruction = await this.program.methods
-            .transfer(encodedData, null)
+            .transfer(encodedData)
             .accounts({
             feePayer: payer,
             authority: currentOwner,
             cpiAuthorityPda: this.deriveCpiAuthorityPda,
-            compressedPdaProgram: LightSystemProgram.programId,
+            lightSystemProgram: LightSystemProgram.programId,
             registeredProgramPda: registeredProgramPda,
             noopProgram: noopProgram,
             accountCompressionAuthority: accountCompressionAuthority,
             accountCompressionProgram: accountCompressionProgram,
             selfProgram: this.programId,
             tokenPoolPda: this.deriveTokenPoolPda(mint),
-            decompressTokenAccount: toAddress, // token
+            decompressTokenAccount: toAddress,
             tokenProgram: TOKEN_PROGRAM_ID,
         })
             .remainingAccounts(remainingAccountMetas)
             .instruction();
-        return [
-            ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }),
-            instruction,
-        ];
+        return instruction;
     }
 }
 
+/**
+ * Mint compressed tokens to a solana address from an external mint authority
+ *
+ * @param rpc            Rpc to use
+ * @param payer          Payer of the transaction fees
+ * @param mint           Mint for the account
+ * @param destination    Address of the account to mint to
+ * @param authority      Minting authority
+ * @param amount         Amount to mint
+ * @param merkleTree     State tree account that the compressed tokens should be
+ *                       part of. Defaults to the default state tree account.
+ * @param confirmOptions Options for confirming the transaction
+ *
+ * @return Signature of the confirmed transaction
+ */
+async function approveAndMintTo(rpc, payer, mint, destination, authority, amount, merkleTree = defaultTestStateTreeAccounts().merkleTree, confirmOptions) {
+    const authorityTokenAccount = await getOrCreateAssociatedTokenAccount(rpc, payer, mint, authority.publicKey);
+    const ixs = await CompressedTokenProgram.approveAndMintTo({
+        feePayer: payer.publicKey,
+        mint,
+        authority: authority.publicKey,
+        authorityTokenAccount: authorityTokenAccount.address,
+        amount,
+        toPubkey: destination,
+        merkleTree,
+    });
+    const { blockhash } = await rpc.getLatestBlockhash();
+    const additionalSigners = dedupeSigner(payer, [authority]);
+    const tx = buildAndSignTx([
+        ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }),
+        ...ixs,
+    ], payer, blockhash, additionalSigners);
+    const txId = await sendAndConfirmTx(rpc, tx, confirmOptions);
+    return txId;
+}
+
 /**
  * Compress SPL tokens
  *
@@ -5908,7 +6339,7 @@ class CompressedTokenProgram {
  */
 async function compress(rpc, payer, mint, amount, owner, sourceTokenAccount, toAddress, merkleTree = defaultTestStateTreeAccounts().merkleTree, confirmOptions) {
     amount = bn(amount);
-    const ixs = await CompressedTokenProgram.compress({
+    const [approveIx, compressIx] = await CompressedTokenProgram.compress({
         payer: payer.publicKey,
         owner: owner.publicKey,
         source: sourceTokenAccount,
@@ -5919,7 +6350,13 @@ async function compress(rpc, payer, mint, amount, owner, sourceTokenAccount, toA
     });
     const blockhashCtx = await rpc.getLatestBlockhash();
     const additionalSigners = dedupeSigner(payer, [owner]);
-    const signedTx = buildAndSignTx(ixs, payer, blockhashCtx.blockhash, additionalSigners);
+    const signedTx = buildAndSignTx([
+        ComputeBudgetProgram.setComputeUnitLimit({
+            units: 1000000,
+        }),
+        approveIx,
+        compressIx,
+    ], payer, blockhashCtx.blockhash, additionalSigners);
     const txId = await sendAndConfirmTx(rpc, signedTx, confirmOptions, blockhashCtx);
     return txId;
 }
@@ -5949,7 +6386,7 @@ merkleTree = defaultTestStateTreeAccounts().merkleTree, confirmOptions) {
     });
     const [inputAccounts] = selectMinCompressedTokenAccountsForTransfer(compressedTokenAccounts, amount);
     const proof = await rpc.getValidityProof(inputAccounts.map(account => bn(account.compressedAccount.hash)));
-    const ixs = await CompressedTokenProgram.transfer({
+    const ix = await CompressedTokenProgram.transfer({
         payer: payer.publicKey,
         inputCompressedTokenAccounts: inputAccounts,
         toAddress,
@@ -5960,7 +6397,7 @@ merkleTree = defaultTestStateTreeAccounts().merkleTree, confirmOptions) {
     });
     const { blockhash } = await rpc.getLatestBlockhash();
     const additionalSigners = dedupeSigner(payer, [owner]);
-    const signedTx = buildAndSignTx(ixs, payer, blockhash, additionalSigners);
+    const signedTx = buildAndSignTx([ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }), ix], payer, blockhash, additionalSigners);
     const txId = await sendAndConfirmTx(rpc, signedTx, confirmOptions);
     return txId;
 }
@@ -6021,7 +6458,7 @@ merkleTree = defaultTestStateTreeAccounts().merkleTree, confirmOptions) {
     /// TODO: consider using a different selection algorithm
     const [inputAccounts] = selectMinCompressedTokenAccountsForTransfer(compressedTokenAccounts, amount);
     const proof = await rpc.getValidityProof(inputAccounts.map(account => bn(account.compressedAccount.hash)));
-    const ixs = await CompressedTokenProgram.decompress({
+    const ix = await CompressedTokenProgram.decompress({
         payer: payer.publicKey,
         inputCompressedTokenAccounts: inputAccounts,
         toAddress, // TODO: add explicit check that it is a token account
@@ -6032,7 +6469,7 @@ merkleTree = defaultTestStateTreeAccounts().merkleTree, confirmOptions) {
     });
     const { blockhash } = await rpc.getLatestBlockhash();
     const additionalSigners = dedupeSigner(payer, [owner]);
-    const signedTx = buildAndSignTx(ixs, payer, blockhash, additionalSigners);
+    const signedTx = buildAndSignTx([ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }), ix], payer, blockhash, additionalSigners);
     const txId = await sendAndConfirmTx(rpc, signedTx, confirmOptions);
     return txId;
 }
@@ -6098,5 +6535,29 @@ confirmOptions) {
     return txId;
 }
 
-export { CPI_AUTHORITY_SEED, CompressedTokenProgram, IDL, MINT_AUTHORITY_SEED, POOL_SEED, SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE, compress, createDecompressOutputState, createMint, createTransferOutputState, decompress, mintTo, packCompressedTokenAccounts, parseInputTokenData, selectMinCompressedTokenAccountsForTransfer, sumUpTokenAmount, transfer, validateSameTokenOwner };
+/**
+ * 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, mintAuthority, mintAddress, confirmOptions) {
+    const ixs = await CompressedTokenProgram.registerMint({
+        feePayer: payer.publicKey,
+        mint: mintAddress,
+        authority: mintAuthority.publicKey,
+    });
+    const { blockhash } = await rpc.getLatestBlockhash();
+    const additionalSigners = dedupeSigner(payer, [mintAuthority]);
+    const tx = buildAndSignTx(ixs, payer, blockhash, additionalSigners);
+    const txId = await sendAndConfirmTx(rpc, tx, confirmOptions);
+    return txId;
+}
+
+export { CPI_AUTHORITY_SEED, CompressedTokenProgram, IDL, MINT_AUTHORITY_SEED, POOL_SEED, SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE, approveAndMintTo, compress, createDecompressOutputState, createMint, createTransferOutputState, decompress, mintTo, packCompressedTokenAccounts, parseTokenData, registerMint, selectMinCompressedTokenAccountsForTransfer, sumUpTokenAmount, transfer, validateSameTokenOwner };
 //# sourceMappingURL=index.js.map