forked from hyperledger-archives/burrow
-
Notifications
You must be signed in to change notification settings - Fork 0
/
account.go
124 lines (105 loc) · 3.26 KB
/
account.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
// Copyright 2017 Monax Industries Limited
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package acm
import (
"bytes"
"fmt"
amino "github.com/tendermint/go-amino"
"github.com/hyperledger/burrow/binary"
"github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/event/query"
"github.com/hyperledger/burrow/permission"
)
var GlobalPermissionsAddress = crypto.Address(binary.Zero160)
func NewAccount(pubKey crypto.PublicKey) *Account {
return &Account{
Address: pubKey.GetAddress(),
PublicKey: pubKey,
}
}
func NewAccountFromSecret(secret string) *Account {
return NewAccount(crypto.PrivateKeyFromSecret(secret, crypto.CurveTypeEd25519).GetPublicKey())
}
func (acc *Account) GetAddress() crypto.Address {
return acc.Address
}
///---- Serialisation methods
var cdc = amino.NewCodec()
func (acc *Account) Encode() ([]byte, error) {
return cdc.MarshalBinaryBare(acc)
}
func Decode(accBytes []byte) (*Account, error) {
ca := new(Account)
err := cdc.UnmarshalBinaryBare(accBytes, ca)
if err != nil {
return nil, err
}
return ca, nil
}
// Conversions
//
// Using the naming convention is this package of 'As<Type>' being
// a conversion from Account to <Type> and 'From<Type>' being conversion
// from <Type> to Account. Conversions are done by copying
// Creates an otherwise zeroed Account from an Addressable and returns it as MutableAccount
func FromAddressable(addressable crypto.Addressable) *Account {
return &Account{
Address: addressable.GetAddress(),
PublicKey: addressable.GetPublicKey(),
// Since nil slices and maps compare differently to empty ones
Code: Bytecode{},
Permissions: permission.AccountPermissions{
Roles: []string{},
},
}
}
// Copies all mutable parts of account
func (acc *Account) Copy() *Account {
if acc == nil {
return nil
}
accCopy := *acc
accCopy.Permissions.Roles = make([]string, len(acc.Permissions.Roles))
copy(accCopy.Permissions.Roles, acc.Permissions.Roles)
return &accCopy
}
func (acc *Account) Equal(accOther *Account) bool {
accEnc, err := acc.Encode()
if err != nil {
return false
}
accOtherEnc, err := acc.Encode()
if err != nil {
return false
}
return bytes.Equal(accEnc, accOtherEnc)
}
func (acc Account) String() string {
return fmt.Sprintf("Account{Address: %s; Sequence: %v; PublicKey: %v Balance: %v; CodeLength: %v; Permissions: %v}",
acc.Address, acc.Sequence, acc.PublicKey, acc.Balance, len(acc.Code), acc.Permissions)
}
func (acc *Account) Tagged() query.Tagged {
return &TaggedAccount{
Account: acc,
Tagged: query.MergeTags(query.MustReflectTags(acc, "Address", "Balance", "Sequence", "Code"),
query.TagMap{
"Permissions": acc.Permissions.Base.ResultantPerms(),
"Roles": acc.Permissions.Roles,
}),
}
}
type TaggedAccount struct {
*Account
query.Tagged
}