#bolt #lightning #bitcoin #serialization #message #array #message-format

no-std serde_bolt

Bitcoin Lightning BOLT-style message serializer / deserializer

30 releases

0.4.1 Aug 12, 2024
0.3.5 Apr 27, 2024
0.3.4 Dec 13, 2023
0.3.1 Aug 11, 2023
0.1.6 Sep 24, 2021

#287 in Encoding

Download history 1061/week @ 2024-05-16 795/week @ 2024-05-23 790/week @ 2024-05-30 677/week @ 2024-06-06 553/week @ 2024-06-13 620/week @ 2024-06-20 385/week @ 2024-06-27 355/week @ 2024-07-04 311/week @ 2024-07-11 333/week @ 2024-07-18 648/week @ 2024-07-25 419/week @ 2024-08-01 756/week @ 2024-08-08 517/week @ 2024-08-15 496/week @ 2024-08-22 616/week @ 2024-08-29

2,503 downloads per month
Used in 16 crates (5 directly)

Apache-2.0

38KB
875 lines

serde-BOLT

Crate Documentation Safety Dance

An incomplete implementation of the Lightning BOLT message serialization format. Compatible with rust-bitcoin Encodable and Decodable traits.

Unlike rust-bitcoin, the default is big-endian encoding and u16/u32 for length fields for the following types:

  • Octets (u16 length field)
  • Array (u16 length field)
  • LargeOctets (u32 length field)
  • IgnoredLargeOctets (u32 length field)

Option is implemented as a single byte, with None as 0x00 and Some as 0x01 followed by the value.

Domain-specific types are not implemented. You can just use Array<u8> or [u8; nnn] or a wrapped version thereof.

Structs and tuples are considered transparent - they are not delimited in the stream.

Unimplemented

  • TLVs

Usage

    use hex::{encode, decode};
    extern crate alloc;

    use serde_bolt::{to_vec, from_vec, bitcoin::consensus::{Encodable, Decodable}, Array};
    use bitcoin_consensus_derive::{Encodable, Decodable};

    #[derive(Encodable, Decodable, PartialEq, Debug)]
    struct Thing([u8; 3]);
    
    #[derive(Encodable, Decodable, Debug)]
    struct Test {
        x: bool,
        a: u32,
        b: u8,
        c: Option<u16>,
        d: Option<u16>,
        e: Array<u8>,
        /// Sub-structs are transparent
        f: Thing
    }

    #[test]
    fn test_simple() {
        let test = Test {
            x: true,
            a: 65538, b:160, c: None, d: Some(3),
            e: vec![0x33, 0x44].into(),
            f: Thing([0x55, 0x66, 0x77])
        };
        let result = to_vec(&test).unwrap();
        assert_eq!("0100010002a00001000300023344556677", encode(&result));
    
        let decoded: Test = from_vec(&mut result.clone()).unwrap();
        assert_eq!(test.a, decoded.a);
		assert_eq!(test.f, decoded.f);
    }

Dependencies

~8.5MB
~117K SLoC