genlayer 0.16.0 → 0.18.0-beta.0

package/tests/actions/call.test.ts

@@ -1,6 +1,6 @@
-import { describe, test, vi, beforeEach, afterEach, expect } from "vitest";
-import { createClient, createAccount } from "genlayer-js";
-import { CallAction } from "../../src/commands/contracts/call";
+import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
+import {createClient, createAccount} from "genlayer-js";
+import {CallAction} from "../../src/commands/contracts/call";
 
 vi.mock("genlayer-js");
 
@@ -11,7 +11,7 @@ describe("CallAction", () => {
     writeContract: vi.fn(),
     waitForTransactionReceipt: vi.fn(),
     getContractSchema: vi.fn(),
-    initializeConsensusSmartContract: vi.fn()
+    initializeConsensusSmartContract: vi.fn(),
   };
 
   const mockPrivateKey = "mocked_private_key";
@@ -19,7 +19,7 @@ describe("CallAction", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     vi.mocked(createClient).mockReturnValue(mockClient as any);
-    vi.mocked(createAccount).mockReturnValue({ privateKey: mockPrivateKey } as any);
+    vi.mocked(createAccount).mockReturnValue({privateKey: mockPrivateKey} as any);
     callActions = new CallAction();
     vi.spyOn(callActions as any, "getPrivateKey").mockResolvedValue(mockPrivateKey);
 
@@ -34,10 +34,9 @@ describe("CallAction", () => {
   });
 
   test("calls readContract successfully", async () => {
-    const options = { args: [1, 2, "Hello"] };
+    const options = {args: [1, 2, "Hello"]};
     const mockResult = "mocked_result";
 
-    vi.mocked(mockClient.getContractSchema).mockResolvedValue({ methods: { getData: { readonly: true } } });
     vi.mocked(mockClient.readContract).mockResolvedValue(mockResult);
 
     await callActions.call({
@@ -51,65 +50,24 @@ describe("CallAction", () => {
       functionName: "getData",
       args: [1, 2, "Hello"],
     });
-    expect(callActions["succeedSpinner"]).toHaveBeenCalledWith("Read operation successfully executed", "mocked_result");
-  });
-
-  test("calls writeContract successfully", async () => {
-    const options = { args: [42, "Update"] };
-    const mockHash = "0xMockedTransactionHash";
-    const mockReceipt = { status: "success" };
-
-    vi.mocked(mockClient.getContractSchema).mockResolvedValue({ methods: { updateData: { readonly: false } } });
-    vi.mocked(mockClient.writeContract).mockResolvedValue(mockHash);
-    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt);
-
-    await callActions.call({
-      contractAddress: "0xMockedContract",
-      method: "updateData",
-      ...options,
-    });
-
-    expect(mockClient.writeContract).toHaveBeenCalledWith({
-      address: "0xMockedContract",
-      functionName: "updateData",
-      args: [42, "Update"],
-      value: 0n,
-    });
-    expect(callActions["log"]).toHaveBeenCalledWith("Write transaction hash:", mockHash);
-    expect(callActions["succeedSpinner"]).toHaveBeenCalledWith("Write operation successfully executed", mockReceipt);
-  });
-
-  test("fails when method is not found", async () => {
-    vi.mocked(mockClient.getContractSchema).mockResolvedValue({ methods: { updateData: { readonly: false } } });
-
-    await callActions.call({ contractAddress: "0xMockedContract", method: "getData", args: [] });
-
-    expect(callActions["failSpinner"]).toHaveBeenCalledWith("method getData not found.");
+    expect(callActions["succeedSpinner"]).toHaveBeenCalledWith(
+      "Read operation successfully executed",
+      "mocked_result",
+    );
   });
 
   test("handles readContract errors", async () => {
-    vi.mocked(mockClient.getContractSchema).mockResolvedValue({ methods: { getData: { readonly: true } } });
     vi.mocked(mockClient.readContract).mockRejectedValue(new Error("Mocked read error"));
 
-    await callActions.call({ contractAddress: "0xMockedContract", method: "getData", args: [1] });
+    await callActions.call({contractAddress: "0xMockedContract", method: "getData", args: [1]});
 
     expect(callActions["failSpinner"]).toHaveBeenCalledWith("Error during read operation", expect.any(Error));
   });
 
-  test("handles writeContract errors", async () => {
-    vi.mocked(mockClient.getContractSchema).mockResolvedValue({ methods: { updateData: { readonly: false } } });
-    vi.mocked(mockClient.writeContract).mockRejectedValue(new Error("Mocked write error"));
-
-    await callActions.call({ contractAddress: "0xMockedContract", method: "updateData", args: [1] });
-
-    expect(callActions["failSpinner"]).toHaveBeenCalledWith("Error during write operation", expect.any(Error));
-  });
-
   test("uses custom RPC URL when provided", async () => {
-    const options = { args: [1, 2, "Hello"], rpc: "https://custom-rpc-url.com" };
+    const options = {args: [1, 2, "Hello"], rpc: "https://custom-rpc-url.com"};
     const mockResult = "mocked_result";
 
-    vi.mocked(mockClient.getContractSchema).mockResolvedValue({ methods: { getData: { readonly: true } } });
     vi.mocked(mockClient.readContract).mockResolvedValue(mockResult);
 
     await callActions.call({
@@ -118,41 +76,19 @@ describe("CallAction", () => {
       ...options,
     });
 
-    expect(createClient).toHaveBeenCalledWith(expect.objectContaining({
-      endpoint: "https://custom-rpc-url.com"
-    }));
+    expect(createClient).toHaveBeenCalledWith(
+      expect.objectContaining({
+        endpoint: "https://custom-rpc-url.com",
+      }),
+    );
     expect(mockClient.readContract).toHaveBeenCalledWith({
       address: "0xMockedContract",
       functionName: "getData",
       args: [1, 2, "Hello"],
     });
-    expect(callActions["succeedSpinner"]).toHaveBeenCalledWith("Read operation successfully executed", "mocked_result");
-  });
-
-  test("uses custom RPC URL for write operations", async () => {
-    const options = { args: [42, "Update"], rpc: "https://custom-rpc-url.com" };
-    const mockHash = "0xMockedTransactionHash";
-    const mockReceipt = { status: "success" };
-
-    vi.mocked(mockClient.getContractSchema).mockResolvedValue({ methods: { updateData: { readonly: false } } });
-    vi.mocked(mockClient.writeContract).mockResolvedValue(mockHash);
-    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt);
-
-    await callActions.call({
-      contractAddress: "0xMockedContract",
-      method: "updateData",
-      ...options,
-    });
-
-    expect(createClient).toHaveBeenCalledWith(expect.objectContaining({
-      endpoint: "https://custom-rpc-url.com"
-    }));
-    expect(mockClient.writeContract).toHaveBeenCalledWith({
-      address: "0xMockedContract",
-      functionName: "updateData",
-      args: [42, "Update"],
-      value: 0n,
-    });
-    expect(callActions["succeedSpinner"]).toHaveBeenCalledWith("Write operation successfully executed", mockReceipt);
+    expect(callActions["succeedSpinner"]).toHaveBeenCalledWith(
+      "Read operation successfully executed",
+      "mocked_result",
+    );
   });
-});
+});

package/tests/actions/create.test.ts

@@ -1,7 +1,7 @@
-import { describe, test, vi, beforeEach, afterEach, expect } from "vitest";
-import { KeypairCreator } from "../../src/commands/keygen/create";
-import { writeFileSync, existsSync } from "fs";
-import { ethers } from "ethers";
+import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
+import {KeypairCreator} from "../../src/commands/keygen/create";
+import {writeFileSync, existsSync} from "fs";
+import {ethers} from "ethers";
 
 vi.mock("fs");
 
@@ -33,7 +33,7 @@ describe("KeypairCreator", () => {
     vi.spyOn(keypairCreator as any, "succeedSpinner").mockImplementation(() => {});
     vi.spyOn(keypairCreator as any, "failSpinner").mockImplementation(() => {});
     vi.spyOn(keypairCreator as any, "writeConfig").mockImplementation(() => {});
-    vi.spyOn(keypairCreator as any, "getFilePath").mockImplementation((fileName) => `/mocked/path/${fileName}`);
+    vi.spyOn(keypairCreator as any, "getFilePath").mockImplementation(fileName => `/mocked/path/${fileName}`);
     vi.mocked(ethers.Wallet.createRandom).mockReturnValue(mockWallet);
   });
 
@@ -43,14 +43,14 @@ describe("KeypairCreator", () => {
 
   test("successfully creates and saves a keypair", () => {
     vi.mocked(existsSync).mockReturnValue(false);
-    const options = { output: "keypair.json", overwrite: false };
+    const options = {output: "keypair.json", overwrite: false};
 
     keypairCreator.createKeypairAction(options);
 
     expect(keypairCreator["startSpinner"]).toHaveBeenCalledWith("Creating keypair...");
     expect(mockKeypairManager.createKeypair).toHaveBeenCalledWith(options.output, options.overwrite);
     expect(keypairCreator["succeedSpinner"]).toHaveBeenCalledWith(
-      "Keypair successfully created and saved to: keypair.json"
+      "Keypair successfully created and saved to: keypair.json",
     );
   });
 
@@ -60,7 +60,7 @@ describe("KeypairCreator", () => {
       throw mockError;
     });
 
-    keypairCreator.createKeypairAction({ output: "keypair.json", overwrite: true });
+    keypairCreator.createKeypairAction({output: "keypair.json", overwrite: true});
 
     expect(keypairCreator["failSpinner"]).toHaveBeenCalledWith("Failed to generate keypair", mockError);
   });

package/tests/actions/deploy.test.ts

@@ -1,9 +1,9 @@
-import { describe, test, vi, beforeEach, afterEach, expect } from "vitest";
+import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
 import fs from "fs";
-import { createClient, createAccount } from "genlayer-js";
-import { DeployAction, DeployOptions } from "../../src/commands/contracts/deploy";
-import { buildSync } from "esbuild";
-import { pathToFileURL } from "url";
+import {createClient, createAccount} from "genlayer-js";
+import {DeployAction, DeployOptions} from "../../src/commands/contracts/deploy";
+import {buildSync} from "esbuild";
+import {pathToFileURL} from "url";
 
 vi.mock("fs");
 vi.mock("genlayer-js");
@@ -24,7 +24,7 @@ describe("DeployAction", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     vi.mocked(createClient).mockReturnValue(mockClient as any);
-    vi.mocked(createAccount).mockReturnValue({ privateKey: mockPrivateKey } as any);
+    vi.mocked(createAccount).mockReturnValue({privateKey: mockPrivateKey} as any);
     deployer = new DeployAction();
     vi.spyOn(deployer as any, "getPrivateKey").mockResolvedValue(mockPrivateKey);
 
@@ -57,7 +57,7 @@ describe("DeployAction", () => {
     vi.mocked(fs.existsSync).mockReturnValue(false);
 
     expect(() => deployer["readContractCode"](contractPath)).toThrowError(
-      `Contract file not found: ${contractPath}`
+      `Contract file not found: ${contractPath}`,
     );
     expect(fs.existsSync).toHaveBeenCalledWith(contractPath);
   });
@@ -73,7 +73,7 @@ describe("DeployAction", () => {
     vi.mocked(fs.readFileSync).mockReturnValue(contractContent);
     vi.mocked(mockClient.deployContract).mockResolvedValue("mocked_tx_hash");
     vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue({
-      data: { contract_address: "0xdasdsadasdasdada" },
+      data: {contract_address: "0xdasdsadasdasdada"},
     });
 
     await deployer.deploy(options);
@@ -105,9 +105,7 @@ describe("DeployAction", () => {
 
     vi.mocked(fs.existsSync).mockReturnValue(true);
     vi.mocked(fs.readFileSync).mockReturnValue(contractContent);
-    vi.mocked(mockClient.deployContract).mockRejectedValue(
-      new Error("Mocked deployment error")
-    );
+    vi.mocked(mockClient.deployContract).mockRejectedValue(new Error("Mocked deployment error"));
 
     await deployer.deploy(options);
 
@@ -131,11 +129,7 @@ describe("DeployAction", () => {
 
   test("deployScripts executes scripts in order", async () => {
     vi.mocked(fs.existsSync).mockReturnValue(true);
-    vi.mocked(fs.readdirSync).mockReturnValue([
-      "1_first.ts",
-      "2_second.js",
-      "10_last.ts",
-    ] as any);
+    vi.mocked(fs.readdirSync).mockReturnValue(["1_first.ts", "2_second.js", "10_last.ts"] as any);
 
     vi.spyOn(deployer as any, "executeTsScript").mockResolvedValue(undefined);
     vi.spyOn(deployer as any, "executeJsScript").mockResolvedValue(undefined);
@@ -144,7 +138,11 @@ describe("DeployAction", () => {
 
     expect(deployer["setSpinnerText"]).toHaveBeenCalledWith("Found 3 deploy scripts. Executing...");
     expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringMatching(/1_first.ts/), undefined);
-    expect(deployer["executeJsScript"]).toHaveBeenCalledWith(expect.stringMatching(/2_second.js/), undefined, undefined);
+    expect(deployer["executeJsScript"]).toHaveBeenCalledWith(
+      expect.stringMatching(/2_second.js/),
+      undefined,
+      undefined,
+    );
     expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringMatching(/10_last.ts/), undefined);
   });
 
@@ -182,20 +180,26 @@ describe("DeployAction", () => {
 
   test("deployScripts sorts and executes scripts correctly", async () => {
     vi.mocked(fs.existsSync).mockReturnValue(true);
-    vi.mocked(fs.readdirSync).mockReturnValue([
-      "10_last.ts",
-      "2_second.js",
-      "1_first.ts"
-    ] as any);
+    vi.mocked(fs.readdirSync).mockReturnValue(["10_last.ts", "2_second.js", "1_first.ts"] as any);
 
     vi.spyOn(deployer as any, "executeTsScript").mockResolvedValue(undefined);
     vi.spyOn(deployer as any, "executeJsScript").mockResolvedValue(undefined);
 
     await deployer.deployScripts();
 
-    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringContaining("1_first.ts"), undefined);
-    expect(deployer["executeJsScript"]).toHaveBeenCalledWith(expect.stringContaining("2_second.js"), undefined, undefined);
-    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringContaining("10_last.ts"), undefined);
+    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(
+      expect.stringContaining("1_first.ts"),
+      undefined,
+    );
+    expect(deployer["executeJsScript"]).toHaveBeenCalledWith(
+      expect.stringContaining("2_second.js"),
+      undefined,
+      undefined,
+    );
+    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(
+      expect.stringContaining("10_last.ts"),
+      undefined,
+    );
   });
 
   test("deployScripts fails when no scripts are found", async () => {
@@ -216,7 +220,7 @@ describe("DeployAction", () => {
 
     expect(deployer["failSpinner"]).toHaveBeenCalledWith(
       expect.stringContaining("Error executing script:"),
-      expect.any(Error)
+      expect.any(Error),
     );
   });
 
@@ -227,12 +231,12 @@ describe("DeployAction", () => {
 
     expect(deployer["failSpinner"]).toHaveBeenCalledWith(
       expect.stringContaining("Error executing:"),
-      expect.any(Error)
+      expect.any(Error),
     );
   });
 
   test("deploy fails when contract code is empty", async () => {
-    const options: DeployOptions = { contract: "/mocked/contract/path" };
+    const options: DeployOptions = {contract: "/mocked/contract/path"};
 
     vi.mocked(fs.existsSync).mockReturnValue(true);
     vi.mocked(fs.readFileSync).mockReturnValue("");
@@ -249,7 +253,7 @@ describe("DeployAction", () => {
       "2alpha_script.ts",
       "3alpha_script.ts",
       "blpha_script.ts",
-      "clpha_script.ts"
+      "clpha_script.ts",
     ] as any);
 
     vi.spyOn(deployer as any, "executeTsScript").mockResolvedValue(undefined);
@@ -258,21 +262,33 @@ describe("DeployAction", () => {
     await deployer.deployScripts();
 
     expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringContaining("script.ts"), undefined);
-    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringContaining("2alpha_script.ts"), undefined);
-    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringContaining("3alpha_script.ts"), undefined);
-    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringContaining("blpha_script.ts"), undefined);
-    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringContaining("clpha_script.ts"), undefined);
+    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(
+      expect.stringContaining("2alpha_script.ts"),
+      undefined,
+    );
+    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(
+      expect.stringContaining("3alpha_script.ts"),
+      undefined,
+    );
+    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(
+      expect.stringContaining("blpha_script.ts"),
+      undefined,
+    );
+    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(
+      expect.stringContaining("clpha_script.ts"),
+      undefined,
+    );
   });
 
   test("executeJsScript fails if module has no default export", async () => {
     const filePath = "/mocked/script.js";
 
-    vi.doMock(pathToFileURL(filePath).href, () => ({ default: "Not a function" }));
+    vi.doMock(pathToFileURL(filePath).href, () => ({default: "Not a function"}));
 
     await deployer["executeJsScript"](filePath);
 
     expect(deployer["failSpinner"]).toHaveBeenCalledWith(
-      expect.stringContaining("No \"default\" function found in:"),
+      expect.stringContaining('No "default" function found in:'),
     );
   });
 
@@ -280,7 +296,7 @@ describe("DeployAction", () => {
     const filePath = "/mocked/script.js";
     const mockFn = vi.fn(); // This mock function simulates the script execution
 
-    vi.doMock(pathToFileURL(filePath).href, () => ({ default: mockFn }));
+    vi.doMock(pathToFileURL(filePath).href, () => ({default: mockFn}));
 
     await deployer["executeJsScript"](filePath);
 
@@ -299,17 +315,14 @@ describe("DeployAction", () => {
 
     await deployer["executeTsScript"](filePath);
 
-    expect(deployer["failSpinner"]).toHaveBeenCalledWith(
-      `Error executing: ${filePath}`,
-      error
-    );
+    expect(deployer["failSpinner"]).toHaveBeenCalledWith(`Error executing: ${filePath}`, error);
   });
 
   test("deploys contract with rpc option", async () => {
     const options: DeployOptions = {
       contract: "/mocked/contract/path",
       args: [1, 2, 3],
-      rpc: "https://custom-rpc-url.com"
+      rpc: "https://custom-rpc-url.com",
     };
     const contractContent = "contract code";
 
@@ -317,14 +330,16 @@ describe("DeployAction", () => {
     vi.mocked(fs.readFileSync).mockReturnValue(contractContent);
     vi.mocked(mockClient.deployContract).mockResolvedValue("mocked_tx_hash");
     vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue({
-      data: { contract_address: "0xdasdsadasdasdada" },
+      data: {contract_address: "0xdasdsadasdasdada"},
     });
 
     await deployer.deploy(options);
 
-    expect(createClient).toHaveBeenCalledWith(expect.objectContaining({
-      endpoint: "https://custom-rpc-url.com"
-    }));
+    expect(createClient).toHaveBeenCalledWith(
+      expect.objectContaining({
+        endpoint: "https://custom-rpc-url.com",
+      }),
+    );
     expect(fs.readFileSync).toHaveBeenCalledWith(options.contract, "utf-8");
     expect(mockClient.deployContract).toHaveBeenCalledWith({
       code: contractContent,
@@ -338,13 +353,15 @@ describe("DeployAction", () => {
     const rpcUrl = "https://custom-rpc-url.com";
     const mockFn = vi.fn();
 
-    vi.doMock(pathToFileURL(filePath).href, () => ({ default: mockFn }));
+    vi.doMock(pathToFileURL(filePath).href, () => ({default: mockFn}));
 
     await deployer["executeJsScript"](filePath, undefined, rpcUrl);
 
-    expect(createClient).toHaveBeenCalledWith(expect.objectContaining({
-      endpoint: rpcUrl
-    }));
+    expect(createClient).toHaveBeenCalledWith(
+      expect.objectContaining({
+        endpoint: rpcUrl,
+      }),
+    );
     expect(mockFn).toHaveBeenCalledWith(mockClient);
     expect(deployer["succeedSpinner"]).toHaveBeenCalledWith(`Successfully executed: ${filePath}`);
   });
@@ -376,26 +393,20 @@ describe("DeployAction", () => {
 
   test("deployScripts passes rpc url to script execution methods", async () => {
     const rpcUrl = "https://custom-rpc-url.com";
-    
+
     vi.mocked(fs.existsSync).mockReturnValue(true);
-    vi.mocked(fs.readdirSync).mockReturnValue([
-      "1_first.ts",
-      "2_second.js",
-    ] as any);
+    vi.mocked(fs.readdirSync).mockReturnValue(["1_first.ts", "2_second.js"] as any);
 
     vi.spyOn(deployer as any, "executeTsScript").mockResolvedValue(undefined);
     vi.spyOn(deployer as any, "executeJsScript").mockResolvedValue(undefined);
 
-    await deployer.deployScripts({ rpc: rpcUrl });
+    await deployer.deployScripts({rpc: rpcUrl});
 
-    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(
-      expect.stringMatching(/1_first.ts/),
-      rpcUrl
-    );
+    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringMatching(/1_first.ts/), rpcUrl);
     expect(deployer["executeJsScript"]).toHaveBeenCalledWith(
       expect.stringMatching(/2_second.js/),
       undefined,
-      rpcUrl
+      rpcUrl,
     );
   });
 });