@cofhe/sdk 0.7.1 → 1.0.0-alpha.0

package/dist/acps.d.cts

@@ -1,9 +1,582 @@
-import { A as ACP, V as ValidationResult, a as ACPPublic, b as ACPSignaturePrimaryType, E as EIP712Types, c as EIP712Message, S as SerializedACP } from './acp-Wi6isVQI.cjs';
-export { v as ACPHashFields, e as ACPMetadata, o as ACPOf, m as ACPPrivate, r as ACPScope, t as ACPScopeOptions, n as ACPType, i as ACPUtils, C as CreateSelfACPOptions, d as CreateSharingACPOptions, h as EIP712Domain, l as EIP712Type, k as EthEncryptedData, w as Expand, G as GenerateSealingKey, I as ImportACPOptions, I as ImportSharedACPOptions, g as IncomingShare, R as RecipientACP, j as SealingKeyPair, p as SelfACP, C as SelfACPOptions, f as SharedACP, q as SharingACP, d as SharingACPOptions, s as seal, u as unsealWithPrivateKey } from './acp-Wi6isVQI.cjs';
+import { A as ACP, S as ShareLabel, a as StoredValueLabel, E as EventValueLabel, L as LabelledShare, V as ValidationResult, b as ACPPublic, c as ACPSignaturePrimaryType, d as EIP712Types, e as EIP712Message, f as SerializedACP } from './onchain-utils-D9Z33IP7.cjs';
+export { O as ACPAccessStatus, P as ACPHashFields, h as ACPMetadata, H as ACPOf, D as ACPPrivate, M as ACPScope, N as ACPScopeOptions, F as ACPType, l as ACPUtils, p as AclServedAddresses, C as CreateSelfACPOptions, g as CreateSharingACPOptions, k as EIP712Domain, B as EIP712Type, r as EthEncryptedData, Q as Expand, G as GenerateSealingKey, I as ImportACPOptions, I as ImportSharedACPOptions, j as IncomingShare, v as LabelVerification, R as RecipientACP, q as SealingKeyPair, J as SelfACP, C as SelfACPOptions, x as ShareLabelCheck, t as ShareLabelReadArg, w as ShareLabelVerifyMode, i as SharedACP, K as SharingACP, g as SharingACPOptions, U as UnlabelledLabel, o as clearAclServedAddresses, m as getAclAddress, n as getAclServedAddresses, s as seal, u as unsealWithPrivateKey, y as verifyShareLabel, z as verifyShareLabels } from './onchain-utils-D9Z33IP7.cjs';
+import { Hex, AbiParameterToPrimitiveType, Address, PublicClient, Abi, ContractFunctionName, ContractFunctionArgs, Log } from 'viem';
 import { z } from 'zod';
 import * as zustand_middleware from 'zustand/middleware';
 import * as zustand_vanilla from 'zustand/vanilla';
-import 'viem';
+
+/**
+ * The on-chain sharing pieces: the share registry and revoker ABIs, the registry payload of a
+ * sharing ACP and its share id, and the read of a share from its `Shared` event. Exported so an
+ * app can send these writes through its own transaction path and still agree with the registry
+ * on ids.
+ *
+ * The registry is pointer-based: storage keeps a share header (issuer, expiration, recipient,
+ * revoker, and the block of its `Shared` event); the full payload and the metadata blob travel in
+ * that event. A reader takes headers from `sharesFor` / `getShare` and fetches the events with one
+ * single-block `getLogs` per block.
+ */
+declare const ACP_REVOKER_ABI: readonly [{
+    readonly name: "revokeSingle";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "id";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "revokeAllExisting";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "disabled";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "issuer";
+    }, {
+        readonly type: "uint256";
+        readonly name: "id";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}];
+declare const ACP_SHARE_REGISTRY_ABI: readonly [{
+    readonly name: "share";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "address";
+            readonly name: "issuer";
+        }, {
+            readonly type: "uint64";
+            readonly name: "expiration";
+        }, {
+            readonly type: "address";
+            readonly name: "recipient";
+        }, {
+            readonly type: "uint256";
+            readonly name: "revokerData";
+        }, {
+            readonly type: "address";
+            readonly name: "revokerContract";
+        }, {
+            readonly type: "uint8";
+            readonly name: "scope";
+        }, {
+            readonly type: "address[]";
+            readonly name: "contracts";
+        }, {
+            readonly type: "bytes32[]";
+            readonly name: "handles";
+        }, {
+            readonly type: "bytes32";
+            readonly name: "sealingKey";
+        }, {
+            readonly type: "bytes";
+            readonly name: "issuerSignature";
+        }, {
+            readonly type: "bytes";
+            readonly name: "recipientSignature";
+        }];
+        readonly name: "acp";
+    }, {
+        readonly type: "bytes";
+        readonly name: "metadata";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bytes32";
+    }];
+}, {
+    readonly name: "removeShare";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "bytes32";
+        readonly name: "shareId";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "sharesFor";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "recipient";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bytes32[]";
+        readonly name: "shareIds";
+    }, {
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly type: "address";
+            readonly name: "issuer";
+        }, {
+            readonly type: "uint64";
+            readonly name: "expiration";
+        }, {
+            readonly type: "address";
+            readonly name: "recipient";
+        }, {
+            readonly type: "uint64";
+            readonly name: "blockNumber";
+        }, {
+            readonly type: "address";
+            readonly name: "revokerContract";
+        }, {
+            readonly type: "uint256";
+            readonly name: "revokerData";
+        }];
+        readonly name: "headers";
+    }];
+}, {
+    readonly name: "getShare";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "bytes32";
+        readonly name: "shareId";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "address";
+            readonly name: "issuer";
+        }, {
+            readonly type: "uint64";
+            readonly name: "expiration";
+        }, {
+            readonly type: "address";
+            readonly name: "recipient";
+        }, {
+            readonly type: "uint64";
+            readonly name: "blockNumber";
+        }, {
+            readonly type: "address";
+            readonly name: "revokerContract";
+        }, {
+            readonly type: "uint256";
+            readonly name: "revokerData";
+        }];
+    }];
+}, {
+    readonly name: "isShareValid";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "bytes32";
+        readonly name: "shareId";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "Shared";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "recipient";
+        readonly indexed: true;
+    }, {
+        readonly type: "address";
+        readonly name: "issuer";
+        readonly indexed: true;
+    }, {
+        readonly type: "bytes32";
+        readonly name: "shareId";
+        readonly indexed: true;
+    }, {
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "address";
+            readonly name: "issuer";
+        }, {
+            readonly type: "uint64";
+            readonly name: "expiration";
+        }, {
+            readonly type: "address";
+            readonly name: "recipient";
+        }, {
+            readonly type: "uint256";
+            readonly name: "revokerData";
+        }, {
+            readonly type: "address";
+            readonly name: "revokerContract";
+        }, {
+            readonly type: "uint8";
+            readonly name: "scope";
+        }, {
+            readonly type: "address[]";
+            readonly name: "contracts";
+        }, {
+            readonly type: "bytes32[]";
+            readonly name: "handles";
+        }, {
+            readonly type: "bytes32";
+            readonly name: "sealingKey";
+        }, {
+            readonly type: "bytes";
+            readonly name: "issuerSignature";
+        }, {
+            readonly type: "bytes";
+            readonly name: "recipientSignature";
+        }];
+        readonly name: "acp";
+    }, {
+        readonly type: "bytes";
+        readonly name: "metadata";
+    }];
+}, {
+    readonly name: "ShareRemoved";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "recipient";
+        readonly indexed: true;
+    }, {
+        readonly type: "address";
+        readonly name: "issuer";
+        readonly indexed: true;
+    }, {
+        readonly type: "bytes32";
+        readonly name: "shareId";
+        readonly indexed: true;
+    }];
+}];
+declare const ACP_SHARE_TUPLE_ABI: readonly [{
+    readonly type: "tuple";
+    readonly components: readonly [{
+        readonly name: "issuer";
+        readonly type: "address";
+    }, {
+        readonly name: "expiration";
+        readonly type: "uint64";
+    }, {
+        readonly name: "recipient";
+        readonly type: "address";
+    }, {
+        readonly name: "revokerData";
+        readonly type: "uint256";
+    }, {
+        readonly name: "revokerContract";
+        readonly type: "address";
+    }, {
+        readonly name: "scope";
+        readonly type: "uint8";
+    }, {
+        readonly name: "contracts";
+        readonly type: "address[]";
+    }, {
+        readonly name: "handles";
+        readonly type: "bytes32[]";
+    }, {
+        readonly name: "sealingKey";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "issuerSignature";
+        readonly type: "bytes";
+    }, {
+        readonly name: "recipientSignature";
+        readonly type: "bytes";
+    }];
+}];
+/** The on-chain payload for a sharing ACP: recipient-side fields empty. */
+declare const toChainShare: (acp: ACP) => {
+    expiration: bigint;
+    revokerData: bigint;
+    sealingKey: `0x${string}`;
+    recipientSignature: Hex;
+    issuer: Hex;
+    recipient: Hex;
+    revokerContract: Hex;
+    scope: number;
+    contracts: Hex[];
+    handles: Hex[];
+    issuerSignature: Hex;
+};
+/** Mirrors the registry's `keccak256(abi.encode(acp))` share id. */
+declare const computeShareId: (acp: ACP) => Hex;
+/** The share id of a registry payload as read back from a `Shared` event. */
+declare const shareIdOfChainShare: (share: ChainShare) => Hex;
+/** A registry payload, as decoded from a `Shared` event (or passed to `share`). */
+type ChainShare = AbiParameterToPrimitiveType<(typeof ACP_SHARE_TUPLE_ABI)[0]>;
+/** What the registry stores of a share: the fields it checks, and the block of its `Shared` event. */
+type ShareHeader = {
+    issuer: Address;
+    expiration: bigint;
+    recipient: Address;
+    /** Block of the `Shared` event (the L2 block on Arbitrum). */
+    blockNumber: bigint;
+    revokerContract: Address;
+    revokerData: bigint;
+};
+/** A share as posted: its payload and the metadata blob that came with it (`0x` when none). */
+type PostedShare = {
+    shareId: Hex;
+    header: ShareHeader;
+    share: ChainShare;
+    metadata: Hex;
+};
+/** A share the registry lists but whose `Shared` event could not be read, and why. */
+type UnreadableShare = {
+    shareId: Hex;
+    header: ShareHeader;
+    reason: string;
+};
+/** Shares read from their events, and those that could not be; each share is on its own. */
+type PostedShares = {
+    posted: PostedShare[];
+    unreadable: UnreadableShare[];
+};
+/**
+ * Fetches the `Shared` events of shares from the blocks their headers name: one single-block
+ * `getLogs` per distinct block, filtered by registry and share ids, so any node answers it. Returns
+ * the shares in the order given; where a block holds several events for one share id, the last.
+ * Never fails as a whole: a share whose block the node cannot serve yet, whose event is missing
+ * from it, or whose event payload does not hash to its id is returned as `unreadable`, with the
+ * reason, and the rest are posted as usual.
+ */
+declare const readPostedShares: (publicClient: PublicClient, registry: Address, headers: readonly {
+    shareId: Hex;
+    header: ShareHeader;
+}[]) => Promise<PostedShares>;
+/**
+ * The importable shares addressed to `recipient` (unexpired, not revoked), read from their events;
+ * those whose event could not be read are listed apart, so one of them never hides the rest.
+ */
+declare const readSharesFor: (publicClient: PublicClient, registry: Address, recipient: Address) => Promise<PostedShares>;
+/**
+ * One share by id, read from its event; null when the registry has no such share (unknown or
+ * removed). Throws, with the reason, when the registry lists it but its event could not be read.
+ */
+declare const readShare: (publicClient: PublicClient, registry: Address, shareId: Hex) => Promise<PostedShare | null>;
+
+/**
+ * Byte layout of a share metadata blob, version 3. Integers are big-endian; sizes in bytes.
+ *
+ *   blob         = version (1)
+ *                | contract count (1)    | contracts (20 each)
+ *                | selector count (1)    | selectors (4 each)       function selectors, and event
+ *                                                                   selectors (first 4 bytes of topic0)
+ *                | transaction count (1) | transactions (6 each: block 4, tx index 2)
+ *                | entries, one per ctHash, in the order of acp.handles
+ *                | app key, optional: 0x01 | key (32)       keccak256 of the name of the app the
+ *                                                           share is for; absent when the blob ends
+ *
+ *   stored value = 0x00 | contract (1) | selector (1) | block (4) | args                  8 bytes or more
+ *   event value  = 0x01 | contract (1) | transaction (1) | log index (2) | selector (1)   6 bytes
+ *   unlabelled   = 0xff                                                                   1 byte
+ *
+ *   args         = 0x00                                   no arguments, return word 0
+ *                | 0x01                                   one argument, the share issuer, return word 0
+ *                | 0xff | return word (1) | count (1) | argument, count times
+ *   argument     = 0x00 | word (32)                       a literal ABI word
+ *                | 0x01                                   the share issuer
+ *
+ * Contracts, selectors and transactions are listed once; entries refer to them by position.
+ * The log index is block-wide, as RPC nodes return it.
+ */
+declare const LAYOUT_VERSION = 3;
+
+/**
+ * Encodes the labels of a share into a version 3 blob: one label per ctHash, in the order of
+ * `acp.handles`. The contracts, selectors and transactions the labels name are listed once each,
+ * in order of first use; function and event selectors share one list. Throws on a value that does
+ * not fit its field (more than 255 contracts, a block past uint32, ...). Given the share `issuer`, a
+ * stored-value argument equal to their address is stored as "the issuer" instead of the address.
+ * Given an `appKey` (`shareAppKey(app)`), it closes the blob, so the app can tell its shares apart.
+ */
+declare const encodeShareMetadata: (labels: readonly ShareLabel[], { issuer, appKey }?: {
+    issuer?: Address;
+    appKey?: Hex;
+}) => Hex;
+
+/** The two things a blob holds: one label per ctHash, and the app key when the share names an app. */
+type DecodedShareMetadata = {
+    labels: ShareLabel[];
+    appKey: Hex | undefined;
+};
+/**
+ * Decodes a version 3 blob: one label per ctHash, in the order of `acp.handles`, and the app key
+ * when there is one. The exact inverse of `encodeShareMetadata`. Throws on another version, an
+ * unknown kind, code or tag, a position outside its list, and unless the blob holds exactly one
+ * entry per ctHash.
+ */
+declare const decodeShareMetadataFull: (blob: Hex, handles: readonly Hex[]) => DecodedShareMetadata;
+/** The labels of a blob, one per ctHash in the order of `acp.handles` (see `decodeShareMetadataFull`). */
+declare const decodeShareMetadata: (blob: Hex, handles: readonly Hex[]) => ShareLabel[];
+/** The app key a share was posted with, or undefined: for a share without metadata, or without a key. */
+declare const decodeShareAppKey: (metadata: Hex | undefined, handles: readonly Hex[]) => Hex | undefined;
+
+/** A parameter as the ABI names it. `name` is absent when the ABI leaves it unnamed. */
+type ShareLabelParam = {
+    name?: string;
+    type: string;
+    indexed?: boolean;
+};
+/** One argument of a stored-value read, decoded with the function's input type when the ABI has one. */
+type ShareLabelArg = ShareLabelParam & {
+    /** The argument stands for the share issuer. */
+    isIssuer: boolean;
+    /** The 32-byte ABI word, or undefined for an issuer argument when no issuer was given. */
+    raw: Hex | undefined;
+    /** The decoded value (an address, a bigint, ...), or the raw word when there is no ABI type for it. */
+    value: unknown;
+};
+type DescriptionBase = {
+    /** Position of the ctHash in `acp.handles`. */
+    index: number;
+    handle: Hex;
+};
+type StoredValueDescription = DescriptionBase & {
+    kind: 'stored';
+    label: StoredValueLabel;
+    contract: Address;
+    block: bigint;
+    selector: Hex;
+    /** The view function, or null when the ABI of the contract is missing or has no function with this selector. */
+    function: {
+        name: string;
+        signature: string;
+        inputs: ShareLabelParam[];
+    } | null;
+    args: ShareLabelArg[];
+    /** The returned field that holds the ctHash, when the ABI names the outputs. */
+    output: ShareLabelParam | null;
+};
+type EventValueDescription = DescriptionBase & {
+    kind: 'event';
+    label: EventValueLabel;
+    contract: Address;
+    block: bigint;
+    txIndex: number;
+    logIndex: number;
+    selector: Hex;
+    /**
+     * The event, or null when the ABI of the contract is missing or has no event with this selector.
+     * Parameter values are not in the label; they come with the log fetched to verify it.
+     */
+    event: {
+        name: string;
+        signature: string;
+        inputs: ShareLabelParam[];
+    } | null;
+};
+type UnlabelledDescription = DescriptionBase & {
+    kind: 'unlabelled';
+    label: ShareLabel & {
+        kind: 'unlabelled';
+    };
+};
+type ShareLabelDescription = StoredValueDescription | EventValueDescription | UnlabelledDescription;
+/** ABIs by contract address; addresses compare case-insensitively. */
+type ShareLabelAbis = Readonly<Record<Address, Abi>>;
+/**
+ * Turns decoded labels into structured, human-readable items, one per ctHash in the order of
+ * `handles`: the function name and decoded arguments of a stored value, the event name and
+ * parameters of an event value. A contract without an ABI, or a selector its ABI doesn't have,
+ * leaves the item in raw form (`function` / `event` null); this never throws. `issuer` (the share
+ * issuer) fills in the arguments that stand for it.
+ */
+declare const describeShareLabels: (labels: readonly ShareLabel[], handles: readonly Hex[], abis?: ShareLabelAbis, options?: {
+    issuer?: Address;
+}) => ShareLabelDescription[];
+/**
+ * Decodes a share's metadata blob and describes it: `decodeShareMetadata` then
+ * `describeShareLabels`, with the share's issuer filling in the arguments that stand for it. The
+ * share is one read from the registry or an acp imported from exported JSON. Null for a share
+ * without labels (no metadata, or `0x`). Throws only when the blob itself is malformed; missing
+ * ABIs leave items in raw form.
+ */
+declare const describeShareMetadata: (share: LabelledShare, abis?: ShareLabelAbis) => ShareLabelDescription[] | null;
+
+/**
+ * Builders for labels. The format knows nothing about tokens: a balance is the value a view
+ * function returned, a transfer amount the value of one event.
+ */
+type ViewFunctionLabelOptions<abi extends Abi, functionName extends ContractFunctionName<abi, 'pure' | 'view'>> = {
+    contract: Address;
+    abi: abi;
+    functionName: functionName;
+    /**
+     * The arguments of the call, static ABI types only. One equal to the share issuer's address
+     * (your own, when you share your balance) is stored as "the issuer" when the labels are encoded.
+     */
+    args?: ContractFunctionArgs<abi, 'pure' | 'view', functionName>;
+    /** Block the value was read at (on Arbitrum: the L2 block number). */
+    block: bigint;
+    /** Which 32-byte word of the return data is the ctHash; 0 (the default) for a single return value. */
+    returnWord?: number;
+};
+/**
+ * The label of a value a view function returned at a block, built from the contract's ABI: the
+ * function's selector, and each argument ABI-encoded to its word. Throws when the ABI has no such
+ * function, the arity is off, or an argument is not one static word.
+ */
+declare const viewFunctionLabel: <const abi extends Abi, functionName extends ContractFunctionName<abi, "pure" | "view">>(options: ViewFunctionLabelOptions<abi, functionName>) => StoredValueLabel;
+/**
+ * The label of a value carried by a log, as viem returns it from `getLogs` / `getContractEvents`:
+ * its contract, block, transaction and log index, and its event selector. Throws for a pending log.
+ */
+declare const eventLogLabel: (log: Pick<Log, "address" | "blockNumber" | "transactionIndex" | "logIndex" | "topics">) => EventValueLabel;
+/** The label of a ctHash the issuer chooses not to describe. */
+declare const UNLABELLED: ShareLabel;
+
+/**
+ * The parts of ERC-7984 (confidential tokens) that share labels most often point at: the balance
+ * read and the transfer event. One definition for the SDK's label presets and for apps, with
+ * `internalType` kept so `@cofhe/abi` recognises the encrypted values.
+ */
+declare const ERC7984_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "confidentialBalanceOf";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "euint64";
+    }];
+}, {
+    readonly type: "event";
+    readonly name: "ConfidentialTransfer";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "from";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "bytes32";
+        readonly indexed: true;
+        readonly internalType: "euint64";
+    }];
+}];
+
+/**
+ * The key an app marks its shares with: keccak256 of its name, e.g. `shareAppKey('explorer.fhenix.io')`.
+ * A client configured with `acp: { app }` puts it on every share it creates and lists only the
+ * shares that carry it; the name itself is never on-chain.
+ */
+declare const shareAppKey: (app: string) => Hex;
 
 declare const addressSchema: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
 declare const addressNotZeroSchema: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
@@ -78,6 +651,7 @@ declare const SelfACPValidator: z.ZodObject<{
     handles: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodType<`0x${string}`, unknown, z.core.$ZodTypeInternals<`0x${string}`, unknown>>>>>;
     issuerSignature: z.ZodDefault<z.ZodOptional<z.ZodCustom<`0x${string}`, `0x${string}`>>>;
     recipientSignature: z.ZodDefault<z.ZodOptional<z.ZodCustom<`0x${string}`, `0x${string}`>>>;
+    metadata: z.ZodOptional<z.ZodCustom<`0x${string}`, `0x${string}`>>;
     sealingPrivateKey: z.ZodOptional<z.ZodString>;
     sealingKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
@@ -146,6 +720,7 @@ declare const SharingACPValidator: z.ZodObject<{
     handles: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodType<`0x${string}`, unknown, z.core.$ZodTypeInternals<`0x${string}`, unknown>>>>>;
     issuerSignature: z.ZodDefault<z.ZodOptional<z.ZodCustom<`0x${string}`, `0x${string}`>>>;
     recipientSignature: z.ZodDefault<z.ZodOptional<z.ZodCustom<`0x${string}`, `0x${string}`>>>;
+    metadata: z.ZodOptional<z.ZodCustom<`0x${string}`, `0x${string}`>>;
     sealingPrivateKey: z.ZodOptional<z.ZodString>;
     sealingKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
@@ -156,7 +731,6 @@ declare const ImportACPOptionsValidator: z.ZodPipe<z.ZodObject<{
     type: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"recipient">>>;
     issuer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
     recipient: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
-    name: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     expiration: z.ZodInt;
     revokerData: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
     revokerContract: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>>>;
@@ -165,11 +739,11 @@ declare const ImportACPOptionsValidator: z.ZodPipe<z.ZodObject<{
     handles: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodType<`0x${string}`, unknown, z.core.$ZodTypeInternals<`0x${string}`, unknown>>>>>;
     issuerSignature: z.ZodCustom<`0x${string}`, `0x${string}`>;
     recipientSignature: z.ZodDefault<z.ZodOptional<z.ZodCustom<`0x${string}`, `0x${string}`>>>;
+    metadata: z.ZodPipe<z.ZodOptional<z.ZodCustom<`0x${string}`, `0x${string}`>>, z.ZodTransform<`0x${string}` | undefined, `0x${string}` | undefined>>;
 }, z.core.$strip>, z.ZodTransform<{
     type: "recipient";
     issuer: `0x${string}`;
     recipient: `0x${string}`;
-    name: string;
     expiration: number;
     revokerData: number;
     revokerContract: `0x${string}`;
@@ -177,6 +751,7 @@ declare const ImportACPOptionsValidator: z.ZodPipe<z.ZodObject<{
     handles: `0x${string}`[];
     issuerSignature: `0x${string}`;
     recipientSignature: `0x${string}`;
+    metadata: `0x${string}` | undefined;
     scope?: number | undefined;
 } & {
     scope: number;
@@ -184,7 +759,6 @@ declare const ImportACPOptionsValidator: z.ZodPipe<z.ZodObject<{
     type: "recipient";
     issuer: `0x${string}`;
     recipient: `0x${string}`;
-    name: string;
     expiration: number;
     revokerData: number;
     revokerContract: `0x${string}`;
@@ -192,6 +766,7 @@ declare const ImportACPOptionsValidator: z.ZodPipe<z.ZodObject<{
     handles: `0x${string}`[];
     issuerSignature: `0x${string}`;
     recipientSignature: `0x${string}`;
+    metadata: `0x${string}` | undefined;
     scope?: number | undefined;
 }>>;
 /**
@@ -214,6 +789,7 @@ declare const ImportACPValidator: z.ZodObject<{
     handles: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodType<`0x${string}`, unknown, z.core.$ZodTypeInternals<`0x${string}`, unknown>>>>>;
     issuerSignature: z.ZodDefault<z.ZodOptional<z.ZodCustom<`0x${string}`, `0x${string}`>>>;
     recipientSignature: z.ZodDefault<z.ZodOptional<z.ZodCustom<`0x${string}`, `0x${string}`>>>;
+    metadata: z.ZodOptional<z.ZodCustom<`0x${string}`, `0x${string}`>>;
     sealingPrivateKey: z.ZodOptional<z.ZodString>;
     sealingKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
@@ -262,7 +838,6 @@ declare const validateImportACPOptions: (options: any) => {
     type: "recipient";
     issuer: `0x${string}`;
     recipient: `0x${string}`;
-    name: string;
     expiration: number;
     revokerData: number;
     revokerContract: `0x${string}`;
@@ -270,6 +845,7 @@ declare const validateImportACPOptions: (options: any) => {
     handles: `0x${string}`[];
     issuerSignature: `0x${string}`;
     recipientSignature: `0x${string}`;
+    metadata: `0x${string}` | undefined;
     scope?: number | undefined;
 } & {
     scope: number;
@@ -290,6 +866,7 @@ declare const validateSelfACP: (acp: any) => {
     handles: `0x${string}`[];
     issuerSignature: `0x${string}`;
     recipientSignature: `0x${string}`;
+    metadata?: `0x${string}` | undefined;
     sealingPrivateKey?: string | undefined;
     sealingKey?: string | undefined;
 };
@@ -309,6 +886,7 @@ declare const validateSharingACP: (acp: any) => {
     handles: `0x${string}`[];
     issuerSignature: `0x${string}`;
     recipientSignature: `0x${string}`;
+    metadata?: `0x${string}` | undefined;
     sealingPrivateKey?: string | undefined;
     sealingKey?: string | undefined;
 };
@@ -328,6 +906,7 @@ declare const validateImportACP: (acp: any) => {
     handles: `0x${string}`[];
     issuerSignature: `0x${string}`;
     recipientSignature: `0x${string}`;
+    metadata?: `0x${string}` | undefined;
     sealingPrivateKey?: string | undefined;
     sealingKey?: string | undefined;
 };
@@ -391,8 +970,8 @@ declare const ACPSignatureAllFields: readonly [{
 }];
 type ACPSignatureFieldOption = (typeof ACPSignatureAllFields)[number]['name'];
 declare const SignatureTypes: {
-    readonly ACPIssuerSelf: ("recipient" | "issuer" | "expiration" | "revokerData" | "revokerContract" | "scope" | "contracts" | "handles" | "sealingKey")[];
-    readonly ACPIssuerShared: ("recipient" | "issuer" | "expiration" | "revokerData" | "revokerContract" | "scope" | "contracts" | "handles")[];
+    readonly ACPIssuerSelf: ("issuer" | "recipient" | "expiration" | "revokerData" | "revokerContract" | "scope" | "contracts" | "handles" | "sealingKey")[];
+    readonly ACPIssuerShared: ("issuer" | "recipient" | "expiration" | "revokerData" | "revokerContract" | "scope" | "contracts" | "handles")[];
     readonly ACPRecipient: ("sealingKey" | "issuerSignature")[];
 };
 /**
@@ -477,4 +1056,4 @@ declare const acpStore: {
     resetStore: () => void;
 };
 
-export { ACP, ACPPublic, ACPSignaturePrimaryType, ACP_STORE_DEFAULTS, EIP712Message, EIP712Types, ImportACPOptionsValidator, ImportACPValidator, SelfACPOptionsValidator, SelfACPValidator, SerializedACP, SharingACPOptionsValidator, SharingACPValidator, SignatureTypes, SignatureUtils, ValidationResult, ValidationUtils, _acpStore, acpStore, addressNotZeroSchema, addressSchema, bytesNotEmptySchema, bytesSchema, clearStaleStore, contractsSchema, getACP, getACPs, getActiveACP, getActiveACPHash, getSignatureTypesAndMessage, handlesSchema, removeACP, removeActiveACPHash, resetStore, setACP, setActiveACPHash, validateImportACP, validateImportACPOptions, validateSelfACP, validateSelfACPOptions, validateSharingACP, validateSharingACPOptions };
+export { ACP, ACPPublic, ACPSignaturePrimaryType, ACP_REVOKER_ABI, ACP_SHARE_REGISTRY_ABI, ACP_SHARE_TUPLE_ABI, ACP_STORE_DEFAULTS, type ChainShare, type DecodedShareMetadata, EIP712Message, EIP712Types, ERC7984_ABI, type EventValueDescription, EventValueLabel, ImportACPOptionsValidator, ImportACPValidator, LabelledShare, type PostedShare, type PostedShares, LAYOUT_VERSION as SHARE_METADATA_VERSION, SelfACPOptionsValidator, SelfACPValidator, SerializedACP, type ShareHeader, ShareLabel, type ShareLabelAbis, type ShareLabelArg, type ShareLabelDescription, type ShareLabelParam, SharingACPOptionsValidator, SharingACPValidator, SignatureTypes, SignatureUtils, type StoredValueDescription, StoredValueLabel, UNLABELLED, type UnlabelledDescription, type UnreadableShare, ValidationResult, ValidationUtils, type ViewFunctionLabelOptions, _acpStore, acpStore, addressNotZeroSchema, addressSchema, bytesNotEmptySchema, bytesSchema, clearStaleStore, computeShareId, contractsSchema, decodeShareAppKey, decodeShareMetadata, decodeShareMetadataFull, describeShareLabels, describeShareMetadata, encodeShareMetadata, eventLogLabel, getACP, getACPs, getActiveACP, getActiveACPHash, getSignatureTypesAndMessage, handlesSchema, readPostedShares, readShare, readSharesFor, removeACP, removeActiveACPHash, resetStore, setACP, setActiveACPHash, shareAppKey, shareIdOfChainShare, toChainShare, validateImportACP, validateImportACPOptions, validateSelfACP, validateSelfACPOptions, validateSharingACP, validateSharingACPOptions, viewFunctionLabel };