eth.sendTransaction({"from":eth.accounts[0],to:eth.accounts[1],value:web3.toWei(10,'ether')})

func (s *PublicTransactionPoolAPI) SendTransaction(ctx  context.Context, args SendTxArgs) (common.Hash, error)

   SignTx(account Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error)

func (ks *KeyStore) SignTx(a accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {// Look up the key to sign with and abort if it cannot be foundks.mu.RLock()defer ks.mu.RUnlock()unlockedKey, found := ks.unlocked[a.Address]if !found {return nil, ErrLocked}// Depending on the presence of the chain ID, sign with EIP155 or homesteadif chainID != nil {return types.SignTx(tx, types.NewEIP155Signer(chainID), unlockedKey.PrivateKey)}return types.SignTx(tx, types.HomesteadSigner{}, unlockedKey.PrivateKey)
}

func SignTx(tx *Transaction, s Signer, prv *ecdsa.PrivateKey) (*Transaction, error) {h := s.Hash(tx)sig, err := crypto.Sign(h[:], prv)if err != nil {return nil, err}return s.WithSignature(tx, sig)
}

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),})
}

func (s EIP155Signer) WithSignature(tx *Transaction, sig []byte) (*Transaction, error) {if len(sig) != 65 {panic(fmt.Sprintf("wrong size for signature: got %d, want 65", len(sig)))}cpy := &Transaction{data: tx.data}cpy.data.R = new(big.Int).SetBytes(sig[:32])cpy.data.S = new(big.Int).SetBytes(sig[32:64])cpy.data.V = new(big.Int).SetBytes([]byte{sig[64]})if s.chainId.Sign() != 0 {cpy.data.V = big.NewInt(int64(sig[64] + 35))cpy.data.V.Add(cpy.data.V, s.chainIdMul)}return cpy, nil
}

func submitTransaction(ctx context.Context, b Backend, tx *types.Transaction) (common.Hash, error) {if err := b.SendTx(ctx, tx); err != nil {return common.Hash{}, err}if tx.To() == nil {signer := types.MakeSigner(b.ChainConfig(), b.CurrentBlock().Number())from, _ := types.Sender(signer, tx)addr := crypto.CreateAddress(from, tx.Nonce())log.Info("Submitted contract creation", "fullhash", tx.Hash().Hex(), "contract", addr.Hex())} else {log.Info("Submitted transaction", "fullhash", tx.Hash().Hex(), "recipient", tx.To())}return tx.Hash(), nil
}

func (pool *TxPool) addTx(tx *types.Transaction, local bool) error {pool.mu.Lock()defer pool.mu.Unlock()// Try to inject the transaction and update any statereplace, err := pool.add(tx, local)if err != nil {return err}// If we added a new transaction, run promotion checks and returnif !replace {state, err := pool.currentState()if err != nil {return err}from, _ := types.Sender(pool.signer, tx) // already validatedpool.promoteExecutables(state, []common.Address{from})}return nil
}

func (pool *TxPool) add(tx *types.Transaction, local bool) (bool, error) {// If the transaction is already known, discard ithash := tx.Hash()if pool.all[hash] != nil {log.Trace("Discarding already known transaction", "hash", hash)return false, fmt.Errorf("known transaction: %x", hash)}// If the transaction fails basic validation, discard itif err := pool.validateTx(tx, local); err != nil {log.Trace("Discarding invalid transaction", "hash", hash, "err", err)invalidTxCounter.Inc(1)return false, err}// If the transaction pool is full, discard underpriced transactionsif uint64(len(pool.all)) >= pool.config.GlobalSlots+pool.config.GlobalQueue {// If the new transaction is underpriced, don't accept itif pool.priced.Underpriced(tx, pool.locals) {log.Trace("Discarding underpriced transaction", "hash", hash, "price", tx.GasPrice())underpricedTxCounter.Inc(1)return false, ErrUnderpriced}// New transaction is better than our worse ones, make room for itdrop := pool.priced.Discard(len(pool.all)-int(pool.config.GlobalSlots+pool.config.GlobalQueue-1), pool.locals)for _, tx := range drop {log.Trace("Discarding freshly underpriced transaction", "hash", tx.Hash(), "price", tx.GasPrice())underpricedTxCounter.Inc(1)pool.removeTx(tx.Hash())}}// If the transaction is replacing an already pending one, do directlyfrom, _ := types.Sender(pool.signer, tx) // already validatedif list := pool.pending[from]; list != nil && list.Overlaps(tx) {// Nonce already pending, check if required price bump is metinserted, old := list.Add(tx, pool.config.PriceBump)if !inserted {pendingDiscardCounter.Inc(1)return false, ErrReplaceUnderpriced}// New transaction is better, replace old oneif old != nil {delete(pool.all, old.Hash())pool.priced.Removed()pendingReplaceCounter.Inc(1)}pool.all[tx.Hash()] = txpool.priced.Put(tx)pool.journalTx(from, tx)log.Trace("Pooled new executable transaction", "hash", hash, "from", from, "to", tx.To())return old != nil, nil}// New transaction isn't replacing a pending one, push into queuereplace, err := pool.enqueueTx(hash, tx)if err != nil {return false, err}// Mark local addresses and journal local transactionsif local {pool.locals.add(from)}pool.journalTx(from, tx)log.Trace("Pooled new future transaction", "hash", hash, "from", from, "to", tx.To())return replace, nil
}

func (pool *TxPool) promoteExecutables(state *state.StateDB, accounts []common.Address) {gaslimit := pool.gasLimit()// Gather all the accounts potentially needing updatesif accounts == nil {accounts = make([]common.Address, 0, len(pool.queue))for addr, _ := range pool.queue {accounts = append(accounts, addr)}}// Iterate over all accounts and promote any executable transactionsfor _, addr := range accounts {list := pool.queue[addr]if list == nil {continue // Just in case someone calls with a non existing account}// Drop all transactions that are deemed too old (low nonce)for _, tx := range list.Forward(state.GetNonce(addr)) {hash := tx.Hash()log.Trace("Removed old queued transaction", "hash", hash)delete(pool.all, hash)pool.priced.Removed()}// Drop all transactions that are too costly (low balance or out of gas)drops, _ := list.Filter(state.GetBalance(addr), gaslimit)for _, tx := range drops {hash := tx.Hash()log.Trace("Removed unpayable queued transaction", "hash", hash)delete(pool.all, hash)pool.priced.Removed()queuedNofundsCounter.Inc(1)}// Gather all executable transactions and promote themfor _, tx := range list.Ready(pool.pendingState.GetNonce(addr)) {hash := tx.Hash()log.Trace("Promoting queued transaction", "hash", hash)pool.promoteTx(addr, hash, tx)}// Drop all transactions over the allowed limitif !pool.locals.contains(addr) {for _, tx := range list.Cap(int(pool.config.AccountQueue)) {hash := tx.Hash()delete(pool.all, hash)pool.priced.Removed()queuedRateLimitCounter.Inc(1)log.Trace("Removed cap-exceeding queued transaction", "hash", hash)}}// Delete the entire queue entry if it became empty.if list.Empty() {delete(pool.queue, addr)}}// If the pending limit is overflown, start equalizing allowancespending := uint64(0)for _, list := range pool.pending {pending += uint64(list.Len())}if pending > pool.config.GlobalSlots {pendingBeforeCap := pending// Assemble a spam order to penalize large transactors firstspammers := prque.New()for addr, list := range pool.pending {// Only evict transactions from high rollersif !pool.locals.contains(addr) && uint64(list.Len()) > pool.config.AccountSlots {spammers.Push(addr, float32(list.Len()))}}// Gradually drop transactions from offendersoffenders := []common.Address{}for pending > pool.config.GlobalSlots && !spammers.Empty() {// Retrieve the next offender if not local addressoffender, _ := spammers.Pop()offenders = append(offenders, offender.(common.Address))// Equalize balances until all the same or below thresholdif len(offenders) > 1 {// Calculate the equalization threshold for all current offendersthreshold := pool.pending[offender.(common.Address)].Len()// Iteratively reduce all offenders until below limit or threshold reachedfor pending > pool.config.GlobalSlots && pool.pending[offenders[len(offenders)-2]].Len() > threshold {for i := 0; i < len(offenders)-1; i++ {list := pool.pending[offenders[i]]for _, tx := range list.Cap(list.Len() - 1) {// Drop the transaction from the global pools toohash := tx.Hash()delete(pool.all, hash)pool.priced.Removed()// Update the account nonce to the dropped transactionif nonce := tx.Nonce(); pool.pendingState.GetNonce(offenders[i]) > nonce {pool.pendingState.SetNonce(offenders[i], nonce)}log.Trace("Removed fairness-exceeding pending transaction", "hash", hash)}pending--}}}}// If still above threshold, reduce to limit or min allowanceif pending > pool.config.GlobalSlots && len(offenders) > 0 {for pending > pool.config.GlobalSlots && uint64(pool.pending[offenders[len(offenders)-1]].Len()) > pool.config.AccountSlots {for _, addr := range offenders {list := pool.pending[addr]for _, tx := range list.Cap(list.Len() - 1) {// Drop the transaction from the global pools toohash := tx.Hash()delete(pool.all, hash)pool.priced.Removed()// Update the account nonce to the dropped transactionif nonce := tx.Nonce(); pool.pendingState.GetNonce(addr) > nonce {pool.pendingState.SetNonce(addr, nonce)}log.Trace("Removed fairness-exceeding pending transaction", "hash", hash)}pending--}}}pendingRateLimitCounter.Inc(int64(pendingBeforeCap - pending))}// If we've queued more transactions than the hard limit, drop oldest onesqueued := uint64(0)for _, list := range pool.queue {queued += uint64(list.Len())}if queued > pool.config.GlobalQueue {// Sort all accounts with queued transactions by heartbeataddresses := make(addresssByHeartbeat, 0, len(pool.queue))for addr := range pool.queue {if !pool.locals.contains(addr) { // don't drop localsaddresses = append(addresses, addressByHeartbeat{addr, pool.beats[addr]})}}sort.Sort(addresses)// Drop transactions until the total is below the limit or only locals remainfor drop := queued - pool.config.GlobalQueue; drop > 0 && len(addresses) > 0; {addr := addresses[len(addresses)-1]list := pool.queue[addr.address]addresses = addresses[:len(addresses)-1]// Drop all transactions if they are less than the overflowif size := uint64(list.Len()); size <= drop {for _, tx := range list.Flatten() {pool.removeTx(tx.Hash())}drop -= sizequeuedRateLimitCounter.Inc(int64(size))continue}// Otherwise drop only last few transactionstxs := list.Flatten()for i := len(txs) - 1; i >= 0 && drop > 0; i-- {pool.removeTx(txs[i].Hash())drop--queuedRateLimitCounter.Inc(1)}}}
}

pool.promoteTx(addr, hash, tx)