fix(stride): Update Redeem method, types and tests.

CHANGELOG.md

@@ -76,6 +76,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
 - (stride-outpost) [#1926](https://github.com/evmos/evmos/pull/1926) Refactor event names and definitions.
 - (stride-outpost) [#1931](https://github.com/evmos/evmos/pull/1931) Add Stride unit testing setup.
 - (stride-outpost) [#1932](https://github.com/evmos/evmos/pull/1932) Add transaction implementation and events unit tests.
+- (stride-outpost) [#1935](https://github.com/evmos/evmos/pull/1935) Refactor RedeemStake method.
 
 ### Bug Fixes
 

precompiles/outposts/stride/IStrideOutpost.sol

@@ -46,13 +46,15 @@ interface IStrideOutpost {
 
     /// @dev Emitted on a Redeem transaction.
     /// @param sender The address of the sender.
+    /// @param receiver The address of the receiver on the Evmos chain.
     /// @param token The token to be un-luquid staked.
-    /// @param receiver The bech32-formatted address of the receiver on the Stride chain.
+    /// @param strideForwarder The bech32-formatted address of the receiver on the Stride chain.
     /// @param amount The amount of tokens to unstake.
-    event Redeem(
+    event RedeemStake(
         address indexed sender,
+        address indexed receiver,
         address indexed token,
-        string receiver,
+        string strideForwarder,
         uint256 amount
     );
 
@@ -61,7 +63,7 @@ interface IStrideOutpost {
     /// @param token The hex ERC20 address of the token pair.
     /// @param amount The amount that will be liquid staked.
     /// @param receiver The bech32 address of the receiver.
-    /// @return nextSequence sequence number of the transfer packet sent
+    /// @return nextSequence The sequence number of the transfer packet sent
     /// @return success True if the ICS20 transfer was successful.
     function liquidStake(
         address sender,
@@ -73,15 +75,17 @@ interface IStrideOutpost {
     /// @dev This method unstakes the LSD Coin (ex. stEvmos, stAtom) and redeems
     /// the native Coin by sending an ICS20 Transfer to the specified chain.
     /// @param sender The sender of the redeem transaction.
+    /// @param receiver the address of the receiver on Evmos.
     /// @param token The hex address of the token to be redeemed.
     /// @param amount The amount of tokens unstaked.
-    /// @param receiver The bech32-formatted address of the receiver on Stride.
-    /// @return nextSequence sequence number of the transfer packet sent
+    /// @param strideForwarder The bech32-formatted address of the receiver on Stride.
+    /// @return nextSequence The sequence number of the transfer packet sent
     /// @return success The boolean value indicating whether the operation succeeded.
-    function redeem(
+    function redeemStake(
         address sender,
+        address receiver,
         address token,
-        uint256 amount,
-        string calldata receiver
+        string calldata strideForwarder,
+        uint256 amount
     ) external returns (uint64 nextSequence, bool success);
 }

precompiles/outposts/stride/abi.json

@@ -82,6 +82,12 @@
         "name": "sender",
         "type": "address"
       },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "receiver",
+        "type": "address"
+      },
       {
         "indexed": true,
         "internalType": "address",
@@ -91,7 +97,7 @@
       {
         "indexed": false,
         "internalType": "string",
-        "name": "receiver",
+        "name": "strideForwarder",
         "type": "string"
       },
       {
@@ -101,7 +107,7 @@
         "type": "uint256"
       }
     ],
-    "name": "Redeem",
+    "name": "RedeemStake",
     "type": "event"
   },
   {
@@ -152,21 +158,26 @@
       },
       {
         "internalType": "address",
-        "name": "token",
+        "name": "receiver",
         "type": "address"
       },
       {
-        "internalType": "uint256",
-        "name": "amount",
-        "type": "uint256"
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
       },
       {
         "internalType": "string",
-        "name": "receiver",
+        "name": "strideForwarder",
         "type": "string"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amount",
+        "type": "uint256"
       }
     ],
-    "name": "redeem",
+    "name": "redeemStake",
     "outputs": [
       {
         "internalType": "uint64",

precompiles/outposts/stride/events.go

@@ -17,8 +17,8 @@
 const (
 	// EventTypeLiquidStake is the event type emitted on a liquidStake transaction to Autopilot on Stride.
 	EventTypeLiquidStake = "LiquidStake"
-	// EventTypeRedeem is the event type emitted on a redeem transaction to Autopilot on Stride.
-	EventTypeRedeem = "Redeem"
+	// EventTypeRedeemStake is the event type emitted on a redeem transaction to Autopilot on Stride.
+	EventTypeRedeemStake = "RedeemStake"
 )
 
 // EmitLiquidStakeEvent creates a new LiquidStake event on the EVM stateDB.
@@ -64,18 +64,18 @@
 	return nil
 }
 
-// EmitRedeemEvent creates a new Redeem event on the EVM stateDB.
-func (p Precompile) EmitRedeemEvent(
+// EmitRedeemStakeEvent creates a new RedeemStake event on the EVM stateDB.
+func (p Precompile) EmitRedeemStakeEvent(
 	ctx sdk.Context,
 	stateDB vm.StateDB,
 	sender,
-	token common.Address,
-	receiver string,
+	token, receiver common.Address,
+	strideForwarder string,
 	amount *big.Int,
 ) error {
 	// Prepare the event topics
-	event := p.ABI.Events[EventTypeRedeem]
-	topics := make([]common.Hash, 3)
+	event := p.ABI.Events[EventTypeRedeemStake]
+	topics := make([]common.Hash, 4)
 
 	// The first topic is always the signature of the event.
 	topics[0] = event.ID
@@ -86,14 +86,20 @@
 	if err != nil {
 		return err
 	}
-	topics[2], err = cmn.MakeTopic(token)
+
+	topics[2], err = cmn.MakeTopic(receiver)
+	if err != nil {
+		return err
+	}
+
+	topics[3], err = cmn.MakeTopic(token)
 	if err != nil {
 		return err
 	}
 
 	// Prepare the event data: receiver, amount
-	arguments := abi.Arguments{event.Inputs[2], event.Inputs[3]}
-	packed, err := arguments.Pack(receiver, amount)
+	arguments := abi.Arguments{event.Inputs[3], event.Inputs[4]}
+	packed, err := arguments.Pack(strideForwarder, amount)
 	if err != nil {
 		return err
 	}

precompiles/outposts/stride/events_test.go

@@ -19,7 +19,6 @@ func (s *PrecompileTestSuite) TestLiquidStakeEvent() {
 	tokenPair, ok := s.app.Erc20Keeper.GetTokenPair(s.ctx, denomID)
 	s.Require().True(ok, "expected token pair to be found")
 
-	//nolint:dupl
 	testCases := []struct {
 		name      string
 		postCheck func()
@@ -68,7 +67,6 @@ func (s *PrecompileTestSuite) TestRedeemEvent() {
 	tokenPair, ok := s.app.Erc20Keeper.GetTokenPair(s.ctx, denomID)
 	s.Require().True(ok, "expected token pair to be found")
 
-	//nolint:dupl
 	testCases := []struct {
 		name      string
 		postCheck func()
@@ -79,15 +77,17 @@ func (s *PrecompileTestSuite) TestRedeemEvent() {
 				redeemLog := s.stateDB.Logs()[0]
 				s.Require().Equal(redeemLog.Address, s.precompile.Address())
 				// Check event signature matches the one emitted
-				event := s.precompile.ABI.Events[stride.EventTypeRedeem]
+				event := s.precompile.ABI.Events[stride.EventTypeRedeemStake]
 				s.Require().Equal(event.ID, common.HexToHash(redeemLog.Topics[0].Hex()))
 				s.Require().Equal(redeemLog.BlockNumber, uint64(s.ctx.BlockHeight()))
 
 				var redeemEvent stride.EventRedeem
-				err := cmn.UnpackLog(s.precompile.ABI, &redeemEvent, stride.EventTypeRedeem, *redeemLog)
+				err := cmn.UnpackLog(s.precompile.ABI, &redeemEvent, stride.EventTypeRedeemStake, *redeemLog)
 				s.Require().NoError(err)
 				s.Require().Equal(common.BytesToAddress(s.address.Bytes()), redeemEvent.Sender)
 				s.Require().Equal(common.HexToAddress(tokenPair.Erc20Address), redeemEvent.Token)
+				s.Require().Equal(s.address, redeemEvent.Receiver)
+				s.Require().Equal(receiver, redeemEvent.StrideForwarder)
 				s.Require().Equal(big.NewInt(1e18), redeemEvent.Amount)
 			},
 		},
@@ -97,7 +97,7 @@ func (s *PrecompileTestSuite) TestRedeemEvent() {
 		s.Run(tc.name, func() {
 			s.SetupTest()
 
-			err := s.precompile.EmitRedeemEvent(s.ctx, s.stateDB, s.address, common.HexToAddress(tokenPair.Erc20Address), receiver, big.NewInt(1e18))
+			err := s.precompile.EmitRedeemStakeEvent(s.ctx, s.stateDB, s.address, common.HexToAddress(tokenPair.Erc20Address), s.address, receiver, big.NewInt(1e18))
 			s.Require().NoError(err)
 			tc.postCheck()
 		})

precompiles/outposts/stride/stride.go

@@ -114,8 +114,8 @@
 	// Stride Outpost Methods:
 	case LiquidStakeMethod:
 		bz, err = p.LiquidStake(ctx, evm.Origin, stateDB, contract, method, args)
-	case RedeemMethod:
-		bz, err = p.Redeem(ctx, evm.Origin, stateDB, contract, method, args)
+	case RedeemStakeMethod:
+		bz, err = p.RedeemStake(ctx, evm.Origin, stateDB, contract, method, args)
 	default:
 		return nil, fmt.Errorf(cmn.ErrUnknownMethod, method.Name)
 	}
@@ -136,7 +136,7 @@
 // IsTransaction checks if the given method name corresponds to a transaction or query.
 func (Precompile) IsTransaction(method string) bool {
 	switch method {
-	case LiquidStakeMethod, RedeemMethod:
+	case LiquidStakeMethod, RedeemStakeMethod:
 		return true
 	default:
 		return false

precompiles/outposts/stride/tx.go

@@ -18,12 +18,14 @@
 const (
 	// LiquidStakeMethod is the name of the liquidStake method
 	LiquidStakeMethod = "liquidStake"
-	// RedeemMethod is the name of the redeem method
-	RedeemMethod = "redeem"
+	// RedeemStakeMethod is the name of the redeem method
+	RedeemStakeMethod = "redeemStake"
 	// LiquidStakeAction is the action name needed in the memo field
 	LiquidStakeAction = "LiquidStake"
-	// RedeemAction is the action name needed in the memo field
-	RedeemAction = "Redeem"
+	// RedeemStakeAction is the action name needed in the memo field
+	RedeemStakeAction = "RedeemStake"
+	// NoReceiver is the string used in the memo field when the receiver is not needed
+	NoReceiver = ""
 )
 
 // LiquidStake is a transaction that liquid stakes tokens using
@@ -69,7 +71,7 @@
 	coin := sdk.Coin{Denom: tokenPair.Denom, Amount: sdk.NewIntFromBigInt(amount)}
 
 	// Create the memo for the ICS20 transfer packet
-	memo, err := CreateMemo(LiquidStakeAction, receiver)
+	memo, err := CreateMemo(LiquidStakeAction, receiver, NoReceiver)
 	if err != nil {
 		return nil, err
 	}
@@ -131,18 +133,18 @@
 	return method.Outputs.Pack(res.Sequence, true)
 }
 
-// Redeem is a transaction that redeems the native tokens using the liquid stake
+// RedeemStake is a transaction that redeems the native tokens using the liquid stake
 // tokens. It executes a ICS20 transfer with a custom memo field that will
 // trigger Stride's Autopilot middleware
-func (p Precompile) Redeem(
+func (p Precompile) RedeemStake(
 	ctx sdk.Context,
 	origin common.Address,
 	stateDB vm.StateDB,
 	contract *vm.Contract,
 	method *abi.Method,
 	args []interface{},
 ) ([]byte, error) {
-	sender, token, amount, receiver, err := parseLiquidStakeArgs(args)
+	sender, receiver, token, strideForwarder, amount, err := parseRedeemStakeArgs(args)
 	if err != nil {
 		return nil, err
 	}
@@ -175,7 +177,7 @@
 	coin := sdk.Coin{Denom: tokenPair.Denom, Amount: sdk.NewIntFromBigInt(amount)}
 
 	// Create the memo for the ICS20 transfer
-	memo, err := CreateMemo(RedeemAction, receiver)
+	memo, err := CreateMemo(RedeemStakeAction, strideForwarder, sdk.AccAddress(receiver.Bytes()).String())
 	if err != nil {
 		return nil, err
 	}
@@ -186,7 +188,7 @@
 		p.channelID,
 		coin,
 		sdk.AccAddress(sender.Bytes()).String(),
-		receiver,
+		strideForwarder,
 		p.timeoutHeight,
 		0,
 		memo,
@@ -229,8 +231,8 @@
 		return nil, err
 	}
 
-	// Emit the custom Redeem Event
-	if err := p.EmitRedeemEvent(ctx, stateDB, sender, token, receiver, amount); err != nil {
+	// Emit the custom RedeemStake Event
+	if err := p.EmitRedeemStakeEvent(ctx, stateDB, sender, token, receiver, strideForwarder, amount); err != nil {
 		return nil, err
 	}