genlayer 0.8.1-beta.0 → 0.9.1

package/.env.example

@@ -79,4 +79,3 @@ HARDHAT_PORT = '8545'
 HARDHAT_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80'
 
 BACKEND_BUILD_TARGET = 'debug'
-VITE_FINALITY_WINDOW=1

package/CHANGELOG.md

@@ -1,11 +1,18 @@
 
 
-## 0.8.1-beta.0 (2024-12-13)
+## 0.9.1 (2024-12-13)
 
 
 ### Bug Fixes
 
-* removing volumes ([36083c0](https://github.com/yeagerai/genlayer-cli/commit/36083c04ad121464a683d69503d53c4be24bc682))
+* removing volumes to stop error when running node without nvm ([#156](https://github.com/yeagerai/genlayer-cli/issues/156)) ([189c759](https://github.com/yeagerai/genlayer-cli/commit/189c7592fedb6373e3603f1bdb4366c79f289160))
+
+## 0.9.0 (2024-12-13)
+
+
+### Features
+
+* Add Deploy Command and Update Configurations for Compatibility ([#153](https://github.com/yeagerai/genlayer-cli/issues/153)) ([8744b2d](https://github.com/yeagerai/genlayer-cli/commit/8744b2d3ef2b4d7fd4d3ac71ac6e8eef69ed1555))
 
 ## 0.8.0 (2024-12-11)
 

package/dist/index.js

@@ -58904,7 +58904,7 @@ var {
 } = import_index.default;
 
 // package.json
-var version = "0.8.1-beta.0";
+var version = "0.9.1";
 var package_default = {
   name: "genlayer",
   version,
@@ -59637,7 +59637,6 @@ var SimulatorService = class {
   }
   addConfigToEnvFile(newConfig) {
     const envFilePath = path2.join(this.location, ".env");
-    fs5.writeFileSync(`${envFilePath}.bak`, fs5.readFileSync(envFilePath));
     const envConfig = dotenv.parse(fs5.readFileSync(envFilePath, "utf8"));
     Object.keys(newConfig).forEach((key) => {
       envConfig[key] = newConfig[key];
@@ -91367,11 +91366,9 @@ var DeployAction = class {
     console.log("Starting contract deployment...");
     console.log("Deployment Parameters:", deployParams);
     try {
-      const hash3 = await this.genlayerClient.deployContract(deployParams);
-      const result = await this.genlayerClient.waitForTransactionReceipt({ hash: hash3, retries: 15, interval: 2e3 });
+      const result = await this.genlayerClient.deployContract(deployParams);
       console.log("Contract deployed successfully.");
-      console.log("Transaction Hash:", hash3);
-      console.log("Contract Address:", result.data?.contract_address);
+      console.log("Transaction Hash:", result);
     } catch (error) {
       console.error("Error deploying contract:", error);
       throw new Error("Contract deployment failed.");
@@ -91379,81 +91376,12 @@ var DeployAction = class {
   }
 };
 
-// src/commands/contracts/call.ts
-var CallAction = class {
-  constructor() {
-    __publicField(this, "genlayerClient");
-    this.genlayerClient = createClient2({
-      chain: simulator,
-      endpoint: process.env.VITE_JSON_RPC_SERVER_URL,
-      account: createAccount(getPrivateKey())
-    });
-  }
-  async call({
-    contractAddress,
-    method,
-    args,
-    type
-  }) {
-    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;
-    }
-  }
-  async executeRead(contractAddress, method, args) {
-    try {
-      const result = await this.genlayerClient.readContract({
-        address: contractAddress,
-        functionName: method,
-        args
-      });
-      console.log("Read result:", result);
-    } catch (error) {
-      console.error("Error during read operation:", error);
-      throw error;
-    }
-  }
-  async executeWrite(contractAddress, method, args) {
-    try {
-      const hash3 = await this.genlayerClient.writeContract({
-        address: contractAddress,
-        functionName: method,
-        args,
-        value: 0n
-      });
-      const result = await this.genlayerClient.waitForTransactionReceipt({
-        hash: hash3,
-        retries: 15,
-        interval: 2e3
-      });
-      console.log("Write transaction hash:", hash3);
-      console.log("Result:", result);
-    } catch (error) {
-      console.error("Error during write operation:", error);
-      throw error;
-    }
-  }
-};
-
 // src/commands/contracts/index.ts
 function initializeContractsCommands(program2) {
   program2.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) => {
     const deployer = new DeployAction();
     await deployer.deploy(options);
   });
-  program2.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, method, options) => {
-    const caller = new CallAction();
-    await caller.call({ contractAddress, method, ...options });
-  });
   return program2;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.8.1-beta.0",
+  "version": "0.9.1",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
   "bin": {

package/src/commands/contracts/deploy.ts

@@ -57,13 +57,10 @@ export class DeployAction {
     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})
+      const result = await this.genlayerClient.deployContract(deployParams);
 
       console.log("Contract deployed successfully.");
-      console.log("Transaction Hash:", hash);
-      console.log("Contract Address:", result.data?.contract_address);
+      console.log("Transaction Hash:", result);
     } catch (error) {
       console.error("Error deploying contract:", error);
       throw new Error("Contract deployment failed.");

package/src/commands/contracts/index.ts

@@ -1,27 +1,18 @@
 import { Command } from "commander";
-import { DeployAction, DeployOptions } from "./deploy";
-import { CallAction, CallOptions } from "./call";
+import { DeployAction, DeployOptions } from "../contracts/deploy";
 
 export function initializeContractsCommands(program: Command) {
+
   program
     .command("deploy")
     .description("Deploy intelligent contracts")
     .option("--contract <contractPath>", "Path to the smart contract to deploy")
+    // .option("--network <networkName>", "Specify the network (e.g., testnet)", "localnet")
     .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/lib/services/simulator.ts

@@ -50,9 +50,6 @@ export class SimulatorService implements ISimulatorService {
   public addConfigToEnvFile(newConfig: Record<string, string>): void {
     const envFilePath = path.join(this.location, ".env");
 
-    // Create a backup of the original .env file
-    fs.writeFileSync(`${envFilePath}.bak`, fs.readFileSync(envFilePath));
-
     // Transform the config string to object
     const envConfig = dotenv.parse(fs.readFileSync(envFilePath, "utf8"));
     Object.keys(newConfig).forEach(key => {

package/tests/actions/deploy.test.ts

@@ -12,7 +12,6 @@ describe("Deploy Action", () => {
   let deployer: DeployAction;
   const mockClient = {
     deployContract: vi.fn(),
-    waitForTransactionReceipt: vi.fn()
   };
 
   const mockPrivateKey = "mocked_private_key";
@@ -63,7 +62,6 @@ describe("Deploy Action", () => {
     vi.mocked(fs.existsSync).mockReturnValue(true);
     vi.mocked(fs.readFileSync).mockReturnValue(contractContent);
     vi.mocked(mockClient.deployContract).mockResolvedValue("mocked_tx_hash");
-    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue({data: {contractAddress: '0xdasdsadasdasdada'}});
 
     await deployer.deploy(options);
 

package/tests/services/simulator.test.ts

@@ -173,7 +173,6 @@ describe("SimulatorService - Basic Tests", () => {
 
     simulatorService.addConfigToEnvFile(newConfig);
 
-    expect(writeFileSyncMock).toHaveBeenCalledWith(`${envFilePath}.bak`, "");
     const expectedUpdatedContent = `NEW_KEY=newValue`;
     expect(writeFileSyncMock).toHaveBeenCalledWith(envFilePath, expectedUpdatedContent);
   });

package/src/commands/contracts/call.ts

@@ -1,83 +0,0 @@
-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/tests/actions/call.test.ts

@@ -1,144 +0,0 @@
-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/commands/call.test.ts

@@ -1,91 +0,0 @@
-import { Command } from "commander";
-import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
-import { initializeContractsCommands } from "../../src/commands/contracts";
-import { CallAction } from "../../src/commands/contracts/call";
-
-vi.mock("../../src/commands/contracts/call");
-
-describe("call command", () => {
-  let program: Command;
-
-  beforeEach(() => {
-    program = new Command();
-    initializeContractsCommands(program);
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("CallAction.call is called with default options", async () => {
-    program.parse(["node", "test", "call", "0xMockedContract", "getData"]);
-    expect(CallAction).toHaveBeenCalledTimes(1);
-    expect(CallAction.prototype.call).toHaveBeenCalledWith({
-      contractAddress: "0xMockedContract",
-      method: "getData",
-      args: [],
-      type: "read",
-    });
-  });
-
-  test("CallAction.call is called with positional arguments", async () => {
-    program.parse([
-      "node",
-      "test",
-      "call",
-      "0xMockedContract",
-      "updateData",
-      "--args",
-      "1",
-      "2",
-      "Hello",
-    ]);
-    expect(CallAction).toHaveBeenCalledTimes(1);
-    expect(CallAction.prototype.call).toHaveBeenCalledWith({
-      contractAddress: "0xMockedContract",
-      method: "updateData",
-      args: ["1", "2", "Hello"],
-      type: "read",
-    });
-  });
-
-  test("CallAction.call is called with write type", async () => {
-    program.parse([
-      "node",
-      "test",
-      "call",
-      "0xMockedContract",
-      "updateData",
-      "--type",
-      "write",
-    ]);
-    expect(CallAction).toHaveBeenCalledTimes(1);
-    expect(CallAction.prototype.call).toHaveBeenCalledWith({
-      contractAddress: "0xMockedContract",
-      method: "updateData",
-      args: [],
-      type: "write",
-    });
-  });
-
-  test("CallAction is instantiated when the call command is executed", async () => {
-    program.parse(["node", "test", "call", "0xMockedContract", "getData"]);
-    expect(CallAction).toHaveBeenCalledTimes(1);
-  });
-
-  test("throws error for unrecognized options", async () => {
-    const callCommand = program.commands.find((cmd) => cmd.name() === "call");
-    callCommand?.exitOverride();
-    expect(() => program.parse(["node", "test", "call", "0xMockedContract", "getData", "--unknown"]))
-      .toThrowError("error: unknown option '--unknown'");
-  });
-
-  test("CallAction.call is called without throwing errors for valid options", async () => {
-    program.parse(["node", "test", "call", "0xMockedContract", "getData"]);
-    vi.mocked(CallAction.prototype.call).mockResolvedValueOnce(undefined);
-    expect(() =>
-      program.parse(["node", "test", "call", "0xMockedContract", "getData"])
-    ).not.toThrow();
-  });
-});