1use std::str::FromStr;
6
7use eyre::eyre;
8use fastcrypto::encoding::decode_bytes_hex;
9use serde::{Deserialize, Serialize};
10use serde_repr::{Deserialize_repr, Serialize_repr};
11
12pub const INTENT_PREFIX_LENGTH: usize = 3;
13
14#[derive(Serialize_repr, Deserialize_repr, Copy, Clone, PartialEq, Eq, Debug, Hash)]
18#[repr(u8)]
19pub enum IntentVersion {
20 V0 = 0,
21}
22
23impl TryFrom<u8> for IntentVersion {
24 type Error = eyre::Report;
25 fn try_from(value: u8) -> Result<Self, Self::Error> {
26 bcs::from_bytes(&[value]).map_err(|_| eyre!("Invalid IntentVersion"))
27 }
28}
29
30#[derive(Serialize_repr, Deserialize_repr, Copy, Clone, PartialEq, Eq, Debug, Hash)]
36#[repr(u8)]
37pub enum AppId {
38 Iota = 0,
39 Consensus = 1,
40}
41
42impl TryFrom<u8> for AppId {
44 type Error = eyre::Report;
45 fn try_from(value: u8) -> Result<Self, Self::Error> {
46 bcs::from_bytes(&[value]).map_err(|_| eyre!("Invalid AppId"))
47 }
48}
49
50impl Default for AppId {
51 fn default() -> Self {
52 Self::Iota
53 }
54}
55
56#[derive(Serialize_repr, Deserialize_repr, Copy, Clone, PartialEq, Eq, Debug, Hash)]
60#[repr(u8)]
61pub enum IntentScope {
62 TransactionData = 0, TransactionEffects = 1, CheckpointSummary = 2, PersonalMessage = 3, SenderSignedTransaction = 4, ProofOfPossession = 5, BridgeEventDeprecated = 6, ConsensusBlock = 7, DiscoveryPeers = 8, }
74
75impl TryFrom<u8> for IntentScope {
76 type Error = eyre::Report;
77 fn try_from(value: u8) -> Result<Self, Self::Error> {
78 bcs::from_bytes(&[value]).map_err(|_| eyre!("Invalid IntentScope"))
79 }
80}
81
82#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Clone, Hash)]
91pub struct Intent {
92 pub scope: IntentScope,
93 pub version: IntentVersion,
94 pub app_id: AppId,
95}
96
97impl Intent {
98 pub fn to_bytes(&self) -> [u8; INTENT_PREFIX_LENGTH] {
99 [self.scope as u8, self.version as u8, self.app_id as u8]
100 }
101
102 pub fn from_bytes(bytes: &[u8]) -> Result<Self, eyre::Report> {
103 if bytes.len() != INTENT_PREFIX_LENGTH {
104 return Err(eyre!("Invalid Intent"));
105 }
106 Ok(Self {
107 scope: bytes[0].try_into()?,
108 version: bytes[1].try_into()?,
109 app_id: bytes[2].try_into()?,
110 })
111 }
112}
113
114impl FromStr for Intent {
115 type Err = eyre::Report;
116 fn from_str(s: &str) -> Result<Self, Self::Err> {
117 let bytes: Vec<u8> = decode_bytes_hex(s).map_err(|_| eyre!("Invalid Intent"))?;
118 Self::from_bytes(bytes.as_slice())
119 }
120}
121
122impl Intent {
123 pub fn iota_app(scope: IntentScope) -> Self {
124 Self {
125 version: IntentVersion::V0,
126 scope,
127 app_id: AppId::Iota,
128 }
129 }
130
131 pub fn iota_transaction() -> Self {
132 Self {
133 scope: IntentScope::TransactionData,
134 version: IntentVersion::V0,
135 app_id: AppId::Iota,
136 }
137 }
138
139 pub fn personal_message() -> Self {
140 Self {
141 scope: IntentScope::PersonalMessage,
142 version: IntentVersion::V0,
143 app_id: AppId::Iota,
144 }
145 }
146
147 pub fn consensus_app(scope: IntentScope) -> Self {
148 Self {
149 scope,
150 version: IntentVersion::V0,
151 app_id: AppId::Consensus,
152 }
153 }
154}
155
156#[derive(Debug, PartialEq, Eq, Serialize, Clone, Hash, Deserialize)]
165pub struct IntentMessage<T> {
166 pub intent: Intent,
167 pub value: T,
168}
169
170impl<T> IntentMessage<T> {
171 pub fn new(intent: Intent, value: T) -> Self {
172 Self { intent, value }
173 }
174}
175
176#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
178pub struct PersonalMessage {
179 pub message: Vec<u8>,
180}
181
182pub trait SecureIntent: Serialize + private::SealedIntent {}
183
184pub(crate) mod private {
185 use super::IntentMessage;
186
187 pub trait SealedIntent {}
188 impl<T> SealedIntent for IntentMessage<T> {}
189}
190
191#[derive(Serialize_repr, Deserialize_repr, Copy, Clone, PartialEq, Eq, Debug, Hash)]
196#[repr(u8)]
197pub enum HashingIntentScope {
198 ChildObjectId = 0xf0,
199 RegularObjectId = 0xf1,
200}