-
Notifications
You must be signed in to change notification settings - Fork 3
/
types.go
270 lines (242 loc) · 7.62 KB
/
types.go
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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
package dbtypes
import (
"database/sql/driver"
"encoding/json"
"fmt"
"strconv"
"github.com/dcrdata/dcrdata/db/dbtypes/internal"
)
// SyncResult is the result of a database sync operation, containing the height
// of the last block and an arror value.
type SyncResult struct {
Height int64
Error error
}
// JSONB is used to implement the sql.Scanner and driver.Valuer interfaces
// required for the type to make a postgresql compatible JSONB type.
type JSONB map[string]interface{}
// Value satisfies driver.Valuer
func (p VinTxPropertyARRAY) Value() (driver.Value, error) {
j, err := json.Marshal(p)
return j, err
}
// Scan satisfies sql.Scanner
func (p *VinTxPropertyARRAY) Scan(src interface{}) error {
source, ok := src.([]byte)
if !ok {
return fmt.Errorf("scan type assertion .([]byte) failed")
}
var i interface{}
err := json.Unmarshal(source, &i)
if err != nil {
return err
}
// Set this JSONB
is, ok := i.([]interface{})
if !ok {
return fmt.Errorf("type assertion .([]interface{}) failed")
}
numVin := len(is)
ba := make(VinTxPropertyARRAY, numVin)
for ii := range is {
VinTxPropertyMapIface, ok := is[ii].(map[string]interface{})
if !ok {
return fmt.Errorf("type assertion .(map[string]interface) failed")
}
b, _ := json.Marshal(VinTxPropertyMapIface)
json.Unmarshal(b, &ba[ii])
}
*p = ba
return nil
}
// VinTxPropertyARRAY is a slice of VinTxProperty sturcts that implements
// sql.Scanner and driver.Valuer.
type VinTxPropertyARRAY []VinTxProperty
// func VinTxPropertyToJSONB(vin *VinTxProperty) (JSONB, error) {
// var vinJSONB map[string]interface{}
// vinJSON, err := json.Marshal(vin)
// if err != nil {
// return vinJSONB, err
// }
// var vinInterface interface{}
// err = json.Unmarshal(vinJSON, &vinInterface)
// if err != nil {
// return vinJSONB, err
// }
// vinJSONB = vinInterface.(map[string]interface{})
// return vinJSONB, nil
// }
// UInt64Array represents a one-dimensional array of PostgreSQL integer types
type UInt64Array []uint64
// Scan implements the sql.Scanner interface.
func (a *UInt64Array) Scan(src interface{}) error {
switch src := src.(type) {
case []byte:
return a.scanBytes(src)
case string:
return a.scanBytes([]byte(src))
case nil:
*a = nil
return nil
}
return fmt.Errorf("pq: cannot convert %T to UInt64Array", src)
}
func (a *UInt64Array) scanBytes(src []byte) error {
elems, err := internal.ScanLinearArray(src, []byte{','}, "UInt64Array")
if err != nil {
return err
}
if *a != nil && len(elems) == 0 {
*a = (*a)[:0]
} else {
b := make(UInt64Array, len(elems))
for i, v := range elems {
if b[i], err = strconv.ParseUint(string(v), 10, 64); err != nil {
return fmt.Errorf("pq: parsing array element index %d: %v", i, err)
}
}
*a = b
}
return nil
}
// Value implements the driver.Valuer interface.
func (a UInt64Array) Value() (driver.Value, error) {
if a == nil {
return nil, nil
}
if n := len(a); n > 0 {
// There will be at least two curly brackets, N bytes of values,
// and N-1 bytes of delimiters.
b := make([]byte, 1, 1+2*n)
b[0] = '{'
b = strconv.AppendUint(b, a[0], 10)
for i := 1; i < n; i++ {
b = append(b, ',')
b = strconv.AppendUint(b, a[i], 10)
}
return string(append(b, '}')), nil
}
return "{}", nil
}
// Vout defines a transaction output
type Vout struct {
// txDbID int64
TxHash string `json:"tx_hash"`
TxIndex uint32 `json:"tx_index"`
TxTree int8 `json:"tx_tree"`
Value uint64 `json:"value"`
Version uint16 `json:"version"`
ScriptPubKey []byte `json:"pkScriptHex"`
ScriptPubKeyData ScriptPubKeyData `json:"pkScript"`
}
// AddressRow represents a row in the addresses table
type AddressRow struct {
// id int64
Address string
FundingTxDbID uint64
FundingTxHash string
FundingTxVoutIndex uint32
VoutDbID uint64
Value uint64
SpendingTxDbID uint64
SpendingTxHash string
SpendingTxVinIndex uint32
VinDbID uint64
}
// ScriptPubKeyData is part of the result of decodescript(ScriptPubKeyHex)
type ScriptPubKeyData struct {
ReqSigs uint32 `json:"reqSigs"`
Type string `json:"type"`
Addresses []string `json:"addresses"`
}
// VinTxProperty models a transaction input with previous outpoint information.
type VinTxProperty struct {
PrevOut string `json:"prevout"`
PrevTxHash string `json:"prevtxhash"`
PrevTxIndex uint32 `json:"prevvoutidx"`
PrevTxTree uint16 `json:"tree"`
Sequence uint32 `json:"sequence"`
ValueIn uint64 `json:"amountin"`
TxID string `json:"tx_hash"`
TxIndex uint32 `json:"tx_index"`
TxTree uint16 `json:"tx_tree"`
BlockHeight uint32 `json:"blockheight"`
BlockIndex uint32 `json:"blockindex"`
ScriptHex []byte `json:"scripthex"`
}
// Vin models a transaction input.
type Vin struct {
//txDbID int64
Coinbase string `json:"coinbase"`
TxHash string `json:"txhash"`
VoutIdx uint32 `json:"voutidx"`
Tree int8 `json:"tree"`
Sequence uint32 `json:"sequence"`
AmountIn float64 `json:"amountin"`
BlockHeight uint32 `json:"blockheight"`
BlockIndex uint32 `json:"blockindex"`
ScriptHex string `json:"scripthex"`
}
// ScriptSig models the signature script used to redeem the origin transaction
// as a JSON object (non-coinbase txns only)
type ScriptSig struct {
Asm string `json:"asm"`
Hex string `json:"hex"`
}
// Tx models a Decred transaction. It is stored in a Block.
type Tx struct {
//blockDbID int64
BlockHash string `json:"block_hash"`
BlockHeight int64 `json:"block_height"`
BlockTime int64 `json:"block_time"`
Time int64 `json:"time"`
TxType int16 `json:"tx_type"`
Version uint16 `json:"version"`
Tree int8 `json:"tree"`
TxID string `json:"txid"`
BlockIndex uint32 `json:"block_index"`
Locktime uint32 `json:"locktime"`
Expiry uint32 `json:"expiry"`
Size uint32 `json:"size"`
Spent int64 `json:"spent"`
Sent int64 `json:"sent"`
Fees int64 `json:"fees"`
NumVin uint32 `json:"numvin"`
Vins VinTxPropertyARRAY `json:"vins"`
VinDbIds []uint64 `json:"vindbids"`
NumVout uint32 `json:"numvout"`
Vouts []*Vout `json:"vouts"`
VoutDbIds []uint64 `json:"voutdbids"`
// NOTE: VoutDbIds may not be needed if there is a vout table since each
// vout will have a tx_dbid
}
// Block models a Decred block.
type Block struct {
Hash string `json:"hash"`
Size uint32 `json:"size"`
Height uint32 `json:"height"`
Version uint32 `json:"version"`
MerkleRoot string `json:"merkleroot"`
StakeRoot string `json:"stakeroot"`
NumTx uint32
NumRegTx uint32
Tx []string `json:"tx"`
TxDbIDs []uint64
NumStakeTx uint32
STx []string `json:"stx"`
STxDbIDs []uint64
Time uint64 `json:"time"`
Nonce uint64 `json:"nonce"`
VoteBits uint16 `json:"votebits"`
FinalState []byte `json:"finalstate"`
Voters uint16 `json:"voters"`
FreshStake uint8 `json:"freshstake"`
Revocations uint8 `json:"revocations"`
PoolSize uint32 `json:"poolsize"`
Bits uint32 `json:"bits"`
SBits uint64 `json:"sbits"`
Difficulty float64 `json:"difficulty"`
ExtraData []byte `json:"extradata"`
StakeVersion uint32 `json:"stakeversion"`
PreviousHash string `json:"previousblockhash"`
}