aboutsummaryrefslogtreecommitdiffstats
path: root/accounts/abi/abi.go
blob: c31127cb34aa7dfad307a9c6c7b1404025ecb2a0 (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
// Copyright 2015 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// go-ethereum is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The go-ethereum library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

package abi

import (
    "encoding/json"
    "fmt"
    "io"
    "strings"

    "github.com/ethereum/go-ethereum/crypto"
)

// Callable method given a `Name` and whether the method is a constant.
// If the method is `Const` no transaction needs to be created for this
// particular Method call. It can easily be simulated using a local VM.
// For example a `Balance()` method only needs to retrieve something
// from the storage and therefor requires no Tx to be send to the
// network. A method such as `Transact` does require a Tx and thus will
// be flagged `true`.
// Input specifies the required input parameters for this gives method.
type Method struct {
    Name   string
    Const  bool
    Input  []Argument
    Return Type // not yet implemented
}

// Returns the methods string signature according to the ABI spec.
//
// Example
//
//     function foo(uint32 a, int b)    =    "foo(uint32,int256)"
//
// Please note that "int" is substitute for its canonical representation "int256"
func (m Method) String() (out string) {
    out += m.Name
    types := make([]string, len(m.Input))
    i := 0
    for _, input := range m.Input {
        types[i] = input.Type.String()
        i++
    }
    out += "(" + strings.Join(types, ",") + ")"

    return
}

func (m Method) Id() []byte {
    return crypto.Sha3([]byte(m.String()))[:4]
}

// Argument holds the name of the argument and the corresponding type.
// Types are used when packing and testing arguments.
type Argument struct {
    Name string
    Type Type
}

func (a *Argument) UnmarshalJSON(data []byte) error {
    var extarg struct {
        Name string
        Type string
    }
    err := json.Unmarshal(data, &extarg)
    if err != nil {
        return fmt.Errorf("argument json err: %v", err)
    }

    a.Type, err = NewType(extarg.Type)
    if err != nil {
        return err
    }
    a.Name = extarg.Name

    return nil
}

// The ABI holds information about a contract's context and available
// invokable methods. It will allow you to type check function calls and
// packs data accordingly.
type ABI struct {
    Methods map[string]Method
}

// tests, tests whether the given input would result in a successful
// call. Checks argument list count and matches input to `input`.
func (abi ABI) pack(name string, args ...interface{}) ([]byte, error) {
    method := abi.Methods[name]

    var ret []byte
    for i, a := range args {
        input := method.Input[i]

        packed, err := input.Type.pack(a)
        if err != nil {
            return nil, fmt.Errorf("`%s` %v", name, err)
        }
        ret = append(ret, packed...)

    }

    return ret, nil
}

// Pack the given method name to conform the ABI. Method call's data
// will consist of method_id, args0, arg1, ... argN. Method id consists
// of 4 bytes and arguments are all 32 bytes.
// Method ids are created from the first 4 bytes of the hash of the
// methods string signature. (signature = baz(uint32,string32))
func (abi ABI) Pack(name string, args ...interface{}) ([]byte, error) {
    method, exist := abi.Methods[name]
    if !exist {
        return nil, fmt.Errorf("method '%s' not found", name)
    }

    // start with argument count match
    if len(args) != len(method.Input) {
        return nil, fmt.Errorf("argument count mismatch: %d for %d", len(args), len(method.Input))
    }

    arguments, err := abi.pack(name, args...)
    if err != nil {
        return nil, err
    }

    // Set function id
    packed := abi.Methods[name].Id()
    packed = append(packed, arguments...)

    return packed, nil
}

func (abi *ABI) UnmarshalJSON(data []byte) error {
    var methods []Method
    if err := json.Unmarshal(data, &methods); err != nil {
        return err
    }

    abi.Methods = make(map[string]Method)
    for _, method := range methods {
        abi.Methods[method.Name] = method
    }

    return nil
}

func JSON(reader io.Reader) (ABI, error) {
    dec := json.NewDecoder(reader)

    var abi ABI
    if err := dec.Decode(&abi); err != nil {
        return ABI{}, err
    }

    return abi, nil
}