import { R1CS } from 'crypto-wasm-new'; import { BBSPlusPublicKeyG2, BBSPlusSignatureParamsG1 } from '../bbs-plus'; import { SaverChunkedCommitmentKey, SaverChunkedCommitmentKeyUncompressed, SaverEncryptionGens, SaverEncryptionGensUncompressed, SaverEncryptionKey, SaverEncryptionKeyUncompressed, SaverProvingKey, SaverProvingKeyUncompressed, SaverVerifyingKey, SaverVerifyingKeyUncompressed } from '../saver'; import { LegoProvingKey, LegoVerifyingKey, LegoProvingKeyUncompressed, LegoVerifyingKeyUncompressed } from '../legosnark'; import { AccumulatorParams, AccumulatorPublicKey, AccumulatorSecretKey, MembershipProvingKey, NonMembershipProvingKey } from '../accumulator'; import { AttributeBoundPseudonym, Pseudonym } from '../Pseudonym'; import { BBSSignatureParams } from '../bbs'; import { PSPublicKey, PSSignatureParams } from '../ps'; import { ParsedR1CSFile } from '../r1cs/file'; import { BoundCheckBppParams, BoundCheckBppParamsUncompressed, BoundCheckSmcParams, BoundCheckSmcParamsUncompressed, BoundCheckSmcWithKVProverParams, BoundCheckSmcWithKVProverParamsUncompressed, BoundCheckSmcWithKVVerifierParams, BoundCheckSmcWithKVVerifierParamsUncompressed } from '../bound-check'; import { PederCommKey, PederCommKeyUncompressed } from '../ped-com'; import { BBDT16MacParams, BBDT16MacSecretKey } from '../bbdt16-mac'; /** * Relation which needs to be proven. Contains any public data that needs to be known to both prover and verifier */ export declare class Statement { /** * Create statement for proving knowledge of opening of Pedersen commitment with commitment key and commitment in G1 * @param commitmentKey - commitment key used to create the commitment * @param commitment */ static pedersenCommitmentG1(commitmentKey: Uint8Array[], commitment: Uint8Array): Uint8Array; /** * Same as `Statement.pedersenCommitmentG1` but does not take the commitment key directly but a reference to it * @param commitmentKeyRef * @param commitment */ static pedersenCommitmentG1FromSetupParamRef(commitmentKeyRef: number, commitment: Uint8Array): Uint8Array; /** * Create statement for proving knowledge of BBS signature * @param sigParams * @param revealedMessages * @param encodeMessages */ static bbsSignatureProver(sigParams: BBSSignatureParams, revealedMessages: Map, encodeMessages: boolean): Uint8Array; /** * Create statement for proving knowledge of BBS signature * @param sigParams * @param revealedMessages * @param encodeMessages */ static bbsSignatureProverConstantTime(sigParams: BBSSignatureParams, revealedMessages: Map, encodeMessages: boolean): Uint8Array; /** * Create statement for verifying knowledge of BBS signature * @param sigParams * @param publicKey * @param revealedMessages * @param encodeMessages */ static bbsSignatureVerifier(sigParams: BBSSignatureParams, publicKey: BBSPlusPublicKeyG2, revealedMessages: Map, encodeMessages: boolean): Uint8Array; /** * Create statement for verifying knowledge of BBS signature * @param sigParams * @param publicKey * @param revealedMessages * @param encodeMessages */ static bbsSignatureVerifierConstantTime(sigParams: BBSSignatureParams, publicKey: BBSPlusPublicKeyG2, revealedMessages: Map, encodeMessages: boolean): Uint8Array; /** * Create statement for proving knowledge of BBS+ signature * @param sigParams * @param revealedMessages * @param encodeMessages */ static bbsPlusSignatureProver(sigParams: BBSPlusSignatureParamsG1, revealedMessages: Map, encodeMessages: boolean): Uint8Array; /** * Create statement for proving knowledge of BBS+ signature * @param sigParams * @param revealedMessages * @param encodeMessages */ static bbsPlusSignatureProverConstantTime(sigParams: BBSPlusSignatureParamsG1, revealedMessages: Map, encodeMessages: boolean): Uint8Array; /** * Create statement for verifying knowledge of BBS+ signature * @param sigParams * @param publicKey * @param revealedMessages * @param encodeMessages */ static bbsPlusSignatureVerifier(sigParams: BBSPlusSignatureParamsG1, publicKey: BBSPlusPublicKeyG2, revealedMessages: Map, encodeMessages: boolean): Uint8Array; /** * Create statement for verifying knowledge of BBS+ signature * @param sigParams * @param publicKey * @param revealedMessages * @param encodeMessages */ static bbsPlusSignatureVerifierConstantTime(sigParams: BBSPlusSignatureParamsG1, publicKey: BBSPlusPublicKeyG2, revealedMessages: Map, encodeMessages: boolean): Uint8Array; /** * Create statement for proving knowledge of Pointcheval-Sanders signature * @param sigParams * @param publicKey * @param revealedMessages */ static psSignature(sigParams: PSSignatureParams, publicKey: PSPublicKey, revealedMessages: Map): Uint8Array; /** * Create statement for proving knowledge of Pointcheval-Sanders signature * @param sigParams * @param publicKey * @param revealedMessages */ static psSignatureConstantTime(sigParams: PSSignatureParams, publicKey: PSPublicKey, revealedMessages: Map): Uint8Array; /** * Same as `Statement.bbsSignatureProver` but does not take the parameters directly but a reference to them as indices in the * array of `SetupParam` * @param sigParamsRef * @param revealedMessages * @param encodeMessages */ static bbsSignatureProverFromSetupParamRefs(sigParamsRef: number, revealedMessages: Map, encodeMessages: boolean): Uint8Array; /** * Same as `Statement.bbsSignatureProver` but does not take the parameters directly but a reference to them as indices in the * array of `SetupParam` * @param sigParamsRef * @param revealedMessages * @param encodeMessages */ static bbsSignatureProverFromSetupParamRefsConstantTime(sigParamsRef: number, revealedMessages: Map, encodeMessages: boolean): Uint8Array; /** * Same as `Statement.bbsSignatureVerifier` but does not take the parameters directly but a reference to them as indices in the * array of `SetupParam` * @param sigParamsRef * @param publicKeyRef * @param revealedMessages * @param encodeMessages */ static bbsSignatureVerifierFromSetupParamRefs(sigParamsRef: number, publicKeyRef: number, revealedMessages: Map, encodeMessages: boolean): Uint8Array; /** * Same as `Statement.bbsSignatureVerifier` but does not take the parameters directly but a reference to them as indices in the * array of `SetupParam` * @param sigParamsRef * @param publicKeyRef * @param revealedMessages * @param encodeMessages */ static bbsSignatureVerifierFromSetupParamRefsConstantTime(sigParamsRef: number, publicKeyRef: number, revealedMessages: Map, encodeMessages: boolean): Uint8Array; /** * Same as `Statement.bbsPlusSignatureProver` but does not take the parameters directly but a reference to them as indices in the * array of `SetupParam` * @param sigParamsRef * @param revealedMessages * @param encodeMessages */ static bbsPlusSignatureProverFromSetupParamRefs(sigParamsRef: number, revealedMessages: Map, encodeMessages: boolean): Uint8Array; /** * Same as `Statement.bbsPlusSignatureProver` but does not take the parameters directly but a reference to them as indices in the * array of `SetupParam` * @param sigParamsRef * @param revealedMessages * @param encodeMessages */ static bbsPlusSignatureProverFromSetupParamRefsConstantTime(sigParamsRef: number, revealedMessages: Map, encodeMessages: boolean): Uint8Array; /** * Same as `Statement.bbsPlusSignatureVerifier` but does not take the parameters directly but a reference to them as indices in the * array of `SetupParam` * @param sigParamsRef * @param publicKeyRef * @param revealedMessages * @param encodeMessages */ static bbsPlusSignatureVerifierFromSetupParamRefs(sigParamsRef: number, publicKeyRef: number, revealedMessages: Map, encodeMessages: boolean): Uint8Array; /** * Same as `Statement.bbsPlusSignatureVerifier` but does not take the parameters directly but a reference to them as indices in the * array of `SetupParam` * @param sigParamsRef * @param publicKeyRef * @param revealedMessages * @param encodeMessages */ static bbsPlusSignatureVerifierFromSetupParamRefsConstantTime(sigParamsRef: number, publicKeyRef: number, revealedMessages: Map, encodeMessages: boolean): Uint8Array; static bbdt16Mac(macParams: BBDT16MacParams, revealedMessages: Map, encodeMessages: boolean): Uint8Array; static bbdt16MacConstantTime(macParams: BBDT16MacParams, revealedMessages: Map, encodeMessages: boolean): Uint8Array; static bbdt16MacFullVerifier(macParams: BBDT16MacParams, secretKey: BBDT16MacSecretKey, revealedMessages: Map, encodeMessages: boolean): Uint8Array; static bbdt16MacFullVerifierConstantTime(macParams: BBDT16MacParams, secretKey: BBDT16MacSecretKey, revealedMessages: Map, encodeMessages: boolean): Uint8Array; static bbdt16MacFromSetupParamRefs(macParamsRef: number, revealedMessages: Map, encodeMessages: boolean): Uint8Array; static bbdt16MacFromSetupParamRefsConstantTime(macParamsRef: number, revealedMessages: Map, encodeMessages: boolean): Uint8Array; static bbdt16MacFullVerifierFromSetupParamRefs(macParamsRef: number, secretKey: BBDT16MacSecretKey, revealedMessages: Map, encodeMessages: boolean): Uint8Array; static bbdt16MacFullVerifierFromSetupParamRefsConstantTime(macParamsRef: number, secretKey: BBDT16MacSecretKey, revealedMessages: Map, encodeMessages: boolean): Uint8Array; /** * Same as `Statement.psSignature` but does not take the parameters directly but a reference to them as indices in the * array of `SetupParam` * @param sigParamsRef * @param publicKeyRef * @param revealedMessages */ static psSignatureFromSetupParamRefs(sigParamsRef: number, publicKeyRef: number, revealedMessages: Map): Uint8Array; /** * Same as `Statement.psSignature` but does not take the parameters directly but a reference to them as indices in the * array of `SetupParam` * @param sigParamsRef * @param publicKeyRef * @param revealedMessages */ static psSignatureFromSetupParamRefsConstantTime(sigParamsRef: number, publicKeyRef: number, revealedMessages: Map): Uint8Array; /** * Create statement for proving knowledge of VB accumulator membership * @param params * @param publicKey * @param provingKey * @param accumulated */ static vbAccumulatorMembership(params: AccumulatorParams, publicKey: AccumulatorPublicKey, provingKey: MembershipProvingKey, accumulated: Uint8Array): Uint8Array; /** * Same as `Statement.vbAccumulatorMembership` but does not take the parameters directly but a reference to them as indices in the * array of `SetupParam` * @param params * @param publicKey * @param provingKey * @param accumulated */ static vbAccumulatorMembershipFromSetupParamRefs(params: number, publicKey: number, provingKey: number, accumulated: Uint8Array): Uint8Array; /** * Create statement for proving knowledge of VB accumulator non-membership * @param params * @param publicKey * @param provingKey * @param accumulated */ static vbAccumulatorNonMembership(params: AccumulatorParams, publicKey: AccumulatorPublicKey, provingKey: NonMembershipProvingKey, accumulated: Uint8Array): Uint8Array; /** * Same as `Statement.vbAccumulatorNonMembership` but does not take the parameters directly but a reference to them as indices in the * array of `SetupParam` * @param params * @param publicKey * @param provingKey * @param accumulated */ static vbAccumulatorNonMembershipFromSetupParamRefs(params: number, publicKey: number, provingKey: number, accumulated: Uint8Array): Uint8Array; static vbAccumulatorMembershipKV(accumulated: Uint8Array): Uint8Array; static vbAccumulatorMembershipKVFullVerifier(secretKey: AccumulatorSecretKey, accumulated: Uint8Array): Uint8Array; /** * Create statement for proving knowledge of KB universal accumulator membership * @param accumulated */ static kbUniAccumulatorMembershipProver(accumulated: Uint8Array): Uint8Array; /** * Create statement for verifying knowledge of KB universal accumulator membership * @param params * @param publicKey * @param accumulated */ static kbUniAccumulatorMembershipVerifier(params: AccumulatorParams, publicKey: AccumulatorPublicKey, accumulated: Uint8Array): Uint8Array; /** * Same as `Statement.kbUniAccumulatorMembershipVerifier` but does not take the parameters directly but a reference to them as indices in the * array of `SetupParam` * @param params * @param publicKey * @param accumulated */ static kbUniAccumulatorMembershipVerifierFromSetupParamRefs(params: number, publicKey: number, accumulated: Uint8Array): Uint8Array; /** * Create statement for proving knowledge of ΒΈ non-membership * @param accumulated */ static kbUniAccumulatorNonMembershipProver(accumulated: Uint8Array): Uint8Array; /** * Create statement for verifying knowledge of KB universal accumulator non-membership * @param params * @param publicKey * @param accumulated */ static kbUniAccumulatorNonMembershipVerifier(params: AccumulatorParams, publicKey: AccumulatorPublicKey, accumulated: Uint8Array): Uint8Array; /** * Same as `Statement.kbUniAccumulatorNonMembershipVerifier` but does not take the parameters directly but a reference to them as indices in the * array of `SetupParam` * @param params * @param publicKey * @param accumulated */ static kbUniAccumulatorNonMembershipVerifierFromSetupParamRefs(params: number, publicKey: number, accumulated: Uint8Array): Uint8Array; static kbUniAccumulatorMembershipKV(accumulated: Uint8Array): Uint8Array; static kbUniAccumulatorMembershipKVFullVerifier(secretKey: AccumulatorSecretKey, accumulated: Uint8Array): Uint8Array; static kbUniAccumulatorNonMembershipKV(accumulated: Uint8Array): Uint8Array; static kbUniAccumulatorNonMembershipKVFullVerifier(secretKey: AccumulatorSecretKey, accumulated: Uint8Array): Uint8Array; /** * Create statement for verifiable encryption of a message using SAVER, for the prover. Accepts the parameters in uncompressed form. * @param encGens * @param commKey * @param encryptionKey * @param snarkPk * @param chunkBitSize - Must be same as the one used by the decryptor to create the parameters. */ static saverProver(encGens: SaverEncryptionGensUncompressed, commKey: SaverChunkedCommitmentKeyUncompressed, encryptionKey: SaverEncryptionKeyUncompressed, snarkPk: SaverProvingKeyUncompressed, chunkBitSize: number): Uint8Array; /** * Same as `Statement.saverProver` except that it takes compressed parameters. * @param encGens * @param commKey * @param encryptionKey * @param snarkPk * @param chunkBitSize - Must be same as the one used by the decryptor to create the parameters. */ static saverProverFromCompressedParams(encGens: SaverEncryptionGens, commKey: SaverChunkedCommitmentKey, encryptionKey: SaverEncryptionKey, snarkPk: SaverProvingKey, chunkBitSize: number): Uint8Array; /** * Same as `Statement.saverProver` but does not take the parameters directly but a reference to them as indices in the * array of `SetupParam` * @param encGensRef * @param commKeyRef * @param encryptionKeyRef * @param snarkPkRef * @param chunkBitSize - Must be same as the one used by the decryptor to create the parameters. */ static saverProverFromSetupParamRefs(encGensRef: number, commKeyRef: number, encryptionKeyRef: number, snarkPkRef: number, chunkBitSize: number): Uint8Array; /** * Create statement for verifiable encryption of a message using SAVER, for the verifier. Accepts the parameters in uncompressed form. * @param encGens * @param commKey * @param encryptionKey * @param snarkVk * @param chunkBitSize - Must be same as the one used by the decryptor to create the parameters */ static saverVerifier(encGens: SaverEncryptionGensUncompressed, commKey: SaverChunkedCommitmentKeyUncompressed, encryptionKey: SaverEncryptionKeyUncompressed, snarkVk: SaverVerifyingKeyUncompressed, chunkBitSize: number): Uint8Array; /** * Same as `Statement.saverVerifier` except that it takes compressed parameters. * @param encGens * @param commKey * @param encryptionKey * @param snarkVk * @param chunkBitSize - Must be same as the one used by the decryptor to create the parameters. */ static saverVerifierFromCompressedParams(encGens: SaverEncryptionGens, commKey: SaverChunkedCommitmentKey, encryptionKey: SaverEncryptionKey, snarkVk: SaverVerifyingKey, chunkBitSize: number): Uint8Array; /** * Same as `Statement.saverVerifier` but does not take the parameters directly but a reference to them as indices in the * array of `SetupParam` * @param encGensRef * @param commGensKey * @param encryptionKeyRef * @param snarkVkRef * @param chunkBitSize */ static saverVerifierFromSetupParamRefs(encGensRef: number, commGensKey: number, encryptionKeyRef: number, snarkVkRef: number, chunkBitSize: number): Uint8Array; /** * Create statement for proving bounds [min, max) of a message using LegoGroth16, for the prover. * @param min - Inclusive lower bound on the message, must be a positive integer. * @param max - Exclusive upper bound on the message, must be a positive integer. * @param snarkPk - Proving key for LegoGroth16 */ static boundCheckLegoProver(min: number, max: number, snarkPk: LegoProvingKeyUncompressed): Uint8Array; /** * Same as `Statement.boundCheckLegoProver` except that it takes compressed parameters. * @param min - Inclusive lower bound on the message. * @param max - Exclusive upper bound on the message. * @param snarkPk - Proving key for LegoGroth16 */ static boundCheckLegoProverFromCompressedParams(min: number, max: number, snarkPk: LegoProvingKey): Uint8Array; /** * Same as `Statement.boundCheckLegoProver` but does not take the parameters directly but a reference to them as indices in the * array of `SetupParam` * @param min - Inclusive lower bound on the message. * @param max - Exclusive upper bound on the message. * @param snarkPkRef - Index of proving key in array of `SetupParam` */ static boundCheckLegoProverFromSetupParamRefs(min: number, max: number, snarkPkRef: number): Uint8Array; /** * Create statement for verifying bounds [min, max) of a message using LegoGroth16, for the verifier. * @param min - Inclusive lower bound on the message, must be a positive integer. * @param max - Exclusive upper bound on the message, must be a positive integer. * @param snarkVk - Verifying key for LegoGroth16 */ static boundCheckLegoVerifier(min: number, max: number, snarkVk: LegoVerifyingKeyUncompressed): Uint8Array; /** * Same as `Statement.boundCheckLegoVerifier` except that it takes compressed parameters. * @param min - Inclusive lower bound on the message. * @param max - Exclusive upper bound on the message. * @param snarkVk - Verifying key for LegoGroth16 */ static boundCheckLegoVerifierFromCompressedParams(min: number, max: number, snarkVk: LegoVerifyingKey): Uint8Array; /** * Same as `Statement.boundCheckLegoVerifier` but does not take the parameters directly but a reference to them as indices in the * array of `SetupParam` * @param min - Inclusive lower bound on the message. * @param max - Exclusive upper bound on the message. * @param snarkVkRef - Index of verifying key in array of `SetupParam` */ static boundCheckLegoVerifierFromSetupParamRefs(min: number, max: number, snarkVkRef: number): Uint8Array; /** * Statement for proving knowledge of secret key behind pseudonym * @param pseudonym * @param base */ static pseudonym(pseudonym: Pseudonym, base: Uint8Array): Uint8Array; static pseudonymVerifier(pseudonym: Uint8Array, base: Uint8Array): Uint8Array; /** * Statement for proving knowledge of secret key and attributes behind pseudonym * @param pseudonym * @param basesForAttributes * @param baseForSecretKey */ static attributeBoundPseudonym(pseudonym: AttributeBoundPseudonym, basesForAttributes: Uint8Array[], baseForSecretKey?: Uint8Array): Uint8Array; static attributeBoundPseudonymVerifier(pseudonym: Uint8Array, basesForAttributes: Uint8Array[], baseForSecretKey?: Uint8Array): Uint8Array; static r1csCircomProver(r1cs: R1CS | ParsedR1CSFile, wasmBytes: Uint8Array, snarkPk: LegoProvingKeyUncompressed): Uint8Array; static r1csCircomProverFromCompressedParams(r1cs: R1CS | ParsedR1CSFile, wasmBytes: Uint8Array, snarkPk: LegoProvingKey): Uint8Array; static r1csCircomProverFromSetupParamRefs(processedR1cs: number, wasmBytes: number, snarkPkRef: number): Uint8Array; static r1csCircomVerifier(publicInputs: Uint8Array[], snarkVk: LegoVerifyingKeyUncompressed): Uint8Array; static r1csCircomVerifierFromCompressedParams(publicInputs: Uint8Array[], snarkVk: LegoVerifyingKey): Uint8Array; static r1csCircomVerifierFromSetupParamRefs(publicInputsRef: number, snarkVkRef: number): Uint8Array; /** * Create statement for proving bounds of a message using Bulletproofs++. * @param min - Inclusive lower bound on the message, must be a positive integer. * @param max - Exclusive upper bound on the message, must be a positive integer. * @param params - Setup params for Bulletproofs++ */ static boundCheckBpp(min: number, max: number, params: BoundCheckBppParamsUncompressed): Uint8Array; /** * Same as `Statement.boundCheckBpp` except that it takes compressed parameters. * @param min - Inclusive lower bound on the message. * @param max - Exclusive upper bound on the message. * @param params - Setup params for Bulletproofs++ */ static boundCheckBppFromCompressedParams(min: number, max: number, params: BoundCheckBppParams): Uint8Array; /** * Same as `Statement.boundCheckBpp` but does not take the parameters directly but a reference to them as indices in the * array of `SetupParam` * @param min - Inclusive lower bound on the message. * @param max - Exclusive upper bound on the message. * @param params - Index of setup params in array of `SetupParam` */ static boundCheckBppFromSetupParamRefs(min: number, max: number, params: number): Uint8Array; /** * Create statement for proving bounds of a message using set-membership check based range proof. * @param min - Inclusive lower bound on the message, must be a positive integer. * @param max - Exclusive upper bound on the message, must be a positive integer. * @param params - Setup params for Bulletproofs++ */ static boundCheckSmc(min: number, max: number, params: BoundCheckSmcParamsUncompressed): Uint8Array; /** * Same as `Statement.boundCheckSmc` except that it takes compressed parameters. * @param min - Inclusive lower bound on the message. * @param max - Exclusive upper bound on the message. * @param params - Setup params for Bulletproofs++ */ static boundCheckSmcFromCompressedParams(min: number, max: number, params: BoundCheckSmcParams): Uint8Array; /** * Same as `Statement.boundCheckSmc` but does not take the parameters directly but a reference to them as indices in the * array of `SetupParam` * @param min - Inclusive lower bound on the message. * @param max - Exclusive upper bound on the message. * @param params - Index of setup params in array of `SetupParam` */ static boundCheckSmcFromSetupParamRefs(min: number, max: number, params: number): Uint8Array; /** * Create statement for proving bounds [min, max) of a message using set-membership check based range proof and keyed verification, for the prover. * @param min - Inclusive lower bound on the message, must be a positive integer. * @param max - Exclusive upper bound on the message, must be a positive integer. * @param params */ static boundCheckSmcWithKVProver(min: number, max: number, params: BoundCheckSmcWithKVProverParamsUncompressed): Uint8Array; /** * Same as `Statement.boundCheckSmcWithKVProver` except that it takes compressed parameters. * @param min - Inclusive lower bound on the message. * @param max - Exclusive upper bound on the message. * @param params */ static boundCheckSmcWithKVProverFromCompressedParams(min: number, max: number, params: BoundCheckSmcWithKVProverParams): Uint8Array; /** * Same as `Statement.boundCheckSmcWithKVProver` but does not take the parameters directly but a reference to them as indices in the * array of `SetupParam` * @param min - Inclusive lower bound on the message. * @param max - Exclusive upper bound on the message. * @param paramsRef - Index of params in array of `SetupParam` */ static boundCheckSmcWithKVProverFromSetupParamRefs(min: number, max: number, paramsRef: number): Uint8Array; /** * Create statement for verifying bounds [min, max) of a message using LegoGroth16, for the verifier. * @param min - Inclusive lower bound on the message, must be a positive integer. * @param max - Exclusive upper bound on the message, must be a positive integer. * @param params */ static boundCheckSmcWithKVVerifier(min: number, max: number, params: BoundCheckSmcWithKVVerifierParamsUncompressed): Uint8Array; /** * Same as `Statement.boundCheckSmcWithKVVerifier` except that it takes compressed parameters. * @param min - Inclusive lower bound on the message. * @param max - Exclusive upper bound on the message. * @param params */ static boundCheckSmcWithKVVerifierFromCompressedParams(min: number, max: number, params: BoundCheckSmcWithKVVerifierParams): Uint8Array; /** * Same as `Statement.boundCheckSmcWithKVVerifier` but does not take the parameters directly but a reference to them as indices in the * array of `SetupParam` * @param min - Inclusive lower bound on the message. * @param max - Exclusive upper bound on the message. * @param params - Index of params in array of `SetupParam` */ static boundCheckSmcWithKVVerifierFromSetupParamRefs(min: number, max: number, params: number): Uint8Array; /** * Create statement for proving inequality of a credential * @param inequalTo * @param commKey */ static publicInequalityG1(inequalTo: Uint8Array, commKey: PederCommKeyUncompressed): Uint8Array; static publicInequalityG1FromCompressedParams(inequalTo: Uint8Array, commKey: PederCommKey): Uint8Array; static publicInequalityG1FromSetupParamRefs(inequalTo: Uint8Array, commKey: number): Uint8Array; } /** * Meta statement used to express equality between witnesses of several statements or of the same statement. * Each witness is known by a pair of indices, the first index is the statement index and second is witness index in a particular * statement. */ export declare class WitnessEqualityMetaStatement { witnessRefs: Set<[number, number]>; constructor(); /** * Add a witness reference * @param statementIndex * @param witnessIndex */ addWitnessRef(statementIndex: number, witnessIndex: number): void; } export declare class MetaStatement { static witnessEquality(eq: WitnessEqualityMetaStatement): Uint8Array; } /** * A collection of statements */ export declare class Statements { values: Uint8Array[]; constructor(statements?: Uint8Array | Uint8Array[]); /** * Add a new statement to the end of the list. Returns the index (id) of the added statement. This index is part of the witness reference. * @param statement */ add(statement: Uint8Array): number; /** * Add new statements to the end of the list. Returns the indices (ids) of the added statements. These indices are part of the witness reference. * @param statements */ append(statements: Statements | Uint8Array[]): number[]; } /** * Expresses a relation between 1 or more statement or several witnesses of the same statement */ export declare class MetaStatements { values: Uint8Array[]; constructor(); /** * Add a new meta statement. * @param metaStatement */ add(metaStatement: Uint8Array): number; addWitnessEquality(wq: WitnessEqualityMetaStatement): number; } //# sourceMappingURL=statement.d.ts.map