@cofhe/mock-contracts 0.7.0 → 0.8.0

package/dist/index.d.ts

@@ -10,14 +10,123 @@ type MockArtifact = {
     isFixed: false;
 });
 
+declare const MockCoFHEAddressBookArtifact: {
+    readonly contractName: "MockCoFHEAddressBook";
+    readonly isFixed: true;
+    readonly fixedAddress: "0xC0F4e00E531a2B086492Ae3DCC1515038307196b";
+    readonly abi: readonly [{
+        readonly type: "function";
+        readonly name: "exists";
+        readonly inputs: readonly [];
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly type: "bool";
+            readonly internalType: "bool";
+        }];
+        readonly stateMutability: "pure";
+    }, {
+        readonly type: "function";
+        readonly name: "getTm";
+        readonly inputs: readonly [{
+            readonly name: "id";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }];
+        readonly outputs: readonly [{
+            readonly name: "tm";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+        readonly stateMutability: "view";
+    }, {
+        readonly type: "function";
+        readonly name: "setTm";
+        readonly inputs: readonly [{
+            readonly name: "id";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "tm";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly name: "unsetTm";
+        readonly inputs: readonly [{
+            readonly name: "id";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "event";
+        readonly name: "TaskManagerSet";
+        readonly inputs: readonly [{
+            readonly name: "id";
+            readonly type: "uint256";
+            readonly indexed: true;
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "previous";
+            readonly type: "address";
+            readonly indexed: true;
+            readonly internalType: "address";
+        }, {
+            readonly name: "current";
+            readonly type: "address";
+            readonly indexed: true;
+            readonly internalType: "address";
+        }];
+        readonly anonymous: false;
+    }, {
+        readonly type: "error";
+        readonly name: "InvalidAddress";
+        readonly inputs: readonly [];
+    }, {
+        readonly type: "error";
+        readonly name: "TaskManagerNotSet";
+        readonly inputs: readonly [{
+            readonly name: "id";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }];
+    }];
+};
+
 declare const MockTaskManagerArtifact: {
     readonly contractName: "MockTaskManager";
     readonly isFixed: true;
-    readonly fixedAddress: "0xeA30c4B8b44078Bbf8a6ef5b9f1eC1626C7848D9";
+    readonly fixedAddress: "0x0000000000000000000000000000000000005000";
     readonly abi: readonly [{
         readonly type: "constructor";
         readonly inputs: readonly [];
         readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly name: "MOCK_dispatchOperation";
+        readonly inputs: readonly [{
+            readonly name: "ctHash";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "funcId";
+            readonly type: "uint8";
+            readonly internalType: "enum FunctionId";
+        }, {
+            readonly name: "inputs";
+            readonly type: "uint256[]";
+            readonly internalType: "uint256[]";
+        }, {
+            readonly name: "arity";
+            readonly type: "uint8";
+            readonly internalType: "uint8";
+        }];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
     }, {
         readonly type: "function";
         readonly name: "MOCK_logAllow";
@@ -442,6 +551,16 @@ declare const MockTaskManagerArtifact: {
             readonly internalType: "bool";
         }];
         readonly stateMutability: "view";
+    }, {
+        readonly type: "function";
+        readonly name: "mockGasExcluded";
+        readonly inputs: readonly [];
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly type: "bool";
+            readonly internalType: "bool";
+        }];
+        readonly stateMutability: "view";
     }, {
         readonly type: "function";
         readonly name: "mockStorage";
@@ -560,6 +679,16 @@ declare const MockTaskManagerArtifact: {
         }];
         readonly outputs: readonly [];
         readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly name: "setMockGasExcluded";
+        readonly inputs: readonly [{
+            readonly name: "_mockGasExcluded";
+            readonly type: "bool";
+            readonly internalType: "bool";
+        }];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
     }, {
         readonly type: "function";
         readonly name: "setSecurityZoneMax";
@@ -748,6 +877,16 @@ declare const MockTaskManagerArtifact: {
             readonly internalType: "address";
         }];
         readonly anonymous: false;
+    }, {
+        readonly type: "event";
+        readonly name: "MockGasConsumed";
+        readonly inputs: readonly [{
+            readonly name: "gas";
+            readonly type: "uint256";
+            readonly indexed: false;
+            readonly internalType: "uint256";
+        }];
+        readonly anonymous: false;
     }, {
         readonly type: "event";
         readonly name: "ProtocolNotification";
@@ -982,6 +1121,10 @@ declare const MockTaskManagerArtifact: {
             readonly type: "address";
             readonly internalType: "address";
         }];
+    }, {
+        readonly type: "error";
+        readonly name: "OnlySelf";
+        readonly inputs: readonly [];
     }, {
         readonly type: "error";
         readonly name: "RandomFunctionNotSupported";
@@ -1024,16 +1167,6 @@ declare const MockACLArtifact: {
         readonly type: "constructor";
         readonly inputs: readonly [];
         readonly stateMutability: "nonpayable";
-    }, {
-        readonly type: "function";
-        readonly name: "TASK_MANAGER_ADDRESS_";
-        readonly inputs: readonly [];
-        readonly outputs: readonly [{
-            readonly name: "";
-            readonly type: "address";
-            readonly internalType: "address";
-        }];
-        readonly stateMutability: "view";
     }, {
         readonly type: "function";
         readonly name: "allow";
@@ -1474,6 +1607,16 @@ declare const MockACLArtifact: {
         }];
         readonly outputs: readonly [];
         readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly name: "setTaskManager";
+        readonly inputs: readonly [{
+            readonly name: "newAddress";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
     }, {
         readonly type: "function";
         readonly name: "shareCtHash";
@@ -1567,6 +1710,21 @@ declare const MockACLArtifact: {
             readonly internalType: "address";
         }];
         readonly anonymous: false;
+    }, {
+        readonly type: "event";
+        readonly name: "TaskManagerUpdated";
+        readonly inputs: readonly [{
+            readonly name: "oldAddress";
+            readonly type: "address";
+            readonly indexed: false;
+            readonly internalType: "address";
+        }, {
+            readonly name: "newAddress";
+            readonly type: "address";
+            readonly indexed: false;
+            readonly internalType: "address";
+        }];
+        readonly anonymous: false;
     }, {
         readonly type: "error";
         readonly name: "AlreadyDelegated";
@@ -1583,6 +1741,10 @@ declare const MockACLArtifact: {
         readonly type: "error";
         readonly name: "InvalidShortString";
         readonly inputs: readonly [];
+    }, {
+        readonly type: "error";
+        readonly name: "InvalidTaskManagerAddress";
+        readonly inputs: readonly [];
     }, {
         readonly type: "error";
         readonly name: "NotShared";
@@ -2854,9 +3016,8 @@ type ACPStruct$2 = {
     recipientSignature: BytesLike;
 };
 interface MockACLInterface extends Interface {
-    getFunction(nameOrSignature: 'TASK_MANAGER_ADDRESS_' | 'allow' | 'allowForDecryption' | 'allowGlobal' | 'allowTransient' | 'allowedOnBehalf' | 'allowedTransient' | 'checkPermissionValidity' | 'cleanTransientStorage' | 'defaultRevokerContract' | 'delegateAccount' | 'eip712Domain' | 'exists' | 'getTaskManagerAddress' | 'getVersion' | 'globalAllowed' | 'hashTypedDataV4' | 'isAllowed' | 'isAllowedForDecryption' | 'isAllowedWithPermission' | 'persistAllowed' | 'receiveCtHash' | 'setDefaultRevokerContract' | 'setShareRegistry' | 'shareCtHash' | 'shareRegistry'): FunctionFragment;
-    getEvent(nameOrSignatureOrTopic: 'AllowedForDecryption' | 'DefaultRevokerContractUpdated' | 'EIP712DomainChanged' | 'NewDelegation' | 'ShareRegistryUpdated'): EventFragment;
-    encodeFunctionData(functionFragment: 'TASK_MANAGER_ADDRESS_', values?: undefined): string;
+    getFunction(nameOrSignature: 'allow' | 'allowForDecryption' | 'allowGlobal' | 'allowTransient' | 'allowedOnBehalf' | 'allowedTransient' | 'checkPermissionValidity' | 'cleanTransientStorage' | 'defaultRevokerContract' | 'delegateAccount' | 'eip712Domain' | 'exists' | 'getTaskManagerAddress' | 'getVersion' | 'globalAllowed' | 'hashTypedDataV4' | 'isAllowed' | 'isAllowedForDecryption' | 'isAllowedWithPermission' | 'persistAllowed' | 'receiveCtHash' | 'setDefaultRevokerContract' | 'setShareRegistry' | 'setTaskManager' | 'shareCtHash' | 'shareRegistry'): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: 'AllowedForDecryption' | 'DefaultRevokerContractUpdated' | 'EIP712DomainChanged' | 'NewDelegation' | 'ShareRegistryUpdated' | 'TaskManagerUpdated'): EventFragment;
     encodeFunctionData(functionFragment: 'allow', values: [BigNumberish, AddressLike, AddressLike]): string;
     encodeFunctionData(functionFragment: 'allowForDecryption', values: [BigNumberish[], AddressLike]): string;
     encodeFunctionData(functionFragment: 'allowGlobal', values: [BigNumberish, AddressLike]): string;
@@ -2880,9 +3041,9 @@ interface MockACLInterface extends Interface {
     encodeFunctionData(functionFragment: 'receiveCtHash', values: [BigNumberish, AddressLike, AddressLike]): string;
     encodeFunctionData(functionFragment: 'setDefaultRevokerContract', values: [AddressLike]): string;
     encodeFunctionData(functionFragment: 'setShareRegistry', values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: 'setTaskManager', values: [AddressLike]): string;
     encodeFunctionData(functionFragment: 'shareCtHash', values: [BigNumberish, AddressLike, AddressLike]): string;
     encodeFunctionData(functionFragment: 'shareRegistry', values?: undefined): string;
-    decodeFunctionResult(functionFragment: 'TASK_MANAGER_ADDRESS_', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'allow', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'allowForDecryption', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'allowGlobal', data: BytesLike): Result;
@@ -2906,6 +3067,7 @@ interface MockACLInterface extends Interface {
     decodeFunctionResult(functionFragment: 'receiveCtHash', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'setDefaultRevokerContract', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'setShareRegistry', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'setTaskManager', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'shareCtHash', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'shareRegistry', data: BytesLike): Result;
 }
@@ -2967,6 +3129,18 @@ declare namespace ShareRegistryUpdatedEvent {
     type Log = TypedEventLog<Event>;
     type LogDescription = TypedLogDescription<Event>;
 }
+declare namespace TaskManagerUpdatedEvent {
+    type InputTuple = [oldAddress: AddressLike, newAddress: AddressLike];
+    type OutputTuple = [oldAddress: string, newAddress: string];
+    interface OutputObject {
+        oldAddress: string;
+        newAddress: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
 interface MockACL extends BaseContract {
     connect(runner?: ContractRunner | null): MockACL;
     waitForDeployment(): Promise<this>;
@@ -2980,7 +3154,6 @@ interface MockACL extends BaseContract {
     listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
     listeners(eventName?: string): Promise<Array<Listener>>;
     removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
-    TASK_MANAGER_ADDRESS_: TypedContractMethod<[], [string], 'view'>;
     allow: TypedContractMethod<[
         handle: BigNumberish,
         account: AddressLike,
@@ -3048,6 +3221,7 @@ interface MockACL extends BaseContract {
     ], 'nonpayable'>;
     setDefaultRevokerContract: TypedContractMethod<[newAddress: AddressLike], [void], 'nonpayable'>;
     setShareRegistry: TypedContractMethod<[newAddress: AddressLike], [void], 'nonpayable'>;
+    setTaskManager: TypedContractMethod<[newAddress: AddressLike], [void], 'nonpayable'>;
     shareCtHash: TypedContractMethod<[
         handle: BigNumberish,
         sharer: AddressLike,
@@ -3057,7 +3231,6 @@ interface MockACL extends BaseContract {
     ], 'nonpayable'>;
     shareRegistry: TypedContractMethod<[], [string], 'view'>;
     getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
-    getFunction(nameOrSignature: 'TASK_MANAGER_ADDRESS_'): TypedContractMethod<[], [string], 'view'>;
     getFunction(nameOrSignature: 'allow'): TypedContractMethod<[handle: BigNumberish, account: AddressLike, requester: AddressLike], [void], 'nonpayable'>;
     getFunction(nameOrSignature: 'allowForDecryption'): TypedContractMethod<[handlesList: BigNumberish[], requester: AddressLike], [void], 'nonpayable'>;
     getFunction(nameOrSignature: 'allowGlobal'): TypedContractMethod<[handle: BigNumberish, requester: AddressLike], [void], 'nonpayable'>;
@@ -3113,6 +3286,7 @@ interface MockACL extends BaseContract {
     ], 'nonpayable'>;
     getFunction(nameOrSignature: 'setDefaultRevokerContract'): TypedContractMethod<[newAddress: AddressLike], [void], 'nonpayable'>;
     getFunction(nameOrSignature: 'setShareRegistry'): TypedContractMethod<[newAddress: AddressLike], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'setTaskManager'): TypedContractMethod<[newAddress: AddressLike], [void], 'nonpayable'>;
     getFunction(nameOrSignature: 'shareCtHash'): TypedContractMethod<[handle: BigNumberish, sharer: AddressLike, receiver: AddressLike], [void], 'nonpayable'>;
     getFunction(nameOrSignature: 'shareRegistry'): TypedContractMethod<[], [string], 'view'>;
     getEvent(key: 'AllowedForDecryption'): TypedContractEvent<AllowedForDecryptionEvent.InputTuple, AllowedForDecryptionEvent.OutputTuple, AllowedForDecryptionEvent.OutputObject>;
@@ -3120,6 +3294,7 @@ interface MockACL extends BaseContract {
     getEvent(key: 'EIP712DomainChanged'): TypedContractEvent<EIP712DomainChangedEvent.InputTuple, EIP712DomainChangedEvent.OutputTuple, EIP712DomainChangedEvent.OutputObject>;
     getEvent(key: 'NewDelegation'): TypedContractEvent<NewDelegationEvent.InputTuple, NewDelegationEvent.OutputTuple, NewDelegationEvent.OutputObject>;
     getEvent(key: 'ShareRegistryUpdated'): TypedContractEvent<ShareRegistryUpdatedEvent.InputTuple, ShareRegistryUpdatedEvent.OutputTuple, ShareRegistryUpdatedEvent.OutputObject>;
+    getEvent(key: 'TaskManagerUpdated'): TypedContractEvent<TaskManagerUpdatedEvent.InputTuple, TaskManagerUpdatedEvent.OutputTuple, TaskManagerUpdatedEvent.OutputObject>;
     filters: {
         'AllowedForDecryption(uint256[])': TypedContractEvent<AllowedForDecryptionEvent.InputTuple, AllowedForDecryptionEvent.OutputTuple, AllowedForDecryptionEvent.OutputObject>;
         AllowedForDecryption: TypedContractEvent<AllowedForDecryptionEvent.InputTuple, AllowedForDecryptionEvent.OutputTuple, AllowedForDecryptionEvent.OutputObject>;
@@ -3131,6 +3306,62 @@ interface MockACL extends BaseContract {
         NewDelegation: TypedContractEvent<NewDelegationEvent.InputTuple, NewDelegationEvent.OutputTuple, NewDelegationEvent.OutputObject>;
         'ShareRegistryUpdated(address,address)': TypedContractEvent<ShareRegistryUpdatedEvent.InputTuple, ShareRegistryUpdatedEvent.OutputTuple, ShareRegistryUpdatedEvent.OutputObject>;
         ShareRegistryUpdated: TypedContractEvent<ShareRegistryUpdatedEvent.InputTuple, ShareRegistryUpdatedEvent.OutputTuple, ShareRegistryUpdatedEvent.OutputObject>;
+        'TaskManagerUpdated(address,address)': TypedContractEvent<TaskManagerUpdatedEvent.InputTuple, TaskManagerUpdatedEvent.OutputTuple, TaskManagerUpdatedEvent.OutputObject>;
+        TaskManagerUpdated: TypedContractEvent<TaskManagerUpdatedEvent.InputTuple, TaskManagerUpdatedEvent.OutputTuple, TaskManagerUpdatedEvent.OutputObject>;
+    };
+}
+
+interface MockCoFHEAddressBookInterface extends Interface {
+    getFunction(nameOrSignature: 'exists' | 'getTm' | 'setTm' | 'unsetTm'): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: 'TaskManagerSet'): EventFragment;
+    encodeFunctionData(functionFragment: 'exists', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'getTm', values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'setTm', values: [BigNumberish, AddressLike]): string;
+    encodeFunctionData(functionFragment: 'unsetTm', values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: 'exists', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'getTm', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'setTm', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'unsetTm', data: BytesLike): Result;
+}
+declare namespace TaskManagerSetEvent {
+    type InputTuple = [id: BigNumberish, previous: AddressLike, current: AddressLike];
+    type OutputTuple = [id: bigint, previous: string, current: string];
+    interface OutputObject {
+        id: bigint;
+        previous: string;
+        current: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+interface MockCoFHEAddressBook extends BaseContract {
+    connect(runner?: ContractRunner | null): MockCoFHEAddressBook;
+    waitForDeployment(): Promise<this>;
+    interface: MockCoFHEAddressBookInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    exists: TypedContractMethod<[], [boolean], 'view'>;
+    getTm: TypedContractMethod<[id: BigNumberish], [string], 'view'>;
+    setTm: TypedContractMethod<[id: BigNumberish, tm: AddressLike], [void], 'nonpayable'>;
+    unsetTm: TypedContractMethod<[id: BigNumberish], [void], 'nonpayable'>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: 'exists'): TypedContractMethod<[], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'getTm'): TypedContractMethod<[id: BigNumberish], [string], 'view'>;
+    getFunction(nameOrSignature: 'setTm'): TypedContractMethod<[id: BigNumberish, tm: AddressLike], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'unsetTm'): TypedContractMethod<[id: BigNumberish], [void], 'nonpayable'>;
+    getEvent(key: 'TaskManagerSet'): TypedContractEvent<TaskManagerSetEvent.InputTuple, TaskManagerSetEvent.OutputTuple, TaskManagerSetEvent.OutputObject>;
+    filters: {
+        'TaskManagerSet(uint256,address,address)': TypedContractEvent<TaskManagerSetEvent.InputTuple, TaskManagerSetEvent.OutputTuple, TaskManagerSetEvent.OutputObject>;
+        TaskManagerSet: TypedContractEvent<TaskManagerSetEvent.InputTuple, TaskManagerSetEvent.OutputTuple, TaskManagerSetEvent.OutputObject>;
     };
 }
 
@@ -3153,8 +3384,9 @@ type ACPStruct$1 = {
     recipientSignature: BytesLike;
 };
 interface MockTaskManagerInterface extends Interface {
-    getFunction(nameOrSignature: 'MOCK_logAllow' | 'MOCK_setInEuintKey' | 'acl' | 'aggregator' | 'allow' | 'allowForDecryption' | 'allowGlobal' | 'allowTransient' | 'batchVerifyInputs' | 'createDecryptTask' | 'createRandomTask' | 'createTask' | 'decryptResultSigner' | 'exists' | 'getDecryptResult' | 'getDecryptResultSafe' | 'handleDecryptResult' | 'handleError' | 'inMockStorage' | 'initialize' | 'isAllowed' | 'isAllowedWithPermission' | 'isInitialized' | 'isPubliclyAllowed' | 'logOps' | 'mockStorage' | 'publishDecryptResult' | 'publishDecryptResultBatch' | 'receiveCtHash' | 'removeFirstLetter' | 'setACLContract' | 'setAggregator' | 'setDecryptResultSigner' | 'setLogOps' | 'setSecurityZoneMax' | 'setSecurityZoneMin' | 'setSecurityZones' | 'setVerifierSigner' | 'shareCtHash' | 'sliceString' | 'verifyDecryptResult' | 'verifyDecryptResultBatch' | 'verifyDecryptResultBatchSafe' | 'verifyDecryptResultSafe'): FunctionFragment;
-    getEvent(nameOrSignatureOrTopic: 'DecryptionResult' | 'ProtocolNotification' | 'TaskCreated'): EventFragment;
+    getFunction(nameOrSignature: 'MOCK_dispatchOperation' | 'MOCK_logAllow' | 'MOCK_setInEuintKey' | 'acl' | 'aggregator' | 'allow' | 'allowForDecryption' | 'allowGlobal' | 'allowTransient' | 'batchVerifyInputs' | 'createDecryptTask' | 'createRandomTask' | 'createTask' | 'decryptResultSigner' | 'exists' | 'getDecryptResult' | 'getDecryptResultSafe' | 'handleDecryptResult' | 'handleError' | 'inMockStorage' | 'initialize' | 'isAllowed' | 'isAllowedWithPermission' | 'isInitialized' | 'isPubliclyAllowed' | 'logOps' | 'mockGasExcluded' | 'mockStorage' | 'publishDecryptResult' | 'publishDecryptResultBatch' | 'receiveCtHash' | 'removeFirstLetter' | 'setACLContract' | 'setAggregator' | 'setDecryptResultSigner' | 'setLogOps' | 'setMockGasExcluded' | 'setSecurityZoneMax' | 'setSecurityZoneMin' | 'setSecurityZones' | 'setVerifierSigner' | 'shareCtHash' | 'sliceString' | 'verifyDecryptResult' | 'verifyDecryptResultBatch' | 'verifyDecryptResultBatchSafe' | 'verifyDecryptResultSafe'): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: 'DecryptionResult' | 'MockGasConsumed' | 'ProtocolNotification' | 'TaskCreated'): EventFragment;
+    encodeFunctionData(functionFragment: 'MOCK_dispatchOperation', values: [BigNumberish, BigNumberish, BigNumberish[], BigNumberish]): string;
     encodeFunctionData(functionFragment: 'MOCK_logAllow', values: [string, BigNumberish, AddressLike]): string;
     encodeFunctionData(functionFragment: 'MOCK_setInEuintKey', values: [BigNumberish, BigNumberish]): string;
     encodeFunctionData(functionFragment: 'acl', values?: undefined): string;
@@ -3180,6 +3412,7 @@ interface MockTaskManagerInterface extends Interface {
     encodeFunctionData(functionFragment: 'isInitialized', values?: undefined): string;
     encodeFunctionData(functionFragment: 'isPubliclyAllowed', values: [BigNumberish]): string;
     encodeFunctionData(functionFragment: 'logOps', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'mockGasExcluded', values?: undefined): string;
     encodeFunctionData(functionFragment: 'mockStorage', values: [BigNumberish]): string;
     encodeFunctionData(functionFragment: 'publishDecryptResult', values: [BigNumberish, BigNumberish, BytesLike]): string;
     encodeFunctionData(functionFragment: 'publishDecryptResultBatch', values: [BigNumberish[], BigNumberish[], BytesLike[]]): string;
@@ -3189,6 +3422,7 @@ interface MockTaskManagerInterface extends Interface {
     encodeFunctionData(functionFragment: 'setAggregator', values: [AddressLike]): string;
     encodeFunctionData(functionFragment: 'setDecryptResultSigner', values: [AddressLike]): string;
     encodeFunctionData(functionFragment: 'setLogOps', values: [boolean]): string;
+    encodeFunctionData(functionFragment: 'setMockGasExcluded', values: [boolean]): string;
     encodeFunctionData(functionFragment: 'setSecurityZoneMax', values: [BigNumberish]): string;
     encodeFunctionData(functionFragment: 'setSecurityZoneMin', values: [BigNumberish]): string;
     encodeFunctionData(functionFragment: 'setSecurityZones', values: [BigNumberish, BigNumberish]): string;
@@ -3199,6 +3433,7 @@ interface MockTaskManagerInterface extends Interface {
     encodeFunctionData(functionFragment: 'verifyDecryptResultBatch', values: [BigNumberish[], BigNumberish[], BytesLike[]]): string;
     encodeFunctionData(functionFragment: 'verifyDecryptResultBatchSafe', values: [BigNumberish[], BigNumberish[], BytesLike[]]): string;
     encodeFunctionData(functionFragment: 'verifyDecryptResultSafe', values: [BigNumberish, BigNumberish, BytesLike]): string;
+    decodeFunctionResult(functionFragment: 'MOCK_dispatchOperation', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'MOCK_logAllow', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'MOCK_setInEuintKey', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'acl', data: BytesLike): Result;
@@ -3224,6 +3459,7 @@ interface MockTaskManagerInterface extends Interface {
     decodeFunctionResult(functionFragment: 'isInitialized', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'isPubliclyAllowed', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'logOps', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'mockGasExcluded', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'mockStorage', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'publishDecryptResult', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'publishDecryptResultBatch', data: BytesLike): Result;
@@ -3233,6 +3469,7 @@ interface MockTaskManagerInterface extends Interface {
     decodeFunctionResult(functionFragment: 'setAggregator', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'setDecryptResultSigner', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'setLogOps', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'setMockGasExcluded', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'setSecurityZoneMax', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'setSecurityZoneMin', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'setSecurityZones', data: BytesLike): Result;
@@ -3257,6 +3494,17 @@ declare namespace DecryptionResultEvent {
     type Log = TypedEventLog<Event>;
     type LogDescription = TypedLogDescription<Event>;
 }
+declare namespace MockGasConsumedEvent {
+    type InputTuple = [gas: BigNumberish];
+    type OutputTuple = [gas: bigint];
+    interface OutputObject {
+        gas: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
 declare namespace ProtocolNotificationEvent {
     type InputTuple = [ctHash: BigNumberish, operation: string, errorMessage: string];
     type OutputTuple = [ctHash: bigint, operation: string, errorMessage: string];
@@ -3304,6 +3552,14 @@ interface MockTaskManager extends BaseContract {
     listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
     listeners(eventName?: string): Promise<Array<Listener>>;
     removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    MOCK_dispatchOperation: TypedContractMethod<[
+        ctHash: BigNumberish,
+        funcId: BigNumberish,
+        inputs: BigNumberish[],
+        arity: BigNumberish
+    ], [
+        void
+    ], 'nonpayable'>;
     MOCK_logAllow: TypedContractMethod<[operation: string, ctHash: BigNumberish, account: AddressLike], [void], 'view'>;
     MOCK_setInEuintKey: TypedContractMethod<[ctHash: BigNumberish, value: BigNumberish], [void], 'nonpayable'>;
     acl: TypedContractMethod<[], [string], 'view'>;
@@ -3367,6 +3623,7 @@ interface MockTaskManager extends BaseContract {
     isInitialized: TypedContractMethod<[], [boolean], 'view'>;
     isPubliclyAllowed: TypedContractMethod<[ctHash: BigNumberish], [boolean], 'view'>;
     logOps: TypedContractMethod<[], [boolean], 'view'>;
+    mockGasExcluded: TypedContractMethod<[], [boolean], 'view'>;
     mockStorage: TypedContractMethod<[arg0: BigNumberish], [bigint], 'view'>;
     publishDecryptResult: TypedContractMethod<[
         ctHash: BigNumberish,
@@ -3388,6 +3645,7 @@ interface MockTaskManager extends BaseContract {
     setAggregator: TypedContractMethod<[_aggregatorAddress: AddressLike], [void], 'nonpayable'>;
     setDecryptResultSigner: TypedContractMethod<[signer: AddressLike], [void], 'nonpayable'>;
     setLogOps: TypedContractMethod<[_logOps: boolean], [void], 'nonpayable'>;
+    setMockGasExcluded: TypedContractMethod<[_mockGasExcluded: boolean], [void], 'nonpayable'>;
     setSecurityZoneMax: TypedContractMethod<[securityZone: BigNumberish], [void], 'nonpayable'>;
     setSecurityZoneMin: TypedContractMethod<[securityZone: BigNumberish], [void], 'nonpayable'>;
     setSecurityZones: TypedContractMethod<[minSZ: BigNumberish, maxSZ: BigNumberish], [void], 'nonpayable'>;
@@ -3423,6 +3681,14 @@ interface MockTaskManager extends BaseContract {
         boolean
     ], 'view'>;
     getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: 'MOCK_dispatchOperation'): TypedContractMethod<[
+        ctHash: BigNumberish,
+        funcId: BigNumberish,
+        inputs: BigNumberish[],
+        arity: BigNumberish
+    ], [
+        void
+    ], 'nonpayable'>;
     getFunction(nameOrSignature: 'MOCK_logAllow'): TypedContractMethod<[operation: string, ctHash: BigNumberish, account: AddressLike], [void], 'view'>;
     getFunction(nameOrSignature: 'MOCK_setInEuintKey'): TypedContractMethod<[ctHash: BigNumberish, value: BigNumberish], [void], 'nonpayable'>;
     getFunction(nameOrSignature: 'acl'): TypedContractMethod<[], [string], 'view'>;
@@ -3470,6 +3736,7 @@ interface MockTaskManager extends BaseContract {
     getFunction(nameOrSignature: 'isInitialized'): TypedContractMethod<[], [boolean], 'view'>;
     getFunction(nameOrSignature: 'isPubliclyAllowed'): TypedContractMethod<[ctHash: BigNumberish], [boolean], 'view'>;
     getFunction(nameOrSignature: 'logOps'): TypedContractMethod<[], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'mockGasExcluded'): TypedContractMethod<[], [boolean], 'view'>;
     getFunction(nameOrSignature: 'mockStorage'): TypedContractMethod<[arg0: BigNumberish], [bigint], 'view'>;
     getFunction(nameOrSignature: 'publishDecryptResult'): TypedContractMethod<[ctHash: BigNumberish, result: BigNumberish, signature: BytesLike], [void], 'nonpayable'>;
     getFunction(nameOrSignature: 'publishDecryptResultBatch'): TypedContractMethod<[
@@ -3485,6 +3752,7 @@ interface MockTaskManager extends BaseContract {
     getFunction(nameOrSignature: 'setAggregator'): TypedContractMethod<[_aggregatorAddress: AddressLike], [void], 'nonpayable'>;
     getFunction(nameOrSignature: 'setDecryptResultSigner'): TypedContractMethod<[signer: AddressLike], [void], 'nonpayable'>;
     getFunction(nameOrSignature: 'setLogOps'): TypedContractMethod<[_logOps: boolean], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'setMockGasExcluded'): TypedContractMethod<[_mockGasExcluded: boolean], [void], 'nonpayable'>;
     getFunction(nameOrSignature: 'setSecurityZoneMax'): TypedContractMethod<[securityZone: BigNumberish], [void], 'nonpayable'>;
     getFunction(nameOrSignature: 'setSecurityZoneMin'): TypedContractMethod<[securityZone: BigNumberish], [void], 'nonpayable'>;
     getFunction(nameOrSignature: 'setSecurityZones'): TypedContractMethod<[minSZ: BigNumberish, maxSZ: BigNumberish], [void], 'nonpayable'>;
@@ -3508,11 +3776,14 @@ interface MockTaskManager extends BaseContract {
     ], 'view'>;
     getFunction(nameOrSignature: 'verifyDecryptResultSafe'): TypedContractMethod<[ctHash: BigNumberish, result: BigNumberish, signature: BytesLike], [boolean], 'view'>;
     getEvent(key: 'DecryptionResult'): TypedContractEvent<DecryptionResultEvent.InputTuple, DecryptionResultEvent.OutputTuple, DecryptionResultEvent.OutputObject>;
+    getEvent(key: 'MockGasConsumed'): TypedContractEvent<MockGasConsumedEvent.InputTuple, MockGasConsumedEvent.OutputTuple, MockGasConsumedEvent.OutputObject>;
     getEvent(key: 'ProtocolNotification'): TypedContractEvent<ProtocolNotificationEvent.InputTuple, ProtocolNotificationEvent.OutputTuple, ProtocolNotificationEvent.OutputObject>;
     getEvent(key: 'TaskCreated'): TypedContractEvent<TaskCreatedEvent.InputTuple, TaskCreatedEvent.OutputTuple, TaskCreatedEvent.OutputObject>;
     filters: {
         'DecryptionResult(uint256,uint256,address)': TypedContractEvent<DecryptionResultEvent.InputTuple, DecryptionResultEvent.OutputTuple, DecryptionResultEvent.OutputObject>;
         DecryptionResult: TypedContractEvent<DecryptionResultEvent.InputTuple, DecryptionResultEvent.OutputTuple, DecryptionResultEvent.OutputObject>;
+        'MockGasConsumed(uint256)': TypedContractEvent<MockGasConsumedEvent.InputTuple, MockGasConsumedEvent.OutputTuple, MockGasConsumedEvent.OutputObject>;
+        MockGasConsumed: TypedContractEvent<MockGasConsumedEvent.InputTuple, MockGasConsumedEvent.OutputTuple, MockGasConsumedEvent.OutputObject>;
         'ProtocolNotification(uint256,string,string)': TypedContractEvent<ProtocolNotificationEvent.InputTuple, ProtocolNotificationEvent.OutputTuple, ProtocolNotificationEvent.OutputObject>;
         ProtocolNotification: TypedContractEvent<ProtocolNotificationEvent.InputTuple, ProtocolNotificationEvent.OutputTuple, ProtocolNotificationEvent.OutputObject>;
         'TaskCreated(uint256,string,uint256,uint256,uint256)': TypedContractEvent<TaskCreatedEvent.InputTuple, TaskCreatedEvent.OutputTuple, TaskCreatedEvent.OutputObject>;
@@ -3823,4 +4094,4 @@ interface MockZkVerifier extends BaseContract {
     filters: {};
 }
 
-export { type ACPShareRegistry, ACPShareRegistryArtifact, type ACPTimestampRevoker, ACPTimestampRevokerArtifact, type MockACL, MockACLArtifact, type MockArtifact, type MockTaskManager, MockTaskManagerArtifact, type MockThresholdNetwork, MockThresholdNetworkArtifact, type MockZkVerifier, MockZkVerifierArtifact };
+export { type ACPShareRegistry, ACPShareRegistryArtifact, type ACPTimestampRevoker, ACPTimestampRevokerArtifact, type MockACL, MockACLArtifact, type MockArtifact, type MockCoFHEAddressBook, MockCoFHEAddressBookArtifact, type MockTaskManager, MockTaskManagerArtifact, type MockThresholdNetwork, MockThresholdNetworkArtifact, type MockZkVerifier, MockZkVerifierArtifact };