algokit-utils 5.0.0a3__py3-none-any.whl

algokit_abi/__init__.py

@@ -0,0 +1,9 @@
+from algokit_abi import abi, arc32, arc56
+from algokit_abi._arc32_to_arc56 import arc32_to_arc56
+
+__all__ = [
+    "abi",
+    "arc32",
+    "arc32_to_arc56",
+    "arc56",
+]

algokit_abi/_arc32_to_arc56.py

@@ -0,0 +1,242 @@
+from __future__ import annotations
+
+import base64
+import json
+from base64 import b64encode
+from collections.abc import Mapping, Sequence
+from enum import Enum
+from typing import Any, Literal, overload
+
+from algokit_abi import abi, arc32, arc56
+from algokit_common import from_wire
+
+
+class _ActionType(str, Enum):
+    CALL = "CALL"
+    CREATE = "CREATE"
+
+
+_ARG_ALIASES: Mapping[str, arc56.ReferenceType | arc56.TransactionType] = {
+    **{r.value: r for r in arc56.ReferenceType},
+    **{t.value: t for t in arc56.TransactionType},
+}
+
+
+__all__ = ["arc32_to_arc56"]
+
+
+def arc32_to_arc56(arc32_application_spec: str | arc32.Arc32Contract) -> arc56.Arc56Contract:
+    """Convert an ARC-32 application specification to ARC-56."""
+
+    arc32_json = (
+        arc32_application_spec.to_json()
+        if isinstance(arc32_application_spec, arc32.Arc32Contract)
+        else arc32_application_spec
+    )
+    return _Arc32ToArc56Converter(arc32_json).convert()
+
+
+class _Arc32ToArc56Converter:
+    def __init__(self, arc32_application_spec: str):
+        self.arc32 = json.loads(arc32_application_spec)
+
+    def convert(self) -> arc56.Arc56Contract:
+        source_data = self.arc32.get("source")
+        methods, structs = self._convert_methods(self.arc32)
+        return arc56.Arc56Contract(
+            name=self.arc32["contract"]["name"],
+            desc=self.arc32["contract"].get("desc"),
+            arcs=[],
+            methods=methods,
+            structs=structs,
+            state=self._convert_state(self.arc32),
+            source=arc56.Source(**source_data) if source_data else None,
+            bare_actions=arc56.Actions(
+                call=self._convert_actions(self.arc32.get("bare_call_config"), _ActionType.CALL),
+                create=self._convert_actions(self.arc32.get("bare_call_config"), _ActionType.CREATE),
+            ),
+        )
+
+    def _convert_storage_keys(self, schema: dict) -> dict[str, arc56.StorageKey]:
+        """Convert ARC32 schema declared fields to ARC56 storage keys."""
+
+        return {
+            name: arc56.StorageKey(
+                key=b64encode(field["key"].encode()).decode(),
+                _key_type=arc56.AVMType.STRING,
+                _value_type=arc56.AVMType.UINT64 if field["type"] == "uint64" else arc56.AVMType.BYTES,
+                desc=field.get("descr"),
+            )
+            for name, field in schema.items()
+        }
+
+    def _convert_state(self, arc32: dict) -> arc56.State:
+        """Convert ARC32 state and schema to ARC56 state specification."""
+        state_data = arc32.get("state", {})
+        return arc56.State(
+            schema=arc56.Schema(
+                global_state=arc56.Global(
+                    ints=state_data.get("global", {}).get("num_uints", 0),
+                    bytes=state_data.get("global", {}).get("num_byte_slices", 0),
+                ),
+                local_state=arc56.Local(
+                    ints=state_data.get("local", {}).get("num_uints", 0),
+                    bytes=state_data.get("local", {}).get("num_byte_slices", 0),
+                ),
+            ),
+            keys=arc56.Keys(
+                global_state=self._convert_storage_keys(arc32.get("schema", {}).get("global", {}).get("declared", {})),
+                local_state=self._convert_storage_keys(arc32.get("schema", {}).get("local", {}).get("declared", {})),
+                box={},
+            ),
+            maps=arc56.Maps(global_state={}, local_state={}, box={}),
+        )
+
+    def _convert_default_value(self, default_arg: dict[str, Any] | None) -> arc56.DefaultValue | None:
+        """Convert ARC32 default argument to ARC56 format."""
+        if not default_arg or not default_arg.get("source"):
+            return None
+
+        source_mapping = {
+            "constant": "literal",
+            "global-state": "global",
+            "local-state": "local",
+            "abi-method": "method",
+        }
+
+        mapped_source = source_mapping.get(default_arg["source"])
+        if not mapped_source:
+            return None
+        arg_data = default_arg["data"]
+        if mapped_source == "method":
+            method = from_wire(arc56.Method, arg_data)
+            return arc56.DefaultValue(
+                source=mapped_source,  # type: ignore[arg-type]
+                data=method.signature,
+            )
+
+        default_value_type: abi.ABIType | arc56.AVMType | None = None
+        if mapped_source == "literal":
+            if isinstance(arg_data, int):
+                default_value_type = abi.UintType(64)
+                arg_data = default_value_type.encode(arg_data)
+            elif isinstance(arg_data, str):
+                default_value_type = arc56.AVMType.STRING
+            else:
+                raise ValueError(f"Invalid default argument data type: {type(arg_data)}")
+        if isinstance(arg_data, str):
+            arg_data = arg_data.encode("utf-8")
+        return arc56.DefaultValue(
+            source=mapped_source,  # type: ignore[arg-type]
+            data=base64.b64encode(arg_data).decode("utf-8"),
+            type=default_value_type,
+        )
+
+    @overload
+    def _convert_actions(self, config: dict | None, action_type: Literal[_ActionType.CALL]) -> list[arc56.CallEnum]: ...
+
+    @overload
+    def _convert_actions(
+        self, config: dict | None, action_type: Literal[_ActionType.CREATE]
+    ) -> list[arc56.CreateEnum]: ...
+
+    def _convert_actions(
+        self, config: dict | None, action_type: _ActionType
+    ) -> Sequence[arc56.CallEnum | arc56.CreateEnum]:
+        """Extract supported actions from call config."""
+        if not config:
+            return []
+
+        actions = list[arc56.CallEnum | arc56.CreateEnum]()
+        mappings = {
+            "no_op": (arc56.CallEnum.NO_OP, arc56.CreateEnum.NO_OP),
+            "opt_in": (arc56.CallEnum.OPT_IN, arc56.CreateEnum.OPT_IN),
+            "close_out": (arc56.CallEnum.CLOSE_OUT, None),
+            "delete_application": (arc56.CallEnum.DELETE_APPLICATION, arc56.CreateEnum.DELETE_APPLICATION),
+            "update_application": (arc56.CallEnum.UPDATE_APPLICATION, None),
+        }
+
+        for action, (call_enum, create_enum) in mappings.items():
+            if action in config and config[action] in ["ALL", action_type]:
+                if action_type == "CALL" and call_enum:
+                    actions.append(call_enum)
+                elif action_type == "CREATE" and create_enum:
+                    actions.append(create_enum)
+
+        return actions
+
+    def _convert_method_actions(self, hint: dict | None) -> arc56.Actions:
+        """Convert method call config to ARC56 actions."""
+        config = hint.get("call_config", {}) if hint else {}
+        return arc56.Actions(
+            call=self._convert_actions(config, _ActionType.CALL),
+            create=self._convert_actions(config, _ActionType.CREATE),
+        )
+
+    def _convert_methods(self, arc32: dict) -> tuple[list[arc56.Method], dict[str, abi.StructType]]:
+        """Convert ARC32 methods to ARC56 format."""
+        methods = []
+        contract = arc32["contract"]
+        hints = arc32.get("hints", {})
+        structs = {}
+        for method in contract["methods"]:
+            args_sig = ",".join(a["type"] for a in method["args"])
+            signature = f"{method['name']}({args_sig}){method['returns']['type']}"
+            hint = hints.get(signature, {})
+            method_structs = hint.get("structs", {})
+            method_args = []
+            for arg in method["args"]:
+                name = arg.get("name")
+                struct_name = None
+                if struct := method_structs.get(name):
+                    struct_type = _convert_struct(struct)
+                    struct_name = struct_type.display_name
+                    structs[struct_name] = struct_type
+                    arg_type: abi.ABIType | arc56.ReferenceType | arc56.TransactionType = struct_type
+                elif alias := _ARG_ALIASES.get(arg["type"]):
+                    arg_type = alias
+                else:
+                    arg_type = abi.ABIType.from_string(arg["type"])
+                method_args.append(
+                    arc56.Argument(
+                        type=arg_type,
+                        name=name,
+                        desc=arg.get("desc"),
+                        default_value=self._convert_default_value(
+                            hint.get("default_arguments", {}).get(arg.get("name"))
+                        ),
+                        struct=struct_name,
+                    )
+                )
+            returns = method["returns"]
+            struct_name = None
+            if struct := method_structs.get("output"):
+                struct_type = _convert_struct(struct)
+                struct_name = struct_type.display_name
+                structs[struct_name] = struct_type
+                return_type: abi.ABIType | arc56.VoidType = struct_type
+            elif returns["type"] == arc56.Void:
+                return_type = arc56.Void
+            else:
+                return_type = abi.ABIType.from_string(returns["type"])
+            methods.append(
+                arc56.Method(
+                    name=method["name"],
+                    desc=method.get("desc"),
+                    readonly=hint.get("read_only"),
+                    args=method_args,
+                    returns=arc56.Returns(
+                        return_type,
+                        desc=returns.get("desc"),
+                        struct=struct_name,
+                    ),
+                    actions=self._convert_method_actions(hint),
+                    events=[],  # ARC32 doesn't specify events
+                )
+            )
+        return methods, structs
+
+
+def _convert_struct(struct: dict) -> abi.StructType:
+    fields = {name: abi.ABIType.from_string(typ) for name, typ in struct["elements"]}
+    return abi.StructType(struct_name=struct["name"], fields=fields)

algokit_abi/_arc56_serde.py

@@ -0,0 +1,161 @@
+import base64
+import typing
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass, field
+
+from algokit_abi import abi
+from algokit_common import from_wire, to_wire, wire
+
+_Metadata = Mapping[str, object]
+_T = typing.TypeVar("_T")
+
+
+def base64_encoded_bytes(alias: str) -> _Metadata:
+    return wire(
+        alias,
+        encode=lambda v: base64.b64encode(v).decode("ascii"),
+        decode=base64.b64decode,
+    )
+
+
+def sequence(alias: str, typ: Callable[..., object], *, omit_empty_seq: bool = True) -> _Metadata:
+    def decode(payload: list) -> object:
+        return [typ(v) for v in payload]
+
+    return wire(alias, decode=decode, omit_empty_seq=omit_empty_seq)
+
+
+def nested_sequence(alias: str, typ: type[_T]) -> _Metadata:
+    def encode(val: list | None) -> object:
+        if val is None:
+            return None
+        return [to_wire(v) for v in val]
+
+    def decode(payload: list | None) -> object:
+        if payload is None:
+            return None
+        return [from_wire(typ, v) for v in payload]
+
+    return wire(alias, encode=encode, decode=decode, omit_empty_seq=False, omit_if_none=True)
+
+
+def mapping(alias: str, typ: type[_T]) -> _Metadata:
+    def encode(value: Mapping) -> Mapping:
+        return {k: to_wire(v) for k, v in value.items()}
+
+    def decode(payload: Mapping) -> Mapping:
+        return {k: from_wire(typ, v) for k, v in payload.items()}
+
+    return wire(alias, decode=decode, encode=encode)
+
+
+def abi_type(alias: str) -> _Metadata:
+    def encode(value: object) -> str:
+        if isinstance(value, abi.ABIType):
+            return value.name
+        else:
+            return str(value)
+
+    def decode(value: str) -> object:
+        from algokit_abi import arc56
+
+        try:
+            return arc56.ENUM_ALIASES[value]
+        except KeyError:
+            return abi.ABIType.from_string(value)
+
+    return wire(alias, encode=encode, decode=decode)
+
+
+def storage(alias: str) -> _Metadata:
+    def encode(value: object) -> str:
+        if isinstance(value, abi.ABIType):
+            return value.name
+        else:
+            return str(value)
+
+    def decode(value: str) -> object:
+        from algokit_abi import arc56
+
+        try:
+            return arc56.AVMType(value)
+        except ValueError:
+            pass
+        try:
+            return abi.ABIType.from_string(value)
+        except ValueError:
+            return str(value)
+
+    return wire(alias, encode=encode, decode=decode)
+
+
+class _StructField(typing.TypedDict):
+    name: str
+    type: "str | list[_StructField]"
+
+
+_StructFieldJson = dict[str, list[_StructField]]
+
+
+@dataclass
+class _StructDecoder:
+    _struct_json: _StructFieldJson
+    result: dict[str, abi.StructType] = field(default_factory=dict)
+
+    @classmethod
+    def decode(cls, struct_json: _StructFieldJson) -> dict[str, abi.StructType]:
+        decoder = cls(struct_json)
+        decoder._process()
+        return decoder.result
+
+    def _process(self) -> None:
+        # add known struct names
+        for struct_name, struct_json in self._struct_json.items():
+            self._get_or_add(struct_name, struct_json)
+
+    def _get_or_add(self, name: str, fields: Sequence[_StructField]) -> abi.StructType:
+        try:
+            return self.result[name]
+        except KeyError:
+            pass
+        self.result[name] = struct = self._decode_struct(name, fields)
+        return struct
+
+    def _decode_struct(self, name: str, fields: Sequence[_StructField]) -> abi.StructType:
+        abi_fields = dict[str, abi.ABIType]()
+        for field_ in fields:
+            field_name = field_["name"]
+            field_type = field_["type"]
+            if isinstance(field_type, Sequence) and not isinstance(field_type, str):  # anonymous inner struct
+                inner_struct_name = f"{name}_{field_name}"
+                field_abi_type: abi.ABIType = self._decode_struct(inner_struct_name, field_type)
+            elif (field_struct_json := self._struct_json.get(field_type)) is not None:  # named struct
+                field_abi_type = self._get_or_add(field_type, field_struct_json)
+            else:
+                field_abi_type = abi.ABIType.from_string(field_type)
+            abi_fields[field_name] = field_abi_type
+        return abi.StructType(struct_name=name, fields=abi_fields)
+
+
+def _encode_structs(structs: dict[str, abi.StructType]) -> dict:
+    return {name: _encode_struct(structs, struct) for name, struct in structs.items()}
+
+
+def _encode_struct(structs: dict[str, abi.StructType], struct: abi.StructType) -> list:
+    fields = []
+    for field_name, field_type in struct.fields.items():
+        fields.append(_StructField(name=field_name, type=_encode_struct_field(structs, field_type)))
+    return fields
+
+
+def _encode_struct_field(structs: dict[str, abi.StructType], field_type: abi.ABIType) -> str | list:
+    if isinstance(field_type, abi.StructType):
+        if field_type.display_name in structs:
+            return field_type.display_name
+        else:
+            return _encode_struct(structs, field_type)
+    else:
+        return field_type.name
+
+
+struct_metadata = wire("structs", encode=_encode_structs, decode=_StructDecoder.decode)