From b7bb2d8589ddfb4f893c881edb6422bacdb6e53b Mon Sep 17 00:00:00 2001
From: Leif Jurvetson <leijurv@gmail.com>
Date: Tue, 15 Mar 2016 11:08:18 -0700
Subject: [PATCH] core: various typos

---
 core/block_validator.go     | 6 +++---
 core/blockchain_test.go     | 8 ++++----
 core/chain_makers.go        | 4 ++--
 core/state/managed_state.go | 2 +-
 core/state/state_test.go    | 2 +-
 core/state_processor.go     | 2 +-
 core/tx_pool.go             | 6 +++---
 core/tx_pool_test.go        | 2 +-
 core/types.go               | 2 +-
 core/types/block.go         | 2 +-
 core/types/transaction.go   | 4 ++--
 core/vm/asm.go              | 2 +-
 core/vm/doc.go              | 2 +-
 core/vm/environment.go      | 6 +++---
 core/vm/jit.go              | 6 +++---
 core/vm/jit_test.go         | 2 +-
 core/vm/jit_util.go         | 2 +-
 core/vm/runtime/runtime.go  | 2 +-
 core/vm/vm.go               | 8 ++++----
 core/vm/vm_jit.go           | 6 +++---
 core/vm_env.go              | 2 +-
 21 files changed, 39 insertions(+), 39 deletions(-)

diff --git a/core/block_validator.go b/core/block_validator.go
index 73c33d8dd..4d710ae3f 100644
--- a/core/block_validator.go
+++ b/core/block_validator.go
@@ -58,7 +58,7 @@ func NewBlockValidator(blockchain *BlockChain, pow pow.PoW) *BlockValidator {
 // the block header's transaction and uncle roots.
 //
 // ValidateBlock does not validate the header's pow. The pow work validated
-// seperately so we can process them in paralel.
+// separately so we can process them in parallel.
 //
 // ValidateBlock also validates and makes sure that any previous state (or present)
 // state that might or might not be present is checked to make sure that fast
@@ -106,7 +106,7 @@ func (v *BlockValidator) ValidateBlock(block *types.Block) error {
 
 // ValidateState validates the various changes that happen after a state
 // transition, such as amount of used gas, the receipt roots and the state root
-// itself. ValidateState returns a database batch if the validation was a succes
+// itself. ValidateState returns a database batch if the validation was a success
 // otherwise nil and an error is returned.
 func (v *BlockValidator) ValidateState(block, parent *types.Block, statedb *state.StateDB, receipts types.Receipts, usedGas *big.Int) (err error) {
 	header := block.Header()
@@ -297,7 +297,7 @@ func calcDifficultyHomestead(time, parentTime uint64, parentNumber, parentDiff *
 	periodCount := new(big.Int).Add(parentNumber, common.Big1)
 	periodCount.Div(periodCount, ExpDiffPeriod)
 
-	// the exponential factor, commonly refered to as "the bomb"
+	// the exponential factor, commonly referred to as "the bomb"
 	// diff = diff + 2^(periodCount - 2)
 	if periodCount.Cmp(common.Big1) > 0 {
 		y.Sub(periodCount, common.Big2)
diff --git a/core/blockchain_test.go b/core/blockchain_test.go
index 310751cca..aafd7cafe 100644
--- a/core/blockchain_test.go
+++ b/core/blockchain_test.go
@@ -578,7 +578,7 @@ func testBadHashes(t *testing.T, full bool) {
 	}
 }
 
-// Tests that bad hashes are detected on boot, and the chan rolled back to a
+// Tests that bad hashes are detected on boot, and the chain rolled back to a
 // good state prior to the bad hash.
 func TestReorgBadHeaderHashes(t *testing.T) { testReorgBadHashes(t, false) }
 func TestReorgBadBlockHashes(t *testing.T)  { testReorgBadHashes(t, true) }
@@ -589,7 +589,7 @@ func testReorgBadHashes(t *testing.T, full bool) {
 	genesis, _ := WriteTestNetGenesisBlock(db)
 	bc := chm(genesis, db)
 
-	// Create a chain, import and ban aferwards
+	// Create a chain, import and ban afterwards
 	headers := makeHeaderChainWithDiff(genesis, []int{1, 2, 3, 4}, 10)
 	blocks := makeBlockChainWithDiff(genesis, []int{1, 2, 3, 4}, 10)
 
@@ -889,7 +889,7 @@ func TestChainTxReorgs(t *testing.T) {
 	var pastDrop, freshDrop *types.Transaction
 
 	// Create three transactions that will be added in the forked chain:
-	//  - pastAdd:   transaction added before the reorganiztion is detected
+	//  - pastAdd:   transaction added before the reorganization is detected
 	//  - freshAdd:  transaction added at the exact block the reorg is detected
 	//  - futureAdd: transaction added after the reorg has already finished
 	var pastAdd, freshAdd, futureAdd *types.Transaction
@@ -1086,7 +1086,7 @@ done:
 	// make sure no more events are fired
 	select {
 	case e := <-subs.Chan():
-		t.Errorf("unexectped event fired: %v", e)
+		t.Errorf("unexpected event fired: %v", e)
 	case <-time.After(250 * time.Millisecond):
 	}
 
diff --git a/core/chain_makers.go b/core/chain_makers.go
index c62618e6c..0e1ca5fff 100644
--- a/core/chain_makers.go
+++ b/core/chain_makers.go
@@ -108,7 +108,7 @@ func (b *BlockGen) Number() *big.Int {
 // backing transaction.
 //
 // AddUncheckedReceipts will cause consensus failures when used during real
-// chain processing. This is best used in conjuction with raw block insertion.
+// chain processing. This is best used in conjunction with raw block insertion.
 func (b *BlockGen) AddUncheckedReceipt(receipt *types.Receipt) {
 	b.receipts = append(b.receipts, receipt)
 }
@@ -215,7 +215,7 @@ func makeHeader(parent *types.Block, state *state.StateDB) *types.Header {
 // chain. Depending on the full flag, if creates either a full block chain or a
 // header only chain.
 func newCanonical(n int, full bool) (ethdb.Database, *BlockChain, error) {
-	// Create te new chain database
+	// Create the new chain database
 	db, _ := ethdb.NewMemDatabase()
 	evmux := &event.TypeMux{}
 
diff --git a/core/state/managed_state.go b/core/state/managed_state.go
index 4df047979..f8e2f2b87 100644
--- a/core/state/managed_state.go
+++ b/core/state/managed_state.go
@@ -82,7 +82,7 @@ func (ms *ManagedState) NewNonce(addr common.Address) uint64 {
 	return uint64(len(account.nonces)-1) + account.nstart
 }
 
-// GetNonce returns the canonical nonce for the managed or unmanged account
+// GetNonce returns the canonical nonce for the managed or unmanaged account
 func (ms *ManagedState) GetNonce(addr common.Address) uint64 {
 	ms.mu.RLock()
 	defer ms.mu.RUnlock()
diff --git a/core/state/state_test.go b/core/state/state_test.go
index 7ce341c36..a45eddd0d 100644
--- a/core/state/state_test.go
+++ b/core/state/state_test.go
@@ -102,7 +102,7 @@ func (s *StateSuite) TestSnapshot(c *checker.C) {
 	data1 := common.BytesToHash([]byte{42})
 	data2 := common.BytesToHash([]byte{43})
 
-	// set inital state object value
+	// set initial state object value
 	s.state.SetState(stateobjaddr, storageaddr, data1)
 	// get snapshot of current state
 	snapshot := s.state.Copy()
diff --git a/core/state_processor.go b/core/state_processor.go
index b9793b157..3ca36a43a 100644
--- a/core/state_processor.go
+++ b/core/state_processor.go
@@ -55,7 +55,7 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB) (ty
 	return receipts, allLogs, totalUsedGas, err
 }
 
-// ApplyTransaction attemps to apply a transaction to the given state database
+// ApplyTransaction attempts to apply a transaction to the given state database
 // and uses the input parameters for its environment.
 //
 // ApplyTransactions returns the generated receipts and vm logs during the
diff --git a/core/tx_pool.go b/core/tx_pool.go
index b8fb4cd35..f4e964bf7 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -60,8 +60,8 @@ type stateFn func() (*state.StateDB, error)
 // current state) and future transactions. Transactions move between those
 // two states over time as they are received and processed.
 type TxPool struct {
-	quit         chan bool // Quiting channel
-	currentState stateFn   // The state function which will allow us to do some pre checkes
+	quit         chan bool // Quitting channel
+	currentState stateFn   // The state function which will allow us to do some pre checks
 	pendingState *state.ManagedState
 	gasLimit     func() *big.Int // The current gas limit function callback
 	minGasPrice  *big.Int
@@ -357,7 +357,7 @@ func (self *TxPool) AddTransactions(txs []*types.Transaction) {
 		}
 	}
 
-	// check and validate the queueue
+	// check and validate the queue
 	self.checkQueue()
 }
 
diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index 811e40111..bd576fb1a 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -331,7 +331,7 @@ func TestTransactionDropping(t *testing.T) {
 
 // Tests that if a transaction is dropped from the current pending pool (e.g. out
 // of fund), all consecutive (still valid, but not executable) transactions are
-// postponed back into the future queue to prevent broadcating them.
+// postponed back into the future queue to prevent broadcasting them.
 func TestTransactionPostponing(t *testing.T) {
 	// Create a test account and fund it
 	pool, key := setupTxPool()
diff --git a/core/types.go b/core/types.go
index 60eb15662..022528374 100644
--- a/core/types.go
+++ b/core/types.go
@@ -39,7 +39,7 @@ import (
 // if it failed to do so.
 //
 // ValidateState validates the given statedb and optionally the receipts and
-// gas used. The implementor should decide what to do with the given input.
+// gas used. The implementer should decide what to do with the given input.
 type Validator interface {
 	HeaderValidator
 	ValidateBlock(block *types.Block) error
diff --git a/core/types/block.go b/core/types/block.go
index 5536e0ea8..5e6a9019d 100644
--- a/core/types/block.go
+++ b/core/types/block.go
@@ -34,7 +34,7 @@ import (
 )
 
 // A BlockNonce is a 64-bit hash which proves (combined with the
-// mix-hash) that a suffcient amount of computation has been carried
+// mix-hash) that a sufficient amount of computation has been carried
 // out on a block.
 type BlockNonce [8]byte
 
diff --git a/core/types/transaction.go b/core/types/transaction.go
index 37715ee53..b99d3a716 100644
--- a/core/types/transaction.go
+++ b/core/types/transaction.go
@@ -158,7 +158,7 @@ func (tx *Transaction) Size() common.StorageSize {
 }
 
 // From returns the address derived from the signature (V, R, S) using secp256k1
-// eliptic curve and an error if it failed deriving or upon an incorrect
+// elliptic curve and an error if it failed deriving or upon an incorrect
 // signature.
 //
 // From Uses the homestead consensus rules to determine whether the signature is
@@ -176,7 +176,7 @@ func (tx *Transaction) From() (common.Address, error) {
 }
 
 // FromFrontier returns the address derived from the signature (V, R, S) using
-// secp256k1 eliptic curve and an error if it failed deriving or upon an
+// secp256k1 elliptic curve and an error if it failed deriving or upon an
 // incorrect signature.
 //
 // FromFrantier uses the frontier consensus rules to determine whether the
diff --git a/core/vm/asm.go b/core/vm/asm.go
index 065d3eb97..b248838a7 100644
--- a/core/vm/asm.go
+++ b/core/vm/asm.go
@@ -23,7 +23,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 )
 
-// Dissassemble dissassembles the byte code and returns the string
+// Disassemble disassembles the byte code and returns the string
 // representation (human readable opcodes).
 func Disassemble(script []byte) (asm []string) {
 	pc := new(big.Int)
diff --git a/core/vm/doc.go b/core/vm/doc.go
index debbdb35e..de7fa6021 100644
--- a/core/vm/doc.go
+++ b/core/vm/doc.go
@@ -20,7 +20,7 @@ Package vm implements the Ethereum Virtual Machine.
 The vm package implements two EVMs, a byte code VM and a JIT VM. The BC
 (Byte Code) VM loops over a set of bytes and executes them according to the set
 of rules defined in the Ethereum yellow paper. When the BC VM is invoked it
-invokes the JIT VM in a seperate goroutine and compiles the byte code in JIT
+invokes the JIT VM in a separate goroutine and compiles the byte code in JIT
 instructions.
 
 The JIT VM, when invoked, loops around a set of pre-defined instructions until
diff --git a/core/vm/environment.go b/core/vm/environment.go
index a58e3ba2b..d5d21a45b 100644
--- a/core/vm/environment.go
+++ b/core/vm/environment.go
@@ -34,9 +34,9 @@ type Environment interface {
 	MakeSnapshot() Database
 	// Set database to previous snapshot
 	SetSnapshot(Database)
-	// Address of the original invoker (first occurance of the VM invoker)
+	// Address of the original invoker (first occurrence of the VM invoker)
 	Origin() common.Address
-	// The block number this VM is invoken on
+	// The block number this VM is invoked on
 	BlockNumber() *big.Int
 	// The n'th hash ago from this block number
 	GetHash(uint64) common.Hash
@@ -101,7 +101,7 @@ type Database interface {
 	IsDeleted(common.Address) bool
 }
 
-// StructLog is emited to the Environment each cycle and lists information about the curent internal state
+// StructLog is emitted to the Environment each cycle and lists information about the current internal state
 // prior to the execution of the statement.
 type StructLog struct {
 	Pc      uint64
diff --git a/core/vm/jit.go b/core/vm/jit.go
index 5404730c1..71ffcf0f6 100644
--- a/core/vm/jit.go
+++ b/core/vm/jit.go
@@ -300,7 +300,7 @@ func CompileProgram(program *Program) (err error) {
 	return nil
 }
 
-// RunProgram runs the program given the enviroment and contract and returns an
+// RunProgram runs the program given the environment and contract and returns an
 // error if the execution failed (non-consensus)
 func RunProgram(program *Program, env Environment, contract *Contract, input []byte) ([]byte, error) {
 	return runProgram(program, 0, NewMemory(), newstack(), env, contract, input)
@@ -346,7 +346,7 @@ func runProgram(program *Program, pcstart uint64, mem *Memory, stack *stack, env
 	return nil, nil
 }
 
-// validDest checks if the given distination is a valid one given the
+// validDest checks if the given destination is a valid one given the
 // destination table of the program
 func validDest(dests map[uint64]struct{}, dest *big.Int) bool {
 	// PC cannot go beyond len(code) and certainly can't be bigger than 64bits.
@@ -416,7 +416,7 @@ func jitCalculateGasAndSize(env Environment, contract *Contract, instr instructi
 		// This checks for 3 scenario's and calculates gas accordingly
 		// 1. From a zero-value address to a non-zero value         (NEW VALUE)
 		// 2. From a non-zero value address to a zero-value address (DELETE)
-		// 3. From a nen-zero to a non-zero                         (CHANGE)
+		// 3. From a non-zero to a non-zero                         (CHANGE)
 		if common.EmptyHash(val) && !common.EmptyHash(common.BigToHash(y)) {
 			g = params.SstoreSetGas
 		} else if !common.EmptyHash(val) && common.EmptyHash(common.BigToHash(y)) {
diff --git a/core/vm/jit_test.go b/core/vm/jit_test.go
index 4174c666f..19261827b 100644
--- a/core/vm/jit_test.go
+++ b/core/vm/jit_test.go
@@ -77,7 +77,7 @@ func TestCompiling(t *testing.T) {
 	}
 
 	if len(prog.instructions) != 1 {
-		t.Error("exected 1 compiled instruction, got", len(prog.instructions))
+		t.Error("expected 1 compiled instruction, got", len(prog.instructions))
 	}
 }
 
diff --git a/core/vm/jit_util.go b/core/vm/jit_util.go
index 0d3d6d701..72e9ccf8f 100644
--- a/core/vm/jit_util.go
+++ b/core/vm/jit_util.go
@@ -41,7 +41,7 @@ func Parse(code []byte) (opcodes []OpCode) {
 
 // MatchFn searcher for match in the given input and calls matcheFn if it finds
 // an appropriate match. matcherFn yields the starting position in the input.
-// MatchFn will continue to search for a match until it reacher the end of the
+// MatchFn will continue to search for a match until it reaches the end of the
 // buffer or if matcherFn return false.
 func MatchFn(input, match []OpCode, matcherFn func(int) bool) {
 	// short circuit if either input or match is empty or if the match is
diff --git a/core/vm/runtime/runtime.go b/core/vm/runtime/runtime.go
index 565ce7b73..3e6057142 100644
--- a/core/vm/runtime/runtime.go
+++ b/core/vm/runtime/runtime.go
@@ -27,7 +27,7 @@ import (
 	"github.com/ethereum/go-ethereum/ethdb"
 )
 
-// Config is a basic type specifing certain configuration flags for running
+// Config is a basic type specifying certain configuration flags for running
 // the EVM.
 type Config struct {
 	Difficulty  *big.Int
diff --git a/core/vm/vm.go b/core/vm/vm.go
index d45d136b5..95d27c64c 100644
--- a/core/vm/vm.go
+++ b/core/vm/vm.go
@@ -63,7 +63,7 @@ func (self *Vm) Run(contract *Contract, input []byte) (ret []byte, err error) {
 	)
 	if EnableJit {
 		// If the JIT is enabled check the status of the JIT program,
-		// if it doesn't exist compile a new program in a seperate
+		// if it doesn't exist compile a new program in a separate
 		// goroutine or wait for compilation to finish if the JIT is
 		// forced.
 		switch GetProgramStatus(codehash) {
@@ -80,7 +80,7 @@ func (self *Vm) Run(contract *Contract, input []byte) (ret []byte, err error) {
 				glog.V(logger.Info).Infoln("error compiling program", err)
 			} else {
 				// create and compile the program. Compilation
-				// is done in a seperate goroutine
+				// is done in a separate goroutine
 				program = NewProgram(contract.Code)
 				go func() {
 					err := CompileProgram(program)
@@ -103,7 +103,7 @@ func (self *Vm) Run(contract *Contract, input []byte) (ret []byte, err error) {
 		stack   = newstack()    // local stack
 		statedb = self.env.Db() // current state
 		// For optimisation reason we're using uint64 as the program counter.
-		// It's theoretically possible to go above 2^64. The YP defines the PC to be uint256. Pratically much less so feasible.
+		// It's theoretically possible to go above 2^64. The YP defines the PC to be uint256. Practically much less so feasible.
 		pc = uint64(0) // program counter
 
 		// jump evaluates and checks whether the given jump destination is a valid one
@@ -271,7 +271,7 @@ func calculateGasAndSize(env Environment, contract *Contract, caller ContractRef
 		// This checks for 3 scenario's and calculates gas accordingly
 		// 1. From a zero-value address to a non-zero value         (NEW VALUE)
 		// 2. From a non-zero value address to a zero-value address (DELETE)
-		// 3. From a nen-zero to a non-zero                         (CHANGE)
+		// 3. From a non-zero to a non-zero                         (CHANGE)
 		if common.EmptyHash(val) && !common.EmptyHash(common.BigToHash(y)) {
 			// 0 => non 0
 			g = params.SstoreSetGas
diff --git a/core/vm/vm_jit.go b/core/vm/vm_jit.go
index 589c30fa8..f6e4a515b 100644
--- a/core/vm/vm_jit.go
+++ b/core/vm/vm_jit.go
@@ -138,7 +138,7 @@ func llvm2big(m *i256) *big.Int {
 }
 
 // llvm2bytesRef creates a []byte slice that references byte buffer on LLVM side (as of that not controller by GC)
-// User must asure that referenced memory is available to Go until the data is copied or not needed any more
+// User must ensure that referenced memory is available to Go until the data is copied or not needed any more
 func llvm2bytesRef(data *byte, length uint64) []byte {
 	if length == 0 {
 		return nil
@@ -171,7 +171,7 @@ func (self *JitVm) Run(me, caller ContextRef, code []byte, value, gas, price *bi
 
 	// TODO: Move it to Env.Call() or sth
 	if Precompiled[string(me.Address())] != nil {
-		// if it's address of precopiled contract
+		// if it's address of precompiled contract
 		// fallback to standard VM
 		stdVm := New(self.env)
 		return stdVm.Run(me, caller, code, value, gas, price, callData)
@@ -348,7 +348,7 @@ func env_create(_vm unsafe.Pointer, _gas *int64, _value unsafe.Pointer, initData
 	gas := big.NewInt(*_gas)
 	ret, suberr, ref := vm.env.Create(vm.me, nil, initData, gas, vm.price, value)
 	if suberr == nil {
-		dataGas := big.NewInt(int64(len(ret))) // TODO: Nto the best design. env.Create can do it, it has the reference to gas counter
+		dataGas := big.NewInt(int64(len(ret))) // TODO: Not the best design. env.Create can do it, it has the reference to gas counter
 		dataGas.Mul(dataGas, params.CreateDataGas)
 		gas.Sub(gas, dataGas)
 		*result = hash2llvm(ref.Address())
diff --git a/core/vm_env.go b/core/vm_env.go
index db29cc32c..7b9a1a0f9 100644
--- a/core/vm_env.go
+++ b/core/vm_env.go
@@ -25,7 +25,7 @@ import (
 	"github.com/ethereum/go-ethereum/core/vm"
 )
 
-// GetHashFn returns a function for which the VM env can query block hashes thru
+// GetHashFn returns a function for which the VM env can query block hashes through
 // up to the limit defined by the Yellow Paper and uses the given block chain
 // to query for information.
 func GetHashFn(ref common.Hash, chain *BlockChain) func(n uint64) common.Hash {