aboutsummaryrefslogtreecommitdiffstats
path: root/ethereum
diff options
context:
space:
mode:
Diffstat (limited to 'ethereum')
-rw-r--r--ethereum/config.go9
-rw-r--r--ethereum/dev_console.go259
-rw-r--r--ethereum/ethereum.go58
-rw-r--r--ethereum/javascript_runtime.go114
-rw-r--r--ethereum/js_lib.go53
-rw-r--r--ethereum/repl.go97
-rw-r--r--ethereum/repl_darwin.go93
l---------ethereum/repl_linux.go1
-rw-r--r--ethereum/repl_windows.go24
9 files changed, 428 insertions, 280 deletions
diff --git a/ethereum/config.go b/ethereum/config.go
index 7ca1a9801..97e8687d8 100644
--- a/ethereum/config.go
+++ b/ethereum/config.go
@@ -4,7 +4,6 @@ import (
"flag"
)
-var StartConsole bool
var StartMining bool
var StartRpc bool
var RpcPort int
@@ -20,12 +19,12 @@ var ExportKey bool
var LogFile string
var DataDir string
var NonInteractive bool
+var StartJsConsole bool
+var InputFile string
func Init() {
- flag.BoolVar(&StartConsole, "c", false, "debug and testing console")
flag.BoolVar(&StartMining, "m", false, "start dagger mining")
flag.BoolVar(&ShowGenesis, "g", false, "prints genesis header and exits")
- //flag.BoolVar(&UseGui, "gui", true, "use the gui")
flag.BoolVar(&StartRpc, "r", false, "start rpc server")
flag.IntVar(&RpcPort, "rpcport", 8080, "port to start json-rpc server on")
flag.BoolVar(&NonInteractive, "y", false, "non-interactive mode (say yes to confirmations)")
@@ -37,7 +36,9 @@ func Init() {
flag.StringVar(&LogFile, "logfile", "", "log file (defaults to standard output)")
flag.StringVar(&DataDir, "dir", ".ethereum", "ethereum data directory")
flag.StringVar(&ImportKey, "import", "", "imports the given private key (hex)")
- flag.IntVar(&MaxPeer, "x", 5, "maximum desired peers")
+ flag.IntVar(&MaxPeer, "x", 10, "maximum desired peers")
+ flag.BoolVar(&StartJsConsole, "js", false, "exp")
+ flag.StringVar(&InputFile, "e", "", "Run javascript file")
flag.Parse()
}
diff --git a/ethereum/dev_console.go b/ethereum/dev_console.go
deleted file mode 100644
index 5941c03ab..000000000
--- a/ethereum/dev_console.go
+++ /dev/null
@@ -1,259 +0,0 @@
-package main
-
-import (
- "bufio"
- "bytes"
- "encoding/hex"
- "errors"
- "fmt"
- "github.com/ethereum/eth-go"
- "github.com/ethereum/eth-go/ethchain"
- "github.com/ethereum/eth-go/ethdb"
- "github.com/ethereum/eth-go/ethutil"
- "github.com/ethereum/eth-go/ethwire"
- "github.com/ethereum/go-ethereum/utils"
- "github.com/obscuren/mutan"
- "os"
- "strings"
-)
-
-type Console struct {
- db *ethdb.MemDatabase
- trie *ethutil.Trie
- ethereum *eth.Ethereum
-}
-
-func NewConsole(s *eth.Ethereum) *Console {
- db, _ := ethdb.NewMemDatabase()
- trie := ethutil.NewTrie(db, "")
-
- return &Console{db: db, trie: trie, ethereum: s}
-}
-
-func (i *Console) ValidateInput(action string, argumentLength int) error {
- err := false
- var expArgCount int
-
- switch {
- case action == "update" && argumentLength != 2:
- err = true
- expArgCount = 2
- case action == "get" && argumentLength != 1:
- err = true
- expArgCount = 1
- case action == "dag" && argumentLength != 2:
- err = true
- expArgCount = 2
- case action == "decode" && argumentLength != 1:
- err = true
- expArgCount = 1
- case action == "encode" && argumentLength != 1:
- err = true
- expArgCount = 1
- case action == "gettx" && argumentLength != 1:
- err = true
- expArgCount = 1
- case action == "tx" && argumentLength != 4:
- err = true
- expArgCount = 4
- case action == "getaddr" && argumentLength != 1:
- err = true
- expArgCount = 1
- case action == "contract" && argumentLength != 2:
- err = true
- expArgCount = 2
- case action == "say" && argumentLength != 1:
- err = true
- expArgCount = 1
- case action == "addp" && argumentLength != 1:
- err = true
- expArgCount = 1
- case action == "block" && argumentLength != 1:
- err = true
- expArgCount = 1
- }
-
- if err {
- return errors.New(fmt.Sprintf("'%s' requires %d args, got %d", action, expArgCount, argumentLength))
- } else {
- return nil
- }
-}
-
-func (i *Console) Editor() string {
- var buff bytes.Buffer
- for {
- reader := bufio.NewReader(os.Stdin)
- str, _, err := reader.ReadLine()
- if len(str) > 0 {
- buff.Write(str)
- buff.WriteString("\n")
- }
-
- if err != nil && err.Error() == "EOF" {
- break
- }
- }
-
- return buff.String()
-}
-
-func (i *Console) PrintRoot() {
- root := ethutil.NewValue(i.trie.Root)
- if len(root.Bytes()) != 0 {
- fmt.Println(hex.EncodeToString(root.Bytes()))
- } else {
- fmt.Println(i.trie.Root)
- }
-}
-
-func (i *Console) ParseInput(input string) bool {
- scanner := bufio.NewScanner(strings.NewReader(input))
- scanner.Split(bufio.ScanWords)
-
- count := 0
- var tokens []string
- for scanner.Scan() {
- count++
- tokens = append(tokens, scanner.Text())
- }
- if err := scanner.Err(); err != nil {
- fmt.Fprintln(os.Stderr, "reading input:", err)
- }
-
- if len(tokens) == 0 {
- return true
- }
-
- err := i.ValidateInput(tokens[0], count-1)
- if err != nil {
- fmt.Println(err)
- } else {
- switch tokens[0] {
- case "update":
- i.trie.Update(tokens[1], tokens[2])
-
- i.PrintRoot()
- case "get":
- fmt.Println(i.trie.Get(tokens[1]))
- case "root":
- i.PrintRoot()
- case "rawroot":
- fmt.Println(i.trie.Root)
- case "print":
- i.db.Print()
- case "dag":
- fmt.Println(ethchain.DaggerVerify(ethutil.Big(tokens[1]), // hash
- ethutil.BigPow(2, 36), // diff
- ethutil.Big(tokens[2]))) // nonce
- case "decode":
- value := ethutil.NewValueFromBytes([]byte(tokens[1]))
- fmt.Println(value)
- case "getaddr":
- encoded, _ := hex.DecodeString(tokens[1])
- addr := i.ethereum.BlockChain().CurrentBlock.State().GetAccount(encoded)
- fmt.Println("addr:", addr)
- case "block":
- encoded, _ := hex.DecodeString(tokens[1])
- block := i.ethereum.BlockChain().GetBlock(encoded)
- info := block.BlockInfo()
- fmt.Printf("++++++++++ #%d ++++++++++\n%v\n", info.Number, block)
- case "say":
- i.ethereum.Broadcast(ethwire.MsgTalkTy, []interface{}{tokens[1]})
- case "addp":
- i.ethereum.ConnectToPeer(tokens[1])
- case "pcount":
- fmt.Println("peers:", i.ethereum.Peers().Len())
- case "encode":
- fmt.Printf("%q\n", ethutil.Encode(tokens[1]))
- case "tx":
- recipient, err := hex.DecodeString(tokens[1])
- if err != nil {
- fmt.Println("recipient err:", err)
- } else {
- tx := ethchain.NewTransactionMessage(recipient, ethutil.Big(tokens[2]), ethutil.Big(tokens[3]), ethutil.Big(tokens[4]), nil)
-
- keyPair := ethutil.GetKeyRing().Get(0)
- tx.Sign(keyPair.PrivateKey)
- i.ethereum.TxPool().QueueTransaction(tx)
-
- fmt.Printf("%x\n", tx.Hash())
- }
- case "gettx":
- addr, _ := hex.DecodeString(tokens[1])
- data, _ := ethutil.Config.Db.Get(addr)
- if len(data) != 0 {
- decoder := ethutil.NewValueFromBytes(data)
- fmt.Println(decoder)
- } else {
- fmt.Println("gettx: tx not found")
- }
- case "contract":
- fmt.Println("Contract editor (Ctrl-D = done)")
-
- mainInput, initInput := mutan.PreParse(i.Editor())
- mainScript, err := utils.Compile(mainInput)
- if err != nil {
- fmt.Println(err)
-
- break
- }
- initScript, err := utils.Compile(initInput)
- if err != nil {
- fmt.Println(err)
-
- break
- }
-
- contract := ethchain.NewContractCreationTx(ethutil.Big(tokens[0]), ethutil.Big(tokens[1]), ethutil.Big(tokens[1]), mainScript, initScript)
-
- keyPair := ethutil.GetKeyRing().Get(0)
- contract.Sign(keyPair.PrivateKey)
-
- i.ethereum.TxPool().QueueTransaction(contract)
-
- fmt.Printf("%x\n", contract.Hash()[12:])
- case "exit", "quit", "q":
- return false
- case "help":
- fmt.Printf("COMMANDS:\n" +
- "\033[1m= DB =\033[0m\n" +
- "update KEY VALUE - Updates/Creates a new value for the given key\n" +
- "get KEY - Retrieves the given key\n" +
- "root - Prints the hex encoded merkle root\n" +
- "rawroot - Prints the raw merkle root\n" +
- "block HASH - Prints the block\n" +
- "getaddr ADDR - Prints the account associated with the address\n" +
- "\033[1m= Dagger =\033[0m\n" +
- "dag HASH NONCE - Verifies a nonce with the given hash with dagger\n" +
- "\033[1m= Encoding =\033[0m\n" +
- "decode STR\n" +
- "encode STR\n" +
- "\033[1m= Other =\033[0m\n" +
- "addp HOST:PORT\n" +
- "tx TO AMOUNT\n" +
- "contract AMOUNT\n")
-
- default:
- fmt.Println("Unknown command:", tokens[0])
- }
- }
-
- return true
-}
-
-func (i *Console) Start() {
- fmt.Printf("Eth Console. Type (help) for help\n")
- reader := bufio.NewReader(os.Stdin)
- for {
- fmt.Printf("eth >>> ")
- str, _, err := reader.ReadLine()
- if err != nil {
- fmt.Println("Error reading input", err)
- } else {
- if !i.ParseInput(string(str)) {
- return
- }
- }
- }
-}
diff --git a/ethereum/ethereum.go b/ethereum/ethereum.go
index 2abf6da42..2fdfd5caf 100644
--- a/ethereum/ethereum.go
+++ b/ethereum/ethereum.go
@@ -6,6 +6,7 @@ import (
"github.com/ethereum/eth-go/ethchain"
"github.com/ethereum/eth-go/ethutil"
"github.com/ethereum/go-ethereum/utils"
+ "io/ioutil"
"log"
"os"
"os/signal"
@@ -15,16 +16,15 @@ import (
const Debug = true
-// Register interrupt handlers so we can stop the ethereum
-func RegisterInterrupts(s *eth.Ethereum) {
- // Buffered chan of one is enough
- c := make(chan os.Signal, 1)
- // Notify about interrupts for now
- signal.Notify(c, os.Interrupt)
+func RegisterInterrupt(cb func(os.Signal)) {
go func() {
+ // Buffered chan of one is enough
+ c := make(chan os.Signal, 1)
+ // Notify about interrupts for now
+ signal.Notify(c, os.Interrupt)
+
for sig := range c {
- fmt.Printf("Shutting down (%v) ... \n", sig)
- s.Stop()
+ cb(sig)
}
}()
}
@@ -52,7 +52,12 @@ func main() {
var logSys *log.Logger
flags := log.LstdFlags
- ethutil.ReadConfig(DataDir)
+ if StartJsConsole || len(InputFile) > 0 {
+ ethutil.ReadConfig(DataDir, ethutil.LogFile)
+ } else {
+ ethutil.ReadConfig(DataDir, ethutil.LogFile|ethutil.LogStd)
+ }
+
logger := ethutil.Config.Log
if LogFile != "" {
@@ -136,21 +141,40 @@ save these words so you can restore your account later: %s
utils.DoMining(ethereum)
}
- if StartConsole {
- err := os.Mkdir(ethutil.Config.ExecPath, os.ModePerm)
- // Error is OK if the error is ErrExist
- if err != nil && !os.IsExist(err) {
- log.Panic("Unable to create EXECPATH:", err)
+ if StartJsConsole {
+ repl := NewJSRepl(ethereum)
+
+ go repl.Start()
+
+ RegisterInterrupt(func(os.Signal) {
+ repl.Stop()
+ })
+ } else if len(InputFile) > 0 {
+ file, err := os.Open(InputFile)
+ if err != nil {
+ ethutil.Config.Log.Fatal(err)
}
- console := NewConsole(ethereum)
- go console.Start()
+ content, err := ioutil.ReadAll(file)
+ if err != nil {
+ ethutil.Config.Log.Fatal(err)
+ }
+
+ re := NewJSRE(ethereum)
+ RegisterInterrupt(func(os.Signal) {
+ re.Stop()
+ })
+ re.Run(string(content))
}
+
if StartRpc {
utils.DoRpc(ethereum, RpcPort)
}
- RegisterInterrupts(ethereum)
+ RegisterInterrupt(func(sig os.Signal) {
+ fmt.Printf("Shutting down (%v) ... \n", sig)
+ ethereum.Stop()
+ })
ethereum.Start(UseSeed)
diff --git a/ethereum/javascript_runtime.go b/ethereum/javascript_runtime.go
new file mode 100644
index 000000000..b06fb9460
--- /dev/null
+++ b/ethereum/javascript_runtime.go
@@ -0,0 +1,114 @@
+package main
+
+import (
+ "fmt"
+ "github.com/ethereum/eth-go"
+ "github.com/ethereum/eth-go/ethchain"
+ "github.com/ethereum/eth-go/ethpub"
+ "github.com/ethereum/eth-go/ethutil"
+ "github.com/robertkrimen/otto"
+)
+
+type JSRE struct {
+ ethereum *eth.Ethereum
+ vm *otto.Otto
+ lib *ethpub.PEthereum
+
+ blockChan chan ethutil.React
+ changeChan chan ethutil.React
+ quitChan chan bool
+
+ objectCb map[string][]otto.Value
+}
+
+func NewJSRE(ethereum *eth.Ethereum) *JSRE {
+ re := &JSRE{
+ ethereum,
+ otto.New(),
+ ethpub.NewPEthereum(ethereum),
+ make(chan ethutil.React, 1),
+ make(chan ethutil.React, 1),
+ make(chan bool),
+ make(map[string][]otto.Value),
+ }
+
+ // Init the JS lib
+ re.vm.Run(jsLib)
+
+ // We have to make sure that, whoever calls this, calls "Stop"
+ go re.mainLoop()
+
+ re.Bind("eth", &JSEthereum{re.lib, re.vm})
+
+ re.initStdFuncs()
+
+ return re
+}
+
+func (self *JSRE) Bind(name string, v interface{}) {
+ self.vm.Set(name, v)
+}
+
+func (self *JSRE) Run(code string) (otto.Value, error) {
+ return self.vm.Run(code)
+}
+
+func (self *JSRE) Stop() {
+ // Kill the main loop
+ self.quitChan <- true
+
+ close(self.blockChan)
+ close(self.quitChan)
+ close(self.changeChan)
+}
+
+func (self *JSRE) mainLoop() {
+ // Subscribe to events
+ reactor := self.ethereum.Reactor()
+ reactor.Subscribe("newBlock", self.blockChan)
+
+out:
+ for {
+ select {
+ case <-self.quitChan:
+ break out
+ case block := <-self.blockChan:
+ if _, ok := block.Resource.(*ethchain.Block); ok {
+ }
+ case object := <-self.changeChan:
+ if stateObject, ok := object.Resource.(*ethchain.StateObject); ok {
+ for _, cb := range self.objectCb[ethutil.Hex(stateObject.Address())] {
+ val, _ := self.vm.ToValue(ethpub.NewPStateObject(stateObject))
+ cb.Call(cb, val)
+ }
+ } else if storageObject, ok := object.Resource.(*ethchain.StorageState); ok {
+ fmt.Println(storageObject)
+ }
+ }
+ }
+}
+
+func (self *JSRE) initStdFuncs() {
+ t, _ := self.vm.Get("eth")
+ eth := t.Object()
+ eth.Set("watch", func(call otto.FunctionCall) otto.Value {
+ addr, _ := call.Argument(0).ToString()
+ cb := call.Argument(1)
+
+ self.objectCb[addr] = append(self.objectCb[addr], cb)
+
+ event := "object:" + string(ethutil.FromHex(addr))
+ self.ethereum.Reactor().Subscribe(event, self.changeChan)
+
+ return otto.UndefinedValue()
+ })
+ eth.Set("addPeer", func(call otto.FunctionCall) otto.Value {
+ host, err := call.Argument(0).ToString()
+ if err != nil {
+ return otto.FalseValue()
+ }
+ self.ethereum.ConnectToPeer(host)
+
+ return otto.TrueValue()
+ })
+}
diff --git a/ethereum/js_lib.go b/ethereum/js_lib.go
new file mode 100644
index 000000000..189dcc3a0
--- /dev/null
+++ b/ethereum/js_lib.go
@@ -0,0 +1,53 @@
+package main
+
+const jsLib = `
+function pp(object) {
+ var str = "";
+
+ if(object instanceof Array) {
+ str += "[ ";
+ for(var i = 0, l = object.length; i < l; i++) {
+ str += pp(object[i]);
+
+ if(i < l-1) {
+ str += ", ";
+ }
+ }
+ str += " ]";
+ } else if(typeof(object) === "object") {
+ str += "{ ";
+ var last = Object.keys(object).sort().pop()
+ for(var k in object) {
+ str += k + ": " + pp(object[k]);
+
+ if(k !== last) {
+ str += ", ";
+ }
+ }
+ str += " }";
+ } else if(typeof(object) === "string") {
+ str += "\033[32m'" + object + "'";
+ } else if(typeof(object) === "undefined") {
+ str += "\033[1m\033[30m" + object;
+ } else if(typeof(object) === "number") {
+ str += "\033[31m" + object;
+ } else if(typeof(object) === "function") {
+ str += "\033[35m[Function]";
+ } else {
+ str += object;
+ }
+
+ str += "\033[0m";
+
+ return str;
+}
+
+function prettyPrint(/* */) {
+ var args = arguments;
+ for(var i = 0, l = args.length; i < l; i++) {
+ console.log(pp(args[i]))
+ }
+}
+
+var print = prettyPrint;
+`
diff --git a/ethereum/repl.go b/ethereum/repl.go
new file mode 100644
index 000000000..c0b63c0a5
--- /dev/null
+++ b/ethereum/repl.go
@@ -0,0 +1,97 @@
+package main
+
+import (
+ "fmt"
+ "github.com/ethereum/eth-go"
+ "github.com/ethereum/eth-go/ethpub"
+ "github.com/robertkrimen/otto"
+)
+
+type Repl interface {
+ Start()
+ Stop()
+}
+
+type JSRepl struct {
+ re *JSRE
+
+ prompt string
+}
+
+func NewJSRepl(ethereum *eth.Ethereum) *JSRepl {
+ return &JSRepl{re: NewJSRE(ethereum), prompt: "> "}
+}
+
+func (self *JSRepl) Start() {
+ self.read()
+}
+
+func (self *JSRepl) Stop() {
+ self.re.Stop()
+}
+
+func (self *JSRepl) parseInput(code string) {
+ defer func() {
+ if r := recover(); r != nil {
+ fmt.Println("[native] error", r)
+ }
+ }()
+
+ value, err := self.re.Run(code)
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ self.PrintValue(value)
+}
+
+// The JSEthereum object attempts to wrap the PEthereum object and returns
+// meaningful javascript objects
+type JSEthereum struct {
+ *ethpub.PEthereum
+ vm *otto.Otto
+}
+
+func (self *JSEthereum) GetKey() otto.Value {
+ return self.toVal(self.PEthereum.GetKey())
+}
+
+func (self *JSEthereum) GetStateObject(addr string) otto.Value {
+ return self.toVal(self.PEthereum.GetStateObject(addr))
+}
+
+func (self *JSEthereum) Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr string) otto.Value {
+ r, err := self.PEthereum.Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr)
+ if err != nil {
+ fmt.Println(err)
+
+ return otto.UndefinedValue()
+ }
+
+ return self.toVal(r)
+}
+
+func (self *JSEthereum) Create(key, valueStr, gasStr, gasPriceStr, initStr, bodyStr string) otto.Value {
+ r, err := self.PEthereum.Create(key, valueStr, gasStr, gasPriceStr, initStr, bodyStr)
+
+ if err != nil {
+ fmt.Println(err)
+
+ return otto.UndefinedValue()
+ }
+
+ return self.toVal(r)
+}
+
+func (self *JSEthereum) toVal(v interface{}) otto.Value {
+ result, err := self.vm.ToValue(v)
+
+ if err != nil {
+ fmt.Println(err)
+
+ return otto.UndefinedValue()
+ }
+
+ return result
+}
diff --git a/ethereum/repl_darwin.go b/ethereum/repl_darwin.go
new file mode 100644
index 000000000..87da3df1d
--- /dev/null
+++ b/ethereum/repl_darwin.go
@@ -0,0 +1,93 @@
+package main
+
+// #cgo LDFLAGS: -lreadline
+// #include <stdio.h>
+// #include <stdlib.h>
+// #include <readline/readline.h>
+// #include <readline/history.h>
+import "C"
+
+import (
+ "github.com/robertkrimen/otto"
+ "strings"
+ "unsafe"
+)
+
+func readLine(prompt *string) *string {
+ var p *C.char
+
+ //readline allows an empty prompt(NULL)
+ if prompt != nil {
+ p = C.CString(*prompt)
+ }
+
+ ret := C.readline(p)
+
+ if p != nil {
+ C.free(unsafe.Pointer(p))
+ }
+
+ if ret == nil {
+ return nil
+ } //EOF
+
+ s := C.GoString(ret)
+ C.free(unsafe.Pointer(ret))
+ return &s
+}
+
+func addHistory(s string) {
+ p := C.CString(s)
+ C.add_history(p)
+ C.free(unsafe.Pointer(p))
+}
+
+var indentCount = 0
+var str = ""
+
+func (self *JSRepl) setIndent() {
+ open := strings.Count(str, "{")
+ open += strings.Count(str, "(")
+ closed := strings.Count(str, "}")
+ closed += strings.Count(str, ")")
+ indentCount = open - closed
+ if indentCount <= 0 {
+ self.prompt = "> "
+ } else {
+ self.prompt = strings.Join(make([]string, indentCount*2), "..")
+ self.prompt += " "
+ }
+}
+
+func (self *JSRepl) read() {
+L:
+ for {
+ switch result := readLine(&self.prompt); true {
+ case result == nil:
+ break L
+
+ case *result != "":
+ str += *result + "\n"
+
+ self.setIndent()
+
+ if indentCount <= 0 {
+ if *result == "exit" {
+ self.Stop()
+ break L
+ }
+
+ addHistory(str) //allow user to recall this line
+
+ self.parseInput(str)
+
+ str = ""
+ }
+ }
+ }
+}
+
+func (self *JSRepl) PrintValue(value otto.Value) {
+ method, _ := self.re.vm.Get("prettyPrint")
+ method.Call(method, value)
+}
diff --git a/ethereum/repl_linux.go b/ethereum/repl_linux.go
new file mode 120000
index 000000000..276f135d7
--- /dev/null
+++ b/ethereum/repl_linux.go
@@ -0,0 +1 @@
+repl_darwin.go \ No newline at end of file
diff --git a/ethereum/repl_windows.go b/ethereum/repl_windows.go
new file mode 100644
index 000000000..9d4787772
--- /dev/null
+++ b/ethereum/repl_windows.go
@@ -0,0 +1,24 @@
+package main
+
+import (
+ "bufio"
+ "fmt"
+ "os"
+)
+
+func (self *JSRepl) read() {
+ reader := bufio.NewReader(os.Stdin)
+ for {
+ fmt.Printf(self.prompt)
+ str, _, err := reader.ReadLine()
+ if err != nil {
+ fmt.Println("Error reading input", err)
+ } else {
+ self.parseInput(string(str))
+ }
+ }
+}
+
+func (self *JSRepl) PrintValue(value otto.Value) {
+ fmt.Println(value)
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-01-11 11:07:24 +0800