@nihilium/client-sdk 0.1.2 → 0.2.1

package/dist/index.d.ts

@@ -1,1358 +1,792 @@
 import * as poseidonLite from 'poseidon-lite';
 
-/** Field is not always over prime: for example, Fp2 has ORDER(q)=p^m. */
-interface IField<T> {
-    ORDER: bigint;
-    isLE: boolean;
-    BYTES: number;
-    BITS: number;
-    MASK: bigint;
-    ZERO: T;
-    ONE: T;
-    create: (num: T) => T;
-    isValid: (num: T) => boolean;
-    is0: (num: T) => boolean;
-    neg(num: T): T;
-    inv(num: T): T;
-    sqrt(num: T): T;
-    sqr(num: T): T;
-    eql(lhs: T, rhs: T): boolean;
-    add(lhs: T, rhs: T): T;
-    sub(lhs: T, rhs: T): T;
-    mul(lhs: T, rhs: T | bigint): T;
-    pow(lhs: T, power: bigint): T;
-    div(lhs: T, rhs: T | bigint): T;
-    addN(lhs: T, rhs: T): T;
-    subN(lhs: T, rhs: T): T;
-    mulN(lhs: T, rhs: T | bigint): T;
-    sqrN(num: T): T;
-    isOdd?(num: T): boolean;
-    pow(lhs: T, power: bigint): T;
-    invertBatch: (lst: T[]) => T[];
-    toBytes(num: T): Uint8Array;
-    fromBytes(bytes: Uint8Array): T;
-    cmov(a: T, b: T, c: boolean): T;
-}
-
 /**
- * Methods for elliptic curve multiplication by scalars.
- * Contains wNAF, pippenger
- * @module
+ *  A [[HexString]] whose length is even, which ensures it is a valid
+ *  representation of binary data.
  */
-/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-
-type AffinePoint$1<T> = {
-    x: T;
-    y: T;
-} & {
-    z?: never;
-    t?: never;
-};
-interface Group$1<T extends Group$1<T>> {
-    double(): T;
-    negate(): T;
-    add(other: T): T;
-    subtract(other: T): T;
-    equals(other: T): boolean;
-    multiply(scalar: bigint): T;
-}
-type GroupConstructor$1<T> = {
-    BASE: T;
-    ZERO: T;
-};
+type DataHexString = string;
 /**
- * Generic BasicCurve interface: works even for polynomial fields (BLS): P, n, h would be ok.
- * Though generator can be different (Fp2 / Fp6 for BLS).
+ *  A string which is prefixed with ``0x`` and followed by any number
+ *  of case-agnostic hexadecimal characters.
+ *
+ *  It must match the regular expression ``/0x[0-9A-Fa-f]*\/``.
  */
-type BasicCurve<T> = {
-    Fp: IField<T>;
-    n: bigint;
-    nBitLength?: number;
-    nByteLength?: number;
-    h: bigint;
-    hEff?: bigint;
-    Gx: T;
-    Gy: T;
-    allowInfinityPoint?: boolean;
-};
-
+type HexString$1 = string;
 /**
- * Hex, bytes and number utilities.
- * @module
+ *  An object that can be used to represent binary data.
  */
-/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-type Hex$1 = Uint8Array | string;
-type FHash = (message: Uint8Array | string) => Uint8Array;
+type BytesLike = DataHexString | Uint8Array;
 
 /**
- * Twisted Edwards curve. The formula is: ax² + y² = 1 + dx²y².
- * For design rationale of types / exports, see weierstrass module documentation.
- * @module
+ *  Addresses are a fundamental part of interacting with Ethereum. They
+ *  represent the global identity of Externally Owned Accounts (accounts
+ *  backed by a private key) and contracts.
+ *
+ *  The Ethereum Naming Service (ENS) provides an interconnected ecosystem
+ *  of contracts, standards and libraries which enable looking up an
+ *  address for an ENS name.
+ *
+ *  These functions help convert between various formats, validate
+ *  addresses and safely resolve ENS names.
+ *
+ *  @_section: api/address:Addresses  [about-addresses]
  */
-/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-
-/** Edwards curves must declare params a & d. */
-type CurveType = BasicCurve<bigint> & {
-    a: bigint;
-    d: bigint;
-    hash: FHash;
-    randomBytes: (bytesLength?: number) => Uint8Array;
-    adjustScalarBytes?: (bytes: Uint8Array) => Uint8Array;
-    domain?: (data: Uint8Array, ctx: Uint8Array, phflag: boolean) => Uint8Array;
-    uvRatio?: (u: bigint, v: bigint) => {
-        isValid: boolean;
-        value: bigint;
-    };
-    prehash?: FHash;
-    mapToCurve?: (scalar: bigint[]) => AffinePoint$1<bigint>;
-};
-type CurveTypeWithLength = Readonly<CurveType & {
-    nByteLength: number;
-    nBitLength: number;
-}>;
-declare function validateOpts(curve: CurveType): CurveTypeWithLength;
-/** Instance of Extended Point with coordinates in X, Y, Z, T. */
-interface ExtPointType$1 extends Group$1<ExtPointType$1> {
-    readonly ex: bigint;
-    readonly ey: bigint;
-    readonly ez: bigint;
-    readonly et: bigint;
-    get x(): bigint;
-    get y(): bigint;
-    assertValidity(): void;
-    multiply(scalar: bigint): ExtPointType$1;
-    multiplyUnsafe(scalar: bigint): ExtPointType$1;
-    isSmallOrder(): boolean;
-    isTorsionFree(): boolean;
-    clearCofactor(): ExtPointType$1;
-    toAffine(iz?: bigint): AffinePoint$1<bigint>;
-    toRawBytes(isCompressed?: boolean): Uint8Array;
-    toHex(isCompressed?: boolean): string;
-    _setWindowSize(windowSize: number): void;
-}
-/** Static methods of Extended Point with coordinates in X, Y, Z, T. */
-interface ExtPointConstructor$1 extends GroupConstructor$1<ExtPointType$1> {
-    new (x: bigint, y: bigint, z: bigint, t: bigint): ExtPointType$1;
-    fromAffine(p: AffinePoint$1<bigint>): ExtPointType$1;
-    fromHex(hex: Hex$1): ExtPointType$1;
-    fromPrivateKey(privateKey: Hex$1): ExtPointType$1;
-    msm(points: ExtPointType$1[], scalars: bigint[]): ExtPointType$1;
+/**
+ *  An interface for objects which have an address, and can
+ *  resolve it asyncronously.
+ *
+ *  This allows objects such as [[Signer]] or [[Contract]] to
+ *  be used most places an address can be, for example getting
+ *  the [balance](Provider-getBalance).
+ */
+interface Addressable {
+    /**
+     *  Get the object address.
+     */
+    getAddress(): Promise<string>;
 }
 /**
- * Edwards Curve interface.
- * Main methods: `getPublicKey(priv)`, `sign(msg, priv)`, `verify(sig, msg, pub)`.
+ *  Anything that can be used to return or resolve an address.
  */
-type CurveFn = {
-    CURVE: ReturnType<typeof validateOpts>;
-    getPublicKey: (privateKey: Hex$1) => Uint8Array;
-    sign: (message: Hex$1, privateKey: Hex$1, options?: {
-        context?: Hex$1;
-    }) => Uint8Array;
-    verify: (sig: Hex$1, message: Hex$1, publicKey: Hex$1, options?: {
-        context?: Hex$1;
-        zip215: boolean;
-    }) => boolean;
-    ExtendedPoint: ExtPointConstructor$1;
-    utils: {
-        randomPrivateKey: () => Uint8Array;
-        getExtendedPublicKey: (key: Hex$1) => {
-            head: Uint8Array;
-            prefix: Uint8Array;
-            scalar: bigint;
-            point: ExtPointType$1;
-            pointBytes: Uint8Array;
-        };
-        precompute: (windowSize?: number, point?: ExtPointType$1) => ExtPointType$1;
-    };
-};
-
-type SnarkBigInt$1 = bigint;
-type PrivKey$1 = bigint;
-type PubKey$1 = ExtPointType$1;
-type BabyJubAffinePoint$1 = AffinePoint$1<bigint>;
-type BabyJubExtPoint$1 = ExtPointType$1;
-declare const babyJubNoble: CurveFn;
+type AddressLike = string | Promise<string> | Addressable;
 /**
- * A private key and a public key
+ *  An interface for any object which can resolve an ENS name.
  */
-interface Keypair$1 {
-    privKey: PrivKey$1;
-    pubKey: PubKey$1;
-}
-declare const SNARK_FIELD_SIZE$1: SnarkBigInt$1;
-declare const babyJub$1: ExtPointConstructor$1;
-
-declare const index_d$1_babyJubNoble: typeof babyJubNoble;
-declare namespace index_d$1 {
-  export { SNARK_FIELD_SIZE$1 as SNARK_FIELD_SIZE, babyJub$1 as babyJub, index_d$1_babyJubNoble as babyJubNoble };
-  export type { BabyJubAffinePoint$1 as BabyJubAffinePoint, BabyJubExtPoint$1 as BabyJubExtPoint, Keypair$1 as Keypair, PrivKey$1 as PrivKey, PubKey$1 as PubKey, SnarkBigInt$1 as SnarkBigInt };
+interface NameResolver {
+    /**
+     *  Resolve to the address for the ENS %%name%%.
+     *
+     *  Resolves to ``null`` if the name is unconfigued. Use
+     *  [[resolveAddress]] (passing this object as %%resolver%%) to
+     *  throw for names that are unconfigured.
+     */
+    resolveName(name: string): Promise<null | string>;
 }
 
-/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-
-type AffinePoint<T> = {
-    x: T;
-    y: T;
-} & {
-    z?: never;
-    t?: never;
+/**
+ *  A SignatureLike
+ *
+ *  @_docloc: api/crypto:Signing
+ */
+type SignatureLike = Signature | string | {
+    r: string;
+    s: string;
+    v: BigNumberish;
+    yParity?: 0 | 1;
+    yParityAndS?: string;
+} | {
+    r: string;
+    yParityAndS: string;
+    yParity?: 0 | 1;
+    s?: string;
+    v?: number;
+} | {
+    r: string;
+    s: string;
+    yParity: 0 | 1;
+    v?: BigNumberish;
+    yParityAndS?: string;
 };
-interface Group<T extends Group<T>> {
-    double(): T;
-    negate(): T;
-    add(other: T): T;
-    subtract(other: T): T;
-    equals(other: T): boolean;
-    multiply(scalar: bigint): T;
-}
-type GroupConstructor<T> = {
-    BASE: T;
-    ZERO: T;
-};
-
-type Hex = Uint8Array | string;
-
-interface ExtPointType extends Group<ExtPointType> {
-    readonly ex: bigint;
-    readonly ey: bigint;
-    readonly ez: bigint;
-    readonly et: bigint;
-    get x(): bigint;
-    get y(): bigint;
-    assertValidity(): void;
-    multiply(scalar: bigint): ExtPointType;
-    multiplyUnsafe(scalar: bigint): ExtPointType;
-    isSmallOrder(): boolean;
-    isTorsionFree(): boolean;
-    clearCofactor(): ExtPointType;
-    toAffine(iz?: bigint): AffinePoint<bigint>;
-    toRawBytes(isCompressed?: boolean): Uint8Array;
-    toHex(isCompressed?: boolean): string;
-}
-interface ExtPointConstructor extends GroupConstructor<ExtPointType> {
-    new (x: bigint, y: bigint, z: bigint, t: bigint): ExtPointType;
-    fromAffine(p: AffinePoint<bigint>): ExtPointType;
-    fromHex(hex: Hex): ExtPointType;
-    fromPrivateKey(privateKey: Hex): ExtPointType;
-}
-
-type SnarkBigInt = bigint;
-type PrivKey = bigint;
-type PubKey = ExtPointType;
-type BabyJubAffinePoint = AffinePoint<bigint>;
-type BabyJubExtPoint = ExtPointType;
 /**
- * A private key and a public key
+ *  A Signature  @TODO
+ *
+ *
+ *  @_docloc: api/crypto:Signing
  */
-interface Keypair {
-    privKey: PrivKey;
-    pubKey: PubKey;
+declare class Signature {
+    #private;
+    /**
+     *  The ``r`` value for a signature.
+     *
+     *  This represents the ``x`` coordinate of a "reference" or
+     *  challenge point, from which the ``y`` can be computed.
+     */
+    get r(): string;
+    set r(value: BytesLike);
+    /**
+     *  The ``s`` value for a signature.
+     */
+    get s(): string;
+    set s(_value: BytesLike);
+    /**
+     *  The ``v`` value for a signature.
+     *
+     *  Since a given ``x`` value for ``r`` has two possible values for
+     *  its correspondin ``y``, the ``v`` indicates which of the two ``y``
+     *  values to use.
+     *
+     *  It is normalized to the values ``27`` or ``28`` for legacy
+     *  purposes.
+     */
+    get v(): 27 | 28;
+    set v(value: BigNumberish);
+    /**
+     *  The EIP-155 ``v`` for legacy transactions. For non-legacy
+     *  transactions, this value is ``null``.
+     */
+    get networkV(): null | bigint;
+    /**
+     *  The chain ID for EIP-155 legacy transactions. For non-legacy
+     *  transactions, this value is ``null``.
+     */
+    get legacyChainId(): null | bigint;
+    /**
+     *  The ``yParity`` for the signature.
+     *
+     *  See ``v`` for more details on how this value is used.
+     */
+    get yParity(): 0 | 1;
+    /**
+     *  The [[link-eip-2098]] compact representation of the ``yParity``
+     *  and ``s`` compacted into a single ``bytes32``.
+     */
+    get yParityAndS(): string;
+    /**
+     *  The [[link-eip-2098]] compact representation.
+     */
+    get compactSerialized(): string;
+    /**
+     *  The serialized representation.
+     */
+    get serialized(): string;
+    /**
+     *  @private
+     */
+    constructor(guard: any, r: string, s: string, v: 27 | 28);
+    /**
+     *  Returns a new identical [[Signature]].
+     */
+    clone(): Signature;
+    /**
+     *  Returns a representation that is compatible with ``JSON.stringify``.
+     */
+    toJSON(): any;
+    /**
+     *  Compute the chain ID from the ``v`` in a legacy EIP-155 transactions.
+     *
+     *  @example:
+     *    Signature.getChainId(45)
+     *    //_result:
+     *
+     *    Signature.getChainId(46)
+     *    //_result:
+     */
+    static getChainId(v: BigNumberish): bigint;
+    /**
+     *  Compute the ``v`` for a chain ID for a legacy EIP-155 transactions.
+     *
+     *  Legacy transactions which use [[link-eip-155]] hijack the ``v``
+     *  property to include the chain ID.
+     *
+     *  @example:
+     *    Signature.getChainIdV(5, 27)
+     *    //_result:
+     *
+     *    Signature.getChainIdV(5, 28)
+     *    //_result:
+     *
+     */
+    static getChainIdV(chainId: BigNumberish, v: 27 | 28): bigint;
+    /**
+     *  Compute the normalized legacy transaction ``v`` from a ``yParirty``,
+     *  a legacy transaction ``v`` or a legacy [[link-eip-155]] transaction.
+     *
+     *  @example:
+     *    // The values 0 and 1 imply v is actually yParity
+     *    Signature.getNormalizedV(0)
+     *    //_result:
+     *
+     *    // Legacy non-EIP-1559 transaction (i.e. 27 or 28)
+     *    Signature.getNormalizedV(27)
+     *    //_result:
+     *
+     *    // Legacy EIP-155 transaction (i.e. >= 35)
+     *    Signature.getNormalizedV(46)
+     *    //_result:
+     *
+     *    // Invalid values throw
+     *    Signature.getNormalizedV(5)
+     *    //_error:
+     */
+    static getNormalizedV(v: BigNumberish): 27 | 28;
+    /**
+     *  Creates a new [[Signature]].
+     *
+     *  If no %%sig%% is provided, a new [[Signature]] is created
+     *  with default values.
+     *
+     *  If %%sig%% is a string, it is parsed.
+     */
+    static from(sig?: SignatureLike): Signature;
 }
-declare const SNARK_FIELD_SIZE: SnarkBigInt;
-declare const babyJub: ExtPointConstructor;
-
-declare const stringifyBigInts: (obj: object) => any;
-declare const unstringifyBigInts: (obj: object) => any;
 
-declare function createNobleBlakeHash(data: Buffer): Buffer<ArrayBuffer>;
-declare function generateRandom248BitNumber(): bigint;
-declare function generateRandom240BitNumber(): bigint;
-declare function shrinkToBits(number: bigint, bits: number): bigint;
-/**
- * Split a very large number into chunks of 32 bits each.
- * @param {BigInt} number - A BigInt representing the large number.
- * @returns {Array<BigInt>} - An array of chunks (BigInts).
- */
-declare function splitLargeNumber(number: bigint, size?: bigint): any[];
-/**
- * Combine chunks of 32 bits each into the original large number.
- * @param {Array<BigInt>} chunks - An array of chunks (BigInts).
- * @param {BigInt} size - The size of each chunk in bits.
- * @returns {BigInt} - The combined large number.
- */
-declare function combineChunksWithCarry(chunks: bigint[], size?: bigint): bigint;
-declare function pruneBuffer(buff: Buffer): Buffer<ArrayBufferLike>;
-declare function stringToCurve(mimc: any, string: string): any;
-declare function prv2pub(prv: Buffer): ExtPointType;
-declare function ffEncodedToBigInt(babyJub: any, encoded: bigint): any;
-/**
- * An internal function which formats a random private key to be compatible
- * with the BabyJub curve. This is the format which should be passed into the
- * PubKey and other circuits.
- */
-declare function formatPrivKeyForBabyJub(privKey: bigint): any;
-/**
- * Function to use when you have just the scalar value of the private key
- * and you need to convert it to the public key (Ax, Ay)
- */
-declare function privateScalarToPubKey(p: bigint): [bigint, bigint];
-/**
- * Convert a BigInt to a Buffer
- */
-declare const bigInt2Buffer: (i: BigInt) => Buffer;
-declare const hexString2Buffer: (i: string) => Buffer;
-declare const buffer2HexString: (i: Buffer) => string;
-declare const uint8ArrayToHex: (uint8Array: Uint8Array | any) => string;
-/**
- * Convert an EC extended point into an array of two bigints
- */
-declare function toBigIntArray(point: BabyJubExtPoint): [bigint, bigint];
 /**
- * Convert an EC extended point into an array of two strings
+ *  Any type that can be used where a numeric value is needed.
  */
-declare function toStringArray(point: BabyJubExtPoint): [string, string];
-declare function combineTwoPublicKeys(pubKey1: bigint[], pubKey2: bigint[]): bigint[];
-declare function combineTwoPublicKeysPlain(pubKey1: bigint[], pubKey2: bigint[]): bigint[];
+type Numeric = number | bigint;
 /**
- * Convert two strings x and y into an EC extended point
+ *  Any type that can be used where a big number is needed.
  */
-declare function coordinatesToExtPoint(x: string, y: string): BabyJubExtPoint;
-declare const bufferToBigInt: (buf: Buffer | Uint8Array) => bigint;
-declare function coordinatesToExtPointBigint(x: bigint, y: bigint): BabyJubExtPoint;
-declare function portableArgon2(data: Buffer, options?: {
-    memory: number;
-    iterations: number;
-    parallelism: number;
-}): Buffer;
+type BigNumberish = string | Numeric;
+
 /**
- * Returns a Uint8Array of cryptographically secure random bytes.
- * This function works in both browser and Node.js environments.
- * In browsers, it uses window.crypto.getRandomValues.
- * In Node.js, it uses require('crypto').randomBytes if available.
- * @param length Number of random bytes to generate.
- * @returns Uint8Array of random bytes.
+ *  A **TransactionLike** is an object which is appropriate as a loose
+ *  input for many operations which will populate missing properties of
+ *  a transaction.
  */
-declare function portableRandomBytes(length: number): Buffer;
-declare function generateNonces(): bigint[];
-declare function HEEncryptFromPoint(message: bigint, pubKey: ExtPointType, nonces?: bigint[], exportNonces?: boolean): {
-    ephemeral_keys: ExtPointType[];
-    encrypted_messages: ExtPointType[];
-    nonces: bigint[];
-};
-declare function SimpelElgamalEncrypt(message: bigint, pubKey: PubKey, bitSize?: number): {
-    ephemeral_key: string;
-    encrypted_message: string;
-};
-declare function SimpelElgamalDecrypt(encrypted_message: string, ephemeral_key: string, privKey: PrivKey): bigint;
-declare function HEEncrypt(message: bigint, pubKey: bigint[], nonces?: bigint[], exportNonces?: boolean): {
-    ephemeral_keys: ExtPointType[];
-    encrypted_messages: ExtPointType[];
-    nonces: bigint[];
-};
-declare function HEDecryptExternalSolver(privKey: bigint, cypherTexts: bigint[], ephemeralKeys: bigint[], solve: (base_x: bigint, base_y: bigint, encoded_x: bigint, encoded_y: bigint) => bigint): Promise<bigint>;
-declare function HEDecrypt(privKey: bigint, cypherTexts: bigint[], ephemeralKeys: bigint[]): Promise<bigint>;
-declare function HEDecryptSync(privKey: bigint, cypherTexts: bigint[], ephemeralKeys: bigint[]): bigint;
-declare const hashExtPoints: (extPoints: ExtPointType[]) => bigint;
-declare const hashCypherText: (message: bigint[], ephemeralKey: bigint[], relatedPublicKey: bigint[], preimage_hash: any, random_value: bigint, unseal_condition_root_hash: any, metadata_root_commit: any) => bigint;
-declare function pruneTo64Bits(originalValue: bigint): bigint;
-declare function pruneTo32Bits(bigInt253Bit: bigint): bigint;
+interface TransactionLike<A = string> {
+    /**
+     *  The type.
+     */
+    type?: null | number;
+    /**
+     *  The recipient address or ``null`` for an ``init`` transaction.
+     */
+    to?: null | A;
+    /**
+     *  The sender.
+     */
+    from?: null | A;
+    /**
+     *  The nonce.
+     */
+    nonce?: null | number;
+    /**
+     *  The maximum amount of gas that can be used.
+     */
+    gasLimit?: null | BigNumberish;
+    /**
+     *  The gas price for legacy and berlin transactions.
+     */
+    gasPrice?: null | BigNumberish;
+    /**
+     *  The maximum priority fee per gas for london transactions.
+     */
+    maxPriorityFeePerGas?: null | BigNumberish;
+    /**
+     *  The maximum total fee per gas for london transactions.
+     */
+    maxFeePerGas?: null | BigNumberish;
+    /**
+     *  The data.
+     */
+    data?: null | string;
+    /**
+     *  The value (in wei) to send.
+     */
+    value?: null | BigNumberish;
+    /**
+     *  The chain ID the transaction is valid on.
+     */
+    chainId?: null | BigNumberish;
+    /**
+     *  The transaction hash.
+     */
+    hash?: null | string;
+    /**
+     *  The signature provided by the sender.
+     */
+    signature?: null | SignatureLike;
+    /**
+     *  The access list for berlin and london transactions.
+     */
+    accessList?: null | AccessListish;
+    /**
+     *  The maximum fee per blob gas (see [[link-eip-4844]]).
+     */
+    maxFeePerBlobGas?: null | BigNumberish;
+    /**
+     *  The versioned hashes (see [[link-eip-4844]]).
+     */
+    blobVersionedHashes?: null | Array<string>;
+    /**
+     *  The blobs (if any) attached to this transaction (see [[link-eip-4844]]).
+     */
+    blobs?: null | Array<BlobLike>;
+    /**
+     *  An external library for computing the KZG commitments and
+     *  proofs necessary for EIP-4844 transactions (see [[link-eip-4844]]).
+     *
+     *  This is generally ``null``, unless you are creating BLOb
+     *  transactions.
+     */
+    kzg?: null | KzgLibraryLike;
+    /**
+     *  The [[link-eip-7702]] authorizations (if any).
+     */
+    authorizationList?: null | Array<Authorization>;
+}
 /**
- * - Returns a signal value similar to the "callGetSignalByName" function from the "circom-helper" package.
- * - This function depends on the "circom_tester" package.
- *
- * Example usage:
- *
- * ```typescript
- * const wasm_tester = require('circom_tester').wasm;
- *
- * /// the circuit is loaded only once and it is available for use across multiple test cases.
- * const circuit = await wasm_tester(path.resolve("./circuit/path"));
- * const witness = await circuit.calculateWitness(inputsObject);
- * await circuit.checkConstraints(witness);
- * await circuit.loadSymbols();
+ *  A BLOb object that can be passed for [[link-eip-4844]]
+ *  transactions.
  *
- * /// You can check signal names by printing "circuit.symbols".
- * /// You will mostly need circuit inputs and outputs.
- * const singalName = 'main.out'
- * const signalValue = getSignalByName(circuit, witness, SignalName)
- * ```
+ *  It may have had its commitment and proof already provided
+ *  or rely on an attached [[KzgLibrary]] to compute them.
  */
-declare const getSignalByName: (circuit: any, witness: any, signalName: string) => any;
+type BlobLike = BytesLike | {
+    data: BytesLike;
+    proof: BytesLike;
+    commitment: BytesLike;
+};
 /**
- * Encrypts a BigInt value using AES-256-CBC encryption
- * @param value - The BigInt value to encrypt
- * @param key - The encryption key as a BigInt
- * @returns The encrypted value as a hex string
+ *  A KZG Library with the necessary functions to compute
+ *  BLOb commitments and proofs.
  */
-declare function encryptAESBigInt(value: bigint, key: bigint): string;
+interface KzgLibrary {
+    blobToKzgCommitment: (blob: Uint8Array) => Uint8Array;
+    computeBlobKzgProof: (blob: Uint8Array, commitment: Uint8Array) => Uint8Array;
+}
 /**
- * Decrypts a hex string back to a BigInt value using AES-256-CBC decryption
- * @param encryptedHex - The encrypted value as a hex string
- * @param key - The decryption key as a BigInt
- * @returns The decrypted BigInt value
+ *  A KZG Library with any of the various API configurations.
+ *  As the library is still experimental and the API is not
+ *  stable, depending on the version used the method names and
+ *  signatures are still in flux.
+ *
+ *  This allows any of the versions to be passed into Transaction
+ *  while providing a stable external API.
  */
-declare function decryptAESBigInt(encryptedHex: string, key: bigint): bigint;
-declare function toBytesLE(bn: bigint, length?: number): Uint8Array;
-declare function fromBytesLE(bytes: Uint8Array): bigint;
-declare function encryptECCBabyJub(message: bigint, recipientPubKey: PubKey, nonce?: bigint | undefined, emperalKey?: ExtPointType | undefined): {
-    ciphertextHex: string;
-    R: {
-        x: string;
-        y: string;
-    };
+type KzgLibraryLike = KzgLibrary | {
+    blobToKZGCommitment: (blob: string) => string;
+    computeBlobKZGProof: (blob: string, commitment: string) => string;
+} | {
+    blobToKzgCommitment: (blob: string) => string | Uint8Array;
+    computeBlobProof: (blob: string, commitment: string) => string | Uint8Array;
 };
-declare function decryptECCBabyJub(ciphertextHex: string, RHex: {
-    x: string;
-    y: string;
-}, recipientPrivKey: PrivKey): bigint;
-/**
- * Returns a BabyJub-compatible random value. We create it by first generating
- * a random value (initially 256 bits large) modulo the snark field size as
- * described in EIP197. This results in a key size of roughly 253 bits and no
- * more than 254 bits. To prevent modulo bias, we then use this efficient
- * algorithm:
- * http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/lib/libc/crypt/arc4random_uniform.c
- * @return A BabyJub-compatible random value.
- * @see {@link https://github.com/privacy-scaling-explorations/maci/blob/master/crypto/ts/index.ts}
- */
-declare function genRandomBabyJubValue(): bigint;
-declare function genSmallRandomBabyJubValue(): bigint;
+
 /**
- * @return A BabyJub-compatible private key.
+ *  Each state-changing operation on Ethereum requires a transaction.
+ *
+ *  @_section api/transaction:Transactions  [about-transactions]
  */
-declare const genPrivKey: () => PrivKey;
+
 /**
- * @return A BabyJub-compatible salt.
+ *  A single [[AccessList]] entry of storage keys (slots) for an address.
  */
-declare const genRandomSalt: () => PrivKey;
+type AccessListEntry = {
+    address: string;
+    storageKeys: Array<string>;
+};
 /**
- * @param privKey A private key generated using genPrivKey()
- * @return A public key associated with the private key
+ *  An ordered collection of [[AccessList]] entries.
  */
-declare function genPubKey(privKey: PrivKey): PubKey;
-declare function genKeypair(scalar?: bigint): Keypair;
+type AccessList = Array<AccessListEntry>;
 /**
- * Encrypts a plaintext such that only the owner of the specified public key
- * may decrypt it.
- * @param pubKey The recepient's public key
- * @param encodedMessage A plaintext encoded as a BabyJub curve point (optional)
- * @param randomVal A random value y used along with the private key to generate the ciphertext (optional)
+ *  Any ethers-supported access list structure.
  */
-declare function encrypt(pubKey: PubKey, encodedMessage: BabyJubExtPoint, randomVal?: bigint): {
-    message: ExtPointType;
-    ephemeral_key: ExtPointType;
-    encrypted_message: ExtPointType;
+type AccessListish = AccessList | Array<[string, Array<string>]> | Record<string, Array<string>>;
+interface Authorization {
+    address: string;
     nonce: bigint;
-};
-/**
- * Decrypts a ciphertext using a private key.
- * @param privKey The private key
- * @param ciphertext The ciphertext to decrypt
- */
-declare function decrypt(privKey: PrivKey, ephemeral_key: BabyJubExtPoint, encrypted_message: BabyJubExtPoint): BabyJubExtPoint;
-declare function HEAdd(empheralKey1: ExtPointType, empheralKey2: ExtPointType, encryptedMessage1: ExtPointType, encryptedMessage2: ExtPointType): {
-    ephemeralKey: ExtPointType;
-    encryptedMessage: ExtPointType;
-};
-declare function HEAddAll(empheralKeys1: ExtPointType[], empheralKeys2: ExtPointType[], encryptedMessages1: ExtPointType[], encryptedMessages2: ExtPointType[]): {
-    ephemeralKeys: ExtPointType[];
-    encryptedMessages: ExtPointType[];
-};
-declare function encrypt_s(message: BabyJubExtPoint, public_key: PubKey, nonce?: bigint): {
-    ephemeral_key: ExtPointType;
-    encrypted_message: ExtPointType;
+    chainId: bigint;
+    signature: Signature;
+}
+type AuthorizationLike = {
+    address: string;
+    nonce: BigNumberish;
+    chainId: BigNumberish;
+    signature: SignatureLike;
 };
 
-/** Canonical uint256 secret material (0x00abc and 0xabc are the same integer). */
-declare function normalizeSigningKeyMaterial(hexKey: string): bigint;
-/**
- * Raw secret bytes for EdDSA (@zk-kit/eddsa-poseidon) from canonical integer hex.
- * Leading zero nybbles in the env string are not preserved as extra bytes.
- */
-declare function hexToSkBuffer(hexKey: string): Buffer;
 /**
- * Derive the scalar used inside the HE (ElGamal) key derivation.
- * This is `formatPrivKeyForBabyJub(BigInt(hexKey))` and matches the scalar
- * used in `genPubKey` / `HEDecrypt` / `encrypt`.
+ *  A **ContractRunner** is a generic interface which defines an object
+ *  capable of interacting with a Contract on the network.
  *
- * @param hexKey  0x-prefixed 32-byte private key hex string
- */
-declare function deriveHEKeyScalar(hexKey: string): bigint;
-/**
- * Derive the HE public key `[x, y]` from a raw private key hex string.
- * Equivalent to `genPubKey(BigInt(hexKey))` but accepts a hex string and
- * returns affine coordinates rather than an ExtPointType.
+ *  The more operations supported, the more utility it is capable of.
  *
- * @param hexKey  0x-prefixed 32-byte private key hex string
+ *  The most common ContractRunners are [Providers](Provider) which enable
+ *  read-only access and [Signers](Signer) which enable write-access.
  */
-declare function deriveHEPublicKey(hexKey: string): [bigint, bigint];
-/**
- * Derive the scalar used inside the EdDSA signing key derivation (Schnorr PoK).
- * Matches `@zk-kit/eddsa-poseidon.deriveSecretScalar`.
- *
- * @param hexKey  0x-prefixed private key hex string
- */
-declare function deriveSigningKeyScalar(hexKey: string): Promise<bigint>;
-/**
- * Derive the EdDSA signing public key `[x, y]` from a raw private key hex string.
- * Matches `@zk-kit/eddsa-poseidon.derivePublicKey` used by the Processor and circuits.
- *
- * @param hexKey  0x-prefixed private key hex string
- */
-declare function deriveSigningPublicKey(hexKey: string): Promise<[bigint, bigint]>;
-
-type tools_d_BabyJubAffinePoint = BabyJubAffinePoint;
-type tools_d_BabyJubExtPoint = BabyJubExtPoint;
-declare const tools_d_HEAdd: typeof HEAdd;
-declare const tools_d_HEAddAll: typeof HEAddAll;
-declare const tools_d_HEDecrypt: typeof HEDecrypt;
-declare const tools_d_HEDecryptExternalSolver: typeof HEDecryptExternalSolver;
-declare const tools_d_HEDecryptSync: typeof HEDecryptSync;
-declare const tools_d_HEEncrypt: typeof HEEncrypt;
-declare const tools_d_HEEncryptFromPoint: typeof HEEncryptFromPoint;
-type tools_d_Keypair = Keypair;
-type tools_d_PrivKey = PrivKey;
-type tools_d_PubKey = PubKey;
-declare const tools_d_SNARK_FIELD_SIZE: typeof SNARK_FIELD_SIZE;
-declare const tools_d_SimpelElgamalDecrypt: typeof SimpelElgamalDecrypt;
-declare const tools_d_SimpelElgamalEncrypt: typeof SimpelElgamalEncrypt;
-declare const tools_d_babyJub: typeof babyJub;
-declare const tools_d_bigInt2Buffer: typeof bigInt2Buffer;
-declare const tools_d_buffer2HexString: typeof buffer2HexString;
-declare const tools_d_bufferToBigInt: typeof bufferToBigInt;
-declare const tools_d_combineChunksWithCarry: typeof combineChunksWithCarry;
-declare const tools_d_combineTwoPublicKeys: typeof combineTwoPublicKeys;
-declare const tools_d_combineTwoPublicKeysPlain: typeof combineTwoPublicKeysPlain;
-declare const tools_d_coordinatesToExtPoint: typeof coordinatesToExtPoint;
-declare const tools_d_coordinatesToExtPointBigint: typeof coordinatesToExtPointBigint;
-declare const tools_d_createNobleBlakeHash: typeof createNobleBlakeHash;
-declare const tools_d_decrypt: typeof decrypt;
-declare const tools_d_decryptAESBigInt: typeof decryptAESBigInt;
-declare const tools_d_decryptECCBabyJub: typeof decryptECCBabyJub;
-declare const tools_d_deriveHEKeyScalar: typeof deriveHEKeyScalar;
-declare const tools_d_deriveHEPublicKey: typeof deriveHEPublicKey;
-declare const tools_d_deriveSigningKeyScalar: typeof deriveSigningKeyScalar;
-declare const tools_d_deriveSigningPublicKey: typeof deriveSigningPublicKey;
-declare const tools_d_encrypt: typeof encrypt;
-declare const tools_d_encryptAESBigInt: typeof encryptAESBigInt;
-declare const tools_d_encryptECCBabyJub: typeof encryptECCBabyJub;
-declare const tools_d_encrypt_s: typeof encrypt_s;
-declare const tools_d_ffEncodedToBigInt: typeof ffEncodedToBigInt;
-declare const tools_d_formatPrivKeyForBabyJub: typeof formatPrivKeyForBabyJub;
-declare const tools_d_fromBytesLE: typeof fromBytesLE;
-declare const tools_d_genKeypair: typeof genKeypair;
-declare const tools_d_genPrivKey: typeof genPrivKey;
-declare const tools_d_genPubKey: typeof genPubKey;
-declare const tools_d_genRandomBabyJubValue: typeof genRandomBabyJubValue;
-declare const tools_d_genRandomSalt: typeof genRandomSalt;
-declare const tools_d_genSmallRandomBabyJubValue: typeof genSmallRandomBabyJubValue;
-declare const tools_d_generateNonces: typeof generateNonces;
-declare const tools_d_generateRandom240BitNumber: typeof generateRandom240BitNumber;
-declare const tools_d_generateRandom248BitNumber: typeof generateRandom248BitNumber;
-declare const tools_d_getSignalByName: typeof getSignalByName;
-declare const tools_d_hashCypherText: typeof hashCypherText;
-declare const tools_d_hashExtPoints: typeof hashExtPoints;
-declare const tools_d_hexString2Buffer: typeof hexString2Buffer;
-declare const tools_d_hexToSkBuffer: typeof hexToSkBuffer;
-declare const tools_d_normalizeSigningKeyMaterial: typeof normalizeSigningKeyMaterial;
-declare const tools_d_portableArgon2: typeof portableArgon2;
-declare const tools_d_portableRandomBytes: typeof portableRandomBytes;
-declare const tools_d_privateScalarToPubKey: typeof privateScalarToPubKey;
-declare const tools_d_pruneBuffer: typeof pruneBuffer;
-declare const tools_d_pruneTo32Bits: typeof pruneTo32Bits;
-declare const tools_d_pruneTo64Bits: typeof pruneTo64Bits;
-declare const tools_d_prv2pub: typeof prv2pub;
-declare const tools_d_shrinkToBits: typeof shrinkToBits;
-declare const tools_d_splitLargeNumber: typeof splitLargeNumber;
-declare const tools_d_stringToCurve: typeof stringToCurve;
-declare const tools_d_stringifyBigInts: typeof stringifyBigInts;
-declare const tools_d_toBigIntArray: typeof toBigIntArray;
-declare const tools_d_toBytesLE: typeof toBytesLE;
-declare const tools_d_toStringArray: typeof toStringArray;
-declare const tools_d_uint8ArrayToHex: typeof uint8ArrayToHex;
-declare const tools_d_unstringifyBigInts: typeof unstringifyBigInts;
-declare namespace tools_d {
-  export { tools_d_HEAdd as HEAdd, tools_d_HEAddAll as HEAddAll, tools_d_HEDecrypt as HEDecrypt, tools_d_HEDecryptExternalSolver as HEDecryptExternalSolver, tools_d_HEDecryptSync as HEDecryptSync, tools_d_HEEncrypt as HEEncrypt, tools_d_HEEncryptFromPoint as HEEncryptFromPoint, tools_d_SNARK_FIELD_SIZE as SNARK_FIELD_SIZE, tools_d_SimpelElgamalDecrypt as SimpelElgamalDecrypt, tools_d_SimpelElgamalEncrypt as SimpelElgamalEncrypt, tools_d_babyJub as babyJub, tools_d_bigInt2Buffer as bigInt2Buffer, tools_d_buffer2HexString as buffer2HexString, tools_d_bufferToBigInt as bufferToBigInt, tools_d_combineChunksWithCarry as combineChunksWithCarry, tools_d_combineTwoPublicKeys as combineTwoPublicKeys, tools_d_combineTwoPublicKeysPlain as combineTwoPublicKeysPlain, tools_d_coordinatesToExtPoint as coordinatesToExtPoint, tools_d_coordinatesToExtPointBigint as coordinatesToExtPointBigint, tools_d_createNobleBlakeHash as createNobleBlakeHash, tools_d_decrypt as decrypt, tools_d_decryptAESBigInt as decryptAESBigInt, tools_d_decryptECCBabyJub as decryptECCBabyJub, tools_d_deriveHEKeyScalar as deriveHEKeyScalar, tools_d_deriveHEPublicKey as deriveHEPublicKey, tools_d_deriveSigningKeyScalar as deriveSigningKeyScalar, tools_d_deriveSigningPublicKey as deriveSigningPublicKey, tools_d_encrypt as encrypt, tools_d_encryptAESBigInt as encryptAESBigInt, tools_d_encryptECCBabyJub as encryptECCBabyJub, tools_d_encrypt_s as encrypt_s, tools_d_ffEncodedToBigInt as ffEncodedToBigInt, tools_d_formatPrivKeyForBabyJub as formatPrivKeyForBabyJub, tools_d_fromBytesLE as fromBytesLE, tools_d_genKeypair as genKeypair, tools_d_genPrivKey as genPrivKey, tools_d_genPubKey as genPubKey, tools_d_genRandomBabyJubValue as genRandomBabyJubValue, tools_d_genRandomSalt as genRandomSalt, tools_d_genSmallRandomBabyJubValue as genSmallRandomBabyJubValue, tools_d_generateNonces as generateNonces, tools_d_generateRandom240BitNumber as generateRandom240BitNumber, tools_d_generateRandom248BitNumber as generateRandom248BitNumber, tools_d_getSignalByName as getSignalByName, tools_d_hashCypherText as hashCypherText, tools_d_hashExtPoints as hashExtPoints, tools_d_hexString2Buffer as hexString2Buffer, tools_d_hexToSkBuffer as hexToSkBuffer, tools_d_normalizeSigningKeyMaterial as normalizeSigningKeyMaterial, tools_d_portableArgon2 as portableArgon2, tools_d_portableRandomBytes as portableRandomBytes, poseidonLite as poseidonTools, tools_d_privateScalarToPubKey as privateScalarToPubKey, tools_d_pruneBuffer as pruneBuffer, tools_d_pruneTo32Bits as pruneTo32Bits, tools_d_pruneTo64Bits as pruneTo64Bits, tools_d_prv2pub as prv2pub, tools_d_shrinkToBits as shrinkToBits, tools_d_splitLargeNumber as splitLargeNumber, tools_d_stringToCurve as stringToCurve, tools_d_stringifyBigInts as stringifyBigInts, tools_d_toBigIntArray as toBigIntArray, tools_d_toBytesLE as toBytesLE, tools_d_toStringArray as toStringArray, tools_d_uint8ArrayToHex as uint8ArrayToHex, tools_d_unstringifyBigInts as unstringifyBigInts };
-  export type { tools_d_BabyJubAffinePoint as BabyJubAffinePoint, tools_d_BabyJubExtPoint as BabyJubExtPoint, tools_d_Keypair as Keypair, tools_d_PrivKey as PrivKey, tools_d_PubKey as PubKey };
-}
-
-/**
- *  A [[HexString]] whose length is even, which ensures it is a valid
- *  representation of binary data.
- */
-type DataHexString = string;
-/**
- *  A string which is prefixed with ``0x`` and followed by any number
- *  of case-agnostic hexadecimal characters.
- *
- *  It must match the regular expression ``/0x[0-9A-Fa-f]*\/``.
- */
-type HexString$1 = string;
-/**
- *  An object that can be used to represent binary data.
- */
-type BytesLike = DataHexString | Uint8Array;
-
-/**
- *  Addresses are a fundamental part of interacting with Ethereum. They
- *  represent the global identity of Externally Owned Accounts (accounts
- *  backed by a private key) and contracts.
- *
- *  The Ethereum Naming Service (ENS) provides an interconnected ecosystem
- *  of contracts, standards and libraries which enable looking up an
- *  address for an ENS name.
- *
- *  These functions help convert between various formats, validate
- *  addresses and safely resolve ENS names.
- *
- *  @_section: api/address:Addresses  [about-addresses]
- */
-/**
- *  An interface for objects which have an address, and can
- *  resolve it asyncronously.
- *
- *  This allows objects such as [[Signer]] or [[Contract]] to
- *  be used most places an address can be, for example getting
- *  the [balance](Provider-getBalance).
- */
-interface Addressable {
+interface ContractRunner {
     /**
-     *  Get the object address.
+     *  The provider used for necessary state querying operations.
+     *
+     *  This can also point to the **ContractRunner** itself, in the
+     *  case of an [[AbstractProvider]].
      */
-    getAddress(): Promise<string>;
+    provider: null | Provider;
+    /**
+     *  Required to estimate gas.
+     */
+    estimateGas?: (tx: TransactionRequest) => Promise<bigint>;
+    /**
+     * Required for pure, view or static calls to contracts.
+     */
+    call?: (tx: TransactionRequest) => Promise<string>;
+    /**
+     *  Required to support ENS names
+     */
+    resolveName?: (name: string) => Promise<null | string>;
+    /**
+     *  Required for state mutating calls
+     */
+    sendTransaction?: (tx: TransactionRequest) => Promise<TransactionResponse>;
 }
+
 /**
- *  Anything that can be used to return or resolve an address.
- */
-type AddressLike = string | Promise<string> | Addressable;
-/**
- *  An interface for any object which can resolve an ENS name.
+ *  A **NetworkPlugin** provides additional functionality on a [[Network]].
  */
-interface NameResolver {
+declare class NetworkPlugin {
     /**
-     *  Resolve to the address for the ENS %%name%%.
+     *  The name of the plugin.
      *
-     *  Resolves to ``null`` if the name is unconfigued. Use
-     *  [[resolveAddress]] (passing this object as %%resolver%%) to
-     *  throw for names that are unconfigured.
+     *  It is recommended to use reverse-domain-notation, which permits
+     *  unique names with a known authority as well as hierarchal entries.
      */
-    resolveName(name: string): Promise<null | string>;
+    readonly name: string;
+    /**
+     *  Creates a new **NetworkPlugin**.
+     */
+    constructor(name: string);
+    /**
+     *  Creates a copy of this plugin.
+     */
+    clone(): NetworkPlugin;
 }
 
 /**
- *  A SignatureLike
+ *  A **Network** encapsulates the various properties required to
+ *  interact with a specific chain.
  *
- *  @_docloc: api/crypto:Signing
+ *  @_subsection: api/providers:Networks  [networks]
  */
-type SignatureLike = Signature | string | {
-    r: string;
-    s: string;
-    v: BigNumberish;
-    yParity?: 0 | 1;
-    yParityAndS?: string;
-} | {
-    r: string;
-    yParityAndS: string;
-    yParity?: 0 | 1;
-    s?: string;
-    v?: number;
-} | {
-    r: string;
-    s: string;
-    yParity: 0 | 1;
-    v?: BigNumberish;
-    yParityAndS?: string;
+
+/**
+ *  A Networkish can be used to allude to a Network, by specifing:
+ *  - a [[Network]] object
+ *  - a well-known (or registered) network name
+ *  - a well-known (or registered) chain ID
+ *  - an object with sufficient details to describe a network
+ */
+type Networkish = Network | number | bigint | string | {
+    name?: string;
+    chainId?: number;
+    ensAddress?: string;
+    ensNetwork?: number;
 };
 /**
- *  A Signature  @TODO
- *
- *
- *  @_docloc: api/crypto:Signing
+ *  A **Network** provides access to a chain's properties and allows
+ *  for plug-ins to extend functionality.
  */
-declare class Signature {
+declare class Network {
     #private;
     /**
-     *  The ``r`` value for a signature.
-     *
-     *  This represents the ``x`` coordinate of a "reference" or
-     *  challenge point, from which the ``y`` can be computed.
+     *  Creates a new **Network** for %%name%% and %%chainId%%.
      */
-    get r(): string;
-    set r(value: BytesLike);
+    constructor(name: string, chainId: BigNumberish);
     /**
-     *  The ``s`` value for a signature.
+     *  Returns a JSON-compatible representation of a Network.
      */
-    get s(): string;
-    set s(_value: BytesLike);
+    toJSON(): any;
     /**
-     *  The ``v`` value for a signature.
-     *
-     *  Since a given ``x`` value for ``r`` has two possible values for
-     *  its correspondin ``y``, the ``v`` indicates which of the two ``y``
-     *  values to use.
+     *  The network common name.
      *
-     *  It is normalized to the values ``27`` or ``28`` for legacy
-     *  purposes.
+     *  This is the canonical name, as networks migh have multiple
+     *  names.
      */
-    get v(): 27 | 28;
-    set v(value: BigNumberish);
+    get name(): string;
+    set name(value: string);
     /**
-     *  The EIP-155 ``v`` for legacy transactions. For non-legacy
-     *  transactions, this value is ``null``.
+     *  The network chain ID.
      */
-    get networkV(): null | bigint;
-    /**
-     *  The chain ID for EIP-155 legacy transactions. For non-legacy
-     *  transactions, this value is ``null``.
-     */
-    get legacyChainId(): null | bigint;
+    get chainId(): bigint;
+    set chainId(value: BigNumberish);
     /**
-     *  The ``yParity`` for the signature.
+     *  Returns true if %%other%% matches this network. Any chain ID
+     *  must match, and if no chain ID is present, the name must match.
      *
-     *  See ``v`` for more details on how this value is used.
-     */
-    get yParity(): 0 | 1;
-    /**
-     *  The [[link-eip-2098]] compact representation of the ``yParity``
-     *  and ``s`` compacted into a single ``bytes32``.
-     */
-    get yParityAndS(): string;
-    /**
-     *  The [[link-eip-2098]] compact representation.
+     *  This method does not currently check for additional properties,
+     *  such as ENS address or plug-in compatibility.
      */
-    get compactSerialized(): string;
+    matches(other: Networkish): boolean;
     /**
-     *  The serialized representation.
+     *  Returns the list of plugins currently attached to this Network.
      */
-    get serialized(): string;
+    get plugins(): Array<NetworkPlugin>;
     /**
-     *  @private
+     *  Attach a new %%plugin%% to this Network. The network name
+     *  must be unique, excluding any fragment.
      */
-    constructor(guard: any, r: string, s: string, v: 27 | 28);
+    attachPlugin(plugin: NetworkPlugin): this;
     /**
-     *  Returns a new identical [[Signature]].
+     *  Return the plugin, if any, matching %%name%% exactly. Plugins
+     *  with fragments will not be returned unless %%name%% includes
+     *  a fragment.
      */
-    clone(): Signature;
+    getPlugin<T extends NetworkPlugin = NetworkPlugin>(name: string): null | T;
     /**
-     *  Returns a representation that is compatible with ``JSON.stringify``.
+     *  Gets a list of all plugins that match %%name%%, with otr without
+     *  a fragment.
      */
-    toJSON(): any;
+    getPlugins<T extends NetworkPlugin = NetworkPlugin>(basename: string): Array<T>;
     /**
-     *  Compute the chain ID from the ``v`` in a legacy EIP-155 transactions.
-     *
-     *  @example:
-     *    Signature.getChainId(45)
-     *    //_result:
-     *
-     *    Signature.getChainId(46)
-     *    //_result:
+     *  Create a copy of this Network.
      */
-    static getChainId(v: BigNumberish): bigint;
+    clone(): Network;
     /**
-     *  Compute the ``v`` for a chain ID for a legacy EIP-155 transactions.
-     *
-     *  Legacy transactions which use [[link-eip-155]] hijack the ``v``
-     *  property to include the chain ID.
-     *
-     *  @example:
-     *    Signature.getChainIdV(5, 27)
-     *    //_result:
-     *
-     *    Signature.getChainIdV(5, 28)
-     *    //_result:
+     *  Compute the intrinsic gas required for a transaction.
      *
+     *  A GasCostPlugin can be attached to override the default
+     *  values.
      */
-    static getChainIdV(chainId: BigNumberish, v: 27 | 28): bigint;
+    computeIntrinsicGas(tx: TransactionLike): number;
     /**
-     *  Compute the normalized legacy transaction ``v`` from a ``yParirty``,
-     *  a legacy transaction ``v`` or a legacy [[link-eip-155]] transaction.
-     *
-     *  @example:
-     *    // The values 0 and 1 imply v is actually yParity
-     *    Signature.getNormalizedV(0)
-     *    //_result:
-     *
-     *    // Legacy non-EIP-1559 transaction (i.e. 27 or 28)
-     *    Signature.getNormalizedV(27)
-     *    //_result:
-     *
-     *    // Legacy EIP-155 transaction (i.e. >= 35)
-     *    Signature.getNormalizedV(46)
-     *    //_result:
-     *
-     *    // Invalid values throw
-     *    Signature.getNormalizedV(5)
-     *    //_error:
+     *  Returns a new Network for the %%network%% name or chainId.
      */
-    static getNormalizedV(v: BigNumberish): 27 | 28;
+    static from(network?: Networkish): Network;
     /**
-     *  Creates a new [[Signature]].
-     *
-     *  If no %%sig%% is provided, a new [[Signature]] is created
-     *  with default values.
-     *
-     *  If %%sig%% is a string, it is parsed.
+     *  Register %%nameOrChainId%% with a function which returns
+     *  an instance of a Network representing that chain.
      */
-    static from(sig?: SignatureLike): Signature;
+    static register(nameOrChainId: string | number | bigint, networkFunc: () => Network): void;
 }
 
 /**
- *  Any type that can be used where a numeric value is needed.
- */
-type Numeric = number | bigint;
-/**
- *  Any type that can be used where a big number is needed.
+ *  About provider formatting?
+ *
+ *  @_section: api/providers/formatting:Formatting  [provider-formatting]
  */
-type BigNumberish = string | Numeric;
 
 /**
- *  A **TransactionLike** is an object which is appropriate as a loose
- *  input for many operations which will populate missing properties of
- *  a transaction.
+ *  a **BlockParams** encodes the minimal required properties for a
+ *  formatted block.
  */
-interface TransactionLike<A = string> {
+interface BlockParams {
     /**
-     *  The type.
+     *  The block hash.
      */
-    type?: null | number;
+    hash?: null | string;
     /**
-     *  The recipient address or ``null`` for an ``init`` transaction.
+     *  The block number.
      */
-    to?: null | A;
+    number: number;
     /**
-     *  The sender.
+     *  The timestamp for this block, which is the number of seconds
+     *  since epoch that this block was included.
      */
-    from?: null | A;
+    timestamp: number;
     /**
-     *  The nonce.
+     *  The hash of the previous block in the blockchain. The genesis block
+     *  has the parentHash of the [[ZeroHash]].
      */
-    nonce?: null | number;
+    parentHash: string;
     /**
-     *  The maximum amount of gas that can be used.
+     *  The hash tree root of the parent beacon block for the given
+     *  execution block. See [[link-eip-4788]].
      */
-    gasLimit?: null | BigNumberish;
+    parentBeaconBlockRoot?: null | string;
     /**
-     *  The gas price for legacy and berlin transactions.
+     *  A random sequence provided during the mining process for
+     *  proof-of-work networks.
      */
-    gasPrice?: null | BigNumberish;
+    nonce: string;
     /**
-     *  The maximum priority fee per gas for london transactions.
+     *  For proof-of-work networks, the difficulty target is used to
+     *  adjust the difficulty in mining to ensure an expected block rate.
      */
-    maxPriorityFeePerGas?: null | BigNumberish;
+    difficulty: bigint;
     /**
-     *  The maximum total fee per gas for london transactions.
+     *  The maximum amount of gas a block can consume.
      */
-    maxFeePerGas?: null | BigNumberish;
+    gasLimit: bigint;
     /**
-     *  The data.
+     *  The amount of gas a block consumed.
      */
-    data?: null | string;
+    gasUsed: bigint;
     /**
-     *  The value (in wei) to send.
+     *  The total amount of BLOb gas consumed by transactions within
+     *  the block. See [[link-eip4844].
      */
-    value?: null | BigNumberish;
+    blobGasUsed?: null | bigint;
     /**
-     *  The chain ID the transaction is valid on.
+     *  The running total of BLOb gas consumed in excess of the target
+     *  prior to the block. See [[link-eip-4844]].
      */
-    chainId?: null | BigNumberish;
+    excessBlobGas?: null | bigint;
     /**
-     *  The transaction hash.
+     *  The miner (or author) of a block.
      */
-    hash?: null | string;
+    miner: string;
     /**
-     *  The signature provided by the sender.
+     *  The latest RANDAO mix of the post beacon state of
+     *  the previous block.
      */
-    signature?: null | SignatureLike;
+    prevRandao?: null | string;
     /**
-     *  The access list for berlin and london transactions.
+     *  Additional data the miner choose to include.
      */
-    accessList?: null | AccessListish;
+    extraData: string;
     /**
-     *  The maximum fee per blob gas (see [[link-eip-4844]]).
+     *  The protocol-defined base fee per gas in an [[link-eip-1559]]
+     *  block.
      */
-    maxFeePerBlobGas?: null | BigNumberish;
+    baseFeePerGas: null | bigint;
     /**
-     *  The versioned hashes (see [[link-eip-4844]]).
+     *  The root hash for the global state after applying changes
+     *  in this block.
      */
-    blobVersionedHashes?: null | Array<string>;
+    stateRoot?: null | string;
     /**
-     *  The blobs (if any) attached to this transaction (see [[link-eip-4844]]).
+     *  The hash of the transaction receipts trie.
      */
-    blobs?: null | Array<BlobLike>;
+    receiptsRoot?: null | string;
     /**
-     *  An external library for computing the KZG commitments and
-     *  proofs necessary for EIP-4844 transactions (see [[link-eip-4844]]).
-     *
-     *  This is generally ``null``, unless you are creating BLOb
-     *  transactions.
+     *  The list of transactions in the block.
      */
-    kzg?: null | KzgLibraryLike;
+    transactions: ReadonlyArray<string | TransactionResponseParams>;
+}
+/**
+ *  a **LogParams** encodes the minimal required properties for a
+ *  formatted log.
+ */
+interface LogParams {
     /**
-     *  The [[link-eip-7702]] authorizations (if any).
+     *  The transaction hash for the transaxction the log occurred in.
      */
-    authorizationList?: null | Array<Authorization>;
+    transactionHash: string;
+    /**
+     *  The block hash of the block that included the transaction for this
+     *  log.
+     */
+    blockHash: string;
+    /**
+     *  The block number of the block that included the transaction for this
+     *  log.
+     */
+    blockNumber: number;
+    /**
+     *  Whether this log was removed due to the transaction it was included
+     *  in being removed dur to an orphaned block.
+     */
+    removed: boolean;
+    /**
+     *  The address of the contract that emitted this log.
+     */
+    address: string;
+    /**
+     *  The data emitted with this log.
+     */
+    data: string;
+    /**
+     *  The topics emitted with this log.
+     */
+    topics: ReadonlyArray<string>;
+    /**
+     *  The index of this log.
+     */
+    index: number;
+    /**
+     *  The transaction index of this log.
+     */
+    transactionIndex: number;
 }
 /**
- *  A BLOb object that can be passed for [[link-eip-4844]]
- *  transactions.
- *
- *  It may have had its commitment and proof already provided
- *  or rely on an attached [[KzgLibrary]] to compute them.
+ *  a **TransactionReceiptParams** encodes the minimal required properties
+ *  for a formatted transaction receipt.
  */
-type BlobLike = BytesLike | {
-    data: BytesLike;
-    proof: BytesLike;
-    commitment: BytesLike;
-};
-/**
- *  A KZG Library with the necessary functions to compute
- *  BLOb commitments and proofs.
- */
-interface KzgLibrary {
-    blobToKzgCommitment: (blob: Uint8Array) => Uint8Array;
-    computeBlobKzgProof: (blob: Uint8Array, commitment: Uint8Array) => Uint8Array;
-}
-/**
- *  A KZG Library with any of the various API configurations.
- *  As the library is still experimental and the API is not
- *  stable, depending on the version used the method names and
- *  signatures are still in flux.
- *
- *  This allows any of the versions to be passed into Transaction
- *  while providing a stable external API.
- */
-type KzgLibraryLike = KzgLibrary | {
-    blobToKZGCommitment: (blob: string) => string;
-    computeBlobKZGProof: (blob: string, commitment: string) => string;
-} | {
-    blobToKzgCommitment: (blob: string) => string | Uint8Array;
-    computeBlobProof: (blob: string, commitment: string) => string | Uint8Array;
-};
-
-/**
- *  Each state-changing operation on Ethereum requires a transaction.
- *
- *  @_section api/transaction:Transactions  [about-transactions]
- */
-
-/**
- *  A single [[AccessList]] entry of storage keys (slots) for an address.
- */
-type AccessListEntry = {
-    address: string;
-    storageKeys: Array<string>;
-};
-/**
- *  An ordered collection of [[AccessList]] entries.
- */
-type AccessList = Array<AccessListEntry>;
-/**
- *  Any ethers-supported access list structure.
- */
-type AccessListish = AccessList | Array<[string, Array<string>]> | Record<string, Array<string>>;
-interface Authorization {
-    address: string;
-    nonce: bigint;
-    chainId: bigint;
-    signature: Signature;
-}
-type AuthorizationLike = {
-    address: string;
-    nonce: BigNumberish;
-    chainId: BigNumberish;
-    signature: SignatureLike;
-};
-
-/**
- *  A **ContractRunner** is a generic interface which defines an object
- *  capable of interacting with a Contract on the network.
- *
- *  The more operations supported, the more utility it is capable of.
- *
- *  The most common ContractRunners are [Providers](Provider) which enable
- *  read-only access and [Signers](Signer) which enable write-access.
- */
-interface ContractRunner {
-    /**
-     *  The provider used for necessary state querying operations.
-     *
-     *  This can also point to the **ContractRunner** itself, in the
-     *  case of an [[AbstractProvider]].
-     */
-    provider: null | Provider;
-    /**
-     *  Required to estimate gas.
-     */
-    estimateGas?: (tx: TransactionRequest) => Promise<bigint>;
-    /**
-     * Required for pure, view or static calls to contracts.
-     */
-    call?: (tx: TransactionRequest) => Promise<string>;
+interface TransactionReceiptParams {
     /**
-     *  Required to support ENS names
+     *  The target of the transaction. If null, the transaction was trying
+     *  to deploy a transaction with the ``data`` as the initi=code.
      */
-    resolveName?: (name: string) => Promise<null | string>;
+    to: null | string;
     /**
-     *  Required for state mutating calls
+     *  The sender of the transaction.
      */
-    sendTransaction?: (tx: TransactionRequest) => Promise<TransactionResponse>;
-}
-
-/**
- *  A **NetworkPlugin** provides additional functionality on a [[Network]].
- */
-declare class NetworkPlugin {
+    from: string;
     /**
-     *  The name of the plugin.
-     *
-     *  It is recommended to use reverse-domain-notation, which permits
-     *  unique names with a known authority as well as hierarchal entries.
+     *  If the transaction was directly deploying a contract, the [[to]]
+     *  will be null, the ``data`` will be initcode and if successful, this
+     *  will be the address of the contract deployed.
      */
-    readonly name: string;
+    contractAddress: null | string;
     /**
-     *  Creates a new **NetworkPlugin**.
+     *  The transaction hash.
      */
-    constructor(name: string);
+    hash: string;
     /**
-     *  Creates a copy of this plugin.
+     *  The transaction index.
      */
-    clone(): NetworkPlugin;
-}
-
-/**
- *  A **Network** encapsulates the various properties required to
- *  interact with a specific chain.
- *
- *  @_subsection: api/providers:Networks  [networks]
- */
-
-/**
- *  A Networkish can be used to allude to a Network, by specifing:
- *  - a [[Network]] object
- *  - a well-known (or registered) network name
- *  - a well-known (or registered) chain ID
- *  - an object with sufficient details to describe a network
- */
-type Networkish = Network | number | bigint | string | {
-    name?: string;
-    chainId?: number;
-    ensAddress?: string;
-    ensNetwork?: number;
-};
-/**
- *  A **Network** provides access to a chain's properties and allows
- *  for plug-ins to extend functionality.
- */
-declare class Network {
-    #private;
+    index: number;
     /**
-     *  Creates a new **Network** for %%name%% and %%chainId%%.
+     *  The block hash of the block that included this transaction.
      */
-    constructor(name: string, chainId: BigNumberish);
+    blockHash: string;
     /**
-     *  Returns a JSON-compatible representation of a Network.
+     *  The block number of the block that included this transaction.
      */
-    toJSON(): any;
+    blockNumber: number;
     /**
-     *  The network common name.
-     *
-     *  This is the canonical name, as networks migh have multiple
-     *  names.
+     *  The bloom filter for the logs emitted during execution of this
+     *  transaction.
      */
-    get name(): string;
-    set name(value: string);
+    logsBloom: string;
     /**
-     *  The network chain ID.
+     *  The logs emitted during the execution of this transaction.
      */
-    get chainId(): bigint;
-    set chainId(value: BigNumberish);
+    logs: ReadonlyArray<LogParams>;
     /**
-     *  Returns true if %%other%% matches this network. Any chain ID
-     *  must match, and if no chain ID is present, the name must match.
-     *
-     *  This method does not currently check for additional properties,
-     *  such as ENS address or plug-in compatibility.
+     *  The amount of gas consumed executing this transaciton.
      */
-    matches(other: Networkish): boolean;
+    gasUsed: bigint;
     /**
-     *  Returns the list of plugins currently attached to this Network.
+     *  The amount of BLOb gas used. See [[link-eip-4844]].
      */
-    get plugins(): Array<NetworkPlugin>;
+    blobGasUsed?: null | bigint;
     /**
-     *  Attach a new %%plugin%% to this Network. The network name
-     *  must be unique, excluding any fragment.
+     *  The total amount of gas consumed during the entire block up to
+     *  and including this transaction.
      */
-    attachPlugin(plugin: NetworkPlugin): this;
+    cumulativeGasUsed: bigint;
     /**
-     *  Return the plugin, if any, matching %%name%% exactly. Plugins
-     *  with fragments will not be returned unless %%name%% includes
-     *  a fragment.
+     *  The actual gas price per gas charged for this transaction.
      */
-    getPlugin<T extends NetworkPlugin = NetworkPlugin>(name: string): null | T;
+    gasPrice?: null | bigint;
     /**
-     *  Gets a list of all plugins that match %%name%%, with otr without
-     *  a fragment.
+     *  The actual BLOb gas price that was charged. See [[link-eip-4844]].
      */
-    getPlugins<T extends NetworkPlugin = NetworkPlugin>(basename: string): Array<T>;
+    blobGasPrice?: null | bigint;
     /**
-     *  Create a copy of this Network.
+     *  The actual gas price per gas charged for this transaction.
      */
-    clone(): Network;
+    effectiveGasPrice?: null | bigint;
     /**
-     *  Compute the intrinsic gas required for a transaction.
-     *
-     *  A GasCostPlugin can be attached to override the default
-     *  values.
+     *  The [[link-eip-2718]] envelope type.
      */
-    computeIntrinsicGas(tx: TransactionLike): number;
+    type: number;
     /**
-     *  Returns a new Network for the %%network%% name or chainId.
+     *  The status of the transaction execution. If ``1`` then the
+     *  the transaction returned success, if ``0`` then the transaction
+     *  was reverted. For pre-byzantium blocks, this is usually null, but
+     *  some nodes may have backfilled this data.
      */
-    static from(network?: Networkish): Network;
+    status: null | number;
     /**
-     *  Register %%nameOrChainId%% with a function which returns
-     *  an instance of a Network representing that chain.
+     *  The root of this transaction in a pre-bazatium block. In
+     *  post-byzantium blocks this is null.
      */
-    static register(nameOrChainId: string | number | bigint, networkFunc: () => Network): void;
+    root: null | string;
 }
-
-/**
- *  About provider formatting?
- *
- *  @_section: api/providers/formatting:Formatting  [provider-formatting]
- */
-
 /**
- *  a **BlockParams** encodes the minimal required properties for a
- *  formatted block.
+ *  a **TransactionResponseParams** encodes the minimal required properties
+ *  for a formatted transaction response.
  */
-interface BlockParams {
+interface TransactionResponseParams {
     /**
-     *  The block hash.
+     *  The block number of the block that included this transaction.
      */
-    hash?: null | string;
+    blockNumber: null | number;
     /**
-     *  The block number.
+     *  The block hash of the block that included this transaction.
      */
-    number: number;
+    blockHash: null | string;
     /**
-     *  The timestamp for this block, which is the number of seconds
-     *  since epoch that this block was included.
+     *  The transaction hash.
      */
-    timestamp: number;
+    hash: string;
     /**
-     *  The hash of the previous block in the blockchain. The genesis block
-     *  has the parentHash of the [[ZeroHash]].
+     *  The transaction index.
      */
-    parentHash: string;
-    /**
-     *  The hash tree root of the parent beacon block for the given
-     *  execution block. See [[link-eip-4788]].
-     */
-    parentBeaconBlockRoot?: null | string;
-    /**
-     *  A random sequence provided during the mining process for
-     *  proof-of-work networks.
-     */
-    nonce: string;
-    /**
-     *  For proof-of-work networks, the difficulty target is used to
-     *  adjust the difficulty in mining to ensure an expected block rate.
-     */
-    difficulty: bigint;
-    /**
-     *  The maximum amount of gas a block can consume.
-     */
-    gasLimit: bigint;
-    /**
-     *  The amount of gas a block consumed.
-     */
-    gasUsed: bigint;
-    /**
-     *  The total amount of BLOb gas consumed by transactions within
-     *  the block. See [[link-eip4844].
-     */
-    blobGasUsed?: null | bigint;
-    /**
-     *  The running total of BLOb gas consumed in excess of the target
-     *  prior to the block. See [[link-eip-4844]].
-     */
-    excessBlobGas?: null | bigint;
-    /**
-     *  The miner (or author) of a block.
-     */
-    miner: string;
-    /**
-     *  The latest RANDAO mix of the post beacon state of
-     *  the previous block.
-     */
-    prevRandao?: null | string;
-    /**
-     *  Additional data the miner choose to include.
-     */
-    extraData: string;
-    /**
-     *  The protocol-defined base fee per gas in an [[link-eip-1559]]
-     *  block.
-     */
-    baseFeePerGas: null | bigint;
-    /**
-     *  The root hash for the global state after applying changes
-     *  in this block.
-     */
-    stateRoot?: null | string;
-    /**
-     *  The hash of the transaction receipts trie.
-     */
-    receiptsRoot?: null | string;
-    /**
-     *  The list of transactions in the block.
-     */
-    transactions: ReadonlyArray<string | TransactionResponseParams>;
-}
-/**
- *  a **LogParams** encodes the minimal required properties for a
- *  formatted log.
- */
-interface LogParams {
-    /**
-     *  The transaction hash for the transaxction the log occurred in.
-     */
-    transactionHash: string;
-    /**
-     *  The block hash of the block that included the transaction for this
-     *  log.
-     */
-    blockHash: string;
-    /**
-     *  The block number of the block that included the transaction for this
-     *  log.
-     */
-    blockNumber: number;
-    /**
-     *  Whether this log was removed due to the transaction it was included
-     *  in being removed dur to an orphaned block.
-     */
-    removed: boolean;
-    /**
-     *  The address of the contract that emitted this log.
-     */
-    address: string;
-    /**
-     *  The data emitted with this log.
-     */
-    data: string;
-    /**
-     *  The topics emitted with this log.
-     */
-    topics: ReadonlyArray<string>;
-    /**
-     *  The index of this log.
-     */
-    index: number;
-    /**
-     *  The transaction index of this log.
-     */
-    transactionIndex: number;
-}
-/**
- *  a **TransactionReceiptParams** encodes the minimal required properties
- *  for a formatted transaction receipt.
- */
-interface TransactionReceiptParams {
-    /**
-     *  The target of the transaction. If null, the transaction was trying
-     *  to deploy a transaction with the ``data`` as the initi=code.
-     */
-    to: null | string;
-    /**
-     *  The sender of the transaction.
-     */
-    from: string;
-    /**
-     *  If the transaction was directly deploying a contract, the [[to]]
-     *  will be null, the ``data`` will be initcode and if successful, this
-     *  will be the address of the contract deployed.
-     */
-    contractAddress: null | string;
-    /**
-     *  The transaction hash.
-     */
-    hash: string;
-    /**
-     *  The transaction index.
-     */
-    index: number;
-    /**
-     *  The block hash of the block that included this transaction.
-     */
-    blockHash: string;
-    /**
-     *  The block number of the block that included this transaction.
-     */
-    blockNumber: number;
-    /**
-     *  The bloom filter for the logs emitted during execution of this
-     *  transaction.
-     */
-    logsBloom: string;
-    /**
-     *  The logs emitted during the execution of this transaction.
-     */
-    logs: ReadonlyArray<LogParams>;
-    /**
-     *  The amount of gas consumed executing this transaciton.
-     */
-    gasUsed: bigint;
-    /**
-     *  The amount of BLOb gas used. See [[link-eip-4844]].
-     */
-    blobGasUsed?: null | bigint;
-    /**
-     *  The total amount of gas consumed during the entire block up to
-     *  and including this transaction.
-     */
-    cumulativeGasUsed: bigint;
-    /**
-     *  The actual gas price per gas charged for this transaction.
-     */
-    gasPrice?: null | bigint;
-    /**
-     *  The actual BLOb gas price that was charged. See [[link-eip-4844]].
-     */
-    blobGasPrice?: null | bigint;
-    /**
-     *  The actual gas price per gas charged for this transaction.
-     */
-    effectiveGasPrice?: null | bigint;
-    /**
-     *  The [[link-eip-2718]] envelope type.
-     */
-    type: number;
-    /**
-     *  The status of the transaction execution. If ``1`` then the
-     *  the transaction returned success, if ``0`` then the transaction
-     *  was reverted. For pre-byzantium blocks, this is usually null, but
-     *  some nodes may have backfilled this data.
-     */
-    status: null | number;
-    /**
-     *  The root of this transaction in a pre-bazatium block. In
-     *  post-byzantium blocks this is null.
-     */
-    root: null | string;
-}
-/**
- *  a **TransactionResponseParams** encodes the minimal required properties
- *  for a formatted transaction response.
- */
-interface TransactionResponseParams {
-    /**
-     *  The block number of the block that included this transaction.
-     */
-    blockNumber: null | number;
-    /**
-     *  The block hash of the block that included this transaction.
-     */
-    blockHash: null | string;
-    /**
-     *  The transaction hash.
-     */
-    hash: string;
-    /**
-     *  The transaction index.
-     */
-    index: number;
+    index: number;
     /**
      *  The [[link-eip-2718]] transaction type.
      */
@@ -4999,52 +4433,6 @@ declare type TreeSlice = {
     elements: Element[];
 };
 
-declare function toPaddedHex(bn: bigint, length?: number): string;
-declare const ZERO = 7507787612525723758659662260399184323980001748885802124580171315331567144978n;
-declare const ZERO_KECCAK = "0x937759b0c00d3bc82439e3acdb505be98d7bca79f508bb77a8bfafc2666260a6";
-/**
- * The the MimC tree hash function,
- * If wanting to hash a single value set right to 0n
- * @param left
- * @param right
- * @returns
- */
-declare var treeHasher: (left: any, right: any) => any;
-/**
- * Creates a merkle tree with the mimc hash function from circomlibjs
- * @param depth
- * @param leaves
- * @returns
- */
-declare var keccakTreeHasher: (left: any, right: any) => any;
-declare function createMimcMerkelTree(depth: number, leaves: string[]): Promise<MerkleTree>;
-declare function createKeccakMerkelTree(depth: number, leaves: string[]): Promise<MerkleTree>;
-declare function createKeccakMerkelTreeSync(depth: number, leaves: string[]): MerkleTree;
-declare function signDataInsertRequestJWT(data: HexString$1[], global_tree_index: number, inserted_at: number, secret: Signer): Promise<string>;
-
-declare const utils_d_ZERO: typeof ZERO;
-declare const utils_d_ZERO_KECCAK: typeof ZERO_KECCAK;
-declare const utils_d_createKeccakMerkelTree: typeof createKeccakMerkelTree;
-declare const utils_d_createKeccakMerkelTreeSync: typeof createKeccakMerkelTreeSync;
-declare const utils_d_createMimcMerkelTree: typeof createMimcMerkelTree;
-declare const utils_d_keccakTreeHasher: typeof keccakTreeHasher;
-declare const utils_d_signDataInsertRequestJWT: typeof signDataInsertRequestJWT;
-declare const utils_d_toPaddedHex: typeof toPaddedHex;
-declare const utils_d_treeHasher: typeof treeHasher;
-declare namespace utils_d {
-  export {
-    utils_d_ZERO as ZERO,
-    utils_d_ZERO_KECCAK as ZERO_KECCAK,
-    utils_d_createKeccakMerkelTree as createKeccakMerkelTree,
-    utils_d_createKeccakMerkelTreeSync as createKeccakMerkelTreeSync,
-    utils_d_createMimcMerkelTree as createMimcMerkelTree,
-    utils_d_keccakTreeHasher as keccakTreeHasher,
-    utils_d_signDataInsertRequestJWT as signDataInsertRequestJWT,
-    utils_d_toPaddedHex as toPaddedHex,
-    utils_d_treeHasher as treeHasher,
-  };
-}
-
 interface ProofResult {
     globalProof: ProofPath;
     localProof: ProofPath;
@@ -5149,16 +4537,6 @@ type CompiledProof = {
     validate_action: UnsealProofAction;
 };
 
-type types_d$2_CompiledProof = CompiledProof;
-type types_d$2_Proof = Proof;
-type types_d$2_UnsealConditionProof = UnsealConditionProof;
-declare const types_d$2_UnsealConditionProof: typeof UnsealConditionProof;
-type types_d$2_UnsealConditionProofData = UnsealConditionProofData;
-declare namespace types_d$2 {
-  export { types_d$2_UnsealConditionProof as UnsealConditionProof };
-  export type { types_d$2_CompiledProof as CompiledProof, types_d$2_Proof as Proof, types_d$2_UnsealConditionProofData as UnsealConditionProofData };
-}
-
 declare abstract class ProofLibraryType {
     standard: {
         [key: string]: UnsealConditionProof;
@@ -5342,30 +4720,6 @@ declare abstract class UnsealConditionModule {
     }, current_proof_depth: number, fork?: boolean): CompiledModule;
 }
 
-type types_d$1_CompiledModule = CompiledModule;
-type types_d$1_IO = IO;
-type types_d$1_IOMap = IOMap;
-type types_d$1_IOType = IOType;
-type types_d$1_ModuleEdge = ModuleEdge;
-declare const types_d$1_ModuleEdge: typeof ModuleEdge;
-type types_d$1_ModuleEdgeInput = ModuleEdgeInput;
-declare const types_d$1_ModuleEdgeInput: typeof ModuleEdgeInput;
-type types_d$1_ModuleNode = ModuleNode;
-declare const types_d$1_ModuleNode: typeof ModuleNode;
-type types_d$1_ModuleOutput = ModuleOutput;
-type types_d$1_ModuleOutputMap = ModuleOutputMap;
-type types_d$1_ModuleProof = ModuleProof;
-type types_d$1_SignalEdge = SignalEdge;
-declare const types_d$1_SignalEdge: typeof SignalEdge;
-type types_d$1_UnsealConditionModule = UnsealConditionModule;
-declare const types_d$1_UnsealConditionModule: typeof UnsealConditionModule;
-type types_d$1_WrappedProof = WrappedProof;
-declare const types_d$1_WrappedProof: typeof WrappedProof;
-declare namespace types_d$1 {
-  export { types_d$1_ModuleEdge as ModuleEdge, types_d$1_ModuleEdgeInput as ModuleEdgeInput, types_d$1_ModuleNode as ModuleNode, types_d$1_SignalEdge as SignalEdge, types_d$1_UnsealConditionModule as UnsealConditionModule, types_d$1_WrappedProof as WrappedProof };
-  export type { types_d$1_CompiledModule as CompiledModule, types_d$1_IO as IO, types_d$1_IOMap as IOMap, types_d$1_IOType as IOType, types_d$1_ModuleOutput as ModuleOutput, types_d$1_ModuleOutputMap as ModuleOutputMap, types_d$1_ModuleProof as ModuleProof };
-}
-
 /**
  * Simplest possible proof collection.
  * Just proofs that a value is reference on chain.
@@ -5782,34 +5136,6 @@ declare class AddressMapWithDefault implements AddressMap {
     getAddress(key: string): string;
 }
 
-type types_d_AddressMap = AddressMap;
-type types_d_AddressMapWithDefault = AddressMapWithDefault;
-declare const types_d_AddressMapWithDefault: typeof AddressMapWithDefault;
-type types_d_BasicAddressMap = BasicAddressMap;
-declare const types_d_BasicAddressMap: typeof BasicAddressMap;
-type types_d_ChangedCallback = ChangedCallback;
-type types_d_ChangedType = ChangedType;
-declare const types_d_ChangedType: typeof ChangedType;
-type types_d_CollectionDataStream = CollectionDataStream;
-declare const types_d_CollectionDataStream: typeof CollectionDataStream;
-type types_d_CollectionEdge = CollectionEdge;
-declare const types_d_CollectionEdge: typeof CollectionEdge;
-type types_d_CollectionEdgeInput = CollectionEdgeInput;
-declare const types_d_CollectionEdgeInput: typeof CollectionEdgeInput;
-type types_d_CollectionNode = CollectionNode;
-declare const types_d_CollectionNode: typeof CollectionNode;
-type types_d_CompiledCollectionExport = CompiledCollectionExport;
-type types_d_DataStreamInput = DataStreamInput;
-type types_d_RequiredUserInput = RequiredUserInput;
-type types_d_UnsealConditionsProofPathDescriptor = UnsealConditionsProofPathDescriptor;
-declare const types_d_UnsealConditionsProofPathDescriptor: typeof UnsealConditionsProofPathDescriptor;
-declare const types_d_import_collectionedge_from_json: typeof import_collectionedge_from_json;
-declare const types_d_import_collectionnode_from_json: typeof import_collectionnode_from_json;
-declare namespace types_d {
-  export { types_d_AddressMapWithDefault as AddressMapWithDefault, types_d_BasicAddressMap as BasicAddressMap, types_d_ChangedType as ChangedType, types_d_CollectionDataStream as CollectionDataStream, types_d_CollectionEdge as CollectionEdge, types_d_CollectionEdgeInput as CollectionEdgeInput, types_d_CollectionNode as CollectionNode, types_d_UnsealConditionsProofPathDescriptor as UnsealConditionsProofPathDescriptor, types_d_import_collectionedge_from_json as import_collectionedge_from_json, types_d_import_collectionnode_from_json as import_collectionnode_from_json };
-  export type { types_d_AddressMap as AddressMap, types_d_ChangedCallback as ChangedCallback, types_d_CompiledCollectionExport as CompiledCollectionExport, types_d_DataStreamInput as DataStreamInput, types_d_RequiredUserInput as RequiredUserInput };
-}
-
 type HexString = string;
 type PaymentProof = string;
 type OpeningCondition = {
@@ -5902,246 +5228,1038 @@ declare enum ProcessorStatus {
     ERROR = -99
 }
 /**
- * Throwaway packages are local to the client during the sealing phase.
- * After the sealing phase is done, the throwaway packages/values are removed to secure unlinkability.
+ * Throwaway packages are local to the client during the sealing phase.
+ * After the sealing phase is done, the throwaway packages/values are removed to secure unlinkability.
+ */
+type SecretThrowawayPackage = {};
+/**
+ * This is an abstract type for all public packages.
+ * Packages marked as public can be shared externally to watch for events that relate to
+ * initiation of the revealing phase. Can be sent to centralized services to notify them of events.
+ *
+ */
+type PublicPackage = {};
+/**
+ * This is an abstract type for all hidden packages.
+ * This meant to be stored behind a password, here might live potentially linkable information.
+ * There is no direct purpose for this package YET.
+ */
+type HiddenPackage = {};
+/**
+ * This is an abstract type for all local private packages.
+ * It is meant to be stored with the client to generate reveal proofs.
+ * Packages marked as private can be used to initiate the revealing phase
+ */
+type PrivatePackage = {};
+type StaticCircuitInput = {
+    circuit_id: HexString;
+    inputfield_name: string;
+    value: HexString;
+};
+type ChainedCircuitInput = {
+    source_circuit_id: HexString;
+    source_circuit_index: number;
+    target_circuit_id: HexString;
+    outputfield_index: number;
+    inputfield_name: string;
+};
+type RevealCondition = {
+    address: HexString;
+    circuit_id: HexString;
+    static_inputs: StaticCircuitInput[];
+    chained_inputs: ChainedCircuitInput[];
+    random_value: HexString;
+    proof: any;
+    public_signals: any;
+};
+/**
+ * This is an abstract type for all reveal condition request packages.
+ * The request packages will be signed separately if the processor supports the address and circuit.
+ *
+ */
+type RevealConditionRequest = {
+    address: HexString;
+    circuit_id: HexString;
+    hashed_input_fields: HexString;
+    random_value: HexString;
+    proof: any;
+    public_signals: any;
+};
+type UnsealRevealConditionRequest = {
+    proof: HexString;
+    commitment: HexString;
+    public_signals: HexString[];
+};
+type RevealConditionRequestResponse = {
+    address: HexString;
+    circuit_id: HexString;
+    hashed_input_fields: HexString;
+    random_value: HexString;
+    signature_S: HexString;
+    signature_R8x: HexString;
+    signature_R8y: HexString;
+};
+type SingleSealRequest = {
+    address: HexString;
+    circuit_id: HexString;
+    hashed_reveal_value_preimage: HexString;
+    hashed_unseal_condition_root: HexString;
+    hashed_metadata_root: HexString;
+    require_proof: boolean;
+};
+type SingleSealRequestResponse = {
+    address: HexString;
+    circuit_id: HexString;
+    cyphertexts: [
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString
+    ];
+    empheral_keys: [
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString,
+        HexString
+    ];
+    signature_S: HexString;
+    signature_R8x: HexString;
+    signature_R8y: HexString;
+    new_public_key: [HexString, HexString];
+    severed_commitment_random_value: HexString;
+    proof: HexString;
+    public_signals: HexString[];
+    hashed_unseal_condition_root: HexString;
+    hashed_metadata_root: HexString;
+};
+type SingleUnsealRequest = {
+    address: HexString;
+    circuit_id: HexString;
+    public_key: [HexString, HexString];
+    signature_S: HexString;
+    signature_R8x: HexString;
+    signature_R8y: HexString;
+    proof: HexString;
+    public_signals: HexString[][];
+    proofs: HexString[];
+    empheral_keys: HexString[];
+    cyphertexts: HexString[];
+    data_stream_address: HexString;
+    unseal_proof_actions: UnsealProofAction[];
+    unseal_root_proof: ProofPath;
+};
+type SingleSealStoragePackage$1 = {
+    private_package: SingleShareSealPrivatePackage;
+    public_package: SingleShareSealPublicPackage;
+    hidden_package: SingleShareSealHiddenPackage;
+};
+type ECCEncryptedMessage = {
+    ciphertextHex: HexString;
+    R: {
+        x: HexString;
+        y: HexString;
+    };
+};
+type UnsealConditionTemplateExport = {
+    name: string;
+    description: string;
+    unseal_proof_actions: UnsealProofAction[][];
+    user_inputs: RequiredUserInput[][];
+    used_input_mapping: {
+        [key: string]: string;
+    };
+    compiled_collection: CompiledCollectionExport;
+    collection_id: string;
+};
+type SingleShareSealPrivatePackage = PrivatePackage & {
+    cyphertexts: HexString[];
+    empheral_keys: HexString[];
+    proof: any;
+    public_signals: any;
+    public_key_he: [HexString, HexString];
+    public_verification_key: [HexString, HexString];
+    encrypted_secret: ECCEncryptedMessage;
+    reveal_value: HexString;
+    unseal_condition_root: HexString;
+    metadata_root: HexString;
+    unseal_template: UnsealConditionTemplateExport;
+    proving_hints: any;
+    unseal_collection_id: string;
+};
+type SingleShareSealPublicPackage = PublicPackage & {
+    reveal_value: HexString;
+    address: HexString;
+    circuit_id: HexString;
+    data_stream_ids: HexString[];
+    proof: any;
+    public_signals: any;
+    data_stream_urls: string[];
+    processor_url: string;
+};
+type SingleShareSealHiddenPackage = HiddenPackage & {};
+type ThrowAwayShamirSecret = {
+    shamir_secret: bigint;
+    secret_ecc_scalar: bigint;
+    ecc_public_key: [bigint, bigint];
+};
+
+declare const from_json: (json_object: UnsealConditionTemplateExport, proof_library: ProofLibraryType, module_library: ModuleLibraryType) => UnsealConditionTemplate;
+declare class UnsealConditionTemplate {
+    name: string;
+    collection_id: string;
+    description: string;
+    proof_library: ProofLibraryType;
+    module_library: ModuleLibraryType;
+    compiled_collection: CompiledCollectionExport;
+    user_inputs: RequiredUserInput[][];
+    unsealProofActions: UnsealProofAction[][];
+    data_streams: DataStreamInput[][];
+    modules: UnsealConditionModule[];
+    used_input_mapping: {
+        [key: string]: any;
+    };
+    private proofs_cache;
+    constructor(name: string, description: string, proof_library: ProofLibraryType, module_library: ModuleLibraryType, compiled_collection: CompiledCollectionExport);
+    export_compiled_to_json(): UnsealConditionTemplateExport;
+    isCompiled(): boolean;
+    private getInputFromMapping;
+    compile(input_mapping: {
+        [key: string]: bigint;
+    }, data_stream_mapping: {
+        [key: string]: string;
+    }, optimize?: boolean): void;
+    address_to_proof(address: string): UnsealConditionProof;
+    /**
+     * Converts V1 unseal proof actions (2D output references via output_proof_index + output_signal_index)
+     * into V2 actions (flat output list with bitmask-based pruning at each chain_proof_verify).
+     *
+     * At each chain_proof_verify:
+     *   1. Append the new proof's outputs to the flat list
+     *   2. Look forward to find which flat entries are still referenced
+     *   3. Build a bitmask (1=keep, 0=remove) over the entire flat list
+     *   4. Prune dead entries
+     *
+     * PASS_SIGNAL and VALIDATE_DATA_ROOT actions are converted from 2D (proof_index, signal_index)
+     * to flat indices into the current output list.
+     */
+    optimize(unseal_proof_actions: UnsealProofAction[]): UnsealProofAction[];
+    /**
+     * Scans actions from startIdx onward to find which flat list entries
+     * are referenced by future PASS_SIGNAL and VALIDATE_DATA_ROOT actions.
+     * Returns the set of flat indices that are still needed.
+     */
+    private collectFutureReferences;
+    /**
+     * Finds an UnsealConditionProof by its on-chain verifier address.
+     * Searches through compiled modules to match the verifier_address
+     * in PREPARE_NEXT_PROOF actions to the corresponding proof.
+     */
+    private getProofByVerifierAddress;
+    getAllDataStreams(): string[];
+    getUnsealProofActions(): UnsealProofAction[][];
+    getExpectedInputs(): string[];
+    getUnsealRootForProof(proof_index: number): Promise<ProofPath>;
+    getUnsealRoot(): Promise<string>;
+}
+
+declare class UnsealConditionCollection {
+    nodes: {
+        [key: string]: CollectionNode;
+    };
+    edges: {
+        [key: string]: CollectionEdge;
+    };
+    comments: {
+        [key: string]: string;
+    };
+    data_streams: CollectionDataStream[];
+    name: string;
+    description: string;
+    starting_node: CollectionNode | undefined;
+    proofLibrary: ProofLibraryType;
+    moduleLibrary: ModuleLibraryType;
+    forks: {
+        [key: string]: string[];
+    };
+    fork_list: string[];
+    private node_to_fork_map;
+    private index_counter;
+    changed_callback: ChangedCallback;
+    constructor(name: string, description: string, proofLibrary: ProofLibraryType, moduleLibrary: ModuleLibraryType, changed_callback?: ChangedCallback);
+    visual_forks(): string[];
+    visual_edges_all(): string[][];
+    visual_edges(fork_id: string): string[];
+    comment(id: string, comment: string): void;
+    add_data_stream(datastream_id: string, from_node_id: string, field_name: string): void;
+    remove_data_stream(datastream_id: string): void;
+    get_data_stream(datastream_id: string): CollectionDataStream | undefined;
+    sort_fork_list(): void;
+    add_node(module: UnsealConditionModule, fork_from_node_id?: string): string;
+    move_node(node_id: string, new_fork_from_node_id: string, at_position?: number): CollectionEdge[];
+    remove_node(node_id: string): void;
+    remove_edge(edge_id: string): void;
+    all_nodes_for_fork(fork_id: string): {
+        nodes: string[];
+        forking: string[];
+    };
+    validate_edge(source_node_id: string | undefined, target_node_id: string | undefined, mapping: [string, any], input_type: CollectionEdgeInput): boolean;
+    add_edge(source_node_id: string | undefined, target_node_id: string | undefined, mapping: [string, any], input_type: CollectionEdgeInput): void;
+    export_to_json(): any;
+    import_from_json(data: any): void;
+    getEdgesToNode(node_id: string): CollectionEdge[];
+    getEdgesFromNode(node_id: string): CollectionEdge[];
+    getCollectionId(): string;
+    generateProofCode(fork_nr: number): string;
+    createTemplate(address_map: AddressMap): UnsealConditionTemplate;
+    createTemplatePerFork(address_map: AddressMap, sorted_nodes: string[], forking: string[]): {
+        compiled_modules: CompiledModule[];
+        user_inputs: RequiredUserInput[];
+        data_stream_inputs: DataStreamInput[];
+    };
+}
+
+/** Field is not always over prime: for example, Fp2 has ORDER(q)=p^m. */
+interface IField<T> {
+    ORDER: bigint;
+    isLE: boolean;
+    BYTES: number;
+    BITS: number;
+    MASK: bigint;
+    ZERO: T;
+    ONE: T;
+    create: (num: T) => T;
+    isValid: (num: T) => boolean;
+    is0: (num: T) => boolean;
+    neg(num: T): T;
+    inv(num: T): T;
+    sqrt(num: T): T;
+    sqr(num: T): T;
+    eql(lhs: T, rhs: T): boolean;
+    add(lhs: T, rhs: T): T;
+    sub(lhs: T, rhs: T): T;
+    mul(lhs: T, rhs: T | bigint): T;
+    pow(lhs: T, power: bigint): T;
+    div(lhs: T, rhs: T | bigint): T;
+    addN(lhs: T, rhs: T): T;
+    subN(lhs: T, rhs: T): T;
+    mulN(lhs: T, rhs: T | bigint): T;
+    sqrN(num: T): T;
+    isOdd?(num: T): boolean;
+    pow(lhs: T, power: bigint): T;
+    invertBatch: (lst: T[]) => T[];
+    toBytes(num: T): Uint8Array;
+    fromBytes(bytes: Uint8Array): T;
+    cmov(a: T, b: T, c: boolean): T;
+}
+
+/**
+ * Methods for elliptic curve multiplication by scalars.
+ * Contains wNAF, pippenger
+ * @module
+ */
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+
+type AffinePoint$1<T> = {
+    x: T;
+    y: T;
+} & {
+    z?: never;
+    t?: never;
+};
+interface Group$1<T extends Group$1<T>> {
+    double(): T;
+    negate(): T;
+    add(other: T): T;
+    subtract(other: T): T;
+    equals(other: T): boolean;
+    multiply(scalar: bigint): T;
+}
+type GroupConstructor$1<T> = {
+    BASE: T;
+    ZERO: T;
+};
+/**
+ * Generic BasicCurve interface: works even for polynomial fields (BLS): P, n, h would be ok.
+ * Though generator can be different (Fp2 / Fp6 for BLS).
+ */
+type BasicCurve<T> = {
+    Fp: IField<T>;
+    n: bigint;
+    nBitLength?: number;
+    nByteLength?: number;
+    h: bigint;
+    hEff?: bigint;
+    Gx: T;
+    Gy: T;
+    allowInfinityPoint?: boolean;
+};
+
+/**
+ * Hex, bytes and number utilities.
+ * @module
+ */
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+type Hex$1 = Uint8Array | string;
+type FHash = (message: Uint8Array | string) => Uint8Array;
+
+/**
+ * Twisted Edwards curve. The formula is: ax² + y² = 1 + dx²y².
+ * For design rationale of types / exports, see weierstrass module documentation.
+ * @module
+ */
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+
+/** Edwards curves must declare params a & d. */
+type CurveType = BasicCurve<bigint> & {
+    a: bigint;
+    d: bigint;
+    hash: FHash;
+    randomBytes: (bytesLength?: number) => Uint8Array;
+    adjustScalarBytes?: (bytes: Uint8Array) => Uint8Array;
+    domain?: (data: Uint8Array, ctx: Uint8Array, phflag: boolean) => Uint8Array;
+    uvRatio?: (u: bigint, v: bigint) => {
+        isValid: boolean;
+        value: bigint;
+    };
+    prehash?: FHash;
+    mapToCurve?: (scalar: bigint[]) => AffinePoint$1<bigint>;
+};
+type CurveTypeWithLength = Readonly<CurveType & {
+    nByteLength: number;
+    nBitLength: number;
+}>;
+declare function validateOpts(curve: CurveType): CurveTypeWithLength;
+/** Instance of Extended Point with coordinates in X, Y, Z, T. */
+interface ExtPointType$1 extends Group$1<ExtPointType$1> {
+    readonly ex: bigint;
+    readonly ey: bigint;
+    readonly ez: bigint;
+    readonly et: bigint;
+    get x(): bigint;
+    get y(): bigint;
+    assertValidity(): void;
+    multiply(scalar: bigint): ExtPointType$1;
+    multiplyUnsafe(scalar: bigint): ExtPointType$1;
+    isSmallOrder(): boolean;
+    isTorsionFree(): boolean;
+    clearCofactor(): ExtPointType$1;
+    toAffine(iz?: bigint): AffinePoint$1<bigint>;
+    toRawBytes(isCompressed?: boolean): Uint8Array;
+    toHex(isCompressed?: boolean): string;
+    _setWindowSize(windowSize: number): void;
+}
+/** Static methods of Extended Point with coordinates in X, Y, Z, T. */
+interface ExtPointConstructor$1 extends GroupConstructor$1<ExtPointType$1> {
+    new (x: bigint, y: bigint, z: bigint, t: bigint): ExtPointType$1;
+    fromAffine(p: AffinePoint$1<bigint>): ExtPointType$1;
+    fromHex(hex: Hex$1): ExtPointType$1;
+    fromPrivateKey(privateKey: Hex$1): ExtPointType$1;
+    msm(points: ExtPointType$1[], scalars: bigint[]): ExtPointType$1;
+}
+/**
+ * Edwards Curve interface.
+ * Main methods: `getPublicKey(priv)`, `sign(msg, priv)`, `verify(sig, msg, pub)`.
+ */
+type CurveFn = {
+    CURVE: ReturnType<typeof validateOpts>;
+    getPublicKey: (privateKey: Hex$1) => Uint8Array;
+    sign: (message: Hex$1, privateKey: Hex$1, options?: {
+        context?: Hex$1;
+    }) => Uint8Array;
+    verify: (sig: Hex$1, message: Hex$1, publicKey: Hex$1, options?: {
+        context?: Hex$1;
+        zip215: boolean;
+    }) => boolean;
+    ExtendedPoint: ExtPointConstructor$1;
+    utils: {
+        randomPrivateKey: () => Uint8Array;
+        getExtendedPublicKey: (key: Hex$1) => {
+            head: Uint8Array;
+            prefix: Uint8Array;
+            scalar: bigint;
+            point: ExtPointType$1;
+            pointBytes: Uint8Array;
+        };
+        precompute: (windowSize?: number, point?: ExtPointType$1) => ExtPointType$1;
+    };
+};
+
+type SnarkBigInt$1 = bigint;
+type PrivKey$1 = bigint;
+type PubKey$1 = ExtPointType$1;
+type BabyJubAffinePoint$1 = AffinePoint$1<bigint>;
+type BabyJubExtPoint$1 = ExtPointType$1;
+declare const babyJubNoble: CurveFn;
+/**
+ * A private key and a public key
+ */
+interface Keypair$1 {
+    privKey: PrivKey$1;
+    pubKey: PubKey$1;
+}
+declare const SNARK_FIELD_SIZE$1: SnarkBigInt$1;
+declare const babyJub$1: ExtPointConstructor$1;
+
+/**
+ * Public type surface — the single flat namespace for all Nihilium domain types.
+ *
+ * Re-exports every protocol / proof / module / collection declaration so consumers can
+ * reach them as `types.X` instead of the old nested `nhsdk.protocolTypes.X` /
+ * `nhsdk.CollectionTypes.X`. These modules mix type aliases with the classes, enums and
+ * functions they describe (e.g. BasicAddressMap, UnsealConditionCollection, the enums), so
+ * this barrel intentionally carries values too — it is emitted as real JS, not types-only.
+ *
+ * Flattening is collision-free (verified: 76 unique names across these modules).
+ */
+
+type public_d_AddressMap = AddressMap;
+type public_d_AddressMapWithDefault = AddressMapWithDefault;
+declare const public_d_AddressMapWithDefault: typeof AddressMapWithDefault;
+type public_d_BasicAddressMap = BasicAddressMap;
+declare const public_d_BasicAddressMap: typeof BasicAddressMap;
+type public_d_ChainedCircuitInput = ChainedCircuitInput;
+type public_d_ChangedCallback = ChangedCallback;
+type public_d_ChangedType = ChangedType;
+declare const public_d_ChangedType: typeof ChangedType;
+type public_d_ClientProcessorSealingPhase = ClientProcessorSealingPhase;
+declare const public_d_ClientProcessorSealingPhase: typeof ClientProcessorSealingPhase;
+type public_d_CollectionDataStream = CollectionDataStream;
+declare const public_d_CollectionDataStream: typeof CollectionDataStream;
+type public_d_CollectionEdge = CollectionEdge;
+declare const public_d_CollectionEdge: typeof CollectionEdge;
+type public_d_CollectionEdgeInput = CollectionEdgeInput;
+declare const public_d_CollectionEdgeInput: typeof CollectionEdgeInput;
+type public_d_CollectionNode = CollectionNode;
+declare const public_d_CollectionNode: typeof CollectionNode;
+type public_d_CompiledCollectionExport = CompiledCollectionExport;
+type public_d_CompiledModule = CompiledModule;
+type public_d_CompiledProof = CompiledProof;
+type public_d_DataStreamInput = DataStreamInput;
+type public_d_DualLatestGlobalLeafProofResult = DualLatestGlobalLeafProofResult;
+type public_d_DualProofResult = DualProofResult;
+type public_d_ECCEncryptedMessage = ECCEncryptedMessage;
+type public_d_HexString = HexString;
+type public_d_HiddenPackage = HiddenPackage;
+type public_d_IClientSingleShareSealingProcess = IClientSingleShareSealingProcess;
+type public_d_IClientSingleShareUnsealingProcess = IClientSingleShareUnsealingProcess;
+type public_d_IDataStream = IDataStream;
+type public_d_IDualDataStream = IDualDataStream;
+type public_d_IO = IO;
+type public_d_IOMap = IOMap;
+type public_d_IOType = IOType;
+type public_d_LatestGlobalLeafProofResult = LatestGlobalLeafProofResult;
+type public_d_ModuleEdge = ModuleEdge;
+declare const public_d_ModuleEdge: typeof ModuleEdge;
+type public_d_ModuleEdgeInput = ModuleEdgeInput;
+declare const public_d_ModuleEdgeInput: typeof ModuleEdgeInput;
+type public_d_ModuleNode = ModuleNode;
+declare const public_d_ModuleNode: typeof ModuleNode;
+type public_d_ModuleOutput = ModuleOutput;
+type public_d_ModuleOutputMap = ModuleOutputMap;
+type public_d_ModuleProof = ModuleProof;
+type public_d_OpeningCondition = OpeningCondition;
+declare const public_d_PROTOCOL_DATA_STREAM_PATHS: typeof PROTOCOL_DATA_STREAM_PATHS;
+declare const public_d_PROTOCOL_PROCESSOR_PATHS: typeof PROTOCOL_PROCESSOR_PATHS;
+type public_d_PaymentProof = PaymentProof;
+type public_d_PrivatePackage = PrivatePackage;
+type public_d_ProcessorEndpoint = ProcessorEndpoint;
+type public_d_ProcessorStatus = ProcessorStatus;
+declare const public_d_ProcessorStatus: typeof ProcessorStatus;
+type public_d_Proof = Proof;
+type public_d_ProofResult = ProofResult;
+type public_d_PublicPackage = PublicPackage;
+type public_d_RequestPackageStageOne = RequestPackageStageOne;
+type public_d_RequestPackageStageTwo = RequestPackageStageTwo;
+type public_d_RequiredUserInput = RequiredUserInput;
+type public_d_RevealCondition = RevealCondition;
+type public_d_RevealConditionRequest = RevealConditionRequest;
+type public_d_RevealConditionRequestResponse = RevealConditionRequestResponse;
+type public_d_RevealConditions = RevealConditions;
+declare const public_d_RevealConditions: typeof RevealConditions;
+type public_d_SecretThrowawayPackage = SecretThrowawayPackage;
+type public_d_SignalEdge = SignalEdge;
+declare const public_d_SignalEdge: typeof SignalEdge;
+type public_d_SingleSealRequest = SingleSealRequest;
+type public_d_SingleSealRequestResponse = SingleSealRequestResponse;
+type public_d_SingleSealUnsealRequestResponse = SingleSealUnsealRequestResponse;
+type public_d_SingleShareSealHiddenPackage = SingleShareSealHiddenPackage;
+type public_d_SingleShareSealPrivatePackage = SingleShareSealPrivatePackage;
+type public_d_SingleShareSealPublicPackage = SingleShareSealPublicPackage;
+type public_d_SingleUnsealRequest = SingleUnsealRequest;
+type public_d_StaticCircuitInput = StaticCircuitInput;
+type public_d_ThrowAwayShamirSecret = ThrowAwayShamirSecret;
+type public_d_UnsealConditionCollection = UnsealConditionCollection;
+declare const public_d_UnsealConditionCollection: typeof UnsealConditionCollection;
+type public_d_UnsealConditionModule = UnsealConditionModule;
+declare const public_d_UnsealConditionModule: typeof UnsealConditionModule;
+type public_d_UnsealConditionProof = UnsealConditionProof;
+declare const public_d_UnsealConditionProof: typeof UnsealConditionProof;
+type public_d_UnsealConditionProofData = UnsealConditionProofData;
+type public_d_UnsealConditionTemplate = UnsealConditionTemplate;
+declare const public_d_UnsealConditionTemplate: typeof UnsealConditionTemplate;
+type public_d_UnsealConditionTemplateExport = UnsealConditionTemplateExport;
+type public_d_UnsealConditionsProofPathDescriptor = UnsealConditionsProofPathDescriptor;
+declare const public_d_UnsealConditionsProofPathDescriptor: typeof UnsealConditionsProofPathDescriptor;
+type public_d_UnsealRevealConditionRequest = UnsealRevealConditionRequest;
+type public_d_UnsealingStatus = UnsealingStatus;
+declare const public_d_UnsealingStatus: typeof UnsealingStatus;
+type public_d_WrappedProof = WrappedProof;
+declare const public_d_WrappedProof: typeof WrappedProof;
+declare const public_d_babyJubNoble: typeof babyJubNoble;
+declare const public_d_from_json: typeof from_json;
+declare const public_d_import_collectionedge_from_json: typeof import_collectionedge_from_json;
+declare const public_d_import_collectionnode_from_json: typeof import_collectionnode_from_json;
+declare namespace public_d {
+  export { public_d_AddressMapWithDefault as AddressMapWithDefault, public_d_BasicAddressMap as BasicAddressMap, public_d_ChangedType as ChangedType, public_d_ClientProcessorSealingPhase as ClientProcessorSealingPhase, public_d_CollectionDataStream as CollectionDataStream, public_d_CollectionEdge as CollectionEdge, public_d_CollectionEdgeInput as CollectionEdgeInput, public_d_CollectionNode as CollectionNode, public_d_ModuleEdge as ModuleEdge, public_d_ModuleEdgeInput as ModuleEdgeInput, public_d_ModuleNode as ModuleNode, public_d_PROTOCOL_DATA_STREAM_PATHS as PROTOCOL_DATA_STREAM_PATHS, public_d_PROTOCOL_PROCESSOR_PATHS as PROTOCOL_PROCESSOR_PATHS, public_d_ProcessorStatus as ProcessorStatus, public_d_RevealConditions as RevealConditions, SNARK_FIELD_SIZE$1 as SNARK_FIELD_SIZE, public_d_SignalEdge as SignalEdge, public_d_UnsealConditionCollection as UnsealConditionCollection, public_d_UnsealConditionModule as UnsealConditionModule, public_d_UnsealConditionProof as UnsealConditionProof, public_d_UnsealConditionTemplate as UnsealConditionTemplate, public_d_UnsealConditionsProofPathDescriptor as UnsealConditionsProofPathDescriptor, public_d_UnsealingStatus as UnsealingStatus, public_d_WrappedProof as WrappedProof, babyJub$1 as babyJub, public_d_babyJubNoble as babyJubNoble, public_d_from_json as from_json, public_d_import_collectionedge_from_json as import_collectionedge_from_json, public_d_import_collectionnode_from_json as import_collectionnode_from_json };
+  export type { public_d_AddressMap as AddressMap, BabyJubAffinePoint$1 as BabyJubAffinePoint, BabyJubExtPoint$1 as BabyJubExtPoint, public_d_ChainedCircuitInput as ChainedCircuitInput, public_d_ChangedCallback as ChangedCallback, public_d_CompiledCollectionExport as CompiledCollectionExport, public_d_CompiledModule as CompiledModule, public_d_CompiledProof as CompiledProof, public_d_DataStreamInput as DataStreamInput, public_d_DualLatestGlobalLeafProofResult as DualLatestGlobalLeafProofResult, public_d_DualProofResult as DualProofResult, public_d_ECCEncryptedMessage as ECCEncryptedMessage, public_d_HexString as HexString, public_d_HiddenPackage as HiddenPackage, public_d_IClientSingleShareSealingProcess as IClientSingleShareSealingProcess, public_d_IClientSingleShareUnsealingProcess as IClientSingleShareUnsealingProcess, public_d_IDataStream as IDataStream, public_d_IDualDataStream as IDualDataStream, public_d_IO as IO, public_d_IOMap as IOMap, public_d_IOType as IOType, Keypair$1 as Keypair, public_d_LatestGlobalLeafProofResult as LatestGlobalLeafProofResult, public_d_ModuleOutput as ModuleOutput, public_d_ModuleOutputMap as ModuleOutputMap, public_d_ModuleProof as ModuleProof, public_d_OpeningCondition as OpeningCondition, public_d_PaymentProof as PaymentProof, PrivKey$1 as PrivKey, public_d_PrivatePackage as PrivatePackage, public_d_ProcessorEndpoint as ProcessorEndpoint, public_d_Proof as Proof, public_d_ProofResult as ProofResult, PubKey$1 as PubKey, public_d_PublicPackage as PublicPackage, public_d_RequestPackageStageOne as RequestPackageStageOne, public_d_RequestPackageStageTwo as RequestPackageStageTwo, public_d_RequiredUserInput as RequiredUserInput, public_d_RevealCondition as RevealCondition, public_d_RevealConditionRequest as RevealConditionRequest, public_d_RevealConditionRequestResponse as RevealConditionRequestResponse, public_d_SecretThrowawayPackage as SecretThrowawayPackage, public_d_SingleSealRequest as SingleSealRequest, public_d_SingleSealRequestResponse as SingleSealRequestResponse, SingleSealStoragePackage$1 as SingleSealStoragePackage, public_d_SingleSealUnsealRequestResponse as SingleSealUnsealRequestResponse, public_d_SingleShareSealHiddenPackage as SingleShareSealHiddenPackage, public_d_SingleShareSealPrivatePackage as SingleShareSealPrivatePackage, public_d_SingleShareSealPublicPackage as SingleShareSealPublicPackage, public_d_SingleUnsealRequest as SingleUnsealRequest, SnarkBigInt$1 as SnarkBigInt, public_d_StaticCircuitInput as StaticCircuitInput, public_d_ThrowAwayShamirSecret as ThrowAwayShamirSecret, public_d_UnsealConditionProofData as UnsealConditionProofData, public_d_UnsealConditionTemplateExport as UnsealConditionTemplateExport, public_d_UnsealRevealConditionRequest as UnsealRevealConditionRequest };
+}
+
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+
+type AffinePoint<T> = {
+    x: T;
+    y: T;
+} & {
+    z?: never;
+    t?: never;
+};
+interface Group<T extends Group<T>> {
+    double(): T;
+    negate(): T;
+    add(other: T): T;
+    subtract(other: T): T;
+    equals(other: T): boolean;
+    multiply(scalar: bigint): T;
+}
+type GroupConstructor<T> = {
+    BASE: T;
+    ZERO: T;
+};
+
+type Hex = Uint8Array | string;
+
+interface ExtPointType extends Group<ExtPointType> {
+    readonly ex: bigint;
+    readonly ey: bigint;
+    readonly ez: bigint;
+    readonly et: bigint;
+    get x(): bigint;
+    get y(): bigint;
+    assertValidity(): void;
+    multiply(scalar: bigint): ExtPointType;
+    multiplyUnsafe(scalar: bigint): ExtPointType;
+    isSmallOrder(): boolean;
+    isTorsionFree(): boolean;
+    clearCofactor(): ExtPointType;
+    toAffine(iz?: bigint): AffinePoint<bigint>;
+    toRawBytes(isCompressed?: boolean): Uint8Array;
+    toHex(isCompressed?: boolean): string;
+}
+interface ExtPointConstructor extends GroupConstructor<ExtPointType> {
+    new (x: bigint, y: bigint, z: bigint, t: bigint): ExtPointType;
+    fromAffine(p: AffinePoint<bigint>): ExtPointType;
+    fromHex(hex: Hex): ExtPointType;
+    fromPrivateKey(privateKey: Hex): ExtPointType;
+}
+
+type SnarkBigInt = bigint;
+type PrivKey = bigint;
+type PubKey = ExtPointType;
+type BabyJubAffinePoint = AffinePoint<bigint>;
+type BabyJubExtPoint = ExtPointType;
+/**
+ * A private key and a public key
+ */
+interface Keypair {
+    privKey: PrivKey;
+    pubKey: PubKey;
+}
+declare const SNARK_FIELD_SIZE: SnarkBigInt;
+declare const babyJub: ExtPointConstructor;
+
+declare const stringifyBigInts: (obj: object) => any;
+declare const unstringifyBigInts: (obj: object) => any;
+
+declare function createNobleBlakeHash(data: Buffer): Buffer<ArrayBuffer>;
+declare function generateRandom248BitNumber(): bigint;
+declare function generateRandom240BitNumber(): bigint;
+declare function shrinkToBits(number: bigint, bits: number): bigint;
+/**
+ * Split a very large number into chunks of 32 bits each.
+ * @param {BigInt} number - A BigInt representing the large number.
+ * @returns {Array<BigInt>} - An array of chunks (BigInts).
+ */
+declare function splitLargeNumber(number: bigint, size?: bigint): any[];
+/**
+ * Combine chunks of 32 bits each into the original large number.
+ * @param {Array<BigInt>} chunks - An array of chunks (BigInts).
+ * @param {BigInt} size - The size of each chunk in bits.
+ * @returns {BigInt} - The combined large number.
+ */
+declare function combineChunksWithCarry(chunks: bigint[], size?: bigint): bigint;
+declare function pruneBuffer(buff: Buffer): Buffer<ArrayBufferLike>;
+declare function stringToCurve(mimc: any, string: string): any;
+declare function prv2pub(prv: Buffer): ExtPointType;
+declare function ffEncodedToBigInt(babyJub: any, encoded: bigint): any;
+/**
+ * An internal function which formats a random private key to be compatible
+ * with the BabyJub curve. This is the format which should be passed into the
+ * PubKey and other circuits.
+ */
+declare function formatPrivKeyForBabyJub(privKey: bigint): any;
+/**
+ * Function to use when you have just the scalar value of the private key
+ * and you need to convert it to the public key (Ax, Ay)
+ */
+declare function privateScalarToPubKey(p: bigint): [bigint, bigint];
+/**
+ * Convert a BigInt to a Buffer
+ */
+declare const bigInt2Buffer: (i: BigInt) => Buffer;
+declare const hexString2Buffer: (i: string) => Buffer;
+declare const buffer2HexString: (i: Buffer) => string;
+declare const uint8ArrayToHex: (uint8Array: Uint8Array | any) => string;
+/**
+ * Convert an EC extended point into an array of two bigints
+ */
+declare function toBigIntArray(point: BabyJubExtPoint): [bigint, bigint];
+/**
+ * Convert an EC extended point into an array of two strings
+ */
+declare function toStringArray(point: BabyJubExtPoint): [string, string];
+declare function combineTwoPublicKeys(pubKey1: bigint[], pubKey2: bigint[]): bigint[];
+declare function combineTwoPublicKeysPlain(pubKey1: bigint[], pubKey2: bigint[]): bigint[];
+/**
+ * Convert two strings x and y into an EC extended point
+ */
+declare function coordinatesToExtPoint(x: string, y: string): BabyJubExtPoint;
+declare const bufferToBigInt: (buf: Buffer | Uint8Array) => bigint;
+declare function coordinatesToExtPointBigint(x: bigint, y: bigint): BabyJubExtPoint;
+declare function portableArgon2(data: Buffer, options?: {
+    memory: number;
+    iterations: number;
+    parallelism: number;
+}): Buffer;
+/**
+ * Returns a Uint8Array of cryptographically secure random bytes.
+ * This function works in both browser and Node.js environments.
+ * In browsers, it uses window.crypto.getRandomValues.
+ * In Node.js, it uses require('crypto').randomBytes if available.
+ * @param length Number of random bytes to generate.
+ * @returns Uint8Array of random bytes.
+ */
+declare function portableRandomBytes(length: number): Buffer;
+declare function generateNonces(): bigint[];
+declare function HEEncryptFromPoint(message: bigint, pubKey: ExtPointType, nonces?: bigint[], exportNonces?: boolean): {
+    ephemeral_keys: ExtPointType[];
+    encrypted_messages: ExtPointType[];
+    nonces: bigint[];
+};
+declare function SimpelElgamalEncrypt(message: bigint, pubKey: PubKey, bitSize?: number): {
+    ephemeral_key: string;
+    encrypted_message: string;
+};
+declare function SimpelElgamalDecrypt(encrypted_message: string, ephemeral_key: string, privKey: PrivKey): bigint;
+declare function HEEncrypt(message: bigint, pubKey: bigint[], nonces?: bigint[], exportNonces?: boolean): {
+    ephemeral_keys: ExtPointType[];
+    encrypted_messages: ExtPointType[];
+    nonces: bigint[];
+};
+declare function HEDecryptExternalSolver(privKey: bigint, cypherTexts: bigint[], ephemeralKeys: bigint[], solve: (base_x: bigint, base_y: bigint, encoded_x: bigint, encoded_y: bigint) => bigint): Promise<bigint>;
+declare function HEDecrypt(privKey: bigint, cypherTexts: bigint[], ephemeralKeys: bigint[]): Promise<bigint>;
+declare function HEDecryptSync(privKey: bigint, cypherTexts: bigint[], ephemeralKeys: bigint[]): bigint;
+declare const hashExtPoints: (extPoints: ExtPointType[]) => bigint;
+declare const hashCypherText: (message: bigint[], ephemeralKey: bigint[], relatedPublicKey: bigint[], preimage_hash: any, random_value: bigint, unseal_condition_root_hash: any, metadata_root_commit: any) => bigint;
+declare function pruneTo64Bits(originalValue: bigint): bigint;
+declare function pruneTo32Bits(bigInt253Bit: bigint): bigint;
+/**
+ * - Returns a signal value similar to the "callGetSignalByName" function from the "circom-helper" package.
+ * - This function depends on the "circom_tester" package.
+ *
+ * Example usage:
+ *
+ * ```typescript
+ * const wasm_tester = require('circom_tester').wasm;
+ *
+ * /// the circuit is loaded only once and it is available for use across multiple test cases.
+ * const circuit = await wasm_tester(path.resolve("./circuit/path"));
+ * const witness = await circuit.calculateWitness(inputsObject);
+ * await circuit.checkConstraints(witness);
+ * await circuit.loadSymbols();
+ *
+ * /// You can check signal names by printing "circuit.symbols".
+ * /// You will mostly need circuit inputs and outputs.
+ * const singalName = 'main.out'
+ * const signalValue = getSignalByName(circuit, witness, SignalName)
+ * ```
+ */
+declare const getSignalByName: (circuit: any, witness: any, signalName: string) => any;
+/**
+ * Encrypts a BigInt value using AES-256-CBC encryption
+ * @param value - The BigInt value to encrypt
+ * @param key - The encryption key as a BigInt
+ * @returns The encrypted value as a hex string
+ */
+declare function encryptAESBigInt(value: bigint, key: bigint): string;
+/**
+ * Decrypts a hex string back to a BigInt value using AES-256-CBC decryption
+ * @param encryptedHex - The encrypted value as a hex string
+ * @param key - The decryption key as a BigInt
+ * @returns The decrypted BigInt value
+ */
+declare function decryptAESBigInt(encryptedHex: string, key: bigint): bigint;
+declare function toBytesLE(bn: bigint, length?: number): Uint8Array;
+declare function fromBytesLE(bytes: Uint8Array): bigint;
+declare function encryptECCBabyJub(message: bigint, recipientPubKey: PubKey, nonce?: bigint | undefined, emperalKey?: ExtPointType | undefined): {
+    ciphertextHex: string;
+    R: {
+        x: string;
+        y: string;
+    };
+};
+declare function decryptECCBabyJub(ciphertextHex: string, RHex: {
+    x: string;
+    y: string;
+}, recipientPrivKey: PrivKey): bigint;
+/**
+ * Returns a BabyJub-compatible random value. We create it by first generating
+ * a random value (initially 256 bits large) modulo the snark field size as
+ * described in EIP197. This results in a key size of roughly 253 bits and no
+ * more than 254 bits. To prevent modulo bias, we then use this efficient
+ * algorithm:
+ * http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/lib/libc/crypt/arc4random_uniform.c
+ * @return A BabyJub-compatible random value.
+ * @see {@link https://github.com/privacy-scaling-explorations/maci/blob/master/crypto/ts/index.ts}
  */
-type SecretThrowawayPackage = {};
+declare function genRandomBabyJubValue(): bigint;
+declare function genSmallRandomBabyJubValue(): bigint;
 /**
- * This is an abstract type for all public packages.
- * Packages marked as public can be shared externally to watch for events that relate to
- * initiation of the revealing phase. Can be sent to centralized services to notify them of events.
- *
+ * @return A BabyJub-compatible private key.
  */
-type PublicPackage = {};
+declare const genPrivKey: () => PrivKey;
 /**
- * This is an abstract type for all hidden packages.
- * This meant to be stored behind a password, here might live potentially linkable information.
- * There is no direct purpose for this package YET.
+ * @return A BabyJub-compatible salt.
  */
-type HiddenPackage = {};
+declare const genRandomSalt: () => PrivKey;
 /**
- * This is an abstract type for all local private packages.
- * It is meant to be stored with the client to generate reveal proofs.
- * Packages marked as private can be used to initiate the revealing phase
+ * @param privKey A private key generated using genPrivKey()
+ * @return A public key associated with the private key
  */
-type PrivatePackage = {};
-type StaticCircuitInput = {
-    circuit_id: HexString;
-    inputfield_name: string;
-    value: HexString;
-};
-type ChainedCircuitInput = {
-    source_circuit_id: HexString;
-    source_circuit_index: number;
-    target_circuit_id: HexString;
-    outputfield_index: number;
-    inputfield_name: string;
-};
-type RevealCondition = {
-    address: HexString;
-    circuit_id: HexString;
-    static_inputs: StaticCircuitInput[];
-    chained_inputs: ChainedCircuitInput[];
-    random_value: HexString;
-    proof: any;
-    public_signals: any;
-};
+declare function genPubKey(privKey: PrivKey): PubKey;
+declare function genKeypair(scalar?: bigint): Keypair;
 /**
- * This is an abstract type for all reveal condition request packages.
- * The request packages will be signed separately if the processor supports the address and circuit.
- *
+ * Encrypts a plaintext such that only the owner of the specified public key
+ * may decrypt it.
+ * @param pubKey The recepient's public key
+ * @param encodedMessage A plaintext encoded as a BabyJub curve point (optional)
+ * @param randomVal A random value y used along with the private key to generate the ciphertext (optional)
  */
-type RevealConditionRequest = {
-    address: HexString;
-    circuit_id: HexString;
-    hashed_input_fields: HexString;
-    random_value: HexString;
-    proof: any;
-    public_signals: any;
-};
-type UnsealRevealConditionRequest = {
-    proof: HexString;
-    commitment: HexString;
-    public_signals: HexString[];
-};
-type RevealConditionRequestResponse = {
-    address: HexString;
-    circuit_id: HexString;
-    hashed_input_fields: HexString;
-    random_value: HexString;
-    signature_S: HexString;
-    signature_R8x: HexString;
-    signature_R8y: HexString;
-};
-type SingleSealRequest = {
-    address: HexString;
-    circuit_id: HexString;
-    hashed_reveal_value_preimage: HexString;
-    hashed_unseal_condition_root: HexString;
-    hashed_metadata_root: HexString;
-    require_proof: boolean;
-};
-type SingleSealRequestResponse = {
-    address: HexString;
-    circuit_id: HexString;
-    cyphertexts: [
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString
-    ];
-    empheral_keys: [
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString,
-        HexString
-    ];
-    signature_S: HexString;
-    signature_R8x: HexString;
-    signature_R8y: HexString;
-    new_public_key: [HexString, HexString];
-    severed_commitment_random_value: HexString;
-    proof: HexString;
-    public_signals: HexString[];
-    hashed_unseal_condition_root: HexString;
-    hashed_metadata_root: HexString;
-};
-type SingleUnsealRequest = {
-    address: HexString;
-    circuit_id: HexString;
-    public_key: [HexString, HexString];
-    signature_S: HexString;
-    signature_R8x: HexString;
-    signature_R8y: HexString;
-    proof: HexString;
-    public_signals: HexString[][];
-    proofs: HexString[];
-    empheral_keys: HexString[];
-    cyphertexts: HexString[];
-    data_stream_address: HexString;
-    unseal_proof_actions: UnsealProofAction[];
-    unseal_root_proof: ProofPath;
-};
-type SingleSealStoragePackage$1 = {
-    private_package: SingleShareSealPrivatePackage;
-    public_package: SingleShareSealPublicPackage;
-    hidden_package: SingleShareSealHiddenPackage;
-};
-type ECCEncryptedMessage = {
-    ciphertextHex: HexString;
-    R: {
-        x: HexString;
-        y: HexString;
-    };
-};
-type UnsealConditionTemplateExport = {
-    name: string;
-    description: string;
-    unseal_proof_actions: UnsealProofAction[][];
-    user_inputs: RequiredUserInput[][];
-    used_input_mapping: {
-        [key: string]: string;
-    };
-    compiled_collection: CompiledCollectionExport;
-    collection_id: string;
+declare function encrypt(pubKey: PubKey, encodedMessage: BabyJubExtPoint, randomVal?: bigint): {
+    message: ExtPointType;
+    ephemeral_key: ExtPointType;
+    encrypted_message: ExtPointType;
+    nonce: bigint;
 };
-type SingleShareSealPrivatePackage = PrivatePackage & {
-    cyphertexts: HexString[];
-    empheral_keys: HexString[];
-    proof: any;
-    public_signals: any;
-    public_key_he: [HexString, HexString];
-    public_verification_key: [HexString, HexString];
-    encrypted_secret: ECCEncryptedMessage;
-    reveal_value: HexString;
-    unseal_condition_root: HexString;
-    metadata_root: HexString;
-    unseal_template: UnsealConditionTemplateExport;
-    proving_hints: any;
-    unseal_collection_id: string;
+/**
+ * Decrypts a ciphertext using a private key.
+ * @param privKey The private key
+ * @param ciphertext The ciphertext to decrypt
+ */
+declare function decrypt(privKey: PrivKey, ephemeral_key: BabyJubExtPoint, encrypted_message: BabyJubExtPoint): BabyJubExtPoint;
+declare function HEAdd(empheralKey1: ExtPointType, empheralKey2: ExtPointType, encryptedMessage1: ExtPointType, encryptedMessage2: ExtPointType): {
+    ephemeralKey: ExtPointType;
+    encryptedMessage: ExtPointType;
 };
-type SingleShareSealPublicPackage = PublicPackage & {
-    reveal_value: HexString;
-    address: HexString;
-    circuit_id: HexString;
-    data_stream_ids: HexString[];
-    proof: any;
-    public_signals: any;
-    data_stream_urls: string[];
-    processor_url: string;
+declare function HEAddAll(empheralKeys1: ExtPointType[], empheralKeys2: ExtPointType[], encryptedMessages1: ExtPointType[], encryptedMessages2: ExtPointType[]): {
+    ephemeralKeys: ExtPointType[];
+    encryptedMessages: ExtPointType[];
 };
-type SingleShareSealHiddenPackage = HiddenPackage & {};
-type ThrowAwayShamirSecret = {
-    shamir_secret: bigint;
-    secret_ecc_scalar: bigint;
-    ecc_public_key: [bigint, bigint];
+declare function encrypt_s(message: BabyJubExtPoint, public_key: PubKey, nonce?: bigint): {
+    ephemeral_key: ExtPointType;
+    encrypted_message: ExtPointType;
 };
 
-type common_d_ChainedCircuitInput = ChainedCircuitInput;
-type common_d_ClientProcessorSealingPhase = ClientProcessorSealingPhase;
-declare const common_d_ClientProcessorSealingPhase: typeof ClientProcessorSealingPhase;
-type common_d_ECCEncryptedMessage = ECCEncryptedMessage;
-type common_d_HexString = HexString;
-type common_d_HiddenPackage = HiddenPackage;
-type common_d_IClientSingleShareSealingProcess = IClientSingleShareSealingProcess;
-type common_d_IClientSingleShareUnsealingProcess = IClientSingleShareUnsealingProcess;
-type common_d_OpeningCondition = OpeningCondition;
-declare const common_d_PROTOCOL_DATA_STREAM_PATHS: typeof PROTOCOL_DATA_STREAM_PATHS;
-declare const common_d_PROTOCOL_PROCESSOR_PATHS: typeof PROTOCOL_PROCESSOR_PATHS;
-type common_d_PaymentProof = PaymentProof;
-type common_d_PrivatePackage = PrivatePackage;
-type common_d_ProcessorEndpoint = ProcessorEndpoint;
-type common_d_ProcessorStatus = ProcessorStatus;
-declare const common_d_ProcessorStatus: typeof ProcessorStatus;
-type common_d_PublicPackage = PublicPackage;
-type common_d_RequestPackageStageOne = RequestPackageStageOne;
-type common_d_RequestPackageStageTwo = RequestPackageStageTwo;
-type common_d_RevealCondition = RevealCondition;
-type common_d_RevealConditionRequest = RevealConditionRequest;
-type common_d_RevealConditionRequestResponse = RevealConditionRequestResponse;
-type common_d_RevealConditions = RevealConditions;
-declare const common_d_RevealConditions: typeof RevealConditions;
-type common_d_SecretThrowawayPackage = SecretThrowawayPackage;
-type common_d_SingleSealRequest = SingleSealRequest;
-type common_d_SingleSealRequestResponse = SingleSealRequestResponse;
-type common_d_SingleSealUnsealRequestResponse = SingleSealUnsealRequestResponse;
-type common_d_SingleShareSealHiddenPackage = SingleShareSealHiddenPackage;
-type common_d_SingleShareSealPrivatePackage = SingleShareSealPrivatePackage;
-type common_d_SingleShareSealPublicPackage = SingleShareSealPublicPackage;
-type common_d_SingleUnsealRequest = SingleUnsealRequest;
-type common_d_StaticCircuitInput = StaticCircuitInput;
-type common_d_ThrowAwayShamirSecret = ThrowAwayShamirSecret;
-type common_d_UnsealConditionTemplateExport = UnsealConditionTemplateExport;
-type common_d_UnsealRevealConditionRequest = UnsealRevealConditionRequest;
-type common_d_UnsealingStatus = UnsealingStatus;
-declare const common_d_UnsealingStatus: typeof UnsealingStatus;
-declare namespace common_d {
-  export { common_d_ClientProcessorSealingPhase as ClientProcessorSealingPhase, common_d_PROTOCOL_DATA_STREAM_PATHS as PROTOCOL_DATA_STREAM_PATHS, common_d_PROTOCOL_PROCESSOR_PATHS as PROTOCOL_PROCESSOR_PATHS, common_d_ProcessorStatus as ProcessorStatus, common_d_RevealConditions as RevealConditions, common_d_UnsealingStatus as UnsealingStatus };
-  export type { common_d_ChainedCircuitInput as ChainedCircuitInput, common_d_ECCEncryptedMessage as ECCEncryptedMessage, common_d_HexString as HexString, common_d_HiddenPackage as HiddenPackage, common_d_IClientSingleShareSealingProcess as IClientSingleShareSealingProcess, common_d_IClientSingleShareUnsealingProcess as IClientSingleShareUnsealingProcess, common_d_OpeningCondition as OpeningCondition, common_d_PaymentProof as PaymentProof, common_d_PrivatePackage as PrivatePackage, common_d_ProcessorEndpoint as ProcessorEndpoint, common_d_PublicPackage as PublicPackage, common_d_RequestPackageStageOne as RequestPackageStageOne, common_d_RequestPackageStageTwo as RequestPackageStageTwo, common_d_RevealCondition as RevealCondition, common_d_RevealConditionRequest as RevealConditionRequest, common_d_RevealConditionRequestResponse as RevealConditionRequestResponse, common_d_SecretThrowawayPackage as SecretThrowawayPackage, common_d_SingleSealRequest as SingleSealRequest, common_d_SingleSealRequestResponse as SingleSealRequestResponse, SingleSealStoragePackage$1 as SingleSealStoragePackage, common_d_SingleSealUnsealRequestResponse as SingleSealUnsealRequestResponse, common_d_SingleShareSealHiddenPackage as SingleShareSealHiddenPackage, common_d_SingleShareSealPrivatePackage as SingleShareSealPrivatePackage, common_d_SingleShareSealPublicPackage as SingleShareSealPublicPackage, common_d_SingleUnsealRequest as SingleUnsealRequest, common_d_StaticCircuitInput as StaticCircuitInput, common_d_ThrowAwayShamirSecret as ThrowAwayShamirSecret, common_d_UnsealConditionTemplateExport as UnsealConditionTemplateExport, common_d_UnsealRevealConditionRequest as UnsealRevealConditionRequest };
+/** Canonical uint256 secret material (0x00abc and 0xabc are the same integer). */
+declare function normalizeSigningKeyMaterial(hexKey: string): bigint;
+/**
+ * Raw secret bytes for EdDSA (@zk-kit/eddsa-poseidon) from canonical integer hex.
+ * Leading zero nybbles in the env string are not preserved as extra bytes.
+ */
+declare function hexToSkBuffer(hexKey: string): Buffer;
+/**
+ * Derive the scalar used inside the HE (ElGamal) key derivation.
+ * This is `formatPrivKeyForBabyJub(BigInt(hexKey))` and matches the scalar
+ * used in `genPubKey` / `HEDecrypt` / `encrypt`.
+ *
+ * @param hexKey  0x-prefixed 32-byte private key hex string
+ */
+declare function deriveHEKeyScalar(hexKey: string): bigint;
+/**
+ * Derive the HE public key `[x, y]` from a raw private key hex string.
+ * Equivalent to `genPubKey(BigInt(hexKey))` but accepts a hex string and
+ * returns affine coordinates rather than an ExtPointType.
+ *
+ * @param hexKey  0x-prefixed 32-byte private key hex string
+ */
+declare function deriveHEPublicKey(hexKey: string): [bigint, bigint];
+/**
+ * Derive the scalar used inside the EdDSA signing key derivation (Schnorr PoK).
+ * Matches `@zk-kit/eddsa-poseidon.deriveSecretScalar`.
+ *
+ * @param hexKey  0x-prefixed private key hex string
+ */
+declare function deriveSigningKeyScalar(hexKey: string): Promise<bigint>;
+/**
+ * Derive the EdDSA signing public key `[x, y]` from a raw private key hex string.
+ * Matches `@zk-kit/eddsa-poseidon.derivePublicKey` used by the Processor and circuits.
+ *
+ * @param hexKey  0x-prefixed private key hex string
+ */
+declare function deriveSigningPublicKey(hexKey: string): Promise<[bigint, bigint]>;
+
+type tools_d_BabyJubAffinePoint = BabyJubAffinePoint;
+type tools_d_BabyJubExtPoint = BabyJubExtPoint;
+declare const tools_d_HEAdd: typeof HEAdd;
+declare const tools_d_HEAddAll: typeof HEAddAll;
+declare const tools_d_HEDecrypt: typeof HEDecrypt;
+declare const tools_d_HEDecryptExternalSolver: typeof HEDecryptExternalSolver;
+declare const tools_d_HEDecryptSync: typeof HEDecryptSync;
+declare const tools_d_HEEncrypt: typeof HEEncrypt;
+declare const tools_d_HEEncryptFromPoint: typeof HEEncryptFromPoint;
+type tools_d_Keypair = Keypair;
+type tools_d_PrivKey = PrivKey;
+type tools_d_PubKey = PubKey;
+declare const tools_d_SNARK_FIELD_SIZE: typeof SNARK_FIELD_SIZE;
+declare const tools_d_SimpelElgamalDecrypt: typeof SimpelElgamalDecrypt;
+declare const tools_d_SimpelElgamalEncrypt: typeof SimpelElgamalEncrypt;
+declare const tools_d_babyJub: typeof babyJub;
+declare const tools_d_bigInt2Buffer: typeof bigInt2Buffer;
+declare const tools_d_buffer2HexString: typeof buffer2HexString;
+declare const tools_d_bufferToBigInt: typeof bufferToBigInt;
+declare const tools_d_combineChunksWithCarry: typeof combineChunksWithCarry;
+declare const tools_d_combineTwoPublicKeys: typeof combineTwoPublicKeys;
+declare const tools_d_combineTwoPublicKeysPlain: typeof combineTwoPublicKeysPlain;
+declare const tools_d_coordinatesToExtPoint: typeof coordinatesToExtPoint;
+declare const tools_d_coordinatesToExtPointBigint: typeof coordinatesToExtPointBigint;
+declare const tools_d_createNobleBlakeHash: typeof createNobleBlakeHash;
+declare const tools_d_decrypt: typeof decrypt;
+declare const tools_d_decryptAESBigInt: typeof decryptAESBigInt;
+declare const tools_d_decryptECCBabyJub: typeof decryptECCBabyJub;
+declare const tools_d_deriveHEKeyScalar: typeof deriveHEKeyScalar;
+declare const tools_d_deriveHEPublicKey: typeof deriveHEPublicKey;
+declare const tools_d_deriveSigningKeyScalar: typeof deriveSigningKeyScalar;
+declare const tools_d_deriveSigningPublicKey: typeof deriveSigningPublicKey;
+declare const tools_d_encrypt: typeof encrypt;
+declare const tools_d_encryptAESBigInt: typeof encryptAESBigInt;
+declare const tools_d_encryptECCBabyJub: typeof encryptECCBabyJub;
+declare const tools_d_encrypt_s: typeof encrypt_s;
+declare const tools_d_ffEncodedToBigInt: typeof ffEncodedToBigInt;
+declare const tools_d_formatPrivKeyForBabyJub: typeof formatPrivKeyForBabyJub;
+declare const tools_d_fromBytesLE: typeof fromBytesLE;
+declare const tools_d_genKeypair: typeof genKeypair;
+declare const tools_d_genPrivKey: typeof genPrivKey;
+declare const tools_d_genPubKey: typeof genPubKey;
+declare const tools_d_genRandomBabyJubValue: typeof genRandomBabyJubValue;
+declare const tools_d_genRandomSalt: typeof genRandomSalt;
+declare const tools_d_genSmallRandomBabyJubValue: typeof genSmallRandomBabyJubValue;
+declare const tools_d_generateNonces: typeof generateNonces;
+declare const tools_d_generateRandom240BitNumber: typeof generateRandom240BitNumber;
+declare const tools_d_generateRandom248BitNumber: typeof generateRandom248BitNumber;
+declare const tools_d_getSignalByName: typeof getSignalByName;
+declare const tools_d_hashCypherText: typeof hashCypherText;
+declare const tools_d_hashExtPoints: typeof hashExtPoints;
+declare const tools_d_hexString2Buffer: typeof hexString2Buffer;
+declare const tools_d_hexToSkBuffer: typeof hexToSkBuffer;
+declare const tools_d_normalizeSigningKeyMaterial: typeof normalizeSigningKeyMaterial;
+declare const tools_d_portableArgon2: typeof portableArgon2;
+declare const tools_d_portableRandomBytes: typeof portableRandomBytes;
+declare const tools_d_privateScalarToPubKey: typeof privateScalarToPubKey;
+declare const tools_d_pruneBuffer: typeof pruneBuffer;
+declare const tools_d_pruneTo32Bits: typeof pruneTo32Bits;
+declare const tools_d_pruneTo64Bits: typeof pruneTo64Bits;
+declare const tools_d_prv2pub: typeof prv2pub;
+declare const tools_d_shrinkToBits: typeof shrinkToBits;
+declare const tools_d_splitLargeNumber: typeof splitLargeNumber;
+declare const tools_d_stringToCurve: typeof stringToCurve;
+declare const tools_d_stringifyBigInts: typeof stringifyBigInts;
+declare const tools_d_toBigIntArray: typeof toBigIntArray;
+declare const tools_d_toBytesLE: typeof toBytesLE;
+declare const tools_d_toStringArray: typeof toStringArray;
+declare const tools_d_uint8ArrayToHex: typeof uint8ArrayToHex;
+declare const tools_d_unstringifyBigInts: typeof unstringifyBigInts;
+declare namespace tools_d {
+  export { tools_d_HEAdd as HEAdd, tools_d_HEAddAll as HEAddAll, tools_d_HEDecrypt as HEDecrypt, tools_d_HEDecryptExternalSolver as HEDecryptExternalSolver, tools_d_HEDecryptSync as HEDecryptSync, tools_d_HEEncrypt as HEEncrypt, tools_d_HEEncryptFromPoint as HEEncryptFromPoint, tools_d_SNARK_FIELD_SIZE as SNARK_FIELD_SIZE, tools_d_SimpelElgamalDecrypt as SimpelElgamalDecrypt, tools_d_SimpelElgamalEncrypt as SimpelElgamalEncrypt, tools_d_babyJub as babyJub, tools_d_bigInt2Buffer as bigInt2Buffer, tools_d_buffer2HexString as buffer2HexString, tools_d_bufferToBigInt as bufferToBigInt, tools_d_combineChunksWithCarry as combineChunksWithCarry, tools_d_combineTwoPublicKeys as combineTwoPublicKeys, tools_d_combineTwoPublicKeysPlain as combineTwoPublicKeysPlain, tools_d_coordinatesToExtPoint as coordinatesToExtPoint, tools_d_coordinatesToExtPointBigint as coordinatesToExtPointBigint, tools_d_createNobleBlakeHash as createNobleBlakeHash, tools_d_decrypt as decrypt, tools_d_decryptAESBigInt as decryptAESBigInt, tools_d_decryptECCBabyJub as decryptECCBabyJub, tools_d_deriveHEKeyScalar as deriveHEKeyScalar, tools_d_deriveHEPublicKey as deriveHEPublicKey, tools_d_deriveSigningKeyScalar as deriveSigningKeyScalar, tools_d_deriveSigningPublicKey as deriveSigningPublicKey, tools_d_encrypt as encrypt, tools_d_encryptAESBigInt as encryptAESBigInt, tools_d_encryptECCBabyJub as encryptECCBabyJub, tools_d_encrypt_s as encrypt_s, tools_d_ffEncodedToBigInt as ffEncodedToBigInt, tools_d_formatPrivKeyForBabyJub as formatPrivKeyForBabyJub, tools_d_fromBytesLE as fromBytesLE, tools_d_genKeypair as genKeypair, tools_d_genPrivKey as genPrivKey, tools_d_genPubKey as genPubKey, tools_d_genRandomBabyJubValue as genRandomBabyJubValue, tools_d_genRandomSalt as genRandomSalt, tools_d_genSmallRandomBabyJubValue as genSmallRandomBabyJubValue, tools_d_generateNonces as generateNonces, tools_d_generateRandom240BitNumber as generateRandom240BitNumber, tools_d_generateRandom248BitNumber as generateRandom248BitNumber, tools_d_getSignalByName as getSignalByName, tools_d_hashCypherText as hashCypherText, tools_d_hashExtPoints as hashExtPoints, tools_d_hexString2Buffer as hexString2Buffer, tools_d_hexToSkBuffer as hexToSkBuffer, tools_d_normalizeSigningKeyMaterial as normalizeSigningKeyMaterial, tools_d_portableArgon2 as portableArgon2, tools_d_portableRandomBytes as portableRandomBytes, poseidonLite as poseidonTools, tools_d_privateScalarToPubKey as privateScalarToPubKey, tools_d_pruneBuffer as pruneBuffer, tools_d_pruneTo32Bits as pruneTo32Bits, tools_d_pruneTo64Bits as pruneTo64Bits, tools_d_prv2pub as prv2pub, tools_d_shrinkToBits as shrinkToBits, tools_d_splitLargeNumber as splitLargeNumber, tools_d_stringToCurve as stringToCurve, tools_d_stringifyBigInts as stringifyBigInts, tools_d_toBigIntArray as toBigIntArray, tools_d_toBytesLE as toBytesLE, tools_d_toStringArray as toStringArray, tools_d_uint8ArrayToHex as uint8ArrayToHex, tools_d_unstringifyBigInts as unstringifyBigInts };
+  export type { tools_d_BabyJubAffinePoint as BabyJubAffinePoint, tools_d_BabyJubExtPoint as BabyJubExtPoint, tools_d_Keypair as Keypair, tools_d_PrivKey as PrivKey, tools_d_PubKey as PubKey };
+}
+
+declare function toPaddedHex(bn: bigint, length?: number): string;
+declare const ZERO = 7507787612525723758659662260399184323980001748885802124580171315331567144978n;
+declare const ZERO_KECCAK = "0x937759b0c00d3bc82439e3acdb505be98d7bca79f508bb77a8bfafc2666260a6";
+/**
+ * The the MimC tree hash function,
+ * If wanting to hash a single value set right to 0n
+ * @param left
+ * @param right
+ * @returns
+ */
+declare var treeHasher: (left: any, right: any) => any;
+/**
+ * Creates a merkle tree with the mimc hash function from circomlibjs
+ * @param depth
+ * @param leaves
+ * @returns
+ */
+declare var keccakTreeHasher: (left: any, right: any) => any;
+declare function createMimcMerkelTree(depth: number, leaves: string[]): Promise<MerkleTree>;
+declare function createKeccakMerkelTree(depth: number, leaves: string[]): Promise<MerkleTree>;
+declare function createKeccakMerkelTreeSync(depth: number, leaves: string[]): MerkleTree;
+declare function signDataInsertRequestJWT(data: HexString$1[], global_tree_index: number, inserted_at: number, secret: Signer): Promise<string>;
+
+declare const utils_d_ZERO: typeof ZERO;
+declare const utils_d_ZERO_KECCAK: typeof ZERO_KECCAK;
+declare const utils_d_createKeccakMerkelTree: typeof createKeccakMerkelTree;
+declare const utils_d_createKeccakMerkelTreeSync: typeof createKeccakMerkelTreeSync;
+declare const utils_d_createMimcMerkelTree: typeof createMimcMerkelTree;
+declare const utils_d_keccakTreeHasher: typeof keccakTreeHasher;
+declare const utils_d_signDataInsertRequestJWT: typeof signDataInsertRequestJWT;
+declare const utils_d_toPaddedHex: typeof toPaddedHex;
+declare const utils_d_treeHasher: typeof treeHasher;
+declare namespace utils_d {
+  export {
+    utils_d_ZERO as ZERO,
+    utils_d_ZERO_KECCAK as ZERO_KECCAK,
+    utils_d_createKeccakMerkelTree as createKeccakMerkelTree,
+    utils_d_createKeccakMerkelTreeSync as createKeccakMerkelTreeSync,
+    utils_d_createMimcMerkelTree as createMimcMerkelTree,
+    utils_d_keccakTreeHasher as keccakTreeHasher,
+    utils_d_signDataInsertRequestJWT as signDataInsertRequestJWT,
+    utils_d_toPaddedHex as toPaddedHex,
+    utils_d_treeHasher as treeHasher,
+  };
 }
 
 /**
@@ -6179,75 +6297,6 @@ declare var deployedProtocolContracts: {
 };
 declare function toAddressMap(networkId: number): AddressMap;
 
-declare const from_json: (json_object: UnsealConditionTemplateExport, proof_library: ProofLibraryType, module_library: ModuleLibraryType) => UnsealConditionTemplate;
-declare class UnsealConditionTemplate {
-    name: string;
-    collection_id: string;
-    description: string;
-    proof_library: ProofLibraryType;
-    module_library: ModuleLibraryType;
-    compiled_collection: CompiledCollectionExport;
-    user_inputs: RequiredUserInput[][];
-    unsealProofActions: UnsealProofAction[][];
-    data_streams: DataStreamInput[][];
-    modules: UnsealConditionModule[];
-    used_input_mapping: {
-        [key: string]: any;
-    };
-    private proofs_cache;
-    constructor(name: string, description: string, proof_library: ProofLibraryType, module_library: ModuleLibraryType, compiled_collection: CompiledCollectionExport);
-    export_compiled_to_json(): UnsealConditionTemplateExport;
-    isCompiled(): boolean;
-    private getInputFromMapping;
-    compile(input_mapping: {
-        [key: string]: bigint;
-    }, data_stream_mapping: {
-        [key: string]: string;
-    }, optimize?: boolean): void;
-    address_to_proof(address: string): UnsealConditionProof;
-    /**
-     * Converts V1 unseal proof actions (2D output references via output_proof_index + output_signal_index)
-     * into V2 actions (flat output list with bitmask-based pruning at each chain_proof_verify).
-     *
-     * At each chain_proof_verify:
-     *   1. Append the new proof's outputs to the flat list
-     *   2. Look forward to find which flat entries are still referenced
-     *   3. Build a bitmask (1=keep, 0=remove) over the entire flat list
-     *   4. Prune dead entries
-     *
-     * PASS_SIGNAL and VALIDATE_DATA_ROOT actions are converted from 2D (proof_index, signal_index)
-     * to flat indices into the current output list.
-     */
-    optimize(unseal_proof_actions: UnsealProofAction[]): UnsealProofAction[];
-    /**
-     * Scans actions from startIdx onward to find which flat list entries
-     * are referenced by future PASS_SIGNAL and VALIDATE_DATA_ROOT actions.
-     * Returns the set of flat indices that are still needed.
-     */
-    private collectFutureReferences;
-    /**
-     * Finds an UnsealConditionProof by its on-chain verifier address.
-     * Searches through compiled modules to match the verifier_address
-     * in PREPARE_NEXT_PROOF actions to the corresponding proof.
-     */
-    private getProofByVerifierAddress;
-    getAllDataStreams(): string[];
-    getUnsealProofActions(): UnsealProofAction[][];
-    getExpectedInputs(): string[];
-    getUnsealRootForProof(proof_index: number): Promise<ProofPath>;
-    getUnsealRoot(): Promise<string>;
-}
-
-type UnsealConditionTemplate_d_UnsealConditionTemplate = UnsealConditionTemplate;
-declare const UnsealConditionTemplate_d_UnsealConditionTemplate: typeof UnsealConditionTemplate;
-declare const UnsealConditionTemplate_d_from_json: typeof from_json;
-declare namespace UnsealConditionTemplate_d {
-  export {
-    UnsealConditionTemplate_d_UnsealConditionTemplate as UnsealConditionTemplate,
-    UnsealConditionTemplate_d_from_json as from_json,
-  };
-}
-
 interface PaymentProvider {
     /**
      * Returns a Bearer token string authorising a seal request.
@@ -6319,70 +6368,6 @@ declare class ClientSingleShareSealingProcess implements IClientSingleShareSeali
     get_reveal_conditions(): RevealConditionRequest[];
 }
 
-declare class UnsealConditionCollection {
-    nodes: {
-        [key: string]: CollectionNode;
-    };
-    edges: {
-        [key: string]: CollectionEdge;
-    };
-    comments: {
-        [key: string]: string;
-    };
-    data_streams: CollectionDataStream[];
-    name: string;
-    description: string;
-    starting_node: CollectionNode | undefined;
-    proofLibrary: ProofLibraryType;
-    moduleLibrary: ModuleLibraryType;
-    forks: {
-        [key: string]: string[];
-    };
-    fork_list: string[];
-    private node_to_fork_map;
-    private index_counter;
-    changed_callback: ChangedCallback;
-    constructor(name: string, description: string, proofLibrary: ProofLibraryType, moduleLibrary: ModuleLibraryType, changed_callback?: ChangedCallback);
-    visual_forks(): string[];
-    visual_edges_all(): string[][];
-    visual_edges(fork_id: string): string[];
-    comment(id: string, comment: string): void;
-    add_data_stream(datastream_id: string, from_node_id: string, field_name: string): void;
-    remove_data_stream(datastream_id: string): void;
-    get_data_stream(datastream_id: string): CollectionDataStream | undefined;
-    sort_fork_list(): void;
-    add_node(module: UnsealConditionModule, fork_from_node_id?: string): string;
-    move_node(node_id: string, new_fork_from_node_id: string, at_position?: number): CollectionEdge[];
-    remove_node(node_id: string): void;
-    remove_edge(edge_id: string): void;
-    all_nodes_for_fork(fork_id: string): {
-        nodes: string[];
-        forking: string[];
-    };
-    validate_edge(source_node_id: string | undefined, target_node_id: string | undefined, mapping: [string, any], input_type: CollectionEdgeInput): boolean;
-    add_edge(source_node_id: string | undefined, target_node_id: string | undefined, mapping: [string, any], input_type: CollectionEdgeInput): void;
-    export_to_json(): any;
-    import_from_json(data: any): void;
-    getEdgesToNode(node_id: string): CollectionEdge[];
-    getEdgesFromNode(node_id: string): CollectionEdge[];
-    getCollectionId(): string;
-    generateProofCode(fork_nr: number): string;
-    createTemplate(address_map: AddressMap): UnsealConditionTemplate;
-    createTemplatePerFork(address_map: AddressMap, sorted_nodes: string[], forking: string[]): {
-        compiled_modules: CompiledModule[];
-        user_inputs: RequiredUserInput[];
-        data_stream_inputs: DataStreamInput[];
-    };
-}
-
-type UnsealConditionCollection_d_UnsealConditionCollection = UnsealConditionCollection;
-declare const UnsealConditionCollection_d_UnsealConditionCollection: typeof UnsealConditionCollection;
-declare namespace UnsealConditionCollection_d {
-  export {
-    UnsealConditionCollection_d_UnsealConditionCollection as UnsealConditionCollection,
-  };
-}
-
 type UnsealingState = {
     phase: UnsealingStatus;
     seal: SingleSealStoragePackage$1;
@@ -7043,7 +7028,7 @@ declare const index_browser_d_proofLibrary: typeof proofLibrary;
 declare const index_browser_d_standardProofs: typeof standardProofs;
 declare const index_browser_d_toAddressMap: typeof toAddressMap;
 declare namespace index_browser_d {
-  export { index_browser_d_ChainedProofWrapper as ChainedProofWrapper, index_browser_d_ClientSingleShareSealingProcess as ClientSingleShareSealingProcess, index_browser_d_ClientSingleShareUnsealingProcess as ClientSingleShareUnsealingProcess, UnsealConditionTemplate_d as CollectionTemplateTypes, types_d as CollectionTypes, index_browser_d_DataStream as DataStream, index_browser_d_DataStreamClient as DataStreamClient, index_browser_d_EmpheralMerkleTreeWrapper as EmpheralMerkleTreeWrapper, index_browser_d_ModuleLibraryType as ModuleLibraryType, types_d$1 as ModuleTypes, index_browser_d_NETWORK_IDS as NETWORK_IDS, index_browser_d_NihiliumPaymentProvider as NihiliumPaymentProvider, index_browser_d_NihiliumPaymentProviderClientAPIKEY_DO_NOT_USE as NihiliumPaymentProviderClientAPIKEY_DO_NOT_USE, index_browser_d_Persistence as Persistence, index_browser_d_Processor as Processor, index_browser_d_ProofLibraryType as ProofLibraryType, types_d$2 as ProofTypes, index_browser_d_StandardModuleLibrary as StandardModuleLibrary, index_browser_d_StandardProofLibrary as StandardProofLibrary, UnsealConditionCollection_d as UnsealConditionCollectionTypes, index_browser_d_createRevealOnlyCollection as createRevealOnlyCollection, tools_d as cryptoTools, index_browser_d_deployedProtocolContracts as deployedProtocolContracts, index_browser_d_moduleLibrary as moduleLibrary, index_browser_d_precompute as precompute, index_browser_d_proofLibrary as proofLibrary, common_d as protocolTypes, index_d as standardModules, index_browser_d_standardProofs as standardProofs, index_browser_d_toAddressMap as toAddressMap, index_d$1 as types, utils_d as utils };
+  export { index_browser_d_ChainedProofWrapper as ChainedProofWrapper, index_browser_d_ClientSingleShareSealingProcess as ClientSingleShareSealingProcess, index_browser_d_ClientSingleShareUnsealingProcess as ClientSingleShareUnsealingProcess, index_browser_d_DataStream as DataStream, index_browser_d_DataStreamClient as DataStreamClient, index_browser_d_EmpheralMerkleTreeWrapper as EmpheralMerkleTreeWrapper, index_browser_d_ModuleLibraryType as ModuleLibraryType, index_browser_d_NETWORK_IDS as NETWORK_IDS, index_browser_d_NihiliumPaymentProvider as NihiliumPaymentProvider, index_browser_d_NihiliumPaymentProviderClientAPIKEY_DO_NOT_USE as NihiliumPaymentProviderClientAPIKEY_DO_NOT_USE, index_browser_d_Persistence as Persistence, index_browser_d_Processor as Processor, index_browser_d_ProofLibraryType as ProofLibraryType, index_browser_d_StandardModuleLibrary as StandardModuleLibrary, index_browser_d_StandardProofLibrary as StandardProofLibrary, from_json as collection_from_json, index_browser_d_createRevealOnlyCollection as createRevealOnlyCollection, tools_d as cryptoTools, index_browser_d_deployedProtocolContracts as deployedProtocolContracts, index_browser_d_moduleLibrary as moduleLibrary, index_browser_d_precompute as precompute, index_browser_d_proofLibrary as proofLibrary, index_d as standardModules, index_browser_d_standardProofs as standardProofs, index_browser_d_toAddressMap as toAddressMap, public_d as types, utils_d as utils };
   export type { index_browser_d_DualLatestGlobalLeafProofResult as DualLatestGlobalLeafProofResult, index_browser_d_DualProofResult as DualProofResult, index_browser_d_IDataStream as IDataStream, index_browser_d_IDualDataStream as IDualDataStream, index_browser_d_LatestGlobalLeafProofResult as LatestGlobalLeafProofResult, index_browser_d_ProofResult as ProofResult };
 }
 
@@ -7075,5 +7060,5 @@ declare function getDefaultSealingProcess(chainId?: number): Promise<ClientSingl
 declare function getDefaultUnsealingProcess(seal: SingleSealStoragePackage$1, chainId?: number): Promise<ClientSingleShareUnsealingProcess>;
 declare function preload_circuits(): Promise<void>;
 
-export { ChainedProofWrapper, ClientSingleShareSealingProcess, ClientSingleShareUnsealingProcess, UnsealConditionTemplate_d as CollectionTemplateTypes, types_d as CollectionTypes, DataStream, DataStreamClient, EmpheralMerkleTreeWrapper, ModuleLibraryType, types_d$1 as ModuleTypes, NETWORK_IDS, NihiliumPaymentProvider, NihiliumPaymentProviderClientAPIKEY_DO_NOT_USE, Persistence, Processor, ProofLibraryType, types_d$2 as ProofTypes, StandardModuleLibrary, StandardProofLibrary, UnsealConditionCollection_d as UnsealConditionCollectionTypes, check_if_reveal_value_is_published, createRevealOnlyCollection, cryptoTools, deployedProtocolContracts, getDefaultSealingProcess, getDefaultUnsealingProcess, getFullDatastreams, getFullProcessors, getProcessorEndpoint, moduleLibrary, index_browser_d as nhsdk, precompute, preload_circuits, proofLibrary, common_d as protocolTypes, setApiEndpoint, index_d as standardModules, standardProofs, toAddressMap, index_d$1 as types, utils_d as utils };
+export { ChainedProofWrapper, ClientSingleShareSealingProcess, ClientSingleShareUnsealingProcess, DataStream, DataStreamClient, EmpheralMerkleTreeWrapper, ModuleLibraryType, NETWORK_IDS, NihiliumPaymentProvider, NihiliumPaymentProviderClientAPIKEY_DO_NOT_USE, Persistence, Processor, ProofLibraryType, StandardModuleLibrary, StandardProofLibrary, check_if_reveal_value_is_published, from_json as collection_from_json, createRevealOnlyCollection, cryptoTools, deployedProtocolContracts, getDefaultSealingProcess, getDefaultUnsealingProcess, getFullDatastreams, getFullProcessors, getProcessorEndpoint, moduleLibrary, index_browser_d as nhsdk, precompute, preload_circuits, proofLibrary, setApiEndpoint, index_d as standardModules, standardProofs, toAddressMap, public_d as types, utils_d as utils };
 export type { DualLatestGlobalLeafProofResult, DualProofResult, IDataStream, IDualDataStream, LatestGlobalLeafProofResult, ProofResult, SingleSealStoragePackage };