@silvana-one/upgradable 0.1.0

package/dist/node/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./validators.js";
+export * from "./upgrade.js";
+export * from "./upgradable.js";

package/dist/node/index.js

@@ -0,0 +1,4 @@
+export * from "./validators.js";
+export * from "./upgrade.js";
+export * from "./upgradable.js";
+//# sourceMappingURL=index.js.map

package/dist/node/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC"}

package/dist/node/upgradable.d.ts

@@ -0,0 +1,294 @@
+import { Bool, PublicKey, SmartContract, VerificationKey, Field, Option } from "o1js";
+export { UpgradeAuthorityBase, VerificationKeyUpgradeData, UpgradeAuthorityContractConstructor, UpgradableContract, PublicKeyOption, UpgradeAuthorityAnswer, };
+declare const VerificationKeyUpgradeData_base: (new (value: {
+    address: PublicKey;
+    tokenId: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+    previousVerificationKeyHash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+    newVerificationKeyHash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+}) => {
+    address: PublicKey;
+    tokenId: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+    previousVerificationKeyHash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+    newVerificationKeyHash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+}) & {
+    _isStruct: true;
+} & Omit<import("node_modules/o1js/dist/node/lib/provable/types/provable-intf.js").Provable<{
+    address: PublicKey;
+    tokenId: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+    previousVerificationKeyHash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+    newVerificationKeyHash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+}, {
+    address: {
+        x: bigint;
+        isOdd: boolean;
+    };
+    tokenId: bigint;
+    previousVerificationKeyHash: bigint;
+    newVerificationKeyHash: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[]) => {
+        address: PublicKey;
+        tokenId: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+        previousVerificationKeyHash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+        newVerificationKeyHash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+    };
+} & {
+    fromValue: (value: {
+        address: PublicKey | {
+            x: Field | bigint;
+            isOdd: Bool | boolean;
+        };
+        tokenId: string | number | bigint | import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+        previousVerificationKeyHash: string | number | bigint | import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+        newVerificationKeyHash: string | number | bigint | import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+    }) => {
+        address: PublicKey;
+        tokenId: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+        previousVerificationKeyHash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+        newVerificationKeyHash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+    };
+    toInput: (x: {
+        address: PublicKey;
+        tokenId: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+        previousVerificationKeyHash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+        newVerificationKeyHash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+    }) => {
+        fields?: Field[] | undefined;
+        packed?: [Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        address: PublicKey;
+        tokenId: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+        previousVerificationKeyHash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+        newVerificationKeyHash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+    }) => {
+        address: string;
+        tokenId: string;
+        previousVerificationKeyHash: string;
+        newVerificationKeyHash: string;
+    };
+    fromJSON: (x: {
+        address: string;
+        tokenId: string;
+        previousVerificationKeyHash: string;
+        newVerificationKeyHash: string;
+    }) => {
+        address: PublicKey;
+        tokenId: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+        previousVerificationKeyHash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+        newVerificationKeyHash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+    };
+    empty: () => {
+        address: PublicKey;
+        tokenId: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+        previousVerificationKeyHash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+        newVerificationKeyHash: import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+    };
+};
+/**
+ * Represents the data required to upgrade a contract's verification key.
+ * It includes the contract's address, token ID, previous verification key hash,
+ * and the new verification key hash. This class also provides a `hash()` method
+ * to generate a unique identifier for the upgrade data.
+ */
+declare class VerificationKeyUpgradeData extends VerificationKeyUpgradeData_base {
+    /**
+     * Generates a unique hash for the upgrade data using the Poseidon hash function.
+     * @returns {Field} The hash representing the upgrade data.
+     */
+    hash(): Field;
+}
+declare const PublicKeyOption_base: Omit<import("node_modules/o1js/dist/node/lib/provable/types/provable-intf.js").Provable<Option<PublicKey, {
+    x: bigint;
+    isOdd: boolean;
+}>, {
+    x: bigint;
+    isOdd: boolean;
+} | undefined>, "fromFields"> & {
+    fromFields: (fields: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[]) => Option<PublicKey, {
+        x: bigint;
+        isOdd: boolean;
+    }>;
+} & (new (option: {
+    isSome: Bool;
+    value: PublicKey;
+}) => Option<PublicKey, {
+    x: bigint;
+    isOdd: boolean;
+}>) & {
+    fromValue(value: PublicKey | {
+        x: bigint;
+        isOdd: boolean;
+    } | {
+        isSome: boolean | Bool;
+        value: PublicKey | {
+            x: bigint;
+            isOdd: boolean;
+        };
+    } | undefined): Option<PublicKey, {
+        x: bigint;
+        isOdd: boolean;
+    }>;
+    from(value?: PublicKey | {
+        x: bigint;
+        isOdd: boolean;
+    } | undefined): Option<PublicKey, {
+        x: bigint;
+        isOdd: boolean;
+    }>;
+    none(): Option<PublicKey, {
+        x: bigint;
+        isOdd: boolean;
+    }>;
+};
+/**
+ * An optional `PublicKey` type, used to specify the next upgrade authority if needed.
+ * This is crucial when the current upgrade authority cannot be used in future upgrades
+ * due to changes in the o1js version or other factors.
+ */
+declare class PublicKeyOption extends PublicKeyOption_base {
+}
+declare const UpgradeAuthorityAnswer_base: (new (value: {
+    nextUpgradeAuthority: PublicKeyOption;
+    isVerified: import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool;
+}) => {
+    nextUpgradeAuthority: PublicKeyOption;
+    isVerified: import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool;
+}) & {
+    _isStruct: true;
+} & Omit<import("node_modules/o1js/dist/node/lib/provable/types/provable-intf.js").Provable<{
+    nextUpgradeAuthority: PublicKeyOption;
+    isVerified: import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool;
+}, {
+    nextUpgradeAuthority: {
+        x: bigint;
+        isOdd: boolean;
+    } | undefined;
+    isVerified: boolean;
+}>, "fromFields"> & {
+    fromFields: (fields: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[]) => {
+        nextUpgradeAuthority: PublicKeyOption;
+        isVerified: import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool;
+    };
+} & {
+    fromValue: (value: {
+        nextUpgradeAuthority: PublicKey | {
+            x: bigint;
+            isOdd: boolean;
+        } | PublicKeyOption | {
+            isSome: boolean | Bool;
+            value: PublicKey | {
+                x: bigint;
+                isOdd: boolean;
+            };
+        } | undefined;
+        isVerified: boolean | import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool;
+    }) => {
+        nextUpgradeAuthority: PublicKeyOption;
+        isVerified: import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool;
+    };
+    toInput: (x: {
+        nextUpgradeAuthority: PublicKeyOption;
+        isVerified: import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool;
+    }) => {
+        fields?: Field[] | undefined;
+        packed?: [Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        nextUpgradeAuthority: PublicKeyOption;
+        isVerified: import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool;
+    }) => {
+        nextUpgradeAuthority: {
+            prototype: {
+                isSome: boolean;
+                value: any;
+                assertSome: {};
+                assertNone: {};
+                orElse: {};
+            };
+            toFields: {};
+            toAuxiliary: {};
+            sizeInFields: {};
+            check: {};
+            toValue: {};
+            fromValue: {};
+            toCanonical?: {} | null | undefined;
+            fromFields: {};
+            from: {};
+            none: {};
+        };
+        isVerified: boolean;
+    };
+    fromJSON: (x: {
+        nextUpgradeAuthority: {
+            prototype: {
+                isSome: boolean;
+                value: any;
+                assertSome: {};
+                assertNone: {};
+                orElse: {};
+            };
+            toFields: {};
+            toAuxiliary: {};
+            sizeInFields: {};
+            check: {};
+            toValue: {};
+            fromValue: {};
+            toCanonical?: {} | null | undefined;
+            fromFields: {};
+            from: {};
+            none: {};
+        };
+        isVerified: boolean;
+    }) => {
+        nextUpgradeAuthority: PublicKeyOption;
+        isVerified: import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool;
+    };
+    empty: () => {
+        nextUpgradeAuthority: PublicKeyOption;
+        isVerified: import("node_modules/o1js/dist/node/lib/provable/bool.js").Bool;
+    };
+};
+/**
+ * Represents the response from the upgrade authority after verifying the upgrade data.
+ * It contains the next upgrade authority's public key if a change is required, and a boolean
+ * indicating whether the upgrade data has been successfully verified.
+ */
+declare class UpgradeAuthorityAnswer extends UpgradeAuthorityAnswer_base {
+}
+/**
+ * Interface that any upgrade authority contract should implement.
+ * Extends `SmartContract` and requires the implementation of the `verifyUpgradeData()` method,
+ * which takes `VerificationKeyUpgradeData` as input and returns an `UpgradeAuthorityAnswer`.
+ */
+type UpgradeAuthorityBase = SmartContract & {
+    /**
+     * Verifies the upgrade data for upgrading a contract's verification key.
+     * @param {VerificationKeyUpgradeData} data - The data required for verification.
+     * @returns {Promise<UpgradeAuthorityAnswer>} The result of the verification.
+     */
+    verifyUpgradeData(data: VerificationKeyUpgradeData): Promise<UpgradeAuthorityAnswer>;
+};
+/**
+ * Interface for contracts that can be upgraded.
+ * Extends `SmartContract` and requires methods to retrieve the associated upgrade authority contract
+ * and to upgrade the contract's verification key using the provided verification key.
+ */
+type UpgradableContract = SmartContract & {
+    /**
+     * Retrieves the associated upgrade authority contract.
+     * @returns {Promise<UpgradeAuthorityBase>} The upgrade authority contract.
+     */
+    getUpgradeContract(): Promise<UpgradeAuthorityBase>;
+    /**
+     * Upgrades the contract's verification key using the provided verification key.
+     * @param {VerificationKey} vk - The new verification key.
+     * @returns {Promise<void>}
+     */
+    upgradeVerificationKey(vk: VerificationKey): Promise<void>;
+};
+/**
+ * Defines a constructor for contracts implementing `UpgradeAuthorityBase`,
+ * accepting an `upgradeAuthority` public key and returning an instance of `UpgradeAuthorityBase`.
+ */
+type UpgradeAuthorityContractConstructor = new (upgradeAuthority: PublicKey) => UpgradeAuthorityBase;

package/dist/node/upgradable.js

@@ -0,0 +1,54 @@
+import { Bool, PublicKey, Field, Struct, Poseidon, Option, } from "o1js";
+export { VerificationKeyUpgradeData, PublicKeyOption, UpgradeAuthorityAnswer, };
+/**
+ * Represents the data required to upgrade a contract's verification key.
+ * It includes the contract's address, token ID, previous verification key hash,
+ * and the new verification key hash. This class also provides a `hash()` method
+ * to generate a unique identifier for the upgrade data.
+ */
+class VerificationKeyUpgradeData extends Struct({
+    /** The address of the contract to be upgraded. */
+    address: PublicKey,
+    /** The token ID associated with the contract. */
+    tokenId: Field,
+    /** The hash of the previous verification key. */
+    previousVerificationKeyHash: Field,
+    /** The hash of the new verification key. */
+    newVerificationKeyHash: Field,
+}) {
+    /**
+     * Generates a unique hash for the upgrade data using the Poseidon hash function.
+     * @returns {Field} The hash representing the upgrade data.
+     */
+    hash() {
+        return Poseidon.hash(VerificationKeyUpgradeData.toFields(this));
+    }
+}
+/**
+ * An optional `PublicKey` type, used to specify the next upgrade authority if needed.
+ * This is crucial when the current upgrade authority cannot be used in future upgrades
+ * due to changes in the o1js version or other factors.
+ */
+class PublicKeyOption extends Option(PublicKey) {
+}
+/**
+ * Represents the response from the upgrade authority after verifying the upgrade data.
+ * It contains the next upgrade authority's public key if a change is required, and a boolean
+ * indicating whether the upgrade data has been successfully verified.
+ */
+class UpgradeAuthorityAnswer extends Struct({
+    /**
+     * The public key of the next upgrade authority, if a change is required.
+     *
+     * If we upgrade the verification key, we may not be able to use the same upgrade
+     * authority next time because the new o1js version can break the verification key
+     * of the upgrade authority too, and since the upgrade authority serves many
+     * contracts, it cannot be upgraded. In this case, we need to use another upgrade
+     * authority with the public key that will be provided in `nextUpgradeAuthority`.
+     */
+    nextUpgradeAuthority: PublicKeyOption,
+    /** Indicates whether the upgrade data has been successfully verified. */
+    isVerified: Bool,
+}) {
+}
+//# sourceMappingURL=upgradable.js.map

package/dist/node/upgradable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgradable.js","sourceRoot":"","sources":["../../src/upgradable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,SAAS,EAGT,KAAK,EACL,MAAM,EACN,QAAQ,EACR,MAAM,GACP,MAAM,MAAM,CAAC;AAEd,OAAO,EAEL,0BAA0B,EAG1B,eAAe,EACf,sBAAsB,GACvB,CAAC;AAEF;;;;;GAKG;AACH,MAAM,0BAA2B,SAAQ,MAAM,CAAC;IAC9C,kDAAkD;IAClD,OAAO,EAAE,SAAS;IAClB,iDAAiD;IACjD,OAAO,EAAE,KAAK;IACd,iDAAiD;IACjD,2BAA2B,EAAE,KAAK;IAClC,4CAA4C;IAC5C,sBAAsB,EAAE,KAAK;CAC9B,CAAC;IACA;;;OAGG;IACH,IAAI;QACF,OAAO,QAAQ,CAAC,IAAI,CAAC,0BAA0B,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;IAClE,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,eAAgB,SAAQ,MAAM,CAAC,SAAS,CAAC;CAAG;AAElD;;;;GAIG;AACH,MAAM,sBAAuB,SAAQ,MAAM,CAAC;IAC1C;;;;;;;;OAQG;IACH,oBAAoB,EAAE,eAAe;IACrC,yEAAyE;IACzE,UAAU,EAAE,IAAI;CACjB,CAAC;CAAG"}

package/dist/node/upgrade.d.ts

@@ -0,0 +1,186 @@
+import { SmartContract, State, VerificationKey, Field, UInt32 } from "o1js";
+import { IndexedMapSerialized, Storage } from "@silvana-one/storage";
+import { UpgradeAuthorityBase, VerificationKeyUpgradeData, UpgradeAuthorityAnswer } from "./upgradable.js";
+import { UpgradeAuthorityDatabase, ValidatorsState, UpgradeDatabaseState, ValidatorsVotingProof, UpgradeDatabaseStatePacked } from "./validators.js";
+export { VerificationKeyUpgradeAuthority, UpgradeAuthorityDatabase, ValidatorsListEvent, ValidatorsListData, };
+/**
+ * Interface representing the data for a list of validators.
+ */
+interface ValidatorsListData {
+    validators: {
+        publicKey: string;
+        authorizedToVote: boolean;
+    }[];
+    validatorsCount: number;
+    root: string;
+    map: IndexedMapSerialized;
+}
+declare const ValidatorsListEvent_base: (new (value: {
+    validators: ValidatorsState;
+    storage: Storage;
+}) => {
+    validators: ValidatorsState;
+    storage: Storage;
+}) & {
+    _isStruct: true;
+} & Omit<import("node_modules/o1js/dist/node/lib/provable/types/provable-intf.js").Provable<{
+    validators: ValidatorsState;
+    storage: Storage;
+}, {
+    validators: {
+        chainId: bigint;
+        root: bigint;
+        count: bigint;
+    };
+    storage: {
+        url: bigint[];
+    };
+}>, "fromFields"> & {
+    fromFields: (fields: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[]) => {
+        validators: ValidatorsState;
+        storage: Storage;
+    };
+} & {
+    fromValue: (value: {
+        validators: ValidatorsState | {
+            chainId: string | number | bigint | import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+            root: string | number | bigint | import("node_modules/o1js/dist/node/lib/provable/field.js").Field;
+            count: bigint | UInt32;
+        };
+        storage: Storage | {
+            url: import("node_modules/o1js/dist/node/lib/provable/field.js").Field[] | bigint[];
+        };
+    }) => {
+        validators: ValidatorsState;
+        storage: Storage;
+    };
+    toInput: (x: {
+        validators: ValidatorsState;
+        storage: Storage;
+    }) => {
+        fields?: Field[] | undefined;
+        packed?: [Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        validators: ValidatorsState;
+        storage: Storage;
+    }) => {
+        validators: {
+            chainId: string;
+            root: string;
+            count: string;
+        };
+        storage: {
+            url: string[];
+        };
+    };
+    fromJSON: (x: {
+        validators: {
+            chainId: string;
+            root: string;
+            count: string;
+        };
+        storage: {
+            url: string[];
+        };
+    }) => {
+        validators: ValidatorsState;
+        storage: Storage;
+    };
+    empty: () => {
+        validators: ValidatorsState;
+        storage: Storage;
+    };
+};
+/**
+ * Event emitted when the validators list is updated.
+ */
+declare class ValidatorsListEvent extends ValidatorsListEvent_base {
+}
+/**
+ * **VerificationKeyUpgradeAuthority** is a smart contract that provides a secure mechanism
+ * for upgrading the verification keys of other contracts without requiring redeployment.
+ * It manages a list of validators who can vote on upgrade proposals, ensuring that only
+ * authorized upgrades are applied.
+ *
+ * **Key Features:**
+ * - **Verification Key Management**: Allows for secure upgrades of verification keys for other contracts.
+ * - **Validators Governance**: Maintains a list of authorized validators who can vote on upgrade proposals.
+ * - **Secure Voting Mechanism**: Implements Zero-Knowledge proofs to validate votes from validators without revealing sensitive information.
+ * - **Upgrade Database Management**: Keeps track of upgrade proposals and their validity periods.
+ * - **Event Emissions**: Emits events when validators list or upgrade database is updated.
+ */
+declare class VerificationKeyUpgradeAuthority extends SmartContract implements UpgradeAuthorityBase {
+    /**
+     * The hash of the verification key.
+     * @type {State<Field>}
+     */
+    verificationKeyHash: State<import("node_modules/o1js/dist/node/lib/provable/field.js").Field>;
+    /**
+     * The hash representing the current state of the validators list.
+     * @type {State<Field>}
+     */
+    validators: State<import("node_modules/o1js/dist/node/lib/provable/field.js").Field>;
+    /**
+     * Packed state containing the upgrade database information.
+     * @type {State<UpgradeDatabaseStatePacked>}
+     */
+    upgradeDatabasePacked: State<UpgradeDatabaseStatePacked>;
+    /**
+     * The events emitted by the VerificationKeyUpgradeAuthority contract.
+     */
+    events: {
+        validatorsList: typeof ValidatorsListEvent;
+        updateDatabase: typeof UpgradeDatabaseState;
+    };
+    /**
+     * Deploys the contract and sets the initial state.
+     */
+    deploy(): Promise<void>;
+    /**
+     * Initializes the contract with validators and sets the verification key hash.
+     *
+     * @param {ValidatorsState} validators - The initial validators state.
+     * @param {Storage} storage - Off-chain storage information, e.g., IPFS hash.
+     * @param {Field} verificationKeyHash - The hash of the verification key.
+     */
+    initialize(validators: ValidatorsState, storage: Storage, verificationKeyHash: Field): Promise<void>;
+    /**
+     * Sets the validators list and emits an event.
+     *
+     * @param {ValidatorsState} validators - The validators state to set.
+     * @param {Storage} storage - The storage associated with the validators list.
+     */
+    setValidatorsList(validators: ValidatorsState, storage: Storage): Promise<void>;
+    /**
+     * Verifies the upgrade data provided by another contract.
+     *
+     * @param {VerificationKeyUpgradeData} data - The upgrade data to verify.
+     * @returns {Promise<UpgradeAuthorityAnswer>} - The answer indicating verification result.
+     */
+    verifyUpgradeData(data: VerificationKeyUpgradeData): Promise<UpgradeAuthorityAnswer>;
+    /**
+     * Updates the upgrade database after validator consensus.
+     *
+     * @param {ValidatorsVotingProof} proof - The proof of validators voting.
+     * @param {VerificationKey} vk - The verification key to validate the proof.
+     */
+    updateDatabase(proof: ValidatorsVotingProof, vk: VerificationKey, validators: ValidatorsState): Promise<void>;
+    /**
+     * Updates the validators list based on validator votes.
+     *
+     * @param {ValidatorsState} validators - The new validators state.
+     * @param {Storage} storage - The storage associated with the validators list.
+     * @param {ValidatorsVotingProof} proof - The proof of validators voting.
+     * @param {VerificationKey} vk - The verification key to validate the proof.
+     */
+    updateValidatorsList(validators: ValidatorsState, storage: Storage, proof: ValidatorsVotingProof, vk: VerificationKey): Promise<void>;
+    /**
+     * Checks the validators' decision by verifying the provided proof.
+     *
+     * @param {ValidatorsVotingProof} proof - The proof to verify.
+     * @param {VerificationKey} vk - The verification key to validate the proof.
+     * @param {Field} decisionType - The type of decision being validated.
+     */
+    checkValidatorsDecision(proof: ValidatorsVotingProof, vk: VerificationKey, decisionType: Field, validatorsState: ValidatorsState): Promise<void>;
+}