mina-attestations

import { DynamicString, StaticArray } from '../dynamic.ts'; import { Bigint2048 } from '../rsa/rsa.ts'; import { MerkleList, Option, Proof, Provable, UInt32, UInt8 } from 'o1js'; export { ProvableEmail, verifyEmailSimple, prepareProvableEmail, verifyEmail, verifyEmailHeader, hashProgram, headerAndBodyProgram, }; type ProvableEmail = { /** * The email header in canonicalized form, i.e. the form that was signed. */ header: string | DynamicString; /** * The email body in canonicalized form, i.e. the form that was signed. */ body: string | DynamicString; /** * RSA public key that signed the email. */ publicKey: Bigint2048; /** * The RSA signature of the email. */ signature: Bigint2048; }; /** * Simple provable method to verify an email. Only for demonstration purposes. * * **Note**: This uses more than 150k constraints, so it doesn't work inside a Pickles proof which has size limited to 2^16 constraints. * `verifyEmail()` achieves the same functionality by breaking up the logic into several proofs. */ declare function verifyEmailSimple(email: ProvableEmail): void; declare function prepareProvableEmail(email: string): Promise<ProvableEmail>; declare function ProvableEmail({ maxHeaderLength, maxBodyLength, }: { maxHeaderLength: number; maxBodyLength: number; }): { new (value: { header: { readonly innerType: import("o1js").ProvableHashable<UInt8, { value: bigint; }>; hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes; toString(): string; concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString; assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | StaticArray<UInt8, { value: bigint; }> | (UInt8 | { value: bigint; })[] | string): void; splitAt(index: number): [DynamicString, DynamicString]; slice(start: number | UInt32): DynamicString; reverse(): DynamicString; assertContains(substring: StaticArray<UInt8, { value: bigint; }> | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | string, message?: string): import("o1js").Field; growMaxLengthTo(maxLength: number): DynamicString; array: UInt8[]; length: import("o1js").Field; readonly maxLength: number; assertIndexInRange(i: UInt32): void; get(i: UInt32): UInt8; getOption(i: UInt32): Option<UInt8>; getOrUnconstrained(i: import("o1js").Field): UInt8; set(i: UInt32, value: UInt8): void; setOrDoNothing(i: import("o1js").Field, value: UInt8): void; map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>; forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void; forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void; reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S; hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field; merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>; chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, { value: bigint; }>, { value: bigint; }[]>, import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>]; assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): void; concatTransposed(other: StaticArray<UInt8, { value: bigint; }> | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; push(value: UInt8): void; growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; normalize(): void; assertNormalized(): void; _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>; _indicesInRange: Set<import("o1js").Field>; __dummyMask?: import("o1js").Bool[]; _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[]; _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[]; isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined; toValue(): { value: bigint; }[]; }; body: { readonly innerType: import("o1js").ProvableHashable<UInt8, { value: bigint; }>; hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes; toString(): string; concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString; assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | StaticArray<UInt8, { value: bigint; }> | (UInt8 | { value: bigint; })[] | string): void; splitAt(index: number): [DynamicString, DynamicString]; slice(start: number | UInt32): DynamicString; reverse(): DynamicString; assertContains(substring: StaticArray<UInt8, { value: bigint; }> | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | string, message?: string): import("o1js").Field; growMaxLengthTo(maxLength: number): DynamicString; array: UInt8[]; length: import("o1js").Field; readonly maxLength: number; assertIndexInRange(i: UInt32): void; get(i: UInt32): UInt8; getOption(i: UInt32): Option<UInt8>; getOrUnconstrained(i: import("o1js").Field): UInt8; set(i: UInt32, value: UInt8): void; setOrDoNothing(i: import("o1js").Field, value: UInt8): void; map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>; forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void; forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void; reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S; hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field; merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>; chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, { value: bigint; }>, { value: bigint; }[]>, import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>]; assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): void; concatTransposed(other: StaticArray<UInt8, { value: bigint; }> | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; push(value: UInt8): void; growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; normalize(): void; assertNormalized(): void; _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>; _indicesInRange: Set<import("o1js").Field>; __dummyMask?: import("o1js").Bool[]; _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[]; _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[]; isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined; toValue(): { value: bigint; }[]; }; publicKey: Bigint2048; signature: Bigint2048; }): { header: { readonly innerType: import("o1js").ProvableHashable<UInt8, { value: bigint; }>; hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes; toString(): string; concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString; assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | StaticArray<UInt8, { value: bigint; }> | (UInt8 | { value: bigint; })[] | string): void; splitAt(index: number): [DynamicString, DynamicString]; slice(start: number | UInt32): DynamicString; reverse(): DynamicString; assertContains(substring: StaticArray<UInt8, { value: bigint; }> | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | string, message?: string): import("o1js").Field; growMaxLengthTo(maxLength: number): DynamicString; array: UInt8[]; length: import("o1js").Field; readonly maxLength: number; assertIndexInRange(i: UInt32): void; get(i: UInt32): UInt8; getOption(i: UInt32): Option<UInt8>; getOrUnconstrained(i: import("o1js").Field): UInt8; set(i: UInt32, value: UInt8): void; setOrDoNothing(i: import("o1js").Field, value: UInt8): void; map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>; forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void; forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void; reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S; hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field; merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>; chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, { value: bigint; }>, { value: bigint; }[]>, import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>]; assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): void; concatTransposed(other: StaticArray<UInt8, { value: bigint; }> | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; push(value: UInt8): void; growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; normalize(): void; assertNormalized(): void; _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>; _indicesInRange: Set<import("o1js").Field>; __dummyMask?: import("o1js").Bool[]; _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[]; _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[]; isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined; toValue(): { value: bigint; }[]; }; body: { readonly innerType: import("o1js").ProvableHashable<UInt8, { value: bigint; }>; hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes; toString(): string; concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString; assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | StaticArray<UInt8, { value: bigint; }> | (UInt8 | { value: bigint; })[] | string): void; splitAt(index: number): [DynamicString, DynamicString]; slice(start: number | UInt32): DynamicString; reverse(): DynamicString; assertContains(substring: StaticArray<UInt8, { value: bigint; }> | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | string, message?: string): import("o1js").Field; growMaxLengthTo(maxLength: number): DynamicString; array: UInt8[]; length: import("o1js").Field; readonly maxLength: number; assertIndexInRange(i: UInt32): void; get(i: UInt32): UInt8; getOption(i: UInt32): Option<UInt8>; getOrUnconstrained(i: import("o1js").Field): UInt8; set(i: UInt32, value: UInt8): void; setOrDoNothing(i: import("o1js").Field, value: UInt8): void; map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>; forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void; forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void; reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S; hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field; merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>; chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, { value: bigint; }>, { value: bigint; }[]>, import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>]; assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): void; concatTransposed(other: StaticArray<UInt8, { value: bigint; }> | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; push(value: UInt8): void; growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; normalize(): void; assertNormalized(): void; _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>; _indicesInRange: Set<import("o1js").Field>; __dummyMask?: import("o1js").Bool[]; _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[]; _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[]; isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined; toValue(): { value: bigint; }[]; }; publicKey: Bigint2048; signature: Bigint2048; }; Header: { new (array: UInt8[], length: import("o1js").Field): { readonly innerType: import("o1js").ProvableHashable<UInt8, { value: bigint; }>; hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes; toString(): string; concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString; assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | StaticArray<UInt8, { value: bigint; }> | (UInt8 | { value: bigint; })[] | string): void; splitAt(index: number): [DynamicString, DynamicString]; slice(start: number | UInt32): DynamicString; reverse(): DynamicString; assertContains(substring: StaticArray<UInt8, { value: bigint; }> | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | string, message?: string): import("o1js").Field; growMaxLengthTo(maxLength: number): DynamicString; array: UInt8[]; length: import("o1js").Field; readonly maxLength: number; assertIndexInRange(i: UInt32): void; get(i: UInt32): UInt8; getOption(i: UInt32): Option<UInt8>; getOrUnconstrained(i: import("o1js").Field): UInt8; set(i: UInt32, value: UInt8): void; setOrDoNothing(i: import("o1js").Field, value: UInt8): void; map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>; forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void; forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void; reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S; hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field; merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>; chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, { value: bigint; }>, { value: bigint; }[]>, import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>]; assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): void; concatTransposed(other: StaticArray<UInt8, { value: bigint; }> | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; push(value: UInt8): void; growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; normalize(): void; assertNormalized(): void; _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>; _indicesInRange: Set<import("o1js").Field>; __dummyMask?: import("o1js").Bool[]; _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[]; _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[]; isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined; toValue(): { value: bigint; }[]; }; readonly maxLength: number; readonly provable: import("../o1js-missing.ts").ProvableHashablePure<{ readonly innerType: import("o1js").ProvableHashable<UInt8, { value: bigint; }>; hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes; toString(): string; concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString; assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | StaticArray<UInt8, { value: bigint; }> | (UInt8 | { value: bigint; })[] | string): void; splitAt(index: number): [DynamicString, DynamicString]; slice(start: number | UInt32): DynamicString; reverse(): DynamicString; assertContains(substring: StaticArray<UInt8, { value: bigint; }> | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | string, message?: string): import("o1js").Field; growMaxLengthTo(maxLength: number): DynamicString; array: UInt8[]; length: import("o1js").Field; readonly maxLength: number; assertIndexInRange(i: UInt32): void; get(i: UInt32): UInt8; getOption(i: UInt32): Option<UInt8>; getOrUnconstrained(i: import("o1js").Field): UInt8; set(i: UInt32, value: UInt8): void; setOrDoNothing(i: import("o1js").Field, value: UInt8): void; map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>; forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void; forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void; reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S; hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field; merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>; chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, { value: bigint; }>, { value: bigint; }[]>, import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>]; assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): void; concatTransposed(other: StaticArray<UInt8, { value: bigint; }> | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; push(value: UInt8): void; growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; normalize(): void; assertNormalized(): void; _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>; _indicesInRange: Set<import("o1js").Field>; __dummyMask?: import("o1js").Bool[]; _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[]; _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[]; isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined; toValue(): { value: bigint; }[]; }, string>; from(s: string | { readonly innerType: import("o1js").ProvableHashable<UInt8, { value: bigint; }>; hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes; toString(): string; concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString; assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | StaticArray<UInt8, { value: bigint; }> | (UInt8 | { value: bigint; })[] | string): void; splitAt(index: number): [DynamicString, DynamicString]; slice(start: number | UInt32): DynamicString; reverse(): DynamicString; assertContains(substring: StaticArray<UInt8, { value: bigint; }> | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | string, message?: string): import("o1js").Field; growMaxLengthTo(maxLength: number): DynamicString; array: UInt8[]; length: import("o1js").Field; readonly maxLength: number; assertIndexInRange(i: UInt32): void; get(i: UInt32): UInt8; getOption(i: UInt32): Option<UInt8>; getOrUnconstrained(i: import("o1js").Field): UInt8; set(i: UInt32, value: UInt8): void; setOrDoNothing(i: import("o1js").Field, value: UInt8): void; map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>; forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void; forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void; reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S; hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field; merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>; chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, { value: bigint; }>, { value: bigint; }[]>, import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>]; assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): void; concatTransposed(other: StaticArray<UInt8, { value: bigint; }> | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; push(value: UInt8): void; growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; normalize(): void; assertNormalized(): void; _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>; _indicesInRange: Set<import("o1js").Field>; __dummyMask?: import("o1js").Bool[]; _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[]; _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[]; isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined; toValue(): { value: bigint; }[]; }): { readonly innerType: import("o1js").ProvableHashable<UInt8, { value: bigint; }>; hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes; toString(): string; concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString; assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | StaticArray<UInt8, { value: bigint; }> | (UInt8 | { value: bigint; })[] | string): void; splitAt(index: number): [DynamicString, DynamicString]; slice(start: number | UInt32): DynamicString; reverse(): DynamicString; assertContains(substring: StaticArray<UInt8, { value: bigint; }> | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | string, message?: string): import("o1js").Field; growMaxLengthTo(maxLength: number): DynamicString; array: UInt8[]; length: import("o1js").Field; readonly maxLength: number; assertIndexInRange(i: UInt32): void; get(i: UInt32): UInt8; getOption(i: UInt32): Option<UInt8>; getOrUnconstrained(i: import("o1js").Field): UInt8; set(i: UInt32, value: UInt8): void; setOrDoNothing(i: import("o1js").Field, value: UInt8): void; map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>; forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void; forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void; reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S; hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field; merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>; chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, { value: bigint; }>, { value: bigint; }[]>, import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>]; assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): void; concatTransposed(other: StaticArray<UInt8, { value: bigint; }> | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; push(value: UInt8): void; growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; normalize(): void; assertNormalized(): void; _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>; _indicesInRange: Set<import("o1js").Field>; __dummyMask?: import("o1js").Bool[]; _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[]; _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[]; isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined; toValue(): { value: bigint; }[]; }; }; Body: { new (array: UInt8[], length: import("o1js").Field): { readonly innerType: import("o1js").ProvableHashable<UInt8, { value: bigint; }>; hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes; toString(): string; concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString; assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | StaticArray<UInt8, { value: bigint; }> | (UInt8 | { value: bigint; })[] | string): void; splitAt(index: number): [DynamicString, DynamicString]; slice(start: number | UInt32): DynamicString; reverse(): DynamicString; assertContains(substring: StaticArray<UInt8, { value: bigint; }> | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | string, message?: string): import("o1js").Field; growMaxLengthTo(maxLength: number): DynamicString; array: UInt8[]; length: import("o1js").Field; readonly maxLength: number; assertIndexInRange(i: UInt32): void; get(i: UInt32): UInt8; getOption(i: UInt32): Option<UInt8>; getOrUnconstrained(i: import("o1js").Field): UInt8; set(i: UInt32, value: UInt8): void; setOrDoNothing(i: import("o1js").Field, value: UInt8): void; map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>; forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void; forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void; reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S; hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field; merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>; chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, { value: bigint; }>, { value: bigint; }[]>, import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>]; assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): void; concatTransposed(other: StaticArray<UInt8, { value: bigint; }> | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; push(value: UInt8): void; growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; normalize(): void; assertNormalized(): void; _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>; _indicesInRange: Set<import("o1js").Field>; __dummyMask?: import("o1js").Bool[]; _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[]; _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[]; isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined; toValue(): { value: bigint; }[]; }; readonly maxLength: number; readonly provable: import("../o1js-missing.ts").ProvableHashablePure<{ readonly innerType: import("o1js").ProvableHashable<UInt8, { value: bigint; }>; hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes; toString(): string; concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString; assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | StaticArray<UInt8, { value: bigint; }> | (UInt8 | { value: bigint; })[] | string): void; splitAt(index: number): [DynamicString, DynamicString]; slice(start: number | UInt32): DynamicString; reverse(): DynamicString; assertContains(substring: StaticArray<UInt8, { value: bigint; }> | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | string, message?: string): import("o1js").Field; growMaxLengthTo(maxLength: number): DynamicString; array: UInt8[]; length: import("o1js").Field; readonly maxLength: number; assertIndexInRange(i: UInt32): void; get(i: UInt32): UInt8; getOption(i: UInt32): Option<UInt8>; getOrUnconstrained(i: import("o1js").Field): UInt8; set(i: UInt32, value: UInt8): void; setOrDoNothing(i: import("o1js").Field, value: UInt8): void; map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>; forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void; forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void; reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S; hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field; merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>; chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, { value: bigint; }>, { value: bigint; }[]>, import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>]; assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): void; concatTransposed(other: StaticArray<UInt8, { value: bigint; }> | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; push(value: UInt8): void; growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; normalize(): void; assertNormalized(): void; _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>; _indicesInRange: Set<import("o1js").Field>; __dummyMask?: import("o1js").Bool[]; _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[]; _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[]; isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined; toValue(): { value: bigint; }[]; }, string>; from(s: string | { readonly innerType: import("o1js").ProvableHashable<UInt8, { value: bigint; }>; hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes; toString(): string; concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString; assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | StaticArray<UInt8, { value: bigint; }> | (UInt8 | { value: bigint; })[] | string): void; splitAt(index: number): [DynamicString, DynamicString]; slice(start: number | UInt32): DynamicString; reverse(): DynamicString; assertContains(substring: StaticArray<UInt8, { value: bigint; }> | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | string, message?: string): import("o1js").Field; growMaxLengthTo(maxLength: number): DynamicString; array: UInt8[]; length: import("o1js").Field; readonly maxLength: number; assertIndexInRange(i: UInt32): void; get(i: UInt32): UInt8; getOption(i: UInt32): Option<UInt8>; getOrUnconstrained(i: import("o1js").Field): UInt8; set(i: UInt32, value: UInt8): void; setOrDoNothing(i: import("o1js").Field, value: UInt8): void; map<S extends import("../o1js-missing.ts").ProvableHashableType>(type: S, f: (t: UInt8, i: number) => import("o1js").From<S>): import("../dynamic.ts").DynamicArray<import("node_modules/o1js/dist/node/bindings/lib/provable-generic.js").InferProvable<S, import("node_modules/o1js/dist/node/lib/provable/field.js").Field>, import("o1js").InferValue<S>>; forEach(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void; forEachReverse(f: (t: UInt8, isDummy: import("o1js").Bool, i: number) => void): void; reduce<S>(stateType: import("../nested.ts").NestedProvableFor<S>, state: S, f: (state: S, t: UInt8, isDummy: import("o1js").Bool) => S): S; hash(): import("node_modules/o1js/dist/node/lib/provable/field.js").Field; merkelize(listHash?: ((hash: import("o1js").Field, t: UInt8) => import("o1js").Field) | undefined): MerkleList<UInt8>; chunk(chunkSize: number): [import("../dynamic.ts").DynamicArray<StaticArray<UInt8, { value: bigint; }>, { value: bigint; }[]>, import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>]; assertEqualsStrict(other: import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): void; concatTransposed(other: StaticArray<UInt8, { value: bigint; }> | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; concatByHashing(other: import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; push(value: UInt8): void; growMaxLengthBy(maxLength: number): import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }>; normalize(): void; assertNormalized(): void; _indexMasks: Map<import("o1js").Field, import("o1js").Bool[]>; _indicesInRange: Set<import("o1js").Field>; __dummyMask?: import("o1js").Bool[]; _indexMask(i: import("o1js").Field): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[]; _dummyMask(): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool[]; isDummyIndex(i: number): import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool | undefined; toValue(): { value: bigint; }[]; }): { readonly innerType: import("o1js").ProvableHashable<UInt8, { value: bigint; }>; hashToBytes(algorithm: "sha2-256" | "sha2-384" | "sha2-512" | "keccak256"): import("node_modules/o1js/dist/node/lib/provable/bytes.js").Bytes; toString(): string; concat(other: import("../dynamic.ts").DynamicArray<UInt8> | string): DynamicString; assertEquals(other: DynamicString | import("../dynamic.ts").DynamicArray<UInt8, { value: bigint; }> | StaticArray<UInt8, { value: bigint; }> | (UInt8 | { value: bigint; })[] | string): void; splitAt(index: numb