@cofhe/sdk 0.6.0 → 0.7.0

package/core/test/apiError.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect } from 'vitest';
+import { mapApiErrorCodeToCofheErrorCode, parseApiErrorResponseBody } from '../decrypt/apiError.js';
+import { CofheErrorCode } from '../error.js';
+
+const makeResponse = (opts: { status?: number; statusText?: string; json: () => Promise<unknown> }): Response => {
+  return {
+    status: opts.status ?? 500,
+    statusText: opts.statusText ?? '',
+    json: opts.json,
+  } as unknown as Response;
+};
+
+describe('mapApiErrorCodeToCofheErrorCode', () => {
+  const cases: Array<[string, CofheErrorCode]> = [
+    ['bad_request', CofheErrorCode.BadRequest],
+    ['unknown_chain', CofheErrorCode.UnknownChain],
+    ['acp_malformed', CofheErrorCode.ACPMalformed],
+    ['acp_denied', CofheErrorCode.ACPDenied],
+    ['acp_expired', CofheErrorCode.ACPExpired],
+    ['acp_invalid', CofheErrorCode.ACPInvalid],
+    ['not_publicly_allowed', CofheErrorCode.NotPubliclyAllowed],
+    ['ct_not_found', CofheErrorCode.CtNotFound],
+    ['unsupported_security_zone', CofheErrorCode.UnsupportedSecurityZone],
+    ['unsupported_type', CofheErrorCode.UnsupportedType],
+    ['internal_error', CofheErrorCode.InternalError],
+    ['signing_failed', CofheErrorCode.SigningFailed],
+    ['ct_source_error', CofheErrorCode.CtSourceError],
+    ['acp_verifier_error', CofheErrorCode.ACPVerifierError],
+    ['ct_source_timeout', CofheErrorCode.CtSourceTimeout],
+    ['acp_verifier_timeout', CofheErrorCode.ACPVerifierTimeout],
+    ['acp_required', CofheErrorCode.ACPRequired],
+    ['seal_failed', CofheErrorCode.SealFailed],
+  ];
+
+  it.each(cases)('maps %s to %s', (apiErrorCode, expected) => {
+    expect(mapApiErrorCodeToCofheErrorCode(apiErrorCode, CofheErrorCode.DecryptFailed)).toBe(expected);
+  });
+
+  it('falls back for an unrecognized code', () => {
+    expect(mapApiErrorCodeToCofheErrorCode('some_future_code', CofheErrorCode.DecryptFailed)).toBe(
+      CofheErrorCode.DecryptFailed
+    );
+  });
+
+  it('falls back for an undefined code', () => {
+    expect(mapApiErrorCodeToCofheErrorCode(undefined, CofheErrorCode.SealOutputFailed)).toBe(
+      CofheErrorCode.SealOutputFailed
+    );
+  });
+});
+
+describe('parseApiErrorResponseBody', () => {
+  it('reads error and error_message from a well-formed body', async () => {
+    const response = makeResponse({
+      status: 401,
+      json: async () => ({ error: 'acp_expired', error_message: 'acp has expired' }),
+    });
+
+    await expect(parseApiErrorResponseBody(response)).resolves.toEqual({
+      apiErrorCode: 'acp_expired',
+      errorMessage: 'acp has expired',
+    });
+  });
+
+  it('falls back to message when error_message is absent', async () => {
+    const response = makeResponse({
+      status: 500,
+      json: async () => ({ error: 'internal_error', message: 'boom' }),
+    });
+
+    await expect(parseApiErrorResponseBody(response)).resolves.toEqual({
+      apiErrorCode: 'internal_error',
+      errorMessage: 'boom',
+    });
+  });
+
+  it('falls back to HTTP <status> when body has neither error_message nor message', async () => {
+    const response = makeResponse({
+      status: 400,
+      json: async () => ({ error: 'bad_request' }),
+    });
+
+    await expect(parseApiErrorResponseBody(response)).resolves.toEqual({
+      apiErrorCode: 'bad_request',
+      errorMessage: 'HTTP 400',
+    });
+  });
+
+  it('falls back to statusText when the body is not JSON (framework rejection)', async () => {
+    const response = makeResponse({
+      status: 415,
+      statusText: 'Unsupported Media Type',
+      json: async () => {
+        throw new Error('Unexpected token in JSON');
+      },
+    });
+
+    await expect(parseApiErrorResponseBody(response)).resolves.toEqual({
+      apiErrorCode: undefined,
+      errorMessage: 'Unsupported Media Type',
+    });
+  });
+
+  it('falls back to HTTP <status> when the body is not JSON and statusText is empty', async () => {
+    const response = makeResponse({
+      status: 405,
+      statusText: '',
+      json: async () => {
+        throw new Error('Unexpected token in JSON');
+      },
+    });
+
+    await expect(parseApiErrorResponseBody(response)).resolves.toEqual({
+      apiErrorCode: undefined,
+      errorMessage: 'HTTP 405',
+    });
+  });
+
+  it('ignores a non-object JSON body', async () => {
+    const response = makeResponse({
+      status: 500,
+      json: async () => 'just a string',
+    });
+
+    await expect(parseApiErrorResponseBody(response)).resolves.toEqual({
+      apiErrorCode: undefined,
+      errorMessage: 'HTTP 500',
+    });
+  });
+});

package/core/test/client.test.ts

@@ -383,7 +383,10 @@ describe('createCofheClientBase', () => {
   describe('encryptInputs', () => {
     it('should throw if not connected', async () => {
       try {
-        await client.encryptInputs([Encryptable.uint8(1n), Encryptable.uint8(2n), Encryptable.uint8(3n)]).execute();
+        await client
+          .encryptInputs([Encryptable.uint8(1n), Encryptable.uint8(2n), Encryptable.uint8(3n)])
+          .setConsumingContract('0xbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef')
+          .execute();
       } catch (error) {
         expect(error).toBeInstanceOf(CofheError);
         expect((error as CofheError).code).toBe(CofheErrorCode.NotConnected);
@@ -406,24 +409,24 @@ describe('createCofheClientBase', () => {
     });
   });
 
-  describe('permits', () => {
-    it('should expose permits', () => {
-      expect(client.permits).toBeDefined();
-      expect(client.permits).toHaveProperty('getSnapshot');
-      expect(client.permits).toHaveProperty('subscribe');
-      expect(client.permits).toHaveProperty('createSelf');
-      expect(client.permits).toHaveProperty('createSharing');
-      expect(client.permits).toHaveProperty('importShared');
-      expect(client.permits).toHaveProperty('getHash');
-      expect(client.permits).toHaveProperty('serialize');
-      expect(client.permits).toHaveProperty('deserialize');
-      expect(client.permits).toHaveProperty('getPermit');
-      expect(client.permits).toHaveProperty('getPermits');
-      expect(client.permits).toHaveProperty('getActivePermit');
-      expect(client.permits).toHaveProperty('getActivePermitHash');
-      expect(client.permits).toHaveProperty('removePermit');
-      expect(client.permits).toHaveProperty('selectActivePermit');
-      expect(client.permits).toHaveProperty('removeActivePermit');
+  describe('acps', () => {
+    it('should expose acps', () => {
+      expect(client.acp).toBeDefined();
+      expect(client.acp).toHaveProperty('getSnapshot');
+      expect(client.acp).toHaveProperty('subscribe');
+      expect(client.acp).toHaveProperty('createSelf');
+      expect(client.acp).toHaveProperty('createSharing');
+      expect(client.acp).toHaveProperty('importShared');
+      expect(client.acp).toHaveProperty('getHash');
+      expect(client.acp).toHaveProperty('serialize');
+      expect(client.acp).toHaveProperty('deserialize');
+      expect(client.acp).toHaveProperty('getACP');
+      expect(client.acp).toHaveProperty('getACPs');
+      expect(client.acp).toHaveProperty('getActiveACP');
+      expect(client.acp).toHaveProperty('getActiveACPHash');
+      expect(client.acp).toHaveProperty('removeACP');
+      expect(client.acp).toHaveProperty('selectActiveACP');
+      expect(client.acp).toHaveProperty('removeActiveACP');
     });
   });
 });

package/core/test/config.test.ts

@@ -72,12 +72,12 @@ describe('createCofheConfigBase', () => {
     expectValidConfigItem('supportedChains', [sepolia, hardhat], [sepolia, hardhat]);
   });
 
-  it('defaultPermitExpiration', () => {
-    expectInvalidConfigItem('defaultPermitExpiration', 'not-a-number');
-    expectInvalidConfigItem('defaultPermitExpiration', null);
+  it('defaultACPExpiration', () => {
+    expectInvalidConfigItem('defaultACPExpiration', 'not-a-number');
+    expectInvalidConfigItem('defaultACPExpiration', null);
 
-    expectValidConfigItem('defaultPermitExpiration', 5, 5);
-    expectValidConfigItem('defaultPermitExpiration', undefined, 60 * 60 * 24 * 30);
+    expectValidConfigItem('defaultACPExpiration', 5, 5);
+    expectValidConfigItem('defaultACPExpiration', undefined, 60 * 60 * 24 * 30);
   });
 
   it('fheKeyStorage', async () => {
@@ -240,3 +240,23 @@ describe('Config helper functions', () => {
     });
   });
 });
+
+describe('createCofheConfigBase - stale key rejection', () => {
+  const validBaseConfig: CofheInputConfig = { supportedChains: [] };
+
+  it('rejects the pre-ACP defaultPermitExpiration and names its replacement', () => {
+    expect(() =>
+      createCofheConfigBase({ ...validBaseConfig, defaultPermitExpiration: 60 } as unknown as CofheInputConfig)
+    ).toThrow(/`defaultPermitExpiration` is now `defaultACPExpiration`/);
+  });
+
+  it('rejects unknown keys instead of silently stripping them', () => {
+    expect(() =>
+      createCofheConfigBase({ ...validBaseConfig, notARealKey: true } as unknown as CofheInputConfig)
+    ).toThrow(/Invalid cofhe configuration/);
+  });
+
+  it('still accepts a valid config', () => {
+    expect(() => createCofheConfigBase({ ...validBaseConfig, defaultACPExpiration: 60 })).not.toThrow();
+  });
+});

package/core/test/decrypt.test.ts

@@ -1,13 +1,15 @@
+import { STAGING_TESTS, stagingViemChain } from './stagingRedirect';
 import { FheTypes, verifyDecryptResult, createCofheConfigBase, TASK_MANAGER_ADDRESS } from '@/core';
-import { getChainById } from '@/chains';
+import { getChainById, stagingCofhe } from '@/chains';
 import {
   TEST_PRIVATE_KEY,
   PRIMARY_TEST_CHAIN,
   primaryTestChainRegistry,
+  stagingTestChainRegistry,
   isPrimaryTestChainReady,
 } from '@cofhe/test-setup';
 
-import { permits } from '../permits.js';
+import { acps } from '../acps.js';
 import { DecryptForTxBuilder } from '../decrypt/decryptForTxBuilder.js';
 import { DecryptForViewBuilder } from '../decrypt/decryptForViewBuilder.js';
 
@@ -19,6 +21,8 @@ import { arbitrumSepolia, baseSepolia, sepolia } from 'viem/chains';
 
 const account = privateKeyToAccount(TEST_PRIVATE_KEY);
 
+const TEST_CHAIN_ID = STAGING_TESTS ? stagingViemChain.id : PRIMARY_TEST_CHAIN;
+
 const VIEM_CHAINS: Record<number, Chain> = {
   421614: arbitrumSepolia,
   84532: baseSepolia,
@@ -37,17 +41,18 @@ describe('Core – Decrypt Tests', () => {
   let publicValue: bigint;
 
   beforeAll(() => {
-    if (!isPrimaryTestChainReady(primaryTestChainRegistry)) {
-      throw new Error('Primary test chain registry is 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 is not initialized. Run `pnpm test:setup` first.');
     }
-
-    const reg = primaryTestChainRegistry;
     const chainId = reg.chainId;
 
-    const viemChain = VIEM_CHAINS[chainId];
+    const viemChain = STAGING_TESTS ? stagingViemChain : VIEM_CHAINS[chainId];
     if (!viemChain) throw new Error(`No viem chain mapping for chain ${chainId}`);
 
-    const cofheChain = getChainById(chainId);
+    const cofheChain = STAGING_TESTS ? stagingCofhe : getChainById(chainId);
     if (!cofheChain) throw new Error(`No cofhe chain config for chain ${chainId}`);
 
     config = createCofheConfigBase({ supportedChains: [cofheChain] });
@@ -67,7 +72,7 @@ describe('Core – Decrypt Tests', () => {
       config,
       publicClient,
       walletClient,
-      chainId: PRIMARY_TEST_CHAIN,
+      chainId: TEST_CHAIN_ID,
       account: account.address,
       ctHash,
       requireConnected: undefined,
@@ -79,7 +84,7 @@ describe('Core – Decrypt Tests', () => {
       config,
       publicClient,
       walletClient,
-      chainId: PRIMARY_TEST_CHAIN,
+      chainId: TEST_CHAIN_ID,
       account: account.address,
       ctHash,
       utype,
@@ -87,17 +92,17 @@ describe('Core – Decrypt Tests', () => {
     });
   }
 
-  async function createPermit() {
-    return permits.createSelf({ issuer: account.address, name: 'Decrypt Test Permit' }, publicClient, walletClient);
+  async function createACP() {
+    return acps.createSelf({ issuer: account.address, name: 'Decrypt Test ACP' }, publicClient, walletClient);
   }
 
   // ---------------------------------------------------------------------------
-  // decryptForTx – withoutPermit (global allowance)
+  // decryptForTx – withoutACP (global allowance)
   // ---------------------------------------------------------------------------
 
-  describe('decryptForTx – withoutPermit (global allowance)', () => {
+  describe('decryptForTx – withoutACP (global allowance)', () => {
     it('should decrypt a publicly allowed ciphertext', async () => {
-      const result = await txBuilder(publicCtHash).withoutPermit().execute();
+      const result = await txBuilder(publicCtHash).withoutACP().execute();
 
       expect(BigInt(result.ctHash)).toBe(BigInt(publicCtHash));
       expect(result.decryptedValue).toBe(publicValue);
@@ -106,25 +111,25 @@ describe('Core – Decrypt Tests', () => {
   });
 
   // ---------------------------------------------------------------------------
-  // decryptForTx – withPermit
+  // decryptForTx – withACP
   // ---------------------------------------------------------------------------
 
-  describe('decryptForTx – withPermit', () => {
-    it('should decrypt with a self permit', async () => {
-      const permit = await createPermit();
+  describe('decryptForTx – withACP', () => {
+    it('should decrypt with a self acp', async () => {
+      const acp = await createACP();
 
-      const result = await txBuilder(privateCtHash).withPermit(permit).execute();
+      const result = await txBuilder(privateCtHash).withACP(acp).execute();
 
       expect(BigInt(result.ctHash)).toBe(BigInt(privateCtHash));
       expect(result.decryptedValue).toBe(privateValue);
       expect(result.signature).toBeDefined();
     }, 180000);
 
-    it('should auto-resolve active permit', async () => {
-      const permit = await createPermit();
-      permits.selectActivePermit(PRIMARY_TEST_CHAIN, account.address, permit.hash);
+    it('should auto-resolve active acp', async () => {
+      const acp = await createACP();
+      acps.selectActiveACP(TEST_CHAIN_ID, account.address, acp.hash);
 
-      const result = await txBuilder(privateCtHash).withPermit().execute();
+      const result = await txBuilder(privateCtHash).withACP().execute();
 
       expect(BigInt(result.ctHash)).toBe(BigInt(privateCtHash));
       expect(result.decryptedValue).toBe(privateValue);
@@ -137,9 +142,9 @@ describe('Core – Decrypt Tests', () => {
 
   describe('verifyDecryptResult', () => {
     it('should verify a valid decrypt result', async () => {
-      const permit = await createPermit();
+      const acp = await createACP();
 
-      const decryptResult = await txBuilder(privateCtHash).withPermit(permit).execute();
+      const decryptResult = await txBuilder(privateCtHash).withACP(acp).execute();
 
       const isValid = await verifyDecryptResult(
         decryptResult.ctHash,
@@ -151,9 +156,9 @@ describe('Core – Decrypt Tests', () => {
     }, 180000);
 
     it('should return false for invalid inputs', async () => {
-      const permit = await createPermit();
+      const acp = await createACP();
 
-      const decryptResult = await txBuilder(privateCtHash).withPermit(permit).execute();
+      const decryptResult = await txBuilder(privateCtHash).withACP(acp).execute();
 
       expect(
         await verifyDecryptResult(decryptResult.ctHash, privateValue + 1n, decryptResult.signature, publicClient)
@@ -167,17 +172,17 @@ describe('Core – Decrypt Tests', () => {
 
   describe('decryptForView', () => {
     it('should return the plaintext value', async () => {
-      await createPermit();
+      await createACP();
 
       const result = await viewBuilder(privateCtHash, FheTypes.Uint32).execute();
       expect(result).toBe(privateValue);
     }, 180000);
 
     it('should agree with decryptForTx on the same handle', async () => {
-      const permit = await createPermit();
+      const acp = await createACP();
 
       const viewResult = await viewBuilder(privateCtHash, FheTypes.Uint32).execute();
-      const txResult = await txBuilder(privateCtHash).withPermit(permit).execute();
+      const txResult = await txBuilder(privateCtHash).withACP(acp).execute();
 
       expect(viewResult).toBe(privateValue);
       expect(BigInt(txResult.ctHash)).toBe(BigInt(privateCtHash));
@@ -187,9 +192,9 @@ describe('Core – Decrypt Tests', () => {
 
   describe('verifyDecryptResult', () => {
     it('should correctly verify a valid decrypt result', async () => {
-      const permit = await createPermit();
+      const acp = await createACP();
 
-      const decryptResult = await txBuilder(privateCtHash).withPermit(permit).execute();
+      const decryptResult = await txBuilder(privateCtHash).withACP(acp).execute();
 
       const isValid = await verifyDecryptResult(
         decryptResult.ctHash,
@@ -201,8 +206,8 @@ describe('Core – Decrypt Tests', () => {
     }, 180000);
 
     it('should verify identically to the on-chain TaskManager contract', async () => {
-      const permit = await createPermit();
-      const decryptResult = await txBuilder(privateCtHash).withPermit(permit).execute();
+      const acp = await createACP();
+      const decryptResult = await txBuilder(privateCtHash).withACP(acp).execute();
 
       const samples = [
         {