From 9c4692c071d87d762219644007c603d70b538672 Mon Sep 17 00:00:00 2001 From: Ethan Buchman Date: Wed, 18 Mar 2015 19:34:55 -0700 Subject: [PATCH] remove gas price and dont run txs before they come in a block --- block/block.go | 4 ---- block/tx.go | 4 ++-- mempool/mempool.go | 4 ++-- state/state.go | 34 ++++++++-------------------------- state/state_test.go | 6 +++--- 5 files changed, 15 insertions(+), 37 deletions(-) diff --git a/block/block.go b/block/block.go index bb5e3d41..bfa8c28f 100644 --- a/block/block.go +++ b/block/block.go @@ -107,16 +107,12 @@ type Header struct { Height uint Time time.Time Fees uint64 - GasPrice uint64 NumTxs uint LastBlockHash []byte LastBlockParts PartSetHeader StateHash []byte } -// possible for actual gas price to be less than 1 -var GasPriceDivisor = 1000000 - func (h *Header) Hash() []byte { buf := new(bytes.Buffer) hasher, n, err := sha256.New(), new(int64), new(error) diff --git a/block/tx.go b/block/tx.go index 5bf5dfc5..6ea8a750 100644 --- a/block/tx.go +++ b/block/tx.go @@ -147,7 +147,7 @@ type CallTx struct { Input *TxInput Address []byte GasLimit uint64 - FeeLimit uint64 + Fee uint64 Data []byte } @@ -157,7 +157,7 @@ func (tx *CallTx) WriteSignBytes(w io.Writer, n *int64, err *error) { tx.Input.WriteSignBytes(w, n, err) binary.WriteByteSlice(tx.Address, w, n, err) binary.WriteUint64(tx.GasLimit, w, n, err) - binary.WriteUint64(tx.FeeLimit, w, n, err) + binary.WriteUint64(tx.Fee, w, n, err) binary.WriteByteSlice(tx.Data, w, n, err) } diff --git a/mempool/mempool.go b/mempool/mempool.go index 7fdd7e80..0778d945 100644 --- a/mempool/mempool.go +++ b/mempool/mempool.go @@ -32,7 +32,7 @@ func NewMempool(state *sm.State) *Mempool { func (mem *Mempool) AddTx(tx blk.Tx) (err error) { mem.mtx.Lock() defer mem.mtx.Unlock() - err = mem.state.ExecTx(tx) + err = mem.state.ExecTx(tx, false) if err != nil { log.Debug("AddTx() error", "tx", tx, "error", err) return err @@ -82,7 +82,7 @@ func (mem *Mempool) ResetForBlockAndState(block *blk.Block, state *sm.State) { // Next, filter all txs that aren't valid given new state. validTxs := []blk.Tx{} for _, tx := range txs { - err := mem.state.ExecTx(tx) + err := mem.state.ExecTx(tx, false) if err == nil { log.Debug("Filter in, valid", "tx", tx) validTxs = append(validTxs, tx) diff --git a/state/state.go b/state/state.go index 48420bef..8d2baf1c 100644 --- a/state/state.go +++ b/state/state.go @@ -4,7 +4,6 @@ import ( "bytes" "errors" "fmt" - "math/big" "time" "github.com/tendermint/tendermint/account" @@ -235,15 +234,14 @@ func (s *State) AdjustByOutputs(accounts map[string]*account.Account, outs []*bl // If the tx is invalid, an error will be returned. // Unlike AppendBlock(), state will not be altered. -func (s *State) ExecTx(tx_ blk.Tx, blk_ *blk.Block) error { +func (s *State) ExecTx(tx_ blk.Tx, runCall bool) error { // TODO: do something with fees fees := uint64(0) // Exec tx - switch tx_.(type) { + switch tx := tx_.(type) { case *blk.SendTx: - tx := tx_.(*blk.SendTx) accounts, err := s.GetOrMakeAccounts(tx.Inputs, tx.Outputs) if err != nil { return err @@ -270,7 +268,6 @@ func (s *State) ExecTx(tx_ blk.Tx, blk_ *blk.Block) error { return nil case *blk.CallTx: - tx := tx_.(*blk.CallTx) accounts := map[string]*account.Account{} inAcc := s.GetAccount(tx.Input.Address) if inAcc == nil { @@ -297,29 +294,20 @@ func (s *State) ExecTx(tx_ blk.Tx, blk_ *blk.Block) error { } accounts[string(tx.Address)] = outAcc - // ensure sufficient gas price - // we multiply to avoid dividing - bigProvidedFee := new(big.Int).Mul(big.NewInt(int64(tx.FeeLimit)), big.NewInt(int64(blk.GasPriceDivisor))) - bigMinFee := new(big.Int).Mul(big.NewInt(int64(blk_.GasPrice)), big.NewInt(int64(tx.GasLimit))) - if bigProvidedFee.Cmp(bigMinFee) < 0 { - return blk.ErrTxInsufficientGasPrice - } - - inTotal -= tx.FeeLimit + inTotal -= tx.Fee // Good! Adjust accounts s.AdjustByInputs(accounts, []*blk.TxInput{tx.Input}) outAcc.Balance += inTotal s.UpdateAccounts(accounts) - // TODO: Run the contract call! - - // TODO: refund some gas - + if runCall { + // TODO: Run the contract call! + // TODO: refund some gas + } return nil case *blk.BondTx: - tx := tx_.(*blk.BondTx) valInfo := s.GetValidatorInfo(tx.PubKey.Address()) if valInfo != nil { // TODO: In the future, check that the validator wasn't destroyed, @@ -373,8 +361,6 @@ func (s *State) ExecTx(tx_ blk.Tx, blk_ *blk.Block) error { return nil case *blk.UnbondTx: - tx := tx_.(*blk.UnbondTx) - // The validator must be active _, val := s.BondedValidators.GetByAddress(tx.Address) if val == nil { @@ -397,8 +383,6 @@ func (s *State) ExecTx(tx_ blk.Tx, blk_ *blk.Block) error { return nil case *blk.RebondTx: - tx := tx_.(*blk.RebondTx) - // The validator must be inactive _, val := s.UnbondingValidators.GetByAddress(tx.Address) if val == nil { @@ -421,8 +405,6 @@ func (s *State) ExecTx(tx_ blk.Tx, blk_ *blk.Block) error { return nil case *blk.DupeoutTx: - tx := tx_.(*blk.DupeoutTx) - // Verify the signatures _, accused := s.BondedValidators.GetByAddress(tx.Address) if accused == nil { @@ -650,7 +632,7 @@ func (s *State) appendBlock(block *blk.Block, blockPartsHeader blk.PartSetHeader // Commit each tx for _, tx := range block.Data.Txs { - err := s.ExecTx(tx, block) + err := s.ExecTx(tx, true) if err != nil { return InvalidTxError{tx, err} } diff --git a/state/state_test.go b/state/state_test.go index b9b90030..63bd0c47 100644 --- a/state/state_test.go +++ b/state/state_test.go @@ -183,7 +183,7 @@ func TestTxSequence(t *testing.T) { tx := makeSendTx(sequence) tx.Inputs[0].Signature = privAccounts[0].Sign(tx) stateCopy := state.Copy() - err := stateCopy.ExecTx(tx, &blk.Block{}) + err := stateCopy.ExecTx(tx, true) if i == 1 { // Sequence is good. if err != nil { @@ -242,7 +242,7 @@ func TestTxs(t *testing.T) { } tx.Inputs[0].Signature = privAccounts[0].Sign(tx) - err := state.ExecTx(tx, &blk.Block{}) + err := state.ExecTx(tx, true) if err != nil { t.Errorf("Got error in executing send transaction, %v", err) } @@ -279,7 +279,7 @@ func TestTxs(t *testing.T) { }, } tx.Inputs[0].Signature = privAccounts[0].Sign(tx) - err := state.ExecTx(tx, &blk.Block{}) + err := state.ExecTx(tx, true) if err != nil { t.Errorf("Got error in executing bond transaction, %v", err) }