-
Notifications
You must be signed in to change notification settings - Fork 9
/
packet.go
134 lines (110 loc) · 4.03 KB
/
packet.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
package types
import (
"crypto/sha256"
"github.com/cosmos/cosmos-sdk/codec"
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
"github.com/bianjieai/tibc-go/modules/tibc/core/exported"
)
// CommitPacket returns the packet commitment bytes. The commitment consists of:
// sha256_hash(timeout_timestamp + timeout_height.RevisionNumber + timeout_height.RevisionHeight + sha256_hash(data))
// from a given packet. This results in a fixed length preimage.
// NOTE: sdk.Uint64ToBigEndian sets the uint64 to a slice of length 8.
func CommitPacket(packet exported.PacketI) []byte {
dataHash := sha256.Sum256(packet.GetData())
return dataHash[:]
}
// CommitAcknowledgement returns the hash of commitment bytes
func CommitAcknowledgement(data []byte) []byte {
hash := sha256.Sum256(data)
return hash[:]
}
var (
_ exported.PacketI = (*Packet)(nil)
ModuleCdc = codec.NewProtoCodec(codectypes.NewInterfaceRegistry())
)
// NewPacket creates a new Packet instance. It panics if the provided
// packet data interface is not registered.
func NewPacket(
data []byte, sequence uint64, sourceChain, destinationChain, relayChain, port string,
) Packet {
return Packet{
Data: data,
Sequence: sequence,
SourceChain: sourceChain,
DestinationChain: destinationChain,
RelayChain: relayChain,
Port: port,
}
}
// GetSequence implements PacketI interface
func (p Packet) GetSequence() uint64 { return p.Sequence }
// GetPort implements PacketI interface
func (p Packet) GetPort() string { return p.Port }
// GetSourceChain implements PacketI interface
func (p Packet) GetSourceChain() string { return p.SourceChain }
// GetDestinationChain implements PacketI interface
func (p Packet) GetDestChain() string { return p.DestinationChain }
// GetRelayChain implements PacketI interface
func (p Packet) GetRelayChain() string { return p.RelayChain }
// GetData implements PacketI interface
func (p Packet) GetData() []byte { return p.Data }
// ValidateBasic implements PacketI interface
func (p Packet) ValidateBasic() error {
if p.Sequence == 0 {
return sdkerrors.Wrap(ErrInvalidPacket, "packet sequence cannot be 0")
}
if len(p.Data) == 0 {
return sdkerrors.Wrap(ErrInvalidPacket, "packet data bytes cannot be empty")
}
return nil
}
var _ exported.CleanPacketI = (*CleanPacket)(nil)
// NewCleanPacket creates a new CleanPacket instance.
func NewCleanPacket(
sequence uint64, sourceChain, destinationChain, relayChain string,
) CleanPacket {
return CleanPacket{
Sequence: sequence,
SourceChain: sourceChain,
DestinationChain: destinationChain,
RelayChain: relayChain,
}
}
// GetSequence implements PacketI interface
func (p CleanPacket) GetSequence() uint64 { return p.Sequence }
// GetSourceChain implements PacketI interface
func (p CleanPacket) GetSourceChain() string { return p.SourceChain }
// GetDestinationChain implements PacketI interface
func (p CleanPacket) GetDestChain() string { return p.DestinationChain }
// GetRelayChain implements PacketI interface
func (p CleanPacket) GetRelayChain() string { return p.RelayChain }
// ValidateBasic implements PacketI interface
func (p CleanPacket) ValidateBasic() error {
if p.Sequence == 0 {
return sdkerrors.Wrap(ErrInvalidPacket, "packet sequence cannot be 0")
}
return nil
}
// NewResultAcknowledgement returns a new instance of Acknowledgement using an Acknowledgement_Result
// type in the Response field.
func NewResultAcknowledgement(result []byte) Acknowledgement {
return Acknowledgement{
Response: &Acknowledgement_Result{
Result: result,
},
}
}
// NewErrorAcknowledgement returns a new instance of Acknowledgement using an Acknowledgement_Error
// type in the Response field.
func NewErrorAcknowledgement(err string) Acknowledgement {
return Acknowledgement{
Response: &Acknowledgement_Error{
Error: err,
},
}
}
// GetBytes is a helper for serialising acknowledgements
func (ack Acknowledgement) GetBytes() []byte {
return ModuleCdc.MustMarshal(&ack)
}