implement IBC transfer on peg in

Author: keithsue

app/app.go

@@ -680,6 +680,7 @@ func New(
 		app.OracleKeeper,
 		app.IncentiveKeeper,
 		app.TSSKeeper,
+		app.TransferKeeper,
 		authtypes.NewModuleAddress(govtypes.ModuleName).String(),
 	)
 

testutil/keeper/btc_bridge.go

@@ -50,6 +50,7 @@ func BtcBridgeKeeper(t testing.TB) (*keeper.Keeper, sdk.Context) {
 		app.OracleKeeper,
 		app.IncentiveKeeper,
 		app.TSSKeeper,
+		app.TransferKeeper,
 		authority,
 	)
 

x/btcbridge/keeper/deposit.go

@@ -21,14 +21,14 @@ func (k Keeper) ProcessBitcoinDepositTransaction(ctx sdk.Context, msg *types.Msg
 		return nil, nil, err
 	}
 
-	assetType, recipient, err := k.Mint(ctx, msg.Sender, tx, prevTx, uint64(k.oracleKeeper.GetBlockHeader(ctx, msg.Blockhash).Height))
+	assetType, recipient, amount, err := k.Mint(ctx, msg.Sender, tx, prevTx, uint64(k.oracleKeeper.GetBlockHeader(ctx, msg.Blockhash).Height))
 	if err != nil {
 		return nil, nil, err
 	}
 
 	// hook
 	if assetType == types.AssetType_ASSET_TYPE_BTC {
-		if err := k.AfterDeposit(ctx, recipient.EncodeAddress()); err != nil {
+		if err := k.AfterDeposit(ctx, recipient.EncodeAddress(), *amount, tx.MsgTx()); err != nil {
 			return nil, nil, err
 		}
 	}
@@ -37,10 +37,10 @@ func (k Keeper) ProcessBitcoinDepositTransaction(ctx sdk.Context, msg *types.Msg
 }
 
 // Mint performs the minting operation of the voucher token
-func (k Keeper) Mint(ctx sdk.Context, sender string, tx *btcutil.Tx, prevTx *btcutil.Tx, height uint64) (types.AssetType, btcutil.Address, error) {
+func (k Keeper) Mint(ctx sdk.Context, sender string, tx *btcutil.Tx, prevTx *btcutil.Tx, height uint64) (types.AssetType, btcutil.Address, *sdk.Coin, error) {
 	hash := tx.Hash().String()
 	if k.existsInHistory(ctx, hash) {
-		return types.AssetType_ASSET_TYPE_UNSPECIFIED, nil, types.ErrTransactionAlreadyMinted
+		return types.AssetType_ASSET_TYPE_UNSPECIFIED, nil, nil, types.ErrTransactionAlreadyMinted
 	}
 
 	k.addToMintHistory(ctx, hash)
@@ -53,7 +53,7 @@ func (k Keeper) Mint(ctx sdk.Context, sender string, tx *btcutil.Tx, prevTx *btc
 	// if the edict is not nil, it indicates that this is a legal runes deposit tx
 	edict, err := types.CheckRunesDepositTransaction(tx.MsgTx(), params.Vaults)
 	if err != nil {
-		return types.AssetType_ASSET_TYPE_UNSPECIFIED, nil, err
+		return types.AssetType_ASSET_TYPE_UNSPECIFIED, nil, nil, err
 	}
 
 	isRunes := edict != nil
@@ -65,52 +65,57 @@ func (k Keeper) Mint(ctx sdk.Context, sender string, tx *btcutil.Tx, prevTx *btc
 
 	// check if the sender is trusted to relay runes deposit
 	if isRunes && !k.IsTrustedNonBtcRelayer(ctx, sender) {
-		return assetType, nil, types.ErrUntrustedNonBtcRelayer
+		return assetType, nil, nil, types.ErrUntrustedNonBtcRelayer
 	}
 
 	// extract the recipient for minting voucher token
 	recipient, err := types.ExtractRecipientAddr(tx.MsgTx(), prevTx.MsgTx(), params.Vaults, isRunes, chainCfg)
 	if err != nil {
-		return assetType, nil, err
+		return assetType, nil, nil, err
 	}
 
+	var amount *sdk.Coin
+
 	if !isRunes {
 		out, vout, vault, err := k.getOutputForMintBTC(ctx, tx.MsgTx(), chainCfg)
 		if err != nil {
-			return assetType, nil, err
+			return assetType, nil, nil, err
 		}
 
-		if err := k.mintBTC(ctx, tx, height, recipient.EncodeAddress(), vault, out, vout, params.BtcVoucherDenom); err != nil {
-			return assetType, nil, err
+		amount, err = k.mintBTC(ctx, tx, height, recipient.EncodeAddress(), vault, out, vout, params.BtcVoucherDenom)
+		if err != nil {
+			return assetType, nil, nil, err
 		}
 	} else {
 		outs, vouts, vaults, err := k.getOutputsForMintRunes(ctx, tx.MsgTx(), edict, chainCfg)
 		if err != nil {
-			return assetType, nil, err
+			return assetType, nil, nil, err
 		}
 
-		if err := k.mintRunes(ctx, tx, height, recipient.EncodeAddress(), vaults, outs, vouts, edict.Id, edict.Amount); err != nil {
-			return assetType, nil, err
+		amount, err = k.mintRunes(ctx, tx, height, recipient.EncodeAddress(), vaults, outs, vouts, edict.Id, edict.Amount)
+		if err != nil {
+			return assetType, nil, nil, err
 		}
 	}
 
-	return assetType, recipient, nil
+	return assetType, recipient, amount, nil
 }
 
-func (k Keeper) mintBTC(ctx sdk.Context, tx *btcutil.Tx, height uint64, recipient string, vault string, out *wire.TxOut, vout int, denom string) error {
+func (k Keeper) mintBTC(ctx sdk.Context, tx *btcutil.Tx, height uint64, recipient string, vault string, out *wire.TxOut, vout int, denom string) (*sdk.Coin, error) {
 	amount := sdk.NewInt64Coin(denom, out.Value)
 
 	recipientAddr, err := sdk.AccAddressFromBech32(recipient)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	if err := k.bankKeeper.MintCoins(ctx, types.ModuleName, sdk.NewCoins(amount)); err != nil {
-		return err
+		return nil, err
 	}
 
-	if err := k.mintBTCWithProtocolFee(ctx, recipientAddr, amount); err != nil {
-		return err
+	actualAmount, err := k.mintBTCWithProtocolFee(ctx, recipientAddr, amount)
+	if err != nil {
+		return nil, err
 	}
 
 	utxo := types.UTXO{
@@ -125,28 +130,28 @@ func (k Keeper) mintBTC(ctx sdk.Context, tx *btcutil.Tx, height uint64, recipien
 
 	k.saveUTXO(ctx, &utxo)
 
-	return nil
+	return actualAmount, nil
 }
 
-func (k Keeper) mintRunes(ctx sdk.Context, tx *btcutil.Tx, height uint64, recipient string, vaults []string, outs []*wire.TxOut, vouts []int, id *types.RuneId, amount string) error {
-	coins := sdk.NewCoins(sdk.NewCoin(id.Denom(), sdkmath.NewIntFromBigInt(types.RuneAmountFromString(amount).Big())))
+func (k Keeper) mintRunes(ctx sdk.Context, tx *btcutil.Tx, height uint64, recipient string, vaults []string, outs []*wire.TxOut, vouts []int, id *types.RuneId, amount string) (*sdk.Coin, error) {
+	coin := sdk.NewCoin(id.Denom(), sdkmath.NewIntFromBigInt(types.RuneAmountFromString(amount).Big()))
 
 	recipientAddr, err := sdk.AccAddressFromBech32(recipient)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	if err := k.bankKeeper.MintCoins(ctx, types.ModuleName, coins); err != nil {
-		return err
+	if err := k.bankKeeper.MintCoins(ctx, types.ModuleName, sdk.NewCoins(coin)); err != nil {
+		return nil, err
 	}
 
-	if err := k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, recipientAddr, coins); err != nil {
-		return err
+	if err := k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, recipientAddr, sdk.NewCoins(coin)); err != nil {
+		return nil, err
 	}
 
 	if k.ProtocolDepositFeeEnabled(ctx) {
 		if err := k.handleRunesProtocolFee(ctx, tx.Hash().String(), height, outs[1], vouts[1], vaults[1]); err != nil {
-			return err
+			return nil, err
 		}
 	}
 
@@ -166,35 +171,38 @@ func (k Keeper) mintRunes(ctx sdk.Context, tx *btcutil.Tx, height uint64, recipi
 
 	k.saveUTXO(ctx, &utxo)
 
-	return nil
+	return &coin, nil
 }
 
 // mintBTCWithProtocolFee performs btc minting along with the protocol fee handling
-func (k Keeper) mintBTCWithProtocolFee(ctx sdk.Context, recipient sdk.AccAddress, amount sdk.Coin) error {
+func (k Keeper) mintBTCWithProtocolFee(ctx sdk.Context, recipient sdk.AccAddress, amount sdk.Coin) (*sdk.Coin, error) {
 	params := k.GetParams(ctx)
 
 	var err error
-	depositAmount := amount
 
 	if k.ProtocolDepositFeeEnabled(ctx) {
 		protocolFee := sdk.NewInt64Coin(params.BtcVoucherDenom, params.ProtocolFees.DepositFee)
 		protocolFeeCollector := sdk.MustAccAddressFromBech32(params.ProtocolFees.Collector)
 
-		depositAmount, err = depositAmount.SafeSub(protocolFee)
+		amount, err = amount.SafeSub(protocolFee)
 		if err != nil {
-			return err
+			return nil, err
 		}
 
 		if err := k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, protocolFeeCollector, sdk.NewCoins(protocolFee)); err != nil {
-			return err
+			return nil, err
 		}
 	}
 
-	if depositAmount.Amount.Int64() < params.ProtocolLimits.BtcMinDeposit {
-		return types.ErrInvalidDepositAmount
+	if amount.Amount.Int64() < params.ProtocolLimits.BtcMinDeposit {
+		return nil, types.ErrInvalidDepositAmount
+	}
+
+	if err := k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, recipient, sdk.NewCoins(amount)); err != nil {
+		return nil, err
 	}
 
-	return k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, recipient, sdk.NewCoins(depositAmount))
+	return &amount, nil
 }
 
 // handleRunesProtocolFee performs the protocol fee handling for runes deposit

x/btcbridge/keeper/hooks.go

@@ -1,16 +1,29 @@
 package keeper
 
 import (
+	"github.com/btcsuite/btcd/wire"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/sideprotocol/side/x/btcbridge/types"
 )
 
 // AfterDeposit performs the extended logic after deposit
-func (k Keeper) AfterDeposit(ctx sdk.Context, addr string) error {
-	// distribute deposit reward
+func (k Keeper) AfterDeposit(ctx sdk.Context, addr string, amount sdk.Coin, tx *wire.MsgTx) error {
+	// distribute deposit reward if enabled
 	if k.incentiveKeeper.DepositIncentiveEnabled(ctx) {
 		_ = k.incentiveKeeper.DistributeDepositReward(ctx, addr)
 	}
 
+	// perform IBC transfer if enabled
+	script := types.GetIBCTransferScript(tx)
+	if len(script) != 0 {
+		channelId, recipient, err := types.ParseIBCTransferScript(script)
+		if err == nil {
+			_ = k.IBCTransfer(ctx, addr, recipient, amount, channelId)
+		}
+	}
+
 	return nil
 }
 

x/btcbridge/keeper/ibc.go

@@ -12,6 +12,26 @@ import (
 	"github.com/sideprotocol/side/x/btcbridge/types"
 )
 
+// IBCTransfer transfers the specified token via IBC
+func (k Keeper) IBCTransfer(ctx sdk.Context, sender string, recipient string, token sdk.Coin, channelId string) error {
+	msg := &transfertypes.MsgTransfer{
+		SourcePort:       types.DefaultPortId,
+		SourceChannel:    channelId,
+		Token:            token,
+		Sender:           sender,
+		Receiver:         recipient,
+		TimeoutHeight:    clienttypes.NewHeight(0, 0),
+		TimeoutTimestamp: 0,
+		Memo:             types.DefaultMemo,
+	}
+
+	if _, err := k.ibctransferKeeper.Transfer(ctx, msg); err != nil {
+		return err
+	}
+
+	return nil
+}
+
 // AddToIBCWithdrawRequestQueue adds the given packet to IBC withdrawal queue for sBTC
 func (k Keeper) AddToIBCWithdrawRequestQueue(ctx sdk.Context, sequence uint64, recipient string, amount int64) {
 	store := ctx.KVStore(k.storeKey)
@@ -62,9 +82,9 @@ func (k Keeper) IterateIBCWithdrawRequestQueue(ctx sdk.Context, cb func(req *typ
 	}
 }
 
-// CheckSBTCAutoPegout returns true if the given packet is sBTC transfer and auto-pegout enabled, false otherwise
-func (k Keeper) CheckSBTCAutoPegout(ctx sdk.Context, packet transfertypes.FungibleTokenPacketData) bool {
-	return packet.Denom == k.BtcDenom(ctx) && packet.Memo == types.TagAutoPegout
+// CheckSBTCAutoPegOut returns true if the given packet is sBTC transfer and auto-pegout enabled, false otherwise
+func (k Keeper) CheckSBTCAutoPegOut(ctx sdk.Context, packet transfertypes.FungibleTokenPacketData) bool {
+	return packet.Denom == k.BtcDenom(ctx) && packet.Memo == types.FlagAutoPegOut
 }
 
 // IBCSendPacketCallback implements IBC callbacks
@@ -121,7 +141,7 @@ func (k Keeper) IBCReceivePacketCallback(
 
 	// parse the transfer packet
 	tranferPacket, ok := tryGetTransferPacket(packet)
-	if !ok || !k.CheckSBTCAutoPegout(ctx, tranferPacket) {
+	if !ok || !k.CheckSBTCAutoPegOut(ctx, tranferPacket) {
 		return nil
 	}
 

x/btcbridge/keeper/keeper.go

@@ -26,11 +26,12 @@ type (
 		storeKey storetypes.StoreKey
 		memKey   storetypes.StoreKey
 
-		bankKeeper      types.BankKeeper
-		stakingKeeper   types.StakingKeeper
-		oracleKeeper    types.OracleKeeper
-		incentiveKeeper types.IncentiveKeeper
-		tssKeeper       types.TSSKeeper
+		bankKeeper        types.BankKeeper
+		stakingKeeper     types.StakingKeeper
+		oracleKeeper      types.OracleKeeper
+		incentiveKeeper   types.IncentiveKeeper
+		tssKeeper         types.TSSKeeper
+		ibctransferKeeper types.IBCTransferKeeper
 
 		authority string
 	}
@@ -45,19 +46,21 @@ func NewKeeper(
 	oracleKeeper types.OracleKeeper,
 	incentiveKeeper types.IncentiveKeeper,
 	tssKeeper types.TSSKeeper,
+	ibctransferKeeper types.IBCTransferKeeper,
 	authority string,
 ) *Keeper {
 	return &Keeper{
-		cdc:             cdc,
-		storeKey:        storeKey,
-		memKey:          memKey,
-		bankKeeper:      bankKeeper,
-		stakingKeeper:   stakingKeeper,
-		oracleKeeper:    oracleKeeper,
-		incentiveKeeper: incentiveKeeper,
-		tssKeeper:       tssKeeper,
-		BaseUTXOKeeper:  *NewBaseUTXOKeeper(cdc, storeKey),
-		authority:       authority,
+		cdc:               cdc,
+		storeKey:          storeKey,
+		memKey:            memKey,
+		bankKeeper:        bankKeeper,
+		stakingKeeper:     stakingKeeper,
+		oracleKeeper:      oracleKeeper,
+		incentiveKeeper:   incentiveKeeper,
+		tssKeeper:         tssKeeper,
+		ibctransferKeeper: ibctransferKeeper,
+		BaseUTXOKeeper:    *NewBaseUTXOKeeper(cdc, storeKey),
+		authority:         authority,
 	}
 }
 

x/btcbridge/keeper/keeper_test.go

@@ -123,7 +123,7 @@ func (suite *KeeperTestSuite) TestMintRunes() {
 	balanceBefore := suite.app.BankKeeper.GetBalance(suite.ctx, sdk.MustAccAddressFromBech32(suite.sender), denom)
 	suite.True(balanceBefore.Amount.IsZero(), "%s balance before mint should be zero", denom)
 
-	assetType, recipient, err := suite.app.BtcBridgeKeeper.Mint(suite.ctx, suite.sender, btcutil.NewTx(tx), btcutil.NewTx(tx), 0)
+	assetType, recipient, _, err := suite.app.BtcBridgeKeeper.Mint(suite.ctx, suite.sender, btcutil.NewTx(tx), btcutil.NewTx(tx), 0)
 	suite.NoError(err)
 	suite.Equal(assetType, types.AssetType_ASSET_TYPE_RUNES)
 	suite.Equal(suite.sender, recipient.EncodeAddress(), "incorrect recipient")

x/btcbridge/types/errors.go

@@ -62,5 +62,5 @@ var (
 
 	ErrInvalidConsolidation = errorsmod.Register(ModuleName, 8100, "invalid consolidation")
 
-	ErrInvalidDepositScript = errorsmod.Register(ModuleName, 9000, "invalid deposit script for IBC transfer")
+	ErrInvalidIBCTransferScript = errorsmod.Register(ModuleName, 9000, "invalid deposit script for IBC transfer")
 )

x/btcbridge/types/expected_keepers.go

@@ -8,6 +8,7 @@ import (
 	banktype "github.com/cosmos/cosmos-sdk/x/bank/types"
 	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 
+	ibctransfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types"
 	oracletypes "github.com/sideprotocol/side/x/oracle/types"
 	tsstypes "github.com/sideprotocol/side/x/tss/types"
 )
@@ -61,7 +62,12 @@ type IncentiveKeeper interface {
 	DistributeWithdrawReward(ctx sdk.Context, addr string) error
 }
 
-// TSSKeeper defines the expected TSS keeper interface
+// TSSKeeper defines the expected TSS keeper interfaces
 type TSSKeeper interface {
 	GetParams(ctx sdk.Context) tsstypes.Params
 }
+
+// IBCTransferKeeper defines the expected IBC transfer interfaces
+type IBCTransferKeeper interface {
+	Transfer(goCtx context.Context, msg *ibctransfertypes.MsgTransfer) (*ibctransfertypes.MsgTransferResponse, error)
+}