From 097ba56df59293f9225a8ecdc9e1c43a5ad891bb Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 20 Oct 2014 11:53:11 +0200 Subject: Renamed block_chain to chain_manager --- ethchain/block_chain.go | 291 ----------------------------------------- ethchain/block_chain_test.go | 1 - ethchain/block_manager_test.go | 36 ----- ethchain/chain_manager.go | 291 +++++++++++++++++++++++++++++++++++++++++ ethchain/chain_manager_test.go | 1 + ethchain/filter.go | 8 +- ethchain/state_manager.go | 16 +-- ethchain/transaction_pool.go | 2 +- 8 files changed, 305 insertions(+), 341 deletions(-) delete mode 100644 ethchain/block_chain.go delete mode 100644 ethchain/block_chain_test.go delete mode 100644 ethchain/block_manager_test.go create mode 100644 ethchain/chain_manager.go create mode 100644 ethchain/chain_manager_test.go (limited to 'ethchain') diff --git a/ethchain/block_chain.go b/ethchain/block_chain.go deleted file mode 100644 index a5dcec438..000000000 --- a/ethchain/block_chain.go +++ /dev/null @@ -1,291 +0,0 @@ -package ethchain - -import ( - "bytes" - "fmt" - "math/big" - - "github.com/ethereum/eth-go/ethlog" - "github.com/ethereum/eth-go/ethutil" -) - -var chainlogger = ethlog.NewLogger("CHAIN") - -type BlockChain struct { - Ethereum EthManager - // The famous, the fabulous Mister GENESIIIIIIS (block) - genesisBlock *Block - // Last known total difficulty - TD *big.Int - - LastBlockNumber uint64 - - CurrentBlock *Block - LastBlockHash []byte -} - -func NewBlockChain(ethereum EthManager) *BlockChain { - bc := &BlockChain{} - bc.genesisBlock = NewBlockFromBytes(ethutil.Encode(Genesis)) - bc.Ethereum = ethereum - - bc.setLastBlock() - - return bc -} - -func (bc *BlockChain) Genesis() *Block { - return bc.genesisBlock -} - -func (bc *BlockChain) NewBlock(coinbase []byte) *Block { - var root interface{} - hash := ZeroHash256 - - if bc.CurrentBlock != nil { - root = bc.CurrentBlock.state.Trie.Root - hash = bc.LastBlockHash - } - - block := CreateBlock( - root, - hash, - coinbase, - ethutil.BigPow(2, 32), - nil, - "") - - block.MinGasPrice = big.NewInt(10000000000000) - - parent := bc.CurrentBlock - if parent != nil { - block.Difficulty = CalcDifficulty(block, parent) - block.Number = new(big.Int).Add(bc.CurrentBlock.Number, ethutil.Big1) - block.GasLimit = block.CalcGasLimit(bc.CurrentBlock) - - } - - return block -} - -func CalcDifficulty(block, parent *Block) *big.Int { - diff := new(big.Int) - - adjust := new(big.Int).Rsh(parent.Difficulty, 10) - if block.Time >= parent.Time+5 { - diff.Sub(parent.Difficulty, adjust) - } else { - diff.Add(parent.Difficulty, adjust) - } - - return diff -} - -func (bc *BlockChain) Reset() { - AddTestNetFunds(bc.genesisBlock) - - bc.genesisBlock.state.Trie.Sync() - // Prepare the genesis block - bc.Add(bc.genesisBlock) - fk := append([]byte("bloom"), bc.genesisBlock.Hash()...) - bc.Ethereum.Db().Put(fk, make([]byte, 255)) - bc.CurrentBlock = bc.genesisBlock - - bc.SetTotalDifficulty(ethutil.Big("0")) - - // Set the last know difficulty (might be 0x0 as initial value, Genesis) - bc.TD = ethutil.BigD(ethutil.Config.Db.LastKnownTD()) -} - -func (bc *BlockChain) HasBlock(hash []byte) bool { - data, _ := ethutil.Config.Db.Get(hash) - return len(data) != 0 -} - -// TODO: At one point we might want to save a block by prevHash in the db to optimise this... -func (bc *BlockChain) HasBlockWithPrevHash(hash []byte) bool { - block := bc.CurrentBlock - - for ; block != nil; block = bc.GetBlock(block.PrevHash) { - if bytes.Compare(hash, block.PrevHash) == 0 { - return true - } - } - return false -} - -func (bc *BlockChain) CalculateBlockTD(block *Block) *big.Int { - blockDiff := new(big.Int) - - for _, uncle := range block.Uncles { - blockDiff = blockDiff.Add(blockDiff, uncle.Difficulty) - } - blockDiff = blockDiff.Add(blockDiff, block.Difficulty) - - return blockDiff -} - -func (bc *BlockChain) GenesisBlock() *Block { - return bc.genesisBlock -} - -func (self *BlockChain) GetChainHashesFromHash(hash []byte, max uint64) (chain [][]byte) { - block := self.GetBlock(hash) - if block == nil { - return - } - - // XXX Could be optimised by using a different database which only holds hashes (i.e., linked list) - for i := uint64(0); i < max; i++ { - chain = append(chain, block.Hash()) - - if block.Number.Cmp(ethutil.Big0) <= 0 { - break - } - - block = self.GetBlock(block.PrevHash) - } - - return -} - -func AddTestNetFunds(block *Block) { - for _, addr := range []string{ - "51ba59315b3a95761d0863b05ccc7a7f54703d99", - "e4157b34ea9615cfbde6b4fda419828124b70c78", - "b9c015918bdaba24b4ff057a92a3873d6eb201be", - "6c386a4b26f73c802f34673f7248bb118f97424a", - "cd2a3d9f938e13cd947ec05abc7fe734df8dd826", - "2ef47100e0787b915105fd5e3f4ff6752079d5cb", - "e6716f9544a56c530d868e4bfbacb172315bdead", - "1a26338f0d905e295fccb71fa9ea849ffa12aaf4", - } { - codedAddr := ethutil.Hex2Bytes(addr) - account := block.state.GetAccount(codedAddr) - account.Balance = ethutil.Big("1606938044258990275541962092341162602522202993782792835301376") //ethutil.BigPow(2, 200) - block.state.UpdateStateObject(account) - } -} - -func (bc *BlockChain) setLastBlock() { - data, _ := ethutil.Config.Db.Get([]byte("LastBlock")) - if len(data) != 0 { - // Prep genesis - AddTestNetFunds(bc.genesisBlock) - - block := NewBlockFromBytes(data) - bc.CurrentBlock = block - bc.LastBlockHash = block.Hash() - bc.LastBlockNumber = block.Number.Uint64() - - // Set the last know difficulty (might be 0x0 as initial value, Genesis) - bc.TD = ethutil.BigD(ethutil.Config.Db.LastKnownTD()) - } else { - bc.Reset() - } - - chainlogger.Infof("Last block (#%d) %x\n", bc.LastBlockNumber, bc.CurrentBlock.Hash()) -} - -func (bc *BlockChain) SetTotalDifficulty(td *big.Int) { - ethutil.Config.Db.Put([]byte("LTD"), td.Bytes()) - bc.TD = td -} - -// Add a block to the chain and record addition information -func (bc *BlockChain) Add(block *Block) { - bc.writeBlockInfo(block) - // Prepare the genesis block - - bc.CurrentBlock = block - bc.LastBlockHash = block.Hash() - - encodedBlock := block.RlpEncode() - ethutil.Config.Db.Put(block.Hash(), encodedBlock) - ethutil.Config.Db.Put([]byte("LastBlock"), encodedBlock) -} - -func (self *BlockChain) CalcTotalDiff(block *Block) (*big.Int, error) { - parent := self.GetBlock(block.PrevHash) - if parent == nil { - return nil, fmt.Errorf("Unable to calculate total diff without known parent %x", block.PrevHash) - } - - parentTd := parent.BlockInfo().TD - - uncleDiff := new(big.Int) - for _, uncle := range block.Uncles { - uncleDiff = uncleDiff.Add(uncleDiff, uncle.Difficulty) - } - - td := new(big.Int) - td = td.Add(parentTd, uncleDiff) - td = td.Add(td, block.Difficulty) - - return td, nil -} - -func (bc *BlockChain) GetBlock(hash []byte) *Block { - data, _ := ethutil.Config.Db.Get(hash) - if len(data) == 0 { - return nil - } - - return NewBlockFromBytes(data) -} - -func (self *BlockChain) GetBlockByNumber(num uint64) *Block { - block := self.CurrentBlock - for ; block != nil; block = self.GetBlock(block.PrevHash) { - if block.Number.Uint64() == num { - break - } - } - - if block != nil && block.Number.Uint64() == 0 && num != 0 { - return nil - } - - return block -} - -func (self *BlockChain) GetBlockBack(num uint64) *Block { - block := self.CurrentBlock - - for ; num != 0 && block != nil; num-- { - block = self.GetBlock(block.PrevHash) - } - - return block -} - -func (bc *BlockChain) BlockInfoByHash(hash []byte) BlockInfo { - bi := BlockInfo{} - data, _ := ethutil.Config.Db.Get(append(hash, []byte("Info")...)) - bi.RlpDecode(data) - - return bi -} - -func (bc *BlockChain) BlockInfo(block *Block) BlockInfo { - bi := BlockInfo{} - data, _ := ethutil.Config.Db.Get(append(block.Hash(), []byte("Info")...)) - bi.RlpDecode(data) - - return bi -} - -// Unexported method for writing extra non-essential block info to the db -func (bc *BlockChain) writeBlockInfo(block *Block) { - bc.LastBlockNumber++ - bi := BlockInfo{Number: bc.LastBlockNumber, Hash: block.Hash(), Parent: block.PrevHash, TD: bc.TD} - - // For now we use the block hash with the words "info" appended as key - ethutil.Config.Db.Put(append(block.Hash(), []byte("Info")...), bi.RlpEncode()) -} - -func (bc *BlockChain) Stop() { - if bc.CurrentBlock != nil { - chainlogger.Infoln("Stopped") - } -} diff --git a/ethchain/block_chain_test.go b/ethchain/block_chain_test.go deleted file mode 100644 index 3603fd8a7..000000000 --- a/ethchain/block_chain_test.go +++ /dev/null @@ -1 +0,0 @@ -package ethchain diff --git a/ethchain/block_manager_test.go b/ethchain/block_manager_test.go deleted file mode 100644 index 3a1e5f510..000000000 --- a/ethchain/block_manager_test.go +++ /dev/null @@ -1,36 +0,0 @@ -package ethchain - -/* -import ( - _ "fmt" - "github.com/ethereum/eth-go/ethdb" - "github.com/ethereum/eth-go/ethutil" - "math/big" - "testing" -) - -func TestVm(t *testing.T) { - InitFees() - ethutil.ReadConfig("") - - db, _ := ethdb.NewMemDatabase() - ethutil.Config.Db = db - bm := NewStateManager(nil) - - block := bm.bc.genesisBlock - bm.Prepare(block.State(), block.State()) - script := Compile([]string{ - "PUSH", - "1", - "PUSH", - "2", - }) - tx := NewTransaction(ContractAddr, big.NewInt(200000000), script) - addr := tx.Hash()[12:] - bm.ApplyTransactions(block, []*Transaction{tx}) - - tx2 := NewTransaction(addr, big.NewInt(1e17), nil) - tx2.Sign([]byte("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")) - bm.ApplyTransactions(block, []*Transaction{tx2}) -} -*/ diff --git a/ethchain/chain_manager.go b/ethchain/chain_manager.go new file mode 100644 index 000000000..227b02c0a --- /dev/null +++ b/ethchain/chain_manager.go @@ -0,0 +1,291 @@ +package ethchain + +import ( + "bytes" + "fmt" + "math/big" + + "github.com/ethereum/eth-go/ethlog" + "github.com/ethereum/eth-go/ethutil" +) + +var chainlogger = ethlog.NewLogger("CHAIN") + +type ChainManager struct { + Ethereum EthManager + // The famous, the fabulous Mister GENESIIIIIIS (block) + genesisBlock *Block + // Last known total difficulty + TD *big.Int + + LastBlockNumber uint64 + + CurrentBlock *Block + LastBlockHash []byte +} + +func NewChainManager(ethereum EthManager) *ChainManager { + bc := &ChainManager{} + bc.genesisBlock = NewBlockFromBytes(ethutil.Encode(Genesis)) + bc.Ethereum = ethereum + + bc.setLastBlock() + + return bc +} + +func (bc *ChainManager) Genesis() *Block { + return bc.genesisBlock +} + +func (bc *ChainManager) NewBlock(coinbase []byte) *Block { + var root interface{} + hash := ZeroHash256 + + if bc.CurrentBlock != nil { + root = bc.CurrentBlock.state.Trie.Root + hash = bc.LastBlockHash + } + + block := CreateBlock( + root, + hash, + coinbase, + ethutil.BigPow(2, 32), + nil, + "") + + block.MinGasPrice = big.NewInt(10000000000000) + + parent := bc.CurrentBlock + if parent != nil { + block.Difficulty = CalcDifficulty(block, parent) + block.Number = new(big.Int).Add(bc.CurrentBlock.Number, ethutil.Big1) + block.GasLimit = block.CalcGasLimit(bc.CurrentBlock) + + } + + return block +} + +func CalcDifficulty(block, parent *Block) *big.Int { + diff := new(big.Int) + + adjust := new(big.Int).Rsh(parent.Difficulty, 10) + if block.Time >= parent.Time+5 { + diff.Sub(parent.Difficulty, adjust) + } else { + diff.Add(parent.Difficulty, adjust) + } + + return diff +} + +func (bc *ChainManager) Reset() { + AddTestNetFunds(bc.genesisBlock) + + bc.genesisBlock.state.Trie.Sync() + // Prepare the genesis block + bc.Add(bc.genesisBlock) + fk := append([]byte("bloom"), bc.genesisBlock.Hash()...) + bc.Ethereum.Db().Put(fk, make([]byte, 255)) + bc.CurrentBlock = bc.genesisBlock + + bc.SetTotalDifficulty(ethutil.Big("0")) + + // Set the last know difficulty (might be 0x0 as initial value, Genesis) + bc.TD = ethutil.BigD(ethutil.Config.Db.LastKnownTD()) +} + +func (bc *ChainManager) HasBlock(hash []byte) bool { + data, _ := ethutil.Config.Db.Get(hash) + return len(data) != 0 +} + +// TODO: At one point we might want to save a block by prevHash in the db to optimise this... +func (bc *ChainManager) HasBlockWithPrevHash(hash []byte) bool { + block := bc.CurrentBlock + + for ; block != nil; block = bc.GetBlock(block.PrevHash) { + if bytes.Compare(hash, block.PrevHash) == 0 { + return true + } + } + return false +} + +func (bc *ChainManager) CalculateBlockTD(block *Block) *big.Int { + blockDiff := new(big.Int) + + for _, uncle := range block.Uncles { + blockDiff = blockDiff.Add(blockDiff, uncle.Difficulty) + } + blockDiff = blockDiff.Add(blockDiff, block.Difficulty) + + return blockDiff +} + +func (bc *ChainManager) GenesisBlock() *Block { + return bc.genesisBlock +} + +func (self *ChainManager) GetChainHashesFromHash(hash []byte, max uint64) (chain [][]byte) { + block := self.GetBlock(hash) + if block == nil { + return + } + + // XXX Could be optimised by using a different database which only holds hashes (i.e., linked list) + for i := uint64(0); i < max; i++ { + chain = append(chain, block.Hash()) + + if block.Number.Cmp(ethutil.Big0) <= 0 { + break + } + + block = self.GetBlock(block.PrevHash) + } + + return +} + +func AddTestNetFunds(block *Block) { + for _, addr := range []string{ + "51ba59315b3a95761d0863b05ccc7a7f54703d99", + "e4157b34ea9615cfbde6b4fda419828124b70c78", + "b9c015918bdaba24b4ff057a92a3873d6eb201be", + "6c386a4b26f73c802f34673f7248bb118f97424a", + "cd2a3d9f938e13cd947ec05abc7fe734df8dd826", + "2ef47100e0787b915105fd5e3f4ff6752079d5cb", + "e6716f9544a56c530d868e4bfbacb172315bdead", + "1a26338f0d905e295fccb71fa9ea849ffa12aaf4", + } { + codedAddr := ethutil.Hex2Bytes(addr) + account := block.state.GetAccount(codedAddr) + account.Balance = ethutil.Big("1606938044258990275541962092341162602522202993782792835301376") //ethutil.BigPow(2, 200) + block.state.UpdateStateObject(account) + } +} + +func (bc *ChainManager) setLastBlock() { + data, _ := ethutil.Config.Db.Get([]byte("LastBlock")) + if len(data) != 0 { + // Prep genesis + AddTestNetFunds(bc.genesisBlock) + + block := NewBlockFromBytes(data) + bc.CurrentBlock = block + bc.LastBlockHash = block.Hash() + bc.LastBlockNumber = block.Number.Uint64() + + // Set the last know difficulty (might be 0x0 as initial value, Genesis) + bc.TD = ethutil.BigD(ethutil.Config.Db.LastKnownTD()) + } else { + bc.Reset() + } + + chainlogger.Infof("Last block (#%d) %x\n", bc.LastBlockNumber, bc.CurrentBlock.Hash()) +} + +func (bc *ChainManager) SetTotalDifficulty(td *big.Int) { + ethutil.Config.Db.Put([]byte("LTD"), td.Bytes()) + bc.TD = td +} + +// Add a block to the chain and record addition information +func (bc *ChainManager) Add(block *Block) { + bc.writeBlockInfo(block) + // Prepare the genesis block + + bc.CurrentBlock = block + bc.LastBlockHash = block.Hash() + + encodedBlock := block.RlpEncode() + ethutil.Config.Db.Put(block.Hash(), encodedBlock) + ethutil.Config.Db.Put([]byte("LastBlock"), encodedBlock) +} + +func (self *ChainManager) CalcTotalDiff(block *Block) (*big.Int, error) { + parent := self.GetBlock(block.PrevHash) + if parent == nil { + return nil, fmt.Errorf("Unable to calculate total diff without known parent %x", block.PrevHash) + } + + parentTd := parent.BlockInfo().TD + + uncleDiff := new(big.Int) + for _, uncle := range block.Uncles { + uncleDiff = uncleDiff.Add(uncleDiff, uncle.Difficulty) + } + + td := new(big.Int) + td = td.Add(parentTd, uncleDiff) + td = td.Add(td, block.Difficulty) + + return td, nil +} + +func (bc *ChainManager) GetBlock(hash []byte) *Block { + data, _ := ethutil.Config.Db.Get(hash) + if len(data) == 0 { + return nil + } + + return NewBlockFromBytes(data) +} + +func (self *ChainManager) GetBlockByNumber(num uint64) *Block { + block := self.CurrentBlock + for ; block != nil; block = self.GetBlock(block.PrevHash) { + if block.Number.Uint64() == num { + break + } + } + + if block != nil && block.Number.Uint64() == 0 && num != 0 { + return nil + } + + return block +} + +func (self *ChainManager) GetBlockBack(num uint64) *Block { + block := self.CurrentBlock + + for ; num != 0 && block != nil; num-- { + block = self.GetBlock(block.PrevHash) + } + + return block +} + +func (bc *ChainManager) BlockInfoByHash(hash []byte) BlockInfo { + bi := BlockInfo{} + data, _ := ethutil.Config.Db.Get(append(hash, []byte("Info")...)) + bi.RlpDecode(data) + + return bi +} + +func (bc *ChainManager) BlockInfo(block *Block) BlockInfo { + bi := BlockInfo{} + data, _ := ethutil.Config.Db.Get(append(block.Hash(), []byte("Info")...)) + bi.RlpDecode(data) + + return bi +} + +// Unexported method for writing extra non-essential block info to the db +func (bc *ChainManager) writeBlockInfo(block *Block) { + bc.LastBlockNumber++ + bi := BlockInfo{Number: bc.LastBlockNumber, Hash: block.Hash(), Parent: block.PrevHash, TD: bc.TD} + + // For now we use the block hash with the words "info" appended as key + ethutil.Config.Db.Put(append(block.Hash(), []byte("Info")...), bi.RlpEncode()) +} + +func (bc *ChainManager) Stop() { + if bc.CurrentBlock != nil { + chainlogger.Infoln("Stopped") + } +} diff --git a/ethchain/chain_manager_test.go b/ethchain/chain_manager_test.go new file mode 100644 index 000000000..3603fd8a7 --- /dev/null +++ b/ethchain/chain_manager_test.go @@ -0,0 +1 @@ +package ethchain diff --git a/ethchain/filter.go b/ethchain/filter.go index 90f2512ab..4e8df7d5f 100644 --- a/ethchain/filter.go +++ b/ethchain/filter.go @@ -76,16 +76,16 @@ func (self *Filter) SetSkip(skip int) { func (self *Filter) Find() []*ethstate.Message { var earliestBlockNo uint64 = uint64(self.earliest) if self.earliest == -1 { - earliestBlockNo = self.eth.BlockChain().CurrentBlock.Number.Uint64() + earliestBlockNo = self.eth.ChainManager().CurrentBlock.Number.Uint64() } var latestBlockNo uint64 = uint64(self.latest) if self.latest == -1 { - latestBlockNo = self.eth.BlockChain().CurrentBlock.Number.Uint64() + latestBlockNo = self.eth.ChainManager().CurrentBlock.Number.Uint64() } var ( messages []*ethstate.Message - block = self.eth.BlockChain().GetBlockByNumber(latestBlockNo) + block = self.eth.ChainManager().GetBlockByNumber(latestBlockNo) quit bool ) for i := 0; !quit && block != nil; i++ { @@ -111,7 +111,7 @@ func (self *Filter) Find() []*ethstate.Message { messages = append(messages, self.FilterMessages(msgs)...) } - block = self.eth.BlockChain().GetBlock(block.PrevHash) + block = self.eth.ChainManager().GetBlock(block.PrevHash) } skip := int(math.Min(float64(len(messages)), float64(self.skip))) diff --git a/ethchain/state_manager.go b/ethchain/state_manager.go index b71cbe8a1..ed513c9dc 100644 --- a/ethchain/state_manager.go +++ b/ethchain/state_manager.go @@ -33,7 +33,7 @@ type Peer interface { type EthManager interface { StateManager() *StateManager - BlockChain() *BlockChain + ChainManager() *ChainManager TxPool() *TxPool Broadcast(msgType ethwire.MsgType, data []interface{}) PeerCount() int @@ -50,7 +50,7 @@ type StateManager struct { // Mutex for locking the block processor. Blocks can only be handled one at a time mutex sync.Mutex // Canonical block chain - bc *BlockChain + bc *ChainManager // non-persistent key/value memory storage mem map[string]*big.Int // Proof of work used for validating @@ -79,10 +79,10 @@ func NewStateManager(ethereum EthManager) *StateManager { mem: make(map[string]*big.Int), Pow: &EasyPow{}, eth: ethereum, - bc: ethereum.BlockChain(), + bc: ethereum.ChainManager(), } - sm.transState = ethereum.BlockChain().CurrentBlock.State().Copy() - sm.miningState = ethereum.BlockChain().CurrentBlock.State().Copy() + sm.transState = ethereum.ChainManager().CurrentBlock.State().Copy() + sm.miningState = ethereum.ChainManager().CurrentBlock.State().Copy() return sm } @@ -113,7 +113,7 @@ func (self *StateManager) updateThread() { } func (sm *StateManager) CurrentState() *ethstate.State { - return sm.eth.BlockChain().CurrentBlock.State() + return sm.eth.ChainManager().CurrentBlock.State() } func (sm *StateManager) TransState() *ethstate.State { @@ -125,12 +125,12 @@ func (sm *StateManager) MiningState() *ethstate.State { } func (sm *StateManager) NewMiningState() *ethstate.State { - sm.miningState = sm.eth.BlockChain().CurrentBlock.State().Copy() + sm.miningState = sm.eth.ChainManager().CurrentBlock.State().Copy() return sm.miningState } -func (sm *StateManager) BlockChain() *BlockChain { +func (sm *StateManager) ChainManager() *ChainManager { return sm.bc } diff --git a/ethchain/transaction_pool.go b/ethchain/transaction_pool.go index 0676af3a3..ff3184582 100644 --- a/ethchain/transaction_pool.go +++ b/ethchain/transaction_pool.go @@ -96,7 +96,7 @@ func (pool *TxPool) addTransaction(tx *Transaction) { func (pool *TxPool) ValidateTransaction(tx *Transaction) error { // Get the last block so we can retrieve the sender and receiver from // the merkle trie - block := pool.Ethereum.BlockChain().CurrentBlock + block := pool.Ethereum.ChainManager().CurrentBlock // Something has gone horribly wrong if this happens if block == nil { return fmt.Errorf("[TXPL] No last block on the block chain") -- cgit v1.2.3