diff options
54 files changed, 821 insertions, 1569 deletions
diff --git a/accounts/abi/abi.go b/accounts/abi/abi.go index 627a2a0c4..3d1010229 100644 --- a/accounts/abi/abi.go +++ b/accounts/abi/abi.go @@ -17,6 +17,7 @@ package abi import ( + "encoding/binary" "encoding/json" "fmt" "io" @@ -129,16 +130,15 @@ func toGoSlice(i int, t Argument, output []byte) (interface{}, error) { var size int var offset int if t.Type.IsSlice { - // get the offset which determines the start of this array ... - offset = int(common.BytesToBig(output[index : index+32]).Uint64()) + offset = int(binary.BigEndian.Uint64(output[index+24 : index+32])) if offset+32 > len(output) { return nil, fmt.Errorf("abi: cannot marshal in to go slice: offset %d would go over slice boundary (len=%d)", len(output), offset+32) } slice = output[offset:] // ... starting with the size of the array in elements ... - size = int(common.BytesToBig(slice[:32]).Uint64()) + size = int(binary.BigEndian.Uint64(slice[24:32])) slice = slice[32:] // ... and make sure that we've at the very least the amount of bytes // available in the buffer. @@ -147,7 +147,7 @@ func toGoSlice(i int, t Argument, output []byte) (interface{}, error) { } // reslice to match the required size - slice = slice[:(size * 32)] + slice = slice[:size*32] } else if t.Type.IsArray { //get the number of elements in the array size = t.Type.SliceSize @@ -165,33 +165,12 @@ func toGoSlice(i int, t Argument, output []byte) (interface{}, error) { inter interface{} // interface type returnOutput = slice[i*32 : i*32+32] // the return output ) - // set inter to the correct type (cast) switch elem.T { case IntTy, UintTy: - bigNum := common.BytesToBig(returnOutput) - switch t.Type.Kind { - case reflect.Uint8: - inter = uint8(bigNum.Uint64()) - case reflect.Uint16: - inter = uint16(bigNum.Uint64()) - case reflect.Uint32: - inter = uint32(bigNum.Uint64()) - case reflect.Uint64: - inter = bigNum.Uint64() - case reflect.Int8: - inter = int8(bigNum.Int64()) - case reflect.Int16: - inter = int16(bigNum.Int64()) - case reflect.Int32: - inter = int32(bigNum.Int64()) - case reflect.Int64: - inter = bigNum.Int64() - default: - inter = common.BytesToBig(returnOutput) - } + inter = readInteger(t.Type.Kind, returnOutput) case BoolTy: - inter = common.BytesToBig(returnOutput).Uint64() > 0 + inter = !allZero(returnOutput) case AddressTy: inter = common.BytesToAddress(returnOutput) case HashTy: @@ -207,6 +186,38 @@ func toGoSlice(i int, t Argument, output []byte) (interface{}, error) { return refSlice.Interface(), nil } +func readInteger(kind reflect.Kind, b []byte) interface{} { + switch kind { + case reflect.Uint8: + return uint8(b[len(b)-1]) + case reflect.Uint16: + return binary.BigEndian.Uint16(b[len(b)-2:]) + case reflect.Uint32: + return binary.BigEndian.Uint32(b[len(b)-4:]) + case reflect.Uint64: + return binary.BigEndian.Uint64(b[len(b)-8:]) + case reflect.Int8: + return int8(b[len(b)-1]) + case reflect.Int16: + return int16(binary.BigEndian.Uint16(b[len(b)-2:])) + case reflect.Int32: + return int32(binary.BigEndian.Uint32(b[len(b)-4:])) + case reflect.Int64: + return int64(binary.BigEndian.Uint64(b[len(b)-8:])) + default: + return new(big.Int).SetBytes(b) + } +} + +func allZero(b []byte) bool { + for _, byte := range b { + if byte != 0 { + return false + } + } + return true +} + // toGoType parses the input and casts it to the proper type defined by the ABI // argument in T. func toGoType(i int, t Argument, output []byte) (interface{}, error) { @@ -226,12 +237,12 @@ func toGoType(i int, t Argument, output []byte) (interface{}, error) { switch t.Type.T { case StringTy, BytesTy: // variable arrays are written at the end of the return bytes // parse offset from which we should start reading - offset := int(common.BytesToBig(output[index : index+32]).Uint64()) + offset := int(binary.BigEndian.Uint64(output[index+24 : index+32])) if offset+32 > len(output) { return nil, fmt.Errorf("abi: cannot marshal in to go type: length insufficient %d require %d", len(output), offset+32) } // parse the size up until we should be reading - size := int(common.BytesToBig(output[offset : offset+32]).Uint64()) + size := int(binary.BigEndian.Uint64(output[offset+24 : offset+32])) if offset+32+size > len(output) { return nil, fmt.Errorf("abi: cannot marshal in to go type: length insufficient %d require %d", len(output), offset+32+size) } @@ -245,32 +256,9 @@ func toGoType(i int, t Argument, output []byte) (interface{}, error) { // convert the bytes to whatever is specified by the ABI. switch t.Type.T { case IntTy, UintTy: - bigNum := common.BytesToBig(returnOutput) - - // If the type is a integer convert to the integer type - // specified by the ABI. - switch t.Type.Kind { - case reflect.Uint8: - return uint8(bigNum.Uint64()), nil - case reflect.Uint16: - return uint16(bigNum.Uint64()), nil - case reflect.Uint32: - return uint32(bigNum.Uint64()), nil - case reflect.Uint64: - return uint64(bigNum.Uint64()), nil - case reflect.Int8: - return int8(bigNum.Int64()), nil - case reflect.Int16: - return int16(bigNum.Int64()), nil - case reflect.Int32: - return int32(bigNum.Int64()), nil - case reflect.Int64: - return int64(bigNum.Int64()), nil - case reflect.Ptr: - return bigNum, nil - } + return readInteger(t.Type.Kind, returnOutput), nil case BoolTy: - return common.BytesToBig(returnOutput).Uint64() > 0, nil + return !allZero(returnOutput), nil case AddressTy: return common.BytesToAddress(returnOutput), nil case HashTy: diff --git a/accounts/abi/bind/backends/simulated.go b/accounts/abi/bind/backends/simulated.go index 1c34ba0e7..5e2fcbae7 100644 --- a/accounts/abi/bind/backends/simulated.go +++ b/accounts/abi/bind/backends/simulated.go @@ -25,6 +25,7 @@ import ( "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" @@ -244,7 +245,7 @@ func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallM } // Set infinite balance to the fake caller account. from := statedb.GetOrNewStateObject(call.From) - from.SetBalance(common.MaxBig) + from.SetBalance(math.MaxBig256) // Execute the call. msg := callmsg{call} @@ -252,7 +253,7 @@ func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallM // Create a new environment which holds all relevant information // about the transaction and calling mechanisms. vmenv := vm.NewEVM(evmContext, statedb, chainConfig, vm.Config{}) - gaspool := new(core.GasPool).AddGas(common.MaxBig) + gaspool := new(core.GasPool).AddGas(math.MaxBig256) ret, gasUsed, _, err := core.NewStateTransition(vmenv, msg, gaspool).TransitionDb() return ret, gasUsed, err } diff --git a/accounts/abi/numbers.go b/accounts/abi/numbers.go index 3d5842292..36fb6705e 100644 --- a/accounts/abi/numbers.go +++ b/accounts/abi/numbers.go @@ -21,6 +21,7 @@ import ( "reflect" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" ) var ( @@ -58,7 +59,7 @@ var ( // U256 converts a big Int into a 256bit EVM number. func U256(n *big.Int) []byte { - return common.LeftPadBytes(common.U256(n).Bytes(), 32) + return common.LeftPadBytes(math.U256(n).Bytes(), 32) } // packNum packs the given number (using the reflect value) and will cast it to appropriate number representation diff --git a/cmd/evm/main.go b/cmd/evm/main.go index 86e2493ca..a489efbfc 100644 --- a/cmd/evm/main.go +++ b/cmd/evm/main.go @@ -20,6 +20,7 @@ package main import ( "fmt" "io/ioutil" + "math/big" "os" goruntime "runtime" "time" @@ -51,20 +52,20 @@ var ( Name: "codefile", Usage: "file containing EVM code", } - GasFlag = cli.StringFlag{ + GasFlag = cli.Uint64Flag{ Name: "gas", Usage: "gas limit for the evm", - Value: "10000000000", + Value: 10000000000, } - PriceFlag = cli.StringFlag{ + PriceFlag = utils.BigFlag{ Name: "price", Usage: "price set for the evm", - Value: "0", + Value: new(big.Int), } - ValueFlag = cli.StringFlag{ + ValueFlag = utils.BigFlag{ Name: "value", Usage: "value set for the evm", - Value: "0", + Value: new(big.Int), } DumpFlag = cli.BoolFlag{ Name: "dump", @@ -160,9 +161,9 @@ func run(ctx *cli.Context) error { ret, _, err = runtime.Create(input, &runtime.Config{ Origin: sender.Address(), State: statedb, - GasLimit: common.Big(ctx.GlobalString(GasFlag.Name)).Uint64(), - GasPrice: common.Big(ctx.GlobalString(PriceFlag.Name)), - Value: common.Big(ctx.GlobalString(ValueFlag.Name)), + GasLimit: ctx.GlobalUint64(GasFlag.Name), + GasPrice: utils.GlobalBig(ctx, PriceFlag.Name), + Value: utils.GlobalBig(ctx, ValueFlag.Name), EVMConfig: vm.Config{ Tracer: logger, Debug: ctx.GlobalBool(DebugFlag.Name), @@ -177,9 +178,9 @@ func run(ctx *cli.Context) error { ret, err = runtime.Call(receiverAddress, common.Hex2Bytes(ctx.GlobalString(InputFlag.Name)), &runtime.Config{ Origin: sender.Address(), State: statedb, - GasLimit: common.Big(ctx.GlobalString(GasFlag.Name)).Uint64(), - GasPrice: common.Big(ctx.GlobalString(PriceFlag.Name)), - Value: common.Big(ctx.GlobalString(ValueFlag.Name)), + GasLimit: ctx.GlobalUint64(GasFlag.Name), + GasPrice: utils.GlobalBig(ctx, PriceFlag.Name), + Value: utils.GlobalBig(ctx, ValueFlag.Name), EVMConfig: vm.Config{ Tracer: logger, Debug: ctx.GlobalBool(DebugFlag.Name), diff --git a/cmd/utils/cmd.go b/cmd/utils/cmd.go index 062b9c50d..843cb5b4e 100644 --- a/cmd/utils/cmd.go +++ b/cmd/utils/cmd.go @@ -23,11 +23,9 @@ import ( "io" "os" "os/signal" - "regexp" "runtime" "strings" - "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/internal/debug" @@ -82,19 +80,6 @@ func StartNode(stack *node.Node) { }() } -func FormatTransactionData(data string) []byte { - d := common.StringToByteFunc(data, func(s string) (ret []byte) { - slice := regexp.MustCompile(`\n|\s`).Split(s, 1000000000) - for _, dataItem := range slice { - d := common.FormatData(dataItem) - ret = append(ret, d...) - } - return - }) - - return d -} - func ImportChain(chain *core.BlockChain, fn string) error { // Watch for Ctrl-C while the import is running. // If a signal is received, the import will stop at the next batch. diff --git a/cmd/utils/customflags.go b/cmd/utils/customflags.go index 52cd7b8c7..00f28f2ec 100644 --- a/cmd/utils/customflags.go +++ b/cmd/utils/customflags.go @@ -17,12 +17,17 @@ package utils import ( + "errors" "flag" "fmt" + "math/big" "os" "os/user" "path" "strings" + + "github.com/ethereum/go-ethereum/common/math" + "gopkg.in/urfave/cli.v1" ) // Custom type which is registered in the flags library which cli uses for @@ -44,10 +49,9 @@ func (self *DirectoryString) Set(value string) error { // Custom cli.Flag type which expand the received string to an absolute path. // e.g. ~/.ethereum -> /home/username/.ethereum type DirectoryFlag struct { - Name string - Value DirectoryString - Usage string - EnvVar string + Name string + Value DirectoryString + Usage string } func (self DirectoryFlag) String() string { @@ -55,7 +59,7 @@ func (self DirectoryFlag) String() string { if len(self.Value.Value) > 0 { fmtString = "%s \"%v\"\t%v" } - return withEnvHint(self.EnvVar, fmt.Sprintf(fmtString, prefixedNames(self.Name), self.Value.Value, self.Usage)) + return fmt.Sprintf(fmtString, prefixedNames(self.Name), self.Value.Value, self.Usage) } func eachName(longName string, fn func(string)) { @@ -69,21 +73,65 @@ func eachName(longName string, fn func(string)) { // called by cli library, grabs variable from environment (if in env) // and adds variable to flag set for parsing. func (self DirectoryFlag) Apply(set *flag.FlagSet) { - if self.EnvVar != "" { - for _, envVar := range strings.Split(self.EnvVar, ",") { - envVar = strings.TrimSpace(envVar) - if envVal := os.Getenv(envVar); envVal != "" { - self.Value.Value = envVal - break - } - } - } - eachName(self.Name, func(name string) { set.Var(&self.Value, self.Name, self.Usage) }) } +// BigFlag is a command line flag that accepts 256 bit big integers in decimal or +// hexadecimal syntax. +type BigFlag struct { + Name string + Value *big.Int + Usage string +} + +// bigValue turns *big.Int into a flag.Value +type bigValue big.Int + +func (b *bigValue) String() string { + if b == nil { + return "" + } + return (*big.Int)(b).String() +} + +func (b *bigValue) Set(s string) error { + int, ok := math.ParseBig256(s) + if !ok { + return errors.New("invalid integer syntax") + } + *b = (bigValue)(*int) + return nil +} + +func (f BigFlag) GetName() string { + return f.Name +} + +func (f BigFlag) String() string { + fmtString := "%s %v\t%v" + if f.Value != nil { + fmtString = "%s \"%v\"\t%v" + } + return fmt.Sprintf(fmtString, prefixedNames(f.Name), f.Value, f.Usage) +} + +func (f BigFlag) Apply(set *flag.FlagSet) { + eachName(f.Name, func(name string) { + set.Var((*bigValue)(f.Value), f.Name, f.Usage) + }) +} + +// GlobalBig returns the value of a BigFlag from the global flag set. +func GlobalBig(ctx *cli.Context, name string) *big.Int { + val := ctx.GlobalGeneric(name) + if val == nil { + return nil + } + return (*big.Int)(val.(*bigValue)) +} + func prefixFor(name string) (prefix string) { if len(name) == 1 { prefix = "-" @@ -106,14 +154,6 @@ func prefixedNames(fullName string) (prefixed string) { return } -func withEnvHint(envVar, str string) string { - envText := "" - if envVar != "" { - envText = fmt.Sprintf(" [$%s]", strings.Join(strings.Split(envVar, ","), ", $")) - } - return str + envText -} - func (self DirectoryFlag) GetName() string { return self.Name } diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go index a2e4ac814..25c3a1ada 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -179,10 +179,10 @@ var ( Usage: "Number of CPU threads to use for mining", Value: runtime.NumCPU(), } - TargetGasLimitFlag = cli.StringFlag{ + TargetGasLimitFlag = cli.Uint64Flag{ Name: "targetgaslimit", Usage: "Target gas limit sets the artificial target gas floor for the blocks to mine", - Value: params.GenesisGasLimit.String(), + Value: params.GenesisGasLimit.Uint64(), } AutoDAGFlag = cli.BoolFlag{ Name: "autodag", @@ -193,10 +193,10 @@ var ( Usage: "Public address for block mining rewards (default = first account created)", Value: "0", } - GasPriceFlag = cli.StringFlag{ + GasPriceFlag = BigFlag{ Name: "gasprice", Usage: "Minimal gas price to accept for mining a transactions", - Value: new(big.Int).Mul(big.NewInt(20), common.Shannon).String(), + Value: big.NewInt(20 * params.Shannon), } ExtraDataFlag = cli.StringFlag{ Name: "extradata", @@ -382,15 +382,15 @@ var ( } // Gas price oracle settings - GpoMinGasPriceFlag = cli.StringFlag{ + GpoMinGasPriceFlag = BigFlag{ Name: "gpomin", Usage: "Minimum suggested gas price", - Value: new(big.Int).Mul(big.NewInt(20), common.Shannon).String(), + Value: big.NewInt(20 * params.Shannon), } - GpoMaxGasPriceFlag = cli.StringFlag{ + GpoMaxGasPriceFlag = BigFlag{ Name: "gpomax", Usage: "Maximum suggested gas price", - Value: new(big.Int).Mul(big.NewInt(500), common.Shannon).String(), + Value: big.NewInt(500 * params.Shannon), } GpoFullBlockRatioFlag = cli.IntFlag{ Name: "gpofull", @@ -741,9 +741,9 @@ func RegisterEthService(ctx *cli.Context, stack *node.Node, extra []byte) { MinerThreads: ctx.GlobalInt(MinerThreadsFlag.Name), ExtraData: MakeMinerExtra(extra, ctx), DocRoot: ctx.GlobalString(DocRootFlag.Name), - GasPrice: common.String2Big(ctx.GlobalString(GasPriceFlag.Name)), - GpoMinGasPrice: common.String2Big(ctx.GlobalString(GpoMinGasPriceFlag.Name)), - GpoMaxGasPrice: common.String2Big(ctx.GlobalString(GpoMaxGasPriceFlag.Name)), + GasPrice: GlobalBig(ctx, GasPriceFlag.Name), + GpoMinGasPrice: GlobalBig(ctx, GpoMinGasPriceFlag.Name), + GpoMaxGasPrice: GlobalBig(ctx, GpoMaxGasPriceFlag.Name), GpoFullBlockRatio: ctx.GlobalInt(GpoFullBlockRatioFlag.Name), GpobaseStepDown: ctx.GlobalInt(GpobaseStepDownFlag.Name), GpobaseStepUp: ctx.GlobalInt(GpobaseStepUpFlag.Name), @@ -819,7 +819,7 @@ func RegisterEthStatsService(stack *node.Node, url string) { // SetupNetwork configures the system for either the main net or some test network. func SetupNetwork(ctx *cli.Context) { - params.TargetGasLimit = common.String2Big(ctx.GlobalString(TargetGasLimitFlag.Name)) + params.TargetGasLimit = new(big.Int).SetUint64(ctx.GlobalUint64(TargetGasLimitFlag.Name)) } // MakeChainConfig reads the chain configuration from the database in ctx.Datadir. diff --git a/common/.gitignore b/common/.gitignore deleted file mode 100644 index f725d58d1..000000000 --- a/common/.gitignore +++ /dev/null @@ -1,12 +0,0 @@ -# See http://help.github.com/ignore-files/ for more about ignoring files. -# -# If you find yourself ignoring temporary files generated by your text editor -# or operating system, you probably want to add a global ignore instead: -# git config --global core.excludesfile ~/.gitignore_global - -/tmp -*/**/*un~ -*un~ -.DS_Store -*/**/.DS_Store - diff --git a/common/.travis.yml b/common/.travis.yml deleted file mode 100644 index 69359072d..000000000 --- a/common/.travis.yml +++ /dev/null @@ -1,3 +0,0 @@ -language: go -go: - - 1.2 diff --git a/common/README.md b/common/README.md deleted file mode 100644 index adea022b7..000000000 --- a/common/README.md +++ /dev/null @@ -1,140 +0,0 @@ -# common - -[](https://travis-ci.org/ethereum/go-ethereum) - -The common package contains the ethereum utility library. - -# Installation - -As a subdirectory the main go-ethereum repository, you get it with -`go get github.com/ethereum/go-ethereum`. - -# Usage - -## RLP (Recursive Linear Prefix) Encoding - -RLP Encoding is an encoding scheme used by the Ethereum project. It -encodes any native value or list to a string. - -More in depth information about the encoding scheme see the -[Wiki](http://wiki.ethereum.org/index.php/RLP) article. - -```go -rlp := common.Encode("doge") -fmt.Printf("%q\n", rlp) // => "\0x83dog" - -rlp = common.Encode([]interface{}{"dog", "cat"}) -fmt.Printf("%q\n", rlp) // => "\0xc8\0x83dog\0x83cat" -decoded := common.Decode(rlp) -fmt.Println(decoded) // => ["dog" "cat"] -``` - -## Patricia Trie - -Patricie Tree is a merkle trie used by the Ethereum project. - -More in depth information about the (modified) Patricia Trie can be -found on the [Wiki](http://wiki.ethereum.org/index.php/Patricia_Tree). - -The patricia trie uses a db as backend and could be anything as long as -it satisfies the Database interface found in `common/db.go`. - -```go -db := NewDatabase() - -// db, root -trie := common.NewTrie(db, "") - -trie.Put("puppy", "dog") -trie.Put("horse", "stallion") -trie.Put("do", "verb") -trie.Put("doge", "coin") - -// Look up the key "do" in the trie -out := trie.Get("do") -fmt.Println(out) // => verb - -trie.Delete("puppy") -``` - -The patricia trie, in combination with RLP, provides a robust, -cryptographically authenticated data structure that can be used to store -all (key, value) bindings. - -```go -// ... Create db/trie - -// Note that RLP uses interface slices as list -value := common.Encode([]interface{}{"one", 2, "three", []interface{}{42}}) -// Store the RLP encoded value of the list -trie.Put("mykey", value) -``` - -## Value - -Value is a Generic Value which is used in combination with RLP data or -`([])interface{}` structures. It may serve as a bridge between RLP data -and actual real values and takes care of all the type checking and -casting. Unlike Go's `reflect.Value` it does not panic if it's unable to -cast to the requested value. It simple returns the base value of that -type (e.g. `Slice()` returns []interface{}, `Uint()` return 0, etc). - -### Creating a new Value - -`NewEmptyValue()` returns a new \*Value with it's initial value set to a -`[]interface{}` - -`AppendList()` appends a list to the current value. - -`Append(v)` appends the value (v) to the current value/list. - -```go -val := common.NewEmptyValue().Append(1).Append("2") -val.AppendList().Append(3) -``` - -### Retrieving values - -`Get(i)` returns the `i` item in the list. - -`Uint()` returns the value as an unsigned int64. - -`Slice()` returns the value as a interface slice. - -`Str()` returns the value as a string. - -`Bytes()` returns the value as a byte slice. - -`Len()` assumes current to be a slice and returns its length. - -`Byte()` returns the value as a single byte. - -```go -val := common.NewValue([]interface{}{1,"2",[]interface{}{3}}) -val.Get(0).Uint() // => 1 -val.Get(1).Str() // => "2" -s := val.Get(2) // => Value([]interface{}{3}) -s.Get(0).Uint() // => 3 -``` - -## Decoding - -Decoding streams of RLP data is simplified - -```go -val := common.NewValueFromBytes(rlpData) -val.Get(0).Uint() -``` - -## Encoding - -Encoding from Value to RLP is done with the `Encode` method. The -underlying value can be anything RLP can encode (int, str, lists, bytes) - -```go -val := common.NewValue([]interface{}{1,"2",[]interface{}{3}}) -rlp := val.Encode() -// Store the rlp data -Store(rlp) -``` diff --git a/common/big.go b/common/big.go index 4ce87ee0c..b552608bc 100644 --- a/common/big.go +++ b/common/big.go @@ -20,137 +20,11 @@ import "math/big" // Common big integers often used var ( - Big1 = big.NewInt(1) - Big2 = big.NewInt(2) - Big3 = big.NewInt(3) - Big0 = big.NewInt(0) - BigTrue = Big1 - BigFalse = Big0 - Big32 = big.NewInt(32) - Big36 = big.NewInt(36) - Big97 = big.NewInt(97) - Big98 = big.NewInt(98) - Big256 = big.NewInt(0xff) - Big257 = big.NewInt(257) - MaxBig = String2Big("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff") + Big1 = big.NewInt(1) + Big2 = big.NewInt(2) + Big3 = big.NewInt(3) + Big0 = big.NewInt(0) + Big32 = big.NewInt(32) + Big256 = big.NewInt(0xff) + Big257 = big.NewInt(257) ) - -// Big pow -// -// Returns the power of two big integers -func BigPow(a, b int) *big.Int { - c := new(big.Int) - c.Exp(big.NewInt(int64(a)), big.NewInt(int64(b)), big.NewInt(0)) - - return c -} - -// Big -// -// Shortcut for new(big.Int).SetString(..., 0) -func Big(num string) *big.Int { - n := new(big.Int) - n.SetString(num, 0) - - return n -} - -// Bytes2Big -// -func BytesToBig(data []byte) *big.Int { - n := new(big.Int) - n.SetBytes(data) - - return n -} -func Bytes2Big(data []byte) *big.Int { return BytesToBig(data) } -func BigD(data []byte) *big.Int { return BytesToBig(data) } - -func String2Big(num string) *big.Int { - n := new(big.Int) - n.SetString(num, 0) - return n -} - -func BitTest(num *big.Int, i int) bool { - return num.Bit(i) > 0 -} - -// To256 -// -// "cast" the big int to a 256 big int (i.e., limit to) -var tt256 = new(big.Int).Lsh(big.NewInt(1), 256) -var tt256m1 = new(big.Int).Sub(new(big.Int).Lsh(big.NewInt(1), 256), big.NewInt(1)) -var tt255 = new(big.Int).Lsh(big.NewInt(1), 255) - -func U256(x *big.Int) *big.Int { - //if x.Cmp(Big0) < 0 { - // return new(big.Int).Add(tt256, x) - // } - - x.And(x, tt256m1) - - return x -} - -func S256(x *big.Int) *big.Int { - if x.Cmp(tt255) < 0 { - return x - } else { - // We don't want to modify x, ever - return new(big.Int).Sub(x, tt256) - } -} - -func FirstBitSet(v *big.Int) int { - for i := 0; i < v.BitLen(); i++ { - if v.Bit(i) > 0 { - return i - } - } - - return v.BitLen() -} - -// Big to bytes -// -// Returns the bytes of a big integer with the size specified by **base** -// Attempts to pad the byte array with zeros. -func BigToBytes(num *big.Int, base int) []byte { - ret := make([]byte, base/8) - - if len(num.Bytes()) > base/8 { - return num.Bytes() - } - - return append(ret[:len(ret)-len(num.Bytes())], num.Bytes()...) -} - -// Big copy -// -// Creates a copy of the given big integer -func BigCopy(src *big.Int) *big.Int { - return new(big.Int).Set(src) -} - -// Big max -// -// Returns the maximum size big integer -func BigMax(x, y *big.Int) *big.Int { - if x.Cmp(y) < 0 { - return y - } - - return x -} - -// Big min -// -// Returns the minimum size big integer -func BigMin(x, y *big.Int) *big.Int { - if x.Cmp(y) > 0 { - return y - } - - return x -} diff --git a/common/big_test.go b/common/big_test.go deleted file mode 100644 index 4d04a8db3..000000000 --- a/common/big_test.go +++ /dev/null @@ -1,89 +0,0 @@ -// Copyright 2014 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. - -package common - -import ( - "bytes" - "testing" -) - -func TestMisc(t *testing.T) { - a := Big("10") - b := Big("57896044618658097711785492504343953926634992332820282019728792003956564819968") - c := []byte{1, 2, 3, 4} - z := BitTest(a, 1) - - if !z { - t.Error("Expected true got", z) - } - - U256(a) - S256(a) - - U256(b) - S256(b) - - BigD(c) -} - -func TestBigMax(t *testing.T) { - a := Big("10") - b := Big("5") - - max1 := BigMax(a, b) - if max1 != a { - t.Errorf("Expected %d got %d", a, max1) - } - - max2 := BigMax(b, a) - if max2 != a { - t.Errorf("Expected %d got %d", a, max2) - } -} - -func TestBigMin(t *testing.T) { - a := Big("10") - b := Big("5") - - min1 := BigMin(a, b) - if min1 != b { - t.Errorf("Expected %d got %d", b, min1) - } - - min2 := BigMin(b, a) - if min2 != b { - t.Errorf("Expected %d got %d", b, min2) - } -} - -func TestBigCopy(t *testing.T) { - a := Big("10") - b := BigCopy(a) - c := Big("1000000000000") - y := BigToBytes(b, 16) - ybytes := []byte{0, 10} - z := BigToBytes(c, 16) - zbytes := []byte{232, 212, 165, 16, 0} - - if !bytes.Equal(y, ybytes) { - t.Error("Got", ybytes) - } - - if !bytes.Equal(z, zbytes) { - t.Error("Got", zbytes) - } -} diff --git a/common/bytes.go b/common/bytes.go index cbceea8b5..0342083a1 100644 --- a/common/bytes.go +++ b/common/bytes.go @@ -18,12 +18,7 @@ package common import ( - "bytes" - "encoding/binary" "encoding/hex" - "fmt" - "math/big" - "strings" ) func ToHex(b []byte) string { @@ -48,65 +43,6 @@ func FromHex(s string) []byte { return nil } -// Number to bytes -// -// Returns the number in bytes with the specified base -func NumberToBytes(num interface{}, bits int) []byte { - buf := new(bytes.Buffer) - err := binary.Write(buf, binary.BigEndian, num) - if err != nil { - fmt.Println("NumberToBytes failed:", err) - } - - return buf.Bytes()[buf.Len()-(bits/8):] -} - -// Bytes to number -// -// Attempts to cast a byte slice to a unsigned integer -func BytesToNumber(b []byte) uint64 { - var number uint64 - - // Make sure the buffer is 64bits - data := make([]byte, 8) - data = append(data[:len(b)], b...) - - buf := bytes.NewReader(data) - err := binary.Read(buf, binary.BigEndian, &number) - if err != nil { - fmt.Println("BytesToNumber failed:", err) - } - - return number -} - -// Read variable int -// -// Read a variable length number in big endian byte order -func ReadVarInt(buff []byte) (ret uint64) { - switch l := len(buff); { - case l > 4: - d := LeftPadBytes(buff, 8) - binary.Read(bytes.NewReader(d), binary.BigEndian, &ret) - case l > 2: - var num uint32 - d := LeftPadBytes(buff, 4) - binary.Read(bytes.NewReader(d), binary.BigEndian, &num) - ret = uint64(num) - case l > 1: - var num uint16 - d := LeftPadBytes(buff, 2) - binary.Read(bytes.NewReader(d), binary.BigEndian, &num) - ret = uint64(num) - default: - var num uint8 - binary.Read(bytes.NewReader(buff), binary.BigEndian, &num) - ret = uint64(num) - } - - return -} - // Copy bytes // // Returns an exact copy of the provided bytes @@ -152,53 +88,6 @@ func Hex2BytesFixed(str string, flen int) []byte { } } -func StringToByteFunc(str string, cb func(str string) []byte) (ret []byte) { - if len(str) > 1 && str[0:2] == "0x" && !strings.Contains(str, "\n") { - ret = Hex2Bytes(str[2:]) - } else { - ret = cb(str) - } - - return -} - -func FormatData(data string) []byte { - if len(data) == 0 { - return nil - } - // Simple stupid - d := new(big.Int) - if data[0:1] == "\"" && data[len(data)-1:] == "\"" { - return RightPadBytes([]byte(data[1:len(data)-1]), 32) - } else if len(data) > 1 && data[:2] == "0x" { - d.SetBytes(Hex2Bytes(data[2:])) - } else { - d.SetString(data, 0) - } - - return BigToBytes(d, 256) -} - -func ParseData(data ...interface{}) (ret []byte) { - for _, item := range data { - switch t := item.(type) { - case string: - var str []byte - if IsHex(t) { - str = Hex2Bytes(t[2:]) - } else { - str = []byte(t) - } - - ret = append(ret, RightPadBytes(str, 32)...) - case []byte: - ret = append(ret, LeftPadBytes(t, 32)...) - } - } - - return -} - func RightPadBytes(slice []byte, l int) []byte { if l < len(slice) { return slice @@ -220,47 +109,3 @@ func LeftPadBytes(slice []byte, l int) []byte { return padded } - -func LeftPadString(str string, l int) string { - if l < len(str) { - return str - } - - zeros := Bytes2Hex(make([]byte, (l-len(str))/2)) - - return zeros + str - -} - -func RightPadString(str string, l int) string { - if l < len(str) { - return str - } - - zeros := Bytes2Hex(make([]byte, (l-len(str))/2)) - - return str + zeros - -} - -func ToAddress(slice []byte) (addr []byte) { - if len(slice) < 20 { - addr = LeftPadBytes(slice, 20) - } else if len(slice) > 20 { - addr = slice[len(slice)-20:] - } else { - addr = slice - } - - addr = CopyBytes(addr) - - return -} - -func ByteSliceToInterface(slice [][]byte) (ret []interface{}) { - for _, i := range slice { - ret = append(ret, i) - } - - return -} diff --git a/common/bytes_test.go b/common/bytes_test.go index 98d402c48..fc164b13d 100644 --- a/common/bytes_test.go +++ b/common/bytes_test.go @@ -27,54 +27,6 @@ type BytesSuite struct{} var _ = checker.Suite(&BytesSuite{}) -func (s *BytesSuite) TestNumberToBytes(c *checker.C) { - // data1 := int(1) - // res1 := NumberToBytes(data1, 16) - // c.Check(res1, checker.Panics) - - var data2 float64 = 3.141592653 - exp2 := []byte{0xe9, 0x38} - res2 := NumberToBytes(data2, 16) - c.Assert(res2, checker.DeepEquals, exp2) -} - -func (s *BytesSuite) TestBytesToNumber(c *checker.C) { - datasmall := []byte{0xe9, 0x38, 0xe9, 0x38} - datalarge := []byte{0xe9, 0x38, 0xe9, 0x38, 0xe9, 0x38, 0xe9, 0x38} - - var expsmall uint64 = 0xe938e938 - var explarge uint64 = 0x0 - - ressmall := BytesToNumber(datasmall) - reslarge := BytesToNumber(datalarge) - - c.Assert(ressmall, checker.Equals, expsmall) - c.Assert(reslarge, checker.Equals, explarge) - -} - -func (s *BytesSuite) TestReadVarInt(c *checker.C) { - data8 := []byte{1, 2, 3, 4, 5, 6, 7, 8} - data4 := []byte{1, 2, 3, 4} - data2 := []byte{1, 2} - data1 := []byte{1} - - exp8 := uint64(72623859790382856) - exp4 := uint64(16909060) - exp2 := uint64(258) - exp1 := uint64(1) - - res8 := ReadVarInt(data8) - res4 := ReadVarInt(data4) - res2 := ReadVarInt(data2) - res1 := ReadVarInt(data1) - - c.Assert(res8, checker.Equals, exp8) - c.Assert(res4, checker.Equals, exp4) - c.Assert(res2, checker.Equals, exp2) - c.Assert(res1, checker.Equals, exp1) -} - func (s *BytesSuite) TestCopyBytes(c *checker.C) { data1 := []byte{1, 2, 3, 4} exp1 := []byte{1, 2, 3, 4} @@ -95,22 +47,6 @@ func (s *BytesSuite) TestIsHex(c *checker.C) { } -func (s *BytesSuite) TestParseDataString(c *checker.C) { - res1 := ParseData("hello", "world", "0x0106") - data := "68656c6c6f000000000000000000000000000000000000000000000000000000776f726c640000000000000000000000000000000000000000000000000000000106000000000000000000000000000000000000000000000000000000000000" - exp1 := Hex2Bytes(data) - c.Assert(res1, checker.DeepEquals, exp1) -} - -func (s *BytesSuite) TestParseDataBytes(c *checker.C) { - data1 := []byte{232, 212, 165, 16, 0} - exp1 := []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 232, 212, 165, 16, 0} - - res1 := ParseData(data1) - c.Assert(res1, checker.DeepEquals, exp1) - -} - func (s *BytesSuite) TestLeftPadBytes(c *checker.C) { val1 := []byte{1, 2, 3, 4} exp1 := []byte{0, 0, 0, 0, 1, 2, 3, 4} @@ -122,28 +58,6 @@ func (s *BytesSuite) TestLeftPadBytes(c *checker.C) { c.Assert(res2, checker.DeepEquals, val1) } -func (s *BytesSuite) TestFormatData(c *checker.C) { - data1 := "" - data2 := "0xa9e67e00" - data3 := "a9e67e" - data4 := "\"a9e67e00\"" - - // exp1 := []byte{} - exp2 := []byte{00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 0xa9, 0xe6, 0x7e, 00} - exp3 := []byte{00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00} - exp4 := []byte{0x61, 0x39, 0x65, 0x36, 0x37, 0x65, 0x30, 0x30, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00} - - res1 := FormatData(data1) - res2 := FormatData(data2) - res3 := FormatData(data3) - res4 := FormatData(data4) - - c.Assert(res1, checker.IsNil) - c.Assert(res2, checker.DeepEquals, exp2) - c.Assert(res3, checker.DeepEquals, exp3) - c.Assert(res4, checker.DeepEquals, exp4) -} - func (s *BytesSuite) TestRightPadBytes(c *checker.C) { val := []byte{1, 2, 3, 4} exp := []byte{1, 2, 3, 4, 0, 0, 0, 0} @@ -155,28 +69,6 @@ func (s *BytesSuite) TestRightPadBytes(c *checker.C) { c.Assert(resshrt, checker.DeepEquals, val) } -func (s *BytesSuite) TestLeftPadString(c *checker.C) { - val := "test" - exp := "\x30\x30\x30\x30" + val - - resstd := LeftPadString(val, 8) - resshrt := LeftPadString(val, 2) - - c.Assert(resstd, checker.Equals, exp) - c.Assert(resshrt, checker.Equals, val) -} - -func (s *BytesSuite) TestRightPadString(c *checker.C) { - val := "test" - exp := val + "\x30\x30\x30\x30" - - resstd := RightPadString(val, 8) - resshrt := RightPadString(val, 2) - - c.Assert(resstd, checker.Equals, exp) - c.Assert(resshrt, checker.Equals, val) -} - func TestFromHex(t *testing.T) { input := "0x01" expected := []byte{1} diff --git a/common/icap.go b/common/icap.go deleted file mode 100644 index a36e669b3..000000000 --- a/common/icap.go +++ /dev/null @@ -1,190 +0,0 @@ -// Copyright 2015 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. - -// Spec at https://github.com/ethereum/wiki/wiki/ICAP:-Inter-exchange-Client-Address-Protocol - -package common - -import ( - "errors" - "math/big" - "strconv" - "strings" -) - -var ( - Base36Chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" - ICAPLengthError = errors.New("Invalid ICAP length") - ICAPEncodingError = errors.New("Invalid ICAP encoding") - ICAPChecksumError = errors.New("Invalid ICAP checksum") - ICAPCountryCodeError = errors.New("Invalid ICAP country code") - ICAPAssetIdentError = errors.New("Invalid ICAP asset identifier") - ICAPInstCodeError = errors.New("Invalid ICAP institution code") - ICAPClientIdentError = errors.New("Invalid ICAP client identifier") -) - -func ICAPToAddress(s string) (Address, error) { - switch len(s) { - case 35: // "XE" + 2 digit checksum + 31 base-36 chars of address - return parseICAP(s) - case 34: // "XE" + 2 digit checksum + 30 base-36 chars of address - return parseICAP(s) - case 20: // "XE" + 2 digit checksum + 3-char asset identifier + - // 4-char institution identifier + 9-char institution client identifier - return parseIndirectICAP(s) - default: - return Address{}, ICAPLengthError - } -} - -func parseICAP(s string) (Address, error) { - if !strings.HasPrefix(s, "XE") { - return Address{}, ICAPCountryCodeError - } - if err := validCheckSum(s); err != nil { - return Address{}, err - } - // checksum is ISO13616, Ethereum address is base-36 - bigAddr, _ := new(big.Int).SetString(s[4:], 36) - return BigToAddress(bigAddr), nil -} - -func parseIndirectICAP(s string) (Address, error) { - if !strings.HasPrefix(s, "XE") { - return Address{}, ICAPCountryCodeError - } - if s[4:7] != "ETH" { - return Address{}, ICAPAssetIdentError - } - if err := validCheckSum(s); err != nil { - return Address{}, err - } - // TODO: integrate with ICAP namereg - return Address{}, errors.New("not implemented") -} - -func AddressToICAP(a Address) (string, error) { - enc := base36Encode(a.Big()) - // zero padd encoded address to Direct ICAP length if needed - if len(enc) < 30 { - enc = join(strings.Repeat("0", 30-len(enc)), enc) - } - icap := join("XE", checkDigits(enc), enc) - return icap, nil -} - -// TODO: integrate with ICAP namereg when it's available -func AddressToIndirectICAP(a Address, instCode string) (string, error) { - // return addressToIndirectICAP(a, instCode) - return "", errors.New("not implemented") -} - -func addressToIndirectICAP(a Address, instCode string) (string, error) { - // TODO: add addressToClientIdent which grabs client ident from ICAP namereg - //clientIdent := addressToClientIdent(a) - clientIdent := "todo" - return clientIdentToIndirectICAP(instCode, clientIdent) -} - -func clientIdentToIndirectICAP(instCode, clientIdent string) (string, error) { - if len(instCode) != 4 || !validBase36(instCode) { - return "", ICAPInstCodeError - } - if len(clientIdent) != 9 || !validBase36(instCode) { - return "", ICAPClientIdentError - } - - // currently ETH is only valid asset identifier - s := join("ETH", instCode, clientIdent) - return join("XE", checkDigits(s), s), nil -} - -// https://en.wikipedia.org/wiki/International_Bank_Account_Number#Validating_the_IBAN -func validCheckSum(s string) error { - s = join(s[4:], s[:4]) - expanded, err := iso13616Expand(s) - if err != nil { - return err - } - checkSumNum, _ := new(big.Int).SetString(expanded, 10) - if checkSumNum.Mod(checkSumNum, Big97).Cmp(Big1) != 0 { - return ICAPChecksumError - } - return nil -} - -func checkDigits(s string) string { - expanded, _ := iso13616Expand(strings.Join([]string{s, "XE00"}, "")) - num, _ := new(big.Int).SetString(expanded, 10) - num.Sub(Big98, num.Mod(num, Big97)) - - checkDigits := num.String() - // zero padd checksum - if len(checkDigits) == 1 { - checkDigits = join("0", checkDigits) - } - return checkDigits -} - -// not base-36, but expansion to decimal literal: A = 10, B = 11, ... Z = 35 -func iso13616Expand(s string) (string, error) { - var parts []string - if !validBase36(s) { - return "", ICAPEncodingError - } - for _, c := range s { - i := uint64(c) - if i >= 65 { - parts = append(parts, strconv.FormatUint(uint64(c)-55, 10)) - } else { - parts = append(parts, string(c)) - } - } - return join(parts...), nil -} - -func base36Encode(i *big.Int) string { - var chars []rune - x := new(big.Int) - for { - x.Mod(i, Big36) - chars = append(chars, rune(Base36Chars[x.Uint64()])) - i.Div(i, Big36) - if i.Cmp(Big0) == 0 { - break - } - } - // reverse slice - for i, j := 0, len(chars)-1; i < j; i, j = i+1, j-1 { - chars[i], chars[j] = chars[j], chars[i] - } - return string(chars) -} - -func validBase36(s string) bool { - for _, c := range s { - i := uint64(c) - // 0-9 or A-Z - if i < 48 || (i > 57 && i < 65) || i > 90 { - return false - } - } - return true -} - -func join(s ...string) string { - return strings.Join(s, "") -} diff --git a/common/icap_test.go b/common/icap_test.go deleted file mode 100644 index 6306686d1..000000000 --- a/common/icap_test.go +++ /dev/null @@ -1,91 +0,0 @@ -// Copyright 2015 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. - -package common - -import "testing" - -/* More test vectors: -https://github.com/ethereum/web3.js/blob/master/test/iban.fromAddress.js -https://github.com/ethereum/web3.js/blob/master/test/iban.toAddress.js -https://github.com/ethereum/web3.js/blob/master/test/iban.isValid.js -https://github.com/ethereum/libethereum/blob/develop/test/libethcore/icap.cpp -*/ - -type icapTest struct { - name string - addr string - icap string -} - -var icapOKTests = []icapTest{ - {"Direct1", "0x52dc504a422f0e2a9e7632a34a50f1a82f8224c7", "XE499OG1EH8ZZI0KXC6N83EKGT1BM97P2O7"}, - {"Direct2", "0x11c5496aee77c1ba1f0854206a26dda82a81d6d8", "XE1222Q908LN1QBBU6XUQSO1OHWJIOS46OO"}, - {"DirectZeroPrefix", "0x00c5496aee77c1ba1f0854206a26dda82a81d6d8", "XE7338O073KYGTWWZN0F2WZ0R8PX5ZPPZS"}, - {"DirectDoubleZeroPrefix", "0x0000a5327eab78357cbf2ae8f3d49fd9d90c7d22", "XE0600DQK33XDTYUCRI0KYM5ELAKXDWWF6"}, -} - -var icapInvalidTests = []icapTest{ - {"DirectInvalidCheckSum", "", "XE7438O073KYGTWWZN0F2WZ0R8PX5ZPPZS"}, - {"DirectInvalidCountryCode", "", "XD7338O073KYGTWWZN0F2WZ0R8PX5ZPPZS"}, - {"DirectInvalidLength36", "", "XE499OG1EH8ZZI0KXC6N83EKGT1BM97P2O77"}, - {"DirectInvalidLength33", "", "XE499OG1EH8ZZI0KXC6N83EKGT1BM97P2"}, - - {"IndirectInvalidCheckSum", "", "XE35ETHXREGGOPHERSSS"}, - {"IndirectInvalidAssetIdentifier", "", "XE34ETHXREGGOPHERSSS"}, - {"IndirectInvalidLength19", "", "XE34ETHXREGGOPHERSS"}, - {"IndirectInvalidLength21", "", "XE34ETHXREGGOPHERSSSS"}, -} - -func TestICAPOK(t *testing.T) { - for _, test := range icapOKTests { - decodeEncodeTest(HexToAddress(test.addr), test.icap, t) - } -} - -func TestICAPInvalid(t *testing.T) { - for _, test := range icapInvalidTests { - failedDecodingTest(test.icap, t) - } -} - -func decodeEncodeTest(addr0 Address, icap0 string, t *testing.T) { - icap1, err := AddressToICAP(addr0) - if err != nil { - t.Errorf("ICAP encoding failed: %s", err) - } - if icap1 != icap0 { - t.Errorf("ICAP mismatch: have: %s want: %s", icap1, icap0) - } - - addr1, err := ICAPToAddress(icap0) - if err != nil { - t.Errorf("ICAP decoding failed: %s", err) - } - if addr1 != addr0 { - t.Errorf("Address mismatch: have: %x want: %x", addr1, addr0) - } -} - -func failedDecodingTest(icap string, t *testing.T) { - addr, err := ICAPToAddress(icap) - if err == nil { - t.Errorf("Expected ICAP decoding to fail.") - } - if addr != (Address{}) { - t.Errorf("Expected empty Address on failed ICAP decoding.") - } -} diff --git a/common/list.go b/common/list.go deleted file mode 100644 index 07b2f17f5..000000000 --- a/common/list.go +++ /dev/null @@ -1,97 +0,0 @@ -// Copyright 2014 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. - -package common - -import ( - "encoding/json" - "reflect" - "sync" -) - -// The list type is an anonymous slice handler which can be used -// for containing any slice type to use in an environment which -// does not support slice types (e.g., JavaScript, QML) -type List struct { - mut sync.Mutex - val interface{} - list reflect.Value - Length int -} - -// Initialise a new list. Panics if non-slice type is given. -func NewList(t interface{}) *List { - list := reflect.ValueOf(t) - if list.Kind() != reflect.Slice { - panic("list container initialized with a non-slice type") - } - - return &List{sync.Mutex{}, t, list, list.Len()} -} - -func EmptyList() *List { - return NewList([]interface{}{}) -} - -// Get N element from the embedded slice. Returns nil if OOB. -func (self *List) Get(i int) interface{} { - if self.list.Len() > i { - self.mut.Lock() - defer self.mut.Unlock() - - i := self.list.Index(i).Interface() - - return i - } - - return nil -} - -func (self *List) GetAsJson(i int) interface{} { - e := self.Get(i) - - r, _ := json.Marshal(e) - - return string(r) -} - -// Appends value at the end of the slice. Panics when incompatible value -// is given. -func (self *List) Append(v interface{}) { - self.mut.Lock() - defer self.mut.Unlock() - - self.list = reflect.Append(self.list, reflect.ValueOf(v)) - self.Length = self.list.Len() -} - -// Returns the underlying slice as interface. -func (self *List) Interface() interface{} { - return self.list.Interface() -} - -// For JavaScript <3 -func (self *List) ToJSON() string { - // make(T, 0) != nil - list := make([]interface{}, 0) - for i := 0; i < self.Length; i++ { - list = append(list, self.Get(i)) - } - - data, _ := json.Marshal(list) - - return string(data) -} diff --git a/common/math/big.go b/common/math/big.go new file mode 100644 index 000000000..c0508c102 --- /dev/null +++ b/common/math/big.go @@ -0,0 +1,143 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. + +// Package math provides integer math utilities. +package math + +import ( + "math/big" +) + +var ( + tt255 = BigPow(2, 255) + tt256 = BigPow(2, 256) + tt256m1 = new(big.Int).Sub(tt256, big.NewInt(1)) + MaxBig256 = new(big.Int).Set(tt256m1) +) + +// ParseBig256 parses s as a 256 bit integer in decimal or hexadecimal syntax. +// Leading zeros are accepted. The empty string parses as zero. +func ParseBig256(s string) (*big.Int, bool) { + if s == "" { + return new(big.Int), true + } + var bigint *big.Int + var ok bool + if len(s) >= 2 && (s[:2] == "0x" || s[:2] == "0X") { + bigint, ok = new(big.Int).SetString(s[2:], 16) + } else { + bigint, ok = new(big.Int).SetString(s, 10) + } + if ok && bigint.BitLen() > 256 { + bigint, ok = nil, false + } + return bigint, ok +} + +// MustParseBig parses s as a 256 bit big integer and panics if the string is invalid. +func MustParseBig256(s string) *big.Int { + v, ok := ParseBig256(s) + if !ok { + panic("invalid 256 bit integer: " + s) + } + return v +} + +// BigPow returns a ** b as a big integer. +func BigPow(a, b int64) *big.Int { + r := big.NewInt(a) + return r.Exp(r, big.NewInt(b), nil) +} + +// BigMax returns the larger of x or y. +func BigMax(x, y *big.Int) *big.Int { + if x.Cmp(y) < 0 { + return y + } + return x +} + +// BigMin returns the smaller of x or y. +func BigMin(x, y *big.Int) *big.Int { + if x.Cmp(y) > 0 { + return y + } + return x +} + +// FirstBitSet returns the index of the first 1 bit in v, counting from LSB. +func FirstBitSet(v *big.Int) int { + for i := 0; i < v.BitLen(); i++ { + if v.Bit(i) > 0 { + return i + } + } + return v.BitLen() +} + +// PaddedBigBytes encodes a big integer as a big-endian byte slice. The length +// of the slice is at least n bytes. +func PaddedBigBytes(bigint *big.Int, n int) []byte { + bytes := bigint.Bytes() + if len(bytes) >= n { + return bytes + } + ret := make([]byte, n) + return append(ret[:len(ret)-len(bytes)], bytes...) +} + +// U256 encodes as a 256 bit two's complement number. This operation is destructive. +func U256(x *big.Int) *big.Int { + return x.And(x, tt256m1) +} + +// S256 interprets x as a two's complement number. +// x must not exceed 256 bits (the result is undefined if it does) and is not modified. +// +// S256(0) = 0 +// S256(1) = 1 +// S256(2**255) = -2**255 +// S256(2**256-1) = -1 +func S256(x *big.Int) *big.Int { + if x.Cmp(tt255) < 0 { + return x + } else { + return new(big.Int).Sub(x, tt256) + } +} + +// wordSize is the size number of bits in a big.Word. +const wordSize = 32 << (uint64(^big.Word(0)) >> 63) + +// Exp implements exponentiation by squaring. +// Exp returns a newly-allocated big integer and does not change +// base or exponent. The result is truncated to 256 bits. +// +// Courtesy @karalabe and @chfast +func Exp(base, exponent *big.Int) *big.Int { + result := big.NewInt(1) + + for _, word := range exponent.Bits() { + for i := 0; i < wordSize; i++ { + if word&1 == 1 { + U256(result.Mul(result, base)) + } + U256(base.Mul(base, base)) + word >>= 1 + } + } + return result +} diff --git a/common/math/big_test.go b/common/math/big_test.go new file mode 100644 index 000000000..a0f48a8eb --- /dev/null +++ b/common/math/big_test.go @@ -0,0 +1,196 @@ +// Copyright 2014 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. + +package math + +import ( + "bytes" + "math/big" + "testing" +) + +func TestParseBig256(t *testing.T) { + tests := []struct { + input string + num *big.Int + ok bool + }{ + {"", big.NewInt(0), true}, + {"0", big.NewInt(0), true}, + {"0x0", big.NewInt(0), true}, + {"12345678", big.NewInt(12345678), true}, + {"0x12345678", big.NewInt(0x12345678), true}, + {"0X12345678", big.NewInt(0x12345678), true}, + // Tests for leading zero behaviour: + {"0123456789", big.NewInt(123456789), true}, // note: not octal + {"00", big.NewInt(0), true}, + {"0x00", big.NewInt(0), true}, + {"0x012345678abc", big.NewInt(0x12345678abc), true}, + // Invalid syntax: + {"abcdef", nil, false}, + {"0xgg", nil, false}, + // Larger than 256 bits: + {"115792089237316195423570985008687907853269984665640564039457584007913129639936", nil, false}, + } + for _, test := range tests { + num, ok := ParseBig256(test.input) + if ok != test.ok { + t.Errorf("ParseBig(%q) -> ok = %t, want %t", test.input, ok, test.ok) + continue + } + if num != nil && test.num != nil && num.Cmp(test.num) != 0 { + t.Errorf("ParseBig(%q) -> %d, want %d", test.input, num, test.num) + } + } +} + +func TestMustParseBig256(t *testing.T) { + defer func() { + if recover() == nil { + t.Error("MustParseBig should've panicked") + } + }() + MustParseBig256("ggg") +} + +func TestBigMax(t *testing.T) { + a := big.NewInt(10) + b := big.NewInt(5) + + max1 := BigMax(a, b) + if max1 != a { + t.Errorf("Expected %d got %d", a, max1) + } + + max2 := BigMax(b, a) + if max2 != a { + t.Errorf("Expected %d got %d", a, max2) + } +} + +func TestBigMin(t *testing.T) { + a := big.NewInt(10) + b := big.NewInt(5) + + min1 := BigMin(a, b) + if min1 != b { + t.Errorf("Expected %d got %d", b, min1) + } + + min2 := BigMin(b, a) + if min2 != b { + t.Errorf("Expected %d got %d", b, min2) + } +} + +func TestFirstBigSet(t *testing.T) { + tests := []struct { + num *big.Int + ix int + }{ + {big.NewInt(0), 0}, + {big.NewInt(1), 0}, + {big.NewInt(2), 1}, + {big.NewInt(0x100), 8}, + } + for _, test := range tests { + if ix := FirstBitSet(test.num); ix != test.ix { + t.Errorf("FirstBitSet(b%b) = %d, want %d", test.num, ix, test.ix) + } + } +} + +func TestPaddedBigBytes(t *testing.T) { + tests := []struct { + num *big.Int + n int + result []byte + }{ + {num: big.NewInt(0), n: 4, result: []byte{0, 0, 0, 0}}, + {num: big.NewInt(1), n: 4, result: []byte{0, 0, 0, 1}}, + {num: big.NewInt(512), n: 4, result: []byte{0, 0, 2, 0}}, + {num: BigPow(2, 32), n: 4, result: []byte{1, 0, 0, 0, 0}}, + } + for _, test := range tests { + if result := PaddedBigBytes(test.num, test.n); !bytes.Equal(result, test.result) { + t.Errorf("PaddedBigBytes(%d, %d) = %v, want %v", test.num, test.n, result, test.result) + } + } +} + +func TestU256(t *testing.T) { + tests := []struct{ x, y *big.Int }{ + {x: big.NewInt(0), y: big.NewInt(0)}, + {x: big.NewInt(1), y: big.NewInt(1)}, + {x: BigPow(2, 255), y: BigPow(2, 255)}, + {x: BigPow(2, 256), y: big.NewInt(0)}, + {x: new(big.Int).Add(BigPow(2, 256), big.NewInt(1)), y: big.NewInt(1)}, + // negative values + {x: big.NewInt(-1), y: new(big.Int).Sub(BigPow(2, 256), big.NewInt(1))}, + {x: big.NewInt(-2), y: new(big.Int).Sub(BigPow(2, 256), big.NewInt(2))}, + {x: BigPow(2, -255), y: big.NewInt(1)}, + } + for _, test := range tests { + if y := U256(new(big.Int).Set(test.x)); y.Cmp(test.y) != 0 { + t.Errorf("U256(%x) = %x, want %x", test.x, y, test.y) + } + } +} + +func TestS256(t *testing.T) { + tests := []struct{ x, y *big.Int }{ + {x: big.NewInt(0), y: big.NewInt(0)}, + {x: big.NewInt(1), y: big.NewInt(1)}, + {x: big.NewInt(2), y: big.NewInt(2)}, + { + x: new(big.Int).Sub(BigPow(2, 255), big.NewInt(1)), + y: new(big.Int).Sub(BigPow(2, 255), big.NewInt(1)), + }, + { + x: BigPow(2, 255), + y: new(big.Int).Neg(BigPow(2, 255)), + }, + { + x: new(big.Int).Sub(BigPow(2, 256), big.NewInt(1)), + y: big.NewInt(-1), + }, + { + x: new(big.Int).Sub(BigPow(2, 256), big.NewInt(2)), + y: big.NewInt(-2), + }, + } + for _, test := range tests { + if y := S256(test.x); y.Cmp(test.y) != 0 { + t.Errorf("S256(%x) = %x, want %x", test.x, y, test.y) + } + } +} + +func TestExp(t *testing.T) { + tests := []struct{ base, exponent, result *big.Int }{ + {base: big.NewInt(0), exponent: big.NewInt(0), result: big.NewInt(1)}, + {base: big.NewInt(1), exponent: big.NewInt(0), result: big.NewInt(1)}, + {base: big.NewInt(1), exponent: big.NewInt(1), result: big.NewInt(1)}, + {base: big.NewInt(1), exponent: big.NewInt(2), result: big.NewInt(1)}, + {base: big.NewInt(3), exponent: big.NewInt(144), result: MustParseBig256("507528786056415600719754159741696356908742250191663887263627442114881")}, + {base: big.NewInt(2), exponent: big.NewInt(255), result: MustParseBig256("57896044618658097711785492504343953926634992332820282019728792003956564819968")}, + } + for _, test := range tests { + if result := Exp(test.base, test.exponent); result.Cmp(test.result) != 0 { + t.Errorf("Exp(%d, %d) = %d, want %d", test.base, test.exponent, result, test.result) + } + } +} diff --git a/common/math/dist.go b/common/math/dist.go deleted file mode 100644 index 913fbfbd4..000000000 --- a/common/math/dist.go +++ /dev/null @@ -1,96 +0,0 @@ -// Copyright 2015 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. - -package math - -import ( - "math/big" - "sort" - - "github.com/ethereum/go-ethereum/common" -) - -type Summer interface { - Sum(i int) *big.Int - Len() int -} - -func Sum(slice Summer) (sum *big.Int) { - sum = new(big.Int) - - for i := 0; i < slice.Len(); i++ { - sum.Add(sum, slice.Sum(i)) - } - return -} - -type Vector struct { - Gas, Price *big.Int -} - -type VectorsBy func(v1, v2 Vector) bool - -func (self VectorsBy) Sort(vectors []Vector) { - bs := vectorSorter{ - vectors: vectors, - by: self, - } - sort.Sort(bs) -} - -type vectorSorter struct { - vectors []Vector - by func(v1, v2 Vector) bool -} - -func (v vectorSorter) Len() int { return len(v.vectors) } -func (v vectorSorter) Less(i, j int) bool { return v.by(v.vectors[i], v.vectors[j]) } -func (v vectorSorter) Swap(i, j int) { v.vectors[i], v.vectors[j] = v.vectors[j], v.vectors[i] } - -func PriceSort(v1, v2 Vector) bool { return v1.Price.Cmp(v2.Price) < 0 } -func GasSort(v1, v2 Vector) bool { return v1.Gas.Cmp(v2.Gas) < 0 } - -type vectorSummer struct { - vectors []Vector - by func(v Vector) *big.Int -} - -type VectorSum func(v Vector) *big.Int - -func (v VectorSum) Sum(vectors []Vector) *big.Int { - vs := vectorSummer{ - vectors: vectors, - by: v, - } - return Sum(vs) -} - -func (v vectorSummer) Len() int { return len(v.vectors) } -func (v vectorSummer) Sum(i int) *big.Int { return v.by(v.vectors[i]) } - -func GasSum(v Vector) *big.Int { return v.Gas } - -var etherInWei = new(big.Rat).SetInt(common.String2Big("1000000000000000000")) - -func GasPrice(bp, gl, ep *big.Int) *big.Int { - BP := new(big.Rat).SetInt(bp) - GL := new(big.Rat).SetInt(gl) - EP := new(big.Rat).SetInt(ep) - GP := new(big.Rat).Quo(BP, GL) - GP = GP.Quo(GP, EP) - - return GP.Mul(GP, etherInWei).Num() -} diff --git a/common/math/dist_test.go b/common/math/dist_test.go deleted file mode 100644 index f5857b6f8..000000000 --- a/common/math/dist_test.go +++ /dev/null @@ -1,82 +0,0 @@ -// Copyright 2015 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. - -package math - -import ( - "fmt" - "math/big" - "testing" -) - -type summer struct { - numbers []*big.Int -} - -func (s summer) Len() int { return len(s.numbers) } -func (s summer) Sum(i int) *big.Int { - return s.numbers[i] -} - -func TestSum(t *testing.T) { - summer := summer{numbers: []*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)}} - sum := Sum(summer) - if sum.Cmp(big.NewInt(6)) != 0 { - t.Errorf("got sum = %d, want 6", sum) - } -} - -func TestDist(t *testing.T) { - var vectors = []Vector{ - {big.NewInt(1000), big.NewInt(1234)}, - {big.NewInt(500), big.NewInt(10023)}, - {big.NewInt(1034), big.NewInt(1987)}, - {big.NewInt(1034), big.NewInt(1987)}, - {big.NewInt(8983), big.NewInt(1977)}, - {big.NewInt(98382), big.NewInt(1887)}, - {big.NewInt(12398), big.NewInt(1287)}, - {big.NewInt(12398), big.NewInt(1487)}, - {big.NewInt(12398), big.NewInt(1987)}, - {big.NewInt(12398), big.NewInt(128)}, - {big.NewInt(12398), big.NewInt(1987)}, - {big.NewInt(1398), big.NewInt(187)}, - {big.NewInt(12328), big.NewInt(1927)}, - {big.NewInt(12398), big.NewInt(1987)}, - {big.NewInt(22398), big.NewInt(1287)}, - {big.NewInt(1370), big.NewInt(1981)}, - {big.NewInt(12398), big.NewInt(1957)}, - {big.NewInt(42198), big.NewInt(1987)}, - } - - VectorsBy(GasSort).Sort(vectors) - fmt.Println(vectors) - - BP := big.NewInt(15) - GL := big.NewInt(1000000) - EP := big.NewInt(100) - fmt.Println("BP", BP, "GL", GL, "EP", EP) - GP := GasPrice(BP, GL, EP) - fmt.Println("GP =", GP, "Wei per GU") - - S := len(vectors) / 4 - fmt.Println("L", len(vectors), "S", S) - for i := 1; i <= S*4; i += S { - fmt.Printf("T%d = %v\n", i, vectors[i]) - } - - g := VectorSum(GasSum).Sum(vectors) - fmt.Printf("G = ∑g* (%v)\n", g) -} diff --git a/common/math/integer.go b/common/math/integer.go index 1689b6586..a3eeee27e 100644 --- a/common/math/integer.go +++ b/common/math/integer.go @@ -1,10 +1,63 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. + package math -import gmath "math" +import "strconv" + +const ( + // Integer limit values. + MaxInt8 = 1<<7 - 1 + MinInt8 = -1 << 7 + MaxInt16 = 1<<15 - 1 + MinInt16 = -1 << 15 + MaxInt32 = 1<<31 - 1 + MinInt32 = -1 << 31 + MaxInt64 = 1<<63 - 1 + MinInt64 = -1 << 63 + MaxUint8 = 1<<8 - 1 + MaxUint16 = 1<<16 - 1 + MaxUint32 = 1<<32 - 1 + MaxUint64 = 1<<64 - 1 +) + +// ParseUint64 parses s as an integer in decimal or hexadecimal syntax. +// Leading zeros are accepted. The empty string parses as zero. +func ParseUint64(s string) (uint64, bool) { + if s == "" { + return 0, true + } + if len(s) >= 2 && (s[:2] == "0x" || s[:2] == "0X") { + v, err := strconv.ParseUint(s[2:], 16, 64) + return v, err == nil + } + v, err := strconv.ParseUint(s, 10, 64) + return v, err == nil +} + +// MustParseUint64 parses s as an integer and panics if the string is invalid. +func MustParseUint64(s string) uint64 { + v, ok := ParseUint64(s) + if !ok { + panic("invalid unsigned 64 bit integer: " + s) + } + return v +} -/* - * NOTE: The following methods need to be optimised using either bit checking or asm - */ +// NOTE: The following methods need to be optimised using either bit checking or asm // SafeSub returns subtraction result and whether overflow occurred. func SafeSub(x, y uint64) (uint64, bool) { @@ -13,7 +66,7 @@ func SafeSub(x, y uint64) (uint64, bool) { // SafeAdd returns the result and whether overflow occurred. func SafeAdd(x, y uint64) (uint64, bool) { - return x + y, y > gmath.MaxUint64-x + return x + y, y > MaxUint64-x } // SafeMul returns multiplication result and whether overflow occurred. @@ -21,5 +74,5 @@ func SafeMul(x, y uint64) (uint64, bool) { if x == 0 || y == 0 { return 0, false } - return x * y, y > gmath.MaxUint64/x + return x * y, y > MaxUint64/x } diff --git a/common/math/integer_test.go b/common/math/integer_test.go index 198114e5e..05bba221f 100644 --- a/common/math/integer_test.go +++ b/common/math/integer_test.go @@ -1,7 +1,22 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. + package math import ( - gmath "math" "testing" ) @@ -21,17 +36,18 @@ func TestOverflow(t *testing.T) { op operation }{ // add operations - {gmath.MaxUint64, 1, true, add}, - {gmath.MaxUint64 - 1, 1, false, add}, + {MaxUint64, 1, true, add}, + {MaxUint64 - 1, 1, false, add}, // sub operations {0, 1, true, sub}, {0, 0, false, sub}, // mul operations + {0, 0, false, mul}, {10, 10, false, mul}, - {gmath.MaxUint64, 2, true, mul}, - {gmath.MaxUint64, 1, false, mul}, + {MaxUint64, 2, true, mul}, + {MaxUint64, 1, false, mul}, } { var overflows bool switch test.op { @@ -48,3 +64,52 @@ func TestOverflow(t *testing.T) { } } } + +func TestParseUint64(t *testing.T) { + tests := []struct { + input string + num uint64 + ok bool + }{ + {"", 0, true}, + {"0", 0, true}, + {"0x0", 0, true}, + {"12345678", 12345678, true}, + {"0x12345678", 0x12345678, true}, + {"0X12345678", 0x12345678, true}, + // Tests for leading zero behaviour: + {"0123456789", 123456789, true}, // note: not octal + {"0x00", 0, true}, + {"0x012345678abc", 0x12345678abc, true}, + // Invalid syntax: + {"abcdef", 0, false}, + {"0xgg", 0, false}, + // Doesn't fit into 64 bits: + {"18446744073709551617", 0, false}, + } + for _, test := range tests { + num, ok := ParseUint64(test.input) + if ok != test.ok { + t.Errorf("ParseUint64(%q) -> ok = %t, want %t", test.input, ok, test.ok) + continue + } + if ok && num != test.num { + t.Errorf("ParseUint64(%q) -> %d, want %d", test.input, num, test.num) + } + } +} + +func TestMustParseUint64(t *testing.T) { + if v := MustParseUint64("12345"); v != 12345 { + t.Errorf(`MustParseUint64("12345") = %d, want 12345`, v) + } +} + +func TestMustParseUint64Panic(t *testing.T) { + defer func() { + if recover() == nil { + t.Error("MustParseBig should've panicked") + } + }() + MustParseUint64("ggg") +} diff --git a/common/size.go b/common/size.go index 9653b3629..c5a0cb0f2 100644 --- a/common/size.go +++ b/common/size.go @@ -18,7 +18,6 @@ package common import ( "fmt" - "math/big" ) type StorageSize float64 @@ -36,54 +35,3 @@ func (self StorageSize) String() string { func (self StorageSize) Int64() int64 { return int64(self) } - -// The different number of units -var ( - Douglas = BigPow(10, 42) - Einstein = BigPow(10, 21) - Ether = BigPow(10, 18) - Finney = BigPow(10, 15) - Szabo = BigPow(10, 12) - Shannon = BigPow(10, 9) - Babbage = BigPow(10, 6) - Ada = BigPow(10, 3) - Wei = big.NewInt(1) -) - -// -// Currency to string -// Returns a string representing a human readable format -func CurrencyToString(num *big.Int) string { - var ( - fin *big.Int = num - denom string = "Wei" - ) - - switch { - case num.Cmp(Ether) >= 0: - fin = new(big.Int).Div(num, Ether) - denom = "Ether" - case num.Cmp(Finney) >= 0: - fin = new(big.Int).Div(num, Finney) - denom = "Finney" - case num.Cmp(Szabo) >= 0: - fin = new(big.Int).Div(num, Szabo) - denom = "Szabo" - case num.Cmp(Shannon) >= 0: - fin = new(big.Int).Div(num, Shannon) - denom = "Shannon" - case num.Cmp(Babbage) >= 0: - fin = new(big.Int).Div(num, Babbage) - denom = "Babbage" - case num.Cmp(Ada) >= 0: - fin = new(big.Int).Div(num, Ada) - denom = "Ada" - } - - // TODO add comment clarifying expected behavior - if len(fin.String()) > 5 { - return fmt.Sprintf("%sE%d %s", fin.String()[0:5], len(fin.String())-5, denom) - } - - return fmt.Sprintf("%v %s", fin, denom) -} diff --git a/common/size_test.go b/common/size_test.go index ce19cab69..f5b6c725e 100644 --- a/common/size_test.go +++ b/common/size_test.go @@ -17,43 +17,22 @@ package common import ( - "math/big" - - checker "gopkg.in/check.v1" + "testing" ) -type SizeSuite struct{} - -var _ = checker.Suite(&SizeSuite{}) - -func (s *SizeSuite) TestStorageSizeString(c *checker.C) { - data1 := 2381273 - data2 := 2192 - data3 := 12 - - exp1 := "2.38 mB" - exp2 := "2.19 kB" - exp3 := "12.00 B" - - c.Assert(StorageSize(data1).String(), checker.Equals, exp1) - c.Assert(StorageSize(data2).String(), checker.Equals, exp2) - c.Assert(StorageSize(data3).String(), checker.Equals, exp3) -} - -func (s *SizeSuite) TestCommon(c *checker.C) { - ether := CurrencyToString(BigPow(10, 19)) - finney := CurrencyToString(BigPow(10, 16)) - szabo := CurrencyToString(BigPow(10, 13)) - shannon := CurrencyToString(BigPow(10, 10)) - babbage := CurrencyToString(BigPow(10, 7)) - ada := CurrencyToString(BigPow(10, 4)) - wei := CurrencyToString(big.NewInt(10)) - - c.Assert(ether, checker.Equals, "10 Ether") - c.Assert(finney, checker.Equals, "10 Finney") - c.Assert(szabo, checker.Equals, "10 Szabo") - c.Assert(shannon, checker.Equals, "10 Shannon") - c.Assert(babbage, checker.Equals, "10 Babbage") - c.Assert(ada, checker.Equals, "10 Ada") - c.Assert(wei, checker.Equals, "10 Wei") +func TestStorageSizeString(t *testing.T) { + tests := []struct { + size StorageSize + str string + }{ + {2381273, "2.38 mB"}, + {2192, "2.19 kB"}, + {12, "12.00 B"}, + } + + for _, test := range tests { + if test.size.String() != test.str { + t.Errorf("%f: got %q, want %q", float64(test.size), test.size.String(), test.str) + } + } } diff --git a/common/types.go b/common/types.go index 8a456e965..d38ea7306 100644 --- a/common/types.go +++ b/common/types.go @@ -52,7 +52,7 @@ func HexToHash(s string) Hash { return BytesToHash(FromHex(s)) } // Get the string representation of the underlying hash func (h Hash) Str() string { return string(h[:]) } func (h Hash) Bytes() []byte { return h[:] } -func (h Hash) Big() *big.Int { return Bytes2Big(h[:]) } +func (h Hash) Big() *big.Int { return new(big.Int).SetBytes(h[:]) } func (h Hash) Hex() string { return hexutil.Encode(h[:]) } // UnmarshalJSON parses a hash in its hex from to a hash. @@ -122,7 +122,7 @@ func IsHexAddress(s string) bool { // Get the string representation of the underlying address func (a Address) Str() string { return string(a[:]) } func (a Address) Bytes() []byte { return a[:] } -func (a Address) Big() *big.Int { return Bytes2Big(a[:]) } +func (a Address) Big() *big.Int { return new(big.Int).SetBytes(a[:]) } func (a Address) Hash() Hash { return BytesToHash(a[:]) } func (a Address) Hex() string { return hexutil.Encode(a[:]) } diff --git a/common/types_template.go b/common/types_template.go index 8048f9cc3..9a8f29977 100644 --- a/common/types_template.go +++ b/common/types_template.go @@ -37,7 +37,7 @@ func HexTo_N_(s string) _N_ { return BytesTo_N_(FromHex(s)) } // Get the string representation of the underlying hash func (h _N_) Str() string { return string(h[:]) } func (h _N_) Bytes() []byte { return h[:] } -func (h _N_) Big() *big.Int { return Bytes2Big(h[:]) } +func (h _N_) Big() *big.Int { return new(big.Int).SetBytes(h[:]) } func (h _N_) Hex() string { return "0x" + Bytes2Hex(h[:]) } // Sets the hash to the value of b. If b is larger than len(h) it will panic diff --git a/core/bench_test.go b/core/bench_test.go index 59b5ad758..8a1600557 100644 --- a/core/bench_test.go +++ b/core/bench_test.go @@ -24,6 +24,7 @@ import ( "testing" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/crypto" @@ -73,7 +74,7 @@ var ( // This is the content of the genesis block used by the benchmarks. benchRootKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") benchRootAddr = crypto.PubkeyToAddress(benchRootKey.PublicKey) - benchRootFunds = common.BigPow(2, 100) + benchRootFunds = math.BigPow(2, 100) ) // genValueTx returns a block generator that includes a single diff --git a/core/block_validator.go b/core/block_validator.go index a23a4134b..117974ee6 100644 --- a/core/block_validator.go +++ b/core/block_validator.go @@ -22,6 +22,7 @@ import ( "time" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/log" @@ -209,7 +210,7 @@ func ValidateHeader(config *params.ChainConfig, pow pow.PoW, header *types.Heade } if uncle { - if header.Time.Cmp(common.MaxBig) == 1 { + if header.Time.Cmp(math.MaxBig256) == 1 { return BlockTSTooBigErr } } else { @@ -344,7 +345,7 @@ func calcDifficultyFrontier(time, parentTime uint64, parentNumber, parentDiff *b expDiff := periodCount.Sub(periodCount, common.Big2) expDiff.Exp(common.Big2, expDiff, nil) diff.Add(diff, expDiff) - diff = common.BigMax(diff, params.MinimumDifficulty) + diff = math.BigMax(diff, params.MinimumDifficulty) } return diff @@ -372,13 +373,13 @@ func CalcGasLimit(parent *types.Block) *big.Int { */ gl := new(big.Int).Sub(parent.GasLimit(), decay) gl = gl.Add(gl, contrib) - gl.Set(common.BigMax(gl, params.MinGasLimit)) + gl.Set(math.BigMax(gl, params.MinGasLimit)) // however, if we're now below the target (TargetGasLimit) we increase the // limit as much as we can (parentGasLimit / 1024 -1) if gl.Cmp(params.TargetGasLimit) < 0 { gl.Add(parent.GasLimit(), decay) - gl.Set(common.BigMin(gl, params.TargetGasLimit)) + gl.Set(math.BigMin(gl, params.TargetGasLimit)) } return gl } diff --git a/core/database_util_test.go b/core/database_util_test.go index d96aa71ba..0af4e4920 100644 --- a/core/database_util_test.go +++ b/core/database_util_test.go @@ -25,6 +25,7 @@ import ( "testing" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto/sha3" @@ -53,11 +54,11 @@ func (d *diffTest) UnmarshalJSON(b []byte) (err error) { return err } - d.ParentTimestamp = common.String2Big(ext.ParentTimestamp).Uint64() - d.ParentDifficulty = common.String2Big(ext.ParentDifficulty) - d.CurrentTimestamp = common.String2Big(ext.CurrentTimestamp).Uint64() - d.CurrentBlocknumber = common.String2Big(ext.CurrentBlocknumber) - d.CurrentDifficulty = common.String2Big(ext.CurrentDifficulty) + d.ParentTimestamp = math.MustParseUint64(ext.ParentTimestamp) + d.ParentDifficulty = math.MustParseBig256(ext.ParentDifficulty) + d.CurrentTimestamp = math.MustParseUint64(ext.CurrentTimestamp) + d.CurrentBlocknumber = math.MustParseBig256(ext.CurrentBlocknumber) + d.CurrentDifficulty = math.MustParseBig256(ext.CurrentDifficulty) return nil } diff --git a/core/genesis.go b/core/genesis.go index a015f04c1..58d3440d6 100644 --- a/core/genesis.go +++ b/core/genesis.go @@ -28,6 +28,7 @@ import ( "strings" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/ethdb" @@ -67,23 +68,48 @@ func WriteGenesisBlock(chainDb ethdb.Database, reader io.Reader) (*types.Block, // creating with empty hash always works statedb, _ := state.New(common.Hash{}, chainDb) for addr, account := range genesis.Alloc { + balance, ok := math.ParseBig256(account.Balance) + if !ok { + return nil, fmt.Errorf("invalid balance for account %s: %q", addr, account.Balance) + } + nonce, ok := math.ParseUint64(account.Nonce) + if !ok { + return nil, fmt.Errorf("invalid nonce for account %s: %q", addr, account.Nonce) + } + address := common.HexToAddress(addr) - statedb.AddBalance(address, common.String2Big(account.Balance)) + statedb.AddBalance(address, balance) statedb.SetCode(address, common.FromHex(account.Code)) - statedb.SetNonce(address, common.String2Big(account.Nonce).Uint64()) + statedb.SetNonce(address, nonce) for key, value := range account.Storage { statedb.SetState(address, common.HexToHash(key), common.HexToHash(value)) } } root, stateBatch := statedb.CommitBatch(false) - difficulty := common.String2Big(genesis.Difficulty) + difficulty, ok := math.ParseBig256(genesis.Difficulty) + if !ok { + return nil, fmt.Errorf("invalid difficulty: %q", genesis.Difficulty) + } + gaslimit, ok := math.ParseUint64(genesis.GasLimit) + if !ok { + return nil, fmt.Errorf("invalid gas limit: %q", genesis.GasLimit) + } + nonce, ok := math.ParseUint64(genesis.Nonce) + if !ok { + return nil, fmt.Errorf("invalid nonce: %q", genesis.Nonce) + } + timestamp, ok := math.ParseBig256(genesis.Timestamp) + if !ok { + return nil, fmt.Errorf("invalid timestamp: %q", genesis.Timestamp) + } + block := types.NewBlock(&types.Header{ - Nonce: types.EncodeNonce(common.String2Big(genesis.Nonce).Uint64()), - Time: common.String2Big(genesis.Timestamp), + Nonce: types.EncodeNonce(nonce), + Time: timestamp, ParentHash: common.HexToHash(genesis.ParentHash), Extra: common.FromHex(genesis.ExtraData), - GasLimit: common.String2Big(genesis.GasLimit), + GasLimit: new(big.Int).SetUint64(gaslimit), Difficulty: difficulty, MixDigest: common.HexToHash(genesis.Mixhash), Coinbase: common.HexToAddress(genesis.Coinbase), @@ -153,7 +179,7 @@ func WriteGenesisBlockForTesting(db ethdb.Database, accounts ...GenesisAccount) if i != 0 { accountJson += "," } - accountJson += fmt.Sprintf(`"0x%x":{"balance":"0x%x"}`, account.Address, account.Balance.Bytes()) + accountJson += fmt.Sprintf(`"0x%x":{"balance":"%d"}`, account.Address, account.Balance) } accountJson += "}" @@ -163,7 +189,10 @@ func WriteGenesisBlockForTesting(db ethdb.Database, accounts ...GenesisAccount) "difficulty":"0x%x", "alloc": %s }`, types.EncodeNonce(0), params.GenesisGasLimit.Bytes(), params.GenesisDifficulty.Bytes(), accountJson) - block, _ := WriteGenesisBlock(db, strings.NewReader(testGenesis)) + block, err := WriteGenesisBlock(db, strings.NewReader(testGenesis)) + if err != nil { + panic(err) + } return block } diff --git a/core/state_transition.go b/core/state_transition.go index 8e7891b96..98a24af2b 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -22,6 +22,7 @@ import ( "math/big" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" @@ -281,7 +282,7 @@ func (self *StateTransition) refundGas() { // Apply refund counter, capped to half of the used gas. uhalf := remaining.Div(self.gasUsed(), common.Big2) - refund := common.BigMin(uhalf, self.state.GetRefund()) + refund := math.BigMin(uhalf, self.state.GetRefund()) self.gas += refund.Uint64() self.state.AddBalance(sender.Address(), refund.Mul(refund, self.gasPrice)) diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go index 98a34b757..3a37dd2b9 100644 --- a/core/tx_pool_test.go +++ b/core/tx_pool_test.go @@ -29,6 +29,7 @@ import ( "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/event" + "github.com/ethereum/go-ethereum/params" ) func transaction(nonce uint64, gaslimit *big.Int, key *ecdsa.PrivateKey) *types.Transaction { @@ -65,7 +66,7 @@ func TestStateChangeDuringPoolReset(t *testing.T) { ) // setup pool with 2 transaction in it - statedb.SetBalance(address, new(big.Int).Mul(common.Big1, common.Ether)) + statedb.SetBalance(address, new(big.Int).SetUint64(params.Ether)) tx0 := transaction(0, big.NewInt(100000), key) tx1 := transaction(1, big.NewInt(100000), key) @@ -82,7 +83,7 @@ func TestStateChangeDuringPoolReset(t *testing.T) { statedb, _ = state.New(common.Hash{}, db) // simulate that the new head block included tx0 and tx1 statedb.SetNonce(address, 2) - statedb.SetBalance(address, new(big.Int).Mul(common.Big1, common.Ether)) + statedb.SetBalance(address, new(big.Int).SetUint64(params.Ether)) trigger = false } return stdb, nil diff --git a/core/types/bloom9.go b/core/types/bloom9.go index 32aa47a41..2a37b5977 100644 --- a/core/types/bloom9.go +++ b/core/types/bloom9.go @@ -20,7 +20,6 @@ import ( "fmt" "math/big" - "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/crypto" ) @@ -60,7 +59,7 @@ func (b *Bloom) Add(d *big.Int) { // Big converts b to a big integer. func (b Bloom) Big() *big.Int { - return common.Bytes2Big(b[:]) + return new(big.Int).SetBytes(b[:]) } func (b Bloom) Bytes() []byte { @@ -72,7 +71,8 @@ func (b Bloom) Test(test *big.Int) bool { } func (b Bloom) TestBytes(test []byte) bool { - return b.Test(common.BytesToBig(test)) + return b.Test(new(big.Int).SetBytes(test)) + } // MarshalJSON encodes b as a hex string with 0x prefix. diff --git a/core/vm/common.go b/core/vm/common.go index b7b9a6a9c..ef40c4a95 100644 --- a/core/vm/common.go +++ b/core/vm/common.go @@ -17,15 +17,10 @@ package vm import ( - "math" "math/big" "github.com/ethereum/go-ethereum/common" -) - -var ( - U256 = common.U256 // Shortcut to common.U256 - S256 = common.S256 // Shortcut to common.S256 + "github.com/ethereum/go-ethereum/common/math" ) // calculates the memory size required for a step @@ -42,8 +37,8 @@ func calcMemSize(off, l *big.Int) *big.Int { func getData(data []byte, start, size *big.Int) []byte { dlen := big.NewInt(int64(len(data))) - s := common.BigMin(start, dlen) - e := common.BigMin(new(big.Int).Add(s, size), dlen) + s := math.BigMin(start, dlen) + e := math.BigMin(new(big.Int).Add(s, size), dlen) return common.RightPadBytes(data[s.Uint64():e.Uint64()], int(size.Uint64())) } @@ -61,3 +56,12 @@ func toWordSize(size uint64) uint64 { return (size + 31) / 32 } + +func allZero(b []byte) bool { + for _, byte := range b { + if byte != 0 { + return false + } + } + return true +} diff --git a/core/vm/contracts.go b/core/vm/contracts.go index 2793d2aa7..0479adfda 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -19,6 +19,7 @@ package vm import ( "crypto/sha256" "fmt" + "math/big" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/crypto" @@ -69,13 +70,13 @@ func (c *ecrecover) Run(in []byte) []byte { // "in" is (hash, v, r, s), each 32 bytes // but for ecrecover we want (r, s, v) - r := common.BytesToBig(in[64:96]) - s := common.BytesToBig(in[96:128]) + r := new(big.Int).SetBytes(in[64:96]) + s := new(big.Int).SetBytes(in[96:128]) v := in[63] - 27 // tighter sig s values in homestead only apply to tx sigs - if common.Bytes2Big(in[32:63]).BitLen() > 0 || !crypto.ValidateSignatureValues(v, r, s, false) { - log.Trace(fmt.Sprintf("ECRECOVER error: v, r or s value invalid")) + if !allZero(in[32:63]) || !crypto.ValidateSignatureValues(v, r, s, false) { + log.Trace("ECRECOVER error: v, r or s value invalid") return nil } // v needs to be at the end for libsecp256k1 diff --git a/core/vm/instructions.go b/core/vm/instructions.go index 39e5c0587..8b7bcc4d6 100644 --- a/core/vm/instructions.go +++ b/core/vm/instructions.go @@ -31,7 +31,7 @@ var bigZero = new(big.Int) func opAdd(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { x, y := stack.pop(), stack.pop() - stack.push(U256(x.Add(x, y))) + stack.push(math.U256(x.Add(x, y))) evm.interpreter.intPool.put(y) @@ -40,7 +40,7 @@ func opAdd(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stac func opSub(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { x, y := stack.pop(), stack.pop() - stack.push(U256(x.Sub(x, y))) + stack.push(math.U256(x.Sub(x, y))) evm.interpreter.intPool.put(y) @@ -49,7 +49,7 @@ func opSub(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stac func opMul(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { x, y := stack.pop(), stack.pop() - stack.push(U256(x.Mul(x, y))) + stack.push(math.U256(x.Mul(x, y))) evm.interpreter.intPool.put(y) @@ -59,7 +59,7 @@ func opMul(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stac func opDiv(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { x, y := stack.pop(), stack.pop() if y.Cmp(common.Big0) != 0 { - stack.push(U256(x.Div(x, y))) + stack.push(math.U256(x.Div(x, y))) } else { stack.push(new(big.Int)) } @@ -70,7 +70,7 @@ func opDiv(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stac } func opSdiv(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { - x, y := S256(stack.pop()), S256(stack.pop()) + x, y := math.S256(stack.pop()), math.S256(stack.pop()) if y.Cmp(common.Big0) == 0 { stack.push(new(big.Int)) return nil, nil @@ -85,7 +85,7 @@ func opSdiv(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Sta res := x.Div(x.Abs(x), y.Abs(y)) res.Mul(res, n) - stack.push(U256(res)) + stack.push(math.U256(res)) } evm.interpreter.intPool.put(y) return nil, nil @@ -96,14 +96,14 @@ func opMod(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stac if y.Cmp(common.Big0) == 0 { stack.push(new(big.Int)) } else { - stack.push(U256(x.Mod(x, y))) + stack.push(math.U256(x.Mod(x, y))) } evm.interpreter.intPool.put(y) return nil, nil } func opSmod(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { - x, y := S256(stack.pop()), S256(stack.pop()) + x, y := math.S256(stack.pop()), math.S256(stack.pop()) if y.Cmp(common.Big0) == 0 { stack.push(new(big.Int)) @@ -118,7 +118,7 @@ func opSmod(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Sta res := x.Mod(x.Abs(x), y.Abs(y)) res.Mul(res, n) - stack.push(U256(res)) + stack.push(math.U256(res)) } evm.interpreter.intPool.put(y) return nil, nil @@ -140,13 +140,13 @@ func opSignExtend(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stac num := stack.pop() mask := back.Lsh(common.Big1, bit) mask.Sub(mask, common.Big1) - if common.BitTest(num, int(bit)) { + if num.Bit(int(bit)) > 0 { num.Or(num, mask.Not(mask)) } else { num.And(num, mask) } - stack.push(U256(num)) + stack.push(math.U256(num)) } evm.interpreter.intPool.put(back) @@ -155,7 +155,7 @@ func opSignExtend(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stac func opNot(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { x := stack.pop() - stack.push(U256(x.Not(x))) + stack.push(math.U256(x.Not(x))) return nil, nil } @@ -184,8 +184,8 @@ func opGt(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack } func opSlt(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { - x, y := S256(stack.pop()), S256(stack.pop()) - if x.Cmp(S256(y)) < 0 { + x, y := math.S256(stack.pop()), math.S256(stack.pop()) + if x.Cmp(math.S256(y)) < 0 { stack.push(evm.interpreter.intPool.get().SetUint64(1)) } else { stack.push(new(big.Int)) @@ -196,7 +196,7 @@ func opSlt(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stac } func opSgt(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { - x, y := S256(stack.pop()), S256(stack.pop()) + x, y := math.S256(stack.pop()), math.S256(stack.pop()) if x.Cmp(y) > 0 { stack.push(evm.interpreter.intPool.get().SetUint64(1)) } else { @@ -269,7 +269,7 @@ func opAddmod(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *S if z.Cmp(bigZero) > 0 { add := x.Add(x, y) add.Mod(add, z) - stack.push(U256(add)) + stack.push(math.U256(add)) } else { stack.push(new(big.Int)) } @@ -282,7 +282,7 @@ func opMulmod(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *S if z.Cmp(bigZero) > 0 { mul := x.Mul(x, y) mul.Mod(mul, z) - stack.push(U256(mul)) + stack.push(math.U256(mul)) } else { stack.push(new(big.Int)) } @@ -300,14 +300,14 @@ func opSha3(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Sta evm.StateDB.AddPreimage(common.BytesToHash(hash), data) } - stack.push(common.BytesToBig(hash)) + stack.push(new(big.Int).SetBytes(hash)) evm.interpreter.intPool.put(offset, size) return nil, nil } func opAddress(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { - stack.push(common.Bytes2Big(contract.Address().Bytes())) + stack.push(contract.Address().Big()) return nil, nil } @@ -335,7 +335,7 @@ func opCallValue(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack } func opCalldataLoad(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { - stack.push(common.Bytes2Big(getData(contract.Input, stack.pop(), common.Big32))) + stack.push(new(big.Int).SetBytes(getData(contract.Input, stack.pop(), common.Big32))) return nil, nil } @@ -427,22 +427,22 @@ func opCoinbase(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack } func opTimestamp(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { - stack.push(U256(new(big.Int).Set(evm.Time))) + stack.push(math.U256(new(big.Int).Set(evm.Time))) return nil, nil } func opNumber(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { - stack.push(U256(new(big.Int).Set(evm.BlockNumber))) + stack.push(math.U256(new(big.Int).Set(evm.BlockNumber))) return nil, nil } func opDifficulty(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { - stack.push(U256(new(big.Int).Set(evm.Difficulty))) + stack.push(math.U256(new(big.Int).Set(evm.Difficulty))) return nil, nil } func opGasLimit(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { - stack.push(U256(new(big.Int).Set(evm.GasLimit))) + stack.push(math.U256(new(big.Int).Set(evm.GasLimit))) return nil, nil } @@ -453,7 +453,7 @@ func opPop(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stac func opMload(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { offset := stack.pop() - val := common.BigD(memory.Get(offset.Int64(), 32)) + val := new(big.Int).SetBytes(memory.Get(offset.Int64(), 32)) stack.push(val) evm.interpreter.intPool.put(offset) @@ -463,7 +463,7 @@ func opMload(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *St func opMstore(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { // pop value of the stack mStart, val := stack.pop(), stack.pop() - memory.Set(mStart.Uint64(), 32, common.BigToBytes(val, 256)) + memory.Set(mStart.Uint64(), 32, math.PaddedBigBytes(val, 32)) evm.interpreter.intPool.put(mStart, val) return nil, nil @@ -505,7 +505,7 @@ func opJump(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Sta } func opJumpi(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { pos, cond := stack.pop(), stack.pop() - if cond.Cmp(common.BigTrue) >= 0 { + if cond.BitLen() > 0 { if !contract.jumpdests.has(contract.CodeHash, contract.Code, pos) { nop := contract.GetOp(pos.Uint64()) return nil, fmt.Errorf("invalid jump destination (%v) %v", nop, pos) @@ -572,7 +572,7 @@ func opCall(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Sta gas := stack.pop().Uint64() // pop gas and value of the stack. addr, value := stack.pop(), stack.pop() - value = U256(value) + value = math.U256(value) // pop input size and offset inOffset, inSize := stack.pop(), stack.pop() // pop return size and offset @@ -605,7 +605,7 @@ func opCallCode(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack gas := stack.pop().Uint64() // pop gas and value of the stack. addr, value := stack.pop(), stack.pop() - value = U256(value) + value = math.U256(value) // pop input size and offset inOffset, inSize := stack.pop(), stack.pop() // pop return size and offset @@ -711,7 +711,7 @@ func makeLog(size int) executionFunc { func makePush(size uint64, bsize *big.Int) executionFunc { return func(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { byts := getData(contract.Code, evm.interpreter.intPool.get().SetUint64(*pc+1), bsize) - stack.push(common.Bytes2Big(byts)) + stack.push(new(big.Int).SetBytes(byts)) *pc += size return nil, nil } diff --git a/core/vm/memory_table.go b/core/vm/memory_table.go index 4db994837..3141a2f61 100644 --- a/core/vm/memory_table.go +++ b/core/vm/memory_table.go @@ -3,7 +3,7 @@ package vm import ( "math/big" - "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" ) func memorySha3(stack *Stack) *big.Int { @@ -42,20 +42,20 @@ func memoryCall(stack *Stack) *big.Int { x := calcMemSize(stack.Back(5), stack.Back(6)) y := calcMemSize(stack.Back(3), stack.Back(4)) - return common.BigMax(x, y) + return math.BigMax(x, y) } func memoryCallCode(stack *Stack) *big.Int { x := calcMemSize(stack.Back(5), stack.Back(6)) y := calcMemSize(stack.Back(3), stack.Back(4)) - return common.BigMax(x, y) + return math.BigMax(x, y) } func memoryDelegateCall(stack *Stack) *big.Int { x := calcMemSize(stack.Back(4), stack.Back(5)) y := calcMemSize(stack.Back(2), stack.Back(3)) - return common.BigMax(x, y) + return math.BigMax(x, y) } func memoryReturn(stack *Stack) *big.Int { diff --git a/core/vm/runtime/runtime_test.go b/core/vm/runtime/runtime_test.go index 8ad74a89a..fe39e97a0 100644 --- a/core/vm/runtime/runtime_test.go +++ b/core/vm/runtime/runtime_test.go @@ -87,7 +87,7 @@ func TestExecute(t *testing.T) { t.Fatal("didn't expect error", err) } - num := common.BytesToBig(ret) + num := new(big.Int).SetBytes(ret) if num.Cmp(big.NewInt(10)) != 0 { t.Error("Expected 10, got", num) } @@ -111,7 +111,7 @@ func TestCall(t *testing.T) { t.Fatal("didn't expect error", err) } - num := common.BytesToBig(ret) + num := new(big.Int).SetBytes(ret) if num.Cmp(big.NewInt(10)) != 0 { t.Error("Expected 10, got", num) } diff --git a/crypto/crypto.go b/crypto/crypto.go index 9d67d82e1..ecc3be3ce 100644 --- a/crypto/crypto.go +++ b/crypto/crypto.go @@ -71,7 +71,7 @@ func ToECDSA(prv []byte) *ecdsa.PrivateKey { priv := new(ecdsa.PrivateKey) priv.PublicKey.Curve = S256() - priv.D = common.BigD(prv) + priv.D = new(big.Int).SetBytes(prv) priv.PublicKey.X, priv.PublicKey.Y = priv.PublicKey.Curve.ScalarBaseMult(prv) return priv } diff --git a/eth/api_backend.go b/eth/api_backend.go index 72ed76cc4..5a5c4c532 100644 --- a/eth/api_backend.go +++ b/eth/api_backend.go @@ -21,6 +21,7 @@ import ( "github.com/ethereum/go-ethereum/accounts" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" @@ -109,7 +110,7 @@ func (b *EthApiBackend) GetTd(blockHash common.Hash) *big.Int { func (b *EthApiBackend) GetEVM(ctx context.Context, msg core.Message, state ethapi.State, header *types.Header, vmCfg vm.Config) (*vm.EVM, func() error, error) { statedb := state.(EthApiState).state from := statedb.GetOrNewStateObject(msg.From()) - from.SetBalance(common.MaxBig) + from.SetBalance(math.MaxBig256) vmError := func() error { return nil } context := core.NewEVMContext(msg, header, b.eth.BlockChain()) diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go index ca31c9f4b..8f4bde471 100644 --- a/internal/ethapi/api.go +++ b/internal/ethapi/api.go @@ -21,7 +21,6 @@ import ( "encoding/hex" "errors" "fmt" - "math" "math/big" "strings" "time" @@ -31,6 +30,7 @@ import ( "github.com/ethereum/go-ethereum/accounts/keystore" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" @@ -38,6 +38,7 @@ import ( "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/p2p" + "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/rpc" "github.com/syndtr/goleveldb/leveldb" @@ -45,9 +46,11 @@ import ( "golang.org/x/net/context" ) -const defaultGas = 90000 - -var emptyHex = "0x" +const ( + defaultGas = 90000 + defaultGasPrice = 50 * params.Shannon + emptyHex = "0x" +) // PublicEthereumAPI provides an API to access Ethereum related information. // It offers only methods that operate on public data that is freely available to anyone. @@ -597,7 +600,7 @@ func (s *PublicBlockChainAPI) doCall(ctx context.Context, args CallArgs, blockNr gas = big.NewInt(50000000) } if gasPrice.BitLen() == 0 { - gasPrice = new(big.Int).Mul(big.NewInt(50), common.Shannon) + gasPrice = new(big.Int).SetUint64(defaultGasPrice) } // Create new call message @@ -631,7 +634,7 @@ func (s *PublicBlockChainAPI) doCall(ctx context.Context, args CallArgs, blockNr // Setup the gas pool (also for unmetered requests) // and apply the message. - gp := new(core.GasPool).AddGas(common.MaxBig) + gp := new(core.GasPool).AddGas(math.MaxBig256) res, gas, err := core.ApplyMessage(evm, msg, gp) if err := vmError(); err != nil { return nil, common.Big0, err diff --git a/les/api_backend.go b/les/api_backend.go index ed2a7cd13..264b381f5 100644 --- a/les/api_backend.go +++ b/les/api_backend.go @@ -21,6 +21,7 @@ import ( "github.com/ethereum/go-ethereum/accounts" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" @@ -95,7 +96,7 @@ func (b *LesApiBackend) GetEVM(ctx context.Context, msg core.Message, state etha if err != nil { return nil, nil, err } - from.SetBalance(common.MaxBig) + from.SetBalance(math.MaxBig256) vmstate := light.NewVMState(ctx, stateDb) context := core.NewEVMContext(msg, header, b.eth.blockchain) diff --git a/les/odr_test.go b/les/odr_test.go index 622d89e5c..4f1fccb24 100644 --- a/les/odr_test.go +++ b/les/odr_test.go @@ -23,6 +23,7 @@ import ( "time" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" @@ -118,7 +119,7 @@ func odrContractCall(ctx context.Context, db ethdb.Database, config *params.Chai if err == nil { from := statedb.GetOrNewStateObject(testBankAddress) - from.SetBalance(common.MaxBig) + from.SetBalance(math.MaxBig256) msg := callmsg{types.NewMessage(from.Address(), &testContractAddr, 0, new(big.Int), big.NewInt(100000), new(big.Int), data, false)} @@ -126,7 +127,7 @@ func odrContractCall(ctx context.Context, db ethdb.Database, config *params.Chai vmenv := vm.NewEVM(context, statedb, config, vm.Config{}) //vmenv := core.NewEnv(statedb, config, bc, msg, header, vm.Config{}) - gp := new(core.GasPool).AddGas(common.MaxBig) + gp := new(core.GasPool).AddGas(math.MaxBig256) ret, _, _ := core.ApplyMessage(vmenv, msg, gp) res = append(res, ret...) } @@ -136,7 +137,7 @@ func odrContractCall(ctx context.Context, db ethdb.Database, config *params.Chai vmstate := light.NewVMState(ctx, state) from, err := state.GetOrNewStateObject(ctx, testBankAddress) if err == nil { - from.SetBalance(common.MaxBig) + from.SetBalance(math.MaxBig256) msg := callmsg{types.NewMessage(from.Address(), &testContractAddr, 0, new(big.Int), big.NewInt(100000), new(big.Int), data, false)} @@ -144,7 +145,7 @@ func odrContractCall(ctx context.Context, db ethdb.Database, config *params.Chai vmenv := vm.NewEVM(context, vmstate, config, vm.Config{}) //vmenv := light.NewEnv(ctx, state, config, lc, msg, header, vm.Config{}) - gp := new(core.GasPool).AddGas(common.MaxBig) + gp := new(core.GasPool).AddGas(math.MaxBig256) ret, _, _ := core.ApplyMessage(vmenv, msg, gp) if vmstate.Error() == nil { res = append(res, ret...) diff --git a/light/odr_test.go b/light/odr_test.go index a76050a29..6987db644 100644 --- a/light/odr_test.go +++ b/light/odr_test.go @@ -24,6 +24,7 @@ import ( "time" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" @@ -169,14 +170,14 @@ func odrContractCall(ctx context.Context, db ethdb.Database, bc *core.BlockChain statedb, err := state.New(header.Root, db) if err == nil { from := statedb.GetOrNewStateObject(testBankAddress) - from.SetBalance(common.MaxBig) + from.SetBalance(math.MaxBig256) msg := callmsg{types.NewMessage(from.Address(), &testContractAddr, 0, new(big.Int), big.NewInt(1000000), new(big.Int), data, false)} context := core.NewEVMContext(msg, header, bc) vmenv := vm.NewEVM(context, statedb, config, vm.Config{}) - gp := new(core.GasPool).AddGas(common.MaxBig) + gp := new(core.GasPool).AddGas(math.MaxBig256) ret, _, _ := core.ApplyMessage(vmenv, msg, gp) res = append(res, ret...) } @@ -186,12 +187,12 @@ func odrContractCall(ctx context.Context, db ethdb.Database, bc *core.BlockChain vmstate := NewVMState(ctx, state) from, err := state.GetOrNewStateObject(ctx, testBankAddress) if err == nil { - from.SetBalance(common.MaxBig) + from.SetBalance(math.MaxBig256) msg := callmsg{types.NewMessage(from.Address(), &testContractAddr, 0, new(big.Int), big.NewInt(1000000), new(big.Int), data, false)} context := core.NewEVMContext(msg, header, lc) vmenv := vm.NewEVM(context, vmstate, config, vm.Config{}) - gp := new(core.GasPool).AddGas(common.MaxBig) + gp := new(core.GasPool).AddGas(math.MaxBig256) ret, _, _ := core.ApplyMessage(vmenv, msg, gp) if vmstate.Error() == nil { res = append(res, ret...) diff --git a/miner/worker.go b/miner/worker.go index 037924257..2f090924e 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -561,7 +561,7 @@ func (env *Work) commitTransactions(mux *event.TypeMux, txs *types.TransactionsB // Ignore any transactions (and accounts subsequently) with low gas limits if tx.GasPrice().Cmp(gasPrice) < 0 && !env.ownedAccounts.Has(from) { // Pop the current low-priced transaction without shifting in the next from the account - log.Info(fmt.Sprintf("Transaction (%x) below gas price (tx=%v ask=%v). All sequential txs from this address(%x) will be ignored\n", tx.Hash().Bytes()[:4], common.CurrencyToString(tx.GasPrice()), common.CurrencyToString(gasPrice), from[:4])) + log.Info(fmt.Sprintf("Transaction (%x) below gas price (tx=%dwei ask=%dwei). All sequential txs from this address(%x) will be ignored\n", tx.Hash().Bytes()[:4], tx.GasPrice(), gasPrice, from[:4])) env.lowGasTxs = append(env.lowGasTxs, tx) txs.Pop() diff --git a/mobile/geth.go b/mobile/geth.go index 52c6986fb..872b482d3 100644 --- a/mobile/geth.go +++ b/mobile/geth.go @@ -24,7 +24,6 @@ import ( "math/big" "path/filepath" - "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/eth" "github.com/ethereum/go-ethereum/ethclient" "github.com/ethereum/go-ethereum/ethstats" @@ -145,9 +144,9 @@ func NewNode(datadir string, config *NodeConfig) (stack *Node, _ error) { LightMode: true, DatabaseCache: config.EthereumDatabaseCache, NetworkId: config.EthereumNetworkID, - GasPrice: new(big.Int).Mul(big.NewInt(20), common.Shannon), - GpoMinGasPrice: new(big.Int).Mul(big.NewInt(20), common.Shannon), - GpoMaxGasPrice: new(big.Int).Mul(big.NewInt(500), common.Shannon), + GasPrice: new(big.Int).SetUint64(20 * params.Shannon), + GpoMinGasPrice: new(big.Int).SetUint64(50 * params.Shannon), + GpoMaxGasPrice: new(big.Int).SetUint64(500 * params.Shannon), GpoFullBlockRatio: 80, GpobaseStepDown: 10, GpobaseStepUp: 100, diff --git a/common/math/exp.go b/params/denomination.go index 113b76b39..9e1b52506 100644 --- a/common/math/exp.go +++ b/params/denomination.go @@ -1,4 +1,4 @@ -// Copyright 2016 The go-ethereum Authors +// Copyright 2017 The go-ethereum Authors // This file is part of the go-ethereum library. // // The go-ethereum library is free software: you can redistribute it and/or modify @@ -14,34 +14,21 @@ // You should have received a copy of the GNU Lesser General Public License // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. -package math +package params -import ( - "math/big" - - "github.com/ethereum/go-ethereum/common" +const ( + // These are the multipliers for ether denominations. + // Example: To get the wei value of an amount in 'douglas', use + // + // new(big.Int).Mul(value, big.NewInt(params.Douglas)) + // + Wei = 1 + Ada = 1e3 + Babbage = 1e6 + Shannon = 1e9 + Szabo = 1e12 + Finney = 1e15 + Ether = 1e18 + Einstein = 1e21 + Douglas = 1e42 ) - -// wordSize is the size number of bits in a big.Int Word. -const wordSize = 32 << (uint64(^big.Word(0)) >> 63) - -// Exp implement exponentiation by squaring algorithm. -// -// Exp return a new variable; base and exponent must -// not be changed under any circumstance. -// -// Courtesy @karalabe and @chfast -func Exp(base, exponent *big.Int) *big.Int { - result := big.NewInt(1) - - for _, word := range exponent.Bits() { - for i := 0; i < wordSize; i++ { - if word&1 == 1 { - common.U256(result.Mul(result, base)) - } - common.U256(base.Mul(base, base)) - word >>= 1 - } - } - return result -} diff --git a/tests/state_test_util.go b/tests/state_test_util.go index 064bf4588..81f49efa5 100644 --- a/tests/state_test_util.go +++ b/tests/state_test_util.go @@ -26,6 +26,7 @@ import ( "testing" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" @@ -170,11 +171,11 @@ func runStateTest(chainConfig *params.ChainConfig, test VmTest) error { return fmt.Errorf("did not find expected post-state account: %s", addr) } - if balance := statedb.GetBalance(address); balance.Cmp(common.Big(account.Balance)) != 0 { - return fmt.Errorf("(%x) balance failed. Expected: %v have: %v\n", address[:4], common.String2Big(account.Balance), balance) + if balance := statedb.GetBalance(address); balance.Cmp(math.MustParseBig256(account.Balance)) != 0 { + return fmt.Errorf("(%x) balance failed. Expected: %v have: %v\n", address[:4], math.MustParseBig256(account.Balance), balance) } - if nonce := statedb.GetNonce(address); nonce != common.String2Big(account.Nonce).Uint64() { + if nonce := statedb.GetNonce(address); nonce != math.MustParseUint64(account.Nonce) { return fmt.Errorf("(%x) nonce failed. Expected: %v have: %v\n", address[:4], account.Nonce, nonce) } @@ -205,7 +206,7 @@ func runStateTest(chainConfig *params.ChainConfig, test VmTest) error { func RunState(chainConfig *params.ChainConfig, statedb *state.StateDB, env, tx map[string]string) ([]byte, []*types.Log, *big.Int, error) { environment, msg := NewEVMEnvironment(false, chainConfig, statedb, env, tx) - gaspool := new(core.GasPool).AddGas(common.Big(env["currentGasLimit"])) + gaspool := new(core.GasPool).AddGas(math.MustParseBig256(env["currentGasLimit"])) root, _ := statedb.Commit(false) statedb.Reset(root) diff --git a/tests/transaction_test_util.go b/tests/transaction_test_util.go index d26725867..1ecc73a67 100644 --- a/tests/transaction_test_util.go +++ b/tests/transaction_test_util.go @@ -24,6 +24,7 @@ import ( "runtime" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" @@ -161,7 +162,7 @@ func verifyTxFields(chainConfig *params.ChainConfig, txTest TransactionTest, dec var decodedSender common.Address - signer := types.MakeSigner(chainConfig, common.String2Big(txTest.Blocknumber)) + signer := types.MakeSigner(chainConfig, math.MustParseBig256(txTest.Blocknumber)) decodedSender, err = types.Sender(signer, decodedTx) if err != nil { return err diff --git a/tests/util.go b/tests/util.go index c96c2e06d..ce5b02fed 100644 --- a/tests/util.go +++ b/tests/util.go @@ -24,6 +24,7 @@ import ( "os" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" @@ -119,8 +120,8 @@ func insertAccount(state *state.StateDB, saddr string, account Account) { } addr := common.HexToAddress(saddr) state.SetCode(addr, common.Hex2Bytes(account.Code)) - state.SetNonce(addr, common.Big(account.Nonce).Uint64()) - state.SetBalance(addr, common.Big(account.Balance)) + state.SetNonce(addr, math.MustParseUint64(account.Nonce)) + state.SetBalance(addr, math.MustParseBig256(account.Balance)) for a, v := range account.Storage { state.SetState(addr, common.HexToHash(a), common.HexToHash(v)) } @@ -152,10 +153,10 @@ type VmTest struct { func NewEVMEnvironment(vmTest bool, chainConfig *params.ChainConfig, statedb *state.StateDB, envValues map[string]string, tx map[string]string) (*vm.EVM, core.Message) { var ( data = common.FromHex(tx["data"]) - gas = common.Big(tx["gasLimit"]) - price = common.Big(tx["gasPrice"]) - value = common.Big(tx["value"]) - nonce = common.Big(tx["nonce"]).Uint64() + gas = math.MustParseBig256(tx["gasLimit"]) + price = math.MustParseBig256(tx["gasPrice"]) + value = math.MustParseBig256(tx["value"]) + nonce = math.MustParseUint64(tx["nonce"]) ) origin := common.HexToAddress(tx["caller"]) @@ -198,10 +199,10 @@ func NewEVMEnvironment(vmTest bool, chainConfig *params.ChainConfig, statedb *st Origin: origin, Coinbase: common.HexToAddress(envValues["currentCoinbase"]), - BlockNumber: common.Big(envValues["currentNumber"]), - Time: common.Big(envValues["currentTimestamp"]), - GasLimit: common.Big(envValues["currentGasLimit"]), - Difficulty: common.Big(envValues["currentDifficulty"]), + BlockNumber: math.MustParseBig256(envValues["currentNumber"]), + Time: math.MustParseBig256(envValues["currentTimestamp"]), + GasLimit: math.MustParseBig256(envValues["currentGasLimit"]), + Difficulty: math.MustParseBig256(envValues["currentDifficulty"]), GasPrice: price, } if context.GasPrice == nil { diff --git a/tests/vm_test_util.go b/tests/vm_test_util.go index 4bf2dbfe9..d2ddee039 100644 --- a/tests/vm_test_util.go +++ b/tests/vm_test_util.go @@ -25,6 +25,7 @@ import ( "testing" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" @@ -180,7 +181,7 @@ func runVmTest(test VmTest) error { if len(test.Gas) == 0 && err == nil { return fmt.Errorf("gas unspecified, indicating an error. VM returned (incorrectly) successful") } else { - gexp := common.Big(test.Gas) + gexp := math.MustParseBig256(test.Gas) if gexp.Cmp(gas) != 0 { return fmt.Errorf("gas failed. Expected %v, got %v\n", gexp, gas) } @@ -222,8 +223,8 @@ func RunVm(statedb *state.StateDB, env, exec map[string]string) ([]byte, []*type to = common.HexToAddress(exec["address"]) from = common.HexToAddress(exec["caller"]) data = common.FromHex(exec["data"]) - gas = common.Big(exec["gas"]) - value = common.Big(exec["value"]) + gas = math.MustParseBig256(exec["gas"]) + value = math.MustParseBig256(exec["value"]) ) caller := statedb.GetOrNewStateObject(from) vm.PrecompiledContracts = make(map[common.Address]vm.PrecompiledContract) diff --git a/whisper/whisperv2/envelope.go b/whisper/whisperv2/envelope.go index 7110ab457..9f1c68204 100644 --- a/whisper/whisperv2/envelope.go +++ b/whisper/whisperv2/envelope.go @@ -23,9 +23,11 @@ import ( "crypto/ecdsa" "encoding/binary" "fmt" + "math/big" "time" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto/ecies" "github.com/ethereum/go-ethereum/rlp" @@ -66,7 +68,8 @@ func (self *Envelope) Seal(pow time.Duration) { for i := 0; i < 1024; i++ { binary.BigEndian.PutUint32(d[60:], nonce) - firstBit := common.FirstBitSet(common.BigD(crypto.Keccak256(d))) + d := new(big.Int).SetBytes(crypto.Keccak256(d)) + firstBit := math.FirstBitSet(d) if firstBit > bestBit { self.Nonce, bestBit = nonce, firstBit } diff --git a/whisper/whisperv5/envelope.go b/whisper/whisperv5/envelope.go index 8812ae207..5d882d5dc 100644 --- a/whisper/whisperv5/envelope.go +++ b/whisper/whisperv5/envelope.go @@ -23,10 +23,12 @@ import ( "encoding/binary" "errors" "fmt" - "math" + gmath "math" + "math/big" "time" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto/ecies" "github.com/ethereum/go-ethereum/rlp" @@ -103,8 +105,8 @@ func (e *Envelope) Seal(options *MessageParams) error { for nonce := uint64(0); time.Now().UnixNano() < finish; { for i := 0; i < 1024; i++ { binary.BigEndian.PutUint64(buf[56:], nonce) - h = crypto.Keccak256(buf) - firstBit := common.FirstBitSet(common.BigD(h)) + d := new(big.Int).SetBytes(crypto.Keccak256(buf)) + firstBit := math.FirstBitSet(d) if firstBit > bestBit { e.EnvNonce, bestBit = nonce, firstBit if target > 0 && bestBit >= target { @@ -138,9 +140,9 @@ func (e *Envelope) calculatePoW(diff uint32) { h := crypto.Keccak256(e.rlpWithoutNonce()) copy(buf[:32], h) binary.BigEndian.PutUint64(buf[56:], e.EnvNonce) - h = crypto.Keccak256(buf) - firstBit := common.FirstBitSet(common.BigD(h)) - x := math.Pow(2, float64(firstBit)) + d := new(big.Int).SetBytes(crypto.Keccak256(buf)) + firstBit := math.FirstBitSet(d) + x := gmath.Pow(2, float64(firstBit)) x /= float64(e.size()) x /= float64(e.TTL + diff) e.pow = x @@ -150,8 +152,8 @@ func (e *Envelope) powToFirstBit(pow float64) int { x := pow x *= float64(e.size()) x *= float64(e.TTL) - bits := math.Log2(x) - bits = math.Ceil(bits) + bits := gmath.Log2(x) + bits = gmath.Ceil(bits) return int(bits) } |