Testing ABI Functionality via Graviton / Dry-runs + Txn Friendly Graviton Logic Sig Example

.github/workflows/build.yml

@@ -23,7 +23,7 @@ jobs:
       - name: Install python dependencies
         run: make setup-development
       - name: Build and Test
-        run: make build-and-test
+        run: make lint-and-test
 
   run-integration-tests:
     runs-on: ubuntu-20.04
@@ -63,8 +63,8 @@ jobs:
         run: make sandbox-dev-up
       - name: Install python dependencies
         run: make setup-development
-      - name: Build, Unit Tests and Integration Tests
-        run: make all-tests
+      - name: Integration Tests Only
+        run: make test-integration
       - name: Stop running images
         run: make sandbox-dev-stop
 

.gitignore

@@ -102,6 +102,7 @@ celerybeat-schedule
 *.sage.py
 
 # Environments
+_env
 .env
 .venv
 env/
@@ -138,3 +139,6 @@ dmypy.json
 
 # mac OS
 .DS_Store
+
+# asdf
+.tool-versions

Makefile

@@ -40,8 +40,7 @@ black:
 flake8:
 	flake8 $(ALLPY)
 
-# TODO: add `tests` to $MYPY when graviton respects mypy (version 🐗) 
-MYPY = pyteal scripts
+MYPY = pyteal scripts tests
 mypy:
 	mypy $(MYPY)
 
@@ -55,9 +54,9 @@ test-unit:
 	pytest -n $(NUM_PROCS) --durations=10 -sv pyteal tests/unit --ignore tests/unit/blackbox_test.py --ignore tests/unit/user_guide_test.py
 	pytest -n 1 -sv tests/unit/blackbox_test.py tests/unit/user_guide_test.py
 
-build-and-test: check-generate-init lint test-unit
+lint-and-test: check-generate-init lint test-unit
 
-# ---- Integration Test (algod required) ---- #
+# ---- Integration Tests (algod required) ---- #
 
 sandbox-dev-up:
 	docker-compose up -d algod
@@ -70,7 +69,7 @@ integration-run:
 
 test-integration: integration-run
 
-all-tests: build-and-test test-integration
+all-tests: lint-and-test test-integration
 
 # ---- Local Github Actions Simulation via `act` ---- #
 # assumes act is installed, e.g. via `brew install act`

pyteal/ast/abi/__init__.py

@@ -36,7 +36,12 @@
 from pyteal.ast.abi.array_dynamic import DynamicArrayTypeSpec, DynamicArray
 
 from pyteal.ast.abi.method_return import MethodReturn
-from pyteal.ast.abi.util import type_spec_from_annotation, make
+from pyteal.ast.abi.util import (
+    algosdk_from_annotation,
+    algosdk_from_type_spec,
+    make,
+    type_spec_from_annotation,
+)
 
 __all__ = [
     "String",
@@ -81,4 +86,6 @@
     "MethodReturn",
     "type_spec_from_annotation",
     "make",
+    "algosdk_from_annotation",
+    "algosdk_from_type_spec",
 ]

pyteal/ast/abi/address.py

@@ -27,6 +27,9 @@ def __init__(self) -> None:
     def new_instance(self) -> "Address":
         return Address()
 
+    def annotation_type(self) -> "type[Address]":
+        return Address
+
     def __str__(self) -> str:
         return "address"
 

pyteal/ast/abi/address_test.py

@@ -21,6 +21,10 @@ def test_AddressTypeSpec_byte_length_static():
     assert (abi.AddressTypeSpec()).byte_length_static() == abi.AddressLength.Bytes
 
 
+def test_AddressTypeSpec_length_static():
+    assert (abi.AddressTypeSpec()).length_static() == abi.AddressLength.Bytes
+
+
 def test_AddressTypeSpec_new_instance():
     assert isinstance(abi.AddressTypeSpec().new_instance(), abi.Address)
 

pyteal/ast/abi/array_dynamic.py

@@ -22,6 +22,9 @@ class DynamicArrayTypeSpec(ArrayTypeSpec[T]):
     def new_instance(self) -> "DynamicArray[T]":
         return DynamicArray(self)
 
+    def annotation_type(self) -> "type[DynamicArray[T]]":
+        return DynamicArray[self.value_type_spec().annotation_type()]  # type: ignore[misc]
+
     def is_length_dynamic(self) -> bool:
         return True
 

pyteal/ast/abi/array_static.py

@@ -1,11 +1,4 @@
-from typing import (
-    Union,
-    Sequence,
-    TypeVar,
-    Generic,
-    Final,
-    cast,
-)
+from typing import Final, Generic, Literal, Sequence, TypeVar, Union, cast
 
 from pyteal.errors import TealInputError
 from pyteal.ast.expr import Expr
@@ -25,11 +18,18 @@ def __init__(self, value_type_spec: TypeSpec, array_length: int) -> None:
         super().__init__(value_type_spec)
         if not isinstance(array_length, int) or array_length < 0:
             raise TypeError(f"Unsupported StaticArray length: {array_length}")
-        self.array_length: Final = array_length
+
+        # Casts to `int` to handle downstream usage where value is a subclass of int like `IntEnum`.
+        self.array_length: Final = int(array_length)
 
     def new_instance(self) -> "StaticArray[T, N]":
         return StaticArray(self)
 
+    def annotation_type(self) -> "type[StaticArray[T, N]]":
+        return StaticArray[  # type: ignore[misc]
+            self.value_spec.annotation_type(), Literal[self.array_length]  # type: ignore
+        ]
+
     def length_static(self) -> int:
         """Get the size of this static array type.
 

pyteal/ast/abi/bool.py

@@ -17,6 +17,9 @@ class BoolTypeSpec(TypeSpec):
     def new_instance(self) -> "Bool":
         return Bool()
 
+    def annotation_type(self) -> "type[Bool]":
+        return Bool
+
     def is_dynamic(self) -> bool:
         # Only accurate if this value is alone, since up to 8 consecutive bools will fit into a single byte
         return False

pyteal/ast/abi/string.py

@@ -29,6 +29,9 @@ def __init__(self) -> None:
     def new_instance(self) -> "String":
         return String()
 
+    def annotation_type(self) -> "type[String]":
+        return String
+
     def __str__(self) -> str:
         return "string"
 

pyteal/ast/abi/tuple.py

@@ -220,6 +220,33 @@ def length_static(self) -> int:
     def new_instance(self) -> "Tuple":
         return Tuple(self)
 
+    def annotation_type(self) -> "type[Tuple]":
+        vtses = self.value_type_specs()
+
+        def annotater():
+            return [x.annotation_type() for x in vtses]
+
+        match len(vtses):
+            case 0:
+                return Tuple0
+            case 1:
+                v0 = annotater()[0]
+                return Tuple1[v0]  # type: ignore[valid-type]
+            case 2:
+                v0, v1 = annotater()
+                return Tuple2[v0, v1]  # type: ignore[valid-type]
+            case 3:
+                v0, v1, v2 = annotater()
+                return Tuple3[v0, v1, v2]  # type: ignore[valid-type]
+            case 4:
+                v0, v1, v2, v3 = annotater()
+                return Tuple4[v0, v1, v2, v3]  # type: ignore[valid-type]
+            case 5:
+                v0, v1, v2, v3, v4 = annotater()
+                return Tuple5[v0, v1, v2, v3, v4]  # type: ignore[valid-type]
+
+        raise TypeError(f"Cannot annotate tuple of length {len(vtses)}")
+
     def is_dynamic(self) -> bool:
         return any(type_spec.is_dynamic() for type_spec in self.value_type_specs())
 
@@ -243,8 +270,7 @@ def __str__(self) -> str:
 
 TupleTypeSpec.__module__ = "pyteal"
 
-
-T = TypeVar("T", bound="Tuple")
+T_tuple = TypeVar("T_tuple", bound="Tuple")
 
 
 class Tuple(BaseType):
@@ -272,7 +298,7 @@ def set(self, *values: BaseType) -> Expr:
         ...
 
     @overload
-    def set(self: T, value: ComputedValue[T]) -> Expr:
+    def set(self: T_tuple, value: ComputedValue[T_tuple]) -> Expr:
         ...
 
     def set(self, *values):
@@ -307,8 +333,10 @@ def __getitem__(self, index: int) -> "TupleElement":
 
 Tuple.__module__ = "pyteal"
 
+T = TypeVar("T", bound=BaseType)
+
 
-class TupleElement(ComputedValue[BaseType]):
+class TupleElement(ComputedValue[T]):
     """Represents the extraction of a specific element from a Tuple."""
 
     def __init__(self, tuple: Tuple, index: int) -> None:
@@ -319,7 +347,7 @@ def __init__(self, tuple: Tuple, index: int) -> None:
     def produced_type_spec(self) -> TypeSpec:
         return self.tuple.type_spec().value_type_specs()[self.index]
 
-    def store_into(self, output: BaseType) -> Expr:
+    def store_into(self, output: T) -> Expr:
         return indexTuple(
             self.tuple.type_spec().value_type_specs(),
             self.tuple.encode(),

pyteal/ast/abi/type.py

@@ -19,6 +19,11 @@ def new_instance(self) -> "BaseType":
         """Create a new instance of the specified type."""
         pass
 
+    @abstractmethod
+    def annotation_type(self) -> "type[BaseType]":
+        """Get the annotation type associated with this spec"""
+        pass
+
     @abstractmethod
     def is_dynamic(self) -> bool:
         """Check if this ABI type is dynamic.

pyteal/ast/abi/uint.py

@@ -123,6 +123,10 @@ def __init__(self, bit_size: int) -> None:
     def new_instance(self) -> "Uint":
         pass
 
+    @abstractmethod
+    def annotation_type(self) -> "type[Uint]":
+        pass
+
     def bit_size(self) -> int:
         """Get the bit size of this uint type"""
         return self.size
@@ -157,6 +161,9 @@ def __init__(self) -> None:
     def new_instance(self) -> "Byte":
         return Byte()
 
+    def annotation_type(self) -> "type[Byte]":
+        return Byte
+
     def __str__(self) -> str:
         return "byte"
 
@@ -171,6 +178,9 @@ def __init__(self) -> None:
     def new_instance(self) -> "Uint8":
         return Uint8()
 
+    def annotation_type(self) -> "type[Uint8]":
+        return Uint8
+
 
 Uint8TypeSpec.__module__ = "pyteal"
 
@@ -182,6 +192,9 @@ def __init__(self) -> None:
     def new_instance(self) -> "Uint16":
         return Uint16()
 
+    def annotation_type(self) -> "type[Uint16]":
+        return Uint16
+
 
 Uint16TypeSpec.__module__ = "pyteal"
 
@@ -193,6 +206,9 @@ def __init__(self) -> None:
     def new_instance(self) -> "Uint32":
         return Uint32()
 
+    def annotation_type(self) -> "type[Uint32]":
+        return Uint32
+
 
 Uint32TypeSpec.__module__ = "pyteal"
 
@@ -204,6 +220,9 @@ def __init__(self) -> None:
     def new_instance(self) -> "Uint64":
         return Uint64()
 
+    def annotation_type(self) -> "type[Uint64]":
+        return Uint64
+
 
 Uint32TypeSpec.__module__ = "pyteal"
 

pyteal/ast/abi/util.py

@@ -1,5 +1,7 @@
 from typing import TypeVar, Any, Literal, get_origin, get_args, cast
 
+import algosdk.abi
+
 from pyteal.errors import TealInputError
 from pyteal.ast.expr import Expr
 from pyteal.ast.int import Int
@@ -232,3 +234,11 @@ def make(t: type[T]) -> T:
         A new instance of the given type class.
     """
     return cast(T, type_spec_from_annotation(t).new_instance())
+
+
+def algosdk_from_type_spec(t: TypeSpec) -> algosdk.abi.ABIType:
+    return algosdk.abi.ABIType.from_string(str(t))
+
+
+def algosdk_from_annotation(t: type[T]) -> algosdk.abi.ABIType:
+    return algosdk_from_type_spec(type_spec_from_annotation(t))