use alloc::{
format,
string::{String, ToString},
};
use minicbor::data::{Int, Tag};
use crate::{
cbor::cbor_map,
crypto_key_path::CryptoKeyPath,
impl_template_struct,
registry_types::{RegistryType, CRYPTO_KEYPATH, TON_SIGN_REQUEST, UUID},
traits::{MapSize, RegistryItem},
types::Bytes,
};
const REQUEST_ID: u8 = 1;
const SIGN_DATA: u8 = 2;
const DATA_TYPE: u8 = 3;
const DERIVATION_PATH: u8 = 4;
const ADDRESS: u8 = 5;
const ORIGIN: u8 = 6;
impl_template_struct!(TonSignRequest {
request_id: Option<Bytes>,
sign_data: Bytes,
data_type: DataType,
derivation_path: Option<CryptoKeyPath>,
address: String,
origin: Option<String>
});
#[derive(Clone, Debug, PartialEq, Default)]
pub enum DataType {
#[default]
Transaction = 1,
SignProof = 2,
}
impl DataType {
pub fn from_u32(i: u32) -> Result<Self, String> {
match i {
1 => Ok(DataType::Transaction),
2 => Ok(DataType::SignProof),
x => Err(format!(
"invalid value for data_type in eth-sign-request, expected (1, 2, 3, 4), received {:?}",
x
)),
}
}
}
impl MapSize for TonSignRequest {
fn map_size(&self) -> u64 {
let mut size = 3;
if self.request_id.is_some() {
size += 1;
}
if self.derivation_path.is_some() {
size += 1;
}
if self.origin.is_some() {
size += 1;
}
size
}
}
impl RegistryItem for TonSignRequest {
fn get_registry_type() -> RegistryType<'static> {
TON_SIGN_REQUEST
}
}
impl<C> minicbor::Encode<C> for TonSignRequest {
fn encode<W: minicbor::encode::Write>(
&self,
e: &mut minicbor::Encoder<W>,
_ctx: &mut C,
) -> Result<(), minicbor::encode::Error<W::Error>> {
e.map(self.map_size())?;
if let Some(request_id) = &self.request_id {
e.int(Int::from(REQUEST_ID))?
.tag(Tag::Unassigned(UUID.get_tag()))?
.bytes(request_id)?;
}
e.int(Int::from(SIGN_DATA))?.bytes(&self.sign_data)?;
e.int(Int::from(DATA_TYPE))?
.int(Int::from(self.data_type.clone() as u8))?;
if let Some(derivation_path) = &self.derivation_path {
e.int(Int::from(DERIVATION_PATH))?
.tag(Tag::Unassigned(CRYPTO_KEYPATH.get_tag()))?;
CryptoKeyPath::encode(derivation_path, e, _ctx)?;
}
e.int(Int::from(ADDRESS))?.str(&self.address)?;
if let Some(origin) = &self.origin {
e.int(Int::from(ORIGIN))?.str(origin)?;
}
Ok(())
}
}
impl<'b, C> minicbor::Decode<'b, C> for TonSignRequest {
fn decode(d: &mut minicbor::Decoder<'b>, ctx: &mut C) -> Result<Self, minicbor::decode::Error> {
let mut result = TonSignRequest::default();
cbor_map(d, &mut result, |key, obj, d| {
let key =
u8::try_from(key).map_err(|e| minicbor::decode::Error::message(e.to_string()))?;
match key {
REQUEST_ID => {
d.tag()?;
obj.request_id = Some(d.bytes()?.to_vec());
}
SIGN_DATA => {
obj.sign_data = d.bytes()?.to_vec();
}
DATA_TYPE => {
obj.data_type = DataType::from_u32(
u32::try_from(d.int()?)
.map_err(|e| minicbor::decode::Error::message(e.to_string()))?,
)
.map_err(minicbor::decode::Error::message)?;
}
DERIVATION_PATH => {
d.tag()?;
obj.derivation_path = Some(CryptoKeyPath::decode(d, ctx)?);
}
ADDRESS => {
obj.address = d.str()?.to_string();
}
ORIGIN => {
obj.origin = Some(d.str()?.to_string());
}
_ => {}
}
Ok(())
})?;
Ok(result)
}
}
#[cfg(test)]
mod tests {
use alloc::vec;
use alloc::vec::Vec;
use base64::Engine;
use crate::crypto_key_path::PathComponent;
use super::*;
extern crate std;
use std::println;
#[test]
fn test_encode() {
let tx = "te6cckEBAgEARwABHCmpoxdmOz6lAAAACAADAQBoQgArFnMvHAX9tOjTp4/RDd3vP2Bn8xG+U5MTuKRKUE1NoqHc1lAAAAAAAAAAAAAAAAAAAHBy4G8=";
let payload = base64::prelude::BASE64_STANDARD.decode(tx).unwrap();
let sig = TonSignRequest {
request_id: Some(hex::decode("9b1deb4d3b7d4bad9bdd2b0d7b3dcb6d").unwrap()),
sign_data: payload,
data_type: DataType::Transaction,
derivation_path: None,
address: "UQC1IywyQwixSOU8pezOZDC9rv2xCV4CGJzOWH6RX8BTsGJx".to_string(),
origin: Some("TonKeeper".to_string()),
};
let result: Vec<u8> = sig.try_into().unwrap();
let expect_result = hex::decode("a501d825509b1deb4d3b7d4bad9bdd2b0d7b3dcb6d025856b5ee9c7241010201004700011c29a9a317663b3ea500000008000301006842002b16732f1c05fdb4e8d3a78fd10dddef3f6067f311be539313b8a44a504d4da2a1dcd65000000000000000000000000000007072e06f0301057830555143314979777951776978534f553870657a4f5a4443397276327843563443474a7a4f574836525838425473474a780669546f6e4b6565706572").unwrap();
assert_eq!(expect_result, result);
}
#[test]
fn test_decode() {
let tx = "te6cckEBAgEARwABHCmpoxdmOz6lAAAACAADAQBoQgArFnMvHAX9tOjTp4/RDd3vP2Bn8xG+U5MTuKRKUE1NoqHc1lAAAAAAAAAAAAAAAAAAAHBy4G8=";
let payload = base64::prelude::BASE64_STANDARD.decode(tx).unwrap();
println!("{}", hex::encode(&payload));
let expect_result = TonSignRequest {
request_id: Some(hex::decode("9b1deb4d3b7d4bad9bdd2b0d7b3dcb6d").unwrap()),
sign_data: payload,
data_type: DataType::Transaction,
derivation_path: None,
address: "UQC1IywyQwixSOU8pezOZDC9rv2xCV4CGJzOWH6RX8BTsGJx".to_string(),
origin: Some("TonKeeper".to_string()),
};
let result = TonSignRequest::try_from(hex::decode("a501d825509b1deb4d3b7d4bad9bdd2b0d7b3dcb6d025856b5ee9c7241010201004700011c29a9a317663b3ea500000008000301006842002b16732f1c05fdb4e8d3a78fd10dddef3f6067f311be539313b8a44a504d4da2a1dcd65000000000000000000000000000007072e06f0301057830555143314979777951776978534f553870657a4f5a4443397276327843563443474a7a4f574836525838425473474a780669546f6e4b6565706572").unwrap()).unwrap();
assert_eq!(expect_result.request_id, result.request_id);
assert_eq!(expect_result.sign_data, result.sign_data);
assert!(result.derivation_path.is_none());
assert_eq!(expect_result.address, result.address);
assert_eq!(expect_result.origin, result.origin);
}
}