@lightprotocol/stateless.js 0.17.2-alpha.1 → 0.18.0

package/dist/cjs/browser/idl.d.ts

@@ -0,0 +1,1015 @@
+export type LightSystemProgram = {
+    version: '1.2.0';
+    name: 'light_system_program';
+    constants: [
+        {
+            name: 'SOL_POOL_PDA_SEED';
+            type: 'bytes';
+            value: '[115, 111, 108, 95, 112, 111, 111, 108, 95, 112, 100, 97]';
+        }
+    ];
+    instructions: [
+        {
+            name: 'initCpiContextAccount';
+            accounts: [
+                {
+                    name: 'feePayer';
+                    isMut: true;
+                    isSigner: true;
+                },
+                {
+                    name: 'cpiContextAccount';
+                    isMut: true;
+                    isSigner: false;
+                },
+                {
+                    name: 'associatedMerkleTree';
+                    isMut: false;
+                    isSigner: false;
+                }
+            ];
+            args: [];
+        },
+        {
+            name: 'invoke';
+            accounts: [
+                {
+                    name: 'feePayer';
+                    isMut: true;
+                    isSigner: true;
+                    docs: [
+                        'Fee payer needs to be mutable to pay rollover and protocol fees.'
+                    ];
+                },
+                {
+                    name: 'authority';
+                    isMut: false;
+                    isSigner: true;
+                },
+                {
+                    name: 'registeredProgramPda';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'noopProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'accountCompressionAuthority';
+                    isMut: false;
+                    isSigner: false;
+                    docs: [
+                        'This pda is used to invoke the account compression program.'
+                    ];
+                },
+                {
+                    name: 'accountCompressionProgram';
+                    isMut: false;
+                    isSigner: false;
+                    docs: ['Merkle trees.'];
+                },
+                {
+                    name: 'solPoolPda';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                    docs: [
+                        'Sol pool pda is used to store the native sol that has been compressed.',
+                        "It's only required when compressing or decompressing sol."
+                    ];
+                },
+                {
+                    name: 'decompressionRecipient';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                    docs: [
+                        'Only needs to be provided for decompression as a recipient for the',
+                        'decompressed sol.',
+                        'Compressed sol originate from authority.'
+                    ];
+                },
+                {
+                    name: 'systemProgram';
+                    isMut: false;
+                    isSigner: false;
+                }
+            ];
+            args: [
+                {
+                    name: 'inputs';
+                    type: 'bytes';
+                }
+            ];
+        },
+        {
+            name: 'invokeCpi';
+            accounts: [
+                {
+                    name: 'feePayer';
+                    isMut: true;
+                    isSigner: true;
+                    docs: [
+                        'Fee payer needs to be mutable to pay rollover and protocol fees.'
+                    ];
+                },
+                {
+                    name: 'authority';
+                    isMut: false;
+                    isSigner: true;
+                },
+                {
+                    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: 'invokingProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'solPoolPda';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                },
+                {
+                    name: 'decompressionRecipient';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                },
+                {
+                    name: 'systemProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'cpiContextAccount';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                }
+            ];
+            args: [
+                {
+                    name: 'inputs';
+                    type: 'bytes';
+                }
+            ];
+        },
+        {
+            name: 'invokeCpiWithReadOnly';
+            accounts: [
+                {
+                    name: 'feePayer';
+                    isMut: true;
+                    isSigner: true;
+                    docs: [
+                        'Fee payer needs to be mutable to pay rollover and protocol fees.'
+                    ];
+                },
+                {
+                    name: 'authority';
+                    isMut: false;
+                    isSigner: true;
+                },
+                {
+                    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: 'invokingProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'solPoolPda';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                },
+                {
+                    name: 'decompressionRecipient';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                },
+                {
+                    name: 'systemProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'cpiContextAccount';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                }
+            ];
+            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: [
+                        'Fee payer needs to be mutable to pay rollover and protocol fees.'
+                    ];
+                },
+                {
+                    name: 'authority';
+                    isMut: false;
+                    isSigner: true;
+                },
+                {
+                    name: 'registeredProgramPda';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'noopProgram';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'accountCompressionAuthority';
+                    isMut: false;
+                    isSigner: false;
+                    docs: [
+                        'This pda is used to invoke the account compression program.'
+                    ];
+                },
+                {
+                    name: 'accountCompressionProgram';
+                    isMut: false;
+                    isSigner: false;
+                    docs: ['Merkle trees.'];
+                },
+                {
+                    name: 'solPoolPda';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                    docs: [
+                        'Sol pool pda is used to store the native sol that has been compressed.',
+                        "It's only required when compressing or decompressing sol."
+                    ];
+                },
+                {
+                    name: 'decompressionRecipient';
+                    isMut: true;
+                    isSigner: false;
+                    isOptional: true;
+                    docs: [
+                        'Only needs to be provided for decompression as a recipient for the',
+                        'decompressed sol.',
+                        'Compressed sol originate from authority.'
+                    ];
+                },
+                {
+                    name: 'systemProgram';
+                    isMut: false;
+                    isSigner: false;
+                }
+            ];
+            args: [
+                {
+                    name: 'inputs1';
+                    type: {
+                        defined: 'InstructionDataInvoke';
+                    };
+                },
+                {
+                    name: 'inputs2';
+                    type: {
+                        defined: 'InstructionDataInvokeCpi';
+                    };
+                },
+                {
+                    name: 'inputs3';
+                    type: {
+                        defined: 'PublicTransactionEvent';
+                    };
+                }
+            ];
+        }
+    ];
+    accounts: [
+        {
+            name: 'cpiContextAccount';
+            docs: [
+                'Collects instruction data without executing a compressed transaction.',
+                'Signer checks are performed on instruction data.',
+                'Collected instruction data is combined with the instruction data of the executing cpi,',
+                'and executed as a single transaction.',
+                'This enables to use input compressed accounts that are owned by multiple programs,',
+                'with one zero-knowledge proof.'
+            ];
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'feePayer';
+                        type: 'publicKey';
+                    },
+                    {
+                        name: 'associatedMerkleTree';
+                        type: 'publicKey';
+                    },
+                    {
+                        name: 'context';
+                        type: {
+                            vec: {
+                                defined: 'InstructionDataInvokeCpi';
+                            };
+                        };
+                    }
+                ];
+            };
+        }
+    ];
+    types: [
+        {
+            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: '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: 'CompressedProof';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'a';
+                        type: {
+                            array: ['u8', 32];
+                        };
+                    },
+                    {
+                        name: 'b';
+                        type: {
+                            array: ['u8', 64];
+                        };
+                    },
+                    {
+                        name: 'c';
+                        type: {
+                            array: ['u8', 32];
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            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: '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: '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: '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';
+                        type: {
+                            option: {
+                                defined: 'QueueIndex';
+                            };
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            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: 'MerkleTreeSequenceNumber';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'pubkey';
+                        type: 'publicKey';
+                    },
+                    {
+                        name: 'seq';
+                        type: 'u64';
+                    }
+                ];
+            };
+        },
+        {
+            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';
+                        };
+                    }
+                ];
+            };
+        }
+    ];
+    errors: [
+        {
+            code: 6000;
+            name: 'SumCheckFailed';
+            msg: 'Sum check failed';
+        },
+        {
+            code: 6001;
+            name: 'SignerCheckFailed';
+            msg: 'Signer check failed';
+        },
+        {
+            code: 6002;
+            name: 'CpiSignerCheckFailed';
+            msg: 'Cpi signer check failed';
+        },
+        {
+            code: 6003;
+            name: 'ComputeInputSumFailed';
+            msg: 'Computing input sum failed.';
+        },
+        {
+            code: 6004;
+            name: 'ComputeOutputSumFailed';
+            msg: 'Computing output sum failed.';
+        },
+        {
+            code: 6005;
+            name: 'ComputeRpcSumFailed';
+            msg: 'Computing rpc sum failed.';
+        },
+        {
+            code: 6006;
+            name: 'InvalidAddress';
+            msg: 'InvalidAddress';
+        },
+        {
+            code: 6007;
+            name: 'DeriveAddressError';
+            msg: 'DeriveAddressError';
+        },
+        {
+            code: 6008;
+            name: 'CompressedSolPdaUndefinedForCompressSol';
+            msg: 'CompressedSolPdaUndefinedForCompressSol';
+        },
+        {
+            code: 6009;
+            name: 'DeCompressLamportsUndefinedForCompressSol';
+            msg: 'DeCompressLamportsUndefinedForCompressSol';
+        },
+        {
+            code: 6010;
+            name: 'CompressedSolPdaUndefinedForDecompressSol';
+            msg: 'CompressedSolPdaUndefinedForDecompressSol';
+        },
+        {
+            code: 6011;
+            name: 'DeCompressLamportsUndefinedForDecompressSol';
+            msg: 'DeCompressLamportsUndefinedForDecompressSol';
+        },
+        {
+            code: 6012;
+            name: 'DecompressRecipientUndefinedForDecompressSol';
+            msg: 'DecompressRecipientUndefinedForDecompressSol';
+        },
+        {
+            code: 6013;
+            name: 'WriteAccessCheckFailed';
+            msg: 'WriteAccessCheckFailed';
+        },
+        {
+            code: 6014;
+            name: 'InvokingProgramNotProvided';
+            msg: 'InvokingProgramNotProvided';
+        },
+        {
+            code: 6015;
+            name: 'InvalidCapacity';
+            msg: 'InvalidCapacity';
+        },
+        {
+            code: 6016;
+            name: 'InvalidMerkleTreeOwner';
+            msg: 'InvalidMerkleTreeOwner';
+        },
+        {
+            code: 6017;
+            name: 'ProofIsNone';
+            msg: 'ProofIsNone';
+        },
+        {
+            code: 6018;
+            name: 'ProofIsSome';
+            msg: 'Proof is some but no input compressed accounts or new addresses provided.';
+        },
+        {
+            code: 6019;
+            name: 'EmptyInputs';
+            msg: 'EmptyInputs';
+        },
+        {
+            code: 6020;
+            name: 'CpiContextAccountUndefined';
+            msg: 'CpiContextAccountUndefined';
+        },
+        {
+            code: 6021;
+            name: 'CpiContextEmpty';
+            msg: 'CpiContextEmpty';
+        },
+        {
+            code: 6022;
+            name: 'CpiContextMissing';
+            msg: 'CpiContextMissing';
+        },
+        {
+            code: 6023;
+            name: 'DecompressionRecipientDefined';
+            msg: 'DecompressionRecipientDefined';
+        },
+        {
+            code: 6024;
+            name: 'SolPoolPdaDefined';
+            msg: 'SolPoolPdaDefined';
+        },
+        {
+            code: 6025;
+            name: 'AppendStateFailed';
+            msg: 'AppendStateFailed';
+        },
+        {
+            code: 6026;
+            name: 'InstructionNotCallable';
+            msg: 'The instruction is not callable';
+        },
+        {
+            code: 6027;
+            name: 'CpiContextFeePayerMismatch';
+            msg: 'CpiContextFeePayerMismatch';
+        },
+        {
+            code: 6028;
+            name: 'CpiContextAssociatedMerkleTreeMismatch';
+            msg: 'CpiContextAssociatedMerkleTreeMismatch';
+        },
+        {
+            code: 6029;
+            name: 'NoInputs';
+            msg: 'NoInputs';
+        },
+        {
+            code: 6030;
+            name: 'InputMerkleTreeIndicesNotInOrder';
+            msg: 'Input merkle tree indices are not in ascending order.';
+        },
+        {
+            code: 6031;
+            name: 'OutputMerkleTreeIndicesNotInOrder';
+            msg: 'Output merkle tree indices are not in ascending order.';
+        },
+        {
+            code: 6032;
+            name: 'OutputMerkleTreeNotUnique';
+        },
+        {
+            code: 6033;
+            name: 'DataFieldUndefined';
+        },
+        {
+            code: 6034;
+            name: 'ReadOnlyAddressAlreadyExists';
+        },
+        {
+            code: 6035;
+            name: 'ReadOnlyAccountDoesNotExist';
+        },
+        {
+            code: 6036;
+            name: 'HashChainInputsLenghtInconsistent';
+        },
+        {
+            code: 6037;
+            name: 'InvalidAddressTreeHeight';
+        }
+    ];
+};
+export declare const IDL: LightSystemProgram;