@cofhe/mock-contracts 0.6.0 → 0.7.0

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { DeferredTopicFilter, EventFragment, EventLog, TransactionRequest, Typed, ContractTransactionResponse, FunctionFragment, ContractTransaction, LogDescription, BaseContract, ContractRunner, Interface, BigNumberish, AddressLike, BytesLike, Result, Listener, ContractMethod } from 'ethers';
+import { DeferredTopicFilter, EventFragment, EventLog, TransactionRequest, Typed, ContractTransactionResponse, FunctionFragment, ContractTransaction, LogDescription, BaseContract, ContractRunner, Interface, BytesLike, AddressLike, BigNumberish, Result, Listener, ContractMethod } from 'ethers';
 
 type MockArtifact = {
     contractName: string;
@@ -118,6 +118,41 @@ declare const MockTaskManagerArtifact: {
         }];
         readonly outputs: readonly [];
         readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly name: "batchVerifyInputs";
+        readonly inputs: readonly [{
+            readonly name: "inputs";
+            readonly type: "tuple[]";
+            readonly internalType: "struct UnsignedEncryptedInput[]";
+            readonly components: readonly [{
+                readonly name: "ctHash";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }, {
+                readonly name: "securityZone";
+                readonly type: "uint8";
+                readonly internalType: "uint8";
+            }, {
+                readonly name: "utype";
+                readonly type: "uint8";
+                readonly internalType: "uint8";
+            }];
+        }, {
+            readonly name: "sender";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "signature";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }];
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly type: "uint256[]";
+            readonly internalType: "uint256[]";
+        }];
+        readonly stateMutability: "nonpayable";
     }, {
         readonly type: "function";
         readonly name: "createDecryptTask";
@@ -314,9 +349,9 @@ declare const MockTaskManagerArtifact: {
         readonly type: "function";
         readonly name: "isAllowedWithPermission";
         readonly inputs: readonly [{
-            readonly name: "permission";
+            readonly name: "acp";
             readonly type: "tuple";
-            readonly internalType: "struct Permission";
+            readonly internalType: "struct ACP";
             readonly components: readonly [{
                 readonly name: "issuer";
                 readonly type: "address";
@@ -330,13 +365,25 @@ declare const MockTaskManagerArtifact: {
                 readonly type: "address";
                 readonly internalType: "address";
             }, {
-                readonly name: "validatorId";
+                readonly name: "revokerData";
                 readonly type: "uint256";
                 readonly internalType: "uint256";
             }, {
-                readonly name: "validatorContract";
+                readonly name: "revokerContract";
                 readonly type: "address";
                 readonly internalType: "address";
+            }, {
+                readonly name: "scope";
+                readonly type: "uint8";
+                readonly internalType: "uint8";
+            }, {
+                readonly name: "contracts";
+                readonly type: "address[]";
+                readonly internalType: "address[]";
+            }, {
+                readonly name: "handles";
+                readonly type: "bytes32[]";
+                readonly internalType: "bytes32[]";
             }, {
                 readonly name: "sealingKey";
                 readonly type: "bytes32";
@@ -445,6 +492,20 @@ declare const MockTaskManagerArtifact: {
         }];
         readonly outputs: readonly [];
         readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly name: "receiveCtHash";
+        readonly inputs: readonly [{
+            readonly name: "ctHash";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "expectedSharer";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
     }, {
         readonly type: "function";
         readonly name: "removeFirstLetter";
@@ -543,6 +604,20 @@ declare const MockTaskManagerArtifact: {
         }];
         readonly outputs: readonly [];
         readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly name: "shareCtHash";
+        readonly inputs: readonly [{
+            readonly name: "ctHash";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "receiver";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
     }, {
         readonly type: "function";
         readonly name: "sliceString";
@@ -653,41 +728,6 @@ declare const MockTaskManagerArtifact: {
             readonly internalType: "bool";
         }];
         readonly stateMutability: "view";
-    }, {
-        readonly type: "function";
-        readonly name: "verifyInput";
-        readonly inputs: readonly [{
-            readonly name: "input";
-            readonly type: "tuple";
-            readonly internalType: "struct EncryptedInput";
-            readonly components: readonly [{
-                readonly name: "ctHash";
-                readonly type: "uint256";
-                readonly internalType: "uint256";
-            }, {
-                readonly name: "securityZone";
-                readonly type: "uint8";
-                readonly internalType: "uint8";
-            }, {
-                readonly name: "utype";
-                readonly type: "uint8";
-                readonly internalType: "uint8";
-            }, {
-                readonly name: "signature";
-                readonly type: "bytes";
-                readonly internalType: "bytes";
-            }];
-        }, {
-            readonly name: "sender";
-            readonly type: "address";
-            readonly internalType: "address";
-        }];
-        readonly outputs: readonly [{
-            readonly name: "";
-            readonly type: "uint256";
-            readonly internalType: "uint256";
-        }];
-        readonly stateMutability: "nonpayable";
     }, {
         readonly type: "event";
         readonly name: "DecryptionResult";
@@ -1104,11 +1144,11 @@ declare const MockACLArtifact: {
         readonly stateMutability: "view";
     }, {
         readonly type: "function";
-        readonly name: "checkPermitValidity";
+        readonly name: "checkPermissionValidity";
         readonly inputs: readonly [{
-            readonly name: "permission";
+            readonly name: "acp";
             readonly type: "tuple";
-            readonly internalType: "struct Permission";
+            readonly internalType: "struct ACP";
             readonly components: readonly [{
                 readonly name: "issuer";
                 readonly type: "address";
@@ -1122,13 +1162,25 @@ declare const MockACLArtifact: {
                 readonly type: "address";
                 readonly internalType: "address";
             }, {
-                readonly name: "validatorId";
+                readonly name: "revokerData";
                 readonly type: "uint256";
                 readonly internalType: "uint256";
             }, {
-                readonly name: "validatorContract";
+                readonly name: "revokerContract";
                 readonly type: "address";
                 readonly internalType: "address";
+            }, {
+                readonly name: "scope";
+                readonly type: "uint8";
+                readonly internalType: "uint8";
+            }, {
+                readonly name: "contracts";
+                readonly type: "address[]";
+                readonly internalType: "address[]";
+            }, {
+                readonly name: "handles";
+                readonly type: "bytes32[]";
+                readonly internalType: "bytes32[]";
             }, {
                 readonly name: "sealingKey";
                 readonly type: "bytes32";
@@ -1155,6 +1207,16 @@ declare const MockACLArtifact: {
         readonly inputs: readonly [];
         readonly outputs: readonly [];
         readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly name: "defaultRevokerContract";
+        readonly inputs: readonly [];
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+        readonly stateMutability: "view";
     }, {
         readonly type: "function";
         readonly name: "delegateAccount";
@@ -1297,9 +1359,9 @@ declare const MockACLArtifact: {
         readonly type: "function";
         readonly name: "isAllowedWithPermission";
         readonly inputs: readonly [{
-            readonly name: "permission";
+            readonly name: "acp";
             readonly type: "tuple";
-            readonly internalType: "struct Permission";
+            readonly internalType: "struct ACP";
             readonly components: readonly [{
                 readonly name: "issuer";
                 readonly type: "address";
@@ -1313,13 +1375,25 @@ declare const MockACLArtifact: {
                 readonly type: "address";
                 readonly internalType: "address";
             }, {
-                readonly name: "validatorId";
+                readonly name: "revokerData";
                 readonly type: "uint256";
                 readonly internalType: "uint256";
             }, {
-                readonly name: "validatorContract";
+                readonly name: "revokerContract";
                 readonly type: "address";
                 readonly internalType: "address";
+            }, {
+                readonly name: "scope";
+                readonly type: "uint8";
+                readonly internalType: "uint8";
+            }, {
+                readonly name: "contracts";
+                readonly type: "address[]";
+                readonly internalType: "address[]";
+            }, {
+                readonly name: "handles";
+                readonly type: "bytes32[]";
+                readonly internalType: "bytes32[]";
             }, {
                 readonly name: "sealingKey";
                 readonly type: "bytes32";
@@ -1362,6 +1436,72 @@ declare const MockACLArtifact: {
             readonly internalType: "bool";
         }];
         readonly stateMutability: "view";
+    }, {
+        readonly type: "function";
+        readonly name: "receiveCtHash";
+        readonly inputs: readonly [{
+            readonly name: "handle";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "expectedSharer";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "receiver";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly name: "setDefaultRevokerContract";
+        readonly inputs: readonly [{
+            readonly name: "newAddress";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly name: "setShareRegistry";
+        readonly inputs: readonly [{
+            readonly name: "newAddress";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly name: "shareCtHash";
+        readonly inputs: readonly [{
+            readonly name: "handle";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "sharer";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "receiver";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly name: "shareRegistry";
+        readonly inputs: readonly [];
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+        readonly stateMutability: "view";
     }, {
         readonly type: "event";
         readonly name: "AllowedForDecryption";
@@ -1372,6 +1512,21 @@ declare const MockACLArtifact: {
             readonly internalType: "uint256[]";
         }];
         readonly anonymous: false;
+    }, {
+        readonly type: "event";
+        readonly name: "DefaultRevokerContractUpdated";
+        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: "event";
         readonly name: "EIP712DomainChanged";
@@ -1397,6 +1552,21 @@ declare const MockACLArtifact: {
             readonly internalType: "address";
         }];
         readonly anonymous: false;
+    }, {
+        readonly type: "event";
+        readonly name: "ShareRegistryUpdated";
+        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";
@@ -1413,6 +1583,18 @@ declare const MockACLArtifact: {
         readonly type: "error";
         readonly name: "InvalidShortString";
         readonly inputs: readonly [];
+    }, {
+        readonly type: "error";
+        readonly name: "NotShared";
+        readonly inputs: readonly [{
+            readonly name: "handle";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "receiver";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
     }, {
         readonly type: "error";
         readonly name: "PermissionInvalid_Disabled";
@@ -1449,32 +1631,67 @@ declare const MockACLArtifact: {
             readonly type: "string";
             readonly internalType: "string";
         }];
+    }, {
+        readonly type: "error";
+        readonly name: "UnexpectedSharer";
+        readonly inputs: readonly [{
+            readonly name: "expected";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "actual";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
     }];
 };
 
-declare const MockZkVerifierArtifact: {
-    readonly contractName: "MockZkVerifier";
-    readonly isFixed: true;
-    readonly fixedAddress: "0x0000000000000000000000000000000000005001";
+declare const ACPTimestampRevokerArtifact: {
+    readonly contractName: "ACPTimestampRevoker";
+    readonly isFixed: false;
     readonly abi: readonly [{
         readonly type: "function";
-        readonly name: "exists";
-        readonly inputs: readonly [];
+        readonly name: "disabled";
+        readonly inputs: readonly [{
+            readonly name: "issuer";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "id";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }];
         readonly outputs: readonly [{
             readonly name: "";
             readonly type: "bool";
             readonly internalType: "bool";
         }];
-        readonly stateMutability: "pure";
+        readonly stateMutability: "view";
     }, {
         readonly type: "function";
-        readonly name: "insertCtHash";
+        readonly name: "revokeAllAt";
         readonly inputs: readonly [{
-            readonly name: "ctHash";
+            readonly name: "";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+        readonly outputs: readonly [{
+            readonly name: "";
             readonly type: "uint256";
             readonly internalType: "uint256";
-        }, {
-            readonly name: "value";
+        }];
+        readonly stateMutability: "view";
+    }, {
+        readonly type: "function";
+        readonly name: "revokeAllExisting";
+        readonly inputs: readonly [];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly name: "revokeSingle";
+        readonly inputs: readonly [{
+            readonly name: "id";
             readonly type: "uint256";
             readonly internalType: "uint256";
         }];
@@ -1482,11 +1699,369 @@ declare const MockZkVerifierArtifact: {
         readonly stateMutability: "nonpayable";
     }, {
         readonly type: "function";
-        readonly name: "insertPackedCtHashes";
+        readonly name: "revokedSingle";
         readonly inputs: readonly [{
-            readonly name: "ctHashes";
-            readonly type: "uint256[]";
-            readonly internalType: "uint256[]";
+            readonly name: "";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }];
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly type: "bool";
+            readonly internalType: "bool";
+        }];
+        readonly stateMutability: "view";
+    }, {
+        readonly type: "event";
+        readonly name: "RevokedAll";
+        readonly inputs: readonly [{
+            readonly name: "issuer";
+            readonly type: "address";
+            readonly indexed: true;
+            readonly internalType: "address";
+        }, {
+            readonly name: "at";
+            readonly type: "uint256";
+            readonly indexed: false;
+            readonly internalType: "uint256";
+        }];
+        readonly anonymous: false;
+    }, {
+        readonly type: "event";
+        readonly name: "RevokedSingle";
+        readonly inputs: readonly [{
+            readonly name: "issuer";
+            readonly type: "address";
+            readonly indexed: true;
+            readonly internalType: "address";
+        }, {
+            readonly name: "id";
+            readonly type: "uint256";
+            readonly indexed: true;
+            readonly internalType: "uint256";
+        }];
+        readonly anonymous: false;
+    }];
+};
+
+declare const ACPShareRegistryArtifact: {
+    readonly contractName: "ACPShareRegistry";
+    readonly isFixed: false;
+    readonly abi: readonly [{
+        readonly type: "function";
+        readonly name: "getShare";
+        readonly inputs: readonly [{
+            readonly name: "shareId";
+            readonly type: "bytes32";
+            readonly internalType: "bytes32";
+        }];
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly type: "tuple";
+            readonly internalType: "struct ACP";
+            readonly components: readonly [{
+                readonly name: "issuer";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "expiration";
+                readonly type: "uint64";
+                readonly internalType: "uint64";
+            }, {
+                readonly name: "recipient";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "revokerData";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }, {
+                readonly name: "revokerContract";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "scope";
+                readonly type: "uint8";
+                readonly internalType: "uint8";
+            }, {
+                readonly name: "contracts";
+                readonly type: "address[]";
+                readonly internalType: "address[]";
+            }, {
+                readonly name: "handles";
+                readonly type: "bytes32[]";
+                readonly internalType: "bytes32[]";
+            }, {
+                readonly name: "sealingKey";
+                readonly type: "bytes32";
+                readonly internalType: "bytes32";
+            }, {
+                readonly name: "issuerSignature";
+                readonly type: "bytes";
+                readonly internalType: "bytes";
+            }, {
+                readonly name: "recipientSignature";
+                readonly type: "bytes";
+                readonly internalType: "bytes";
+            }];
+        }];
+        readonly stateMutability: "view";
+    }, {
+        readonly type: "function";
+        readonly name: "isShareValid";
+        readonly inputs: readonly [{
+            readonly name: "shareId";
+            readonly type: "bytes32";
+            readonly internalType: "bytes32";
+        }];
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly type: "bool";
+            readonly internalType: "bool";
+        }];
+        readonly stateMutability: "view";
+    }, {
+        readonly type: "function";
+        readonly name: "removeShare";
+        readonly inputs: readonly [{
+            readonly name: "shareId";
+            readonly type: "bytes32";
+            readonly internalType: "bytes32";
+        }];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly name: "share";
+        readonly inputs: readonly [{
+            readonly name: "acp";
+            readonly type: "tuple";
+            readonly internalType: "struct ACP";
+            readonly components: readonly [{
+                readonly name: "issuer";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "expiration";
+                readonly type: "uint64";
+                readonly internalType: "uint64";
+            }, {
+                readonly name: "recipient";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "revokerData";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }, {
+                readonly name: "revokerContract";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "scope";
+                readonly type: "uint8";
+                readonly internalType: "uint8";
+            }, {
+                readonly name: "contracts";
+                readonly type: "address[]";
+                readonly internalType: "address[]";
+            }, {
+                readonly name: "handles";
+                readonly type: "bytes32[]";
+                readonly internalType: "bytes32[]";
+            }, {
+                readonly name: "sealingKey";
+                readonly type: "bytes32";
+                readonly internalType: "bytes32";
+            }, {
+                readonly name: "issuerSignature";
+                readonly type: "bytes";
+                readonly internalType: "bytes";
+            }, {
+                readonly name: "recipientSignature";
+                readonly type: "bytes";
+                readonly internalType: "bytes";
+            }];
+        }];
+        readonly outputs: readonly [{
+            readonly name: "shareId";
+            readonly type: "bytes32";
+            readonly internalType: "bytes32";
+        }];
+        readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly name: "sharesFor";
+        readonly inputs: readonly [{
+            readonly name: "recipient";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+        readonly outputs: readonly [{
+            readonly name: "acps";
+            readonly type: "tuple[]";
+            readonly internalType: "struct ACP[]";
+            readonly components: readonly [{
+                readonly name: "issuer";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "expiration";
+                readonly type: "uint64";
+                readonly internalType: "uint64";
+            }, {
+                readonly name: "recipient";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "revokerData";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }, {
+                readonly name: "revokerContract";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "scope";
+                readonly type: "uint8";
+                readonly internalType: "uint8";
+            }, {
+                readonly name: "contracts";
+                readonly type: "address[]";
+                readonly internalType: "address[]";
+            }, {
+                readonly name: "handles";
+                readonly type: "bytes32[]";
+                readonly internalType: "bytes32[]";
+            }, {
+                readonly name: "sealingKey";
+                readonly type: "bytes32";
+                readonly internalType: "bytes32";
+            }, {
+                readonly name: "issuerSignature";
+                readonly type: "bytes";
+                readonly internalType: "bytes";
+            }, {
+                readonly name: "recipientSignature";
+                readonly type: "bytes";
+                readonly internalType: "bytes";
+            }];
+        }];
+        readonly stateMutability: "view";
+    }, {
+        readonly type: "event";
+        readonly name: "ShareRemoved";
+        readonly inputs: readonly [{
+            readonly name: "recipient";
+            readonly type: "address";
+            readonly indexed: true;
+            readonly internalType: "address";
+        }, {
+            readonly name: "issuer";
+            readonly type: "address";
+            readonly indexed: true;
+            readonly internalType: "address";
+        }, {
+            readonly name: "shareId";
+            readonly type: "bytes32";
+            readonly indexed: false;
+            readonly internalType: "bytes32";
+        }];
+        readonly anonymous: false;
+    }, {
+        readonly type: "event";
+        readonly name: "Shared";
+        readonly inputs: readonly [{
+            readonly name: "recipient";
+            readonly type: "address";
+            readonly indexed: true;
+            readonly internalType: "address";
+        }, {
+            readonly name: "issuer";
+            readonly type: "address";
+            readonly indexed: true;
+            readonly internalType: "address";
+        }, {
+            readonly name: "shareId";
+            readonly type: "bytes32";
+            readonly indexed: false;
+            readonly internalType: "bytes32";
+        }];
+        readonly anonymous: false;
+    }, {
+        readonly type: "error";
+        readonly name: "AlreadyShared";
+        readonly inputs: readonly [];
+    }, {
+        readonly type: "error";
+        readonly name: "IssuerSignatureMissing";
+        readonly inputs: readonly [];
+    }, {
+        readonly type: "error";
+        readonly name: "NotIssuer";
+        readonly inputs: readonly [];
+    }, {
+        readonly type: "error";
+        readonly name: "NotIssuerOrRecipient";
+        readonly inputs: readonly [];
+    }, {
+        readonly type: "error";
+        readonly name: "RecipientMissing";
+        readonly inputs: readonly [];
+    }, {
+        readonly type: "error";
+        readonly name: "SealingKeyMustBeEmpty";
+        readonly inputs: readonly [];
+    }, {
+        readonly type: "error";
+        readonly name: "ShareExpired";
+        readonly inputs: readonly [];
+    }, {
+        readonly type: "error";
+        readonly name: "UnknownShare";
+        readonly inputs: readonly [];
+    }];
+};
+
+declare const MockZkVerifierArtifact: {
+    readonly contractName: "MockZkVerifier";
+    readonly isFixed: true;
+    readonly fixedAddress: "0x0000000000000000000000000000000000005001";
+    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: "insertCtHash";
+        readonly inputs: readonly [{
+            readonly name: "ctHash";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "value";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }];
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+    }, {
+        readonly type: "function";
+        readonly name: "insertPackedCtHashes";
+        readonly inputs: readonly [{
+            readonly name: "ctHashes";
+            readonly type: "uint256[]";
+            readonly internalType: "uint256[]";
         }, {
             readonly name: "values";
             readonly type: "uint256[]";
@@ -1675,15 +2250,15 @@ declare const MockThresholdNetworkArtifact: {
         readonly stateMutability: "pure";
     }, {
         readonly type: "function";
-        readonly name: "decryptForTxWithPermit";
+        readonly name: "decryptForTxWithACP";
         readonly inputs: readonly [{
             readonly name: "ctHash";
             readonly type: "uint256";
             readonly internalType: "uint256";
         }, {
-            readonly name: "permission";
+            readonly name: "acp";
             readonly type: "tuple";
-            readonly internalType: "struct Permission";
+            readonly internalType: "struct ACP";
             readonly components: readonly [{
                 readonly name: "issuer";
                 readonly type: "address";
@@ -1697,13 +2272,25 @@ declare const MockThresholdNetworkArtifact: {
                 readonly type: "address";
                 readonly internalType: "address";
             }, {
-                readonly name: "validatorId";
+                readonly name: "revokerData";
                 readonly type: "uint256";
                 readonly internalType: "uint256";
             }, {
-                readonly name: "validatorContract";
+                readonly name: "revokerContract";
                 readonly type: "address";
                 readonly internalType: "address";
+            }, {
+                readonly name: "scope";
+                readonly type: "uint8";
+                readonly internalType: "uint8";
+            }, {
+                readonly name: "contracts";
+                readonly type: "address[]";
+                readonly internalType: "address[]";
+            }, {
+                readonly name: "handles";
+                readonly type: "bytes32[]";
+                readonly internalType: "bytes32[]";
             }, {
                 readonly name: "sealingKey";
                 readonly type: "bytes32";
@@ -1734,7 +2321,7 @@ declare const MockThresholdNetworkArtifact: {
         readonly stateMutability: "view";
     }, {
         readonly type: "function";
-        readonly name: "decryptForTxWithoutPermit";
+        readonly name: "decryptForTxWithoutACP";
         readonly inputs: readonly [{
             readonly name: "ctHash";
             readonly type: "uint256";
@@ -1840,9 +2427,9 @@ declare const MockThresholdNetworkArtifact: {
             readonly type: "uint256";
             readonly internalType: "uint256";
         }, {
-            readonly name: "permission";
+            readonly name: "acp";
             readonly type: "tuple";
-            readonly internalType: "struct Permission";
+            readonly internalType: "struct ACP";
             readonly components: readonly [{
                 readonly name: "issuer";
                 readonly type: "address";
@@ -1856,13 +2443,25 @@ declare const MockThresholdNetworkArtifact: {
                 readonly type: "address";
                 readonly internalType: "address";
             }, {
-                readonly name: "validatorId";
+                readonly name: "revokerData";
                 readonly type: "uint256";
                 readonly internalType: "uint256";
             }, {
-                readonly name: "validatorContract";
+                readonly name: "revokerContract";
                 readonly type: "address";
                 readonly internalType: "address";
+            }, {
+                readonly name: "scope";
+                readonly type: "uint8";
+                readonly internalType: "uint8";
+            }, {
+                readonly name: "contracts";
+                readonly type: "address[]";
+                readonly internalType: "address[]";
+            }, {
+                readonly name: "handles";
+                readonly type: "bytes32[]";
+                readonly internalType: "bytes32[]";
             }, {
                 readonly name: "sealingKey";
                 readonly type: "bytes32";
@@ -1903,9 +2502,9 @@ declare const MockThresholdNetworkArtifact: {
             readonly type: "uint256";
             readonly internalType: "uint256";
         }, {
-            readonly name: "permission";
+            readonly name: "acp";
             readonly type: "tuple";
-            readonly internalType: "struct Permission";
+            readonly internalType: "struct ACP";
             readonly components: readonly [{
                 readonly name: "issuer";
                 readonly type: "address";
@@ -1919,13 +2518,25 @@ declare const MockThresholdNetworkArtifact: {
                 readonly type: "address";
                 readonly internalType: "address";
             }, {
-                readonly name: "validatorId";
+                readonly name: "revokerData";
                 readonly type: "uint256";
                 readonly internalType: "uint256";
             }, {
-                readonly name: "validatorContract";
+                readonly name: "revokerContract";
                 readonly type: "address";
                 readonly internalType: "address";
+            }, {
+                readonly name: "scope";
+                readonly type: "uint8";
+                readonly internalType: "uint8";
+            }, {
+                readonly name: "contracts";
+                readonly type: "address[]";
+                readonly internalType: "address[]";
+            }, {
+                readonly name: "handles";
+                readonly type: "bytes32[]";
+                readonly internalType: "bytes32[]";
             }, {
                 readonly name: "sealingKey";
                 readonly type: "bytes32";
@@ -2045,19 +2656,206 @@ interface TypedContractMethod<A extends Array<any> = Array<any>, R = any, S exte
     staticCallResult(...args: ContractMethodArgs<A, 'view'>): Promise<R>;
 }
 
-type PermissionStruct$2 = {
+type ACPStruct$3 = {
+    issuer: AddressLike;
+    expiration: BigNumberish;
+    recipient: AddressLike;
+    revokerData: BigNumberish;
+    revokerContract: AddressLike;
+    scope: BigNumberish;
+    contracts: AddressLike[];
+    handles: BytesLike[];
+    sealingKey: BytesLike;
+    issuerSignature: BytesLike;
+    recipientSignature: BytesLike;
+};
+type ACPStructOutput = [
+    issuer: string,
+    expiration: bigint,
+    recipient: string,
+    revokerData: bigint,
+    revokerContract: string,
+    scope: bigint,
+    contracts: string[],
+    handles: string[],
+    sealingKey: string,
+    issuerSignature: string,
+    recipientSignature: string
+] & {
+    issuer: string;
+    expiration: bigint;
+    recipient: string;
+    revokerData: bigint;
+    revokerContract: string;
+    scope: bigint;
+    contracts: string[];
+    handles: string[];
+    sealingKey: string;
+    issuerSignature: string;
+    recipientSignature: string;
+};
+interface ACPShareRegistryInterface extends Interface {
+    getFunction(nameOrSignature: 'getShare' | 'isShareValid' | 'removeShare' | 'share' | 'sharesFor'): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: 'ShareRemoved' | 'Shared'): EventFragment;
+    encodeFunctionData(functionFragment: 'getShare', values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: 'isShareValid', values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: 'removeShare', values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: 'share', values: [ACPStruct$3]): string;
+    encodeFunctionData(functionFragment: 'sharesFor', values: [AddressLike]): string;
+    decodeFunctionResult(functionFragment: 'getShare', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'isShareValid', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'removeShare', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'share', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'sharesFor', data: BytesLike): Result;
+}
+declare namespace ShareRemovedEvent {
+    type InputTuple = [recipient: AddressLike, issuer: AddressLike, shareId: BytesLike];
+    type OutputTuple = [recipient: string, issuer: string, shareId: string];
+    interface OutputObject {
+        recipient: string;
+        issuer: string;
+        shareId: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+declare namespace SharedEvent {
+    type InputTuple = [recipient: AddressLike, issuer: AddressLike, shareId: BytesLike];
+    type OutputTuple = [recipient: string, issuer: string, shareId: string];
+    interface OutputObject {
+        recipient: string;
+        issuer: string;
+        shareId: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+interface ACPShareRegistry extends BaseContract {
+    connect(runner?: ContractRunner | null): ACPShareRegistry;
+    waitForDeployment(): Promise<this>;
+    interface: ACPShareRegistryInterface;
+    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>;
+    getShare: TypedContractMethod<[shareId: BytesLike], [ACPStructOutput], 'view'>;
+    isShareValid: TypedContractMethod<[shareId: BytesLike], [boolean], 'view'>;
+    removeShare: TypedContractMethod<[shareId: BytesLike], [void], 'nonpayable'>;
+    share: TypedContractMethod<[acp: ACPStruct$3], [string], 'nonpayable'>;
+    sharesFor: TypedContractMethod<[recipient: AddressLike], [ACPStructOutput[]], 'view'>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: 'getShare'): TypedContractMethod<[shareId: BytesLike], [ACPStructOutput], 'view'>;
+    getFunction(nameOrSignature: 'isShareValid'): TypedContractMethod<[shareId: BytesLike], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'removeShare'): TypedContractMethod<[shareId: BytesLike], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'share'): TypedContractMethod<[acp: ACPStruct$3], [string], 'nonpayable'>;
+    getFunction(nameOrSignature: 'sharesFor'): TypedContractMethod<[recipient: AddressLike], [ACPStructOutput[]], 'view'>;
+    getEvent(key: 'ShareRemoved'): TypedContractEvent<ShareRemovedEvent.InputTuple, ShareRemovedEvent.OutputTuple, ShareRemovedEvent.OutputObject>;
+    getEvent(key: 'Shared'): TypedContractEvent<SharedEvent.InputTuple, SharedEvent.OutputTuple, SharedEvent.OutputObject>;
+    filters: {
+        'ShareRemoved(address,address,bytes32)': TypedContractEvent<ShareRemovedEvent.InputTuple, ShareRemovedEvent.OutputTuple, ShareRemovedEvent.OutputObject>;
+        ShareRemoved: TypedContractEvent<ShareRemovedEvent.InputTuple, ShareRemovedEvent.OutputTuple, ShareRemovedEvent.OutputObject>;
+        'Shared(address,address,bytes32)': TypedContractEvent<SharedEvent.InputTuple, SharedEvent.OutputTuple, SharedEvent.OutputObject>;
+        Shared: TypedContractEvent<SharedEvent.InputTuple, SharedEvent.OutputTuple, SharedEvent.OutputObject>;
+    };
+}
+
+interface ACPTimestampRevokerInterface extends Interface {
+    getFunction(nameOrSignature: 'disabled' | 'revokeAllAt' | 'revokeAllExisting' | 'revokeSingle' | 'revokedSingle'): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: 'RevokedAll' | 'RevokedSingle'): EventFragment;
+    encodeFunctionData(functionFragment: 'disabled', values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'revokeAllAt', values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: 'revokeAllExisting', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'revokeSingle', values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: 'revokedSingle', values: [AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: 'disabled', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'revokeAllAt', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'revokeAllExisting', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'revokeSingle', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'revokedSingle', data: BytesLike): Result;
+}
+declare namespace RevokedAllEvent {
+    type InputTuple = [issuer: AddressLike, at: BigNumberish];
+    type OutputTuple = [issuer: string, at: bigint];
+    interface OutputObject {
+        issuer: string;
+        at: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+declare namespace RevokedSingleEvent {
+    type InputTuple = [issuer: AddressLike, id: BigNumberish];
+    type OutputTuple = [issuer: string, id: bigint];
+    interface OutputObject {
+        issuer: string;
+        id: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+interface ACPTimestampRevoker extends BaseContract {
+    connect(runner?: ContractRunner | null): ACPTimestampRevoker;
+    waitForDeployment(): Promise<this>;
+    interface: ACPTimestampRevokerInterface;
+    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>;
+    disabled: TypedContractMethod<[issuer: AddressLike, id: BigNumberish], [boolean], 'view'>;
+    revokeAllAt: TypedContractMethod<[arg0: AddressLike], [bigint], 'view'>;
+    revokeAllExisting: TypedContractMethod<[], [void], 'nonpayable'>;
+    revokeSingle: TypedContractMethod<[id: BigNumberish], [void], 'nonpayable'>;
+    revokedSingle: TypedContractMethod<[arg0: AddressLike, arg1: BigNumberish], [boolean], 'view'>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: 'disabled'): TypedContractMethod<[issuer: AddressLike, id: BigNumberish], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'revokeAllAt'): TypedContractMethod<[arg0: AddressLike], [bigint], 'view'>;
+    getFunction(nameOrSignature: 'revokeAllExisting'): TypedContractMethod<[], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'revokeSingle'): TypedContractMethod<[id: BigNumberish], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'revokedSingle'): TypedContractMethod<[arg0: AddressLike, arg1: BigNumberish], [boolean], 'view'>;
+    getEvent(key: 'RevokedAll'): TypedContractEvent<RevokedAllEvent.InputTuple, RevokedAllEvent.OutputTuple, RevokedAllEvent.OutputObject>;
+    getEvent(key: 'RevokedSingle'): TypedContractEvent<RevokedSingleEvent.InputTuple, RevokedSingleEvent.OutputTuple, RevokedSingleEvent.OutputObject>;
+    filters: {
+        'RevokedAll(address,uint256)': TypedContractEvent<RevokedAllEvent.InputTuple, RevokedAllEvent.OutputTuple, RevokedAllEvent.OutputObject>;
+        RevokedAll: TypedContractEvent<RevokedAllEvent.InputTuple, RevokedAllEvent.OutputTuple, RevokedAllEvent.OutputObject>;
+        'RevokedSingle(address,uint256)': TypedContractEvent<RevokedSingleEvent.InputTuple, RevokedSingleEvent.OutputTuple, RevokedSingleEvent.OutputObject>;
+        RevokedSingle: TypedContractEvent<RevokedSingleEvent.InputTuple, RevokedSingleEvent.OutputTuple, RevokedSingleEvent.OutputObject>;
+    };
+}
+
+type ACPStruct$2 = {
     issuer: AddressLike;
     expiration: BigNumberish;
     recipient: AddressLike;
-    validatorId: BigNumberish;
-    validatorContract: AddressLike;
+    revokerData: BigNumberish;
+    revokerContract: AddressLike;
+    scope: BigNumberish;
+    contracts: AddressLike[];
+    handles: BytesLike[];
     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;
+    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;
     encodeFunctionData(functionFragment: 'allow', values: [BigNumberish, AddressLike, AddressLike]): string;
     encodeFunctionData(functionFragment: 'allowForDecryption', values: [BigNumberish[], AddressLike]): string;
@@ -2065,8 +2863,9 @@ interface MockACLInterface extends Interface {
     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: 'checkPermissionValidity', values: [ACPStruct$2]): string;
     encodeFunctionData(functionFragment: 'cleanTransientStorage', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'defaultRevokerContract', values?: undefined): string;
     encodeFunctionData(functionFragment: 'delegateAccount', values: [AddressLike, AddressLike]): string;
     encodeFunctionData(functionFragment: 'eip712Domain', values?: undefined): string;
     encodeFunctionData(functionFragment: 'exists', values?: undefined): string;
@@ -2076,8 +2875,13 @@ interface MockACLInterface extends Interface {
     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: 'isAllowedWithPermission', values: [ACPStruct$2, BigNumberish]): string;
     encodeFunctionData(functionFragment: 'persistAllowed', values: [BigNumberish, AddressLike]): string;
+    encodeFunctionData(functionFragment: 'receiveCtHash', values: [BigNumberish, AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: 'setDefaultRevokerContract', values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: 'setShareRegistry', 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;
@@ -2085,8 +2889,9 @@ interface MockACLInterface extends Interface {
     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: 'checkPermissionValidity', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'cleanTransientStorage', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'defaultRevokerContract', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'delegateAccount', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'eip712Domain', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'exists', data: BytesLike): Result;
@@ -2098,6 +2903,11 @@ interface MockACLInterface extends Interface {
     decodeFunctionResult(functionFragment: 'isAllowedForDecryption', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'isAllowedWithPermission', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'persistAllowed', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'receiveCtHash', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'setDefaultRevokerContract', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'setShareRegistry', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'shareCtHash', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'shareRegistry', data: BytesLike): Result;
 }
 declare namespace AllowedForDecryptionEvent {
     type InputTuple = [handlesList: BigNumberish[]];
@@ -2110,6 +2920,18 @@ declare namespace AllowedForDecryptionEvent {
     type Log = TypedEventLog<Event>;
     type LogDescription = TypedLogDescription<Event>;
 }
+declare namespace DefaultRevokerContractUpdatedEvent {
+    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>;
+}
 declare namespace EIP712DomainChangedEvent {
     type InputTuple = [];
     type OutputTuple = [];
@@ -2133,6 +2955,18 @@ declare namespace NewDelegationEvent {
     type Log = TypedEventLog<Event>;
     type LogDescription = TypedLogDescription<Event>;
 }
+declare namespace ShareRegistryUpdatedEvent {
+    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>;
@@ -2172,8 +3006,9 @@ interface MockACL extends BaseContract {
         boolean
     ], 'view'>;
     allowedTransient: TypedContractMethod<[handle: BigNumberish, account: AddressLike], [boolean], 'view'>;
-    checkPermitValidity: TypedContractMethod<[permission: PermissionStruct$2], [boolean], 'view'>;
+    checkPermissionValidity: TypedContractMethod<[acp: ACPStruct$2], [boolean], 'view'>;
     cleanTransientStorage: TypedContractMethod<[], [void], 'nonpayable'>;
+    defaultRevokerContract: TypedContractMethod<[], [string], 'view'>;
     delegateAccount: TypedContractMethod<[delegatee: AddressLike, delegateeContract: AddressLike], [void], 'nonpayable'>;
     eip712Domain: TypedContractMethod<[
     ], [
@@ -2202,8 +3037,25 @@ interface MockACL extends BaseContract {
     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'>;
+    isAllowedWithPermission: TypedContractMethod<[acp: ACPStruct$2, handle: BigNumberish], [boolean], 'view'>;
     persistAllowed: TypedContractMethod<[handle: BigNumberish, account: AddressLike], [boolean], 'view'>;
+    receiveCtHash: TypedContractMethod<[
+        handle: BigNumberish,
+        expectedSharer: AddressLike,
+        receiver: AddressLike
+    ], [
+        void
+    ], 'nonpayable'>;
+    setDefaultRevokerContract: TypedContractMethod<[newAddress: AddressLike], [void], 'nonpayable'>;
+    setShareRegistry: TypedContractMethod<[newAddress: AddressLike], [void], 'nonpayable'>;
+    shareCtHash: TypedContractMethod<[
+        handle: BigNumberish,
+        sharer: AddressLike,
+        receiver: AddressLike
+    ], [
+        void
+    ], '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'>;
@@ -2219,8 +3071,9 @@ interface MockACL extends BaseContract {
         boolean
     ], 'view'>;
     getFunction(nameOrSignature: 'allowedTransient'): TypedContractMethod<[handle: BigNumberish, account: AddressLike], [boolean], 'view'>;
-    getFunction(nameOrSignature: 'checkPermitValidity'): TypedContractMethod<[permission: PermissionStruct$2], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'checkPermissionValidity'): TypedContractMethod<[acp: ACPStruct$2], [boolean], 'view'>;
     getFunction(nameOrSignature: 'cleanTransientStorage'): TypedContractMethod<[], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'defaultRevokerContract'): TypedContractMethod<[], [string], 'view'>;
     getFunction(nameOrSignature: 'delegateAccount'): TypedContractMethod<[delegatee: AddressLike, delegateeContract: AddressLike], [void], 'nonpayable'>;
     getFunction(nameOrSignature: 'eip712Domain'): TypedContractMethod<[
     ], [
@@ -2249,39 +3102,58 @@ interface MockACL extends BaseContract {
     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: 'isAllowedWithPermission'): TypedContractMethod<[acp: ACPStruct$2, handle: BigNumberish], [boolean], 'view'>;
     getFunction(nameOrSignature: 'persistAllowed'): TypedContractMethod<[handle: BigNumberish, account: AddressLike], [boolean], 'view'>;
+    getFunction(nameOrSignature: 'receiveCtHash'): TypedContractMethod<[
+        handle: BigNumberish,
+        expectedSharer: AddressLike,
+        receiver: AddressLike
+    ], [
+        void
+    ], 'nonpayable'>;
+    getFunction(nameOrSignature: 'setDefaultRevokerContract'): TypedContractMethod<[newAddress: AddressLike], [void], 'nonpayable'>;
+    getFunction(nameOrSignature: 'setShareRegistry'): 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>;
+    getEvent(key: 'DefaultRevokerContractUpdated'): TypedContractEvent<DefaultRevokerContractUpdatedEvent.InputTuple, DefaultRevokerContractUpdatedEvent.OutputTuple, DefaultRevokerContractUpdatedEvent.OutputObject>;
     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>;
     filters: {
         'AllowedForDecryption(uint256[])': TypedContractEvent<AllowedForDecryptionEvent.InputTuple, AllowedForDecryptionEvent.OutputTuple, AllowedForDecryptionEvent.OutputObject>;
         AllowedForDecryption: TypedContractEvent<AllowedForDecryptionEvent.InputTuple, AllowedForDecryptionEvent.OutputTuple, AllowedForDecryptionEvent.OutputObject>;
+        'DefaultRevokerContractUpdated(address,address)': TypedContractEvent<DefaultRevokerContractUpdatedEvent.InputTuple, DefaultRevokerContractUpdatedEvent.OutputTuple, DefaultRevokerContractUpdatedEvent.OutputObject>;
+        DefaultRevokerContractUpdated: TypedContractEvent<DefaultRevokerContractUpdatedEvent.InputTuple, DefaultRevokerContractUpdatedEvent.OutputTuple, DefaultRevokerContractUpdatedEvent.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>;
+        'ShareRegistryUpdated(address,address)': TypedContractEvent<ShareRegistryUpdatedEvent.InputTuple, ShareRegistryUpdatedEvent.OutputTuple, ShareRegistryUpdatedEvent.OutputObject>;
+        ShareRegistryUpdated: TypedContractEvent<ShareRegistryUpdatedEvent.InputTuple, ShareRegistryUpdatedEvent.OutputTuple, ShareRegistryUpdatedEvent.OutputObject>;
     };
 }
 
-type PermissionStruct$1 = {
+type UnsignedEncryptedInputStruct = {
+    ctHash: BigNumberish;
+    securityZone: BigNumberish;
+    utype: BigNumberish;
+};
+type ACPStruct$1 = {
     issuer: AddressLike;
     expiration: BigNumberish;
     recipient: AddressLike;
-    validatorId: BigNumberish;
-    validatorContract: AddressLike;
+    revokerData: BigNumberish;
+    revokerContract: AddressLike;
+    scope: BigNumberish;
+    contracts: AddressLike[];
+    handles: BytesLike[];
     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' | 'verifyDecryptResultBatch' | 'verifyDecryptResultBatchSafe' | 'verifyDecryptResultSafe' | 'verifyInput'): FunctionFragment;
+    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;
     encodeFunctionData(functionFragment: 'MOCK_logAllow', values: [string, BigNumberish, AddressLike]): string;
     encodeFunctionData(functionFragment: 'MOCK_setInEuintKey', values: [BigNumberish, BigNumberish]): string;
@@ -2291,6 +3163,7 @@ interface MockTaskManagerInterface extends Interface {
     encodeFunctionData(functionFragment: 'allowForDecryption', values: [BigNumberish]): string;
     encodeFunctionData(functionFragment: 'allowGlobal', values: [BigNumberish]): string;
     encodeFunctionData(functionFragment: 'allowTransient', values: [BigNumberish, AddressLike]): string;
+    encodeFunctionData(functionFragment: 'batchVerifyInputs', values: [UnsignedEncryptedInputStruct[], AddressLike, BytesLike]): 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;
@@ -2303,13 +3176,14 @@ interface MockTaskManagerInterface extends Interface {
     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: 'isAllowedWithPermission', values: [ACPStruct$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: 'receiveCtHash', values: [BigNumberish, AddressLike]): string;
     encodeFunctionData(functionFragment: 'removeFirstLetter', values: [string]): string;
     encodeFunctionData(functionFragment: 'setACLContract', values: [AddressLike]): string;
     encodeFunctionData(functionFragment: 'setAggregator', values: [AddressLike]): string;
@@ -2319,12 +3193,12 @@ interface MockTaskManagerInterface extends Interface {
     encodeFunctionData(functionFragment: 'setSecurityZoneMin', values: [BigNumberish]): string;
     encodeFunctionData(functionFragment: 'setSecurityZones', values: [BigNumberish, BigNumberish]): string;
     encodeFunctionData(functionFragment: 'setVerifierSigner', values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: 'shareCtHash', values: [BigNumberish, AddressLike]): string;
     encodeFunctionData(functionFragment: 'sliceString', values: [string, BigNumberish, BigNumberish]): string;
     encodeFunctionData(functionFragment: 'verifyDecryptResult', values: [BigNumberish, BigNumberish, BytesLike]): string;
     encodeFunctionData(functionFragment: 'verifyDecryptResultBatch', values: [BigNumberish[], BigNumberish[], BytesLike[]]): string;
     encodeFunctionData(functionFragment: 'verifyDecryptResultBatchSafe', 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;
@@ -2333,6 +3207,7 @@ interface MockTaskManagerInterface extends Interface {
     decodeFunctionResult(functionFragment: 'allowForDecryption', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'allowGlobal', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'allowTransient', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'batchVerifyInputs', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'createDecryptTask', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'createRandomTask', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'createTask', data: BytesLike): Result;
@@ -2352,6 +3227,7 @@ interface MockTaskManagerInterface extends Interface {
     decodeFunctionResult(functionFragment: 'mockStorage', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'publishDecryptResult', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'publishDecryptResultBatch', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'receiveCtHash', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'removeFirstLetter', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'setACLContract', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'setAggregator', data: BytesLike): Result;
@@ -2361,12 +3237,12 @@ interface MockTaskManagerInterface extends Interface {
     decodeFunctionResult(functionFragment: 'setSecurityZoneMin', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'setSecurityZones', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'setVerifierSigner', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'shareCtHash', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'sliceString', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'verifyDecryptResult', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'verifyDecryptResultBatch', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'verifyDecryptResultBatchSafe', 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];
@@ -2436,6 +3312,13 @@ interface MockTaskManager extends BaseContract {
     allowForDecryption: TypedContractMethod<[ctHash: BigNumberish], [void], 'nonpayable'>;
     allowGlobal: TypedContractMethod<[ctHash: BigNumberish], [void], 'nonpayable'>;
     allowTransient: TypedContractMethod<[ctHash: BigNumberish, account: AddressLike], [void], 'nonpayable'>;
+    batchVerifyInputs: TypedContractMethod<[
+        inputs: UnsignedEncryptedInputStruct[],
+        sender: AddressLike,
+        signature: BytesLike
+    ], [
+        bigint[]
+    ], 'nonpayable'>;
     createDecryptTask: TypedContractMethod<[ctHash: BigNumberish, arg1: AddressLike], [void], 'nonpayable'>;
     createRandomTask: TypedContractMethod<[
         returnType: BigNumberish,
@@ -2480,7 +3363,7 @@ interface MockTaskManager extends BaseContract {
     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'>;
+    isAllowedWithPermission: TypedContractMethod<[acp: ACPStruct$1, handle: BigNumberish], [boolean], 'view'>;
     isInitialized: TypedContractMethod<[], [boolean], 'view'>;
     isPubliclyAllowed: TypedContractMethod<[ctHash: BigNumberish], [boolean], 'view'>;
     logOps: TypedContractMethod<[], [boolean], 'view'>;
@@ -2499,6 +3382,7 @@ interface MockTaskManager extends BaseContract {
     ], [
         void
     ], 'nonpayable'>;
+    receiveCtHash: TypedContractMethod<[ctHash: BigNumberish, expectedSharer: AddressLike], [void], 'nonpayable'>;
     removeFirstLetter: TypedContractMethod<[str: string], [string], 'view'>;
     setACLContract: TypedContractMethod<[_aclAddress: AddressLike], [void], 'nonpayable'>;
     setAggregator: TypedContractMethod<[_aggregatorAddress: AddressLike], [void], 'nonpayable'>;
@@ -2508,6 +3392,7 @@ interface MockTaskManager extends BaseContract {
     setSecurityZoneMin: TypedContractMethod<[securityZone: BigNumberish], [void], 'nonpayable'>;
     setSecurityZones: TypedContractMethod<[minSZ: BigNumberish, maxSZ: BigNumberish], [void], 'nonpayable'>;
     setVerifierSigner: TypedContractMethod<[signer: AddressLike], [void], 'nonpayable'>;
+    shareCtHash: TypedContractMethod<[ctHash: BigNumberish, receiver: AddressLike], [void], 'nonpayable'>;
     sliceString: TypedContractMethod<[str: string, start: BigNumberish, length: BigNumberish], [string], 'view'>;
     verifyDecryptResult: TypedContractMethod<[
         ctHash: BigNumberish,
@@ -2537,7 +3422,6 @@ interface MockTaskManager extends BaseContract {
     ], [
         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'>;
@@ -2547,6 +3431,13 @@ interface MockTaskManager extends BaseContract {
     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: 'batchVerifyInputs'): TypedContractMethod<[
+        inputs: UnsignedEncryptedInputStruct[],
+        sender: AddressLike,
+        signature: BytesLike
+    ], [
+        bigint[]
+    ], 'nonpayable'>;
     getFunction(nameOrSignature: 'createDecryptTask'): TypedContractMethod<[ctHash: BigNumberish, arg1: AddressLike], [void], 'nonpayable'>;
     getFunction(nameOrSignature: 'createRandomTask'): TypedContractMethod<[
         returnType: BigNumberish,
@@ -2575,7 +3466,7 @@ interface MockTaskManager extends BaseContract {
     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: 'isAllowedWithPermission'): TypedContractMethod<[acp: ACPStruct$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'>;
@@ -2588,6 +3479,7 @@ interface MockTaskManager extends BaseContract {
     ], [
         void
     ], 'nonpayable'>;
+    getFunction(nameOrSignature: 'receiveCtHash'): TypedContractMethod<[ctHash: BigNumberish, expectedSharer: AddressLike], [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'>;
@@ -2597,6 +3489,7 @@ interface MockTaskManager extends BaseContract {
     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: 'shareCtHash'): TypedContractMethod<[ctHash: BigNumberish, receiver: 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: 'verifyDecryptResultBatch'): TypedContractMethod<[
@@ -2614,7 +3507,6 @@ interface MockTaskManager extends BaseContract {
         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>;
@@ -2628,33 +3520,36 @@ interface MockTaskManager extends BaseContract {
     };
 }
 
-type PermissionStruct = {
+type ACPStruct = {
     issuer: AddressLike;
     expiration: BigNumberish;
     recipient: AddressLike;
-    validatorId: BigNumberish;
-    validatorContract: AddressLike;
+    revokerData: BigNumberish;
+    revokerContract: AddressLike;
+    scope: BigNumberish;
+    contracts: AddressLike[];
+    handles: BytesLike[];
     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;
+    getFunction(nameOrSignature: 'decodeLowLevelReversion' | 'decryptForTxWithACP' | 'decryptForTxWithoutACP' | '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: 'decryptForTxWithACP', values: [BigNumberish, ACPStruct]): string;
+    encodeFunctionData(functionFragment: 'decryptForTxWithoutACP', 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: 'queryDecrypt', values: [BigNumberish, BigNumberish, ACPStruct]): string;
+    encodeFunctionData(functionFragment: 'querySealOutput', values: [BigNumberish, BigNumberish, ACPStruct]): 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: 'decryptForTxWithACP', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'decryptForTxWithoutACP', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'exists', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'initialize', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'mockAcl', data: BytesLike): Result;
@@ -2679,9 +3574,9 @@ interface MockThresholdNetwork extends BaseContract {
     listeners(eventName?: string): Promise<Array<Listener>>;
     removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
     decodeLowLevelReversion: TypedContractMethod<[data: BytesLike], [string], 'view'>;
-    decryptForTxWithPermit: TypedContractMethod<[
+    decryptForTxWithACP: TypedContractMethod<[
         ctHash: BigNumberish,
-        permission: PermissionStruct
+        acp: ACPStruct
     ], [
         [
             boolean,
@@ -2693,7 +3588,7 @@ interface MockThresholdNetwork extends BaseContract {
             decryptedValue: bigint;
         }
     ], 'view'>;
-    decryptForTxWithoutPermit: TypedContractMethod<[
+    decryptForTxWithoutACP: TypedContractMethod<[
         ctHash: BigNumberish
     ], [
         [
@@ -2723,7 +3618,7 @@ interface MockThresholdNetwork extends BaseContract {
     queryDecrypt: TypedContractMethod<[
         ctHash: BigNumberish,
         arg1: BigNumberish,
-        permission: PermissionStruct
+        acp: ACPStruct
     ], [
         [boolean, string, bigint] & {
             allowed: boolean;
@@ -2733,7 +3628,7 @@ interface MockThresholdNetwork extends BaseContract {
     querySealOutput: TypedContractMethod<[
         ctHash: BigNumberish,
         arg1: BigNumberish,
-        permission: PermissionStruct
+        acp: ACPStruct
     ], [
         [boolean, string, string] & {
             allowed: boolean;
@@ -2744,9 +3639,9 @@ interface MockThresholdNetwork extends BaseContract {
     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<[
+    getFunction(nameOrSignature: 'decryptForTxWithACP'): TypedContractMethod<[
         ctHash: BigNumberish,
-        permission: PermissionStruct
+        acp: ACPStruct
     ], [
         [
             boolean,
@@ -2758,7 +3653,7 @@ interface MockThresholdNetwork extends BaseContract {
             decryptedValue: bigint;
         }
     ], 'view'>;
-    getFunction(nameOrSignature: 'decryptForTxWithoutPermit'): TypedContractMethod<[
+    getFunction(nameOrSignature: 'decryptForTxWithoutACP'): TypedContractMethod<[
         ctHash: BigNumberish
     ], [
         [
@@ -2788,7 +3683,7 @@ interface MockThresholdNetwork extends BaseContract {
     getFunction(nameOrSignature: 'queryDecrypt'): TypedContractMethod<[
         ctHash: BigNumberish,
         arg1: BigNumberish,
-        permission: PermissionStruct
+        acp: ACPStruct
     ], [
         [boolean, string, bigint] & {
             allowed: boolean;
@@ -2798,7 +3693,7 @@ interface MockThresholdNetwork extends BaseContract {
     getFunction(nameOrSignature: 'querySealOutput'): TypedContractMethod<[
         ctHash: BigNumberish,
         arg1: BigNumberish,
-        permission: PermissionStruct
+        acp: ACPStruct
     ], [
         [boolean, string, string] & {
             allowed: boolean;
@@ -2928,4 +3823,4 @@ interface MockZkVerifier extends BaseContract {
     filters: {};
 }
 
-export { 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 MockTaskManager, MockTaskManagerArtifact, type MockThresholdNetwork, MockThresholdNetworkArtifact, type MockZkVerifier, MockZkVerifierArtifact };