@cofhe/sdk 0.6.0 → 0.7.0

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-BDy1qIBu.cjs';
+import { I as IStorage, C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-CYZjFznO.cjs';
 import 'viem';
 import './types-C07FK-cL.cjs';
 import 'zod';
-import './permit-DnVMDT5h.cjs';
+import './acp-Wi6isVQI.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-CyUvRRzA.js';
+import { I as IStorage, C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-BN3nbzYM.js';
 import 'viem';
 import './types-C07FK-cL.js';
 import 'zod';
-import './permit-DnVMDT5h.js';
+import './acp-Wi6isVQI.js';
 import 'zustand/vanilla';
 
 declare function createSsrStorage(): IStorage;

package/dist/web.js

@@ -1,6 +1,6 @@
-import { createCofheConfigBase, createCofheClientBase, fheTypeToString } from './chunk-PE5V5CCV.js';
-import './chunk-MTRAXQXC.js';
-import './chunk-VB62WYPL.js';
+import { createCofheConfigBase, createCofheClientBase, fheTypeToString } from './chunk-43USWPEH.js';
+import './chunk-N6IDQRRU.js';
+import './chunk-Q7CBWGQX.js';
 import { TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT } from './chunk-ESMZCFJY.js';
 import { constructClient } from 'iframe-shared-storage';
 

package/node/test/inherited.test.ts

@@ -1,9 +1,11 @@
+import { STAGING_TESTS, stagingViemChain } from '../../core/test/stagingRedirect';
 import { Encryptable, FheTypes, type CofheClient } from '@/core';
-import { arbSepolia as cofheArbSepolia, getChainById } from '@/chains';
+import { arbSepolia as cofheArbSepolia, getChainById, stagingCofhe } from '@/chains';
 import {
   TEST_PRIVATE_KEY,
   PRIMARY_TEST_CHAIN,
   primaryTestChainRegistry,
+  stagingTestChainRegistry,
   isPrimaryTestChainReady,
 } from '@cofhe/test-setup';
 
@@ -27,6 +29,9 @@ const VIEM_CHAINS: Record<number, Chain> = {
   11155111: sepolia,
 };
 
+const testViemChain = STAGING_TESTS ? stagingViemChain : arbitrumSepolia;
+const testCofheChain = STAGING_TESTS ? stagingCofhe : cofheArbSepolia;
+
 describe('@cofhe/node - Inherited Client Tests', () => {
   let cofheClient: CofheClient;
   let publicClient: PublicClient;
@@ -35,18 +40,18 @@ describe('@cofhe/node - Inherited Client Tests', () => {
 
   beforeAll(() => {
     publicClient = createPublicClient({
-      chain: arbitrumSepolia,
+      chain: testViemChain,
       transport: http(),
     });
 
     bobWalletClient = createWalletClient({
-      chain: arbitrumSepolia,
+      chain: testViemChain,
       transport: http(),
       account: bobAccount,
     });
 
     aliceWalletClient = createWalletClient({
-      chain: arbitrumSepolia,
+      chain: testViemChain,
       transport: http(),
       account: aliceAccount,
     });
@@ -54,7 +59,7 @@ describe('@cofhe/node - Inherited Client Tests', () => {
 
   beforeEach(() => {
     const config = createCofheConfig({
-      supportedChains: [cofheArbSepolia],
+      supportedChains: [testCofheChain],
     });
     cofheClient = createCofheClient(config);
   });
@@ -71,7 +76,7 @@ describe('@cofhe/node - Inherited Client Tests', () => {
       expect(typeof cofheClient.decryptForTx).toBe('function');
       expect(typeof cofheClient.getSnapshot).toBe('function');
       expect(typeof cofheClient.subscribe).toBe('function');
-      expect(cofheClient.permits).toBeDefined();
+      expect(cofheClient.acp).toBeDefined();
     });
   });
 
@@ -83,7 +88,7 @@ describe('@cofhe/node - Inherited Client Tests', () => {
 
       const snapshot = cofheClient.getSnapshot();
       expect(snapshot.connected).toBe(true);
-      expect(snapshot.chainId).toBe(cofheArbSepolia.id);
+      expect(snapshot.chainId).toBe(testCofheChain.id);
       expect(snapshot.account).toBe(bobAccount.address);
     }, 30000);
   });
@@ -92,81 +97,85 @@ describe('@cofhe/node - Inherited Client Tests', () => {
     it('should encrypt a uint128 value', async () => {
       await cofheClient.connect(publicClient, bobWalletClient);
 
-      const encrypted = await cofheClient.encryptInputs([Encryptable.uint128(100n)]).execute();
+      const encrypted = await cofheClient
+        .encryptInputs([Encryptable.uint128(100n)])
+        .setConsumingContract(bobAccount.address)
+        .execute();
 
+      // [hash, signature] - one hash per input, followed by the shared batch signature.
       expect(encrypted).toBeDefined();
-      expect(encrypted.length).toBe(1);
-      expect(encrypted[0].utype).toBe(FheTypes.Uint128);
-      expect(encrypted[0].ctHash).toBeDefined();
-      expect(typeof encrypted[0].ctHash).toBe('bigint');
-      expect(encrypted[0].signature).toBeDefined();
-      expect(typeof encrypted[0].signature).toBe('string');
-      expect(encrypted[0].securityZone).toBe(0);
-    }, 60000);
+      expect(encrypted.length).toBe(2);
+
+      const [hash, signature] = encrypted;
+      expect(typeof hash).toBe('string');
+      expect(hash).toMatch(/^0x[0-9a-fA-F]+$/);
+      expect(typeof signature).toBe('string');
+      expect(signature).toMatch(/^0x[0-9a-fA-F]+$/);
+    }, 120000);
   });
 
-  describe('Self Permit', () => {
-    it('should create a self permit', async () => {
+  describe('Self ACP', () => {
+    it('should create a self acp', async () => {
       await cofheClient.connect(publicClient, bobWalletClient);
 
-      const permit = await cofheClient.permits.createSelf({
+      const acp = await cofheClient.acp.createSelf({
         issuer: bobAccount.address,
-        name: 'Test Self Permit',
+        name: 'Test Self ACP',
       });
 
-      expect(permit).toBeDefined();
-      expect(permit.type).toBe('self');
-      expect(permit.name).toBe('Test Self Permit');
-      expect(permit.issuer).toBe(bobAccount.address);
-      expect(permit.issuerSignature).not.toBe('0x');
-      expect(permit.sealingPair).toBeDefined();
-      expect(permit.sealingPair.publicKey).toBeDefined();
-
-      const activePermit = cofheClient.permits.getActivePermit();
-      expect(activePermit).toBeDefined();
-      expect(activePermit!.hash).toBe(permit.hash);
+      expect(acp).toBeDefined();
+      expect(acp.type).toBe('self');
+      expect(acp.name).toBe('Test Self ACP');
+      expect(acp.issuer).toBe(bobAccount.address);
+      expect(acp.issuerSignature).not.toBe('0x');
+      expect(acp.sealingPrivateKey).toBeDefined();
+      expect(acp.sealingKey).toBeDefined();
+
+      const activeACP = cofheClient.acp.getActiveACP();
+      expect(activeACP).toBeDefined();
+      expect(activeACP!.hash).toBe(acp.hash);
     }, 30000);
   });
 
-  describe('Sharing Permit', () => {
-    it('should create a sharing permit, export it, and import it as another user', async () => {
+  describe('Sharing ACP', () => {
+    it('should create a sharing acp, export it, and import it as another user', async () => {
       await cofheClient.connect(publicClient, bobWalletClient);
 
-      const sharingPermit = await cofheClient.permits.createSharing({
+      const sharingACP = await cofheClient.acp.createSharing({
         issuer: bobAccount.address,
         recipient: aliceAccount.address,
-        name: 'Test Sharing Permit',
+        name: 'Test Sharing ACP',
       });
 
-      expect(sharingPermit).toBeDefined();
-      expect(sharingPermit.type).toBe('sharing');
-      expect(sharingPermit.issuer).toBe(bobAccount.address);
-      expect(sharingPermit.recipient).toBe(aliceAccount.address);
-      expect(sharingPermit.issuerSignature).not.toBe('0x');
+      expect(sharingACP).toBeDefined();
+      expect(sharingACP.type).toBe('sharing');
+      expect(sharingACP.issuer).toBe(bobAccount.address);
+      expect(sharingACP.recipient).toBe(aliceAccount.address);
+      expect(sharingACP.issuerSignature).not.toBe('0x');
 
-      const exported = cofheClient.permits.export(sharingPermit);
+      const exported = cofheClient.acp.export(sharingACP);
       expect(exported).toBeDefined();
       const parsed = JSON.parse(exported);
       expect(parsed.type).toBe('sharing');
       expect(parsed.issuer).toBe(bobAccount.address);
       expect(parsed.recipient).toBe(aliceAccount.address);
       expect(parsed.issuerSignature).toBeDefined();
-      expect(parsed).not.toHaveProperty('sealingPair');
+      expect(parsed).not.toHaveProperty('sealingPrivateKey');
 
       const aliceConfig = createCofheConfig({
-        supportedChains: [cofheArbSepolia],
+        supportedChains: [testCofheChain],
       });
       const aliceClient = createCofheClient(aliceConfig);
       await aliceClient.connect(publicClient, aliceWalletClient);
 
-      const importedPermit = await aliceClient.permits.importShared(exported);
+      const importedACP = await aliceClient.acp.importShared(exported);
 
-      expect(importedPermit).toBeDefined();
-      expect(importedPermit.type).toBe('recipient');
-      expect(importedPermit.issuer).toBe(bobAccount.address);
-      expect(importedPermit.recipient).toBe(aliceAccount.address);
-      expect(importedPermit.recipientSignature).not.toBe('0x');
-      expect(importedPermit.sealingPair).toBeDefined();
+      expect(importedACP).toBeDefined();
+      expect(importedACP.type).toBe('recipient');
+      expect(importedACP.issuer).toBe(bobAccount.address);
+      expect(importedACP.recipient).toBe(aliceAccount.address);
+      expect(importedACP.recipientSignature).not.toBe('0x');
+      expect(importedACP.sealingPrivateKey).toBeDefined();
     }, 30000);
   });
 
@@ -181,15 +190,16 @@ describe('@cofhe/node - Inherited Client Tests', () => {
     let publicValue: bigint;
 
     beforeAll(() => {
-      if (!isPrimaryTestChainReady(primaryTestChainRegistry)) {
-        throw new Error('Primary test chain registry not initialized. Run `pnpm test:setup` first.');
+      const reg = STAGING_TESTS
+        ? (stagingTestChainRegistry as typeof primaryTestChainRegistry)
+        : primaryTestChainRegistry;
+      if (!isPrimaryTestChainReady(reg)) {
+        throw new Error('Test chain registry not initialized. Run `pnpm test:setup` first.');
       }
-
-      const reg = primaryTestChainRegistry;
-      const viemChain = VIEM_CHAINS[reg.chainId];
+      const viemChain = STAGING_TESTS ? stagingViemChain : VIEM_CHAINS[reg.chainId];
       if (!viemChain) throw new Error(`No viem chain mapping for chain ${reg.chainId}`);
 
-      const cofheChain = getChainById(reg.chainId);
+      const cofheChain = STAGING_TESTS ? stagingCofhe : getChainById(reg.chainId);
       if (!cofheChain) throw new Error(`No cofhe chain config for chain ${reg.chainId}`);
 
       privateCtHash = reg.privateValue.ctHash as `0x${string}`;
@@ -204,37 +214,37 @@ describe('@cofhe/node - Inherited Client Tests', () => {
       decryptClient = createCofheClient(config);
     });
 
-    it('decryptForView — private value with permit', async () => {
+    it('decryptForView — private value with acp', async () => {
       await decryptClient.connect(decryptPublicClient, decryptWalletClient);
 
-      await decryptClient.permits.createSelf({
+      await decryptClient.acp.createSelf({
         issuer: bobAccount.address,
-        name: 'Decrypt View Permit',
+        name: 'Decrypt View ACP',
       });
 
       const result = await decryptClient.decryptForView(privateCtHash, FheTypes.Uint32).execute();
       expect(result).toBe(privateValue);
     }, 180000);
 
-    it('decryptForTx — public value without permit', async () => {
+    it('decryptForTx — public value without acp', async () => {
       await decryptClient.connect(decryptPublicClient, decryptWalletClient);
 
-      const result = await decryptClient.decryptForTx(publicCtHash).withoutPermit().execute();
+      const result = await decryptClient.decryptForTx(publicCtHash).withoutACP().execute();
 
       expect(BigInt(result.ctHash)).toBe(BigInt(publicCtHash));
       expect(result.decryptedValue).toBe(publicValue);
       expect(result.signature).toMatch(/^0x[0-9a-fA-F]+$/);
     }, 180000);
 
-    it('decryptForTx — private value with permit', async () => {
+    it('decryptForTx — private value with acp', async () => {
       await decryptClient.connect(decryptPublicClient, decryptWalletClient);
 
-      const permit = await decryptClient.permits.createSelf({
+      const acp = await decryptClient.acp.createSelf({
         issuer: bobAccount.address,
-        name: 'Decrypt Tx Permit',
+        name: 'Decrypt Tx ACP',
       });
 
-      const result = await decryptClient.decryptForTx(privateCtHash).withPermit(permit).execute();
+      const result = await decryptClient.decryptForTx(privateCtHash).withACP(acp).execute();
 
       expect(BigInt(result.ctHash)).toBe(BigInt(privateCtHash));
       expect(result.decryptedValue).toBe(privateValue);

package/node/test/tfheinit.test.ts

@@ -1,5 +1,6 @@
+import { STAGING_TESTS, stagingViemChain } from '../../core/test/stagingRedirect';
 import { Encryptable, type CofheClient } from '@/core';
-import { arbSepolia as cofheArbSepolia } from '@/chains';
+import { arbSepolia as cofheArbSepolia, stagingCofhe } from '@/chains';
 
 import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
 import type { PublicClient, WalletClient } from 'viem';
@@ -10,28 +11,33 @@ import { createCofheClient, createCofheConfig } from '../index.js';
 
 const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
 
+const testViemChain = STAGING_TESTS ? stagingViemChain : viemArbitrumSepolia;
+const testCofheChain = STAGING_TESTS ? stagingCofhe : cofheArbSepolia;
+
 describe('@cofhe/node - TFHE Initialization Tests', () => {
   let cofheClient: CofheClient;
   let publicClient: PublicClient;
   let walletClient: WalletClient;
+  let consumingContract: `0x${string}`;
 
   beforeAll(() => {
     publicClient = createPublicClient({
-      chain: viemArbitrumSepolia,
+      chain: testViemChain,
       transport: http(),
     });
 
     const account = privateKeyToAccount(TEST_PRIVATE_KEY);
     walletClient = createWalletClient({
-      chain: viemArbitrumSepolia,
+      chain: testViemChain,
       transport: http(),
       account,
     });
+    consumingContract = account.address;
   });
 
   beforeEach(() => {
     const config = createCofheConfig({
-      supportedChains: [cofheArbSepolia],
+      supportedChains: [testCofheChain],
     });
     cofheClient = createCofheClient(config);
   });
@@ -40,17 +46,26 @@ describe('@cofhe/node - TFHE Initialization Tests', () => {
     it('should initialize node-tfhe on first encryption', async () => {
       await cofheClient.connect(publicClient, walletClient);
 
-      const result = await cofheClient.encryptInputs([Encryptable.uint128(100n)]).execute();
+      const result = await cofheClient
+        .encryptInputs([Encryptable.uint128(100n)])
+        .setConsumingContract(consumingContract)
+        .execute();
 
       expect(result).toBeDefined();
-    }, 60000);
+    }, 120000);
 
     it('should handle multiple encryptions without re-initializing', async () => {
       await cofheClient.connect(publicClient, walletClient);
 
-      await cofheClient.encryptInputs([Encryptable.uint128(100n)]).execute();
+      await cofheClient
+        .encryptInputs([Encryptable.uint128(100n)])
+        .setConsumingContract(consumingContract)
+        .execute();
 
-      await cofheClient.encryptInputs([Encryptable.uint64(50n)]).execute();
+      await cofheClient
+        .encryptInputs([Encryptable.uint64(50n)])
+        .setConsumingContract(consumingContract)
+        .execute();
     }, 120000);
   });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cofhe/sdk",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "type": "module",
   "description": "SDK for Fhenix COFHE coprocessor interaction",
   "main": "./dist/core.cjs",
@@ -23,10 +23,10 @@
       "require": "./dist/chains.cjs",
       "types": "./dist/chains.d.ts"
     },
-    "./permits": {
-      "import": "./dist/permits.js",
-      "require": "./dist/permits.cjs",
-      "types": "./dist/permits.d.ts"
+    "./acps": {
+      "import": "./dist/acps.js",
+      "require": "./dist/acps.cjs",
+      "types": "./dist/acps.d.ts"
     },
     "./node": {
       "import": "./dist/node.js",
@@ -51,7 +51,7 @@
     "core/**",
     "adapters/**",
     "chains/**",
-    "permits/**",
+    "acps/**",
     "node/**",
     "web/**",
     "CHANGELOG.md"

package/web/test/client.web.test.ts

@@ -130,7 +130,11 @@ describe('@cofhe/web - Client', () => {
       expect(typeof builder.setChainId).toBe('function');
       expect(typeof builder.setAccount).toBe('function');
       expect(typeof builder.setSecurityZone).toBe('function');
-      expect(typeof builder.execute).toBe('function');
+      expect(typeof builder.setConsumingContract).toBe('function');
+      // execute() only exists once a consuming contract has been committed to.
+      expect(typeof builder.setConsumingContract('0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef').execute).toBe(
+        'function'
+      );
     }, 30000);
 
     it('should create decrypt builder after connection', async () => {