@cofhe/mock-contracts 0.3.1 → 0.3.2

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { DeferredTopicFilter, EventFragment, EventLog, TransactionRequest, Typed, ContractTransactionResponse, FunctionFragment, ContractTransaction, LogDescription, BaseContract, ContractRunner, Interface, BigNumberish, AddressLike, BytesLike, Result, Listener, ContractMethod } from 'ethers';
+
 type MockArtifact = {
     contractName: string;
     abi: any;
@@ -267,4 +269,989 @@ declare const TestBedArtifact: {
     deployedBytecode: string;
 };
 
-export { MockACLArtifact, type MockArtifact, MockTaskManagerArtifact, MockThresholdNetworkArtifact, MockZkVerifierArtifact, TestBedArtifact };
+interface TypedDeferredTopicFilter<_TCEvent extends TypedContractEvent> extends DeferredTopicFilter {
+}
+interface TypedContractEvent<InputTuple extends Array<any> = any, OutputTuple extends Array<any> = any, OutputObject = any> {
+    (...args: Partial<InputTuple>): TypedDeferredTopicFilter<TypedContractEvent<InputTuple, OutputTuple, OutputObject>>;
+    name: string;
+    fragment: EventFragment;
+    getFragment(...args: Partial<InputTuple>): EventFragment;
+}
+type __TypechainAOutputTuple<T> = T extends TypedContractEvent<infer _U, infer W> ? W : never;
+type __TypechainOutputObject<T> = T extends TypedContractEvent<infer _U, infer _W, infer V> ? V : never;
+interface TypedEventLog<TCEvent extends TypedContractEvent> extends Omit<EventLog, 'args'> {
+    args: __TypechainAOutputTuple<TCEvent> & __TypechainOutputObject<TCEvent>;
+}
+interface TypedLogDescription<TCEvent extends TypedContractEvent> extends Omit<LogDescription, 'args'> {
+    args: __TypechainAOutputTuple<TCEvent> & __TypechainOutputObject<TCEvent>;
+}
+type TypedListener<TCEvent extends TypedContractEvent> = (...listenerArg: [...__TypechainAOutputTuple<TCEvent>, TypedEventLog<TCEvent>, ...undefined[]]) => void;
+type StateMutability = 'nonpayable' | 'payable' | 'view';
+type BaseOverrides = Omit<TransactionRequest, 'to' | 'data'>;
+type NonPayableOverrides = Omit<BaseOverrides, 'value' | 'blockTag' | 'enableCcipRead'>;
+type PayableOverrides = Omit<BaseOverrides, 'blockTag' | 'enableCcipRead'>;
+type ViewOverrides = Omit<TransactionRequest, 'to' | 'data'>;
+type Overrides<S extends StateMutability> = S extends 'nonpayable' ? NonPayableOverrides : S extends 'payable' ? PayableOverrides : ViewOverrides;
+type PostfixOverrides<A extends Array<any>, S extends StateMutability> = A | [...A, Overrides<S>];
+type ContractMethodArgs<A extends Array<any>, S extends StateMutability> = PostfixOverrides<{
+    [I in keyof A]-?: A[I] | Typed;
+}, S>;
+type DefaultReturnType<R> = R extends Array<any> ? R[0] : R;
+interface TypedContractMethod<A extends Array<any> = Array<any>, R = any, S extends StateMutability = 'payable'> {
+    (...args: ContractMethodArgs<A, S>): S extends 'view' ? Promise<DefaultReturnType<R>> : Promise<ContractTransactionResponse>;
+    name: string;
+    fragment: FunctionFragment;
+    getFragment(...args: ContractMethodArgs<A, S>): FunctionFragment;
+    populateTransaction(...args: ContractMethodArgs<A, S>): Promise<ContractTransaction>;
+    staticCall(...args: ContractMethodArgs<A, 'view'>): Promise<DefaultReturnType<R>>;
+    send(...args: ContractMethodArgs<A, S>): Promise<ContractTransactionResponse>;
+    estimateGas(...args: ContractMethodArgs<A, S>): Promise<bigint>;
+    staticCallResult(...args: ContractMethodArgs<A, 'view'>): Promise<R>;
+}
+
+type PermissionStruct$2 = {
+    issuer: AddressLike;
+    expiration: BigNumberish;
+    recipient: AddressLike;
+    validatorId: BigNumberish;
+    validatorContract: AddressLike;
+    sealingKey: BytesLike;
+    issuerSignature: BytesLike;
+    recipientSignature: BytesLike;
+};
+interface MockACLInterface extends Interface {
+    getFunction(nameOrSignature: 'TASK_MANAGER_ADDRESS_' | 'allow' | 'allowForDecryption' | 'allowGlobal' | 'allowTransient' | 'allowedOnBehalf' | 'allowedTransient' | 'checkPermitValidity' | 'cleanTransientStorage' | 'delegateAccount' | 'eip712Domain' | 'exists' | 'getTaskManagerAddress' | 'getVersion' | 'globalAllowed' | 'hashTypedDataV4' | 'isAllowed' | 'isAllowedForDecryption' | 'isAllowedWithPermission' | 'persistAllowed'): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: 'AllowedForDecryption' | 'EIP712DomainChanged' | 'NewDelegation'): EventFragment;
+    encodeFunctionData(functionFragment: 'TASK_MANAGER_ADDRESS_', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'allow', values: [BigNumberish, AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: 'allowForDecryption', values: [BigNumberish[], AddressLike]): string;
+    encodeFunctionData(functionFragment: 'allowGlobal', values: [BigNumberish, AddressLike]): string;
+    encodeFunctionData(functionFragment: 'allowTransient', values: [BigNumberish, AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: 'allowedOnBehalf', values: [AddressLike, BigNumberish, AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: 'allowedTransient', values: [BigNumberish, AddressLike]): string;
+    encodeFunctionData(functionFragment: 'checkPermitValidity', values: [PermissionStruct$2]): string;
+    encodeFunctionData(functionFragment: 'cleanTransientStorage', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'delegateAccount', values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: 'eip712Domain', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'exists', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'getTaskManagerAddress', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'getVersion', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'globalAllowed', values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'hashTypedDataV4', values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: 'isAllowed', values: [BigNumberish, AddressLike]): string;
+    encodeFunctionData(functionFragment: 'isAllowedForDecryption', values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'isAllowedWithPermission', values: [PermissionStruct$2, BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'persistAllowed', values: [BigNumberish, AddressLike]): 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;
+    decodeFunctionResult(functionFragment: 'allowTransient', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'allowedOnBehalf', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'allowedTransient', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'checkPermitValidity', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'cleanTransientStorage', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'delegateAccount', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'eip712Domain', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'exists', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'getTaskManagerAddress', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'getVersion', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'globalAllowed', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'hashTypedDataV4', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'isAllowed', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'isAllowedForDecryption', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'isAllowedWithPermission', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'persistAllowed', data: BytesLike): Result;
+}
+declare namespace AllowedForDecryptionEvent {
+    type InputTuple = [handlesList: BigNumberish[]];
+    type OutputTuple = [handlesList: bigint[]];
+    interface OutputObject {
+        handlesList: bigint[];
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+declare namespace EIP712DomainChangedEvent {
+    type InputTuple = [];
+    type OutputTuple = [];
+    interface OutputObject {
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+declare namespace NewDelegationEvent {
+    type InputTuple = [sender: AddressLike, delegatee: AddressLike, contractAddress: AddressLike];
+    type OutputTuple = [sender: string, delegatee: string, contractAddress: string];
+    interface OutputObject {
+        sender: string;
+        delegatee: string;
+        contractAddress: 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>;
+    interface: MockACLInterface;
+    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>;
+    TASK_MANAGER_ADDRESS_: TypedContractMethod<[], [string], 'view'>;
+    allow: TypedContractMethod<[
+        handle: BigNumberish,
+        account: AddressLike,
+        requester: AddressLike
+    ], [
+        void
+    ], 'nonpayable'>;
+    allowForDecryption: TypedContractMethod<[handlesList: BigNumberish[], requester: AddressLike], [void], 'nonpayable'>;
+    allowGlobal: TypedContractMethod<[handle: BigNumberish, requester: AddressLike], [void], 'nonpayable'>;
+    allowTransient: TypedContractMethod<[
+        handle: BigNumberish,
+        account: AddressLike,
+        requester: AddressLike
+    ], [
+        void
+    ], 'nonpayable'>;
+    allowedOnBehalf: TypedContractMethod<[
+        delegatee: AddressLike,
+        handle: BigNumberish,
+        contractAddress: AddressLike,
+        account: AddressLike
+    ], [
+        boolean
+    ], 'view'>;
+    allowedTransient: TypedContractMethod<[handle: BigNumberish, account: AddressLike], [boolean], 'view'>;
+    checkPermitValidity: TypedContractMethod<[permission: PermissionStruct$2], [boolean], 'view'>;
+    cleanTransientStorage: TypedContractMethod<[], [void], 'nonpayable'>;
+    delegateAccount: TypedContractMethod<[delegatee: AddressLike, delegateeContract: AddressLike], [void], 'nonpayable'>;
+    eip712Domain: TypedContractMethod<[
+    ], [
+        [
+            string,
+            string,
+            string,
+            bigint,
+            string,
+            string,
+            bigint[]
+        ] & {
+            fields: string;
+            name: string;
+            version: string;
+            chainId: bigint;
+            verifyingContract: string;
+            salt: string;
+            extensions: bigint[];
+        }
+    ], 'view'>;
+    exists: TypedContractMethod<[], [boolean], 'view'>;
+    getTaskManagerAddress: TypedContractMethod<[], [string], 'view'>;
+    getVersion: TypedContractMethod<[], [string], 'view'>;
+    globalAllowed: TypedContractMethod<[handle: BigNumberish], [boolean], 'view'>;
+    hashTypedDataV4: TypedContractMethod<[structHash: BytesLike], [string], 'view'>;
+    isAllowed: TypedContractMethod<[handle: BigNumberish, account: AddressLike], [boolean], 'view'>;
+    isAllowedForDecryption: TypedContractMethod<[handle: BigNumberish], [boolean], 'view'>;
+    isAllowedWithPermission: TypedContractMethod<[permission: PermissionStruct$2, handle: BigNumberish], [boolean], 'view'>;
+    persistAllowed: TypedContractMethod<[handle: BigNumberish, account: AddressLike], [boolean], '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'>;
+    getFunction(nameOrSignature: 'allowTransient'): TypedContractMethod<[handle: BigNumberish, account: AddressLike, requester: AddressLike], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'allowedOnBehalf'): TypedContractMethod<[
+        delegatee: AddressLike,
+        handle: BigNumberish,
+        contractAddress: AddressLike,
+        account: AddressLike
+    ], [
+        boolean
+    ], 'view'>;
+    getFunction(nameOrSignature: 'allowedTransient'): TypedContractMethod<[handle: BigNumberish, account: AddressLike], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'checkPermitValidity'): TypedContractMethod<[permission: PermissionStruct$2], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'cleanTransientStorage'): TypedContractMethod<[], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'delegateAccount'): TypedContractMethod<[delegatee: AddressLike, delegateeContract: AddressLike], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'eip712Domain'): TypedContractMethod<[
+    ], [
+        [
+            string,
+            string,
+            string,
+            bigint,
+            string,
+            string,
+            bigint[]
+        ] & {
+            fields: string;
+            name: string;
+            version: string;
+            chainId: bigint;
+            verifyingContract: string;
+            salt: string;
+            extensions: bigint[];
+        }
+    ], 'view'>;
+    getFunction(nameOrSignature: 'exists'): TypedContractMethod<[], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'getTaskManagerAddress'): TypedContractMethod<[], [string], 'view'>;
+    getFunction(nameOrSignature: 'getVersion'): TypedContractMethod<[], [string], 'view'>;
+    getFunction(nameOrSignature: 'globalAllowed'): TypedContractMethod<[handle: BigNumberish], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'hashTypedDataV4'): TypedContractMethod<[structHash: BytesLike], [string], 'view'>;
+    getFunction(nameOrSignature: 'isAllowed'): TypedContractMethod<[handle: BigNumberish, account: AddressLike], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'isAllowedForDecryption'): TypedContractMethod<[handle: BigNumberish], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'isAllowedWithPermission'): TypedContractMethod<[permission: PermissionStruct$2, handle: BigNumberish], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'persistAllowed'): TypedContractMethod<[handle: BigNumberish, account: AddressLike], [boolean], 'view'>;
+    getEvent(key: 'AllowedForDecryption'): TypedContractEvent<AllowedForDecryptionEvent.InputTuple, AllowedForDecryptionEvent.OutputTuple, AllowedForDecryptionEvent.OutputObject>;
+    getEvent(key: 'EIP712DomainChanged'): TypedContractEvent<EIP712DomainChangedEvent.InputTuple, EIP712DomainChangedEvent.OutputTuple, EIP712DomainChangedEvent.OutputObject>;
+    getEvent(key: 'NewDelegation'): TypedContractEvent<NewDelegationEvent.InputTuple, NewDelegationEvent.OutputTuple, NewDelegationEvent.OutputObject>;
+    filters: {
+        'AllowedForDecryption(uint256[])': TypedContractEvent<AllowedForDecryptionEvent.InputTuple, AllowedForDecryptionEvent.OutputTuple, AllowedForDecryptionEvent.OutputObject>;
+        AllowedForDecryption: TypedContractEvent<AllowedForDecryptionEvent.InputTuple, AllowedForDecryptionEvent.OutputTuple, AllowedForDecryptionEvent.OutputObject>;
+        'EIP712DomainChanged()': TypedContractEvent<EIP712DomainChangedEvent.InputTuple, EIP712DomainChangedEvent.OutputTuple, EIP712DomainChangedEvent.OutputObject>;
+        EIP712DomainChanged: TypedContractEvent<EIP712DomainChangedEvent.InputTuple, EIP712DomainChangedEvent.OutputTuple, EIP712DomainChangedEvent.OutputObject>;
+        'NewDelegation(address,address,address)': TypedContractEvent<NewDelegationEvent.InputTuple, NewDelegationEvent.OutputTuple, NewDelegationEvent.OutputObject>;
+        NewDelegation: TypedContractEvent<NewDelegationEvent.InputTuple, NewDelegationEvent.OutputTuple, NewDelegationEvent.OutputObject>;
+    };
+}
+
+type PermissionStruct$1 = {
+    issuer: AddressLike;
+    expiration: BigNumberish;
+    recipient: AddressLike;
+    validatorId: BigNumberish;
+    validatorContract: AddressLike;
+    sealingKey: BytesLike;
+    issuerSignature: BytesLike;
+    recipientSignature: BytesLike;
+};
+type EncryptedInputStruct = {
+    ctHash: BigNumberish;
+    securityZone: BigNumberish;
+    utype: BigNumberish;
+    signature: BytesLike;
+};
+interface MockTaskManagerInterface extends Interface {
+    getFunction(nameOrSignature: 'MOCK_logAllow' | 'MOCK_setInEuintKey' | 'acl' | 'aggregator' | 'allow' | 'allowForDecryption' | 'allowGlobal' | 'allowTransient' | 'createDecryptTask' | 'createRandomTask' | 'createTask' | 'decryptResultSigner' | 'exists' | 'getDecryptResult' | 'getDecryptResultSafe' | 'handleDecryptResult' | 'handleError' | 'inMockStorage' | 'initialize' | 'isAllowed' | 'isAllowedWithPermission' | 'isInitialized' | 'isPubliclyAllowed' | 'logOps' | 'mockStorage' | 'publishDecryptResult' | 'publishDecryptResultBatch' | 'removeFirstLetter' | 'setACLContract' | 'setAggregator' | 'setDecryptResultSigner' | 'setLogOps' | 'setSecurityZoneMax' | 'setSecurityZoneMin' | 'setSecurityZones' | 'setVerifierSigner' | 'sliceString' | 'verifyDecryptResult' | 'verifyDecryptResultSafe' | 'verifyInput'): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: 'DecryptionResult' | 'ProtocolNotification' | 'TaskCreated'): EventFragment;
+    encodeFunctionData(functionFragment: 'MOCK_logAllow', values: [string, BigNumberish, AddressLike]): string;
+    encodeFunctionData(functionFragment: 'MOCK_setInEuintKey', values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'acl', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'aggregator', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'allow', values: [BigNumberish, AddressLike]): string;
+    encodeFunctionData(functionFragment: 'allowForDecryption', values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'allowGlobal', values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'allowTransient', values: [BigNumberish, AddressLike]): string;
+    encodeFunctionData(functionFragment: 'createDecryptTask', values: [BigNumberish, AddressLike]): string;
+    encodeFunctionData(functionFragment: 'createRandomTask', values: [BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'createTask', values: [BigNumberish, BigNumberish, BigNumberish[], BigNumberish[]]): string;
+    encodeFunctionData(functionFragment: 'decryptResultSigner', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'exists', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'getDecryptResult', values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'getDecryptResultSafe', values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'handleDecryptResult', values: [BigNumberish, BigNumberish, AddressLike[]]): string;
+    encodeFunctionData(functionFragment: 'handleError', values: [BigNumberish, string, string]): string;
+    encodeFunctionData(functionFragment: 'inMockStorage', values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'initialize', values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: 'isAllowed', values: [BigNumberish, AddressLike]): string;
+    encodeFunctionData(functionFragment: 'isAllowedWithPermission', values: [PermissionStruct$1, BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'isInitialized', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'isPubliclyAllowed', values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'logOps', 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;
+    encodeFunctionData(functionFragment: 'removeFirstLetter', values: [string]): string;
+    encodeFunctionData(functionFragment: 'setACLContract', values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: 'setAggregator', values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: 'setDecryptResultSigner', values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: 'setLogOps', values: [boolean]): string;
+    encodeFunctionData(functionFragment: 'setSecurityZoneMax', values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'setSecurityZoneMin', values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'setSecurityZones', values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'setVerifierSigner', values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: 'sliceString', values: [string, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'verifyDecryptResult', values: [BigNumberish, BigNumberish, BytesLike]): string;
+    encodeFunctionData(functionFragment: 'verifyDecryptResultSafe', values: [BigNumberish, BigNumberish, BytesLike]): string;
+    encodeFunctionData(functionFragment: 'verifyInput', values: [EncryptedInputStruct, AddressLike]): string;
+    decodeFunctionResult(functionFragment: 'MOCK_logAllow', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'MOCK_setInEuintKey', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'acl', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'aggregator', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'allow', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'allowForDecryption', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'allowGlobal', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'allowTransient', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'createDecryptTask', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'createRandomTask', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'createTask', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'decryptResultSigner', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'exists', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'getDecryptResult', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'getDecryptResultSafe', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'handleDecryptResult', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'handleError', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'inMockStorage', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'initialize', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'isAllowed', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'isAllowedWithPermission', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'isInitialized', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'isPubliclyAllowed', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'logOps', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'mockStorage', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'publishDecryptResult', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'publishDecryptResultBatch', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'removeFirstLetter', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'setACLContract', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'setAggregator', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'setDecryptResultSigner', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'setLogOps', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'setSecurityZoneMax', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'setSecurityZoneMin', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'setSecurityZones', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'setVerifierSigner', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'sliceString', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'verifyDecryptResult', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'verifyDecryptResultSafe', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'verifyInput', data: BytesLike): Result;
+}
+declare namespace DecryptionResultEvent {
+    type InputTuple = [ctHash: BigNumberish, result: BigNumberish, requestor: AddressLike];
+    type OutputTuple = [ctHash: bigint, result: bigint, requestor: string];
+    interface OutputObject {
+        ctHash: bigint;
+        result: bigint;
+        requestor: string;
+    }
+    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];
+    interface OutputObject {
+        ctHash: bigint;
+        operation: string;
+        errorMessage: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+declare namespace TaskCreatedEvent {
+    type InputTuple = [
+        ctHash: BigNumberish,
+        operation: string,
+        input1: BigNumberish,
+        input2: BigNumberish,
+        input3: BigNumberish
+    ];
+    type OutputTuple = [ctHash: bigint, operation: string, input1: bigint, input2: bigint, input3: bigint];
+    interface OutputObject {
+        ctHash: bigint;
+        operation: string;
+        input1: bigint;
+        input2: bigint;
+        input3: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+interface MockTaskManager extends BaseContract {
+    connect(runner?: ContractRunner | null): MockTaskManager;
+    waitForDeployment(): Promise<this>;
+    interface: MockTaskManagerInterface;
+    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>;
+    MOCK_logAllow: TypedContractMethod<[operation: string, ctHash: BigNumberish, account: AddressLike], [void], 'view'>;
+    MOCK_setInEuintKey: TypedContractMethod<[ctHash: BigNumberish, value: BigNumberish], [void], 'nonpayable'>;
+    acl: TypedContractMethod<[], [string], 'view'>;
+    aggregator: TypedContractMethod<[], [string], 'view'>;
+    allow: TypedContractMethod<[ctHash: BigNumberish, account: AddressLike], [void], 'nonpayable'>;
+    allowForDecryption: TypedContractMethod<[ctHash: BigNumberish], [void], 'nonpayable'>;
+    allowGlobal: TypedContractMethod<[ctHash: BigNumberish], [void], 'nonpayable'>;
+    allowTransient: TypedContractMethod<[ctHash: BigNumberish, account: AddressLike], [void], 'nonpayable'>;
+    createDecryptTask: TypedContractMethod<[ctHash: BigNumberish, arg1: AddressLike], [void], 'nonpayable'>;
+    createRandomTask: TypedContractMethod<[
+        returnType: BigNumberish,
+        seed: BigNumberish,
+        securityZone: BigNumberish
+    ], [
+        bigint
+    ], 'nonpayable'>;
+    createTask: TypedContractMethod<[
+        returnType: BigNumberish,
+        funcId: BigNumberish,
+        encryptedHashes: BigNumberish[],
+        extraInputs: BigNumberish[]
+    ], [
+        bigint
+    ], 'nonpayable'>;
+    decryptResultSigner: TypedContractMethod<[], [string], 'view'>;
+    exists: TypedContractMethod<[], [boolean], 'view'>;
+    getDecryptResult: TypedContractMethod<[ctHash: BigNumberish], [bigint], 'view'>;
+    getDecryptResultSafe: TypedContractMethod<[
+        ctHash: BigNumberish
+    ], [
+        [bigint, boolean] & {
+            result: bigint;
+            decrypted: boolean;
+        }
+    ], 'view'>;
+    handleDecryptResult: TypedContractMethod<[
+        ctHash: BigNumberish,
+        result: BigNumberish,
+        arg2: AddressLike[]
+    ], [
+        void
+    ], 'nonpayable'>;
+    handleError: TypedContractMethod<[
+        ctHash: BigNumberish,
+        operation: string,
+        errorMessage: string
+    ], [
+        void
+    ], 'nonpayable'>;
+    inMockStorage: TypedContractMethod<[arg0: BigNumberish], [boolean], 'view'>;
+    initialize: TypedContractMethod<[initialOwner: AddressLike], [void], 'nonpayable'>;
+    isAllowed: TypedContractMethod<[ctHash: BigNumberish, account: AddressLike], [boolean], 'view'>;
+    isAllowedWithPermission: TypedContractMethod<[permission: PermissionStruct$1, handle: BigNumberish], [boolean], 'view'>;
+    isInitialized: TypedContractMethod<[], [boolean], 'view'>;
+    isPubliclyAllowed: TypedContractMethod<[ctHash: BigNumberish], [boolean], 'view'>;
+    logOps: TypedContractMethod<[], [boolean], 'view'>;
+    mockStorage: TypedContractMethod<[arg0: BigNumberish], [bigint], 'view'>;
+    publishDecryptResult: TypedContractMethod<[
+        ctHash: BigNumberish,
+        result: BigNumberish,
+        signature: BytesLike
+    ], [
+        void
+    ], 'nonpayable'>;
+    publishDecryptResultBatch: TypedContractMethod<[
+        ctHashes: BigNumberish[],
+        results: BigNumberish[],
+        signatures: BytesLike[]
+    ], [
+        void
+    ], 'nonpayable'>;
+    removeFirstLetter: TypedContractMethod<[str: string], [string], 'view'>;
+    setACLContract: TypedContractMethod<[_aclAddress: AddressLike], [void], 'nonpayable'>;
+    setAggregator: TypedContractMethod<[_aggregatorAddress: AddressLike], [void], 'nonpayable'>;
+    setDecryptResultSigner: TypedContractMethod<[signer: AddressLike], [void], 'nonpayable'>;
+    setLogOps: TypedContractMethod<[_logOps: boolean], [void], 'nonpayable'>;
+    setSecurityZoneMax: TypedContractMethod<[securityZone: BigNumberish], [void], 'nonpayable'>;
+    setSecurityZoneMin: TypedContractMethod<[securityZone: BigNumberish], [void], 'nonpayable'>;
+    setSecurityZones: TypedContractMethod<[minSZ: BigNumberish, maxSZ: BigNumberish], [void], 'nonpayable'>;
+    setVerifierSigner: TypedContractMethod<[signer: AddressLike], [void], 'nonpayable'>;
+    sliceString: TypedContractMethod<[str: string, start: BigNumberish, length: BigNumberish], [string], 'view'>;
+    verifyDecryptResult: TypedContractMethod<[
+        ctHash: BigNumberish,
+        result: BigNumberish,
+        signature: BytesLike
+    ], [
+        boolean
+    ], 'view'>;
+    verifyDecryptResultSafe: TypedContractMethod<[
+        ctHash: BigNumberish,
+        result: BigNumberish,
+        signature: BytesLike
+    ], [
+        boolean
+    ], 'view'>;
+    verifyInput: TypedContractMethod<[input: EncryptedInputStruct, sender: AddressLike], [bigint], 'nonpayable'>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    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'>;
+    getFunction(nameOrSignature: 'aggregator'): TypedContractMethod<[], [string], 'view'>;
+    getFunction(nameOrSignature: 'allow'): TypedContractMethod<[ctHash: BigNumberish, account: AddressLike], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'allowForDecryption'): TypedContractMethod<[ctHash: BigNumberish], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'allowGlobal'): TypedContractMethod<[ctHash: BigNumberish], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'allowTransient'): TypedContractMethod<[ctHash: BigNumberish, account: AddressLike], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'createDecryptTask'): TypedContractMethod<[ctHash: BigNumberish, arg1: AddressLike], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'createRandomTask'): TypedContractMethod<[
+        returnType: BigNumberish,
+        seed: BigNumberish,
+        securityZone: BigNumberish
+    ], [
+        bigint
+    ], 'nonpayable'>;
+    getFunction(nameOrSignature: 'createTask'): TypedContractMethod<[
+        returnType: BigNumberish,
+        funcId: BigNumberish,
+        encryptedHashes: BigNumberish[],
+        extraInputs: BigNumberish[]
+    ], [
+        bigint
+    ], 'nonpayable'>;
+    getFunction(nameOrSignature: 'decryptResultSigner'): TypedContractMethod<[], [string], 'view'>;
+    getFunction(nameOrSignature: 'exists'): TypedContractMethod<[], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'getDecryptResult'): TypedContractMethod<[ctHash: BigNumberish], [bigint], 'view'>;
+    getFunction(nameOrSignature: 'getDecryptResultSafe'): TypedContractMethod<[ctHash: BigNumberish], [[bigint, boolean] & {
+        result: bigint;
+        decrypted: boolean;
+    }], 'view'>;
+    getFunction(nameOrSignature: 'handleDecryptResult'): TypedContractMethod<[ctHash: BigNumberish, result: BigNumberish, arg2: AddressLike[]], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'handleError'): TypedContractMethod<[ctHash: BigNumberish, operation: string, errorMessage: string], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'inMockStorage'): TypedContractMethod<[arg0: BigNumberish], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'initialize'): TypedContractMethod<[initialOwner: AddressLike], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'isAllowed'): TypedContractMethod<[ctHash: BigNumberish, account: AddressLike], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'isAllowedWithPermission'): TypedContractMethod<[permission: PermissionStruct$1, handle: BigNumberish], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'isInitialized'): TypedContractMethod<[], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'isPubliclyAllowed'): TypedContractMethod<[ctHash: BigNumberish], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'logOps'): 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<[
+        ctHashes: BigNumberish[],
+        results: BigNumberish[],
+        signatures: BytesLike[]
+    ], [
+        void
+    ], 'nonpayable'>;
+    getFunction(nameOrSignature: 'removeFirstLetter'): TypedContractMethod<[str: string], [string], 'view'>;
+    getFunction(nameOrSignature: 'setACLContract'): TypedContractMethod<[_aclAddress: AddressLike], [void], 'nonpayable'>;
+    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: 'setSecurityZoneMax'): TypedContractMethod<[securityZone: BigNumberish], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'setSecurityZoneMin'): TypedContractMethod<[securityZone: BigNumberish], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'setSecurityZones'): TypedContractMethod<[minSZ: BigNumberish, maxSZ: BigNumberish], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'setVerifierSigner'): TypedContractMethod<[signer: AddressLike], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'sliceString'): TypedContractMethod<[str: string, start: BigNumberish, length: BigNumberish], [string], 'view'>;
+    getFunction(nameOrSignature: 'verifyDecryptResult'): TypedContractMethod<[ctHash: BigNumberish, result: BigNumberish, signature: BytesLike], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'verifyDecryptResultSafe'): TypedContractMethod<[ctHash: BigNumberish, result: BigNumberish, signature: BytesLike], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'verifyInput'): TypedContractMethod<[input: EncryptedInputStruct, sender: AddressLike], [bigint], 'nonpayable'>;
+    getEvent(key: 'DecryptionResult'): TypedContractEvent<DecryptionResultEvent.InputTuple, DecryptionResultEvent.OutputTuple, DecryptionResultEvent.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>;
+        '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>;
+        TaskCreated: TypedContractEvent<TaskCreatedEvent.InputTuple, TaskCreatedEvent.OutputTuple, TaskCreatedEvent.OutputObject>;
+    };
+}
+
+type PermissionStruct = {
+    issuer: AddressLike;
+    expiration: BigNumberish;
+    recipient: AddressLike;
+    validatorId: BigNumberish;
+    validatorContract: AddressLike;
+    sealingKey: BytesLike;
+    issuerSignature: BytesLike;
+    recipientSignature: BytesLike;
+};
+interface MockThresholdNetworkInterface extends Interface {
+    getFunction(nameOrSignature: 'decodeLowLevelReversion' | 'decryptForTxWithPermit' | 'decryptForTxWithoutPermit' | 'exists' | 'initialize' | 'mockAcl' | 'mockQueryDecrypt' | 'mockTaskManager' | 'queryDecrypt' | 'querySealOutput' | 'seal' | 'unseal'): FunctionFragment;
+    encodeFunctionData(functionFragment: 'decodeLowLevelReversion', values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: 'decryptForTxWithPermit', values: [BigNumberish, PermissionStruct]): string;
+    encodeFunctionData(functionFragment: 'decryptForTxWithoutPermit', values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'exists', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'initialize', values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: 'mockAcl', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'mockQueryDecrypt', values: [BigNumberish, BigNumberish, AddressLike]): string;
+    encodeFunctionData(functionFragment: 'mockTaskManager', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'queryDecrypt', values: [BigNumberish, BigNumberish, PermissionStruct]): string;
+    encodeFunctionData(functionFragment: 'querySealOutput', values: [BigNumberish, BigNumberish, PermissionStruct]): string;
+    encodeFunctionData(functionFragment: 'seal', values: [BigNumberish, BytesLike]): string;
+    encodeFunctionData(functionFragment: 'unseal', values: [BytesLike, BytesLike]): string;
+    decodeFunctionResult(functionFragment: 'decodeLowLevelReversion', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'decryptForTxWithPermit', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'decryptForTxWithoutPermit', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'exists', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'initialize', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'mockAcl', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'mockQueryDecrypt', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'mockTaskManager', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'queryDecrypt', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'querySealOutput', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'seal', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'unseal', data: BytesLike): Result;
+}
+interface MockThresholdNetwork extends BaseContract {
+    connect(runner?: ContractRunner | null): MockThresholdNetwork;
+    waitForDeployment(): Promise<this>;
+    interface: MockThresholdNetworkInterface;
+    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>;
+    decodeLowLevelReversion: TypedContractMethod<[data: BytesLike], [string], 'view'>;
+    decryptForTxWithPermit: TypedContractMethod<[
+        ctHash: BigNumberish,
+        permission: PermissionStruct
+    ], [
+        [
+            boolean,
+            string,
+            bigint
+        ] & {
+            allowed: boolean;
+            error: string;
+            decryptedValue: bigint;
+        }
+    ], 'view'>;
+    decryptForTxWithoutPermit: TypedContractMethod<[
+        ctHash: BigNumberish
+    ], [
+        [
+            boolean,
+            string,
+            bigint
+        ] & {
+            allowed: boolean;
+            error: string;
+            decryptedValue: bigint;
+        }
+    ], 'view'>;
+    exists: TypedContractMethod<[], [boolean], 'view'>;
+    initialize: TypedContractMethod<[_taskManager: AddressLike, _acl: AddressLike], [void], 'nonpayable'>;
+    mockAcl: TypedContractMethod<[], [string], 'view'>;
+    mockQueryDecrypt: TypedContractMethod<[
+        ctHash: BigNumberish,
+        arg1: BigNumberish,
+        issuer: AddressLike
+    ], [
+        [boolean, string, bigint] & {
+            allowed: boolean;
+            error: string;
+        }
+    ], 'view'>;
+    mockTaskManager: TypedContractMethod<[], [string], 'view'>;
+    queryDecrypt: TypedContractMethod<[
+        ctHash: BigNumberish,
+        arg1: BigNumberish,
+        permission: PermissionStruct
+    ], [
+        [boolean, string, bigint] & {
+            allowed: boolean;
+            error: string;
+        }
+    ], 'view'>;
+    querySealOutput: TypedContractMethod<[
+        ctHash: BigNumberish,
+        arg1: BigNumberish,
+        permission: PermissionStruct
+    ], [
+        [boolean, string, string] & {
+            allowed: boolean;
+            error: string;
+        }
+    ], 'view'>;
+    seal: TypedContractMethod<[input: BigNumberish, key: BytesLike], [string], 'view'>;
+    unseal: TypedContractMethod<[hashed: BytesLike, key: BytesLike], [bigint], 'view'>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: 'decodeLowLevelReversion'): TypedContractMethod<[data: BytesLike], [string], 'view'>;
+    getFunction(nameOrSignature: 'decryptForTxWithPermit'): TypedContractMethod<[
+        ctHash: BigNumberish,
+        permission: PermissionStruct
+    ], [
+        [
+            boolean,
+            string,
+            bigint
+        ] & {
+            allowed: boolean;
+            error: string;
+            decryptedValue: bigint;
+        }
+    ], 'view'>;
+    getFunction(nameOrSignature: 'decryptForTxWithoutPermit'): TypedContractMethod<[
+        ctHash: BigNumberish
+    ], [
+        [
+            boolean,
+            string,
+            bigint
+        ] & {
+            allowed: boolean;
+            error: string;
+            decryptedValue: bigint;
+        }
+    ], 'view'>;
+    getFunction(nameOrSignature: 'exists'): TypedContractMethod<[], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'initialize'): TypedContractMethod<[_taskManager: AddressLike, _acl: AddressLike], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'mockAcl'): TypedContractMethod<[], [string], 'view'>;
+    getFunction(nameOrSignature: 'mockQueryDecrypt'): TypedContractMethod<[
+        ctHash: BigNumberish,
+        arg1: BigNumberish,
+        issuer: AddressLike
+    ], [
+        [boolean, string, bigint] & {
+            allowed: boolean;
+            error: string;
+        }
+    ], 'view'>;
+    getFunction(nameOrSignature: 'mockTaskManager'): TypedContractMethod<[], [string], 'view'>;
+    getFunction(nameOrSignature: 'queryDecrypt'): TypedContractMethod<[
+        ctHash: BigNumberish,
+        arg1: BigNumberish,
+        permission: PermissionStruct
+    ], [
+        [boolean, string, bigint] & {
+            allowed: boolean;
+            error: string;
+        }
+    ], 'view'>;
+    getFunction(nameOrSignature: 'querySealOutput'): TypedContractMethod<[
+        ctHash: BigNumberish,
+        arg1: BigNumberish,
+        permission: PermissionStruct
+    ], [
+        [boolean, string, string] & {
+            allowed: boolean;
+            error: string;
+        }
+    ], 'view'>;
+    getFunction(nameOrSignature: 'seal'): TypedContractMethod<[input: BigNumberish, key: BytesLike], [string], 'view'>;
+    getFunction(nameOrSignature: 'unseal'): TypedContractMethod<[hashed: BytesLike, key: BytesLike], [bigint], 'view'>;
+    filters: {};
+}
+
+type EncryptedInputStructOutput = [ctHash: bigint, securityZone: bigint, utype: bigint, signature: string] & {
+    ctHash: bigint;
+    securityZone: bigint;
+    utype: bigint;
+    signature: string;
+};
+interface MockZkVerifierInterface extends Interface {
+    getFunction(nameOrSignature: 'exists' | 'insertCtHash' | 'insertPackedCtHashes' | 'zkVerify' | 'zkVerifyCalcCtHash' | 'zkVerifyCalcCtHashesPacked' | 'zkVerifyPacked'): FunctionFragment;
+    encodeFunctionData(functionFragment: 'exists', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'insertCtHash', values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'insertPackedCtHashes', values: [BigNumberish[], BigNumberish[]]): string;
+    encodeFunctionData(functionFragment: 'zkVerify', values: [BigNumberish, BigNumberish, AddressLike, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'zkVerifyCalcCtHash', values: [BigNumberish, BigNumberish, AddressLike, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'zkVerifyCalcCtHashesPacked', values: [BigNumberish[], BigNumberish[], AddressLike, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'zkVerifyPacked', values: [BigNumberish[], BigNumberish[], AddressLike, BigNumberish, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: 'exists', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'insertCtHash', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'insertPackedCtHashes', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'zkVerify', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'zkVerifyCalcCtHash', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'zkVerifyCalcCtHashesPacked', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'zkVerifyPacked', data: BytesLike): Result;
+}
+interface MockZkVerifier extends BaseContract {
+    connect(runner?: ContractRunner | null): MockZkVerifier;
+    waitForDeployment(): Promise<this>;
+    interface: MockZkVerifierInterface;
+    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'>;
+    insertCtHash: TypedContractMethod<[ctHash: BigNumberish, value: BigNumberish], [void], 'nonpayable'>;
+    insertPackedCtHashes: TypedContractMethod<[ctHashes: BigNumberish[], values: BigNumberish[]], [void], 'nonpayable'>;
+    zkVerify: TypedContractMethod<[
+        value: BigNumberish,
+        utype: BigNumberish,
+        user: AddressLike,
+        securityZone: BigNumberish,
+        arg4: BigNumberish
+    ], [
+        EncryptedInputStructOutput
+    ], 'nonpayable'>;
+    zkVerifyCalcCtHash: TypedContractMethod<[
+        value: BigNumberish,
+        utype: BigNumberish,
+        user: AddressLike,
+        securityZone: BigNumberish,
+        arg4: BigNumberish
+    ], [
+        bigint
+    ], 'view'>;
+    zkVerifyCalcCtHashesPacked: TypedContractMethod<[
+        values: BigNumberish[],
+        utypes: BigNumberish[],
+        user: AddressLike,
+        securityZone: BigNumberish,
+        chainId: BigNumberish
+    ], [
+        bigint[]
+    ], 'view'>;
+    zkVerifyPacked: TypedContractMethod<[
+        values: BigNumberish[],
+        utypes: BigNumberish[],
+        user: AddressLike,
+        securityZone: BigNumberish,
+        chainId: BigNumberish
+    ], [
+        EncryptedInputStructOutput[]
+    ], 'nonpayable'>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: 'exists'): TypedContractMethod<[], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'insertCtHash'): TypedContractMethod<[ctHash: BigNumberish, value: BigNumberish], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'insertPackedCtHashes'): TypedContractMethod<[ctHashes: BigNumberish[], values: BigNumberish[]], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'zkVerify'): TypedContractMethod<[
+        value: BigNumberish,
+        utype: BigNumberish,
+        user: AddressLike,
+        securityZone: BigNumberish,
+        arg4: BigNumberish
+    ], [
+        EncryptedInputStructOutput
+    ], 'nonpayable'>;
+    getFunction(nameOrSignature: 'zkVerifyCalcCtHash'): TypedContractMethod<[
+        value: BigNumberish,
+        utype: BigNumberish,
+        user: AddressLike,
+        securityZone: BigNumberish,
+        arg4: BigNumberish
+    ], [
+        bigint
+    ], 'view'>;
+    getFunction(nameOrSignature: 'zkVerifyCalcCtHashesPacked'): TypedContractMethod<[
+        values: BigNumberish[],
+        utypes: BigNumberish[],
+        user: AddressLike,
+        securityZone: BigNumberish,
+        chainId: BigNumberish
+    ], [
+        bigint[]
+    ], 'view'>;
+    getFunction(nameOrSignature: 'zkVerifyPacked'): TypedContractMethod<[
+        values: BigNumberish[],
+        utypes: BigNumberish[],
+        user: AddressLike,
+        securityZone: BigNumberish,
+        chainId: BigNumberish
+    ], [
+        EncryptedInputStructOutput[]
+    ], 'nonpayable'>;
+    filters: {};
+}
+
+type InEuint32Struct = {
+    ctHash: BigNumberish;
+    securityZone: BigNumberish;
+    utype: BigNumberish;
+    signature: BytesLike;
+};
+interface TestBedInterface extends Interface {
+    getFunction(nameOrSignature: 'add' | 'decrypt' | 'eNumber' | 'exists' | 'getDecryptResult' | 'getDecryptResultSafe' | 'increment' | 'mul' | 'numberHash' | 'publishDecryptResult' | 'setNumber' | 'setNumberTrivial' | 'sub'): FunctionFragment;
+    encodeFunctionData(functionFragment: 'add', values: [InEuint32Struct]): string;
+    encodeFunctionData(functionFragment: 'decrypt', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'eNumber', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'exists', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'getDecryptResult', values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: 'getDecryptResultSafe', values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: 'increment', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'mul', values: [InEuint32Struct]): string;
+    encodeFunctionData(functionFragment: 'numberHash', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'publishDecryptResult', values: [BytesLike, BigNumberish, BytesLike]): string;
+    encodeFunctionData(functionFragment: 'setNumber', values: [InEuint32Struct]): string;
+    encodeFunctionData(functionFragment: 'setNumberTrivial', values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'sub', values: [InEuint32Struct]): string;
+    decodeFunctionResult(functionFragment: 'add', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'decrypt', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'eNumber', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'exists', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'getDecryptResult', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'getDecryptResultSafe', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'increment', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'mul', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'numberHash', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'publishDecryptResult', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'setNumber', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'setNumberTrivial', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'sub', data: BytesLike): Result;
+}
+interface TestBed extends BaseContract {
+    connect(runner?: ContractRunner | null): TestBed;
+    waitForDeployment(): Promise<this>;
+    interface: TestBedInterface;
+    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>;
+    add: TypedContractMethod<[inNumber: InEuint32Struct], [void], 'nonpayable'>;
+    decrypt: TypedContractMethod<[], [void], 'nonpayable'>;
+    eNumber: TypedContractMethod<[], [string], 'view'>;
+    exists: TypedContractMethod<[], [boolean], 'view'>;
+    getDecryptResult: TypedContractMethod<[input1: BytesLike], [bigint], 'view'>;
+    getDecryptResultSafe: TypedContractMethod<[
+        input1: BytesLike
+    ], [
+        [bigint, boolean] & {
+            value: bigint;
+            decrypted: boolean;
+        }
+    ], 'view'>;
+    increment: TypedContractMethod<[], [void], 'nonpayable'>;
+    mul: TypedContractMethod<[inNumber: InEuint32Struct], [void], 'nonpayable'>;
+    numberHash: TypedContractMethod<[], [string], 'view'>;
+    publishDecryptResult: TypedContractMethod<[
+        input: BytesLike,
+        result: BigNumberish,
+        signature: BytesLike
+    ], [
+        void
+    ], 'nonpayable'>;
+    setNumber: TypedContractMethod<[inNumber: InEuint32Struct], [void], 'nonpayable'>;
+    setNumberTrivial: TypedContractMethod<[inNumber: BigNumberish], [void], 'nonpayable'>;
+    sub: TypedContractMethod<[inNumber: InEuint32Struct], [void], 'nonpayable'>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: 'add'): TypedContractMethod<[inNumber: InEuint32Struct], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'decrypt'): TypedContractMethod<[], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'eNumber'): TypedContractMethod<[], [string], 'view'>;
+    getFunction(nameOrSignature: 'exists'): TypedContractMethod<[], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'getDecryptResult'): TypedContractMethod<[input1: BytesLike], [bigint], 'view'>;
+    getFunction(nameOrSignature: 'getDecryptResultSafe'): TypedContractMethod<[input1: BytesLike], [[bigint, boolean] & {
+        value: bigint;
+        decrypted: boolean;
+    }], 'view'>;
+    getFunction(nameOrSignature: 'increment'): TypedContractMethod<[], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'mul'): TypedContractMethod<[inNumber: InEuint32Struct], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'numberHash'): TypedContractMethod<[], [string], 'view'>;
+    getFunction(nameOrSignature: 'publishDecryptResult'): TypedContractMethod<[input: BytesLike, result: BigNumberish, signature: BytesLike], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'setNumber'): TypedContractMethod<[inNumber: InEuint32Struct], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'setNumberTrivial'): TypedContractMethod<[inNumber: BigNumberish], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'sub'): TypedContractMethod<[inNumber: InEuint32Struct], [void], 'nonpayable'>;
+    filters: {};
+}
+
+export { type MockACL, MockACLArtifact, type MockArtifact, type MockTaskManager, MockTaskManagerArtifact, type MockThresholdNetwork, MockThresholdNetworkArtifact, type MockZkVerifier, MockZkVerifierArtifact, type TestBed, TestBedArtifact };