use crate::erc20::Erc20Token;
use alloy::primitives::{Address, AddressError, U256};
use alloy_sol_types::SolValue;
use cosmwasm_schema::cw_serde;
use cosmwasm_std::{HexBinary, Uint128};
/// Marks either `String` or valid EVM `Address`.
///
/// String is used in unverified types, such as messages and query responses.
/// Addr is used in verified types, which are to be stored in blockchain state.
///
/// This trait is intended to be used as a generic in type definitions.
pub trait EvmAddressLike {}
impl EvmAddressLike for String {}
impl EvmAddressLike for HexBinary {}
impl EvmAddressLike for Address {}
/// A message to be sent to the EVM
#[cw_serde]
#[non_exhaustive]
pub enum EvmMsg<T: EvmAddressLike> {
/// Call a contract with the given data
Call {
/// The address of the contract to call, must pass checksum validation
to: T,
/// The calldata to send to the contract
data: HexBinary,
/// Native ETH used in the tx
#[serde(skip_serializing_if = "Option::is_none")]
value: Option<Uint128>,
/// Don't revert entire batch when this transaction fails
#[serde(skip_serializing_if = "Option::is_none")]
allow_failure: Option<bool>,
},
/// Delegate a call to an external contract. This is dangerous and should be used with caution.
DelegateCall {
/// The address of the contract to call, must pass checksum validation
to: T,
/// The calldata to send to the contract
data: HexBinary,
/// Native ETH used in the tx
#[serde(skip_serializing_if = "Option::is_none")]
value: Option<Uint128>,
/// Don't revert entire batch when this transaction fails
#[serde(skip_serializing_if = "Option::is_none")]
allow_failure: Option<bool>,
},
}
impl<T> EvmMsg<T>
where
T: EvmAddressLike,
{
pub fn call(to: T, data: impl Into<HexBinary>) -> Self {
EvmMsg::Call {
to,
data: data.into(),
value: None,
allow_failure: None,
}
}
pub fn call_with_value(to: T, data: impl Into<HexBinary>, value: Uint128) -> Self {
EvmMsg::Call {
to,
data: data.into(),
value: Some(value),
allow_failure: None,
}
}
pub fn delegate_call(to: T, data: impl Into<HexBinary>) -> Self {
EvmMsg::DelegateCall {
to,
data: data.into(),
value: None,
allow_failure: None,
}
}
}
impl EvmMsg<String> {
/// Check the validity of the addresses
pub fn check(self) -> Result<EvmMsg<Address>, AddressError> {
match self {
EvmMsg::Call {
to,
data,
value,
allow_failure,
} => {
let to: Address = Address::parse_checksummed(to, None)?;
Ok(EvmMsg::Call {
to,
data,
value,
allow_failure,
})
}
EvmMsg::DelegateCall {
to,
data,
value,
allow_failure,
} => {
let to: Address = Address::parse_checksummed(to, None)?;
Ok(EvmMsg::DelegateCall {
to,
data,
value,
allow_failure,
})
}
}
}
}
impl EvmMsg<Address> {
pub fn encode(self) -> Vec<u8> {
match self {
EvmMsg::Call {
to,
data,
allow_failure,
value,
} => {
let data = data.to_vec();
let call = abi_types::CallMessage {
to,
data: data.to_vec().into(),
allowFailure: allow_failure.unwrap_or(false),
value: value.map(|v| U256::from(v.u128())).unwrap_or_default(),
}
.abi_encode();
abi_types::EvmMsg {
msgType: abi_types::EvmMsgType::Call,
message: call.into(),
}
.abi_encode()
}
EvmMsg::DelegateCall {
to,
data,
allow_failure,
value,
} => {
let data = data.to_vec();
let call = abi_types::CallMessage {
to,
data: data.to_vec().into(),
allowFailure: allow_failure.unwrap_or(false),
value: value.map(|v| U256::from(v.u128())).unwrap_or_default(),
}
.abi_encode();
abi_types::EvmMsg {
msgType: abi_types::EvmMsgType::DelegateCall,
message: call.into(),
}
.abi_encode()
}
}
}
#[allow(dead_code)]
fn unchecked(self) -> EvmMsg<String> {
match self {
EvmMsg::Call {
to,
data,
allow_failure,
value,
} => EvmMsg::Call {
to: to.to_string(),
data,
allow_failure,
value,
},
EvmMsg::DelegateCall {
to,
data,
allow_failure,
value,
} => EvmMsg::DelegateCall {
to: to.to_string(),
data,
allow_failure,
value,
},
}
}
}
pub(crate) mod abi_types {
use alloy_sol_types::sol;
// Copied directly from solidity/src/Requests.sol
sol! {
// Reflect the CW Packet
struct Packet {
string sender;
Msg msg;
}
// Message called on the voice
struct Msg {
MsgType msgType;
// Requests on the voice (Exec / Query)
bytes[] data;
}
// Type of voice message
enum MsgType {
Execute
// Query
}
// Message called on the proxy contract
// Reflect EvmMsg<Address>
struct EvmMsg {
EvmMsgType msgType;
bytes message;
}
// Type of message called on proxy contract
enum EvmMsgType {
Call,
DelegateCall,
}
// Data to execute by proxy
struct CallMessage {
address to;
bool allowFailure;
uint256 value;
bytes data;
}
struct ExecuteResult {
bool success;
bytes data;
}
struct ExecuteResponsePacket {
address executedBy;
ExecuteResult[] result;
}
struct Token {
address denom;
uint128 amount;
}
}
}
impl From<abi_types::Token> for Erc20Token<String> {
fn from(token: abi_types::Token) -> Self {
Erc20Token {
address: token.denom.to_string(),
amount: token.amount.into(),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
mod call_message {
use crate::ibc::{Msg, Packet};
use super::*;
#[test]
fn unchecked_encoding() {
let msg = abi_types::CallMessage {
to: "0x785B548D3d7064F77A26e479AC7847DBCE0c1B46"
.parse()
.unwrap(),
data: HexBinary::from_hex("b49004e9").unwrap().to_vec().into(),
allowFailure: false,
value: U256::from(0),
};
let encoded = msg.abi_encode();
let actual = HexBinary::from(encoded);
let expected = HexBinary::from_hex("0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000785b548d3d7064f77a26e479ac7847dbce0c1b460000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000004b49004e900000000000000000000000000000000000000000000000000000000").unwrap();
assert_eq!(actual, expected);
}
#[test]
fn checked_encoding() {
let msg = EvmMsg::call(
"0x785B548D3d7064F77A26e479AC7847DBCE0c1B46".to_string(),
HexBinary::from_hex("b49004e9").unwrap(),
)
.check()
.unwrap();
let encoded = msg.encode();
let actual = HexBinary::from(encoded);
let expected = HexBinary::from_hex("0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000785b548d3d7064f77a26e479ac7847dbce0c1b460000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000004b49004e900000000000000000000000000000000000000000000000000000000").unwrap();
assert_eq!(actual, expected);
}
const TEST_SENDER: &str =
"union1tw2y3uk7fwcjeh208gdwaqd3utkuzmnp2fyvqve00jg8vtyhuhfqsender";
#[test]
fn packet_encoding() {
let evm_msg = EvmMsg::call(
"0x785B548D3d7064F77A26e479AC7847DBCE0c1B46".to_string(),
HexBinary::from_hex("b49004e9").unwrap(),
);
let msg = Msg::Execute {
msgs: vec![evm_msg],
};
let request: Packet = Packet {
msg,
sender: TEST_SENDER.to_string(),
};
let encoded = request.encode().unwrap();
let actual = HexBinary::from(encoded);
let expected = HexBinary::from_hex("0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000040756e696f6e317477327933756b376677636a65683230386764776171643375746b757a6d6e703266797671766530306a6738767479687568667173656e6465720000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000785b548d3d7064f77a26e479ac7847dbce0c1b460000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000004b49004e900000000000000000000000000000000000000000000000000000000").unwrap();
assert_eq!(actual, expected);
}
}
#[test]
fn test_address() {
EvmMsg::call(
"0x785B548D3d7064F77A26e479AC7847DBCE0c1B46".to_string(),
HexBinary::from_hex("b49004e9").unwrap(),
);
}
}