From 89cfe151c16bd9fb53ea5e09da84db0f4ac1f2a6 Mon Sep 17 00:00:00 2001 From: Daniel McGregor Date: Wed, 15 Oct 2025 15:34:01 +0800 Subject: [PATCH 1/7] test: add test for resource population of a box and app --- .../testing_app_puya/app_spec.arc32.json | 41 ++++++++++++++++--- tests/artifacts/testing_app_puya/contract.py | 24 ++++++++++- tests/transactions/test_resource_packing.py | 25 +++++++++++ 3 files changed, 84 insertions(+), 6 deletions(-) diff --git a/tests/artifacts/testing_app_puya/app_spec.arc32.json b/tests/artifacts/testing_app_puya/app_spec.arc32.json index d8518906..9a318013 100644 --- a/tests/artifacts/testing_app_puya/app_spec.arc32.json +++ b/tests/artifacts/testing_app_puya/app_spec.arc32.json @@ -44,16 +44,26 @@ ] } } + }, + "bootstrap_external_app()uint64": { + "call_config": { + "no_op": "CALL" + } + }, + "set_external_box()void": { + "call_config": { + "no_op": "CALL" + } } }, "source": { - "approval": "#pragma version 10

smart_contracts.hello_world3.contract.TestPuyaBoxes.approval_program:
    intcblock 1 0
    callsub __puya_arc4_router__
    return


// smart_contracts.hello_world3.contract.TestPuyaBoxes.__puya_arc4_router__() -> uint64:
__puya_arc4_router__:
    // smart_contracts/hello_world3/contract.py:11
    // class TestPuyaBoxes(ARC4Contract):
    proto 0 1
    txn NumAppArgs
    bz __puya_arc4_router___bare_routing@10
    pushbytess 0x202fa73a 0xdf7eea4a 0x3688ed2c 0x5d1720dd 0xf806665c 0x81d260e2 // method "set_box_bytes(string,byte[])void", method "set_box_str(string,string)void", method "set_box_int(string,uint32)void", method "set_box_int512(string,uint512)void", method "set_box_static(string,byte[4])void", method "set_struct(string,(string,uint64))void"
    txna ApplicationArgs 0
    match __puya_arc4_router___set_box_bytes_route@2 __puya_arc4_router___set_box_str_route@3 __puya_arc4_router___set_box_int_route@4 __puya_arc4_router___set_box_int512_route@5 __puya_arc4_router___set_box_static_route@6 __puya_arc4_router___set_struct_route@7
    intc_1 // 0
    retsub

__puya_arc4_router___set_box_bytes_route@2:
    // smart_contracts/hello_world3/contract.py:20
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // smart_contracts/hello_world3/contract.py:11
    // class TestPuyaBoxes(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    extract 2 0
    // smart_contracts/hello_world3/contract.py:20
    // @arc4.abimethod
    callsub set_box_bytes
    intc_0 // 1
    retsub

__puya_arc4_router___set_box_str_route@3:
    // smart_contracts/hello_world3/contract.py:24
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // smart_contracts/hello_world3/contract.py:11
    // class TestPuyaBoxes(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // smart_contracts/hello_world3/contract.py:24
    // @arc4.abimethod
    callsub set_box_str
    intc_0 // 1
    retsub

__puya_arc4_router___set_box_int_route@4:
    // smart_contracts/hello_world3/contract.py:28
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // smart_contracts/hello_world3/contract.py:11
    // class TestPuyaBoxes(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // smart_contracts/hello_world3/contract.py:28
    // @arc4.abimethod
    callsub set_box_int
    intc_0 // 1
    retsub

__puya_arc4_router___set_box_int512_route@5:
    // smart_contracts/hello_world3/contract.py:32
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // smart_contracts/hello_world3/contract.py:11
    // class TestPuyaBoxes(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // smart_contracts/hello_world3/contract.py:32
    // @arc4.abimethod
    callsub set_box_int512
    intc_0 // 1
    retsub

__puya_arc4_router___set_box_static_route@6:
    // smart_contracts/hello_world3/contract.py:36
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // smart_contracts/hello_world3/contract.py:11
    // class TestPuyaBoxes(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // smart_contracts/hello_world3/contract.py:36
    // @arc4.abimethod
    callsub set_box_static
    intc_0 // 1
    retsub

__puya_arc4_router___set_struct_route@7:
    // smart_contracts/hello_world3/contract.py:42
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // smart_contracts/hello_world3/contract.py:11
    // class TestPuyaBoxes(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // smart_contracts/hello_world3/contract.py:42
    // @arc4.abimethod()
    callsub set_struct
    intc_0 // 1
    retsub

__puya_arc4_router___bare_routing@10:
    // smart_contracts/hello_world3/contract.py:11
    // class TestPuyaBoxes(ARC4Contract):
    txn OnCompletion
    bnz __puya_arc4_router___after_if_else@14
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    retsub

__puya_arc4_router___after_if_else@14:
    // smart_contracts/hello_world3/contract.py:11
    // class TestPuyaBoxes(ARC4Contract):
    intc_1 // 0
    retsub


// smart_contracts.hello_world3.contract.TestPuyaBoxes.set_box_bytes(name: bytes, value: bytes) -> void:
set_box_bytes:
    // smart_contracts/hello_world3/contract.py:20-21
    // @arc4.abimethod
    // def set_box_bytes(self, name: arc4.String, value: Bytes) -> None:
    proto 2 0
    // smart_contracts/hello_world3/contract.py:22
    // self.box_bytes[name] = value
    pushbytes "box_bytes"
    frame_dig -2
    concat
    dup
    box_del
    pop
    frame_dig -1
    box_put
    retsub


// smart_contracts.hello_world3.contract.TestPuyaBoxes.set_box_str(name: bytes, value: bytes) -> void:
set_box_str:
    // smart_contracts/hello_world3/contract.py:24-25
    // @arc4.abimethod
    // def set_box_str(self, name: arc4.String, value: arc4.String) -> None:
    proto 2 0
    // smart_contracts/hello_world3/contract.py:26
    // self.box_str[name] = value
    pushbytes "box_str"
    frame_dig -2
    concat
    dup
    box_del
    pop
    frame_dig -1
    box_put
    retsub


// smart_contracts.hello_world3.contract.TestPuyaBoxes.set_box_int(name: bytes, value: bytes) -> void:
set_box_int:
    // smart_contracts/hello_world3/contract.py:28-29
    // @arc4.abimethod
    // def set_box_int(self, name: arc4.String, value: arc4.UInt32) -> None:
    proto 2 0
    // smart_contracts/hello_world3/contract.py:30
    // self.box_int[name] = value
    pushbytes "box_int"
    frame_dig -2
    concat
    frame_dig -1
    box_put
    retsub


// smart_contracts.hello_world3.contract.TestPuyaBoxes.set_box_int512(name: bytes, value: bytes) -> void:
set_box_int512:
    // smart_contracts/hello_world3/contract.py:32-33
    // @arc4.abimethod
    // def set_box_int512(self, name: arc4.String, value: arc4.UInt512) -> None:
    proto 2 0
    // smart_contracts/hello_world3/contract.py:34
    // self.box_int512[name] = value
    pushbytes "box_int512"
    frame_dig -2
    concat
    frame_dig -1
    box_put
    retsub


// smart_contracts.hello_world3.contract.TestPuyaBoxes.set_box_static(name: bytes, value: bytes) -> void:
set_box_static:
    // smart_contracts/hello_world3/contract.py:36-39
    // @arc4.abimethod
    // def set_box_static(
    //     self, name: arc4.String, value: arc4.StaticArray[arc4.Byte, Literal[4]]
    // ) -> None:
    proto 2 0
    // smart_contracts/hello_world3/contract.py:40
    // self.box_static[name] = value.copy()
    pushbytes "box_static"
    frame_dig -2
    concat
    frame_dig -1
    box_put
    retsub


// smart_contracts.hello_world3.contract.TestPuyaBoxes.set_struct(name: bytes, value: bytes) -> void:
set_struct:
    // smart_contracts/hello_world3/contract.py:42-43
    // @arc4.abimethod()
    // def set_struct(self, name: arc4.String, value: DummyStruct) -> None:
    proto 2 0
    // smart_contracts/hello_world3/contract.py:44
    // assert name.bytes == value.name.bytes, "Name must match id of struct"
    frame_dig -1
    intc_1 // 0
    extract_uint16
    frame_dig -1
    len
    frame_dig -1
    cover 2
    substring3
    frame_dig -2
    ==
    assert // Name must match id of struct
    // smart_contracts/hello_world3/contract.py:45
    // op.Box.put(name.bytes, value.bytes)
    frame_dig -2
    frame_dig -1
    box_put
    retsub
", - "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCgpzbWFydF9jb250cmFjdHMuaGVsbG9fd29ybGQzLmNvbnRyYWN0LlRlc3RQdXlhQm94ZXMuY2xlYXJfc3RhdGVfcHJvZ3JhbToKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K" + "approval": "#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 0 2 1 4
    bytecblock "external"
    txn ApplicationID
    bnz main_after_if_else@2
    // tests/artifacts/testing_app_puya/contract.py:27
    // self.external = Application(0)
    bytec_0 // "external"
    intc_0 // 0
    app_global_put

main_after_if_else@2:
    // tests/artifacts/testing_app_puya/contract.py:19
    // class TestPuyaBoxes(ARC4Contract):
    txn NumAppArgs
    bz main___algopy_default_create@17
    txn OnCompletion
    !
    assert // OnCompletion must be NoOp
    txn ApplicationID
    assert
    pushbytess 0x202fa73a 0xdf7eea4a 0x3688ed2c 0x5d1720dd 0xf806665c 0x81d260e2 0x2c278d4f 0xa54e202c // method "set_box_bytes(string,byte[])void", method "set_box_str(string,string)void", method "set_box_int(string,uint32)void", method "set_box_int512(string,uint512)void", method "set_box_static(string,byte[4])void", method "set_struct(string,(string,uint64))void", method "bootstrap_external_app()uint64", method "set_external_box()void"
    txna ApplicationArgs 0
    match set_box_bytes set_box_str set_box_int set_box_int512 set_box_static set_struct bootstrap_external_app set_external_box
    err

main___algopy_default_create@17:
    txn OnCompletion
    !
    txn ApplicationID
    !
    &&
    return // on error: OnCompletion must be NoOp && can only call when creating


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.set_box_bytes[routing]() -> void:
set_box_bytes:
    // tests/artifacts/testing_app_puya/contract.py:29
    // @arc4.abimethod
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    intc_1 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+utf8[])
    txna ApplicationArgs 2
    dup
    intc_0 // 0
    extract_uint16
    intc_1 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+uint8[])
    extract 2 0
    // tests/artifacts/testing_app_puya/contract.py:31
    // self.box_bytes[name] = value
    pushbytes "box_bytes"
    uncover 2
    concat
    dup
    box_del
    pop
    swap
    box_put
    // tests/artifacts/testing_app_puya/contract.py:29
    // @arc4.abimethod
    intc_2 // 1
    return


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.set_box_str[routing]() -> void:
set_box_str:
    // tests/artifacts/testing_app_puya/contract.py:33
    // @arc4.abimethod
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    intc_1 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+utf8[])
    txna ApplicationArgs 2
    dup
    intc_0 // 0
    extract_uint16
    intc_1 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+utf8[])
    // tests/artifacts/testing_app_puya/contract.py:35
    // self.box_str[name] = value
    pushbytes "box_str"
    uncover 2
    concat
    dup
    box_del
    pop
    swap
    box_put
    // tests/artifacts/testing_app_puya/contract.py:33
    // @arc4.abimethod
    intc_2 // 1
    return


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.set_box_int[routing]() -> void:
set_box_int:
    // tests/artifacts/testing_app_puya/contract.py:37
    // @arc4.abimethod
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    intc_1 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+utf8[])
    txna ApplicationArgs 2
    dup
    len
    intc_3 // 4
    ==
    assert // invalid number of bytes for uint32
    // tests/artifacts/testing_app_puya/contract.py:39
    // self.box_int[name] = value
    pushbytes "box_int"
    uncover 2
    concat
    swap
    box_put
    // tests/artifacts/testing_app_puya/contract.py:37
    // @arc4.abimethod
    intc_2 // 1
    return


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.set_box_int512[routing]() -> void:
set_box_int512:
    // tests/artifacts/testing_app_puya/contract.py:41
    // @arc4.abimethod
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    intc_1 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+utf8[])
    txna ApplicationArgs 2
    dup
    len
    pushint 64 // 64
    ==
    assert // invalid number of bytes for uint512
    // tests/artifacts/testing_app_puya/contract.py:43
    // self.box_int512[name] = value
    pushbytes "box_int512"
    uncover 2
    concat
    swap
    box_put
    // tests/artifacts/testing_app_puya/contract.py:41
    // @arc4.abimethod
    intc_2 // 1
    return


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.set_box_static[routing]() -> void:
set_box_static:
    // tests/artifacts/testing_app_puya/contract.py:45
    // @arc4.abimethod
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    intc_1 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+utf8[])
    txna ApplicationArgs 2
    dup
    len
    intc_3 // 4
    ==
    assert // invalid number of bytes for uint8[4]
    // tests/artifacts/testing_app_puya/contract.py:47
    // self.box_static[name] = value.copy()
    pushbytes "box_static"
    uncover 2
    concat
    swap
    box_put
    // tests/artifacts/testing_app_puya/contract.py:45
    // @arc4.abimethod
    intc_2 // 1
    return


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.set_struct[routing]() -> void:
set_struct:
    // tests/artifacts/testing_app_puya/contract.py:49
    // @arc4.abimethod()
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    intc_1 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+utf8[])
    txna ApplicationArgs 2
    // tests/artifacts/testing_app_puya/contract.py:51
    // assert name.bytes == value.name.bytes, "Name must match id of struct"
    dup
    intc_0 // 0
    extract_uint16
    dig 1
    len
    dig 2
    cover 2
    substring3
    dig 2
    ==
    assert // Name must match id of struct
    // tests/artifacts/testing_app_puya/contract.py:52
    // op.Box.put(name.bytes, value.bytes)
    box_put
    // tests/artifacts/testing_app_puya/contract.py:49
    // @arc4.abimethod()
    intc_2 // 1
    return


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.bootstrap_external_app[routing]() -> void:
bootstrap_external_app:
    // tests/artifacts/testing_app_puya/contract.py:56
    // self.external = arc4.arc4_create(External).created_app
    itxn_begin
    pushbytes base64(C4EBQw==)
    itxn_field ClearStateProgramPages
    pushbytes base64(CyYBA2JveDEbQQAYgARNPkPsNhoAjgEAAQAxGRQxGBBEQgAIMRkUMRgUEEMovEgogANmb2+/gQFD)
    itxn_field ApprovalProgramPages
    pushint 6 // appl
    itxn_field TypeEnum
    intc_0 // 0
    itxn_field Fee
    itxn_submit
    itxn CreatedApplicationID
    bytec_0 // "external"
    dig 1
    app_global_put
    // tests/artifacts/testing_app_puya/contract.py:54
    // @arc4.abimethod
    itob
    pushbytes 0x151f7c75
    swap
    concat
    log
    intc_2 // 1
    return


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.set_external_box[routing]() -> void:
set_external_box:
    // tests/artifacts/testing_app_puya/contract.py:61-64
    // arc4.abi_call(
    //     External.set_box,
    //     app_id=self.external,
    // )
    itxn_begin
    // tests/artifacts/testing_app_puya/contract.py:63
    // app_id=self.external,
    intc_0 // 0
    bytec_0 // "external"
    app_global_get_ex
    assert // check self.external exists
    itxn_field ApplicationID
    // tests/artifacts/testing_app_puya/contract.py:61-64
    // arc4.abi_call(
    //     External.set_box,
    //     app_id=self.external,
    // )
    pushbytes 0x4d3e43ec // method "set_box()void"
    itxn_field ApplicationArgs
    pushint 6 // appl
    itxn_field TypeEnum
    intc_0 // 0
    itxn_field Fee
    itxn_submit
    // tests/artifacts/testing_app_puya/contract.py:59
    // @arc4.abimethod
    intc_2 // 1
    return
", + "clear": "I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K" }, "state": { "global": { "num_byte_slices": 0, - "num_uints": 0 + "num_uints": 1 }, "local": { "num_byte_slices": 0, @@ -62,7 +72,12 @@ }, "schema": { "global": { - "declared": {}, + "declared": { + "external": { + "type": "uint64", + "key": "external" + } + }, "reserved": {} }, "local": { @@ -174,6 +189,22 @@ "returns": { "type": "void" } + }, + { + "name": "bootstrap_external_app", + "args": [], + "readonly": false, + "returns": { + "type": "uint64" + } + }, + { + "name": "set_external_box", + "args": [], + "readonly": false, + "returns": { + "type": "void" + } } ], "networks": {} @@ -181,4 +212,4 @@ "bare_call_config": { "no_op": "CREATE" } -} +} \ No newline at end of file diff --git a/tests/artifacts/testing_app_puya/contract.py b/tests/artifacts/testing_app_puya/contract.py index 7074dd6b..d2c22499 100644 --- a/tests/artifacts/testing_app_puya/contract.py +++ b/tests/artifacts/testing_app_puya/contract.py @@ -1,6 +1,6 @@ from typing import Literal -from algopy import ARC4Contract, BoxMap, Bytes, arc4, op +from algopy import Application, ARC4Contract, Box, BoxMap, Bytes, arc4, op class DummyStruct(arc4.Struct): @@ -8,6 +8,15 @@ class DummyStruct(arc4.Struct): id: arc4.UInt64 +class External(ARC4Contract): + def __init__(self) -> None: + self.box = Box(Bytes) + + @arc4.abimethod + def set_box(self) -> None: + self.box.value = Bytes(b"foo") + + class TestPuyaBoxes(ARC4Contract): def __init__(self) -> None: self.box_bytes = BoxMap(arc4.String, Bytes) @@ -16,6 +25,7 @@ def __init__(self) -> None: self.box_int = BoxMap(arc4.String, arc4.UInt32) self.box_int512 = BoxMap(arc4.String, arc4.UInt512) self.box_static = BoxMap(arc4.String, arc4.StaticArray[arc4.Byte, Literal[4]]) + self.external = Application(0) @arc4.abimethod def set_box_bytes(self, name: arc4.String, value: Bytes) -> None: @@ -41,3 +51,15 @@ def set_box_static(self, name: arc4.String, value: arc4.StaticArray[arc4.Byte, L def set_struct(self, name: arc4.String, value: DummyStruct) -> None: assert name.bytes == value.name.bytes, "Name must match id of struct" op.Box.put(name.bytes, value.bytes) + + @arc4.abimethod + def bootstrap_external_app(self) -> Application: + self.external = arc4.arc4_create(External).created_app + return self.external + + @arc4.abimethod + def set_external_box(self) -> None: + arc4.abi_call( + External.set_box, + app_id=self.external, + ) diff --git a/tests/transactions/test_resource_packing.py b/tests/transactions/test_resource_packing.py index e0f563cb..c3e3e516 100644 --- a/tests/transactions/test_resource_packing.py +++ b/tests/transactions/test_resource_packing.py @@ -428,3 +428,28 @@ def test_create_box_in_new_app(self, algorand: AlgorandClient, funded_account: S box_ref = result.transaction.application_call.boxes[0] if result.transaction.application_call.boxes else None assert box_ref is not None assert box_ref.app_index == 0 # type: ignore # noqa: PGH003 + + +def test_inner_txn_with_box(algorand: AlgorandClient, funded_account: SigningAccount) -> None: + spec = (Path(__file__).parent.parent / "artifacts" / "testing_app_puya" / "app_spec.arc32.json").read_text() + factory = algorand.client.get_app_factory( + app_spec=spec, + default_sender=funded_account.address, + ) + app_client, _ = factory.send.bare.create() + app_client.fund_app_account(FundAppAccountParams(amount=AlgoAmount.from_algo(1))) + result = app_client.send.call( + AppClientMethodCallParams(method="bootstrap_external_app", static_fee=AlgoAmount.from_micro_algo(3_000)) + ) + external_app_id = result.abi_return + assert isinstance(external_app_id, int), "expected app id" + external_app = algorand.app.get_by_id(external_app_id) + algorand.account.ensure_funded( + external_app.app_address, funded_account, min_spending_balance=AlgoAmount.from_algo(1) + ) + + app_client.send.call( + AppClientMethodCallParams(method="set_external_box", static_fee=AlgoAmount.from_micro_algo(2_000)) + ) + + assert algorand.app.get_box_value(external_app_id, "box") == b"foo" From 87a141ea50366266ca7e537ec96146359b1aeece Mon Sep 17 00:00:00 2001 From: Daniel McGregor Date: Wed, 15 Oct 2025 13:54:21 +0800 Subject: [PATCH 2/7] fix: add app id first when populating a box ref --- src/algokit_utils/transactions/transaction_composer.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/algokit_utils/transactions/transaction_composer.py b/src/algokit_utils/transactions/transaction_composer.py index 0f75f033..0b05e999 100644 --- a/src/algokit_utils/transactions/transaction_composer.py +++ b/src/algokit_utils/transactions/transaction_composer.py @@ -1041,13 +1041,15 @@ def is_appl_below_limit(t: TransactionWithSigner) -> bool: foreign_apps.append(app_id) app_txn.foreign_apps = foreign_apps elif ref_type == "box": + # ensure app_id is added before calling translate_box_reference + app_id = box_ref[0] + if app_id != 0: + foreign_apps = list(getattr(app_txn, "foreign_apps", []) or []) + foreign_apps.append(app_id) + app_txn.foreign_apps = foreign_apps boxes = list(getattr(app_txn, "boxes", []) or []) boxes.append(BoxReference.translate_box_reference(box_ref, app_txn.foreign_apps or [], app_txn.index)) # type: ignore[arg-type] app_txn.boxes = boxes - if box_ref[0] != 0: - foreign_apps = list(getattr(app_txn, "foreign_apps", []) or []) - foreign_apps.append(box_ref[0]) - app_txn.foreign_apps = foreign_apps elif ref_type == "asset": asset_id = int(cast(str | int, reference)) foreign_assets = list(getattr(app_txn, "foreign_assets", []) or []) From c934ed364247fd6968cb4b8b0f13b0c1f5489a00 Mon Sep 17 00:00:00 2001 From: Daniel McGregor Date: Wed, 15 Oct 2025 16:52:29 +0800 Subject: [PATCH 3/7] chore: ignore pip audit --- .github/workflows/check-python.yaml | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/.github/workflows/check-python.yaml b/.github/workflows/check-python.yaml index 1aab5125..7a3042ef 100644 --- a/.github/workflows/check-python.yaml +++ b/.github/workflows/check-python.yaml @@ -23,14 +23,16 @@ jobs: - name: Audit with pip-audit run: | + # GHSA-4xh5-x5gv-qwph is safe to ignore since we are using a python version that is not affected + # can remove once pip has fix # audit non dev dependencies, no exclusions - poetry export --without=dev > requirements.txt && poetry run pip-audit -r requirements.txt + poetry export --without=dev > requirements.txt && poetry run pip-audit -r requirements.txt --ignore-vuln GHSA-4xh5-x5gv-qwph # audit all dependencies, with exclusions. # If a vulnerability is found in a dev dependency without an available fix, # it can be temporarily ignored by adding --ignore-vuln e.g. # --ignore-vuln "GHSA-hcpj-qp55-gfph" # GitPython vulnerability, dev only dependency - poetry run pip-audit + poetry run pip-audit --ignore-vuln GHSA-4xh5-x5gv-qwph - name: Check formatting with Ruff run: | From 0239ca21155d939a88d080eca09cd6dd897be68a Mon Sep 17 00:00:00 2001 From: Daniel McGregor Date: Wed, 15 Oct 2025 17:25:55 +0800 Subject: [PATCH 4/7] test: add test for an error due to a rejection --- tests/applications/test_app_client.py | 65 +++++++++---------- .../testing_app_puya/app_spec.arc32.json | 28 +++++++- tests/artifacts/testing_app_puya/contract.py | 11 +++- 3 files changed, 67 insertions(+), 37 deletions(-) diff --git a/tests/applications/test_app_client.py b/tests/applications/test_app_client.py index 24637506..f88cde38 100644 --- a/tests/applications/test_app_client.py +++ b/tests/applications/test_app_client.py @@ -8,6 +8,7 @@ import pytest from algosdk.atomic_transaction_composer import TransactionSigner, TransactionWithSigner +from algokit_utils import SendParams from algokit_utils._legacy_v2.application_specification import ApplicationSpecification from algokit_utils.algorand import AlgorandClient from algokit_utils.applications.abi import ABIType @@ -166,45 +167,16 @@ def testing_app_puya_arc32_app_spec() -> ApplicationSpecification: return ApplicationSpecification.from_json(raw_json_spec.read_text()) -@pytest.fixture -def testing_app_puya_arc32_app_id( - algorand: AlgorandClient, funded_account: SigningAccount, testing_app_puya_arc32_app_spec: ApplicationSpecification -) -> int: - global_schema = testing_app_puya_arc32_app_spec.global_state_schema - local_schema = testing_app_puya_arc32_app_spec.local_state_schema - - response = algorand.send.app_create( - AppCreateParams( - sender=funded_account.address, - approval_program=testing_app_puya_arc32_app_spec.approval_program, - clear_state_program=testing_app_puya_arc32_app_spec.clear_program, - schema={ - "global_byte_slices": int(global_schema.num_byte_slices) if global_schema.num_byte_slices else 0, - "global_ints": int(global_schema.num_uints) if global_schema.num_uints else 0, - "local_byte_slices": int(local_schema.num_byte_slices) if local_schema.num_byte_slices else 0, - "local_ints": int(local_schema.num_uints) if local_schema.num_uints else 0, - }, - ) - ) - return response.app_id - - @pytest.fixture def test_app_client_puya( - algorand: AlgorandClient, - funded_account: SigningAccount, - testing_app_puya_arc32_app_spec: ApplicationSpecification, - testing_app_puya_arc32_app_id: int, + algorand: AlgorandClient, funded_account: SigningAccount, testing_app_puya_arc32_app_spec: ApplicationSpecification ) -> AppClient: - return AppClient( - AppClientParams( - default_sender=funded_account.address, - default_signer=funded_account.signer, - app_id=testing_app_puya_arc32_app_id, - algorand=algorand, - app_spec=testing_app_puya_arc32_app_spec, - ) + factory = algorand.client.get_app_factory( + app_spec=testing_app_puya_arc32_app_spec, + default_sender=funded_account.address, ) + app_client, _ = factory.send.bare.create() + return app_client def test_clone_overriding_default_sender_and_inheriting_app_name( @@ -709,6 +681,29 @@ def test_box_methods_with_arc4_returns_parametrized( assert abi_decoded_boxes[0].value == arg_value +@pytest.mark.parametrize( + "populate", + [ + True, + # False, # enable this test once rejected transactions contain pc information + ], +) +def test_txn_with_reject(test_app_client_puya: AppClient, *, populate: bool) -> None: + with pytest.raises(LogicError, match="expect this txn to be rejected"): + test_app_client_puya.send.call( + AppClientMethodCallParams(method="rejected"), send_params=SendParams(populate_app_call_resources=populate) + ) + + +@pytest.mark.parametrize("populate", [True, False]) +def test_txn_with_logic_err(test_app_client_puya: AppClient, *, populate: bool) -> None: + with pytest.raises(LogicError, match="expect this to be a logic err") as exc: + test_app_client_puya.send.call( + AppClientMethodCallParams(method="logic_err"), send_params=SendParams(populate_app_call_resources=populate) + ) + assert exc + + def test_abi_with_default_arg_method( algorand: AlgorandClient, funded_account: SigningAccount, diff --git a/tests/artifacts/testing_app_puya/app_spec.arc32.json b/tests/artifacts/testing_app_puya/app_spec.arc32.json index 9a318013..bb42312b 100644 --- a/tests/artifacts/testing_app_puya/app_spec.arc32.json +++ b/tests/artifacts/testing_app_puya/app_spec.arc32.json @@ -54,10 +54,20 @@ "call_config": { "no_op": "CALL" } + }, + "rejected()void": { + "call_config": { + "no_op": "CALL" + } + }, + "logic_err()bool": { + "call_config": { + "no_op": "CALL" + } } }, "source": { - "approval": "#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 0 2 1 4
    bytecblock "external"
    txn ApplicationID
    bnz main_after_if_else@2
    // tests/artifacts/testing_app_puya/contract.py:27
    // self.external = Application(0)
    bytec_0 // "external"
    intc_0 // 0
    app_global_put

main_after_if_else@2:
    // tests/artifacts/testing_app_puya/contract.py:19
    // class TestPuyaBoxes(ARC4Contract):
    txn NumAppArgs
    bz main___algopy_default_create@17
    txn OnCompletion
    !
    assert // OnCompletion must be NoOp
    txn ApplicationID
    assert
    pushbytess 0x202fa73a 0xdf7eea4a 0x3688ed2c 0x5d1720dd 0xf806665c 0x81d260e2 0x2c278d4f 0xa54e202c // method "set_box_bytes(string,byte[])void", method "set_box_str(string,string)void", method "set_box_int(string,uint32)void", method "set_box_int512(string,uint512)void", method "set_box_static(string,byte[4])void", method "set_struct(string,(string,uint64))void", method "bootstrap_external_app()uint64", method "set_external_box()void"
    txna ApplicationArgs 0
    match set_box_bytes set_box_str set_box_int set_box_int512 set_box_static set_struct bootstrap_external_app set_external_box
    err

main___algopy_default_create@17:
    txn OnCompletion
    !
    txn ApplicationID
    !
    &&
    return // on error: OnCompletion must be NoOp && can only call when creating


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.set_box_bytes[routing]() -> void:
set_box_bytes:
    // tests/artifacts/testing_app_puya/contract.py:29
    // @arc4.abimethod
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    intc_1 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+utf8[])
    txna ApplicationArgs 2
    dup
    intc_0 // 0
    extract_uint16
    intc_1 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+uint8[])
    extract 2 0
    // tests/artifacts/testing_app_puya/contract.py:31
    // self.box_bytes[name] = value
    pushbytes "box_bytes"
    uncover 2
    concat
    dup
    box_del
    pop
    swap
    box_put
    // tests/artifacts/testing_app_puya/contract.py:29
    // @arc4.abimethod
    intc_2 // 1
    return


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.set_box_str[routing]() -> void:
set_box_str:
    // tests/artifacts/testing_app_puya/contract.py:33
    // @arc4.abimethod
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    intc_1 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+utf8[])
    txna ApplicationArgs 2
    dup
    intc_0 // 0
    extract_uint16
    intc_1 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+utf8[])
    // tests/artifacts/testing_app_puya/contract.py:35
    // self.box_str[name] = value
    pushbytes "box_str"
    uncover 2
    concat
    dup
    box_del
    pop
    swap
    box_put
    // tests/artifacts/testing_app_puya/contract.py:33
    // @arc4.abimethod
    intc_2 // 1
    return


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.set_box_int[routing]() -> void:
set_box_int:
    // tests/artifacts/testing_app_puya/contract.py:37
    // @arc4.abimethod
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    intc_1 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+utf8[])
    txna ApplicationArgs 2
    dup
    len
    intc_3 // 4
    ==
    assert // invalid number of bytes for uint32
    // tests/artifacts/testing_app_puya/contract.py:39
    // self.box_int[name] = value
    pushbytes "box_int"
    uncover 2
    concat
    swap
    box_put
    // tests/artifacts/testing_app_puya/contract.py:37
    // @arc4.abimethod
    intc_2 // 1
    return


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.set_box_int512[routing]() -> void:
set_box_int512:
    // tests/artifacts/testing_app_puya/contract.py:41
    // @arc4.abimethod
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    intc_1 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+utf8[])
    txna ApplicationArgs 2
    dup
    len
    pushint 64 // 64
    ==
    assert // invalid number of bytes for uint512
    // tests/artifacts/testing_app_puya/contract.py:43
    // self.box_int512[name] = value
    pushbytes "box_int512"
    uncover 2
    concat
    swap
    box_put
    // tests/artifacts/testing_app_puya/contract.py:41
    // @arc4.abimethod
    intc_2 // 1
    return


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.set_box_static[routing]() -> void:
set_box_static:
    // tests/artifacts/testing_app_puya/contract.py:45
    // @arc4.abimethod
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    intc_1 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+utf8[])
    txna ApplicationArgs 2
    dup
    len
    intc_3 // 4
    ==
    assert // invalid number of bytes for uint8[4]
    // tests/artifacts/testing_app_puya/contract.py:47
    // self.box_static[name] = value.copy()
    pushbytes "box_static"
    uncover 2
    concat
    swap
    box_put
    // tests/artifacts/testing_app_puya/contract.py:45
    // @arc4.abimethod
    intc_2 // 1
    return


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.set_struct[routing]() -> void:
set_struct:
    // tests/artifacts/testing_app_puya/contract.py:49
    // @arc4.abimethod()
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    intc_1 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+utf8[])
    txna ApplicationArgs 2
    // tests/artifacts/testing_app_puya/contract.py:51
    // assert name.bytes == value.name.bytes, "Name must match id of struct"
    dup
    intc_0 // 0
    extract_uint16
    dig 1
    len
    dig 2
    cover 2
    substring3
    dig 2
    ==
    assert // Name must match id of struct
    // tests/artifacts/testing_app_puya/contract.py:52
    // op.Box.put(name.bytes, value.bytes)
    box_put
    // tests/artifacts/testing_app_puya/contract.py:49
    // @arc4.abimethod()
    intc_2 // 1
    return


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.bootstrap_external_app[routing]() -> void:
bootstrap_external_app:
    // tests/artifacts/testing_app_puya/contract.py:56
    // self.external = arc4.arc4_create(External).created_app
    itxn_begin
    pushbytes base64(C4EBQw==)
    itxn_field ClearStateProgramPages
    pushbytes base64(CyYBA2JveDEbQQAYgARNPkPsNhoAjgEAAQAxGRQxGBBEQgAIMRkUMRgUEEMovEgogANmb2+/gQFD)
    itxn_field ApprovalProgramPages
    pushint 6 // appl
    itxn_field TypeEnum
    intc_0 // 0
    itxn_field Fee
    itxn_submit
    itxn CreatedApplicationID
    bytec_0 // "external"
    dig 1
    app_global_put
    // tests/artifacts/testing_app_puya/contract.py:54
    // @arc4.abimethod
    itob
    pushbytes 0x151f7c75
    swap
    concat
    log
    intc_2 // 1
    return


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.set_external_box[routing]() -> void:
set_external_box:
    // tests/artifacts/testing_app_puya/contract.py:61-64
    // arc4.abi_call(
    //     External.set_box,
    //     app_id=self.external,
    // )
    itxn_begin
    // tests/artifacts/testing_app_puya/contract.py:63
    // app_id=self.external,
    intc_0 // 0
    bytec_0 // "external"
    app_global_get_ex
    assert // check self.external exists
    itxn_field ApplicationID
    // tests/artifacts/testing_app_puya/contract.py:61-64
    // arc4.abi_call(
    //     External.set_box,
    //     app_id=self.external,
    // )
    pushbytes 0x4d3e43ec // method "set_box()void"
    itxn_field ApplicationArgs
    pushint 6 // appl
    itxn_field TypeEnum
    intc_0 // 0
    itxn_field Fee
    itxn_submit
    // tests/artifacts/testing_app_puya/contract.py:59
    // @arc4.abimethod
    intc_2 // 1
    return
", + "approval": "#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 0 1 2 4
    bytecblock "external"
    txn ApplicationID
    bnz main_after_if_else@2
    // tests/artifacts/testing_app_puya/contract.py:28
    // self.external = Application(0)
    bytec_0 // "external"
    intc_0 // 0
    app_global_put

main_after_if_else@2:
    // tests/artifacts/testing_app_puya/contract.py:20
    // class TestPuyaBoxes(ARC4Contract):
    txn NumAppArgs
    bz main___algopy_default_create@19
    txn OnCompletion
    !
    assert // OnCompletion must be NoOp
    txn ApplicationID
    assert
    pushbytess 0x202fa73a 0xdf7eea4a 0x3688ed2c 0x5d1720dd 0xf806665c 0x81d260e2 0x2c278d4f 0xa54e202c 0xe4deb743 0xb180fbb5 // method "set_box_bytes(string,byte[])void", method "set_box_str(string,string)void", method "set_box_int(string,uint32)void", method "set_box_int512(string,uint512)void", method "set_box_static(string,byte[4])void", method "set_struct(string,(string,uint64))void", method "bootstrap_external_app()uint64", method "set_external_box()void", method "rejected()void", method "logic_err()bool"
    txna ApplicationArgs 0
    match set_box_bytes set_box_str set_box_int set_box_int512 set_box_static set_struct bootstrap_external_app set_external_box rejected logic_err
    err

main___algopy_default_create@19:
    txn OnCompletion
    !
    txn ApplicationID
    !
    &&
    return // on error: OnCompletion must be NoOp && can only call when creating


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.set_box_bytes[routing]() -> void:
set_box_bytes:
    // tests/artifacts/testing_app_puya/contract.py:30
    // @arc4.abimethod
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    intc_2 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+utf8[])
    txna ApplicationArgs 2
    dup
    intc_0 // 0
    extract_uint16
    intc_2 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+uint8[])
    extract 2 0
    // tests/artifacts/testing_app_puya/contract.py:32
    // self.box_bytes[name] = value
    pushbytes "box_bytes"
    uncover 2
    concat
    dup
    box_del
    pop
    swap
    box_put
    // tests/artifacts/testing_app_puya/contract.py:30
    // @arc4.abimethod
    intc_1 // 1
    return


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.set_box_str[routing]() -> void:
set_box_str:
    // tests/artifacts/testing_app_puya/contract.py:34
    // @arc4.abimethod
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    intc_2 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+utf8[])
    txna ApplicationArgs 2
    dup
    intc_0 // 0
    extract_uint16
    intc_2 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+utf8[])
    // tests/artifacts/testing_app_puya/contract.py:36
    // self.box_str[name] = value
    pushbytes "box_str"
    uncover 2
    concat
    dup
    box_del
    pop
    swap
    box_put
    // tests/artifacts/testing_app_puya/contract.py:34
    // @arc4.abimethod
    intc_1 // 1
    return


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.set_box_int[routing]() -> void:
set_box_int:
    // tests/artifacts/testing_app_puya/contract.py:38
    // @arc4.abimethod
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    intc_2 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+utf8[])
    txna ApplicationArgs 2
    dup
    len
    intc_3 // 4
    ==
    assert // invalid number of bytes for uint32
    // tests/artifacts/testing_app_puya/contract.py:40
    // self.box_int[name] = value
    pushbytes "box_int"
    uncover 2
    concat
    swap
    box_put
    // tests/artifacts/testing_app_puya/contract.py:38
    // @arc4.abimethod
    intc_1 // 1
    return


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.set_box_int512[routing]() -> void:
set_box_int512:
    // tests/artifacts/testing_app_puya/contract.py:42
    // @arc4.abimethod
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    intc_2 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+utf8[])
    txna ApplicationArgs 2
    dup
    len
    pushint 64 // 64
    ==
    assert // invalid number of bytes for uint512
    // tests/artifacts/testing_app_puya/contract.py:44
    // self.box_int512[name] = value
    pushbytes "box_int512"
    uncover 2
    concat
    swap
    box_put
    // tests/artifacts/testing_app_puya/contract.py:42
    // @arc4.abimethod
    intc_1 // 1
    return


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.set_box_static[routing]() -> void:
set_box_static:
    // tests/artifacts/testing_app_puya/contract.py:46
    // @arc4.abimethod
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    intc_2 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+utf8[])
    txna ApplicationArgs 2
    dup
    len
    intc_3 // 4
    ==
    assert // invalid number of bytes for uint8[4]
    // tests/artifacts/testing_app_puya/contract.py:48
    // self.box_static[name] = value.copy()
    pushbytes "box_static"
    uncover 2
    concat
    swap
    box_put
    // tests/artifacts/testing_app_puya/contract.py:46
    // @arc4.abimethod
    intc_1 // 1
    return


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.set_struct[routing]() -> void:
set_struct:
    // tests/artifacts/testing_app_puya/contract.py:50
    // @arc4.abimethod()
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    intc_2 // 2
    +
    dig 1
    len
    ==
    assert // invalid number of bytes for (len+utf8[])
    txna ApplicationArgs 2
    // tests/artifacts/testing_app_puya/contract.py:52
    // assert name.bytes == value.name.bytes, "Name must match id of struct"
    dup
    intc_0 // 0
    extract_uint16
    dig 1
    len
    dig 2
    cover 2
    substring3
    dig 2
    ==
    assert // Name must match id of struct
    // tests/artifacts/testing_app_puya/contract.py:53
    // op.Box.put(name.bytes, value.bytes)
    box_put
    // tests/artifacts/testing_app_puya/contract.py:50
    // @arc4.abimethod()
    intc_1 // 1
    return


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.bootstrap_external_app[routing]() -> void:
bootstrap_external_app:
    // tests/artifacts/testing_app_puya/contract.py:57
    // self.external = arc4.arc4_create(External).created_app
    itxn_begin
    pushbytes base64(C4EBQw==)
    itxn_field ClearStateProgramPages
    pushbytes base64(CyYBA2JveDEbQQAYgARNPkPsNhoAjgEAAQAxGRQxGBBEQgAIMRkUMRgUEEMovEgogANmb2+/gQFD)
    itxn_field ApprovalProgramPages
    pushint 6 // appl
    itxn_field TypeEnum
    intc_0 // 0
    itxn_field Fee
    itxn_submit
    itxn CreatedApplicationID
    bytec_0 // "external"
    dig 1
    app_global_put
    // tests/artifacts/testing_app_puya/contract.py:55
    // @arc4.abimethod
    itob
    pushbytes 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.set_external_box[routing]() -> void:
set_external_box:
    // tests/artifacts/testing_app_puya/contract.py:62-65
    // arc4.abi_call(
    //     External.set_box,
    //     app_id=self.external,
    // )
    itxn_begin
    // tests/artifacts/testing_app_puya/contract.py:64
    // app_id=self.external,
    intc_0 // 0
    bytec_0 // "external"
    app_global_get_ex
    assert // check self.external exists
    itxn_field ApplicationID
    // tests/artifacts/testing_app_puya/contract.py:62-65
    // arc4.abi_call(
    //     External.set_box,
    //     app_id=self.external,
    // )
    pushbytes 0x4d3e43ec // method "set_box()void"
    itxn_field ApplicationArgs
    pushint 6 // appl
    itxn_field TypeEnum
    intc_0 // 0
    itxn_field Fee
    itxn_submit
    // tests/artifacts/testing_app_puya/contract.py:60
    // @arc4.abimethod
    intc_1 // 1
    return


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.rejected[routing]() -> void:
rejected:
    // tests/artifacts/testing_app_puya/contract.py:69
    // assert Txn.num_app_args == 0, "expect this txn to be rejected"
    txn NumAppArgs
    !
    // tests/artifacts/testing_app_puya/contract.py:67
    // @arc4.abimethod
    return // on error: expect this txn to be rejected


// tests.artifacts.testing_app_puya.contract.TestPuyaBoxes.logic_err[routing]() -> void:
logic_err:
    // tests/artifacts/testing_app_puya/contract.py:73
    // assert Txn.num_app_args == 0, "expect this to be a logic err"
    txn NumAppArgs
    !
    assert // expect this to be a logic err
    // tests/artifacts/testing_app_puya/contract.py:71
    // @arc4.abimethod
    pushbytes 0x151f7c7580
    log
    intc_1 // 1
    return
", "clear": "I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K" }, "state": { @@ -205,6 +215,22 @@ "returns": { "type": "void" } + }, + { + "name": "rejected", + "args": [], + "readonly": false, + "returns": { + "type": "void" + } + }, + { + "name": "logic_err", + "args": [], + "readonly": false, + "returns": { + "type": "bool" + } } ], "networks": {} diff --git a/tests/artifacts/testing_app_puya/contract.py b/tests/artifacts/testing_app_puya/contract.py index d2c22499..631e4329 100644 --- a/tests/artifacts/testing_app_puya/contract.py +++ b/tests/artifacts/testing_app_puya/contract.py @@ -1,6 +1,6 @@ from typing import Literal -from algopy import Application, ARC4Contract, Box, BoxMap, Bytes, arc4, op +from algopy import Application, ARC4Contract, Box, BoxMap, Bytes, Txn, arc4, op class DummyStruct(arc4.Struct): @@ -63,3 +63,12 @@ def set_external_box(self) -> None: External.set_box, app_id=self.external, ) + + @arc4.abimethod + def rejected(self) -> None: + assert Txn.num_app_args == 0, "expect this txn to be rejected" + + @arc4.abimethod + def logic_err(self) -> bool: + assert Txn.num_app_args == 0, "expect this to be a logic err" + return True From 2aa9768b68601b2a3d830d0cd4b05f5b435f47fb Mon Sep 17 00:00:00 2001 From: Daniel McGregor Date: Wed, 15 Oct 2025 18:18:26 +0800 Subject: [PATCH 5/7] fix: extract pc from simulation trace for rejected transactions during simulation --- src/algokit_utils/errors/logic_error.py | 2 +- .../transactions/transaction_composer.py | 47 ++++++++++++++----- 2 files changed, 36 insertions(+), 13 deletions(-) diff --git a/src/algokit_utils/errors/logic_error.py b/src/algokit_utils/errors/logic_error.py index 755b89e4..42b19c20 100644 --- a/src/algokit_utils/errors/logic_error.py +++ b/src/algokit_utils/errors/logic_error.py @@ -20,7 +20,7 @@ LOGIC_ERROR = ( - ".*transaction (?P[A-Z0-9]+): logic eval error: (?P.*). Details: .*pc=(?P[0-9]+).*" + ".*transaction (?P[A-Z0-9]+): (logic eval error: )?(?P.*). Details: .*pc=(?P[0-9]+).*" ) diff --git a/src/algokit_utils/transactions/transaction_composer.py b/src/algokit_utils/transactions/transaction_composer.py index 0b05e999..57ab24a3 100644 --- a/src/algokit_utils/transactions/transaction_composer.py +++ b/src/algokit_utils/transactions/transaction_composer.py @@ -21,7 +21,7 @@ from algosdk.transaction import OnComplete, SuggestedParams from algosdk.v2client.algod import AlgodClient from algosdk.v2client.models.simulate_request import SimulateRequest -from typing_extensions import deprecated +from typing_extensions import Never, deprecated from algokit_utils.applications.abi import ABIReturn, ABIValue from algokit_utils.applications.app_manager import AppManager @@ -667,7 +667,7 @@ def _encode_lease(lease: str | bytes | None) -> bytes | None: raise TypeError(f"Unknown lease type received of {type(lease)}") -def _get_group_execution_info( # noqa: C901, PLR0912 +def _get_group_execution_info( # noqa: C901 atc: AtomicTransactionComposer, algod: AlgodClient, populate_app_call_resources: bool | None = None, @@ -682,6 +682,7 @@ def _get_group_execution_info( # noqa: C901, PLR0912 txn_groups=[], allow_unnamed_resources=True, allow_empty_signatures=True, + exec_trace_config=algosdk.v2client.models.SimulateTraceConfig(enable=True), ) # Clone ATC with null signers @@ -720,16 +721,8 @@ def _get_group_execution_info( # noqa: C901, PLR0912 group_response = result.simulate_response["txn-groups"][0] if group_response.get("failure-message"): - msg = group_response["failure-message"] - if cover_app_call_inner_transaction_fees and "fee too small" in msg: - raise ValueError( - "Fees were too small to resolve execution info via simulate. " - "You may need to increase an app call transaction maxFee." - ) - failed_at = group_response.get("failed-at", [0])[0] - raise ValueError( - f"Error resolving execution info via simulate in transaction {failed_at}: " - f"{group_response['failure-message']}" + _handle_simulation_error( + group_response, cover_app_call_inner_transaction_fees=cover_app_call_inner_transaction_fees ) # Build execution info @@ -782,6 +775,36 @@ def calculate_inner_fee_delta(inner_txns: list[dict], acc: int = 0) -> int: ) +def _handle_simulation_error( + group_response: dict[str, Any], *, cover_app_call_inner_transaction_fees: bool | None +) -> Never: + msg = group_response["failure-message"] + if cover_app_call_inner_transaction_fees and "fee too small" in msg: + raise ValueError( + "Fees were too small to resolve execution info via simulate. " + "You may need to increase an app call transaction maxFee." + ) + failed_at = group_response.get("failed-at", [0])[0] + details = "" + if "logic eval error" not in msg: + # extract last pc from trace so we can format an error that can be parsed into a LogicError + try: + trace = group_response["txn-results"][failed_at]["exec-trace"] + except (KeyError, IndexError): + pass + else: + try: + program_trace = trace["approval-program-trace"] + except KeyError: + program_trace = trace["clear-program-trace"] + pc = program_trace[-1]["pc"] + details = f". Details: pc={pc}" + raise ValueError( + f"Error resolving execution info via simulate in transaction {failed_at}: " + f"{group_response['failure-message']}{details}" + ) + + def _find_available_transaction_index( txns: list[TransactionWithSigner], reference_type: str, reference: str | dict[str, Any] | int ) -> int: From f23475b01a39ff429f2ef2561f219d0ca8a697b1 Mon Sep 17 00:00:00 2001 From: Daniel McGregor Date: Wed, 15 Oct 2025 19:12:14 +0800 Subject: [PATCH 6/7] refactor: extract method --- .../transactions/transaction_composer.py | 53 +++++++++++-------- 1 file changed, 31 insertions(+), 22 deletions(-) diff --git a/src/algokit_utils/transactions/transaction_composer.py b/src/algokit_utils/transactions/transaction_composer.py index 57ab24a3..2eacb9df 100644 --- a/src/algokit_utils/transactions/transaction_composer.py +++ b/src/algokit_utils/transactions/transaction_composer.py @@ -667,7 +667,7 @@ def _encode_lease(lease: str | bytes | None) -> bytes | None: raise TypeError(f"Unknown lease type received of {type(lease)}") -def _get_group_execution_info( # noqa: C901 +def _get_group_execution_info( atc: AtomicTransactionComposer, algod: AlgodClient, populate_app_call_resources: bool | None = None, @@ -736,27 +736,12 @@ def _get_group_execution_info( # noqa: C901 required_fee_delta = 0 if cover_app_call_inner_transaction_fees: - # Calculate parent transaction fee - parent_per_byte_fee = per_byte_txn_fee * (original_txn.estimate_size() + 75) - parent_min_fee = max(parent_per_byte_fee, min_txn_fee) - parent_fee_delta = parent_min_fee - original_txn.fee - - if isinstance(original_txn, algosdk.transaction.ApplicationCallTxn): - # Calculate inner transaction fees recursively - def calculate_inner_fee_delta(inner_txns: list[dict], acc: int = 0) -> int: - for inner_txn in reversed(inner_txns): - current_fee_delta = ( - calculate_inner_fee_delta(inner_txn["inner-txns"], acc) - if inner_txn.get("inner-txns") - else acc - ) + (min_txn_fee - inner_txn["txn"]["txn"].get("fee", 0)) - acc = max(0, current_fee_delta) - return acc - - inner_fee_delta = calculate_inner_fee_delta(txn_result.get("inner-txns", [])) - required_fee_delta = inner_fee_delta + parent_fee_delta - else: - required_fee_delta = parent_fee_delta + required_fee_delta = _calculate_required_fee_delta( + original_txn, + txn_result, + per_byte_txn_fee=per_byte_txn_fee, + min_txn_fee=min_txn_fee, + ) txn_results.append( ExecutionInfoTxn( @@ -805,6 +790,30 @@ def _handle_simulation_error( ) +def _calculate_required_fee_delta( + original_txn: transaction.Transaction, txn_result: dict[str, Any], *, per_byte_txn_fee: int, min_txn_fee: int +) -> int: + # Calculate parent transaction fee + parent_per_byte_fee = per_byte_txn_fee * (original_txn.estimate_size() + 75) + parent_min_fee = max(parent_per_byte_fee, min_txn_fee) + parent_fee_delta = parent_min_fee - original_txn.fee + + if isinstance(original_txn, algosdk.transaction.ApplicationCallTxn): + # Calculate inner transaction fees recursively + def calculate_inner_fee_delta(inner_txns: list[dict], acc: int = 0) -> int: + for inner_txn in reversed(inner_txns): + current_fee_delta = ( + calculate_inner_fee_delta(inner_txn["inner-txns"], acc) if inner_txn.get("inner-txns") else acc + ) + (min_txn_fee - inner_txn["txn"]["txn"].get("fee", 0)) + acc = max(0, current_fee_delta) + return acc + + inner_fee_delta = calculate_inner_fee_delta(txn_result.get("inner-txns", [])) + return inner_fee_delta + parent_fee_delta + else: + return parent_fee_delta + + def _find_available_transaction_index( txns: list[TransactionWithSigner], reference_type: str, reference: str | dict[str, Any] | int ) -> int: From 935b5f917a2f65618428be10df6bf4dbf8b0d5d0 Mon Sep 17 00:00:00 2001 From: Daniel McGregor Date: Wed, 15 Oct 2025 19:16:32 +0800 Subject: [PATCH 7/7] chore: remove type warnings and minor refactor --- .../transactions/transaction_composer.py | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/algokit_utils/transactions/transaction_composer.py b/src/algokit_utils/transactions/transaction_composer.py index 2eacb9df..b2e78332 100644 --- a/src/algokit_utils/transactions/transaction_composer.py +++ b/src/algokit_utils/transactions/transaction_composer.py @@ -711,10 +711,6 @@ def _get_group_execution_info( f"Required for transactions: {', '.join(str(i) for i in app_call_indexes_without_max_fees)}" ) - # Get fee parameters - per_byte_txn_fee = suggested_params.fee if suggested_params else 0 - min_txn_fee = int(suggested_params.min_fee) if suggested_params else 1000 # type: ignore[unused-ignore] - # Simulate transactions result = empty_signer_atc.simulate(algod, simulate_request) @@ -739,8 +735,8 @@ def _get_group_execution_info( required_fee_delta = _calculate_required_fee_delta( original_txn, txn_result, - per_byte_txn_fee=per_byte_txn_fee, - min_txn_fee=min_txn_fee, + per_byte_txn_fee=suggested_params.fee if suggested_params else 0, + min_txn_fee=int(suggested_params.min_fee) if suggested_params else 1000, ) txn_results.append( @@ -791,14 +787,18 @@ def _handle_simulation_error( def _calculate_required_fee_delta( - original_txn: transaction.Transaction, txn_result: dict[str, Any], *, per_byte_txn_fee: int, min_txn_fee: int + txn: transaction.Transaction, txn_result: dict[str, Any], *, per_byte_txn_fee: int, min_txn_fee: int ) -> int: # Calculate parent transaction fee - parent_per_byte_fee = per_byte_txn_fee * (original_txn.estimate_size() + 75) + original_txn_size = txn.estimate_size() + assert isinstance(original_txn_size, int), "expected txn size to be an int" + parent_per_byte_fee = per_byte_txn_fee * (original_txn_size + 75) parent_min_fee = max(parent_per_byte_fee, min_txn_fee) - parent_fee_delta = parent_min_fee - original_txn.fee + original_txn_fee = txn.fee + assert isinstance(original_txn_fee, int), "expected original txn fee to be an int" + parent_fee_delta = parent_min_fee - original_txn_fee - if isinstance(original_txn, algosdk.transaction.ApplicationCallTxn): + if isinstance(txn, algosdk.transaction.ApplicationCallTxn): # Calculate inner transaction fees recursively def calculate_inner_fee_delta(inner_txns: list[dict], acc: int = 0) -> int: for inner_txn in reversed(inner_txns):