genlayer 0.25.0 → 0.26.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.26.0 (2025-08-07)
+
+### Features
+
+* add schema command to inspect deployed contract schema ([#244](https://github.com/yeagerai/genlayer-cli/issues/244)) ([4d66a7b](https://github.com/yeagerai/genlayer-cli/commit/4d66a7b9b2ac813cf0d47f12fc82cbc06ed25b3c))
+
 ## 0.25.0 (2025-07-23)
 
 ### Features

package/README.md

@@ -146,6 +146,7 @@ USAGE:
    genlayer deploy [options]
    genlayer call <contractAddress> <method> [options]
    genlayer write <contractAddress> <method> [options]
+   genlayer schema <contractAddress> [options]
 
 OPTIONS (deploy):
    --contract <contractPath>  (Optional) Path to the intelligent contract to deploy
@@ -160,12 +161,16 @@ OPTIONS (write):
    --rpc <rpcUrl>             RPC URL for the network
    --args <args...>           Positional arguments for the method (space-separated, use quotes for multi-word arguments)
 
+OPTIONS (schema):
+   --rpc <rpcUrl>             RPC URL for the network
+
 EXAMPLES:
    genlayer deploy
    genlayer deploy --contract ./my_contract.gpy
    genlayer deploy --contract ./my_contract.gpy --args "arg1" "arg2" 123
    genlayer call 0x123456789abcdef greet --args "Hello World!"
    genlayer write 0x123456789abcdef updateValue --args 42
+   genlayer schema 0x123456789abcdef
 ```
 
 ##### Deploy Behavior
@@ -176,6 +181,9 @@ EXAMPLES:
 - `call` - Calls a contract method without sending a transaction or changing the state (read-only)
 - `write` - Sends a transaction to a contract method that modifies the state
 
+##### Schema
+- `schema` - Retrieves the contract schema
+
 #### Keypair Management
 
 Generate and manage keypairs.

package/dist/index.js

@@ -17856,7 +17856,7 @@ var require_semver2 = __commonJS({
 import { program } from "commander";
 
 // package.json
-var version = "0.25.0";
+var version = "0.26.0";
 var package_default = {
   name: "genlayer",
   version,
@@ -42553,6 +42553,27 @@ var WriteAction = class extends BaseAction {
   }
 };
 
+// src/commands/contracts/schema.ts
+var SchemaAction = class extends BaseAction {
+  constructor() {
+    super();
+  }
+  async schema({
+    contractAddress,
+    rpc
+  }) {
+    const client = await this.getClient(rpc, true);
+    await client.initializeConsensusSmartContract();
+    this.startSpinner(`Getting schema for contract at ${contractAddress}...`);
+    try {
+      const result = await client.getContractSchema(contractAddress);
+      this.succeedSpinner("Contract schema retrieved successfully", result);
+    } catch (error) {
+      this.failSpinner("Error retrieving contract schema", error);
+    }
+  }
+};
+
 // src/commands/contracts/index.ts
 function parseArg(value, previous = []) {
   if (value === "true") return [...previous, true];
@@ -42581,8 +42602,8 @@ function initializeContractsCommands(program2) {
     parseArg,
     []
   ).action(async (contractAddress, method, options) => {
-    const caller = new CallAction();
-    await caller.call({ contractAddress, method, ...options });
+    const callAction = new CallAction();
+    await callAction.call({ contractAddress, method, ...options });
   });
   program2.command("write <contractAddress> <method>").description("Sends a transaction to a contract method that modifies the state").option("--rpc <rpcUrl>", "RPC URL for the network").option(
     "--args <args...>",
@@ -42590,8 +42611,12 @@ function initializeContractsCommands(program2) {
     parseArg,
     []
   ).action(async (contractAddress, method, options) => {
-    const writer = new WriteAction();
-    await writer.write({ contractAddress, method, ...options });
+    const writeAction = new WriteAction();
+    await writeAction.write({ contractAddress, method, ...options });
+  });
+  program2.command("schema <contractAddress>").description("Get the schema for a deployed contract").option("--rpc <rpcUrl>", "RPC URL for the network").action(async (contractAddress, options) => {
+    const schemaAction = new SchemaAction();
+    await schemaAction.schema({ contractAddress, ...options });
   });
   return program2;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
   "type": "module",

package/src/commands/contracts/index.ts

@@ -2,6 +2,7 @@ import {Command} from "commander";
 import {DeployAction, DeployOptions, DeployScriptsOptions} from "./deploy";
 import {CallAction, CallOptions} from "./call";
 import {WriteAction, WriteOptions} from "./write";
+import {SchemaAction, SchemaOptions} from "./schema";
 
 function parseArg(value: string, previous: any[] = []): any[] {
   if (value === "true") return [...previous, true];
@@ -43,8 +44,8 @@ export function initializeContractsCommands(program: Command) {
       [],
     )
     .action(async (contractAddress: string, method: string, options: CallOptions) => {
-      const caller = new CallAction();
-      await caller.call({contractAddress, method, ...options});
+      const callAction = new CallAction();
+      await callAction.call({contractAddress, method, ...options});
     });
 
   program
@@ -58,8 +59,17 @@ export function initializeContractsCommands(program: Command) {
       [],
     )
     .action(async (contractAddress: string, method: string, options: WriteOptions) => {
-      const writer = new WriteAction();
-      await writer.write({contractAddress, method, ...options});
+      const writeAction = new WriteAction();
+      await writeAction.write({contractAddress, method, ...options});
+    });
+
+  program
+    .command("schema <contractAddress>")
+    .description("Get the schema for a deployed contract")
+    .option("--rpc <rpcUrl>", "RPC URL for the network")
+    .action(async (contractAddress: string, options: SchemaOptions) => {
+      const schemaAction = new SchemaAction();
+      await schemaAction.schema({contractAddress, ...options});
     });
 
   return program;

package/src/commands/contracts/schema.ts

@@ -0,0 +1,31 @@
+import {BaseAction} from "../../lib/actions/BaseAction";
+import type {Address} from "genlayer-js/types";
+
+export interface SchemaOptions {
+  rpc?: string;
+}
+
+export class SchemaAction extends BaseAction {
+  constructor() {
+    super();
+  }
+
+  async schema({
+    contractAddress,
+    rpc,
+  }: {
+    contractAddress: string;
+    rpc?: string;
+  }): Promise<void> {
+    const client = await this.getClient(rpc, true);
+    await client.initializeConsensusSmartContract();
+    this.startSpinner(`Getting schema for contract at ${contractAddress}...`);
+
+    try {
+      const result = await client.getContractSchema(contractAddress as Address);
+      this.succeedSpinner("Contract schema retrieved successfully", result);
+    } catch (error) {
+      this.failSpinner("Error retrieving contract schema", error);
+    }
+  }
+} 

package/tests/actions/schema.test.ts

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

package/tests/commands/schema.test.ts

@@ -0,0 +1,67 @@
+import { Command } from "commander";
+import { SchemaAction } from "../../src/commands/contracts/schema";
+import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
+import { initializeContractsCommands } from "../../src/commands/contracts";
+
+vi.mock("../../src/commands/contracts/schema");
+vi.mock("esbuild", () => ({
+  buildSync: vi.fn(),
+}));
+
+describe("schema command", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    initializeContractsCommands(program);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("SchemaAction.schema is called with default options", async () => {
+    program.parse(["node", "test", "schema", "0xMockedContract"]);
+    expect(SchemaAction).toHaveBeenCalledTimes(1);
+    expect(SchemaAction.prototype.schema).toHaveBeenCalledWith({
+      contractAddress: "0xMockedContract",
+    });
+  });
+
+  test("SchemaAction.schema is called with custom RPC URL", async () => {
+    program.parse([
+      "node",
+      "test",
+      "schema",
+      "0xMockedContract",
+      "--rpc",
+      "https://custom-rpc-url.com"
+    ]);
+    expect(SchemaAction).toHaveBeenCalledTimes(1);
+    expect(SchemaAction.prototype.schema).toHaveBeenCalledWith({
+      contractAddress: "0xMockedContract",
+      rpc: "https://custom-rpc-url.com"
+    });
+  });
+
+  test("SchemaAction is instantiated when the schema command is executed", async () => {
+    program.parse(["node", "test", "schema", "0xMockedContract"]);
+    expect(SchemaAction).toHaveBeenCalledTimes(1);
+  });
+
+  test("throws error for unrecognized options", async () => {
+    const schemaCommand = program.commands.find((cmd) => cmd.name() === "schema");
+    schemaCommand?.exitOverride();
+    expect(() => program.parse(["node", "test", "schema", "0xMockedContract", "--unknown"]))
+      .toThrowError("error: unknown option '--unknown'");
+  });
+
+  test("SchemaAction.schema is called without throwing errors for valid options", async () => {
+    program.parse(["node", "test", "schema", "0xMockedContract"]);
+    vi.mocked(SchemaAction.prototype.schema).mockResolvedValueOnce(undefined);
+    expect(() =>
+      program.parse(["node", "test", "schema", "0xMockedContract"])
+    ).not.toThrow();
+  });
+});