type txdata struct {
    AccountNonce uint64          `json:"nonce"    gencodec:"required"`
    Price        *big.Int        `json:"gasPrice" gencodec:"required"`
    GasLimit     uint64          `json:"gas"      gencodec:"required"`
    Recipient    *common.Address `json:"to"       rlp:"nil"` // nil means contract creation
    Amount       *big.Int        `json:"value"    gencodec:"required"`
    Payload      []byte          `json:"input"    gencodec:"required"`

    // Signature values
    V *big.Int `json:"v" gencodec:"required"`
    R *big.Int `json:"r" gencodec:"required"`
    S *big.Int `json:"s" gencodec:"required"`

    // This is only used when marshaling to JSON.
    Hash *common.Hash `json:"hash" rlp:"-"`
}

func (s EIP155Signer) Hash(tx *Transaction) common.Hash {
	return rlpHash([]interface{}{
		tx.data.AccountNonce,
		tx.data.Price,
		tx.data.GasLimit,
		tx.data.Recipient,
		tx.data.Amount,
		tx.data.Payload,
		s.chainId, uint(0), uint(0),
	})
}

// Creates an ethereum address given the bytes and the nonce
func CreateAddress(b common.Address, nonce uint64) common.Address {
    data, _ := rlp.EncodeToBytes([]interface{}{b, nonce})
    return common.BytesToAddress(Keccak256(data)[12:])
}

hash := tx.Hash()
if pool.all[hash] != nil {
    log.Trace("Discarding already known transaction", "hash", hash)
    return false, fmt.Errorf("known transaction: %x",

// Discard finds a number of most underpriced transactions, removes them from the
// priced list and returns them for further removal from the entire pool.
func (l *txPricedList) Discard(count int, local *accountSet) types.Transactions {
    drop := make(types.Transactions, 0, count) // Remote underpriced transactions to drop
    save := make(types.Transactions, 0, 64)    // Local underpriced transactions to keep

    for len(*l.items) > 0 && count > 0 {
        // Discard stale transactions if found during cleanup
        tx := heap.Pop(l.items).(*types.Transaction)
        if _, ok := (*l.all)[tx.Hash()]; !ok {
            l.stales--
            continue
        }
        // Non stale transaction found, discard unless local
        if local.containsTx(tx) {
            save = append(save, tx)
        } else {
            drop = append(drop, tx)
            count--
        }
    }
    for _, tx := range save {
        heap.Push(l.items, tx)
    }
    return drop
}

// Ensure the transaction adheres to nonce ordering
if pool.currentState.GetNonce(from) > tx.Nonce() {
	return ErrNonceTooLow
}

if list := pool.pending[from]; list != nil && list.Overlaps(tx) {
   ...
}

// 检查并剔除小于最新区块的交易
for _, tx := range list.Forward(pool.currentState.GetNonce(addr)) {
   ...
}

for _, tx := range list.Ready(pool.pendingState.GetNonce(addr)) {
   ...
}

func (env *Work) commitTransaction(tx *types.Transaction, bc *core.BlockChain, coinbase common.Address, gp *core.GasPool) (error, []*types.Log) {
  ...
  // 如果执行交易报错,则回滚账户状态(即不从用户账户扣钱,完全回滚,交易不会打包)
  receipt, _, err := core.ApplyTransaction(env.config, bc, &coinbase, gp, env.state, env.header, tx, &env.header.GasUsed, vm.Config{})
  if err != nil {
    env.state.RevertToSnapshot(snap)
    return err, nil
  }
  env.txs = append(env.txs, tx)
  env.receipts = append(env.receipts, receipt)

  return nil, receipt.Logs
}

func ApplyTransaction(config *params.ChainConfig, bc *BlockChain, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *type$
  // 1.参数检查类错误
  msg, err := tx.AsMessage(types.MakeSigner(config, header.Number))
  if err != nil {
    return nil, 0, err
  }
  ...
  // 2.执行类,稍后再看
  _, gas, failed, err := ApplyMessage(vmenv, msg, gp)
  if err != nil {
    return nil, 0, err
  }
  // 3.存储交易收据,注意失败的交易也会创建收据
  receipt := types.NewReceipt(root, failed, *usedGas)
  receipt.TxHash = tx.Hash()
  receipt.GasUsed = gas
  ...
}

unc (st *StateTransition) TransitionDb() (ret []byte, usedGas uint64, failed bool, err error) {
  ...
  // 1. 该函数根据交易数据检查是否超出基本gas限制,会抛出我们常见的vm.ErrOutOfGas(out of gas),注意此处抛出的错误会使得交易完全回滚
  gas, err := IntrinsicGas(st.data, contractCreation, homestead)
  if err = st.useGas(gas); err != nil {
    return nil, 0, false, err
  }

  var (
    evm = st.evm
    vmerr error
  )
  // 2.这里如果返回错误(vmerr!=nil)则说明交易执行失败
  if contractCreation {
    ret, _, st.gas, vmerr = evm.Create(sender, st.data, st.gas, st.value)
  } else {
    // Increment the nonce for the next transaction
    st.state.SetNonce(sender.Address(), st.state.GetNonce(sender.Address())+1)
    ret, st.gas, vmerr = evm.Call(sender, st.to().Address(), st.data, st.gas, st.value)
  }
  if vmerr != nil {
    // 余额不足("insufficient balance for transfer")错误也会导致交易完全回滚
    if vmerr == vm.ErrInsufficientBalance {
      return nil, 0, false, vmerr
    }
  }
  // 退回剩余的gas
  st.refundGas()
  st.state.AddBalance(st.evm.Coinbase, new(big.Int).Mul(new(big.Int).SetUint64(st.gasUsed()), st.gasPrice))

  // 3.vmerr不为空将导致交易失败,但仍能正确打包
  return ret, st.gasUsed(), vmerr != nil, err
}