autopilot fallback address

app/app.go

@@ -613,6 +613,7 @@ func NewStrideApp(
 		appCodec,
 		keys[autopilottypes.StoreKey],
 		app.GetSubspace(autopilottypes.ModuleName),
+		app.BankKeeper,
 		app.StakeibcKeeper,
 		app.ClaimKeeper,
 		app.TransferKeeper,

app/apptesting/test_helpers.go

@@ -18,7 +18,6 @@ import (
 	upgradetypes "github.com/cosmos/cosmos-sdk/x/upgrade/types"
 	"github.com/cosmos/gogoproto/proto"
 	icatypes "github.com/cosmos/ibc-go/v7/modules/apps/27-interchain-accounts/types"
-	ibctransfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types"
 	transfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types"
 	clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types"
 	connectiontypes "github.com/cosmos/ibc-go/v7/modules/core/03-connection/types"
@@ -461,7 +460,7 @@ func (s *AppTestHelper) CreateAndStoreIBCDenom(baseDenom string) (ibcDenom strin
 }
 
 func (s *AppTestHelper) MarshalledICS20PacketData() sdk.AccAddress {
-	data := ibctransfertypes.FungibleTokenPacketData{}
+	data := transfertypes.FungibleTokenPacketData{}
 	return data.GetBytes()
 }
 

x/autopilot/keeper/airdrop.go

@@ -12,16 +12,15 @@ import (
 	channeltypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types"
 
 	"github.com/Stride-Labs/stride/v16/utils"
-	"github.com/Stride-Labs/stride/v16/x/autopilot/types"
 	claimtypes "github.com/Stride-Labs/stride/v16/x/claim/types"
 	stakeibctypes "github.com/Stride-Labs/stride/v16/x/stakeibc/types"
 )
 
+// Attempt to link a host address with a stride address to enable airdrop claims
 func (k Keeper) TryUpdateAirdropClaim(
 	ctx sdk.Context,
 	packet channeltypes.Packet,
-	data transfertypes.FungibleTokenPacketData,
-	packetMetadata types.ClaimPacketMetadata,
+	transferMetadata transfertypes.FungibleTokenPacketData,
 ) error {
 	params := k.GetParams(ctx)
 	if !params.ClaimActive {
@@ -39,11 +38,11 @@ func (k Keeper) TryUpdateAirdropClaim(
 	}
 
 	// grab relevant addresses
-	senderStrideAddress := utils.ConvertAddressToStrideAddress(data.Sender)
+	senderStrideAddress := utils.ConvertAddressToStrideAddress(transferMetadata.Sender)
 	if senderStrideAddress == "" {
-		return errorsmod.Wrapf(sdkerrors.ErrInvalidAddress, fmt.Sprintf("invalid sender address (%s)", data.Sender))
+		return errorsmod.Wrapf(sdkerrors.ErrInvalidAddress, fmt.Sprintf("invalid sender address (%s)", transferMetadata.Sender))
 	}
-	newStrideAddress := packetMetadata.StrideAddress
+	newStrideAddress := transferMetadata.Receiver
 
 	// find the airdrop for this host chain ID
 	airdrop, found := k.claimKeeper.GetAirdropByChainId(ctx, hostZone.ChainId)
@@ -56,7 +55,7 @@ func (k Keeper) TryUpdateAirdropClaim(
 
 	airdropId := airdrop.AirdropIdentifier
 	k.Logger(ctx).Info(fmt.Sprintf("updating airdrop address %s (orig %s) to %s for airdrop %s",
-		senderStrideAddress, data.Sender, newStrideAddress, airdropId))
+		senderStrideAddress, transferMetadata.Sender, newStrideAddress, airdropId))
 
 	return k.claimKeeper.UpdateAirdropAddress(ctx, senderStrideAddress, newStrideAddress, airdropId)
 }

x/autopilot/keeper/fallback.go

@@ -0,0 +1,39 @@
+package keeper
+
+import (
+	"github.com/cosmos/cosmos-sdk/store/prefix"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/Stride-Labs/stride/v16/x/autopilot/types"
+)
+
+// Stores a fallback address for an outbound transfer
+func (k Keeper) SetTransferFallbackAddress(ctx sdk.Context, channelId string, sequence uint64, address string) {
+	store := prefix.NewStore(ctx.KVStore(k.storeKey), types.TransferFallbackAddressPrefix)
+	key := types.GetTransferFallbackAddressKey(channelId, sequence)
+	value := []byte(address)
+	store.Set(key, value)
+}
+
+// Removes a fallback address from the store
+// This is used after the ack or timeout for a packet has been received
+func (k Keeper) RemoveTransferFallbackAddress(ctx sdk.Context, channelId string, sequence uint64) {
+	store := prefix.NewStore(ctx.KVStore(k.storeKey), types.TransferFallbackAddressPrefix)
+	key := types.GetTransferFallbackAddressKey(channelId, sequence)
+	store.Delete(key)
+}
+
+// Returns a fallback address, given the channel ID and sequence number of the packet
+// If no fallback address has been stored, return false
+func (k Keeper) GetTransferFallbackAddress(ctx sdk.Context, channelId string, sequence uint64) (address string, found bool) {
+	store := prefix.NewStore(ctx.KVStore(k.storeKey), types.TransferFallbackAddressPrefix)
+
+	key := types.GetTransferFallbackAddressKey(channelId, sequence)
+	valueBz := store.Get(key)
+
+	if len(valueBz) == 0 {
+		return "", false
+	}
+
+	return string(valueBz), true
+}

x/autopilot/keeper/fallback_test.go

@@ -0,0 +1,22 @@
+package keeper_test
+
+// Tests Get/Set/RemoveTransferFallbackAddress
+func (s *KeeperTestSuite) TestTransferFallbackAddress() {
+	channelId := "channel-0"
+	sequence := uint64(100)
+	expectedAddress := "stride1xjp08gxef09fck6yj2lg0vrgpcjhqhp055ffhj"
+
+	// Add a new fallback address
+	s.App.AutopilotKeeper.SetTransferFallbackAddress(s.Ctx, channelId, sequence, expectedAddress)
+
+	// Confirm we can retrieve it
+	actualAddress, found := s.App.AutopilotKeeper.GetTransferFallbackAddress(s.Ctx, channelId, sequence)
+	s.Require().True(found, "address should have been found")
+	s.Require().Equal(expectedAddress, actualAddress, "fallback addres")
+
+	// Remove it and confirm we can no longer retrieve it
+	s.App.AutopilotKeeper.RemoveTransferFallbackAddress(s.Ctx, channelId, sequence)
+
+	_, found = s.App.AutopilotKeeper.GetTransferFallbackAddress(s.Ctx, channelId, sequence)
+	s.Require().False(found, "address should have been removed")
+}

x/autopilot/keeper/ibc.go

@@ -0,0 +1,97 @@
+package keeper
+
+import (
+	"fmt"
+
+	errorsmod "cosmossdk.io/errors"
+	sdkmath "cosmossdk.io/math"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	transfertypes "github.com/cosmos/ibc-go/v7/modules/apps/transfer/types"
+	channeltypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types"
+
+	"github.com/Stride-Labs/stride/v16/x/icacallbacks"
+	icacallbacktypes "github.com/Stride-Labs/stride/v16/x/icacallbacks/types"
+)
+
+// In the event of an ack error after a outbound transfer, we'll have to bank send to a fallback address
+func (k Keeper) SendToFallbackAddress(ctx sdk.Context, packetData []byte, fallbackAddress string) error {
+	// First unmarshal the transfer metadata to get the sender/reciever, and token amount/denom
+	var transferMetadata transfertypes.FungibleTokenPacketData
+	if err := transfertypes.ModuleCdc.UnmarshalJSON(packetData, &transferMetadata); err != nil {
+		return err
+	}
+
+	// Pull out the original sender of the transfer which will also be the bank sender
+	sender := transferMetadata.Sender
+	senderAccount, err := sdk.AccAddressFromBech32(sender)
+	if err != nil {
+		return errorsmod.Wrapf(err, "invalid sender address")
+	}
+	fallbackAccount, err := sdk.AccAddressFromBech32(fallbackAddress)
+	if err != nil {
+		return errorsmod.Wrapf(err, "invalid fallback address")
+	}
+
+	// Build the token from the transfer metadata
+	amount, ok := sdkmath.NewIntFromString(transferMetadata.Amount)
+	if !ok {
+		return fmt.Errorf("unable to parse amount from transfer packet: %v", transferMetadata)
+	}
+	token := sdk.NewCoin(transferMetadata.Denom, amount)
+
+	// Finally send to the fallback account
+	if err := k.bankKeeper.SendCoins(ctx, senderAccount, fallbackAccount, sdk.NewCoins(token)); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// If there was a timeout or failed ack from an outbound transfer of one of the autopilot actions,
+// we'll need to check if there was a fallback address. If one was stored, bank send to that address
+// If the ack was successful, we should delete the address (if it exists)
+func (k Keeper) HandleFallbackAddress(ctx sdk.Context, packet channeltypes.Packet, acknowledgement []byte, packetTimedOut bool) error {
+	// Retrieve the fallback address for the given packet
+	// We use the packet source channel here since this will correspond with the channel on Stride
+	channelId := packet.SourceChannel
+	sequence := packet.Sequence
+	fallbackAddress, fallbackAddressFound := k.GetTransferFallbackAddress(ctx, channelId, sequence)
+
+	// If there was no fallback address, there's nothing else to do
+	if !fallbackAddressFound {
+		return nil
+	}
+
+	// Remove the fallback address since the packet is no longer pending
+	k.RemoveTransferFallbackAddress(ctx, channelId, sequence)
+
+	// If the packet timed out, send to the fallback address
+	if packetTimedOut {
+		return k.SendToFallbackAddress(ctx, packet.Data, fallbackAddress)
+	}
+
+	// If the packet did not timeout, check whether the ack was successful or was an ack error
+	isICATx := false
+	ackResponse, err := icacallbacks.UnpackAcknowledgementResponse(ctx, k.Logger(ctx), acknowledgement, isICATx)
+	if err != nil {
+		return err
+	}
+
+	// If successful, no additional action is necessary
+	if ackResponse.Status == icacallbacktypes.AckResponseStatus_SUCCESS {
+		return nil
+	}
+
+	// If there was an ack error, we'll need to bank send to the fallback address
+	return k.SendToFallbackAddress(ctx, packet.Data, fallbackAddress)
+}
+
+// OnTimeoutPacket should always send to the fallback address
+func (k Keeper) OnTimeoutPacket(ctx sdk.Context, packet channeltypes.Packet) error {
+	return k.HandleFallbackAddress(ctx, packet, []byte{}, true)
+}
+
+// OnAcknowledgementPacket should send to the fallback address if the ack is an ack error
+func (k Keeper) OnAcknowledgementPacket(ctx sdk.Context, packet channeltypes.Packet, acknowledgement []byte) error {
+	return k.HandleFallbackAddress(ctx, packet, acknowledgement, false)
+}