ADR 8 Interface and Packet Data Implementations

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.CallbackPacketData = (*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,77 @@ func (iapd InterchainAccountPacketData) GetBytes() []byte {
 	return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&iapd))
 }
 
+/*
+
+ADR-8 CallbackPacketData implementation
+
+InterchainAccountPacketData implements CallbackPacketData interface. This will allow middlewares targeting specific VMs
+to retrieve the desired callback address for the ICA packet on the source chain. Destination callback addresses are not
+supported for ICS 27.
+
+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": {contractAddrOnSourceChain},
+
+		// optional fields
+		"src_callback_msg": {jsonObjectForSourceChainCallback},
+	}
+}
+```
+
+*/
+
+// GetSourceCallbackAddress returns the source callback address provided in the packet data memo.
+// If no callback address is specified, an empty string is returned.
+//
+// The memo is expected to specify the callback address in the following format:
+// { "callbacks": { "src_callback_address": {contractAddrOnSourceChain}}
+//
+// ADR-8 middleware should callback on the returned address if it is a PacketActor
+// (i.e. smart contract that accepts IBC callbacks).
+func (iapd InterchainAccountPacketData) GetSourceCallbackAddress() string {
+	if len(iapd.Memo) == 0 {
+		return ""
+	}
+
+	jsonObject := make(map[string]interface{})
+	err := json.Unmarshal([]byte(iapd.Memo), &jsonObject)
+	if err != nil {
+		return ""
+	}
+
+	callbackData, ok := jsonObject["callbacks"].(map[string]interface{})
+	if !ok {
+		return ""
+	}
+
+	callbackAddr, ok := callbackData["src_callback_address"].(string)
+	if !ok {
+		return ""
+	}
+
+	return callbackAddr
+}
+
+// GetDestCallbackAddress returns an empty string. Destination callback addresses
+// are not supported for ICS 27. This feature is natively supported by
+// interchain accounts host submodule transaction execution.
+func (iapd InterchainAccountPacketData) GetDestCallbackAddress() string {
+	return ""
+}
+
+// UserDefinedGasLimit returns 0 (no-op). The gas limit of the executing
+// transaction will be used.
+func (iapd 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/27-interchain-accounts/types/packet_test.go

@@ -1,6 +1,8 @@
 package types_test
 
 import (
+	"fmt"
+
 	"github.com/cosmos/ibc-go/v7/modules/apps/27-interchain-accounts/types"
 )
 
@@ -82,3 +84,123 @@ func (suite *TypesTestSuite) TestValidateBasic() {
 		})
 	}
 }
+
+func (suite *TypesTestSuite) TestGetSourceCallbackAddress() {
+	const expSrcCbAddr = "srcCbAddr"
+
+	testCases := []struct {
+		name       string
+		packetData types.InterchainAccountPacketData
+		expPass    bool
+	}{
+		{
+			"memo is empty",
+			types.InterchainAccountPacketData{
+				Type: types.EXECUTE_TX,
+				Data: []byte("data"),
+				Memo: "",
+			},
+			false,
+		},
+		{
+			"memo is not json string",
+			types.InterchainAccountPacketData{
+				Type: types.EXECUTE_TX,
+				Data: []byte("data"),
+				Memo: "memo",
+			},
+			false,
+		},
+		{
+			"memo does not have callbacks in json struct",
+			types.InterchainAccountPacketData{
+				Type: types.EXECUTE_TX,
+				Data: []byte("data"),
+				Memo: `{"Key": 10}`,
+			},
+			false,
+		},
+		{
+			"memo has callbacks in json struct but does not have src_callback_address key",
+			types.InterchainAccountPacketData{
+				Type: types.EXECUTE_TX,
+				Data: []byte("data"),
+				Memo: `{"callbacks": {"Key": 10}}`,
+			},
+			false,
+		},
+		{
+			"memo has callbacks in json struct but does not have string value for src_callback_address key",
+			types.InterchainAccountPacketData{
+				Type: types.EXECUTE_TX,
+				Data: []byte("data"),
+				Memo: `{"callbacks": {"src_callback_address": 10}}`,
+			},
+			false,
+		},
+		{
+			"memo has callbacks in json struct and properly formatted src_callback_address",
+			types.InterchainAccountPacketData{
+				Type: types.EXECUTE_TX,
+				Data: []byte("data"),
+				Memo: fmt.Sprintf(`{"callbacks": {"src_callback_address": "%s"}}`, expSrcCbAddr),
+			},
+			true,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		suite.Run(tc.name, func() {
+			srcCbAddr := tc.packetData.GetSourceCallbackAddress()
+
+			if tc.expPass {
+				suite.Require().Equal(expSrcCbAddr, srcCbAddr)
+			} else {
+				suite.Require().Equal("", srcCbAddr)
+			}
+		})
+	}
+}
+
+func (suite *TypesTestSuite) TestGetDestCallbackAddress() {
+	testCases := []struct {
+		name       string
+		packetData types.InterchainAccountPacketData
+	}{
+		{
+			"memo is empty",
+			types.InterchainAccountPacketData{
+				Type: types.EXECUTE_TX,
+				Data: []byte("data"),
+				Memo: "",
+			},
+		},
+		{
+			"memo has dest callback address specified in json struct",
+			types.InterchainAccountPacketData{
+				Type: types.EXECUTE_TX,
+				Data: []byte("data"),
+				Memo: `{"callbacks": {"dest_callback_address": "testAddress"}}`,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		suite.Run(tc.name, func() {
+			destCbAddr := tc.packetData.GetDestCallbackAddress()
+			suite.Require().Equal("", destCbAddr)
+		})
+	}
+}
+
+func (suite *TypesTestSuite) TestUserDefinedGasLimit() {
+	packetData := types.InterchainAccountPacketData{
+		Type: types.EXECUTE_TX,
+		Data: []byte("data"),
+		Memo: `{"callbacks": {"user_defined_gas_limit": 100}}`,
+	}
+
+	suite.Require().Equal(uint64(0), packetData.UserDefinedGasLimit(), "user defined gas limit does not return 0")
+}

modules/apps/transfer/types/codec.go

@@ -3,14 +3,13 @@ package types
 import (
 	"bytes"
 
-	"github.com/cosmos/cosmos-sdk/x/authz"
-	"github.com/cosmos/gogoproto/jsonpb"
-	"github.com/cosmos/gogoproto/proto"
-
 	"github.com/cosmos/cosmos-sdk/codec"
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/msgservice"
+	"github.com/cosmos/cosmos-sdk/x/authz"
+	"github.com/cosmos/gogoproto/jsonpb"
+	"github.com/cosmos/gogoproto/proto"
 )
 
 // RegisterLegacyAminoCodec registers the necessary x/ibc transfer interfaces and concrete types

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.CallbackPacketData = (*FungibleTokenPacketData)(nil)
+
 // NewFungibleTokenPacketData contructs a new FungibleTokenPacketData instance
 func NewFungibleTokenPacketData(
 	denom string, amount string,
@@ -62,3 +66,109 @@ func (ftpd FungibleTokenPacketData) ValidateBasic() error {
 func (ftpd FungibleTokenPacketData) GetBytes() []byte {
 	return sdk.MustSortJSON(mustProtoMarshalJSON(&ftpd))
 }
+
+/*
+
+ADR-8 CallbackPacketData implementation
+
+FungibleTokenPacketData implements CallbackPacketData interface. This will allow middlewares targeting 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": {contractAddrOnSourceChain},
+		"dest_callback_address": {contractAddrOnDestChain},
+
+		// optional fields
+		"src_callback_msg": {jsonObjectForSourceChainCallback},
+		"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.
+
+*/
+
+// GetSourceCallbackAddress returns the sender address if it is also specified in
+// the packet data memo. 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 called automatically. If no callback address is
+// specified, an empty string is returned.
+//
+// The memo is expected to contain the source callback address in the following format:
+// { "callbacks": { "src_callback_address": {contractAddrOnSourceChain}}
+//
+// ADR-8 middleware should callback on the returned address if it is a PacketActor
+// (i.e. smart contract that accepts IBC callbacks).
+func (ftpd FungibleTokenPacketData) GetSourceCallbackAddress() string {
+	if len(ftpd.Memo) == 0 {
+		return ""
+	}
+
+	jsonObject := make(map[string]interface{})
+	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 ""
+}
+
+// GetDestCallbackAddress returns the receiving address if it is also specified in
+// the packet data memo. 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 called automatically. If no callback address is
+// specified, an empty string is returned.
+//
+// The memo is expected to contain the destination callback address in the following format:
+// { "callbacks": { "dest_callback_address": {contractAddrOnDestChain}}
+//
+// ADR-8 middleware should callback on the returned address if it is a PacketActor
+// (i.e. smart contract that accepts IBC callbacks).
+func (ftpd FungibleTokenPacketData) GetDestCallbackAddress() string {
+	if len(ftpd.Memo) == 0 {
+		return ""
+	}
+
+	jsonObject := make(map[string]interface{})
+	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 ""
+}
+
+// UserDefinedGasLimit returns 0 (no-op). The gas limit of the executing
+// transaction will be used.
+func (ftpd FungibleTokenPacketData) UserDefinedGasLimit() uint64 {
+	return 0
+}