genlayer 0.38.8 → 0.38.10

package/tests/actions/call.test.ts

@@ -0,0 +1,94 @@
+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");
+
+describe("CallAction", () => {
+  let callActions: CallAction;
+  const mockClient = {
+    readContract: vi.fn(),
+    writeContract: vi.fn(),
+    waitForTransactionReceipt: vi.fn(),
+    getContractSchema: vi.fn(),
+    initializeConsensusSmartContract: 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);
+    callActions = new CallAction();
+    vi.spyOn(callActions as any, "getAccount").mockResolvedValue({privateKey: mockPrivateKey});
+
+    vi.spyOn(callActions as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(callActions as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(callActions as any, "failSpinner").mockImplementation(() => {});
+    vi.spyOn(callActions as any, "log").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("calls readContract successfully", async () => {
+    const options = {args: [1, 2, "Hello"]};
+    const mockResult = "mocked_result";
+
+    vi.mocked(mockClient.readContract).mockResolvedValue(mockResult);
+
+    await callActions.call({
+      contractAddress: "0xMockedContract",
+      method: "getData",
+      ...options,
+    });
+
+    expect(mockClient.readContract).toHaveBeenCalledWith({
+      address: "0xMockedContract",
+      functionName: "getData",
+      args: [1, 2, "Hello"],
+    });
+    expect(callActions["succeedSpinner"]).toHaveBeenCalledWith(
+      "Read operation successfully executed",
+      "mocked_result",
+    );
+  });
+
+  test("handles readContract errors", async () => {
+    vi.mocked(mockClient.readContract).mockRejectedValue(new Error("Mocked read error"));
+
+    await callActions.call({contractAddress: "0xMockedContract", method: "getData", args: [1]});
+
+    expect(callActions["failSpinner"]).toHaveBeenCalledWith("Error during read 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 mockResult = "mocked_result";
+
+    vi.mocked(mockClient.readContract).mockResolvedValue(mockResult);
+
+    await callActions.call({
+      contractAddress: "0xMockedContract",
+      method: "getData",
+      ...options,
+    });
+
+    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",
+    );
+  });
+});

package/tests/actions/code.test.ts

@@ -0,0 +1,87 @@
+import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
+import {createClient, createAccount} from "genlayer-js";
+import {CodeAction} from "../../src/commands/contracts/code";
+
+vi.mock("genlayer-js");
+
+describe("CodeAction", () => {
+  let codeAction: CodeAction;
+  const mockClient = {
+    getContractCode: vi.fn(),
+    initializeConsensusSmartContract: 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);
+    codeAction = new CodeAction();
+    vi.spyOn(codeAction as any, "getAccount").mockResolvedValue({privateKey: mockPrivateKey});
+
+    vi.spyOn(codeAction as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(codeAction as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(codeAction as any, "failSpinner").mockImplementation(() => {});
+    vi.spyOn(codeAction as any, "log").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("gets contract code successfully", async () => {
+    const mockResult = "0x600160...";
+
+    vi.mocked(mockClient.getContractCode).mockResolvedValue(mockResult as any);
+
+    await codeAction.code({
+      contractAddress: "0xMockedContract",
+    });
+
+    expect(mockClient.getContractCode).toHaveBeenCalledWith("0xMockedContract");
+    expect(codeAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Contract code retrieved successfully",
+      mockResult,
+    );
+  });
+
+  test("handles getContractCode errors", async () => {
+    vi.mocked(mockClient.getContractCode).mockRejectedValue(new Error("Mocked code error"));
+
+    await codeAction.code({contractAddress: "0xMockedContract"});
+
+    expect(codeAction["failSpinner"]).toHaveBeenCalledWith("Error retrieving contract code", expect.any(Error));
+  });
+
+  test("uses custom RPC URL when provided", async () => {
+    const mockResult = "0x600160...";
+    vi.mocked(mockClient.getContractCode).mockResolvedValue(mockResult as any);
+
+    await codeAction.code({
+      contractAddress: "0xMockedContract",
+      rpc: "https://custom-rpc-url.com",
+    });
+
+    expect(createClient).toHaveBeenCalledWith(
+      expect.objectContaining({
+        endpoint: "https://custom-rpc-url.com",
+      }),
+    );
+    expect(mockClient.getContractCode).toHaveBeenCalledWith("0xMockedContract");
+    expect(codeAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Contract code retrieved successfully",
+      mockResult,
+    );
+  });
+
+  test("initializes consensus smart contract", async () => {
+    vi.mocked(mockClient.getContractCode).mockResolvedValue("0x" as any);
+
+    await codeAction.code({contractAddress: "0xMockedContract"});
+
+    expect(mockClient.initializeConsensusSmartContract).toHaveBeenCalled();
+  });
+});
+
+

package/tests/actions/create.test.ts

@@ -0,0 +1,65 @@
+import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
+import {CreateAccountAction} from "../../src/commands/account/create";
+import {readFileSync, existsSync} from "fs";
+import os from "os";
+
+vi.mock("fs");
+vi.mock("os");
+
+describe("CreateAccountAction", () => {
+  let createAction: CreateAccountAction;
+  const mockKeystorePath = "/mocked/home/.genlayer/keystores/main.json";
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Setup mocks before creating the action (needed for constructor)
+    vi.mocked(os.homedir).mockReturnValue("/mocked/home");
+    vi.mocked(existsSync).mockReturnValue(true);
+    vi.mocked(readFileSync).mockReturnValue(JSON.stringify({activeAccount: "default"}));
+
+    createAction = new CreateAccountAction();
+
+    // Mock the BaseAction methods
+    vi.spyOn(createAction as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(createAction as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(createAction as any, "failSpinner").mockImplementation(() => {});
+    vi.spyOn(createAction as any, "createKeypairByName").mockResolvedValue("0x1234567890abcdef");
+    vi.spyOn(createAction as any, "setActiveAccount").mockImplementation(() => {});
+    vi.spyOn(createAction as any, "getKeystorePath").mockReturnValue(mockKeystorePath);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("successfully creates and saves an encrypted keystore", async () => {
+    const options = {name: "main", overwrite: false, setActive: true};
+
+    await createAction.execute(options);
+
+    expect(createAction["startSpinner"]).toHaveBeenCalledWith("Creating account 'main'...");
+    expect(createAction["createKeypairByName"]).toHaveBeenCalledWith("main", false, undefined);
+    expect(createAction["setActiveAccount"]).toHaveBeenCalledWith("main");
+    expect(createAction["succeedSpinner"]).toHaveBeenCalledWith(
+      `Account 'main' created at: ${mockKeystorePath}`,
+    );
+  });
+
+  test("handles errors during keystore creation", async () => {
+    const mockError = new Error("Mocked creation error");
+    vi.spyOn(createAction as any, "createKeypairByName").mockRejectedValue(mockError);
+
+    await createAction.execute({name: "main", overwrite: true});
+
+    expect(createAction["failSpinner"]).toHaveBeenCalledWith("Failed to create account", mockError);
+  });
+
+  test("skips setting active account when setActive is false", async () => {
+    const options = {name: "validator", overwrite: false, setActive: false};
+
+    await createAction.execute(options);
+
+    expect(createAction["setActiveAccount"]).not.toHaveBeenCalled();
+    expect(createAction["succeedSpinner"]).toHaveBeenCalled();
+  });
+});

package/tests/actions/deploy.test.ts

@@ -0,0 +1,420 @@
+import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
+import fs from "fs";
+import os from "os";
+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("os");
+vi.mock("genlayer-js");
+vi.mock("esbuild", () => ({
+  buildSync: vi.fn(),
+}));
+
+describe("DeployAction", () => {
+  let deployer: DeployAction;
+  const mockClient = {
+    deployContract: vi.fn(),
+    waitForTransactionReceipt: vi.fn(),
+    initializeConsensusSmartContract: vi.fn(),
+  };
+
+  const mockPrivateKey = "mocked_private_key";
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Setup mocks before creating the action (needed for constructor)
+    vi.mocked(os.homedir).mockReturnValue("/mocked/home");
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({activeAccount: "default"}));
+
+    vi.mocked(createClient).mockReturnValue(mockClient as any);
+    vi.mocked(createAccount).mockReturnValue({privateKey: mockPrivateKey} as any);
+    deployer = new DeployAction();
+    vi.spyOn(deployer as any, "getAccount").mockResolvedValue({privateKey: mockPrivateKey});
+    vi.spyOn(deployer as any, "getConfig").mockReturnValue({});
+
+    vi.spyOn(deployer as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(deployer as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(deployer as any, "failSpinner").mockImplementation(() => {});
+    vi.spyOn(deployer as any, "setSpinnerText").mockImplementation(() => {});
+    vi.spyOn(deployer as any, "log").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("reads contract code successfully", () => {
+    const contractPath = "/mocked/contract/path";
+    const contractContent = "contract code";
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(contractContent);
+
+    const result = deployer["readContractCode"](contractPath);
+
+    expect(fs.existsSync).toHaveBeenCalledWith(contractPath);
+    expect(fs.readFileSync).toHaveBeenCalledWith(contractPath, "utf-8");
+    expect(result).toBe(contractContent);
+  });
+
+  test("throws error if contract file is missing", () => {
+    const contractPath = "/mocked/contract/path";
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    expect(() => deployer["readContractCode"](contractPath)).toThrowError(
+      `Contract file not found: ${contractPath}`,
+    );
+    expect(fs.existsSync).toHaveBeenCalledWith(contractPath);
+  });
+
+  test("deploys contract with args", async () => {
+    const options: DeployOptions = {
+      contract: "/mocked/contract/path",
+      args: [1, 2, 3],
+    };
+    const contractContent = "contract code";
+
+    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: {contract_address: "0xdasdsadasdasdada"},
+    });
+
+    await deployer.deploy(options);
+
+    expect(fs.readFileSync).toHaveBeenCalledWith(options.contract, "utf-8");
+    expect(mockClient.deployContract).toHaveBeenCalledWith({
+      code: contractContent,
+      args: [1, 2, 3],
+      leaderOnly: false,
+    });
+    expect(mockClient.deployContract).toHaveReturnedWith(Promise.resolve("mocked_tx_hash"));
+  });
+
+  test("throws error for missing contract", async () => {
+    const options: DeployOptions = {};
+
+    await deployer.deploy(options);
+
+    expect(deployer["failSpinner"]).toHaveBeenCalledWith("No contract specified for deployment.");
+    expect(mockClient.deployContract).not.toHaveBeenCalled();
+  });
+
+  test("handles deployment errors", async () => {
+    const options: DeployOptions = {
+      contract: "/mocked/contract/path",
+      args: [1, 2, 3],
+    };
+    const contractContent = "contract code";
+
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(contractContent);
+    vi.mocked(mockClient.deployContract).mockRejectedValue(new Error("Mocked deployment error"));
+
+    await deployer.deploy(options);
+
+    expect(deployer["failSpinner"]).toHaveBeenCalledWith("Error deploying contract", expect.any(Error));
+    expect(mockClient.deployContract).toHaveBeenCalled();
+  });
+
+  test("handles empty contract code", async () => {
+    const options: DeployOptions = {
+      contract: "/mocked/contract/path",
+    };
+
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue("");
+
+    await deployer.deploy(options);
+
+    expect(deployer["failSpinner"]).toHaveBeenCalledWith("Contract code is empty.");
+    expect(mockClient.deployContract).not.toHaveBeenCalled();
+  });
+
+  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.spyOn(deployer as any, "executeTsScript").mockResolvedValue(undefined);
+    vi.spyOn(deployer as any, "executeJsScript").mockResolvedValue(undefined);
+
+    await deployer.deployScripts();
+
+    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["executeTsScript"]).toHaveBeenCalledWith(expect.stringMatching(/10_last.ts/), undefined);
+  });
+
+  test("executeTsScript transpiles and executes TypeScript", async () => {
+    const filePath = "/mocked/script.ts";
+    const outFile = "/mocked/script.compiled.js";
+
+    vi.spyOn(deployer as any, "executeJsScript").mockResolvedValue(undefined);
+    vi.mocked(buildSync).mockImplementation((() => {}) as any);
+
+    await deployer["executeTsScript"](filePath);
+
+    expect(deployer["startSpinner"]).toHaveBeenCalledWith(`Transpiling TypeScript file: ${filePath}`);
+    expect(buildSync).toHaveBeenCalledWith({
+      entryPoints: [filePath],
+      outfile: outFile,
+      bundle: false,
+      platform: "node",
+      format: "esm",
+      target: "es2020",
+      sourcemap: false,
+    });
+
+    expect(deployer["executeJsScript"]).toHaveBeenCalledWith(filePath, outFile, undefined);
+    expect(fs.unlinkSync).toHaveBeenCalledWith(outFile);
+  });
+
+  test("deployScripts fails when deploy folder is missing", async () => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    await deployer.deployScripts();
+
+    expect(deployer["failSpinner"]).toHaveBeenCalledWith("No deploy folder found.");
+  });
+
+  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.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,
+    );
+  });
+
+  test("deployScripts fails when no scripts are found", async () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readdirSync).mockReturnValue([]);
+
+    await deployer.deployScripts();
+
+    expect(deployer["failSpinner"]).toHaveBeenCalledWith("No deploy scripts found.");
+  });
+
+  test("deployScripts handles script execution errors", async () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readdirSync).mockReturnValue(["1_failing.ts"] as any);
+    vi.spyOn(deployer as any, "executeTsScript").mockRejectedValue(new Error("Script error"));
+
+    await deployer.deployScripts();
+
+    expect(deployer["failSpinner"]).toHaveBeenCalledWith(
+      expect.stringContaining("Error executing script:"),
+      expect.any(Error),
+    );
+  });
+
+  test("executeJsScript fails gracefully", async () => {
+    const filePath = "/mocked/script.js";
+
+    await deployer["executeJsScript"](filePath);
+
+    expect(deployer["failSpinner"]).toHaveBeenCalledWith(
+      expect.stringContaining("Error executing:"),
+      expect.any(Error),
+    );
+  });
+
+  test("deploy fails when contract code is empty", async () => {
+    const options: DeployOptions = {contract: "/mocked/contract/path"};
+
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue("");
+
+    await deployer.deploy(options);
+
+    expect(deployer["failSpinner"]).toHaveBeenCalledWith("Contract code is empty.");
+  });
+
+  test("deployScripts correctly sorts mixed numbered and non-numbered scripts", async () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readdirSync).mockReturnValue([
+      "script.ts",
+      "2alpha_script.ts",
+      "3alpha_script.ts",
+      "blpha_script.ts",
+      "clpha_script.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("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"}));
+
+    await deployer["executeJsScript"](filePath);
+
+    expect(deployer["failSpinner"]).toHaveBeenCalledWith(
+      expect.stringContaining('No "default" function found in:'),
+    );
+  });
+
+  test("executeJsScript successfully executes a script", async () => {
+    const filePath = "/mocked/script.js";
+    const mockFn = vi.fn(); // This mock function simulates the script execution
+
+    vi.doMock(pathToFileURL(filePath).href, () => ({default: mockFn}));
+
+    await deployer["executeJsScript"](filePath);
+
+    expect(mockFn).toHaveBeenCalledWith(mockClient);
+
+    expect(deployer["succeedSpinner"]).toHaveBeenCalledWith(`Successfully executed: ${filePath}`);
+  });
+
+  test("executeTsScript fails when buildSync throws an error", async () => {
+    const filePath = "/mocked/script.ts";
+    const error = new Error("Build failed");
+
+    vi.mocked(buildSync).mockImplementation(() => {
+      throw error; // Simulate an error during transpilation
+    });
+
+    await deployer["executeTsScript"](filePath);
+
+    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",
+    };
+    const contractContent = "contract code";
+
+    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: {contract_address: "0xdasdsadasdasdada"},
+    });
+
+    await deployer.deploy(options);
+
+    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,
+      args: [1, 2, 3],
+      leaderOnly: false,
+    });
+  });
+
+  test("executeJsScript uses rpc url when provided", async () => {
+    const filePath = "/mocked/script.js";
+    const rpcUrl = "https://custom-rpc-url.com";
+    const mockFn = vi.fn();
+
+    vi.doMock(pathToFileURL(filePath).href, () => ({default: mockFn}));
+
+    await deployer["executeJsScript"](filePath, undefined, rpcUrl);
+
+    expect(createClient).toHaveBeenCalledWith(
+      expect.objectContaining({
+        endpoint: rpcUrl,
+      }),
+    );
+    expect(mockFn).toHaveBeenCalledWith(mockClient);
+    expect(deployer["succeedSpinner"]).toHaveBeenCalledWith(`Successfully executed: ${filePath}`);
+  });
+
+  test("executeTsScript passes rpc url to executeJsScript", async () => {
+    const filePath = "/mocked/script.ts";
+    const outFile = "/mocked/script.compiled.js";
+    const rpcUrl = "https://custom-rpc-url.com";
+
+    vi.spyOn(deployer as any, "executeJsScript").mockResolvedValue(undefined);
+    vi.mocked(buildSync).mockImplementation((() => {}) as any);
+
+    await deployer["executeTsScript"](filePath, rpcUrl);
+
+    expect(deployer["startSpinner"]).toHaveBeenCalledWith(`Transpiling TypeScript file: ${filePath}`);
+    expect(buildSync).toHaveBeenCalledWith({
+      entryPoints: [filePath],
+      outfile: outFile,
+      bundle: false,
+      platform: "node",
+      format: "esm",
+      target: "es2020",
+      sourcemap: false,
+    });
+
+    expect(deployer["executeJsScript"]).toHaveBeenCalledWith(filePath, outFile, rpcUrl);
+    expect(fs.unlinkSync).toHaveBeenCalledWith(outFile);
+  });
+
+  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.spyOn(deployer as any, "executeTsScript").mockResolvedValue(undefined);
+    vi.spyOn(deployer as any, "executeJsScript").mockResolvedValue(undefined);
+
+    await deployer.deployScripts({rpc: rpcUrl});
+
+    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringMatching(/1_first.ts/), rpcUrl);
+    expect(deployer["executeJsScript"]).toHaveBeenCalledWith(
+      expect.stringMatching(/2_second.js/),
+      undefined,
+      rpcUrl,
+    );
+  });
+});