@cofhe/sdk 0.1.1 → 0.2.1

package/core/index.ts

@@ -1,5 +1,5 @@
 // Client (base implementations)
-export { createCofhesdkClientBase } from './client.js';
+export { createCofhesdkClientBase, InitialConnectStore as CONNECT_STORE_DEFAULTS } from './client.js';
 
 // Configuration (base implementations)
 export { createCofhesdkConfigBase, getCofhesdkConfigItem } from './config.js';
@@ -12,6 +12,9 @@ export type {
   CofhesdkClientParams,
   CofhesdkClientConnectionState,
   CofhesdkClientPermits,
+} from './clientTypes.js';
+
+export type {
   IStorage,
   // Primitive types
   Primitive,
@@ -34,35 +37,33 @@ export type {
   EncryptedUint32Input,
   EncryptedUint64Input,
   EncryptedUint128Input,
-  EncryptedUint256Input,
   EncryptedAddressInput,
   EncryptedItemInputs,
   EncryptableToEncryptedItemInputMap,
+  FheTypeValue,
   // Decryption types
   UnsealedItem,
   // Util types
   EncryptStepCallbackFunction as EncryptSetStateFn,
+  EncryptStepCallbackContext,
+} from './types.js';
+export {
+  FheTypes,
+  FheUintUTypes,
+  FheAllUTypes,
+  Encryptable,
+  isEncryptableItem,
+  EncryptStep,
+  isLastEncryptionStep,
+  assertCorrectEncryptedItemInput,
 } from './types.js';
-export { FheTypes, FheUintUTypes, FheAllUTypes, Encryptable, isEncryptableItem, EncryptStep } from './types.js';
 
 // Error handling
 export { CofhesdkError, CofhesdkErrorCode, isCofhesdkError } from './error.js';
 export type { CofhesdkErrorParams } from './error.js';
 
-// Result types
-export {
-  ResultErr,
-  ResultOk,
-  ResultErrOrInternal,
-  ResultHttpError,
-  ResultValidationError,
-  resultWrapper,
-  resultWrapperSync,
-} from './result.js';
-export type { Result } from './result.js';
-
 // Key fetching
-export { fetchKeys, fetchMultichainKeys } from './fetchKeys.js';
+export { fetchKeys } from './fetchKeys.js';
 export type { FheKeyDeserializer } from './fetchKeys.js';
 
 // Key storage
@@ -74,4 +75,23 @@ export { EncryptInputsBuilder } from './encrypt/encryptInputsBuilder.js';
 export { DecryptHandlesBuilder } from './decrypt/decryptHandleBuilder.js';
 
 // ZK utilities
-export type { ZkBuilderAndCrsGenerator } from './encrypt/zkPackProveVerify.js';
+export type {
+  ZkBuilderAndCrsGenerator,
+  ZkProveWorkerFunction,
+  ZkProveWorkerRequest,
+  ZkProveWorkerResponse,
+} from './encrypt/zkPackProveVerify.js';
+export { zkProveWithWorker } from './encrypt/zkPackProveVerify.js';
+
+// Contract addresses
+export {
+  TASK_MANAGER_ADDRESS,
+  MOCKS_ZK_VERIFIER_ADDRESS,
+  MOCKS_ZK_VERIFIER_SIGNER_ADDRESS,
+  MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY,
+  MOCKS_QUERY_DECRYPTER_ADDRESS,
+  TEST_BED_ADDRESS,
+} from './consts.js';
+
+// Utils
+export { fheTypeToString } from './utils.js';

package/core/keyStore.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-unused-vars */
 import { createStore, type StoreApi } from 'zustand/vanilla';
 import { persist, createJSONStorage } from 'zustand/middleware';
 import { produce } from 'immer';
@@ -24,6 +23,30 @@ export type KeysStorage = {
   rehydrateKeysStore: () => Promise<void>;
 };
 
+function isValidPersistedState(state: unknown): state is KeysStore {
+  if (state && typeof state === 'object') {
+    if ('fhe' in state && 'crs' in state) {
+      return true;
+    } else {
+      throw new Error(
+        "Invalid persisted state structure for KeysStore. Is object but doesn't contain required fields 'fhe' and 'crs'."
+      );
+    }
+  }
+
+  return false;
+}
+
+const DEFAULT_KEYS_STORE: KeysStore = {
+  fhe: {},
+  crs: {},
+};
+
+type StoreWithPersist = ReturnType<typeof createStoreWithPersit>;
+
+function isStoreWithPersist(store: StoreApi<KeysStore> | StoreWithPersist): store is StoreWithPersist {
+  return 'persist' in store;
+}
 /**
  * Creates a keys storage instance using the provided storage implementation
  * @param storage - The storage implementation to use (IStorage interface), or null for non-persisted store
@@ -32,39 +55,7 @@ export type KeysStorage = {
 export function createKeysStore(storage: IStorage | null): KeysStorage {
   // Conditionally create store with or without persist wrapper
   const keysStore = storage
-    ? createStore<KeysStore>()(
-        persist(
-          () => ({
-            fhe: {},
-            crs: {},
-          }),
-          {
-            name: 'cofhesdk-keys',
-            storage: createJSONStorage(() => storage),
-            merge: (persistedState, currentState) => {
-              const persisted = persistedState as KeysStore;
-              const current = currentState as KeysStore;
-
-              // Deep merge for fhe
-              const mergedFhe: KeysStore['fhe'] = { ...persisted.fhe };
-              const allChainIds = new Set([...Object.keys(current.fhe), ...Object.keys(persisted.fhe)]);
-              for (const chainId of allChainIds) {
-                const persistedZones = persisted.fhe[chainId] || {};
-                const currentZones = current.fhe[chainId] || {};
-                mergedFhe[chainId] = { ...persistedZones, ...currentZones };
-              }
-
-              // Deep merge for crs
-              const mergedCrs: KeysStore['crs'] = { ...persisted.crs, ...current.crs };
-
-              return {
-                fhe: mergedFhe,
-                crs: mergedCrs,
-              };
-            },
-          }
-        )
-      )
+    ? createStoreWithPersit(storage)
     : createStore<KeysStore>()(() => ({
         fhe: {},
         crs: {},
@@ -109,10 +100,9 @@ export function createKeysStore(storage: IStorage | null): KeysStorage {
   };
 
   const rehydrateKeysStore = async () => {
-    if ('persist' in keysStore) {
-      if ((keysStore.persist as any).hasHydrated()) return;
-      await (keysStore.persist as any).rehydrate();
-    }
+    if (!isStoreWithPersist(keysStore)) return;
+    if (keysStore.persist.hasHydrated()) return;
+    await keysStore.persist.rehydrate();
   };
 
   return {
@@ -125,3 +115,40 @@ export function createKeysStore(storage: IStorage | null): KeysStorage {
     rehydrateKeysStore,
   };
 }
+
+function createStoreWithPersit(storage: IStorage) {
+  const result = createStore<KeysStore>()(
+    persist(() => DEFAULT_KEYS_STORE, {
+      // because earleir tests were written with on-init hydration skipped (due to the error suppression in zustand), returning this flag to fix test (i.e. KeyStore > Storage Utilities > should rehydrate keys store)
+      skipHydration: true,
+      // if onRehydrateStorage is not passed here, the errors thrown by storage layer are swallowed by zustand here: https://github.com/pmndrs/zustand/blob/39a391b6c1ff9aa89b81694d9bdb21da37dd4ac6/src/middleware/persist.ts#L321
+      onRehydrateStorage: () => (_state?, _error?) => {
+        if (_error) throw new Error(`onRehydrateStorage: Error rehydrating keys store: ${_error}`);
+      },
+      name: 'cofhesdk-keys',
+      storage: createJSONStorage(() => storage),
+      merge: (persistedState, currentState) => {
+        const persisted = isValidPersistedState(persistedState) ? persistedState : DEFAULT_KEYS_STORE;
+        const current = currentState as KeysStore;
+
+        // Deep merge for fhe
+        const mergedFhe: KeysStore['fhe'] = { ...persisted.fhe };
+        const allChainIds = new Set([...Object.keys(current.fhe), ...Object.keys(persisted.fhe)]);
+        for (const chainId of allChainIds) {
+          const persistedZones = persisted.fhe[chainId] || {};
+          const currentZones = current.fhe[chainId] || {};
+          mergedFhe[chainId] = { ...persistedZones, ...currentZones };
+        }
+
+        // Deep merge for crs
+        const mergedCrs: KeysStore['crs'] = { ...persisted.crs, ...current.crs };
+
+        return {
+          fhe: mergedFhe,
+          crs: mergedCrs,
+        };
+      },
+    })
+  );
+  return result;
+}

package/core/permits.test.ts

@@ -1,7 +1,6 @@
 /**
  * @vitest-environment happy-dom
  */
-/* eslint-disable no-unused-vars */
 import { permitStore } from '@/permits';
 
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
@@ -152,7 +151,7 @@ describe('Core Permits Tests', () => {
         publicClient,
         bobWalletClient
       );
-      permitHash = permits.getHash(createdPermit);
+      permitHash = createdPermit.hash;
     });
 
     it('should get permit by hash', async () => {
@@ -196,9 +195,8 @@ describe('Core Permits Tests', () => {
       const permitKeys = Object.keys(parsedData.state.permits[chainId][bobAddress]);
       expect(permitKeys.length).toBeGreaterThan(0);
 
-      const permitHash = permits.getHash(createdPermit);
       const serializedPermit = permits.serialize(createdPermit);
-      expect(parsedData.state.permits[chainId][bobAddress][permitHash]).toEqual(serializedPermit);
+      expect(parsedData.state.permits[chainId][bobAddress][createdPermit.hash]).toEqual(serializedPermit);
     });
   });
 
@@ -239,4 +237,257 @@ describe('Core Permits Tests', () => {
       expect(activePermit?.name).toBe('Permit 2');
     });
   });
+
+  describe('getOrCreateSelfPermit', () => {
+    it('should create a new self permit when none exists', async () => {
+      const permit = await permits.getOrCreateSelfPermit(publicClient, bobWalletClient, chainId, bobAddress, {
+        issuer: bobAddress,
+        name: 'New Self Permit',
+      });
+
+      expect(permit).toBeDefined();
+      expect(permit.name).toBe('New Self Permit');
+      expect(permit.type).toBe('self');
+      expect(permit.issuer).toBe(bobAddress);
+      expect(permit.issuerSignature).toBeDefined();
+
+      // Verify it was stored and set as active
+      const activePermit = await permits.getActivePermit(chainId, bobAddress);
+      expect(activePermit?.name).toBe('New Self Permit');
+    });
+
+    it('should return existing self permit when one exists', async () => {
+      // Create an initial self permit
+      const firstPermit = await permits.createSelf(
+        { name: 'First Self Permit', issuer: bobAddress },
+        publicClient,
+        bobWalletClient
+      );
+
+      // Call getOrCreateSelfPermit - should return existing
+      const permit = await permits.getOrCreateSelfPermit(publicClient, bobWalletClient, chainId, bobAddress, {
+        issuer: bobAddress,
+        name: 'Should Not Create This',
+      });
+
+      expect(permit.name).toBe('First Self Permit');
+      expect(permit.hash).toBe(firstPermit.hash);
+
+      // Verify no new permit was created
+      const allPermits = await permits.getPermits(chainId, bobAddress);
+      expect(Object.keys(allPermits).length).toBe(1);
+    });
+
+    it('should create new self permit when active permit is sharing type', async () => {
+      // Create a sharing permit first
+      await permits.createSharing(
+        {
+          name: 'Sharing Permit',
+          issuer: bobAddress,
+          recipient: aliceAddress,
+        },
+        publicClient,
+        bobWalletClient
+      );
+
+      // Call getOrCreateSelfPermit - should create new since active is sharing type
+      const permit = await permits.getOrCreateSelfPermit(publicClient, bobWalletClient, chainId, bobAddress, {
+        issuer: bobAddress,
+        name: 'New Self Permit',
+      });
+
+      expect(permit.name).toBe('New Self Permit');
+      expect(permit.type).toBe('self');
+
+      // Verify two permits exist now
+      const allPermits = await permits.getPermits(chainId, bobAddress);
+      expect(Object.keys(allPermits).length).toBe(2);
+    });
+
+    it('should use default options when none provided', async () => {
+      const permit = await permits.getOrCreateSelfPermit(publicClient, bobWalletClient, chainId, bobAddress);
+
+      expect(permit).toBeDefined();
+      expect(permit.type).toBe('self');
+      expect(permit.issuer).toBe(bobAddress);
+      expect(permit.name).toBe('Autogenerated Self Permit');
+    });
+
+    it('should use default chainId and account when not provided', async () => {
+      const permit = await permits.getOrCreateSelfPermit(publicClient, bobWalletClient, undefined, undefined, {
+        issuer: bobAddress,
+        name: 'Test Permit',
+      });
+
+      expect(permit).toBeDefined();
+      expect(permit.issuer).toBe(bobAddress);
+
+      // Verify it was stored with the chain's actual chainId
+      const activePermit = await permits.getActivePermit(chainId, bobAddress);
+      expect(activePermit?.name).toBe('Test Permit');
+    });
+  });
+
+  describe('getOrCreateSharingPermit', () => {
+    it('should create a new sharing permit when none exists', async () => {
+      const permit = await permits.getOrCreateSharingPermit(
+        publicClient,
+        bobWalletClient,
+        {
+          issuer: bobAddress,
+          recipient: aliceAddress,
+          name: 'New Sharing Permit',
+        },
+        chainId,
+        bobAddress
+      );
+
+      expect(permit).toBeDefined();
+      expect(permit.name).toBe('New Sharing Permit');
+      expect(permit.type).toBe('sharing');
+      expect(permit.issuer).toBe(bobAddress);
+      expect(permit.recipient).toBe(aliceAddress);
+      expect(permit.issuerSignature).toBeDefined();
+
+      // Verify it was stored and set as active
+      const activePermit = await permits.getActivePermit(chainId, bobAddress);
+      expect(activePermit?.name).toBe('New Sharing Permit');
+    });
+
+    it('should return existing sharing permit when one exists', async () => {
+      // Create an initial sharing permit
+      const firstPermit = await permits.createSharing(
+        {
+          name: 'First Sharing Permit',
+          issuer: bobAddress,
+          recipient: aliceAddress,
+        },
+        publicClient,
+        bobWalletClient
+      );
+
+      // Call getOrCreateSharingPermit - should return existing
+      const permit = await permits.getOrCreateSharingPermit(
+        publicClient,
+        bobWalletClient,
+        {
+          issuer: bobAddress,
+          recipient: aliceAddress,
+          name: 'Should Not Create This',
+        },
+        chainId,
+        bobAddress
+      );
+
+      expect(permit.name).toBe('First Sharing Permit');
+      expect(permit.hash).toBe(firstPermit.hash);
+
+      // Verify no new permit was created
+      const allPermits = await permits.getPermits(chainId, bobAddress);
+      expect(Object.keys(allPermits).length).toBe(1);
+    });
+
+    it('should create new sharing permit when active permit is self type', async () => {
+      // Create a self permit first
+      await permits.createSelf({ name: 'Self Permit', issuer: bobAddress }, publicClient, bobWalletClient);
+
+      // Call getOrCreateSharingPermit - should create new since active is self type
+      const permit = await permits.getOrCreateSharingPermit(
+        publicClient,
+        bobWalletClient,
+        {
+          issuer: bobAddress,
+          recipient: aliceAddress,
+          name: 'New Sharing Permit',
+        },
+        chainId,
+        bobAddress
+      );
+
+      expect(permit.name).toBe('New Sharing Permit');
+      expect(permit.type).toBe('sharing');
+
+      // Verify two permits exist now
+      const allPermits = await permits.getPermits(chainId, bobAddress);
+      expect(Object.keys(allPermits).length).toBe(2);
+    });
+
+    it('should use default chainId and account when not provided', async () => {
+      const permit = await permits.getOrCreateSharingPermit(
+        publicClient,
+        bobWalletClient,
+        {
+          issuer: bobAddress,
+          recipient: aliceAddress,
+          name: 'Test Sharing Permit',
+        },
+        undefined,
+        undefined
+      );
+
+      expect(permit).toBeDefined();
+      expect(permit.issuer).toBe(bobAddress);
+      expect(permit.recipient).toBe(aliceAddress);
+
+      // Verify it was stored with the chain's actual chainId
+      const activePermit = await permits.getActivePermit(chainId, bobAddress);
+      expect(activePermit?.name).toBe('Test Sharing Permit');
+    });
+  });
+
+  describe('getOrCreate - Multiple Types Scenarios', () => {
+    it('should handle switching between self and sharing permits', async () => {
+      // Create self permit
+      const selfPermit = await permits.getOrCreateSelfPermit(publicClient, bobWalletClient, chainId, bobAddress, {
+        issuer: bobAddress,
+        name: 'Self Permit',
+      });
+      expect(selfPermit.type).toBe('self');
+
+      // Create sharing permit (should create new one)
+      const sharingPermit = await permits.getOrCreateSharingPermit(
+        publicClient,
+        bobWalletClient,
+        {
+          issuer: bobAddress,
+          recipient: aliceAddress,
+          name: 'Sharing Permit',
+        },
+        chainId,
+        bobAddress
+      );
+      expect(sharingPermit.type).toBe('sharing');
+
+      // Both should exist
+      const allPermits = await permits.getPermits(chainId, bobAddress);
+      expect(Object.keys(allPermits).length).toBe(2);
+
+      // Active permit should be the sharing one
+      const activePermit = await permits.getActivePermit(chainId, bobAddress);
+      expect(activePermit?.type).toBe('sharing');
+      expect(activePermit?.name).toBe('Sharing Permit');
+    });
+
+    it('should correctly handle sequential getOrCreate calls', async () => {
+      // First call - creates new
+      const permit1 = await permits.getOrCreateSelfPermit(publicClient, bobWalletClient, chainId, bobAddress, {
+        issuer: bobAddress,
+        name: 'Permit 1',
+      });
+
+      // Second call - returns existing
+      const permit2 = await permits.getOrCreateSelfPermit(publicClient, bobWalletClient, chainId, bobAddress, {
+        issuer: bobAddress,
+        name: 'Permit 2',
+      });
+
+      // Should be the same permit
+      expect(permit1.hash).toBe(permit2.hash);
+      expect(permit2.name).toBe('Permit 1'); // Original name
+
+      // Only one permit should exist
+      const allPermits = await permits.getPermits(chainId, bobAddress);
+      expect(Object.keys(allPermits).length).toBe(1);
+    });
+  });
 });

package/core/permits.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-unused-vars */
 import {
   type ImportSharedPermitOptions,
   PermitUtils,
@@ -7,6 +6,10 @@ import {
   type Permit,
   permitStore,
   type SerializedPermit,
+  type SelfPermit,
+  type RecipientPermit,
+  type SharingPermit,
+  type PermitHashFields,
 } from '@/permits';
 
 import { type PublicClient, type WalletClient } from 'viem';
@@ -19,16 +22,16 @@ const storeActivePermit = async (permit: Permit, publicClient: any, walletClient
   const account = walletClient.account!.address;
 
   permitStore.setPermit(chainId, account, permit);
-  permitStore.setActivePermitHash(chainId, account, PermitUtils.getHash(permit));
+  permitStore.setActivePermitHash(chainId, account, permit.hash);
 };
 
 // Generic function to handle permit creation with error handling
-const createPermitWithSign = async <T>(
+const createPermitWithSign = async <T, TPermit extends Permit>(
   options: T,
   publicClient: PublicClient,
   walletClient: WalletClient,
-  permitMethod: (options: T, publicClient: PublicClient, walletClient: WalletClient) => Promise<Permit>
-): Promise<Permit> => {
+  permitMethod: (options: T, publicClient: PublicClient, walletClient: WalletClient) => Promise<TPermit>
+): Promise<TPermit> => {
   const permit = await permitMethod(options, publicClient, walletClient);
   await storeActivePermit(permit, publicClient, walletClient);
   return permit;
@@ -46,7 +49,7 @@ const createSelf = async (
   options: CreateSelfPermitOptions,
   publicClient: PublicClient,
   walletClient: WalletClient
-): Promise<Permit> => {
+): Promise<SelfPermit> => {
   return createPermitWithSign(options, publicClient, walletClient, PermitUtils.createSelfAndSign);
 };
 
@@ -54,21 +57,21 @@ const createSharing = async (
   options: CreateSharingPermitOptions,
   publicClient: PublicClient,
   walletClient: WalletClient
-): Promise<Permit> => {
+): Promise<SharingPermit> => {
   return createPermitWithSign(options, publicClient, walletClient, PermitUtils.createSharingAndSign);
 };
 
 const importShared = async (
-  options: ImportSharedPermitOptions | any | string,
+  options: ImportSharedPermitOptions | string,
   publicClient: PublicClient,
   walletClient: WalletClient
-): Promise<Permit> => {
+): Promise<RecipientPermit> => {
   return createPermitWithSign(options, publicClient, walletClient, PermitUtils.importSharedAndSign);
 };
 
 // PERMIT UTILS
 
-const getHash = (permit: Permit) => {
+const getHash = (permit: PermitHashFields) => {
   return PermitUtils.getHash(permit);
 };
 
@@ -94,24 +97,83 @@ const getActivePermit = async (chainId: number, account: string): Promise<Permit
   return permitStore.getActivePermit(chainId, account);
 };
 
-const getActivePermitHash = async (chainId: number, account: string): Promise<string | undefined> => {
+const getActivePermitHash = (chainId: number, account: string): string | undefined => {
   return permitStore.getActivePermitHash(chainId, account);
 };
 
-const selectActivePermit = async (chainId: number, account: string, hash: string): Promise<void> => {
-  await permitStore.setActivePermitHash(chainId, account, hash);
+const selectActivePermit = (chainId: number, account: string, hash: string): void => {
+  permitStore.setActivePermitHash(chainId, account, hash);
 };
 
-// REMOVE
+// GET OR CREATE
+
+/**
+ * Get the active self permit or create a new one if it doesn't exist
+ * @param publicClient - The public client
+ * @param walletClient - The wallet client
+ * @param chainId - Optional chain ID (will use publicClient if not provided)
+ * @param account - Optional account (will use walletClient if not provided)
+ * @param options - The options for creating a self permit
+ * @returns The existing or newly created permit
+ */
+const getOrCreateSelfPermit = async (
+  publicClient: PublicClient,
+  walletClient: WalletClient,
+  chainId?: number,
+  account?: string,
+  options?: CreateSelfPermitOptions
+): Promise<Permit> => {
+  const _chainId = chainId ?? (await publicClient.getChainId());
+  const _account = account ?? walletClient.account!.address;
+
+  // Try to get active permit first
+  const activePermit = await getActivePermit(_chainId, _account);
+
+  if (activePermit && activePermit.type === 'self') {
+    return activePermit;
+  }
 
-const removePermit = async (chainId: number, account: string, hash: string): Promise<void> => {
-  await permitStore.removePermit(chainId, account, hash);
+  // No active permit or wrong type, create new one
+  return createSelf(options ?? { issuer: _account, name: 'Autogenerated Self Permit' }, publicClient, walletClient);
 };
 
-const removeActivePermit = async (chainId: number, account: string): Promise<void> => {
-  await permitStore.removeActivePermitHash(chainId, account);
+/**
+ * Get the active sharing permit or create a new one if it doesn't exist
+ * @param publicClient - The public client
+ * @param walletClient - The wallet client
+ * @param options - The options for creating a sharing permit (required)
+ * @param chainId - Optional chain ID (will use publicClient if not provided)
+ * @param account - Optional account (will use walletClient if not provided)
+ * @returns The existing or newly created permit
+ */
+const getOrCreateSharingPermit = async (
+  publicClient: PublicClient,
+  walletClient: WalletClient,
+  options: CreateSharingPermitOptions,
+  chainId?: number,
+  account?: string
+): Promise<Permit> => {
+  const _chainId = chainId ?? (await publicClient.getChainId());
+  const _account = account ?? walletClient.account!.address;
+
+  // Try to get active permit first
+  const activePermit = await getActivePermit(_chainId, _account);
+
+  if (activePermit && activePermit.type === 'sharing') {
+    return activePermit;
+  }
+
+  return createSharing(options, publicClient, walletClient);
 };
 
+// REMOVE
+
+const removePermit = async (chainId: number, account: string, hash: string): Promise<void> =>
+  permitStore.removePermit(chainId, account, hash);
+
+const removeActivePermit = async (chainId: number, account: string): Promise<void> =>
+  permitStore.removeActivePermitHash(chainId, account);
+
 // EXPORT
 
 export const permits = {
@@ -122,6 +184,9 @@ export const permits = {
   createSharing,
   importShared,
 
+  getOrCreateSelfPermit,
+  getOrCreateSharingPermit,
+
   getHash,
   serialize,
   deserialize,