Removed all old code

ethutil/parsing.go

@@ -1,95 +1,88 @@
 package ethutil
 
 import (
-	"errors"
-	"fmt"
 	"math/big"
 	"strconv"
-	"strings"
 )
 
 // Op codes
-var OpCodes = map[string]string{
+var OpCodes = map[string]byte{
-	"STOP":      "0",
+	"STOP":           0,
-	"ADD":       "1",
+	"ADD":            1,
-	"MUL":       "2",
+	"MUL":            2,
-	"SUB":       "3",
+	"SUB":            3,
-	"DIV":       "4",
+	"DIV":            4,
-	"SDIV":      "5",
+	"SDIV":           5,
-	"MOD":       "6",
+	"MOD":            6,
-	"SMOD":      "7",
+	"SMOD":           7,
-	"EXP":       "8",
+	"EXP":            8,
-	"NEG":       "9",
+	"NEG":            9,
-	"LT":        "10",
+	"LT":             10,
-	"LE":        "11",
+	"LE":             11,
-	"GT":        "12",
+	"GT":             12,
-	"GE":        "13",
+	"GE":             13,
-	"EQ":        "14",
+	"EQ":             14,
-	"NOT":       "15",
+	"NOT":            15,
-	"MYADDRESS": "16",
+	"MYADDRESS":      16,
-	"TXSENDER":  "17",
+	"TXSENDER":       17,
-
+	"TXVALUE":        18,
-	"PUSH": "48",
+	"TXFEE":          19,
-	"POP":  "49",
+	"TXDATAN":        20,
-	"LOAD": "54",
+	"TXDATA":         21,
+	"BLK_PREVHASH":   22,
+	"BLK_COINBASE":   23,
+	"BLK_TIMESTAMP":  24,
+	"BLK_NUMBER":     25,
+	"BLK_DIFFICULTY": 26,
+	"BASEFEE":        27,
+	"SHA256":         32,
+	"RIPEMD160":      33,
+	"ECMUL":          34,
+	"ECADD":          35,
+	"ECSIGN":         36,
+	"ECRECOVER":      37,
+	"ECVALID":        38,
+	"SHA3":           39,
+	"PUSH":           48,
+	"POP":            49,
+	"DUP":            50,
+	"SWAP":           51,
+	"MLOAD":          52,
+	"MSTORE":         53,
+	"SLOAD":          54,
+	"SSTORE":         55,
+	"JMP":            56,
+	"JMPI":           57,
+	"IND":            58,
+	"EXTRO":          59,
+	"BALANCE":        60,
+	"MKTX":           61,
+	"SUICIDE":        62,
 }
 
-func CompileInstr(s string) (string, error) {
+func IsOpCode(s string) bool {
-	tokens := strings.Split(s, " ")
+	for key, _ := range OpCodes {
-	if OpCodes[tokens[0]] == "" {
+		if key == s {
-		return s, errors.New(fmt.Sprintf("OP not found: %s", tokens[0]))
+			return true
+		}
 	}
+	return false
+}
 
-	code := OpCodes[tokens[0]] // Replace op codes with the proper numerical equivalent
+func CompileInstr(s string) ([]byte, error) {
-	op := new(big.Int)
+	isOp := IsOpCode(s)
-	op.SetString(code, 0)
+	if isOp {
-
+		return []byte{OpCodes[s]}, nil
-	args := make([]*big.Int, 6)
-	for i, val := range tokens[1:len(tokens)] {
-		num := new(big.Int)
-		num.SetString(val, 0)
-		args[i] = num
-	}
-
-	// Big int equation = op + x * 256 + y * 256**2 + z * 256**3 + a * 256**4 + b * 256**5 + c * 256**6
-	base := new(big.Int)
-	x := new(big.Int)
-	y := new(big.Int)
-	z := new(big.Int)
-	a := new(big.Int)
-	b := new(big.Int)
-	c := new(big.Int)
-
-	if args[0] != nil {
-		x.Mul(args[0], big.NewInt(256))
-	}
-	if args[1] != nil {
-		y.Mul(args[1], BigPow(256, 2))
-	}
-	if args[2] != nil {
-		z.Mul(args[2], BigPow(256, 3))
-	}
-	if args[3] != nil {
-		a.Mul(args[3], BigPow(256, 4))
-	}
-	if args[4] != nil {
-		b.Mul(args[4], BigPow(256, 5))
-	}
-	if args[5] != nil {
-		c.Mul(args[5], BigPow(256, 6))
 	}
 
-	base.Add(op, x)
+	num := new(big.Int)
-	base.Add(base, y)
+	num.SetString(s, 0)
-	base.Add(base, z)
-	base.Add(base, a)
-	base.Add(base, b)
-	base.Add(base, c)
 
-	return base.String(), nil
+	return num.Bytes(), nil
 }
 
 func Instr(instr string) (int, []string, error) {
+
 	base := new(big.Int)
 	base.SetString(instr, 0)