ADR 8 Interface and Packet Data Implementations

modules/apps/27-interchain-accounts/types/codec.go

@@ -7,6 +7,7 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 	"github.com/cosmos/gogoproto/proto"
+	"github.com/cosmos/ibc-go/v7/modules/core/exported"
 )
 
 // ModuleCdc references the global interchain accounts module codec. Note, the codec
@@ -21,6 +22,11 @@ var ModuleCdc = codec.NewProtoCodec(codectypes.NewInterfaceRegistry())
 func RegisterInterfaces(registry codectypes.InterfaceRegistry) {
 	registry.RegisterImplementations((*authtypes.AccountI)(nil), &InterchainAccount{})
 	registry.RegisterImplementations((*authtypes.GenesisAccount)(nil), &InterchainAccount{})
+
+	registry.RegisterImplementations(
+		(*exported.CallbackPacketDataI)(nil),
+		&InterchainAccountPacketData{},
+	)
 }
 
 // SerializeCosmosTx serializes a slice of sdk.Msg's using the CosmosTx type. The sdk.Msg's are

modules/apps/27-interchain-accounts/types/packet.go

@@ -1,11 +1,13 @@
 package types
 
 import (
+	"encoding/json"
 	"time"
 
 	errorsmod "cosmossdk.io/errors"
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/ibc-go/v7/modules/core/exported"
 )
 
 // MaxMemoCharLength defines the maximum length for the InterchainAccountPacketData memo field
@@ -24,6 +26,8 @@ var (
 	DefaultRelativePacketTimeoutTimestamp = uint64((time.Duration(10) * time.Minute).Nanoseconds())
 )
 
+var _ exported.CallbackPacketDataI = (*InterchainAccountPacketData)(nil)
+
 // ValidateBasic performs basic validation of the interchain account packet data.
 // The memo may be empty.
 func (iapd InterchainAccountPacketData) ValidateBasic() error {
@@ -47,6 +51,83 @@ func (iapd InterchainAccountPacketData) GetBytes() []byte {
 	return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&iapd))
 }
 
+/**
+
+ADR-8 CallbackPacketData implementation
+
+InterchainAccountPacketData implements CallbackPacketDataI interface. This will allow middlewares targetting specific VMs
+to retrieve the desired callback addresses for the ICA packet on the source and destination chains.
+
+The Memo is used to set the desired callback addresses.
+
+The Memo format is defined like so:
+
+```json
+{
+	// ... other memo fields we don't care about
+	"callbacks": {
+		"src_callback_address": {contractAddrOnSrcChain},
+		"dest_callback_address": {contractAddrOnDestChain},
+		"src_callback_msg": {jsonObjectForSrcChainCallback},
+		"dest_callback_msg": {jsonObjectForDestChainCallback},
+	}
+
+}
+```
+
+**/
+
+// ADR-8 middleware should callback on the sender address on the source chain
+// if the sender address is an IBC Actor (i.e. smart contract that accepts IBC callbacks)
+func (iapd InterchainAccountPacketData) GetSrcCallbackAddress() (addr string) {
+	if len(iapd.Memo) == 0 {
+		return
+	}
+
+	jsonObject := make(map[string]interface{})
+	// the jsonObject must be a valid JSON object
+	err := json.Unmarshal([]byte(iapd.Memo), &jsonObject)
+	if err != nil {
+		return
+	}
+
+	callbackData, ok := jsonObject["callbacks"].(map[string]interface{})
+	if !ok {
+		return
+	}
+
+	callbackAddr := callbackData["src_callback_address"].(string)
+	return callbackAddr
+}
+
+// ADR-8 middleware should callback on the receiver address on the destination chain
+// if the receiver address is an IBC Actor (i.e. smart contract that accepts IBC callbacks)
+func (iapd InterchainAccountPacketData) GetDestCallbackAddress() (addr string) {
+	if len(iapd.Memo) == 0 {
+		return
+	}
+
+	jsonObject := make(map[string]interface{})
+	// the jsonObject must be a valid JSON object
+	err := json.Unmarshal([]byte(iapd.Memo), &jsonObject)
+	if err != nil {
+		return
+	}
+
+	callbackData, ok := jsonObject["callbacks"].(map[string]interface{})
+	if !ok {
+		return
+	}
+
+	callbackAddr := callbackData["dest_callback_address"].(string)
+	return callbackAddr
+}
+
+// no-op on this method to use relayer passed in gas
+func (fptd InterchainAccountPacketData) UserDefinedGasLimit() uint64 {
+	return 0
+}
+
 // GetBytes returns the JSON marshalled interchain account CosmosTx.
 func (ct CosmosTx) GetBytes() []byte {
 	return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&ct))

modules/apps/transfer/types/codec.go

@@ -6,6 +6,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/authz"
 	"github.com/cosmos/gogoproto/jsonpb"
 	"github.com/cosmos/gogoproto/proto"
+	"github.com/cosmos/ibc-go/v7/modules/core/exported"
 
 	"github.com/cosmos/cosmos-sdk/codec"
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
@@ -29,6 +30,11 @@ func RegisterInterfaces(registry codectypes.InterfaceRegistry) {
 		&TransferAuthorization{},
 	)
 
+	registry.RegisterImplementations(
+		(*exported.CallbackPacketDataI)(nil),
+		&FungibleTokenPacketData{}
+	)
+
 	msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc)
 }
 

modules/apps/transfer/types/packet.go

@@ -1,13 +1,15 @@
 package types
 
 import (
+	"encoding/json"
 	"strings"
 	"time"
 
 	errorsmod "cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	ibcerrors "github.com/cosmos/ibc-go/v7/internal/errors"
+	"github.com/cosmos/ibc-go/v7/modules/core/exported"
 )
 
 var (
@@ -23,6 +25,8 @@ var (
 	DefaultRelativePacketTimeoutTimestamp = uint64((time.Duration(10) * time.Minute).Nanoseconds())
 )
 
+var _ exported.CallbackPacketDataI = (*FungibleTokenPacketData)(nil)
+
 // NewFungibleTokenPacketData contructs a new FungibleTokenPacketData instance
 func NewFungibleTokenPacketData(
 	denom string, amount string,
@@ -62,3 +66,95 @@ func (ftpd FungibleTokenPacketData) ValidateBasic() error {
 func (ftpd FungibleTokenPacketData) GetBytes() []byte {
 	return sdk.MustSortJSON(mustProtoMarshalJSON(&ftpd))
 }
+
+/**
+
+ADR-8 CallbackPacketData implementation
+
+FungibleTokenPacketData implements CallbackPacketDataI interface. This will allow middlewares targetting specific VMs
+to retrieve the desired callback addresses for the ICS20 packet on the source and destination chains.
+
+The Memo is used to ensure that the callback is desired by the user. This allows a user to send an ICS20 packet
+to a contract with ADR-8 enabled without automatically triggering the callback logic which may lead to unexpected
+behaviour.
+
+The Memo format is defined like so:
+
+```json
+{
+	// ... other memo fields we don't care about
+	"callbacks": {
+		"src_callback_address": {contractAddrOnSrcChain},
+		"dest_callback_address": {contractAddrOnDestChain},
+		"src_callback_msg": {jsonObjectForSrcChainCallback},
+		"dest_callback_msg": {jsonObjectForDestChainCallback},
+	}
+
+}
+```
+
+For transfer, we will enforce that the src_callback_address is the same as sender and dest_callback_address is the same as receiver.
+However, we may remove this restriction at a later date if it proves useful.
+
+**/
+
+// ADR-8 middleware should callback on the sender address on the source chain
+// if the sender address is an IBC Actor (i.e. smart contract that accepts IBC callbacks)
+// The desired callback address must be confirmed in the memo under the "callbacks" key.
+// This ensures that the callback is explicitly desired by the user and not just called
+// automatically.
+func (ftpd FungibleTokenPacketData) GetSrcCallbackAddress() (addr string) {
+	if len(ftpd.Memo) == 0 {
+		return
+	}
+
+	jsonObject := make(map[string]interface{})
+	// the jsonObject must be a valid JSON object
+	err := json.Unmarshal([]byte(ftpd.Memo), &jsonObject)
+	if err != nil {
+		return
+	}
+
+	callbackData, ok := jsonObject["callbacks"].(map[string]interface{})
+	if !ok {
+		return
+	}
+
+	if callbackData["src_callback_address"] == ftpd.Sender {
+		return ftpd.Sender
+	}
+	return
+}
+
+// ADR-8 middleware should callback on the receiver address on the destination chain
+// if the receiver address is an IBC Actor (i.e. smart contract that accepts IBC callbacks)
+// The desired callback address must be confirmed in the memo under the "callbacks" key.
+// This ensures that the callback is explicitly desired by the user and not just called
+// automatically.
+func (ftpd FungibleTokenPacketData) GetDestCallbackAddress() (addr string) {
+	if len(ftpd.Memo) == 0 {
+		return
+	}
+
+	jsonObject := make(map[string]interface{})
+	// the jsonObject must be a valid JSON object
+	err := json.Unmarshal([]byte(ftpd.Memo), &jsonObject)
+	if err != nil {
+		return
+	}
+
+	callbackData, ok := jsonObject["callbacks"].(map[string]interface{})
+	if !ok {
+		return
+	}
+
+	if callbackData["dest_callback_address"] == ftpd.Receiver {
+		return ftpd.Receiver
+	}
+	return
+}
+
+// no-op on this method to use relayer passed in gas
+func (fptd FungibleTokenPacketData) UserDefinedGasLimit() uint64 {
+	return 0
+}

modules/core/exported/callbacks.go

@@ -0,0 +1,19 @@
+package exported
+
+type CallbackPacketDataI interface {
+	// may return the empty string
+	GetSrcCallbackAddress() string
+
+	// may return the empty string
+	GetDestCallbackAddress() string
+
+	// UserDefinedGasLimit allows the sender of the packet to define inside the packet data
+	// a gas limit for how much the ADR-8 callbacks can consume. If defined, this will be passed
+	// in as the gas limit so that the callback is guaranteed to complete within a specific limit.
+	// On recvPacket, a gas-overflow will just fail the transaction allowing it to timeout on the sender side.
+	// On ackPacket and timeoutPacket, a gas-overflow will reject state changes made during callback but still
+	// commit the transaction. This ensures the packet lifecycle can always complete.
+	// If the packet data returns 0, the remaining gas limit will be passed in (modulo any chain-defined limit)
+	// Otherwise, we will set the gas limit passed into the callback to the `min(ctx.GasLimit, UserDefinedGasLimit())`
+	UserDefinedGasLimit() uint64
+}

modules/core/exported/codec.go

@@ -0,0 +1,12 @@
+package exported
+
+import (
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+)
+
+func RegisterInterfaces(registry codectypes.InterfaceRegistry) {
+	registry.RegisterInterface(
+		"ibc.core.exported.v1.CallbackPacketDataI",
+		(*CallbackPacketDataI)(nil),
+	)
+}

modules/core/types/codec.go

@@ -7,6 +7,7 @@ import (
 	connectiontypes "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types"
 	channeltypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types"
 	commitmenttypes "github.com/cosmos/ibc-go/v7/modules/core/23-commitment/types"
+	"github.com/cosmos/ibc-go/v7/modules/core/exported"
 	localhost "github.com/cosmos/ibc-go/v7/modules/light-clients/09-localhost"
 )
 
@@ -18,4 +19,5 @@ func RegisterInterfaces(registry codectypes.InterfaceRegistry) {
 	channeltypes.RegisterInterfaces(registry)
 	commitmenttypes.RegisterInterfaces(registry)
 	localhost.RegisterInterfaces(registry)
+	exported.RegisterInterfaces(registry)
 }