genlayer 0.12.4 → 0.12.5

package/templates/default/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "genlayer-project",
+  "type": "module",
+  "devDependencies": {
+    "genlayer-js": "^0.6.0"
+  }
+}

package/templates/default/requirements.txt

@@ -0,0 +1,6 @@
+requests==2.31.0
+python-dotenv==1.0.1
+pytest==8.2.1
+pytest-mock==3.14.0
+eth-account==0.13.3
+eth-utils==5.0.0

package/templates/default/test/football_bets_get_contract_schema_for_code.py

@@ -0,0 +1,124 @@
+football_bets_contract_schema = {
+    "id": 1,
+    "jsonrpc": "2.0",
+    "result": {
+        "ctor": {"kwparams": {}, "params": []},
+        "methods": {
+            "create_bet": {
+                "kwparams": {},
+                "params": [
+                    ["game_date", "string"],
+                    ["team1", "string"],
+                    ["team2", "string"],
+                    ["predicted_winner", "string"],
+                ],
+                "readonly": False,
+                "ret": "null",
+            },
+            "get_bets": {"kwparams": {}, "params": [], "readonly": True, "ret": "dict"},
+            "get_player_points": {
+                "kwparams": {},
+                "params": [["player_address", "string"]],
+                "readonly": True,
+                "ret": "int",
+            },
+            "get_points": {
+                "kwparams": {},
+                "params": [],
+                "readonly": True,
+                "ret": "dict",
+            },
+            "resolve_bet": {
+                "kwparams": {},
+                "params": [["bet_id", "string"]],
+                "readonly": False,
+                "ret": "null",
+            },
+        },
+    },
+}
+
+
+test_football_bets_win_unresolved = {
+    "2024-06-20_spain_italy": {
+        "game_date": "2024-06-20",
+        "has_resolved": False,
+        "id": "2024-06-20_spain_italy",
+        "predicted_winner": "1",
+        "real_score": None,
+        "real_winner": None,
+        "resolution_url": "https://www.bbc.com/sport/football/scores-fixtures/2024-06-20",
+        "team1": "Spain",
+        "team2": "Italy",
+    }
+}
+
+test_football_bets_win_resolved = {
+    "2024-06-20_spain_italy": {
+        "game_date": "2024-06-20",
+        "has_resolved": True,
+        "id": "2024-06-20_spain_italy",
+        "predicted_winner": "1",
+        "real_score": "1:0",
+        "real_winner": "1",
+        "resolution_url": "https://www.bbc.com/sport/football/scores-fixtures/2024-06-20",
+        "team1": "Spain",
+        "team2": "Italy",
+    }
+}
+
+test_football_bets_draw_unresolved = {
+    "2024-06-20_denmark_england": {
+        "game_date": "2024-06-20",
+        "has_resolved": False,
+        "id": "2024-06-20_denmark_england",
+        "predicted_winner": "0",
+        "real_score": None,
+        "real_winner": None,
+        "resolution_url": "https://www.bbc.com/sport/football/scores-fixtures/2024-06-20",
+        "team1": "Denmark",
+        "team2": "England",
+    }
+}
+
+test_football_bets_draw_resolved = {
+    "2024-06-20_denmark_england": {
+        "game_date": "2024-06-20",
+        "has_resolved": True,
+        "id": "2024-06-20_denmark_england",
+        "predicted_winner": "0",
+        "real_score": "1:1",
+        "real_winner": "0",
+        "resolution_url": "https://www.bbc.com/sport/football/scores-fixtures/2024-06-20",
+        "team1": "Denmark",
+        "team2": "England",
+    }
+}
+
+test_football_bets_unsuccess_unresolved = {
+    "2024-06-20_spain_italy": {
+        "game_date": "2024-06-20",
+        "has_resolved": False,
+        "id": "2024-06-20_spain_italy",
+        "predicted_winner": "2",
+        "real_score": None,
+        "real_winner": None,
+        "resolution_url": "https://www.bbc.com/sport/football/scores-fixtures/2024-06-20",
+        "team1": "Spain",
+        "team2": "Italy",
+    }
+}
+
+test_football_bets_unsuccess_resolved = {
+    "2024-06-20_spain_italy": {
+        "game_date": "2024-06-20",
+        "has_resolved": True,
+        "id": "2024-06-20_spain_italy",
+        "predicted_winner": "2",
+        "real_score": "1:0",
+        "real_winner": "1",
+        "resolution_url": "https://www.bbc.com/sport/football/scores-fixtures/2024-06-20",
+        "team1": "Spain",
+        "team2": "Italy",
+    }
+}

package/templates/default/test/test_football_bet_success_draw.py

@@ -0,0 +1,108 @@
+# tests/e2e/test_wizard_of_coin.py
+
+from tools.accounts import create_new_account
+from tools.request import (
+    deploy_intelligent_contract,
+    send_transaction,
+    call_contract_method,
+    payload,
+    post_request,
+)
+from tools.structure import execute_icontract_function_response_structure
+from tools.response import (
+    assert_dict_struct,
+    assert_dict_exact,
+    has_success_status,
+)
+from test.football_bets_get_contract_schema_for_code import (
+    football_bets_contract_schema,
+    test_football_bets_win_resolved,
+    test_football_bets_win_unresolved,
+)
+
+
+def test_football_bets_success():
+    # Account
+    account_1 = create_new_account()
+    # Validators - not needed for studio.genlayer.com
+    # result = post_request(
+    #     payload("sim_createRandomValidators", 5, 8, 12, ["openai"], ["gpt-4o"])
+    # ).json()
+    # assert has_success_status(result)
+
+    # Contract Schema
+    contract_code = open("contracts/football_bets.py", "r").read()
+    result_schema = post_request(
+        payload("gen_getContractSchemaForCode", contract_code)
+    ).json()
+    assert has_success_status(result_schema)
+    assert_dict_exact(result_schema, football_bets_contract_schema)
+
+    # Contract Deploy
+    contract_address, transaction_response_deploy = deploy_intelligent_contract(
+        account_1,
+        contract_code,
+        "{}",
+    )
+    assert has_success_status(transaction_response_deploy)
+
+    # Get Initial State
+    contract_all_points_state = call_contract_method(
+        contract_address, account_1, "get_points", []
+    )
+    assert contract_all_points_state == {}
+
+    contract_all_bets_state = call_contract_method(
+        contract_address, account_1, "get_bets", []
+    )
+    assert contract_all_bets_state == {}
+
+    # Create Successful Bet
+    create_successful_bet_result = send_transaction(
+        account_1,
+        contract_address,
+        "create_bet",
+        ["2024-06-20", "Denmark", "England", "0"],
+    )
+    assert has_success_status(create_successful_bet_result)
+    assert_dict_struct(
+        create_successful_bet_result,
+        execute_icontract_function_response_structure,
+    )
+
+    # Get Bets
+    get_bet_result = call_contract_method(contract_address, account_1, "get_bets", [])
+    assert get_bet_result == {account_1.address: test_football_bets_win_unresolved}
+
+    # Resolve Successful Bet
+    resolve_successful_bet_result = send_transaction(
+        account_1,
+        contract_address,
+        "resolve_bet",
+        ["2024-06-20_denmark_england"],
+    )
+    assert has_success_status(resolve_successful_bet_result)
+    assert_dict_struct(
+        resolve_successful_bet_result,
+        execute_icontract_function_response_structure,
+    )
+
+    # Get Bets
+    get_bet_result = call_contract_method(contract_address, account_1, "get_bets", [])
+    assert get_bet_result == {account_1.address: test_football_bets_win_resolved}
+
+    # Get Points
+    get_points_result = call_contract_method(
+        contract_address, account_1, "get_points", []
+    )
+    assert get_points_result == {account_1.address: 1}
+
+    # Get Player Points
+    get_player_points_result = call_contract_method(
+        contract_address, account_1, "get_player_points", [account_1.address]
+    )
+    assert get_player_points_result == 1
+
+    # Delete Validators - not needed for studio.genlayer.com
+    # delete_validators_result = post_request(payload("sim_deleteAllValidators")).json()
+    # assert has_success_status(delete_validators_result)

package/templates/default/test/test_football_bet_success_win.py

@@ -0,0 +1,106 @@
+# tests/e2e/test_wizard_of_coin.py
+
+from tools.accounts import create_new_account
+from tools.request import (
+    deploy_intelligent_contract,
+    send_transaction,
+    call_contract_method,
+    payload,
+    post_request,
+)
+from tools.structure import execute_icontract_function_response_structure
+from tools.response import (
+    assert_dict_struct,
+    assert_dict_exact,
+    has_success_status,
+)
+from test.football_bets_get_contract_schema_for_code import (
+    football_bets_contract_schema,
+    test_football_bets_win_unresolved,
+    test_football_bets_win_resolved,
+)
+
+
+def test_football_bets_success():
+    # Account
+    account_1 = create_new_account()
+    # Validators - not needed for studio.genlayer.com
+    # result = post_request(
+    #     payload("sim_createRandomValidators", 5, 8, 12, ["openai"], ["gpt-4o"])
+    # ).json()
+    # assert has_success_status(result)
+
+    # Contract Schema
+    contract_code = open("contracts/football_bet_market.py", "r").read()
+    result_schema = post_request(
+        payload("gen_getContractSchemaForCode", contract_code)
+    ).json()
+    assert has_success_status(result_schema)
+    assert_dict_exact(result_schema, football_bets_contract_schema)
+
+    # Contract Deploy
+    contract_address, transaction_response_deploy = deploy_intelligent_contract(
+        account_1,
+        contract_code,
+        "{}",
+    )
+    assert has_success_status(transaction_response_deploy)
+
+    # Get Initial State
+    contract_all_points_state = call_contract_method(
+        contract_address, account_1, "get_points", []
+    )
+    assert contract_all_points_state == {}
+
+    contract_all_bets_state = call_contract_method(
+        contract_address, account_1, "get_bets", []
+    )
+    assert contract_all_bets_state == {}
+
+    # Create Successful Bet
+    create_successful_bet_result = send_transaction(
+        account_1,
+        contract_address,
+        "create_bet",
+        ["2024-06-20", "Spain", "Italy", "1"],
+    )
+    assert has_success_status(create_successful_bet_result)
+    assert_dict_struct(
+        create_successful_bet_result,
+        execute_icontract_function_response_structure,
+    )
+
+    # Get Bets
+    get_bet_result = call_contract_method(contract_address, account_1, "get_bets", [])
+    print("~ ~ ~ ~ ~ get_bet_result", get_bet_result)
+    assert get_bet_result == {account_1.address: test_football_bets_win_unresolved}
+
+    # Resolve Successful Bet
+    resolve_successful_bet_result = send_transaction(
+        account_1, contract_address, "resolve_bet", ["2024-06-20_spain_italy"]
+    )
+    assert has_success_status(resolve_successful_bet_result)
+    assert_dict_struct(
+        resolve_successful_bet_result,
+        execute_icontract_function_response_structure,
+    )
+
+    # Get Bets
+    get_bet_result = call_contract_method(contract_address, account_1, "get_bets", [])
+    assert get_bet_result == {account_1.address: test_football_bets_win_resolved}
+
+    # Get Points
+    get_points_result = call_contract_method(
+        contract_address, account_1, "get_points", []
+    )
+    assert get_points_result == {account_1.address: 1}
+
+    # Get Player Points
+    get_player_points_result = call_contract_method(
+        contract_address, account_1, "get_player_points", [account_1.address]
+    )
+    assert get_player_points_result == 1
+
+    # Delete Validators - not needed for studio.genlayer.com
+    # delete_validators_result = post_request(payload("sim_deleteAllValidators")).json()
+    # assert has_success_status(delete_validators_result)

package/templates/default/test/test_football_bet_unsuccess.py

@@ -0,0 +1,107 @@
+# tests/e2e/test_wizard_of_coin.py
+
+from tools.accounts import create_new_account
+from tools.request import (
+    deploy_intelligent_contract,
+    send_transaction,
+    call_contract_method,
+    payload,
+    post_request,
+)
+from tools.structure import execute_icontract_function_response_structure
+from tools.response import (
+    assert_dict_struct,
+    assert_dict_exact,
+    has_success_status,
+)
+from test.football_bets_get_contract_schema_for_code import (
+    football_bets_contract_schema,
+    test_football_bets_unsuccess_unresolved,
+    test_football_bets_unsuccess_resolved,
+)
+
+
+def test_football_bets_unsuccess():
+    # Account
+    account_1 = create_new_account()
+    # Validators - not needed for studio.genlayer.com
+    # result = post_request(
+    #     payload("sim_createRandomValidators", 5, 8, 12, ["openai"], ["gpt-4o"])
+    # ).json()
+    # assert has_success_status(result)
+
+    # Contract Schema
+    contract_code = open("contracts/football_bet_market.py", "r").read()
+    result_schema = post_request(
+        payload("gen_getContractSchemaForCode", contract_code)
+    ).json()
+    assert has_success_status(result_schema)
+    assert_dict_exact(result_schema, football_bets_contract_schema)
+
+    # Contract Deploy
+    contract_address, transaction_response_deploy = deploy_intelligent_contract(
+        account_1,
+        contract_code,
+        "{}",
+    )
+    assert has_success_status(transaction_response_deploy)
+
+    # Get Initial State
+    contract_all_points_state = call_contract_method(
+        contract_address, account_1, "get_points", []
+    )
+    assert contract_all_points_state == {}
+
+    contract_all_bets_state = call_contract_method(
+        contract_address, account_1, "get_bets", []
+    )
+    assert contract_all_bets_state == {}
+
+    # Create Successful Bet
+    create_successful_bet_result = send_transaction(
+        account_1,
+        contract_address,
+        "create_bet",
+        ["2024-06-20", "Spain", "Italy", "2"],
+    )
+    assert has_success_status(create_successful_bet_result)
+    assert_dict_struct(
+        create_successful_bet_result,
+        execute_icontract_function_response_structure,
+    )
+
+    # Get Bets
+    get_bet_result = call_contract_method(contract_address, account_1, "get_bets", [])
+    assert get_bet_result == {
+        account_1.address: test_football_bets_unsuccess_unresolved
+    }
+
+    # Resolve Successful Bet
+    resolve_successful_bet_result = send_transaction(
+        account_1, contract_address, "resolve_bet", ["2024-06-20_spain_italy"]
+    )
+    assert has_success_status(resolve_successful_bet_result)
+    assert_dict_struct(
+        resolve_successful_bet_result,
+        execute_icontract_function_response_structure,
+    )
+
+    # Get Bets
+    get_bet_result = call_contract_method(contract_address, account_1, "get_bets", [])
+    assert get_bet_result == {account_1.address: test_football_bets_unsuccess_resolved}
+
+    # Get Points
+    get_points_result = call_contract_method(
+        contract_address, account_1, "get_points", []
+    )
+    assert get_points_result == {}
+
+    # Get Player Points
+    get_player_points_result = call_contract_method(
+        contract_address, account_1, "get_player_points", [account_1.address]
+    )
+    assert get_player_points_result == 0
+
+    # Delete Validators - not needed for studio.genlayer.com
+    # delete_validators_result = post_request(payload("sim_deleteAllValidators")).json()
+    # assert has_success_status(delete_validators_result)

package/templates/default/tools/accounts.py

@@ -0,0 +1,5 @@
+from eth_account import Account
+
+
+def create_new_account() -> Account:
+    return Account.create()

package/templates/default/tools/calldata.py

@@ -0,0 +1,224 @@
+from tools.types import Address
+import typing
+import collections.abc
+import dataclasses
+import abc
+import json
+
+BITS_IN_TYPE = 3
+
+TYPE_SPECIAL = 0
+TYPE_PINT = 1
+TYPE_NINT = 2
+TYPE_BYTES = 3
+TYPE_STR = 4
+TYPE_ARR = 5
+TYPE_MAP = 6
+
+SPECIAL_NULL = (0 << BITS_IN_TYPE) | TYPE_SPECIAL
+SPECIAL_FALSE = (1 << BITS_IN_TYPE) | TYPE_SPECIAL
+SPECIAL_TRUE = (2 << BITS_IN_TYPE) | TYPE_SPECIAL
+SPECIAL_ADDR = (3 << BITS_IN_TYPE) | TYPE_SPECIAL
+
+
+class CalldataEncodable(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def __to_calldata__(self) -> typing.Any: ...
+
+
+def encode(
+    x: typing.Any, *, default: typing.Callable[[typing.Any], typing.Any] = lambda x: x
+) -> bytes:
+    mem = bytearray()
+
+    def append_uleb128(i):
+        assert i >= 0
+        if i == 0:
+            mem.append(0)
+        while i > 0:
+            cur = i & 0x7F
+            i = i >> 7
+            if i > 0:
+                cur |= 0x80
+            mem.append(cur)
+
+    def impl_dict(b: collections.abc.Mapping):
+        keys = list(b.keys())
+        keys.sort()
+        le = len(keys)
+        le = (le << 3) | TYPE_MAP
+        append_uleb128(le)
+        for k in keys:
+            if not isinstance(k, str):
+                raise Exception(f"key is not string {type(k)}")
+            bts = k.encode("utf-8")
+            append_uleb128(len(bts))
+            mem.extend(bts)
+            impl(b[k])
+
+    def impl(b: typing.Any):
+        b = default(b)
+        if isinstance(b, CalldataEncodable):
+            b = b.__to_calldata__()
+        if b is None:
+            mem.append(SPECIAL_NULL)
+        elif b is True:
+            mem.append(SPECIAL_TRUE)
+        elif b is False:
+            mem.append(SPECIAL_FALSE)
+        elif isinstance(b, int):
+            if b >= 0:
+                b = (b << 3) | TYPE_PINT
+                append_uleb128(b)
+            else:
+                b = -b - 1
+                b = (b << 3) | TYPE_NINT
+                append_uleb128(b)
+        elif isinstance(b, Address):
+            mem.append(SPECIAL_ADDR)
+            mem.extend(b.as_bytes)
+        elif isinstance(b, bytes):
+            lb = len(b)
+            lb = (lb << 3) | TYPE_BYTES
+            append_uleb128(lb)
+            mem.extend(b)
+        elif isinstance(b, str):
+            b = b.encode("utf-8")
+            lb = len(b)
+            lb = (lb << 3) | TYPE_STR
+            append_uleb128(lb)
+            mem.extend(b)
+        elif isinstance(b, collections.abc.Sequence):
+            lb = len(b)
+            lb = (lb << 3) | TYPE_ARR
+            append_uleb128(lb)
+            for x in b:
+                impl(x)
+        elif isinstance(b, collections.abc.Mapping):
+            impl_dict(b)
+        elif dataclasses.is_dataclass(b):
+            assert not isinstance(b, type)
+            impl_dict(dataclasses.asdict(b))
+        else:
+            raise Exception(f"invalid type {type(b)}")
+
+    impl(x)
+    return bytes(mem)
+
+
+def decode(mem0: collections.abc.Buffer) -> typing.Any:
+    mem: memoryview = memoryview(mem0)
+
+    def read_uleb128() -> int:
+        nonlocal mem
+        ret = 0
+        off = 0
+        while True:
+            m = mem[0]
+            ret = ret | ((m & 0x7F) << off)
+            off += 7
+            mem = mem[1:]
+            if (m & 0x80) == 0:
+                break
+        return ret
+
+    def impl() -> typing.Any:
+        nonlocal mem
+        code = read_uleb128()
+        typ = code & 0x7
+        if typ == TYPE_SPECIAL:
+            if code == SPECIAL_NULL:
+                return None
+            if code == SPECIAL_FALSE:
+                return False
+            if code == SPECIAL_TRUE:
+                return True
+            if code == SPECIAL_ADDR:
+                ret_addr = mem[: Address.SIZE]
+                mem = mem[Address.SIZE :]
+                return Address(ret_addr)
+            raise Exception(f"Unknown special {bin(code)} {hex(code)}")
+        code = code >> 3
+        if typ == TYPE_PINT:
+            return code
+        elif typ == TYPE_NINT:
+            return -code - 1
+        elif typ == TYPE_BYTES:
+            ret_bytes = mem[:code]
+            mem = mem[code:]
+            return ret_bytes
+        elif typ == TYPE_STR:
+            ret_str = mem[:code]
+            mem = mem[code:]
+            return str(ret_str, encoding="utf-8")
+        elif typ == TYPE_ARR:
+            ret_arr = []
+            for _i in range(code):
+                ret_arr.append(impl())
+            return ret_arr
+        elif typ == TYPE_MAP:
+            ret_dict: dict[str, typing.Any] = {}
+            prev = None
+            for _i in range(code):
+                le = read_uleb128()
+                key = str(mem[:le], encoding="utf-8")
+                mem = mem[le:]
+                if prev is not None:
+                    assert prev < key
+                prev = key
+                assert key not in ret_dict
+                ret_dict[key] = impl()
+            return ret_dict
+        raise Exception(f"invalid type {typ}")
+
+    res = impl()
+    if len(mem) != 0:
+        raise Exception(f"unparsed end {bytes(mem[:5])!r}... (decoded {res})")
+    return res
+
+
+def to_str(d: typing.Any) -> str:
+    buf: list[str] = []
+
+    def impl(d: typing.Any) -> None:
+        if d is None:
+            buf.append("null")
+        elif d is True:
+            buf.append("true")
+        elif d is False:
+            buf.append("false")
+        elif isinstance(d, str):
+            buf.append(json.dumps(d))
+        elif isinstance(d, bytes):
+            buf.append("b#")
+            buf.append(d.hex())
+        elif isinstance(d, int):
+            buf.append(str(d))
+        elif isinstance(d, Address):
+            buf.append("addr#")
+            buf.append(d.as_bytes.hex())
+        elif isinstance(d, dict):
+            buf.append("{")
+            comma = False
+            for k, v in d.items():
+                if comma:
+                    buf.append(",")
+                comma = True
+                buf.append(json.dumps(k))
+                buf.append(":")
+                impl(v)
+            buf.append("}")
+        elif isinstance(d, list):
+            buf.append("[")
+            comma = False
+            for v in d:
+                if comma:
+                    buf.append(",")
+                comma = True
+                impl(v)
+            buf.append("]")
+        else:
+            raise Exception(f"can't encode {d} to calldata")
+
+    impl(d)
+    return "".join(buf)