add resource encoding option with value as default

Author: boblat

src/_algopy_testing/context_helpers/txn_context.py

@@ -121,6 +121,7 @@ def defer_app_call(
                 arc4_signature=arc4_metadata.arc4_signature,
                 args=ordered_args,
                 allow_actions=allow_actions,
+                resource_encoding=arc4_metadata.resource_encoding,
             )
         # Handle bare methods
         else:
@@ -169,7 +170,7 @@ def create_group(
         new_group = TransactionGroup(
             txns=processed_gtxns,
             active_txn_index=active_txn_index,
-            active_txn_overrides=typing.cast(dict[str, typing.Any], active_txn_overrides),
+            active_txn_overrides=typing.cast("dict[str, typing.Any]", active_txn_overrides),
         )
         self._active_group = new_group
         try:

src/_algopy_testing/decorators/arc4.py

@@ -34,6 +34,8 @@
         ]
     )
 _CreateValues = typing.Literal["allow", "require", "disallow"]
+_ResourceEncoding = typing.Literal["index", "value"]
+_Direction = typing.Literal["input", "output"]
 ARC4_METADATA_ATTR = "arc4_metadata"
 
 
@@ -51,6 +53,7 @@ class MethodMetadata:
     create: _CreateValues
     allow_actions: Sequence[_AllowActions]
     arc4_signature: str | None = None
+    resource_encoding: _ResourceEncoding = "value"
 
     @property
     def is_create(self) -> bool:
@@ -145,6 +148,7 @@ def abimethod(  # noqa: PLR0913
     name: str | None = None,
     create: _CreateValues = "disallow",
     allow_actions: Sequence[_AllowActions] = ("NoOp",),
+    resource_encoding: _ResourceEncoding = "value",
     readonly: bool = False,
     default_args: Mapping[str, str | object] | None = None,
 ) -> Callable[[Callable[_P, _R]], Callable[_P, _R]] | Callable[_P, _R]:
@@ -160,13 +164,15 @@ def abimethod(  # noqa: PLR0913
             allow_actions=allow_actions,
             readonly=readonly,
             default_args=default_args,
+            resource_encoding=resource_encoding,
         )
 
     arc4_name = name or fn.__name__
     metadata = MethodMetadata(
         create=create,
         allow_actions=allow_actions,
-        arc4_signature=_generate_arc4_signature_from_fn(fn, arc4_name),
+        arc4_signature=_generate_arc4_signature_from_fn(fn, arc4_name, resource_encoding),
+        resource_encoding=resource_encoding,
     )
     set_arc4_metadata(fn, metadata)
 
@@ -187,6 +193,7 @@ def wrapper(*args: _P.args, **kwargs: _P.kwargs) -> _R:
             arc4_signature=metadata.arc4_signature,
             args=ordered_args,
             allow_actions=allow_actions,
+            resource_encoding=metadata.resource_encoding,
         )
         with context.txn._maybe_implicit_txn_group(txns):
             check_routing_conditions(app_id, metadata)
@@ -204,6 +211,7 @@ def create_abimethod_txns(
     arc4_signature: str,
     args: Sequence[object],
     allow_actions: Sequence[_AllowActions],
+    resource_encoding: _ResourceEncoding,
 ) -> list[algopy.gtxn.TransactionBase]:
     contract_app = lazy_context.ledger.get_app(app_id)
     txn_fields = get_active_txn_fields(contract_app, allow_actions)
@@ -215,6 +223,7 @@ def create_abimethod_txns(
         method_selector=method_selector,
         sender=txn_fields["sender"],
         app=contract_app,
+        resource_encoding=resource_encoding,
     )
     txn_fields.setdefault("accounts", txn_arrays.accounts)
     txn_fields.setdefault("assets", txn_arrays.assets)
@@ -273,11 +282,12 @@ class _TxnArrays:
     app_args: list[algopy.Bytes]
 
 
-def _extract_arrays_from_args(
+def _extract_arrays_from_args(  # noqa: PLR0912
     args: Sequence[object],
     method_selector: algopy.Bytes,
     app: algopy.Application,
     sender: algopy.Account,
+    resource_encoding: _ResourceEncoding,
 ) -> _TxnArrays:
     from _algopy_testing.serialize import native_to_arc4
 
@@ -291,14 +301,23 @@ def _extract_arrays_from_args(
             case _algopy_testing.gtxn.TransactionBase() as txn:
                 txns.append(txn)
             case _algopy_testing.Account() as acc:
-                app_args.append(_algopy_testing.arc4.UInt8(len(accounts)))
-                accounts.append(acc)
+                if resource_encoding == "index":
+                    app_args.append(_algopy_testing.arc4.UInt8(len(accounts)))
+                    accounts.append(acc)
+                else:
+                    app_args.append(native_to_arc4(acc))
             case _algopy_testing.Asset() as asset:
-                app_args.append(_algopy_testing.arc4.UInt8(len(assets)))
-                assets.append(asset)
+                if resource_encoding == "index":
+                    app_args.append(_algopy_testing.arc4.UInt8(len(assets)))
+                    assets.append(asset)
+                else:
+                    app_args.append(native_to_arc4(asset.id))
             case _algopy_testing.Application() as arg_app:
-                app_args.append(_algopy_testing.arc4.UInt8(len(apps)))
-                apps.append(arg_app)
+                if resource_encoding == "index":
+                    app_args.append(_algopy_testing.arc4.UInt8(len(apps)))
+                    apps.append(arg_app)
+                else:
+                    app_args.append(native_to_arc4(arg_app.id))
             case _ as maybe_native:
                 app_args.append(native_to_arc4(maybe_native))
     if len(app_args) > 15:
@@ -313,18 +332,29 @@ def _extract_arrays_from_args(
     )
 
 
-def _generate_arc4_signature_from_fn(fn: typing.Callable[_P, _R], arc4_name: str) -> str:
+def _generate_arc4_signature_from_fn(
+    fn: typing.Callable[_P, _R], arc4_name: str, resource_encoding: _ResourceEncoding
+) -> str:
     annotations = inspect.get_annotations(fn, eval_str=True).copy()
-    returns = algosdk.abi.Returns(_type_to_arc4(annotations.pop("return")))
+    returns = algosdk.abi.Returns(
+        _type_to_arc4(annotations.pop("return"), resource_encoding, "output")
+    )
     method = algosdk.abi.Method(
         name=arc4_name,
-        args=[algosdk.abi.Argument(_type_to_arc4(a)) for a in annotations.values()],
+        args=[
+            algosdk.abi.Argument(_type_to_arc4(a, resource_encoding, "input"))
+            for a in annotations.values()
+        ],
         returns=returns,
     )
     return method.get_signature()
 
 
-def _type_to_arc4(annotation: types.GenericAlias | type | None) -> str:  # noqa: PLR0911, PLR0912
+def _type_to_arc4(  # noqa: PLR0912 PLR0911
+    annotation: types.GenericAlias | type | None,
+    resource_encoding: _ResourceEncoding,
+    direction: _Direction,
+) -> str:
     from _algopy_testing.arc4 import _ABIEncoded
     from _algopy_testing.gtxn import Transaction, TransactionBase
     from _algopy_testing.models import Account, Application, Asset
@@ -340,7 +370,9 @@ def _type_to_arc4(annotation: types.GenericAlias | type | None) -> str:  # noqa:
         return "void"
 
     if isinstance(annotation, types.GenericAlias) and typing.get_origin(annotation) is tuple:
-        tuple_args = [_type_to_arc4(a) for a in typing.get_args(annotation)]
+        tuple_args = [
+            _type_to_arc4(a, resource_encoding, direction) for a in typing.get_args(annotation)
+        ]
         return f"({','.join(tuple_args)})"
 
     if not isinstance(annotation, type):
@@ -350,11 +382,11 @@ def _type_to_arc4(annotation: types.GenericAlias | type | None) -> str:  # noqa:
         annotation, Struct
     ):
         tuple_fields = list(inspect.get_annotations(annotation).values())
-        tuple_args = [_type_to_arc4(a) for a in tuple_fields]
+        tuple_args = [_type_to_arc4(a, resource_encoding, direction) for a in tuple_fields]
         return f"({','.join(tuple_args)})"
 
     if issubclass(annotation, Array | FixedArray | ImmutableArray | ImmutableFixedArray):
-        return f"{_type_to_arc4(annotation._element_type)}[]"
+        return f"{_type_to_arc4(annotation._element_type, resource_encoding, direction)}[]"
     # arc4 types
     if issubclass(annotation, _ABIEncoded):
         return annotation._type_info.arc4_name
@@ -365,11 +397,17 @@ def _type_to_arc4(annotation: types.GenericAlias | type | None) -> str:  # noqa:
         return annotation.type_enum.txn_name
     # reference types
     if issubclass(annotation, Account):
-        return "account"
+        if resource_encoding == "index" and direction == "input":
+            return "account"
+        return "address"
     if issubclass(annotation, Asset):
-        return "asset"
+        if resource_encoding == "index" and direction == "input":
+            return "asset"
+        return "uint64"
     if issubclass(annotation, Application):
-        return "application"
+        if resource_encoding == "index" and direction == "input":
+            return "application"
+        return "uint64"
     # native types
     if issubclass(annotation, UInt64):
         return "uint64"

tests/arc4/test_arc4_method_signature.py

@@ -369,3 +369,106 @@ def test_prepare_txns_with_complex(
     assert app_args[0] == arc4.arc4_signature(SignaturesContract.complex_sig)
     assert result[0].bytes == struct.another_struct.bytes
     assert result[1].bytes == struct.bytes
+
+
+def test_app_args_is_correct_with_index_resource_encoding(  # noqa: PLR0913
+    context: _algopy_testing.AlgopyTestContext,
+    localnet_creator_address: str,
+    other_app_id: int,
+    funded_account: str,
+    algorand: AlgorandClient,
+    get_avm_result: AVMInvoker,
+) -> None:
+    # arrange
+    contract = SignaturesContract()
+    contract.create()
+
+    asa_id = algorand.send.asset_create(
+        AssetCreateParams(
+            sender=localnet_creator_address,
+            total=123,
+        )
+    ).confirmation[
+        "asset-index"
+    ]  # type: ignore[call-overload]
+
+    # act
+    contract.echo_resource_by_index(
+        context.any.asset(total=algopy.UInt64(123)),
+        context.ledger.get_app(other_app_id),
+        context.ledger.get_account(funded_account),
+    )
+    result = get_avm_result(
+        "echo_resource_by_index",
+        asset=asa_id,
+        app=other_app_id,
+        acc=funded_account,
+    )
+
+    # assert
+    txn = context.txn.last_active
+    app_args = [txn.app_args(i) for i in range(int(txn.num_app_args))]
+    assert app_args == [
+        algosdk.abi.Method.from_signature(
+            "echo_resource_by_index(asset,application,account)(uint64,uint64,address)"
+        ).get_selector(),
+        b"\x00",
+        b"\x01",
+        b"\x01",
+    ]
+    assert app_args[0] == arc4.arc4_signature(SignaturesContract.echo_resource_by_index)
+
+    assert result == [asa_id, other_app_id, funded_account]
+
+
+def test_app_args_is_correct_with_value_resource_encoding(  # noqa: PLR0913
+    context: _algopy_testing.AlgopyTestContext,
+    localnet_creator_address: str,
+    other_app_id: int,
+    funded_account: str,
+    algorand: AlgorandClient,
+    get_avm_result: AVMInvoker,
+) -> None:
+    # arrange
+    contract = SignaturesContract()
+    contract.create()
+
+    asa_id = algorand.send.asset_create(
+        AssetCreateParams(
+            sender=localnet_creator_address,
+            total=123,
+        )
+    ).confirmation[
+        "asset-index"
+    ]  # type: ignore[call-overload]
+
+    asset = context.any.asset(asset_id=asa_id, total=algopy.UInt64(123))
+    app = context.ledger.get_app(other_app_id)
+    acc = context.ledger.get_account(funded_account)
+    # act
+    contract.echo_resource_by_value(
+        asset,
+        app,
+        acc,
+    )
+    result = get_avm_result(
+        "echo_resource_by_value",
+        asset=asa_id,
+        app=other_app_id,
+        acc=funded_account,
+    )
+
+    # assert
+    txn = context.txn.last_active
+    app_args = [txn.app_args(i) for i in range(int(txn.num_app_args))]
+    assert app_args == [
+        algosdk.abi.Method.from_signature(
+            "echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address)"
+        ).get_selector(),
+        asa_id.to_bytes(length=8),  # asset id as bytes
+        other_app_id.to_bytes(length=8),  # app id as bytes
+        context.ledger.get_account(funded_account).bytes,  # account address as bytes
+    ]
+    assert app_args[0] == arc4.arc4_signature(SignaturesContract.echo_resource_by_value)
+
+    assert result == [asset.id, app.id, acc]

tests/artifacts/Arc4ABIMethod/contract.py

@@ -51,14 +51,14 @@ def with_txn(self, value: arc4.String, pay: gtxn.PaymentTransaction, arr: UInt8A
         assert Txn.group_index == 1
         assert pay.amount == 123
 
-    @arc4.abimethod
+    @arc4.abimethod(resource_encoding="index")
     def with_asset(self, value: arc4.String, asset: Asset, arr: UInt8Array) -> None:
         assert value
         assert arr
         assert asset.total == 123
         assert Txn.assets(0) == asset
 
-    @arc4.abimethod
+    @arc4.abimethod(resource_encoding="index")
     def with_app(
         self, value: arc4.String, app: Application, app_id: arc4.UInt64, arr: UInt8Array
     ) -> None:
@@ -72,15 +72,15 @@ def with_app(
         assert app_txn.apps(1) == app
         assert Txn.applications(1) == app
 
-    @arc4.abimethod
+    @arc4.abimethod(resource_encoding="index")
     def with_acc(self, value: arc4.String, acc: Account, arr: UInt8Array) -> None:
         assert value
         assert arr
         assert acc.balance == acc.min_balance + 1234
         assert Txn.accounts(0) == Txn.sender
         assert Txn.accounts(1) == acc
 
-    @arc4.abimethod
+    @arc4.abimethod(resource_encoding="index")
     def complex_sig(
         self, struct1: MyStruct, txn: algopy.gtxn.Transaction, acc: Account, five: UInt8Array
     ) -> tuple[MyStructAlias, MyStruct]:
@@ -102,3 +102,31 @@ def complex_sig(
         assert five[0] == 5
 
         return struct1.another_struct.copy(), struct1.copy()
+
+    @arc4.abimethod(
+        resource_encoding="index",
+    )
+    def echo_resource_by_index(
+        self, asset: Asset, app: Application, acc: Account
+    ) -> tuple[Asset, Application, Account]:
+        asset_idx = op.btoi(Txn.application_args(1))
+        assert asset == Txn.assets(asset_idx), "expected asset to be passed by index"
+        app_idx = op.btoi(Txn.application_args(2))
+        assert app == Txn.applications(app_idx), "expected application to be passed by index"
+        acc_idx = op.btoi(Txn.application_args(3))
+        assert acc == Txn.accounts(acc_idx), "expected account to be passed by index"
+        return asset, app, acc
+
+    @arc4.abimethod(
+        resource_encoding="value",
+    )
+    def echo_resource_by_value(
+        self, asset: Asset, app: Application, acc: Account
+    ) -> tuple[Asset, Application, Account]:
+        asset_id = op.btoi(Txn.application_args(1))
+        assert asset.id == asset_id, "expected asset to be passed by value"
+        app_id = op.btoi(Txn.application_args(2))
+        assert app.id == app_id, "expected application to be passed by value"
+        address = Txn.application_args(3)
+        assert acc.bytes == address, "expected account to be passed by value"
+        return asset, app, acc