@cofhe/abi 0.5.1 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @cofhe/abi Changelog
 
+## 0.6.0
+
+### Patch Changes
+
+- Updated dependencies [bf23270]
+- Updated dependencies [2711f9b]
+- Updated dependencies [566f126]
+  - @cofhe/sdk@0.6.0
+
+## 0.5.2
+
+### Patch Changes
+
+- Updated dependencies [2fbb918]
+  - @cofhe/sdk@0.5.2
+
 ## 0.5.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cofhe/abi",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "type": "module",
   "description": "ABI utilities for Fhenix FHE contracts",
   "types": "./dist/index.d.ts",
@@ -27,7 +27,7 @@
   ],
   "dependencies": {
     "abitype": "1.2.3",
-    "@cofhe/sdk": "0.5.1"
+    "@cofhe/sdk": "0.6.0"
   },
   "devDependencies": {
     "@types/node": "20.19.15",

package/src/mockEncrypt.ts

@@ -1,17 +1,4 @@
-import {
-  FheTypes,
-  type EncryptableItem,
-  type EncryptableToEncryptedItemInputMap,
-  type EncryptedAddressInput,
-  type EncryptedBoolInput,
-  type EncryptedItemInput,
-  type EncryptedItemInputs,
-  type EncryptedUint128Input,
-  type EncryptedUint16Input,
-  type EncryptedUint32Input,
-  type EncryptedUint64Input,
-  type EncryptedUint8Input,
-} from '@cofhe/sdk';
+import { type EncryptableItem, type EncryptedItemInputs } from '@cofhe/sdk';
 
 /**
  * Generates a mock ctHash from the encryptable data.
@@ -25,14 +12,15 @@ export function generateMockCtHash(data: unknown): bigint {
     return data;
   }
   if (typeof data === 'string') {
-    // Simple hash: convert string to number and create a bigint
+    // Keep only the low 32 bits after each round so the accumulator stays in
+    // the uint32 range instead of growing as an unbounded bigint.
     let hash = 0n;
     for (let i = 0; i < data.length; i++) {
       const char = data.charCodeAt(i);
       hash = (hash << 5n) - hash + BigInt(char);
-      hash = hash & hash; // Convert to 32-bit integer
+      hash = BigInt.asUintN(32, hash);
     }
-    return hash < 0n ? -hash : hash;
+    return hash;
   }
   // Fallback: use a simple hash based on string representation
   return BigInt(

package/src/mockEncryptedInput.ts

@@ -1,139 +0,0 @@
-import {
-  FheTypes,
-  type EncryptableItem,
-  type EncryptedAddressInput,
-  type EncryptedBoolInput,
-  type EncryptedItemInput,
-  type EncryptedUint128Input,
-  type EncryptedUint16Input,
-  type EncryptedUint32Input,
-  type EncryptedUint64Input,
-  type EncryptedUint8Input,
-} from '@cofhe/sdk';
-
-/**
- * Generates a mock ctHash from the encryptable data.
- * This is a simple deterministic hash function for testing purposes.
- */
-function generateMockCtHash(data: unknown): bigint {
-  if (typeof data === 'boolean') {
-    return BigInt(data ? 1 : 0);
-  }
-  if (typeof data === 'bigint') {
-    return data;
-  }
-  if (typeof data === 'string') {
-    // Simple hash: convert string to number and create a bigint
-    let hash = 0n;
-    for (let i = 0; i < data.length; i++) {
-      const char = data.charCodeAt(i);
-      hash = (hash << 5n) - hash + BigInt(char);
-      hash = hash & hash; // Convert to 32-bit integer
-    }
-    return hash < 0n ? -hash : hash;
-  }
-  // Fallback: use a simple hash based on string representation
-  return BigInt(
-    Math.abs(
-      JSON.stringify(data)
-        .split('')
-        .reduce((a, b) => {
-          a = (a << 5) - a + b.charCodeAt(0);
-          return a & a;
-        }, 0)
-    )
-  );
-}
-
-/**
- * Generates a mock signature for testing purposes.
- * Returns a hex string that looks like a valid signature.
- */
-function generateMockSignature(): `0x${string}` {
-  // Generate a 64-character hex string (32 bytes)
-  const hexChars = '0123456789abcdef';
-  let signature = '0x';
-  for (let i = 0; i < 64; i++) {
-    signature += hexChars[Math.floor(Math.random() * hexChars.length)];
-  }
-  return signature as `0x${string}`;
-}
-
-/**
- * Converts an EncryptableItem to a mock EncryptedItemInput.
- * This is useful for testing and development when you don't need actual encryption.
- *
- * @param encryptable - The EncryptableItem to convert
- * @returns A mock EncryptedItemInput with the same utype and securityZone, but with mock ctHash and signature
- *
- * @example
- * const encryptable = Encryptable.uint32(100n);
- * const mockEncrypted = mockEncryptedInput(encryptable);
- * // Returns: { ctHash: 100n, securityZone: 0, utype: FheTypes.Uint32, signature: "0x..." }
- */
-export function mockEncryptedInput<T extends EncryptableItem>(encryptable: T): EncryptedItemInput {
-  const ctHash = generateMockCtHash(encryptable.data);
-  const signature = generateMockSignature();
-
-  // Map based on utype to return the correct specific type
-  switch (encryptable.utype) {
-    case FheTypes.Bool:
-      return {
-        ctHash,
-        securityZone: 0,
-        utype: FheTypes.Bool,
-        signature,
-      } as EncryptedBoolInput;
-
-    case FheTypes.Uint8:
-      return {
-        ctHash,
-        securityZone: 0,
-        utype: FheTypes.Uint8,
-        signature,
-      } as EncryptedUint8Input;
-
-    case FheTypes.Uint16:
-      return {
-        ctHash,
-        securityZone: 0,
-        utype: FheTypes.Uint16,
-        signature,
-      } as EncryptedUint16Input;
-
-    case FheTypes.Uint32:
-      return {
-        ctHash,
-        securityZone: 0,
-        utype: FheTypes.Uint32,
-        signature,
-      } as EncryptedUint32Input;
-
-    case FheTypes.Uint64:
-      return {
-        ctHash,
-        securityZone: 0,
-        utype: FheTypes.Uint64,
-        signature,
-      } as EncryptedUint64Input;
-
-    case FheTypes.Uint128:
-      return {
-        ctHash,
-        securityZone: 0,
-        utype: FheTypes.Uint128,
-        signature,
-      } as EncryptedUint128Input;
-
-    case FheTypes.Uint160:
-      return {
-        ctHash,
-        securityZone: 0,
-        utype: FheTypes.Uint160,
-        signature,
-      } as EncryptedAddressInput;
-
-    default:
-      throw new Error(`Unsupported encryptable: ${encryptable}`);
-  }
-}