@cofhe/sdk 0.6.1 → 0.7.0

package/core/error.ts

@@ -9,12 +9,13 @@ export enum CofheErrorCode {
   MissingWalletClient = 'MISSING_WALLET_CLIENT',
   MissingProviderParam = 'MISSING_PROVIDER_PARAM',
   EmptySecurityZonesParam = 'EMPTY_SECURITY_ZONES_PARAM',
-  InvalidPermitData = 'INVALID_PERMIT_DATA',
-  InvalidPermitDomain = 'INVALID_PERMIT_DOMAIN',
-  PermitNotFound = 'PERMIT_NOT_FOUND',
-  CannotRemoveLastPermit = 'CANNOT_REMOVE_LAST_PERMIT',
+  InvalidACPData = 'INVALID_ACP_DATA',
+  InvalidACPDomain = 'INVALID_ACP_DOMAIN',
+  ACPNotFound = 'ACP_NOT_FOUND',
+  CannotRemoveLastACP = 'CANNOT_REMOVE_LAST_ACP',
   AccountUninitialized = 'ACCOUNT_UNINITIALIZED',
   ChainIdUninitialized = 'CHAIN_ID_UNINITIALIZED',
+  ConsumingContractUninitialized = 'CONSUMING_CONTRACT_UNINITIALIZED',
   SealOutputFailed = 'SEAL_OUTPUT_FAILED',
   SealOutputReturnedNull = 'SEAL_OUTPUT_RETURNED_NULL',
   InvalidUtype = 'INVALID_UTYPE',
@@ -42,6 +43,26 @@ export enum CofheErrorCode {
   PublicWalletGetChainIdFailed = 'PUBLIC_WALLET_GET_CHAIN_ID_FAILED',
   PublicWalletGetAddressesFailed = 'PUBLIC_WALLET_GET_ADDRESSES_FAILED',
   RehydrateKeysStoreFailed = 'REHYDRATE_KEYS_STORE_FAILED',
+
+  // Threshold-network stable error codes (decrypt/sealoutput), see API-RESPONSES.md
+  BadRequest = 'BAD_REQUEST',
+  UnknownChain = 'UNKNOWN_CHAIN',
+  ACPMalformed = 'ACP_MALFORMED',
+  ACPDenied = 'ACP_DENIED',
+  ACPExpired = 'ACP_EXPIRED',
+  ACPInvalid = 'ACP_INVALID',
+  ACPRevoked = 'ACP_REVOKED',
+  NotPubliclyAllowed = 'NOT_PUBLICLY_ALLOWED',
+  CtNotFound = 'CT_NOT_FOUND',
+  UnsupportedSecurityZone = 'UNSUPPORTED_SECURITY_ZONE',
+  UnsupportedType = 'UNSUPPORTED_TYPE',
+  SigningFailed = 'SIGNING_FAILED',
+  CtSourceError = 'CT_SOURCE_ERROR',
+  ACPVerifierError = 'ACP_VERIFIER_ERROR',
+  CtSourceTimeout = 'CT_SOURCE_TIMEOUT',
+  ACPVerifierTimeout = 'ACP_VERIFIER_TIMEOUT',
+  ACPRequired = 'ACP_REQUIRED',
+  SealFailed = 'SEAL_FAILED',
 }
 
 export type CofheErrorParams = {
@@ -50,6 +71,8 @@ export type CofheErrorParams = {
   cause?: Error;
   hint?: string;
   context?: Record<string, unknown>;
+  /** Raw backend `error` string, when this error originated from a threshold-network response. */
+  apiErrorCode?: string;
 };
 
 /**
@@ -68,8 +91,9 @@ export class CofheError extends Error {
   public readonly cause?: Error;
   public readonly hint?: string;
   public readonly context?: Record<string, unknown>;
+  public readonly apiErrorCode?: string;
 
-  constructor({ code, message, cause, hint, context }: CofheErrorParams) {
+  constructor({ code, message, cause, hint, context, apiErrorCode }: CofheErrorParams) {
     // If there's a cause, append its message to provide full context
     const fullMessage = cause ? `${message} | Caused by: ${cause.message}` : message;
 
@@ -79,6 +103,7 @@ export class CofheError extends Error {
     this.cause = cause;
     this.hint = hint;
     this.context = context;
+    this.apiErrorCode = apiErrorCode;
 
     // Maintains proper stack trace for where our error was thrown (only available on V8)
     if (Error.captureStackTrace) {
@@ -101,6 +126,7 @@ export class CofheError extends Error {
       message: wrapperError?.message ?? 'An internal error occurred',
       hint: wrapperError?.hint,
       context: wrapperError?.context,
+      apiErrorCode: wrapperError?.apiErrorCode,
       cause: cause,
     });
   }
@@ -115,6 +141,7 @@ export class CofheError extends Error {
       message: this.message,
       hint: this.hint,
       context: this.context,
+      apiErrorCode: this.apiErrorCode,
       cause: this.cause
         ? {
             name: this.cause.name,
@@ -130,7 +157,8 @@ export class CofheError extends Error {
    * Returns a human-readable string representation of the error
    */
   toString(): string {
-    const parts = [`${this.name} [${this.code}]: ${this.message}`];
+    const codeSuffix = this.apiErrorCode ? ` (api: ${this.apiErrorCode})` : '';
+    const parts = [`${this.name} [${this.code}]${codeSuffix}: ${this.message}`];
 
     if (this.hint) {
       parts.push(`Hint: ${this.hint}`);

package/core/index.ts

@@ -12,7 +12,7 @@ export type {
 } from './debug.js';
 
 // Configuration (base implementations)
-export { createCofheConfigBase, getCofheConfigItem } from './config.js';
+export { createCofheConfigBase, getCofheConfigItem, assertNoRenamedConfigKeys } from './config.js';
 export type { CofheConfig, CofheInputConfig, CofheInternalConfig } from './config.js';
 
 // Types
@@ -21,7 +21,7 @@ export type {
   CofheClient as CofheClient,
   CofheClientParams as CofheClientParams,
   CofheClientConnectionState as CofheClientConnectionState,
-  CofheClientPermits as CofheClientPermits,
+  CofheClientACPs as CofheClientACPs,
 } from './clientTypes.js';
 
 export type {
@@ -40,18 +40,8 @@ export type {
   EncryptableAddress,
   // Encrypted types
   EncryptedNumber,
-  EncryptedItemInput,
-  EncryptedBoolInput,
-  EncryptedUint8Input,
-  EncryptedUint16Input,
-  EncryptedUint32Input,
-  EncryptedUint64Input,
-  EncryptedUint128Input,
-  EncryptedAddressInput,
-  EncryptedItemInputs,
-  EncryptableToEncryptedItemInputMap,
   FheTypeValue,
-  // Hash-plus-proof external types
+  // Batch-verified external hash + signature types
   ExternalBoolHash,
   ExternalUint8Hash,
   ExternalUint16Hash,
@@ -81,7 +71,6 @@ export {
   isEncryptableItem,
   EncryptStep,
   isLastEncryptionStep,
-  assertCorrectEncryptedItemInput,
 } from './types.js';
 
 // Error handling
@@ -98,6 +87,7 @@ export type { KeysStorage, KeysStore } from './keyStore.js';
 
 // Builders (exported via client, but can be imported directly for typing)
 export { EncryptInputsBuilder } from './encrypt/encryptInputsBuilder.js';
+export type { EncryptInputsBuilderUnset } from './encrypt/encryptInputsBuilder.js';
 export { DecryptForViewBuilder } from './decrypt/decryptForViewBuilder.js';
 export { DecryptForTxBuilder } from './decrypt/decryptForTxBuilder.js';
 export type { DecryptForTxResult } from './decrypt/decryptForTxBuilder.js';

package/core/test/acpDefaults.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect } from 'vitest';
+import { acps } from '../acps.js';
+
+type ScopeOpts = {
+  revokerData?: number;
+  revokerContract?: string;
+  scope?: number;
+  contracts?: string[];
+  handles?: bigint[];
+};
+const opts = (o: ScopeOpts): ScopeOpts => o;
+
+const CHAIN = 31337;
+const REVOKER = '0x00000000000000000000000000000000000000aa' as `0x${string}`;
+const CONTRACT_A = '0x00000000000000000000000000000000000000bb' as `0x${string}`;
+
+const acpConfig = {
+  defaultRevoker: { [CHAIN]: REVOKER },
+  defaultContractScopes: { [CHAIN]: [CONTRACT_A] },
+};
+
+describe('applyACPDefaults', () => {
+  it('injects default revoker (contract + creation timestamp) when no revoker options given', () => {
+    const before = Math.round(Date.now() / 1000);
+    const result = acps.applyACPDefaults(opts({}), acpConfig, CHAIN);
+    expect(result.revokerContract).toBe(REVOKER);
+    expect(result.revokerData).toBeGreaterThanOrEqual(before - 60); // 60s clock-skew backdating
+    expect(result.revokerData).toBeLessThanOrEqual(Math.round(Date.now() / 1000) - 59);
+  });
+
+  it('does not override an explicit revoker pair', () => {
+    const result = acps.applyACPDefaults({ revokerData: 42, revokerContract: CONTRACT_A }, acpConfig, CHAIN);
+    expect(result.revokerData).toBe(42);
+    expect(result.revokerContract).toBe(CONTRACT_A);
+  });
+
+  it('injects default contract scopes when no scope options given', () => {
+    const result = acps.applyACPDefaults(opts({}), acpConfig, CHAIN);
+    expect(result.contracts).toEqual([CONTRACT_A]);
+  });
+
+  it('does not inject scopes when the caller provides any scope option (incl. explicit scope)', () => {
+    expect(acps.applyACPDefaults(opts({ scope: 0 }), acpConfig, CHAIN).contracts).toBeUndefined();
+    expect(acps.applyACPDefaults(opts({ handles: [1n] }), acpConfig, CHAIN).contracts).toBeUndefined();
+    expect(acps.applyACPDefaults(opts({ contracts: [] }), acpConfig, CHAIN).contracts).toEqual([]);
+  });
+
+  it('no-op for chains without defaults and for missing config', () => {
+    expect(acps.applyACPDefaults(opts({}), acpConfig, 999)).toEqual({});
+    expect(acps.applyACPDefaults(opts({}), undefined, CHAIN)).toEqual({});
+  });
+});