/// Test the `Address::static` convenience method: typed STATICCALLs that

/// forward all gas, plus revert-data bubbling on failure.

use std::evm::{Ctx, Evm, encode_msg_calldata, decode_returndata, last_returndata}

msg ViewMsg {

#[selector = sol("getValue()")]

GetValue -> u256,

#[selector = sol("getOwner()")]

GetOwner -> Address,

#[selector = sol("boom()")]

Boom -> u256,

}

pub contract Viewer {

init() {}

recv ViewMsg {

GetValue -> u256 {

1234

}

GetOwner -> Address {

Address { inner: 0xbeef }

}

Boom -> u256 {

let sentinel: u256 = 0xdeadbeef

revert(sentinel)

}

}

}

msg RelayMsg {

#[selector = sol("relayBoom(address)")]

RelayBoom { target: Address } -> u256,

}

/// Calls `target.static(Boom)` so the test can observe the bubbled revert

/// data from outside the reverting context.

pub contract Relay uses (call: mut Call) {

init() {}

recv RelayMsg {

RelayBoom { target } -> u256 uses (mut call) {

target.static(ViewMsg::Boom {})

}

}

}

#[test]

fn test_address_static_happy_path() uses (evm: mut Evm, call: mut Call) {

let viewer = evm.create2<Viewer>(value: 0, args: (), salt: 0)

assert!(viewer.inner != 0)

let value: u256 = viewer.static(ViewMsg::GetValue {})

assert!(value == 1234)

let owner: Address = viewer.static(ViewMsg::GetOwner {})

assert!(owner.inner == 0xbeef)

}

#[test(should_revert)]

fn test_address_static_bubbles_revert() uses (evm: mut Evm, call: mut Call) {

let viewer = evm.create2<Viewer>(value: 0, args: (), salt: 0)

viewer.static(ViewMsg::Boom {})

}

#[test]

fn test_address_static_bubbles_revert_data() uses (evm: mut Evm, call: mut Call, ctx: Ctx) {

let viewer = evm.create2<Viewer>(value: 0, args: (), salt: 0)

let relay = evm.create2<Relay>(value: 0, args: (), salt: 0)

let (ptr, len) = encode_msg_calldata(RelayMsg::RelayBoom { target: viewer })

let ok = call.raw_call(addr: relay, gas: ctx.gas(), value: 0, args_offset: ptr, args_len: len)

assert!(!ok)

let bubbled: u256 = decode_returndata(last_returndata())

assert!(bubbled == 0xdeadbeef)

}