feat(stride): Stride outpost types and events

precompiles/outposts/stride/events.go

@@ -0,0 +1,110 @@
+// Copyright Tharsis Labs Ltd.(Evmos)
+// SPDX-License-Identifier:ENCL-1.0(https://github.com/evmos/evmos/blob/main/LICENSE)
+
+package stride
+
+import (
+	"math/big"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+	ethtypes "github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/core/vm"
+	cmn "github.com/evmos/evmos/v15/precompiles/common"
+)
+
+const (
+	// EventLiquidStake is the event type emitted on a liquidStake transaction to Autopilot on Stride.
+	EventLiquidStake = "LiquidStake"
+	// EventRedeem is the event type emitted on a redeem transaction to Autopilot on Stride.
+	EventRedeem = "Redeem"
+)
+
+// EmitLiquidStakeEvent creates a new LiquidStake event on the EVM stateDB.
+func (p Precompile) EmitLiquidStakeEvent(
+	ctx sdk.Context,
+	stateDB vm.StateDB,
+	sender,
+	token common.Address,
+	amount *big.Int,
+) error {
+	// Prepare the event topics
+	event := p.ABI.Events[EventLiquidStake]
+	topics := make([]common.Hash, 3)
+
+	// The first topic is always the signature of the event.
+	topics[0] = event.ID
+
+	var err error
+	// sender and receiver are indexed
+	topics[1], err = cmn.MakeTopic(sender)
+	if err != nil {
+		return err
+	}
+
+	topics[2], err = cmn.MakeTopic(token)
+	if err != nil {
+		return err
+	}
+
+	// Prepare the event data: amount
+	arguments := abi.Arguments{event.Inputs[2]}
+	packed, err := arguments.Pack(amount)
+	if err != nil {
+		return err
+	}
+
+	stateDB.AddLog(&ethtypes.Log{
+		Address:     p.Address(),
+		Topics:      topics,
+		Data:        packed,
+		BlockNumber: uint64(ctx.BlockHeight()),
+	})
+
+	return nil
+}
+
+// EmitRedeemEvent creates a new Redeem event on the EVM stateDB.
+func (p Precompile) EmitRedeemEvent(
+	ctx sdk.Context,
+	stateDB vm.StateDB,
+	sender,
+	token common.Address,
+	receiver string,
+	amount *big.Int,
+) error {
+	// Prepare the event topics
+	event := p.ABI.Events[EventRedeem]
+	topics := make([]common.Hash, 3)
+
+	// The first topic is always the signature of the event.
+	topics[0] = event.ID
+
+	var err error
+	// sender and token are indexed
+	topics[1], err = cmn.MakeTopic(sender)
+	if err != nil {
+		return err
+	}
+	topics[2], 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)
+	if err != nil {
+		return err
+	}
+
+	stateDB.AddLog(&ethtypes.Log{
+		Address:     p.Address(),
+		Topics:      topics,
+		Data:        packed,
+		BlockNumber: uint64(ctx.BlockHeight()),
+	})
+
+	return nil
+}

precompiles/outposts/stride/types.go

@@ -0,0 +1,116 @@
+// Copyright Tharsis Labs Ltd.(Evmos)
+// SPDX-License-Identifier:ENCL-1.0(https://github.com/evmos/evmos/blob/main/LICENSE)
+
+package stride
+
+import (
+	"encoding/json"
+	"fmt"
+	"math/big"
+	"strings"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+	"github.com/ethereum/go-ethereum/common"
+	cmn "github.com/evmos/evmos/v15/precompiles/common"
+)
+
+// StakeIBCPacketMetadata metadata info specific to StakeIBC (e.g. 1-click liquid staking)
+type StakeIBCPacketMetadata struct {
+	Action        string `json:"action"`
+	StrideAddress string
+}
+
+// Autopilot defines the receiver and IBC packet metadata info specific to the
+// Stride Autopilot liquid staking behavior
+type Autopilot struct {
+	Receiver string                  `json:"receiver"`
+	StakeIBC *StakeIBCPacketMetadata `json:"stakeibc,omitempty"`
+}
+
+// RawPacketMetadata is the raw packet metadata used to construct a JSON string
+type RawPacketMetadata struct {
+	Autopilot *Autopilot `json:"autopilot"`
+}
+
+// parseLiquidStakeArgs parses the arguments from the Liquid Stake method call
+//
+//nolint:unused
+func parseLiquidStakeArgs(args []interface{}) (common.Address, common.Address, *big.Int, string, error) {
+	if len(args) != 4 {
+		return common.Address{}, common.Address{}, nil, "", fmt.Errorf(cmn.ErrInvalidNumberOfArgs, 4, len(args))
+	}
+
+	sender, ok := args[0].(common.Address)
+	if !ok {
+		return common.Address{}, common.Address{}, nil, "", fmt.Errorf(cmn.ErrInvalidType, "sender", "", args[0])
+	}
+
+	token, ok := args[1].(common.Address)
+	if !ok {
+		return common.Address{}, common.Address{}, nil, "", fmt.Errorf(cmn.ErrInvalidType, "token", "", args[1])
+	}
+
+	amount, ok := args[2].(*big.Int)
+	if !ok {
+		return common.Address{}, common.Address{}, nil, "", fmt.Errorf(cmn.ErrInvalidType, "amount", "", args[2])
+	}
+
+	receiver, ok := args[3].(string)
+	if !ok {
+		return common.Address{}, common.Address{}, nil, "", fmt.Errorf(cmn.ErrInvalidType, "receiver", "", args[3])
+	}
+
+	// Check if the receiver address has stride before
+	if receiver[:6] != "stride" {
+		return common.Address{}, common.Address{}, nil, "", fmt.Errorf("receiver is not a stride address")
+	}
+
+	// Check if account is a valid bech32 address
+	_, err := AccAddressFromBech32(receiver, "stride")
+	if err != nil {
+		return common.Address{}, common.Address{}, nil, "", sdkerrors.ErrInvalidAddress.Wrapf("invalid stride bech32 address: %s", err)
+	}
+
+	return sender, token, amount, receiver, nil
+}
+
+// AccAddressFromBech32 creates an AccAddress from a Bech32 string.
+func AccAddressFromBech32(address string, bech32prefix string) (addr sdk.AccAddress, err error) {
+	if len(strings.TrimSpace(address)) == 0 {
+		return sdk.AccAddress{}, fmt.Errorf("empty address string is not allowed")
+	}
+
+	bz, err := sdk.GetFromBech32(address, bech32prefix)
+	if err != nil {
+		return nil, err
+	}
+
+	err = sdk.VerifyAddressFormat(bz)
+	if err != nil {
+		return nil, err
+	}
+
+	return sdk.AccAddress(bz), nil
+}
+
+// CreateMemo creates the memo for the StakeIBC actions - LiquidStake and Redeem.
+func CreateMemo(action, receiverAddress string) (string, error) {
+	// Create a new instance of the struct and populate it
+	data := &RawPacketMetadata{
+		Autopilot: &Autopilot{
+			Receiver: receiverAddress,
+			StakeIBC: &StakeIBCPacketMetadata{
+				Action: action,
+			},
+		},
+	}
+
+	// Convert the struct to a JSON string
+	jsonBytes, err := json.MarshalIndent(data, "", "  ")
+	if err != nil {
+		return "", sdkerrors.ErrJSONMarshal.Wrap("autopilot packet")
+	}
+
+	return string(jsonBytes), nil
+}

precompiles/outposts/stride/types_test.go

@@ -0,0 +1,44 @@
+package stride_test
+
+import (
+	"testing"
+
+	strideoutpost "github.com/evmos/evmos/v15/precompiles/outposts/stride"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCreateMemo(t *testing.T) {
+	t.Parallel()
+
+	testcases := []struct {
+		name        string
+		action      string
+		receiver    string
+		expPass     bool
+		errContains string
+	}{
+		{
+			name:     "success - liquid stake",
+			action:   strideoutpost.LiquidStakeAction,
+			receiver: "cosmos1xv9tklw7d82sezh9haa573wufgy59vmwe6xxe5",
+			expPass:  true,
+		},
+	}
+
+	for _, tc := range testcases {
+		tc := tc
+
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			memo, err := strideoutpost.CreateMemo(tc.action, tc.receiver)
+			if tc.expPass {
+				require.NoError(t, err, "expected no error while creating memo")
+				require.NotEmpty(t, memo, "expected memo not to be empty")
+			} else {
+				require.Error(t, err, "expected error while creating memo")
+				require.Contains(t, err.Error(), tc.errContains, "expected different error")
+			}
+		})
+	}
+}