[action] remove GasLimit(), use Gas() (#4390)

action/actctx.go

@@ -39,8 +39,8 @@ func (act *AbstractAction) SetNonce(val uint64) {
 	act.nonce = val
 }
 
-// GasLimit returns the gas limit
-func (act *AbstractAction) GasLimit() uint64 { return act.gasLimit }
+// Gas returns the gas limit
+func (act *AbstractAction) Gas() uint64 { return act.gasLimit }
 
 // SetGasLimit sets gaslimit
 func (act *AbstractAction) SetGasLimit(val uint64) {

action/builder_test.go

@@ -42,7 +42,7 @@ func TestActionBuilder(t *testing.T) {
 
 	r.Equal(uint32(version.ProtocolVersion), act.Version())
 	r.Equal(uint64(2), act.Nonce())
-	r.Equal(uint64(10003), act.GasLimit())
+	r.Equal(uint64(10003), act.Gas())
 	r.Equal(big.NewInt(10004), act.GasPrice())
 }
 
@@ -98,7 +98,7 @@ func TestBuildRewardingAction(t *testing.T) {
 			r.NoError(err)
 			r.IsType(&ClaimFromRewardingFund{}, elp.Action())
 			r.Equal(big.NewInt(10004), elp.GasPrice())
-			r.Equal(uint64(10000), elp.GasLimit())
+			r.Equal(uint64(10000), elp.Gas())
 			r.Equal(big.NewInt(101), elp.Action().(*ClaimFromRewardingFund).ClaimAmount())
 		})
 		t.Run("Debug", func(t *testing.T) {
@@ -134,7 +134,7 @@ func TestBuildRewardingAction(t *testing.T) {
 			r.NoError(err)
 			r.IsType(&DepositToRewardingFund{}, elp.Action())
 			r.EqualValues(big.NewInt(10004), elp.GasPrice())
-			r.EqualValues(10000, elp.GasLimit())
+			r.EqualValues(10000, elp.Gas())
 			r.EqualValues(big.NewInt(102), elp.Action().(*DepositToRewardingFund).Amount())
 		})
 	})

action/candidate_transfer_ownership_test.go

@@ -80,7 +80,7 @@ func TestCandidateTransferOwnership(t *testing.T) {
 		}
 
 		require.Equal(test.serialize, hex.EncodeToString(cr.Serialize()))
-		require.Equal(test.gasLimit, elp.GasLimit())
+		require.Equal(test.gasLimit, elp.Gas())
 		require.Equal(test.gasPrice, elp.GasPrice())
 		require.Equal(test.nonce, elp.Nonce())
 		require.Equal(test.newOwner, cr.NewOwner().String())

action/candidateregister_test.go

@@ -86,7 +86,7 @@ func TestCandidateRegister(t *testing.T) {
 		}
 
 		require.Equal(test.Serialize, hex.EncodeToString(cr.Serialize()))
-		require.Equal(test.GasLimit, elp.GasLimit())
+		require.Equal(test.GasLimit, elp.Gas())
 		require.Equal(test.GasPrice, elp.GasPrice())
 		require.Equal(test.Nonce, elp.Nonce())
 

action/candidateupdate_test.go

@@ -32,7 +32,7 @@ func TestCandidateUpdate(t *testing.T) {
 	t.Run("proto", func(t *testing.T) {
 		ser := cu.Serialize()
 		require.Equal("0a04746573741229696f31636c36726c32657635646661393838716d677a673278346866617a6d7039766e326736366e671a29696f316a757678356730363365753474733833326e756b7034766763776b32676e6335637539617964", hex.EncodeToString(ser))
-		require.Equal(_cuGasLimit, elp.GasLimit())
+		require.Equal(_cuGasLimit, elp.Gas())
 		require.Equal(_cuGasPrice, elp.GasPrice())
 		require.Equal(_cuNonce, elp.Nonce())
 		require.Equal(_cuName, cu.Name())

action/envelope.go

@@ -22,7 +22,6 @@ type (
 		TxData
 		Version() uint32
 		ChainID() uint32
-		GasLimit() uint64
 		Destination() (string, bool)
 		Cost() (*big.Int, error)
 		IntrinsicGas() (uint64, error)
@@ -139,7 +138,7 @@ func (elp *envelope) Cost() (*big.Int, error) {
 		return nil, errors.Wrap(err, "failed to get payload's intrinsic gas")
 	}
 	if _, ok := elp.payload.(gasLimitForCost); ok {
-		gas = elp.GasLimit()
+		gas = elp.Gas()
 	}
 	if acl := elp.AccessList(); len(acl) > 0 {
 		gas += uint64(len(acl)) * TxAccessListAddressGas

action/envelope_test.go

@@ -17,7 +17,7 @@ func TestEnvelope_Basic(t *testing.T) {
 	evlp, tsf := createEnvelope()
 	req.Equal(uint32(1), evlp.Version())
 	req.Equal(uint64(10), evlp.Nonce())
-	req.Equal(uint64(20010), evlp.GasLimit())
+	req.Equal(uint64(20010), evlp.Gas())
 	req.Equal("11000000000000000000", evlp.GasPrice().String())
 	c, err := evlp.Cost()
 	req.NoError(err)
@@ -122,7 +122,7 @@ func TestEnvelope_Actions(t *testing.T) {
 		require.Equal(elp.Nonce(), evlp.Nonce())
 		require.Equal(elp.ChainID(), evlp.ChainID())
 		require.Equal(elp.GasPrice(), evlp.GasPrice())
-		require.Equal(elp.GasLimit(), evlp.GasLimit())
+		require.Equal(elp.Gas(), evlp.Gas())
 	}
 }
 

action/protocol/generic_validator.go

@@ -41,7 +41,7 @@ func (v *GenericValidator) Validate(ctx context.Context, selp *action.SealedEnve
 	if err != nil {
 		return err
 	}
-	if intrinsicGas > selp.GasLimit() {
+	if intrinsicGas > selp.Gas() {
 		return action.ErrIntrinsicGas
 	}
 

action/protocol/staking/handler_stake_migrate.go

@@ -51,7 +51,7 @@ func (p *Protocol) handleStakeMigrate(ctx context.Context, elp action.Envelope,
 		return nil, nil, gasConsumed, gasToBeDeducted, errCandNotExist
 	}
 	duration := uint64(bucket.StakedDuration / p.helperCtx.BlockInterval(protocol.MustGetBlockCtx(ctx).BlockHeight))
-	exec, err := p.constructExecution(candidate.GetIdentifier(), bucket.StakedAmount, duration, elp.Nonce(), elp.GasLimit(), elp.GasPrice())
+	exec, err := p.constructExecution(candidate.GetIdentifier(), bucket.StakedAmount, duration, elp.Nonce(), elp.Gas(), elp.GasPrice())
 	if err != nil {
 		return nil, nil, gasConsumed, gasToBeDeducted, errors.Wrap(err, "failed to construct execution")
 	}

action/rlp_tx.go

@@ -146,7 +146,7 @@ func toLegacyTx(ab *AbstractAction, act Action) (*types.Transaction, error) {
 	return types.NewTx(&types.LegacyTx{
 		Nonce:    ab.Nonce(),
 		GasPrice: ab.GasPrice(),
-		Gas:      ab.GasLimit(),
+		Gas:      ab.Gas(),
 		To:       to,
 		Value:    tx.Value(),
 		Data:     data,

action/rlp_tx_test.go

@@ -36,7 +36,7 @@ func TestGenerateRlp(t *testing.T) {
 		gasPrice: new(big.Int),
 	}
 	builder := (&EnvelopeBuilder{}).SetNonce(ab.Nonce()).
-		SetGasLimit(ab.GasLimit()).SetGasPrice(ab.GasPrice())
+		SetGasLimit(ab.Gas()).SetGasPrice(ab.GasPrice())
 	for _, v := range []struct {
 		act  actionPayload
 		sig  []byte

action/sealedenvelope_test.go

@@ -112,7 +112,7 @@ func TestSealedEnvelope_Actions(t *testing.T) {
 
 		require.Equal(elp.Nonce(), rlp.Nonce())
 		require.Equal(elp.GasPrice(), rlp.GasPrice())
-		require.Equal(elp.GasLimit(), rlp.Gas())
+		require.Equal(elp.Gas(), rlp.Gas())
 	}
 }
 

action/signedaction_test.go

@@ -46,7 +46,7 @@ func TestSignedTransfer(t *testing.T) {
 	require.EqualValues(1, selp.Nonce())
 	require.Equal(big.NewInt(2), tsf.Amount())
 	require.Equal([]byte{}, tsf.Payload())
-	require.EqualValues(100000, selp.GasLimit())
+	require.EqualValues(100000, selp.Gas())
 	require.Equal(big.NewInt(10), selp.GasPrice())
 	require.NotNil(selp.Signature())
 }
@@ -60,7 +60,7 @@ func TestSignedExecution(t *testing.T) {
 	require.Equal(EmptyAddress, exec.Contract())
 	require.Equal(uint64(1), selp.Nonce())
 	require.Equal(big.NewInt(0), exec.Amount())
-	require.Equal(uint64(100000), selp.GasLimit())
+	require.Equal(uint64(100000), selp.Gas())
 	require.Equal(big.NewInt(10), selp.GasPrice())
 	require.Equal([]byte{}, exec.Data())
 	require.NotNil(selp.Signature())
@@ -73,7 +73,7 @@ func TestSignedCandidateRegister(t *testing.T) {
 
 	cand := selp.Action().(*CandidateRegister)
 	require.Equal(uint64(1), selp.Nonce())
-	require.Equal(_gasLimit, selp.GasLimit())
+	require.Equal(_gasLimit, selp.Gas())
 	require.Equal(_gasPrice, selp.GasPrice())
 	require.Equal(_candidate1Name, cand.name)
 	require.Equal(identityset.Address(12), cand.operatorAddress)
@@ -92,7 +92,7 @@ func TestSignedCandidateUpdate(t *testing.T) {
 
 	canu := selp.Action().(*CandidateUpdate)
 	require.Equal(uint64(1), selp.Nonce())
-	require.Equal(_gasLimit, selp.GasLimit())
+	require.Equal(_gasLimit, selp.Gas())
 	require.Equal(_gasPrice, selp.GasPrice())
 	require.Equal(_candidate1Name, canu.name)
 	require.NotNil(selp.Signature())
@@ -107,7 +107,7 @@ func TestSignedCreateStake(t *testing.T) {
 	require.Equal(_candidate1Name, exec.candName)
 	require.Equal(uint64(1), selp.Nonce())
 	require.Equal(big.NewInt(10), exec.Amount())
-	require.Equal(_gasLimit, selp.GasLimit())
+	require.Equal(_gasLimit, selp.Gas())
 	require.Equal(_gasPrice, selp.GasPrice())
 	require.Equal([]byte{}, exec.payload)
 	require.Equal(true, exec.autoStake)
@@ -122,7 +122,7 @@ func TestNewUnstakeSignedReclaimStake(t *testing.T) {
 	exec := selp.Action().(*Unstake)
 	require.Equal(uint64(1), selp.Nonce())
 	require.Equal(uint64(2), exec.bucketIndex)
-	require.Equal(_gasLimit, selp.GasLimit())
+	require.Equal(_gasLimit, selp.Gas())
 	require.Equal(_gasPrice, selp.GasPrice())
 	require.Equal([]byte{}, exec.payload)
 	require.NotNil(selp.Signature())
@@ -136,7 +136,7 @@ func TestNewWithdrawStakeSignedReclaimStake(t *testing.T) {
 	exec := selp.Action().(*WithdrawStake)
 	require.Equal(uint64(1), selp.Nonce())
 	require.Equal(uint64(2), exec.bucketIndex)
-	require.Equal(_gasLimit, selp.GasLimit())
+	require.Equal(_gasLimit, selp.Gas())
 	require.Equal(_gasPrice, selp.GasPrice())
 	require.Equal([]byte{}, exec.payload)
 	require.NotNil(selp.Signature())
@@ -151,7 +151,7 @@ func TestSignedChangeCandidate(t *testing.T) {
 	require.Equal(_candidate1Name, exec.candidateName)
 	require.Equal(uint64(1), selp.Nonce())
 	require.Equal(uint64(2), exec.bucketIndex)
-	require.Equal(_gasLimit, selp.GasLimit())
+	require.Equal(_gasLimit, selp.Gas())
 	require.Equal(_gasPrice, selp.GasPrice())
 	require.Equal([]byte{}, exec.payload)
 	require.NotNil(selp.Signature())
@@ -166,7 +166,7 @@ func TestSignedTransferStake(t *testing.T) {
 	require.Equal(identityset.Address(12), exec.voterAddress)
 	require.Equal(uint64(1), selp.Nonce())
 	require.Equal(uint64(2), exec.bucketIndex)
-	require.Equal(_gasLimit, selp.GasLimit())
+	require.Equal(_gasLimit, selp.Gas())
 	require.Equal(_gasPrice, selp.GasPrice())
 	require.Equal([]byte{}, exec.payload)
 	require.NotNil(selp.Signature())
@@ -181,7 +181,7 @@ func TestSignedDepositToStake(t *testing.T) {
 	require.Equal(uint64(2), exec.bucketIndex)
 	require.Equal(uint64(1), selp.Nonce())
 	require.Equal(big.NewInt(10), exec.Amount())
-	require.Equal(_gasLimit, selp.GasLimit())
+	require.Equal(_gasLimit, selp.Gas())
 	require.Equal(_gasPrice, selp.GasPrice())
 	require.Equal([]byte{}, exec.payload)
 	require.NotNil(selp.Signature())
@@ -197,7 +197,7 @@ func TestSignedRestake(t *testing.T) {
 	require.Equal(uint32(91), exec.duration)
 	require.Equal(true, exec.autoStake)
 	require.Equal(uint64(2), exec.bucketIndex)
-	require.Equal(_gasLimit, selp.GasLimit())
+	require.Equal(_gasLimit, selp.Gas())
 	require.Equal(_gasPrice, selp.GasPrice())
 	require.Equal([]byte{}, exec.payload)
 	require.NotNil(selp.Signature())
@@ -211,7 +211,7 @@ func TestSignedCandidateTransferOwnership(t *testing.T) {
 	exec := selp.Action().(*CandidateTransferOwnership)
 	require.Equal(uint64(1), selp.Nonce())
 	require.Equal(_cand1Addr, exec.newOwner.String())
-	require.Equal(_gasLimit, selp.GasLimit())
+	require.Equal(_gasLimit, selp.Gas())
 	require.Equal(_gasPrice, selp.GasPrice())
 	require.Equal([]byte{}, exec.payload)
 	require.NotNil(selp.Signature())
@@ -225,7 +225,7 @@ func TestSignedMigrateStake(t *testing.T) {
 	exec := selp.Action().(*MigrateStake)
 	require.EqualValues(1, selp.Nonce())
 	require.EqualValues(9, exec.bucketIndex)
-	require.Equal(_gasLimit, selp.GasLimit())
+	require.Equal(_gasLimit, selp.Gas())
 	require.Equal(_gasPrice, selp.GasPrice())
 	require.NotNil(selp.Signature())
 }

action/stake_changecandidate_test.go

@@ -23,7 +23,7 @@ func TestChangeCandidate(t *testing.T) {
 	t.Run("proto", func(t *testing.T) {
 		ser := stake.Serialize()
 		require.Equal("080a120a63616e646964617465311a077061796c6f6164", hex.EncodeToString(ser))
-		require.Equal(_gaslimit, elp.GasLimit())
+		require.Equal(_gaslimit, elp.Gas())
 		require.Equal(_gasprice, elp.GasPrice())
 		require.Equal(_nonce, elp.Nonce())
 

action/stake_transferownership_test.go

@@ -17,7 +17,7 @@ func TestStakingTransfer(t *testing.T) {
 	t.Run("proto", func(t *testing.T) {
 		ser := stake.Serialize()
 		require.Equal("080a1229696f3178707136326177383575717a72636367397935686e727976386c64326e6b7079636333677a611a077061796c6f6164", hex.EncodeToString(ser))
-		require.Equal(_gaslimit, elp.GasLimit())
+		require.Equal(_gaslimit, elp.Gas())
 		require.Equal(_gasprice, elp.GasPrice())
 		require.Equal(_nonce, elp.Nonce())
 

action/stakeadddeposit_test.go

@@ -75,7 +75,7 @@ func TestDeposit(t *testing.T) {
 		require.Equal(test.Serialize, hex.EncodeToString(ser))
 
 		require.NoError(err)
-		require.Equal(test.GasLimit, elp.GasLimit())
+		require.Equal(test.GasLimit, elp.Gas())
 		require.Equal(test.GasPrice, elp.GasPrice())
 		require.Equal(test.Nonce, elp.Nonce())
 

action/stakecreate_test.go

@@ -76,7 +76,7 @@ func TestCreateStake(t *testing.T) {
 
 		ser := stake.Serialize()
 		require.Equal(test.Serialize, hex.EncodeToString(ser))
-		require.Equal(test.GasLimit, elp.GasLimit())
+		require.Equal(test.GasLimit, elp.Gas())
 		require.Equal(test.GasPrice, elp.GasPrice())
 		require.Equal(test.Nonce, elp.Nonce())
 

action/stakereclaim_test.go

@@ -35,7 +35,7 @@ func TestUnstake(t *testing.T) {
 	t.Run("proto", func(t *testing.T) {
 		ser := stake.Serialize()
 		require.Equal("080a12077061796c6f6164", hex.EncodeToString(ser))
-		require.Equal(_gaslimit, elp.GasLimit())
+		require.Equal(_gaslimit, elp.Gas())
 		require.Equal(_gasprice, elp.GasPrice())
 		require.Equal(_nonce, elp.Nonce())
 		require.Equal(_payload, stake.Payload())
@@ -84,7 +84,7 @@ func TestWithdraw(t *testing.T) {
 	t.Run("proto", func(t *testing.T) {
 		ser := stake.Serialize()
 		require.Equal("080a12077061796c6f6164", hex.EncodeToString(ser))
-		require.Equal(_gaslimit, elp.GasLimit())
+		require.Equal(_gaslimit, elp.Gas())
 		require.Equal(_gasprice, elp.GasPrice())
 		require.Equal(_nonce, elp.Nonce())
 		require.Equal(_payload, stake.Payload())

action/stakerestake_test.go

@@ -26,7 +26,7 @@ func TestRestake(t *testing.T) {
 	t.Run("proto", func(t *testing.T) {
 		ser := stake.Serialize()
 		require.Equal("080a10e807180122077061796c6f6164", hex.EncodeToString(ser))
-		require.Equal(_gaslimit, elp.GasLimit())
+		require.Equal(_gaslimit, elp.Gas())
 		require.Equal(_gasprice, elp.GasPrice())
 		require.Equal(_nonce, elp.Nonce())
 

action/transfer_test.go

@@ -62,7 +62,7 @@ func TestTransfer(t *testing.T) {
 	require.Error(w.VerifySignature())
 	require.Equal("10", tsf.Amount().Text(10))
 	require.Equal([]byte{}, tsf.Payload())
-	require.Equal(uint64(100000), elp.GasLimit())
+	require.Equal(uint64(100000), elp.Gas())
 	require.Equal("10", elp.GasPrice().Text(10))
 	require.Zero(elp.Nonce())
 	require.Equal(senderKey.PublicKey().HexString(), w.SrcPubkey().HexString())

actpool/actioniterator/actioniterator_test.go

@@ -123,7 +123,7 @@ func BenchmarkLooping(b *testing.B) {
 		if !ok {
 			break
 		}
-		if act.GasLimit() < 30 {
+		if act.Gas() < 30 {
 			ai.PopAccount()
 		}
 	}

api/coreservice.go

@@ -547,7 +547,7 @@ func (core *coreService) ReadContract(ctx context.Context, callerAddr address.Ad
 		g             = core.bc.Genesis()
 		blockGasLimit = g.BlockGasLimitByHeight(core.bc.TipHeight())
 	)
-	if elp.GasLimit() == 0 || blockGasLimit < elp.GasLimit() {
+	if elp.Gas() == 0 || blockGasLimit < elp.Gas() {
 		elp.SetGas(blockGasLimit)
 	}
 	retval, receipt, err := core.simulateExecution(ctx, callerAddr, elp)

api/grpcserver.go

@@ -760,7 +760,7 @@ func generateBlockMeta(blkStore *apitypes.BlockWithReceipts) *iotextypes.BlockMe
 func gasLimitAndUsed(acts []*action.SealedEnvelope, receipts []*action.Receipt) (uint64, uint64) {
 	var gasLimit, gasUsed uint64
 	for _, tx := range acts {
-		gasLimit += tx.GasLimit()
+		gasLimit += tx.Gas()
 	}
 	for _, r := range receipts {
 		gasUsed += r.GasConsumed

api/grpcserver_integrity_test.go

@@ -1477,7 +1477,7 @@ func TestGrpcServer_ReadContractIntegrity(t *testing.T) {
 		request := &iotexapi.ReadContractRequest{
 			Execution:     exec.Proto().GetCore().GetExecution(),
 			CallerAddress: test.callerAddr,
-			GasLimit:      exec.GasLimit(),
+			GasLimit:      exec.Gas(),
 			GasPrice:      big.NewInt(unit.Qev).String(),
 		}
 

api/web3server_marshal.go

@@ -165,7 +165,7 @@ func (obj *getBlockResult) MarshalJSON() ([]byte, error) {
 		return nil, err
 	}
 	for _, tx := range obj.blk.Actions {
-		gasLimit += tx.GasLimit()
+		gasLimit += tx.Gas()
 	}
 	for _, r := range obj.blk.Receipts {
 		gasUsed += r.GasConsumed

blockchain/block/runnable_test.go

@@ -29,5 +29,5 @@ func TestRunnableActionsBuilder(t *testing.T) {
 	require.Equal(1, len(racs.Actions()))
 	act := racs.Actions()[0]
 	require.Equal(big.NewInt(10), act.GasPrice())
-	require.Equal(uint64(100000), act.GasLimit())
+	require.Equal(uint64(100000), act.Gas())
 }

state/factory/workingset.go

@@ -572,7 +572,7 @@ func (ws *workingSet) pickAndRunActions(
 			if !ok {
 				break
 			}
-			if nextAction.GasLimit() > blkCtx.GasLimit {
+			if nextAction.Gas() > blkCtx.GasLimit {
 				actionIterator.PopAccount()
 				continue
 			}