@cofhe/sdk 0.6.0 → 0.7.0

package/core/test/submitRetry.test.ts

@@ -0,0 +1,182 @@
+import { describe, it, expect, vi } from 'vitest';
+import { classifySubmitResponse, throwIfSubmitRetryTimedOut } from '../decrypt/submitRetry.js';
+import { CofheError, CofheErrorCode } from '../error.js';
+
+const makeResponse = (opts: {
+  ok: boolean;
+  status: number;
+  statusText?: string;
+  json: () => Promise<unknown>;
+}): Response => {
+  return {
+    ok: opts.ok,
+    status: opts.status,
+    statusText: opts.statusText ?? '',
+    json: opts.json,
+  } as unknown as Response;
+};
+
+describe('classifySubmitResponse', () => {
+  it('classifies 204 as retryable without reading the body', async () => {
+    const json = vi.fn(async () => {
+      throw new Error('json() should not be called for 204');
+    });
+    const response = makeResponse({ ok: true, status: 204, json });
+
+    const result = await classifySubmitResponse({ response, fallbackErrorCode: CofheErrorCode.DecryptFailed });
+
+    expect(result).toEqual({ kind: 'retryable', status: 204 });
+    expect(json).not.toHaveBeenCalled();
+  });
+
+  it('classifies 200 as parse-json', async () => {
+    const response = makeResponse({ ok: true, status: 200, json: async () => ({}) });
+
+    const result = await classifySubmitResponse({ response, fallbackErrorCode: CofheErrorCode.DecryptFailed });
+
+    expect(result).toEqual({ kind: 'parse-json' });
+  });
+
+  it('classifies 404 with error=ct_not_found as retryable', async () => {
+    const response = makeResponse({
+      ok: false,
+      status: 404,
+      json: async () => ({ error: 'ct_not_found', error_message: 'ciphertext not indexed yet' }),
+    });
+
+    const result = await classifySubmitResponse({ response, fallbackErrorCode: CofheErrorCode.DecryptFailed });
+
+    expect(result).toEqual({ kind: 'retryable', status: 404, apiErrorMessage: 'ciphertext not indexed yet' });
+  });
+
+  it('classifies 404 with a different error code as retryable', async () => {
+    const response = makeResponse({
+      ok: false,
+      status: 404,
+      json: async () => ({ error: 'acp_denied', error_message: 'acp was rejected' }),
+    });
+
+    const result = await classifySubmitResponse({ response, fallbackErrorCode: CofheErrorCode.DecryptFailed });
+
+    expect(result).toEqual({
+      kind: 'retryable',
+      status: 404,
+      apiErrorMessage: 'acp was rejected',
+    });
+  });
+
+  it('classifies 404 with an unparsable body as retryable', async () => {
+    const response = makeResponse({
+      ok: false,
+      status: 404,
+      statusText: 'Not Found',
+      json: async () => {
+        throw new Error('not json');
+      },
+    });
+
+    const result = await classifySubmitResponse({ response, fallbackErrorCode: CofheErrorCode.DecryptFailed });
+
+    expect(result).toEqual({
+      kind: 'retryable',
+      status: 404,
+      apiErrorMessage: 'Not Found',
+    });
+  });
+
+  it('classifies other non-ok statuses as fatal with the mapped error code', async () => {
+    const response = makeResponse({
+      ok: false,
+      status: 500,
+      json: async () => ({ error: 'internal_error', error_message: 'decrypt task panicked' }),
+    });
+
+    const result = await classifySubmitResponse({ response, fallbackErrorCode: CofheErrorCode.SealOutputFailed });
+
+    expect(result).toEqual({
+      kind: 'fatal-http',
+      status: 500,
+      cofheErrorCode: CofheErrorCode.InternalError,
+      apiErrorCode: 'internal_error',
+      errorMessage: 'decrypt task panicked',
+    });
+  });
+});
+
+describe('throwIfSubmitRetryTimedOut', () => {
+  const baseParams = {
+    operationLabel: 'decrypt',
+    errorCode: CofheErrorCode.DecryptFailed,
+    thresholdNetworkUrl: 'http://threshold.local',
+    body: { some: 'body' },
+    attemptIndex: 3,
+  };
+
+  it('does not throw when under both budgets', () => {
+    expect(() =>
+      throwIfSubmitRetryTimedOut({
+        ...baseParams,
+        status: 204,
+        elapsedMs: 1000,
+        retry404TimeoutMs: 10_000,
+        overallTimeoutMs: 300_000,
+      })
+    ).not.toThrow();
+  });
+
+  it('throws CtNotFound with the last-known message once the 404 retry budget elapses', () => {
+    try {
+      throwIfSubmitRetryTimedOut({
+        ...baseParams,
+        status: 404,
+        elapsedMs: 10_001,
+        retry404TimeoutMs: 10_000,
+        overallTimeoutMs: 300_000,
+        lastKnownErrorMessage: 'ciphertext not indexed yet',
+      });
+      expect.fail('expected throwIfSubmitRetryTimedOut to throw');
+    } catch (error) {
+      expect(error).toBeInstanceOf(CofheError);
+      const cofheError = error as CofheError;
+      expect(cofheError.code).toBe(CofheErrorCode.CtNotFound);
+      expect(cofheError.apiErrorCode).toBe('ct_not_found');
+      expect(cofheError.message).toBe(
+        'decrypt ciphertext not found after retrying for 10000ms: ciphertext not indexed yet'
+      );
+    }
+  });
+
+  it('omits the trailing message when no lastKnownErrorMessage is available', () => {
+    try {
+      throwIfSubmitRetryTimedOut({
+        ...baseParams,
+        status: 404,
+        elapsedMs: 10_001,
+        retry404TimeoutMs: 10_000,
+        overallTimeoutMs: 300_000,
+      });
+      expect.fail('expected throwIfSubmitRetryTimedOut to throw');
+    } catch (error) {
+      const cofheError = error as CofheError;
+      expect(cofheError.message).toBe('decrypt ciphertext not found after retrying for 10000ms');
+    }
+  });
+
+  it('throws the generic operation error once the overall timeout elapses (204)', () => {
+    try {
+      throwIfSubmitRetryTimedOut({
+        ...baseParams,
+        status: 204,
+        elapsedMs: 300_001,
+        retry404TimeoutMs: 10_000,
+        overallTimeoutMs: 300_000,
+      });
+      expect.fail('expected throwIfSubmitRetryTimedOut to throw');
+    } catch (error) {
+      const cofheError = error as CofheError;
+      expect(cofheError.code).toBe(CofheErrorCode.DecryptFailed);
+      expect(cofheError.apiErrorCode).toBeUndefined();
+      expect(cofheError.message).toBe('decrypt submit retried without receiving request_id for 300000ms');
+    }
+  });
+});

package/core/types.ts

@@ -111,43 +111,6 @@ export type EncryptedNumber = {
   securityZone: number;
 };
 
-export type EncryptedItemInput = {
-  ctHash: bigint;
-  securityZone: number;
-  utype: FheTypes;
-  signature: `0x${string}`;
-};
-
-export function assertCorrectEncryptedItemInput(input: EncryptedItemInput): asserts input is EncryptedItemInput {
-  if (!input.signature.startsWith('0x')) throw new Error('Signature must be a hex string starting with 0x');
-}
-
-export type EncryptedBoolInput = EncryptedItemInput & {
-  utype: FheTypes.Bool;
-};
-export type EncryptedUint8Input = EncryptedItemInput & {
-  utype: FheTypes.Uint8;
-};
-export type EncryptedUint16Input = EncryptedItemInput & {
-  utype: FheTypes.Uint16;
-};
-export type EncryptedUint32Input = EncryptedItemInput & {
-  utype: FheTypes.Uint32;
-};
-export type EncryptedUint64Input = EncryptedItemInput & {
-  utype: FheTypes.Uint64;
-};
-export type EncryptedUint128Input = EncryptedItemInput & {
-  utype: FheTypes.Uint128;
-};
-// [U256-DISABLED]
-// export type EncryptedUint256Input = EncryptedItemInput & {
-//   utype: FheTypes.Uint256;
-// };
-export type EncryptedAddressInput = EncryptedItemInput & {
-  utype: FheTypes.Uint160;
-};
-
 export type EncryptableBase<U extends FheTypes, D> = {
   data: D;
   securityZone: number;
@@ -321,34 +284,6 @@ export type EncryptableItemByFheType<T extends FheTypes> = T extends FheTypes.Bo
               ? EncryptableAddress
               : never;
 
-// COFHE Encrypt
-export 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
-            : // [U256-DISABLED]
-              // : E extends EncryptableUint256
-              //   ? EncryptedUint256Input
-              E extends EncryptableAddress
-              ? EncryptedAddressInput
-              : never;
-
-export type EncryptedItemInputs<T> = T extends Primitive
-  ? LiteralToPrimitive<T>
-  : T extends EncryptableItem
-    ? EncryptableToEncryptedItemInputMap<T>
-    : {
-        [K in keyof T]: EncryptedItemInputs<T[K]>;
-      };
-
 export function isEncryptableItem(value: unknown): value is EncryptableItem {
   return (
     // Is object and exists
@@ -399,7 +334,12 @@ export type ExternalUint64Hash = `0x${string}` & { readonly utype: FheTypes.Uint
 export type ExternalUint128Hash = `0x${string}` & { readonly utype: FheTypes.Uint128 };
 export 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.
+ */
 export type ExternalHashProof = `0x${string}` & { readonly _kind: 'ExternalHashProof' };
 
 /** Union of all External*Hash types — useful for utilities that operate on any hash without caring about the specific FHE type. */
@@ -414,7 +354,6 @@ export type AnyExternalHash =
 
 /**
  * Maps a single EncryptableItem to its corresponding External*Hash type.
- * Mirrors EncryptableToEncryptedItemInputMap.
  */
 export type EncryptableToExternalHashMap<E extends EncryptableItem> = E extends EncryptableBool
   ? ExternalBoolHash
@@ -441,8 +380,9 @@ export type ExternalItemHashes<T extends EncryptableItem[]> = {
 };
 
 /**
- * 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]
  */
 export type HashPlusProofResult<T extends EncryptableItem[]> = [...ExternalItemHashes<T>, ExternalHashProof];

package/dist/acp-Wi6isVQI.d.cts

@@ -0,0 +1,407 @@
+import { Hex, PublicClient, WalletClient } from 'viem';
+
+type EthEncryptedData = {
+    data: Uint8Array;
+    public_key: Uint8Array;
+    nonce: Uint8Array;
+};
+/**
+ * An X25519 sealing keypair, both halves 0x-prefixed 32-byte hex.
+ * The public key travels in the ACP (`sealingKey`); the private key never
+ * leaves the client (`sealingPrivateKey`).
+ */
+type SealingKeyPair = {
+    privateKey: Hex;
+    publicKey: Hex;
+};
+/**
+ * Generates a new sealing keypair. A sealing key is used to encrypt data such
+ * that it can only be unsealed (decrypted) by the owner of the corresponding
+ * private key.
+ */
+declare const GenerateSealingKey: () => SealingKeyPair;
+/**
+ * Seals (encrypts) the provided message for a receiver with the specified public key.
+ *
+ * @param {bigint | number} value - The message to be encrypted.
+ * @param {string} publicKey - The public key of the intended recipient (with or without 0x prefix).
+ * @returns {EthEncryptedData} - The encrypted message.
+ * @throws Will throw if the provided publicKey or value do not meet defined preconditions.
+ */
+declare const seal: (value: bigint | number, publicKey: string) => EthEncryptedData;
+/**
+ * Unseal (decrypt) data with a sealing private key (with or without 0x prefix).
+ * The ephemeral public key travels inside the payload, so the private key alone suffices.
+ */
+declare const unsealWithPrivateKey: (privateKey: string, parsedData: EthEncryptedData) => bigint;
+
+/**
+ * EIP712 related types
+ */
+type EIP712Type = {
+    name: string;
+    type: string;
+};
+type EIP712Types = Record<string, EIP712Type[]>;
+type EIP712Message = Record<string, string>;
+type EIP712Domain = {
+    chainId: number;
+    name: string;
+    verifyingContract: Hex;
+    version: string;
+};
+
+/**
+ * The client-side-only component of an ACP — never leaves the client.
+ */
+interface ACPPrivate {
+    /**
+     * Stable hash of relevant acp data, used as key in storage
+     */
+    hash: string;
+    /**
+     * Name for this acp, for organization and UI usage, not included in signature.
+     */
+    name: string;
+    /**
+     * The type of the ACP (self / sharing / recipient)
+     * (self) ACP that will be signed and used by the issuer
+     * (sharing) ACP that is signed by the issuer, but intended to be shared with recipient
+     * (recipient) ACP that has been received, and signed by the recipient
+     */
+    type: 'self' | 'sharing' | 'recipient';
+    /**
+     * The private half of the sealing keypair — used to unseal returned data.
+     * `sealingKey` (in the public component) is the corresponding public key.
+     * Never leaves the client.
+     */
+    sealingPrivateKey: Hex;
+    /**
+     * EIP712 domain used to sign this acp.
+     * Should not be set manually, included in metadata as part of serialization flows.
+     */
+    _signedDomain?: EIP712Domain;
+}
+/**
+ * The public component of an ACP — the signed struct passed on-chain / to the
+ * decryption backend to grant encrypted data access. Produced by `getPublic()`.
+ */
+interface ACPPublic {
+    /**
+     * (base) User that initially created the permission, target of data fetching
+     */
+    issuer: Hex;
+    /**
+     * (base) Expiration timestamp
+     */
+    expiration: number;
+    /**
+     * (sharing) The user that this permission will be shared with
+     * ** optional, use `address(0)` to disable **
+     */
+    recipient: Hex;
+    /**
+     * (revocation) Opaque data interpreted by `revokerContract` — the default
+     * revoker interprets it as the acp's creation timestamp.
+     * ** optional, use `0` to disable **
+     */
+    revokerData: number;
+    /**
+     * (revocation) The contract to query to determine permission validity
+     * ** optional, use `address(0)` to disable **
+     */
+    revokerContract: Hex;
+    /**
+     * (scope) Scope discriminator — exactly one scope mode per ACP (see ACPScope).
+     * Global: all of `issuer`s values (arrays empty). Contract: values readable by
+     * `contracts`. Handles: the listed `handles` only.
+     */
+    scope: number;
+    /**
+     * (scope) Grants access to `issuer`s values readable by any of these contracts.
+     * Checked on-chain as an intersection with the ACL's persisted allowances.
+     */
+    contracts: Hex[];
+    /**
+     * (scope) Grants access to these specific ciphertext handles (bytes32 hex)
+     */
+    handles: Hex[];
+    /**
+     * (base) The public half of the sealing keypair — used to re-encrypt `issuer`s confidential data
+     *   (non-sharing) Populated by `issuer`
+     *   (sharing)     Populated by `recipient`
+     */
+    sealingKey: Hex;
+    /**
+     * (base) `signTypedData` signature created by `issuer`.
+     * (base) Shared- and Self- permissions differ in signature format: (`sealingKey` absent in shared signature)
+     */
+    issuerSignature: Hex;
+    /**
+     * (sharing) `signTypedData` signature created by `recipient`
+     * ** required for shared acps **
+     */
+    recipientSignature: Hex;
+}
+/**
+ * Core ACP (Access Control Permission) type — immutable design for React compatibility.
+ * The union of the private (client-only) and public (signed) components.
+ */
+type ACP = Expand<ACPPrivate & ACPPublic>;
+/**
+ * ACP discriminant helpers
+ */
+type ACPType = ACP['type'];
+/**
+ * Utility type to narrow an ACP to a specific discriminant.
+ *
+ * Note: this only narrows the `type` field. Runtime/validation constraints
+ * (e.g. recipient == zeroAddress for self acps) are enforced elsewhere.
+ */
+type ACPOf<T extends ACPType> = Expand<Omit<ACP, 'type'> & {
+    type: T;
+}>;
+type SelfACP = ACPOf<'self'>;
+type SharingACP = ACPOf<'sharing'>;
+type RecipientACP = ACPOf<'recipient'>;
+/**
+ * Optional additional metadata of an ACP
+ * Can be passed into the constructor, but not necessary
+ * Useful for deserialization
+ */
+interface ACPMetadata {
+    /**
+     * EIP712 domain used to sign this acp.
+     * Should not be set manually, included in metadata as part of serialization flows.
+     */
+    _signedDomain?: EIP712Domain;
+}
+/**
+ * Utility types for acp creation
+ */
+/**
+ * Scope fields shared by all acp creation options.
+ * When any scope array is populated and `global` is not explicitly set,
+ * `global` defaults to false (narrowest matching scope); with no scope
+ * arrays it defaults to true (V2 behavior).
+ */
+declare const ACPScope: {
+    readonly Global: 0;
+    readonly Contract: 1;
+    readonly Handles: 2;
+};
+type ACPScopeOptions = {
+    scope?: number;
+    contracts?: Hex[];
+    handles?: Hex[];
+};
+type CreateSelfACPOptions = ACPScopeOptions & {
+    type?: 'self';
+    issuer: string;
+    name?: string;
+    expiration?: number;
+    revokerData?: number;
+    revokerContract?: string;
+};
+type CreateSharingACPOptions = ACPScopeOptions & {
+    type?: 'sharing';
+    issuer: string;
+    recipient: string;
+    name?: string;
+    expiration?: number;
+    revokerData?: number;
+    revokerContract?: string;
+};
+type ImportSharedACPOptions = ACPScopeOptions & {
+    type?: 'sharing';
+    issuer: string;
+    recipient: string;
+    issuerSignature: string;
+    name?: string;
+    expiration: number;
+    revokerData?: number;
+    revokerContract?: string;
+};
+/** An ACP is plain JSON-serializable data — the serialized form is the ACP itself. */
+type SerializedACP = ACP;
+/**
+ * The share payload produced by `ACPUtils.export()` — the full public component
+ * with `sealingKey`/`recipientSignature` left for the recipient to fill, plus
+ * the display name and acp type. Fixed shape: every field is always present
+ * (zero-values instead of omissions), so importers can parse a single schema.
+ * Mirrors the on-chain sharing payload struct field-for-field.
+ */
+type SharedACP = Expand<Omit<ACPPublic, 'sealingKey' | 'recipientSignature'> & {
+    name: string;
+    type: 'sharing';
+}>;
+/**
+ * A share read back from the on-chain ACPShareRegistry: the posted payload
+ * (SharedACP minus the client-side name/type) plus its registry id.
+ */
+type IncomingShare = Expand<Omit<SharedACP, 'name' | 'type'> & {
+    shareId: Hex;
+}>;
+/**
+ * A type representing the acp fields that are used to generate the hash
+ */
+type ACPHashFields = Pick<ACP, 'type' | 'issuer' | 'expiration' | 'recipient' | 'revokerData' | 'revokerContract' | 'scope' | 'contracts' | 'handles'>;
+/**
+ * Validation result type
+ */
+interface ValidationResult {
+    valid: boolean;
+    error: 'invalid-schema' | 'expired' | 'not-signed' | null;
+}
+/**
+ * Signature types for EIP712 signing
+ */
+type ACPSignaturePrimaryType = 'ACPIssuerSelf' | 'ACPIssuerShared' | 'ACPRecipient';
+type Expand<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+
+/**
+ * Main ACP utilities - functional approach for React compatibility
+ */
+declare const ACPUtils: {
+    /**
+     * Create a self acp for personal use
+     */
+    createSelf: (options: CreateSelfACPOptions) => SelfACP;
+    /**
+     * Create a sharing acp to be shared with another user
+     */
+    createSharing: (options: CreateSharingACPOptions) => SharingACP;
+    /**
+     * Import a shared acp from various input formats
+     */
+    importShared: (options: ImportSharedACPOptions | string) => RecipientACP;
+    /**
+     * Sign an ACP with the provided wallet client
+     */
+    sign: <T extends ACP>(acp: T, publicClient: PublicClient, walletClient: WalletClient) => Promise<T>;
+    /**
+     * Create and sign a self acp in one operation
+     */
+    createSelfAndSign: (options: CreateSelfACPOptions, publicClient: PublicClient, walletClient: WalletClient) => Promise<SelfACP>;
+    /**
+     * Create and sign a sharing acp in one operation
+     */
+    createSharingAndSign: (options: CreateSharingACPOptions, publicClient: PublicClient, walletClient: WalletClient) => Promise<SharingACP>;
+    /**
+     * Import and sign a shared acp in one operation from various input formats
+     */
+    importSharedAndSign: (options: ImportSharedACPOptions | string, publicClient: PublicClient, walletClient: WalletClient) => Promise<RecipientACP>;
+    /**
+     * Deserialize an ACP from serialized data
+     */
+    deserialize: (data: SerializedACP) => ACP;
+    /**
+     * Serialize an ACP for storage
+     */
+    serialize: (acp: ACP) => SerializedACP;
+    /**
+     * Validate an ACP (schema-level validation)
+     */
+    validateSchema: (acp: ACP) => {
+        name: string;
+        type: "self" | "sharing" | "recipient";
+        issuer: `0x${string}`;
+        expiration: number;
+        recipient: `0x${string}`;
+        revokerData: number;
+        revokerContract: `0x${string}`;
+        scope: number;
+        contracts: `0x${string}`[];
+        handles: `0x${string}`[];
+        issuerSignature: `0x${string}`;
+        recipientSignature: `0x${string}`;
+        sealingPrivateKey?: string | undefined;
+        sealingKey?: string | undefined;
+    };
+    /**
+     * Validate an ACP (holistic validation).
+     *
+     * This validates:
+     * - ACP schema (shape + invariants)
+     * - ACP is signed
+     * - ACP is not expired
+     *
+     * For schema-only validation, use `validateSchema(acp)`.
+     */
+    validate: (acp: ACP) => {
+        name: string;
+        type: "self" | "sharing" | "recipient";
+        issuer: `0x${string}`;
+        expiration: number;
+        recipient: `0x${string}`;
+        revokerData: number;
+        revokerContract: `0x${string}`;
+        scope: number;
+        contracts: `0x${string}`[];
+        handles: `0x${string}`[];
+        issuerSignature: `0x${string}`;
+        recipientSignature: `0x${string}`;
+        sealingPrivateKey?: string | undefined;
+        sealingKey?: string | undefined;
+    };
+    /**
+     * Get the public component of an ACP — the signed struct sent on-chain / to the decryption backend.
+     * Strips the private component (hash, name, type, sealing pair).
+     */
+    getPublic: (acp: ACP, skipValidation?: boolean) => ACPPublic;
+    /**
+     * Get a stable hash for the acp (used as key in storage)
+     */
+    getHash: (acp: ACPHashFields) => string;
+    /**
+     * Export acp data for sharing (strips the private component).
+     * Fixed `SharedACP` shape — every field always present, aligned with
+     * `ACPPublic` and the on-chain sharing payload.
+     */
+    export: (acp: ACP) => string;
+    /**
+     * Unseal encrypted data using the acp's sealing key
+     */
+    unseal: (acp: ACP, ciphertext: EthEncryptedData) => bigint;
+    /**
+     * Check if acp is expired
+     */
+    isExpired: (acp: ACP) => boolean;
+    /**
+     * Check if acp is signed
+     */
+    isSigned: (acp: ACP) => boolean;
+    /**
+     * Check if acp is signed and not expired
+     */
+    isSignedAndNotExpired: (acp: ACP) => ValidationResult;
+    /**
+     * Assert that acp is signed and not expired
+     */
+    assertSignedAndNotExpired: (acp: ACP) => void;
+    isValid: (acp: ACP) => ValidationResult;
+    /**
+     * Update acp name (returns new acp instance)
+     */
+    updateName: (acp: ACP, name: string) => ACP;
+    /**
+     * Fetch EIP712 domain from the blockchain
+     */
+    fetchEIP712Domain: (publicClient: PublicClient) => Promise<EIP712Domain>;
+    /**
+     * Check if acp's signed domain matches the provided domain
+     */
+    matchesDomain: (acp: ACP, domain: EIP712Domain) => boolean;
+    /**
+     * Check if acp's signed domain is valid for the current chain
+     */
+    checkSignedDomainValid: (acp: ACP, publicClient: PublicClient) => Promise<boolean>;
+    /**
+     * Check if acp passes the on-chain validation
+     */
+    checkValidityOnChain: (acp: ACP, publicClient: PublicClient) => Promise<boolean>;
+};
+
+export { type ACP as A, type CreateSelfACPOptions as C, type EIP712Types as E, GenerateSealingKey as G, type ImportSharedACPOptions as I, type RecipientACP as R, type SerializedACP as S, type ValidationResult as V, type ACPPublic as a, type ACPSignaturePrimaryType as b, type EIP712Message as c, type CreateSharingACPOptions as d, type ACPMetadata as e, type SharedACP as f, type IncomingShare as g, type EIP712Domain as h, ACPUtils as i, type SealingKeyPair as j, type EthEncryptedData as k, type EIP712Type as l, type ACPPrivate as m, type ACPType as n, type ACPOf as o, type SelfACP as p, type SharingACP as q, ACPScope as r, seal as s, type ACPScopeOptions as t, unsealWithPrivateKey as u, type ACPHashFields as v, type Expand as w };