rust-secp256k1-unsafe-fast/tests/serde.rs

#![cfg(feature = "serde")]

extern crate bincode;
#[cfg(target_arch = "x86_64")]
extern crate cbor;
extern crate secp256k1;

#[cfg(feature = "global-context")]
use secp256k1::{KeyPair, Secp256k1};
use secp256k1::{PublicKey, SecretKey, XOnlyPublicKey};

// Arbitrary key data.

#[rustfmt::skip]
static SK_BYTES: [u8; 32] = [
    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
    0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23,
    0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30, 0x31,
    0x0f, 0x10, 0x1f, 0xa0, 0xa9, 0xaa, 0xaf, 0xff,
];

#[rustfmt::skip]
static PK_BYTES: [u8; 33] = [
    0x02,
    0x18, 0x84, 0x57, 0x81, 0xf6, 0x31, 0xc4, 0x8f,
    0x1c, 0x97, 0x09, 0xe2, 0x30, 0x92, 0x06, 0x7d,
    0x06, 0x83, 0x7f, 0x30, 0xaa, 0x0c, 0xd0, 0x54,
    0x4a, 0xc8, 0x87, 0xfe, 0x91, 0xdd, 0xd1, 0x66,
];

#[rustfmt::skip]
static XONLY_PK_BYTES: [u8; 32] = [
    0x18, 0x84, 0x57, 0x81, 0xf6, 0x31, 0xc4, 0x8f,
    0x1c, 0x97, 0x09, 0xe2, 0x30, 0x92, 0x06, 0x7d,
    0x06, 0x83, 0x7f, 0x30, 0xaa, 0x0c, 0xd0, 0x54,
    0x4a, 0xc8, 0x87, 0xfe, 0x91, 0xdd, 0xd1, 0x66,
];

fn secret_key() -> SecretKey {
    SecretKey::from_slice(&SK_BYTES).expect("failed to create sk from slice")
}

// Our current serde serialization implementation is only guaranteed to be fixed
// width for bincode. https://docs.rs/bincode/latest/bincode/index.html
#[test]
fn bincode_secret_key() {
    let sk = secret_key();
    let ser = bincode::serialize(&sk).unwrap();

    assert_eq!(ser, SK_BYTES);
}

#[test]
fn bincode_public_key() {
    let pk = PublicKey::from_slice(&PK_BYTES).expect("failed to create pk from slice");
    let ser = bincode::serialize(&pk).unwrap();

    assert_eq!(ser, &PK_BYTES as &[u8])
}

#[test]
#[cfg(feature = "global-context")]
fn bincode_key_pair() {
    let secp = Secp256k1::new();
    let kp = KeyPair::from_seckey_slice(&secp, &SK_BYTES).expect("failed to create keypair");
    let ser = bincode::serialize(&kp).unwrap();

    assert_eq!(ser, SK_BYTES);
}

#[test]
fn bincode_x_only_public_key() {
    let pk =
        XOnlyPublicKey::from_slice(&XONLY_PK_BYTES).expect("failed to create xonly pk from slice");
    let ser = bincode::serialize(&pk).unwrap();

    assert_eq!(ser, XONLY_PK_BYTES);
}

// cbor adds an additional byte of metadata to certain byte values (byte_value < 24).
#[test]
#[cfg(target_arch = "x86_64")]
fn cbor() {
    let sk = secret_key();

    let mut e = cbor::Encoder::from_memory();
    e.encode(sk.as_ref()).unwrap();

    // 52 because there are 22 bytes in the key for which cbor adds metadata.
    assert_eq!(e.as_bytes().len(), 52);
}