@lightprotocol/compressed-token 0.1.2 → 0.2.0

package/dist/types/index.d.ts

@@ -3,7 +3,7 @@ import { PublicKey, AccountMeta, TransactionInstruction, Signer, ConfirmOptions,
 import { BN, Program } from '@coral-xyz/anchor';
 
 type LightCompressedToken = {
-    version: '0.3.0';
+    version: '0.3.1';
     name: 'light_compressed_token';
     constants: [
         {
@@ -16,9 +16,10 @@ type LightCompressedToken = {
         {
             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 @@ type LightCompressedToken = {
                     isSigner: false;
                 },
                 {
-                    name: 'compressedPdaProgram';
+                    name: 'lightSystemProgram';
                     isMut: false;
                     isSigner: false;
                 },
@@ -131,6 +132,11 @@ type LightCompressedToken = {
                     name: 'selfProgram';
                     isMut: false;
                     isSigner: false;
+                },
+                {
+                    name: 'systemProgram';
+                    isMut: false;
+                    isSigner: false;
                 }
             ];
             args: [
@@ -145,6 +151,10 @@ type LightCompressedToken = {
                     type: {
                         vec: 'u64';
                     };
+                },
+                {
+                    name: 'bump';
+                    type: 'u8';
                 }
             ];
         },
@@ -153,7 +163,7 @@ type LightCompressedToken = {
             accounts: [
                 {
                     name: 'feePayer';
-                    isMut: false;
+                    isMut: true;
                     isSigner: true;
                 },
                 {
@@ -167,7 +177,7 @@ type LightCompressedToken = {
                     isSigner: false;
                 },
                 {
-                    name: 'compressedPdaProgram';
+                    name: 'lightSystemProgram';
                     isMut: false;
                     isSigner: false;
                 },
@@ -213,140 +223,162 @@ type LightCompressedToken = {
                     isMut: false;
                     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: '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: '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 @@ type LightCompressedToken = {
             };
         },
         {
-            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';
                             };
                         };
                     },
@@ -419,16 +431,19 @@ type LightCompressedToken = {
                     },
                     {
                         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,177 +453,240 @@ type LightCompressedToken = {
                         type: 'bool';
                     },
                     {
-                        name: 'compressionLamports';
+                        name: 'signerSeeds';
                         type: {
-                            option: 'u64';
+                            vec: 'bytes';
                         };
                     },
                     {
-                        name: 'pubkeyArray';
+                        name: 'cpiContext';
                         type: {
-                            vec: 'publicKey';
+                            option: {
+                                defined: 'CompressedCpiContext';
+                            };
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: 'PackedCompressedAccountWithMerkleContext';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'compressedAccount';
+                        type: {
+                            defined: 'CompressedAccount';
                         };
                     },
                     {
-                        name: 'message';
+                        name: 'merkleContext';
                         type: {
-                            option: 'bytes';
+                            defined: 'PackedMerkleContext';
                         };
                     }
                 ];
             };
         },
         {
-            name: 'InstructionDataTransfer';
+            name: 'CompressedAccountWithMerkleContext';
             type: {
                 kind: 'struct';
                 fields: [
                     {
-                        name: 'proof';
+                        name: 'compressedAccount';
                         type: {
-                            option: {
-                                defined: 'CompressedProof';
-                            };
+                            defined: 'CompressedAccount';
                         };
                     },
                     {
-                        name: 'newAddressParams';
+                        name: 'merkleContext';
                         type: {
-                            vec: {
-                                defined: 'NewAddressParamsPacked';
-                            };
+                            defined: 'MerkleContext';
                         };
+                    }
+                ];
+            };
+        },
+        {
+            name: 'MerkleContext';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'merkleTreePubkey';
+                        type: 'publicKey';
                     },
                     {
-                        name: 'inputRootIndices';
-                        type: {
-                            vec: 'u16';
-                        };
+                        name: 'nullifierQueuePubkey';
+                        type: 'publicKey';
                     },
                     {
-                        name: 'inputCompressedAccountsWithMerkleContext';
-                        type: {
-                            vec: {
-                                defined: 'CompressedAccountWithMerkleContext';
-                            };
-                        };
+                        name: 'leafIndex';
+                        type: 'u32';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'PackedMerkleContext';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'merkleTreePubkeyIndex';
+                        type: 'u8';
                     },
                     {
-                        name: 'outputCompressedAccounts';
-                        type: {
-                            vec: {
-                                defined: 'CompressedAccount';
-                            };
-                        };
+                        name: 'nullifierQueuePubkeyIndex';
+                        type: 'u8';
                     },
                     {
-                        name: 'outputStateMerkleTreeAccountIndices';
-                        docs: [
-                            'The indices of the accounts in the output state merkle tree.'
-                        ];
-                        type: 'bytes';
+                        name: 'leafIndex';
+                        type: 'u32';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'CompressedAccount';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'owner';
+                        type: 'publicKey';
                     },
                     {
-                        name: 'relayFee';
+                        name: 'lamports';
+                        type: 'u64';
+                    },
+                    {
+                        name: 'address';
                         type: {
-                            option: 'u64';
+                            option: {
+                                array: ['u8', 32];
+                            };
                         };
                     },
                     {
-                        name: 'compressionLamports';
+                        name: 'data';
                         type: {
-                            option: 'u64';
+                            option: {
+                                defined: 'CompressedAccountData';
+                            };
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: 'CompressedAccountData';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'discriminator';
+                        type: {
+                            array: ['u8', 8];
                         };
                     },
                     {
-                        name: 'isCompress';
-                        type: 'bool';
+                        name: 'data';
+                        type: 'bytes';
                     },
                     {
-                        name: 'signerSeeds';
+                        name: 'dataHash';
                         type: {
-                            option: {
-                                vec: 'bytes';
-                            };
+                            array: ['u8', 32];
                         };
                     }
                 ];
             };
         },
         {
-            name: 'NewAddressParamsPacked';
+            name: 'PublicTransactionEvent';
             type: {
                 kind: 'struct';
                 fields: [
                     {
-                        name: 'seed';
+                        name: 'inputCompressedAccountHashes';
                         type: {
-                            array: ['u8', 32];
+                            vec: {
+                                array: ['u8', 32];
+                            };
+                        };
+                    },
+                    {
+                        name: 'outputCompressedAccountHashes';
+                        type: {
+                            vec: {
+                                array: ['u8', 32];
+                            };
+                        };
+                    },
+                    {
+                        name: 'outputCompressedAccounts';
+                        type: {
+                            vec: {
+                                defined: 'CompressedAccount';
+                            };
+                        };
+                    },
+                    {
+                        name: 'outputStateMerkleTreeAccountIndices';
+                        type: 'bytes';
+                    },
+                    {
+                        name: 'outputLeafIndices';
+                        type: {
+                            vec: 'u32';
                         };
                     },
                     {
-                        name: 'addressQueueAccountIndex';
-                        type: 'u8';
+                        name: 'relayFee';
+                        type: {
+                            option: 'u64';
+                        };
                     },
                     {
-                        name: 'addressMerkleTreeAccountIndex';
-                        type: 'u8';
+                        name: 'isCompress';
+                        type: 'bool';
                     },
                     {
-                        name: 'addressMerkleTreeRootIndex';
-                        type: 'u16';
-                    }
-                ];
-            };
-        },
-        {
-            name: 'NewAddressParams';
-            type: {
-                kind: 'struct';
-                fields: [
-                    {
-                        name: 'seed';
+                        name: 'compressionLamports';
                         type: {
-                            array: ['u8', 32];
+                            option: 'u64';
                         };
                     },
                     {
-                        name: 'addressQueuePubkey';
-                        type: 'publicKey';
-                    },
-                    {
-                        name: 'addressMerkleTreePubkey';
-                        type: 'publicKey';
+                        name: 'pubkeyArray';
+                        type: {
+                            vec: 'publicKey';
+                        };
                     },
                     {
-                        name: 'addressMerkleTreeRootIndex';
-                        type: 'u16';
+                        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 @@ type LightCompressedToken = {
                         };
                     },
                     {
-                        name: 'merkleTreePubkeyIndex';
-                        type: 'u8';
-                    },
-                    {
-                        name: 'nullifierQueuePubkeyIndex';
-                        type: 'u8';
-                    },
-                    {
-                        name: 'leafIndex';
-                        type: 'u32';
+                        name: 'merkleContext';
+                        type: {
+                            defined: 'PackedMerkleContext';
+                        };
                     }
                 ];
             };
@@ -711,6 +783,14 @@ type LightCompressedToken = {
                         type: {
                             option: 'u64';
                         };
+                    },
+                    {
+                        name: 'cpiContext';
+                        type: {
+                            option: {
+                                defined: 'CompressedCpiContext';
+                            };
+                        };
                     }
                 ];
             };
@@ -794,69 +874,11 @@ type LightCompressedToken = {
                 ];
             };
         },
-        {
-            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';
                     },
@@ -1060,7 +1082,9 @@ type TransferParams = {
      */
     outputStateTrees?: PublicKey[] | PublicKey;
 };
-/** Create Mint account for compressed Tokens */
+/**
+ * Create Mint account for compressed Tokens
+ */
 type CreateMintParams = {
     /** Tx feepayer */
     feePayer: PublicKey;
@@ -1092,14 +1116,69 @@ type MintToParams = {
     /** Public key of the state tree to mint into. */
     merkleTree: PublicKey;
 };
+/**
+ * Register an existing SPL mint account to the compressed token program
+ * Creates an omnibus account for the mint
+ */
+type RegisterMintParams = {
+    /** Tx feepayer */
+    feePayer: PublicKey;
+    /** Mint authority */
+    authority: PublicKey;
+    /** Mint public key */
+    mint: PublicKey;
+};
+/**
+ * Mint from existing SPL mint to compressed token accounts
+ */
+type ApproveAndMintToParams = {
+    /** Tx feepayer */
+    feePayer: PublicKey;
+    /** Mint authority */
+    authority: PublicKey;
+    /** Mint authority (associated) token account */
+    authorityTokenAccount: PublicKey;
+    /** Mint public key */
+    mint: PublicKey;
+    /** The Solana Public Key to mint to. */
+    toPubkey: PublicKey;
+    /** The amount of compressed tokens to mint. */
+    amount: BN | number;
+    /** Public key of the state tree to mint into. */
+    merkleTree: PublicKey;
+};
+/**
+ * Sum up the token amounts of the compressed token accounts
+ */
 declare const sumUpTokenAmount: (accounts: ParsedTokenAccount[]) => BN;
+/**
+ * Validate that all the compressed token accounts are owned by the same owner.
+ */
 declare const validateSameTokenOwner: (accounts: ParsedTokenAccount[]) => void;
-declare const parseInputTokenData: (inputCompressedTokenAccounts: ParsedTokenAccount[]) => {
+/**
+ * Parse compressed token accounts to get the mint, current owner and delegate.
+ */
+declare const parseTokenData: (compressedTokenAccounts: ParsedTokenAccount[]) => {
     mint: PublicKey;
     currentOwner: PublicKey;
     delegate: PublicKey | null;
 };
+/**
+ * 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
+ */
 declare function createTransferOutputState(inputCompressedTokenAccounts: ParsedTokenAccount[], toAddress: PublicKey, amount: number | BN): TokenTransferOutputData$1[];
+/**
+ * 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
+ */
 declare function createDecompressOutputState(inputCompressedTokenAccounts: ParsedTokenAccount[], amount: number | BN): TokenTransferOutputData$1[];
 declare class CompressedTokenProgram {
     /**
@@ -1111,57 +1190,178 @@ declare class CompressedTokenProgram {
      */
     static programId: PublicKey;
     private static _program;
+    /** @internal */
     static get program(): Program<LightCompressedToken>;
     /**
+     * @internal
      * Initializes the program statically if not already initialized.
      */
     private static initializeProgram;
     /** @internal */
-    static deriveMintAuthorityPda: (authority: PublicKey, mint: PublicKey) => PublicKey;
+    static deriveMintAuthorityPda: (authority: PublicKey, mint: PublicKey) => [PublicKey, number];
     /** @internal */
     static deriveTokenPoolPda(mint: PublicKey): PublicKey;
     /** @internal */
     static get deriveCpiAuthorityPda(): PublicKey;
+    /**
+     * Construct createMint instruction for compressed tokens
+     */
     static createMint(params: CreateMintParams): Promise<TransactionInstruction[]>;
+    /**
+     * Enable compression for an existing SPL mint, creating an omnibus account.
+     * For new mints, use `CompressedTokenProgram.createMint`.
+     */
+    static registerMint(params: RegisterMintParams): Promise<TransactionInstruction[]>;
+    /**
+     * Construct mintTo instruction for compressed tokens
+     */
     static mintTo(params: MintToParams): Promise<TransactionInstruction>;
-    static transfer(params: TransferParams): Promise<TransactionInstruction[]>;
+    /**
+     * Mint tokens from registed SPL mint account to a compressed account
+     */
+    static approveAndMintTo(params: ApproveAndMintToParams): Promise<TransactionInstruction[]>;
+    /**
+     * Construct transfer instruction for compressed tokens
+     */
+    static transfer(params: TransferParams): Promise<TransactionInstruction>;
+    /**
+     * Construct approve and compress instructions
+     * @returns [approveInstruction, compressInstruction]
+     */
     static compress(params: CompressParams): Promise<TransactionInstruction[]>;
-    static decompress(params: DecompressParams): Promise<TransactionInstruction[]>;
+    /**
+     * Construct decompress instruction
+     */
+    static decompress(params: DecompressParams): Promise<TransactionInstruction>;
 }
 
 type TokenTransferOutputData = {
+    /**
+     * The owner of the output token account
+     */
     owner: PublicKey;
+    /**
+     * The amount of tokens of the output token account
+     */
     amount: BN;
+    /**
+     * lamports associated with the output token account
+     */
     lamports: BN | null;
 };
 type InputTokenDataWithContext = {
+    /**
+     * The amount of tokens to transfer
+     */
     amount: BN;
+    /**
+     * Optional: The index of the delegate in remaining accounts
+     */
     delegateIndex: number | null;
+    /**
+     * Optional: The amount of delegated tokens
+     */
     delegatedAmount: BN | null;
+    /**
+     * Optional: Whether the token is native (wSOL)
+     */
     isNative: BN | null;
+    /**
+     * The index of the merkle tree address in remaining accounts
+     */
     merkleTreePubkeyIndex: number;
+    /**
+     * The index of the nullifier queue address in remaining accounts
+     */
     nullifierQueuePubkeyIndex: number;
+    /**
+     * The index of the leaf in the merkle tree
+     */
     leafIndex: number;
 };
-type CompressedTokenInstructionDataTransfer = {
+type CompressedTokenInstructionDataInvoke = {
+    /**
+     * Validity proof
+     */
     proof: CompressedProof | null;
+    /**
+     * The root indices of the transfer
+     */
     rootIndices: number[];
+    /**
+     * The mint of the transfer
+     */
     mint: PublicKey;
+    /**
+     * Whether the signer is a delegate
+     */
     signerIsDelegate: boolean;
+    /**
+     * Input token data with packed merkle context
+     */
     inputTokenDataWithContext: InputTokenDataWithContext[];
+    /**
+     * Data of the output token accounts
+     */
     outputCompressedAccounts: TokenTransferOutputData[];
+    /**
+     * The indices of the output state merkle tree accounts in 'remaining
+     * accounts'
+     */
     outputStateMerkleTreeAccountIndices: Buffer;
 };
 type TokenData = {
+    /**
+     * The mint associated with this account
+     */
     mint: PublicKey;
+    /**
+     * The owner of this account
+     */
     owner: PublicKey;
+    /**
+     * The amount of tokens this account holds
+     */
     amount: BN;
+    /**
+     * If `delegate` is `Some` then `delegated_amount` represents the amount
+     * authorized by the delegate
+     */
     delegate: PublicKey | null;
+    /**
+     * The account's state
+     */
     state: number;
+    /**
+     * If is_some, this is a native token, and the value logs the rent-exempt
+     * reserve. An Account is required to be rent-exempt, so the value is used
+     * by the Processor to ensure that wrapped SOL accounts do not drop below
+     * this threshold.
+     */
     isNative: BN | null;
+    /**
+     * The amount delegated
+     */
     delegatedAmount: BN;
 };
 
+/**
+ * Mint compressed tokens to a solana address from an external mint authority
+ *
+ * @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
+ */
+declare function approveAndMintTo(rpc: Rpc, payer: Signer, mint: PublicKey, destination: PublicKey, authority: Signer, amount: number | BN, merkleTree?: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+
 /**
  * Compress SPL tokens
  *
@@ -1237,6 +1437,19 @@ declare function createMint(rpc: Rpc, payer: Signer, mintAuthority: Signer, deci
 declare function mintTo(rpc: Rpc, payer: Signer, mint: PublicKey, destination: PublicKey, authority: Signer, amount: number | BN, merkleTree?: PublicKey, // DEFAULT IF NOT PROVIDED
 confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 
+/**
+ * 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
+ */
+declare function registerMint(rpc: Rpc, payer: Signer, mintAuthority: Signer, mintAddress: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+
 /**
  * Transfer compressed tokens from one owner to another
  *
@@ -1267,4 +1480,4 @@ declare function selectMinCompressedTokenAccountsForTransfer(accounts: ParsedTok
     totalLamports: BN | null
 ];
 
-export { CPI_AUTHORITY_SEED, type CompressedTokenInstructionDataTransfer, CompressedTokenProgram, type CreateMintParams, IDL, type InputTokenDataWithContext, type LightCompressedToken, MINT_AUTHORITY_SEED, type MintToParams, POOL_SEED, type PackCompressedTokenAccountsParams, SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE, type TokenData, type TokenTransferOutputData, type TransferParams, compress, createDecompressOutputState, createMint, createTransferOutputState, decompress, mintTo, packCompressedTokenAccounts, parseInputTokenData, selectMinCompressedTokenAccountsForTransfer, sumUpTokenAmount, transfer, validateSameTokenOwner };
+export { type ApproveAndMintToParams, CPI_AUTHORITY_SEED, type CompressedTokenInstructionDataInvoke, CompressedTokenProgram, type CreateMintParams, IDL, type InputTokenDataWithContext, type LightCompressedToken, MINT_AUTHORITY_SEED, type MintToParams, POOL_SEED, type PackCompressedTokenAccountsParams, type RegisterMintParams, SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE, type TokenData, type TokenTransferOutputData, type TransferParams, approveAndMintTo, compress, createDecompressOutputState, createMint, createTransferOutputState, decompress, mintTo, packCompressedTokenAccounts, parseTokenData, registerMint, selectMinCompressedTokenAccountsForTransfer, sumUpTokenAmount, transfer, validateSameTokenOwner };