// NewWhisperFilter creates and registers a new message filter to watch for inbound whisper messages. func (s *PublicWhisperAPI) NewFilter(args NewFilterArgs) (*rpc.HexNumber, error) { if s.w == nil { return nil, whisperOffLineErr } var id int filter := Filter{ To: crypto.ToECDSAPub(common.FromHex(args.To)), From: crypto.ToECDSAPub(common.FromHex(args.From)), Topics: NewFilterTopics(args.Topics...), Fn: func(message *Message) { wmsg := NewWhisperMessage(message) s.messagesMu.RLock() // Only read lock to the filter pool defer s.messagesMu.RUnlock() if s.messages[id] != nil { s.messages[id].insert(wmsg) } }, } id = s.w.Watch(filter) s.messagesMu.Lock() s.messages[id] = newWhisperFilter(id, s.w) s.messagesMu.Unlock() return rpc.NewHexNumber(id), nil }
func (self *Whisper) Post(payload []string, to, from string, topics []string, priority, ttl uint32) { var data []byte for _, d := range payload { data = append(data, common.FromHex(d)...) } pk := crypto.ToECDSAPub(common.FromHex(from)) if key := self.Whisper.GetIdentity(pk); key != nil { msg := whisper.NewMessage(data) envelope, err := msg.Wrap(time.Duration(priority*100000), whisper.Options{ TTL: time.Duration(ttl) * time.Second, To: crypto.ToECDSAPub(common.FromHex(to)), From: key, Topics: whisper.NewTopicsFromStrings(topics...), }) if err != nil { qlogger.Infoln(err) // handle error return } if err := self.Whisper.Send(envelope); err != nil { qlogger.Infoln(err) // handle error return } } else { qlogger.Infoln("unmatched pub / priv for seal") } }
// Post injects a message into the whisper network for distribution. func (s *PublicWhisperAPI) Post(args PostArgs) (bool, error) { if s.w == nil { return false, whisperOffLineErr } // construct whisper message with transmission options message := NewMessage(common.FromHex(args.Payload)) options := Options{ To: crypto.ToECDSAPub(common.FromHex(args.To)), TTL: time.Duration(args.TTL) * time.Second, Topics: NewTopics(args.Topics...), } // set sender identity if len(args.From) > 0 { if key := s.w.GetIdentity(crypto.ToECDSAPub(common.FromHex(args.From))); key != nil { options.From = key } else { return false, fmt.Errorf("unknown identity to send from: %s", args.From) } } // Wrap and send the message pow := time.Duration(args.Priority) * time.Millisecond envelope, err := message.Wrap(pow, options) if err != nil { return false, err } return true, s.w.Send(envelope) }
// Post injects a message into the whisper network for distribution. func (self *Whisper) Post(payload string, to, from string, topics []string, priority, ttl uint32) error { // Decode the topic strings topicsDecoded := make([][]byte, len(topics)) for i, topic := range topics { topicsDecoded[i] = common.FromHex(topic) } // Construct the whisper message and transmission options message := whisper.NewMessage(common.FromHex(payload)) options := whisper.Options{ To: crypto.ToECDSAPub(common.FromHex(to)), TTL: time.Duration(ttl) * time.Second, Topics: whisper.NewTopics(topicsDecoded...), } if len(from) != 0 { if key := self.Whisper.GetIdentity(crypto.ToECDSAPub(common.FromHex(from))); key != nil { options.From = key } else { return fmt.Errorf("unknown identity to send from: %s", from) } } // Wrap and send the message pow := time.Duration(priority) * time.Millisecond envelope, err := message.Wrap(pow, options) if err != nil { return err } if err := self.Whisper.Send(envelope); err != nil { return err } return nil }
func (self *XEth) EthTransactionByHash(hash string) (tx *types.Transaction, blhash common.Hash, blnum *big.Int, txi uint64) { data, _ := self.backend.ExtraDb().Get(common.FromHex(hash)) if len(data) != 0 { tx = types.NewTransactionFromBytes(data) } else { // check pending transactions tx = self.backend.TxPool().GetTransaction(common.HexToHash(hash)) } // meta var txExtra struct { BlockHash common.Hash BlockIndex uint64 Index uint64 } v, _ := self.backend.ExtraDb().Get(append(common.FromHex(hash), 0x0001)) r := bytes.NewReader(v) err := rlp.Decode(r, &txExtra) if err == nil { blhash = txExtra.BlockHash blnum = big.NewInt(int64(txExtra.BlockIndex)) txi = txExtra.Index } else { glog.V(logger.Error).Infoln(err) } return }
func (self *XEth) EthTransactionByHash(hash string) (tx *types.Transaction, blhash common.Hash, blnum *big.Int, txi uint64) { // Due to increasing return params and need to determine if this is from transaction pool or // some chain, this probably needs to be refactored for more expressiveness data, _ := self.backend.ExtraDb().Get(common.FromHex(hash)) if len(data) != 0 { tx = types.NewTransactionFromBytes(data) } else { // check pending transactions tx = self.backend.TxPool().GetTransaction(common.HexToHash(hash)) } // meta var txExtra struct { BlockHash common.Hash BlockIndex uint64 Index uint64 } v, dberr := self.backend.ExtraDb().Get(append(common.FromHex(hash), 0x0001)) // TODO check specifically for ErrNotFound if dberr != nil { return } r := bytes.NewReader(v) err := rlp.Decode(r, &txExtra) if err == nil { blhash = txExtra.BlockHash blnum = big.NewInt(int64(txExtra.BlockIndex)) txi = txExtra.Index } else { glog.V(logger.Error).Infoln(err) } return }
func filterFromMap(opts map[string]interface{}) (f whisper.Filter) { if to, ok := opts["to"].(string); ok { f.To = crypto.ToECDSAPub(common.FromHex(to)) } if from, ok := opts["from"].(string); ok { f.From = crypto.ToECDSAPub(common.FromHex(from)) } if topicList, ok := opts["topics"].(*qml.List); ok { var topics []string topicList.Convert(&topics) f.Topics = whisper.NewFilterTopicsFromStringsFlat(topics...) } return }
func (args *PostArgs) UnmarshalJSON(data []byte) (err error) { var obj struct { From string `json:"from"` To string `json:"to"` Topics []string `json:"topics"` Payload string `json:"payload"` Priority rpc.HexNumber `json:"priority"` TTL rpc.HexNumber `json:"ttl"` } if err := json.Unmarshal(data, &obj); err != nil { return err } args.From = obj.From args.To = obj.To args.Payload = obj.Payload args.Priority = obj.Priority.Int64() args.TTL = obj.TTL.Int64() // decode topic strings args.Topics = make([][]byte, len(obj.Topics)) for i, topic := range obj.Topics { args.Topics[i] = common.FromHex(topic) } return nil }
func RunState(ruleSet RuleSet, statedb *state.StateDB, env, tx map[string]string) ([]byte, vm.Logs, *big.Int, error) { 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() ) var to *common.Address if len(tx["to"]) > 2 { t := common.HexToAddress(tx["to"]) to = &t } // Set pre compiled contracts vm.Precompiled = vm.PrecompiledContracts() snapshot := statedb.Copy() gaspool := new(core.GasPool).AddGas(common.Big(env["currentGasLimit"])) key, _ := hex.DecodeString(tx["secretKey"]) addr := crypto.PubkeyToAddress(crypto.ToECDSA(key).PublicKey) message := NewMessage(addr, to, data, value, gas, price, nonce) vmenv := NewEnvFromMap(ruleSet, statedb, env, tx) vmenv.origin = addr ret, _, err := core.ApplyMessage(vmenv, message, gaspool) if core.IsNonceErr(err) || core.IsInvalidTxErr(err) || core.IsGasLimitErr(err) { statedb.Set(snapshot) } statedb.Commit() return ret, vmenv.state.Logs(), vmenv.Gas, err }
func (self *XEth) FromNumber(str string) string { if common.IsHex(str) { str = str[2:] } return common.BigD(common.FromHex(str)).String() }
func (js *jsre) unlock(call otto.FunctionCall) otto.Value { addr, err := call.Argument(0).ToString() if err != nil { fmt.Println(err) return otto.FalseValue() } seconds, err := call.Argument(2).ToInteger() if err != nil { fmt.Println(err) return otto.FalseValue() } arg := call.Argument(1) var passphrase string if arg.IsUndefined() { fmt.Println("Please enter a passphrase now.") passphrase, err = readPassword("Passphrase: ", true) if err != nil { utils.Fatalf("%v", err) } } else { passphrase, err = arg.ToString() if err != nil { fmt.Println(err) return otto.FalseValue() } } am := js.ethereum.AccountManager() err = am.TimedUnlock(common.FromHex(addr), passphrase, time.Duration(seconds)*time.Second) if err != nil { fmt.Printf("Unlock account failed '%v'\n", err) return otto.FalseValue() } return otto.TrueValue() }
func RunState(statedb *state.StateDB, env, tx map[string]string) ([]byte, state.Logs, *big.Int, error) { var ( keyPair, _ = crypto.NewKeyPairFromSec([]byte(common.Hex2Bytes(tx["secretKey"]))) 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() caddr = common.HexToAddress(env["currentCoinbase"]) ) var to *common.Address if len(tx["to"]) > 2 { t := common.HexToAddress(tx["to"]) to = &t } // Set pre compiled contracts vm.Precompiled = vm.PrecompiledContracts() snapshot := statedb.Copy() coinbase := statedb.GetOrNewStateObject(caddr) coinbase.SetGasLimit(common.Big(env["currentGasLimit"])) message := NewMessage(common.BytesToAddress(keyPair.Address()), to, data, value, gas, price, nonce) vmenv := NewEnvFromMap(statedb, env, tx) vmenv.origin = common.BytesToAddress(keyPair.Address()) ret, _, err := core.ApplyMessage(vmenv, message, coinbase) if core.IsNonceErr(err) || core.IsInvalidTxErr(err) || state.IsGasLimitErr(err) { statedb.Set(snapshot) } statedb.Update() return ret, vmenv.state.Logs(), vmenv.Gas, err }
// GenesisBlock creates a genesis block with the given nonce. func GenesisBlock(nonce uint64, db common.Database) *types.Block { var accounts map[string]struct { Balance string Code string } err := json.Unmarshal(GenesisAccounts, &accounts) if err != nil { fmt.Println("unable to decode genesis json data:", err) os.Exit(1) } statedb := state.New(common.Hash{}, db) for addr, account := range accounts { codedAddr := common.Hex2Bytes(addr) accountState := statedb.CreateAccount(common.BytesToAddress(codedAddr)) accountState.SetBalance(common.Big(account.Balance)) accountState.SetCode(common.FromHex(account.Code)) statedb.UpdateStateObject(accountState) } statedb.Sync() block := types.NewBlock(&types.Header{ Difficulty: params.GenesisDifficulty, GasLimit: params.GenesisGasLimit, Nonce: types.EncodeNonce(nonce), Root: statedb.Root(), }, nil, nil, nil) block.Td = params.GenesisDifficulty return block }
// ContractCall implements ContractCaller.ContractCall, delegating the execution of // a contract call to the remote node, returning the reply to for local processing. func (b *rpcBackend) ContractCall(contract common.Address, data []byte, pending bool) ([]byte, error) { // Pack up the request into an RPC argument args := struct { To common.Address `json:"to"` Data string `json:"data"` }{ To: contract, Data: common.ToHex(data), } // Execute the RPC call and retrieve the response block := "latest" if pending { block = "pending" } res, err := b.request("eth_call", []interface{}{args, block}) if err != nil { return nil, err } var hex string if err := json.Unmarshal(res, &hex); err != nil { return nil, err } // Convert the response back to a Go byte slice and return return common.FromHex(hex), nil }
func TestNull(t *testing.T) { var trie Trie key := make([]byte, 32) value := common.FromHex("0x823140710bf13990e4500136726d8b55") trie.Update(key, value) value = trie.Get(key) }
func TestLoadECDSAFile(t *testing.T) { keyBytes := common.FromHex(testPrivHex) fileName0 := "test_key0" fileName1 := "test_key1" checkKey := func(k *ecdsa.PrivateKey) { checkAddr(t, PubkeyToAddress(k.PublicKey), common.HexToAddress(testAddrHex)) loadedKeyBytes := FromECDSA(k) if !bytes.Equal(loadedKeyBytes, keyBytes) { t.Fatalf("private key mismatch: want: %x have: %x", keyBytes, loadedKeyBytes) } } ioutil.WriteFile(fileName0, []byte(testPrivHex), 0600) defer os.Remove(fileName0) key0, err := LoadECDSA(fileName0) if err != nil { t.Fatal(err) } checkKey(key0) // again, this time with SaveECDSA instead of manual save: err = SaveECDSA(fileName1, key0) if err != nil { t.Fatal(err) } defer os.Remove(fileName1) key1, err := LoadECDSA(fileName1) if err != nil { t.Fatal(err) } checkKey(key1) }
func Assemble(ir *list.List) (asm []byte, err error) { for e := ir.Front(); e != nil; e = e.Next() { code := strings.Split(e.Value.(string), " ") switch len(code) { case 2: asm = append(asm, byte(vm.StringToOp(code[0]))) if len(code[1]) > 1 && code[1][:2] == "0x" { asm = append(asm, common.FromHex(code[1])...) } else { num := common.String2Big(code[1]).Bytes() if len(num) == 0 { num = []byte{0} } asm = append(asm, num...) } case 1: asm = append(asm, byte(vm.StringToOp(code[0]))) default: return nil, fmt.Errorf("invalid IR %v", code) } } return }
func (self *XEth) FromAscii(str string) string { if common.IsHex(str) { str = str[2:] } return string(bytes.Trim(common.FromHex(str), "\x00")) }
func checkLogs(tlog []Log, logs state.Logs) error { if len(tlog) != len(logs) { return fmt.Errorf("log length mismatch. Expected %d, got %d", len(tlog), len(logs)) } else { for i, log := range tlog { if common.HexToAddress(log.AddressF) != logs[i].Address { return fmt.Errorf("log address expected %v got %x", log.AddressF, logs[i].Address) } if !bytes.Equal(logs[i].Data, common.FromHex(log.DataF)) { return fmt.Errorf("log data expected %v got %x", log.DataF, logs[i].Data) } if len(log.TopicsF) != len(logs[i].Topics) { return fmt.Errorf("log topics length expected %d got %d", len(log.TopicsF), logs[i].Topics) } else { for j, topic := range log.TopicsF { if common.HexToHash(topic) != logs[i].Topics[j] { return fmt.Errorf("log topic[%d] expected %v got %x", j, topic, logs[i].Topics[j]) } } } genBloom := common.LeftPadBytes(types.LogsBloom(state.Logs{logs[i]}).Bytes(), 256) if !bytes.Equal(genBloom, common.Hex2Bytes(log.BloomF)) { return fmt.Errorf("bloom mismatch") } } } return nil }
func (self *XEth) PushTx(encodedTx string) (string, error) { tx := new(types.Transaction) err := rlp.DecodeBytes(common.FromHex(encodedTx), tx) if err != nil { glog.V(logger.Error).Infoln(err) return "", err } err = self.backend.TxPool().Add(tx) if err != nil { return "", err } if tx.To() == nil { from, err := tx.From() if err != nil { return "", err } addr := crypto.CreateAddress(from, tx.Nonce()) glog.V(logger.Info).Infof("Tx(%x) created: %x\n", tx.Hash(), addr) } else { glog.V(logger.Info).Infof("Tx(%x) to: %x\n", tx.Hash(), tx.To()) } return tx.Hash().Hex(), nil }
func (args *DbHexArgs) UnmarshalJSON(b []byte) (err error) { var obj []interface{} if err := json.Unmarshal(b, &obj); err != nil { return shared.NewDecodeParamError(err.Error()) } if len(obj) < 2 { return shared.NewInsufficientParamsError(len(obj), 2) } var objstr string var ok bool if objstr, ok = obj[0].(string); !ok { return shared.NewInvalidTypeError("database", "not a string") } args.Database = objstr if objstr, ok = obj[1].(string); !ok { return shared.NewInvalidTypeError("key", "not a string") } args.Key = objstr if len(obj) > 2 { objstr, ok = obj[2].(string) if !ok { return shared.NewInvalidTypeError("value", "not a string") } args.Value = common.FromHex(objstr) } return nil }
// HasCode implements bind.ContractVerifier.HasCode by retrieving any code associated // with the contract from the local API, and checking its size. func (b *ContractBackend) HasCode(contract common.Address, pending bool) (bool, error) { block := rpc.LatestBlockNumber if pending { block = rpc.PendingBlockNumber } out, err := b.bcapi.GetCode(contract, block) return len(common.FromHex(out)) > 0, err }
func (self *XEth) SecretToAddress(key string) string { pair, err := crypto.NewKeyPairFromSec(common.FromHex(key)) if err != nil { return "" } return common.ToHex(pair.Address()) }
// Calculates the sha3 over req.Params.Data func (self *web3Api) Sha3(req *shared.Request) (interface{}, error) { args := new(Sha3Args) if err := self.codec.Decode(req.Params, &args); err != nil { return nil, err } return common.ToHex(crypto.Sha3(common.FromHex(args.Data))), nil }
func TestTransactionEncode(t *testing.T) { txb, err := rlp.EncodeToBytes(rightvrsTx) if err != nil { t.Fatalf("encode error: %v", err) } should := common.FromHex("f86103018207d094b94f5374fce5edbc8e2a8697c15331677e6ebf0b0a8255441ca098ff921201554726367d2be8c804a7ff89ccf285ebc57dff8ae4c44b9c19ac4aa08887321be575c8095f789dd4c743dfe42c1820f9231f98a962b210e3ac2452a3") if !bytes.Equal(txb, should) { t.Errorf("encoded RLP mismatch, got %x", txb) } }
func (self *XEth) SignTransaction(fromStr, toStr, nonceStr, valueStr, gasStr, gasPriceStr, codeStr string) (*types.Transaction, error) { if len(toStr) > 0 && toStr != "0x" && !isAddress(toStr) { return nil, errors.New("Invalid address") } var ( from = common.HexToAddress(fromStr) to = common.HexToAddress(toStr) value = common.Big(valueStr) gas *big.Int price *big.Int data []byte contractCreation bool ) if len(gasStr) == 0 { gas = DefaultGas() } else { gas = common.Big(gasStr) } if len(gasPriceStr) == 0 { price = self.DefaultGasPrice() } else { price = common.Big(gasPriceStr) } data = common.FromHex(codeStr) if len(toStr) == 0 { contractCreation = true } var nonce uint64 if len(nonceStr) != 0 { nonce = common.Big(nonceStr).Uint64() } else { // XXX: replaced tx pool state with managed state from app // state := self.backend.TxPool().State() state := self.ManagedState() nonce = state.GetNonce(from) } var tx *types.Transaction if contractCreation { tx = types.NewContractCreation(nonce, value, gas, price, data) } else { tx = types.NewTransaction(nonce, to, value, gas, price, data) } signed, err := self.sign(tx, from, false) if err != nil { return nil, err } return signed, nil }
// DeployReleaseOracle deploys a new Ethereum contract, binding an instance of ReleaseOracle to it. func DeployReleaseOracle(auth *bind.TransactOpts, backend bind.ContractBackend, signers []common.Address) (common.Address, *types.Transaction, *ReleaseOracle, error) { parsed, err := abi.JSON(strings.NewReader(ReleaseOracleABI)) if err != nil { return common.Address{}, nil, nil, err } address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ReleaseOracleBin), backend, signers) if err != nil { return common.Address{}, nil, nil, err } return address, tx, &ReleaseOracle{ReleaseOracleCaller: ReleaseOracleCaller{contract: contract}, ReleaseOracleTransactor: ReleaseOracleTransactor{contract: contract}}, nil }
// BlockNumber retrieves the current head number of the blockchain. func (api *API) BlockNumber() (uint64, error) { res, err := api.Request("eth_blockNumber", nil) if err != nil { return 0, err } var hex string if err := json.Unmarshal(res, &hex); err != nil { return 0, err } return new(big.Int).SetBytes(common.FromHex(hex)).Uint64(), nil }
// Watch installs a new message handler to run in case a matching packet arrives // from the whisper network. func (self *Whisper) Watch(to, from string, topics [][]string, fn func(WhisperMessage)) int { // Decode the topic strings topicsDecoded := make([][][]byte, len(topics)) for i, condition := range topics { topicsDecoded[i] = make([][]byte, len(condition)) for j, topic := range condition { topicsDecoded[i][j] = common.FromHex(topic) } } // Assemble and inject the filter into the whisper client filter := whisper.Filter{ To: crypto.ToECDSAPub(common.FromHex(to)), From: crypto.ToECDSAPub(common.FromHex(from)), Topics: whisper.NewFilterTopics(topicsDecoded...), } filter.Fn = func(message *whisper.Message) { fn(NewWhisperMessage(message)) } return self.Whisper.Watch(filter) }
// Syncing returns the current sync status of the node, or nil if the node is not // currently synchronizing with the network. func (api *API) Syncing() (*SyncStatus, error) { // Execute the request and check if syncing is not running res, err := api.Request("eth_syncing", nil) if err != nil { return nil, err } var running bool if err := json.Unmarshal(res, &running); err == nil { return nil, nil } // Sync is running, extract the current status result := make(map[string]string) if err := json.Unmarshal(res, &result); err != nil { return nil, err } return &SyncStatus{ StartingBlock: new(big.Int).SetBytes(common.FromHex(result["startingBlock"])).Uint64(), CurrentBlock: new(big.Int).SetBytes(common.FromHex(result["currentBlock"])).Uint64(), HighestBlock: new(big.Int).SetBytes(common.FromHex(result["highestBlock"])).Uint64(), }, nil }