use std::fmt;
use serde::{Deserialize, Deserializer, Serialize};
use super::{AccessListEntry, Address, ChainId, Data, Quantity, U256, Word, encoding};
use crate::{
error::{Error, ValidationError},
wallets::Preparation,
};
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
pub enum FeeTerms {
Legacy {
gas_price: Quantity,
},
AccessList {
gas_price: Quantity,
access_list: Vec<AccessListEntry>,
},
DynamicFee {
max_fee_per_gas: Quantity,
max_priority_fee_per_gas: Quantity,
access_list: Vec<AccessListEntry>,
},
}
impl FeeTerms {
#[must_use]
pub const fn type_byte(&self) -> u8 {
match self {
Self::Legacy { .. } => 0,
Self::AccessList { .. } => 1,
Self::DynamicFee { .. } => 2,
}
}
pub(super) fn validate(&self) -> Result<(), Error> {
match self {
Self::Legacy { .. } => Ok(()),
Self::AccessList { access_list, .. } => encoding::validate_access_list(access_list),
Self::DynamicFee {
max_fee_per_gas,
max_priority_fee_per_gas,
access_list,
} => {
if max_fee_per_gas < max_priority_fee_per_gas {
return Err(invalid());
}
encoding::validate_access_list(access_list)
}
}
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
pub enum TransferIntent {
Native {
to: Address,
value: Quantity,
},
Erc20Transfer {
contract: Address,
to: Address,
amount: Quantity,
},
Erc20Approval {
contract: Address,
spender: Address,
amount: Quantity,
},
}
impl TransferIntent {
fn fields(&self) -> Result<(Address, Quantity, Data), Error> {
match *self {
Self::Native { to, value } => Ok((to, value, Data::new(Vec::new())?)),
Self::Erc20Transfer {
contract,
to,
amount,
} => Ok((
contract,
Quantity::from(0),
calldata([0xa9, 0x05, 0x9c, 0xbb], to, amount)?,
)),
Self::Erc20Approval {
contract,
spender,
amount,
} => Ok((
contract,
Quantity::from(0),
calldata([0x09, 0x5e, 0xa7, 0xb3], spender, amount)?,
)),
}
}
}
fn calldata(selector: [u8; 4], address: Address, amount: Quantity) -> Result<Data, Error> {
let mut bytes = Vec::with_capacity(68);
bytes.extend_from_slice(&selector);
bytes.extend_from_slice(&[0; 12]);
bytes.extend_from_slice(&address.bytes());
bytes.extend_from_slice(&amount.value().to_be_bytes::<32>());
Data::new(bytes)
}
fn invalid() -> Error {
ValidationError::InvalidEvmPreparation.into()
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TransactionRequestData {
pub chain_id: ChainId,
pub sender: Address,
pub nonce: u64,
pub gas_limit: u64,
pub fees: FeeTerms,
pub intent: TransferIntent,
}
#[derive(Clone, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "TransactionRequestData", into = "TransactionRequestData")]
pub struct TransactionRequest(TransactionRequestData);
impl TransactionRequest {
pub fn new(data: TransactionRequestData) -> Result<Self, Error> {
data.fees.validate()?;
if data.nonce == u64::MAX
|| data.gas_limit == 0
|| matches!(data.fees, FeeTerms::Legacy { .. })
&& data.chain_id.value() > (U256::MAX - U256::from(36)) / U256::from(2)
{
return Err(invalid());
}
Ok(Self(data))
}
#[must_use]
pub const fn data(&self) -> &TransactionRequestData {
&self.0
}
pub fn prepare(self) -> Result<PreparedTransaction, Error> {
PreparedTransaction::new(self)
}
}
impl fmt::Debug for TransactionRequest {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("TransactionRequest").finish_non_exhaustive()
}
}
impl TryFrom<TransactionRequestData> for TransactionRequest {
type Error = Error;
fn try_from(value: TransactionRequestData) -> Result<Self, Error> {
Self::new(value)
}
}
impl From<TransactionRequest> for TransactionRequestData {
fn from(value: TransactionRequest) -> Self {
value.0
}
}
#[derive(Clone, Eq, PartialEq, Serialize)]
pub struct UnsignedTransaction {
chain_id: ChainId,
nonce: u64,
gas_limit: u64,
fees: FeeTerms,
to: Address,
value: Quantity,
input: Data,
signing_payload: Data,
}
impl UnsignedTransaction {
fn from_request(request: &TransactionRequest) -> Result<Self, Error> {
let data = request.data();
let (to, value, input) = data.intent.fields()?;
let nonce = encoding::integer(U256::from(data.nonce));
let gas = encoding::integer(U256::from(data.gas_limit));
let recipient = encoding::bytes(&to.bytes());
let amount = encoding::integer(value.value());
let calldata = encoding::bytes(input.bytes());
let chain = encoding::integer(data.chain_id.value());
let mut payload = match &data.fees {
FeeTerms::Legacy { gas_price } => encoding::list(&[
nonce,
encoding::integer(gas_price.value()),
gas,
recipient,
amount,
calldata,
chain,
encoding::integer(U256::ZERO),
encoding::integer(U256::ZERO),
]),
FeeTerms::AccessList {
gas_price,
access_list,
} => encoding::list(&[
chain,
nonce,
encoding::integer(gas_price.value()),
gas,
recipient,
amount,
calldata,
encoding::access_list(access_list),
]),
FeeTerms::DynamicFee {
max_fee_per_gas,
max_priority_fee_per_gas,
access_list,
} => encoding::list(&[
chain,
nonce,
encoding::integer(max_priority_fee_per_gas.value()),
encoding::integer(max_fee_per_gas.value()),
gas,
recipient,
amount,
calldata,
encoding::access_list(access_list),
]),
};
if data.fees.type_byte() != 0 {
payload.insert(0, data.fees.type_byte());
}
Ok(Self {
chain_id: data.chain_id,
nonce: data.nonce,
gas_limit: data.gas_limit,
fees: data.fees.clone(),
to,
value,
input,
signing_payload: Data::new(payload)?,
})
}
#[must_use]
pub const fn chain_id(&self) -> ChainId {
self.chain_id
}
#[must_use]
pub const fn nonce(&self) -> u64 {
self.nonce
}
#[must_use]
pub const fn gas_limit(&self) -> u64 {
self.gas_limit
}
#[must_use]
pub const fn fees(&self) -> &FeeTerms {
&self.fees
}
#[must_use]
pub const fn to(&self) -> Address {
self.to
}
#[must_use]
pub const fn value(&self) -> Quantity {
self.value
}
#[must_use]
pub const fn input(&self) -> &Data {
&self.input
}
#[must_use]
pub const fn signing_payload(&self) -> &Data {
&self.signing_payload
}
#[must_use]
pub fn signing_hash(&self) -> Word {
encoding::hash(self.signing_payload.bytes())
}
}
impl fmt::Debug for UnsignedTransaction {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("UnsignedTransaction")
.finish_non_exhaustive()
}
}
#[derive(Clone, Eq, PartialEq)]
pub struct PreparedTransaction {
request: TransactionRequest,
unsigned: UnsignedTransaction,
}
impl PreparedTransaction {
pub fn new(request: TransactionRequest) -> Result<Self, Error> {
let unsigned = UnsignedTransaction::from_request(&request)?;
Ok(Self { request, unsigned })
}
#[must_use]
pub const fn request(&self) -> &TransactionRequest {
&self.request
}
#[must_use]
pub const fn unsigned(&self) -> &UnsignedTransaction {
&self.unsigned
}
}
impl Preparation for PreparedTransaction {
type Network = ChainId;
type Intent = TransactionRequest;
type UnsignedPayload = UnsignedTransaction;
fn network(&self) -> &ChainId {
&self.request.0.chain_id
}
fn intent(&self) -> &TransactionRequest {
&self.request
}
fn unsigned_payload(&self) -> &UnsignedTransaction {
&self.unsigned
}
fn validate(&self) -> Result<(), Error> {
Ok(())
}
}
impl fmt::Debug for PreparedTransaction {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("PreparedTransaction")
.finish_non_exhaustive()
}
}
impl Serialize for PreparedTransaction {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
self.request.serialize(s)
}
}
impl<'de> Deserialize<'de> for PreparedTransaction {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
Self::new(TransactionRequest::deserialize(d)?).map_err(serde::de::Error::custom)
}
}