feat: replace rlp with abi.encode in cross-cahin transfer

x/bridge/keeper/cross_app_test.go

@@ -5,7 +5,6 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/cosmos/cosmos-sdk/bsc/rlp"
 	"github.com/cosmos/cosmos-sdk/crypto/hd"
 	"github.com/cosmos/cosmos-sdk/testutil"
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -72,7 +71,7 @@ func (s *TestSuite) TestTransferOutAck() {
 		RefundReason: 1,
 	}
 
-	packageBytes, err := rlp.EncodeToBytes(&refundPackage)
+	packageBytes, err := refundPackage.Serialize()
 	s.Require().Nil(err, "encode refund package error")
 
 	transferOutApp := keeper.NewTransferOutApp(*s.bridgeKeeper)
@@ -94,7 +93,7 @@ func (s *TestSuite) TestTransferOutFailAck() {
 		RefundAddress: addr1,
 	}
 
-	packageBytes, err := rlp.EncodeToBytes(&synPackage)
+	packageBytes, err := synPackage.Serialize()
 	s.Require().Nil(err, "encode refund package error")
 
 	transferOutApp := keeper.NewTransferOutApp(*s.bridgeKeeper)
@@ -172,7 +171,7 @@ func (s *TestSuite) TestTransferInSyn() {
 		RefundAddress:   sdk.AccAddress{1},
 	}
 
-	packageBytes, err := rlp.EncodeToBytes(&transferInSynPackage)
+	packageBytes, err := transferInSynPackage.Serialize()
 	s.Require().Nil(err, "encode refund package error")
 
 	transferInApp := keeper.NewTransferInApp(*s.bridgeKeeper)

x/bridge/keeper/msg_server_transfer_out.go

@@ -4,7 +4,6 @@ import (
 	"context"
 
 	"cosmossdk.io/errors"
-	"github.com/cosmos/cosmos-sdk/bsc/rlp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	crosschaintypes "github.com/cosmos/cosmos-sdk/x/crosschain/types"
 
@@ -42,7 +41,7 @@ func (k msgServer) TransferOut(goCtx context.Context, msg *types.MsgTransferOut)
 		Amount:        msg.Amount.Amount.BigInt(),
 	}
 
-	encodedPackage, err := rlp.EncodeToBytes(transferPackage)
+	encodedPackage, err := transferPackage.Serialize()
 	if err != nil {
 		return nil, errors.Wrapf(types.ErrInvalidPackage, "encode transfer out package error")
 	}

x/bridge/types/types.go

@@ -4,9 +4,10 @@ import (
 	"math/big"
 
 	"cosmossdk.io/errors"
-	"github.com/cosmos/cosmos-sdk/bsc/rlp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/gov/types"
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
 )
 
 const (
@@ -24,11 +25,48 @@ type TransferOutSynPackage struct {
 	RefundAddress sdk.AccAddress
 }
 
+type TransferOutSynPackageStruct struct {
+	Amount        *big.Int
+	Recipient     common.Address
+	RefundAddress common.Address
+}
+
+var (
+	transferOutSynPackageType, _ = abi.NewType("tuple", "", []abi.ArgumentMarshaling{
+		{Name: "Amount", Type: "uint256"},
+		{Name: "Recipient", Type: "address"},
+		{Name: "RefundAddress", Type: "address"},
+	})
+
+	transferOutSynPackageArgs = abi.Arguments{
+		{Type: transferOutSynPackageType},
+	}
+)
+
+func (pkg *TransferOutSynPackage) Serialize() ([]byte, error) {
+	return transferOutSynPackageArgs.Pack(&TransferOutSynPackageStruct{
+		pkg.Amount,
+		common.BytesToAddress(pkg.Recipient),
+		common.BytesToAddress(pkg.RefundAddress),
+	})
+}
+
 func DeserializeTransferOutSynPackage(serializedPackage []byte) (*TransferOutSynPackage, error) {
-	var tp TransferOutSynPackage
-	err := rlp.DecodeBytes(serializedPackage, &tp)
+	unpacked, err := transferOutSynPackageArgs.Unpack(serializedPackage)
 	if err != nil {
-		return nil, errors.Wrapf(ErrInvalidPackage, "deserialize transfer out package failed")
+		return nil, errors.Wrapf(ErrInvalidPackage, "deserialize transfer out sync package failed")
+	}
+
+	unpackedStruct := abi.ConvertType(unpacked[0], TransferOutSynPackageStruct{})
+	pkgStruct, ok := unpackedStruct.(TransferOutSynPackageStruct)
+	if !ok {
+		return nil, errors.Wrapf(ErrInvalidPackage, "reflect transfer out sync package failed")
+	}
+
+	tp := TransferOutSynPackage{
+		pkgStruct.Amount,
+		pkgStruct.Recipient.Bytes(),
+		pkgStruct.RefundAddress.Bytes(),
 	}
 	return &tp, nil
 }
@@ -39,12 +77,49 @@ type TransferOutRefundPackage struct {
 	RefundReason uint32
 }
 
+type TransferOutRefundPackageStruct struct {
+	RefundAmount *big.Int
+	RefundAddr   common.Address
+	RefundReason uint32
+}
+
+var (
+	transferOutRefundPackageType, _ = abi.NewType("tuple", "", []abi.ArgumentMarshaling{
+		{Name: "RefundAmount", Type: "uint256"},
+		{Name: "RefundAddr", Type: "address"},
+		{Name: "RefundReason", Type: "uint32"},
+	})
+
+	transferOutRefundPackageArgs = abi.Arguments{
+		{Type: transferOutRefundPackageType},
+	}
+)
+
+func (pkg *TransferOutRefundPackage) Serialize() ([]byte, error) {
+	return transferOutRefundPackageArgs.Pack(&TransferOutRefundPackageStruct{
+		pkg.RefundAmount,
+		common.BytesToAddress(pkg.RefundAddr),
+		pkg.RefundReason,
+	})
+}
+
 func DeserializeTransferOutRefundPackage(serializedPackage []byte) (*TransferOutRefundPackage, error) {
-	var tp TransferOutRefundPackage
-	err := rlp.DecodeBytes(serializedPackage, &tp)
+	unpacked, err := transferOutRefundPackageArgs.Unpack(serializedPackage)
 	if err != nil {
 		return nil, errors.Wrapf(ErrInvalidPackage, "deserialize transfer out refund package failed")
 	}
+
+	unpackedStruct := abi.ConvertType(unpacked[0], TransferOutRefundPackageStruct{})
+	pkgStruct, ok := unpackedStruct.(TransferOutRefundPackageStruct)
+	if !ok {
+		return nil, errors.Wrapf(ErrInvalidPackage, "reflect transfer out refund package failed")
+	}
+
+	tp := TransferOutRefundPackage{
+		pkgStruct.RefundAmount,
+		pkgStruct.RefundAddr.Bytes(),
+		pkgStruct.RefundReason,
+	}
 	return &tp, nil
 }
 
@@ -54,12 +129,48 @@ type TransferInSynPackage struct {
 	RefundAddress   sdk.AccAddress
 }
 
+type TransferInSynPackageStruct struct {
+	Amount          *big.Int
+	ReceiverAddress common.Address
+	RefundAddress   common.Address
+}
+
+var (
+	transferInSynPackageType, _ = abi.NewType("tuple", "", []abi.ArgumentMarshaling{
+		{Name: "Amount", Type: "uint256"},
+		{Name: "ReceiverAddress", Type: "address"},
+		{Name: "RefundAddress", Type: "address"},
+	})
+
+	transferInSynPackageArgs = abi.Arguments{
+		{Type: transferInSynPackageType},
+	}
+)
+
+func (pkg *TransferInSynPackage) Serialize() ([]byte, error) {
+	return transferInSynPackageArgs.Pack(&TransferInSynPackageStruct{
+		pkg.Amount,
+		common.BytesToAddress(pkg.ReceiverAddress),
+		common.BytesToAddress(pkg.RefundAddress),
+	})
+}
+
 func DeserializeTransferInSynPackage(serializedPackage []byte) (*TransferInSynPackage, error) {
-	var tp TransferInSynPackage
-	err := rlp.DecodeBytes(serializedPackage, &tp)
+	unpacked, err := transferInSynPackageArgs.Unpack(serializedPackage)
 	if err != nil {
-		return nil, errors.Wrapf(ErrInvalidPackage, "deserialize transfer in package failed")
+		return nil, errors.Wrapf(ErrInvalidPackage, "deserialize transfer in sync package failed")
+	}
 
+	unpackedStruct := abi.ConvertType(unpacked[0], TransferInSynPackageStruct{})
+	pkgStruct, ok := unpackedStruct.(TransferInSynPackageStruct)
+	if !ok {
+		return nil, errors.Wrapf(ErrInvalidPackage, "reflect transfer in sync package failed")
+	}
+
+	tp := TransferInSynPackage{
+		pkgStruct.Amount,
+		pkgStruct.ReceiverAddress.Bytes(),
+		pkgStruct.RefundAddress.Bytes(),
 	}
 	return &tp, nil
 }
@@ -69,3 +180,29 @@ type TransferInRefundPackage struct {
 	RefundAddress sdk.AccAddress
 	RefundReason  uint32
 }
+
+type TransferInRefundPackageStruct struct {
+	RefundAmount  *big.Int
+	RefundAddress common.Address
+	RefundReason  uint32
+}
+
+var (
+	transferInRefundPackageType, _ = abi.NewType("tuple", "", []abi.ArgumentMarshaling{
+		{Name: "RefundAmount", Type: "uint256"},
+		{Name: "RefundAddr", Type: "address"},
+		{Name: "RefundReason", Type: "uint32"},
+	})
+
+	transferInRefundPackageArgs = abi.Arguments{
+		{Type: transferInRefundPackageType},
+	}
+)
+
+func (pkg *TransferInRefundPackage) Serialize() ([]byte, error) {
+	return transferInRefundPackageArgs.Pack(&TransferInRefundPackageStruct{
+		pkg.RefundAmount,
+		common.BytesToAddress(pkg.RefundAddress),
+		pkg.RefundReason,
+	})
+}