@cofhe/sdk 1.0.0 → 1.1.0-alpha.0

package/dist/{onchain-utils-CgOslubH.d.cts → onchain-utils-Ns56cBm0.d.ts}

@@ -1,4 +1,4 @@
-import { Hex, Address, PublicClient, WalletClient } from 'viem';
+import { Hex, Address, PublicClient, WalletClient, AbiParameterToPrimitiveType } from 'viem';
 
 type EthEncryptedData = {
     data: Uint8Array;
@@ -504,6 +504,360 @@ declare const ACPUtils: {
     checkAccessOnChain: (acp: ACP, publicClient: PublicClient, handle?: bigint | Hex) => Promise<ACPAccessStatus>;
 };
 
+/**
+ * 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>;
+
 /**
  * - `verified`: the chain confirms the label.
  * - `mismatch`: the chain contradicts it.
@@ -558,4 +912,4 @@ declare const clearAclServedAddresses: () => void;
  */
 declare const getAclServedAddresses: (publicClient: PublicClient, chainId: number) => Promise<AclServedAddresses>;
 
-export { type ACP as A, type EIP712Type as B, type CreateSelfACPOptions as C, type ACPPrivate as D, type EventValueLabel as E, type ACPType as F, GenerateSealingKey as G, type ACPOf as H, type ImportSharedACPOptions as I, type SelfACP as J, type SharingACP as K, type LabelledShare as L, ACPScope as M, type ACPScopeOptions as N, type ACPAccessStatus as O, type ACPHashFields as P, type Expand as Q, type RecipientACP as R, type ShareLabel as S, type UnlabelledLabel as U, type ValidationResult as V, type StoredValueLabel as a, type ACPPublic as b, type ACPSignaturePrimaryType as c, type EIP712Types as d, type EIP712Message as e, type SerializedACP as f, type CreateSharingACPOptions as g, type ACPMetadata as h, type SharedACP as i, type IncomingShare as j, type EIP712Domain as k, ACPUtils as l, getAclAddress as m, getAclServedAddresses as n, clearAclServedAddresses as o, type AclServedAddresses as p, type SealingKeyPair as q, type EthEncryptedData as r, seal as s, type ShareLabelReadArg as t, unsealWithPrivateKey as u, type LabelVerification as v, type ShareLabelVerifyMode as w, type ShareLabelCheck as x, verifyShareLabel as y, verifyShareLabels as z };
+export { type SelfACP as $, type ACP as A, type ChainShare as B, type CreateSelfACPOptions as C, type ShareHeader as D, type EventValueLabel as E, type PostedShares as F, GenerateSealingKey as G, readPostedShares as H, type ImportSharedACPOptions as I, readSharesFor as J, readShare as K, type LabelledShare as L, type ShareLabelReadArg as M, type UnlabelledLabel as N, type LabelVerification as O, type PostedShare as P, type ShareLabelVerifyMode as Q, type ShareLabelCheck as R, type ShareLabel as S, verifyShareLabel as T, type UnreadableShare as U, type ValidationResult as V, verifyShareLabels as W, type EIP712Type as X, type ACPPrivate as Y, type ACPType as Z, type ACPOf as _, type StoredValueLabel as a, type SharingACP as a0, type RecipientACP as a1, ACPScope as a2, type ACPScopeOptions as a3, type ACPAccessStatus as a4, type ACPHashFields as a5, type Expand as a6, type ACPPublic as b, type ACPSignaturePrimaryType as c, type EIP712Types as d, type EIP712Message as e, type SerializedACP as f, type CreateSharingACPOptions as g, type ACPMetadata as h, type SharedACP as i, type IncomingShare as j, type EIP712Domain as k, ACPUtils as l, getAclAddress as m, getAclServedAddresses as n, clearAclServedAddresses as o, type AclServedAddresses as p, type SealingKeyPair as q, type EthEncryptedData as r, seal as s, ACP_REVOKER_ABI as t, unsealWithPrivateKey as u, ACP_SHARE_REGISTRY_ABI as v, ACP_SHARE_TUPLE_ABI as w, toChainShare as x, computeShareId as y, shareIdOfChainShare as z };

package/dist/web.cjs

@@ -3292,23 +3292,25 @@ var getBlockRevokerData = async (publicClient) => {
   }
   return revokerData;
 };
-var revokeACP = async (acp, walletClient) => {
+var prepareRevokeACP = (acp) => {
   if (acp.revokerContract === viem.zeroAddress || acp.revokerData === 0) {
     throw new Error("ACP is not revocable: it has no revoker (revokerContract/revokerData unset)");
   }
+  return {
+    address: acp.revokerContract,
+    abi: ACP_REVOKER_ABI,
+    functionName: "revokeSingle",
+    args: [BigInt(acp.revokerData)]
+  };
+};
+var revokeACP = async (acp, walletClient) => {
+  const write = prepareRevokeACP(acp);
   if (walletClient.account == null)
     throw new Error("Missing walletClient account");
   if (walletClient.account.address.toLowerCase() !== acp.issuer.toLowerCase()) {
     throw new Error("Only the acp issuer can revoke it");
   }
-  return walletClient.writeContract({
-    address: acp.revokerContract,
-    abi: ACP_REVOKER_ABI,
-    functionName: "revokeSingle",
-    args: [BigInt(acp.revokerData)],
-    account: walletClient.account,
-    chain: walletClient.chain
-  });
+  return walletClient.writeContract({ ...write, account: walletClient.account, chain: walletClient.chain });
 };
 var revokeAllACPs = async (walletClient, publicClient, revokerContract) => {
   if (walletClient.account == null)
@@ -3359,28 +3361,36 @@ var metadataOf = (acp, { labels, metadata, appKey }) => {
   }
   return encodeShareMetadata(labels, { issuer: acp.issuer, appKey });
 };
-var shareOnChain = async (acp, walletClient, registry, options = {}) => {
+var prepareShareOnChain = (acp, registry, options = {}) => {
   if (acp.type !== "sharing") {
     throw new Error(`Cannot share a '${acp.type}' ACP on-chain \u2014 only 'sharing' ACPs are shareable.`);
   }
   if (acp.issuerSignature === "0x") {
     throw new Error("Cannot share an unsigned sharing ACP \u2014 sign it first.");
   }
+  return {
+    write: {
+      address: registry,
+      abi: ACP_SHARE_REGISTRY_ABI,
+      functionName: "share",
+      args: [toChainShare(acp), metadataOf(acp, options)]
+    },
+    shareId: computeShareId(acp)
+  };
+};
+var shareOnChain = async (acp, walletClient, registry, options = {}) => {
+  const { write, shareId } = prepareShareOnChain(acp, registry, options);
   if (walletClient.account == null)
     throw new Error("Missing walletClient account");
   if (walletClient.account.address.toLowerCase() !== acp.issuer.toLowerCase()) {
     throw new Error("Only the ACP issuer can share it on-chain");
   }
-  const metadata = metadataOf(acp, options);
   const txHash = await walletClient.writeContract({
-    address: registry,
-    abi: ACP_SHARE_REGISTRY_ABI,
-    functionName: "share",
-    args: [toChainShare(acp), metadata],
+    ...write,
     account: walletClient.account,
     chain: walletClient.chain ?? null
   });
-  return { txHash, shareId: computeShareId(acp) };
+  return { txHash, shareId };
 };
 var toIncomingShare = ({ shareId, share: s, metadata }) => ({
   shareId,
@@ -3415,14 +3425,17 @@ var importFromChain = async (share, publicClient, walletClient, importOptions =
   const { shareId: _shareId, appKey: _appKey, ...options } = share;
   return importShared({ ...options, type: "sharing" }, publicClient, walletClient, importOptions);
 };
+var prepareRemoveShare = (shareId, registry) => ({
+  address: registry,
+  abi: ACP_SHARE_REGISTRY_ABI,
+  functionName: "removeShare",
+  args: [shareId]
+});
 var removeShareOnChain = async (shareId, walletClient, registry) => {
   if (walletClient.account == null)
     throw new Error("Missing walletClient account");
   return walletClient.writeContract({
-    address: registry,
-    abi: ACP_SHARE_REGISTRY_ABI,
-    functionName: "removeShare",
-    args: [shareId],
+    ...prepareRemoveShare(shareId, registry),
     account: walletClient.account,
     chain: walletClient.chain ?? null
   });
@@ -3449,14 +3462,17 @@ var acps = {
   selectActiveACP,
   removeActiveACP,
   revokeACP,
+  prepareRevokeACP,
   revokeAllACPs,
   isACPRevoked,
   checkAccess,
   shareOnChain,
+  prepareShareOnChain,
   getIncomingShares,
   getShareFromChain,
   importFromChain,
   removeShareOnChain,
+  prepareRemoveShare,
   computeShareId,
   applyACPDefaultsFromChain,
   getAclServedAddresses,
@@ -5232,6 +5248,12 @@ function createCofheClientBase(opts) {
       });
     }
   };
+  const _requireIssuer = (acp, what) => {
+    const sender = connectStore.getState().walletClient?.account?.address;
+    if (sender == null || sender.toLowerCase() !== acp.issuer.toLowerCase()) {
+      throw new Error(`Only the acp issuer can ${what}`);
+    }
+  };
   async function connect(publicClient, walletClient) {
     const state = connectStore.getState();
     if (state.connected && state.publicClient === publicClient && state.walletClient === walletClient)
@@ -5399,6 +5421,11 @@ function createCofheClientBase(opts) {
       const { walletClient } = connectStore.getState();
       return acps.revokeACP(acp, walletClient);
     },
+    prepareRevokeACP: (acp) => {
+      _requireConnected();
+      _requireIssuer(acp, "revoke it");
+      return acps.prepareRevokeACP(acp);
+    },
     revokeAllACPs: async (revokerContract) => {
       _requireConnected();
       const { publicClient, walletClient } = connectStore.getState();
@@ -5422,6 +5449,21 @@ function createCofheClientBase(opts) {
       const sharingRegistry = await _resolveSharingRegistry(publicClient, chainId);
       return acps.shareOnChain(acp, walletClient, sharingRegistry, { ...withAppKey(), ...options });
     },
+    prepareShareOnChain: async (acp, options) => {
+      _requireConnected();
+      _requireIssuer(acp, "share it on-chain");
+      const { publicClient } = connectStore.getState();
+      const chainId = await publicClient.getChainId();
+      const sharingRegistry = await _resolveSharingRegistry(publicClient, chainId);
+      return acps.prepareShareOnChain(acp, sharingRegistry, { ...withAppKey(), ...options });
+    },
+    prepareRemoveShare: async (shareId) => {
+      _requireConnected();
+      const { publicClient } = connectStore.getState();
+      const chainId = await publicClient.getChainId();
+      const sharingRegistry = await _resolveSharingRegistry(publicClient, chainId);
+      return acps.prepareRemoveShare(shareId, sharingRegistry);
+    },
     getIncomingShares: async () => {
       _requireConnected();
       const { publicClient, walletClient } = connectStore.getState();

package/dist/web.d.cts

@@ -1,8 +1,8 @@
-import { I as IStorage, C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-IO6b5Um8.cjs';
+import { I as IStorage, C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-RXwLVWou.cjs';
 import 'viem';
 import './types-C07FK-cL.cjs';
 import 'zod';
-import './onchain-utils-CgOslubH.cjs';
+import './onchain-utils-Ns56cBm0.cjs';
 import 'zustand/vanilla';
 
 declare function createSsrStorage(): IStorage;

package/dist/web.d.ts

@@ -1,8 +1,8 @@
-import { I as IStorage, C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-b1pOxOUE.js';
+import { I as IStorage, C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-CnslFzxB.js';
 import 'viem';
 import './types-C07FK-cL.js';
 import 'zod';
-import './onchain-utils-CgOslubH.js';
+import './onchain-utils-Ns56cBm0.js';
 import 'zustand/vanilla';
 
 declare function createSsrStorage(): IStorage;

package/dist/web.js

@@ -1,4 +1,4 @@
-import { createCofheConfigBase, createCofheClientBase } from './chunk-O2ITEUEU.js';
+import { createCofheConfigBase, createCofheClientBase } from './chunk-2EO4JSR7.js';
 import './chunk-UKQAJK4N.js';
 import './chunk-3L2IVPMI.js';
 import { initTfheThreadPool } from './chunk-KSOV5B4B.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cofhe/sdk",
-  "version": "1.0.0",
+  "version": "1.1.0-alpha.0",
   "type": "module",
   "description": "SDK for Fhenix COFHE coprocessor interaction",
   "main": "./dist/core.cjs",
@@ -102,8 +102,8 @@
     "typescript": "5.5.4",
     "vitest": "3.2.4",
     "@cofhe/eslint-config": "0.2.1",
-    "@cofhe/tsconfig": "0.1.2",
-    "@cofhe/test-setup": "0.0.0"
+    "@cofhe/test-setup": "0.0.0",
+    "@cofhe/tsconfig": "0.1.2"
   },
   "publishConfig": {
     "access": "public",