chainhook-types 1.3.8

Bitcoin and Stacks data schemas, based on the Rosetta specification
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

use crate::StacksTransactionData;

#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct NakamotoBlockHeaderData {
    pub version: u8,
    pub chain_length: u64,
    pub burn_spent: u64,
    pub consensus_hash: String,
    pub parent_block_id: String,
    pub tx_merkle_root: String,
    pub state_index_root: String,
    pub timestamp: u64,
    pub miner_signature: String,
    pub signer_signature: Vec<String>,
    pub pox_treatment: String,
}

#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct NakamotoBlockData {
    pub header: NakamotoBlockHeaderData,
    pub block_hash: String,
    pub index_block_hash: String,
    pub transactions: Vec<StacksTransactionData>,
}

#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct BlockProposalData {
    pub block: NakamotoBlockData,
    pub burn_height: u64,
    pub reward_cycle: u64,
}

#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct BlockAcceptedResponse {
    pub signer_signature_hash: String,
    pub signature: String,
    pub metadata: SignerMessageMetadata,
}

#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct SignerMessageMetadata {
    pub server_version: String,
}

#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum BlockValidationFailedCode {
    BadBlockHash,
    BadTransaction,
    InvalidBlock,
    ChainstateError,
    UnknownParent,
    NonCanonicalTenure,
    NoSuchTenure,
}

#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum BlockRejectReasonCode {
    #[serde(rename_all = "SCREAMING_SNAKE_CASE")] 
    ValidationFailed {
        #[serde(rename = "VALIDATION_FAILED")]
        validation_failed: BlockValidationFailedCode,
    },
    ConnectivityIssues,
    RejectedInPriorRound,
    NoSortitionView,
    SortitionViewMismatch,
    TestingDirective,
}

#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct BlockRejectedResponse {
    pub reason: String,
    pub reason_code: BlockRejectReasonCode,
    pub signer_signature_hash: String,
    pub chain_id: u32,
    pub signature: String,
    pub metadata: SignerMessageMetadata,
}

#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
#[serde(tag = "type", content = "data")]
pub enum BlockResponseData {
    Accepted(BlockAcceptedResponse),
    Rejected(BlockRejectedResponse),
}

#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct BlockPushedData {
    pub block: NakamotoBlockData,
}

#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct PeerInfoData {
    pub burn_block_height: u64,
    pub stacks_tip_consensus_hash: String,
    pub stacks_tip: String,
    pub stacks_tip_height: u64,
    pub pox_consensus: String,
    pub server_version: String,
    pub network_id: u32,
    pub index_block_hash: String,
}

#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct MockProposalData {
    pub peer_info: PeerInfoData,
}

#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct MockSignatureData {
    pub mock_proposal: MockProposalData,
    pub metadata: SignerMessageMetadata,
    pub signature: String,
    pub pubkey: String,
}

#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct MockBlockData {
    pub mock_proposal: MockProposalData,
    pub mock_signatures: Vec<MockSignatureData>
}

#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
#[serde(tag = "type", content = "data")]
pub enum StacksSignerMessage {
    BlockProposal(BlockProposalData),
    BlockResponse(BlockResponseData),
    BlockPushed(BlockPushedData),
    MockSignature(MockSignatureData),
    MockProposal(PeerInfoData),
    MockBlock(MockBlockData),
}

#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct StacksStackerDbChunk {
    pub contract: String,
    pub sig: String,
    pub pubkey: String,
    pub message: StacksSignerMessage,
}