-
Notifications
You must be signed in to change notification settings - Fork 23
/
base_message.go
106 lines (88 loc) · 2.57 KB
/
base_message.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
package types
import (
"fmt"
"github.com/ethereum/go-ethereum/crypto"
)
const (
// BaseMessageTipsOffset is the tips offset.
BaseMessageTipsOffset = 0
// BaseMessageSenderOffset is the sender offset.
BaseMessageSenderOffset = 32
// BaseMessageRecipientOffset is the recipient offset.
BaseMessageRecipientOffset = 64
// BaseMessageRequestOffset is the request offset.
BaseMessageRequestOffset = BaseMessageRecipientOffset + TipsSize
// BaseMessageContentOffset is the content offset.
BaseMessageContentOffset = BaseMessageRequestOffset + RequestSize
)
// BaseMessage is an interface that contains the base message.
//
//nolint:interfacebloat
type BaseMessage interface {
// Sender address on origin chain.
Sender() [32]byte
// Recipient address on destination chain.
Recipient() [32]byte
// Tips paid on the origin chain.
Tips() Tips
// Request gets the message request.
Request() Request
// Content to be passed to recipient.
Content() []byte
// BodyLeaf gets the message body.
BodyLeaf() ([]byte, error)
// Leaf gets the message leaf.
Leaf() ([32]byte, error)
}
// baseMessageImpl implements a base message. It is used for testutils. Real base messages are emitted by the contract.
type baseMessageImpl struct {
sender [32]byte
recipient [32]byte
tips Tips
request Request
content []byte
}
// NewBaseMessage creates a new message from fields passed in.
func NewBaseMessage(sender, recipient [32]byte, tips Tips, request Request, content []byte) BaseMessage {
return &baseMessageImpl{
sender: sender,
recipient: recipient,
tips: tips,
request: request,
content: content,
}
}
func (m baseMessageImpl) Sender() [32]byte {
return m.sender
}
func (m baseMessageImpl) Recipient() [32]byte {
return m.recipient
}
func (m baseMessageImpl) Tips() Tips {
return m.tips
}
func (m baseMessageImpl) Request() Request {
return m.request
}
func (m baseMessageImpl) Content() []byte {
return m.content
}
func (m baseMessageImpl) BodyLeaf() ([]byte, error) {
encodeMessage, err := EncodeBaseMessage(m)
if err != nil {
return nil, fmt.Errorf("failed to encode message: %w", err)
}
return crypto.Keccak256(encodeMessage[BaseMessageSenderOffset:]), nil
}
func (m baseMessageImpl) Leaf() ([32]byte, error) {
bodyLeaf, err := m.BodyLeaf()
if err != nil {
return [32]byte{}, fmt.Errorf("failed to get body leaf: %w", err)
}
tipsBytes, err := EncodeTips(m.Tips())
if err != nil {
return [32]byte{}, fmt.Errorf("failed to encode tips: %w", err)
}
hashedTips := crypto.Keccak256(tipsBytes)
return crypto.Keccak256Hash(hashedTips, bodyLeaf), nil
}