@lightprotocol/compressed-token 0.17.0 → 0.17.2-alpha.0

package/dist/cjs/node/index.cjs

@@ -1,2828 +1,2 @@
-'use strict';
-
-var stateless_js = require('@lightprotocol/stateless.js');
-var web3_js = require('@solana/web3.js');
-var anchor = require('@coral-xyz/anchor');
-var splToken = require('@solana/spl-token');
-
-const IDL = {
-    version: '1.2.0',
-    name: 'light_compressed_token',
-    instructions: [
-        {
-            name: 'createTokenPool',
-            docs: [
-                'This instruction creates a token pool for a given mint. Every spl mint',
-                'can have one token pool. When a token is compressed the tokens are',
-                'transferrred to the token pool, and their compressed equivalent is',
-                'minted into a Merkle tree.',
-            ],
-            accounts: [
-                {
-                    name: 'feePayer',
-                    isMut: true,
-                    isSigner: true,
-                    docs: ['UNCHECKED: only pays fees.'],
-                },
-                {
-                    name: 'tokenPoolPda',
-                    isMut: true,
-                    isSigner: false,
-                },
-                {
-                    name: 'systemProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'mint',
-                    isMut: true,
-                    isSigner: false,
-                },
-                {
-                    name: 'tokenProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'cpiAuthorityPda',
-                    isMut: false,
-                    isSigner: false,
-                },
-            ],
-            args: [],
-        },
-        {
-            name: 'mintTo',
-            docs: [
-                'Mints tokens from an spl token mint to a list of compressed accounts.',
-                'Minted tokens are transferred to a pool account owned by the compressed',
-                'token program. The instruction creates one compressed output account for',
-                'every amount and pubkey input pair. A constant amount of lamports can be',
-                'transferred to each output account to enable. A use case to add lamports',
-                'to a compressed token account is to prevent spam. This is the only way',
-                'to add lamports to a compressed token account.',
-            ],
-            accounts: [
-                {
-                    name: 'feePayer',
-                    isMut: true,
-                    isSigner: true,
-                    docs: ['UNCHECKED: only pays fees.'],
-                },
-                {
-                    name: 'authority',
-                    isMut: false,
-                    isSigner: true,
-                },
-                {
-                    name: 'cpiAuthorityPda',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'mint',
-                    isMut: true,
-                    isSigner: false,
-                },
-                {
-                    name: 'tokenPoolPda',
-                    isMut: true,
-                    isSigner: false,
-                },
-                {
-                    name: 'tokenProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'lightSystemProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'registeredProgramPda',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'noopProgram',
-                    isMut: false,
-                    isSigner: false,
-                    docs: ['programs'],
-                },
-                {
-                    name: 'accountCompressionAuthority',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'accountCompressionProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'merkleTree',
-                    isMut: true,
-                    isSigner: false,
-                },
-                {
-                    name: 'selfProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'systemProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'solPoolPda',
-                    isMut: true,
-                    isSigner: false,
-                    isOptional: true,
-                },
-            ],
-            args: [
-                {
-                    name: 'publicKeys',
-                    type: {
-                        vec: 'publicKey',
-                    },
-                },
-                {
-                    name: 'amounts',
-                    type: {
-                        vec: 'u64',
-                    },
-                },
-                {
-                    name: 'lamports',
-                    type: {
-                        option: 'u64',
-                    },
-                },
-            ],
-        },
-        {
-            name: 'compressSplTokenAccount',
-            docs: [
-                'Compresses the balance of an spl token account sub an optional remaining',
-                'amount. This instruction does not close the spl token account. To close',
-                'the account bundle a close spl account instruction in your transaction.',
-            ],
-            accounts: [
-                {
-                    name: 'feePayer',
-                    isMut: true,
-                    isSigner: true,
-                    docs: ['UNCHECKED: only pays fees.'],
-                },
-                {
-                    name: 'authority',
-                    isMut: false,
-                    isSigner: true,
-                    docs: [
-                        'Authority is verified through proof since both owner and delegate',
-                        'are included in the token data hash, which is a public input to the',
-                        'validity proof.',
-                    ],
-                },
-                {
-                    name: 'cpiAuthorityPda',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'lightSystemProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'registeredProgramPda',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'noopProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'accountCompressionAuthority',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'accountCompressionProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'selfProgram',
-                    isMut: false,
-                    isSigner: false,
-                    docs: ['this program is the signer of the cpi.'],
-                },
-                {
-                    name: 'tokenPoolPda',
-                    isMut: true,
-                    isSigner: false,
-                    isOptional: true,
-                },
-                {
-                    name: 'compressOrDecompressTokenAccount',
-                    isMut: true,
-                    isSigner: false,
-                    isOptional: true,
-                },
-                {
-                    name: 'tokenProgram',
-                    isMut: false,
-                    isSigner: false,
-                    isOptional: true,
-                },
-                {
-                    name: 'systemProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-            ],
-            args: [
-                {
-                    name: 'owner',
-                    type: 'publicKey',
-                },
-                {
-                    name: 'remainingAmount',
-                    type: {
-                        option: 'u64',
-                    },
-                },
-                {
-                    name: 'cpiContext',
-                    type: {
-                        option: {
-                            defined: 'CompressedCpiContext',
-                        },
-                    },
-                },
-            ],
-        },
-        {
-            name: 'transfer',
-            docs: [
-                'Transfers compressed tokens from one account to another. All accounts',
-                'must be of the same mint. Additional spl tokens can be compressed or',
-                'decompressed. In one transaction only compression or decompression is',
-                'possible. Lamports can be transferred alongside tokens. If output token',
-                'accounts specify less lamports than inputs the remaining lamports are',
-                'transferred to an output compressed account. Signer must be owner or',
-                'delegate. If a delegated token account is transferred the delegate is',
-                'not preserved.',
-            ],
-            accounts: [
-                {
-                    name: 'feePayer',
-                    isMut: true,
-                    isSigner: true,
-                    docs: ['UNCHECKED: only pays fees.'],
-                },
-                {
-                    name: 'authority',
-                    isMut: false,
-                    isSigner: true,
-                    docs: [
-                        'Authority is verified through proof since both owner and delegate',
-                        'are included in the token data hash, which is a public input to the',
-                        'validity proof.',
-                    ],
-                },
-                {
-                    name: 'cpiAuthorityPda',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'lightSystemProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'registeredProgramPda',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'noopProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'accountCompressionAuthority',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'accountCompressionProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'selfProgram',
-                    isMut: false,
-                    isSigner: false,
-                    docs: ['this program is the signer of the cpi.'],
-                },
-                {
-                    name: 'tokenPoolPda',
-                    isMut: true,
-                    isSigner: false,
-                    isOptional: true,
-                },
-                {
-                    name: 'compressOrDecompressTokenAccount',
-                    isMut: true,
-                    isSigner: false,
-                    isOptional: true,
-                },
-                {
-                    name: 'tokenProgram',
-                    isMut: false,
-                    isSigner: false,
-                    isOptional: true,
-                },
-                {
-                    name: 'systemProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-            ],
-            args: [
-                {
-                    name: 'inputs',
-                    type: 'bytes',
-                },
-            ],
-        },
-        {
-            name: 'approve',
-            docs: [
-                'Delegates an amount to a delegate. A compressed token account is either',
-                'completely delegated or not. Prior delegates are not preserved. Cannot',
-                'be called by a delegate.',
-                'The instruction creates two output accounts:',
-                '1. one account with delegated amount',
-                '2. one account with remaining(change) amount',
-            ],
-            accounts: [
-                {
-                    name: 'feePayer',
-                    isMut: true,
-                    isSigner: true,
-                    docs: ['UNCHECKED: only pays fees.'],
-                },
-                {
-                    name: 'authority',
-                    isMut: false,
-                    isSigner: true,
-                    docs: [
-                        'Authority is verified through proof since both owner and delegate',
-                        'are included in the token data hash, which is a public input to the',
-                        'validity proof.',
-                    ],
-                },
-                {
-                    name: 'cpiAuthorityPda',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'lightSystemProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'registeredProgramPda',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'noopProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'accountCompressionAuthority',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'accountCompressionProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'selfProgram',
-                    isMut: false,
-                    isSigner: false,
-                    docs: ['this program is the signer of the cpi.'],
-                },
-                {
-                    name: 'systemProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-            ],
-            args: [
-                {
-                    name: 'inputs',
-                    type: 'bytes',
-                },
-            ],
-        },
-        {
-            name: 'revoke',
-            docs: [
-                'Revokes a delegation. The instruction merges all inputs into one output',
-                'account. Cannot be called by a delegate. Delegates are not preserved.',
-            ],
-            accounts: [
-                {
-                    name: 'feePayer',
-                    isMut: true,
-                    isSigner: true,
-                    docs: ['UNCHECKED: only pays fees.'],
-                },
-                {
-                    name: 'authority',
-                    isMut: false,
-                    isSigner: true,
-                    docs: [
-                        'Authority is verified through proof since both owner and delegate',
-                        'are included in the token data hash, which is a public input to the',
-                        'validity proof.',
-                    ],
-                },
-                {
-                    name: 'cpiAuthorityPda',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'lightSystemProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'registeredProgramPda',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'noopProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'accountCompressionAuthority',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'accountCompressionProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'selfProgram',
-                    isMut: false,
-                    isSigner: false,
-                    docs: ['this program is the signer of the cpi.'],
-                },
-                {
-                    name: 'systemProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-            ],
-            args: [
-                {
-                    name: 'inputs',
-                    type: 'bytes',
-                },
-            ],
-        },
-        {
-            name: 'freeze',
-            docs: [
-                'Freezes compressed token accounts. Inputs must not be frozen. Creates as',
-                'many outputs as inputs. Balances and delegates are preserved.',
-            ],
-            accounts: [
-                {
-                    name: 'feePayer',
-                    isMut: true,
-                    isSigner: true,
-                    docs: ['UNCHECKED: only pays fees.'],
-                },
-                {
-                    name: 'authority',
-                    isMut: false,
-                    isSigner: true,
-                },
-                {
-                    name: 'cpiAuthorityPda',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'lightSystemProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'registeredProgramPda',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'noopProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'accountCompressionAuthority',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'accountCompressionProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'selfProgram',
-                    isMut: false,
-                    isSigner: false,
-                    docs: ['that this program is the signer of the cpi.'],
-                },
-                {
-                    name: 'systemProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'mint',
-                    isMut: false,
-                    isSigner: false,
-                },
-            ],
-            args: [
-                {
-                    name: 'inputs',
-                    type: 'bytes',
-                },
-            ],
-        },
-        {
-            name: 'thaw',
-            docs: [
-                'Thaws frozen compressed token accounts. Inputs must be frozen. Creates',
-                'as many outputs as inputs. Balances and delegates are preserved.',
-            ],
-            accounts: [
-                {
-                    name: 'feePayer',
-                    isMut: true,
-                    isSigner: true,
-                    docs: ['UNCHECKED: only pays fees.'],
-                },
-                {
-                    name: 'authority',
-                    isMut: false,
-                    isSigner: true,
-                },
-                {
-                    name: 'cpiAuthorityPda',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'lightSystemProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'registeredProgramPda',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'noopProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'accountCompressionAuthority',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'accountCompressionProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'selfProgram',
-                    isMut: false,
-                    isSigner: false,
-                    docs: ['that this program is the signer of the cpi.'],
-                },
-                {
-                    name: 'systemProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'mint',
-                    isMut: false,
-                    isSigner: false,
-                },
-            ],
-            args: [
-                {
-                    name: 'inputs',
-                    type: 'bytes',
-                },
-            ],
-        },
-        {
-            name: 'burn',
-            docs: [
-                'Burns compressed tokens and spl tokens from the pool account. Delegates',
-                'can burn tokens. The output compressed token account remains delegated.',
-                'Creates one output compressed token account.',
-            ],
-            accounts: [
-                {
-                    name: 'feePayer',
-                    isMut: true,
-                    isSigner: true,
-                    docs: ['UNCHECKED: only pays fees.'],
-                },
-                {
-                    name: 'authority',
-                    isMut: false,
-                    isSigner: true,
-                    docs: [
-                        'Authority is verified through proof since both owner and delegate',
-                        'are included in the token data hash, which is a public input to the',
-                        'validity proof.',
-                    ],
-                },
-                {
-                    name: 'cpiAuthorityPda',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'mint',
-                    isMut: true,
-                    isSigner: false,
-                },
-                {
-                    name: 'tokenPoolPda',
-                    isMut: true,
-                    isSigner: false,
-                },
-                {
-                    name: 'tokenProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'lightSystemProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'registeredProgramPda',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'noopProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'accountCompressionAuthority',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'accountCompressionProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'selfProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'systemProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-            ],
-            args: [
-                {
-                    name: 'inputs',
-                    type: 'bytes',
-                },
-            ],
-        },
-        {
-            name: 'stubIdlBuild',
-            docs: [
-                'This function is a stub to allow Anchor to include the input types in',
-                'the IDL. It should not be included in production builds nor be called in',
-                'practice.',
-            ],
-            accounts: [
-                {
-                    name: 'feePayer',
-                    isMut: true,
-                    isSigner: true,
-                    docs: ['UNCHECKED: only pays fees.'],
-                },
-                {
-                    name: 'authority',
-                    isMut: false,
-                    isSigner: true,
-                    docs: [
-                        'Authority is verified through proof since both owner and delegate',
-                        'are included in the token data hash, which is a public input to the',
-                        'validity proof.',
-                    ],
-                },
-                {
-                    name: 'cpiAuthorityPda',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'lightSystemProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'registeredProgramPda',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'noopProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'accountCompressionAuthority',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'accountCompressionProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-                {
-                    name: 'selfProgram',
-                    isMut: false,
-                    isSigner: false,
-                    docs: ['this program is the signer of the cpi.'],
-                },
-                {
-                    name: 'tokenPoolPda',
-                    isMut: true,
-                    isSigner: false,
-                    isOptional: true,
-                },
-                {
-                    name: 'compressOrDecompressTokenAccount',
-                    isMut: true,
-                    isSigner: false,
-                    isOptional: true,
-                },
-                {
-                    name: 'tokenProgram',
-                    isMut: false,
-                    isSigner: false,
-                    isOptional: true,
-                },
-                {
-                    name: 'systemProgram',
-                    isMut: false,
-                    isSigner: false,
-                },
-            ],
-            args: [
-                {
-                    name: 'inputs1',
-                    type: {
-                        defined: 'CompressedTokenInstructionDataTransfer',
-                    },
-                },
-                {
-                    name: 'inputs2',
-                    type: {
-                        defined: 'TokenData',
-                    },
-                },
-            ],
-        },
-    ],
-    types: [
-        {
-            name: 'AccessMetadata',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'owner',
-                        docs: ['Owner of the Merkle tree.'],
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'programOwner',
-                        docs: [
-                            'Program owner of the Merkle tree. This will be used for program owned Merkle trees.',
-                        ],
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'forester',
-                        docs: [
-                            'Optional privileged forester pubkey, can be set for custom Merkle trees',
-                            'without a network fee. Merkle trees without network fees are not',
-                            'forested by light foresters. The variable is not used in the account',
-                            'compression program but the registry program. The registry program',
-                            'implements access control to prevent contention during forester. The',
-                            'forester pubkey specified in this struct can bypass contention checks.',
-                        ],
-                        type: 'publicKey',
-                    },
-                ],
-            },
-        },
-        {
-            name: 'AccountState',
-            type: {
-                kind: 'enum',
-                variants: [
-                    {
-                        name: 'Initialized',
-                    },
-                    {
-                        name: 'Frozen',
-                    },
-                ],
-            },
-        },
-        {
-            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',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'setContext',
-                        docs: [
-                            'Is set by the program that is invoking the CPI to signal that is should',
-                            'set the cpi context.',
-                        ],
-                        type: 'bool',
-                    },
-                    {
-                        name: 'firstSetContext',
-                        docs: [
-                            'Is set to wipe the cpi context since someone could have set it before',
-                            'with unrelated data.',
-                        ],
-                        type: 'bool',
-                    },
-                    {
-                        name: 'cpiContextAccountIndex',
-                        docs: [
-                            'Index of cpi context account in remaining accounts.',
-                        ],
-                        type: 'u8',
-                    },
-                ],
-            },
-        },
-        {
-            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: 'CompressedTokenInstructionDataTransfer',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'proof',
-                        type: {
-                            option: {
-                                defined: 'CompressedProof',
-                            },
-                        },
-                    },
-                    {
-                        name: 'mint',
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'delegatedTransfer',
-                        docs: [
-                            'Is required if the signer is delegate,',
-                            '-> delegate is authority account,',
-                            'owner = Some(owner) is the owner of the token account.',
-                        ],
-                        type: {
-                            option: {
-                                defined: 'DelegatedTransfer',
-                            },
-                        },
-                    },
-                    {
-                        name: 'inputTokenDataWithContext',
-                        type: {
-                            vec: {
-                                defined: 'InputTokenDataWithContext',
-                            },
-                        },
-                    },
-                    {
-                        name: 'outputCompressedAccounts',
-                        type: {
-                            vec: {
-                                defined: 'PackedTokenTransferOutputData',
-                            },
-                        },
-                    },
-                    {
-                        name: 'isCompress',
-                        type: 'bool',
-                    },
-                    {
-                        name: 'compressOrDecompressAmount',
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                    {
-                        name: 'cpiContext',
-                        type: {
-                            option: {
-                                defined: 'CompressedCpiContext',
-                            },
-                        },
-                    },
-                    {
-                        name: 'lamportsChangeAccountMerkleTreeIndex',
-                        type: {
-                            option: 'u8',
-                        },
-                    },
-                ],
-            },
-        },
-        {
-            name: 'DelegatedTransfer',
-            docs: [
-                'Struct to provide the owner when the delegate is signer of the transaction.',
-            ],
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'owner',
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'delegateChangeAccountIndex',
-                        docs: [
-                            'Index of change compressed account in output compressed accounts. In',
-                            "case that the delegate didn't spend the complete delegated compressed",
-                            'account balance the change compressed account will be delegated to her',
-                            'as well.',
-                        ],
-                        type: {
-                            option: 'u8',
-                        },
-                    },
-                ],
-            },
-        },
-        {
-            name: 'InputTokenDataWithContext',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'amount',
-                        type: 'u64',
-                    },
-                    {
-                        name: 'delegateIndex',
-                        type: {
-                            option: 'u8',
-                        },
-                    },
-                    {
-                        name: 'merkleContext',
-                        type: {
-                            defined: 'PackedMerkleContext',
-                        },
-                    },
-                    {
-                        name: 'rootIndex',
-                        type: 'u16',
-                    },
-                    {
-                        name: 'lamports',
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                    {
-                        name: 'tlv',
-                        docs: [
-                            'Placeholder for TokenExtension tlv data (unimplemented)',
-                        ],
-                        type: {
-                            option: 'bytes',
-                        },
-                    },
-                ],
-            },
-        },
-        {
-            name: 'InstructionDataInvoke',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'proof',
-                        type: {
-                            option: {
-                                defined: 'CompressedProof',
-                            },
-                        },
-                    },
-                    {
-                        name: 'inputCompressedAccountsWithMerkleContext',
-                        type: {
-                            vec: {
-                                defined: 'PackedCompressedAccountWithMerkleContext',
-                            },
-                        },
-                    },
-                    {
-                        name: 'outputCompressedAccounts',
-                        type: {
-                            vec: {
-                                defined: 'OutputCompressedAccountWithPackedContext',
-                            },
-                        },
-                    },
-                    {
-                        name: 'relayFee',
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                    {
-                        name: 'newAddressParams',
-                        type: {
-                            vec: {
-                                defined: 'NewAddressParamsPacked',
-                            },
-                        },
-                    },
-                    {
-                        name: 'compressOrDecompressLamports',
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                    {
-                        name: 'isCompress',
-                        type: 'bool',
-                    },
-                ],
-            },
-        },
-        {
-            name: 'InstructionDataInvokeCpi',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'proof',
-                        type: {
-                            option: {
-                                defined: 'CompressedProof',
-                            },
-                        },
-                    },
-                    {
-                        name: 'newAddressParams',
-                        type: {
-                            vec: {
-                                defined: 'NewAddressParamsPacked',
-                            },
-                        },
-                    },
-                    {
-                        name: 'inputCompressedAccountsWithMerkleContext',
-                        type: {
-                            vec: {
-                                defined: 'PackedCompressedAccountWithMerkleContext',
-                            },
-                        },
-                    },
-                    {
-                        name: 'outputCompressedAccounts',
-                        type: {
-                            vec: {
-                                defined: 'OutputCompressedAccountWithPackedContext',
-                            },
-                        },
-                    },
-                    {
-                        name: 'relayFee',
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                    {
-                        name: 'compressOrDecompressLamports',
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                    {
-                        name: 'isCompress',
-                        type: 'bool',
-                    },
-                    {
-                        name: 'cpiContext',
-                        type: {
-                            option: {
-                                defined: 'CompressedCpiContext',
-                            },
-                        },
-                    },
-                ],
-            },
-        },
-        {
-            name: 'MerkleTreeMetadata',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'accessMetadata',
-                        type: {
-                            defined: 'AccessMetadata',
-                        },
-                    },
-                    {
-                        name: 'rolloverMetadata',
-                        type: {
-                            defined: 'RolloverMetadata',
-                        },
-                    },
-                    {
-                        name: 'associatedQueue',
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'nextMerkleTree',
-                        type: 'publicKey',
-                    },
-                ],
-            },
-        },
-        {
-            name: 'MerkleTreeSequenceNumber',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'pubkey',
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'seq',
-                        type: 'u64',
-                    },
-                ],
-            },
-        },
-        {
-            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: 'OutputCompressedAccountWithPackedContext',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'compressedAccount',
-                        type: {
-                            defined: 'CompressedAccount',
-                        },
-                    },
-                    {
-                        name: 'merkleTreeIndex',
-                        type: 'u8',
-                    },
-                ],
-            },
-        },
-        {
-            name: 'PackedCompressedAccountWithMerkleContext',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'compressedAccount',
-                        type: {
-                            defined: 'CompressedAccount',
-                        },
-                    },
-                    {
-                        name: 'merkleContext',
-                        type: {
-                            defined: 'PackedMerkleContext',
-                        },
-                    },
-                    {
-                        name: 'rootIndex',
-                        docs: [
-                            'Index of root used in inclusion validity proof.',
-                        ],
-                        type: 'u16',
-                    },
-                    {
-                        name: 'readOnly',
-                        docs: [
-                            'Placeholder to mark accounts read-only unimplemented set to false.',
-                        ],
-                        type: 'bool',
-                    },
-                ],
-            },
-        },
-        {
-            name: 'PackedMerkleContext',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'merkleTreePubkeyIndex',
-                        type: 'u8',
-                    },
-                    {
-                        name: 'nullifierQueuePubkeyIndex',
-                        type: 'u8',
-                    },
-                    {
-                        name: 'leafIndex',
-                        type: 'u32',
-                    },
-                    {
-                        name: 'queueIndex',
-                        docs: [
-                            'Index of leaf in queue. Placeholder of batched Merkle tree updates',
-                            'currently unimplemented.',
-                        ],
-                        type: {
-                            option: {
-                                defined: 'QueueIndex',
-                            },
-                        },
-                    },
-                ],
-            },
-        },
-        {
-            name: 'PackedTokenTransferOutputData',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'owner',
-                        type: 'publicKey',
-                    },
-                    {
-                        name: 'amount',
-                        type: 'u64',
-                    },
-                    {
-                        name: 'lamports',
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                    {
-                        name: 'merkleTreeIndex',
-                        type: 'u8',
-                    },
-                    {
-                        name: 'tlv',
-                        docs: [
-                            'Placeholder for TokenExtension tlv data (unimplemented)',
-                        ],
-                        type: {
-                            option: 'bytes',
-                        },
-                    },
-                ],
-            },
-        },
-        {
-            name: 'PublicTransactionEvent',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'inputCompressedAccountHashes',
-                        type: {
-                            vec: {
-                                array: ['u8', 32],
-                            },
-                        },
-                    },
-                    {
-                        name: 'outputCompressedAccountHashes',
-                        type: {
-                            vec: {
-                                array: ['u8', 32],
-                            },
-                        },
-                    },
-                    {
-                        name: 'outputCompressedAccounts',
-                        type: {
-                            vec: {
-                                defined: 'OutputCompressedAccountWithPackedContext',
-                            },
-                        },
-                    },
-                    {
-                        name: 'outputLeafIndices',
-                        type: {
-                            vec: 'u32',
-                        },
-                    },
-                    {
-                        name: 'sequenceNumbers',
-                        type: {
-                            vec: {
-                                defined: 'MerkleTreeSequenceNumber',
-                            },
-                        },
-                    },
-                    {
-                        name: 'relayFee',
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                    {
-                        name: 'isCompress',
-                        type: 'bool',
-                    },
-                    {
-                        name: 'compressOrDecompressLamports',
-                        type: {
-                            option: 'u64',
-                        },
-                    },
-                    {
-                        name: 'pubkeyArray',
-                        type: {
-                            vec: 'publicKey',
-                        },
-                    },
-                    {
-                        name: 'message',
-                        type: {
-                            option: 'bytes',
-                        },
-                    },
-                ],
-            },
-        },
-        {
-            name: 'QueueIndex',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'queueId',
-                        docs: ['Id of queue in queue account.'],
-                        type: 'u8',
-                    },
-                    {
-                        name: 'index',
-                        docs: ['Index of compressed account hash in queue.'],
-                        type: 'u16',
-                    },
-                ],
-            },
-        },
-        {
-            name: 'RolloverMetadata',
-            type: {
-                kind: 'struct',
-                fields: [
-                    {
-                        name: 'index',
-                        docs: ['Unique index.'],
-                        type: 'u64',
-                    },
-                    {
-                        name: 'rolloverFee',
-                        docs: [
-                            'This fee is used for rent for the next account.',
-                            'It accumulates in the account so that once the corresponding Merkle tree account is full it can be rolled over',
-                        ],
-                        type: 'u64',
-                    },
-                    {
-                        name: 'rolloverThreshold',
-                        docs: [
-                            'The threshold in percentage points when the account should be rolled over (95 corresponds to 95% filled).',
-                        ],
-                        type: 'u64',
-                    },
-                    {
-                        name: 'networkFee',
-                        docs: ['Tip for maintaining the account.'],
-                        type: 'u64',
-                    },
-                    {
-                        name: 'rolledoverSlot',
-                        docs: [
-                            'The slot when the account was rolled over, a rolled over account should not be written to.',
-                        ],
-                        type: 'u64',
-                    },
-                    {
-                        name: 'closeThreshold',
-                        docs: [
-                            'If current slot is greater than rolledover_slot + close_threshold and',
-                            "the account is empty it can be closed. No 'close' functionality has been",
-                            'implemented yet.',
-                        ],
-                        type: 'u64',
-                    },
-                    {
-                        name: 'additionalBytes',
-                        docs: [
-                            'Placeholder for bytes of additional accounts which are tied to the',
-                            'Merkle trees operation and need to be rolled over as well.',
-                        ],
-                        type: '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: 'tlv',
-                        docs: [
-                            'Placeholder for TokenExtension tlv data (unimplemented)',
-                        ],
-                        type: {
-                            option: 'bytes',
-                        },
-                    },
-                ],
-            },
-        },
-    ],
-    errors: [
-        {
-            code: 6000,
-            name: 'PublicKeyAmountMissmatch',
-            msg: 'public keys and amounts must be of same length',
-        },
-        {
-            code: 6001,
-            name: 'ComputeInputSumFailed',
-            msg: 'ComputeInputSumFailed',
-        },
-        {
-            code: 6002,
-            name: 'ComputeOutputSumFailed',
-            msg: 'ComputeOutputSumFailed',
-        },
-        {
-            code: 6003,
-            name: 'ComputeCompressSumFailed',
-            msg: 'ComputeCompressSumFailed',
-        },
-        {
-            code: 6004,
-            name: 'ComputeDecompressSumFailed',
-            msg: 'ComputeDecompressSumFailed',
-        },
-        {
-            code: 6005,
-            name: 'SumCheckFailed',
-            msg: 'SumCheckFailed',
-        },
-        {
-            code: 6006,
-            name: 'DecompressRecipientUndefinedForDecompress',
-            msg: 'DecompressRecipientUndefinedForDecompress',
-        },
-        {
-            code: 6007,
-            name: 'CompressedPdaUndefinedForDecompress',
-            msg: 'CompressedPdaUndefinedForDecompress',
-        },
-        {
-            code: 6008,
-            name: 'DeCompressAmountUndefinedForDecompress',
-            msg: 'DeCompressAmountUndefinedForDecompress',
-        },
-        {
-            code: 6009,
-            name: 'CompressedPdaUndefinedForCompress',
-            msg: 'CompressedPdaUndefinedForCompress',
-        },
-        {
-            code: 6010,
-            name: 'DeCompressAmountUndefinedForCompress',
-            msg: 'DeCompressAmountUndefinedForCompress',
-        },
-        {
-            code: 6011,
-            name: 'DelegateSignerCheckFailed',
-            msg: 'DelegateSignerCheckFailed',
-        },
-        {
-            code: 6012,
-            name: 'MintTooLarge',
-            msg: 'Minted amount greater than u64::MAX',
-        },
-        {
-            code: 6013,
-            name: 'SplTokenSupplyMismatch',
-            msg: 'SplTokenSupplyMismatch',
-        },
-        {
-            code: 6014,
-            name: 'HeapMemoryCheckFailed',
-            msg: 'HeapMemoryCheckFailed',
-        },
-        {
-            code: 6015,
-            name: 'InstructionNotCallable',
-            msg: 'The instruction is not callable',
-        },
-        {
-            code: 6016,
-            name: 'ArithmeticUnderflow',
-            msg: 'ArithmeticUnderflow',
-        },
-        {
-            code: 6017,
-            name: 'HashToFieldError',
-            msg: 'HashToFieldError',
-        },
-        {
-            code: 6018,
-            name: 'InvalidAuthorityMint',
-            msg: 'Expected the authority to be also a mint authority',
-        },
-        {
-            code: 6019,
-            name: 'InvalidFreezeAuthority',
-            msg: 'Provided authority is not the freeze authority',
-        },
-        {
-            code: 6020,
-            name: 'InvalidDelegateIndex',
-        },
-        {
-            code: 6021,
-            name: 'TokenPoolPdaUndefined',
-        },
-        {
-            code: 6022,
-            name: 'IsTokenPoolPda',
-            msg: 'Compress or decompress recipient is the same account as the token pool pda.',
-        },
-        {
-            code: 6023,
-            name: 'InvalidTokenPoolPda',
-        },
-        {
-            code: 6024,
-            name: 'NoInputTokenAccountsProvided',
-        },
-        {
-            code: 6025,
-            name: 'NoInputsProvided',
-        },
-        {
-            code: 6026,
-            name: 'MintHasNoFreezeAuthority',
-        },
-        {
-            code: 6027,
-            name: 'MintWithInvalidExtension',
-        },
-        {
-            code: 6028,
-            name: 'InsufficientTokenAccountBalance',
-            msg: 'The token account balance is less than the remaining amount.',
-        },
-    ],
-};
-
-// TODO: include owner and lamports in packing.
-/**
- * Packs Compressed Token Accounts.
- */
-function packCompressedTokenAccounts(params) {
-    const { inputCompressedTokenAccounts, outputStateTrees, remainingAccounts = [], rootIndices, tokenTransferOutputs, } = params;
-    const _remainingAccounts = remainingAccounts.slice();
-    let delegateIndex = null;
-    if (inputCompressedTokenAccounts.length > 0 &&
-        inputCompressedTokenAccounts[0].parsed.delegate) {
-        delegateIndex = stateless_js.getIndexOrAdd(_remainingAccounts, inputCompressedTokenAccounts[0].parsed.delegate);
-    }
-    /// TODO: move pubkeyArray to remainingAccounts
-    /// Currently just packs 'delegate' to pubkeyArray
-    const packedInputTokenData = [];
-    /// pack inputs
-    inputCompressedTokenAccounts.forEach((account, index) => {
-        const merkleTreePubkeyIndex = stateless_js.getIndexOrAdd(_remainingAccounts, account.compressedAccount.merkleTree);
-        const nullifierQueuePubkeyIndex = stateless_js.getIndexOrAdd(_remainingAccounts, account.compressedAccount.nullifierQueue);
-        packedInputTokenData.push({
-            amount: account.parsed.amount,
-            delegateIndex,
-            merkleContext: {
-                merkleTreePubkeyIndex,
-                nullifierQueuePubkeyIndex,
-                leafIndex: account.compressedAccount.leafIndex,
-                queueIndex: null,
-            },
-            rootIndex: rootIndices[index],
-            lamports: account.compressedAccount.lamports.eq(stateless_js.bn(0))
-                ? null
-                : account.compressedAccount.lamports,
-            tlv: null,
-        });
-    });
-    /// pack output state trees
-    const paddedOutputStateMerkleTrees = stateless_js.padOutputStateMerkleTrees(outputStateTrees, tokenTransferOutputs.length, inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
-    const packedOutputTokenData = [];
-    paddedOutputStateMerkleTrees.forEach((account, index) => {
-        var _a;
-        const merkleTreeIndex = stateless_js.getIndexOrAdd(_remainingAccounts, account);
-        packedOutputTokenData.push({
-            owner: tokenTransferOutputs[index].owner,
-            amount: tokenTransferOutputs[index].amount,
-            lamports: ((_a = tokenTransferOutputs[index].lamports) === null || _a === void 0 ? void 0 : _a.eq(stateless_js.bn(0)))
-                ? null
-                : tokenTransferOutputs[index].lamports,
-            merkleTreeIndex,
-            tlv: null,
-        });
-    });
-    // to meta
-    const remainingAccountMetas = _remainingAccounts.map((account) => ({
-        pubkey: account,
-        isWritable: true,
-        isSigner: false,
-    }));
-    return {
-        inputTokenDataWithContext: packedInputTokenData,
-        remainingAccountMetas,
-        packedOutputTokenData,
-    };
-}
-
-const POOL_SEED = Buffer.from('pool');
-const CPI_AUTHORITY_SEED = Buffer.from('cpi_authority');
-const SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE = 1461600;
-
-/**
- * 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 => {
-        if (!acc.parsed.owner.equals(owner)) {
-            throw new Error('Token accounts must be owned by the same owner');
-        }
-    });
-};
-/**
- * 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);
-    const inputLamports = stateless_js.sumUpLamports(inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
-    const changeAmount = inputAmount.sub(amount);
-    stateless_js.validateSufficientBalance(changeAmount);
-    if (changeAmount.eq(stateless_js.bn(0)) && inputLamports.eq(stateless_js.bn(0))) {
-        return [
-            {
-                owner: toAddress,
-                amount,
-                lamports: inputLamports,
-                tlv: null,
-            },
-        ];
-    }
-    /// validates token program
-    stateless_js.validateSameOwner(inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
-    validateSameTokenOwner(inputCompressedTokenAccounts);
-    const outputCompressedAccounts = [
-        {
-            owner: inputCompressedTokenAccounts[0].parsed.owner,
-            amount: changeAmount,
-            lamports: inputLamports,
-            tlv: null,
-        },
-        {
-            owner: toAddress,
-            amount,
-            lamports: stateless_js.bn(0),
-            tlv: null,
-        },
-    ];
-    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));
-    const inputAmount = sumUpTokenAmount(inputCompressedTokenAccounts);
-    const changeAmount = inputAmount.sub(amount);
-    stateless_js.validateSufficientBalance(changeAmount);
-    /// lamports gets decompressed
-    if (changeAmount.eq(stateless_js.bn(0)) && inputLamports.eq(stateless_js.bn(0))) {
-        return [];
-    }
-    stateless_js.validateSameOwner(inputCompressedTokenAccounts.map(acc => acc.compressedAccount));
-    validateSameTokenOwner(inputCompressedTokenAccounts);
-    const tokenTransferOutputs = [
-        {
-            owner: inputCompressedTokenAccounts[0].parsed.owner,
-            amount: changeAmount,
-            lamports: inputLamports,
-            tlv: null,
-        },
-    ];
-    return tokenTransferOutputs;
-}
-class CompressedTokenProgram {
-    /**
-     * @internal
-     */
-    constructor() { }
-    /**
-     * Set a custom programId via PublicKey or base58 encoded string.
-     * This method is not required for regular usage.
-     *
-     * Use this only if you know what you are doing.
-     */
-    static setProgramId(programId) {
-        this.programId =
-            typeof programId === 'string'
-                ? new web3_js.PublicKey(programId)
-                : programId;
-        // Reset program when programId changes
-        this._program = null;
-    }
-    /** @internal */
-    static get program() {
-        if (!this._program) {
-            this.initializeProgram();
-        }
-        return this._program;
-    }
-    /**
-     * @internal
-     * Initializes the program statically if not already initialized.
-     */
-    static initializeProgram() {
-        if (!this._program) {
-            /// 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);
-            anchor.setProvider(mockProvider);
-            this._program = new anchor.Program(IDL, this.programId, mockProvider);
-        }
-    }
-    /** @internal */
-    static deriveTokenPoolPda(mint) {
-        const seeds = [POOL_SEED, mint.toBuffer()];
-        const [address, _] = web3_js.PublicKey.findProgramAddressSync(seeds, this.programId);
-        return address;
-    }
-    /** @internal */
-    static get deriveCpiAuthorityPda() {
-        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, tokenProgramId, freezeAuthority, mintSize, } = params;
-        const tokenProgram = tokenProgramId !== null && tokenProgramId !== void 0 ? tokenProgramId : splToken.TOKEN_PROGRAM_ID;
-        /// Create and initialize SPL Mint account
-        const createMintAccountInstruction = web3_js.SystemProgram.createAccount({
-            fromPubkey: feePayer,
-            lamports: rentExemptBalance,
-            newAccountPubkey: mint,
-            programId: tokenProgram,
-            space: mintSize !== null && mintSize !== void 0 ? mintSize : splToken.MINT_SIZE,
-        });
-        const initializeMintInstruction = splToken.createInitializeMint2Instruction(mint, params.decimals, authority, freezeAuthority, tokenProgram);
-        const ix = await this.createTokenPool({
-            feePayer,
-            mint,
-            tokenProgramId: tokenProgram,
-        });
-        return [createMintAccountInstruction, initializeMintInstruction, ix];
-    }
-    /**
-     * Enable compression for an existing SPL mint, creating an omnibus account.
-     * For new mints, use `CompressedTokenProgram.createMint`.
-     */
-    static async createTokenPool(params) {
-        const { mint, feePayer, tokenProgramId } = params;
-        const tokenProgram = tokenProgramId !== null && tokenProgramId !== void 0 ? tokenProgramId : splToken.TOKEN_PROGRAM_ID;
-        const tokenPoolPda = this.deriveTokenPoolPda(mint);
-        const ix = await this.program.methods
-            .createTokenPool()
-            .accounts({
-            mint,
-            feePayer,
-            tokenPoolPda,
-            systemProgram: web3_js.SystemProgram.programId,
-            tokenProgram,
-            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, tokenProgramId, } = params;
-        const tokenProgram = tokenProgramId !== null && tokenProgramId !== void 0 ? tokenProgramId : splToken.TOKEN_PROGRAM_ID;
-        const tokenPoolPda = this.deriveTokenPoolPda(mint);
-        const amounts = stateless_js.toArray(amount).map(amount => stateless_js.bn(amount));
-        const toPubkeys = stateless_js.toArray(toPubkey);
-        if (amounts.length !== toPubkeys.length) {
-            throw new Error('Amount and toPubkey arrays must have the same length');
-        }
-        const instruction = await this.program.methods
-            .mintTo(toPubkeys, amounts, null)
-            .accounts({
-            feePayer,
-            authority,
-            cpiAuthorityPda: this.deriveCpiAuthorityPda,
-            mint,
-            tokenPoolPda,
-            tokenProgram,
-            lightSystemProgram: stateless_js.LightSystemProgram.programId,
-            registeredProgramPda: systemKeys.registeredProgramPda,
-            noopProgram: systemKeys.noopProgram,
-            accountCompressionAuthority: systemKeys.accountCompressionAuthority,
-            accountCompressionProgram: systemKeys.accountCompressionProgram,
-            merkleTree: merkleTree !== null && merkleTree !== void 0 ? merkleTree : stateless_js.defaultTestStateTreeAccounts().merkleTree,
-            selfProgram: this.programId,
-            solPoolPda: null,
-        })
-            .instruction();
-        return instruction;
-    }
-    /**
-     * Mint tokens from registered SPL mint account to a compressed account
-     */
-    static async approveAndMintTo(params) {
-        const { mint, feePayer, authorityTokenAccount, authority, merkleTree, toPubkey, tokenProgramId, } = params;
-        const amount = BigInt(params.amount.toString());
-        /// 1. Mint to existing ATA of mintAuthority.
-        const splMintToInstruction = splToken.createMintToInstruction(mint, authorityTokenAccount, authority, amount, [], tokenProgramId);
-        /// 2. Compress from mint authority ATA to recipient compressed account
-        const compressInstruction = await this.compress({
-            payer: feePayer,
-            owner: authority,
-            source: authorityTokenAccount,
-            toAddress: toPubkey,
-            mint,
-            amount: params.amount,
-            outputStateTree: merkleTree,
-            tokenProgramId,
-        });
-        return [splMintToInstruction, compressInstruction];
-    }
-    /**
-     * Construct transfer instruction for compressed tokens
-     */
-    static async transfer(params) {
-        const { payer, inputCompressedTokenAccounts, recentInputStateRootIndices, recentValidityProof, amount, outputStateTrees, toAddress, } = params;
-        const tokenTransferOutputs = createTransferOutputState(inputCompressedTokenAccounts, toAddress, amount);
-        const { inputTokenDataWithContext, packedOutputTokenData, remainingAccountMetas, } = packCompressedTokenAccounts({
-            inputCompressedTokenAccounts,
-            outputStateTrees,
-            rootIndices: recentInputStateRootIndices,
-            tokenTransferOutputs,
-        });
-        const { mint, currentOwner } = parseTokenData(inputCompressedTokenAccounts);
-        const data = {
-            proof: recentValidityProof,
-            mint,
-            delegatedTransfer: null, // TODO: implement
-            inputTokenDataWithContext,
-            outputCompressedAccounts: packedOutputTokenData,
-            compressOrDecompressAmount: null,
-            isCompress: false,
-            cpiContext: null,
-            lamportsChangeAccountMerkleTreeIndex: 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)
-            .accounts({
-            feePayer: payer,
-            authority: currentOwner,
-            cpiAuthorityPda: this.deriveCpiAuthorityPda,
-            lightSystemProgram: stateless_js.LightSystemProgram.programId,
-            registeredProgramPda: registeredProgramPda,
-            noopProgram: noopProgram,
-            accountCompressionAuthority: accountCompressionAuthority,
-            accountCompressionProgram: accountCompressionProgram,
-            selfProgram: this.programId,
-            tokenPoolPda: null,
-            compressOrDecompressTokenAccount: null,
-            tokenProgram: null,
-        })
-            .remainingAccounts(remainingAccountMetas)
-            .instruction();
-        return instruction;
-    }
-    /**
-     * Create lookup table instructions for the token program's default accounts.
-     */
-    static async createTokenProgramLookupTable(params) {
-        const { authority, mints, recentSlot, payer, remainingAccounts } = params;
-        const [createInstruction, lookupTableAddress] = web3_js.AddressLookupTableProgram.createLookupTable({
-            authority,
-            payer: authority,
-            recentSlot,
-        });
-        let optionalMintKeys = [];
-        if (mints) {
-            optionalMintKeys = [
-                ...mints,
-                ...mints.map(mint => this.deriveTokenPoolPda(mint)),
-            ];
-        }
-        const extendInstruction = web3_js.AddressLookupTableProgram.extendLookupTable({
-            payer,
-            authority,
-            lookupTable: lookupTableAddress,
-            addresses: [
-                this.deriveCpiAuthorityPda,
-                stateless_js.LightSystemProgram.programId,
-                stateless_js.defaultStaticAccountsStruct().registeredProgramPda,
-                stateless_js.defaultStaticAccountsStruct().noopProgram,
-                stateless_js.defaultStaticAccountsStruct().accountCompressionAuthority,
-                stateless_js.defaultStaticAccountsStruct().accountCompressionProgram,
-                stateless_js.defaultTestStateTreeAccounts().merkleTree,
-                stateless_js.defaultTestStateTreeAccounts().nullifierQueue,
-                stateless_js.defaultTestStateTreeAccounts().addressTree,
-                stateless_js.defaultTestStateTreeAccounts().addressQueue,
-                this.programId,
-                splToken.TOKEN_PROGRAM_ID,
-                splToken.TOKEN_2022_PROGRAM_ID,
-                authority,
-                ...optionalMintKeys,
-                ...(remainingAccounts !== null && remainingAccounts !== void 0 ? remainingAccounts : []),
-            ],
-        });
-        return {
-            instructions: [createInstruction, extendInstruction],
-            address: lookupTableAddress,
-        };
-    }
-    /**
-     * Create compress instruction
-     * @returns compressInstruction
-     */
-    static async compress(params) {
-        const { payer, owner, source, toAddress, mint, outputStateTree, tokenProgramId, } = params;
-        if (Array.isArray(params.amount) !== Array.isArray(params.toAddress)) {
-            throw new Error('Both amount and toAddress must be arrays or both must be single values');
-        }
-        let tokenTransferOutputs;
-        if (Array.isArray(params.amount) && Array.isArray(params.toAddress)) {
-            if (params.amount.length !== params.toAddress.length) {
-                throw new Error('Amount and toAddress arrays must have the same length');
-            }
-            tokenTransferOutputs = params.amount.map((amt, index) => {
-                const amount = stateless_js.bn(amt);
-                return {
-                    owner: params.toAddress[index],
-                    amount,
-                    lamports: stateless_js.bn(0),
-                    tlv: null,
-                };
-            });
-        }
-        else {
-            tokenTransferOutputs = [
-                {
-                    owner: toAddress,
-                    amount: stateless_js.bn(params.amount),
-                    lamports: stateless_js.bn(0),
-                    tlv: null,
-                },
-            ];
-        }
-        const { inputTokenDataWithContext, packedOutputTokenData, remainingAccountMetas, } = packCompressedTokenAccounts({
-            inputCompressedTokenAccounts: [],
-            outputStateTrees: outputStateTree,
-            rootIndices: [],
-            tokenTransferOutputs,
-        });
-        const data = {
-            proof: null,
-            mint,
-            delegatedTransfer: null, // TODO: implement
-            inputTokenDataWithContext,
-            outputCompressedAccounts: packedOutputTokenData,
-            compressOrDecompressAmount: Array.isArray(params.amount)
-                ? params.amount
-                    .map(amt => new anchor.BN(amt))
-                    .reduce((sum, amt) => sum.add(amt), new anchor.BN(0))
-                : new anchor.BN(params.amount),
-            isCompress: true,
-            cpiContext: null,
-            lamportsChangeAccountMerkleTreeIndex: null,
-        };
-        const encodedData = this.program.coder.types.encode('CompressedTokenInstructionDataTransfer', data);
-        const tokenProgram = tokenProgramId !== null && tokenProgramId !== void 0 ? tokenProgramId : splToken.TOKEN_PROGRAM_ID;
-        const instruction = await this.program.methods
-            .transfer(encodedData)
-            .accounts({
-            feePayer: payer,
-            authority: owner,
-            cpiAuthorityPda: this.deriveCpiAuthorityPda,
-            lightSystemProgram: stateless_js.LightSystemProgram.programId,
-            registeredProgramPda: stateless_js.defaultStaticAccountsStruct().registeredProgramPda,
-            noopProgram: stateless_js.defaultStaticAccountsStruct().noopProgram,
-            accountCompressionAuthority: stateless_js.defaultStaticAccountsStruct().accountCompressionAuthority,
-            accountCompressionProgram: stateless_js.defaultStaticAccountsStruct().accountCompressionProgram,
-            selfProgram: this.programId,
-            tokenPoolPda: this.deriveTokenPoolPda(mint),
-            compressOrDecompressTokenAccount: source, // token
-            tokenProgram,
-        })
-            .remainingAccounts(remainingAccountMetas)
-            .instruction();
-        return instruction;
-    }
-    /**
-     * Construct decompress instruction
-     */
-    static async decompress(params) {
-        const { payer, inputCompressedTokenAccounts, toAddress, outputStateTree, recentValidityProof, recentInputStateRootIndices, tokenProgramId, } = params;
-        const amount = stateless_js.bn(params.amount);
-        const tokenTransferOutputs = createDecompressOutputState(inputCompressedTokenAccounts, amount);
-        /// Pack
-        const { inputTokenDataWithContext, packedOutputTokenData, remainingAccountMetas, } = packCompressedTokenAccounts({
-            inputCompressedTokenAccounts,
-            outputStateTrees: outputStateTree,
-            rootIndices: recentInputStateRootIndices,
-            tokenTransferOutputs: tokenTransferOutputs,
-        });
-        const { mint, currentOwner } = parseTokenData(inputCompressedTokenAccounts);
-        const data = {
-            proof: recentValidityProof,
-            mint,
-            delegatedTransfer: null, // TODO: implement
-            inputTokenDataWithContext,
-            outputCompressedAccounts: packedOutputTokenData,
-            compressOrDecompressAmount: amount,
-            isCompress: false,
-            cpiContext: null,
-            lamportsChangeAccountMerkleTreeIndex: null,
-        };
-        const encodedData = this.program.coder.types.encode('CompressedTokenInstructionDataTransfer', data);
-        const { accountCompressionAuthority, noopProgram, registeredProgramPda, accountCompressionProgram, } = stateless_js.defaultStaticAccountsStruct();
-        const tokenProgram = tokenProgramId !== null && tokenProgramId !== void 0 ? tokenProgramId : splToken.TOKEN_PROGRAM_ID;
-        const instruction = await this.program.methods
-            .transfer(encodedData)
-            .accounts({
-            feePayer: payer,
-            authority: currentOwner,
-            cpiAuthorityPda: this.deriveCpiAuthorityPda,
-            lightSystemProgram: stateless_js.LightSystemProgram.programId,
-            registeredProgramPda: registeredProgramPda,
-            noopProgram: noopProgram,
-            accountCompressionAuthority: accountCompressionAuthority,
-            accountCompressionProgram: accountCompressionProgram,
-            selfProgram: this.programId,
-            tokenPoolPda: this.deriveTokenPoolPda(mint),
-            compressOrDecompressTokenAccount: toAddress,
-            tokenProgram,
-        })
-            .remainingAccounts(remainingAccountMetas)
-            .instruction();
-        return instruction;
-    }
-    static async mergeTokenAccounts(params) {
-        const { payer, owner, inputCompressedTokenAccounts, outputStateTree, recentValidityProof, recentInputStateRootIndices, } = params;
-        if (inputCompressedTokenAccounts.length > 3) {
-            throw new Error('Cannot merge more than 3 token accounts at once');
-        }
-        const ix = await this.transfer({
-            payer,
-            inputCompressedTokenAccounts,
-            toAddress: owner,
-            amount: inputCompressedTokenAccounts.reduce((sum, account) => sum.add(account.parsed.amount), new anchor.BN(0)),
-            outputStateTrees: outputStateTree,
-            recentInputStateRootIndices,
-            recentValidityProof,
-        });
-        return [ix];
-    }
-    static async compressSplTokenAccount(params) {
-        const { feePayer, authority, tokenAccount, mint, remainingAmount, outputStateTree, tokenProgramId, } = params;
-        const tokenProgram = tokenProgramId !== null && tokenProgramId !== void 0 ? tokenProgramId : splToken.TOKEN_PROGRAM_ID;
-        const remainingAccountMetas = [
-            {
-                pubkey: outputStateTree,
-                isSigner: false,
-                isWritable: true,
-            },
-        ];
-        const instruction = await this.program.methods
-            .compressSplTokenAccount(authority, remainingAmount !== null && remainingAmount !== void 0 ? remainingAmount : null, null)
-            .accounts({
-            feePayer,
-            authority,
-            cpiAuthorityPda: this.deriveCpiAuthorityPda,
-            lightSystemProgram: stateless_js.LightSystemProgram.programId,
-            registeredProgramPda: stateless_js.defaultStaticAccountsStruct().registeredProgramPda,
-            noopProgram: stateless_js.defaultStaticAccountsStruct().noopProgram,
-            accountCompressionAuthority: stateless_js.defaultStaticAccountsStruct().accountCompressionAuthority,
-            accountCompressionProgram: stateless_js.defaultStaticAccountsStruct().accountCompressionProgram,
-            selfProgram: this.programId,
-            tokenPoolPda: this.deriveTokenPoolPda(mint),
-            compressOrDecompressTokenAccount: tokenAccount,
-            tokenProgram,
-            systemProgram: web3_js.SystemProgram.programId,
-        })
-            .remainingAccounts(remainingAccountMetas)
-            .instruction();
-        return instruction;
-    }
-    static async get_mint_program_id(mint, connection) {
-        var _a;
-        return (_a = (await connection.getAccountInfo(mint))) === null || _a === void 0 ? void 0 : _a.owner;
-    }
-}
-/**
- * Public key that identifies the CompressedPda program
- */
-CompressedTokenProgram.programId = new web3_js.PublicKey('cTokenmWW8bLPjZEBAUgYy3zKxQZW6VKi7bqNFEVv3m');
-CompressedTokenProgram._program = null;
-
-/**
- * Mint compressed tokens to a solana address from an external mint authority
- *
- * @param rpc            Rpc to use
- * @param payer          Payer of the transaction fees
- * @param mint           Mint for the account
- * @param destination    Address of the account to mint to
- * @param authority      Minting authority
- * @param amount         Amount to mint
- * @param merkleTree     State tree account that the compressed tokens should be
- *                       part of. Defaults to the default state tree account.
- * @param confirmOptions Options for confirming the transaction
- *
- * @return Signature of the confirmed transaction
- */
-async function approveAndMintTo(rpc, payer, mint, destination, authority, amount, merkleTree, confirmOptions, tokenProgramId) {
-    tokenProgramId = tokenProgramId
-        ? tokenProgramId
-        : await CompressedTokenProgram.get_mint_program_id(mint, rpc);
-    const authorityTokenAccount = await splToken.getOrCreateAssociatedTokenAccount(rpc, payer, mint, authority.publicKey, undefined, undefined, confirmOptions, tokenProgramId);
-    const ixs = await CompressedTokenProgram.approveAndMintTo({
-        feePayer: payer.publicKey,
-        mint,
-        authority: authority.publicKey,
-        authorityTokenAccount: authorityTokenAccount.address,
-        amount,
-        toPubkey: destination,
-        merkleTree,
-        tokenProgramId,
-    });
-    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
- *
- * @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
- */
-async function compress(rpc, payer, mint, amount, owner, sourceTokenAccount, toAddress, merkleTree, confirmOptions, tokenProgramId) {
-    tokenProgramId = tokenProgramId
-        ? tokenProgramId
-        : await CompressedTokenProgram.get_mint_program_id(mint, rpc);
-    const compressIx = await CompressedTokenProgram.compress({
-        payer: payer.publicKey,
-        owner: owner.publicKey,
-        source: sourceTokenAccount,
-        toAddress,
-        amount,
-        mint,
-        outputStateTree: merkleTree,
-        tokenProgramId,
-    });
-    const blockhashCtx = await rpc.getLatestBlockhash();
-    const additionalSigners = stateless_js.dedupeSigner(payer, [owner]);
-    const signedTx = stateless_js.buildAndSignTx([
-        web3_js.ComputeBudgetProgram.setComputeUnitLimit({
-            units: 1000000,
-        }),
-        compressIx,
-    ], payer, blockhashCtx.blockhash, additionalSigners);
-    const txId = await stateless_js.sendAndConfirmTx(rpc, signedTx, confirmOptions, blockhashCtx);
-    return txId;
-}
-
-/**
- * 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
- */
-async function transfer(rpc, payer, mint, amount, owner, toAddress, 
-/// TODO: allow multiple
-merkleTree, confirmOptions) {
-    amount = stateless_js.bn(amount);
-    const compressedTokenAccounts = await rpc.getCompressedTokenAccountsByOwner(owner.publicKey, {
-        mint,
-    });
-    const [inputAccounts] = selectMinCompressedTokenAccountsForTransfer(compressedTokenAccounts.items, amount);
-    const proof = await rpc.getValidityProof(inputAccounts.map(account => stateless_js.bn(account.compressedAccount.hash)));
-    const ix = await CompressedTokenProgram.transfer({
-        payer: payer.publicKey,
-        inputCompressedTokenAccounts: inputAccounts,
-        toAddress,
-        amount,
-        recentInputStateRootIndices: proof.rootIndices,
-        recentValidityProof: proof.compressedProof,
-        outputStateTrees: merkleTree,
-    });
-    const { blockhash } = await rpc.getLatestBlockhash();
-    const additionalSigners = stateless_js.dedupeSigner(payer, [owner]);
-    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;
-}
-/**
- * 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
- */
-function selectMinCompressedTokenAccountsForTransfer(accounts, transferAmount) {
-    let accumulatedAmount = stateless_js.bn(0);
-    let accumulatedLamports = stateless_js.bn(0);
-    const selectedAccounts = [];
-    accounts.sort((a, b) => b.parsed.amount.cmp(a.parsed.amount));
-    for (const account of accounts) {
-        if (accumulatedAmount.gte(stateless_js.bn(transferAmount)))
-            break;
-        accumulatedAmount = accumulatedAmount.add(account.parsed.amount);
-        accumulatedLamports = accumulatedLamports.add(account.compressedAccount.lamports);
-        selectedAccounts.push(account);
-    }
-    if (accumulatedAmount.lt(stateless_js.bn(transferAmount))) {
-        throw new Error(`Not enough balance for transfer. Required: ${transferAmount.toString()}, available: ${accumulatedAmount.toString()}`);
-    }
-    return [
-        selectedAccounts,
-        accumulatedAmount,
-        accumulatedLamports.lt(stateless_js.bn(0)) ? accumulatedLamports : null,
-    ];
-}
-
-/**
- * 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
- */
-async function decompress(rpc, payer, mint, amount, owner, toAddress, 
-/// TODO: allow multiple
-merkleTree, confirmOptions, tokenProgramId) {
-    tokenProgramId = tokenProgramId
-        ? tokenProgramId
-        : await CompressedTokenProgram.get_mint_program_id(mint, rpc);
-    amount = stateless_js.bn(amount);
-    const compressedTokenAccounts = await rpc.getCompressedTokenAccountsByOwner(owner.publicKey, {
-        mint,
-    });
-    /// TODO: consider using a different selection algorithm
-    const [inputAccounts] = selectMinCompressedTokenAccountsForTransfer(compressedTokenAccounts.items, amount);
-    const proof = await rpc.getValidityProof(inputAccounts.map(account => stateless_js.bn(account.compressedAccount.hash)));
-    const ix = await CompressedTokenProgram.decompress({
-        payer: payer.publicKey,
-        inputCompressedTokenAccounts: inputAccounts,
-        toAddress, // TODO: add explicit check that it is a token account
-        amount,
-        outputStateTree: merkleTree,
-        recentInputStateRootIndices: proof.rootIndices,
-        recentValidityProof: proof.compressedProof,
-        tokenProgramId,
-    });
-    const { blockhash } = await rpc.getLatestBlockhash();
-    const additionalSigners = stateless_js.dedupeSigner(payer, [owner]);
-    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;
-}
-
-/**
- * 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
- * @param decimals        Location of the decimal place
- * @param keypair         Optional keypair, defaulting to a new random one
- * @param confirmOptions  Options for confirming the transaction
- * @param isToken22       Whether to create a Token 2022 mint. Defaults to false.
- *
- * @return Address of the new mint and the transaction signature
- */
-async function createMint(rpc, payer, mintAuthority, decimals, keypair = web3_js.Keypair.generate(), confirmOptions, isToken22 = false) {
-    const rentExemptBalance = await rpc.getMinimumBalanceForRentExemption(splToken.MINT_SIZE);
-    const tokenProgramId = isToken22 ? splToken.TOKEN_2022_PROGRAM_ID : splToken.TOKEN_PROGRAM_ID;
-    const ixs = await CompressedTokenProgram.createMint({
-        feePayer: payer.publicKey,
-        mint: keypair.publicKey,
-        decimals,
-        authority: mintAuthority,
-        freezeAuthority: null, // TODO: add feature
-        rentExemptBalance,
-        tokenProgramId,
-    });
-    const { blockhash } = await rpc.getLatestBlockhash();
-    const additionalSigners = stateless_js.dedupeSigner(payer, [keypair]);
-    const tx = stateless_js.buildAndSignTx(ixs, payer, blockhash, additionalSigners);
-    const txId = await stateless_js.sendAndConfirmTx(rpc, tx, confirmOptions);
-    return { mint: keypair.publicKey, transactionSignature: txId };
-}
-
-/**
- * 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. Can be an array of
- *                       addresses if the amount is an array of amounts.
- * @param authority      Minting authority
- * @param amount         Amount to mint. Can be an array of amounts if the
- *                       destination is an array of addresses.
- * @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 mintTo(rpc, payer, mint, destination, authority, amount, merkleTree, confirmOptions, tokenProgramId) {
-    tokenProgramId = tokenProgramId
-        ? tokenProgramId
-        : await CompressedTokenProgram.get_mint_program_id(mint, rpc);
-    const additionalSigners = stateless_js.dedupeSigner(payer, [authority]);
-    const ix = await CompressedTokenProgram.mintTo({
-        feePayer: payer.publicKey,
-        mint,
-        authority: authority.publicKey,
-        amount: amount,
-        toPubkey: destination,
-        merkleTree,
-        tokenProgramId,
-    });
-    const { blockhash } = await rpc.getLatestBlockhash();
-    const tx = stateless_js.buildAndSignTx([web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }), ix], payer, blockhash, additionalSigners);
-    const txId = await stateless_js.sendAndConfirmTx(rpc, tx, confirmOptions);
-    return txId;
-}
-
-/**
- * Merge multiple compressed token accounts for a given mint into a single
- * account
- *
- * @param rpc             RPC to use
- * @param payer           Payer of the transaction fees
- * @param mint            Public key of the token's mint
- * @param owner           Owner of the token accounts to be merged
- * @param merkleTree      Optional merkle tree for compressed tokens
- * @param confirmOptions  Options for confirming the transaction
- *
- * @return Array of transaction signatures
- */
-async function mergeTokenAccounts(rpc, payer, mint, owner, merkleTree, confirmOptions) {
-    const compressedTokenAccounts = await rpc.getCompressedTokenAccountsByOwner(owner.publicKey, { mint });
-    if (compressedTokenAccounts.items.length === 0) {
-        throw new Error(`No compressed token accounts found for mint ${mint.toBase58()}`);
-    }
-    if (compressedTokenAccounts.items.length >= 6) {
-        throw new Error(`Too many compressed token accounts used for mint ${mint.toBase58()}`);
-    }
-    const instructions = [
-        web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 1000000 }),
-    ];
-    for (let i = 0; i < compressedTokenAccounts.items.slice(0, 6).length; i += 3) {
-        const batch = compressedTokenAccounts.items.slice(i, i + 3);
-        const proof = await rpc.getValidityProof(batch.map(account => stateless_js.bn(account.compressedAccount.hash)));
-        const batchInstructions = await CompressedTokenProgram.mergeTokenAccounts({
-            payer: payer.publicKey,
-            owner: owner.publicKey,
-            mint,
-            inputCompressedTokenAccounts: batch,
-            outputStateTree: merkleTree,
-            recentValidityProof: proof.compressedProof,
-            recentInputStateRootIndices: proof.rootIndices,
-        });
-        instructions.push(...batchInstructions);
-    }
-    const { blockhash } = await rpc.getLatestBlockhash();
-    const additionalSigners = stateless_js.dedupeSigner(payer, [owner]);
-    const signedTx = stateless_js.buildAndSignTx(instructions, payer, blockhash, additionalSigners);
-    const txId = await stateless_js.sendAndConfirmTx(rpc, signedTx, 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 createTokenPool(rpc, payer, mint, confirmOptions, tokenProgramId) {
-    tokenProgramId = tokenProgramId
-        ? tokenProgramId
-        : await CompressedTokenProgram.get_mint_program_id(mint, rpc);
-    const ix = await CompressedTokenProgram.createTokenPool({
-        feePayer: payer.publicKey,
-        mint,
-        tokenProgramId,
-    });
-    const { blockhash } = await rpc.getLatestBlockhash();
-    const tx = stateless_js.buildAndSignTx([ix], payer, blockhash);
-    const txId = await stateless_js.sendAndConfirmTx(rpc, tx, confirmOptions);
-    return txId;
-}
-
-/**
- * Create a lookup table for the token program's default accounts
- *
- * @param rpc                   Rpc connection to use
- * @param payer                 Payer of the transaction fees
- * @param authority             Authority of the lookup table
- * @param mints                 Optional array of mint public keys to include in
- *                              the lookup table
- * @param additionalAccounts    Optional array of additional account public keys
- *                              to include in the lookup table
- *
- * @return Transaction signatures and the address of the created lookup table
- */
-async function createTokenProgramLookupTable(rpc, payer, authority, mints, additionalAccounts) {
-    const recentSlot = await rpc.getSlot('finalized');
-    const { instructions, address } = await CompressedTokenProgram.createTokenProgramLookupTable({
-        payer: payer.publicKey,
-        authority: authority.publicKey,
-        mints,
-        remainingAccounts: additionalAccounts,
-        recentSlot,
-    });
-    const additionalSigners = stateless_js.dedupeSigner(payer, [authority]);
-    const blockhashCtx = await rpc.getLatestBlockhash();
-    const signedTx = stateless_js.buildAndSignTx([instructions[0]], payer, blockhashCtx.blockhash, additionalSigners);
-    /// Must wait for the first instruction to be finalized.
-    const txId = await stateless_js.sendAndConfirmTx(rpc, signedTx, { commitment: 'finalized' }, blockhashCtx);
-    const blockhashCtx2 = await rpc.getLatestBlockhash();
-    const signedTx2 = stateless_js.buildAndSignTx([instructions[1]], payer, blockhashCtx2.blockhash, additionalSigners);
-    const txId2 = await stateless_js.sendAndConfirmTx(rpc, signedTx2, { commitment: 'finalized' }, blockhashCtx2);
-    return { txIds: [txId, txId2], address };
-}
-
-/**
- * Compress SPL tokens into compressed token format
- *
- * @param rpc                   Rpc connection to use
- * @param payer                 Payer of the transaction fees
- * @param mint                  Mint of the token to compress
- * @param owner                 Owner of the token account
- * @param tokenAccount         Token account to compress
- * @param outputStateTree       State tree to insert the compressed token account into
- * @param remainingAmount      Optional: amount to leave in token account. Default: 0
- * @param confirmOptions       Options for confirming the transaction
- *
- * @return Signature of the confirmed transaction
- */
-async function compressSplTokenAccount(rpc, payer, mint, owner, tokenAccount, outputStateTree, remainingAmount, confirmOptions, tokenProgramId) {
-    tokenProgramId = tokenProgramId
-        ? tokenProgramId
-        : await CompressedTokenProgram.get_mint_program_id(mint, rpc);
-    const compressIx = await CompressedTokenProgram.compressSplTokenAccount({
-        feePayer: payer.publicKey,
-        authority: owner.publicKey,
-        tokenAccount,
-        mint,
-        remainingAmount,
-        outputStateTree,
-        tokenProgramId,
-    });
-    const blockhashCtx = await rpc.getLatestBlockhash();
-    const additionalSigners = stateless_js.dedupeSigner(payer, [owner]);
-    const signedTx = stateless_js.buildAndSignTx([
-        web3_js.ComputeBudgetProgram.setComputeUnitLimit({
-            units: 1000000,
-        }),
-        compressIx,
-    ], payer, blockhashCtx.blockhash, additionalSigners);
-    const txId = await stateless_js.sendAndConfirmTx(rpc, signedTx, confirmOptions, blockhashCtx);
-    return txId;
-}
-
-exports.CPI_AUTHORITY_SEED = CPI_AUTHORITY_SEED;
-exports.CompressedTokenProgram = CompressedTokenProgram;
-exports.IDL = IDL;
-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.compressSplTokenAccount = compressSplTokenAccount;
-exports.createDecompressOutputState = createDecompressOutputState;
-exports.createMint = createMint;
-exports.createTokenPool = createTokenPool;
-exports.createTokenProgramLookupTable = createTokenProgramLookupTable;
-exports.createTransferOutputState = createTransferOutputState;
-exports.decompress = decompress;
-exports.mergeTokenAccounts = mergeTokenAccounts;
-exports.mintTo = mintTo;
-exports.packCompressedTokenAccounts = packCompressedTokenAccounts;
-exports.parseTokenData = parseTokenData;
-exports.selectMinCompressedTokenAccountsForTransfer = selectMinCompressedTokenAccountsForTransfer;
-exports.sumUpTokenAmount = sumUpTokenAmount;
-exports.transfer = transfer;
-exports.validateSameTokenOwner = validateSameTokenOwner;
+"use strict";var t=require("@lightprotocol/stateless.js"),e=require("@solana/web3.js"),r=require("@solana/spl-token"),n=require("buffer");function i(e){const{inputCompressedTokenAccounts:r,outputStateTrees:n,remainingAccounts:i=[],rootIndices:o,tokenTransferOutputs:s}=e,a=i.slice();let u=null;r.length>0&&r[0].parsed.delegate&&(u=t.getIndexOrAdd(a,r[0].parsed.delegate));const h=[];r.forEach(((e,r)=>{const n=t.getIndexOrAdd(a,e.compressedAccount.merkleTree),i=t.getIndexOrAdd(a,e.compressedAccount.nullifierQueue);h.push({amount:e.parsed.amount,delegateIndex:u,merkleContext:{merkleTreePubkeyIndex:n,nullifierQueuePubkeyIndex:i,leafIndex:e.compressedAccount.leafIndex,queueIndex:null},rootIndex:o[r],lamports:e.compressedAccount.lamports.eq(t.bn(0))?null:e.compressedAccount.lamports,tlv:null})}));const l=t.padOutputStateMerkleTrees(n,s.length,r.map((t=>t.compressedAccount))),d=[];l.forEach(((e,r)=>{var n;const i=t.getIndexOrAdd(a,e);d.push({owner:s[r].owner,amount:s[r].amount,lamports:(null===(n=s[r].lamports)||void 0===n?void 0:n.eq(t.bn(0)))?null:s[r].lamports,merkleTreeIndex:i,tlv:null})}));const c=a.map((t=>({pubkey:t,isWritable:1,isSigner:0})));return{inputTokenDataWithContext:h,remainingAccountMetas:c,packedOutputTokenData:d}}const o=Buffer.from("pool"),s=Buffer.from("cpi_authority");var a="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{};function u(t){return t&&t.__esModule&&Object.prototype.hasOwnProperty.call(t,"default")?t.default:t}function h(t){if(t.__esModule)return t;var e=t.default;if("function"==typeof e){var r=function t(){return this instanceof t?Reflect.construct(e,arguments,this.constructor):e.apply(this,arguments)};r.prototype=e.prototype}else r={};return Object.defineProperty(r,"__esModule",{value:1}),Object.keys(t).forEach((function(e){var n=Object.getOwnPropertyDescriptor(t,e);Object.defineProperty(r,e,n.get?n:{enumerable:1,get:function(){return t[e]}})})),r}var l={exports:{}},d=h(Object.freeze({__proto__:null,default:{}}));!function(t,e){function r(t,e){if(!t)throw new Error(e||"Assertion failed")}function n(t,e){t.super_=e;var r=function(){};r.prototype=e.prototype,t.prototype=new r,t.prototype.constructor=t}function i(t,e,r){if(i.isBN(t))return t;this.negative=0,this.words=null,this.length=0,this.red=null,null!==t&&("le"!==e&&"be"!==e||(r=e,e=10),this._init(t||0,e||10,r||"be"))}var o;"object"==typeof l?l.exports=i:e.BN=i,i.BN=i,i.wordSize=26;try{o="undefined"!=typeof window&&void 0!==window.Buffer?window.Buffer:d.Buffer}catch(t){}function s(t,e){var n=t.charCodeAt(e);return n>=48&&n<=57?n-48:n>=65&&n<=70?n-55:n>=97&&n<=102?n-87:void r(0,"Invalid character in "+t)}function a(t,e,r){var n=s(t,r);return r-1>=e&&(n|=s(t,r-1)<<4),n}function u(t,e,n,i){for(var o=0,s=0,a=Math.min(t.length,n),u=e;u<a;u++){var h=t.charCodeAt(u)-48;o*=i,s=h>=49?h-49+10:h>=17?h-17+10:h,r(h>=0&&s<i,"Invalid character"),o+=s}return o}function h(t,e){t.words=e.words,t.length=e.length,t.negative=e.negative,t.red=e.red}if(i.isBN=function(t){return t instanceof i?1:null!==t&&"object"==typeof t&&t.constructor.wordSize===i.wordSize&&Array.isArray(t.words)},i.max=function(t,e){return t.cmp(e)>0?t:e},i.min=function(t,e){return t.cmp(e)<0?t:e},i.prototype._init=function(t,e,n){if("number"==typeof t)return this._initNumber(t,e,n);if("object"==typeof t)return this._initArray(t,e,n);"hex"===e&&(e=16),r(e===(0|e)&&e>=2&&e<=36);var i=0;"-"===(t=t.toString().replace(/\s+/g,""))[0]&&(i++,this.negative=1),i<t.length&&(16===e?this._parseHex(t,i,n):(this._parseBase(t,e,i),"le"===n&&this._initArray(this.toArray(),e,n)))},i.prototype._initNumber=function(t,e,n){t<0&&(this.negative=1,t=-t),t<67108864?(this.words=[67108863&t],this.length=1):t<4503599627370496?(this.words=[67108863&t,t/67108864&67108863],this.length=2):(r(t<9007199254740992),this.words=[67108863&t,t/67108864&67108863,1],this.length=3),"le"===n&&this._initArray(this.toArray(),e,n)},i.prototype._initArray=function(t,e,n){if(r("number"==typeof t.length),t.length<=0)return this.words=[0],this.length=1,this;this.length=Math.ceil(t.length/3),this.words=new Array(this.length);for(var i=0;i<this.length;i++)this.words[i]=0;var o,s,a=0;if("be"===n)for(i=t.length-1,o=0;i>=0;i-=3)s=t[i]|t[i-1]<<8|t[i-2]<<16,this.words[o]|=s<<a&67108863,this.words[o+1]=s>>>26-a&67108863,(a+=24)>=26&&(a-=26,o++);else if("le"===n)for(i=0,o=0;i<t.length;i+=3)s=t[i]|t[i+1]<<8|t[i+2]<<16,this.words[o]|=s<<a&67108863,this.words[o+1]=s>>>26-a&67108863,(a+=24)>=26&&(a-=26,o++);return this._strip()},i.prototype._parseHex=function(t,e,r){this.length=Math.ceil((t.length-e)/6),this.words=new Array(this.length);for(var n=0;n<this.length;n++)this.words[n]=0;var i,o=0,s=0;if("be"===r)for(n=t.length-1;n>=e;n-=2)i=a(t,e,n)<<o,this.words[s]|=67108863&i,o>=18?(o-=18,s+=1,this.words[s]|=i>>>26):o+=8;else for(n=(t.length-e)%2==0?e+1:e;n<t.length;n+=2)i=a(t,e,n)<<o,this.words[s]|=67108863&i,o>=18?(o-=18,s+=1,this.words[s]|=i>>>26):o+=8;this._strip()},i.prototype._parseBase=function(t,e,r){this.words=[0],this.length=1;for(var n=0,i=1;i<=67108863;i*=e)n++;n--,i=i/e|0;for(var o=t.length-r,s=o%n,a=Math.min(o,o-s)+r,h=0,l=r;l<a;l+=n)h=u(t,l,l+n,e),this.imuln(i),this.words[0]+h<67108864?this.words[0]+=h:this._iaddn(h);if(0!==s){var d=1;for(h=u(t,l,t.length,e),l=0;l<s;l++)d*=e;this.imuln(d),this.words[0]+h<67108864?this.words[0]+=h:this._iaddn(h)}this._strip()},i.prototype.copy=function(t){t.words=new Array(this.length);for(var e=0;e<this.length;e++)t.words[e]=this.words[e];t.length=this.length,t.negative=this.negative,t.red=this.red},i.prototype._move=function(t){h(t,this)},i.prototype.clone=function(){var t=new i(null);return this.copy(t),t},i.prototype._expand=function(t){for(;this.length<t;)this.words[this.length++]=0;return this},i.prototype._strip=function(){for(;this.length>1&&0===this.words[this.length-1];)this.length--;return this._normSign()},i.prototype._normSign=function(){return 1===this.length&&0===this.words[0]&&(this.negative=0),this},"undefined"!=typeof Symbol&&"function"==typeof Symbol.for)try{i.prototype[Symbol.for("nodejs.util.inspect.custom")]=c}catch(t){i.prototype.inspect=c}else i.prototype.inspect=c;function c(){return(this.red?"<BN-R: ":"<BN: ")+this.toString(16)+">"}var m=["","0","00","000","0000","00000","000000","0000000","00000000","000000000","0000000000","00000000000","000000000000","0000000000000","00000000000000","000000000000000","0000000000000000","00000000000000000","000000000000000000","0000000000000000000","00000000000000000000","000000000000000000000","0000000000000000000000","00000000000000000000000","000000000000000000000000","0000000000000000000000000"],p=[0,0,25,16,12,11,10,9,8,8,7,7,7,7,6,6,6,6,6,6,6,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],f=[0,0,33554432,43046721,16777216,48828125,60466176,40353607,16777216,43046721,1e7,19487171,35831808,62748517,7529536,11390625,16777216,24137569,34012224,47045881,64e6,4084101,5153632,6436343,7962624,9765625,11881376,14348907,17210368,20511149,243e5,28629151,33554432,39135393,45435424,52521875,60466176];function g(t,e,r){r.negative=e.negative^t.negative;var n=t.length+e.length|0;r.length=n,n=n-1|0;var i=0|t.words[0],o=0|e.words[0],s=i*o,a=67108863&s,u=s/67108864|0;r.words[0]=a;for(var h=1;h<n;h++){for(var l=u>>>26,d=67108863&u,c=Math.min(h,e.length-1),m=Math.max(0,h-t.length+1);m<=c;m++){var p=h-m|0;l+=(s=(i=0|t.words[p])*(o=0|e.words[m])+d)/67108864|0,d=67108863&s}r.words[h]=0|d,u=0|l}return 0!==u?r.words[h]=0|u:r.length--,r._strip()}i.prototype.toString=function(t,e){var n;if(e=0|e||1,16===(t=t||10)||"hex"===t){n="";for(var i=0,o=0,s=0;s<this.length;s++){var a=this.words[s],u=(16777215&(a<<i|o)).toString(16);o=a>>>24-i&16777215,(i+=2)>=26&&(i-=26,s--),n=0!==o||s!==this.length-1?m[6-u.length]+u+n:u+n}for(0!==o&&(n=o.toString(16)+n);n.length%e!=0;)n="0"+n;return 0!==this.negative&&(n="-"+n),n}if(t===(0|t)&&t>=2&&t<=36){var h=p[t],l=f[t];n="";var d=this.clone();for(d.negative=0;!d.isZero();){var c=d.modrn(l).toString(t);n=(d=d.idivn(l)).isZero()?c+n:m[h-c.length]+c+n}for(this.isZero()&&(n="0"+n);n.length%e!=0;)n="0"+n;return 0!==this.negative&&(n="-"+n),n}r(0,"Base should be between 2 and 36")},i.prototype.toNumber=function(){var t=this.words[0];return 2===this.length?t+=67108864*this.words[1]:3===this.length&&1===this.words[2]?t+=4503599627370496+67108864*this.words[1]:this.length>2&&r(0,"Number can only safely store up to 53 bits"),0!==this.negative?-t:t},i.prototype.toJSON=function(){return this.toString(16,2)},o&&(i.prototype.toBuffer=function(t,e){return this.toArrayLike(o,t,e)}),i.prototype.toArray=function(t,e){return this.toArrayLike(Array,t,e)},i.prototype.toArrayLike=function(t,e,n){this._strip();var i=this.byteLength(),o=n||Math.max(1,i);r(i<=o,"byte array longer than desired length"),r(o>0,"Requested array length <= 0");var s=function(t,e){return t.allocUnsafe?t.allocUnsafe(e):new t(e)}(t,o);return this["_toArrayLike"+("le"===e?"LE":"BE")](s,i),s},i.prototype._toArrayLikeLE=function(t){for(var e=0,r=0,n=0,i=0;n<this.length;n++){var o=this.words[n]<<i|r;t[e++]=255&o,e<t.length&&(t[e++]=o>>8&255),e<t.length&&(t[e++]=o>>16&255),6===i?(e<t.length&&(t[e++]=o>>24&255),r=0,i=0):(r=o>>>24,i+=2)}if(e<t.length)for(t[e++]=r;e<t.length;)t[e++]=0},i.prototype._toArrayLikeBE=function(t){for(var e=t.length-1,r=0,n=0,i=0;n<this.length;n++){var o=this.words[n]<<i|r;t[e--]=255&o,e>=0&&(t[e--]=o>>8&255),e>=0&&(t[e--]=o>>16&255),6===i?(e>=0&&(t[e--]=o>>24&255),r=0,i=0):(r=o>>>24,i+=2)}if(e>=0)for(t[e--]=r;e>=0;)t[e--]=0},Math.clz32?i.prototype._countBits=function(t){return 32-Math.clz32(t)}:i.prototype._countBits=function(t){var e=t,r=0;return e>=4096&&(r+=13,e>>>=13),e>=64&&(r+=7,e>>>=7),e>=8&&(r+=4,e>>>=4),e>=2&&(r+=2,e>>>=2),r+e},i.prototype._zeroBits=function(t){if(0===t)return 26;var e=t,r=0;return 0==(8191&e)&&(r+=13,e>>>=13),0==(127&e)&&(r+=7,e>>>=7),0==(15&e)&&(r+=4,e>>>=4),0==(3&e)&&(r+=2,e>>>=2),0==(1&e)&&r++,r},i.prototype.bitLength=function(){var t=this.words[this.length-1],e=this._countBits(t);return 26*(this.length-1)+e},i.prototype.zeroBits=function(){if(this.isZero())return 0;for(var t=0,e=0;e<this.length;e++){var r=this._zeroBits(this.words[e]);if(t+=r,26!==r)break}return t},i.prototype.byteLength=function(){return Math.ceil(this.bitLength()/8)},i.prototype.toTwos=function(t){return 0!==this.negative?this.abs().inotn(t).iaddn(1):this.clone()},i.prototype.fromTwos=function(t){return this.testn(t-1)?this.notn(t).iaddn(1).ineg():this.clone()},i.prototype.isNeg=function(){return 0!==this.negative},i.prototype.neg=function(){return this.clone().ineg()},i.prototype.ineg=function(){return this.isZero()||(this.negative^=1),this},i.prototype.iuor=function(t){for(;this.length<t.length;)this.words[this.length++]=0;for(var e=0;e<t.length;e++)this.words[e]=this.words[e]|t.words[e];return this._strip()},i.prototype.ior=function(t){return r(0==(this.negative|t.negative)),this.iuor(t)},i.prototype.or=function(t){return this.length>t.length?this.clone().ior(t):t.clone().ior(this)},i.prototype.uor=function(t){return this.length>t.length?this.clone().iuor(t):t.clone().iuor(this)},i.prototype.iuand=function(t){var e;e=this.length>t.length?t:this;for(var r=0;r<e.length;r++)this.words[r]=this.words[r]&t.words[r];return this.length=e.length,this._strip()},i.prototype.iand=function(t){return r(0==(this.negative|t.negative)),this.iuand(t)},i.prototype.and=function(t){return this.length>t.length?this.clone().iand(t):t.clone().iand(this)},i.prototype.uand=function(t){return this.length>t.length?this.clone().iuand(t):t.clone().iuand(this)},i.prototype.iuxor=function(t){var e,r;this.length>t.length?(e=this,r=t):(e=t,r=this);for(var n=0;n<r.length;n++)this.words[n]=e.words[n]^r.words[n];if(this!==e)for(;n<e.length;n++)this.words[n]=e.words[n];return this.length=e.length,this._strip()},i.prototype.ixor=function(t){return r(0==(this.negative|t.negative)),this.iuxor(t)},i.prototype.xor=function(t){return this.length>t.length?this.clone().ixor(t):t.clone().ixor(this)},i.prototype.uxor=function(t){return this.length>t.length?this.clone().iuxor(t):t.clone().iuxor(this)},i.prototype.inotn=function(t){r("number"==typeof t&&t>=0);var e=0|Math.ceil(t/26),n=t%26;this._expand(e),n>0&&e--;for(var i=0;i<e;i++)this.words[i]=67108863&~this.words[i];return n>0&&(this.words[i]=~this.words[i]&67108863>>26-n),this._strip()},i.prototype.notn=function(t){return this.clone().inotn(t)},i.prototype.setn=function(t,e){r("number"==typeof t&&t>=0);var n=t/26|0,i=t%26;return this._expand(n+1),this.words[n]=e?this.words[n]|1<<i:this.words[n]&~(1<<i),this._strip()},i.prototype.iadd=function(t){var e,r,n;if(0!==this.negative&&0===t.negative)return this.negative=0,e=this.isub(t),this.negative^=1,this._normSign();if(0===this.negative&&0!==t.negative)return t.negative=0,e=this.isub(t),t.negative=1,e._normSign();this.length>t.length?(r=this,n=t):(r=t,n=this);for(var i=0,o=0;o<n.length;o++)e=(0|r.words[o])+(0|n.words[o])+i,this.words[o]=67108863&e,i=e>>>26;for(;0!==i&&o<r.length;o++)e=(0|r.words[o])+i,this.words[o]=67108863&e,i=e>>>26;if(this.length=r.length,0!==i)this.words[this.length]=i,this.length++;else if(r!==this)for(;o<r.length;o++)this.words[o]=r.words[o];return this},i.prototype.add=function(t){var e;return 0!==t.negative&&0===this.negative?(t.negative=0,e=this.sub(t),t.negative^=1,e):0===t.negative&&0!==this.negative?(this.negative=0,e=t.sub(this),this.negative=1,e):this.length>t.length?this.clone().iadd(t):t.clone().iadd(this)},i.prototype.isub=function(t){if(0!==t.negative){t.negative=0;var e=this.iadd(t);return t.negative=1,e._normSign()}if(0!==this.negative)return this.negative=0,this.iadd(t),this.negative=1,this._normSign();var r,n,i=this.cmp(t);if(0===i)return this.negative=0,this.length=1,this.words[0]=0,this;i>0?(r=this,n=t):(r=t,n=this);for(var o=0,s=0;s<n.length;s++)o=(e=(0|r.words[s])-(0|n.words[s])+o)>>26,this.words[s]=67108863&e;for(;0!==o&&s<r.length;s++)o=(e=(0|r.words[s])+o)>>26,this.words[s]=67108863&e;if(0===o&&s<r.length&&r!==this)for(;s<r.length;s++)this.words[s]=r.words[s];return this.length=Math.max(this.length,s),r!==this&&(this.negative=1),this._strip()},i.prototype.sub=function(t){return this.clone().isub(t)};var y=function(t,e,r){var n,i,o,s=t.words,a=e.words,u=r.words,h=0,l=0|s[0],d=8191&l,c=l>>>13,m=0|s[1],p=8191&m,f=m>>>13,g=0|s[2],y=8191&g,w=g>>>13,v=0|s[3],M=8191&v,b=v>>>13,k=0|s[4],P=8191&k,S=k>>>13,A=0|s[5],T=8191&A,x=A>>>13,_=0|s[6],I=8191&_,E=_>>>13,C=0|s[7],L=8191&C,B=C>>>13,O=0|s[8],R=8191&O,D=O>>>13,K=0|s[9],U=8191&K,W=K>>>13,q=0|a[0],N=8191&q,j=q>>>13,V=0|a[1],Z=8191&V,z=V>>>13,F=0|a[2],G=8191&F,Q=F>>>13,$=0|a[3],H=8191&$,Y=$>>>13,J=0|a[4],X=8191&J,tt=J>>>13,et=0|a[5],rt=8191&et,nt=et>>>13,it=0|a[6],ot=8191&it,st=it>>>13,at=0|a[7],ut=8191&at,ht=at>>>13,lt=0|a[8],dt=8191&lt,ct=lt>>>13,mt=0|a[9],pt=8191&mt,ft=mt>>>13;r.negative=t.negative^e.negative,r.length=19;var gt=(h+(n=Math.imul(d,N))|0)+((8191&(i=(i=Math.imul(d,j))+Math.imul(c,N)|0))<<13)|0;h=((o=Math.imul(c,j))+(i>>>13)|0)+(gt>>>26)|0,gt&=67108863,n=Math.imul(p,N),i=(i=Math.imul(p,j))+Math.imul(f,N)|0,o=Math.imul(f,j);var yt=(h+(n=n+Math.imul(d,Z)|0)|0)+((8191&(i=(i=i+Math.imul(d,z)|0)+Math.imul(c,Z)|0))<<13)|0;h=((o=o+Math.imul(c,z)|0)+(i>>>13)|0)+(yt>>>26)|0,yt&=67108863,n=Math.imul(y,N),i=(i=Math.imul(y,j))+Math.imul(w,N)|0,o=Math.imul(w,j),n=n+Math.imul(p,Z)|0,i=(i=i+Math.imul(p,z)|0)+Math.imul(f,Z)|0,o=o+Math.imul(f,z)|0;var wt=(h+(n=n+Math.imul(d,G)|0)|0)+((8191&(i=(i=i+Math.imul(d,Q)|0)+Math.imul(c,G)|0))<<13)|0;h=((o=o+Math.imul(c,Q)|0)+(i>>>13)|0)+(wt>>>26)|0,wt&=67108863,n=Math.imul(M,N),i=(i=Math.imul(M,j))+Math.imul(b,N)|0,o=Math.imul(b,j),n=n+Math.imul(y,Z)|0,i=(i=i+Math.imul(y,z)|0)+Math.imul(w,Z)|0,o=o+Math.imul(w,z)|0,n=n+Math.imul(p,G)|0,i=(i=i+Math.imul(p,Q)|0)+Math.imul(f,G)|0,o=o+Math.imul(f,Q)|0;var vt=(h+(n=n+Math.imul(d,H)|0)|0)+((8191&(i=(i=i+Math.imul(d,Y)|0)+Math.imul(c,H)|0))<<13)|0;h=((o=o+Math.imul(c,Y)|0)+(i>>>13)|0)+(vt>>>26)|0,vt&=67108863,n=Math.imul(P,N),i=(i=Math.imul(P,j))+Math.imul(S,N)|0,o=Math.imul(S,j),n=n+Math.imul(M,Z)|0,i=(i=i+Math.imul(M,z)|0)+Math.imul(b,Z)|0,o=o+Math.imul(b,z)|0,n=n+Math.imul(y,G)|0,i=(i=i+Math.imul(y,Q)|0)+Math.imul(w,G)|0,o=o+Math.imul(w,Q)|0,n=n+Math.imul(p,H)|0,i=(i=i+Math.imul(p,Y)|0)+Math.imul(f,H)|0,o=o+Math.imul(f,Y)|0;var Mt=(h+(n=n+Math.imul(d,X)|0)|0)+((8191&(i=(i=i+Math.imul(d,tt)|0)+Math.imul(c,X)|0))<<13)|0;h=((o=o+Math.imul(c,tt)|0)+(i>>>13)|0)+(Mt>>>26)|0,Mt&=67108863,n=Math.imul(T,N),i=(i=Math.imul(T,j))+Math.imul(x,N)|0,o=Math.imul(x,j),n=n+Math.imul(P,Z)|0,i=(i=i+Math.imul(P,z)|0)+Math.imul(S,Z)|0,o=o+Math.imul(S,z)|0,n=n+Math.imul(M,G)|0,i=(i=i+Math.imul(M,Q)|0)+Math.imul(b,G)|0,o=o+Math.imul(b,Q)|0,n=n+Math.imul(y,H)|0,i=(i=i+Math.imul(y,Y)|0)+Math.imul(w,H)|0,o=o+Math.imul(w,Y)|0,n=n+Math.imul(p,X)|0,i=(i=i+Math.imul(p,tt)|0)+Math.imul(f,X)|0,o=o+Math.imul(f,tt)|0;var bt=(h+(n=n+Math.imul(d,rt)|0)|0)+((8191&(i=(i=i+Math.imul(d,nt)|0)+Math.imul(c,rt)|0))<<13)|0;h=((o=o+Math.imul(c,nt)|0)+(i>>>13)|0)+(bt>>>26)|0,bt&=67108863,n=Math.imul(I,N),i=(i=Math.imul(I,j))+Math.imul(E,N)|0,o=Math.imul(E,j),n=n+Math.imul(T,Z)|0,i=(i=i+Math.imul(T,z)|0)+Math.imul(x,Z)|0,o=o+Math.imul(x,z)|0,n=n+Math.imul(P,G)|0,i=(i=i+Math.imul(P,Q)|0)+Math.imul(S,G)|0,o=o+Math.imul(S,Q)|0,n=n+Math.imul(M,H)|0,i=(i=i+Math.imul(M,Y)|0)+Math.imul(b,H)|0,o=o+Math.imul(b,Y)|0,n=n+Math.imul(y,X)|0,i=(i=i+Math.imul(y,tt)|0)+Math.imul(w,X)|0,o=o+Math.imul(w,tt)|0,n=n+Math.imul(p,rt)|0,i=(i=i+Math.imul(p,nt)|0)+Math.imul(f,rt)|0,o=o+Math.imul(f,nt)|0;var kt=(h+(n=n+Math.imul(d,ot)|0)|0)+((8191&(i=(i=i+Math.imul(d,st)|0)+Math.imul(c,ot)|0))<<13)|0;h=((o=o+Math.imul(c,st)|0)+(i>>>13)|0)+(kt>>>26)|0,kt&=67108863,n=Math.imul(L,N),i=(i=Math.imul(L,j))+Math.imul(B,N)|0,o=Math.imul(B,j),n=n+Math.imul(I,Z)|0,i=(i=i+Math.imul(I,z)|0)+Math.imul(E,Z)|0,o=o+Math.imul(E,z)|0,n=n+Math.imul(T,G)|0,i=(i=i+Math.imul(T,Q)|0)+Math.imul(x,G)|0,o=o+Math.imul(x,Q)|0,n=n+Math.imul(P,H)|0,i=(i=i+Math.imul(P,Y)|0)+Math.imul(S,H)|0,o=o+Math.imul(S,Y)|0,n=n+Math.imul(M,X)|0,i=(i=i+Math.imul(M,tt)|0)+Math.imul(b,X)|0,o=o+Math.imul(b,tt)|0,n=n+Math.imul(y,rt)|0,i=(i=i+Math.imul(y,nt)|0)+Math.imul(w,rt)|0,o=o+Math.imul(w,nt)|0,n=n+Math.imul(p,ot)|0,i=(i=i+Math.imul(p,st)|0)+Math.imul(f,ot)|0,o=o+Math.imul(f,st)|0;var Pt=(h+(n=n+Math.imul(d,ut)|0)|0)+((8191&(i=(i=i+Math.imul(d,ht)|0)+Math.imul(c,ut)|0))<<13)|0;h=((o=o+Math.imul(c,ht)|0)+(i>>>13)|0)+(Pt>>>26)|0,Pt&=67108863,n=Math.imul(R,N),i=(i=Math.imul(R,j))+Math.imul(D,N)|0,o=Math.imul(D,j),n=n+Math.imul(L,Z)|0,i=(i=i+Math.imul(L,z)|0)+Math.imul(B,Z)|0,o=o+Math.imul(B,z)|0,n=n+Math.imul(I,G)|0,i=(i=i+Math.imul(I,Q)|0)+Math.imul(E,G)|0,o=o+Math.imul(E,Q)|0,n=n+Math.imul(T,H)|0,i=(i=i+Math.imul(T,Y)|0)+Math.imul(x,H)|0,o=o+Math.imul(x,Y)|0,n=n+Math.imul(P,X)|0,i=(i=i+Math.imul(P,tt)|0)+Math.imul(S,X)|0,o=o+Math.imul(S,tt)|0,n=n+Math.imul(M,rt)|0,i=(i=i+Math.imul(M,nt)|0)+Math.imul(b,rt)|0,o=o+Math.imul(b,nt)|0,n=n+Math.imul(y,ot)|0,i=(i=i+Math.imul(y,st)|0)+Math.imul(w,ot)|0,o=o+Math.imul(w,st)|0,n=n+Math.imul(p,ut)|0,i=(i=i+Math.imul(p,ht)|0)+Math.imul(f,ut)|0,o=o+Math.imul(f,ht)|0;var St=(h+(n=n+Math.imul(d,dt)|0)|0)+((8191&(i=(i=i+Math.imul(d,ct)|0)+Math.imul(c,dt)|0))<<13)|0;h=((o=o+Math.imul(c,ct)|0)+(i>>>13)|0)+(St>>>26)|0,St&=67108863,n=Math.imul(U,N),i=(i=Math.imul(U,j))+Math.imul(W,N)|0,o=Math.imul(W,j),n=n+Math.imul(R,Z)|0,i=(i=i+Math.imul(R,z)|0)+Math.imul(D,Z)|0,o=o+Math.imul(D,z)|0,n=n+Math.imul(L,G)|0,i=(i=i+Math.imul(L,Q)|0)+Math.imul(B,G)|0,o=o+Math.imul(B,Q)|0,n=n+Math.imul(I,H)|0,i=(i=i+Math.imul(I,Y)|0)+Math.imul(E,H)|0,o=o+Math.imul(E,Y)|0,n=n+Math.imul(T,X)|0,i=(i=i+Math.imul(T,tt)|0)+Math.imul(x,X)|0,o=o+Math.imul(x,tt)|0,n=n+Math.imul(P,rt)|0,i=(i=i+Math.imul(P,nt)|0)+Math.imul(S,rt)|0,o=o+Math.imul(S,nt)|0,n=n+Math.imul(M,ot)|0,i=(i=i+Math.imul(M,st)|0)+Math.imul(b,ot)|0,o=o+Math.imul(b,st)|0,n=n+Math.imul(y,ut)|0,i=(i=i+Math.imul(y,ht)|0)+Math.imul(w,ut)|0,o=o+Math.imul(w,ht)|0,n=n+Math.imul(p,dt)|0,i=(i=i+Math.imul(p,ct)|0)+Math.imul(f,dt)|0,o=o+Math.imul(f,ct)|0;var At=(h+(n=n+Math.imul(d,pt)|0)|0)+((8191&(i=(i=i+Math.imul(d,ft)|0)+Math.imul(c,pt)|0))<<13)|0;h=((o=o+Math.imul(c,ft)|0)+(i>>>13)|0)+(At>>>26)|0,At&=67108863,n=Math.imul(U,Z),i=(i=Math.imul(U,z))+Math.imul(W,Z)|0,o=Math.imul(W,z),n=n+Math.imul(R,G)|0,i=(i=i+Math.imul(R,Q)|0)+Math.imul(D,G)|0,o=o+Math.imul(D,Q)|0,n=n+Math.imul(L,H)|0,i=(i=i+Math.imul(L,Y)|0)+Math.imul(B,H)|0,o=o+Math.imul(B,Y)|0,n=n+Math.imul(I,X)|0,i=(i=i+Math.imul(I,tt)|0)+Math.imul(E,X)|0,o=o+Math.imul(E,tt)|0,n=n+Math.imul(T,rt)|0,i=(i=i+Math.imul(T,nt)|0)+Math.imul(x,rt)|0,o=o+Math.imul(x,nt)|0,n=n+Math.imul(P,ot)|0,i=(i=i+Math.imul(P,st)|0)+Math.imul(S,ot)|0,o=o+Math.imul(S,st)|0,n=n+Math.imul(M,ut)|0,i=(i=i+Math.imul(M,ht)|0)+Math.imul(b,ut)|0,o=o+Math.imul(b,ht)|0,n=n+Math.imul(y,dt)|0,i=(i=i+Math.imul(y,ct)|0)+Math.imul(w,dt)|0,o=o+Math.imul(w,ct)|0;var Tt=(h+(n=n+Math.imul(p,pt)|0)|0)+((8191&(i=(i=i+Math.imul(p,ft)|0)+Math.imul(f,pt)|0))<<13)|0;h=((o=o+Math.imul(f,ft)|0)+(i>>>13)|0)+(Tt>>>26)|0,Tt&=67108863,n=Math.imul(U,G),i=(i=Math.imul(U,Q))+Math.imul(W,G)|0,o=Math.imul(W,Q),n=n+Math.imul(R,H)|0,i=(i=i+Math.imul(R,Y)|0)+Math.imul(D,H)|0,o=o+Math.imul(D,Y)|0,n=n+Math.imul(L,X)|0,i=(i=i+Math.imul(L,tt)|0)+Math.imul(B,X)|0,o=o+Math.imul(B,tt)|0,n=n+Math.imul(I,rt)|0,i=(i=i+Math.imul(I,nt)|0)+Math.imul(E,rt)|0,o=o+Math.imul(E,nt)|0,n=n+Math.imul(T,ot)|0,i=(i=i+Math.imul(T,st)|0)+Math.imul(x,ot)|0,o=o+Math.imul(x,st)|0,n=n+Math.imul(P,ut)|0,i=(i=i+Math.imul(P,ht)|0)+Math.imul(S,ut)|0,o=o+Math.imul(S,ht)|0,n=n+Math.imul(M,dt)|0,i=(i=i+Math.imul(M,ct)|0)+Math.imul(b,dt)|0,o=o+Math.imul(b,ct)|0;var xt=(h+(n=n+Math.imul(y,pt)|0)|0)+((8191&(i=(i=i+Math.imul(y,ft)|0)+Math.imul(w,pt)|0))<<13)|0;h=((o=o+Math.imul(w,ft)|0)+(i>>>13)|0)+(xt>>>26)|0,xt&=67108863,n=Math.imul(U,H),i=(i=Math.imul(U,Y))+Math.imul(W,H)|0,o=Math.imul(W,Y),n=n+Math.imul(R,X)|0,i=(i=i+Math.imul(R,tt)|0)+Math.imul(D,X)|0,o=o+Math.imul(D,tt)|0,n=n+Math.imul(L,rt)|0,i=(i=i+Math.imul(L,nt)|0)+Math.imul(B,rt)|0,o=o+Math.imul(B,nt)|0,n=n+Math.imul(I,ot)|0,i=(i=i+Math.imul(I,st)|0)+Math.imul(E,ot)|0,o=o+Math.imul(E,st)|0,n=n+Math.imul(T,ut)|0,i=(i=i+Math.imul(T,ht)|0)+Math.imul(x,ut)|0,o=o+Math.imul(x,ht)|0,n=n+Math.imul(P,dt)|0,i=(i=i+Math.imul(P,ct)|0)+Math.imul(S,dt)|0,o=o+Math.imul(S,ct)|0;var _t=(h+(n=n+Math.imul(M,pt)|0)|0)+((8191&(i=(i=i+Math.imul(M,ft)|0)+Math.imul(b,pt)|0))<<13)|0;h=((o=o+Math.imul(b,ft)|0)+(i>>>13)|0)+(_t>>>26)|0,_t&=67108863,n=Math.imul(U,X),i=(i=Math.imul(U,tt))+Math.imul(W,X)|0,o=Math.imul(W,tt),n=n+Math.imul(R,rt)|0,i=(i=i+Math.imul(R,nt)|0)+Math.imul(D,rt)|0,o=o+Math.imul(D,nt)|0,n=n+Math.imul(L,ot)|0,i=(i=i+Math.imul(L,st)|0)+Math.imul(B,ot)|0,o=o+Math.imul(B,st)|0,n=n+Math.imul(I,ut)|0,i=(i=i+Math.imul(I,ht)|0)+Math.imul(E,ut)|0,o=o+Math.imul(E,ht)|0,n=n+Math.imul(T,dt)|0,i=(i=i+Math.imul(T,ct)|0)+Math.imul(x,dt)|0,o=o+Math.imul(x,ct)|0;var It=(h+(n=n+Math.imul(P,pt)|0)|0)+((8191&(i=(i=i+Math.imul(P,ft)|0)+Math.imul(S,pt)|0))<<13)|0;h=((o=o+Math.imul(S,ft)|0)+(i>>>13)|0)+(It>>>26)|0,It&=67108863,n=Math.imul(U,rt),i=(i=Math.imul(U,nt))+Math.imul(W,rt)|0,o=Math.imul(W,nt),n=n+Math.imul(R,ot)|0,i=(i=i+Math.imul(R,st)|0)+Math.imul(D,ot)|0,o=o+Math.imul(D,st)|0,n=n+Math.imul(L,ut)|0,i=(i=i+Math.imul(L,ht)|0)+Math.imul(B,ut)|0,o=o+Math.imul(B,ht)|0,n=n+Math.imul(I,dt)|0,i=(i=i+Math.imul(I,ct)|0)+Math.imul(E,dt)|0,o=o+Math.imul(E,ct)|0;var Et=(h+(n=n+Math.imul(T,pt)|0)|0)+((8191&(i=(i=i+Math.imul(T,ft)|0)+Math.imul(x,pt)|0))<<13)|0;h=((o=o+Math.imul(x,ft)|0)+(i>>>13)|0)+(Et>>>26)|0,Et&=67108863,n=Math.imul(U,ot),i=(i=Math.imul(U,st))+Math.imul(W,ot)|0,o=Math.imul(W,st),n=n+Math.imul(R,ut)|0,i=(i=i+Math.imul(R,ht)|0)+Math.imul(D,ut)|0,o=o+Math.imul(D,ht)|0,n=n+Math.imul(L,dt)|0,i=(i=i+Math.imul(L,ct)|0)+Math.imul(B,dt)|0,o=o+Math.imul(B,ct)|0;var Ct=(h+(n=n+Math.imul(I,pt)|0)|0)+((8191&(i=(i=i+Math.imul(I,ft)|0)+Math.imul(E,pt)|0))<<13)|0;h=((o=o+Math.imul(E,ft)|0)+(i>>>13)|0)+(Ct>>>26)|0,Ct&=67108863,n=Math.imul(U,ut),i=(i=Math.imul(U,ht))+Math.imul(W,ut)|0,o=Math.imul(W,ht),n=n+Math.imul(R,dt)|0,i=(i=i+Math.imul(R,ct)|0)+Math.imul(D,dt)|0,o=o+Math.imul(D,ct)|0;var Lt=(h+(n=n+Math.imul(L,pt)|0)|0)+((8191&(i=(i=i+Math.imul(L,ft)|0)+Math.imul(B,pt)|0))<<13)|0;h=((o=o+Math.imul(B,ft)|0)+(i>>>13)|0)+(Lt>>>26)|0,Lt&=67108863,n=Math.imul(U,dt),i=(i=Math.imul(U,ct))+Math.imul(W,dt)|0,o=Math.imul(W,ct);var Bt=(h+(n=n+Math.imul(R,pt)|0)|0)+((8191&(i=(i=i+Math.imul(R,ft)|0)+Math.imul(D,pt)|0))<<13)|0;h=((o=o+Math.imul(D,ft)|0)+(i>>>13)|0)+(Bt>>>26)|0,Bt&=67108863;var Ot=(h+(n=Math.imul(U,pt))|0)+((8191&(i=(i=Math.imul(U,ft))+Math.imul(W,pt)|0))<<13)|0;return h=((o=Math.imul(W,ft))+(i>>>13)|0)+(Ot>>>26)|0,Ot&=67108863,u[0]=gt,u[1]=yt,u[2]=wt,u[3]=vt,u[4]=Mt,u[5]=bt,u[6]=kt,u[7]=Pt,u[8]=St,u[9]=At,u[10]=Tt,u[11]=xt,u[12]=_t,u[13]=It,u[14]=Et,u[15]=Ct,u[16]=Lt,u[17]=Bt,u[18]=Ot,0!==h&&(u[19]=h,r.length++),r};function w(t,e,r){r.negative=e.negative^t.negative,r.length=t.length+e.length;for(var n=0,i=0,o=0;o<r.length-1;o++){var s=i;i=0;for(var a=67108863&n,u=Math.min(o,e.length-1),h=Math.max(0,o-t.length+1);h<=u;h++){var l=o-h,d=(0|t.words[l])*(0|e.words[h]),c=67108863&d;a=67108863&(c=c+a|0),i+=(s=(s=s+(d/67108864|0)|0)+(c>>>26)|0)>>>26,s&=67108863}r.words[o]=a,n=s,s=i}return 0!==n?r.words[o]=n:r.length--,r._strip()}function v(t,e,r){return w(t,e,r)}Math.imul||(y=g),i.prototype.mulTo=function(t,e){var r=this.length+t.length;return 10===this.length&&10===t.length?y(this,t,e):r<63?g(this,t,e):r<1024?w(this,t,e):v(this,t,e)},i.prototype.mul=function(t){var e=new i(null);return e.words=new Array(this.length+t.length),this.mulTo(t,e)},i.prototype.mulf=function(t){var e=new i(null);return e.words=new Array(this.length+t.length),v(this,t,e)},i.prototype.imul=function(t){return this.clone().mulTo(t,this)},i.prototype.imuln=function(t){var e=t<0;e&&(t=-t),r("number"==typeof t),r(t<67108864);for(var n=0,i=0;i<this.length;i++){var o=(0|this.words[i])*t,s=(67108863&o)+(67108863&n);n>>=26,n+=o/67108864|0,n+=s>>>26,this.words[i]=67108863&s}return 0!==n&&(this.words[i]=n,this.length++),e?this.ineg():this},i.prototype.muln=function(t){return this.clone().imuln(t)},i.prototype.sqr=function(){return this.mul(this)},i.prototype.isqr=function(){return this.imul(this.clone())},i.prototype.pow=function(t){var e=function(t){for(var e=new Array(t.bitLength()),r=0;r<e.length;r++){var n=r/26|0,i=r%26;e[r]=t.words[n]>>>i&1}return e}(t);if(0===e.length)return new i(1);for(var r=this,n=0;n<e.length&&0===e[n];n++,r=r.sqr());if(++n<e.length)for(var o=r.sqr();n<e.length;n++,o=o.sqr())0!==e[n]&&(r=r.mul(o));return r},i.prototype.iushln=function(t){r("number"==typeof t&&t>=0);var e,n=t%26,i=(t-n)/26,o=67108863>>>26-n<<26-n;if(0!==n){var s=0;for(e=0;e<this.length;e++){var a=this.words[e]&o,u=(0|this.words[e])-a<<n;this.words[e]=u|s,s=a>>>26-n}s&&(this.words[e]=s,this.length++)}if(0!==i){for(e=this.length-1;e>=0;e--)this.words[e+i]=this.words[e];for(e=0;e<i;e++)this.words[e]=0;this.length+=i}return this._strip()},i.prototype.ishln=function(t){return r(0===this.negative),this.iushln(t)},i.prototype.iushrn=function(t,e,n){var i;r("number"==typeof t&&t>=0),i=e?(e-e%26)/26:0;var o=t%26,s=Math.min((t-o)/26,this.length),a=67108863^67108863>>>o<<o,u=n;if(i-=s,i=Math.max(0,i),u){for(var h=0;h<s;h++)u.words[h]=this.words[h];u.length=s}if(0===s);else if(this.length>s)for(this.length-=s,h=0;h<this.length;h++)this.words[h]=this.words[h+s];else this.words[0]=0,this.length=1;var l=0;for(h=this.length-1;h>=0&&(0!==l||h>=i);h--){var d=0|this.words[h];this.words[h]=l<<26-o|d>>>o,l=d&a}return u&&0!==l&&(u.words[u.length++]=l),0===this.length&&(this.words[0]=0,this.length=1),this._strip()},i.prototype.ishrn=function(t,e,n){return r(0===this.negative),this.iushrn(t,e,n)},i.prototype.shln=function(t){return this.clone().ishln(t)},i.prototype.ushln=function(t){return this.clone().iushln(t)},i.prototype.shrn=function(t){return this.clone().ishrn(t)},i.prototype.ushrn=function(t){return this.clone().iushrn(t)},i.prototype.testn=function(t){r("number"==typeof t&&t>=0);var e=t%26,n=(t-e)/26,i=1<<e;return this.length<=n?0:!!(this.words[n]&i)},i.prototype.imaskn=function(t){r("number"==typeof t&&t>=0);var e=t%26,n=(t-e)/26;if(r(0===this.negative,"imaskn works only with positive numbers"),this.length<=n)return this;if(0!==e&&n++,this.length=Math.min(n,this.length),0!==e){var i=67108863^67108863>>>e<<e;this.words[this.length-1]&=i}return this._strip()},i.prototype.maskn=function(t){return this.clone().imaskn(t)},i.prototype.iaddn=function(t){return r("number"==typeof t),r(t<67108864),t<0?this.isubn(-t):0!==this.negative?1===this.length&&(0|this.words[0])<=t?(this.words[0]=t-(0|this.words[0]),this.negative=0,this):(this.negative=0,this.isubn(t),this.negative=1,this):this._iaddn(t)},i.prototype._iaddn=function(t){this.words[0]+=t;for(var e=0;e<this.length&&this.words[e]>=67108864;e++)this.words[e]-=67108864,e===this.length-1?this.words[e+1]=1:this.words[e+1]++;return this.length=Math.max(this.length,e+1),this},i.prototype.isubn=function(t){if(r("number"==typeof t),r(t<67108864),t<0)return this.iaddn(-t);if(0!==this.negative)return this.negative=0,this.iaddn(t),this.negative=1,this;if(this.words[0]-=t,1===this.length&&this.words[0]<0)this.words[0]=-this.words[0],this.negative=1;else for(var e=0;e<this.length&&this.words[e]<0;e++)this.words[e]+=67108864,this.words[e+1]-=1;return this._strip()},i.prototype.addn=function(t){return this.clone().iaddn(t)},i.prototype.subn=function(t){return this.clone().isubn(t)},i.prototype.iabs=function(){return this.negative=0,this},i.prototype.abs=function(){return this.clone().iabs()},i.prototype._ishlnsubmul=function(t,e,n){var i,o,s=t.length+n;this._expand(s);var a=0;for(i=0;i<t.length;i++){o=(0|this.words[i+n])+a;var u=(0|t.words[i])*e;a=((o-=67108863&u)>>26)-(u/67108864|0),this.words[i+n]=67108863&o}for(;i<this.length-n;i++)a=(o=(0|this.words[i+n])+a)>>26,this.words[i+n]=67108863&o;if(0===a)return this._strip();for(r(-1===a),a=0,i=0;i<this.length;i++)a=(o=-(0|this.words[i])+a)>>26,this.words[i]=67108863&o;return this.negative=1,this._strip()},i.prototype._wordDiv=function(t,e){var r=(this.length,t.length),n=this.clone(),o=t,s=0|o.words[o.length-1];0!=(r=26-this._countBits(s))&&(o=o.ushln(r),n.iushln(r),s=0|o.words[o.length-1]);var a,u=n.length-o.length;if("mod"!==e){(a=new i(null)).length=u+1,a.words=new Array(a.length);for(var h=0;h<a.length;h++)a.words[h]=0}var l=n.clone()._ishlnsubmul(o,1,u);0===l.negative&&(n=l,a&&(a.words[u]=1));for(var d=u-1;d>=0;d--){var c=67108864*(0|n.words[o.length+d])+(0|n.words[o.length+d-1]);for(c=Math.min(c/s|0,67108863),n._ishlnsubmul(o,c,d);0!==n.negative;)c--,n.negative=0,n._ishlnsubmul(o,1,d),n.isZero()||(n.negative^=1);a&&(a.words[d]=c)}return a&&a._strip(),n._strip(),"div"!==e&&0!==r&&n.iushrn(r),{div:a||null,mod:n}},i.prototype.divmod=function(t,e,n){return r(!t.isZero()),this.isZero()?{div:new i(0),mod:new i(0)}:0!==this.negative&&0===t.negative?(a=this.neg().divmod(t,e),"mod"!==e&&(o=a.div.neg()),"div"!==e&&(s=a.mod.neg(),n&&0!==s.negative&&s.iadd(t)),{div:o,mod:s}):0===this.negative&&0!==t.negative?(a=this.divmod(t.neg(),e),"mod"!==e&&(o=a.div.neg()),{div:o,mod:a.mod}):0!=(this.negative&t.negative)?(a=this.neg().divmod(t.neg(),e),"div"!==e&&(s=a.mod.neg(),n&&0!==s.negative&&s.isub(t)),{div:a.div,mod:s}):t.length>this.length||this.cmp(t)<0?{div:new i(0),mod:this}:1===t.length?"div"===e?{div:this.divn(t.words[0]),mod:null}:"mod"===e?{div:null,mod:new i(this.modrn(t.words[0]))}:{div:this.divn(t.words[0]),mod:new i(this.modrn(t.words[0]))}:this._wordDiv(t,e);var o,s,a},i.prototype.div=function(t){return this.divmod(t,"div",0).div},i.prototype.mod=function(t){return this.divmod(t,"mod",0).mod},i.prototype.umod=function(t){return this.divmod(t,"mod",1).mod},i.prototype.divRound=function(t){var e=this.divmod(t);if(e.mod.isZero())return e.div;var r=0!==e.div.negative?e.mod.isub(t):e.mod,n=t.ushrn(1),i=t.andln(1),o=r.cmp(n);return o<0||1===i&&0===o?e.div:0!==e.div.negative?e.div.isubn(1):e.div.iaddn(1)},i.prototype.modrn=function(t){var e=t<0;e&&(t=-t),r(t<=67108863);for(var n=(1<<26)%t,i=0,o=this.length-1;o>=0;o--)i=(n*i+(0|this.words[o]))%t;return e?-i:i},i.prototype.modn=function(t){return this.modrn(t)},i.prototype.idivn=function(t){var e=t<0;e&&(t=-t),r(t<=67108863);for(var n=0,i=this.length-1;i>=0;i--){var o=(0|this.words[i])+67108864*n;this.words[i]=o/t|0,n=o%t}return this._strip(),e?this.ineg():this},i.prototype.divn=function(t){return this.clone().idivn(t)},i.prototype.egcd=function(t){r(0===t.negative),r(!t.isZero());var e=this,n=t.clone();e=0!==e.negative?e.umod(t):e.clone();for(var o=new i(1),s=new i(0),a=new i(0),u=new i(1),h=0;e.isEven()&&n.isEven();)e.iushrn(1),n.iushrn(1),++h;for(var l=n.clone(),d=e.clone();!e.isZero();){for(var c=0,m=1;0==(e.words[0]&m)&&c<26;++c,m<<=1);if(c>0)for(e.iushrn(c);c-- >0;)(o.isOdd()||s.isOdd())&&(o.iadd(l),s.isub(d)),o.iushrn(1),s.iushrn(1);for(var p=0,f=1;0==(n.words[0]&f)&&p<26;++p,f<<=1);if(p>0)for(n.iushrn(p);p-- >0;)(a.isOdd()||u.isOdd())&&(a.iadd(l),u.isub(d)),a.iushrn(1),u.iushrn(1);e.cmp(n)>=0?(e.isub(n),o.isub(a),s.isub(u)):(n.isub(e),a.isub(o),u.isub(s))}return{a:a,b:u,gcd:n.iushln(h)}},i.prototype._invmp=function(t){r(0===t.negative),r(!t.isZero());var e=this,n=t.clone();e=0!==e.negative?e.umod(t):e.clone();for(var o,s=new i(1),a=new i(0),u=n.clone();e.cmpn(1)>0&&n.cmpn(1)>0;){for(var h=0,l=1;0==(e.words[0]&l)&&h<26;++h,l<<=1);if(h>0)for(e.iushrn(h);h-- >0;)s.isOdd()&&s.iadd(u),s.iushrn(1);for(var d=0,c=1;0==(n.words[0]&c)&&d<26;++d,c<<=1);if(d>0)for(n.iushrn(d);d-- >0;)a.isOdd()&&a.iadd(u),a.iushrn(1);e.cmp(n)>=0?(e.isub(n),s.isub(a)):(n.isub(e),a.isub(s))}return(o=0===e.cmpn(1)?s:a).cmpn(0)<0&&o.iadd(t),o},i.prototype.gcd=function(t){if(this.isZero())return t.abs();if(t.isZero())return this.abs();var e=this.clone(),r=t.clone();e.negative=0,r.negative=0;for(var n=0;e.isEven()&&r.isEven();n++)e.iushrn(1),r.iushrn(1);for(;;){for(;e.isEven();)e.iushrn(1);for(;r.isEven();)r.iushrn(1);var i=e.cmp(r);if(i<0){var o=e;e=r,r=o}else if(0===i||0===r.cmpn(1))break;e.isub(r)}return r.iushln(n)},i.prototype.invm=function(t){return this.egcd(t).a.umod(t)},i.prototype.isEven=function(){return 0==(1&this.words[0])},i.prototype.isOdd=function(){return 1==(1&this.words[0])},i.prototype.andln=function(t){return this.words[0]&t},i.prototype.bincn=function(t){r("number"==typeof t);var e=t%26,n=(t-e)/26,i=1<<e;if(this.length<=n)return this._expand(n+1),this.words[n]|=i,this;for(var o=i,s=n;0!==o&&s<this.length;s++){var a=0|this.words[s];o=(a+=o)>>>26,a&=67108863,this.words[s]=a}return 0!==o&&(this.words[s]=o,this.length++),this},i.prototype.isZero=function(){return 1===this.length&&0===this.words[0]},i.prototype.cmpn=function(t){var e,n=t<0;if(0!==this.negative&&!n)return-1;if(0===this.negative&&n)return 1;if(this._strip(),this.length>1)e=1;else{n&&(t=-t),r(t<=67108863,"Number is too big");var i=0|this.words[0];e=i===t?0:i<t?-1:1}return 0!==this.negative?0|-e:e},i.prototype.cmp=function(t){if(0!==this.negative&&0===t.negative)return-1;if(0===this.negative&&0!==t.negative)return 1;var e=this.ucmp(t);return 0!==this.negative?0|-e:e},i.prototype.ucmp=function(t){if(this.length>t.length)return 1;if(this.length<t.length)return-1;for(var e=0,r=this.length-1;r>=0;r--){var n=0|this.words[r],i=0|t.words[r];if(n!==i){n<i?e=-1:n>i&&(e=1);break}}return e},i.prototype.gtn=function(t){return 1===this.cmpn(t)},i.prototype.gt=function(t){return 1===this.cmp(t)},i.prototype.gten=function(t){return this.cmpn(t)>=0},i.prototype.gte=function(t){return this.cmp(t)>=0},i.prototype.ltn=function(t){return-1===this.cmpn(t)},i.prototype.lt=function(t){return-1===this.cmp(t)},i.prototype.lten=function(t){return this.cmpn(t)<=0},i.prototype.lte=function(t){return this.cmp(t)<=0},i.prototype.eqn=function(t){return 0===this.cmpn(t)},i.prototype.eq=function(t){return 0===this.cmp(t)},i.red=function(t){return new T(t)},i.prototype.toRed=function(t){return r(!this.red,"Already a number in reduction context"),r(0===this.negative,"red works only with positives"),t.convertTo(this)._forceRed(t)},i.prototype.fromRed=function(){return r(this.red,"fromRed works only with numbers in reduction context"),this.red.convertFrom(this)},i.prototype._forceRed=function(t){return this.red=t,this},i.prototype.forceRed=function(t){return r(!this.red,"Already a number in reduction context"),this._forceRed(t)},i.prototype.redAdd=function(t){return r(this.red,"redAdd works only with red numbers"),this.red.add(this,t)},i.prototype.redIAdd=function(t){return r(this.red,"redIAdd works only with red numbers"),this.red.iadd(this,t)},i.prototype.redSub=function(t){return r(this.red,"redSub works only with red numbers"),this.red.sub(this,t)},i.prototype.redISub=function(t){return r(this.red,"redISub works only with red numbers"),this.red.isub(this,t)},i.prototype.redShl=function(t){return r(this.red,"redShl works only with red numbers"),this.red.shl(this,t)},i.prototype.redMul=function(t){return r(this.red,"redMul works only with red numbers"),this.red._verify2(this,t),this.red.mul(this,t)},i.prototype.redIMul=function(t){return r(this.red,"redMul works only with red numbers"),this.red._verify2(this,t),this.red.imul(this,t)},i.prototype.redSqr=function(){return r(this.red,"redSqr works only with red numbers"),this.red._verify1(this),this.red.sqr(this)},i.prototype.redISqr=function(){return r(this.red,"redISqr works only with red numbers"),this.red._verify1(this),this.red.isqr(this)},i.prototype.redSqrt=function(){return r(this.red,"redSqrt works only with red numbers"),this.red._verify1(this),this.red.sqrt(this)},i.prototype.redInvm=function(){return r(this.red,"redInvm works only with red numbers"),this.red._verify1(this),this.red.invm(this)},i.prototype.redNeg=function(){return r(this.red,"redNeg works only with red numbers"),this.red._verify1(this),this.red.neg(this)},i.prototype.redPow=function(t){return r(this.red&&!t.red,"redPow(normalNum)"),this.red._verify1(this),this.red.pow(this,t)};var M={k256:null,p224:null,p192:null,p25519:null};function b(t,e){this.name=t,this.p=new i(e,16),this.n=this.p.bitLength(),this.k=new i(1).iushln(this.n).isub(this.p),this.tmp=this._tmp()}function k(){b.call(this,"k256","ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f")}function P(){b.call(this,"p224","ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001")}function S(){b.call(this,"p192","ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff")}function A(){b.call(this,"25519","7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed")}function T(t){if("string"==typeof t){var e=i._prime(t);this.m=e.p,this.prime=e}else r(t.gtn(1),"modulus must be greater than 1"),this.m=t,this.prime=null}function x(t){T.call(this,t),this.shift=this.m.bitLength(),this.shift%26!=0&&(this.shift+=26-this.shift%26),this.r=new i(1).iushln(this.shift),this.r2=this.imod(this.r.sqr()),this.rinv=this.r._invmp(this.m),this.minv=this.rinv.mul(this.r).isubn(1).div(this.m),this.minv=this.minv.umod(this.r),this.minv=this.r.sub(this.minv)}b.prototype._tmp=function(){var t=new i(null);return t.words=new Array(Math.ceil(this.n/13)),t},b.prototype.ireduce=function(t){var e,r=t;do{this.split(r,this.tmp),e=(r=(r=this.imulK(r)).iadd(this.tmp)).bitLength()}while(e>this.n);var n=e<this.n?-1:r.ucmp(this.p);return 0===n?(r.words[0]=0,r.length=1):n>0?r.isub(this.p):void 0!==r.strip?r.strip():r._strip(),r},b.prototype.split=function(t,e){t.iushrn(this.n,0,e)},b.prototype.imulK=function(t){return t.imul(this.k)},n(k,b),k.prototype.split=function(t,e){for(var r=4194303,n=Math.min(t.length,9),i=0;i<n;i++)e.words[i]=t.words[i];if(e.length=n,t.length<=9)return t.words[0]=0,void(t.length=1);var o=t.words[9];for(e.words[e.length++]=o&r,i=10;i<t.length;i++){var s=0|t.words[i];t.words[i-10]=(s&r)<<4|o>>>22,o=s}o>>>=22,t.words[i-10]=o,0===o&&t.length>10?t.length-=10:t.length-=9},k.prototype.imulK=function(t){t.words[t.length]=0,t.words[t.length+1]=0,t.length+=2;for(var e=0,r=0;r<t.length;r++){var n=0|t.words[r];e+=977*n,t.words[r]=67108863&e,e=64*n+(e/67108864|0)}return 0===t.words[t.length-1]&&(t.length--,0===t.words[t.length-1]&&t.length--),t},n(P,b),n(S,b),n(A,b),A.prototype.imulK=function(t){for(var e=0,r=0;r<t.length;r++){var n=19*(0|t.words[r])+e,i=67108863&n;n>>>=26,t.words[r]=i,e=n}return 0!==e&&(t.words[t.length++]=e),t},i._prime=function(t){if(M[t])return M[t];var e;if("k256"===t)e=new k;else if("p224"===t)e=new P;else if("p192"===t)e=new S;else{if("p25519"!==t)throw new Error("Unknown prime "+t);e=new A}return M[t]=e,e},T.prototype._verify1=function(t){r(0===t.negative,"red works only with positives"),r(t.red,"red works only with red numbers")},T.prototype._verify2=function(t,e){r(0==(t.negative|e.negative),"red works only with positives"),r(t.red&&t.red===e.red,"red works only with red numbers")},T.prototype.imod=function(t){return this.prime?this.prime.ireduce(t)._forceRed(this):(h(t,t.umod(this.m)._forceRed(this)),t)},T.prototype.neg=function(t){return t.isZero()?t.clone():this.m.sub(t)._forceRed(this)},T.prototype.add=function(t,e){this._verify2(t,e);var r=t.add(e);return r.cmp(this.m)>=0&&r.isub(this.m),r._forceRed(this)},T.prototype.iadd=function(t,e){this._verify2(t,e);var r=t.iadd(e);return r.cmp(this.m)>=0&&r.isub(this.m),r},T.prototype.sub=function(t,e){this._verify2(t,e);var r=t.sub(e);return r.cmpn(0)<0&&r.iadd(this.m),r._forceRed(this)},T.prototype.isub=function(t,e){this._verify2(t,e);var r=t.isub(e);return r.cmpn(0)<0&&r.iadd(this.m),r},T.prototype.shl=function(t,e){return this._verify1(t),this.imod(t.ushln(e))},T.prototype.imul=function(t,e){return this._verify2(t,e),this.imod(t.imul(e))},T.prototype.mul=function(t,e){return this._verify2(t,e),this.imod(t.mul(e))},T.prototype.isqr=function(t){return this.imul(t,t.clone())},T.prototype.sqr=function(t){return this.mul(t,t)},T.prototype.sqrt=function(t){if(t.isZero())return t.clone();var e=this.m.andln(3);if(r(e%2==1),3===e){var n=this.m.add(new i(1)).iushrn(2);return this.pow(t,n)}for(var o=this.m.subn(1),s=0;!o.isZero()&&0===o.andln(1);)s++,o.iushrn(1);r(!o.isZero());var a=new i(1).toRed(this),u=a.redNeg(),h=this.m.subn(1).iushrn(1),l=this.m.bitLength();for(l=new i(2*l*l).toRed(this);0!==this.pow(l,h).cmp(u);)l.redIAdd(u);for(var d=this.pow(l,o),c=this.pow(t,o.addn(1).iushrn(1)),m=this.pow(t,o),p=s;0!==m.cmp(a);){for(var f=m,g=0;0!==f.cmp(a);g++)f=f.redSqr();r(g<p);var y=this.pow(d,new i(1).iushln(p-g-1));c=c.redMul(y),d=y.redSqr(),m=m.redMul(d),p=g}return c},T.prototype.invm=function(t){var e=t._invmp(this.m);return 0!==e.negative?(e.negative=0,this.imod(e).redNeg()):this.imod(e)},T.prototype.pow=function(t,e){if(e.isZero())return new i(1).toRed(this);if(0===e.cmpn(1))return t.clone();var r=new Array(16);r[0]=new i(1).toRed(this),r[1]=t;for(var n=2;n<r.length;n++)r[n]=this.mul(r[n-1],t);var o=r[0],s=0,a=0,u=e.bitLength()%26;for(0===u&&(u=26),n=e.length-1;n>=0;n--){for(var h=e.words[n],l=u-1;l>=0;l--){var d=h>>l&1;o!==r[0]&&(o=this.sqr(o)),0!==d||0!==s?(s<<=1,s|=d,(4==++a||0===n&&0===l)&&(o=this.mul(o,r[s]),a=0,s=0)):a=0}u=26}return o},T.prototype.convertTo=function(t){var e=t.umod(this.m);return e===t?e.clone():e},T.prototype.convertFrom=function(t){var e=t.clone();return e.red=null,e},i.mont=function(t){return new x(t)},n(x,T),x.prototype.convertTo=function(t){return this.imod(t.ushln(this.shift))},x.prototype.convertFrom=function(t){var e=this.imod(t.mul(this.rinv));return e.red=null,e},x.prototype.imul=function(t,e){if(t.isZero()||e.isZero())return t.words[0]=0,t.length=1,t;var r=t.imul(e),n=r.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m),i=r.isub(n).iushrn(this.shift),o=i;return i.cmp(this.m)>=0?o=i.isub(this.m):i.cmpn(0)<0&&(o=i.iadd(this.m)),o._forceRed(this)},x.prototype.mul=function(t,e){if(t.isZero()||e.isZero())return new i(0)._forceRed(this);var r=t.mul(e),n=r.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m),o=r.isub(n).iushrn(this.shift),s=o;return o.cmp(this.m)>=0?s=o.isub(this.m):o.cmpn(0)<0&&(s=o.iadd(this.m)),s._forceRed(this)},x.prototype.invm=function(t){return this.imod(t._invmp(this.m).mul(this.r2))._forceRed(this)}}(0,a);var c=l.exports,m=u(c),p={},f={};class g{constructor(t,e){if(!Number.isInteger(t))throw new TypeError("span must be an integer");this.span=t,this.property=e}makeDestinationObject(){return{}}decode(t,e){throw new Error("Layout is abstract")}encode(t,e,r){throw new Error("Layout is abstract")}getSpan(t,e){if(0>this.span)throw new RangeError("indeterminate span");return this.span}replicate(t){const e=Object.create(this.constructor.prototype);return Object.assign(e,this),e.property=t,e}fromArray(t){}}function y(t,e){return e.property?t+"["+e.property+"]":t}f.Layout=g,f.nameWithProperty=y,f.bindConstructorLayout=function(t,e){if("function"!=typeof t)throw new TypeError("Class must be constructor");if(t.hasOwnProperty("layout_"))throw new Error("Class is already bound to a layout");if(!(e&&e instanceof g))throw new TypeError("layout must be a Layout");if(e.hasOwnProperty("boundConstructor_"))throw new Error("layout is already bound to a constructor");t.layout_=e,e.boundConstructor_=t,e.makeDestinationObject=()=>new t,Object.defineProperty(t.prototype,"encode",{value:function(t,r){return e.encode(this,t,r)},writable:1}),Object.defineProperty(t,"decode",{value:function(t,r){return e.decode(t,r)},writable:1})};class w extends g{isCount(){throw new Error("ExternalLayout is abstract")}}class v extends w{constructor(t,e){if(void 0===t&&(t=1),!Number.isInteger(t)||0>=t)throw new TypeError("elementSpan must be a (positive) integer");super(-1,e),this.elementSpan=t}isCount(){return 1}decode(t,e){void 0===e&&(e=0);const r=t.length-e;return Math.floor(r/this.elementSpan)}encode(t,e,r){return 0}}class M extends w{constructor(t,e,r){if(!(t instanceof g))throw new TypeError("layout must be a Layout");if(void 0===e)e=0;else if(!Number.isInteger(e))throw new TypeError("offset must be integer or undefined");super(t.span,r||t.property),this.layout=t,this.offset=e}isCount(){return this.layout instanceof b||this.layout instanceof k}decode(t,e){return void 0===e&&(e=0),this.layout.decode(t,e+this.offset)}encode(t,e,r){return void 0===r&&(r=0),this.layout.encode(t,e,r+this.offset)}}class b extends g{constructor(t,e){if(super(t,e),6<this.span)throw new RangeError("span must not exceed 6 bytes")}decode(t,e){return void 0===e&&(e=0),t.readUIntLE(e,this.span)}encode(t,e,r){return void 0===r&&(r=0),e.writeUIntLE(t,r,this.span),this.span}}class k extends g{constructor(t,e){if(super(t,e),6<this.span)throw new RangeError("span must not exceed 6 bytes")}decode(t,e){return void 0===e&&(e=0),t.readUIntBE(e,this.span)}encode(t,e,r){return void 0===r&&(r=0),e.writeUIntBE(t,r,this.span),this.span}}class P extends g{constructor(t,e){if(super(t,e),6<this.span)throw new RangeError("span must not exceed 6 bytes")}decode(t,e){return void 0===e&&(e=0),t.readIntLE(e,this.span)}encode(t,e,r){return void 0===r&&(r=0),e.writeIntLE(t,r,this.span),this.span}}class S extends g{constructor(t,e){if(super(t,e),6<this.span)throw new RangeError("span must not exceed 6 bytes")}decode(t,e){return void 0===e&&(e=0),t.readIntBE(e,this.span)}encode(t,e,r){return void 0===r&&(r=0),e.writeIntBE(t,r,this.span),this.span}}const A=Math.pow(2,32);function T(t){const e=Math.floor(t/A);return{hi32:e,lo32:t-e*A}}function x(t,e){return t*A+e}class _ extends g{constructor(t){super(8,t)}decode(t,e){void 0===e&&(e=0);const r=t.readUInt32LE(e);return x(t.readUInt32LE(e+4),r)}encode(t,e,r){void 0===r&&(r=0);const n=T(t);return e.writeUInt32LE(n.lo32,r),e.writeUInt32LE(n.hi32,r+4),8}}class I extends g{constructor(t){super(8,t)}decode(t,e){return void 0===e&&(e=0),x(t.readUInt32BE(e),t.readUInt32BE(e+4))}encode(t,e,r){void 0===r&&(r=0);const n=T(t);return e.writeUInt32BE(n.hi32,r),e.writeUInt32BE(n.lo32,r+4),8}}class E extends g{constructor(t){super(8,t)}decode(t,e){void 0===e&&(e=0);const r=t.readUInt32LE(e);return x(t.readInt32LE(e+4),r)}encode(t,e,r){void 0===r&&(r=0);const n=T(t);return e.writeUInt32LE(n.lo32,r),e.writeInt32LE(n.hi32,r+4),8}}class C extends g{constructor(t){super(8,t)}decode(t,e){return void 0===e&&(e=0),x(t.readInt32BE(e),t.readUInt32BE(e+4))}encode(t,e,r){void 0===r&&(r=0);const n=T(t);return e.writeInt32BE(n.hi32,r),e.writeUInt32BE(n.lo32,r+4),8}}class L extends g{constructor(t){super(4,t)}decode(t,e){return void 0===e&&(e=0),t.readFloatLE(e)}encode(t,e,r){return void 0===r&&(r=0),e.writeFloatLE(t,r),4}}class B extends g{constructor(t){super(4,t)}decode(t,e){return void 0===e&&(e=0),t.readFloatBE(e)}encode(t,e,r){return void 0===r&&(r=0),e.writeFloatBE(t,r),4}}class O extends g{constructor(t){super(8,t)}decode(t,e){return void 0===e&&(e=0),t.readDoubleLE(e)}encode(t,e,r){return void 0===r&&(r=0),e.writeDoubleLE(t,r),8}}class R extends g{constructor(t){super(8,t)}decode(t,e){return void 0===e&&(e=0),t.readDoubleBE(e)}encode(t,e,r){return void 0===r&&(r=0),e.writeDoubleBE(t,r),8}}class D extends g{constructor(t,e,r){if(!(t instanceof g))throw new TypeError("elementLayout must be a Layout");if(!(e instanceof w&&e.isCount()||Number.isInteger(e)&&0<=e))throw new TypeError("count must be non-negative integer or an unsigned integer ExternalLayout");let n=-1;!(e instanceof w)&&0<t.span&&(n=e*t.span),super(n,r),this.elementLayout=t,this.count=e}getSpan(t,e){if(0<=this.span)return this.span;void 0===e&&(e=0);let r=0,n=this.count;if(n instanceof w&&(n=n.decode(t,e)),0<this.elementLayout.span)r=n*this.elementLayout.span;else{let i=0;for(;i<n;)r+=this.elementLayout.getSpan(t,e+r),++i}return r}decode(t,e){void 0===e&&(e=0);const r=[];let n=0,i=this.count;for(i instanceof w&&(i=i.decode(t,e));n<i;)r.push(this.elementLayout.decode(t,e)),e+=this.elementLayout.getSpan(t,e),n+=1;return r}encode(t,e,r){void 0===r&&(r=0);const n=this.elementLayout,i=t.reduce(((t,i)=>t+n.encode(i,e,r+t)),0);return this.count instanceof w&&this.count.encode(t.length,e,r),i}}class K extends g{constructor(t,e,r){if(!Array.isArray(t)||!t.reduce(((t,e)=>t&&e instanceof g),1))throw new TypeError("fields must be array of Layout instances");"boolean"==typeof e&&void 0===r&&(r=e,e=void 0);for(const e of t)if(0>e.span&&void 0===e.property)throw new Error("fields cannot contain unnamed variable-length layout");let n=-1;try{n=t.reduce(((t,e)=>t+e.getSpan()),0)}catch(t){}super(n,e),this.fields=t,this.decodePrefixes=!!r}getSpan(t,e){if(0<=this.span)return this.span;void 0===e&&(e=0);let r=0;try{r=this.fields.reduce(((r,n)=>{const i=n.getSpan(t,e);return e+=i,r+i}),0)}catch(t){throw new RangeError("indeterminate span")}return r}decode(t,e){void 0===e&&(e=0);const r=this.makeDestinationObject();for(const n of this.fields)if(void 0!==n.property&&(r[n.property]=n.decode(t,e)),e+=n.getSpan(t,e),this.decodePrefixes&&t.length===e)break;return r}encode(t,e,r){void 0===r&&(r=0);const n=r;let i=0,o=0;for(const n of this.fields){let s=n.span;if(o=0<s?s:0,void 0!==n.property){const i=t[n.property];void 0!==i&&(o=n.encode(i,e,r),0>s&&(s=n.getSpan(e,r)))}i=r,r+=s}return i+o-n}fromArray(t){const e=this.makeDestinationObject();for(const r of this.fields)void 0!==r.property&&0<t.length&&(e[r.property]=t.shift());return e}layoutFor(t){if("string"!=typeof t)throw new TypeError("property must be string");for(const e of this.fields)if(e.property===t)return e}offsetOf(t){if("string"!=typeof t)throw new TypeError("property must be string");let e=0;for(const r of this.fields){if(r.property===t)return e;0>r.span?e=-1:0<=e&&(e+=r.span)}}}class U{constructor(t){this.property=t}decode(){throw new Error("UnionDiscriminator is abstract")}encode(){throw new Error("UnionDiscriminator is abstract")}}class W extends U{constructor(t,e){if(!(t instanceof w&&t.isCount()))throw new TypeError("layout must be an unsigned integer ExternalLayout");super(e||t.property||"variant"),this.layout=t}decode(t,e){return this.layout.decode(t,e)}encode(t,e,r){return this.layout.encode(t,e,r)}}class q extends g{constructor(t,e,r){const n=t instanceof b||t instanceof k;if(n)t=new W(new M(t));else if(t instanceof w&&t.isCount())t=new W(t);else if(!(t instanceof U))throw new TypeError("discr must be a UnionDiscriminator or an unsigned integer layout");if(void 0===e&&(e=null),!(null===e||e instanceof g))throw new TypeError("defaultLayout must be null or a Layout");if(null!==e){if(0>e.span)throw new Error("defaultLayout must have constant span");void 0===e.property&&(e=e.replicate("content"))}let i=-1;e&&(i=e.span,0<=i&&n&&(i+=t.layout.span)),super(i,r),this.discriminator=t,this.usesPrefixDiscriminator=n,this.defaultLayout=e,this.registry={};let o=this.defaultGetSourceVariant.bind(this);this.getSourceVariant=function(t){return o(t)},this.configGetSourceVariant=function(t){o=t.bind(this)}}getSpan(t,e){if(0<=this.span)return this.span;void 0===e&&(e=0);const r=this.getVariant(t,e);if(!r)throw new Error("unable to determine span for unrecognized variant");return r.getSpan(t,e)}defaultGetSourceVariant(t){if(t.hasOwnProperty(this.discriminator.property)){if(this.defaultLayout&&t.hasOwnProperty(this.defaultLayout.property))return;const e=this.registry[t[this.discriminator.property]];if(e&&(!e.layout||t.hasOwnProperty(e.property)))return e}else for(const e in this.registry){const r=this.registry[e];if(t.hasOwnProperty(r.property))return r}throw new Error("unable to infer src variant")}decode(t,e){let r;void 0===e&&(e=0);const n=this.discriminator,i=n.decode(t,e);let o=this.registry[i];if(void 0===o){let s=0;o=this.defaultLayout,this.usesPrefixDiscriminator&&(s=n.layout.span),r=this.makeDestinationObject(),r[n.property]=i,r[o.property]=this.defaultLayout.decode(t,e+s)}else r=o.decode(t,e);return r}encode(t,e,r){void 0===r&&(r=0);const n=this.getSourceVariant(t);if(void 0===n){const n=this.discriminator,i=this.defaultLayout;let o=0;return this.usesPrefixDiscriminator&&(o=n.layout.span),n.encode(t[n.property],e,r),o+i.encode(t[i.property],e,r+o)}return n.encode(t,e,r)}addVariant(t,e,r){const n=new N(this,t,e,r);return this.registry[t]=n,n}getVariant(t,e){let r=t;return Buffer.isBuffer(t)&&(void 0===e&&(e=0),r=this.discriminator.decode(t,e)),this.registry[r]}}class N extends g{constructor(t,e,r,n){if(!(t instanceof q))throw new TypeError("union must be a Union");if(!Number.isInteger(e)||0>e)throw new TypeError("variant must be a (non-negative) integer");if("string"==typeof r&&void 0===n&&(n=r,r=null),r){if(!(r instanceof g))throw new TypeError("layout must be a Layout");if(null!==t.defaultLayout&&0<=r.span&&r.span>t.defaultLayout.span)throw new Error("variant span exceeds span of containing union");if("string"!=typeof n)throw new TypeError("variant must have a String property")}let i=t.span;0>t.span&&(i=r?r.span:0,0<=i&&t.usesPrefixDiscriminator&&(i+=t.discriminator.layout.span)),super(i,n),this.union=t,this.variant=e,this.layout=r||null}getSpan(t,e){if(0<=this.span)return this.span;void 0===e&&(e=0);let r=0;return this.union.usesPrefixDiscriminator&&(r=this.union.discriminator.layout.span),r+this.layout.getSpan(t,e+r)}decode(t,e){const r=this.makeDestinationObject();if(void 0===e&&(e=0),this!==this.union.getVariant(t,e))throw new Error("variant mismatch");let n=0;return this.union.usesPrefixDiscriminator&&(n=this.union.discriminator.layout.span),this.layout?r[this.property]=this.layout.decode(t,e+n):this.property?r[this.property]=1:this.union.usesPrefixDiscriminator&&(r[this.union.discriminator.property]=this.variant),r}encode(t,e,r){void 0===r&&(r=0);let n=0;if(this.union.usesPrefixDiscriminator&&(n=this.union.discriminator.layout.span),this.layout&&!t.hasOwnProperty(this.property))throw new TypeError("variant lacks property "+this.property);this.union.discriminator.encode(this.variant,e,r);let i=n;if(this.layout&&(this.layout.encode(t[this.property],e,r+n),i+=this.layout.getSpan(e,r+n),0<=this.union.span&&i>this.union.span))throw new Error("encoded variant overruns containing union");return i}fromArray(t){if(this.layout)return this.layout.fromArray(t)}}function j(t){return 0>t&&(t+=4294967296),t}class V extends g{constructor(t,e,r){if(!(t instanceof b||t instanceof k))throw new TypeError("word must be a UInt or UIntBE layout");if("string"==typeof e&&void 0===r&&(r=e,e=void 0),4<t.span)throw new RangeError("word cannot exceed 32 bits");super(t.span,r),this.word=t,this.msb=!!e,this.fields=[];let n=0;this._packedSetValue=function(t){return n=j(t),this},this._packedGetValue=function(){return n}}decode(t,e){const r=this.makeDestinationObject();void 0===e&&(e=0);const n=this.word.decode(t,e);this._packedSetValue(n);for(const t of this.fields)void 0!==t.property&&(r[t.property]=t.decode(n));return r}encode(t,e,r){void 0===r&&(r=0);const n=this.word.decode(e,r);this._packedSetValue(n);for(const e of this.fields)if(void 0!==e.property){const r=t[e.property];void 0!==r&&e.encode(r)}return this.word.encode(this._packedGetValue(),e,r)}addField(t,e){const r=new Z(this,t,e);return this.fields.push(r),r}addBoolean(t){const e=new z(this,t);return this.fields.push(e),e}fieldFor(t){if("string"!=typeof t)throw new TypeError("property must be string");for(const e of this.fields)if(e.property===t)return e}}class Z{constructor(t,e,r){if(!(t instanceof V))throw new TypeError("container must be a BitStructure");if(!Number.isInteger(e)||0>=e)throw new TypeError("bits must be positive integer");const n=8*t.span,i=t.fields.reduce(((t,e)=>t+e.bits),0);if(e+i>n)throw new Error("bits too long for span remainder ("+(n-i)+" of "+n+" remain)");this.container=t,this.bits=e,this.valueMask=(1<<e)-1,32===e&&(this.valueMask=4294967295),this.start=i,this.container.msb&&(this.start=n-i-e),this.wordMask=j(this.valueMask<<this.start),this.property=r}decode(){return j(this.container._packedGetValue()&this.wordMask)>>>this.start}encode(t){if(!Number.isInteger(t)||t!==j(t&this.valueMask))throw new TypeError(y("BitField.encode",this)+" value must be integer not exceeding "+this.valueMask);const e=this.container._packedGetValue(),r=j(t<<this.start);this.container._packedSetValue(j(e&~this.wordMask)|r)}}class z extends Z{constructor(t,e){super(t,1,e)}decode(t,e){return!!Z.prototype.decode.call(this,t,e)}encode(t){return"boolean"==typeof t&&(t=+t),Z.prototype.encode.call(this,t)}}class F extends g{constructor(t,e){if(!(t instanceof w&&t.isCount()||Number.isInteger(t)&&0<=t))throw new TypeError("length must be positive integer or an unsigned integer ExternalLayout");let r=-1;t instanceof w||(r=t),super(r,e),this.length=t}getSpan(t,e){let r=this.span;return 0>r&&(r=this.length.decode(t,e)),r}decode(t,e){void 0===e&&(e=0);let r=this.span;return 0>r&&(r=this.length.decode(t,e)),t.slice(e,e+r)}encode(t,e,r){let n=this.length;if(this.length instanceof w&&(n=t.length),!Buffer.isBuffer(t)||n!==t.length)throw new TypeError(y("Blob.encode",this)+" requires (length "+n+") Buffer as src");if(r+n>e.length)throw new RangeError("encoding overruns Buffer");return e.write(t.toString("hex"),r,n,"hex"),this.length instanceof w&&this.length.encode(n,e,r),n}}class G extends g{constructor(t){super(-1,t)}getSpan(t,e){if(!Buffer.isBuffer(t))throw new TypeError("b must be a Buffer");void 0===e&&(e=0);let r=e;for(;r<t.length&&0!==t[r];)r+=1;return 1+r-e}decode(t,e,r){void 0===e&&(e=0);let n=this.getSpan(t,e);return t.slice(e,e+n-1).toString("utf-8")}encode(t,e,r){void 0===r&&(r=0),"string"!=typeof t&&(t=t.toString());const n=new Buffer(t,"utf8"),i=n.length;if(r+i>e.length)throw new RangeError("encoding overruns Buffer");return n.copy(e,r),e[r+i]=0,i+1}}class Q extends g{constructor(t,e){if("string"==typeof t&&void 0===e&&(e=t,t=void 0),void 0===t)t=-1;else if(!Number.isInteger(t))throw new TypeError("maxSpan must be an integer");super(-1,e),this.maxSpan=t}getSpan(t,e){if(!Buffer.isBuffer(t))throw new TypeError("b must be a Buffer");return void 0===e&&(e=0),t.length-e}decode(t,e,r){void 0===e&&(e=0);let n=this.getSpan(t,e);if(0<=this.maxSpan&&this.maxSpan<n)throw new RangeError("text length exceeds maxSpan");return t.slice(e,e+n).toString("utf-8")}encode(t,e,r){void 0===r&&(r=0),"string"!=typeof t&&(t=t.toString());const n=new Buffer(t,"utf8"),i=n.length;if(0<=this.maxSpan&&this.maxSpan<i)throw new RangeError("text length exceeds maxSpan");if(r+i>e.length)throw new RangeError("encoding overruns Buffer");return n.copy(e,r),i}}class $ extends g{constructor(t,e){super(0,e),this.value=t}decode(t,e,r){return this.value}encode(t,e,r){return 0}}f.ExternalLayout=w,f.GreedyCount=v,f.OffsetLayout=M,f.UInt=b,f.UIntBE=k,f.Int=P,f.IntBE=S,f.Float=L,f.FloatBE=B,f.Double=O,f.DoubleBE=R,f.Sequence=D,f.Structure=K,f.UnionDiscriminator=U,f.UnionLayoutDiscriminator=W,f.Union=q,f.VariantLayout=N,f.BitStructure=V,f.BitField=Z,f.Boolean=z,f.Blob=F,f.CString=G,f.UTF8=Q,f.Constant=$,f.greedy=(t,e)=>new v(t,e),f.offset=(t,e,r)=>new M(t,e,r),f.u8=t=>new b(1,t),f.u16=t=>new b(2,t),f.u24=t=>new b(3,t),f.u32=t=>new b(4,t),f.u40=t=>new b(5,t),f.u48=t=>new b(6,t),f.nu64=t=>new _(t),f.u16be=t=>new k(2,t),f.u24be=t=>new k(3,t),f.u32be=t=>new k(4,t),f.u40be=t=>new k(5,t),f.u48be=t=>new k(6,t),f.nu64be=t=>new I(t),f.s8=t=>new P(1,t),f.s16=t=>new P(2,t),f.s24=t=>new P(3,t),f.s32=t=>new P(4,t),f.s40=t=>new P(5,t),f.s48=t=>new P(6,t),f.ns64=t=>new E(t),f.s16be=t=>new S(2,t),f.s24be=t=>new S(3,t),f.s32be=t=>new S(4,t),f.s40be=t=>new S(5,t),f.s48be=t=>new S(6,t),f.ns64be=t=>new C(t),f.f32=t=>new L(t),f.f32be=t=>new B(t),f.f64=t=>new O(t),f.f64be=t=>new R(t),f.struct=(t,e,r)=>new K(t,e,r),f.bits=(t,e,r)=>new V(t,e,r),f.seq=(t,e,r)=>new D(t,e,r),f.union=(t,e,r)=>new q(t,e,r),f.unionLayoutDiscriminator=(t,e)=>new W(t,e),f.blob=(t,e)=>new F(t,e),f.cstr=t=>new G(t),f.utf8=(t,e)=>new Q(t,e),f.const=(t,e)=>new $(t,e),function(t){var r=a&&a.__importDefault||function(t){return t&&t.__esModule?t:{default:t}};Object.defineProperty(t,"__esModule",{value:1}),t.map=t.array=t.rustEnum=t.str=t.vecU8=t.tagged=t.vec=t.bool=t.option=t.publicKey=t.i256=t.u256=t.i128=t.u128=t.i64=t.u64=t.struct=t.f64=t.f32=t.i32=t.u32=t.i16=t.u16=t.i8=t.u8=void 0;const n=f,i=e,o=r(c);var s=f;Object.defineProperty(t,"u8",{enumerable:1,get:function(){return s.u8}}),Object.defineProperty(t,"i8",{enumerable:1,get:function(){return s.s8}}),Object.defineProperty(t,"u16",{enumerable:1,get:function(){return s.u16}}),Object.defineProperty(t,"i16",{enumerable:1,get:function(){return s.s16}}),Object.defineProperty(t,"u32",{enumerable:1,get:function(){return s.u32}}),Object.defineProperty(t,"i32",{enumerable:1,get:function(){return s.s32}}),Object.defineProperty(t,"f32",{enumerable:1,get:function(){return s.f32}}),Object.defineProperty(t,"f64",{enumerable:1,get:function(){return s.f64}}),Object.defineProperty(t,"struct",{enumerable:1,get:function(){return s.struct}});class u extends n.Layout{constructor(t,e,r){super(t,r),this.blob=(0,n.blob)(t),this.signed=e}decode(t,e=0){const r=new o.default(this.blob.decode(t,e),10,"le");return this.signed?r.fromTwos(8*this.span).clone():r}encode(t,e,r=0){return this.signed&&(t=t.toTwos(8*this.span)),this.blob.encode(t.toArrayLike(Buffer,"le",this.span),e,r)}}function h(t){return new u(8,0,t)}t.u64=h,t.i64=function(t){return new u(8,1,t)},t.u128=function(t){return new u(16,0,t)},t.i128=function(t){return new u(16,1,t)},t.u256=function(t){return new u(32,0,t)},t.i256=function(t){return new u(32,1,t)};class l extends n.Layout{constructor(t,e,r,n){super(t.span,n),this.layout=t,this.decoder=e,this.encoder=r}decode(t,e){return this.decoder(this.layout.decode(t,e))}encode(t,e,r){return this.layout.encode(this.encoder(t),e,r)}getSpan(t,e){return this.layout.getSpan(t,e)}}t.publicKey=function(t){return new l((0,n.blob)(32),(t=>new i.PublicKey(t)),(t=>t.toBuffer()),t)};class d extends n.Layout{constructor(t,e){super(-1,e),this.layout=t,this.discriminator=(0,n.u8)()}encode(t,e,r=0){return null==t?this.discriminator.encode(0,e,r):(this.discriminator.encode(1,e,r),this.layout.encode(t,e,r+1)+1)}decode(t,e=0){const r=this.discriminator.decode(t,e);if(0===r)return null;if(1===r)return this.layout.decode(t,e+1);throw new Error("Invalid option "+this.property)}getSpan(t,e=0){const r=this.discriminator.decode(t,e);if(0===r)return 1;if(1===r)return this.layout.getSpan(t,e+1)+1;throw new Error("Invalid option "+this.property)}}function m(t){if(0===t)return 0;if(1===t)return 1;throw new Error("Invalid bool: "+t)}function p(t){return t?1:0}function g(t){const e=(0,n.u32)("length"),r=(0,n.struct)([e,(0,n.blob)((0,n.offset)(e,-e.span),"data")]);return new l(r,(({data:t})=>t),(t=>({data:t})),t)}t.option=function(t,e){return new d(t,e)},t.bool=function(t){return new l((0,n.u8)(),m,p,t)},t.vec=function(t,e){const r=(0,n.u32)("length"),i=(0,n.struct)([r,(0,n.seq)(t,(0,n.offset)(r,-r.span),"values")]);return new l(i,(({values:t})=>t),(t=>({values:t})),e)},t.tagged=function(t,e,r){const i=(0,n.struct)([h("tag"),e.replicate("data")]);return new l(i,(function({tag:e,data:r}){if(!e.eq(t))throw new Error("Invalid tag, expected: "+t.toString("hex")+", got: "+e.toString("hex"));return r}),(e=>({tag:t,data:e})),r)},t.vecU8=g,t.str=function(t){return new l(g(),(t=>t.toString("utf-8")),(t=>Buffer.from(t,"utf-8")),t)},t.rustEnum=function(t,e,r){const i=(0,n.union)(null!=r?r:(0,n.u8)(),e);return t.forEach(((t,e)=>i.addVariant(e,t,t.property))),i},t.array=function(t,e,r){const i=(0,n.struct)([(0,n.seq)(t,e,"values")]);return new l(i,(({values:t})=>t),(t=>({values:t})),r)};class y extends n.Layout{constructor(t,e,r){super(t.span+e.span,r),this.keyLayout=t,this.valueLayout=e}decode(t,e){return e=e||0,[this.keyLayout.decode(t,e),this.valueLayout.decode(t,e+this.keyLayout.getSpan(t,e))]}encode(t,e,r){r=r||0;const n=this.keyLayout.encode(t[0],e,r);return n+this.valueLayout.encode(t[1],e,r+n)}getSpan(t,e){return this.keyLayout.getSpan(t,e)+this.valueLayout.getSpan(t,e)}}t.map=function(t,e,r){const i=(0,n.u32)("length"),o=(0,n.struct)([i,(0,n.seq)(new y(t,e),(0,n.offset)(i,-i.span),"values")]);return new l(o,(({values:t})=>new Map(t)),(t=>({values:Array.from(t.entries())})),r)}}(p);const H=n.Buffer.from([23,169,27,122,147,169,209,152]),Y=p.struct([p.array(p.u8(),32,"a"),p.array(p.u8(),64,"b"),p.array(p.u8(),32,"c")]),J=p.struct([p.publicKey("owner"),p.u64("amount"),p.option(p.u64(),"lamports"),p.u8("merkleTreeIndex"),p.option(p.vecU8(),"tlv")]),X=p.struct([p.u8("queueId"),p.u16("index")]),tt=p.struct([p.u64("amount"),p.option(p.u8(),"delegateIndex"),p.struct([p.u8("merkleTreePubkeyIndex"),p.u8("nullifierQueuePubkeyIndex"),p.u32("leafIndex"),p.option(X,"QueueIndex")],"merkleContext"),p.u16("rootIndex"),p.option(p.u64(),"lamports"),p.option(p.vecU8(),"tlv")]),et=p.struct([p.publicKey("owner"),p.option(p.u8(),"delegateChangeAccountIndex")]),rt=p.struct([p.bool("setContext"),p.bool("firstSetContext"),p.u8("cpiContextAccountIndex")]),nt=p.struct([p.option(Y,"proof"),p.publicKey("mint"),p.option(et,"delegatedTransfer"),p.vec(tt,"inputTokenDataWithContext"),p.vec(J,"outputCompressedAccounts"),p.bool("isCompress"),p.option(p.u64(),"compressOrDecompressAmount"),p.option(rt,"cpiContext"),p.option(p.u8(),"lamportsChangeAccountMerkleTreeIndex")]),it=p.struct([p.vec(p.publicKey(),"recipients"),p.vec(p.u64(),"amounts"),p.option(p.u64(),"lamports")]),ot=p.struct([p.publicKey("owner"),p.option(p.u64(),"remainingAmount"),p.option(rt,"cpiContext")]),st=n.Buffer.from([241,34,48,186,37,179,123,192]),at=n.Buffer.from([163,52,200,231,140,3,69,186]),ut=n.Buffer.from([112,230,105,101,145,202,157,97]);function ht(t){const e=n.Buffer.alloc(1e3),r=nt.encode(t,e),i=n.Buffer.alloc(4);return i.writeUInt32LE(r,0),n.Buffer.concat([at,i,e.slice(0,r)])}p.struct([p.publicKey("owner"),p.option(p.u64(),"remainingAmount"),p.option(p.struct([],"CompressedCpiContext"),"cpiContext")],"compressSplTokenAccountArgs");const lt=t=>{const e=gt.programId,{feePayer:r,authority:n,cpiAuthorityPda:i,lightSystemProgram:o,registeredProgramPda:s,noopProgram:a,accountCompressionAuthority:u,accountCompressionProgram:h,selfProgram:l,tokenPoolPda:d,compressOrDecompressTokenAccount:c,tokenProgram:m,systemProgram:p}=t;return[{pubkey:r,isSigner:1,isWritable:1},{pubkey:n,isSigner:1,isWritable:0},{pubkey:i,isSigner:0,isWritable:0},{pubkey:o,isSigner:0,isWritable:0},{pubkey:s,isSigner:0,isWritable:0},{pubkey:a,isSigner:0,isWritable:0},{pubkey:u,isSigner:0,isWritable:0},{pubkey:h,isSigner:0,isWritable:0},{pubkey:l,isSigner:0,isWritable:0},{pubkey:null!=d?d:e,isSigner:0,isWritable:1},{pubkey:null!=c?c:e,isSigner:0,isWritable:1},{pubkey:null!=m?m:e,isSigner:0,isWritable:0},{pubkey:p,isSigner:0,isWritable:0}]},dt=e=>e.reduce(((t,e)=>t.add(e.parsed.amount)),t.bn(0)),ct=t=>{const e=t[0].parsed.owner;t.forEach((t=>{if(!t.parsed.owner.equals(e))throw new Error("Token accounts must be owned by the same owner")}))},mt=t=>({mint:t[0].parsed.mint,currentOwner:t[0].parsed.owner,delegate:t[0].parsed.delegate});function pt(e,r,n){n=t.bn(n);const i=dt(e),o=t.sumUpLamports(e.map((t=>t.compressedAccount))),s=i.sub(n);return t.validateSufficientBalance(s),s.eq(t.bn(0))&&o.eq(t.bn(0))?[{owner:r,amount:n,lamports:o,tlv:null}]:(t.validateSameOwner(e.map((t=>t.compressedAccount))),ct(e),[{owner:e[0].parsed.owner,amount:s,lamports:o,tlv:null},{owner:r,amount:n,lamports:t.bn(0),tlv:null}])}function ft(e,r){r=t.bn(r);const n=t.sumUpLamports(e.map((t=>t.compressedAccount))),i=dt(e).sub(r);return t.validateSufficientBalance(i),i.eq(t.bn(0))&&n.eq(t.bn(0))?[]:(t.validateSameOwner(e.map((t=>t.compressedAccount))),ct(e),[{owner:e[0].parsed.owner,amount:i,lamports:n,tlv:null}])}class gt{constructor(){}static setProgramId(t){this.programId="string"==typeof t?new e.PublicKey(t):t}static deriveTokenPoolPda(t){const r=[o,t.toBuffer()],[n,i]=e.PublicKey.findProgramAddressSync(r,this.programId);return n}static get deriveCpiAuthorityPda(){const[t,r]=e.PublicKey.findProgramAddressSync([s],this.programId);return t}static async createMint(t){const{mint:n,authority:i,feePayer:o,rentExemptBalance:s,tokenProgramId:a,freezeAuthority:u,mintSize:h}=t,l=null!=a?a:r.TOKEN_PROGRAM_ID;return[e.SystemProgram.createAccount({fromPubkey:o,lamports:s,newAccountPubkey:n,programId:l,space:null!=h?h:r.MINT_SIZE}),r.createInitializeMint2Instruction(n,t.decimals,i,u,l),await this.createTokenPool({feePayer:o,mint:n,tokenProgramId:l})]}static async createTokenPool(t){const{mint:n,feePayer:i,tokenProgramId:o}=t,s=null!=o?o:r.TOKEN_PROGRAM_ID,a=(t=>{const{feePayer:e,tokenPoolPda:r,systemProgram:n,mint:i,tokenProgram:o,cpiAuthorityPda:s}=t;return[{pubkey:e,isSigner:1,isWritable:1},{pubkey:r,isSigner:0,isWritable:1},{pubkey:n,isSigner:0,isWritable:0},{pubkey:i,isSigner:0,isWritable:1},{pubkey:o,isSigner:0,isWritable:0},{pubkey:s,isSigner:0,isWritable:0}]})({mint:n,feePayer:i,tokenPoolPda:this.deriveTokenPoolPda(n),tokenProgram:s,cpiAuthorityPda:this.deriveCpiAuthorityPda,systemProgram:e.SystemProgram.programId});return new e.TransactionInstruction({programId:this.programId,keys:a,data:H})}static async mintTo(i){const o=t.defaultStaticAccountsStruct(),{mint:s,feePayer:a,authority:u,merkleTree:h,toPubkey:l,amount:d,tokenProgramId:c}=i,m=null!=c?c:r.TOKEN_PROGRAM_ID,p=this.deriveTokenPoolPda(s),f=t.toArray(d).map((e=>t.bn(e))),g=t.toArray(l);if(f.length!==g.length)throw new Error("Amount and toPubkey arrays must have the same length");const y=(t=>{const e=gt.programId,{feePayer:r,authority:n,cpiAuthorityPda:i,mint:o,tokenPoolPda:s,tokenProgram:a,lightSystemProgram:u,registeredProgramPda:h,noopProgram:l,accountCompressionAuthority:d,accountCompressionProgram:c,merkleTree:m,selfProgram:p,systemProgram:f,solPoolPda:g}=t;return[{pubkey:r,isSigner:1,isWritable:1},{pubkey:n,isSigner:1,isWritable:0},{pubkey:i,isSigner:0,isWritable:0},{pubkey:o,isSigner:0,isWritable:1},{pubkey:s,isSigner:0,isWritable:1},{pubkey:a,isSigner:0,isWritable:0},{pubkey:u,isSigner:0,isWritable:0},{pubkey:h,isSigner:0,isWritable:0},{pubkey:l,isSigner:0,isWritable:0},{pubkey:d,isSigner:0,isWritable:0},{pubkey:c,isSigner:0,isWritable:0},{pubkey:m,isSigner:0,isWritable:1},{pubkey:p,isSigner:0,isWritable:0},{pubkey:f,isSigner:0,isWritable:0},{pubkey:null!=g?g:e,isSigner:0,isWritable:1}]})({mint:s,feePayer:a,authority:u,cpiAuthorityPda:this.deriveCpiAuthorityPda,tokenProgram:m,tokenPoolPda:p,lightSystemProgram:t.LightSystemProgram.programId,registeredProgramPda:o.registeredProgramPda,noopProgram:o.noopProgram,accountCompressionAuthority:o.accountCompressionAuthority,accountCompressionProgram:o.accountCompressionProgram,merkleTree:null!=h?h:t.defaultTestStateTreeAccounts().merkleTree,selfProgram:this.programId,systemProgram:e.SystemProgram.programId,solPoolPda:null}),w=function(t,e){const r=n.Buffer.alloc(1e3),i=it.encode({recipients:t,amounts:e,lamports:null},r);return n.Buffer.concat([st,r.slice(0,i)])}(g,f);return new e.TransactionInstruction({programId:this.programId,keys:y,data:w})}static async approveAndMintTo(t){const{mint:e,feePayer:n,authorityTokenAccount:i,authority:o,merkleTree:s,toPubkey:a,tokenProgramId:u}=t,h=BigInt(t.amount.toString());return[r.createMintToInstruction(e,i,o,h,[],u),await this.compress({payer:n,owner:o,source:i,toAddress:a,mint:e,amount:t.amount,outputStateTree:s,tokenProgramId:u})]}static async transfer(r){const{payer:n,inputCompressedTokenAccounts:o,recentInputStateRootIndices:s,recentValidityProof:a,amount:u,outputStateTrees:h,toAddress:l}=r,d=pt(o,l,u),{inputTokenDataWithContext:c,packedOutputTokenData:m,remainingAccountMetas:p}=i({inputCompressedTokenAccounts:o,outputStateTrees:h,rootIndices:s,tokenTransferOutputs:d}),{mint:f,currentOwner:g}=mt(o),y=ht({proof:a,mint:f,delegatedTransfer:null,inputTokenDataWithContext:c,outputCompressedAccounts:m,compressOrDecompressAmount:null,isCompress:0,cpiContext:null,lamportsChangeAccountMerkleTreeIndex:null}),{accountCompressionAuthority:w,noopProgram:v,registeredProgramPda:M,accountCompressionProgram:b}=t.defaultStaticAccountsStruct(),k=lt({feePayer:n,authority:g,cpiAuthorityPda:this.deriveCpiAuthorityPda,lightSystemProgram:t.LightSystemProgram.programId,registeredProgramPda:M,noopProgram:v,accountCompressionAuthority:w,accountCompressionProgram:b,selfProgram:this.programId,tokenPoolPda:void 0,compressOrDecompressTokenAccount:void 0,tokenProgram:void 0,systemProgram:e.SystemProgram.programId});return k.push(...p),new e.TransactionInstruction({programId:this.programId,keys:k,data:y})}static async createTokenProgramLookupTable(n){const{authority:i,mints:o,recentSlot:s,payer:a,remainingAccounts:u}=n,[h,l]=e.AddressLookupTableProgram.createLookupTable({authority:i,payer:i,recentSlot:s});let d=[];return o&&(d=[...o,...o.map((t=>this.deriveTokenPoolPda(t)))]),{instructions:[h,e.AddressLookupTableProgram.extendLookupTable({payer:a,authority:i,lookupTable:l,addresses:[this.deriveCpiAuthorityPda,t.LightSystemProgram.programId,t.defaultStaticAccountsStruct().registeredProgramPda,t.defaultStaticAccountsStruct().noopProgram,t.defaultStaticAccountsStruct().accountCompressionAuthority,t.defaultStaticAccountsStruct().accountCompressionProgram,t.defaultTestStateTreeAccounts().merkleTree,t.defaultTestStateTreeAccounts().nullifierQueue,t.defaultTestStateTreeAccounts().addressTree,t.defaultTestStateTreeAccounts().addressQueue,this.programId,r.TOKEN_PROGRAM_ID,r.TOKEN_2022_PROGRAM_ID,i,...d,...null!=u?u:[]]})],address:l}}static async compress(n){const{payer:o,owner:s,source:a,toAddress:u,mint:h,outputStateTree:l,tokenProgramId:d}=n;if(Array.isArray(n.amount)!==Array.isArray(n.toAddress))throw new Error("Both amount and toAddress must be arrays or both must be single values");let c;if(Array.isArray(n.amount)&&Array.isArray(n.toAddress)){if(n.amount.length!==n.toAddress.length)throw new Error("Amount and toAddress arrays must have the same length");c=n.amount.map(((e,r)=>{const i=t.bn(e);return{owner:n.toAddress[r],amount:i,lamports:t.bn(0),tlv:null}}))}else c=[{owner:u,amount:t.bn(n.amount),lamports:t.bn(0),tlv:null}];const{inputTokenDataWithContext:p,packedOutputTokenData:f,remainingAccountMetas:g}=i({inputCompressedTokenAccounts:[],outputStateTrees:l,rootIndices:[],tokenTransferOutputs:c}),y=ht({proof:null,mint:h,delegatedTransfer:null,inputTokenDataWithContext:p,outputCompressedAccounts:f,compressOrDecompressAmount:Array.isArray(n.amount)?n.amount.map((t=>new m(t))).reduce(((t,e)=>t.add(e)),new m(0)):new m(n.amount),isCompress:1,cpiContext:null,lamportsChangeAccountMerkleTreeIndex:null}),w=null!=d?d:r.TOKEN_PROGRAM_ID,v=lt(Object.assign(Object.assign({},t.defaultStaticAccountsStruct()),{feePayer:o,authority:s,cpiAuthorityPda:this.deriveCpiAuthorityPda,lightSystemProgram:t.LightSystemProgram.programId,selfProgram:this.programId,systemProgram:e.SystemProgram.programId,tokenPoolPda:this.deriveTokenPoolPda(h),compressOrDecompressTokenAccount:a,tokenProgram:w}));return v.push(...g),new e.TransactionInstruction({programId:this.programId,keys:v,data:y})}static async decompress(n){const{payer:o,inputCompressedTokenAccounts:s,toAddress:a,outputStateTree:u,recentValidityProof:h,recentInputStateRootIndices:l,tokenProgramId:d}=n,c=t.bn(n.amount),m=ft(s,c),{inputTokenDataWithContext:p,packedOutputTokenData:f,remainingAccountMetas:g}=i({inputCompressedTokenAccounts:s,outputStateTrees:u,rootIndices:l,tokenTransferOutputs:m}),{mint:y,currentOwner:w}=mt(s),v=ht({proof:h,mint:y,delegatedTransfer:null,inputTokenDataWithContext:p,outputCompressedAccounts:f,compressOrDecompressAmount:c,isCompress:0,cpiContext:null,lamportsChangeAccountMerkleTreeIndex:null}),M=null!=d?d:r.TOKEN_PROGRAM_ID,{accountCompressionAuthority:b,noopProgram:k,registeredProgramPda:P,accountCompressionProgram:S}=t.defaultStaticAccountsStruct(),A=lt({feePayer:o,authority:w,cpiAuthorityPda:this.deriveCpiAuthorityPda,lightSystemProgram:t.LightSystemProgram.programId,registeredProgramPda:P,noopProgram:k,accountCompressionAuthority:b,accountCompressionProgram:S,selfProgram:this.programId,tokenPoolPda:this.deriveTokenPoolPda(y),compressOrDecompressTokenAccount:a,tokenProgram:M,systemProgram:e.SystemProgram.programId});return A.push(...g),new e.TransactionInstruction({programId:this.programId,keys:A,data:v})}static async mergeTokenAccounts(t){const{payer:e,owner:r,inputCompressedTokenAccounts:n,outputStateTree:i,recentValidityProof:o,recentInputStateRootIndices:s}=t;if(n.length>3)throw new Error("Cannot merge more than 3 token accounts at once");return[await this.transfer({payer:e,inputCompressedTokenAccounts:n,toAddress:r,amount:n.reduce(((t,e)=>t.add(e.parsed.amount)),new m(0)),outputStateTrees:i,recentInputStateRootIndices:s,recentValidityProof:o})]}static async compressSplTokenAccount(i){const{feePayer:o,authority:s,tokenAccount:a,mint:u,remainingAmount:h,outputStateTree:l,tokenProgramId:d}=i,c=null!=d?d:r.TOKEN_PROGRAM_ID,m=[{pubkey:l,isSigner:0,isWritable:1}],p=function(t,e){const r=n.Buffer.alloc(1e3),i=ot.encode({owner:t,remainingAmount:e,cpiContext:null},r);return n.Buffer.concat([ut,r.slice(0,i)])}(s,null!=h?h:null),{accountCompressionAuthority:f,noopProgram:g,registeredProgramPda:y,accountCompressionProgram:w}=t.defaultStaticAccountsStruct(),v=lt({feePayer:o,authority:s,cpiAuthorityPda:this.deriveCpiAuthorityPda,lightSystemProgram:t.LightSystemProgram.programId,registeredProgramPda:y,noopProgram:g,accountCompressionAuthority:f,accountCompressionProgram:w,selfProgram:this.programId,tokenPoolPda:this.deriveTokenPoolPda(u),compressOrDecompressTokenAccount:a,tokenProgram:c,systemProgram:e.SystemProgram.programId});return v.push(...m),new e.TransactionInstruction({programId:this.programId,keys:v,data:p})}static async get_mint_program_id(t,e){var r;return null===(r=await e.getAccountInfo(t))||void 0===r?void 0:r.owner}}function yt(e,r){let n=t.bn(0),i=t.bn(0);const o=[];e.sort(((t,e)=>e.parsed.amount.cmp(t.parsed.amount)));for(const s of e){if(n.gte(t.bn(r)))break;n=n.add(s.parsed.amount),i=i.add(s.compressedAccount.lamports),o.push(s)}if(n.lt(t.bn(r)))throw new Error(`Not enough balance for transfer. Required: ${r.toString()}, available: ${n.toString()}`);return[o,n,i.lt(t.bn(0))?i:null]}gt.programId=new e.PublicKey("cTokenmWW8bLPjZEBAUgYy3zKxQZW6VKi7bqNFEVv3m"),exports.CPI_AUTHORITY_SEED=s,exports.CompressedTokenProgram=gt,exports.POOL_SEED=o,exports.SPL_TOKEN_MINT_RENT_EXEMPT_BALANCE=1461600,exports.approveAndMintTo=async function(n,i,o,s,a,u,h,l,d){d=d||await gt.get_mint_program_id(o,n);const c=await r.getOrCreateAssociatedTokenAccount(n,i,o,a.publicKey,void 0,void 0,l,d),m=await gt.approveAndMintTo({feePayer:i.publicKey,mint:o,authority:a.publicKey,authorityTokenAccount:c.address,amount:u,toPubkey:s,merkleTree:h,tokenProgramId:d}),{blockhash:p}=await n.getLatestBlockhash(),f=t.dedupeSigner(i,[a]),g=t.buildAndSignTx([e.ComputeBudgetProgram.setComputeUnitLimit({units:1e6}),...m],i,p,f);return await t.sendAndConfirmTx(n,g,l)},exports.compress=async function(r,n,i,o,s,a,u,h,l,d){d=d||await gt.get_mint_program_id(i,r);const c=await gt.compress({payer:n.publicKey,owner:s.publicKey,source:a,toAddress:u,amount:o,mint:i,outputStateTree:h,tokenProgramId:d}),m=await r.getLatestBlockhash(),p=t.dedupeSigner(n,[s]),f=t.buildAndSignTx([e.ComputeBudgetProgram.setComputeUnitLimit({units:1e6}),c],n,m.blockhash,p);return await t.sendAndConfirmTx(r,f,l,m)},exports.compressSplTokenAccount=async function(r,n,i,o,s,a,u,h,l){l=l||await gt.get_mint_program_id(i,r);const d=await gt.compressSplTokenAccount({feePayer:n.publicKey,authority:o.publicKey,tokenAccount:s,mint:i,remainingAmount:u,outputStateTree:a,tokenProgramId:l}),c=await r.getLatestBlockhash(),m=t.dedupeSigner(n,[o]),p=t.buildAndSignTx([e.ComputeBudgetProgram.setComputeUnitLimit({units:1e6}),d],n,c.blockhash,m);return await t.sendAndConfirmTx(r,p,h,c)},exports.createDecompressOutputState=ft,exports.createMint=async function(n,i,o,s,a=e.Keypair.generate(),u,h=0){const l=await n.getMinimumBalanceForRentExemption(r.MINT_SIZE),d=h?r.TOKEN_2022_PROGRAM_ID:r.TOKEN_PROGRAM_ID,c=await gt.createMint({feePayer:i.publicKey,mint:a.publicKey,decimals:s,authority:o,freezeAuthority:null,rentExemptBalance:l,tokenProgramId:d}),{blockhash:m}=await n.getLatestBlockhash(),p=t.dedupeSigner(i,[a]),f=t.buildAndSignTx(c,i,m,p),g=await t.sendAndConfirmTx(n,f,u);return{mint:a.publicKey,transactionSignature:g}},exports.createTokenPool=async function(e,r,n,i,o){o=o||await gt.get_mint_program_id(n,e);const s=await gt.createTokenPool({feePayer:r.publicKey,mint:n,tokenProgramId:o}),{blockhash:a}=await e.getLatestBlockhash(),u=t.buildAndSignTx([s],r,a);return await t.sendAndConfirmTx(e,u,i)},exports.createTokenProgramLookupTable=async function(e,r,n,i,o){const s=await e.getSlot("finalized"),{instructions:a,address:u}=await gt.createTokenProgramLookupTable({payer:r.publicKey,authority:n.publicKey,mints:i,remainingAccounts:o,recentSlot:s}),h=t.dedupeSigner(r,[n]),l=await e.getLatestBlockhash(),d=t.buildAndSignTx([a[0]],r,l.blockhash,h),c=await t.sendAndConfirmTx(e,d,{commitment:"finalized"},l),m=await e.getLatestBlockhash(),p=t.buildAndSignTx([a[1]],r,m.blockhash,h);return{txIds:[c,await t.sendAndConfirmTx(e,p,{commitment:"finalized"},m)],address:u}},exports.createTransferOutputState=pt,exports.decompress=async function(r,n,i,o,s,a,u,h,l){l=l||await gt.get_mint_program_id(i,r),o=t.bn(o);const d=await r.getCompressedTokenAccountsByOwner(s.publicKey,{mint:i}),[c]=yt(d.items,o),m=await r.getValidityProof(c.map((e=>t.bn(e.compressedAccount.hash)))),p=await gt.decompress({payer:n.publicKey,inputCompressedTokenAccounts:c,toAddress:a,amount:o,outputStateTree:u,recentInputStateRootIndices:m.rootIndices,recentValidityProof:m.compressedProof,tokenProgramId:l}),{blockhash:f}=await r.getLatestBlockhash(),g=t.dedupeSigner(n,[s]),y=t.buildAndSignTx([e.ComputeBudgetProgram.setComputeUnitLimit({units:1e6}),p],n,f,g);return await t.sendAndConfirmTx(r,y,h)},exports.mergeTokenAccounts=async function(r,n,i,o,s,a){const u=await r.getCompressedTokenAccountsByOwner(o.publicKey,{mint:i});if(0===u.items.length)throw new Error(`No compressed token accounts found for mint ${i.toBase58()}`);if(u.items.length>=6)throw new Error(`Too many compressed token accounts used for mint ${i.toBase58()}`);const h=[e.ComputeBudgetProgram.setComputeUnitLimit({units:1e6})];for(let e=0;e<u.items.slice(0,6).length;e+=3){const a=u.items.slice(e,e+3),l=await r.getValidityProof(a.map((e=>t.bn(e.compressedAccount.hash)))),d=await gt.mergeTokenAccounts({payer:n.publicKey,owner:o.publicKey,mint:i,inputCompressedTokenAccounts:a,outputStateTree:s,recentValidityProof:l.compressedProof,recentInputStateRootIndices:l.rootIndices});h.push(...d)}const{blockhash:l}=await r.getLatestBlockhash(),d=t.dedupeSigner(n,[o]),c=t.buildAndSignTx(h,n,l,d);return await t.sendAndConfirmTx(r,c,a)},exports.mintTo=async function(r,n,i,o,s,a,u,h,l){l=l||await gt.get_mint_program_id(i,r);const d=t.dedupeSigner(n,[s]),c=await gt.mintTo({feePayer:n.publicKey,mint:i,authority:s.publicKey,amount:a,toPubkey:o,merkleTree:u,tokenProgramId:l}),{blockhash:m}=await r.getLatestBlockhash(),p=t.buildAndSignTx([e.ComputeBudgetProgram.setComputeUnitLimit({units:1e6}),c],n,m,d);return await t.sendAndConfirmTx(r,p,h)},exports.packCompressedTokenAccounts=i,exports.parseTokenData=mt,exports.selectMinCompressedTokenAccountsForTransfer=yt,exports.sumUpTokenAmount=dt,exports.transfer=async function(r,n,i,o,s,a,u,h){o=t.bn(o);const l=await r.getCompressedTokenAccountsByOwner(s.publicKey,{mint:i}),[d]=yt(l.items,o),c=await r.getValidityProof(d.map((e=>t.bn(e.compressedAccount.hash)))),m=await gt.transfer({payer:n.publicKey,inputCompressedTokenAccounts:d,toAddress:a,amount:o,recentInputStateRootIndices:c.rootIndices,recentValidityProof:c.compressedProof,outputStateTrees:u}),{blockhash:p}=await r.getLatestBlockhash(),f=t.dedupeSigner(n,[s]),g=t.buildAndSignTx([e.ComputeBudgetProgram.setComputeUnitLimit({units:1e6}),m],n,p,f);return await t.sendAndConfirmTx(r,g,h)},exports.validateSameTokenOwner=ct;
 //# sourceMappingURL=index.cjs.map