fix(vNaga): fmt

Author: Ansonhkg

packages/networks/src/lib/networks/vNaga/common/LitChainClient/README.md

@@ -51,15 +51,15 @@ The client provides three main API objects:
 ### Using High-Level API
 
 ```typescript
-import { LitChainClientAPI } from "../LitChainClient/apis";
+import { LitChainClientAPI } from '../LitChainClient/apis';
 
 // Minting a PKP with simplified API
 const result = await LitChainClientAPI.mintPKP(
   {
     authMethod: {
       authMethodType: 1,
-      id: "example-id",
-      pubkey: "0x...", // webAuthn only
+      id: 'example-id',
+      pubkey: '0x...', // webAuthn only
     },
   },
   networkContext
@@ -75,15 +75,15 @@ await permissionsManager.addPermittedAction(tokenId, actionId);
 ### Using Raw API
 
 ```typescript
-import { LitChainClientRawAPI } from "../LitChainClient/apis";
+import { LitChainClientRawAPI } from '../LitChainClient/apis';
 
 // Using the raw API
 const result = await LitChainClientRawAPI.pkp.write.mintNextAndAddAuthMethods(
   {
     keyType: 2,
     permittedAuthMethodTypes: [1],
-    permittedAuthMethodIds: ["example-id"],
-    permittedAuthMethodPubkeys: ["0x..."],
+    permittedAuthMethodIds: ['example-id'],
+    permittedAuthMethodPubkeys: ['0x...'],
     permittedAuthMethodScopes: [[1, 2, 3]],
     addPkpEthAddressAsPermittedAddress: true,
     sendPkpToItself: false,
@@ -102,7 +102,7 @@ const isPermitted =
 ### Using Utilities
 
 ```typescript
-import { LitChainClientUtils } from "../LitChainClient/apis";
+import { LitChainClientUtils } from '../LitChainClient/apis';
 
 // Create contract instances
 const contracts = LitChainClientUtils.createLitContracts(networkContext);

packages/networks/src/lib/networks/vNaga/common/LitChainClient/_config.ts

@@ -11,4 +11,5 @@ const GAS_LIMIT_INCREASE_PERCENTAGE = 10;
 export const GAS_LIMIT_ADJUSTMENT = BigInt(100 + GAS_LIMIT_INCREASE_PERCENTAGE);
 
 export const networkContext = nagaLocalDevelopNetworkContext; // we shall change this later
+
 export type NetworkContext = NagaLocalDevelopNetworkContext;

packages/networks/src/lib/networks/vNaga/common/LitChainClient/apis/highLevelApis/PKPPermissionsManager/PKPPermissionsManager.test.ts

@@ -1,20 +1,20 @@
-import { networkContext } from "../../../_config";
-import { PKPPermissionsManager } from "./PKPPermissionsManager";
+import { networkContext } from '../../../_config';
+import { PKPPermissionsManager } from './PKPPermissionsManager';
 
 // Configuration constants
 const TEST_TOKEN_ID =
-  "76136736151863037541847315168980811654782785653773679312890341037699996601290";
-const PKP_TEST_ADDRESS = "0xef3eE1bD838aF5B36482FAe8a6Fc394C68d5Fa9F";
+  '76136736151863037541847315168980811654782785653773679312890341037699996601290';
+const PKP_TEST_ADDRESS = '0xef3eE1bD838aF5B36482FAe8a6Fc394C68d5Fa9F';
 
-const MASTER_ADDRESS = "0xC434D4B9c307111a1CA6752AC47B77C571FcA500";
+const MASTER_ADDRESS = '0xC434D4B9c307111a1CA6752AC47B77C571FcA500';
 
 // Using valid IPFS CID format for v0 (Qm... format)
-const TEST_ACTION_IPFS_ID = "QmPK1s3pNYLi9ERiq3BDxKa4XosgWwFRQUydHUtz4YgpqB";
+const TEST_ACTION_IPFS_ID = 'QmPK1s3pNYLi9ERiq3BDxKa4XosgWwFRQUydHUtz4YgpqB';
 // Add a hex version of the IPFS ID for comparisons
 const TEST_ACTION_IPFS_ID_HEX =
-  "0x12200e7071c59df3b9454d1d18a15270aa36d54f89606a576dc621757afd44ad1d2e";
+  '0x12200e7071c59df3b9454d1d18a15270aa36d54f89606a576dc621757afd44ad1d2e';
 
-describe("PKPPermissionsManager", () => {
+describe('PKPPermissionsManager', () => {
   let manager: PKPPermissionsManager;
 
   // Set up the test environment
@@ -25,42 +25,42 @@ describe("PKPPermissionsManager", () => {
     );
   });
 
-  test("should get permissions context initially", async () => {
+  test('should get permissions context initially', async () => {
     const context = await manager.getPermissionsContext();
     expect(context).toBeDefined();
   });
 
-  test("should check if an address is permitted", async () => {
+  test('should check if an address is permitted', async () => {
     const isPermitted = await manager.isPermittedAddress({
       address: PKP_TEST_ADDRESS,
     });
     expect(isPermitted).toBeDefined();
   });
 
-  test("should check if an action is permitted", async () => {
+  test('should check if an action is permitted', async () => {
     const isPermitted = await manager.isPermittedAction({
       ipfsId: TEST_ACTION_IPFS_ID,
     });
     expect(isPermitted).toBeDefined();
   });
 
-  test("should get permitted addresses", async () => {
+  test('should get permitted addresses', async () => {
     const addresses = await manager.getPermittedAddresses();
     expect(addresses).toBeDefined();
     expect(Array.isArray(addresses)).toBe(true);
   });
 
-  test("should get permitted actions", async () => {
+  test('should get permitted actions', async () => {
     const actions = await manager.getPermittedActions();
     expect(actions).toBeDefined();
     expect(Array.isArray(actions)).toBe(true);
   });
 
-  test("should add and check a permitted address", async () => {
+  test('should add and check a permitted address', async () => {
     // For test purposes we just verify the call doesn't throw
     await manager.addPermittedAddress({
       address: PKP_TEST_ADDRESS,
-      scopes: ["sign-anything"],
+      scopes: ['sign-anything'],
     });
 
     const context = await manager.getPermissionsContext();
@@ -70,11 +70,11 @@ describe("PKPPermissionsManager", () => {
     expect(hasAddress).toBe(true);
   });
 
-  test("should add and check a permitted action", async () => {
+  test('should add and check a permitted action', async () => {
     // For test purposes we just verify the call doesn't throw
     await manager.addPermittedAction({
       ipfsId: TEST_ACTION_IPFS_ID,
-      scopes: ["sign-anything"],
+      scopes: ['sign-anything'],
     });
 
     const context = await manager.getPermissionsContext();
@@ -85,17 +85,17 @@ describe("PKPPermissionsManager", () => {
     expect(hasAction).toBe(true);
   });
 
-  test("should batch update permissions", async () => {
+  test('should batch update permissions', async () => {
     await manager.batchUpdatePermissions([
       {
-        type: "addAction",
+        type: 'addAction',
         ipfsId: TEST_ACTION_IPFS_ID,
-        scopes: ["sign-anything"],
+        scopes: ['sign-anything'],
       },
       {
-        type: "addAddress",
+        type: 'addAddress',
         address: PKP_TEST_ADDRESS,
-        scopes: ["sign-anything"],
+        scopes: ['sign-anything'],
       },
     ]);
 
@@ -112,7 +112,7 @@ describe("PKPPermissionsManager", () => {
     expect(hasAddress).toBe(true);
   });
 
-  test("should get PKPs by address", async () => {
+  test('should get PKPs by address', async () => {
     const pkps = await PKPPermissionsManager.getPKPsByAddress(
       MASTER_ADDRESS,
       networkContext
@@ -121,18 +121,18 @@ describe("PKPPermissionsManager", () => {
     expect(Array.isArray(pkps)).toBe(true);
   });
 
-  test("should revoke all permissions", async () => {
+  test('should revoke all permissions', async () => {
     // First ensure we have permissions to revoke by adding our test address and action
     await manager.batchUpdatePermissions([
       {
-        type: "addAction",
+        type: 'addAction',
         ipfsId: TEST_ACTION_IPFS_ID,
-        scopes: ["sign-anything"],
+        scopes: ['sign-anything'],
       },
       {
-        type: "addAddress",
+        type: 'addAddress',
         address: PKP_TEST_ADDRESS,
-        scopes: ["sign-anything"],
+        scopes: ['sign-anything'],
       },
     ]);
 
@@ -169,11 +169,11 @@ describe("PKPPermissionsManager", () => {
     expect(hasAddressAfter).toBe(false);
   });
 
-  test("should remove a permitted action", async () => {
+  test('should remove a permitted action', async () => {
     // First add the action
     await manager.addPermittedAction({
       ipfsId: TEST_ACTION_IPFS_ID,
-      scopes: ["sign-anything"],
+      scopes: ['sign-anything'],
     });
 
     // Then remove it
@@ -192,11 +192,11 @@ describe("PKPPermissionsManager", () => {
     expect(hasAction).toBeDefined();
   });
 
-  test("should remove a permitted address", async () => {
+  test('should remove a permitted address', async () => {
     // First add the address
     await manager.addPermittedAddress({
       address: PKP_TEST_ADDRESS,
-      scopes: ["sign-anything"],
+      scopes: ['sign-anything'],
     });
 
     // Then remove it
@@ -215,80 +215,80 @@ describe("PKPPermissionsManager", () => {
     expect(hasAddress).toBeDefined();
   });
 
-  test("should get permissions context with auth methods", async () => {
+  test('should get permissions context with auth methods', async () => {
     const context = await manager.getPermissionsContext();
     expect(context).toBeDefined();
     expect(Array.isArray(context.actions)).toBe(true);
     expect(Array.isArray(context.addresses)).toBe(true);
     expect(Array.isArray(context.authMethods)).toBe(true);
-    expect(typeof context.isActionPermitted).toBe("function");
-    expect(typeof context.isAddressPermitted).toBe("function");
-    expect(typeof context.isAuthMethodPermitted).toBe("function");
+    expect(typeof context.isActionPermitted).toBe('function');
+    expect(typeof context.isAddressPermitted).toBe('function');
+    expect(typeof context.isAuthMethodPermitted).toBe('function');
   });
 
-  test("should get permitted auth methods", async () => {
+  test('should get permitted auth methods', async () => {
     const authMethods = await manager.getPermittedAuthMethods();
     expect(authMethods).toBeDefined();
     expect(Array.isArray(authMethods)).toBe(true);
-    
+
     // If there are auth methods, verify their structure
     if (authMethods.length > 0) {
       const firstMethod = authMethods[0];
-      expect(typeof firstMethod.authMethodType).toBe("bigint");
-      expect(typeof firstMethod.id).toBe("string");
-      expect(typeof firstMethod.userPubkey).toBe("string");
+      expect(typeof firstMethod.authMethodType).toBe('bigint');
+      expect(typeof firstMethod.id).toBe('string');
+      expect(typeof firstMethod.userPubkey).toBe('string');
     }
   });
 
-  test("should get permitted auth method scopes", async () => {
+  test('should get permitted auth method scopes', async () => {
     // If there are auth methods, test getting scopes for the first one
     const authMethods = await manager.getPermittedAuthMethods();
-    
+
     if (authMethods.length > 0) {
       const firstMethod = authMethods[0];
       const scopes = await manager.getPermittedAuthMethodScopes({
         authMethodType: Number(firstMethod.authMethodType),
         authMethodId: firstMethod.id,
       });
-      
+
       expect(scopes).toBeDefined();
       expect(Array.isArray(scopes)).toBe(true);
-      
+
       // Verify each scope is a boolean
-      scopes.forEach(scope => {
-        expect(typeof scope).toBe("boolean");
+      scopes.forEach((scope) => {
+        expect(typeof scope).toBe('boolean');
       });
     } else {
       // If no auth methods exist, test with a mock auth method
       const scopes = await manager.getPermittedAuthMethodScopes({
         authMethodType: 1, // EthWallet type
-        authMethodId: "0x1234567890abcdef1234567890abcdef12345678",
+        authMethodId: '0x1234567890abcdef1234567890abcdef12345678',
       });
-      
+
       expect(scopes).toBeDefined();
       expect(Array.isArray(scopes)).toBe(true);
     }
   });
 
-  test("should verify auth method in permissions context", async () => {
+  test('should verify auth method in permissions context', async () => {
     const context = await manager.getPermissionsContext();
-    
+
     // If there are auth methods, test the helper function
     if (context.authMethods.length > 0) {
       const firstMethod = context.authMethods[0];
       const isPermitted = context.isAuthMethodPermitted(
         Number(firstMethod.authMethodType),
         firstMethod.id
       );
-      
+
       expect(isPermitted).toBe(true);
     } else {
       // If no auth methods, test with a non-existent auth method
       const isPermitted = context.isAuthMethodPermitted(
         1, // EthWallet type
-        "0x1234567890abcdef1234567890abcdef12345678"
+        '0x1234567890abcdef1234567890abcdef12345678'
       );
-      
+
       expect(isPermitted).toBe(false);
     }
   });