feat: transaction revert + nondeterministic addresses (#62)

This pr adds a few important features:
- No randomness in address generation anymore. Addresses will be derived from a string representation of the argument name. And the argument name is guarantied to be unique by rust
- State of the contract (on-chain data, events) and account balances can be reverted when call fails. Works even in external multi call cases, when just a single contract reverted transaction, but others handled error and finished transaction.
- String representation of address linked to string tag (argument name) that can be used to create better error messages.

Resolves #32, resolves #27

Author: qalisander

CHANGELOG.md

@@ -9,6 +9,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- Fixed bug with invalid size of return data from external call #68
+- No randomness in address generation anymore.
+  Addresses will be derived from a string representation of the argument name #62
+- State of the contract (on-chain data, events) and account balances can be
+  reverted when call fails #62
+- String representation of address linked to a string tag (argument name),
+  that is used for error message formatting #62
+
 ### Changed (Breaking)
 
 ## [0.5.0] - 2025-03-05

crates/motsu-proc/src/test.rs

@@ -40,9 +40,9 @@ pub(crate) fn test(_attr: &TokenStream, input: TokenStream) -> TokenStream {
     });
 
     // Collect argument initializations.
-    let arg_inits = arg_binding_and_ty.iter().map(|(_arg_binding, arg_ty)| {
+    let arg_inits = arg_binding_and_ty.iter().map(|(arg_binding, arg_ty)| {
         quote! {
-            <#arg_ty>::random()
+            <#arg_ty as motsu::prelude::FromTag>::from_tag(stringify!(#arg_binding))
         }
     });
 

crates/motsu/README.md

@@ -33,6 +33,8 @@ mod tests {
 }
 ```
 
+### Sender and Value
+
 Function `Contract::sender()` is necessary to trigger call
 to a contract, and should accept an `Account` or `Address` as an argument.
 
@@ -65,9 +67,11 @@ fn pay_three_proxies(proxy: Contract<Proxy>, alice: Account) {
 }
 ```
 
+### External Calls
+
 Multiple external calls are supported in Motsu.
 Assuming `Proxy` is a contract that exposes (`#[public]`) function `call_proxy`,
-where it adds `one` to the passed argument and calls next `Proxy` contract 
+where it adds `one` to the passed argument and calls next `Proxy` contract
 at the address provided during initialization.
 The following test case can emulate a call chain of three `Proxy` contracts:
 
@@ -98,11 +102,39 @@ fn call_three_proxies(
 }
 ```
 
-It is possible to check emitted events by specific contract with 
+### Checking Events
+
+It is possible to check emitted events by specific contract with
 `Contract::emitted` method.
-And assert with `Contract::assert_emitted` that will print all matching 
+And assert with `Contract::assert_emitted` that will print all matching
 events in case of failed assertion.
 
+### Transaction Revert
+
+To revert a transaction in case of `Result::Err`, you should call one of
+the following functions:
+
+- `ResultExt::motsu_unwrap`
+- `ResultExt::motsu_unwrap_err`
+- `ResultExt::motsu_expect`
+- `ResultExt::motsu_expect_err`
+- `ResultExt::motsu_res`
+
+```rust, ignore
+const FOUR: U256 = uint!(4_U256);
+
+// If the argument is `FOUR`, the call should revert.
+let err = proxy.sender(alice).try_call_proxy(FOUR).motsu_unwrap_err();
+assert!(matches!(err, Error::ProxyError(_)));
+```
+
+Otherwise, the state of the contract including persistent storage, balances
+and emitted events won't be reverted in case of `Result::Err`.
+
+Panics in contract code are not handled as a revert and will fail the test.
+
+### Notes
+
 Annotating a test function that accepts no parameters will make
 `#[motsu::test]` behave the same as `#[test]`.