-
Notifications
You must be signed in to change notification settings - Fork 6
/
transaction.go
193 lines (164 loc) · 4.62 KB
/
transaction.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
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
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
package tezosprotocol
import (
"bytes"
"fmt"
"math/big"
"github.com/anchorageoss/tezosprotocol/v3/zarith"
"golang.org/x/xerrors"
)
// Transaction models the tezos transaction type
type Transaction struct {
Source ContractID
Fee *big.Int
Counter *big.Int
GasLimit *big.Int
StorageLimit *big.Int
Amount *big.Int
Destination ContractID
Parameters *TransactionParameters
}
func (t *Transaction) String() string {
return fmt.Sprintf("%#v", t)
}
// GetTag implements OperationContents
func (t *Transaction) GetTag() ContentsTag {
return ContentsTagTransaction
}
// GetSource returns the operation's source
func (t *Transaction) GetSource() ContractID {
return t.Source
}
// MarshalBinary implements encoding.BinaryMarshaler
func (t *Transaction) MarshalBinary() ([]byte, error) {
buf := bytes.Buffer{}
// tag
buf.WriteByte(byte(t.GetTag()))
// source
sourceBytes, err := t.Source.EncodePubKeyHash()
if err != nil {
return nil, xerrors.Errorf("failed to write source: %w", err)
}
buf.Write(sourceBytes)
// fee
fee, err := zarith.Encode(t.Fee)
if err != nil {
return nil, xerrors.Errorf("failed to write Fee: %w", err)
}
buf.Write(fee)
// counter
counter, err := zarith.Encode(t.Counter)
if err != nil {
return nil, xerrors.Errorf("failed to write Counter: %w", err)
}
buf.Write(counter)
// gas limit
gasLimit, err := zarith.Encode(t.GasLimit)
if err != nil {
return nil, xerrors.Errorf("failed to write GasLimit: %w", err)
}
buf.Write(gasLimit)
// storage limit
storageLimit, err := zarith.Encode(t.StorageLimit)
if err != nil {
return nil, xerrors.Errorf("failed to write StorageLimit: %w", err)
}
buf.Write(storageLimit)
// amount
amount, err := zarith.Encode(t.Amount)
if err != nil {
return nil, xerrors.Errorf("failed to write Amount: %w", err)
}
buf.Write(amount)
// destination
destinationBytes, err := t.Destination.MarshalBinary()
if err != nil {
return nil, xerrors.Errorf("failed to write destination: %w", err)
}
buf.Write(destinationBytes)
// parameters
paramsFollow := t.Parameters != nil
buf.WriteByte(serializeBoolean(paramsFollow))
if paramsFollow {
paramsBytes, err := t.Parameters.MarshalBinary()
if err != nil {
return nil, xerrors.Errorf("failed to write transaction parameters: %w", err)
}
buf.Write(paramsBytes)
}
return buf.Bytes(), nil
}
// UnmarshalBinary implements encoding.BinaryUnmarshaler
func (t *Transaction) UnmarshalBinary(data []byte) (err error) {
// cleanly recover from out of bounds exceptions
defer func() {
if err == nil {
if r := recover(); r != nil {
err = catchOutOfRangeExceptions(r)
}
}
}()
dataPtr := data
// tag
tag := ContentsTag(dataPtr[0])
if tag != ContentsTagTransaction {
return xerrors.Errorf("invalid tag for transaction. Expected %d, saw %d", ContentsTagTransaction, tag)
}
dataPtr = dataPtr[1:]
// source
err = t.Source.UnmarshalBinary(dataPtr[:TaggedPubKeyHashLen])
if err != nil {
return xerrors.Errorf("failed to unmarshal source: %w", err)
}
dataPtr = dataPtr[TaggedPubKeyHashLen:]
// fee
var bytesRead int
t.Fee, bytesRead, err = zarith.ReadNext(dataPtr)
if err != nil {
return xerrors.Errorf("failed to unmarshal fee: %w", err)
}
dataPtr = dataPtr[bytesRead:]
// counter
t.Counter, bytesRead, err = zarith.ReadNext(dataPtr)
if err != nil {
return xerrors.Errorf("failed to unmarshal counter: %w", err)
}
dataPtr = dataPtr[bytesRead:]
// gas limit
t.GasLimit, bytesRead, err = zarith.ReadNext(dataPtr)
if err != nil {
return xerrors.Errorf("failed to unmarshal gas limit: %w", err)
}
dataPtr = dataPtr[bytesRead:]
// storage limit
t.StorageLimit, bytesRead, err = zarith.ReadNext(dataPtr)
if err != nil {
return xerrors.Errorf("failed to unmarshal storage limit: %w", err)
}
dataPtr = dataPtr[bytesRead:]
// amount
t.Amount, bytesRead, err = zarith.ReadNext(dataPtr)
if err != nil {
return xerrors.Errorf("failed to unmarshal counter: %w", err)
}
dataPtr = dataPtr[bytesRead:]
// destination
err = t.Destination.UnmarshalBinary(dataPtr[:ContractIDLen])
if err != nil {
return xerrors.Errorf("failed to unmarshal destination: %w", err)
}
dataPtr = dataPtr[ContractIDLen:]
// parameters
hasParameters, err := deserializeBoolean(dataPtr[0])
dataPtr = dataPtr[1:]
if err != nil {
return xerrors.Errorf("failed to deserialialize presence of field \"parameters\": %w", err)
}
if hasParameters {
t.Parameters = &TransactionParameters{Value: &TransactionParametersValueRawBytes{}}
err = t.Parameters.UnmarshalBinary(dataPtr)
if err != nil {
return xerrors.Errorf("failed to deserialize transaction parameters: %w", err)
}
}
return nil
}