@lightprotocol/compressed-token 0.1.3 → 0.2.0

package/dist/cjs/node/index.cjs

@@ -4,11 +4,9 @@ var stateless_js = require('@lightprotocol/stateless.js');
 var anchor = require('@coral-xyz/anchor');
 var web3_js = require('@solana/web3.js');
 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.3.1',
     name: 'light_compressed_token',
     constants: [
         {
@@ -21,9 +19,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: [
                 {
@@ -103,7 +102,7 @@ const IDL = {
                     isSigner: false,
                 },
                 {
-                    name: 'compressedPdaProgram',
+                    name: 'lightSystemProgram',
                     isMut: false,
                     isSigner: false,
                 },
@@ -137,6 +136,11 @@ const IDL = {
                     isMut: false,
                     isSigner: false,
                 },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
             ],
             args: [
                 {
@@ -151,6 +155,10 @@ const IDL = {
                         vec: 'u64',
                     },
                 },
+                {
+                    name: 'bump',
+                    type: 'u8',
+                },
             ],
         },
         {
@@ -158,7 +166,7 @@ const IDL = {
             accounts: [
                 {
                     name: 'feePayer',
-                    isMut: false,
+                    isMut: true,
                     isSigner: true,
                 },
                 {
@@ -172,7 +180,7 @@ const IDL = {
                     isSigner: false,
                 },
                 {
-                    name: 'compressedPdaProgram',
+                    name: 'lightSystemProgram',
                     isMut: false,
                     isSigner: false,
                 },
@@ -219,139 +227,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],
                         },
@@ -360,57 +390,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: 'proof',
+                        type: {
+                            option: {
+                                defined: 'CompressedProof',
+                            },
+                        },
                     },
                     {
-                        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: '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',
                             },
                         },
                     },
@@ -424,16 +434,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',
                         },
@@ -443,178 +456,241 @@ 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',
-                        type: {
-                            option: {
-                                vec: 'bytes',
-                            },
-                        },
+                        name: 'leafIndex',
+                        type: 'u32',
                     },
                 ],
             },
         },
         {
-            name: 'NewAddressParamsPacked',
+            name: 'CompressedAccount',
             type: {
                 kind: 'struct',
                 fields: [
                     {
-                        name: 'seed',
-                        type: {
-                            array: ['u8', 32],
-                        },
+                        name: 'owner',
+                        type: 'publicKey',
                     },
                     {
-                        name: 'addressQueueAccountIndex',
-                        type: 'u8',
+                        name: 'lamports',
+                        type: 'u64',
                     },
                     {
-                        name: 'addressMerkleTreeAccountIndex',
-                        type: 'u8',
+                        name: 'address',
+                        type: {
+                            option: {
+                                array: ['u8', 32],
+                            },
+                        },
                     },
                     {
-                        name: 'addressMerkleTreeRootIndex',
-                        type: 'u16',
+                        name: 'data',
+                        type: {
+                            option: {
+                                defined: 'CompressedAccountData',
+                            },
+                        },
                     },
                 ],
             },
         },
         {
-            name: 'NewAddressParams',
+            name: 'CompressedAccountData',
             type: {
                 kind: 'struct',
                 fields: [
                     {
-                        name: 'seed',
+                        name: 'discriminator',
                         type: {
-                            array: ['u8', 32],
+                            array: ['u8', 8],
                         },
                     },
                     {
-                        name: 'addressQueuePubkey',
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'addressMerkleTreePubkey',
-                        type: 'publicKey',
+                        name: 'data',
+                        type: 'bytes',
                     },
                     {
-                        name: 'addressMerkleTreeRootIndex',
-                        type: 'u16',
+                        name: 'dataHash',
+                        type: {
+                            array: ['u8', 32],
+                        },
                     },
                 ],
             },
         },
         {
-            name: 'CompressedProof',
+            name: 'PublicTransactionEvent',
             type: {
                 kind: 'struct',
                 fields: [
                     {
-                        name: 'a',
+                        name: 'inputCompressedAccountHashes',
                         type: {
-                            array: ['u8', 32],
+                            vec: {
+                                array: ['u8', 32],
+                            },
                         },
                     },
                     {
-                        name: 'b',
+                        name: 'outputCompressedAccountHashes',
                         type: {
-                            array: ['u8', 64],
+                            vec: {
+                                array: ['u8', 32],
+                            },
                         },
                     },
                     {
-                        name: 'c',
+                        name: 'outputCompressedAccounts',
                         type: {
-                            array: ['u8', 32],
+                            vec: {
+                                defined: 'CompressedAccount',
+                            },
                         },
                     },
+                    {
+                        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: 'CompressedCpiContext',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'setContext',
+                        type: 'bool',
+                    },
+                    {
+                        name: 'cpiContextAccountIndex',
+                        type: 'u8',
+                    },
                 ],
             },
         },
@@ -646,16 +722,10 @@ const IDL = {
                         },
                     },
                     {
-                        name: 'merkleTreePubkeyIndex',
-                        type: 'u8',
-                    },
-                    {
-                        name: 'nullifierQueuePubkeyIndex',
-                        type: 'u8',
-                    },
-                    {
-                        name: 'leafIndex',
-                        type: 'u32',
+                        name: 'merkleContext',
+                        type: {
+                            defined: 'PackedMerkleContext',
+                        },
                     },
                 ],
             },
@@ -717,90 +787,41 @@ const IDL = {
                             option: 'u64',
                         },
                     },
-                ],
-            },
-        },
-        {
-            name: 'TokenTransferOutputData',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'owner',
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'amount',
-                        type: 'u64',
-                    },
                     {
-                        name: 'lamports',
+                        name: 'cpiContext',
                         type: {
-                            option: 'u64',
+                            option: {
+                                defined: 'CompressedCpiContext',
+                            },
                         },
                     },
                 ],
             },
         },
         {
-            name: 'TokenData',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'mint',
-                        docs: ['The mint associated with this account'],
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'owner',
-                        docs: ['The owner of this account.'],
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'amount',
-                        docs: ['The amount of tokens this account holds.'],
-                        type: 'u64',
-                    },
-                    {
-                        name: 'delegate',
-                        docs: [
-                            'If `delegate` is `Some` then `delegated_amount` represents',
-                            'the amount authorized by the delegate',
-                        ],
-                        type: {
-                            option: 'publicKey',
-                        },
+            name: 'TokenTransferOutputData',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'owner',
+                        type: 'publicKey',
                     },
                     {
-                        name: 'state',
-                        docs: ["The account's state"],
-                        type: {
-                            defined: 'AccountState',
-                        },
+                        name: 'amount',
+                        type: 'u64',
                     },
                     {
-                        name: 'isNative',
-                        docs: [
-                            'If is_some, this is a native token, and the value logs the rent-exempt',
-                            'reserve. An Account is required to be rent-exempt, so the value is',
-                            'used by the Processor to ensure that wrapped SOL accounts do not',
-                            'drop below this threshold.',
-                        ],
+                        name: 'lamports',
                         type: {
                             option: 'u64',
                         },
                     },
-                    {
-                        name: 'delegatedAmount',
-                        docs: ['The amount delegated'],
-                        type: 'u64',
-                    },
                 ],
             },
         },
         {
-            name: 'TokenDataClient',
+            name: 'TokenData',
             type: {
                 kind: 'struct',
                 fields: [
@@ -832,7 +853,9 @@ const IDL = {
                     {
                         name: 'state',
                         docs: ["The account's state"],
-                        type: 'u8',
+                        type: {
+                            defined: 'AccountState',
+                        },
                     },
                     {
                         name: 'isNative',
@@ -859,9 +882,6 @@ const IDL = {
             type: {
                 kind: 'enum',
                 variants: [
-                    {
-                        name: 'Uninitialized',
-                    },
                     {
                         name: 'Initialized',
                     },
@@ -965,9 +985,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
@@ -1000,7 +1022,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 +3317,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 browser = {};
 
-		  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;
-		      }
-		    }
-		  }
-
-		  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 +3335,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 +3359,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 +3374,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 +3427,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 +3522,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 +3573,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 +3691,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 +3772,94 @@ function createInitializeMint2Instruction(mint, decimals, mintAuthority, freezeA
     return new web3_js.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 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 });
+}
+
 var _a;
+/**
+ * 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 +3868,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 +3917,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 +3950,7 @@ class CompressedTokenProgram {
      * @internal
      */
     constructor() { }
+    /** @internal */
     static get program() {
         if (!this._program) {
             this.initializeProgram();
@@ -3942,12 +3958,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 +3984,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,14 +3997,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 = web3_js.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({
@@ -4003,15 +4028,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: web3_js.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 = stateless_js.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 = stateless_js.toArray(amount).map(amount => stateless_js.bn(amount));
         const toPubkeys = stateless_js.toArray(toPubkey);
-        const ix = await this.program.methods
-            .mintTo(toPubkeys, amounts)
+        const instruction = await this.program.methods
+            .mintTo(toPubkeys, amounts, bump)
             .accounts({
             feePayer,
             authority,
@@ -4019,7 +4070,7 @@ class CompressedTokenProgram {
             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,
@@ -4028,18 +4079,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: stateless_js.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,
@@ -4050,16 +4126,17 @@ class CompressedTokenProgram {
             outputStateMerkleTreeAccountIndices: require$$0.Buffer.from(outputStateMerkleTreeIndices),
             compressionAmount: 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,
@@ -4071,11 +4148,12 @@ class CompressedTokenProgram {
         })
             .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);
@@ -4086,7 +4164,6 @@ class CompressedTokenProgram {
                 lamports: stateless_js.bn(0),
             },
         ];
-        /// Pack
         const { inputTokenDataWithContext, outputStateMerkleTreeIndices, remainingAccountMetas, } = packCompressedTokenAccounts({
             inputCompressedTokenAccounts: [],
             outputCompressedAccountsLength: outputCompressedAccounts.length,
@@ -4102,19 +4179,18 @@ class CompressedTokenProgram {
             outputStateMerkleTreeAccountIndices: require$$0.Buffer.from(outputStateMerkleTreeIndices),
             compressionAmount: 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,
@@ -4126,12 +4202,11 @@ class CompressedTokenProgram {
         })
             .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);
@@ -4142,7 +4217,7 @@ class CompressedTokenProgram {
             outputCompressedAccountsLength: tokenTransferOutputs.length,
             outputStateTrees: [outputStateTree],
         });
-        const { mint, currentOwner } = parseInputTokenData(inputCompressedTokenAccounts);
+        const { mint, currentOwner } = parseTokenData(inputCompressedTokenAccounts);
         const data = {
             proof: recentValidityProof,
             rootIndices: recentInputStateRootIndices,
@@ -4153,47 +4228,78 @@ class CompressedTokenProgram {
             outputStateMerkleTreeAccountIndices: require$$0.Buffer.from(outputStateMerkleTreeIndices),
             compressionAmount: 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
+            decompressTokenAccount: 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('9sixVEthz2kMSKfeApZXHwuboT6DZuT6crAYJTciUCqE');
 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;
+    return web3_js.PublicKey.findProgramAddressSync([MINT_AUTHORITY_SEED, authority.toBuffer(), mint.toBuffer()], _a.programId);
 };
 
+/**
+ * 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 = stateless_js.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 = 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
  *
@@ -4214,7 +4320,7 @@ CompressedTokenProgram.deriveMintAuthorityPda = (authority, mint) => {
  */
 async function compress(rpc, payer, mint, amount, owner, sourceTokenAccount, toAddress, merkleTree = stateless_js.defaultTestStateTreeAccounts().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 +4331,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;
 }
@@ -4255,7 +4367,7 @@ merkleTree = stateless_js.defaultTestStateTreeAccounts().merkleTree, confirmOpti
     });
     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 +4378,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;
 }
@@ -4327,7 +4439,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 +4450,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;
 }
@@ -4404,12 +4516,37 @@ 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, mintAuthority, mintAddress, confirmOptions) {
+    const ixs = await CompressedTokenProgram.registerMint({
+        feePayer: payer.publicKey,
+        mint: mintAddress,
+        authority: mintAuthority.publicKey,
+    });
+    const { blockhash } = await rpc.getLatestBlockhash();
+    const additionalSigners = stateless_js.dedupeSigner(payer, [mintAuthority]);
+    const tx = stateless_js.buildAndSignTx(ixs, payer, blockhash, additionalSigners);
+    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 +4554,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;