lightning_signer/util/
ser_util.rs

1//! By convention, structs ending with `Def` are serde local types
2//! describing how to serialize a remote type via `serde(remote)`.
3//! Structs ending with `Entry` are local types that require a manual
4//! transformation from the remote type - implemented via `From` / `Into`.
5
6use crate::prelude::*;
7
8use alloc::borrow::Cow;
9use core::fmt;
10use core::fmt::Formatter;
11use core::time::Duration;
12use lightning::ln::channel_keys::{DelayedPaymentBasepoint, HtlcBasepoint, RevocationBasepoint};
13use vls_common::HexEncode;
14
15use bitcoin::hashes::Hash;
16use bitcoin::secp256k1::PublicKey;
17use bitcoin::{OutPoint, Script, ScriptBuf, Txid};
18use lightning::ln::chan_utils::ChannelPublicKeys;
19use lightning::util::ser::Writer;
20use serde::de::SeqAccess;
21use serde::ser::SerializeSeq;
22use serde::{Deserialize, Deserializer, Serialize, Serializer};
23use serde_with::serde_as;
24use serde_with::{DeserializeAs, SerializeAs};
25
26use crate::channel::ChannelId;
27use crate::io;
28
29#[derive(Copy, Clone, Debug, Default)]
30pub struct PublicKeyHandler;
31
32impl SerializeAs<PublicKey> for PublicKeyHandler {
33    fn serialize_as<S>(source: &PublicKey, serializer: S) -> Result<S::Ok, S::Error>
34    where
35        S: Serializer,
36    {
37        serializer.serialize_str(hex::encode(source.serialize().to_vec()).as_str())
38    }
39}
40
41impl<'de> DeserializeAs<'de, PublicKey> for PublicKeyHandler {
42    fn deserialize_as<D>(deserializer: D) -> Result<PublicKey, D::Error>
43    where
44        D: Deserializer<'de>,
45    {
46        let res = <Cow<'de, str> as Deserialize<'de>>::deserialize(deserializer)?;
47        let key = PublicKey::from_slice(hex::decode(&*res).unwrap().as_slice()).unwrap();
48        Ok(key)
49    }
50}
51
52#[derive(Copy, Clone, Debug, Default)]
53pub struct RevocationBasepointHandler;
54
55impl SerializeAs<RevocationBasepoint> for RevocationBasepointHandler {
56    fn serialize_as<S>(source: &RevocationBasepoint, serializer: S) -> Result<S::Ok, S::Error>
57    where
58        S: Serializer,
59    {
60        serde::Serialize::serialize(&source.0, serializer)
61    }
62}
63
64impl<'de> DeserializeAs<'de, RevocationBasepoint> for RevocationBasepointHandler {
65    fn deserialize_as<D>(deserializer: D) -> Result<RevocationBasepoint, D::Error>
66    where
67        D: Deserializer<'de>,
68    {
69        let key = PublicKey::deserialize(deserializer)?;
70        Ok(key.into())
71    }
72}
73
74#[derive(Copy, Clone, Debug, Default)]
75pub struct DelayedPaymentBasepointHandler;
76
77impl SerializeAs<DelayedPaymentBasepoint> for DelayedPaymentBasepointHandler {
78    fn serialize_as<S>(source: &DelayedPaymentBasepoint, serializer: S) -> Result<S::Ok, S::Error>
79    where
80        S: Serializer,
81    {
82        serde::Serialize::serialize(&source.0, serializer)
83    }
84}
85
86impl<'de> DeserializeAs<'de, DelayedPaymentBasepoint> for DelayedPaymentBasepointHandler {
87    fn deserialize_as<D>(deserializer: D) -> Result<DelayedPaymentBasepoint, D::Error>
88    where
89        D: Deserializer<'de>,
90    {
91        let key = PublicKey::deserialize(deserializer)?;
92        Ok(key.into())
93    }
94}
95
96#[derive(Copy, Clone, Debug, Default)]
97pub struct HtlcBasepointHandler;
98
99impl SerializeAs<HtlcBasepoint> for HtlcBasepointHandler {
100    fn serialize_as<S>(source: &HtlcBasepoint, serializer: S) -> Result<S::Ok, S::Error>
101    where
102        S: Serializer,
103    {
104        serde::Serialize::serialize(&source.0, serializer)
105    }
106}
107
108impl<'de> DeserializeAs<'de, HtlcBasepoint> for HtlcBasepointHandler {
109    fn deserialize_as<D>(deserializer: D) -> Result<HtlcBasepoint, D::Error>
110    where
111        D: Deserializer<'de>,
112    {
113        let key = PublicKey::deserialize(deserializer)?;
114        Ok(key.into())
115    }
116}
117
118pub struct ChannelIdHandler;
119
120impl SerializeAs<ChannelId> for ChannelIdHandler {
121    fn serialize_as<S>(source: &ChannelId, serializer: S) -> Result<S::Ok, S::Error>
122    where
123        S: Serializer,
124    {
125        serializer.serialize_str(hex::encode(source.as_slice()).as_str())
126    }
127}
128
129impl<'de> DeserializeAs<'de, ChannelId> for ChannelIdHandler {
130    fn deserialize_as<D>(deserializer: D) -> Result<ChannelId, D::Error>
131    where
132        D: Deserializer<'de>,
133    {
134        let res = <Cow<'de, str> as Deserialize<'de>>::deserialize(deserializer).unwrap();
135        let key = ChannelId::new(&hex::decode(&*res).unwrap());
136        Ok(key)
137    }
138}
139
140#[serde_as]
141#[derive(Serialize, Deserialize)]
142#[serde(remote = "ChannelPublicKeys")]
143pub struct ChannelPublicKeysDef {
144    pub funding_pubkey: PublicKey,
145    #[serde_as(as = "RevocationBasepointHandler")]
146    pub revocation_basepoint: RevocationBasepoint,
147    pub payment_point: PublicKey,
148    #[serde_as(as = "DelayedPaymentBasepointHandler")]
149    pub delayed_payment_basepoint: DelayedPaymentBasepoint,
150    #[serde_as(as = "HtlcBasepointHandler")]
151    pub htlc_basepoint: HtlcBasepoint,
152}
153
154#[derive(Deserialize)]
155struct ChannelPublicKeysHelper(#[serde(with = "ChannelPublicKeysDef")] ChannelPublicKeys);
156
157impl SerializeAs<ChannelPublicKeys> for ChannelPublicKeysDef {
158    fn serialize_as<S>(value: &ChannelPublicKeys, serializer: S) -> Result<S::Ok, S::Error>
159    where
160        S: Serializer,
161    {
162        ChannelPublicKeysDef::serialize(value, serializer)
163    }
164}
165
166impl<'de> DeserializeAs<'de, ChannelPublicKeys> for ChannelPublicKeysDef {
167    fn deserialize_as<D>(
168        deserializer: D,
169    ) -> Result<ChannelPublicKeys, <D as Deserializer<'de>>::Error>
170    where
171        D: Deserializer<'de>,
172    {
173        ChannelPublicKeysHelper::deserialize(deserializer).map(|h| h.0)
174    }
175}
176
177pub struct VecWriter(pub Vec<u8>);
178impl Writer for VecWriter {
179    fn write_all(&mut self, buf: &[u8]) -> Result<(), io::Error> {
180        self.0.extend_from_slice(buf);
181        Ok(())
182    }
183}
184
185/// TxIdReversedDef should be used with the assumption
186/// that the transaction is built from a big-endian vector
187/// stream. This will produce a different Txid if not
188/// properly considered. For more details, see [issue#490].
189///
190/// [issue#490]: https://gitlab.com/lightning-signer/validating-lightning-signer/-/issues/490
191pub struct TxIdReversedDef;
192
193impl SerializeAs<Txid> for TxIdReversedDef {
194    fn serialize_as<S>(value: &Txid, serializer: S) -> Result<S::Ok, S::Error>
195    where
196        S: Serializer,
197    {
198        serializer.serialize_str(value.as_byte_array().to_hex().as_str())
199    }
200}
201
202impl<'de> DeserializeAs<'de, Txid> for TxIdReversedDef {
203    fn deserialize_as<D>(deserializer: D) -> Result<Txid, <D as Deserializer<'de>>::Error>
204    where
205        D: Deserializer<'de>,
206    {
207        let res = <Cow<'de, str> as Deserialize<'de>>::deserialize(deserializer).unwrap();
208        let txid = Txid::from_slice(hex::decode(&*res).unwrap().as_slice()).unwrap();
209        Ok(txid)
210    }
211}
212
213/// OutPointReversedDef uses TxIdReversedDef for decoding the txid
214/// and this type should be used with the assumption
215/// that the transaction is built from a big-endian vector stream.
216/// This will produce a different Txid if not properly considered.
217/// For more details, see [issue#490].
218///
219/// [issue#490]: https://gitlab.com/lightning-signer/validating-lightning-signer/-/issues/490
220#[serde_as]
221#[derive(Serialize, Deserialize)]
222#[serde(remote = "OutPoint")]
223pub struct OutPointReversedDef {
224    #[serde_as(as = "TxIdReversedDef")]
225    pub txid: Txid,
226    pub vout: u32,
227}
228
229#[derive(Deserialize)]
230struct OutPointHelper(#[serde(with = "OutPointReversedDef")] OutPoint);
231
232impl SerializeAs<OutPoint> for OutPointReversedDef {
233    fn serialize_as<S>(value: &OutPoint, serializer: S) -> Result<S::Ok, S::Error>
234    where
235        S: Serializer,
236    {
237        OutPointReversedDef::serialize(value, serializer)
238    }
239}
240
241impl<'de> DeserializeAs<'de, OutPoint> for OutPointReversedDef {
242    fn deserialize_as<D>(deserializer: D) -> Result<OutPoint, <D as Deserializer<'de>>::Error>
243    where
244        D: Deserializer<'de>,
245    {
246        OutPointHelper::deserialize(deserializer).map(|h| h.0)
247    }
248}
249
250#[derive(Serialize, Deserialize)]
251#[serde(remote = "ScriptBuf")]
252pub struct ScriptDef(#[serde(getter = "Script::to_bytes")] Vec<u8>);
253
254impl From<ScriptDef> for ScriptBuf {
255    fn from(s: ScriptDef) -> Self {
256        ScriptBuf::from(s.0)
257    }
258}
259
260#[derive(Deserialize)]
261struct ScriptHelper(#[serde(with = "ScriptDef")] ScriptBuf);
262
263impl SerializeAs<ScriptBuf> for ScriptDef {
264    fn serialize_as<S>(value: &ScriptBuf, serializer: S) -> Result<S::Ok, S::Error>
265    where
266        S: Serializer,
267    {
268        ScriptDef::serialize(value, serializer)
269    }
270}
271
272impl<'de> DeserializeAs<'de, ScriptBuf> for ScriptDef {
273    fn deserialize_as<D>(deserializer: D) -> Result<ScriptBuf, <D as Deserializer<'de>>::Error>
274    where
275        D: Deserializer<'de>,
276    {
277        ScriptHelper::deserialize(deserializer).map(|h| h.0)
278    }
279}
280
281#[derive(Copy, Clone, Debug, Default)]
282pub struct DurationHandler;
283
284impl SerializeAs<Duration> for DurationHandler {
285    fn serialize_as<S>(value: &Duration, serializer: S) -> Result<S::Ok, S::Error>
286    where
287        S: Serializer,
288    {
289        let mut seq = serializer.serialize_seq(Some(2))?;
290        seq.serialize_element(&value.as_secs())?;
291        seq.serialize_element(&value.subsec_nanos())?;
292        seq.end()
293    }
294}
295
296struct DurationVisitor;
297
298impl<'de> serde::de::Visitor<'de> for DurationVisitor {
299    type Value = Duration;
300
301    fn expecting(&self, fmt: &mut Formatter) -> fmt::Result {
302        fmt.write_str("tuple")
303    }
304
305    fn visit_seq<V>(self, mut seq: V) -> Result<Duration, V::Error>
306    where
307        V: SeqAccess<'de>,
308    {
309        let secs = seq.next_element()?.ok_or_else(|| serde::de::Error::invalid_length(0, &self))?;
310        let nanos =
311            seq.next_element()?.ok_or_else(|| serde::de::Error::invalid_length(1, &self))?;
312        Ok(Duration::new(secs, nanos))
313    }
314}
315
316impl<'de> DeserializeAs<'de, Duration> for DurationHandler {
317    fn deserialize_as<D>(deserializer: D) -> Result<Duration, <D as Deserializer<'de>>::Error>
318    where
319        D: Deserializer<'de>,
320    {
321        deserializer.deserialize_seq(DurationVisitor)
322    }
323}
lightning_signer/util/ser_util.rs

lightning_signer/util/
ser_util.rs
