aboutsummaryrefslogtreecommitdiffstats
path: root/ethchain/stack.go
blob: 02834bd782cdd46d7e282e76ef1cb0eb5371bdc6 (plain) (blame)
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
package ethchain

import (
    "fmt"
    "math/big"
)

type OpCode int

// Op codes
const (
    oSTOP OpCode = iota
    oADD
    oMUL
    oSUB
    oDIV
    oSDIV
    oMOD
    oSMOD
    oEXP
    oNEG
    oLT
    oLE
    oGT
    oGE
    oEQ
    oNOT
    oMYADDRESS
    oTXSENDER
    oTXVALUE
    oTXFEE
    oTXDATAN
    oTXDATA
    oBLK_PREVHASH
    oBLK_COINBASE
    oBLK_TIMESTAMP
    oBLK_NUMBER
    oBLK_DIFFICULTY
    oBASEFEE
    oSHA256    OpCode = 32
    oRIPEMD160 OpCode = 33
    oECMUL     OpCode = 34
    oECADD     OpCode = 35
    oECSIGN    OpCode = 36
    oECRECOVER OpCode = 37
    oECVALID   OpCode = 38
    oSHA3      OpCode = 39
    oPUSH      OpCode = 48
    oPOP       OpCode = 49
    oDUP       OpCode = 50
    oSWAP      OpCode = 51
    oMLOAD     OpCode = 52
    oMSTORE    OpCode = 53
    oSLOAD     OpCode = 54
    oSSTORE    OpCode = 55
    oJMP       OpCode = 56
    oJMPI      OpCode = 57
    oIND       OpCode = 58
    oEXTRO     OpCode = 59
    oBALANCE   OpCode = 60
    oMKTX      OpCode = 61
    oSUICIDE   OpCode = 62
)

// Since the opcodes aren't all in order we can't use a regular slice
var opCodeToString = map[OpCode]string{
    oSTOP:           "STOP",
    oADD:            "ADD",
    oMUL:            "MUL",
    oSUB:            "SUB",
    oDIV:            "DIV",
    oSDIV:           "SDIV",
    oMOD:            "MOD",
    oSMOD:           "SMOD",
    oEXP:            "EXP",
    oNEG:            "NEG",
    oLT:             "LT",
    oLE:             "LE",
    oGT:             "GT",
    oGE:             "GE",
    oEQ:             "EQ",
    oNOT:            "NOT",
    oMYADDRESS:      "MYADDRESS",
    oTXSENDER:       "TXSENDER",
    oTXVALUE:        "TXVALUE",
    oTXFEE:          "TXFEE",
    oTXDATAN:        "TXDATAN",
    oTXDATA:         "TXDATA",
    oBLK_PREVHASH:   "BLK_PREVHASH",
    oBLK_COINBASE:   "BLK_COINBASE",
    oBLK_TIMESTAMP:  "BLK_TIMESTAMP",
    oBLK_NUMBER:     "BLK_NUMBER",
    oBLK_DIFFICULTY: "BLK_DIFFICULTY",
    oBASEFEE:        "BASEFEE",
    oSHA256:         "SHA256",
    oRIPEMD160:      "RIPEMD160",
    oECMUL:          "ECMUL",
    oECADD:          "ECADD",
    oECSIGN:         "ECSIGN",
    oECRECOVER:      "ECRECOVER",
    oECVALID:        "ECVALID",
    oSHA3:           "SHA3",
    oPUSH:           "PUSH",
    oPOP:            "POP",
    oDUP:            "DUP",
    oSWAP:           "SWAP",
    oMLOAD:          "MLOAD",
    oMSTORE:         "MSTORE",
    oSLOAD:          "SLOAD",
    oSSTORE:         "SSTORE",
    oJMP:            "JMP",
    oJMPI:           "JMPI",
    oIND:            "IND",
    oEXTRO:          "EXTRO",
    oBALANCE:        "BALANCE",
    oMKTX:           "MKTX",
    oSUICIDE:        "SUICIDE",
}

func (o OpCode) String() string {
    return opCodeToString[o]
}

type OpType int

const (
    tNorm = iota
    tData
    tExtro
    tCrypto
)

type TxCallback func(opType OpType) bool

// Simple push/pop stack mechanism
type Stack struct {
    data []*big.Int
}

func NewStack() *Stack {
    return &Stack{}
}

func (st *Stack) Pop() *big.Int {
    s := len(st.data)

    str := st.data[s-1]
    st.data = st.data[:s-1]

    return str
}

func (st *Stack) Popn() (*big.Int, *big.Int) {
    s := len(st.data)

    ints := st.data[s-2:]
    st.data = st.data[:s-2]

    return ints[0], ints[1]
}

func (st *Stack) Push(d *big.Int) {
    st.data = append(st.data, d)
}
func (st *Stack) Print() {
    fmt.Println("#   val (STACK)")
    if len(st.data) > 0 {
        for i, val := range st.data {
            fmt.Printf("%-3d  %v\n", i, val)
        }
    } else {
        fmt.Println("-- empty --")
    }
}