func (k *Key) UnmarshalJSON(j []byte) (err error) { keyJSON := new(plainKeyJSON) err = json.Unmarshal(j, &keyJSON) if err != nil { return err } u := new(uuid.UUID) *u = uuid.Parse(keyJSON.Id) k.Id = *u addr, err := hex.DecodeString(keyJSON.Address) if err != nil { return err } privkey, err := hex.DecodeString(keyJSON.PrivateKey) if err != nil { return err } k.Address = common.BytesToAddress(addr) k.PrivateKey = ToECDSA(privkey) return nil }
// UnlockAccount asks the user agent for the user password and tries to unlock the account. // It will try 3 attempts before giving up. func (fe *RemoteFrontend) UnlockAccount(address []byte) bool { if !fe.enabled { return false } err := fe.send(AskPasswordMethod, common.Bytes2Hex(address)) if err != nil { glog.V(logger.Error).Infof("Unable to send password request to agent - %v\n", err) return false } passwdRes, err := fe.recv() if err != nil { glog.V(logger.Error).Infof("Unable to recv password response from agent - %v\n", err) return false } if passwd, ok := passwdRes.Result.(string); ok { err = fe.mgr.Unlock(common.BytesToAddress(address), passwd) } if err == nil { return true } glog.V(logger.Debug).Infoln("3 invalid account unlock attempts") return false }
func (self *testjethre) UnlockAccount(acc []byte) bool { err := self.ethereum.AccountManager().Unlock(common.BytesToAddress(acc), "") if err != nil { panic("unable to unlock") } return true }
func mustConvertAddress(in string) common.Address { out, err := hex.DecodeString(strings.TrimPrefix(in, "0x")) if err != nil { panic(fmt.Errorf("invalid hex: %q", in)) } return common.BytesToAddress(out) }
func (self *jsre) IsAccountLocked(addr []byte) bool { fmt.Printf("Please check account lock status %x.\n", addr) locked := self.ethereum.AccountManager().IsLocked(common.BytesToAddress(addr)) if locked { fmt.Println("Account is still locked.") } else { fmt.Println("Account is still unlocked.") } return locked }
func (self *jsre) UnlockAccount(addr []byte) bool { fmt.Printf("Please unlock account %x.\n", addr) pass, err := self.PasswordPrompt("Passphrase: ") if err != nil { return false } // TODO: allow retry if err := self.ethereum.AccountManager().Unlock(common.BytesToAddress(addr), pass); err != nil { return false } else { fmt.Println("Account is now unlocked for this session.") return true } }
func (t *BlockTest) ValidatePostState(statedb *state.StateDB) error { for addrString, acct := range t.preAccounts { // XXX: is is worth it checking for errors here? addr, err := hex.DecodeString(addrString) if err != nil { return err } code, err := hex.DecodeString(strings.TrimPrefix(acct.Code, "0x")) if err != nil { return err } balance, ok := new(big.Int).SetString(acct.Balance, 0) if !ok { return err } nonce, err := strconv.ParseUint(prepInt(16, acct.Nonce), 16, 64) if err != nil { return err } // address is indirectly verified by the other fields, as it's the db key code2 := statedb.GetCode(common.BytesToAddress(addr)) balance2 := statedb.GetBalance(common.BytesToAddress(addr)) nonce2 := statedb.GetNonce(common.BytesToAddress(addr)) if !bytes.Equal(code2, code) { return fmt.Errorf("account code mismatch, addr, found, expected: ", addrString, hex.EncodeToString(code2), hex.EncodeToString(code)) } if balance2.Cmp(balance) != 0 { return fmt.Errorf("account balance mismatch, addr, found, expected: ", addrString, balance2, balance) } if nonce2 != nonce { return fmt.Errorf("account nonce mismatch, addr, found, expected: ", addrString, nonce2, nonce) } } return nil }
// InsertPreState populates the given database with the genesis // accounts defined by the test. func (t *BlockTest) InsertPreState(ethereum *eth.Ethereum) (*state.StateDB, error) { db := ethereum.ChainDb() statedb := state.New(common.Hash{}, db) for addrString, acct := range t.preAccounts { addr, err := hex.DecodeString(addrString) if err != nil { return nil, err } code, err := hex.DecodeString(strings.TrimPrefix(acct.Code, "0x")) if err != nil { return nil, err } balance, ok := new(big.Int).SetString(acct.Balance, 0) if !ok { return nil, err } nonce, err := strconv.ParseUint(prepInt(16, acct.Nonce), 16, 64) if err != nil { return nil, err } if acct.PrivateKey != "" { privkey, err := hex.DecodeString(strings.TrimPrefix(acct.PrivateKey, "0x")) err = crypto.ImportBlockTestKey(privkey) err = ethereum.AccountManager().TimedUnlock(common.BytesToAddress(addr), "", 999999*time.Second) if err != nil { return nil, err } } obj := statedb.CreateAccount(common.HexToAddress(addrString)) obj.SetCode(code) obj.SetBalance(balance) obj.SetNonce(nonce) for k, v := range acct.Storage { statedb.SetState(common.HexToAddress(addrString), common.HexToHash(k), common.HexToHash(v)) } } // sync objects to trie statedb.SyncObjects() // sync trie to disk statedb.Sync() if !bytes.Equal(t.Genesis.Root().Bytes(), statedb.Root().Bytes()) { return nil, fmt.Errorf("computed state root does not match genesis block %x %x", t.Genesis.Root().Bytes()[:4], statedb.Root().Bytes()[:4]) } return statedb, nil }
func getKeyAddresses(keysDirPath string) (addresses []common.Address, err error) { fileInfos, err := ioutil.ReadDir(keysDirPath) if err != nil { return nil, err } for _, fileInfo := range fileInfos { filename := fileInfo.Name() if len(filename) >= 40 { addr := filename[len(filename)-40 : len(filename)] address, err := hex.DecodeString(addr) if err == nil { addresses = append(addresses, common.BytesToAddress(address)) } } } return addresses, err }
func (self *StateDB) RawDump() World { world := World{ Root: common.Bytes2Hex(self.trie.Root()), Accounts: make(map[string]Account), } it := self.trie.Iterator() for it.Next() { addr := self.trie.GetKey(it.Key) stateObject := NewStateObjectFromBytes(common.BytesToAddress(addr), it.Value, self.db) account := Account{Balance: stateObject.balance.String(), Nonce: stateObject.nonce, Root: common.Bytes2Hex(stateObject.Root()), CodeHash: common.Bytes2Hex(stateObject.codeHash)} account.Storage = make(map[string]string) storageIt := stateObject.trie.Iterator() for storageIt.Next() { account.Storage[common.Bytes2Hex(self.trie.GetKey(storageIt.Key))] = common.Bytes2Hex(storageIt.Value) } world.Accounts[common.Bytes2Hex(addr)] = account } return world }
// 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 state import ( "testing" "github.com/shiftcurrency/shift/common" "github.com/shiftcurrency/shift/ethdb" ) var addr = common.BytesToAddress([]byte("test")) func create() (*ManagedState, *account) { db, _ := ethdb.NewMemDatabase() statedb := New(common.Hash{}, db) ms := ManageState(statedb) so := &StateObject{address: addr, nonce: 100} ms.StateDB.stateObjects[addr.Str()] = so ms.accounts[addr.Str()] = newAccount(so) return ms, ms.accounts[addr.Str()] } func TestNewNonce(t *testing.T) { ms, _ := create()
// Creates an ethereum address given the bytes and the nonce func CreateAddress(b common.Address, nonce uint64) common.Address { data, _ := rlp.EncodeToBytes([]interface{}{b, nonce}) return common.BytesToAddress(Sha3(data)[12:]) //return Sha3(common.NewValue([]interface{}{b, nonce}).Encode())[12:] }
func verifyTxFields(txTest TransactionTest, decodedTx *types.Transaction) (err error) { defer func() { if recovered := recover(); recovered != nil { buf := make([]byte, 64<<10) buf = buf[:runtime.Stack(buf, false)] err = fmt.Errorf("%v\n%s", recovered, buf) } }() decodedSender, err := decodedTx.From() if err != nil { return err } expectedSender := mustConvertAddress(txTest.Sender) if expectedSender != decodedSender { return fmt.Errorf("Sender mismatch: %v %v", expectedSender, decodedSender) } expectedData := mustConvertBytes(txTest.Transaction.Data) if !bytes.Equal(expectedData, decodedTx.Data()) { return fmt.Errorf("Tx input data mismatch: %#v %#v", expectedData, decodedTx.Data()) } expectedGasLimit := mustConvertBigInt(txTest.Transaction.GasLimit, 16) if expectedGasLimit.Cmp(decodedTx.Gas()) != 0 { return fmt.Errorf("GasLimit mismatch: %v %v", expectedGasLimit, decodedTx.Gas()) } expectedGasPrice := mustConvertBigInt(txTest.Transaction.GasPrice, 16) if expectedGasPrice.Cmp(decodedTx.GasPrice()) != 0 { return fmt.Errorf("GasPrice mismatch: %v %v", expectedGasPrice, decodedTx.GasPrice()) } expectedNonce := mustConvertUint(txTest.Transaction.Nonce, 16) if expectedNonce != decodedTx.Nonce() { return fmt.Errorf("Nonce mismatch: %v %v", expectedNonce, decodedTx.Nonce()) } v, r, s := decodedTx.SignatureValues() expectedR := mustConvertBigInt(txTest.Transaction.R, 16) if r.Cmp(expectedR) != 0 { return fmt.Errorf("R mismatch: %v %v", expectedR, r) } expectedS := mustConvertBigInt(txTest.Transaction.S, 16) if s.Cmp(expectedS) != 0 { return fmt.Errorf("S mismatch: %v %v", expectedS, s) } expectedV := mustConvertUint(txTest.Transaction.V, 16) if uint64(v) != expectedV { return fmt.Errorf("V mismatch: %v %v", expectedV, v) } expectedTo := mustConvertAddress(txTest.Transaction.To) if decodedTx.To() == nil { if expectedTo != common.BytesToAddress([]byte{}) { // "empty" or "zero" address return fmt.Errorf("To mismatch when recipient is nil (contract creation): %v", expectedTo) } } else { if expectedTo != *decodedTx.To() { return fmt.Errorf("To mismatch: %v %v", expectedTo, *decodedTx.To()) } } expectedValue := mustConvertBigInt(txTest.Transaction.Value, 16) if expectedValue.Cmp(decodedTx.Value()) != 0 { return fmt.Errorf("Value mismatch: %v %v", expectedValue, decodedTx.Value()) } return nil }
func (self *testjethre) IsAccountLocked(acc []byte) bool { return self.ethereum.AccountManager().IsLocked(common.BytesToAddress(acc)) }
func (self *testFrontend) UnlockAccount(acc []byte) bool { self.ethereum.AccountManager().Unlock(common.BytesToAddress(acc), "password") return true }
func (self *testFrontend) IsAccountLocked(acc []byte) bool { self.ethereum.AccountManager().IsLocked(common.BytesToAddress(acc)) return true }
func PubkeyToAddress(p ecdsa.PublicKey) common.Address { pubBytes := FromECDSAPub(&p) return common.BytesToAddress(Sha3(pubBytes[1:])[12:]) }