nit: could be done withoutmut.

let api_invoice_result = {
  for ts in ... {
     match {
     Ok(res) -> return Some(res)
  }
  None
}

The return clause works for the function instead of the scope unless the scope is converted to a lambda. I was thinking about break Some(res); syntax just like in some other languages but it does not work in rust.

If you want to avoid mut here, you still could use labelled blocks, e.g.:

let api_invoc_result = 'block: {
    for ts in ts.chain_arc(ctx.store()) {
        match ctx.state_manager.call(&message, Some(ts)) {
            Ok(res) => {
                break 'block res;
            }
            Err(e) => tracing::warn!(%e),
        }
    }
    return Err(anyhow::anyhow!("Call failed").into());
};

@elmattic Didn't know about this. This is great, thanks!

nit: return early on if, then there is no need for else.

Personally, I feel using early returns here is not Rustic given rust is expression-based

I guess it boils down to personal preference, however if .. else nesting here does not read very well.
Imagine if every if in this method would have an else. Non-blocking.

Looking at this more I'm thinking: why do we need Option for api_invoc_result? It would be much easier to use Result. Then there is no need for let Some..

Something like:

  for ... {
    match {
       Ok(res) -> return Ok(res)
    } 
  }
  return Err(err)

  and then just do `api_invoc_result?`
  

I don't think the return clause works this way. #4340 (comment)

Fixed.

It it actually possible for !api_invoc_result.error.is_empty when msg_rct is Some?

Logically yes, in practice, I'm not sure. I think it does not hurt to check both and make the logic look more robust

If you mean to pad on an EVM word boundary, you can use the EVM_WORD_LENGTH constant.

Fixed.

If you mean to return a zeroed EVM word, you could use the EVM_WORD_LENGTH constant.

Fixed.

The loop label here is unnecessary. Non-blocking.

Could you elaborate? I can compile the code without the loop label

error[E0571]: `break` with value from a `for` loop
    --> src/rpc/methods/eth.rs:1298:25
     |
1295 |             for ts in ts.chain_arc(ctx.store()) {
     |             ----------------------------------- you can't `break` with a value in a `for` loop
...
1298 |                         break res;
     |                         ^^^^^^^^^ can only break with a value inside `loop` or breakable block
     |
help: use `break` on its own without a value inside this `for` loop
     |
1298 |                         break;
     |                         ~~~~~