genlayer 0.7.0 → 0.8.1-beta.0

package/docker-compose.yml

@@ -7,8 +7,8 @@ services:
       - "${FRONTEND_PORT:-8080}:8080"
     environment:
       - VITE_*
-    volumes:
-      - ./.env:/app/.env
+    env_file:
+      - ./.env
     depends_on:
       jsonrpc:
         condition: service_healthy
@@ -36,8 +36,8 @@ services:
     ports:
       - "${RPCPORT:-5000}:${RPCPORT:-5000}"
       - "${RPCDEBUGPORT:-5001}:${RPCDEBUGPORT:-5001}"
-    volumes:
-      - ./.env:/app/.env
+    env_file:
+      - ./.env
     healthcheck:
       test: [ "CMD", "python", "backend/healthcheck.py", "--port", "${RPCPORT}" ]
       interval: 30s
@@ -75,8 +75,8 @@ services:
     expose:
       - "${WEBREQUESTPORT:-5002}:${WEBREQUESTPORT:-5002}"
       - "${WEBREQUESTSELENIUMPORT:-4444}:${WEBREQUESTSELENIUMPORT:-4444}"
-    volumes:
-      - ./.env:/app/webrequest/.env
+    env_file:
+      - ./.env
     depends_on:
       ollama:
         condition: service_started
@@ -142,3 +142,10 @@ services:
         condition: service_healthy
       webrequest:
         condition: service_healthy
+
+  hardhat:
+    image: yeagerai/simulator-hardhat
+    ports:
+      - "${HARDHAT_PORT:-8545}:8545"
+    environment:
+      - HARDHAT_NETWORK=hardhat

package/esbuild.config.dev

@@ -5,7 +5,7 @@ module.exports = {
     bundle: true, // Bundle all dependencies
     outfile: "dist/index.js", // Output file
     platform: "node",
-    target: "es6",
+    target: "es2020",
     define: { 'import.meta.url': '_importMetaUrl' },
     banner: {
       js: "const _importMetaUrl=require('url').pathToFileURL(__filename)",

package/esbuild.config.prod

@@ -5,7 +5,7 @@ module.exports = {
     bundle: true, // Bundle all dependencies
     outfile: "dist/index.js", // Output file
     platform: "node",
-    target: "es6",
+    target: "es2020",
     define: { 'import.meta.url': '_importMetaUrl' },
     banner: {
       js: "const _importMetaUrl=require('url').pathToFileURL(__filename)",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.7.0",
+  "version": "0.8.1-beta.0",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
   "bin": {
@@ -60,11 +60,13 @@
     "dockerode": "^4.0.2",
     "dotenv": "^16.4.5",
     "ethers": "^6.13.4",
+    "genlayer-js": "^0.4.7",
     "inquirer": "^9.2.19",
     "node-fetch": "^2.7.0",
     "open": "^10.1.0",
     "update-check": "^1.5.4",
     "uuid": "^9.0.1",
+    "viem": "^2.21.54",
     "vitest": "^2.1.4"
   }
 }

package/src/commands/config/getSetReset.ts

@@ -0,0 +1,44 @@
+import { ConfigFileManager } from "../../lib/config/ConfigFileManager";
+
+export class ConfigActions {
+  private configManager: ConfigFileManager;
+
+  constructor() {
+    this.configManager = new ConfigFileManager();
+  }
+
+  set(keyValue: string): void {
+    const [key, value] = keyValue.split("=");
+    if (!key || value === undefined) {
+      console.error("Invalid format. Use key=value.");
+      process.exit(1);
+    }
+    this.configManager.writeConfig(key, value);
+    console.log(`Configuration updated: ${key}=${value}`);
+  }
+
+  get(key?: string): void {
+    if (key) {
+      const value = this.configManager.getConfigByKey(key);
+      if (value === null) {
+        console.log(`No value set for key: ${key}`);
+      } else {
+        console.log(`${key}=${value}`);
+      }
+    } else {
+      const config = this.configManager.getConfig();
+      console.log("Current configuration:", JSON.stringify(config, null, 2));
+    }
+  }
+
+  reset(key: string): void {
+    const config = this.configManager.getConfig();
+    if (config[key] === undefined) {
+      console.log(`Key does not exist in the configuration: ${key}`);
+      return;
+    }
+    delete config[key];
+    this.configManager.writeConfig(key, undefined);
+    console.log(`Configuration key reset: ${key}`);
+  }
+}

package/src/commands/config/index.ts

@@ -0,0 +1,30 @@
+import { Command } from "commander";
+import { ConfigActions } from "./getSetReset";
+
+export function initializeConfigCommands(program: Command) {
+  const configActions = new ConfigActions();
+
+  const configCommand = program
+    .command("config")
+    .description("Manage CLI configuration, including the default network");
+
+  configCommand
+    .command("set")
+    .description("Set a configuration value")
+    .argument("<key=value>", "Configuration key-value pair to set")
+    .action((keyValue: string) => configActions.set(keyValue));
+
+  configCommand
+    .command("get")
+    .description("Get the current configuration")
+    .argument("[key]", "Configuration key to retrieve")
+    .action((key?: string) => configActions.get(key));
+
+  configCommand
+    .command("reset")
+    .description("Reset a configuration value to its default")
+    .argument("<key>", "Configuration key to reset")
+    .action((key: string) => configActions.reset(key));
+
+  return program;
+}

package/src/commands/contracts/call.ts

@@ -0,0 +1,83 @@
+import { createClient, createAccount } from "genlayer-js";
+import { simulator } from "genlayer-js/chains";
+import type { GenLayerClient } from "genlayer-js/types";
+import { getPrivateKey } from "../../lib/accounts/getPrivateKey";
+
+export interface CallOptions {
+  args: any[];
+  type: "read" | "write";
+}
+
+export class CallAction {
+  private genlayerClient: GenLayerClient<typeof simulator>;
+
+  constructor() {
+    this.genlayerClient = createClient({
+      chain: simulator,
+      endpoint: process.env.VITE_JSON_RPC_SERVER_URL,
+      account: createAccount(getPrivateKey() as any),
+    });
+  }
+
+  async call({
+               contractAddress,
+               method,
+               args,
+               type,
+             }: {
+    contractAddress: string;
+    method: string;
+    args: any[];
+    type: "read" | "write";
+  }): Promise<void> {
+    console.log(`Calling ${type} method ${method} on contract at ${contractAddress}...`);
+
+    try {
+      if (type === "read") {
+        await this.executeRead(contractAddress, method, args);
+      } else if (type === "write") {
+        await this.executeWrite(contractAddress, method, args);
+      } else {
+        throw new Error(`Invalid call type: ${type}. Use "read" or "write".`);
+      }
+    } catch (error) {
+      console.error("Error calling contract method:", error);
+      throw error;
+    }
+  }
+
+  private async executeRead(contractAddress: string, method: string, args: any[]): Promise<void> {
+    try {
+      const result = await this.genlayerClient.readContract({
+        address: contractAddress as any,
+        functionName: method,
+        args,
+      });
+      console.log("Read result:", result);
+    } catch (error) {
+      console.error("Error during read operation:", error);
+      throw error;
+    }
+  }
+
+  private async executeWrite(contractAddress: string, method: string, args: any[]): Promise<void> {
+    try {
+      const hash = await this.genlayerClient.writeContract({
+        address: contractAddress as any,
+        functionName: method,
+        args,
+        value: 0n,
+      });
+      const result = await this.genlayerClient.waitForTransactionReceipt({
+        hash,
+        retries: 15,
+        interval: 2000,
+      });
+      console.log("Write transaction hash:", hash);
+      console.log("Result:", result);
+    } catch (error) {
+      console.error("Error during write operation:", error);
+      throw error;
+    }
+  }
+}

package/src/commands/contracts/deploy.ts

@@ -0,0 +1,72 @@
+import fs from "fs";
+import { createClient, createAccount } from "genlayer-js";
+import { simulator } from "genlayer-js/chains";
+import type { GenLayerClient } from "genlayer-js/types";
+import { getPrivateKey } from "../../lib/accounts/getPrivateKey";
+
+export interface DeployOptions {
+  contract?: string;
+  // network: string;
+  args?: any[];
+  kwargs?: string;
+}
+
+export class DeployAction {
+  private genlayerClient: GenLayerClient<typeof simulator>;
+
+  constructor() {
+    this.genlayerClient = createClient({
+      chain: simulator,
+      endpoint: process.env.VITE_JSON_RPC_SERVER_URL,
+      account: createAccount(getPrivateKey() as any),
+    });
+  }
+
+  private readContractCode(contractPath: string): string {
+    if (!fs.existsSync(contractPath)) {
+      throw new Error(`Contract file not found: ${contractPath}`);
+    }
+    return fs.readFileSync(contractPath, "utf-8");
+  }
+
+  async deploy(options: DeployOptions): Promise<void> {
+
+    const argsUsed = options.args && options.args.length > 0;
+    const kwargsUsed = options.kwargs && options.kwargs.trim() !== "";
+
+    if (argsUsed && kwargsUsed) {
+      throw new Error("Invalid usage: Please specify either `args` or `kwargs`, but not both.");
+    }
+
+    if (!options.contract) {
+      console.error("No contract specified for deployment.");
+      return;
+    }
+
+    const contractCode = this.readContractCode(options.contract);
+
+    if (!contractCode) {
+      console.error("Contract code is empty.");
+      return;
+    }
+
+    const leaderOnly = false;
+    let deployParams: any = { code: contractCode, args: options.args, leaderOnly };
+
+    console.log("Starting contract deployment...");
+    console.log("Deployment Parameters:", deployParams);
+
+    try {
+      const hash = await this.genlayerClient.deployContract(deployParams) as any;
+
+      const result = await this.genlayerClient.waitForTransactionReceipt({hash, retries: 15, interval: 2000})
+
+      console.log("Contract deployed successfully.");
+      console.log("Transaction Hash:", hash);
+      console.log("Contract Address:", result.data?.contract_address);
+    } catch (error) {
+      console.error("Error deploying contract:", error);
+      throw new Error("Contract deployment failed.");
+    }
+  }
+}

package/src/commands/contracts/index.ts

@@ -0,0 +1,27 @@
+import { Command } from "commander";
+import { DeployAction, DeployOptions } from "./deploy";
+import { CallAction, CallOptions } from "./call";
+
+export function initializeContractsCommands(program: Command) {
+  program
+    .command("deploy")
+    .description("Deploy intelligent contracts")
+    .option("--contract <contractPath>", "Path to the smart contract to deploy")
+    .option("--args <args...>", "Positional arguments for the contract (space-separated, use quotes for multi-word arguments)", [])
+    .action(async (options: DeployOptions) => {
+      const deployer = new DeployAction();
+      await deployer.deploy(options);
+    });
+
+  program
+    .command("call <contractAddress> <method>")
+    .description("Call a contract method")
+    .option("--args <args...>", "Positional arguments for the method (space-separated, use quotes for multi-word arguments)", [])
+    .option("--type <type>", "Type of call: read or write (default is read)", "read")
+    .action(async (contractAddress: string, method: string, options: CallOptions) => {
+      const caller = new CallAction();
+      await caller.call({ contractAddress, method, ...options });
+    });
+
+  return program;
+}

package/src/commands/general/index.ts

@@ -1,5 +1,4 @@
 import { Command } from "commander";
-
 import simulatorService from "../../lib/services/simulator";
 import { initAction, InitActionOptions } from "./init";
 import { startAction, StartActionOptions } from "./start";
@@ -11,7 +10,7 @@ export function initializeGeneralCommands(program: Command) {
     .option("--numValidators <numValidators>", "Number of validators", "5")
     .option("--headless", "Headless mode", false)
     .option("--reset-db", "Reset Database", false)
-    .option("--localnet-version <localnetVersion>", "Select a specific localnet version", 'latest')
+    .option("--localnet-version <localnetVersion>", "Select a specific localnet version", "latest")
     .action((options: InitActionOptions) => initAction(options, simulatorService));
 
   program

package/src/index.ts

@@ -4,11 +4,15 @@ import {version} from "../package.json";
 import {CLI_DESCRIPTION} from "../src/lib/config/text";
 import { initializeGeneralCommands } from "../src/commands/general";
 import { initializeKeygenCommands } from "../src/commands/keygen";
+import { initializeContractsCommands } from "../src/commands/contracts";
+import { initializeConfigCommands } from "../src/commands/config";
 
 export function initializeCLI() {
   program.version(version).description(CLI_DESCRIPTION);
   initializeGeneralCommands(program);
   initializeKeygenCommands(program);
+  initializeContractsCommands(program);
+  initializeConfigCommands(program);
   program.parse(process.argv);
 }
 

package/src/lib/accounts/getPrivateKey.ts

@@ -0,0 +1,21 @@
+import fs from "fs";
+import { ConfigFileManager } from "../config/ConfigFileManager";
+
+export function getPrivateKey(): string {
+  const configFileManager: ConfigFileManager = new ConfigFileManager();
+  const keypairPath = configFileManager.getConfigByKey("keyPairPath");
+
+  if (!keypairPath || !fs.existsSync(keypairPath)) {
+    console.error("Keypair file not found. Please generate or specify a valid keypair path.");
+    process.exit(1);
+  }
+
+  const keypairData = JSON.parse(fs.readFileSync(keypairPath, "utf-8"));
+
+  if (!keypairData.privateKey) {
+    console.error("Invalid keypair file. Private key is missing.");
+    process.exit(1);
+  }
+
+  return keypairData.privateKey;
+}

package/tests/actions/call.test.ts

@@ -0,0 +1,144 @@
+import { describe, test, vi, beforeEach, afterEach, expect } from "vitest";
+import { createClient, createAccount } from "genlayer-js";
+import { CallAction, CallOptions } from "../../src/commands/contracts/call";
+import { getPrivateKey } from "../../src/lib/accounts/getPrivateKey";
+
+vi.mock("genlayer-js");
+vi.mock("../../src/lib/accounts/getPrivateKey");
+
+describe("Call Action", () => {
+  let caller: CallAction;
+  const mockClient = {
+    readContract: vi.fn(),
+    writeContract: vi.fn(),
+    waitForTransactionReceipt: vi.fn(),
+  };
+
+  const mockPrivateKey = "mocked_private_key";
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(createClient).mockReturnValue(mockClient as any);
+    vi.mocked(createAccount).mockReturnValue({ privateKey: mockPrivateKey } as any);
+    vi.mocked(getPrivateKey).mockReturnValue(mockPrivateKey);
+    caller = new CallAction();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("calls readContract successfully", async () => {
+    const options: CallOptions = {
+      args: [1, 2, "Hello"],
+      type: "read",
+    };
+    const mockResult = "mocked_result";
+
+    vi.mocked(mockClient.readContract).mockResolvedValue(mockResult);
+
+    await caller.call({
+      contractAddress: "0xMockedContract",
+      method: "getData",
+      ...options,
+    });
+
+    expect(mockClient.readContract).toHaveBeenCalledWith({
+      address: "0xMockedContract",
+      functionName: "getData",
+      args: [1, 2, "Hello"],
+    });
+    expect(mockClient.readContract).toHaveResolvedWith(mockResult);
+  });
+
+  test("calls writeContract successfully", async () => {
+    const options: CallOptions = {
+      args: [42, "Update"],
+      type: "write",
+    };
+    const mockHash = "0xMockedTransactionHash";
+    const mockReceipt = { status: "success" };
+
+    vi.mocked(mockClient.writeContract).mockResolvedValue(mockHash);
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt);
+
+    await caller.call({
+      contractAddress: "0xMockedContract",
+      method: "updateData",
+      ...options,
+    });
+
+    expect(mockClient.writeContract).toHaveBeenCalledWith({
+      address: "0xMockedContract",
+      functionName: "updateData",
+      args: [42, "Update"],
+      value: 0n,
+    });
+    expect(mockClient.waitForTransactionReceipt).toHaveBeenCalledWith({
+      hash: mockHash,
+      retries: 15,
+      interval: 2000,
+    });
+    expect(mockClient.writeContract).toHaveResolvedWith(mockHash);
+  });
+
+  test("throws error for invalid call type", async () => {
+    const options: CallOptions = {
+      args: [],
+      type: "invalid" as any,
+    };
+
+    await expect(
+      caller.call({
+        contractAddress: "0xMockedContract",
+        method: "getData",
+        ...options,
+      })
+    ).rejects.toThrowError("Invalid call type: invalid. Use \"read\" or \"write\".");
+
+    expect(mockClient.readContract).not.toHaveBeenCalled();
+    expect(mockClient.writeContract).not.toHaveBeenCalled();
+  });
+
+  test("handles errors during readContract", async () => {
+    const options: CallOptions = {
+      args: [1],
+      type: "read",
+    };
+
+    vi.mocked(mockClient.readContract).mockRejectedValue(
+      new Error("Mocked read error")
+    );
+
+    await expect(
+      caller.call({
+        contractAddress: "0xMockedContract",
+        method: "getData",
+        ...options,
+      })
+    ).rejects.toThrowError("Mocked read error");
+
+    expect(mockClient.readContract).toHaveBeenCalled();
+  });
+
+  test("handles errors during writeContract", async () => {
+    const options: CallOptions = {
+      args: [1],
+      type: "write",
+    };
+
+    vi.mocked(mockClient.writeContract).mockRejectedValue(
+      new Error("Mocked write error")
+    );
+
+    await expect(
+      caller.call({
+        contractAddress: "0xMockedContract",
+        method: "updateData",
+        ...options,
+      })
+    ).rejects.toThrowError("Mocked write error");
+
+    expect(mockClient.writeContract).toHaveBeenCalled();
+  });
+});

package/tests/actions/create.test.ts

@@ -89,7 +89,7 @@ describe("KeypairCreator", () => {
 
   test("overwrites the file if overwrite is true", () => {
     const consoleLogSpy = vi.spyOn(console, "log");
-    vi.mocked(existsSync).mockReturnValue(true); // Simulate file exists
+    vi.mocked(existsSync).mockReturnValue(true);
     const options = { output: "keypair.json", overwrite: true };
 
     keypairCreator.createKeypairAction(options);