forked from Onyx-Protocol/Onyx
/
ops.go
486 lines (448 loc) · 13.1 KB
/
ops.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
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
package vm
import (
"encoding/binary"
"fmt"
"math"
"chain/errors"
"chain/math/checked"
)
type Op uint8
func (op Op) String() string {
return ops[op].name
}
type Instruction struct {
Op Op
Len uint32
Data []byte
}
const (
OP_FALSE Op = 0x00
OP_0 Op = 0x00 // synonym
OP_1 Op = 0x51
OP_TRUE Op = 0x51 // synonym
OP_2 Op = 0x52
OP_3 Op = 0x53
OP_4 Op = 0x54
OP_5 Op = 0x55
OP_6 Op = 0x56
OP_7 Op = 0x57
OP_8 Op = 0x58
OP_9 Op = 0x59
OP_10 Op = 0x5a
OP_11 Op = 0x5b
OP_12 Op = 0x5c
OP_13 Op = 0x5d
OP_14 Op = 0x5e
OP_15 Op = 0x5f
OP_16 Op = 0x60
OP_DATA_1 Op = 0x01
OP_DATA_2 Op = 0x02
OP_DATA_3 Op = 0x03
OP_DATA_4 Op = 0x04
OP_DATA_5 Op = 0x05
OP_DATA_6 Op = 0x06
OP_DATA_7 Op = 0x07
OP_DATA_8 Op = 0x08
OP_DATA_9 Op = 0x09
OP_DATA_10 Op = 0x0a
OP_DATA_11 Op = 0x0b
OP_DATA_12 Op = 0x0c
OP_DATA_13 Op = 0x0d
OP_DATA_14 Op = 0x0e
OP_DATA_15 Op = 0x0f
OP_DATA_16 Op = 0x10
OP_DATA_17 Op = 0x11
OP_DATA_18 Op = 0x12
OP_DATA_19 Op = 0x13
OP_DATA_20 Op = 0x14
OP_DATA_21 Op = 0x15
OP_DATA_22 Op = 0x16
OP_DATA_23 Op = 0x17
OP_DATA_24 Op = 0x18
OP_DATA_25 Op = 0x19
OP_DATA_26 Op = 0x1a
OP_DATA_27 Op = 0x1b
OP_DATA_28 Op = 0x1c
OP_DATA_29 Op = 0x1d
OP_DATA_30 Op = 0x1e
OP_DATA_31 Op = 0x1f
OP_DATA_32 Op = 0x20
OP_DATA_33 Op = 0x21
OP_DATA_34 Op = 0x22
OP_DATA_35 Op = 0x23
OP_DATA_36 Op = 0x24
OP_DATA_37 Op = 0x25
OP_DATA_38 Op = 0x26
OP_DATA_39 Op = 0x27
OP_DATA_40 Op = 0x28
OP_DATA_41 Op = 0x29
OP_DATA_42 Op = 0x2a
OP_DATA_43 Op = 0x2b
OP_DATA_44 Op = 0x2c
OP_DATA_45 Op = 0x2d
OP_DATA_46 Op = 0x2e
OP_DATA_47 Op = 0x2f
OP_DATA_48 Op = 0x30
OP_DATA_49 Op = 0x31
OP_DATA_50 Op = 0x32
OP_DATA_51 Op = 0x33
OP_DATA_52 Op = 0x34
OP_DATA_53 Op = 0x35
OP_DATA_54 Op = 0x36
OP_DATA_55 Op = 0x37
OP_DATA_56 Op = 0x38
OP_DATA_57 Op = 0x39
OP_DATA_58 Op = 0x3a
OP_DATA_59 Op = 0x3b
OP_DATA_60 Op = 0x3c
OP_DATA_61 Op = 0x3d
OP_DATA_62 Op = 0x3e
OP_DATA_63 Op = 0x3f
OP_DATA_64 Op = 0x40
OP_DATA_65 Op = 0x41
OP_DATA_66 Op = 0x42
OP_DATA_67 Op = 0x43
OP_DATA_68 Op = 0x44
OP_DATA_69 Op = 0x45
OP_DATA_70 Op = 0x46
OP_DATA_71 Op = 0x47
OP_DATA_72 Op = 0x48
OP_DATA_73 Op = 0x49
OP_DATA_74 Op = 0x4a
OP_DATA_75 Op = 0x4b
OP_PUSHDATA1 Op = 0x4c
OP_PUSHDATA2 Op = 0x4d
OP_PUSHDATA4 Op = 0x4e
OP_1NEGATE Op = 0x4f
OP_NOP Op = 0x61
OP_JUMP Op = 0x63
OP_JUMPIF Op = 0x64
OP_VERIFY Op = 0x69
OP_FAIL Op = 0x6a
OP_CHECKPREDICATE Op = 0xc0
OP_TOALTSTACK Op = 0x6b
OP_FROMALTSTACK Op = 0x6c
OP_2DROP Op = 0x6d
OP_2DUP Op = 0x6e
OP_3DUP Op = 0x6f
OP_2OVER Op = 0x70
OP_2ROT Op = 0x71
OP_2SWAP Op = 0x72
OP_IFDUP Op = 0x73
OP_DEPTH Op = 0x74
OP_DROP Op = 0x75
OP_DUP Op = 0x76
OP_NIP Op = 0x77
OP_OVER Op = 0x78
OP_PICK Op = 0x79
OP_ROLL Op = 0x7a
OP_ROT Op = 0x7b
OP_SWAP Op = 0x7c
OP_TUCK Op = 0x7d
OP_CAT Op = 0x7e
OP_SUBSTR Op = 0x7f
OP_LEFT Op = 0x80
OP_RIGHT Op = 0x81
OP_SIZE Op = 0x82
OP_CATPUSHDATA Op = 0x89
OP_INVERT Op = 0x83
OP_AND Op = 0x84
OP_OR Op = 0x85
OP_XOR Op = 0x86
OP_EQUAL Op = 0x87
OP_EQUALVERIFY Op = 0x88
OP_1ADD Op = 0x8b
OP_1SUB Op = 0x8c
OP_2MUL Op = 0x8d
OP_2DIV Op = 0x8e
OP_NEGATE Op = 0x8f
OP_ABS Op = 0x90
OP_NOT Op = 0x91
OP_0NOTEQUAL Op = 0x92
OP_ADD Op = 0x93
OP_SUB Op = 0x94
OP_MUL Op = 0x95
OP_DIV Op = 0x96
OP_MOD Op = 0x97
OP_LSHIFT Op = 0x98
OP_RSHIFT Op = 0x99
OP_BOOLAND Op = 0x9a
OP_BOOLOR Op = 0x9b
OP_NUMEQUAL Op = 0x9c
OP_NUMEQUALVERIFY Op = 0x9d
OP_NUMNOTEQUAL Op = 0x9e
OP_LESSTHAN Op = 0x9f
OP_GREATERTHAN Op = 0xa0
OP_LESSTHANOREQUAL Op = 0xa1
OP_GREATERTHANOREQUAL Op = 0xa2
OP_MIN Op = 0xa3
OP_MAX Op = 0xa4
OP_WITHIN Op = 0xa5
OP_RIPEMD160 Op = 0xa6
OP_SHA1 Op = 0xa7
OP_SHA256 Op = 0xa8
OP_SHA3 Op = 0xaa
OP_CHECKSIG Op = 0xac
OP_CHECKMULTISIG Op = 0xad
OP_TXSIGHASH Op = 0xae
OP_BLOCKSIGHASH Op = 0xaf
OP_CHECKOUTPUT Op = 0xc1
OP_ASSET Op = 0xc2
OP_AMOUNT Op = 0xc3
OP_PROGRAM Op = 0xc4
OP_MINTIME Op = 0xc5
OP_MAXTIME Op = 0xc6
OP_TXREFDATAHASH Op = 0xc7
OP_REFDATAHASH Op = 0xc8
OP_INDEX Op = 0xc9
OP_OUTPOINT Op = 0xcb
OP_NONCE Op = 0xcc
OP_NEXTPROGRAM Op = 0xcd
OP_BLOCKTIME Op = 0xce
)
type opInfo struct {
op Op
name string
fn func(*virtualMachine) error
}
var (
ops = [256]opInfo{
// data pushing
OP_FALSE: {OP_FALSE, "FALSE", opFalse},
// sic: the PUSHDATA ops all share an implementation
OP_PUSHDATA1: {OP_PUSHDATA1, "PUSHDATA1", opPushdata},
OP_PUSHDATA2: {OP_PUSHDATA2, "PUSHDATA2", opPushdata},
OP_PUSHDATA4: {OP_PUSHDATA4, "PUSHDATA4", opPushdata},
OP_1NEGATE: {OP_1NEGATE, "1NEGATE", op1Negate},
OP_NOP: {OP_NOP, "NOP", opNop},
// control flow
OP_JUMP: {OP_JUMP, "JUMP", opJump},
OP_JUMPIF: {OP_JUMPIF, "JUMPIF", opJumpIf},
OP_VERIFY: {OP_VERIFY, "VERIFY", opVerify},
OP_FAIL: {OP_FAIL, "FAIL", opFail},
OP_TOALTSTACK: {OP_TOALTSTACK, "TOALTSTACK", opToAltStack},
OP_FROMALTSTACK: {OP_FROMALTSTACK, "FROMALTSTACK", opFromAltStack},
OP_2DROP: {OP_2DROP, "2DROP", op2Drop},
OP_2DUP: {OP_2DUP, "2DUP", op2Dup},
OP_3DUP: {OP_3DUP, "3DUP", op3Dup},
OP_2OVER: {OP_2OVER, "2OVER", op2Over},
OP_2ROT: {OP_2ROT, "2ROT", op2Rot},
OP_2SWAP: {OP_2SWAP, "2SWAP", op2Swap},
OP_IFDUP: {OP_IFDUP, "IFDUP", opIfDup},
OP_DEPTH: {OP_DEPTH, "DEPTH", opDepth},
OP_DROP: {OP_DROP, "DROP", opDrop},
OP_DUP: {OP_DUP, "DUP", opDup},
OP_NIP: {OP_NIP, "NIP", opNip},
OP_OVER: {OP_OVER, "OVER", opOver},
OP_PICK: {OP_PICK, "PICK", opPick},
OP_ROLL: {OP_ROLL, "ROLL", opRoll},
OP_ROT: {OP_ROT, "ROT", opRot},
OP_SWAP: {OP_SWAP, "SWAP", opSwap},
OP_TUCK: {OP_TUCK, "TUCK", opTuck},
OP_CAT: {OP_CAT, "CAT", opCat},
OP_SUBSTR: {OP_SUBSTR, "SUBSTR", opSubstr},
OP_LEFT: {OP_LEFT, "LEFT", opLeft},
OP_RIGHT: {OP_RIGHT, "RIGHT", opRight},
OP_SIZE: {OP_SIZE, "SIZE", opSize},
OP_CATPUSHDATA: {OP_CATPUSHDATA, "CATPUSHDATA", opCatpushdata},
OP_INVERT: {OP_INVERT, "INVERT", opInvert},
OP_AND: {OP_AND, "AND", opAnd},
OP_OR: {OP_OR, "OR", opOr},
OP_XOR: {OP_XOR, "XOR", opXor},
OP_EQUAL: {OP_EQUAL, "EQUAL", opEqual},
OP_EQUALVERIFY: {OP_EQUALVERIFY, "EQUALVERIFY", opEqualVerify},
OP_1ADD: {OP_1ADD, "1ADD", op1Add},
OP_1SUB: {OP_1SUB, "1SUB", op1Sub},
OP_2MUL: {OP_2MUL, "2MUL", op2Mul},
OP_2DIV: {OP_2DIV, "2DIV", op2Div},
OP_NEGATE: {OP_NEGATE, "NEGATE", opNegate},
OP_ABS: {OP_ABS, "ABS", opAbs},
OP_NOT: {OP_NOT, "NOT", opNot},
OP_0NOTEQUAL: {OP_0NOTEQUAL, "0NOTEQUAL", op0NotEqual},
OP_ADD: {OP_ADD, "ADD", opAdd},
OP_SUB: {OP_SUB, "SUB", opSub},
OP_MUL: {OP_MUL, "MUL", opMul},
OP_DIV: {OP_DIV, "DIV", opDiv},
OP_MOD: {OP_MOD, "MOD", opMod},
OP_LSHIFT: {OP_LSHIFT, "LSHIFT", opLshift},
OP_RSHIFT: {OP_RSHIFT, "RSHIFT", opRshift},
OP_BOOLAND: {OP_BOOLAND, "BOOLAND", opBoolAnd},
OP_BOOLOR: {OP_BOOLOR, "BOOLOR", opBoolOr},
OP_NUMEQUAL: {OP_NUMEQUAL, "NUMEQUAL", opNumEqual},
OP_NUMEQUALVERIFY: {OP_NUMEQUALVERIFY, "NUMEQUALVERIFY", opNumEqualVerify},
OP_NUMNOTEQUAL: {OP_NUMNOTEQUAL, "NUMNOTEQUAL", opNumNotEqual},
OP_LESSTHAN: {OP_LESSTHAN, "LESSTHAN", opLessThan},
OP_GREATERTHAN: {OP_GREATERTHAN, "GREATERTHAN", opGreaterThan},
OP_LESSTHANOREQUAL: {OP_LESSTHANOREQUAL, "LESSTHANOREQUAL", opLessThanOrEqual},
OP_GREATERTHANOREQUAL: {OP_GREATERTHANOREQUAL, "GREATERTHANOREQUAL", opGreaterThanOrEqual},
OP_MIN: {OP_MIN, "MIN", opMin},
OP_MAX: {OP_MAX, "MAX", opMax},
OP_WITHIN: {OP_WITHIN, "WITHIN", opWithin},
OP_RIPEMD160: {OP_RIPEMD160, "RIPEMD160", opRipemd160},
OP_SHA1: {OP_SHA1, "SHA1", opSha1},
OP_SHA256: {OP_SHA256, "SHA256", opSha256},
OP_SHA3: {OP_SHA3, "SHA3", opSha3},
OP_CHECKSIG: {OP_CHECKSIG, "CHECKSIG", opCheckSig},
OP_CHECKMULTISIG: {OP_CHECKMULTISIG, "CHECKMULTISIG", opCheckMultiSig},
OP_TXSIGHASH: {OP_TXSIGHASH, "TXSIGHASH", opTxSigHash},
OP_BLOCKSIGHASH: {OP_BLOCKSIGHASH, "BLOCKSIGHASH", opBlockSigHash},
OP_CHECKOUTPUT: {OP_CHECKOUTPUT, "CHECKOUTPUT", opCheckOutput},
OP_ASSET: {OP_ASSET, "ASSET", opAsset},
OP_AMOUNT: {OP_AMOUNT, "AMOUNT", opAmount},
OP_PROGRAM: {OP_PROGRAM, "PROGRAM", opProgram},
OP_MINTIME: {OP_MINTIME, "MINTIME", opMinTime},
OP_MAXTIME: {OP_MAXTIME, "MAXTIME", opMaxTime},
OP_TXREFDATAHASH: {OP_TXREFDATAHASH, "TXREFDATAHASH", opTxRefDataHash},
OP_REFDATAHASH: {OP_REFDATAHASH, "REFDATAHASH", opRefDataHash},
OP_INDEX: {OP_INDEX, "INDEX", opIndex},
OP_OUTPOINT: {OP_OUTPOINT, "OUTPOINT", opOutpoint},
OP_NONCE: {OP_NONCE, "NONCE", opNonce},
OP_NEXTPROGRAM: {OP_NEXTPROGRAM, "NEXTPROGRAM", opNextProgram},
OP_BLOCKTIME: {OP_BLOCKTIME, "BLOCKTIME", opBlockTime},
}
opsByName map[string]opInfo
)
// ParseOp parses the op at position pc in prog, returning the parsed
// instruction (opcode plus any associated data).
func ParseOp(prog []byte, pc uint32) (inst Instruction, err error) {
if len(prog) > math.MaxInt32 {
err = ErrLongProgram
}
l := uint32(len(prog))
if pc >= l {
err = ErrShortProgram
return
}
opcode := Op(prog[pc])
inst.Op = opcode
inst.Len = 1
if opcode >= OP_1 && opcode <= OP_16 {
inst.Data = []byte{uint8(opcode-OP_1) + 1}
return
}
if opcode >= OP_DATA_1 && opcode <= OP_DATA_75 {
inst.Len += uint32(opcode - OP_DATA_1 + 1)
end, ok := checked.AddUint32(pc, inst.Len)
if !ok {
err = errors.WithDetail(checked.ErrOverflow, "data length exceeds max program size")
return
}
if end > l {
err = ErrShortProgram
return
}
inst.Data = prog[pc+1 : end]
return
}
if opcode == OP_PUSHDATA1 {
if pc == l-1 {
err = ErrShortProgram
return
}
n := prog[pc+1]
inst.Len += uint32(n) + 1
end, ok := checked.AddUint32(pc, inst.Len)
if !ok {
err = errors.WithDetail(checked.ErrOverflow, "data length exceeds max program size")
}
if end > l {
err = ErrShortProgram
return
}
inst.Data = prog[pc+2 : end]
return
}
if opcode == OP_PUSHDATA2 {
if len(prog) < 3 || pc > l-3 {
err = ErrShortProgram
return
}
n := binary.LittleEndian.Uint16(prog[pc+1 : pc+3])
inst.Len += uint32(n) + 2
end, ok := checked.AddUint32(pc, inst.Len)
if !ok {
err = errors.WithDetail(checked.ErrOverflow, "data length exceeds max program size")
return
}
if end > l {
err = ErrShortProgram
return
}
inst.Data = prog[pc+3 : end]
return
}
if opcode == OP_PUSHDATA4 {
if len(prog) < 5 || pc > l-5 {
err = ErrShortProgram
return
}
n := binary.LittleEndian.Uint32(prog[pc+1 : pc+5])
inst.Len += 4 + n
end, ok := checked.AddUint32(pc, inst.Len)
if !ok {
err = errors.WithDetail(checked.ErrOverflow, "data length exceeds max program size")
return
}
if end > l {
err = ErrShortProgram
return
}
inst.Data = prog[pc+5 : end]
return
}
if opcode == OP_JUMP || opcode == OP_JUMPIF {
inst.Len += 4
end, ok := checked.AddUint32(pc, inst.Len)
if !ok {
err = errors.WithDetail(checked.ErrOverflow, "jump target exceeds max program size")
return
}
if end > l {
err = ErrShortProgram
return
}
inst.Data = prog[pc+1 : end]
return
}
return
}
func ParseProgram(prog []byte) ([]Instruction, error) {
var result []Instruction
for pc := uint32(0); pc < uint32(len(prog)); { // update pc inside the loop
inst, err := ParseOp(prog, pc)
if err != nil {
return nil, err
}
result = append(result, inst)
var ok bool
pc, ok = checked.AddUint32(pc, inst.Len)
if !ok {
return nil, errors.WithDetail(checked.ErrOverflow, "program counter exceeds max program size")
}
}
return result, nil
}
var isExpansion [256]bool
func init() {
for i := 1; i <= 75; i++ {
ops[i] = opInfo{Op(i), fmt.Sprintf("DATA_%d", i), opPushdata}
}
for i := uint8(0); i <= 15; i++ {
op := uint8(OP_1) + i
ops[op] = opInfo{Op(op), fmt.Sprintf("%d", i+1), opPushdata}
}
// This is here to break a dependency cycle
ops[OP_CHECKPREDICATE] = opInfo{OP_CHECKPREDICATE, "CHECKPREDICATE", opCheckPredicate}
opsByName = make(map[string]opInfo)
for _, info := range ops {
opsByName[info.name] = info
}
opsByName["0"] = ops[OP_FALSE]
opsByName["TRUE"] = ops[OP_1]
for i := 0; i <= 255; i++ {
if ops[i].name == "" {
ops[i] = opInfo{Op(i), fmt.Sprintf("NOPx%02x", i), opNop}
isExpansion[i] = true
}
}
}