dig-clvm 0.1.1

DIG L2 CLVM consensus engine — validates spend bundles, computes coin additions and removals
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

//! REQUIREMENT: CON-005 — AGG_SIG additional data derivation
//!
//! Validates the cryptographic derivation of AGG_SIG_* additional data fields.
//! AGG_SIG_ME == genesis_challenge. The remaining six variants are derived as
//! sha256(genesis_challenge || opcode_byte) with opcode bytes 43..=48.
//! Mainnet and testnet must produce distinct values.

use dig_clvm::{DIG_MAINNET, DIG_TESTNET};
use sha2::{Digest, Sha256};

/// Compute sha256(genesis || opcode_byte).
fn sha256_genesis_with_opcode(genesis: &[u8; 32], opcode: u8) -> [u8; 32] {
    let mut hasher = Sha256::new();
    hasher.update(genesis);
    hasher.update([opcode]);
    hasher.finalize().into()
}

#[test]
fn con_005_agg_sig_me_equals_genesis_challenge() {
    // AGG_SIG_ME additional data is the genesis challenge itself.
    assert_eq!(
        DIG_MAINNET.agg_sig_me_additional_data(),
        DIG_MAINNET.genesis_challenge(),
        "Mainnet: AGG_SIG_ME must equal genesis_challenge"
    );
    assert_eq!(
        DIG_TESTNET.agg_sig_me_additional_data(),
        DIG_TESTNET.genesis_challenge(),
        "Testnet: AGG_SIG_ME must equal genesis_challenge"
    );
}

#[test]
fn con_005_derived_agg_sig_fields_mainnet() {
    let genesis: [u8; 32] = DIG_MAINNET.genesis_challenge().into();
    let c = DIG_MAINNET.consensus();

    // AGG_SIG_PARENT  opcode 43
    let expected_parent: [u8; 32] = sha256_genesis_with_opcode(&genesis, 43);
    assert_eq!(
        <[u8; 32]>::from(c.agg_sig_parent_additional_data),
        expected_parent
    );

    // AGG_SIG_PUZZLE  opcode 44
    let expected_puzzle: [u8; 32] = sha256_genesis_with_opcode(&genesis, 44);
    assert_eq!(
        <[u8; 32]>::from(c.agg_sig_puzzle_additional_data),
        expected_puzzle
    );

    // AGG_SIG_AMOUNT  opcode 45
    let expected_amount: [u8; 32] = sha256_genesis_with_opcode(&genesis, 45);
    assert_eq!(
        <[u8; 32]>::from(c.agg_sig_amount_additional_data),
        expected_amount
    );

    // AGG_SIG_PUZZLE_AMOUNT  opcode 46
    let expected_puzzle_amount: [u8; 32] = sha256_genesis_with_opcode(&genesis, 46);
    assert_eq!(
        <[u8; 32]>::from(c.agg_sig_puzzle_amount_additional_data),
        expected_puzzle_amount
    );

    // AGG_SIG_PARENT_AMOUNT  opcode 47
    let expected_parent_amount: [u8; 32] = sha256_genesis_with_opcode(&genesis, 47);
    assert_eq!(
        <[u8; 32]>::from(c.agg_sig_parent_amount_additional_data),
        expected_parent_amount
    );

    // AGG_SIG_PARENT_PUZZLE  opcode 48
    let expected_parent_puzzle: [u8; 32] = sha256_genesis_with_opcode(&genesis, 48);
    assert_eq!(
        <[u8; 32]>::from(c.agg_sig_parent_puzzle_additional_data),
        expected_parent_puzzle
    );
}

#[test]
fn con_005_derived_agg_sig_fields_testnet() {
    let genesis: [u8; 32] = DIG_TESTNET.genesis_challenge().into();
    let c = DIG_TESTNET.consensus();

    let expected_parent: [u8; 32] = sha256_genesis_with_opcode(&genesis, 43);
    assert_eq!(
        <[u8; 32]>::from(c.agg_sig_parent_additional_data),
        expected_parent
    );

    let expected_puzzle: [u8; 32] = sha256_genesis_with_opcode(&genesis, 44);
    assert_eq!(
        <[u8; 32]>::from(c.agg_sig_puzzle_additional_data),
        expected_puzzle
    );

    let expected_amount: [u8; 32] = sha256_genesis_with_opcode(&genesis, 45);
    assert_eq!(
        <[u8; 32]>::from(c.agg_sig_amount_additional_data),
        expected_amount
    );

    let expected_puzzle_amount: [u8; 32] = sha256_genesis_with_opcode(&genesis, 46);
    assert_eq!(
        <[u8; 32]>::from(c.agg_sig_puzzle_amount_additional_data),
        expected_puzzle_amount
    );

    let expected_parent_amount: [u8; 32] = sha256_genesis_with_opcode(&genesis, 47);
    assert_eq!(
        <[u8; 32]>::from(c.agg_sig_parent_amount_additional_data),
        expected_parent_amount
    );

    let expected_parent_puzzle: [u8; 32] = sha256_genesis_with_opcode(&genesis, 48);
    assert_eq!(
        <[u8; 32]>::from(c.agg_sig_parent_puzzle_additional_data),
        expected_parent_puzzle
    );
}

#[test]
fn con_005_mainnet_and_testnet_derived_values_differ() {
    let mc = DIG_MAINNET.consensus();
    let tc = DIG_TESTNET.consensus();

    // Since genesis challenges differ, all derived values must differ.
    assert_ne!(
        mc.agg_sig_parent_additional_data,
        tc.agg_sig_parent_additional_data
    );
    assert_ne!(
        mc.agg_sig_puzzle_additional_data,
        tc.agg_sig_puzzle_additional_data
    );
    assert_ne!(
        mc.agg_sig_amount_additional_data,
        tc.agg_sig_amount_additional_data
    );
    assert_ne!(
        mc.agg_sig_puzzle_amount_additional_data,
        tc.agg_sig_puzzle_amount_additional_data
    );
    assert_ne!(
        mc.agg_sig_parent_amount_additional_data,
        tc.agg_sig_parent_amount_additional_data
    );
    assert_ne!(
        mc.agg_sig_parent_puzzle_additional_data,
        tc.agg_sig_parent_puzzle_additional_data
    );
}