Fix formatting and enforce linting in workflow (5afe#11)

.github/workflows/ci.yml

@@ -31,4 +31,4 @@ jobs:
           path: "**/node_modules"
           key: ${{ runner.os }}-modules-${{ hashFiles('**/yarn.lock') }}
       - run: yarn --frozen-lockfile
-      - run: yarn lint:sol
+      - run: yarn lint

contracts/test/SamplePlugin.spec.ts

@@ -1,7 +1,7 @@
 import hre, { deployments } from "hardhat";
 import { expect } from "chai";
 import { SignerWithAddress } from "@nomicfoundation/hardhat-ethers/signers";
-import {  getSamplePlugin } from "./utils/contracts";
+import { getSamplePlugin } from "./utils/contracts";
 import { loadPluginMetaData } from "./utils/metadata";
 
 describe("SamplePlugin", async () => {
@@ -15,25 +15,26 @@ describe("SamplePlugin", async () => {
         await deployments.fixture();
         const plugin = await getSamplePlugin();
         return {
-            plugin
-        }
+            plugin,
+        };
     });
 
     it("should be inititalized correctly", async () => {
-        const { plugin } = await setup()
+        const { plugin } = await setup();
+        console.log(user1);
         expect(await plugin.name()).to.be.eq("Sample Plugin");
         expect(await plugin.version()).to.be.eq("1.0.0");
         expect(await plugin.requiresRootAccess()).to.be.false;
     });
 
     it("can retrieve meta data for module", async () => {
-        const { plugin } = await setup()
+        const { plugin } = await setup();
         expect(await loadPluginMetaData(plugin)).to.be.deep.eq({
-            name: 'Sample Plugin',
-            version: '1.0.0',
+            name: "Sample Plugin",
+            version: "1.0.0",
             requiresRootAccess: false,
-            iconUrl: '',
-            appUrl: ''
+            iconUrl: "",
+            appUrl: "",
         });
     });
 });

contracts/test/utils/contracts.ts

@@ -1,15 +1,15 @@
-import { Addressable, BaseContract } from "ethers";
+import { BaseContract } from "ethers";
 import hre, { deployments } from "hardhat";
 import { SamplePlugin } from "../../typechain-types";
 
-export const getInstance = async<T extends BaseContract>(name: string, address: string): Promise<T> => {
+export const getInstance = async <T extends BaseContract>(name: string, address: string): Promise<T> => {
     // TODO: this typecasting should be refactored
-    return (await hre.ethers.getContractAt(name, address) as unknown) as T;
+    return (await hre.ethers.getContractAt(name, address)) as unknown as T;
 };
 
-export const getSingleton = async<T extends BaseContract>(name: string): Promise<T> => {
+export const getSingleton = async <T extends BaseContract>(name: string): Promise<T> => {
     const deployment = await deployments.get(name);
-    return getInstance<T>(name, deployment.address)
+    return getInstance<T>(name, deployment.address);
 };
 
-export const getSamplePlugin = () => getSingleton<SamplePlugin>("SamplePlugin")
+export const getSamplePlugin = () => getSingleton<SamplePlugin>("SamplePlugin");

contracts/test/utils/metadata.ts

@@ -1,64 +1,55 @@
-import { AbiCoder, ParamType, isHexString, keccak256 } from "ethers"
-import { BasePlugin, MetaDataProvider, MetaDataProvider__factory } from "../../typechain-types"
+import { AbiCoder, isHexString, keccak256 } from "ethers";
+import { BasePlugin, MetaDataProvider } from "../../typechain-types";
 import { getInstance } from "./contracts";
 
 interface PluginMetaData {
-    name: string,
-    version: string,
-    requiresRootAccess: boolean,
-    iconUrl: string,
-    appUrl: string
+    name: string;
+    version: string;
+    requiresRootAccess: boolean;
+    iconUrl: string;
+    appUrl: string;
 }
 
-const ProviderType_IPFS = 0n;
-const ProviderType_URL = 1n;
+// const ProviderType_IPFS = 0n;
+// const ProviderType_URL = 1n;
 const ProviderType_Contract = 2n;
-const ProviderType_Event = 3n;
+// const ProviderType_Event = 3n;
 
-const PluginMetaDataType: string[] = [
-    "string name",
-    "string version",
-    "bool requiresRootAccess",
-    "string iconUrl",
-    "string appUrl"
-]
+const PluginMetaDataType: string[] = ["string name", "string version", "bool requiresRootAccess", "string iconUrl", "string appUrl"];
 
 const loadPluginMetaDataFromContract = async (provider: string, metaDataHash: string): Promise<string> => {
-    const providerInstance = await getInstance<MetaDataProvider>("MetaDataProvider", provider)
-    return await providerInstance.retrieveMetaData(metaDataHash)
-}
+    const providerInstance = await getInstance<MetaDataProvider>("MetaDataProvider", provider);
+    return await providerInstance.retrieveMetaData(metaDataHash);
+};
 
-const loadRawMetaData = async(plugin: BasePlugin, metaDataHash: string): Promise<string> => {
-    const [type, source] = await plugin.metaProvider()
-    switch(type) {
-        case ProviderType_Contract: 
-            return loadPluginMetaDataFromContract(AbiCoder.defaultAbiCoder().decode(["address"], source)[0], metaDataHash)
+const loadRawMetaData = async (plugin: BasePlugin, metaDataHash: string): Promise<string> => {
+    const [type, source] = await plugin.metaProvider();
+    switch (type) {
+        case ProviderType_Contract:
+            return loadPluginMetaDataFromContract(AbiCoder.defaultAbiCoder().decode(["address"], source)[0], metaDataHash);
         default:
-            throw Error("Unsupported MetaDataProviderType")
+            throw Error("Unsupported MetaDataProviderType");
     }
-}
+};
 
 export const loadPluginMetaData = async (plugin: BasePlugin): Promise<PluginMetaData> => {
-    const metaDataHash = await plugin.metaDataHash()
-    const metaData = await loadRawMetaData(plugin, metaDataHash)
-    if (metaDataHash !== keccak256(metaData)) throw Error("Invalid meta data retrieved!")
-    return decodePluginMetaData(metaData)
-} 
+    const metaDataHash = await plugin.metaDataHash();
+    const metaData = await loadRawMetaData(plugin, metaDataHash);
+    if (metaDataHash !== keccak256(metaData)) throw Error("Invalid meta data retrieved!");
+    return decodePluginMetaData(metaData);
+};
 
 export const decodePluginMetaData = (data: string): PluginMetaData => {
     if (!isHexString(data)) throw Error("Invalid data format");
-    const format = data.slice(2, 6)
+    const format = data.slice(2, 6);
     if (format !== "0000") throw Error("Unsupported format or format version");
-    const metaData = data.slice(6)
-    const decoded = AbiCoder.defaultAbiCoder().decode(
-        PluginMetaDataType,
-        "0x" + metaData
-    )
+    const metaData = data.slice(6);
+    const decoded = AbiCoder.defaultAbiCoder().decode(PluginMetaDataType, "0x" + metaData);
     return {
         name: decoded[0],
         version: decoded[1],
         requiresRootAccess: decoded[2],
         iconUrl: decoded[3],
-        appUrl: decoded[4]
-    }
-}
+        appUrl: decoded[4],
+    };
+};