tx_test.go raw
1 package util_test
2
3 import (
4 "bytes"
5 "github.com/p9c/p9/pkg/wire"
6 "io"
7 "reflect"
8 "testing"
9 "time"
10
11 "github.com/davecgh/go-spew/spew"
12
13 "github.com/p9c/p9/pkg/chainhash"
14 "github.com/p9c/p9/pkg/util"
15 )
16
17 var Block100000 = wire.Block{
18 Header: wire.BlockHeader{
19 Version: 1,
20 PrevBlock: chainhash.Hash(
21 [32]byte{
22 // Make go vet happy.
23 0x50, 0x12, 0x01, 0x19, 0x17, 0x2a, 0x61, 0x04,
24 0x21, 0xa6, 0xc3, 0x01, 0x1d, 0xd3, 0x30, 0xd9,
25 0xdf, 0x07, 0xb6, 0x36, 0x16, 0xc2, 0xcc, 0x1f,
26 0x1c, 0xd0, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
27 },
28 ),
29 // 000000000002d01c1fccc21636b607dfd930d31d01c3a62104612a1719011250
30 MerkleRoot: chainhash.Hash(
31 [32]byte{
32 // Make go vet happy.
33 0x66, 0x57, 0xa9, 0x25, 0x2a, 0xac, 0xd5, 0xc0,
34 0xb2, 0x94, 0x09, 0x96, 0xec, 0xff, 0x95, 0x22,
35 0x28, 0xc3, 0x06, 0x7c, 0xc3, 0x8d, 0x48, 0x85,
36 0xef, 0xb5, 0xa4, 0xac, 0x42, 0x47, 0xe9, 0xf3,
37 },
38 ),
39 // f3e94742aca4b5ef85488dc37c06c3282295ffec960994b2c0d5ac2a25a95766
40 Timestamp: time.Unix(1293623863, 0), // 2010-12-29 11:57:43 +0000 UTC
41 Bits: 0x1b04864c, // 453281356
42 Nonce: 0x10572b0f, // 274148111
43 },
44 Transactions: []*wire.MsgTx{
45 {
46 Version: 1,
47 TxIn: []*wire.TxIn{
48 {
49 PreviousOutPoint: wire.OutPoint{
50 Hash: chainhash.Hash{},
51 Index: 0xffffffff,
52 },
53 SignatureScript: []byte{
54 0x04, 0x4c, 0x86, 0x04, 0x1b, 0x02, 0x06, 0x02,
55 },
56 Sequence: 0xffffffff,
57 },
58 },
59 TxOut: []*wire.TxOut{
60 {
61 Value: 0x12a05f200, // 5000000000
62 PkScript: []byte{
63 0x41, // OP_DATA_65
64 0x04, 0x1b, 0x0e, 0x8c, 0x25, 0x67, 0xc1, 0x25,
65 0x36, 0xaa, 0x13, 0x35, 0x7b, 0x79, 0xa0, 0x73,
66 0xdc, 0x44, 0x44, 0xac, 0xb8, 0x3c, 0x4e, 0xc7,
67 0xa0, 0xe2, 0xf9, 0x9d, 0xd7, 0x45, 0x75, 0x16,
68 0xc5, 0x81, 0x72, 0x42, 0xda, 0x79, 0x69, 0x24,
69 0xca, 0x4e, 0x99, 0x94, 0x7d, 0x08, 0x7f, 0xed,
70 0xf9, 0xce, 0x46, 0x7c, 0xb9, 0xf7, 0xc6, 0x28,
71 0x70, 0x78, 0xf8, 0x01, 0xdf, 0x27, 0x6f, 0xdf,
72 0x84, // 65-byte signature
73 0xac, // OP_CHECKSIG
74 },
75 },
76 },
77 LockTime: 0,
78 },
79 {
80 Version: 1,
81 TxIn: []*wire.TxIn{
82 {
83 PreviousOutPoint: wire.OutPoint{
84 Hash: chainhash.Hash(
85 [32]byte{
86 // Make go vet happy.
87 0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60,
88 0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac,
89 0xc4, 0x1d, 0x27, 0x5e, 0xc5, 0x5f, 0xc0, 0x07,
90 0x79, 0xac, 0x88, 0xfd, 0xf3, 0x57, 0xa1, 0x87,
91 },
92 ),
93 // 87a157f3fd88ac7907c05fc55e271dc4acdc5605d187d646604ca8c0e9382e03
94 Index: 0,
95 },
96 SignatureScript: []byte{
97 0x49, // OP_DATA_73
98 0x30, 0x46, 0x02, 0x21, 0x00, 0xc3, 0x52, 0xd3,
99 0xdd, 0x99, 0x3a, 0x98, 0x1b, 0xeb, 0xa4, 0xa6,
100 0x3a, 0xd1, 0x5c, 0x20, 0x92, 0x75, 0xca, 0x94,
101 0x70, 0xab, 0xfc, 0xd5, 0x7d, 0xa9, 0x3b, 0x58,
102 0xe4, 0xeb, 0x5d, 0xce, 0x82, 0x02, 0x21, 0x00,
103 0x84, 0x07, 0x92, 0xbc, 0x1f, 0x45, 0x60, 0x62,
104 0x81, 0x9f, 0x15, 0xd3, 0x3e, 0xe7, 0x05, 0x5c,
105 0xf7, 0xb5, 0xee, 0x1a, 0xf1, 0xeb, 0xcc, 0x60,
106 0x28, 0xd9, 0xcd, 0xb1, 0xc3, 0xaf, 0x77, 0x48,
107 0x01, // 73-byte signature
108 0x41, // OP_DATA_65
109 0x04, 0xf4, 0x6d, 0xb5, 0xe9, 0xd6, 0x1a, 0x9d,
110 0xc2, 0x7b, 0x8d, 0x64, 0xad, 0x23, 0xe7, 0x38,
111 0x3a, 0x4e, 0x6c, 0xa1, 0x64, 0x59, 0x3c, 0x25,
112 0x27, 0xc0, 0x38, 0xc0, 0x85, 0x7e, 0xb6, 0x7e,
113 0xe8, 0xe8, 0x25, 0xdc, 0xa6, 0x50, 0x46, 0xb8,
114 0x2c, 0x93, 0x31, 0x58, 0x6c, 0x82, 0xe0, 0xfd,
115 0x1f, 0x63, 0x3f, 0x25, 0xf8, 0x7c, 0x16, 0x1b,
116 0xc6, 0xf8, 0xa6, 0x30, 0x12, 0x1d, 0xf2, 0xb3,
117 0xd3, // 65-byte pubkey
118 },
119 Sequence: 0xffffffff,
120 },
121 },
122 TxOut: []*wire.TxOut{
123 {
124 Value: 0x2123e300, // 556000000
125 PkScript: []byte{
126 0x76, // OP_DUP
127 0xa9, // OP_HASH160
128 0x14, // OP_DATA_20
129 0xc3, 0x98, 0xef, 0xa9, 0xc3, 0x92, 0xba, 0x60,
130 0x13, 0xc5, 0xe0, 0x4e, 0xe7, 0x29, 0x75, 0x5e,
131 0xf7, 0xf5, 0x8b, 0x32,
132 0x88, // OP_EQUALVERIFY
133 0xac, // OP_CHECKSIG
134 },
135 },
136 {
137 Value: 0x108e20f00, // 4444000000
138 PkScript: []byte{
139 0x76, // OP_DUP
140 0xa9, // OP_HASH160
141 0x14, // OP_DATA_20
142 0x94, 0x8c, 0x76, 0x5a, 0x69, 0x14, 0xd4, 0x3f,
143 0x2a, 0x7a, 0xc1, 0x77, 0xda, 0x2c, 0x2f, 0x6b,
144 0x52, 0xde, 0x3d, 0x7c,
145 0x88, // OP_EQUALVERIFY
146 0xac, // OP_CHECKSIG
147 },
148 },
149 },
150 LockTime: 0,
151 },
152 {
153 Version: 1,
154 TxIn: []*wire.TxIn{
155 {
156 PreviousOutPoint: wire.OutPoint{
157 Hash: chainhash.Hash(
158 [32]byte{
159 // Make go vet happy.
160 0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d,
161 0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27,
162 0x86, 0xaf, 0x7d, 0x7e, 0x2d, 0xe0, 0x92, 0x65,
163 0xe4, 0x1c, 0x61, 0xd0, 0x78, 0x29, 0x4e, 0xcf,
164 },
165 ),
166 // cf4e2978d0611ce46592e02d7e7daf8627a316ab69759a9f3df109a7f2bf3ec3
167 Index: 1,
168 },
169 SignatureScript: []byte{
170 0x47, // OP_DATA_71
171 0x30, 0x44, 0x02, 0x20, 0x03, 0x2d, 0x30, 0xdf,
172 0x5e, 0xe6, 0xf5, 0x7f, 0xa4, 0x6c, 0xdd, 0xb5,
173 0xeb, 0x8d, 0x0d, 0x9f, 0xe8, 0xde, 0x6b, 0x34,
174 0x2d, 0x27, 0x94, 0x2a, 0xe9, 0x0a, 0x32, 0x31,
175 0xe0, 0xba, 0x33, 0x3e, 0x02, 0x20, 0x3d, 0xee,
176 0xe8, 0x06, 0x0f, 0xdc, 0x70, 0x23, 0x0a, 0x7f,
177 0x5b, 0x4a, 0xd7, 0xd7, 0xbc, 0x3e, 0x62, 0x8c,
178 0xbe, 0x21, 0x9a, 0x88, 0x6b, 0x84, 0x26, 0x9e,
179 0xae, 0xb8, 0x1e, 0x26, 0xb4, 0xfe, 0x01,
180 0x41, // OP_DATA_65
181 0x04, 0xae, 0x31, 0xc3, 0x1b, 0xf9, 0x12, 0x78,
182 0xd9, 0x9b, 0x83, 0x77, 0xa3, 0x5b, 0xbc, 0xe5,
183 0xb2, 0x7d, 0x9f, 0xff, 0x15, 0x45, 0x68, 0x39,
184 0xe9, 0x19, 0x45, 0x3f, 0xc7, 0xb3, 0xf7, 0x21,
185 0xf0, 0xba, 0x40, 0x3f, 0xf9, 0x6c, 0x9d, 0xee,
186 0xb6, 0x80, 0xe5, 0xfd, 0x34, 0x1c, 0x0f, 0xc3,
187 0xa7, 0xb9, 0x0d, 0xa4, 0x63, 0x1e, 0xe3, 0x95,
188 0x60, 0x63, 0x9d, 0xb4, 0x62, 0xe9, 0xcb, 0x85,
189 0x0f, // 65-byte pubkey
190 },
191 Sequence: 0xffffffff,
192 },
193 },
194 TxOut: []*wire.TxOut{
195 {
196 Value: 0xf4240, // 1000000
197 PkScript: []byte{
198 0x76, // OP_DUP
199 0xa9, // OP_HASH160
200 0x14, // OP_DATA_20
201 0xb0, 0xdc, 0xbf, 0x97, 0xea, 0xbf, 0x44, 0x04,
202 0xe3, 0x1d, 0x95, 0x24, 0x77, 0xce, 0x82, 0x2d,
203 0xad, 0xbe, 0x7e, 0x10,
204 0x88, // OP_EQUALVERIFY
205 0xac, // OP_CHECKSIG
206 },
207 },
208 {
209 Value: 0x11d260c0, // 299000000
210 PkScript: []byte{
211 0x76, // OP_DUP
212 0xa9, // OP_HASH160
213 0x14, // OP_DATA_20
214 0x6b, 0x12, 0x81, 0xee, 0xc2, 0x5a, 0xb4, 0xe1,
215 0xe0, 0x79, 0x3f, 0xf4, 0xe0, 0x8a, 0xb1, 0xab,
216 0xb3, 0x40, 0x9c, 0xd9,
217 0x88, // OP_EQUALVERIFY
218 0xac, // OP_CHECKSIG
219 },
220 },
221 },
222 LockTime: 0,
223 },
224 {
225 Version: 1,
226 TxIn: []*wire.TxIn{
227 {
228 PreviousOutPoint: wire.OutPoint{
229 Hash: chainhash.Hash(
230 [32]byte{
231 // Make go vet happy.
232 0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73,
233 0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac,
234 0x3b, 0x24, 0x0c, 0x84, 0xb9, 0x17, 0xa3, 0x90,
235 0x9b, 0xa1, 0xc4, 0x3d, 0xed, 0x5f, 0x51, 0xf4,
236 },
237 ),
238 // f4515fed3dc4a19b90a317b9840c243bac26114cf637522373a7d486b372600b
239 Index: 0,
240 },
241 SignatureScript: []byte{
242 0x49, // OP_DATA_73
243 0x30, 0x46, 0x02, 0x21, 0x00, 0xbb, 0x1a, 0xd2,
244 0x6d, 0xf9, 0x30, 0xa5, 0x1c, 0xce, 0x11, 0x0c,
245 0xf4, 0x4f, 0x7a, 0x48, 0xc3, 0xc5, 0x61, 0xfd,
246 0x97, 0x75, 0x00, 0xb1, 0xae, 0x5d, 0x6b, 0x6f,
247 0xd1, 0x3d, 0x0b, 0x3f, 0x4a, 0x02, 0x21, 0x00,
248 0xc5, 0xb4, 0x29, 0x51, 0xac, 0xed, 0xff, 0x14,
249 0xab, 0xba, 0x27, 0x36, 0xfd, 0x57, 0x4b, 0xdb,
250 0x46, 0x5f, 0x3e, 0x6f, 0x8d, 0xa1, 0x2e, 0x2c,
251 0x53, 0x03, 0x95, 0x4a, 0xca, 0x7f, 0x78, 0xf3,
252 0x01, // 73-byte signature
253 0x41, // OP_DATA_65
254 0x04, 0xa7, 0x13, 0x5b, 0xfe, 0x82, 0x4c, 0x97,
255 0xec, 0xc0, 0x1e, 0xc7, 0xd7, 0xe3, 0x36, 0x18,
256 0x5c, 0x81, 0xe2, 0xaa, 0x2c, 0x41, 0xab, 0x17,
257 0x54, 0x07, 0xc0, 0x94, 0x84, 0xce, 0x96, 0x94,
258 0xb4, 0x49, 0x53, 0xfc, 0xb7, 0x51, 0x20, 0x65,
259 0x64, 0xa9, 0xc2, 0x4d, 0xd0, 0x94, 0xd4, 0x2f,
260 0xdb, 0xfd, 0xd5, 0xaa, 0xd3, 0xe0, 0x63, 0xce,
261 0x6a, 0xf4, 0xcf, 0xaa, 0xea, 0x4e, 0xa1, 0x4f,
262 0xbb, // 65-byte pubkey
263 },
264 Sequence: 0xffffffff,
265 },
266 },
267 TxOut: []*wire.TxOut{
268 {
269 Value: 0xf4240, // 1000000
270 PkScript: []byte{
271 0x76, // OP_DUP
272 0xa9, // OP_HASH160
273 0x14, // OP_DATA_20
274 0x39, 0xaa, 0x3d, 0x56, 0x9e, 0x06, 0xa1, 0xd7,
275 0x92, 0x6d, 0xc4, 0xbe, 0x11, 0x93, 0xc9, 0x9b,
276 0xf2, 0xeb, 0x9e, 0xe0,
277 0x88, // OP_EQUALVERIFY
278 0xac, // OP_CHECKSIG
279 },
280 },
281 },
282 LockTime: 0,
283 },
284 },
285 }
286
287 // TestTx tests the API for Tx.
288 func TestTx(t *testing.T) {
289 testTx := Block100000.Transactions[0]
290 tx := util.NewTx(testTx)
291 // Ensure we get the same data back out.
292 if msgTx := tx.MsgTx(); !reflect.DeepEqual(msgTx, testTx) {
293 t.Errorf("MsgTx: mismatched MsgTx - got %v, want %v",
294 spew.Sdump(msgTx), spew.Sdump(testTx),
295 )
296 }
297 // Ensure transaction index set and get work properly.
298 wantIndex := 0
299 tx.SetIndex(0)
300 if gotIndex := tx.Index(); gotIndex != wantIndex {
301 t.Errorf("Index: mismatched index - got %v, want %v",
302 gotIndex, wantIndex,
303 )
304 }
305 // Hash for block 100,000 transaction 0.
306 wantHashStr := "8c14f0db3df150123e6f3dbbf30f8b955a8249b62ac1d1ff16284aefa3d06d87"
307 wantHash, e := chainhash.NewHashFromStr(wantHashStr)
308 if e != nil {
309 t.Errorf("NewHashFromStr: %v", e)
310 }
311 // Request the hash multiple times to test generation and caching.
312 for i := 0; i < 2; i++ {
313 hash := tx.Hash()
314 if !hash.IsEqual(wantHash) {
315 t.Errorf("Hash #%d mismatched hash - got %v, want %v", i,
316 hash, wantHash,
317 )
318 }
319 }
320 }
321
322 // TestNewTxFromBytes tests creation of a Tx from serialized bytes.
323 func TestNewTxFromBytes(t *testing.T) {
324 // Serialize the test transaction.
325 testTx := Block100000.Transactions[0]
326 var testTxBuf bytes.Buffer
327 e := testTx.Serialize(&testTxBuf)
328 if e != nil {
329 t.Errorf("Serialize: %v", e)
330 }
331 testTxBytes := testTxBuf.Bytes()
332 // Create a new transaction from the serialized bytes.
333 tx, e := util.NewTxFromBytes(testTxBytes)
334 if e != nil {
335 t.Errorf("NewTxFromBytes: %v", e)
336 return
337 }
338 // Ensure the generated MsgTx is correct.
339 if msgTx := tx.MsgTx(); !reflect.DeepEqual(msgTx, testTx) {
340 t.Errorf("MsgTx: mismatched MsgTx - got %v, want %v",
341 spew.Sdump(msgTx), spew.Sdump(testTx),
342 )
343 }
344 }
345
346 // TestTxErrors tests the error paths for the Tx API.
347 func TestTxErrors(t *testing.T) {
348 // Serialize the test transaction.
349 testTx := Block100000.Transactions[0]
350 var testTxBuf bytes.Buffer
351 e := testTx.Serialize(&testTxBuf)
352 if e != nil {
353 t.Errorf("Serialize: %v", e)
354 }
355 testTxBytes := testTxBuf.Bytes()
356 // Truncate the transaction byte buffer to force errors.
357 shortBytes := testTxBytes[:4]
358 _, e = util.NewTxFromBytes(shortBytes)
359 if e != io.EOF {
360 t.Errorf("NewTxFromBytes: did not get expected error - "+
361 "got %v, want %v", e, io.EOF,
362 )
363 }
364 }
365