aboutsummaryrefslogtreecommitdiffstats
path: root/vm/closure.go
blob: b556bc03d8765bf79153c498e89b4e2ff8c4dec9 (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
package vm

// TODO Re write VM to use values instead of big integers?

import (
    "math/big"

    "github.com/ethereum/go-ethereum/ethstate"
    "github.com/ethereum/go-ethereum/ethutil"
)

type ClosureRef interface {
    ReturnGas(*big.Int, *big.Int)
    Address() []byte
    Object() *ethstate.StateObject
    GetStorage(*big.Int) *ethutil.Value
    SetStorage(*big.Int, *ethutil.Value)
}

// Basic inline closure object which implement the 'closure' interface
type Closure struct {
    caller  ClosureRef
    object  *ethstate.StateObject
    Code    []byte
    message *ethstate.Message
    exe     *Execution

    Gas, UsedGas, Price *big.Int

    Args []byte
}

// Create a new closure for the given data items
func NewClosure(msg *ethstate.Message, caller ClosureRef, object *ethstate.StateObject, code []byte, gas, price *big.Int) *Closure {
    c := &Closure{message: msg, caller: caller, object: object, Code: code, Args: nil}

    // Gas should be a pointer so it can safely be reduced through the run
    // This pointer will be off the state transition
    c.Gas = gas //new(big.Int).Set(gas)
    // In most cases price and value are pointers to transaction objects
    // and we don't want the transaction's values to change.
    c.Price = new(big.Int).Set(price)
    c.UsedGas = new(big.Int)

    return c
}

// Retuns the x element in data slice
func (c *Closure) GetStorage(x *big.Int) *ethutil.Value {
    m := c.object.GetStorage(x)
    if m == nil {
        return ethutil.EmptyValue()
    }

    return m
}

func (c *Closure) Get(x *big.Int) *ethutil.Value {
    return c.Gets(x, big.NewInt(1))
}

func (c *Closure) GetOp(x int) OpCode {
    return OpCode(c.GetByte(x))
}

func (c *Closure) GetByte(x int) byte {
    if x < len(c.Code) {
        return c.Code[x]
    }

    return 0
}

func (c *Closure) GetBytes(x, y int) []byte {
    if x >= len(c.Code) || y >= len(c.Code) {
        return nil
    }

    return c.Code[x : x+y]
}

func (c *Closure) Gets(x, y *big.Int) *ethutil.Value {
    if x.Int64() >= int64(len(c.Code)) || y.Int64() >= int64(len(c.Code)) {
        return ethutil.NewValue(0)
    }

    partial := c.Code[x.Int64() : x.Int64()+y.Int64()]

    return ethutil.NewValue(partial)
}

func (c *Closure) SetStorage(x *big.Int, val *ethutil.Value) {
    c.object.SetStorage(x, val)
}

func (c *Closure) Address() []byte {
    return c.object.Address()
}

func (c *Closure) Call(vm VirtualMachine, args []byte) ([]byte, *big.Int, error) {
    c.Args = args

    ret, err := vm.RunClosure(c)

    return ret, c.UsedGas, err
}

func (c *Closure) Return(ret []byte) []byte {
    // Return the remaining gas to the caller
    c.caller.ReturnGas(c.Gas, c.Price)

    return ret
}

func (c *Closure) UseGas(gas *big.Int) bool {
    if c.Gas.Cmp(gas) < 0 {
        return false
    }

    // Sub the amount of gas from the remaining
    c.Gas.Sub(c.Gas, gas)
    c.UsedGas.Add(c.UsedGas, gas)

    return true
}

// Implement the caller interface
func (c *Closure) ReturnGas(gas, price *big.Int) {
    // Return the gas to the closure
    c.Gas.Add(c.Gas, gas)
    c.UsedGas.Sub(c.UsedGas, gas)
}

func (c *Closure) Object() *ethstate.StateObject {
    return c.object
}

func (c *Closure) Caller() ClosureRef {
    return c.caller
}