@nihilium/client-sdk 0.1.2 → 0.2.0

package/dist/types.d.ts

@@ -0,0 +1,989 @@
+declare type Element = string | number;
+declare type ProofPath = {
+    pathElements: Element[];
+    pathIndices: number[];
+    pathPositions: number[];
+    pathRoot: Element;
+};
+
+interface ProofResult {
+    globalProof: ProofPath;
+    localProof: ProofPath;
+    timestamp: number;
+    globalIndex: number;
+    localIndex: number;
+    blockHash: string;
+}
+interface LatestGlobalLeafProofResult {
+    globalProof: ProofPath;
+    leafRoot: string;
+    timestamp: number;
+    globalIndex: number;
+    blockHash: string;
+}
+interface DualProofResult {
+    dualProof: ProofPath;
+    globalProof: ProofPath;
+    localProof: ProofPath;
+    timestamp: string;
+    globalIndex: number;
+    localIndex: number;
+    blockHash: string;
+    dualLeafValue: string;
+}
+interface DualLatestGlobalLeafProofResult {
+    dualProof: ProofPath;
+    globalProof: ProofPath;
+    leafRoot: string;
+    timestamp: string;
+    globalIndex: number;
+    blockHash: string;
+}
+interface IDataStream {
+    initialize: () => Promise<void>;
+    getAddress: () => string;
+    getUrl: () => string;
+    getLatestGlobalLeafProof: () => Promise<LatestGlobalLeafProofResult>;
+    postData: (data: HexString[]) => Promise<[number, number, string]>;
+    getProof: (value: HexString) => Promise<ProofResult>;
+    hasDataStreamRoot: (root: string) => Promise<boolean>;
+    isProvable: (value: HexString) => Promise<boolean>;
+}
+interface IDualDataStream extends Omit<IDataStream, 'getProof' | 'getLatestGlobalLeafProof'> {
+    getProof(value: HexString): Promise<DualProofResult>;
+    getLatestGlobalLeafProof(): Promise<DualLatestGlobalLeafProofResult>;
+}
+
+type UnsealProofAction = {
+    action: string;
+    params: any;
+};
+
+type Proof = {
+    proof: any;
+    public_signals: any[];
+};
+type UnsealConditionProofData = {
+    name: string;
+    addressMapKey: string;
+    description?: string;
+    version: string;
+    public_signals: {
+        [key: string]: [number, number];
+    };
+    /**
+     *
+     * @description The complexity score of the proof. Essentially the gas cost of the proof.
+     * Be generous when setting this score! A score too low will result a proof being unchallangable
+     *
+     * @default 250_000 General gasscost of a ZKProof
+     
+     */
+    complexity_score: number;
+};
+declare class UnsealConditionProof {
+    data: UnsealConditionProofData;
+    constructor(data: UnsealConditionProofData);
+    getOutputSize(): number;
+    getSignalIndex(signal: string): [number, number];
+    getPublicSignals(): {
+        [key: string]: [number, number];
+    };
+    getVersion(): string;
+    getDescription(): string;
+    getName(): string;
+    compile(addresses: AddressMap, verifier_must_be_true?: boolean): CompiledProof;
+}
+type CompiledProof = {
+    prepare_action: UnsealProofAction;
+    validate_action: UnsealProofAction;
+};
+
+declare abstract class ProofLibraryType {
+    standard: {
+        [key: string]: UnsealConditionProof;
+    };
+    custom: {
+        [key: string]: UnsealConditionProof;
+    };
+    addCustomProof(name: string, proof: UnsealConditionProof): void;
+    getProof(name: string): UnsealConditionProof;
+}
+
+type IOType = "Timestamp" | "BigInt" | "Number" | "String" | "HexString" | "Randomness" | "Other" | "Boolean" | IOType[];
+type IO = {
+    type_order: IOType[];
+    user_input: boolean;
+    description: string;
+    required: boolean;
+};
+type ModuleOutput = {
+    type_order: IOType[];
+    name: string;
+    description: string;
+    proof_key: string;
+    signal_key: string;
+};
+type IOMap = {
+    [key: string]: IO;
+};
+type ModuleOutputMap = {
+    [key: string]: ModuleOutput;
+};
+type CompiledModule = {
+    module_id: string;
+    module_name: string;
+    new_depth: number;
+    actions: UnsealProofAction[];
+    outputs: {
+        [key: string]: {
+            output_proof_index: number;
+            output_signal_index: [number, number];
+        };
+    };
+};
+declare class ModuleNode {
+    node_id: string;
+    proof: UnsealConditionProof;
+    public_inputs: any[];
+    constructor(node_id: string, proof: UnsealConditionProof, public_inputs: any[]);
+    get_outputs(): {
+        [key: string]: [number, number];
+    };
+    get_output_keys(): string[];
+}
+declare enum ModuleEdgeInput {
+    external_input = "external_input",
+    link = "link",//Simple link to define ordering
+    signal_pass = "signal_pass",
+    static_input = "static_input",
+    user_input = "user_input"
+}
+declare class WrappedProof {
+    proof: UnsealConditionProof;
+    id: string;
+    index: number;
+    constructor(proof: UnsealConditionProof, id: string, index: number);
+    get_outputs(): {
+        [key: string]: [number, number];
+    };
+    get_output_keys(): string[];
+}
+declare class SignalEdge {
+    edge_id: string;
+    from: WrappedProof | undefined;
+    to: WrappedProof;
+    mapping: [string, string | any];
+    input_type: ModuleEdgeInput;
+    constructor(from: WrappedProof | undefined, to: WrappedProof, mapping: [string, any], input_type: ModuleEdgeInput, edge_id?: string);
+    validate_inputs(): boolean;
+}
+declare class ModuleEdge {
+    edge_id: string;
+    from: ModuleNode | undefined;
+    to: ModuleNode;
+    mapping: [string, string | any];
+    input_type: ModuleEdgeInput;
+    constructor(from: ModuleNode | undefined, to: ModuleNode, mapping: [string, any], input_type: ModuleEdgeInput, edge_id?: string);
+    validate_inputs(): boolean;
+}
+/**
+ *
+ */
+type ModuleProof = {
+    proofs: any[];
+    public_inputs: any[][];
+    outputs: {
+        [key: string]: string;
+    };
+};
+declare abstract class UnsealConditionModule {
+    name: string;
+    short_description: string;
+    description: string;
+    protected inputs: IOMap;
+    protected forkingProof: string | undefined;
+    protected dataStreamOutputFields: string[];
+    protected outputs: ModuleOutputMap;
+    protected proofLibrary: ProofLibraryType;
+    protected proofs: {
+        [key: string]: WrappedProof;
+    };
+    protected proofList: string[];
+    protected edges: {
+        [key: string]: SignalEdge;
+    };
+    constructor(name: string, short_description: string, proofLibrary: ProofLibraryType);
+    getProofByIndex(proof_index: number): WrappedProof;
+    getUserInputs(): IOMap;
+    getOutputs(): ModuleOutputMap;
+    canFork(): boolean;
+    addProof(proof: UnsealConditionProof, easyId?: boolean): string;
+    addSignalEdge(from: string | undefined, to: string, mapping: [string, any], input_type: ModuleEdgeInput): void;
+    private generateProofId;
+    validateInputs(inputs: IOMap): boolean;
+    getInputEdgesForProof(proof_id: string): SignalEdge[];
+    obtain_outputs(public_signals: any[][]): {
+        [key: string]: any;
+    };
+    /**
+     * Produces the proofs for the module
+     * @param args
+     */
+    produce_proofs(...args: any[]): Promise<ModuleProof>;
+    /**
+     * Prepares the module for proving, this can be publishing a value onto the
+     * data stream or call external functions that might take longer to complete.
+     
+     * @param args
+     */
+    prepare_for_proving(...args: any[]): Promise<any>;
+    /**
+     * Checks if the module is eligible to prove
+     * @param args
+     */
+    eligible_to_prove(...args: any[]): Promise<boolean>;
+    transform_user_inputs(input_mapping: {
+        [key: string]: any;
+    }): Promise<{
+        [key: string]: any;
+    }>;
+    compile(external_node_id: string, address_map: AddressMap, input_mapping: {
+        [key: string]: {
+            output_proof_index: number;
+            output_signal_indexes: number[];
+        };
+    }, current_proof_depth: number, fork?: boolean): CompiledModule;
+}
+
+declare abstract class ModuleLibraryType {
+    standard: {
+        [key: string]: new (...args: any[]) => UnsealConditionModule;
+    };
+    custom: {
+        [key: string]: new (...args: any[]) => UnsealConditionModule;
+    };
+    addCustomModule(name: string, module: new (...args: any[]) => UnsealConditionModule): void;
+    getModule(name: string, proofLibrary: ProofLibraryType): UnsealConditionModule;
+}
+
+/**
+ * Describes the path you are planning to proof
+ * It is constructed as a 256 bit number with the first bit being the length of the proof path
+ * The remaining 248 bits are the proof path
+ * This means there is a limited to the amount of 'forks' you can take in a proof path
+ * Which is 248 and should be more than anyone would ever need
+ * The proof path is a boolean array of length 248
+ 
+ */
+declare class UnsealConditionsProofPathDescriptor {
+    proof_path_length: number;
+    proof_path: boolean[];
+    constructor();
+}
+declare function import_collectionnode_from_json(data: any, moduleLibrary: ModuleLibraryType, proofLibrary: ProofLibraryType): CollectionNode;
+declare class CollectionNode {
+    node_id: string;
+    module: UnsealConditionModule;
+    public_inputs: any[];
+    constructor(node_id: string, module: UnsealConditionModule, public_inputs: any[]);
+    export_to_json(): any;
+    get_outputs(): ModuleOutputMap;
+    get_output_keys(): string[];
+    get_input_keys(): string[];
+    validate_input_mapping(input_mapping: {
+        [key: string]: any;
+    }): boolean;
+}
+declare enum CollectionEdgeInput {
+    signal_pass = "signal_pass",
+    static_input = "static_input",
+    user_input = "user_input"
+}
+declare function import_collectionedge_from_json(data: any, nodes: {
+    [key: string]: CollectionNode;
+}): CollectionEdge;
+declare class CollectionDataStream {
+    datastream_id: string;
+    from: CollectionNode;
+    field_name: string;
+    constructor(datastream_id: string, from: CollectionNode, field_name: string);
+    export_to_json(): any;
+}
+declare class CollectionEdge {
+    edge_id: string;
+    from: CollectionNode | undefined;
+    to: CollectionNode;
+    mapping: [string, string | any];
+    input_type: CollectionEdgeInput;
+    constructor(from: CollectionNode | undefined, to: CollectionNode, mapping: [string, any], input_type: CollectionEdgeInput, edge_id?: string);
+    toShortNodeId(node_id: string | undefined): string;
+    toString(): string;
+    export_to_json(): any;
+    validate_inputs(): boolean;
+}
+declare enum ChangedType {
+    removed = "removed",
+    added = "added",
+    modified = "modified",
+    moved = "moved"
+}
+type ChangedCallback = (changes: {
+    action: ChangedType;
+    nodes?: CollectionNode[];
+    edges?: CollectionEdge[];
+    data_streams?: CollectionDataStream[];
+    starting_node?: CollectionNode | undefined;
+    comments?: {
+        [key: string]: string;
+    };
+}) => void;
+type RequiredUserInput = {
+    proof_index: number;
+    signal_indexes: [number, number];
+    name: string;
+    module_id: string;
+    description: string;
+    input_signal_name: string;
+};
+type DataStreamInput = {
+    datastream_id: string;
+    output_proof_index: number;
+    output_signal_index: number;
+};
+type CompiledCollectionExport = {
+    compiled_modules: CompiledModule[][];
+    user_inputs: RequiredUserInput[][];
+    data_stream_inputs: DataStreamInput[][];
+    collection_id: string;
+    collection_export: any;
+};
+interface AddressMap {
+    getAddress(key: string): string;
+}
+declare class BasicAddressMap implements AddressMap {
+    address_map: {
+        [key: string]: string;
+    };
+    constructor(address_map: {
+        [key: string]: string;
+    });
+    getAddress(key: string): string;
+    addAddress(key: string, address: string): void;
+}
+declare class AddressMapWithDefault implements AddressMap {
+    address_map: {
+        [key: string]: string;
+    };
+    default_address: string;
+    constructor(address_map: {
+        [key: string]: string;
+    }, default_address: string);
+    getAddress(key: string): string;
+}
+
+type HexString = string;
+type PaymentProof = string;
+type OpeningCondition = {
+    address: string;
+};
+type RequestPackageStageOne = {
+    public_key: string;
+    payment_proof?: PaymentProof;
+};
+type RequestPackageStageTwo = {
+    encrypted_payment_proof: string;
+};
+declare enum RevealConditions {
+    TOP_LEVEL = "top_level",
+    TIMELOCK = "timelock",
+    IDENTITY_PROOF = "identity_proof",
+    NON_INTERVENTION_PROOF = "non_intervention_proof"
+}
+declare const PROTOCOL_PROCESSOR_PATHS: {
+    REQUEST_SEAL: string;
+    REQUEST_UNSEAL: string;
+    GET_PUBLIC_KEYS: string;
+};
+declare const PROTOCOL_DATA_STREAM_PATHS: {
+    POST_DATA: string;
+    GET_PROOF: string;
+    IS_PROVABLE: string;
+    GET_GLOBAL_TREE_INDEX: string;
+    GET_ADDRESS: string;
+    GET_LATEST_GLOBAL_LEAF_PROOF: string;
+};
+type ProcessorEndpoint = {
+    url: string;
+    is_tor: boolean;
+    public_verification_key: [bigint, bigint];
+    public_he_encryption_key: [bigint, bigint];
+    server_address: HexString;
+};
+declare enum ClientProcessorSealingPhase {
+    NOT_STARTED = -1,
+    GENERATING_SECRETS = 0,
+    REQUEST_COMMITMENT = 1,
+    PROCESSING_COMMITMENT = 2,
+    PROCESSING_INDIVIDUAL_REVEAL_CONDITIONS = 3,
+    ENCRYPTING_SHAMIR_SECRET = 4,
+    DONE = 5,
+    ERROR = -99
+}
+interface IClientSingleShareSealingProcess {
+    initialize(secret: bigint, metadata_root: bigint, template_inputs: {
+        [key: string]: any;
+    }): Promise<void>;
+    request_commitment(call_processor: boolean): Promise<SingleSealRequest>;
+    process_seal_response(processor_response: SingleSealRequestResponse): Promise<SingleSealStoragePackage>;
+    get_phase(): ClientProcessorSealingPhase;
+    get_secret_throwaway_packages(): SecretThrowawayPackage[];
+    get_reveal_conditions(): RevealConditionRequest[];
+}
+interface IClientSingleShareUnsealingProcess {
+    initialize(seal: SingleSealStoragePackage): Promise<void>;
+    reveal_value_published(): Promise<boolean>;
+    get_unsealing_status(): Promise<UnsealingStatus>;
+    get_processor_status(): Promise<ProcessorStatus>;
+    display_reveal_conditions(): Promise<void>;
+    publish_reveal_value(data_stream_id: string): Promise<void>;
+    start_unsealing(proof_index: number, proofs: any[], public_inputs: any[][]): Promise<SingleUnsealRequest>;
+    process_unseal_response(processor_response: SingleSealUnsealRequestResponse): Promise<bigint>;
+}
+type SingleSealUnsealRequestResponse = {
+    unpacked_private_scalar: string;
+};
+declare enum UnsealingStatus {
+    NOT_STARTED = 0,
+    REVEALING_INITIAL_CONDITION = 1,
+    REVEAL_VALUE_SENT = 2,
+    REVEAL_VALUE_EXPOSED = 3,
+    AWAIT_OTHER_SEAL_CONDITIONS = 4,
+    UNSEAL_POSSIBLE = 5,
+    UNSEALING_IN_PROGRESS = 6,
+    DONE = 7,
+    ERROR = -99
+}
+declare enum ProcessorStatus {
+    AVAILABLE = 0,
+    WARN_STAKE_DECREASING = 1,
+    WARN_STAKE_LOW = 2,
+    WARN_STAKE_CRITICAL = 3,
+    UNAVAILABLE = 4,
+    NEW_PUBLIC_KEYS_REQUIRED = 5,
+    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.
+ */
+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 = {
+    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<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;
+};
+/**
+ * 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 = 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<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 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;
+    _setWindowSize(windowSize: number): void;
+}
+/** Static methods of Extended Point with coordinates in X, Y, Z, T. */
+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;
+    msm(points: ExtPointType[], scalars: bigint[]): ExtPointType;
+}
+/**
+ * Edwards Curve interface.
+ * Main methods: `getPublicKey(priv)`, `sign(msg, priv)`, `verify(sig, msg, pub)`.
+ */
+type CurveFn = {
+    CURVE: ReturnType<typeof validateOpts>;
+    getPublicKey: (privateKey: Hex) => Uint8Array;
+    sign: (message: Hex, privateKey: Hex, options?: {
+        context?: Hex;
+    }) => Uint8Array;
+    verify: (sig: Hex, message: Hex, publicKey: Hex, options?: {
+        context?: Hex;
+        zip215: boolean;
+    }) => boolean;
+    ExtendedPoint: ExtPointConstructor;
+    utils: {
+        randomPrivateKey: () => Uint8Array;
+        getExtendedPublicKey: (key: Hex) => {
+            head: Uint8Array;
+            prefix: Uint8Array;
+            scalar: bigint;
+            point: ExtPointType;
+            pointBytes: Uint8Array;
+        };
+        precompute: (windowSize?: number, point?: ExtPointType) => ExtPointType;
+    };
+};
+
+type SnarkBigInt = bigint;
+type PrivKey = bigint;
+type PubKey = ExtPointType;
+type BabyJubAffinePoint = AffinePoint<bigint>;
+type BabyJubExtPoint = ExtPointType;
+declare const babyJubNoble: CurveFn;
+/**
+ * A private key and a public key
+ */
+interface Keypair {
+    privKey: PrivKey;
+    pubKey: PubKey;
+}
+declare const SNARK_FIELD_SIZE: SnarkBigInt;
+declare const babyJub: ExtPointConstructor;
+
+type SelectableProcessor = {
+    url: string;
+    is_tor: boolean;
+    jurisdiction: string;
+    stake: bigint;
+    name: string;
+    ethAddress: string;
+};
+type SelectableDataStream = {
+    url: string;
+    is_tor: boolean;
+    jurisdiction: string;
+    stake: bigint;
+};
+
+export { AddressMapWithDefault, BasicAddressMap, ChangedType, ClientProcessorSealingPhase, CollectionDataStream, CollectionEdge, CollectionEdgeInput, CollectionNode, ModuleEdge, ModuleEdgeInput, ModuleNode, PROTOCOL_DATA_STREAM_PATHS, PROTOCOL_PROCESSOR_PATHS, ProcessorStatus, RevealConditions, SNARK_FIELD_SIZE, SignalEdge, UnsealConditionCollection, UnsealConditionModule, UnsealConditionProof, UnsealConditionTemplate, UnsealConditionsProofPathDescriptor, UnsealingStatus, WrappedProof, babyJub, babyJubNoble, from_json, import_collectionedge_from_json, import_collectionnode_from_json };
+export type { AddressMap, BabyJubAffinePoint, BabyJubExtPoint, ChainedCircuitInput, ChangedCallback, CompiledCollectionExport, CompiledModule, CompiledProof, DataStreamInput, DualLatestGlobalLeafProofResult, DualProofResult, ECCEncryptedMessage, HexString, HiddenPackage, IClientSingleShareSealingProcess, IClientSingleShareUnsealingProcess, IDataStream, IDualDataStream, IO, IOMap, IOType, Keypair, LatestGlobalLeafProofResult, ModuleOutput, ModuleOutputMap, ModuleProof, OpeningCondition, PaymentProof, PrivKey, PrivatePackage, ProcessorEndpoint, Proof, ProofResult, PubKey, PublicPackage, RequestPackageStageOne, RequestPackageStageTwo, RequiredUserInput, RevealCondition, RevealConditionRequest, RevealConditionRequestResponse, SecretThrowawayPackage, SelectableDataStream, SelectableProcessor, SingleSealRequest, SingleSealRequestResponse, SingleSealStoragePackage, SingleSealUnsealRequestResponse, SingleShareSealHiddenPackage, SingleShareSealPrivatePackage, SingleShareSealPublicPackage, SingleUnsealRequest, SnarkBigInt, StaticCircuitInput, ThrowAwayShamirSecret, UnsealConditionProofData, UnsealConditionTemplateExport, UnsealRevealConditionRequest };