@cofhe/sdk 0.1.1 → 0.2.1

package/permits/permit.test.ts

@@ -44,8 +44,9 @@ describe('PermitUtils Tests', () => {
         name: 'Test Permit',
       };
 
-      const permit = await PermitUtils.createSelf(options);
+      const permit = PermitUtils.createSelf(options);
 
+      expect(permit.hash).toBe(PermitUtils.getHash(permit));
       expect(permit.type).toBe('self');
       expect(permit.name).toBe('Test Permit');
       expect(permit.type).toBe('self');
@@ -66,7 +67,7 @@ describe('PermitUtils Tests', () => {
         name: 'Test Permit',
       };
 
-      await expect(PermitUtils.createSelf(options)).rejects.toThrow();
+      expect(() => PermitUtils.createSelf(options)).toThrowError();
     });
   });
 
@@ -79,8 +80,9 @@ describe('PermitUtils Tests', () => {
         name: 'Test Sharing Permit',
       };
 
-      const permit = await PermitUtils.createSharing(options);
+      const permit = PermitUtils.createSharing(options);
 
+      expect(permit.hash).toBe(PermitUtils.getHash(permit));
       expect(permit.type).toBe('sharing');
       expect(permit.name).toBe('Test Sharing Permit');
       expect(permit.type).toBe('sharing');
@@ -103,7 +105,7 @@ describe('PermitUtils Tests', () => {
         name: 'Test Sharing Permit',
       };
 
-      await expect(PermitUtils.createSharing(options)).rejects.toThrow();
+      expect(() => PermitUtils.createSharing(options)).toThrow();
     });
   });
 
@@ -111,13 +113,15 @@ describe('PermitUtils Tests', () => {
     it('should import a shared permit with valid options', async () => {
       const options: ImportSharedPermitOptions = {
         issuer: bobAddress,
+        expiration: Math.floor(Date.now() / 1000) + 3600, // 1 hour from now
         recipient: aliceAddress,
         issuerSignature: '0x1234567890abcdef',
         name: 'Test Import Permit',
       };
 
-      const permit = await PermitUtils.importShared(options);
+      const permit = PermitUtils.importShared(options);
 
+      expect(permit.hash).toBe(PermitUtils.getHash(permit));
       expect(permit.type).toBe('recipient');
       expect(permit.name).toBe('Test Import Permit');
       expect(permit.issuer).toBe(bobAddress);
@@ -134,13 +138,14 @@ describe('PermitUtils Tests', () => {
     it('should import a shared permit with valid options as string', async () => {
       const options: ImportSharedPermitOptions = {
         issuer: bobAddress,
+        expiration: Math.floor(Date.now() / 1000) + 3600, // 1 hour from now
         recipient: aliceAddress,
         issuerSignature: '0x1234567890abcdef',
       };
 
       const stringOptions = JSON.stringify(options);
 
-      const permit = await PermitUtils.importShared(stringOptions);
+      const permit = PermitUtils.importShared(stringOptions);
 
       expect(permit.type).toBe('recipient');
     });
@@ -153,7 +158,7 @@ describe('PermitUtils Tests', () => {
         issuerSignature: '0x1234567890abcdef',
       } as unknown as ImportSharedPermitOptions;
 
-      await expect(PermitUtils.importShared(options)).rejects.toThrow();
+      expect(() => PermitUtils.importShared(options)).toThrow();
 
       const options2 = {
         type: 'recipient',
@@ -162,18 +167,28 @@ describe('PermitUtils Tests', () => {
         issuerSignature: '0x1234567890abcdef',
       } as unknown as ImportSharedPermitOptions;
 
-      await expect(PermitUtils.importShared(options2)).rejects.toThrow();
+      expect(() => PermitUtils.importShared(options2)).toThrow();
     });
 
     it('should throw error for missing issuerSignature', async () => {
       const options: ImportSharedPermitOptions = {
         issuer: bobAddress,
+        expiration: Math.floor(Date.now() / 1000) + 3600, // 1 hour from now
         recipient: aliceAddress,
         issuerSignature: '0x', // Invalid empty signature
         name: 'Test Import Permit',
       };
 
-      await expect(PermitUtils.importShared(options)).rejects.toThrow();
+      expect(() => PermitUtils.importShared(options)).toThrow();
+    });
+
+    it('should throw error for missing expiration', async () => {
+      const options = {
+        issuer: bobAddress,
+        recipient: aliceAddress,
+        issuerSignature: '0x1234567890abcdef',
+      } as unknown as ImportSharedPermitOptions;
+      expect(() => PermitUtils.importShared(options)).toThrow();
     });
   });
 
@@ -217,6 +232,7 @@ describe('PermitUtils Tests', () => {
       const options: ImportSharedPermitOptions = {
         issuer: bobAddress,
         recipient: aliceAddress,
+        expiration: Math.floor(Date.now() / 1000) + 3600, // 1 hour from now
         issuerSignature: '0x1234567890abcdef',
         name: 'Test Import Permit',
       };
@@ -233,6 +249,7 @@ describe('PermitUtils Tests', () => {
       const options: ImportSharedPermitOptions = {
         issuer: bobAddress,
         recipient: aliceAddress,
+        expiration: Math.floor(Date.now() / 1000) + 3600, // 1 hour from now
         issuerSignature: '0x1234567890abcdef',
       };
 
@@ -250,6 +267,7 @@ describe('PermitUtils Tests', () => {
       const options: ImportSharedPermitOptions = {
         issuer: bobAddress,
         recipient: aliceAddress,
+        expiration: Math.floor(Date.now() / 1000) + 3600, // 1 hour from now
         issuerSignature: '0x1234567890abcdef',
       };
 
@@ -266,7 +284,7 @@ describe('PermitUtils Tests', () => {
 
   describe('sign', () => {
     it('should sign a self permit', async () => {
-      const permit = await PermitUtils.createSelf({
+      const permit = PermitUtils.createSelf({
         issuer: bobAddress,
         name: 'Test Permit',
       });
@@ -280,10 +298,11 @@ describe('PermitUtils Tests', () => {
     });
 
     it('should sign a recipient permit', async () => {
-      const permit = await PermitUtils.importShared({
+      const permit = PermitUtils.importShared({
         issuer: bobAddress,
         recipient: aliceAddress,
-        issuerSignature: '0xexisting-signature',
+        expiration: Math.floor(Date.now() / 1000) + 3600, // 1 hour from now
+        issuerSignature: '0x1111111111111111111111111111111111111111111111111111111111111111',
         name: 'Test Permit',
       });
 
@@ -295,7 +314,7 @@ describe('PermitUtils Tests', () => {
     });
 
     it('should throw error for undefined signer', async () => {
-      const permit = await PermitUtils.createSelf({
+      const permit = PermitUtils.createSelf({
         issuer: bobAddress,
         name: 'Test Permit',
       });
@@ -309,7 +328,7 @@ describe('PermitUtils Tests', () => {
 
   describe('serialize/deserialize', () => {
     it('should serialize and deserialize a permit', async () => {
-      const originalPermit = await PermitUtils.createSelf({
+      const originalPermit = PermitUtils.createSelf({
         issuer: bobAddress,
         name: 'Test Permit',
       });
@@ -348,26 +367,26 @@ describe('PermitUtils Tests', () => {
 
   describe('getHash', () => {
     it('should generate consistent hash for same permit data', async () => {
-      const permit1 = await PermitUtils.createSelf({
+      const expiration = Math.floor(Date.now() / 1000) + 3600; // 1 hour from now
+      const permit1 = PermitUtils.createSelf({
+        expiration,
         issuer: bobAddress,
         name: 'Test Permit',
       });
 
-      const permit2 = await PermitUtils.createSelf({
+      const permit2 = PermitUtils.createSelf({
+        expiration,
         issuer: bobAddress,
         name: 'Test Permit',
       });
 
-      const hash1 = PermitUtils.getHash(permit1);
-      const hash2 = PermitUtils.getHash(permit2);
-
-      expect(hash1).toBe(hash2);
+      expect(permit1.hash).toBe(permit2.hash);
     });
   });
 
   describe('export', () => {
     it('should export permit data without sensitive fields', async () => {
-      const permit = await PermitUtils.createSelf({
+      const permit = PermitUtils.createSelf({
         issuer: bobAddress,
         name: 'Test Permit',
       });
@@ -384,7 +403,7 @@ describe('PermitUtils Tests', () => {
 
   describe('updateName', () => {
     it('should update permit name immutably', async () => {
-      const permit = await PermitUtils.createSelf({
+      const permit = PermitUtils.createSelf({
         issuer: bobAddress,
         name: 'Original Name',
       });
@@ -399,13 +418,13 @@ describe('PermitUtils Tests', () => {
 
   describe('validation helpers', () => {
     it('should check if permit is expired', async () => {
-      const expiredPermit = await PermitUtils.createSelf({
+      const expiredPermit = PermitUtils.createSelf({
         issuer: bobAddress,
         name: 'Test Permit',
         expiration: Math.floor(Date.now() / 1000) - 3600, // 1 hour ago
       });
 
-      const validPermit = await PermitUtils.createSelf({
+      const validPermit = PermitUtils.createSelf({
         issuer: bobAddress,
         name: 'Test Permit',
         expiration: Math.floor(Date.now() / 1000) + 3600, // 1 hour from now
@@ -416,7 +435,7 @@ describe('PermitUtils Tests', () => {
     });
 
     it('should check if permit is signed', async () => {
-      const unsignedPermit = await PermitUtils.createSelf({
+      const unsignedPermit = PermitUtils.createSelf({
         issuer: bobAddress,
         name: 'Test Permit',
       });
@@ -428,7 +447,7 @@ describe('PermitUtils Tests', () => {
     });
 
     it('should check overall validity', async () => {
-      const validPermit = await PermitUtils.createSelf({
+      const validPermit = PermitUtils.createSelf({
         issuer: bobAddress,
         name: 'Test Permit',
         expiration: Math.floor(Date.now() / 1000) + 3600,
@@ -456,7 +475,7 @@ describe('PermitUtils Tests', () => {
     }, 10000); // 10 second timeout for network call
 
     it('should check signed domain validity with real contract data', async () => {
-      const permit = await PermitUtils.createSelf({
+      const permit = PermitUtils.createSelf({
         type: 'self',
         issuer: bobAddress,
         name: 'Test Permit',
@@ -470,5 +489,35 @@ describe('PermitUtils Tests', () => {
 
       expect(typeof isValid).toBe('boolean');
     }, 10000); // 10 second timeout for network call
+
+    // TODO: Uncomment when updated ACL with checkPermitValidity function is deployed
+
+    // it('should check permit validity on chain with real contract data', async () => {
+    //   const permit = PermitUtils.createSelf({
+    //     type: 'self',
+    //     issuer: bobAddress,
+    //     name: 'Test Permit',
+    //   });
+
+    //   const signedPermit = await PermitUtils.sign(permit, publicClient, bobWalletClient);
+
+    //   const isValid = await PermitUtils.checkValidityOnChain(signedPermit, publicClient);
+
+    //   expect(typeof isValid).toBe('boolean');
+    //   expect(isValid).toBe(true);
+
+    //   const permitInvalid = PermitUtils.createSelf({
+    //     type: 'self',
+    //     issuer: bobAddress,
+    //     name: 'Test Permit',
+    //     expiration: Math.floor(Date.now() / 1000) - 3600, // 1 hour ago
+    //   });
+
+    //   const signedPermitInvalid = await PermitUtils.sign(permitInvalid, publicClient, bobWalletClient);
+    //   const isValidInvalid = await PermitUtils.checkValidityOnChain(signedPermitInvalid, publicClient);
+
+    //   expect(typeof isValidInvalid).toBe('boolean');
+    //   expect(isValidInvalid).toBe(false);
+    // });
   });
 });

package/permits/permit.ts

@@ -1,6 +1,9 @@
 import { keccak256, toHex, zeroAddress, parseAbi, type PublicClient, type WalletClient } from 'viem';
 import {
   type Permit,
+  type SelfPermit,
+  type SharingPermit,
+  type RecipientPermit,
   type CreateSelfPermitOptions,
   type CreateSharingPermitOptions,
   type ImportSharedPermitOptions,
@@ -8,6 +11,7 @@ import {
   type EIP712Domain,
   type Permission,
   type EthEncryptedData,
+  type PermitHashFields,
 } from './types.js';
 import {
   validateSelfPermitOptions,
@@ -18,8 +22,10 @@ import {
   validateImportPermit,
   ValidationUtils,
 } from './validation.js';
+import * as z from 'zod';
 import { SignatureUtils } from './signature.js';
 import { GenerateSealingKey, SealingKey } from './sealing.js';
+import { checkPermitValidityOnChain, getAclEIP712Domain } from './onchain-utils.js';
 
 /**
  * Main Permit utilities - functional approach for React compatibility
@@ -28,52 +34,45 @@ export const PermitUtils = {
   /**
    * Create a self permit for personal use
    */
-  createSelf: async (options: CreateSelfPermitOptions): Promise<Permit> => {
+  createSelf: (options: CreateSelfPermitOptions): SelfPermit => {
     const validation = validateSelfPermitOptions(options);
 
-    if (!validation.success) {
-      throw new Error(
-        'PermitUtils :: createSelf :: Parsing SelfPermitOptions failed ' + JSON.stringify(validation.error, null, 2)
-      );
-    }
-
     // Always generate a new sealing key - users cannot provide their own
-    const sealingPair = await GenerateSealingKey();
+    const sealingPair = GenerateSealingKey();
 
-    return {
-      ...validation.data,
+    const permit = {
+      hash: PermitUtils.getHash(validation),
+      ...validation,
       sealingPair,
       _signedDomain: undefined,
-    };
+    } satisfies SelfPermit;
+
+    return permit;
   },
 
   /**
    * Create a sharing permit to be shared with another user
    */
-  createSharing: async (options: CreateSharingPermitOptions): Promise<Permit> => {
+  createSharing: (options: CreateSharingPermitOptions): SharingPermit => {
     const validation = validateSharingPermitOptions(options);
 
-    if (!validation.success) {
-      throw new Error(
-        'PermitUtils :: createSharing :: Parsing SharingPermitOptions failed ' +
-          JSON.stringify(validation.error, null, 2)
-      );
-    }
-
     // Always generate a new sealing key - users cannot provide their own
-    const sealingPair = await GenerateSealingKey();
+    const sealingPair = GenerateSealingKey();
 
-    return {
-      ...validation.data,
+    const permit = {
+      hash: PermitUtils.getHash(validation),
+      ...validation,
       sealingPair,
       _signedDomain: undefined,
-    };
+    } satisfies SharingPermit;
+
+    return permit;
   },
 
   /**
    * Import a shared permit from various input formats
    */
-  importShared: async (options: ImportSharedPermitOptions | any | string): Promise<Permit> => {
+  importShared: (options: ImportSharedPermitOptions | string): RecipientPermit => {
     let parsedOptions: ImportSharedPermitOptions;
 
     // Handle different input types
@@ -82,52 +81,47 @@ export const PermitUtils = {
       try {
         parsedOptions = JSON.parse(options);
       } catch (error) {
-        throw new Error(`PermitUtils :: importShared :: Failed to parse JSON string: ${error}`);
+        throw new Error(`Failed to parse JSON string: ${error}`);
       }
     } else if (typeof options === 'object' && options !== null) {
       // Handle both ImportSharedPermitOptions and any object
       parsedOptions = options;
     } else {
-      throw new Error(
-        'PermitUtils :: importShared :: Invalid input type, expected ImportSharedPermitOptions, object, or string'
-      );
+      throw new Error('Invalid input type, expected ImportSharedPermitOptions, object, or string');
     }
 
     // Validate type if provided
     if (parsedOptions.type != null && parsedOptions.type !== 'sharing') {
-      throw new Error(`PermitUtils :: importShared :: Invalid permit type <${parsedOptions.type}>, must be "sharing"`);
+      throw new Error(`Invalid permit type <${parsedOptions.type}>, must be "sharing"`);
     }
 
     const validation = validateImportPermitOptions({ ...parsedOptions, type: 'recipient' });
 
-    if (!validation.success) {
-      throw new Error(
-        'PermitUtils :: importShared :: Parsing ImportPermitOptions failed ' + JSON.stringify(validation.error, null, 2)
-      );
-    }
-
     // Always generate a new sealing key - users cannot provide their own
-    const sealingPair = await GenerateSealingKey();
+    const sealingPair = GenerateSealingKey();
 
-    return {
-      ...validation.data,
+    const permit = {
+      hash: PermitUtils.getHash(validation),
+      ...validation,
       sealingPair,
       _signedDomain: undefined,
-    };
+    } satisfies RecipientPermit;
+
+    return permit;
   },
 
   /**
    * Sign a permit with the provided wallet client
    */
-  sign: async (permit: Permit, publicClient: PublicClient, walletClient: WalletClient): Promise<Permit> => {
+  sign: async <T extends Permit>(permit: T, publicClient: PublicClient, walletClient: WalletClient): Promise<T> => {
     if (walletClient == null || walletClient.account == null) {
       throw new Error(
-        'PermitUtils :: sign - walletClient undefined, you must pass in a `walletClient` for the connected user to create a permit signature'
+        'Missing walletClient, you must pass in a `walletClient` for the connected user to create a permit signature'
       );
     }
 
     const primaryType = SignatureUtils.getPrimaryType(permit.type);
-    const domain = await PermitUtils.fetchEIP712Domain(publicClient);
+    const domain = await getAclEIP712Domain(publicClient);
     const { types, message } = SignatureUtils.getSignatureParams(PermitUtils.getPermission(permit, true), primaryType);
 
     const signature = await walletClient.signTypedData({
@@ -153,7 +147,7 @@ export const PermitUtils = {
       };
     }
 
-    return updatedPermit;
+    return updatedPermit as T;
   },
 
   /**
@@ -163,8 +157,8 @@ export const PermitUtils = {
     options: CreateSelfPermitOptions,
     publicClient: PublicClient,
     walletClient: WalletClient
-  ): Promise<Permit> => {
-    const permit = await PermitUtils.createSelf(options);
+  ): Promise<SelfPermit> => {
+    const permit = PermitUtils.createSelf(options);
     return PermitUtils.sign(permit, publicClient, walletClient);
   },
 
@@ -175,8 +169,8 @@ export const PermitUtils = {
     options: CreateSharingPermitOptions,
     publicClient: PublicClient,
     walletClient: WalletClient
-  ): Promise<Permit> => {
-    const permit = await PermitUtils.createSharing(options);
+  ): Promise<SharingPermit> => {
+    const permit = PermitUtils.createSharing(options);
     return PermitUtils.sign(permit, publicClient, walletClient);
   },
 
@@ -184,11 +178,11 @@ export const PermitUtils = {
    * Import and sign a shared permit in one operation from various input formats
    */
   importSharedAndSign: async (
-    options: ImportSharedPermitOptions | any | string,
+    options: ImportSharedPermitOptions | string,
     publicClient: PublicClient,
     walletClient: WalletClient
-  ): Promise<Permit> => {
-    const permit = await PermitUtils.importShared(options);
+  ): Promise<RecipientPermit> => {
+    const permit = PermitUtils.importShared(options);
     return PermitUtils.sign(permit, publicClient, walletClient);
   },
 
@@ -207,6 +201,7 @@ export const PermitUtils = {
    */
   serialize: (permit: Permit): SerializedPermit => {
     return {
+      hash: permit.hash,
       name: permit.name,
       type: permit.type,
       issuer: permit.issuer,
@@ -232,7 +227,7 @@ export const PermitUtils = {
     } else if (permit.type === 'recipient') {
       return validateImportPermit(permit);
     } else {
-      throw new Error('PermitUtils :: validate :: Invalid permit type');
+      throw new Error('Invalid permit type');
     }
   },
 
@@ -241,13 +236,7 @@ export const PermitUtils = {
    */
   getPermission: (permit: Permit, skipValidation = false): Permission => {
     if (!skipValidation) {
-      const validationResult = PermitUtils.validate(permit);
-
-      if (!validationResult.success) {
-        throw new Error(
-          `PermitUtils :: getPermission :: permit validation failed - ${JSON.stringify(validationResult.error, null, 2)} ${JSON.stringify(permit, null, 2)}`
-        );
-      }
+      PermitUtils.validate(permit);
     }
 
     return {
@@ -265,7 +254,7 @@ export const PermitUtils = {
   /**
    * Get a stable hash for the permit (used as key in storage)
    */
-  getHash: (permit: Permit): string => {
+  getHash: (permit: PermitHashFields): string => {
     const data = JSON.stringify({
       type: permit.type,
       issuer: permit.issuer,
@@ -336,41 +325,7 @@ export const PermitUtils = {
    * Fetch EIP712 domain from the blockchain
    */
   fetchEIP712Domain: async (publicClient: PublicClient): Promise<EIP712Domain> => {
-    // Hardcoded constants from the original implementation
-    const TASK_MANAGER_ADDRESS = '0xeA30c4B8b44078Bbf8a6ef5b9f1eC1626C7848D9';
-    const ACL_IFACE = 'function acl() view returns (address)';
-    const EIP712_DOMAIN_IFACE =
-      'function eip712Domain() public view returns (bytes1 fields, string name, string version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] extensions)';
-
-    // Parse the ABI for the ACL function
-    const aclAbi = parseAbi([ACL_IFACE]);
-
-    // Get the ACL address
-    const aclAddress = (await publicClient.readContract({
-      address: TASK_MANAGER_ADDRESS as `0x${string}`,
-      abi: aclAbi,
-      functionName: 'acl',
-    })) as `0x${string}`;
-
-    // Parse the ABI for the EIP712 domain function
-    const domainAbi = parseAbi([EIP712_DOMAIN_IFACE]);
-
-    // Get the EIP712 domain
-    const domain = await publicClient.readContract({
-      address: aclAddress,
-      abi: domainAbi,
-      functionName: 'eip712Domain',
-    });
-
-    // eslint-disable-next-line no-unused-vars
-    const [_fields, name, version, chainId, verifyingContract, _salt, _extensions] = domain;
-
-    return {
-      name,
-      version,
-      chainId: Number(chainId),
-      verifyingContract,
-    };
+    return getAclEIP712Domain(publicClient);
   },
 
   /**
@@ -390,7 +345,15 @@ export const PermitUtils = {
    */
   checkSignedDomainValid: async (permit: Permit, publicClient: PublicClient): Promise<boolean> => {
     if (permit._signedDomain == null) return false;
-    const domain = await PermitUtils.fetchEIP712Domain(publicClient);
+    const domain = await getAclEIP712Domain(publicClient);
     return PermitUtils.matchesDomain(permit, domain);
   },
+
+  /**
+   * Check if permit passes the on-chain validation
+   */
+  checkValidityOnChain: async (permit: Permit, publicClient: PublicClient): Promise<boolean> => {
+    const permission = PermitUtils.getPermission(permit);
+    return checkPermitValidityOnChain(permission, publicClient);
+  },
 };

package/permits/sealing.test.ts

@@ -67,7 +67,7 @@ describe('SealingKey', () => {
 
 describe('GenerateSealingKey', () => {
   it('should generate a valid SealingKey', async () => {
-    const sealingKey = await GenerateSealingKey();
+    const sealingKey = GenerateSealingKey();
 
     expect(sealingKey).toBeInstanceOf(SealingKey);
     expect(sealingKey.privateKey).toHaveLength(64);
@@ -75,8 +75,8 @@ describe('GenerateSealingKey', () => {
   });
 
   it('should generate different keys on each call', async () => {
-    const key1 = await GenerateSealingKey();
-    const key2 = await GenerateSealingKey();
+    const key1 = GenerateSealingKey();
+    const key2 = GenerateSealingKey();
 
     expect(key1.privateKey).not.toBe(key2.privateKey);
     expect(key1.publicKey).not.toBe(key2.publicKey);

package/permits/sealing.ts

@@ -122,9 +122,9 @@ export class SealingKey {
  * Asynchronously generates a new SealingKey.
  * This function uses the 'nacl' library to create a new public/private key pair for sealing purposes.
  * A sealing key is used to encrypt data such that it can only be unsealed (decrypted) by the owner of the corresponding private key.
- * @returns {Promise<SealingKey>} - A promise that resolves to a new SealingKey object containing the hexadecimal strings of the public and private keys.
+ * @returns {SealingKey} - A new SealingKey object containing the hexadecimal strings of the public and private keys.
  */
-export const GenerateSealingKey = async (): Promise<SealingKey> => {
+export const GenerateSealingKey = (): SealingKey => {
   const sodiumKeypair = nacl.box.keyPair();
 
   return new SealingKey(toHexString(sodiumKeypair.secretKey), toHexString(sodiumKeypair.publicKey));