@cofhe/sdk 1.0.1 → 1.1.0-alpha.1

package/core/encrypt/zkPackProveVerify.ts

@@ -239,24 +239,13 @@ export const zkProve = async (
 };
 
 /**
- * Constructs the ZK Proof of Knowledge metadata for the proof:
- * `securityZone (1) || account (20) || chainId (32, big-endian) || consumingContract (20)`.
- *
- * The verifier rebuilds the same bytes from the request fields before it checks the proof, so the
- * proof is bound to the consuming contract itself, not only to the signature the verifier returns.
+ * Constructs the ZK Proof of Knowledge metadata for the proof
  * @internal - Used internally within the encrypt module
  */
-export const constructZkPoKMetadata = (
-  accountAddr: string,
-  securityZone: number,
-  chainId: number,
-  consumingContract: string
-): Uint8Array => {
-  // Decode the account and contract addresses from hex
+export const constructZkPoKMetadata = (accountAddr: string, securityZone: number, chainId: number): Uint8Array => {
+  // Decode the account address from hex
   const accountAddrNoPrefix = accountAddr.startsWith('0x') ? accountAddr.slice(2) : accountAddr;
   const accountBytes = hexToBytes(accountAddrNoPrefix);
-  const contractNoPrefix = consumingContract.startsWith('0x') ? consumingContract.slice(2) : consumingContract;
-  const contractBytes = hexToBytes(contractNoPrefix);
 
   // Encode chainId as 32 bytes (u256) in big-endian format
   const chainIdBytes = new Uint8Array(32);
@@ -270,11 +259,10 @@ export const constructZkPoKMetadata = (
     value = value >>> 8;
   }
 
-  const metadata = new Uint8Array(1 + accountBytes.length + 32 + contractBytes.length);
+  const metadata = new Uint8Array(1 + accountBytes.length + 32);
   metadata[0] = securityZone;
   metadata.set(accountBytes, 1);
   metadata.set(chainIdBytes, 1 + accountBytes.length);
-  metadata.set(contractBytes, 1 + accountBytes.length + 32);
 
   return metadata;
 };

package/core/error.ts

@@ -16,7 +16,6 @@ export enum CofheErrorCode {
   AccountUninitialized = 'ACCOUNT_UNINITIALIZED',
   ChainIdUninitialized = 'CHAIN_ID_UNINITIALIZED',
   ConsumingContractUninitialized = 'CONSUMING_CONTRACT_UNINITIALIZED',
-  ConsumingContractInvalid = 'CONSUMING_CONTRACT_INVALID',
   SealOutputFailed = 'SEAL_OUTPUT_FAILED',
   SealOutputReturnedNull = 'SEAL_OUTPUT_RETURNED_NULL',
   InvalidUtype = 'INVALID_UTYPE',

package/core/test/acpsPrepare.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from 'vitest';
+import type { Hex } from 'viem';
+import { ACP_REVOKER_ABI, ACP_SHARE_REGISTRY_ABI, computeShareId, encodeShareMetadata, toChainShare } from '@/acps';
+import { UNLABELLED } from '../../acps/share-metadata';
+import { createMockACP } from '../../acps/test-utils';
+import { acps } from '../acps';
+
+/**
+ * The sharing writes built but not sent: what a caller that sends through its own path
+ * (simulation, transaction store) gets, and what the plain senders send. No chain involved.
+ */
+
+const REGISTRY = '0x00000000000000000000000000000000000000A1';
+const REVOKER = '0x00000000000000000000000000000000000000B2';
+const ALICE = '0x70997970C51812dc3A010C7d01b50e0d17dc79C8';
+const HANDLE: Hex = `0x${'1'.repeat(64)}`;
+
+const signedSharing = (overrides: Parameters<typeof createMockACP>[0] = {}) =>
+  createMockACP({ type: 'sharing', recipient: ALICE, issuerSignature: '0x1234', ...overrides });
+
+describe('prepareShareOnChain', () => {
+  it('a signed sharing acp: the registry share call with the acp and its metadata, and its share id', async () => {
+    const acp = await signedSharing();
+    const { write, shareId } = acps.prepareShareOnChain(acp, REGISTRY);
+    expect(write).toStrictEqual({
+      address: REGISTRY,
+      abi: ACP_SHARE_REGISTRY_ABI,
+      functionName: 'share',
+      args: [toChainShare(acp), '0x'],
+    });
+    expect(shareId).toBe(computeShareId(acp));
+  });
+
+  it('posts the labels it is given, else the metadata on the acp', async () => {
+    const acp = await signedSharing({ handles: [HANDLE] });
+    const labelled = acps.prepareShareOnChain(acp, REGISTRY, { labels: [UNLABELLED] });
+    expect(labelled.write.args[1]).toBe(encodeShareMetadata([UNLABELLED], { issuer: acp.issuer }));
+
+    const kept = acps.prepareShareOnChain({ ...acp, metadata: '0xdead' }, REGISTRY);
+    expect(kept.write.args[1]).toBe('0xdead');
+  });
+
+  it('refuses a self acp and an unsigned sharing acp', async () => {
+    const self = await createMockACP();
+    expect(() => acps.prepareShareOnChain(self, REGISTRY)).toThrow(/only 'sharing' ACPs/);
+    const unsigned = await createMockACP({ type: 'sharing', recipient: ALICE });
+    expect(() => acps.prepareShareOnChain(unsigned, REGISTRY)).toThrow(/sign it first/);
+  });
+});
+
+describe('prepareRemoveShare', () => {
+  it('the registry removeShare call for the share id', () => {
+    expect(acps.prepareRemoveShare(HANDLE, REGISTRY)).toStrictEqual({
+      address: REGISTRY,
+      abi: ACP_SHARE_REGISTRY_ABI,
+      functionName: 'removeShare',
+      args: [HANDLE],
+    });
+  });
+});
+
+describe('prepareRevokeACP', () => {
+  it('the revoker revokeSingle call for the acp revoker data', async () => {
+    const acp = await signedSharing({ revokerContract: REVOKER, revokerData: 42 });
+    expect(acps.prepareRevokeACP(acp)).toStrictEqual({
+      address: REVOKER,
+      abi: ACP_REVOKER_ABI,
+      functionName: 'revokeSingle',
+      args: [42n],
+    });
+  });
+
+  it('refuses an acp without a revoker', async () => {
+    const acp = await signedSharing();
+    expect(() => acps.prepareRevokeACP(acp)).toThrow(/not revocable/);
+  });
+});

package/core/test/decryptBuilders.test.ts

@@ -224,6 +224,21 @@ describe('DecryptForTxBuilder', () => {
 
       expect(() => builder.set404RetryTimeout(-1)).toThrow('set404RetryTimeout(timeoutMs) expects');
     });
+
+    it('should allow configuring the overall timeout', () => {
+      const builder = createTxBuilder();
+      const result = builder.setTimeout(20_000);
+
+      expect(result).toBe(builder);
+      expect((builder as any).timeoutMs).toBe(20_000);
+    });
+
+    it('should throw for an overall timeout that is not a positive number', () => {
+      const builder = createTxBuilder();
+
+      expect(() => builder.setTimeout(0)).toThrow('setTimeout(timeoutMs) expects');
+      expect(() => builder.setTimeout(Number.NaN)).toThrow('setTimeout(timeoutMs) expects');
+    });
   });
 
   // --- execute error paths ---
@@ -367,6 +382,21 @@ describe('DecryptForViewBuilder', () => {
 
       expect(() => builder.set404RetryTimeout(-1)).toThrow('set404RetryTimeout(timeoutMs) expects');
     });
+
+    it('should allow configuring the overall timeout', () => {
+      const builder = createViewBuilder(FheTypes.Uint32);
+      const result = builder.setTimeout(20_000);
+
+      expect(result).toBe(builder);
+      expect((builder as any).timeoutMs).toBe(20_000);
+    });
+
+    it('should throw for an overall timeout that is not a positive number', () => {
+      const builder = createViewBuilder(FheTypes.Uint32);
+
+      expect(() => builder.setTimeout(0)).toThrow('setTimeout(timeoutMs) expects');
+      expect(() => builder.setTimeout(-5)).toThrow('setTimeout(timeoutMs) expects');
+    });
   });
 
   // --- execute error paths ---
@@ -503,6 +533,16 @@ describe('execute – expired acp (regression, issue #272)', () => {
       expect(result.decryptedValue).toBe(7n);
       expect(tnDecryptV2).toHaveBeenCalledOnce();
     });
+
+    it('passes the overall timeout to the threshold network call', async () => {
+      vi.mocked(tnDecryptV2).mockResolvedValue({ decryptedValue: 7n, signature: '0x1234' });
+      const acp = createSignedSelfACP(now() + 3600);
+      seedACP(acp);
+
+      await selectTxACP('active acp', acp).setTimeout(20_000).execute();
+
+      expect(tnDecryptV2).toHaveBeenCalledWith(expect.objectContaining({ timeoutMs: 20_000 }));
+    });
   });
 
   describe('decryptForView', () => {
@@ -522,5 +562,16 @@ describe('execute – expired acp (regression, issue #272)', () => {
       await expect(selectViewACP('active acp', acp).execute()).rejects.toThrow('stubbed threshold network');
       expect(tnSealOutputV2).toHaveBeenCalledOnce();
     });
+
+    it('passes the overall timeout to the threshold network call', async () => {
+      vi.mocked(tnSealOutputV2).mockRejectedValue(new Error('stubbed threshold network'));
+      const acp = createSignedSelfACP(now() + 3600);
+      seedACP(acp);
+
+      await expect(selectViewACP('active acp', acp).setTimeout(20_000).execute()).rejects.toThrow(
+        'stubbed threshold network'
+      );
+      expect(tnSealOutputV2).toHaveBeenCalledWith(expect.objectContaining({ timeoutMs: 20_000 }));
+    });
   });
 });

package/core/test/encryptInputsBuilder.test.ts

@@ -10,7 +10,7 @@ import {
 } from '../types.js';
 import { CofheError, CofheErrorCode } from '../error.js';
 import { fromHexString, toHexString } from '../utils.js';
-import { type PublicClient, createPublicClient, http, type WalletClient, createWalletClient, isAddress } from 'viem';
+import { type PublicClient, createPublicClient, http, type WalletClient, createWalletClient } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import { arbitrumSepolia } from 'viem/chains';
 import { type CofheConfig, createCofheConfigBase } from '../config.js';
@@ -53,9 +53,9 @@ const unpackMetadata = (metadata: string) => {
 
 export const deconstructZkPoKMetadata = (
   metadata: Uint8Array
-): { accountAddr: string; securityZone: number; chainId: number; contractAddr: string } => {
-  if (metadata.length < 73) {
-    // 1 + 20 + 32 + 20 = 73 bytes minimum
+): { accountAddr: string; securityZone: number; chainId: number } => {
+  if (metadata.length < 53) {
+    // 1 + 20 + 32 = 53 bytes minimum
     throw new CofheError({
       code: CofheErrorCode.InternalError,
       message: 'Invalid metadata: insufficient length',
@@ -78,14 +78,10 @@ export const deconstructZkPoKMetadata = (
     chainId = (chainId << 8) | chainIdBytes[i];
   }
 
-  // Extract the consuming contract (last 20 bytes)
-  const contractAddr = '0x' + toHexString(metadata.slice(53, 73));
-
   return {
     accountAddr,
     securityZone,
     chainId,
-    contractAddr,
   };
 };
 
@@ -449,38 +445,6 @@ describe('EncryptInputsBuilder', () => {
         expect((error as CofheError).code).toBe(CofheErrorCode.ConsumingContractUninitialized);
       }
     });
-
-    it('accepts a mixed-case consuming contract whose checksum is wrong', async () => {
-      // The verifier decodes the address case-insensitively and the chain compares
-      // 20 bytes, so a 1.0.0 dApp with such an address must keep working.
-      const wrongChecksum = '0xBEEFbeefBEEFbeefBEEFbeefBEEFbeefBEEFbeef';
-      expect(isAddress(wrongChecksum)).toBe(false);
-      expect(isAddress(wrongChecksum, { strict: false })).toBe(true);
-
-      const result = await new EncryptInputsBuilder(createDefaultParams())
-        .setConsumingContract(wrongChecksum)
-        .execute();
-
-      expect(Array.isArray(result)).toBe(true);
-    });
-
-    it('rejects a consuming contract that is not an address before any encrypt step runs', async () => {
-      for (const notAnAddress of ['0x0', 'not-an-address', '0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbee']) {
-        const steps = vi.fn();
-        const invalid = new EncryptInputsBuilder(createDefaultParams())
-          .setConsumingContract(notAnAddress)
-          .onStep(steps);
-        try {
-          await invalid.execute();
-          expect.unreachable(`execute() should have thrown for ${notAnAddress}`);
-        } catch (error) {
-          expect(error, notAnAddress).toBeInstanceOf(CofheError);
-          expect((error as CofheError).code, notAnAddress).toBe(CofheErrorCode.ConsumingContractInvalid);
-        }
-        // Rejected before initTfhe, so no step (and no proving) ever started.
-        expect(steps, notAnAddress).not.toHaveBeenCalled();
-      }
-    });
   });
 
   describe('zkVerifierUrl', () => {
@@ -631,22 +595,6 @@ describe('EncryptInputsBuilder', () => {
       expect(encryptedMetadata.chainId).toBe(defaultChainId);
     });
 
-    it('binds the consuming contract into the proof metadata', async () => {
-      mockFetch.mockClear();
-
-      await builder.execute();
-
-      const verifyCall = mockFetch.mock.calls.find(([url]) => url === `${MockZkVerifierUrl}/verifyBatch`);
-      expect(verifyCall).toBeDefined();
-      const body = JSON.parse(verifyCall![1].body as string);
-      const { metadata } = parseWithBigInt(new TextDecoder().decode(fromHexString(body.packed_list)));
-      const embedded = deconstructZkPoKMetadata(Uint8Array.from(Object.values(metadata) as number[]));
-      expect(embedded.accountAddr).toBe(defaultSender);
-      expect(embedded.securityZone).toBe(0);
-      expect(embedded.chainId).toBe(defaultChainId);
-      expect(embedded.contractAddr).toBe(defaultConsumingContract);
-    });
-
     it('should use overridden account when set', async () => {
       const overriddenSender = '0x5555555555555555555555555555555555555555';
       builder.setAccount(overriddenSender);

package/dist/acps.d.cts

@@ -1,364 +1,10 @@
-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-CgOslubH.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-CgOslubH.cjs';
-import { Hex, AbiParameterToPrimitiveType, Address, PublicClient, Abi, ContractFunctionName, ContractFunctionArgs, Log } from 'viem';
+import { S as ShareLabel, a as StoredValueLabel, E as EventValueLabel, L as LabelledShare, A as ACP, V as ValidationResult, b as ACPPublic, c as ACPSignaturePrimaryType, d as EIP712Types, e as EIP712Message, f as SerializedACP } from './onchain-utils-Ns56cBm0.cjs';
+export { a4 as ACPAccessStatus, a5 as ACPHashFields, h as ACPMetadata, _ as ACPOf, Y as ACPPrivate, a2 as ACPScope, a3 as ACPScopeOptions, Z as ACPType, l as ACPUtils, t as ACP_REVOKER_ABI, v as ACP_SHARE_REGISTRY_ABI, w as ACP_SHARE_TUPLE_ABI, p as AclServedAddresses, B as ChainShare, C as CreateSelfACPOptions, g as CreateSharingACPOptions, k as EIP712Domain, X as EIP712Type, r as EthEncryptedData, a6 as Expand, G as GenerateSealingKey, I as ImportACPOptions, I as ImportSharedACPOptions, j as IncomingShare, O as LabelVerification, P as PostedShare, F as PostedShares, a1 as RecipientACP, q as SealingKeyPair, $ as SelfACP, C as SelfACPOptions, D as ShareHeader, R as ShareLabelCheck, M as ShareLabelReadArg, Q as ShareLabelVerifyMode, i as SharedACP, a0 as SharingACP, g as SharingACPOptions, N as UnlabelledLabel, U as UnreadableShare, o as clearAclServedAddresses, y as computeShareId, m as getAclAddress, n as getAclServedAddresses, H as readPostedShares, K as readShare, J as readSharesFor, s as seal, z as shareIdOfChainShare, x as toChainShare, u as unsealWithPrivateKey, T as verifyShareLabel, W as verifyShareLabels } from './onchain-utils-Ns56cBm0.cjs';
+import { Address, Hex, Abi, ContractFunctionName, ContractFunctionArgs, Log } from 'viem';
 import { z } from 'zod';
 import * as zustand_middleware from 'zustand/middleware';
 import * as zustand_vanilla from 'zustand/vanilla';
 
-/**
- * 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.
  *
@@ -1056,4 +702,4 @@ declare const acpStore: {
     resetStore: () => void;
 };
 
-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 };
+export { ACP, ACPPublic, ACPSignaturePrimaryType, ACP_STORE_DEFAULTS, type DecodedShareMetadata, EIP712Message, EIP712Types, ERC7984_ABI, type EventValueDescription, EventValueLabel, ImportACPOptionsValidator, ImportACPValidator, LabelledShare, LAYOUT_VERSION as SHARE_METADATA_VERSION, SelfACPOptionsValidator, SelfACPValidator, SerializedACP, ShareLabel, type ShareLabelAbis, type ShareLabelArg, type ShareLabelDescription, type ShareLabelParam, SharingACPOptionsValidator, SharingACPValidator, SignatureTypes, SignatureUtils, type StoredValueDescription, StoredValueLabel, UNLABELLED, type UnlabelledDescription, ValidationResult, ValidationUtils, type ViewFunctionLabelOptions, _acpStore, acpStore, addressNotZeroSchema, addressSchema, bytesNotEmptySchema, bytesSchema, clearStaleStore, contractsSchema, decodeShareAppKey, decodeShareMetadata, decodeShareMetadataFull, describeShareLabels, describeShareMetadata, encodeShareMetadata, eventLogLabel, getACP, getACPs, getActiveACP, getActiveACPHash, getSignatureTypesAndMessage, handlesSchema, removeACP, removeActiveACPHash, resetStore, setACP, setActiveACPHash, shareAppKey, validateImportACP, validateImportACPOptions, validateSelfACP, validateSelfACPOptions, validateSharingACP, validateSharingACPOptions, viewFunctionLabel };