@goplausible/algorand-mcp 3.0.7

package/dist/resources/knowledge/taxonomy/puya:python:testing:docs:testing-guide:contract-testing.md

@@ -0,0 +1,225 @@
+# Smart Contract Testing
+
+This guide provides an overview of how to test smart contracts using the Algorand Python SDK (`algopy`). We will cover the basics of testing `ARC4Contract` and `Contract` classes, focusing on `abimethod` and `baremethod` decorators.
+
+![](https://mermaid.ink/img/pako:eNqVkrFugzAQhl_Fujnp1ImhEiJrJNREWeoOV9sNVsFG9iEVBd69R5w0JE2llsk2n7-7_-AAymsDGewDtpXYrqQT_GyKFwl5vfcBnRZlT5V3IjYYSCjvKKAiCa-JzXfrObyzgTqsxRpVZZ25YOX2nnRrIomCneZzpszLkllktu0f8ratrUKyjFsXCZ1K2gTH7i01_8dGUjOT_55YeLdUFVr3zRunf5b6R5hZoFnBq9cX72_Br_Cj8bl4vJCHaVucvowYxHk5Xg_sfPkY6SbbphDL5dMgQZu29n0U5DMJwzTVGyApySKZKFSNMXKVxPJYYAGNCQ1azX_VYboqgSrTcAcZLzWGDwnSjcxhR37TOwUZhc4sIPhuX0H2jnXkXddqrrCyyKNpTqfjF5m74B8?type=png)
+
+```{note}
+The code snippets showcasing the contract testing capabilities are using [pytest](https://docs.pytest.org/en/latest/) as the test framework. However, note that the `algorand-python-testing` package can be used with any other test framework that supports Python. `pytest` is used for demonstration purposes in this documentation.
+```
+
+```{testsetup}
+import algopy
+import algopy_testing
+from algopy_testing import algopy_testing_context
+
+# Create the context manager for snippets below
+ctx_manager = algopy_testing_context()
+
+# Enter the context
+context = ctx_manager.__enter__()
+```
+
+## `algopy.ARC4Contract`
+
+Subclasses of `algopy.ARC4Contract` are **required** to be instantiated with an active test context. As part of instantiation, the test context will automatically create a matching `algopy.Application` object instance.
+
+Within the class implementation, methods decorated with `algopy.arc4.abimethod` and `algopy.arc4.baremethod` will automatically assemble an `algopy.gtxn.ApplicationCallTransaction` transaction to emulate the AVM application call. This behavior can be overriden by setting the transaction group manually as part of test setup, this is done via implicit invocation of `algopy_testing.context.any_application()` _value generator_ (refer to [APIs](../apis.md) for more details).
+
+```{testcode}
+class SimpleVotingContract(algopy.ARC4Contract):
+    def __init__(self) -> None:
+        self.topic = algopy.GlobalState(algopy.Bytes(b"default_topic"), key="topic", description="Voting topic")
+        self.votes = algopy.GlobalState(
+            algopy.UInt64(0),
+            key="votes",
+            description="Votes for the option",
+        )
+        self.voted = algopy.LocalState(algopy.UInt64, key="voted", description="Tracks if an account has voted")
+
+    @algopy.arc4.abimethod(create="require")
+    def create(self, initial_topic: algopy.Bytes) -> None:
+        self.topic.value = initial_topic
+        self.votes.value = algopy.UInt64(0)
+
+    @algopy.arc4.abimethod
+    def vote(self) -> algopy.UInt64:
+        assert self.voted[algopy.Txn.sender] == algopy.UInt64(0), "Account has already voted"
+        self.votes.value += algopy.UInt64(1)
+        self.voted[algopy.Txn.sender] = algopy.UInt64(1)
+        return self.votes.value
+
+    @algopy.arc4.abimethod(readonly=True)
+    def get_votes(self) -> algopy.UInt64:
+        return self.votes.value
+
+    @algopy.arc4.abimethod
+    def change_topic(self, new_topic: algopy.Bytes) -> None:
+        assert algopy.Txn.sender == algopy.Txn.application_id.creator, "Only creator can change topic"
+        self.topic.value = new_topic
+        self.votes.value = algopy.UInt64(0)
+        # Reset user's vote (this is simplified per single user for the sake of example)
+        self.voted[algopy.Txn.sender] = algopy.UInt64(0)
+
+# Arrange
+initial_topic = algopy.Bytes(b"initial_topic")
+contract = SimpleVotingContract()
+contract.voted[context.default_sender] = algopy.UInt64(0)
+
+# Act - Create the contract
+contract.create(initial_topic)
+
+# Assert - Check initial state
+assert contract.topic.value == initial_topic
+assert contract.votes.value == algopy.UInt64(0)
+
+# Act - Vote
+# The method `.vote()` is decorated with `algopy.arc4.abimethod`, which means it will assemble a transaction to emulate the AVM application call
+result = contract.vote()
+
+# Assert - you can access the corresponding auto generated application call transaction via test context
+assert len(context.txn.last_group.txns) == 1
+
+# Assert - Note how local and global state are accessed via regular python instance attributes
+assert result == algopy.UInt64(1)
+assert contract.votes.value == algopy.UInt64(1)
+assert contract.voted[context.default_sender] == algopy.UInt64(1)
+
+# Act - Change topic
+new_topic = algopy.Bytes(b"new_topic")
+contract.change_topic(new_topic)
+
+# Assert - Check topic changed and votes reset
+assert contract.topic.value == new_topic
+assert contract.votes.value == algopy.UInt64(0)
+assert contract.voted[context.default_sender] == algopy.UInt64(0)
+
+# Act - Get votes (should be 0 after reset)
+votes = contract.get_votes()
+
+# Assert - Check votes
+assert votes == algopy.UInt64(0)
+
+```
+
+For more examples of tests using `algopy.ARC4Contract`, see the [examples](../examples.md) section.
+
+## `algopy.Contract``
+
+Subclasses of `algopy.Contract` are **required** to be instantiated with an active test context. As part of instantiation, the test context will automatically create a matching `algopy.Application` object instance. This behavior is identical to `algopy.ARC4Contract` class instances.
+
+Unlike `algopy.ARC4Contract`, `algopy.Contract` requires manual setup of the transaction context and explicit method calls. Alternatively, you can use `active_txn_overrides` to specify application arguments and foreign arrays without needing to create a full transaction group if your aim is to patch a specific active transaction related metadata.
+
+Here's an updated example demonstrating how to test a `Contract` class:
+
+```{testcode}
+import algopy
+import pytest
+from algopy_testing import AlgopyTestContext, algopy_testing_context
+
+class CounterContract(algopy.Contract):
+    def __init__(self):
+        self.counter = algopy.UInt64(0)
+
+    @algopy.subroutine
+    def increment(self):
+        self.counter += algopy.UInt64(1)
+        return algopy.UInt64(1)
+
+    @algopy.arc4.baremethod
+    def approval_program(self):
+        return self.increment()
+
+    @algopy.arc4.baremethod
+    def clear_state_program(self):
+        return algopy.UInt64(1)
+
+@pytest.fixture()
+def context():
+    with algopy_testing_context() as ctx:
+        yield ctx
+
+def test_counter_contract(context: AlgopyTestContext):
+    # Instantiate contract
+    contract = CounterContract()
+
+    # Set up the transaction context using active_txn_overrides
+    with context.txn.create_group(
+        active_txn_overrides={
+            "sender": context.default_sender,
+            "app_args": [algopy.Bytes(b"increment")],
+        }
+    ):
+        # Invoke approval program
+        result = contract.approval_program()
+
+        # Assert approval program result
+        assert result == algopy.UInt64(1)
+
+        # Assert counter value
+        assert contract.counter == algopy.UInt64(1)
+
+    # Test clear state program
+    assert contract.clear_state_program() == algopy.UInt64(1)
+
+def test_counter_contract_multiple_txns(context: AlgopyTestContext):
+    contract = CounterContract()
+
+    # For scenarios with multiple transactions, you can still use gtxns
+    extra_payment = context.any.txn.payment()
+
+    with context.txn.create_group(
+        gtxns=[
+            extra_payment,
+            context.any.txn.application_call(
+                sender=context.default_sender,
+                app_id=contract.app_id,
+                app_args=[algopy.Bytes(b"increment")],
+            ),
+        ],
+        active_txn_index=1  # Set the application call as the active transaction
+    ):
+        result = contract.approval_program()
+
+        assert result == algopy.UInt64(1)
+        assert contract.counter == algopy.UInt64(1)
+
+    assert len(context.txn.last_group.txns) == 2
+```
+
+In this updated example:
+
+1. We use `context.txn.create_group()` with `active_txn_overrides` to set up the transaction context for a single application call. This simplifies the process when you don't need to specify a full transaction group.
+
+2. The `active_txn_overrides` parameter allows you to specify `app_args` and other transaction fields directly, without creating a full `ApplicationCallTransaction` object.
+
+3. For scenarios involving multiple transactions, you can still use the `gtxns` parameter to create a transaction group, as shown in the `test_counter_contract_multiple_txns` function.
+
+4. The `app_id` is automatically set to the contract's application ID, so you don't need to specify it explicitly when using `active_txn_overrides`.
+
+This approach provides more flexibility in setting up the transaction context for testing `Contract` classes, allowing for both simple single-transaction scenarios and more complex multi-transaction tests.
+
+## Defer contract method invocation
+
+You can create deferred application calls for more complex testing scenarios where order of transactions needs to be controlled:
+
+```python
+def test_deferred_call(context):
+    contract = MyARC4Contract()
+
+    extra_payment = context.any.txn.payment()
+    extra_asset_transfer = context.any.txn.asset_transfer()
+    implicit_payment = context.any.txn.payment()
+    deferred_call = context.txn.defer_app_call(contract.some_method, implicit_payment)
+
+    with context.txn.create_group([extra_payment, deferred_call, extra_asset_transfer]):
+        result = deferred_call.submit()
+
+    print(context.txn.last_group) # [extra_payment, implicit_payment, app call, extra_asset_transfer]
+```
+
+A deferred application call prepares the application call transaction without immediately executing it. The call can be executed later by invoking the `.submit()` method on the deferred application call instance. As demonstrated in the example, you can also include the deferred call in a transaction group creation context manager to execute it as part of a larger transaction group. When `.submit()` is called, only the specific method passed to `defer_app_call()` will be executed.
+
+```{testcleanup}
+ctx_manager.__exit__(None, None, None)
+```

package/dist/resources/knowledge/taxonomy/puya:python:testing:docs:testing-guide:index.md

@@ -0,0 +1,67 @@
+# Testing Guide
+
+The Algorand Python Testing framework provides powerful tools for testing Algorand Python smart contracts within a Python interpreter. This guide covers the main features and concepts of the framework, helping you write effective tests for your Algorand applications.
+
+```{note}
+For all code examples in the _Testing Guide_ section, assume `context` is an instance of `AlgopyTestContext` obtained using the `algopy_testing_context()` context manager. All subsequent code is executed within this context.
+```
+
+```{mermaid}
+graph TD
+    subgraph GA["Your Development Environment"]
+        A["algopy (type stubs)"]
+        B["algopy_testing (testing framework)<br>(You are here 📍)"]
+        C["puya (compiler)"]
+    end
+
+    subgraph GB["Your Algorand Project"]
+        D[Your Algorand Python contract]
+    end
+
+    D -->|type hints inferred from| A
+    D -->|compiled using| C
+    D -->|tested via| B
+```
+
+> _High-level overview of the relationship between your smart contracts project, Algorand Python Testing framework, Algorand Python type stubs, and the compiler_
+
+The Algorand Python Testing framework streamlines unit testing of your Algorand Python smart contracts by offering functionality to:
+
+1. Simulate the Algorand Virtual Machine (AVM) environment
+2. Create and manipulate test accounts, assets, applications, transactions, and ARC4 types
+3. Test smart contract classes, including their states, variables, and methods
+4. Verify logic signatures and subroutines
+5. Manage global state, local state, scratch slots, and boxes in test contexts
+6. Simulate transactions and transaction groups, including inner transactions
+7. Verify opcode behavior
+
+By using this framework, you can ensure your Algorand Python smart contracts function correctly before deploying them to a live network.
+
+Key features of the framework include:
+
+-   `AlgopyTestContext`: The main entry point for testing, providing access to various testing utilities and simulated blockchain state
+-   AVM Type Simulation: Accurate representations of AVM types like `UInt64` and `Bytes`
+-   ARC4 Support: Tools for testing ARC4 contracts and methods, including struct definitions and ABI encoding/decoding
+-   Transaction Simulation: Ability to create and execute various transaction types
+-   State Management: Tools for managing and verifying global and local state changes
+-   Opcode Simulation: Implementations of AVM opcodes for accurate smart contract behavior testing
+
+The framework is designed to work seamlessly with Algorand Python smart contracts, allowing developers to write comprehensive unit tests that closely mimic the behavior of contracts on the Algorand blockchain.
+
+## Table of Contents
+
+```{toctree}
+---
+maxdepth: 3
+---
+
+concepts
+avm-types
+arc4-types
+transactions
+contract-testing
+signature-testing
+state-management
+subroutines
+opcodes
+```

package/dist/resources/knowledge/taxonomy/puya:python:testing:docs:testing-guide:opcodes.md

@@ -0,0 +1,382 @@
+# AVM Opcodes
+
+The [coverage](coverage.md) file provides a comprehensive list of all opcodes and their respective types, categorized as _Mockable_, _Emulated_, or _Native_ within the `algorand-python-testing` package. This section highlights a **subset** of opcodes and types that typically require interaction with the test context manager.
+
+`Native` opcodes are assumed to function as they do in the Algorand Virtual Machine, given their stateless nature. If you encounter issues with any `Native` opcodes, please raise an issue in the [`algorand-python-testing` repo](https://github.com/algorandfoundation/algorand-python-testing/issues/new/choose) or contribute a PR following the [Contributing](https://github.com/algorandfoundation/algorand-python-testing/blob/main/CONTRIBUTING.md) guide.
+
+```{testsetup}
+import algopy
+from algopy_testing import algopy_testing_context
+
+# Create the context manager for snippets below
+ctx_manager = algopy_testing_context()
+
+# Enter the context
+context = ctx_manager.__enter__()
+```
+
+## Implemented Types
+
+These types are fully implemented in Python and behave identically to their AVM counterparts:
+
+### 1. Cryptographic Operations
+
+The following opcodes are demonstrated:
+
+-   `op.sha256`
+-   `op.keccak256`
+-   `op.ecdsa_verify`
+
+```{testcode}
+from algopy import op
+
+# SHA256 hash
+data = algopy.Bytes(b"Hello, World!")
+hashed = op.sha256(data)
+
+# Keccak256 hash
+keccak_hashed = op.keccak256(data)
+
+# ECDSA verification
+message_hash = bytes.fromhex("f809fd0aa0bb0f20b354c6b2f86ea751957a4e262a546bd716f34f69b9516ae1")
+sig_r = bytes.fromhex("18d96c7cda4bc14d06277534681ded8a94828eb731d8b842e0da8105408c83cf")
+sig_s = bytes.fromhex("7d33c61acf39cbb7a1d51c7126f1718116179adebd31618c4604a1f03b5c274a")
+pubkey_x = bytes.fromhex("f8140e3b2b92f7cbdc8196bc6baa9ce86cf15c18e8ad0145d50824e6fa890264")
+pubkey_y = bytes.fromhex("bd437b75d6f1db67155a95a0da4b41f2b6b3dc5d42f7db56238449e404a6c0a3")
+
+result = op.ecdsa_verify(op.ECDSA.Secp256r1, message_hash, sig_r, sig_s, pubkey_x, pubkey_y)
+assert result
+```
+
+### 2. Arithmetic and Bitwise Operations
+
+The following opcodes are demonstrated:
+
+-   `op.addw`
+-   `op.bitlen`
+-   `op.getbit`
+-   `op.setbit_uint64`
+
+```{testcode}
+from algopy import op
+
+# Addition with carry
+result, carry = op.addw(algopy.UInt64(2**63), algopy.UInt64(2**63))
+
+# Bitwise operations
+value = algopy.UInt64(42)
+bit_length = op.bitlen(value)
+is_bit_set = op.getbit(value, 3)
+new_value = op.setbit_uint64(value, 2, 1)
+```
+
+For a comprehensive list of all opcodes and types, refer to the [coverage](../coverage.md) page.
+
+## Emulated Types Requiring Transaction Context
+
+These types necessitate interaction with the transaction context:
+
+### algopy.op.Global
+
+```{testcode}
+from algopy import op
+
+class MyContract(algopy.ARC4Contract):
+    @algopy.arc4.abimethod
+    def check_globals(self) -> algopy.UInt64:
+        return op.Global.min_txn_fee + op.Global.min_balance
+
+... # setup context (below assumes available under 'ctx' variable)
+
+context.ledger.patch_global_fields(
+    min_txn_fee=algopy.UInt64(1000),
+    min_balance=algopy.UInt64(100000)
+)
+
+contract = MyContract()
+result = contract.check_globals()
+assert result == algopy.UInt64(101000)
+```
+
+### algopy.op.Txn
+
+```{testcode}
+from algopy import op
+
+class MyContract(algopy.ARC4Contract):
+    @algopy.arc4.abimethod
+    def check_txn_fields(self) -> algopy.arc4.Address:
+        return algopy.arc4.Address(op.Txn.sender)
+
+... # setup context (below assumes available under 'ctx' variable)
+
+contract = MyContract()
+custom_sender = context.any.account()
+with context.txn.create_group(active_txn_overrides={"sender": custom_sender}):
+    result = contract.check_txn_fields()
+assert result == custom_sender
+```
+
+### algopy.op.AssetHoldingGet
+
+```{testcode}
+from algopy import op
+
+class AssetContract(algopy.ARC4Contract):
+    @algopy.arc4.abimethod
+    def check_asset_holding(self, account: algopy.Account, asset: algopy.Asset) -> algopy.UInt64:
+        balance, _ = op.AssetHoldingGet.asset_balance(account, asset)
+        return balance
+
+... # setup context (below assumes available under 'ctx' variable)
+
+asset = context.any.asset(total=algopy.UInt64(1000000))
+account = context.any.account(opted_asset_balances={asset.id: algopy.UInt64(5000)})
+contract = AssetContract()
+result = contract.check_asset_holding(account, asset)
+assert result == algopy.UInt64(5000)
+```
+
+### algopy.op.AppGlobal
+
+```{testcode}
+from algopy import op
+
+class StateContract(algopy.ARC4Contract):
+    @algopy.arc4.abimethod
+    def set_and_get_state(self, key: algopy.Bytes, value: algopy.UInt64) -> algopy.UInt64:
+        op.AppGlobal.put(key, value)
+        return op.AppGlobal.get_uint64(key)
+
+... # setup context (below assumes available under 'ctx' variable)
+
+contract = StateContract()
+key, value = algopy.Bytes(b"test_key"), algopy.UInt64(42)
+result = contract.set_and_get_state(key, value)
+assert result == value
+stored_value = context.ledger.get_global_state(contract, key)
+assert stored_value == 42
+```
+
+### algopy.op.Block
+
+```{testcode}
+from algopy import op
+
+class BlockInfoContract(algopy.ARC4Contract):
+    @algopy.arc4.abimethod
+    def get_block_seed(self) -> algopy.Bytes:
+        return op.Block.blk_seed(1000)
+
+... # setup context (below assumes available under 'ctx' variable)
+
+context.ledger.set_block(1000, seed=123456, timestamp=1625097600)
+contract = BlockInfoContract()
+seed = contract.get_block_seed()
+assert seed == algopy.op.itob(123456)
+```
+
+### algopy.op.AcctParamsGet
+
+```{testcode}
+from algopy import op
+
+class AccountParamsContract(algopy.ARC4Contract):
+    @algopy.arc4.abimethod
+    def get_account_balance(self, account: algopy.Account) -> algopy.UInt64:
+        balance, exists = op.AcctParamsGet.acct_balance(account)
+        assert exists
+        return balance
+
+... # setup context (below assumes available under 'ctx' variable)
+
+account = context.any.account(balance=algopy.UInt64(1000000))
+contract = AccountParamsContract()
+balance = contract.get_account_balance(account)
+assert balance == algopy.UInt64(1000000)
+```
+
+### algopy.op.AppParamsGet
+
+```{testcode}
+class AppParamsContract(algopy.ARC4Contract):
+    @algopy.arc4.abimethod
+    def get_app_creator(self, app_id: algopy.Application) -> algopy.arc4.Address:
+        creator, exists = algopy.op.AppParamsGet.app_creator(app_id)
+        assert exists
+        return algopy.arc4.Address(creator)
+
+... # setup context (below assumes available under 'ctx' variable)
+
+contract = AppParamsContract()
+app = context.any.application()
+creator = contract.get_app_creator(app)
+assert creator == context.default_sender
+```
+
+### algopy.op.AssetParamsGet
+
+```{testcode}
+from algopy import op
+
+class AssetParamsContract(algopy.ARC4Contract):
+    @algopy.arc4.abimethod
+    def get_asset_total(self, asset_id: algopy.UInt64) -> algopy.UInt64:
+        total, exists = op.AssetParamsGet.asset_total(asset_id)
+        assert exists
+        return total
+
+... # setup context (below assumes available under 'ctx' variable)
+
+asset = context.any.asset(total=algopy.UInt64(1000000), decimals=algopy.UInt64(6))
+contract = AssetParamsContract()
+total = contract.get_asset_total(asset.id)
+assert total == algopy.UInt64(1000000)
+```
+
+### algopy.op.Box
+
+```{testcode}
+from algopy import op
+
+class BoxStorageContract(algopy.ARC4Contract):
+    @algopy.arc4.abimethod
+    def store_and_retrieve(self, key: algopy.Bytes, value: algopy.Bytes) -> algopy.Bytes:
+        op.Box.put(key, value)
+        retrieved_value, exists = op.Box.get(key)
+        assert exists
+        return retrieved_value
+
+... # setup context (below assumes available under 'ctx' variable)
+
+contract = BoxStorageContract()
+key, value = algopy.Bytes(b"test_key"), algopy.Bytes(b"test_value")
+result = contract.store_and_retrieve(key, value)
+assert result == value
+stored_value = context.ledger.get_box(contract, key)
+assert stored_value == value.value
+```
+
+## Mockable Opcodes
+
+These opcodes are mockable in `algorand-python-testing`, allowing for controlled testing of complex operations:
+
+### algopy.compile_contract
+
+```{testcode}
+from unittest.mock import patch, MagicMock
+import algopy
+
+mocked_response = MagicMock()
+mocked_response.local_bytes = algopy.UInt64(4)
+
+class MockContract(algopy.Contract):
+    ...
+
+class ContractFactory(algopy.ARC4Contract):
+    ...
+
+    @algopy.arc4.abimethod
+    def compile_and_get_bytes(self) -> algopy.UInt64:
+        contract_response = algopy.compile_contract(MockContract)
+        return contract_response.local_bytes
+
+... # setup context (below assumes available under 'ctx' variable)
+
+contract = ContractFactory()
+with patch('algopy.compile_contract', return_value=mocked_response):
+    assert contract.compile_and_get_bytes() == 4
+```
+
+### algopy.arc4.abi_call
+
+```{testcode}
+import unittest
+from unittest.mock import patch, MagicMock
+import algopy
+import typing
+
+class MockAbiCall:
+    def __call__(
+        self, *args: typing.Any, **_kwargs: typing.Any
+    ) -> tuple[typing.Any, typing.Any]:
+        return (
+            algopy.arc4.UInt64(11),
+            MagicMock(),
+        )
+
+    def __getitem__(self, _item: object) -> typing.Self:
+        return self
+
+class MyContract(algopy.ARC4Contract):
+    @algopy.arc4.abimethod
+    def my_method(self, arg1: algopy.UInt64, arg2: algopy.UInt64) -> algopy.UInt64:
+        return algopy.arc4.abi_call[algopy.arc4.UInt64]("my_other_method", arg1, arg2)[0].native
+
+... # setup context (below assumes available under 'ctx' variable)
+
+contract = MyContract()
+with patch('algopy.arc4.abi_call', MockAbiCall()):
+    result = contract.my_method(algopy.UInt64(10), algopy.UInt64(1))
+assert result == 11
+```
+
+### algopy.op.vrf_verify
+
+```{testcode}
+from unittest.mock import patch, MagicMock
+import algopy
+
+def test_mock_vrf_verify():
+    mock_result = (algopy.Bytes(b'mock_output'), True)
+    with patch('algopy.op.vrf_verify', return_value=mock_result) as mock_vrf_verify:
+        result = algopy.op.vrf_verify(
+            algopy.op.VrfVerify.VrfAlgorand,
+            algopy.Bytes(b'proof'),
+            algopy.Bytes(b'message'),
+            algopy.Bytes(b'public_key')
+        )
+    assert result == mock_result
+    mock_vrf_verify.assert_called_once_with(
+        algopy.op.VrfVerify.VrfAlgorand,
+        algopy.Bytes(b'proof'),
+        algopy.Bytes(b'message'),
+        algopy.Bytes(b'public_key')
+    )
+
+test_mock_vrf_verify()
+```
+
+### algopy.op.EllipticCurve
+
+```{testcode}
+from unittest.mock import patch, MagicMock
+import algopy
+
+def test_mock_elliptic_curve_decompress():
+    mock_result = (algopy.Bytes(b'x_coord'), algopy.Bytes(b'y_coord'))
+    with patch('algopy.op.EllipticCurve.decompress', return_value=mock_result) as mock_decompress:
+        result = algopy.op.EllipticCurve.decompress(
+            algopy.op.EC.BN254g1,
+            algopy.Bytes(b'compressed_point')
+        )
+    assert result == mock_result
+    mock_decompress.assert_called_once_with(
+        algopy.op.EC.BN254g1,
+        algopy.Bytes(b'compressed_point')
+    )
+
+test_mock_elliptic_curve_decompress()
+```
+
+These examples demonstrate how to mock key mockable opcodes in `algorand-python-testing`. Use similar techniques (in your preferred testing framework) for other mockable opcodes like `algopy.compile_logicsig`, `algopy.arc4.arc4_create`, and `algopy.arc4.arc4_update`.
+
+Mocking these opcodes allows you to:
+
+1. Control complex operations' behavior not covered by _implemented_ and _emulated_ types.
+2. Test edge cases and error conditions.
+3. Isolate contract logic from external dependencies.
+
+```{testcleanup}
+ctx_manager.__exit__(None, None, None)
+```