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
+}