genlayer 0.12.4 → 0.13.0

package/templates/default/tools/request.py

@@ -0,0 +1,134 @@
+# tests/common/request.py
+import os
+import json
+import requests
+import time
+from dotenv import load_dotenv
+from eth_account import Account
+import base64
+
+from tools.transactions import sign_transaction, encode_transaction_data
+
+import tools.calldata as calldata
+
+load_dotenv()
+
+
+def payload(function_name: str, *args) -> dict:
+    return {
+        "jsonrpc": "2.0",
+        "method": function_name,
+        "params": [*args],
+        "id": 1,
+    }
+
+
+def post_request(
+    payload: dict,
+    protocol: str = os.environ["RPCPROTOCOL"],
+    host: str = os.environ["RPCHOST"],
+    port: str = os.environ["RPCPORT"],
+):
+    return requests.post(
+        protocol + "://" + host + ":" + port + "/api",
+        data=json.dumps(payload),
+        headers={"Content-Type": "application/json"},
+    )
+
+
+def get_transaction_by_hash(transaction_hash: str):
+    payload_data = payload("eth_getTransactionByHash", transaction_hash)
+    raw_response = post_request(payload_data)
+    parsed_raw_response = raw_response.json()
+    return parsed_raw_response["result"]
+
+
+def get_transaction_count(account_address: str):
+    payload_data = payload("eth_getTransactionCount", account_address)
+    raw_response = post_request(payload_data)
+    parsed_raw_response = raw_response.json()
+    return parsed_raw_response["result"]
+
+
+def call_contract_method(
+    contract_address: str,
+    from_account: Account,
+    method_name: str,
+    method_args: list,
+):
+    encoded_data = encode_transaction_data(
+        [calldata.encode({"method": method_name, "args": method_args})]
+    )
+    method_response = post_request(
+        payload(
+            "eth_call",
+            {
+                "to": contract_address,
+                "from": from_account.address,
+                "data": encoded_data,
+            },
+        )
+    ).json()
+    print("method_response", method_response)
+    enc_result = method_response["result"]
+    return calldata.decode(base64.b64decode(enc_result))
+
+
+def send_transaction(
+    account: Account,
+    contract_address: str,
+    method_name: str | None,
+    method_args: list | None,
+    value: int = 0,
+):
+    call_data = (
+        None
+        if method_name is None and method_args is None
+        else [calldata.encode({"method": method_name, "args": method_args})]
+    )
+    nonce = get_transaction_count(account.address)
+    signed_transaction = sign_transaction(
+        account, call_data, contract_address, value, nonce
+    )
+    return send_raw_transaction(signed_transaction)
+
+
+def deploy_intelligent_contract(
+    account: Account, contract_code: str, method_args: list
+) -> tuple[str, dict]:
+    nonce = get_transaction_count(account.address)
+    deploy_data = [
+        contract_code,
+        calldata.encode({"method": "__init__", "args": method_args}),
+    ]
+    signed_transaction = sign_transaction(account, deploy_data, nonce=nonce)
+    result = send_raw_transaction(signed_transaction)
+    contract_address = result["data"]["contract_address"]
+    return contract_address, result
+
+
+def send_raw_transaction(signed_transaction: str):
+    payload_data = payload("eth_sendRawTransaction", signed_transaction)
+    raw_response = post_request(payload_data)
+    call_method_response = raw_response.json()
+    print("call_method_response", call_method_response)
+    transaction_hash = call_method_response["result"]
+
+    transaction_response = wait_for_transaction(transaction_hash)
+    return transaction_response
+
+
+def wait_for_transaction(transaction_hash: str, interval: int = 10, retries: int = 15):
+    attempts = 0
+    while attempts < retries:
+        transaction_response = get_transaction_by_hash(str(transaction_hash))
+        print("transaction_response", transaction_response)
+        status = transaction_response["status"]
+        if status == "FINALIZED":
+            return transaction_response
+        time.sleep(interval)
+        attempts += 1
+
+    raise TimeoutError(
+        f"Transaction {transaction_hash} not finalized after {retries} retries"
+    )

package/templates/default/tools/response.py

@@ -0,0 +1,52 @@
+def assert_dict_struct(data, structure):
+    if isinstance(structure, dict):
+        assert_is_instance(data, dict)
+        for key, value in structure.items():
+            assert key in data
+            assert_dict_struct(data[key], value)
+    elif isinstance(structure, list):
+        assert_is_instance(data, list)
+        for item in data:
+            assert_dict_struct(item, structure[0])
+    else:
+        assert_is_instance(data, structure)
+
+
+def assert_is_instance(data, structure):
+    assert isinstance(data, structure), f"Expected {structure}, but got {data}"
+
+
+def assert_dict_exact(data, expected):
+    assert data == expected, f"Expected {expected}, but got {data}"
+
+
+def has_error_status(result: dict) -> bool:
+    return "error" in result
+
+
+def has_success_status(result: dict) -> bool:
+    return "error" not in result
+
+
+def has_message(result: dict) -> bool:
+    return "message" in result
+
+
+def has_data(result: dict) -> bool:
+    return "data" in result
+
+
+def message_is(result: dict, message: dict) -> bool:
+    return result["message"] == message
+
+
+def data_is(result: dict, data: dict) -> bool:
+    return result["data"] == data
+
+
+def message_contains(result: dict, message: dict) -> bool:
+    return message in result["message"]
+
+
+def data_contains(result: dict, data: dict) -> bool:
+    return data in result["data"]

package/templates/default/tools/structure.py

@@ -0,0 +1,39 @@
+execute_icontract_function_response_structure = {
+    "consensus_data": {
+        "final": bool,
+        "leader_receipt": {
+            "args": list,
+            "class_name": str,
+            "contract_state": str,
+            "eq_outputs": {"leader": dict},
+            "error": str | None,
+            "execution_result": str,
+            "gas_used": int,
+            "method": str,
+            "mode": str,
+            "node_config": {
+                "address": str,
+                "config": dict,
+                "model": str,
+                "provider": str,
+                "stake": int,
+                "plugin": str,
+                "plugin_config": dict,
+            },
+            "vote": str,
+        },
+        "validators": list,
+        "votes": dict,
+    },
+    "created_at": str,
+    "data": {
+        "function_args": str,  # TODO: can we make this a list?
+        "function_name": str,
+    },
+    "from_address": str,
+    "hash": str,
+    "status": str,
+    "to_address": str,
+    "type": int,
+    "value": int,
+}

package/templates/default/tools/transactions.py

@@ -0,0 +1,28 @@
+from eth_account import Account
+from eth_utils import to_hex
+import rlp
+from eth_account._utils.legacy_transactions import Transaction
+
+
+def encode_transaction_data(data: list) -> str:
+    serialized_data = rlp.encode(data)
+    return to_hex(serialized_data)
+
+
+def sign_transaction(
+    account: Account, data: list = None, to: str = None, value: int = 0, nonce: int = 0
+) -> dict:
+    transaction = {
+        "nonce": nonce,
+        "gasPrice": 0,
+        "gas": 0,
+        "to": to,
+        "value": value,
+    }
+
+    if data is not None:
+        encoded_data = encode_transaction_data(data)
+        transaction["data"] = encoded_data
+
+    signed_transaction = Account.sign_transaction(transaction, account.key)
+    return to_hex(signed_transaction.raw_transaction)

package/templates/default/tools/types.py

@@ -0,0 +1,214 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Iterable, Optional
+import base64
+
+import collections.abc
+
+from eth_hash.auto import keccak
+
+
+class Address:
+    SIZE = 20
+
+    __slots__ = ("_as_bytes", "_as_hex")
+
+    _as_bytes: bytes
+    _as_hex: str | None
+
+    def __init__(self, val: str | collections.abc.Buffer):
+        self._as_hex = None
+        if isinstance(val, str):
+            if len(val) == 2 + Address.SIZE * 2 and val.startswith("0x"):
+                val = bytes.fromhex(val[2:])
+            elif len(val) > Address.SIZE:
+                val = base64.b64decode(val)
+        else:
+            val = bytes(val)
+        if not isinstance(val, bytes) or len(val) != Address.SIZE:
+            raise Exception(f"invalid address {val}")
+        self._as_bytes = val
+
+    @property
+    def as_bytes(self) -> bytes:
+        return self._as_bytes
+
+    @property
+    def as_hex(self) -> str:
+        if self._as_hex is None:
+            simple = self._as_bytes.hex()
+            low_up = keccak(simple.encode("ascii")).hex()
+            res = ["0", "x"]
+            for i in range(len(simple)):
+                if low_up[i] in ["0", "1", "2", "3", "4", "5", "6", "7"]:
+                    res.append(simple[i])
+                else:
+                    res.append(simple[i].upper())
+            self._as_hex = "".join(res)
+        return self._as_hex
+
+    @property
+    def as_b64(self) -> str:
+        return str(base64.b64encode(self.as_bytes), encoding="ascii")
+
+    @property
+    def as_int(self) -> int:
+        return int.from_bytes(self._as_bytes, "little", signed=False)
+
+    def __hash__(self):
+        return hash(self._as_bytes)
+
+    def __lt__(self, r):
+        assert isinstance(r, Address)
+        return self._as_bytes < r._as_bytes
+
+    def __le__(self, r):
+        assert isinstance(r, Address)
+        return self._as_bytes <= r._as_bytes
+
+    def __eq__(self, r):
+        if not isinstance(r, Address):
+            return False
+        return self._as_bytes == r._as_bytes
+
+    def __ge__(self, r):
+        assert isinstance(r, Address)
+        return self._as_bytes >= r._as_bytes
+
+    def __gt__(self, r):
+        assert isinstance(r, Address)
+        return self._as_bytes > r._as_bytes
+
+    def __repr__(self) -> str:
+        return "addr#" + "".join(["{:02x}".format(x) for x in self._as_bytes])
+
+
+class Vote(Enum):
+    AGREE = "agree"
+    DISAGREE = "disagree"
+
+    @classmethod
+    def from_string(cls, value: str) -> "Vote":
+        try:
+            return cls(value.lower())
+        except ValueError:
+            raise ValueError(f"Invalid vote value: {value}")
+
+
+class ExecutionMode(Enum):
+    LEADER = "leader"
+    VALIDATOR = "validator"
+
+    @classmethod
+    def from_string(cls, value: str) -> "ExecutionMode":
+        try:
+            return cls(value.lower())
+        except ValueError:
+            raise ValueError(f"Invalid execution mode value: {value}")
+
+
+class ExecutionResultStatus(Enum):
+    SUCCESS = "SUCCESS"
+    ERROR = "ERROR"
+
+    @classmethod
+    def from_string(cls, value: str) -> "ExecutionResultStatus":
+        try:
+            return cls(value.upper())
+        except ValueError:
+            raise ValueError(f"Invalid execution result status value: {value}")
+
+
+@dataclass
+class PendingTransaction:
+    address: str  # Address of the contract to call
+    calldata: bytes
+    code: bytes | None
+    salt_nonce: int
+
+    def is_deploy(self) -> bool:
+        return self.code is not None
+
+    def to_dict(self):
+        if self.code is None:
+            return {
+                "address": self.address,
+                "calldata": str(base64.b64encode(self.calldata), encoding="ascii"),
+            }
+        else:
+            return {
+                "code": str(base64.b64encode(self.code), encoding="ascii"),
+                "calldata": str(base64.b64encode(self.calldata), encoding="ascii"),
+                "salt_nonce": self.salt_nonce,
+            }
+
+    @classmethod
+    def from_dict(cls, input: dict) -> "PendingTransaction":
+        if "code" in input:
+            return cls(
+                address="0x",
+                calldata=base64.b64decode(input["calldata"]),
+                code=base64.b64decode(input["code"]),
+                salt_nonce=input.get("salt_nonce", 0),
+            )
+        else:
+            return cls(
+                address=input["address"],
+                calldata=base64.b64decode(input["calldata"]),
+                code=None,
+                salt_nonce=0,
+            )
+
+
+@dataclass
+class Receipt:
+    result: bytes
+    calldata: bytes
+    gas_used: int
+    mode: ExecutionMode
+    contract_state: dict[str, dict[str, str]]
+    node_config: dict
+    eq_outputs: dict[int, str]
+    execution_result: ExecutionResultStatus
+    vote: Optional[Vote] = None
+    pending_transactions: Iterable[PendingTransaction] = ()
+
+    def to_dict(self):
+        return {
+            "vote": self.vote.value,
+            "execution_result": self.execution_result.value,
+            "result": base64.b64encode(self.result).decode("ascii"),
+            "calldata": str(base64.b64encode(self.calldata), encoding="ascii"),
+            "gas_used": self.gas_used,
+            "mode": self.mode.value,
+            "contract_state": self.contract_state,
+            "node_config": self.node_config,
+            "eq_outputs": self.eq_outputs,
+            "pending_transactions": [
+                pending_transaction.to_dict()
+                for pending_transaction in self.pending_transactions
+            ],
+        }
+
+    @classmethod
+    def from_dict(cls, input: dict) -> Optional["Receipt"]:
+        if input:
+            return cls(
+                vote=Vote.from_string(input.get("vote")),
+                execution_result=ExecutionResultStatus.from_string(
+                    input.get("execution_result")
+                ),
+                result=base64.b64decode(input.get("result")),
+                calldata=base64.b64decode(input.get("calldata")),
+                gas_used=input.get("gas_used"),
+                mode=ExecutionMode.from_string(input.get("mode")),
+                contract_state=input.get("contract_state"),
+                node_config=input.get("node_config"),
+                eq_outputs={int(k): v for k, v in input.get("eq_outputs", {}).items()},
+                pending_transactions=[
+                    PendingTransaction.from_dict(pending_transaction)
+                    for pending_transaction in input.get("pending_transactions", [])
+                ],
+            )
+        else:
+            return None

package/templates/default/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "compilerOptions": {
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "outDir": "dist"
+  }
+}

package/tests/actions/call.test.ts

@@ -1,18 +1,16 @@
 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";
+import { CallAction } from "../../src/commands/contracts/call";
 
 vi.mock("genlayer-js");
-vi.mock("../../src/lib/accounts/getPrivateKey");
 
-describe("Call Action", () => {
-  let caller: CallAction;
+describe("CallAction", () => {
+  let callActions: CallAction;
   const mockClient = {
     readContract: vi.fn(),
     writeContract: vi.fn(),
     waitForTransactionReceipt: vi.fn(),
-    getContractSchema: vi.fn()
+    getContractSchema: vi.fn(),
   };
 
   const mockPrivateKey = "mocked_private_key";
@@ -21,8 +19,13 @@ describe("Call Action", () => {
     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();
+    callActions = new CallAction();
+    vi.spyOn(callActions as any, "getPrivateKey").mockResolvedValue(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(() => {
@@ -30,15 +33,13 @@ describe("Call Action", () => {
   });
 
   test("calls readContract successfully", async () => {
-    const options: CallOptions = {
-      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);
-    vi.mocked(mockClient.getContractSchema).mockResolvedValue({methods: {getData: {readonly: true}}});
 
-    await caller.call({
+    await callActions.call({
       contractAddress: "0xMockedContract",
       method: "getData",
       ...options,
@@ -49,21 +50,19 @@ describe("Call Action", () => {
       functionName: "getData",
       args: [1, 2, "Hello"],
     });
-    expect(mockClient.readContract).toHaveResolvedWith(mockResult);
+    expect(callActions["succeedSpinner"]).toHaveBeenCalledWith("Read operation successfully executed", "mocked_result");
   });
 
   test("calls writeContract successfully", async () => {
-    const options: CallOptions = {
-      args: [42, "Update"]
-    };
+    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);
-    vi.mocked(mockClient.getContractSchema).mockResolvedValue({methods: {updateData: {readonly: false}}});
 
-    await caller.call({
+    await callActions.call({
       contractAddress: "0xMockedContract",
       method: "updateData",
       ...options,
@@ -75,72 +74,33 @@ describe("Call Action", () => {
       args: [42, "Update"],
       value: 0n,
     });
-    expect(mockClient.waitForTransactionReceipt).toHaveBeenCalledWith({
-      hash: mockHash,
-      retries: 15,
-      interval: 2000,
-    });
-    expect(mockClient.writeContract).toHaveResolvedWith(mockHash);
+    expect(callActions["log"]).toHaveBeenCalledWith("Write transaction hash:", mockHash);
+    expect(callActions["succeedSpinner"]).toHaveBeenCalledWith("Write operation successfully executed", mockReceipt);
   });
 
-  test("throws error when method is not found", async () => {
-    const options: CallOptions = {
-      args: []
-    };
+  test("fails when method is not found", async () => {
+    vi.mocked(mockClient.getContractSchema).mockResolvedValue({ methods: { updateData: { readonly: false } } });
 
-    vi.mocked(mockClient.getContractSchema).mockResolvedValue({methods: {updateData: {readonly: false}}});
+    await callActions.call({ contractAddress: "0xMockedContract", method: "getData", args: [] });
 
-    await expect(
-      caller.call({
-        contractAddress: "0xMockedContract",
-        method: "getData",
-        ...options,
-      })
-    ).rejects.toThrowError('process.exit unexpectedly called with "1"');
-
-    expect(mockClient.readContract).not.toHaveBeenCalled();
-    expect(mockClient.writeContract).not.toHaveBeenCalled();
+    expect(callActions["failSpinner"]).toHaveBeenCalledWith("method getData not found.");
   });
 
-  test("handles errors during readContract", async () => {
-    const options: CallOptions = {
-      args: [1]
-    };
-
-    vi.mocked(mockClient.getContractSchema).mockResolvedValue({methods: {getData: {readonly: true}}});
-    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 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] });
+
+    expect(callActions["failSpinner"]).toHaveBeenCalledWith("Error during read operation", expect.any(Error));
   });
 
-  test("handles errors during writeContract", async () => {
-    const options: CallOptions = {
-      args: [1]
-    };
-
-    vi.mocked(mockClient.getContractSchema).mockResolvedValue({methods: {updateData: {readonly: false}}});
-    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();
+  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));
   });
-});
+});