Add async support to wasm hooks

app/keepers/keepers.go

@@ -243,6 +243,8 @@ func (appKeepers *AppKeepers) InitNormalKeepers(
 	// Configure the hooks keeper
 	hooksKeeper := ibchookskeeper.NewKeeper(
 		appKeepers.keys[ibchookstypes.StoreKey],
+		appKeepers.IBCKeeper.ChannelKeeper,
+		nil,
 	)
 	appKeepers.IBCHooksKeeper = &hooksKeeper
 
@@ -456,6 +458,7 @@ func (appKeepers *AppKeepers) InitNormalKeepers(
 	appKeepers.ContractKeeper = wasmkeeper.NewDefaultPermissionKeeper(appKeepers.WasmKeeper)
 	appKeepers.RateLimitingICS4Wrapper.ContractKeeper = appKeepers.ContractKeeper
 	appKeepers.Ics20WasmHooks.ContractKeeper = appKeepers.ContractKeeper
+	appKeepers.IBCHooksKeeper.ContractKeeper = appKeepers.ContractKeeper
 
 	// wire up x/wasm to IBC
 	ibcRouter.AddRoute(wasm.ModuleName, wasm.NewIBCHandler(appKeepers.WasmKeeper, appKeepers.IBCKeeper.ChannelKeeper, appKeepers.IBCKeeper.ChannelKeeper))

app/modules.go

@@ -178,7 +178,7 @@ func appModules(
 		tokenfactory.NewAppModule(*app.TokenFactoryKeeper, app.AccountKeeper, app.BankKeeper),
 		valsetprefmodule.NewAppModule(appCodec, *app.ValidatorSetPreferenceKeeper),
 		ibcratelimitmodule.NewAppModule(*app.RateLimitingICS4Wrapper),
-		ibc_hooks.NewAppModule(app.AccountKeeper),
+		ibc_hooks.NewAppModule(app.AccountKeeper, *app.IBCHooksKeeper),
 		icq.NewAppModule(*app.AppKeepers.ICQKeeper),
 		packetforward.NewAppModule(app.PacketForwardKeeper),
 	}

cosmwasm/contracts/crosschain-swaps/src/execute.rs

@@ -6,7 +6,7 @@ use swaprouter::msg::ExecuteMsg as SwapRouterExecute;
 
 use crate::checks::{check_is_contract_governor, ensure_key_missing, validate_receiver};
 use crate::consts::{MsgReplyID, CALLBACK_KEY};
-use crate::msg::{CrosschainSwapResponse, FailedDeliveryAction};
+use crate::msg::{AsyncResponse, CrosschainSwapResponse, FailedDeliveryAction};
 use registry::proto::MsgTransferResponse;
 
 use crate::state::{

osmoutils/ibc.go

@@ -2,6 +2,7 @@ package osmoutils
 
 import (
 	"encoding/json"
+	"fmt"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	transfertypes "github.com/cosmos/ibc-go/v4/modules/apps/transfer/types"
 	channeltypes "github.com/cosmos/ibc-go/v4/modules/core/04-channel/types"
@@ -11,15 +12,19 @@ import (
 // NewEmitErrorAcknowledgement creates a new error acknowledgement after having emitted an event with the
 // details of the error.
 func NewEmitErrorAcknowledgement(ctx sdk.Context, err error, errorContexts ...string) channeltypes.Acknowledgement {
+	errorType := "ibc-acknowledgement-error"
+	logger := ctx.Logger().With("module", errorType)
+
 	attributes := make([]sdk.Attribute, len(errorContexts)+1)
 	attributes[0] = sdk.NewAttribute("error", err.Error())
 	for i, s := range errorContexts {
 		attributes[i+1] = sdk.NewAttribute("error-context", s)
+		logger.Error(fmt.Sprintf("error-context: %v", s))
 	}
 
 	ctx.EventManager().EmitEvents(sdk.Events{
 		sdk.NewEvent(
-			"ibc-acknowledgement-error",
+			errorType,
 			attributes...,
 		),
 	})

proto/osmosis/ibc-hooks/tx.proto

@@ -0,0 +1,25 @@
+syntax = "proto3";
+package osmosis.ibchooks;
+
+import "gogoproto/gogo.proto";
+
+option go_package = "github.com/osmosis-labs/osmosis/v15/x/ibc-hooks/types";
+
+// Msg defines the Msg service.
+service Msg {
+  // EmitIBCAck checks the sender can emit the ack and writes the IBC
+  // acknowledgement
+  rpc EmitIBCAck(MsgEmitIBCAck) returns (MsgEmitIBCAckResponse);
+}
+
+message MsgEmitIBCAck {
+  string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ];
+  uint64 packet_sequence = 2
+      [ (gogoproto.moretags) = "yaml:\"packet_sequence\"" ];
+  string channel = 3 [ (gogoproto.moretags) = "yaml:\"channel\"" ];
+}
+message MsgEmitIBCAckResponse {
+  string contract_result = 1
+      [ (gogoproto.moretags) = "yaml:\"contract_result\"" ];
+  string ibc_ack = 2 [ (gogoproto.moretags) = "yaml:\"ibc_ack\"" ];
+}

tests/ibc-hooks/async_acks_test.go

@@ -0,0 +1,90 @@
+package ibc_hooks_test
+
+import (
+	"encoding/json"
+	"fmt"
+	wasmkeeper "github.com/CosmWasm/wasmd/x/wasm/keeper"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	channeltypes "github.com/cosmos/ibc-go/v4/modules/core/04-channel/types"
+	ibctesting "github.com/cosmos/ibc-go/v4/testing"
+	"github.com/osmosis-labs/osmosis/v15/app"
+)
+
+func (suite *HooksTestSuite) forceContractToEmitAckForPacket(osmosisApp *app.OsmosisApp, contractAddr sdk.AccAddress, packet channeltypes.Packet) ([]byte, error) {
+	packetJson, err := json.Marshal(packet)
+	suite.Require().NoError(err)
+
+	msg := fmt.Sprintf(`{"force_emit_ibc_ack": {"packet": %s, "channel": "channel-0"}}`, packetJson)
+	contractKeeper := wasmkeeper.NewDefaultPermissionKeeper(osmosisApp.WasmKeeper)
+	return contractKeeper.Execute(suite.chainA.GetContext(), contractAddr, suite.chainA.SenderAccount.GetAddress(), []byte(msg), sdk.NewCoins())
+
+}
+
+func (suite *HooksTestSuite) TestWasmHooksAsyncAcks() {
+	sender := suite.chainB.SenderAccount.GetAddress()
+	osmosisApp := suite.chainA.GetOsmosisApp()
+
+	// Instantiate a contract that knows how to send async Acks
+	suite.chainA.StoreContractCode(&suite.Suite, "./bytecode/echo.wasm")
+	contractAddr := suite.chainA.InstantiateContract(&suite.Suite, "{}", 1)
+
+	// Calls that don't specify async acks work as expected
+	memo := fmt.Sprintf(`{"wasm": {"contract": "%s", "msg": {"async": {"use_async": false}}}}`, contractAddr)
+	suite.fundAccount(suite.chainB, sender)
+	transferMsg := NewMsgTransfer(sdk.NewCoin("token0", sdk.NewInt(2000)), sender.String(), contractAddr.String(), "channel-0", memo)
+	sendResult, receiveResult, ack, err := suite.FullSend(transferMsg, BtoA)
+	suite.Require().NoError(err)
+	suite.Require().NotNil(sendResult)
+	suite.Require().NotNil(receiveResult)
+	suite.Require().NotNil(ack)
+
+	// the ack has been written
+	allAcks := osmosisApp.IBCKeeper.ChannelKeeper.GetAllPacketAcks(suite.chainA.GetContext())
+	suite.Require().Equal(1, len(allAcks))
+
+	// Try to emit an ack for a packet that already has been acked. This should fail
+
+	// we extract the packet that has been acked here to test later that our contract can't emit an ack for it
+	alreadyAckedPacket, err := ibctesting.ParsePacketFromEvents(sendResult.GetEvents())
+	suite.Require().NoError(err)
+
+	_, err = suite.forceContractToEmitAckForPacket(osmosisApp, contractAddr, alreadyAckedPacket)
+	suite.Require().Error(err)
+	suite.Require().Contains(err.Error(), "no ack actor set for channel channel-0 packet 1")
+
+	// Calls that specify async Acks work and no Acks are sent
+	memo = fmt.Sprintf(`{"wasm": {"contract": "%s", "msg": {"async": {"use_async": true}}}}`, contractAddr)
+	suite.fundAccount(suite.chainB, sender)
+	transferMsg = NewMsgTransfer(sdk.NewCoin("token0", sdk.NewInt(2000)), sender.String(), contractAddr.String(), "channel-0", memo)
+
+	sendResult, err = suite.chainB.SendMsgsNoCheck(transferMsg)
+	suite.Require().NoError(err)
+
+	packet, err := ibctesting.ParsePacketFromEvents(sendResult.GetEvents())
+	suite.Require().NoError(err)
+
+	receiveResult = suite.RelayPacketNoAck(packet, BtoA)
+	newAck, err := ibctesting.ParseAckFromEvents(receiveResult.GetEvents())
+	suite.Require().Error(err) // No ack!
+	suite.Require().Nil(newAck)
+
+	// No new ack has been written
+	allAcks = osmosisApp.IBCKeeper.ChannelKeeper.GetAllPacketAcks(suite.chainA.GetContext())
+	suite.Require().Equal(1, len(allAcks))
+
+	// Store a second contract and ask that one to emit an ack for the packet that the first contract sent
+	contractAddr2 := suite.chainA.InstantiateContract(&suite.Suite, "{}", 1)
+	_, err = suite.forceContractToEmitAckForPacket(osmosisApp, contractAddr2, packet)
+	// This should fail because the new contract is not authorized to emit acks for that packet
+	suite.Require().Error(err)
+	suite.Require().Contains(err.Error(), "is not allowed to send an ack for channel channel-0 packet 2")
+
+	// only the contract that sent the packet can send an ack for that packet sequence
+	_, err = suite.forceContractToEmitAckForPacket(osmosisApp, contractAddr, packet)
+	suite.Require().NoError(err)
+
+	allAcks = osmosisApp.IBCKeeper.ChannelKeeper.GetAllPacketAcks(suite.chainA.GetContext())
+	fmt.Println(allAcks)
+	suite.Require().Equal(2, len(allAcks))
+
+}