use super::*;
use quai_consensus::{QuaiTransaction, SignedQuaiTransaction};
use quai_primitives::Hash32;
use quai_provider::{Inclusion, Provider, ProviderError};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub struct WalletSendIdentity {
pub from: QuaiAddress,
pub chain_id: U256,
pub nonce: u64,
pub signing_digest: Hash32,
}
impl WalletSendIdentity {
pub fn new(from: QuaiAddress, transaction: &QuaiTransaction) -> Result<Self, BrowserError> {
Ok(Self {
from,
chain_id: transaction.chain_id,
nonce: transaction.nonce,
signing_digest: transaction
.signing_digest()
.map_err(|_| BrowserError::InvalidConfig)?,
})
}
}
#[derive(Debug, thiserror::Error)]
#[non_exhaustive]
pub enum WalletSendError {
#[error("wallet transaction preflight failed: {0}")]
Preflight(#[source] BrowserError),
#[error("wallet transaction outcome is ambiguous: {source}")]
Ambiguous {
identity: WalletSendIdentity,
reported_hash: Option<Hash32>,
#[source]
source: BrowserError,
},
}
impl WalletSendError {
pub fn acceptance_is_ambiguous(&self) -> bool {
matches!(self, Self::Ambiguous { .. })
}
}
#[derive(Clone)]
pub struct WalletSendAcknowledgement {
identity: WalletSendIdentity,
reported_hash: Hash32,
requested: QuaiTransaction,
}
impl fmt::Debug for WalletSendAcknowledgement {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("WalletSendAcknowledgement")
.field("identity", &self.identity)
.field("reported_hash", &self.reported_hash)
.finish()
}
}
impl WalletSendAcknowledgement {
pub fn from_reported_hash(
from: QuaiAddress,
requested: QuaiTransaction,
reported_hash: Hash32,
) -> Result<Self, BrowserError> {
if requested.chain_id == U256::ZERO || !valid_hash(from, reported_hash) {
return Err(BrowserError::InvalidResult);
}
let identity = WalletSendIdentity::new(from, &requested)?;
Ok(Self {
identity,
reported_hash,
requested,
})
}
pub fn identity(&self) -> WalletSendIdentity {
self.identity
}
pub fn reported_hash(&self) -> Hash32 {
self.reported_hash
}
pub fn requested_transaction(&self) -> &QuaiTransaction {
&self.requested
}
pub async fn observe<T: Transport>(
&self,
provider: &Provider<T>,
) -> Result<Option<WalletSendObservation>, ProviderError> {
let zone = self.identity.from.zone();
let actual = provider.chain_id(zone.into()).await?;
if actual != self.identity.chain_id {
return Err(ProviderError::ChainMismatch {
expected: self.identity.chain_id,
actual,
});
}
let Some(observed) = provider.transaction(zone, self.reported_hash).await? else {
return Ok(None);
};
let signed = observed.verified_quai()?;
let matches_request =
signed.from() == self.identity.from && signed.transaction() == &self.requested;
Ok(Some(WalletSendObservation {
signed,
matches_request,
inclusion: observed.inclusion,
}))
}
}
#[derive(Debug)]
pub struct WalletSendObservation {
signed: SignedQuaiTransaction,
matches_request: bool,
inclusion: Option<Inclusion>,
}
impl WalletSendObservation {
pub fn signed(&self) -> &SignedQuaiTransaction {
&self.signed
}
pub fn matches_request(&self) -> bool {
self.matches_request
}
pub fn inclusion(&self) -> Option<Inclusion> {
self.inclusion
}
}
impl InjectedProvider {
pub async fn send_quai_transaction(
&self,
address: QuaiAddress,
transaction: &QuaiTransaction,
) -> Result<WalletSendAcknowledgement, WalletSendError> {
let params = self
.transaction_params(address, transaction, "quai_sendTransaction")
.map_err(WalletSendError::Preflight)?;
let identity =
WalletSendIdentity::new(address, transaction).map_err(WalletSendError::Preflight)?;
let revision = self.context_revision();
self.check_chain()
.await
.map_err(WalletSendError::Preflight)?;
let accounts = Self::accounts_from(
self.raw("quai_accounts", json!([]))
.await
.map_err(WalletSendError::Preflight)?,
)
.map_err(WalletSendError::Preflight)?;
if !accounts.contains(&address) {
return Err(WalletSendError::Preflight(BrowserError::AccountUnavailable));
}
if provider_changed(&self.watch.0, revision) {
return Err(WalletSendError::Preflight(BrowserError::ContextChanged));
}
let value = self
.raw("quai_sendTransaction", params)
.await
.map_err(|source| WalletSendError::Ambiguous {
identity,
reported_hash: None,
source,
})?;
let reported_hash = value.as_str().and_then(|s| s.parse::<Hash32>().ok());
self.verify_context(revision, Some(address))
.await
.map_err(|source| WalletSendError::Ambiguous {
identity,
reported_hash,
source,
})?;
let valid = reported_hash
.filter(|hash| valid_hash(address, *hash))
.ok_or(WalletSendError::Ambiguous {
identity,
reported_hash,
source: BrowserError::InvalidResult,
})?;
Ok(WalletSendAcknowledgement {
identity,
reported_hash: valid,
requested: transaction.clone(),
})
}
}
fn valid_hash(address: QuaiAddress, hash: Hash32) -> bool {
let bytes = hash.bytes();
hash != Hash32::ZERO
&& bytes[0] == address.zone().byte()
&& bytes[2] == address.zone().byte()
&& bytes[1] & 0x80 == 0
&& bytes[3] & 0x80 == 0
}