-
Notifications
You must be signed in to change notification settings - Fork 47
/
ibc_module.go
373 lines (321 loc) · 12.1 KB
/
ibc_module.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
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
package profiles
import (
"fmt"
"math"
"github.com/cosmos/cosmos-sdk/codec"
oracletypes "github.com/desmos-labs/desmos/v5/x/oracle/types"
"cosmossdk.io/errors"
sdk "github.com/cosmos/cosmos-sdk/types"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
capabilitytypes "github.com/cosmos/cosmos-sdk/x/capability/types"
channeltypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types"
porttypes "github.com/cosmos/ibc-go/v7/modules/core/05-port/types"
host "github.com/cosmos/ibc-go/v7/modules/core/24-host"
ibcexported "github.com/cosmos/ibc-go/v7/modules/core/exported"
"github.com/desmos-labs/desmos/v5/x/profiles/keeper"
"github.com/desmos-labs/desmos/v5/x/profiles/types"
)
var (
_ porttypes.IBCModule = IBCModule{}
)
// IBCModule implements the ICS26 interface for transfer given the transfer keeper.
type IBCModule struct {
cdc codec.Codec
keeper keeper.Keeper
}
// NewIBCModule creates a new IBCModule given the keeper
func NewIBCModule(cdc codec.Codec, k keeper.Keeper) IBCModule {
return IBCModule{
cdc: cdc,
keeper: k,
}
}
// ValidateProfilesChannelParams does validation of a newly created profiles channel. A profiles
// channel must be UNORDERED, use the correct port (by default 'profiles'), and use the current
// supported version. Only 2^32 channels are allowed to be created.
func ValidateProfilesChannelParams(
ctx sdk.Context,
keeper keeper.Keeper,
order channeltypes.Order,
portID string,
channelID string,
) error {
// NOTE: for escrow address security only 2^32 channels are allowed to be created
// Issue: https://github.com/cosmos/cosmos-sdk/issues/7737
channelSequence, err := channeltypes.ParseChannelSequence(channelID)
if err != nil {
return err
}
if channelSequence > uint64(math.MaxUint32) {
return errors.Wrapf(types.ErrMaxProfilesChannels, "channel sequence %d is greater than max allowed profiles channels %d", channelSequence, uint64(math.MaxUint32))
}
if order != channeltypes.UNORDERED {
return errors.Wrapf(channeltypes.ErrInvalidChannelOrdering, "expected %s channel, got %s ", channeltypes.UNORDERED, order)
}
// Require portID is the portID profiles module is bound to
boundPort := keeper.GetPort(ctx)
if boundPort != portID {
return errors.Wrapf(porttypes.ErrInvalidPort, "invalid port: %s, expected %s", portID, boundPort)
}
return nil
}
// -------------------------------------------------------------------------------------------------------------------
// OnChanOpenInit implements the IBCModule interface
func (am IBCModule) OnChanOpenInit(
ctx sdk.Context,
order channeltypes.Order,
connectionHops []string,
portID string,
channelID string,
channelCap *capabilitytypes.Capability,
counterparty channeltypes.Counterparty,
version string,
) (string, error) {
if err := ValidateProfilesChannelParams(ctx, am.keeper, order, portID, channelID); err != nil {
return "", err
}
// Claim channel capability passed back by IBC module
if err := am.keeper.ClaimCapability(ctx, channelCap, host.ChannelCapabilityPath(portID, channelID)); err != nil {
return "", err
}
return version, nil
}
// OnChanOpenTry implements the IBCModule interface
func (am IBCModule) OnChanOpenTry(
ctx sdk.Context,
order channeltypes.Order,
connectionHops []string,
portID,
channelID string,
channelCap *capabilitytypes.Capability,
counterparty channeltypes.Counterparty,
counterpartyVersion string,
) (string, error) {
if err := ValidateProfilesChannelParams(ctx, am.keeper, order, portID, channelID); err != nil {
return "", err
}
// Module may have already claimed capability in OnChanOpenInit in the case of crossing hellos
// (ie chainA and chainB both call ChanOpenInit before one of them calls ChanOpenTry)
// If module can already authenticate the capability then module already owns it so we don't need to claim
// Otherwise, module does not have channel capability and we must claim it from IBC
if !am.keeper.AuthenticateCapability(ctx, channelCap, host.ChannelCapabilityPath(portID, channelID)) {
// Only claim channel capability passed back by IBC module if we do not already own it
err := am.keeper.ClaimCapability(ctx, channelCap, host.ChannelCapabilityPath(portID, channelID))
if err != nil {
return "", err
}
}
return counterpartyVersion, nil
}
// OnChanOpenAck implements the IBCModule interface
func (am IBCModule) OnChanOpenAck(
ctx sdk.Context,
portID,
channelID string,
counterpartyChannelID string,
counterpartyVersion string,
) error {
return nil
}
// OnChanOpenConfirm implements the IBCModule interface
func (am IBCModule) OnChanOpenConfirm(
ctx sdk.Context,
portID,
channelID string,
) error {
return nil
}
// OnChanCloseInit implements the IBCModule interface
func (am IBCModule) OnChanCloseInit(
ctx sdk.Context,
portID,
channelID string,
) error {
// Disallow user-initiated channel closing for channels
return errors.Wrap(sdkerrors.ErrInvalidRequest, "user cannot close channel")
}
// OnChanCloseConfirm implements the IBCModule interface
func (am IBCModule) OnChanCloseConfirm(
ctx sdk.Context,
portID,
channelID string,
) error {
return nil
}
// -------------------------------------------------------------------------------------------------------------------
// OnRecvPacket implements the IBCModule interface
func (am IBCModule) OnRecvPacket(
ctx sdk.Context,
packet channeltypes.Packet,
relayer sdk.AccAddress,
) ibcexported.Acknowledgement {
// Try handling the chain link packet data
ack, err := am.HandlePacket(ctx, packet, handleOracleRequestPacketData, handleLinkChainAccountPacketData)
if err != nil {
ack = channeltypes.NewErrorAcknowledgement(err)
}
// NOTE: acknowledgement will be written synchronously during IBC handler execution.
return ack
}
// PacketHandler represents a method that tries handling a packet.
// If the packet has been handled properly, handled will be true and the acknowledgment and error will
// tell how the execution has ended.
// If the packet cannot be handled properly, false will be returned instead as first value.
type PacketHandler = func(
am IBCModule, ctx sdk.Context, packet channeltypes.Packet,
) (handled bool, ack channeltypes.Acknowledgement, err error)
// HandlePacket handles the given packet by passing it to the provided packet handlers one by one until
// at least one of them can handle it.
// If no handler supports the given packet, it returns types.ErrInvalidPacketData.
func (am IBCModule) HandlePacket(
ctx sdk.Context, packet channeltypes.Packet, packetHandlers ...PacketHandler,
) (channeltypes.Acknowledgement, error) {
for _, handler := range packetHandlers {
handled, ack, err := handler(am, ctx, packet)
if handled {
return ack, err
}
}
return channeltypes.Acknowledgement{}, errors.Wrapf(types.ErrInvalidPacketData, "%T", packet)
}
// handleLinkChainAccountPacketData tries handling athe given packet by deserializing the inner data
// as a LinkChainAccountPacketData instance.
func handleLinkChainAccountPacketData(
am IBCModule, ctx sdk.Context, packet channeltypes.Packet,
) (handled bool, ack channeltypes.Acknowledgement, err error) {
var packetData types.LinkChainAccountPacketData
if err := types.ModuleCdc.UnmarshalJSON(packet.GetData(), &packetData); err != nil {
return false, channeltypes.Acknowledgement{}, nil
}
var acknowledgement channeltypes.Acknowledgement
packetAck, err := am.keeper.OnRecvLinkChainAccountPacket(ctx, packetData)
if err != nil {
acknowledgement = channeltypes.NewErrorAcknowledgement(err)
} else {
// Encode packet acknowledgment
packetAckBytes, err := packetAck.Marshal()
if err != nil {
return true, channeltypes.Acknowledgement{}, errors.Wrap(sdkerrors.ErrJSONMarshal, err.Error())
}
acknowledgement = channeltypes.NewResultAcknowledgement(packetAckBytes)
}
address, err := types.UnpackAddressData(am.cdc, packetData.SourceAddress)
if err != nil {
return true, channeltypes.Acknowledgement{}, err
}
ctx.EventManager().EmitEvent(
sdk.NewEvent(
types.EventTypeLinkChainAccountPacket,
sdk.NewAttribute(sdk.AttributeKeyModule, types.ModuleName),
sdk.NewAttribute(types.AttributeKeyChainLinkExternalAddress, address.GetValue()),
sdk.NewAttribute(types.AttributeKeyChainLinkChainName, packetData.SourceChainConfig.Name),
sdk.NewAttribute(types.AttributeKeyChainLinkOwner, packetData.DestinationAddress),
sdk.NewAttribute(types.AttributeKeyAckSuccess, fmt.Sprintf("%t", true)),
),
)
return true, acknowledgement, nil
}
// handleOracleRequestPacketData tries handling athe given packet by deserializing the inner data
// as an OracleResponsePacketData instance.
func handleOracleRequestPacketData(
am IBCModule, ctx sdk.Context, packet channeltypes.Packet,
) (handled bool, ack channeltypes.Acknowledgement, err error) {
var data oracletypes.OracleResponsePacketData
if err := types.ModuleCdc.UnmarshalJSON(packet.GetData(), &data); err != nil {
return false, channeltypes.Acknowledgement{}, nil
}
acknowledgement := channeltypes.NewResultAcknowledgement([]byte{byte(1)})
err = am.keeper.OnRecvApplicationLinkPacketData(ctx, data)
if err != nil {
acknowledgement = channeltypes.NewErrorAcknowledgement(err)
}
ctx.EventManager().EmitEvent(
sdk.NewEvent(
types.EventTypePacket,
sdk.NewAttribute(sdk.AttributeKeyModule, types.ModuleName),
sdk.NewAttribute(types.AttributeKeyClientID, data.ClientID),
sdk.NewAttribute(types.AttributeKeyRequestID, fmt.Sprintf("%d", data.RequestID)),
sdk.NewAttribute(types.AttributeKeyResolveStatus, data.ResolveStatus.String()),
sdk.NewAttribute(types.AttributeKeyAckSuccess, fmt.Sprintf("%t", true)),
),
)
// NOTE: acknowledgement will be written synchronously during IBC handler execution.
return true, acknowledgement, nil
}
// -------------------------------------------------------------------------------------------------------------------
// OnAcknowledgementPacket implements the IBCModule interface
func (am IBCModule) OnAcknowledgementPacket(
ctx sdk.Context,
packet channeltypes.Packet,
acknowledgement []byte,
relayer sdk.AccAddress,
) error {
var ack channeltypes.Acknowledgement
err := types.ModuleCdc.UnmarshalJSON(acknowledgement, &ack)
if err != nil {
return errors.Wrapf(sdkerrors.ErrUnknownRequest,
"cannot unmarshal oracle packet acknowledgement: %v", err)
}
var data oracletypes.OracleRequestPacketData
err = types.ModuleCdc.UnmarshalJSON(packet.GetData(), &data)
if err != nil {
return errors.Wrapf(sdkerrors.ErrUnknownRequest,
"cannot unmarshal oracle request packet data: %s", err)
}
err = am.keeper.OnOracleRequestAcknowledgementPacket(ctx, data, ack)
if err != nil {
return err
}
ctx.EventManager().EmitEvent(
sdk.NewEvent(
types.EventTypePacket,
sdk.NewAttribute(sdk.AttributeKeyModule, types.ModuleName),
sdk.NewAttribute(types.AttributeKeyClientID, data.ClientID),
sdk.NewAttribute(types.AttributeKeyAck, fmt.Sprintf("%v", ack)),
),
)
switch resp := ack.Response.(type) {
case *channeltypes.Acknowledgement_Result:
ctx.EventManager().EmitEvent(
sdk.NewEvent(
types.EventTypePacket,
sdk.NewAttribute(types.AttributeKeyAckSuccess, string(resp.Result)),
),
)
case *channeltypes.Acknowledgement_Error:
ctx.EventManager().EmitEvent(
sdk.NewEvent(
types.EventTypePacket,
sdk.NewAttribute(types.AttributeKeyAckError, resp.Error),
),
)
}
return nil
}
// -------------------------------------------------------------------------------------------------------------------
// OnTimeoutPacket implements the IBCModule interface
func (am IBCModule) OnTimeoutPacket(
ctx sdk.Context,
packet channeltypes.Packet,
relayer sdk.AccAddress,
) error {
var data oracletypes.OracleRequestPacketData
err := types.ModuleCdc.UnmarshalJSON(packet.GetData(), &data)
if err != nil {
return errors.Wrapf(sdkerrors.ErrUnknownRequest,
"cannot unmarshal oracle request packet data: %s", err)
}
err = am.keeper.OnOracleRequestTimeoutPacket(ctx, data)
if err != nil {
return err
}
ctx.EventManager().EmitEvent(
sdk.NewEvent(
types.EventTypeTimeout,
sdk.NewAttribute(sdk.AttributeKeyModule, types.ModuleName),
sdk.NewAttribute(types.AttributeKeyOracleID, fmt.Sprintf("%d", data.OracleScriptID)),
sdk.NewAttribute(types.AttributeKeyClientID, data.ClientID),
),
)
return nil
}