@lightprotocol/compressed-token 0.1.0

package/dist/types/index.d.ts

@@ -0,0 +1,1270 @@
+import { ParsedTokenAccount, InputTokenDataWithContext as InputTokenDataWithContext$1, CompressedProof, TokenTransferOutputData as TokenTransferOutputData$1, Rpc } from '@lightprotocol/stateless.js';
+import { PublicKey, AccountMeta, TransactionInstruction, Signer, ConfirmOptions, TransactionSignature, Keypair } from '@solana/web3.js';
+import { BN, Program } from '@coral-xyz/anchor';
+
+type LightCompressedToken = {
+    version: '0.3.0';
+    name: 'light_compressed_token';
+    constants: [
+        {
+            name: 'PROGRAM_ID';
+            type: 'string';
+            value: '"9sixVEthz2kMSKfeApZXHwuboT6DZuT6crAYJTciUCqE"';
+        }
+    ];
+    instructions: [
+        {
+            name: 'createMint';
+            docs: [
+                'This instruction expects a mint account to be created in a separate token program instruction',
+                'with token authority as mint authority.',
+                'This instruction creates a token pool account for that mint owned by token authority.'
+            ];
+            accounts: [
+                {
+                    name: 'feePayer';
+                    isMut: true;
+                    isSigner: true;
+                },
+                {
+                    name: 'authority';
+                    isMut: true;
+                    isSigner: true;
+                },
+                {
+                    name: 'tokenPoolPda';
+                    isMut: true;
+                    isSigner: false;
+                },
+                {
+                    name: 'systemProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'mint';
+                    isMut: true;
+                    isSigner: false;
+                },
+                {
+                    name: 'mintAuthorityPda';
+                    isMut: true;
+                    isSigner: false;
+                },
+                {
+                    name: 'tokenProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'cpiAuthorityPda';
+                    isMut: false;
+                    isSigner: false;
+                }
+            ];
+            args: [];
+        },
+        {
+            name: 'mintTo';
+            accounts: [
+                {
+                    name: 'feePayer';
+                    isMut: true;
+                    isSigner: true;
+                },
+                {
+                    name: 'authority';
+                    isMut: true;
+                    isSigner: true;
+                },
+                {
+                    name: 'mintAuthorityPda';
+                    isMut: true;
+                    isSigner: false;
+                },
+                {
+                    name: 'mint';
+                    isMut: true;
+                    isSigner: false;
+                },
+                {
+                    name: 'tokenPoolPda';
+                    isMut: true;
+                    isSigner: false;
+                },
+                {
+                    name: 'tokenProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'compressedPdaProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'registeredProgramPda';
+                    isMut: true;
+                    isSigner: false;
+                },
+                {
+                    name: 'noopProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'accountCompressionAuthority';
+                    isMut: true;
+                    isSigner: false;
+                },
+                {
+                    name: 'accountCompressionProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'merkleTree';
+                    isMut: true;
+                    isSigner: false;
+                },
+                {
+                    name: 'selfProgram';
+                    isMut: false;
+                    isSigner: false;
+                }
+            ];
+            args: [
+                {
+                    name: 'publicKeys';
+                    type: {
+                        vec: 'publicKey';
+                    };
+                },
+                {
+                    name: 'amounts';
+                    type: {
+                        vec: 'u64';
+                    };
+                }
+            ];
+        },
+        {
+            name: 'transfer';
+            accounts: [
+                {
+                    name: 'feePayer';
+                    isMut: false;
+                    isSigner: true;
+                },
+                {
+                    name: 'authority';
+                    isMut: false;
+                    isSigner: true;
+                },
+                {
+                    name: 'cpiAuthorityPda';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'compressedPdaProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'registeredProgramPda';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'noopProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'accountCompressionAuthority';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'accountCompressionProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'selfProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'tokenPoolPda';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                },
+                {
+                    name: 'decompressTokenAccount';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                },
+                {
+                    name: 'tokenProgram';
+                    isMut: false;
+                    isSigner: false;
+                    isOptional: true;
+                }
+            ];
+            args: [
+                {
+                    name: 'inputs';
+                    type: 'bytes';
+                },
+                {
+                    name: 'cpiContext';
+                    type: {
+                        option: {
+                            defined: 'CompressedCpiContext';
+                        };
+                    };
+                }
+            ];
+        }
+    ];
+    types: [
+        {
+            name: 'CompressedAccountWithMerkleContext';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'compressedAccount';
+                        type: {
+                            defined: 'CompressedAccount';
+                        };
+                    },
+                    {
+                        name: 'merkleTreePubkeyIndex';
+                        type: 'u8';
+                    },
+                    {
+                        name: 'nullifierQueuePubkeyIndex';
+                        type: 'u8';
+                    },
+                    {
+                        name: 'leafIndex';
+                        type: 'u32';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'MerkleContext';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'merkleTreePubkey';
+                        type: 'publicKey';
+                    },
+                    {
+                        name: 'nullifierQueuePubkey';
+                        type: 'publicKey';
+                    },
+                    {
+                        name: 'leafIndex';
+                        type: 'u32';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'PackedMerkleContext';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'merkleTreePubkeyIndex';
+                        type: 'u8';
+                    },
+                    {
+                        name: 'nullifierQueuePubkeyIndex';
+                        type: 'u8';
+                    },
+                    {
+                        name: 'leafIndex';
+                        type: 'u32';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'CompressedAccount';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'owner';
+                        type: 'publicKey';
+                    },
+                    {
+                        name: 'lamports';
+                        type: 'u64';
+                    },
+                    {
+                        name: 'address';
+                        type: {
+                            option: {
+                                array: ['u8', 32];
+                            };
+                        };
+                    },
+                    {
+                        name: 'data';
+                        type: {
+                            option: {
+                                defined: 'CompressedAccountData';
+                            };
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: 'CompressedAccountData';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'discriminator';
+                        type: {
+                            array: ['u8', 8];
+                        };
+                    },
+                    {
+                        name: 'data';
+                        type: 'bytes';
+                    },
+                    {
+                        name: 'dataHash';
+                        type: {
+                            array: ['u8', 32];
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: 'CompressedCpiContext';
+            docs: ['To spend multiple compressed'];
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'cpiSignatureAccountIndex';
+                        docs: [
+                            'index of the output state Merkle tree that will be used to store cpi signatures',
+                            'The transaction will fail if this index is not consistent in your transaction.'
+                        ];
+                        type: 'u8';
+                    },
+                    {
+                        name: 'execute';
+                        docs: [
+                            'The final cpi of your program needs to set execute to true.',
+                            'Execute compressed transaction will verify the proof and execute the transaction if this is true.',
+                            'If this is false the transaction will be stored in the cpi signature account.'
+                        ];
+                        type: 'bool';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'PublicTransactionEvent';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'inputCompressedAccountHashes';
+                        type: {
+                            vec: {
+                                array: ['u8', 32];
+                            };
+                        };
+                    },
+                    {
+                        name: 'outputCompressedAccountHashes';
+                        type: {
+                            vec: {
+                                array: ['u8', 32];
+                            };
+                        };
+                    },
+                    {
+                        name: 'inputCompressedAccounts';
+                        type: {
+                            vec: {
+                                defined: 'CompressedAccountWithMerkleContext';
+                            };
+                        };
+                    },
+                    {
+                        name: 'outputCompressedAccounts';
+                        type: {
+                            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: 'InstructionDataTransfer';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'proof';
+                        type: {
+                            option: {
+                                defined: 'CompressedProof';
+                            };
+                        };
+                    },
+                    {
+                        name: 'newAddressParams';
+                        type: {
+                            vec: {
+                                defined: 'NewAddressParamsPacked';
+                            };
+                        };
+                    },
+                    {
+                        name: 'inputRootIndices';
+                        type: {
+                            vec: 'u16';
+                        };
+                    },
+                    {
+                        name: 'inputCompressedAccountsWithMerkleContext';
+                        type: {
+                            vec: {
+                                defined: 'CompressedAccountWithMerkleContext';
+                            };
+                        };
+                    },
+                    {
+                        name: 'outputCompressedAccounts';
+                        type: {
+                            vec: {
+                                defined: 'CompressedAccount';
+                            };
+                        };
+                    },
+                    {
+                        name: 'outputStateMerkleTreeAccountIndices';
+                        docs: [
+                            'The indices of the accounts in the output state merkle tree.'
+                        ];
+                        type: 'bytes';
+                    },
+                    {
+                        name: 'relayFee';
+                        type: {
+                            option: 'u64';
+                        };
+                    },
+                    {
+                        name: 'compressionLamports';
+                        type: {
+                            option: 'u64';
+                        };
+                    },
+                    {
+                        name: 'isCompress';
+                        type: 'bool';
+                    },
+                    {
+                        name: 'signerSeeds';
+                        type: {
+                            option: {
+                                vec: 'bytes';
+                            };
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: 'NewAddressParamsPacked';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'seed';
+                        type: {
+                            array: ['u8', 32];
+                        };
+                    },
+                    {
+                        name: 'addressQueueAccountIndex';
+                        type: 'u8';
+                    },
+                    {
+                        name: 'addressMerkleTreeAccountIndex';
+                        type: 'u8';
+                    },
+                    {
+                        name: 'addressMerkleTreeRootIndex';
+                        type: 'u16';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'NewAddressParams';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'seed';
+                        type: {
+                            array: ['u8', 32];
+                        };
+                    },
+                    {
+                        name: 'addressQueuePubkey';
+                        type: 'publicKey';
+                    },
+                    {
+                        name: 'addressMerkleTreePubkey';
+                        type: 'publicKey';
+                    },
+                    {
+                        name: 'addressMerkleTreeRootIndex';
+                        type: 'u16';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'CompressedProof';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'a';
+                        type: {
+                            array: ['u8', 32];
+                        };
+                    },
+                    {
+                        name: 'b';
+                        type: {
+                            array: ['u8', 64];
+                        };
+                    },
+                    {
+                        name: 'c';
+                        type: {
+                            array: ['u8', 32];
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: 'InputTokenDataWithContext';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'amount';
+                        type: 'u64';
+                    },
+                    {
+                        name: 'delegateIndex';
+                        type: {
+                            option: 'u8';
+                        };
+                    },
+                    {
+                        name: 'delegatedAmount';
+                        type: {
+                            option: 'u64';
+                        };
+                    },
+                    {
+                        name: 'isNative';
+                        type: {
+                            option: 'u64';
+                        };
+                    },
+                    {
+                        name: 'merkleTreePubkeyIndex';
+                        type: 'u8';
+                    },
+                    {
+                        name: 'nullifierQueuePubkeyIndex';
+                        type: 'u8';
+                    },
+                    {
+                        name: 'leafIndex';
+                        type: 'u32';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'CompressedTokenInstructionDataTransfer';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'proof';
+                        type: {
+                            option: {
+                                defined: 'CompressedProof';
+                            };
+                        };
+                    },
+                    {
+                        name: 'rootIndices';
+                        type: {
+                            vec: 'u16';
+                        };
+                    },
+                    {
+                        name: 'mint';
+                        type: 'publicKey';
+                    },
+                    {
+                        name: 'signerIsDelegate';
+                        type: 'bool';
+                    },
+                    {
+                        name: 'inputTokenDataWithContext';
+                        type: {
+                            vec: {
+                                defined: 'InputTokenDataWithContext';
+                            };
+                        };
+                    },
+                    {
+                        name: 'outputCompressedAccounts';
+                        type: {
+                            vec: {
+                                defined: 'TokenTransferOutputData';
+                            };
+                        };
+                    },
+                    {
+                        name: 'outputStateMerkleTreeAccountIndices';
+                        type: 'bytes';
+                    },
+                    {
+                        name: 'isCompress';
+                        type: 'bool';
+                    },
+                    {
+                        name: 'compressionAmount';
+                        type: {
+                            option: 'u64';
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: 'TokenTransferOutputData';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'owner';
+                        type: 'publicKey';
+                    },
+                    {
+                        name: 'amount';
+                        type: 'u64';
+                    },
+                    {
+                        name: 'lamports';
+                        type: {
+                            option: 'u64';
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: 'TokenData';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'mint';
+                        docs: ['The mint associated with this account'];
+                        type: 'publicKey';
+                    },
+                    {
+                        name: 'owner';
+                        docs: ['The owner of this account.'];
+                        type: 'publicKey';
+                    },
+                    {
+                        name: 'amount';
+                        docs: ['The amount of tokens this account holds.'];
+                        type: 'u64';
+                    },
+                    {
+                        name: '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: {
+                            defined: 'AccountState';
+                        };
+                    },
+                    {
+                        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: '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';
+                    },
+                    {
+                        name: 'Frozen';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'ErrorCode';
+            type: {
+                kind: 'enum';
+                variants: [
+                    {
+                        name: 'PublicKeyAmountMissmatch';
+                    },
+                    {
+                        name: 'MissingNewAuthorityPda';
+                    },
+                    {
+                        name: 'SignerCheckFailed';
+                    },
+                    {
+                        name: 'MintCheckFailed';
+                    },
+                    {
+                        name: 'ComputeInputSumFailed';
+                    },
+                    {
+                        name: 'ComputeOutputSumFailed';
+                    },
+                    {
+                        name: 'ComputeCompressSumFailed';
+                    },
+                    {
+                        name: 'ComputeDecompressSumFailed';
+                    },
+                    {
+                        name: 'SumCheckFailed';
+                    },
+                    {
+                        name: 'DecompressRecipientUndefinedForDecompress';
+                    },
+                    {
+                        name: 'CompressedPdaUndefinedForDecompress';
+                    },
+                    {
+                        name: 'DeCompressAmountUndefinedForDecompress';
+                    },
+                    {
+                        name: 'CompressedPdaUndefinedForCompress';
+                    },
+                    {
+                        name: 'DeCompressAmountUndefinedForCompress';
+                    },
+                    {
+                        name: 'DelegateUndefined';
+                    }
+                ];
+            };
+        }
+    ];
+    errors: [
+        {
+            code: 6000;
+            name: 'SignerCheckFailed';
+            msg: 'Signer check failed';
+        },
+        {
+            code: 6001;
+            name: 'CreateTransferInstructionFailed';
+            msg: 'Create transfer instruction failed';
+        }
+    ];
+};
+declare const IDL: LightCompressedToken;
+
+type PackCompressedTokenAccountsParams = {
+    /** Input state to be consumed */
+    inputCompressedTokenAccounts: ParsedTokenAccount[];
+    /** Length of output compressed accounts */
+    outputCompressedAccountsLength: number;
+    /**
+     * State trees that the output should be inserted into. Defaults to the 0th
+     * state tree of the input state. Gets padded to the length of
+     * outputCompressedAccounts.
+     */
+    outputStateTrees?: PublicKey[] | PublicKey;
+    /** Optional remaining accounts to append to */
+    remainingAccounts?: PublicKey[];
+};
+/**
+ * Packs Compressed Token Accounts.
+ */
+declare function packCompressedTokenAccounts(params: PackCompressedTokenAccountsParams): {
+    inputTokenDataWithContext: InputTokenDataWithContext$1[];
+    outputStateMerkleTreeIndices: number[];
+    remainingAccountMetas: AccountMeta[];
+};
+
+declare const POOL_SEED: Buffer;
+declare const CPI_AUTHORITY_SEED: Buffer;
+declare const MINT_AUTHORITY_SEED: Uint8Array;
+declare const SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE = 1461600;
+
+type CompressParams = {
+    /**
+     * The payer of the transaction.
+     */
+    payer: PublicKey;
+    /**
+     * owner of the *uncompressed* token account.
+     */
+    owner: PublicKey;
+    /**
+     * source (associated) token account address.
+     */
+    source: PublicKey;
+    /**
+     * owner of the compressed token account.
+     */
+    toAddress: PublicKey;
+    /**
+     * Mint address of the token to compress.
+     */
+    mint: PublicKey;
+    /**
+     * amount of tokens to compress.
+     */
+    amount: number | BN;
+    /**
+     * The state tree that the tx output should be inserted into.
+     */
+    outputStateTree: PublicKey;
+};
+type DecompressParams = {
+    /**
+     * The payer of the transaction.
+     */
+    payer: PublicKey;
+    /**
+     * input state to be consumed
+     */
+    inputCompressedTokenAccounts: ParsedTokenAccount[];
+    /**
+     * address of **uncompressed** destination token account.
+     */
+    toAddress: PublicKey;
+    /**
+     * amount of tokens to decompress.
+     */
+    amount: number | BN;
+    /**
+     * The state tree that the change tx output should be inserted into.
+     */
+    outputStateTree: PublicKey;
+    /**
+     * The recent state root indices of the input state. The expiry is tied to
+     * the proof.
+     */
+    recentInputStateRootIndices: number[];
+    /**
+     * The recent validity proof for state inclusion of the input state. It
+     * expires after n slots.
+     */
+    recentValidityProof: CompressedProof;
+};
+type TransferParams = {
+    /**
+     * The payer of the transaction
+     */
+    payer: PublicKey;
+    /**
+     * The input state to be consumed
+     */
+    inputCompressedTokenAccounts: ParsedTokenAccount[];
+    /**
+     * Recipient address
+     */
+    toAddress: PublicKey;
+    /**
+     * Amount of tokens to transfer
+     */
+    amount: BN | number;
+    /**
+     * The recent state root indices of the input state. The expiry is tied to
+     * the proof.
+
+     */
+    recentInputStateRootIndices: number[];
+    /**
+     * The recent validity proof for state inclusion of the input state. It
+     * expires after n slots.
+     */
+    recentValidityProof: CompressedProof;
+    /**
+     * The state trees that the tx output should be inserted into. This can be a
+     * single PublicKey or an array of PublicKey. Defaults to the 0th state tree
+     * of input state.
+     */
+    outputStateTrees?: PublicKey[] | PublicKey;
+};
+/** Create Mint account for compressed Tokens */
+type CreateMintParams = {
+    /** Tx feepayer */
+    feePayer: PublicKey;
+    /** Mint authority */
+    authority: PublicKey;
+    /** Mint public key */
+    mint: PublicKey;
+    /** Mint decimals */
+    decimals: number;
+    /** Optional: freeze authority */
+    freezeAuthority: PublicKey | null;
+    /** lamport amount for mint account rent exemption */
+    rentExemptBalance: number;
+};
+/**
+ * Create compressed token accounts
+ */
+type MintToParams = {
+    /** Tx feepayer */
+    feePayer: PublicKey;
+    /** Mint authority */
+    authority: PublicKey;
+    /** Mint public key */
+    mint: PublicKey;
+    /** The Solana Public Keys to mint to. Accepts batches */
+    toPubkey: PublicKey[] | PublicKey;
+    /** The amount of compressed tokens to mint. Accepts batches */
+    amount: BN | BN[] | number | number[];
+    /** Public key of the state tree to mint into. */
+    merkleTree: PublicKey;
+};
+declare const sumUpTokenAmount: (accounts: ParsedTokenAccount[]) => BN;
+declare const validateSameTokenOwner: (accounts: ParsedTokenAccount[]) => void;
+declare const parseInputTokenData: (inputCompressedTokenAccounts: ParsedTokenAccount[]) => {
+    mint: PublicKey;
+    currentOwner: PublicKey;
+    delegate: PublicKey | null;
+};
+declare function createTransferOutputState(inputCompressedTokenAccounts: ParsedTokenAccount[], toAddress: PublicKey, amount: number | BN): TokenTransferOutputData$1[];
+declare function createDecompressOutputState(inputCompressedTokenAccounts: ParsedTokenAccount[], amount: number | BN): TokenTransferOutputData$1[];
+declare class CompressedTokenProgram {
+    /**
+     * @internal
+     */
+    constructor();
+    /**
+     * Public key that identifies the CompressedPda program
+     */
+    static programId: PublicKey;
+    private static _program;
+    static get program(): Program<LightCompressedToken>;
+    /**
+     * Initializes the program statically if not already initialized.
+     */
+    private static initializeProgram;
+    /** @internal */
+    static deriveMintAuthorityPda: (authority: PublicKey, mint: PublicKey) => PublicKey;
+    /** @internal */
+    static deriveTokenPoolPda(mint: PublicKey): PublicKey;
+    /** @internal */
+    static get deriveCpiAuthorityPda(): PublicKey;
+    static createMint(params: CreateMintParams): Promise<TransactionInstruction[]>;
+    static mintTo(params: MintToParams): Promise<TransactionInstruction>;
+    static transfer(params: TransferParams): Promise<TransactionInstruction[]>;
+    static compress(params: CompressParams): Promise<TransactionInstruction[]>;
+    static decompress(params: DecompressParams): Promise<TransactionInstruction[]>;
+}
+
+type TokenTransferOutputData = {
+    owner: PublicKey;
+    amount: BN;
+    lamports: BN | null;
+};
+type InputTokenDataWithContext = {
+    amount: BN;
+    delegateIndex: number | null;
+    delegatedAmount: BN | null;
+    isNative: BN | null;
+    merkleTreePubkeyIndex: number;
+    nullifierQueuePubkeyIndex: number;
+    leafIndex: number;
+};
+type CompressedTokenInstructionDataTransfer = {
+    proof: CompressedProof | null;
+    rootIndices: number[];
+    mint: PublicKey;
+    signerIsDelegate: boolean;
+    inputTokenDataWithContext: InputTokenDataWithContext[];
+    outputCompressedAccounts: TokenTransferOutputData[];
+    outputStateMerkleTreeAccountIndices: Buffer;
+};
+type TokenData = {
+    mint: PublicKey;
+    owner: PublicKey;
+    amount: BN;
+    delegate: PublicKey | null;
+    state: number;
+    isNative: BN | null;
+    delegatedAmount: BN;
+};
+
+/**
+ * Compress SPL tokens
+ *
+ * @param rpc                   Rpc connection to use
+ * @param payer                 Payer of the transaction fees
+ * @param mint                  Mint of the compressed token
+ * @param amount                Number of tokens to transfer
+ * @param owner                 Owner of the compressed tokens.
+ * @param sourceTokenAccount    Source (associated) token account
+ * @param toAddress             Destination address of the recipient
+ * @param merkleTree            State tree account that the compressed tokens
+ *                              should be inserted into. Defaults to a default
+ *                              state tree account.
+ * @param confirmOptions        Options for confirming the transaction
+ *
+ *
+ * @return Signature of the confirmed transaction
+ */
+declare function compress(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, sourceTokenAccount: PublicKey, toAddress: PublicKey, merkleTree?: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+
+/**
+ * Decompress compressed tokens
+ *
+ * @param rpc            Rpc to use
+ * @param payer          Payer of the transaction fees
+ * @param mint           Mint of the compressed token
+ * @param amount         Number of tokens to transfer
+ * @param owner          Owner of the compressed tokens
+ * @param toAddress      Destination **uncompressed** (associated) token account
+ *                       address.
+ * @param merkleTree     State tree account that any change compressed tokens should be
+ *                       inserted into. Defaults to a default state tree
+ *                       account.
+ * @param confirmOptions Options for confirming the transaction
+ *
+ *
+ * @return Signature of the confirmed transaction
+ */
+declare function decompress(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, merkleTree?: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+
+/**
+ * Create and initialize a new compressed token mint
+ *
+ * @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 decimals        Location of the decimal place
+ * @param keypair         Optional keypair, defaulting to a new random one
+ * @param confirmOptions  Options for confirming the transaction
+ *
+ * @return Address of the new mint and the transaction signature
+ */
+declare function createMint(rpc: Rpc, payer: Signer, mintAuthority: Signer, decimals: number, keypair?: Keypair, confirmOptions?: ConfirmOptions): Promise<{
+    mint: PublicKey;
+    transactionSignature: TransactionSignature;
+}>;
+
+/**
+ * Mint compressed tokens to a solana address
+ *
+ * @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 mintTo(rpc: Rpc, payer: Signer, mint: PublicKey, destination: PublicKey, authority: Signer, amount: number | BN, merkleTree?: PublicKey, // DEFAULT IF NOT PROVIDED
+confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+
+/**
+ * Transfer compressed tokens from one owner to another
+ *
+ * @param rpc            Rpc to use
+ * @param payer          Payer of the transaction fees
+ * @param mint           Mint of the compressed token
+ * @param amount         Number of tokens to transfer
+ * @param owner          Owner of the compressed tokens
+ * @param toAddress      Destination address of the recipient
+ * @param merkleTree     State tree account that the compressed tokens should be
+ *                       inserted into. Defaults to the default state tree account.
+ * @param confirmOptions Options for confirming the transaction
+ *
+ *
+ * @return Signature of the confirmed transaction
+ */
+declare function transfer(rpc: Rpc, payer: Signer, mint: PublicKey, amount: number | BN, owner: Signer, toAddress: PublicKey, merkleTree?: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+/**
+ * Selects the minimal number of compressed token accounts for a transfer.
+ *
+ * 1. Sorts the accounts by amount in descending order
+ * 2. Accumulates the amount until it is greater than or equal to the transfer
+ *    amount
+ */
+declare function selectMinCompressedTokenAccountsForTransfer(accounts: ParsedTokenAccount[], transferAmount: BN): [
+    selectedAccounts: ParsedTokenAccount[],
+    total: BN,
+    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 };