use crate::error::SidewinderError;
use algo_ops::AppArg;
use anyhow::Result;
use rmp_serde::Serializer;
use serde::{Deserialize, Serialize};
use serde_bytes::ByteBuf;
use sha2::{Digest, Sha512_256};
const HASH_BYTES: usize = 32;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TransactionRequest {
pub txn_type: u32,
pub args: Vec<AppArg>,
pub max_fee: u64,
pub first_valid: u64,
pub last_valid: u64,
pub instance: Vec<u8>,
pub note: Option<Vec<u8>>,
pub group: Option<Vec<u8>>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SignedTransaction {
pub tx_id: String,
pub bytes: Vec<u8>,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
struct TransactionBodyWire {
#[serde(rename = "args")]
args: Vec<ByteBuf>,
#[serde(rename = "fee")]
fee: u64,
#[serde(rename = "fv")]
fv: u64,
#[serde(rename = "grp", default, skip_serializing_if = "Option::is_none")]
grp: Option<ByteBuf>,
#[serde(rename = "inst")]
inst: ByteBuf,
#[serde(rename = "lv")]
lv: u64,
#[serde(rename = "note", default, skip_serializing_if = "Option::is_none")]
note: Option<ByteBuf>,
#[serde(rename = "snd")]
snd: ByteBuf,
#[serde(rename = "typ")]
typ: u32,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
struct SignedTransactionWire {
#[serde(rename = "txn")]
txn: TransactionBodyWire,
#[serde(rename = "sig")]
sig: ByteBuf,
}
fn to_canonical<T: Serialize>(operation: &str, value: &T) -> Result<Vec<u8>> {
let mut buf = Vec::new();
value
.serialize(&mut Serializer::new(&mut buf).with_struct_map())
.map_err(|e| {
SidewinderError::invalid_transaction(
operation,
&format!("canonical encode failed: {e}"),
)
})?;
Ok(buf)
}
fn content_address(bytes: &[u8]) -> String {
let digest = Sha512_256::digest(bytes);
let mut hex = String::with_capacity(digest.len() * 2);
for byte in digest {
hex.push_str(&format!("{byte:02x}"));
}
hex
}
fn require_hash(operation: &str, field: &str, bytes: &[u8]) -> Result<ByteBuf> {
if bytes.len() != HASH_BYTES {
return Err(SidewinderError::invalid_transaction(
operation,
&format!("`{field}` must be {HASH_BYTES} bytes, got {}", bytes.len()),
)
.into());
}
Ok(ByteBuf::from(bytes.to_vec()))
}
pub(crate) fn build_signed(
operation: &str,
request: &TransactionRequest,
sender: [u8; 32],
sign: impl FnOnce(&[u8]) -> Result<[u8; 64]>,
) -> Result<SignedTransaction> {
if request.last_valid < request.first_valid {
return Err(SidewinderError::invalid_transaction(
operation,
&format!(
"validity window inverted: last_valid {} precedes first_valid {}",
request.last_valid, request.first_valid
),
)
.into());
}
let grp = match &request.group {
Some(bytes) => Some(require_hash(operation, "group", bytes)?),
None => None,
};
let body = TransactionBodyWire {
args: request
.args
.iter()
.map(|arg| ByteBuf::from(arg.to_bytes()))
.collect(),
fee: request.max_fee,
fv: request.first_valid,
grp,
inst: require_hash(operation, "instance", &request.instance)?,
lv: request.last_valid,
note: request.note.clone().map(ByteBuf::from),
snd: ByteBuf::from(sender.to_vec()),
typ: request.txn_type,
};
let body_bytes = to_canonical(operation, &body)?;
let tx_id = content_address(&body_bytes);
let signature = sign(&body_bytes)?;
let signed = SignedTransactionWire {
txn: body,
sig: ByteBuf::from(signature.to_vec()),
};
let bytes = to_canonical(operation, &signed)?;
Ok(SignedTransaction { tx_id, bytes })
}