diff --git a/action/builder.go b/action/builder.go index f491135216..495208683f 100644 --- a/action/builder.go +++ b/action/builder.go @@ -22,7 +22,8 @@ type Builder struct { } var ( - _stakingProtocolAddr, _ = address.FromString(address.StakingProtocolAddr) + _stakingProtocolAddr, _ = address.FromString(address.StakingProtocolAddr) + _rewardingProtocolAddr, _ = address.FromString(address.RewardingProtocol) ) // SetVersion sets action's version. @@ -202,6 +203,20 @@ func (b *EnvelopeBuilder) BuildStakingAction(tx *types.Transaction) (Envelope, e return b.build(), nil } +// BuildRewardingAction loads rewarding action into envelope from abi-encoded data +func (b *EnvelopeBuilder) BuildRewardingAction(tx *types.Transaction) (Envelope, error) { + if !bytes.Equal(tx.To().Bytes(), _rewardingProtocolAddr.Bytes()) { + return nil, ErrInvalidAct + } + b.setEnvelopeCommonFields(tx) + act, err := newRewardingActionFromABIBinary(tx.Data()) + if err != nil { + return nil, err + } + b.elp.payload = act + return b.build(), nil +} + func newStakingActionFromABIBinary(data []byte) (actionPayload, error) { if len(data) <= 4 { return nil, ErrInvalidABI @@ -235,3 +250,16 @@ func newStakingActionFromABIBinary(data []byte) (actionPayload, error) { } return nil, ErrInvalidABI } + +func newRewardingActionFromABIBinary(data []byte) (actionPayload, error) { + if len(data) <= 4 { + return nil, ErrInvalidABI + } + if act, err := NewClaimFromRewardingFundFromABIBinary(data); err == nil { + return act, nil + } + if act, err := NewDepositToRewardingFundFromABIBinary(data); err == nil { + return act, nil + } + return nil, ErrInvalidABI +} diff --git a/action/builder_test.go b/action/builder_test.go index 6b622009d9..8bd7dacee2 100644 --- a/action/builder_test.go +++ b/action/builder_test.go @@ -6,10 +6,14 @@ package action import ( + "encoding/hex" "math/big" "testing" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/iotexproject/iotex-core/pkg/version" ) @@ -27,3 +31,40 @@ func TestActionBuilder(t *testing.T) { assert.Equal(t, uint64(10003), act.GasLimit()) assert.Equal(t, big.NewInt(10004), act.GasPrice()) } + +func TestBuildRewardingAction(t *testing.T) { + r := require.New(t) + + eb := &EnvelopeBuilder{} + eb.SetChainID(2) + + claimData, _ := hex.DecodeString("2df163ef000000000000000000000000000000000000000000000000000000000000006500000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000") + tx := types.NewTransaction(1, common.HexToAddress("0x0000000000000000000000000000000000000001"), big.NewInt(100), 10000, big.NewInt(10004), claimData) + + env, err := eb.BuildRewardingAction(tx) + r.Nil(env) + r.EqualValues("invalid action type", err.Error()) + + tx = types.NewTransaction(1, common.HexToAddress(_rewardingProtocolAddr.Hex()), big.NewInt(100), 10000, big.NewInt(10004), claimData) + env, err = eb.BuildRewardingAction(tx) + r.Nil(err) + r.IsType(&ClaimFromRewardingFund{}, env.Action()) + r.EqualValues(big.NewInt(10004), env.GasPrice()) + r.EqualValues(10000, env.GasLimit()) + r.EqualValues(big.NewInt(101), env.Action().(*ClaimFromRewardingFund).Amount()) + + depositData, _ := hex.DecodeString("27852a6b000000000000000000000000000000000000000000000000000000000000006500000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003") + tx = types.NewTransaction(1, common.HexToAddress("0x0000000000000000000000000000000000000001"), big.NewInt(100), 10000, big.NewInt(10004), depositData) + + env, err = eb.BuildRewardingAction(tx) + r.Nil(env) + r.EqualValues("invalid action type", err.Error()) + + tx = types.NewTransaction(1, common.HexToAddress(_rewardingProtocolAddr.Hex()), big.NewInt(100), 10000, big.NewInt(10004), depositData) + env, err = eb.BuildRewardingAction(tx) + r.Nil(err) + r.IsType(&DepositToRewardingFund{}, env.Action()) + r.EqualValues(big.NewInt(10004), env.GasPrice()) + r.EqualValues(10000, env.GasLimit()) + r.EqualValues(big.NewInt(101), env.Action().(*DepositToRewardingFund).Amount()) +} diff --git a/action/claimreward.go b/action/claimreward.go index f843495554..365350660d 100644 --- a/action/claimreward.go +++ b/action/claimreward.go @@ -6,22 +6,63 @@ package action import ( + "bytes" "math/big" + "strings" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" "github.com/pkg/errors" "google.golang.org/protobuf/proto" + "github.com/iotexproject/iotex-address/address" "github.com/iotexproject/iotex-core/pkg/util/byteutil" "github.com/iotexproject/iotex-proto/golang/iotextypes" ) +const _claimRewardingInterfaceABI = `[ + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint8[]", + "name": "data", + "type": "uint8[]" + } + ], + "name": "claim", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } +]` + var ( // ClaimFromRewardingFundBaseGas represents the base intrinsic gas for claimFromRewardingFund ClaimFromRewardingFundBaseGas = uint64(10000) // ClaimFromRewardingFundGasPerByte represents the claimFromRewardingFund payload gas per uint ClaimFromRewardingFundGasPerByte = uint64(100) + + _claimRewardingMethod abi.Method ) +func init() { + claimRewardInterface, err := abi.JSON(strings.NewReader(_claimRewardingInterfaceABI)) + if err != nil { + panic(err) + } + var ok bool + _claimRewardingMethod, ok = claimRewardInterface.Methods["claim"] + if !ok { + panic("fail to load the claim method") + } +} + // ClaimFromRewardingFund is the action to claim reward from the rewarding fund type ClaimFromRewardingFund struct { AbstractAction @@ -108,3 +149,49 @@ func (b *ClaimFromRewardingFundBuilder) Build() ClaimFromRewardingFund { b.claim.AbstractAction = b.Builder.Build() return b.claim } + +// encodeABIBinary encodes data in abi encoding +func (c *ClaimFromRewardingFund) encodeABIBinary() ([]byte, error) { + data, err := _claimRewardingMethod.Inputs.Pack(c.Amount(), c.Data()) + if err != nil { + return nil, err + } + return append(_claimRewardingMethod.ID, data...), nil +} + +// ToEthTx converts action to eth-compatible tx +func (c *ClaimFromRewardingFund) ToEthTx() (*types.Transaction, error) { + addr, err := address.FromString(address.RewardingProtocol) + if err != nil { + return nil, err + } + ethAddr := common.BytesToAddress(addr.Bytes()) + data, err := c.encodeABIBinary() + if err != nil { + return nil, err + } + return types.NewTransaction(c.Nonce(), ethAddr, big.NewInt(0), c.GasLimit(), c.GasPrice(), data), nil +} + +// NewClaimFromRewardingFundFromABIBinary decodes data into action +func NewClaimFromRewardingFundFromABIBinary(data []byte) (*ClaimFromRewardingFund, error) { + var ( + paramsMap = map[string]interface{}{} + ok bool + ac ClaimFromRewardingFund + ) + // sanity check + if len(data) <= 4 || !bytes.Equal(_claimRewardingMethod.ID[:], data[:4]) { + return nil, errDecodeFailure + } + if err := _claimRewardingMethod.Inputs.UnpackIntoMap(paramsMap, data[4:]); err != nil { + return nil, err + } + if ac.amount, ok = paramsMap["amount"].(*big.Int); !ok { + return nil, errDecodeFailure + } + if ac.data, ok = paramsMap["data"].([]byte); !ok { + return nil, errDecodeFailure + } + return &ac, nil +} diff --git a/action/claimreward_test.go b/action/claimreward_test.go new file mode 100644 index 0000000000..22adbca18f --- /dev/null +++ b/action/claimreward_test.go @@ -0,0 +1,146 @@ +package action + +import ( + "encoding/hex" + "math/big" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/iotexproject/iotex-address/address" + "github.com/stretchr/testify/require" +) + +var ( + _defaultGasPrice = big.NewInt(1000000000000) + _errNegativeNumberMsg = "negative value" +) + +func TestClaimRewardSerialize(t *testing.T) { + r := require.New(t) + + rc := &ClaimFromRewardingFund{} + data := rc.Serialize() + r.NotNil(data) + + rc.amount = big.NewInt(100) + rc.data = []byte{1} + data = rc.Serialize() + r.NotNil(data) + r.EqualValues("0a03313030120101", hex.EncodeToString(data)) +} + +func TestClaimRewardIntrinsicGas(t *testing.T) { + r := require.New(t) + + rc := &ClaimFromRewardingFund{} + gas, err := rc.IntrinsicGas() + r.NoError(err) + r.EqualValues(10000, gas) + + rc.amount = big.NewInt(100000000) + gas, err = rc.IntrinsicGas() + r.NoError(err) + r.EqualValues(10000, gas) + + rc.data = []byte{1} + gas, err = rc.IntrinsicGas() + r.NoError(err) + r.EqualValues(10100, gas) +} + +func TestClaimRewardSanityCheck(t *testing.T) { + r := require.New(t) + + rc := &ClaimFromRewardingFund{} + + rc.amount = big.NewInt(1) + err := rc.SanityCheck() + r.NoError(err) + + rc.amount = big.NewInt(-1) + err = rc.SanityCheck() + r.NotNil(err) + r.EqualValues(_errNegativeNumberMsg, err.Error()) +} + +func TestClaimRewardCost(t *testing.T) { + r := require.New(t) + + rc := &ClaimFromRewardingFund{} + rc.gasPrice = _defaultGasPrice + cost, err := rc.Cost() + r.Nil(err) + r.EqualValues("10000000000000000", cost.String()) + + rc.amount = big.NewInt(100) + cost, err = rc.Cost() + r.Nil(err) + r.EqualValues("10000000000000000", cost.String()) + + rc.data = []byte{1} + cost, err = rc.Cost() + r.Nil(err) + r.EqualValues("10100000000000000", cost.String()) +} + +func TestClaimRewardEncodeABIBinary(t *testing.T) { + r := require.New(t) + + rc := &ClaimFromRewardingFund{} + rc.amount = big.NewInt(101) + data, err := rc.encodeABIBinary() + r.Nil(err) + r.EqualValues( + "2df163ef000000000000000000000000000000000000000000000000000000000000006500000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000", + hex.EncodeToString(data), + ) + + rc.data = []byte{1, 2, 3} + data, err = rc.encodeABIBinary() + r.Nil(err) + r.EqualValues( + "2df163ef000000000000000000000000000000000000000000000000000000000000006500000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003", + hex.EncodeToString(data), + ) +} + +func TestClaimRewardToEthTx(t *testing.T) { + r := require.New(t) + + rewardingPool, _ := address.FromString(address.RewardingProtocol) + rewardEthAddr := common.BytesToAddress(rewardingPool.Bytes()) + + rc := &ClaimFromRewardingFund{} + + rc.amount = big.NewInt(101) + tx, err := rc.ToEthTx() + r.Nil(err) + r.EqualValues(rewardEthAddr, *tx.To()) + r.EqualValues( + "2df163ef000000000000000000000000000000000000000000000000000000000000006500000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000", + hex.EncodeToString(tx.Data()), + ) + r.EqualValues("0", tx.Value().String()) + + rc.data = []byte{1, 2, 3} + tx, err = rc.ToEthTx() + r.Nil(err) + r.EqualValues(rewardEthAddr, *tx.To()) + r.EqualValues( + "2df163ef000000000000000000000000000000000000000000000000000000000000006500000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003", + hex.EncodeToString(tx.Data()), + ) + r.EqualValues("0", tx.Value().String()) +} + +func TestNewRewardingClaimFromABIBinary(t *testing.T) { + r := require.New(t) + + data, _ := hex.DecodeString("2df163ef000000000000000000000000000000000000000000000000000000000000006500000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003") + + rc, err := NewClaimFromRewardingFundFromABIBinary(data) + r.Nil(err) + r.IsType(&ClaimFromRewardingFund{}, rc) + r.EqualValues("101", rc.Amount().String()) + r.EqualValues([]byte{1, 2, 3}, rc.Data()) +} diff --git a/action/depositreward.go b/action/depositreward.go index 6abb14175b..8bf394ed7d 100644 --- a/action/depositreward.go +++ b/action/depositreward.go @@ -6,22 +6,63 @@ package action import ( + "bytes" "math/big" + "strings" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" "github.com/pkg/errors" "google.golang.org/protobuf/proto" + "github.com/iotexproject/iotex-address/address" "github.com/iotexproject/iotex-core/pkg/util/byteutil" "github.com/iotexproject/iotex-proto/golang/iotextypes" ) +const _depositRewardInterfaceABI = `[ + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint8[]", + "name": "data", + "type": "uint8[]" + } + ], + "name": "deposit", + "outputs": [], + "stateMutability": "payable", + "type": "function" + } +]` + var ( // DepositToRewardingFundBaseGas represents the base intrinsic gas for depositToRewardingFund DepositToRewardingFundBaseGas = uint64(10000) // DepositToRewardingFundGasPerByte represents the depositToRewardingFund payload gas per uint DepositToRewardingFundGasPerByte = uint64(100) + + _depositRewardMethod abi.Method ) +func init() { + depositRewardInterface, err := abi.JSON(strings.NewReader(_depositRewardInterfaceABI)) + if err != nil { + panic(err) + } + var ok bool + _depositRewardMethod, ok = depositRewardInterface.Methods["deposit"] + if !ok { + panic("fail to load the deposit method") + } +} + // DepositToRewardingFund is the action to deposit to the rewarding fund type DepositToRewardingFund struct { AbstractAction @@ -108,3 +149,49 @@ func (b *DepositToRewardingFundBuilder) Build() DepositToRewardingFund { b.deposit.AbstractAction = b.Builder.Build() return b.deposit } + +// encodeABIBinary encodes data in abi encoding +func (d *DepositToRewardingFund) encodeABIBinary() ([]byte, error) { + data, err := _depositRewardMethod.Inputs.Pack(d.Amount(), d.Data()) + if err != nil { + return nil, err + } + return append(_depositRewardMethod.ID, data...), nil +} + +// ToEthTx converts action to eth-compatible tx +func (d *DepositToRewardingFund) ToEthTx() (*types.Transaction, error) { + addr, err := address.FromString(address.RewardingProtocol) + if err != nil { + return nil, err + } + ethAddr := common.BytesToAddress(addr.Bytes()) + data, err := d.encodeABIBinary() + if err != nil { + return nil, err + } + return types.NewTransaction(d.Nonce(), ethAddr, big.NewInt(0), d.GasLimit(), d.GasPrice(), data), nil +} + +// NewDepositToRewardingFundFromABIBinary decodes data into action +func NewDepositToRewardingFundFromABIBinary(data []byte) (*DepositToRewardingFund, error) { + var ( + paramsMap = map[string]interface{}{} + ok bool + ac DepositToRewardingFund + ) + // sanity check + if len(data) <= 4 || !bytes.Equal(_depositRewardMethod.ID[:], data[:4]) { + return nil, errDecodeFailure + } + if err := _depositRewardMethod.Inputs.UnpackIntoMap(paramsMap, data[4:]); err != nil { + return nil, err + } + if ac.amount, ok = paramsMap["amount"].(*big.Int); !ok { + return nil, errDecodeFailure + } + if ac.data, ok = paramsMap["data"].([]byte); !ok { + return nil, errDecodeFailure + } + return &ac, nil +} diff --git a/action/depositreward_test.go b/action/depositreward_test.go new file mode 100644 index 0000000000..a08822dc63 --- /dev/null +++ b/action/depositreward_test.go @@ -0,0 +1,137 @@ +package action + +import ( + "encoding/hex" + "math/big" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/iotexproject/iotex-address/address" + "github.com/stretchr/testify/require" +) + +func TestDepositRewardSerialize(t *testing.T) { + r := require.New(t) + + rp := &DepositToRewardingFund{} + data := rp.Serialize() + r.NotNil(data) + + rp.amount = big.NewInt(100) + rp.data = []byte{1} + data = rp.Serialize() + r.NotNil(data) + r.EqualValues("0a03313030120101", hex.EncodeToString(data)) +} + +func TestDepositRewardIntrinsicGas(t *testing.T) { + r := require.New(t) + + rp := &DepositToRewardingFund{} + gas, err := rp.IntrinsicGas() + r.NoError(err) + r.EqualValues(10000, gas) + + rp.amount = big.NewInt(100000000) + gas, err = rp.IntrinsicGas() + r.NoError(err) + r.EqualValues(10000, gas) + + rp.data = []byte{1} + gas, err = rp.IntrinsicGas() + r.NoError(err) + r.EqualValues(10100, gas) +} + +func TestDepositRewardSanityCheck(t *testing.T) { + r := require.New(t) + + rp := &DepositToRewardingFund{} + + rp.amount = big.NewInt(1) + err := rp.SanityCheck() + r.NoError(err) + + rp.amount = big.NewInt(-1) + err = rp.SanityCheck() + r.NotNil(err) + r.EqualValues(_errNegativeNumberMsg, err.Error()) +} + +func TestDepositRewardCost(t *testing.T) { + r := require.New(t) + + rp := &DepositToRewardingFund{} + rp.gasPrice = _defaultGasPrice + rp.amount = big.NewInt(100) + cost, err := rp.Cost() + r.NoError(err) + r.EqualValues("10000000000000000", cost.String()) + + rp.data = []byte{1} + cost, err = rp.Cost() + r.NoError(err) + r.EqualValues("10100000000000000", cost.String()) +} + +func TestDepositRewardEncodeABIBinary(t *testing.T) { + r := require.New(t) + + rp := &DepositToRewardingFund{} + + rp.amount = big.NewInt(101) + data, err := rp.encodeABIBinary() + r.NoError(err) + r.EqualValues( + "27852a6b000000000000000000000000000000000000000000000000000000000000006500000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000", + hex.EncodeToString(data), + ) + + rp.data = []byte{1, 2, 3} + data, err = rp.encodeABIBinary() + r.NoError(err) + r.EqualValues( + "27852a6b000000000000000000000000000000000000000000000000000000000000006500000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003", + hex.EncodeToString(data), + ) +} + +func TestDepositRewardToEthTx(t *testing.T) { + r := require.New(t) + + rewardingPool, _ := address.FromString(address.RewardingProtocol) + rewardEthAddr := common.BytesToAddress(rewardingPool.Bytes()) + + rp := &DepositToRewardingFund{} + rp.amount = big.NewInt(101) + tx, err := rp.ToEthTx() + r.NoError(err) + r.EqualValues(rewardEthAddr, *tx.To()) + r.EqualValues( + "27852a6b000000000000000000000000000000000000000000000000000000000000006500000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000", + hex.EncodeToString(tx.Data()), + ) + r.EqualValues("0", tx.Value().String()) + + rp.data = []byte{1, 2, 3} + tx, err = rp.ToEthTx() + r.NoError(err) + r.EqualValues(rewardEthAddr, *tx.To()) + r.EqualValues( + "27852a6b000000000000000000000000000000000000000000000000000000000000006500000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003", + hex.EncodeToString(tx.Data()), + ) + r.EqualValues("0", tx.Value().String()) +} + +func TestNewRewardingDepositFromABIBinary(t *testing.T) { + r := require.New(t) + + data, _ := hex.DecodeString("27852a6b000000000000000000000000000000000000000000000000000000000000006500000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003") + + rp, err := NewDepositToRewardingFundFromABIBinary(data) + r.NoError(err) + r.IsType(&DepositToRewardingFund{}, rp) + r.EqualValues("101", rp.Amount().String()) + r.EqualValues([]byte{1, 2, 3}, rp.Data()) +} diff --git a/action/rlp_tx_test.go b/action/rlp_tx_test.go index f29497a795..22798b6c19 100644 --- a/action/rlp_tx_test.go +++ b/action/rlp_tx_test.go @@ -260,6 +260,32 @@ func TestRlpDecodeVerify(t *testing.T) { "04dc4c548c3a478278a6a09ffa8b5c4b384368e49654b35a6961ee8288fc889cdc39e9f8194e41abdbfac248ef9dc3f37b131a36ee2c052d974c21c1d2cd56730b", "1e14d5373e1af9cc77f0032ad2cd0fba8be5ea2e", }, + { + "rewardingClaim", + "f8c6806482520894a576c141e5659137ddda4223d209d4744b2106be80b8642df163ef0000000000000000000000000000000000000000000000000000000000000065000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000008224c6a03d62943431b8ca0e8ea0a9c79dc8f64df14c965ca5486da124804013778ed566a065956b185116b65cec0ec9bcf9539e924784a4b448190b0aa9d017f1719be921", + 0, + 21000, + "100", + "0", + "0xA576C141e5659137ddDa4223d209d4744b2106BE", + 100, + "4d26d0736ebd9e69bd5994f3730b05a2d48c810b3bb54818be65d02004cf4ff4", + "04830579b50e01602c2015c24e72fbc48bca1cca1e601b119ca73abe2e0b5bd61fcb7874567e091030d6b644f927445d80e00b3f9ca0c566c21c30615e94c343da", + "8d38efe45794d7fceea10b2262c23c12245959db", + }, + { + "rewardingDeposit", + "f8c6016482520894a576c141e5659137ddda4223d209d4744b2106be80b86427852a6b0000000000000000000000000000000000000000000000000000000000000065000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000008224c6a013b7679dbabcb0f97b93942436f5072cca3c7fe43451a8fedcdf3c84c1344e1da02af4cc67594c0200b59f4e30ba149af15e546acbfc69fa31f14e8788ab063d85", + 1, + 21000, + "100", + "0", + "0xA576C141e5659137ddDa4223d209d4744b2106BE", + 100, + "842fea9a292c0bc7a1e05a14a8255ed8dc945fdae7c01a6b70f5213ebe35583b", + "04830579b50e01602c2015c24e72fbc48bca1cca1e601b119ca73abe2e0b5bd61fcb7874567e091030d6b644f927445d80e00b3f9ca0c566c21c30615e94c343da", + "8d38efe45794d7fceea10b2262c23c12245959db", + }, } for _, v := range rlpTests { @@ -346,6 +372,9 @@ func convertToNativeProto(tx *types.Transaction, actType string) *iotextypes.Act "transferStake", "candidateRegister", "candidateUpdate": elp, _ := elpBuilder.BuildStakingAction(tx) return elp.Proto() + case "rewardingClaim", "rewardingDeposit": + elp, _ := elpBuilder.BuildRewardingAction(tx) + return elp.Proto() default: panic("unsupported") } diff --git a/api/web3server_utils.go b/api/web3server_utils.go index 14374e9d31..047f7534b7 100644 --- a/api/web3server_utils.go +++ b/api/web3server_utils.go @@ -176,6 +176,9 @@ func (svr *web3Handler) ethTxToEnvelope(tx *types.Transaction) (action.Envelope, if to == address.StakingProtocolAddr { return elpBuilder.BuildStakingAction(tx) } + if to == address.RewardingProtocol { + return elpBuilder.BuildRewardingAction(tx) + } isContract, err := svr.checkContractAddr(to) if err != nil { return nil, err