/
types.go
295 lines (250 loc) · 9.84 KB
/
types.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
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
package eth
import (
"bytes"
"fmt"
"math/big"
"reflect"
"github.com/holiman/uint256"
"github.com/ethereum/go-ethereum/beacon/engine"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/trie"
)
type ErrorCode int
const (
UnknownPayload ErrorCode = -32001 // Payload does not exist / is not available.
InvalidForkchoiceState ErrorCode = -38002 // Forkchoice state is invalid / inconsistent.
InvalidPayloadAttributes ErrorCode = -38003 // Payload attributes are invalid / inconsistent.
)
// InputError distinguishes an user-input error from regular rpc errors,
// to help the (Engine) API user divert from accidental input mistakes.
type InputError struct {
Inner error
Code ErrorCode
}
func (ie InputError) Error() string {
return fmt.Sprintf("input error %d: %s", ie.Code, ie.Inner.Error())
}
func (ie InputError) Unwrap() error {
return ie.Inner
}
// Is checks if the error is the given target type.
// Any type of InputError counts, regardless of code.
func (ie InputError) Is(target error) bool {
_, ok := target.(InputError)
return ok // we implement Unwrap, so we do not have to check the inner type now
}
type Bytes32 [32]byte
func (b *Bytes32) UnmarshalJSON(text []byte) error {
return hexutil.UnmarshalFixedJSON(reflect.TypeOf(b), text, b[:])
}
func (b *Bytes32) UnmarshalText(text []byte) error {
return hexutil.UnmarshalFixedText("Bytes32", text, b[:])
}
func (b Bytes32) MarshalText() ([]byte, error) {
return hexutil.Bytes(b[:]).MarshalText()
}
func (b Bytes32) String() string {
return hexutil.Encode(b[:])
}
// TerminalString implements log.TerminalStringer, formatting a string for console
// output during logging.
func (b Bytes32) TerminalString() string {
return fmt.Sprintf("%x..%x", b[:3], b[29:])
}
type Bytes256 [256]byte
func (b *Bytes256) UnmarshalJSON(text []byte) error {
return hexutil.UnmarshalFixedJSON(reflect.TypeOf(b), text, b[:])
}
func (b *Bytes256) UnmarshalText(text []byte) error {
return hexutil.UnmarshalFixedText("Bytes32", text, b[:])
}
func (b Bytes256) MarshalText() ([]byte, error) {
return hexutil.Bytes(b[:]).MarshalText()
}
func (b Bytes256) String() string {
return hexutil.Encode(b[:])
}
// TerminalString implements log.TerminalStringer, formatting a string for console
// output during logging.
func (b Bytes256) TerminalString() string {
return fmt.Sprintf("%x..%x", b[:3], b[253:])
}
type Uint64Quantity = hexutil.Uint64
type BytesMax32 []byte
func (b *BytesMax32) UnmarshalJSON(text []byte) error {
if len(text) > 64+2+2 { // account for delimiter "", and 0x prefix
return fmt.Errorf("input too long, expected at most 32 hex-encoded, 0x-prefixed, bytes: %x", text)
}
return (*hexutil.Bytes)(b).UnmarshalJSON(text)
}
func (b *BytesMax32) UnmarshalText(text []byte) error {
if len(text) > 64+2 { // account for 0x prefix
return fmt.Errorf("input too long, expected at most 32 hex-encoded, 0x-prefixed, bytes: %x", text)
}
return (*hexutil.Bytes)(b).UnmarshalText(text)
}
func (b BytesMax32) MarshalText() ([]byte, error) {
return (hexutil.Bytes)(b).MarshalText()
}
func (b BytesMax32) String() string {
return hexutil.Encode(b)
}
type Uint256Quantity = uint256.Int
type Data = hexutil.Bytes
type PayloadID = engine.PayloadID
type ExecutionPayload struct {
ParentHash common.Hash `json:"parentHash"`
FeeRecipient common.Address `json:"feeRecipient"`
StateRoot Bytes32 `json:"stateRoot"`
ReceiptsRoot Bytes32 `json:"receiptsRoot"`
LogsBloom Bytes256 `json:"logsBloom"`
PrevRandao Bytes32 `json:"prevRandao"`
BlockNumber Uint64Quantity `json:"blockNumber"`
GasLimit Uint64Quantity `json:"gasLimit"`
GasUsed Uint64Quantity `json:"gasUsed"`
Timestamp Uint64Quantity `json:"timestamp"`
ExtraData BytesMax32 `json:"extraData"`
BaseFeePerGas Uint256Quantity `json:"baseFeePerGas"`
BlockHash common.Hash `json:"blockHash"`
// Array of transaction objects, each object is a byte list (DATA) representing
// TransactionType || TransactionPayload or LegacyTransaction as defined in EIP-2718
Transactions []Data `json:"transactions"`
}
func (payload *ExecutionPayload) ID() BlockID {
return BlockID{Hash: payload.BlockHash, Number: uint64(payload.BlockNumber)}
}
func (payload *ExecutionPayload) ParentID() BlockID {
n := uint64(payload.BlockNumber)
if n > 0 {
n -= 1
}
return BlockID{Hash: payload.ParentHash, Number: n}
}
type rawTransactions []Data
func (s rawTransactions) Len() int { return len(s) }
func (s rawTransactions) EncodeIndex(i int, w *bytes.Buffer) {
w.Write(s[i])
}
// CheckBlockHash recomputes the block hash and returns if the embedded block hash matches.
func (payload *ExecutionPayload) CheckBlockHash() (actual common.Hash, ok bool) {
hasher := trie.NewStackTrie(nil)
txHash := types.DeriveSha(rawTransactions(payload.Transactions), hasher)
header := types.Header{
ParentHash: payload.ParentHash,
UncleHash: types.EmptyUncleHash,
Coinbase: payload.FeeRecipient,
Root: common.Hash(payload.StateRoot),
TxHash: txHash,
ReceiptHash: common.Hash(payload.ReceiptsRoot),
Bloom: types.Bloom(payload.LogsBloom),
Difficulty: common.Big0, // zeroed, proof-of-work legacy
Number: big.NewInt(int64(payload.BlockNumber)),
GasLimit: uint64(payload.GasLimit),
GasUsed: uint64(payload.GasUsed),
Time: uint64(payload.Timestamp),
Extra: payload.ExtraData,
MixDigest: common.Hash(payload.PrevRandao),
Nonce: types.BlockNonce{}, // zeroed, proof-of-work legacy
BaseFee: payload.BaseFeePerGas.ToBig(),
}
blockHash := header.Hash()
return blockHash, blockHash == payload.BlockHash
}
func BlockAsPayload(bl *types.Block) (*ExecutionPayload, error) {
baseFee, overflow := uint256.FromBig(bl.BaseFee())
if overflow {
return nil, fmt.Errorf("invalid base fee in block: %s", bl.BaseFee())
}
opaqueTxs := make([]Data, len(bl.Transactions()))
for i, tx := range bl.Transactions() {
otx, err := tx.MarshalBinary()
if err != nil {
return nil, fmt.Errorf("tx %d failed to marshal: %w", i, err)
}
opaqueTxs[i] = otx
}
return &ExecutionPayload{
ParentHash: bl.ParentHash(),
FeeRecipient: bl.Coinbase(),
StateRoot: Bytes32(bl.Root()),
ReceiptsRoot: Bytes32(bl.ReceiptHash()),
LogsBloom: Bytes256(bl.Bloom()),
PrevRandao: Bytes32(bl.MixDigest()),
BlockNumber: Uint64Quantity(bl.NumberU64()),
GasLimit: Uint64Quantity(bl.GasLimit()),
GasUsed: Uint64Quantity(bl.GasUsed()),
Timestamp: Uint64Quantity(bl.Time()),
ExtraData: bl.Extra(),
BaseFeePerGas: Uint256Quantity(*baseFee),
BlockHash: bl.Hash(),
Transactions: opaqueTxs,
}, nil
}
type PayloadAttributes struct {
// value for the timestamp field of the new payload
Timestamp Uint64Quantity `json:"timestamp"`
// value for the random field of the new payload
PrevRandao Bytes32 `json:"prevRandao"`
// suggested value for the coinbase field of the new payload
SuggestedFeeRecipient common.Address `json:"suggestedFeeRecipient"`
// Transactions to force into the block (always at the start of the transactions list).
Transactions []Data `json:"transactions,omitempty"`
// NoTxPool to disable adding any transactions from the transaction-pool.
NoTxPool bool `json:"noTxPool,omitempty"`
// GasLimit override
GasLimit *Uint64Quantity `json:"gasLimit,omitempty"`
}
type ExecutePayloadStatus string
const (
// given payload is valid
ExecutionValid ExecutePayloadStatus = "VALID"
// given payload is invalid
ExecutionInvalid ExecutePayloadStatus = "INVALID"
// sync process is in progress
ExecutionSyncing ExecutePayloadStatus = "SYNCING"
// returned if the payload is not fully validated, and does not extend the canonical chain,
// but will be remembered for later (on reorgs or sync updates and such)
ExecutionAccepted ExecutePayloadStatus = "ACCEPTED"
// if the block-hash in the payload is not correct
ExecutionInvalidBlockHash ExecutePayloadStatus = "INVALID_BLOCK_HASH"
// proof-of-stake transition only, not used in rollup
ExecutionInvalidTerminalBlock ExecutePayloadStatus = "INVALID_TERMINAL_BLOCK"
)
type PayloadStatusV1 struct {
// the result of the payload execution
Status ExecutePayloadStatus `json:"status"`
// the hash of the most recent valid block in the branch defined by payload and its ancestors (optional field)
LatestValidHash *common.Hash `json:"latestValidHash,omitempty"`
// additional details on the result (optional field)
ValidationError *string `json:"validationError,omitempty"`
}
type ForkchoiceState struct {
// block hash of the head of the canonical chain
HeadBlockHash common.Hash `json:"headBlockHash"`
// safe block hash in the canonical chain
SafeBlockHash common.Hash `json:"safeBlockHash"`
// block hash of the most recent finalized block
FinalizedBlockHash common.Hash `json:"finalizedBlockHash"`
}
type ForkchoiceUpdatedResult struct {
// the result of the payload execution
PayloadStatus PayloadStatusV1 `json:"payloadStatus"`
// the payload id if requested
PayloadID *PayloadID `json:"payloadId"`
}
// SystemConfig represents the rollup system configuration that carries over in every L2 block,
// and may be changed through L1 system config events.
// The initial SystemConfig at rollup genesis is embedded in the rollup configuration.
type SystemConfig struct {
// BatcherAddr identifies the batch-sender address used in batch-inbox data-transaction filtering.
BatcherAddr common.Address `json:"batcherAddr"`
// Overhead identifies the L1 fee overhead, and is passed through opaquely to pt-geth.
Overhead Bytes32 `json:"overhead"`
// Scalar identifies the L1 fee scalar, and is passed through opaquely to pt-geth.
Scalar Bytes32 `json:"scalar"`
// GasLimit identifies the L2 block gas limit
GasLimit uint64 `json:"gasLimit"`
// More fields can be added for future SystemConfig versions.
}