Method call itxn

pyteal/__init__.pyi

@@ -132,6 +132,7 @@ __all__ = [
     "MIN_TEAL_VERSION",
     "MaybeValue",
     "MethodConfig",
+    "MethodReturn",
     "MethodSignature",
     "MinBalance",
     "Minus",

pyteal/ast/__init__.py

@@ -131,6 +131,9 @@
 from pyteal.ast.continue_ import Continue
 
 # misc
+
+from pyteal.ast.method_return import MethodReturn
+
 from pyteal.ast.scratch import (
     ScratchIndex,
     ScratchLoad,
@@ -305,4 +308,5 @@
     "EcdsaVerify",
     "EcdsaDecompress",
     "EcdsaRecover",
+    "MethodReturn",
 ]

pyteal/ast/abi/__init__.py

@@ -41,6 +41,8 @@
     AssetTypeSpec,
     Application,
     ApplicationTypeSpec,
+    ReferenceType,
+    ReferenceTypeSpec,
     ReferenceTypeSpecs,
 )
 from pyteal.ast.abi.transaction import (
@@ -60,7 +62,6 @@
     KeyRegisterTransactionTypeSpec,
     TransactionTypeSpecs,
 )
-from pyteal.ast.abi.method_return import MethodReturn
 from pyteal.ast.abi.util import (
     algosdk_from_annotation,
     algosdk_from_type_spec,
@@ -79,6 +80,8 @@
     "AssetTypeSpec",
     "Application",
     "ApplicationTypeSpec",
+    "ReferenceType",
+    "ReferenceTypeSpec",
     "ReferenceTypeSpecs",
     "Address",
     "AddressTypeSpec",
@@ -117,7 +120,6 @@
     "StaticArray",
     "DynamicArrayTypeSpec",
     "DynamicArray",
-    "MethodReturn",
     "Transaction",
     "TransactionTypeSpec",
     "PaymentTransaction",

pyteal/ast/abi/uint.py

@@ -91,20 +91,24 @@ def uint_decode(
     raise ValueError("Unsupported uint size: {}".format(size))
 
 
-def uint_encode(size: int, uintVar: ScratchVar) -> Expr:
+def uint_encode(size: int, uintVar: Expr | ScratchVar) -> Expr:
+
+    if isinstance(uintVar, ScratchVar):
+        uintVar = uintVar.load()
+
     if size > 64:
         raise NotImplementedError(
             "Uint operations have not yet been implemented for bit sizes larger than 64"
         )
 
     if size == 8:
-        return SetByte(Bytes(b"\x00"), Int(0), uintVar.load())
+        return SetByte(Bytes(b"\x00"), Int(0), uintVar)
     if size == 16:
-        return Suffix(Itob(uintVar.load()), Int(6))
+        return Suffix(Itob(uintVar), Int(6))
     if size == 32:
-        return Suffix(Itob(uintVar.load()), Int(4))
+        return Suffix(Itob(uintVar), Int(4))
     if size == 64:
-        return Itob(uintVar.load())
+        return Itob(uintVar)
 
     raise ValueError("Unsupported uint size: {}".format(size))
 

pyteal/ast/abi/util.py

@@ -1,4 +1,14 @@
-from typing import Sequence, TypeVar, Any, Literal, get_origin, get_args, cast
+from typing import (
+    Any,
+    Literal,
+    Optional,
+    Sequence,
+    TypeVar,
+    Union,
+    cast,
+    get_args,
+    get_origin,
+)
 
 import algosdk.abi
 
@@ -379,3 +389,91 @@ def algosdk_from_type_spec(t: TypeSpec) -> algosdk.abi.ABIType:
 
 def algosdk_from_annotation(t: type[T]) -> algosdk.abi.ABIType:
     return algosdk_from_type_spec(type_spec_from_annotation(t))
+
+
+def type_spec_from_algosdk(t: Union[algosdk.abi.ABIType, str]) -> TypeSpec:
+
+    from pyteal.ast.abi.reference_type import ReferenceTypeSpecs
+    from pyteal.ast.abi.transaction import TransactionTypeSpecs
+
+    from pyteal.ast.abi.array_dynamic import DynamicArrayTypeSpec
+    from pyteal.ast.abi.array_static import StaticArrayTypeSpec
+    from pyteal.ast.abi.tuple import TupleTypeSpec
+    from pyteal.ast.abi.bool import BoolTypeSpec
+    from pyteal.ast.abi.string import StringTypeSpec
+    from pyteal.ast.abi.address import AddressTypeSpec
+    from pyteal.ast.abi.uint import (
+        ByteTypeSpec,
+        Uint8TypeSpec,
+        Uint16TypeSpec,
+        Uint32TypeSpec,
+        Uint64TypeSpec,
+    )
+
+    match t:
+        # Currently reference and transaction types are only strings
+        case str():
+            if algosdk.abi.is_abi_reference_type(t):
+                ref_dict: dict[str, TypeSpec] = {
+                    str(rts): rts for rts in ReferenceTypeSpecs
+                }
+                if t in ref_dict:
+                    return ref_dict[t]
+                else:
+                    raise TealInputError(f"Invalid reference type: {t}")
+
+            elif algosdk.abi.is_abi_transaction_type(t):
+                txn_dict: dict[str, TypeSpec] = {
+                    str(tts): tts for tts in TransactionTypeSpecs
+                }
+                if t in txn_dict:
+                    return txn_dict[t]
+                else:
+                    raise TealInputError(f"Invalid transaction type: {t}")
+            else:
+                raise TealInputError(f"Invalid ABI type: {t}")
+
+        case algosdk.abi.ABIType():
+            match t:
+                case algosdk.abi.ArrayDynamicType():
+                    return DynamicArrayTypeSpec(type_spec_from_algosdk(t.child_type))
+                case algosdk.abi.ArrayStaticType():
+                    return StaticArrayTypeSpec(
+                        type_spec_from_algosdk(t.child_type), t.static_length
+                    )
+                case algosdk.abi.TupleType():
+                    return TupleTypeSpec(
+                        *[type_spec_from_algosdk(ct) for ct in t.child_types]
+                    )
+                case algosdk.abi.UintType():
+                    match t.bit_size:
+                        case 8:
+                            return Uint8TypeSpec()
+                        case 16:
+                            return Uint16TypeSpec()
+                        case 32:
+                            return Uint32TypeSpec()
+                        case 64:
+                            return Uint64TypeSpec()
+                case algosdk.abi.ByteType():
+                    return ByteTypeSpec()
+                case algosdk.abi.BoolType():
+                    return BoolTypeSpec()
+                case algosdk.abi.StringType():
+                    return StringTypeSpec()
+                case algosdk.abi.AddressType():
+                    return AddressTypeSpec()
+                case algosdk.abi.UfixedType():
+                    raise TealInputError("Ufixed not supported")
+
+    raise TealInputError(f"Invalid Type: {t}")
+
+
+def type_specs_from_signature(sig: str) -> tuple[list[TypeSpec], Optional[TypeSpec]]:
+    sdk_method = algosdk.abi.Method.from_signature(sig)
+
+    return_type = None
+    if sdk_method.returns.type != algosdk.abi.Returns.VOID:
+        return_type = type_spec_from_algosdk(sdk_method.returns.type)
+
+    return [type_spec_from_algosdk(arg.type) for arg in sdk_method.args], return_type

pyteal/ast/abi/util_test.py

@@ -9,7 +9,9 @@
 from pyteal.ast.abi.util import (
     substringForDecoding,
     int_literal_from_annotation,
+    type_spec_from_algosdk,
     type_spec_from_annotation,
+    type_specs_from_signature,
 )
 from pyteal.errors import TealInputError
 
@@ -552,6 +554,62 @@ def test_size_of():
     ),
 ]
 
+ABI_SIGNATURE_TYPESPEC_CASES = [
+    (
+        "check(uint64,uint64)uint64",
+        [abi.Uint64TypeSpec(), abi.Uint64TypeSpec()],
+        abi.Uint64TypeSpec(),
+    ),
+    (
+        "check(uint64[],uint64)uint64",
+        [abi.DynamicArrayTypeSpec(abi.Uint64TypeSpec()), abi.Uint64TypeSpec()],
+        abi.Uint64TypeSpec(),
+    ),
+    (
+        "check(uint64[5],uint64)uint64",
+        [abi.StaticArrayTypeSpec(abi.Uint64TypeSpec(), 5), abi.Uint64TypeSpec()],
+        abi.Uint64TypeSpec(),
+    ),
+    (
+        "check(uint64,uint64)uint64[]",
+        [abi.Uint64TypeSpec(), abi.Uint64TypeSpec()],
+        abi.DynamicArrayTypeSpec(abi.Uint64TypeSpec()),
+    ),
+    (
+        "check(uint64,uint64)uint64[5]",
+        [abi.Uint64TypeSpec(), abi.Uint64TypeSpec()],
+        abi.StaticArrayTypeSpec(abi.Uint64TypeSpec(), 5),
+    ),
+    (
+        "check((uint64,uint64),asset)string",
+        [
+            abi.TupleTypeSpec(abi.Uint64TypeSpec(), abi.Uint64TypeSpec()),
+            abi.AssetTypeSpec(),
+        ],
+        abi.StringTypeSpec(),
+    ),
+    (
+        "check(string,asset)(uint64,uint64)",
+        [abi.StringTypeSpec(), abi.AssetTypeSpec()],
+        abi.TupleTypeSpec(abi.Uint64TypeSpec(), abi.Uint64TypeSpec()),
+    ),
+    (
+        "check(account,asset,application)string",
+        [abi.AccountTypeSpec(), abi.AssetTypeSpec(), abi.ApplicationTypeSpec()],
+        abi.StringTypeSpec(),
+    ),
+    (
+        "check(pay,txn,appl)string",
+        [
+            abi.PaymentTransactionTypeSpec(),
+            abi.TransactionTypeSpec(),
+            abi.ApplicationCallTransactionTypeSpec(),
+        ],
+        abi.StringTypeSpec(),
+    ),
+    ("check(uint64,uint64)void", [abi.Uint64TypeSpec(), abi.Uint64TypeSpec()], None),
+]
+
 
 @pytest.mark.parametrize(
     "algosdk_abi, abi_string, pyteal_abi_ts, pyteal_abi", ABI_TRANSLATION_TEST_CASES
@@ -593,3 +651,18 @@ def test_abi_type_translation(algosdk_abi, abi_string, pyteal_abi_ts, pyteal_abi
     )
     assert algosdk_abi == abi.algosdk_from_type_spec(pyteal_abi_ts)
     assert algosdk_abi == abi.algosdk_from_annotation(pyteal_abi)
+
+
+@pytest.mark.parametrize("case", ABI_TRANSLATION_TEST_CASES)
+def test_sdk_abi_translation(case):
+    # Errors are strings in the 0th element
+    if type(case[0]) is str:
+        return
+    assert type_spec_from_algosdk(case[0]) == case[2]
+
+
+@pytest.mark.parametrize("sig_str, sig_args, sig_rets", ABI_SIGNATURE_TYPESPEC_CASES)
+def test_sdk_type_specs_from_signature(sig_str, sig_args, sig_rets):
+    args, ret = type_specs_from_signature(sig_str)
+    assert args == sig_args
+    assert ret == sig_rets