use serde::{Deserialize, Serialize};
use solana_address::Address;
use solana_instruction::{AccountMeta, Instruction};
use solana_message::{Message, VersionedMessage};
use super::{Hash, Network, Pubkey, UnsignedMessage, UnsignedTransaction};
use crate::error::{Error, ValidationError};
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct BlockhashLifetime {
pub blockhash: Hash,
pub last_valid_block_height: u64,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
pub enum TransferIntent {
Native {
fee_payer: Pubkey,
sender: Pubkey,
recipient: Pubkey,
lamports: u64,
},
TokenChecked {
fee_payer: Pubkey,
source_account: Pubkey,
mint: Pubkey,
destination_account: Pubkey,
authority: Pubkey,
raw_amount: u64,
decimals: u8,
},
}
impl TransferIntent {
#[must_use]
pub const fn fee_payer(&self) -> Pubkey {
match self {
Self::Native { fee_payer, .. } | Self::TokenChecked { fee_payer, .. } => *fee_payer,
}
}
fn instruction(&self) -> Result<Instruction, Error> {
let address = |p: Pubkey| Address::new_from_array(p.bytes());
Ok(match *self {
Self::Native {
sender,
recipient,
lamports,
..
} => solana_system_interface::instruction::transfer(
&address(sender),
&address(recipient),
lamports,
),
Self::TokenChecked {
source_account,
mint,
destination_account,
authority,
raw_amount,
decimals,
..
} => Instruction {
program_id: address(Pubkey::parse(
"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
)?),
accounts: vec![
AccountMeta::new(address(source_account), false),
AccountMeta::new_readonly(address(mint), false),
AccountMeta::new(address(destination_account), false),
AccountMeta::new_readonly(address(authority), true),
],
data: spl_token_interface::instruction::TokenInstruction::TransferChecked {
amount: raw_amount,
decimals,
}
.pack(),
},
})
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "Fields")]
pub struct TransferPreparation {
network: Network,
intent: TransferReview,
unsigned_transaction: UnsignedTransaction,
}
impl TransferPreparation {
pub fn new(
network: Network,
intent: TransferIntent,
lifetime: BlockhashLifetime,
) -> Result<Self, Error> {
let instruction = intent.instruction()?;
let message = Message::new_with_blockhash(
&[instruction],
Some(&Address::new_from_array(intent.fee_payer().bytes())),
&solana_hash::Hash::new_from_array(lifetime.blockhash.bytes()),
);
let unsigned_transaction = UnsignedTransaction::from_message(
UnsignedMessage::from_message(VersionedMessage::Legacy(message))?,
)?;
Ok(Self {
network,
intent: TransferReview {
transfer: intent,
lifetime,
},
unsigned_transaction,
})
}
#[must_use]
pub const fn network(&self) -> &Network {
&self.network
}
#[must_use]
pub const fn intent(&self) -> &TransferReview {
&self.intent
}
#[must_use]
pub const fn lifetime(&self) -> BlockhashLifetime {
self.intent.lifetime
}
#[must_use]
pub const fn unsigned_transaction(&self) -> &UnsignedTransaction {
&self.unsigned_transaction
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct Fields {
network: Network,
intent: TransferReview,
unsigned_transaction: UnsignedTransaction,
}
impl TryFrom<Fields> for TransferPreparation {
type Error = Error;
fn try_from(f: Fields) -> Result<Self, Error> {
let value = Self::new(f.network, f.intent.transfer, f.intent.lifetime)?;
if value.unsigned_transaction != f.unsigned_transaction {
return Err(ValidationError::InvalidSolanaPreparation.into());
}
Ok(value)
}
}
impl crate::wallets::Preparation for TransferPreparation {
type Network = Network;
type Intent = TransferReview;
type UnsignedPayload = UnsignedTransaction;
fn network(&self) -> &Network {
&self.network
}
fn intent(&self) -> &TransferReview {
&self.intent
}
fn unsigned_payload(&self) -> &UnsignedTransaction {
&self.unsigned_transaction
}
fn validate(&self) -> Result<(), Error> {
if Self::new(
self.network.clone(),
self.intent.transfer.clone(),
self.intent.lifetime,
)? != *self
{
return Err(ValidationError::InvalidSolanaPreparation.into());
}
Ok(())
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TransferReview {
pub transfer: TransferIntent,
pub lifetime: BlockhashLifetime,
}