@cofhe/sdk 0.6.0 → 0.7.0

package/dist/{clientTypes-BDy1qIBu.d.cts → clientTypes-CYZjFznO.d.cts}

@@ -1,7 +1,7 @@
 import { WalletClient, PublicClient, Hex } from 'viem';
 import { C as CofheChain } from './types-C07FK-cL.cjs';
 import { z } from 'zod';
-import { P as Permit, S as SerializedPermit, C as CreateSelfPermitOptions, m as SelfPermit, d as CreateSharingPermitOptions, n as SharingPermit, I as ImportSharedPermitOptions, R as RecipientPermit, o as PermitHashFields, g as PermitUtils } from './permit-DnVMDT5h.cjs';
+import { A as ACP, h as EIP712Domain, C as CreateSelfACPOptions, p as SelfACP, d as CreateSharingACPOptions, q as SharingACP, I as ImportSharedACPOptions, R as RecipientACP, v as ACPHashFields, S as SerializedACP, g as IncomingShare, i as ACPUtils } from './acp-Wi6isVQI.cjs';
 import { StoreApi } from 'zustand/vanilla';
 
 type TfheInitializer = () => Promise<boolean>;
@@ -59,34 +59,6 @@ type EncryptedNumber = {
     data: Uint8Array;
     securityZone: number;
 };
-type EncryptedItemInput = {
-    ctHash: bigint;
-    securityZone: number;
-    utype: FheTypes;
-    signature: `0x${string}`;
-};
-declare function assertCorrectEncryptedItemInput(input: EncryptedItemInput): asserts input is EncryptedItemInput;
-type EncryptedBoolInput = EncryptedItemInput & {
-    utype: FheTypes.Bool;
-};
-type EncryptedUint8Input = EncryptedItemInput & {
-    utype: FheTypes.Uint8;
-};
-type EncryptedUint16Input = EncryptedItemInput & {
-    utype: FheTypes.Uint16;
-};
-type EncryptedUint32Input = EncryptedItemInput & {
-    utype: FheTypes.Uint32;
-};
-type EncryptedUint64Input = EncryptedItemInput & {
-    utype: FheTypes.Uint64;
-};
-type EncryptedUint128Input = EncryptedItemInput & {
-    utype: FheTypes.Uint128;
-};
-type EncryptedAddressInput = EncryptedItemInput & {
-    utype: FheTypes.Uint160;
-};
 type EncryptableBase<U extends FheTypes, D> = {
     data: D;
     securityZone: number;
@@ -146,10 +118,6 @@ declare const Encryptable: {
     };
 };
 type EncryptableItem = EncryptableBool | EncryptableUint8 | EncryptableUint16 | EncryptableUint32 | EncryptableUint64 | EncryptableUint128 | EncryptableAddress;
-type EncryptableToEncryptedItemInputMap<E extends EncryptableItem> = E extends EncryptableBool ? EncryptedBoolInput : E extends EncryptableUint8 ? EncryptedUint8Input : E extends EncryptableUint16 ? EncryptedUint16Input : E extends EncryptableUint32 ? EncryptedUint32Input : E extends EncryptableUint64 ? EncryptedUint64Input : E extends EncryptableUint128 ? EncryptedUint128Input : E extends EncryptableAddress ? EncryptedAddressInput : never;
-type EncryptedItemInputs<T> = T extends Primitive ? LiteralToPrimitive<T> : T extends EncryptableItem ? EncryptableToEncryptedItemInputMap<T> : {
-    [K in keyof T]: EncryptedItemInputs<T[K]>;
-};
 declare function isEncryptableItem(value: unknown): value is EncryptableItem;
 declare enum EncryptStep {
     InitTfhe = "initTfhe",
@@ -190,7 +158,12 @@ type ExternalUint128Hash = `0x${string}` & {
 type ExternalAddressHash = `0x${string}` & {
     readonly utype: FheTypes.Uint160;
 };
-/** Branded bytes proof blob (Solidity: bytes memory proof). */
+/**
+ * Branded batch signature (Solidity: bytes memory signature).
+ * A single ECDSA signature (65-byte r||s||v, hex-encoded) authenticating an entire batch of
+ * ciphertexts at once — it covers keccak256(h_0 || h_1 || ... || h_n), where each h_i is the
+ * per-ciphertext message hash for the corresponding ExternalItemHashes entry, in order.
+ */
 type ExternalHashProof = `0x${string}` & {
     readonly _kind: 'ExternalHashProof';
 };
@@ -198,7 +171,6 @@ type ExternalHashProof = `0x${string}` & {
 type AnyExternalHash = ExternalBoolHash | ExternalUint8Hash | ExternalUint16Hash | ExternalUint32Hash | ExternalUint64Hash | ExternalUint128Hash | ExternalAddressHash;
 /**
  * Maps a single EncryptableItem to its corresponding External*Hash type.
- * Mirrors EncryptableToEncryptedItemInputMap.
  */
 type EncryptableToExternalHashMap<E extends EncryptableItem> = E extends EncryptableBool ? ExternalBoolHash : E extends EncryptableUint8 ? ExternalUint8Hash : E extends EncryptableUint16 ? ExternalUint16Hash : E extends EncryptableUint32 ? ExternalUint32Hash : E extends EncryptableUint64 ? ExternalUint64Hash : E extends EncryptableUint128 ? ExternalUint128Hash : E extends EncryptableAddress ? ExternalAddressHash : never;
 /**
@@ -209,8 +181,9 @@ type ExternalItemHashes<T extends EncryptableItem[]> = {
     [K in keyof T]: T[K] extends EncryptableItem ? EncryptableToExternalHashMap<T[K]> : never;
 };
 /**
- * Return type of EncryptInputsBuilder.execute() when asHashPlusProof() is set.
- * Tuple of per-input hashes in input order, followed by a single proof blob.
+ * Return type of EncryptInputsBuilder.execute().
+ * Tuple of per-input hashes in input order, followed by the single batch signature that
+ * authenticates all of them together.
  * e.g. [Encryptable.bool(true), Encryptable.uint32(5)] → [ExternalBoolHash, ExternalUint32Hash, ExternalHashProof]
  */
 type HashPlusProofResult<T extends EncryptableItem[]> = [...ExternalItemHashes<T>, ExternalHashProof];
@@ -242,8 +215,8 @@ type CofheConfig = {
     environment: 'node' | 'hardhat' | 'web' | 'react';
     /** List of supported chains */
     supportedChains: CofheChain[];
-    /** Default permit expiration in seconds, default is 30 days */
-    defaultPermitExpiration: number;
+    /** Default acp expiration in seconds, default is 30 days */
+    defaultACPExpiration: number;
     /**
      * Storage scheme for the fetched fhe keys
      * FHE keys are large, and caching prevents re-fetching them on each encryptInputs call
@@ -256,6 +229,32 @@ type CofheConfig = {
      * Default: true
      */
     useWorkers: boolean;
+    /** ACP acp defaults, applied when creating acps (user options always win) */
+    acp: {
+        /**
+         * Default revoker contract per chainId — an explicit override; when unset,
+         * the address served by the chain's ACL (`defaultRevokerContract()`) is
+         * used. When available, created acps are revocable by default:
+         * revokerContract = this address and revokerData = acp creation
+         * timestamp (interpreted by the default timestamp revoker; enables
+         * revokeSingle + O(1) revokeAll).
+         */
+        defaultRevoker?: Record<number, `0x${string}`>;
+        /**
+         * Default contract scopes per chainId, injected into created acps'
+         * `contracts` when the caller doesn't provide scope options.
+         * Note: injecting scopes makes created acps non-global by default.
+         */
+        defaultContractScopes?: Record<number, `0x${string}`[]>;
+        /**
+         * ACPShareRegistry address per chainId — the on-chain hand-off for sharing
+         * ACPs. An explicit override; when unset, the address served by the
+         * chain's ACL (`shareRegistry()`) is used. client.acp.shareOnChain /
+         * getIncomingShares / importFromChain throw MissingConfig when neither
+         * names a registry.
+         */
+        sharingRegistry?: Record<number, `0x${string}`>;
+    };
     /** Mocks configs */
     mocks: {
         /**
@@ -304,13 +303,18 @@ declare const CofheConfigSchema: z.ZodObject<{
         thresholdNetworkUrl: string;
         environment: "MOCK" | "TESTNET" | "MAINNET";
     }>>;
-    defaultPermitExpiration: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    defaultACPExpiration: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     fheKeyStorage: z.ZodDefault<z.ZodUnion<[z.ZodObject<{
         getItem: z.ZodCustom<(name: string) => Promise<any>, (name: string) => Promise<any>>;
         setItem: z.ZodCustom<(name: string, value: any) => Promise<void>, (name: string, value: any) => Promise<void>>;
         removeItem: z.ZodCustom<(name: string) => Promise<void>, (name: string) => Promise<void>>;
     }, z.core.$strip>, z.ZodNull]>>;
     useWorkers: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    acp: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        defaultRevoker: z.ZodOptional<z.ZodCustom<Record<number, `0x${string}`>, Record<number, `0x${string}`>>>;
+        defaultContractScopes: z.ZodOptional<z.ZodCustom<Record<number, `0x${string}`[]>, Record<number, `0x${string}`[]>>>;
+        sharingRegistry: z.ZodOptional<z.ZodCustom<Record<number, `0x${string}`>, Record<number, `0x${string}`>>>;
+    }, z.core.$strip>>>;
     mocks: z.ZodDefault<z.ZodOptional<z.ZodObject<{
         decryptDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         encryptDelay: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>>;
@@ -323,6 +327,11 @@ declare const CofheConfigSchema: z.ZodObject<{
  * Input config type inferred from the schema
  */
 type CofheInputConfig = z.input<typeof CofheConfigSchema>;
+/**
+ * Throws a migration-shaped error if any pre-ACP config key is present.
+ * @throws {Error} Naming each stale key and its replacement.
+ */
+declare function assertNoRenamedConfigKeys(config: object, renamedKeys: Record<string, string>, label: string): void;
 /**
  * Creates and validates a cofhe configuration (base implementation)
  * @param config - The configuration object to validate
@@ -394,36 +403,36 @@ declare abstract class BaseBuilder {
  * await client.decryptForView(ctHash, utype)
  *   .setChainId(chainId)
  *   .setAccount(account)
- *   .withPermit()              // optional (active permit)
- *   // or .withPermit(permitHash) / .withPermit(permit)
+ *   .withACP()              // optional (active acp)
+ *   // or .withACP(acpHash) / .withACP(acp)
  *   .execute()
  *
  * If chainId not set, uses client's chainId
  * If account not set, uses client's account
- * withPermit() uses chainId + account to get the active permit.
- * withPermit(permitHash) fetches that permit using chainId + account.
- * withPermit(permit) uses the provided permit regardless of chainId/account.
+ * withACP() uses chainId + account to get the active acp.
+ * withACP(acpHash) fetches that acp using chainId + account.
+ * withACP(acp) uses the provided acp regardless of chainId/account.
  *
- * Note: decryptForView always requires a permit (no global-allowance mode).
+ * Note: decryptForView always requires an ACP (no global-allowance mode).
  *
  * Returns the unsealed item.
  */
 type DecryptForViewBuilderParams<U extends FheTypes> = BaseBuilderParams & {
     ctHash: bigint | string;
     utype: U;
-    permitHash?: string;
-    permit?: Permit;
+    acpHash?: string;
+    acp?: ACP;
 };
 declare class DecryptForViewBuilder<U extends FheTypes> extends BaseBuilder {
     private ctHash;
     private utype;
-    private permitHash?;
-    private permit?;
+    private acpHash?;
+    private acp?;
     private pollCallback?;
     private retry404TimeoutMs;
     constructor(params: DecryptForViewBuilderParams<U>);
     /**
-     * @param chainId - Chain to decrypt values from. Used to fetch the threshold network URL and use the correct permit.
+     * @param chainId - Chain to decrypt values from. Used to fetch the threshold network URL and use the correct acp.
      *
      * If not provided, the chainId will be fetched from the connected publicClient.
      *
@@ -439,7 +448,7 @@ declare class DecryptForViewBuilder<U extends FheTypes> extends BaseBuilder {
     setChainId(chainId: number): DecryptForViewBuilder<U>;
     getChainId(): number | undefined;
     /**
-     * @param account - Account to decrypt values from. Used to fetch the correct permit.
+     * @param account - Account to decrypt values from. Used to fetch the correct acp.
      *
      * If not provided, the account will be fetched from the connected walletClient.
      *
@@ -457,53 +466,53 @@ declare class DecryptForViewBuilder<U extends FheTypes> extends BaseBuilder {
     onPoll(callback: DecryptPollCallbackFunction): DecryptForViewBuilder<U>;
     set404RetryTimeout(timeoutMs: number): DecryptForViewBuilder<U>;
     /**
-     * Select "use permit" mode (optional).
+     * Select "use acp" mode (optional).
      *
-     * - `withPermit(permit)` uses the provided permit.
-     * - `withPermit(permitHash)` fetches that permit.
-     * - `withPermit()` uses the active permit for the resolved `chainId + account`.
+     * - `withACP(acp)` uses the provided acp.
+     * - `withACP(acpHash)` fetches that acp.
+     * - `withACP()` uses the active acp for the resolved `chainId + account`.
      */
-    withPermit(): DecryptForViewBuilder<U>;
-    withPermit(permitHash: string): DecryptForViewBuilder<U>;
-    withPermit(permit: Permit): DecryptForViewBuilder<U>;
+    withACP(): DecryptForViewBuilder<U>;
+    withACP(acpHash: string): DecryptForViewBuilder<U>;
+    withACP(acp: ACP): DecryptForViewBuilder<U>;
     /**
-     * @param permitHash - Permit hash to decrypt values from. Used to fetch the correct permit.
+     * @param acpHash - ACP hash to decrypt values from. Used to fetch the correct acp.
      *
-     * If not provided, the active permit for the chainId and account will be used.
-     * If `setPermit()` is called, it will be used regardless of chainId, account, or permitHash.
+     * If not provided, the active acp for the chainId and account will be used.
+     * If `setACP()` is called, it will be used regardless of chainId, account, or acpHash.
      *
      * Example:
      * ```typescript
      * const unsealed = await client.decryptForView(ctHash, utype)
-     *   .setPermitHash('0x1234567890123456789012345678901234567890')
+     *   .setACPHash('0x1234567890123456789012345678901234567890')
      *   .execute();
      * ```
      *
      * @returns The chainable DecryptForViewBuilder instance.
      */
-    /** @deprecated Use `withPermit(permitHash)` instead. */
-    setPermitHash(permitHash: string): DecryptForViewBuilder<U>;
-    getPermitHash(): string | undefined;
+    /** @deprecated Use `withACP(acpHash)` instead. */
+    setACPHash(acpHash: string): DecryptForViewBuilder<U>;
+    getACPHash(): string | undefined;
     /**
-     * @param permit - Permit to decrypt values with. If provided, it will be used regardless of chainId, account, or permitHash.
+     * @param acp - ACP to decrypt values with. If provided, it will be used regardless of chainId, account, or acpHash.
      *
-     * If not provided, the permit will be determined by chainId, account, and permitHash.
+     * If not provided, the acp will be determined by chainId, account, and acpHash.
      *
      * Example:
      * ```typescript
      * const unsealed = await client.decryptForView(ctHash, utype)
-     *   .setPermit(permit)
+     *   .setACP(acp)
      *   .execute();
      * ```
      *
      * @returns The chainable DecryptForViewBuilder instance.
      */
-    /** @deprecated Use `withPermit(permit)` instead. */
-    setPermit(permit: Permit): DecryptForViewBuilder<U>;
-    getPermit(): Permit | undefined;
+    /** @deprecated Use `withACP(acp)` instead. */
+    setACP(acp: ACP): DecryptForViewBuilder<U>;
+    getACP(): ACP | undefined;
     private getThresholdNetworkUrl;
     private validateUtypeOrThrow;
-    private getResolvedPermit;
+    private getResolvedACP;
     /**
      * On hardhat, interact with MockZkVerifier contract instead of CoFHE
      */
@@ -516,10 +525,10 @@ declare class DecryptForViewBuilder<U extends FheTypes> extends BaseBuilder {
      * Final step of the decryption process. MUST BE CALLED LAST IN THE CHAIN.
      *
      * This will:
-     * - Use a permit based on provided permit OR chainId + account + permitHash
-     * - Check permit validity
-     * - Call CoFHE `/sealoutput` with the permit, which returns a sealed (encrypted) item
-     * - Unseal the sealed item with the permit
+     * - Use an ACP based on provided acp OR chainId + account + acpHash
+     * - Check acp validity
+     * - Call CoFHE `/sealoutput` with the acp, which returns a sealed (encrypted) item
+     * - Unseal the sealed item with the acp
      * - Return the unsealed item
      *
      * Example:
@@ -527,7 +536,7 @@ declare class DecryptForViewBuilder<U extends FheTypes> extends BaseBuilder {
      * const unsealed = await client.decryptForView(ctHash, utype)
      *   .setChainId(11155111)      // optional
      *   .setAccount('0x123...890') // optional
-     *   .withPermit()              // optional
+     *   .withACP()              // optional
      *   .execute();                // execute
      * ```
      *
@@ -547,21 +556,21 @@ type DecryptForTxResult = {
 /**
  * Type-level gating:
  * - The initial builder returned from `client.decryptForTx(...)` intentionally does not expose `execute()`.
- * - Calling `withPermit(...)` or `withoutPermit()` returns a builder that *does* expose `execute()`, but no longer
- *   exposes `withPermit/withoutPermit` (so you can't select twice, or switch modes).
+ * - Calling `withACP(...)` or `withoutACP()` returns a builder that *does* expose `execute()`, but no longer
+ *   exposes `withACP/withoutACP` (so you can't select twice, or switch modes).
  */
 type DecryptForTxBuilderUnset = Omit<DecryptForTxBuilder, 'execute'>;
-type DecryptForTxBuilderSelected = Omit<DecryptForTxBuilder, 'withPermit' | 'withoutPermit'>;
+type DecryptForTxBuilderSelected = Omit<DecryptForTxBuilder, 'withACP' | 'withoutACP'>;
 declare class DecryptForTxBuilder extends BaseBuilder {
     private ctHash;
-    private permitHash?;
-    private permit?;
-    private permitSelection;
+    private acpHash?;
+    private acp?;
+    private acpSelection;
     private pollCallback?;
     private retry404TimeoutMs;
     constructor(params: DecryptForTxBuilderParams);
     /**
-     * @param chainId - Chain to decrypt values from. Used to fetch the threshold network URL and use the correct permit.
+     * @param chainId - Chain to decrypt values from. Used to fetch the threshold network URL and use the correct acp.
      *
      * If not provided, the chainId will be fetched from the connected publicClient.
      *
@@ -578,7 +587,7 @@ declare class DecryptForTxBuilder extends BaseBuilder {
     setChainId(this: DecryptForTxBuilderSelected, chainId: number): DecryptForTxBuilderSelected;
     getChainId(): number | undefined;
     /**
-     * @param account - Account to decrypt values from. Used to fetch the correct permit.
+     * @param account - Account to decrypt values from. Used to fetch the correct acp.
      *
      * If not provided, the account will be fetched from the connected walletClient.
      *
@@ -599,27 +608,27 @@ declare class DecryptForTxBuilder extends BaseBuilder {
     set404RetryTimeout(this: DecryptForTxBuilderUnset, timeoutMs: number): DecryptForTxBuilderUnset;
     set404RetryTimeout(this: DecryptForTxBuilderSelected, timeoutMs: number): DecryptForTxBuilderSelected;
     /**
-     * Select "use permit" mode.
+     * Select "use acp" mode.
      *
-     * - `withPermit(permit)` uses the provided permit.
-     * - `withPermit(permitHash)` fetches that permit.
-     * - `withPermit()` uses the active permit for the resolved `chainId + account`.
+     * - `withACP(acp)` uses the provided acp.
+     * - `withACP(acpHash)` fetches that acp.
+     * - `withACP()` uses the active acp for the resolved `chainId + account`.
      *
-     * Note: "global allowance" (no permit) is ONLY available via `withoutPermit()`.
+     * Note: "global allowance" (no acp) is ONLY available via `withoutACP()`.
      */
-    withPermit(): DecryptForTxBuilderSelected;
-    withPermit(permitHash: string): DecryptForTxBuilderSelected;
-    withPermit(permit: Permit): DecryptForTxBuilderSelected;
+    withACP(): DecryptForTxBuilderSelected;
+    withACP(acpHash: string): DecryptForTxBuilderSelected;
+    withACP(acp: ACP): DecryptForTxBuilderSelected;
     /**
-     * Select "no permit" mode.
+     * Select "no acp" mode.
      *
-     * This uses global allowance (no permit required) and sends an empty permission payload to `/decrypt`.
+     * This uses global allowance (no acp required) and sends an empty permission payload to `/decrypt`.
      */
-    withoutPermit(): DecryptForTxBuilderSelected;
-    getPermit(): Permit | undefined;
-    getPermitHash(): string | undefined;
+    withoutACP(): DecryptForTxBuilderSelected;
+    getACP(): ACP | undefined;
+    getACPHash(): string | undefined;
     private getThresholdNetworkUrl;
-    private getResolvedPermit;
+    private getResolvedACP;
     /**
      * On hardhat, interact with MockThresholdNetwork contract
      */
@@ -631,9 +640,9 @@ declare class DecryptForTxBuilder extends BaseBuilder {
     /**
      * Final step of the decryptForTx process. MUST BE CALLED LAST IN THE CHAIN.
      *
-     * You must explicitly choose one permit mode before calling `execute()`:
-     * - `withPermit(permit)` / `withPermit(permitHash)` / `withPermit()` (active permit)
-     * - `withoutPermit()` (global allowance)
+     * You must explicitly choose one acp mode before calling `execute()`:
+     * - `withACP(acp)` / `withACP(acpHash)` / `withACP()` (active acp)
+     * - `withoutACP()` (global allowance)
      */
     execute(): Promise<DecryptForTxResult>;
 }
@@ -751,11 +760,19 @@ type EncryptInputsBuilderParams<T extends EncryptableItem[]> = BaseBuilderParams
  * account, securityZone, and chainId can be overridden in the builder.
  * config, tfhePublicKeyDeserializer, compactPkeCrsDeserializer, and zkBuilderAndCrsGenerator are required to be set in the builder.
  */
-declare class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends boolean = false> extends BaseBuilder {
+/**
+ * The builder as returned by `client.encryptInputs(...)`, before a consuming contract has been set.
+ *
+ * `execute()` is intentionally absent: the verifier binds the consuming contract into the signed
+ * digest, so no batch can be produced until the caller commits to the contract that will consume it.
+ * `setConsumingContract(...)` returns the full {@link EncryptInputsBuilder}, unlocking `execute()`.
+ */
+type EncryptInputsBuilderUnset<T extends EncryptableItem[]> = Omit<EncryptInputsBuilder<T>, 'execute'>;
+declare class EncryptInputsBuilder<T extends EncryptableItem[]> extends BaseBuilder {
     private securityZone;
+    protected consumingContract: string | undefined;
     private stepCallback?;
     private inputItems;
-    private hpp;
     private zkvWalletClient;
     private tfhePublicKeyDeserializer;
     private compactPkeCrsDeserializer;
@@ -780,7 +797,8 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends bool
      *
      * @returns The chainable EncryptInputsBuilder instance.
      */
-    setAccount(account: string): EncryptInputsBuilder<T, HPP>;
+    setAccount(this: EncryptInputsBuilder<T>, account: string): EncryptInputsBuilder<T>;
+    setAccount(this: EncryptInputsBuilderUnset<T>, account: string): EncryptInputsBuilderUnset<T>;
     getAccount(): string | undefined;
     /**
      * @param chainId - Chain that will consume the encrypted inputs.
@@ -796,7 +814,8 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends bool
      *
      * @returns The chainable EncryptInputsBuilder instance.
      */
-    setChainId(chainId: number): EncryptInputsBuilder<T, HPP>;
+    setChainId(this: EncryptInputsBuilder<T>, chainId: number): EncryptInputsBuilder<T>;
+    setChainId(this: EncryptInputsBuilderUnset<T>, chainId: number): EncryptInputsBuilderUnset<T>;
     getChainId(): number | undefined;
     /**
      * @param securityZone - Security zone to encrypt the inputs for.
@@ -812,19 +831,32 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends bool
      *
      * @returns The chainable EncryptInputsBuilder instance.
      */
-    setSecurityZone(securityZone: number): EncryptInputsBuilder<T, HPP>;
+    setSecurityZone(this: EncryptInputsBuilder<T>, securityZone: number): EncryptInputsBuilder<T>;
+    setSecurityZone(this: EncryptInputsBuilderUnset<T>, securityZone: number): EncryptInputsBuilderUnset<T>;
     getSecurityZone(): number;
     /**
+     * @param address - The contract that will consume the resulting hashes+signature (i.e. the
+     * contract that will call `FHE.asEuint*`/`FHE.asEuint*s` with them).
+     *
+     * Required before `execute()` - the verifier binds this address into the signed digest, so a
+     * batch signed for one contract cannot be replayed into another.
+     *
      * Example:
      * ```typescript
      * const encrypted = await encryptInputs([Encryptable.uint128(10n)])
-     *   .asHashPlusProof()
+     *   .setConsumingContract("0x123...890")
      *   .execute();
      * ```
      *
-     * @returns Chainable EncryptInputsBuilder instance that will return a HashPlusProofResult instead of an array of EncryptedItemInputs.
+     * @returns The chainable EncryptInputsBuilder instance.
+     */
+    setConsumingContract(address: string): EncryptInputsBuilder<T>;
+    getConsumingContract(): string | undefined;
+    /**
+     * Asserts that this.consumingContract is populated
+     * @throws {CofheError} If consumingContract is not set
      */
-    asHashPlusProof(): EncryptInputsBuilder<T, true>;
+    private assertConsumingContract;
     /**
      * @param useWorker - Whether to use Web Workers for ZK proof generation.
      *
@@ -839,7 +871,8 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends bool
      *
      * @returns The chainable EncryptInputsBuilder instance.
      */
-    setUseWorker(useWorker: boolean): EncryptInputsBuilder<T, HPP>;
+    setUseWorker(this: EncryptInputsBuilder<T>, useWorker: boolean): EncryptInputsBuilder<T>;
+    setUseWorker(this: EncryptInputsBuilderUnset<T>, useWorker: boolean): EncryptInputsBuilderUnset<T>;
     /**
      * Gets the current worker configuration.
      *
@@ -869,7 +902,8 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends bool
      *
      * @returns The EncryptInputsBuilder instance.
      */
-    onStep(callback: EncryptStepCallbackFunction): EncryptInputsBuilder<T, HPP>;
+    onStep(this: EncryptInputsBuilder<T>, callback: EncryptStepCallbackFunction): EncryptInputsBuilder<T>;
+    onStep(this: EncryptInputsBuilderUnset<T>, callback: EncryptStepCallbackFunction): EncryptInputsBuilderUnset<T>;
     getStepCallback(): EncryptStepCallbackFunction | undefined;
     /**
      * Fires the step callback if set
@@ -910,7 +944,11 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends bool
      * In the production context, perform a true encryption with the CoFHE coprocessor.
      */
     private productionExecute;
-    private structsToHashPlusProof;
+    /**
+     * Converts a batch-verified result (per-item ctHash/ctType + one shared signature) into the
+     * tuple returned by `execute()`: per-item hashes in input order, followed by the single signature.
+     */
+    private buildBatchResult;
     /**
      * Final step of the encryption process. MUST BE CALLED LAST IN THE CHAIN.
      *
@@ -930,67 +968,189 @@ declare class EncryptInputsBuilder<T extends EncryptableItem[], HPP extends bool
      *
      * @returns The encrypted inputs.
      */
-    execute(): Promise<HPP extends true ? HashPlusProofResult<T> : [...EncryptedItemInputs<T>]>;
+    execute(): Promise<HashPlusProofResult<T>>;
 }
 
-declare const permits: {
+interface AclServedAddresses {
+    defaultRevoker?: Hex;
+    shareRegistry?: Hex;
+}
+declare const acps: {
     getSnapshot: () => {
-        permits: {
+        acps: {
             [x: number]: {
                 [x: string]: {
-                    [x: string]: SerializedPermit | undefined;
+                    [x: string]: {
+                        hash: string;
+                        name: string;
+                        type: "self" | "sharing" | "recipient";
+                        sealingPrivateKey: Hex;
+                        _signedDomain?: EIP712Domain | undefined;
+                        issuer: Hex;
+                        expiration: number;
+                        recipient: Hex;
+                        revokerData: number;
+                        revokerContract: Hex;
+                        scope: number;
+                        contracts: Hex[];
+                        handles: Hex[];
+                        sealingKey: Hex;
+                        issuerSignature: Hex;
+                        recipientSignature: Hex;
+                    } | undefined;
                 };
             };
         };
-        activePermitHash: {
+        activeACPHash: {
             [x: number]: {
                 [x: string]: string | undefined;
             };
         };
     };
     subscribe: (listener: (state: {
-        permits: {
+        acps: {
             [x: number]: {
                 [x: string]: {
-                    [x: string]: SerializedPermit | undefined;
+                    [x: string]: {
+                        hash: string;
+                        name: string;
+                        type: "self" | "sharing" | "recipient";
+                        sealingPrivateKey: Hex;
+                        _signedDomain?: EIP712Domain | undefined;
+                        issuer: Hex;
+                        expiration: number;
+                        recipient: Hex;
+                        revokerData: number;
+                        revokerContract: Hex;
+                        scope: number;
+                        contracts: Hex[];
+                        handles: Hex[];
+                        sealingKey: Hex;
+                        issuerSignature: Hex;
+                        recipientSignature: Hex;
+                    } | undefined;
                 };
             };
         };
-        activePermitHash: {
+        activeACPHash: {
             [x: number]: {
                 [x: string]: string | undefined;
             };
         };
     }, prevState: {
-        permits: {
+        acps: {
             [x: number]: {
                 [x: string]: {
-                    [x: string]: SerializedPermit | undefined;
+                    [x: string]: {
+                        hash: string;
+                        name: string;
+                        type: "self" | "sharing" | "recipient";
+                        sealingPrivateKey: Hex;
+                        _signedDomain?: EIP712Domain | undefined;
+                        issuer: Hex;
+                        expiration: number;
+                        recipient: Hex;
+                        revokerData: number;
+                        revokerContract: Hex;
+                        scope: number;
+                        contracts: Hex[];
+                        handles: Hex[];
+                        sealingKey: Hex;
+                        issuerSignature: Hex;
+                        recipientSignature: Hex;
+                    } | undefined;
                 };
             };
         };
-        activePermitHash: {
+        activeACPHash: {
             [x: number]: {
                 [x: string]: string | undefined;
             };
         };
     }) => void) => () => void;
-    createSelf: (options: CreateSelfPermitOptions, publicClient: PublicClient, walletClient: WalletClient) => Promise<SelfPermit>;
-    createSharing: (options: CreateSharingPermitOptions, publicClient: PublicClient, walletClient: WalletClient) => Promise<SharingPermit>;
-    importShared: (options: ImportSharedPermitOptions | string, publicClient: PublicClient, walletClient: WalletClient) => Promise<RecipientPermit>;
-    getOrCreateSelfPermit: (publicClient: PublicClient, walletClient: WalletClient, chainId?: number, account?: string, options?: CreateSelfPermitOptions) => Promise<Permit>;
-    getOrCreateSharingPermit: (publicClient: PublicClient, walletClient: WalletClient, options: CreateSharingPermitOptions, chainId?: number, account?: string) => Promise<Permit>;
-    getHash: (permit: PermitHashFields) => string;
-    export: (permit: Permit) => string;
-    serialize: (permit: Permit) => SerializedPermit;
-    deserialize: (serialized: SerializedPermit) => Permit;
-    getPermit: (chainId: number, account: string, hash: string) => Permit | undefined;
-    getPermits: (chainId: number, account: string) => Record<string, Permit>;
-    getActivePermit: (chainId: number, account: string) => Permit | undefined;
-    getActivePermitHash: (chainId: number, account: string) => string | undefined;
-    removePermit: (chainId: number, account: string, hash: string) => Promise<void>;
-    selectActivePermit: (chainId: number, account: string, hash: string) => void;
-    removeActivePermit: (chainId: number, account: string) => Promise<void>;
+    createSelf: (options: CreateSelfACPOptions, publicClient: PublicClient, walletClient: WalletClient) => Promise<SelfACP>;
+    createSharing: (options: CreateSharingACPOptions, publicClient: PublicClient, walletClient: WalletClient) => Promise<SharingACP>;
+    importShared: (options: ImportSharedACPOptions | string, publicClient: PublicClient, walletClient: WalletClient) => Promise<RecipientACP>;
+    getOrCreateSelfACP: (publicClient: PublicClient, walletClient: WalletClient, chainId?: number, account?: string, options?: CreateSelfACPOptions) => Promise<ACP>;
+    getOrCreateSharingACP: (publicClient: PublicClient, walletClient: WalletClient, options: CreateSharingACPOptions, chainId?: number, account?: string) => Promise<ACP>;
+    getHash: (acp: ACPHashFields) => string;
+    export: (acp: ACP) => string;
+    serialize: (acp: ACP) => {
+        hash: string;
+        name: string;
+        type: "self" | "sharing" | "recipient";
+        sealingPrivateKey: Hex;
+        _signedDomain?: EIP712Domain | undefined;
+        issuer: Hex;
+        expiration: number;
+        recipient: Hex;
+        revokerData: number;
+        revokerContract: Hex;
+        scope: number;
+        contracts: Hex[];
+        handles: Hex[];
+        sealingKey: Hex;
+        issuerSignature: Hex;
+        recipientSignature: Hex;
+    };
+    deserialize: (serialized: SerializedACP) => {
+        hash: string;
+        name: string;
+        type: "self" | "sharing" | "recipient";
+        sealingPrivateKey: Hex;
+        _signedDomain?: EIP712Domain | undefined;
+        issuer: Hex;
+        expiration: number;
+        recipient: Hex;
+        revokerData: number;
+        revokerContract: Hex;
+        scope: number;
+        contracts: Hex[];
+        handles: Hex[];
+        sealingKey: Hex;
+        issuerSignature: Hex;
+        recipientSignature: Hex;
+    };
+    getACP: (chainId: number, account: string, hash: string) => ACP | undefined;
+    getACPs: (chainId: number, account: string) => Record<string, ACP>;
+    getActiveACP: (chainId: number, account: string) => ACP | undefined;
+    getActiveACPHash: (chainId: number, account: string) => string | undefined;
+    removeACP: (chainId: number, account: string, hash: string) => Promise<void>;
+    selectActiveACP: (chainId: number, account: string, hash: string) => void;
+    removeActiveACP: (chainId: number, account: string) => Promise<void>;
+    revokeACP: (acp: ACP, walletClient: WalletClient) => Promise<Hex>;
+    revokeAllACPs: (walletClient: WalletClient, publicClient: PublicClient, revokerContract?: Hex) => Promise<Hex>;
+    isACPRevoked: (acp: ACP, publicClient: PublicClient) => Promise<boolean>;
+    shareOnChain: (acp: ACP, walletClient: WalletClient, registry: Hex) => Promise<{
+        txHash: Hex;
+        shareId: Hex;
+    }>;
+    getIncomingShares: (publicClient: PublicClient, registry: Hex, recipient: Hex) => Promise<IncomingShare[]>;
+    importFromChain: (share: IncomingShare, publicClient: PublicClient, walletClient: WalletClient) => Promise<RecipientACP>;
+    removeShareOnChain: (shareId: Hex, walletClient: WalletClient, registry: Hex) => Promise<Hex>;
+    computeShareId: (acp: ACP) => Hex;
+    applyACPDefaults: <T extends {
+        revokerData?: number;
+        revokerContract?: string;
+        scope?: number;
+        contracts?: string[];
+        handles?: (bigint | number | string)[];
+    }>(options: T, acpConfig: {
+        defaultRevoker?: Record<number, Hex>;
+        defaultContractScopes?: Record<number, Hex[]>;
+    } | undefined, chainId: number) => T;
+    applyACPDefaultsFromChain: <T extends {
+        revokerData?: number;
+        revokerContract?: string;
+        scope?: number;
+        contracts?: string[];
+        handles?: (bigint | number | string)[];
+    }>(options: T, acpConfig: {
+        defaultRevoker?: Record<number, Hex>;
+        defaultContractScopes?: Record<number, Hex[]>;
+    } | undefined, publicClient: PublicClient, chainId: number) => Promise<T>;
+    getAclServedAddresses: (publicClient: PublicClient, chainId: number) => Promise<AclServedAddresses>;
+    clearAclServedAddresses: () => void;
 };
 
 type CofheClient<TConfig extends CofheConfig = CofheConfig> = {
@@ -1004,13 +1164,13 @@ type CofheClient<TConfig extends CofheConfig = CofheConfig> = {
     /**
      * Clears the current connection state (account/chainId/clients) and marks the client as disconnected.
      *
-     * This does not delete persisted permits or stored FHE keys; it only resets the in-memory connection.
+     * This does not delete persisted acps or stored FHE keys; it only resets the in-memory connection.
      */
     disconnect(): void;
     /**
      * Types docstring
      */
-    encryptInputs<T extends EncryptableItem[]>(inputs: [...T]): EncryptInputsBuilder<[...T]>;
+    encryptInputs<T extends EncryptableItem[]>(inputs: [...T]): EncryptInputsBuilderUnset<[...T]>;
     /**
      * @deprecated Use `decryptForView` instead. Kept for backward compatibility.
      */
@@ -1018,7 +1178,8 @@ type CofheClient<TConfig extends CofheConfig = CofheConfig> = {
     decryptForView<U extends FheTypes>(ctHash: bigint | string, utype: U): DecryptForViewBuilder<U>;
     decryptForTx(ctHash: bigint | string): DecryptForTxBuilderUnset;
     verifyDecryptResult(handle: bigint | string, cleartext: bigint, signature: Hex): Promise<boolean>;
-    permits: CofheClientPermits;
+    /** ACP (Access Control Permission) management — create, share, revoke, select. */
+    acp: CofheClientACPs;
 };
 type CofheClientConnectionState = {
     connected: boolean;
@@ -1030,29 +1191,45 @@ type CofheClientConnectionState = {
     walletClient: WalletClient | undefined;
 };
 type Listener = (snapshot: CofheClientConnectionState) => void;
-type CofheClientPermitsClients = {
+type CofheClientACPsClients = {
     publicClient: PublicClient;
     walletClient: WalletClient;
 };
-type CofheClientPermits = {
-    getSnapshot: typeof permits.getSnapshot;
-    subscribe: typeof permits.subscribe;
-    createSelf: (options: CreateSelfPermitOptions, clients?: CofheClientPermitsClients) => Promise<SelfPermit>;
-    createSharing: (options: CreateSharingPermitOptions, clients?: CofheClientPermitsClients) => Promise<SharingPermit>;
-    importShared: (options: ImportSharedPermitOptions | string, clients?: CofheClientPermitsClients) => Promise<RecipientPermit>;
-    getPermit: (hash: string, chainId?: number, account?: string) => Permit | undefined;
-    getPermits: (chainId?: number, account?: string) => Record<string, Permit>;
-    getActivePermit: (chainId?: number, account?: string) => Permit | undefined;
-    getActivePermitHash: (chainId?: number, account?: string) => string | undefined;
-    getOrCreateSelfPermit: (chainId?: number, account?: string, options?: CreateSelfPermitOptions) => Promise<Permit>;
-    getOrCreateSharingPermit: (options: CreateSharingPermitOptions, chainId?: number, account?: string) => Promise<Permit>;
-    selectActivePermit: (hash: string, chainId?: number, account?: string) => void;
-    removePermit: (hash: string, chainId?: number, account?: string) => void;
-    removeActivePermit: (chainId?: number, account?: string) => void;
-    getHash: typeof PermitUtils.getHash;
-    export: typeof PermitUtils.export;
-    serialize: typeof PermitUtils.serialize;
-    deserialize: typeof PermitUtils.deserialize;
+type CofheClientACPs = {
+    getSnapshot: typeof acps.getSnapshot;
+    subscribe: typeof acps.subscribe;
+    createSelf: (options: CreateSelfACPOptions, clients?: CofheClientACPsClients) => Promise<SelfACP>;
+    createSharing: (options: CreateSharingACPOptions, clients?: CofheClientACPsClients) => Promise<SharingACP>;
+    importShared: (options: ImportSharedACPOptions | string, clients?: CofheClientACPsClients) => Promise<RecipientACP>;
+    getACP: (hash: string, chainId?: number, account?: string) => ACP | undefined;
+    getACPs: (chainId?: number, account?: string) => Record<string, ACP>;
+    getActiveACP: (chainId?: number, account?: string) => ACP | undefined;
+    getActiveACPHash: (chainId?: number, account?: string) => string | undefined;
+    getOrCreateSelfACP: (chainId?: number, account?: string, options?: CreateSelfACPOptions) => Promise<ACP>;
+    getOrCreateSharingACP: (options: CreateSharingACPOptions, chainId?: number, account?: string) => Promise<ACP>;
+    selectActiveACP: (hash: string, chainId?: number, account?: string) => void;
+    removeACP: (hash: string, chainId?: number, account?: string) => void;
+    removeActiveACP: (chainId?: number, account?: string) => void;
+    revokeACP: (acp: ACP) => Promise<`0x${string}`>;
+    revokeAllACPs: (revokerContract?: `0x${string}`) => Promise<`0x${string}`>;
+    isACPRevoked: (acp: ACP) => Promise<boolean>;
+    /** Post a signed sharing ACP to the on-chain share registry (ACL-served, or config `acp.sharingRegistry`). */
+    shareOnChain: (acp: ACP) => Promise<{
+        txHash: `0x${string}`;
+        shareId: `0x${string}`;
+    }>;
+    /** Importable shares addressed to the connected account (unexpired, not revoked). */
+    getIncomingShares: () => Promise<IncomingShare[]>;
+    /** Import a share read from the registry: sign as recipient, store and activate. */
+    importFromChain: (share: IncomingShare) => Promise<RecipientACP>;
+    /** Recipient-side: remove a share from the registry (after import, or to decline). */
+    dismissShare: (shareId: `0x${string}`) => Promise<`0x${string}`>;
+    /** Issuer-side: retract a pending share from the registry. */
+    cancelShare: (shareId: `0x${string}`) => Promise<`0x${string}`>;
+    getHash: typeof ACPUtils.getHash;
+    export: typeof ACPUtils.export;
+    serialize: typeof ACPUtils.serialize;
+    deserialize: typeof ACPUtils.deserialize;
 };
 type CofheClientParams<TConfig extends CofheConfig> = {
     config: TConfig;
@@ -1063,4 +1240,4 @@ type CofheClientParams<TConfig extends CofheConfig> = {
     zkProveWorkerFn?: ZkProveWorkerFunction;
 };
 
-export { Encryptable as $, type FheTypeValue as A, type ExternalBoolHash as B, type CofheInputConfig as C, type ExternalUint8Hash as D, type EncryptableItem as E, FheTypes as F, type ExternalUint16Hash as G, type ExternalUint32Hash as H, type IStorage as I, type ExternalUint64Hash as J, type ExternalUint128Hash as K, type LiteralToPrimitive as L, type ExternalAddressHash as M, type ExternalHashProof as N, type AnyExternalHash as O, type Primitive as P, type EncryptableToExternalHashMap as Q, type ExternalItemHashes as R, type HashPlusProofResult as S, type DecryptPollCallbackFunction as T, type UnsealedItem as U, type DecryptPollCallbackContext as V, type DecryptEndpoint as W, type EncryptStepCallbackFunction as X, type EncryptStepCallbackContext as Y, FheUintUTypes as Z, FheAllUTypes as _, type CofheConfig as a, isEncryptableItem as a0, EncryptStep as a1, isLastEncryptionStep as a2, assertCorrectEncryptedItemInput as a3, fetchKeys as a4, type FheKeyDeserializer as a5, createKeysStore as a6, type KeysStorage as a7, type KeysStore as a8, EncryptInputsBuilder as a9, DecryptForViewBuilder as aa, DecryptForTxBuilder as ab, type DecryptForTxResult as ac, type ZkBuilderAndCrsGenerator as ad, type ZkProveWorkerFunction as ae, type ZkProveWorkerRequest as af, type ZkProveWorkerResponse as ag, zkProveWithWorker as ah, type CofheClient as b, type CofheClientParams as c, type CofheClientConnectionState as d, createCofheConfigBase as e, type CofheInternalConfig as f, getCofheConfigItem as g, type CofheClientPermits as h, type EncryptableBool as i, type EncryptableUint8 as j, type EncryptableUint16 as k, type EncryptableUint32 as l, type EncryptableUint64 as m, type EncryptableUint128 as n, type EncryptableAddress as o, type EncryptedNumber as p, type EncryptedItemInput as q, type EncryptedBoolInput as r, type EncryptedUint8Input as s, type EncryptedUint16Input as t, type EncryptedUint32Input as u, type EncryptedUint64Input as v, type EncryptedUint128Input as w, type EncryptedAddressInput as x, type EncryptedItemInputs as y, type EncryptableToEncryptedItemInputMap as z };
+export { EncryptInputsBuilder as $, type AnyExternalHash as A, type EncryptableToExternalHashMap as B, type CofheInputConfig as C, type ExternalItemHashes as D, type EncryptableItem as E, FheTypes as F, type DecryptPollCallbackFunction as G, type HashPlusProofResult as H, type IStorage as I, type DecryptPollCallbackContext as J, type DecryptEndpoint as K, type LiteralToPrimitive as L, type EncryptStepCallbackFunction as M, type EncryptStepCallbackContext as N, FheUintUTypes as O, type Primitive as P, FheAllUTypes as Q, Encryptable as R, isEncryptableItem as S, EncryptStep as T, type UnsealedItem as U, isLastEncryptionStep as V, fetchKeys as W, type FheKeyDeserializer as X, createKeysStore as Y, type KeysStorage as Z, type KeysStore as _, type CofheConfig as a, type EncryptInputsBuilderUnset as a0, DecryptForViewBuilder as a1, DecryptForTxBuilder as a2, type DecryptForTxResult as a3, type ZkBuilderAndCrsGenerator as a4, type ZkProveWorkerFunction as a5, type ZkProveWorkerRequest as a6, type ZkProveWorkerResponse as a7, zkProveWithWorker as a8, type CofheClient as b, type CofheClientParams as c, type CofheClientConnectionState as d, createCofheConfigBase as e, assertNoRenamedConfigKeys as f, getCofheConfigItem as g, type CofheInternalConfig as h, type CofheClientACPs as i, type EncryptableBool as j, type EncryptableUint8 as k, type EncryptableUint16 as l, type EncryptableUint32 as m, type EncryptableUint64 as n, type EncryptableUint128 as o, type EncryptableAddress as p, type EncryptedNumber as q, type FheTypeValue as r, type ExternalBoolHash as s, type ExternalUint8Hash as t, type ExternalUint16Hash as u, type ExternalUint32Hash as v, type ExternalUint64Hash as w, type ExternalUint128Hash as x, type ExternalAddressHash as y, type ExternalHashProof as z };