grassrootseconomics/openethereum
5
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'master' into jg-typedinput-tests

Browse Source
This commit is contained in:
Jaco Greeff 2016-12-12 10:14:29 +01:00
commit f9b5a056cf
39 changed files with 921 additions and 355 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.lock generated
View File

@ -1290,7 +1290,7 @@ dependencies = [
[[package]]
name = "parity-ui-precompiled"
version = "1.4.0"
source = "git+https://github.com/ethcore/js-precompiled.git#76b1f17e5a446de76493530d1d9d330e08d6ceac"
source = "git+https://github.com/ethcore/js-precompiled.git#eb9d978ed5ad1c514b37e89c716f80b3c8d613b5"
dependencies = [
"parity-dapps-glue 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
]

22
ethcore/light/src/net/context.rs
View File

@ -16,7 +16,7 @@
//! I/O and event context generalizations.
use network::{NetworkContext, PeerId};
use network::{NetworkContext, PeerId, NodeId};
use super::{Announcement, LightProtocol, ReqId};
use super::error::Error;
@ -41,8 +41,12 @@ pub trait IoContext {
/// Get a peer's protocol version.
fn protocol_version(&self, peer: PeerId) -> Option<u8>;
/// Persistent peer id
fn persistent_peer_id(&self, peer: PeerId) -> Option<NodeId>;
}
impl<'a> IoContext for NetworkContext<'a> {
fn send(&self, peer: PeerId, packet_id: u8, packet_body: Vec<u8>) {
if let Err(e) = self.send(peer, packet_id, packet_body) {
@ -67,6 +71,10 @@ impl<'a> IoContext for NetworkContext<'a> {
fn protocol_version(&self, peer: PeerId) -> Option<u8> {
self.protocol_version(self.subprotocol_name(), peer)
}
fn persistent_peer_id(&self, peer: PeerId) -> Option<NodeId> {
self.session_info(peer).and_then(|info| info.id)
}
}
/// Context for a protocol event.
@ -75,6 +83,9 @@ pub trait EventContext {
/// disconnected/connected peer.
fn peer(&self) -> PeerId;
/// Returns the relevant's peer persistent Id (aka NodeId).
fn persistent_peer_id(&self, peer: PeerId) -> Option<NodeId>;
/// Make a request from a peer.
fn request_from(&self, peer: PeerId, request: Request) -> Result<ReqId, Error>;
@ -101,7 +112,14 @@ pub struct Ctx<'a> {
}
impl<'a> EventContext for Ctx<'a> {
fn peer(&self) -> PeerId { self.peer }
fn peer(&self) -> PeerId {
self.peer
}
fn persistent_peer_id(&self, id: PeerId) -> Option<NodeId> {
self.io.persistent_peer_id(id)
}
fn request_from(&self, peer: PeerId, request: Request) -> Result<ReqId, Error> {
self.proto.request_from(self.io, &peer, request)
}

6
ethcore/light/src/net/tests/mod.rs
View File

@ -21,7 +21,7 @@ use ethcore::blockchain_info::BlockChainInfo;
use ethcore::client::{BlockChainClient, EachBlockWith, TestBlockChainClient};
use ethcore::ids::BlockId;
use ethcore::transaction::SignedTransaction;
use network::PeerId;
use network::{PeerId, NodeId};
use net::buffer_flow::FlowParams;
use net::context::IoContext;
@ -68,6 +68,10 @@ impl IoContext for Expect {
fn protocol_version(&self, _peer: PeerId) -> Option<u8> {
Some(super::MAX_PROTOCOL_VERSION)
}
fn persistent_peer_id(&self, _peer: PeerId) -> Option<NodeId> {
None
}
}
// can't implement directly for Arc due to cross-crate orphan rules.

8
ethcore/src/client/chain_notify.rs
View File

@ -40,6 +40,14 @@ pub trait ChainNotify : Send + Sync {
fn stop(&self) {
// does nothing by default
}
/// fires when new transactions are received from a peer
fn transactions_received(&self,
_hashes: Vec<H256>,
_peer_id: usize,
) {
// does nothing by default
}
}
impl IpcConfig for ChainNotify { }

12
ethcore/src/client/client.rs
View File

@ -559,11 +559,15 @@ impl Client {
}
/// Import transactions from the IO queue
pub fn import_queued_transactions(&self, transactions: &[Bytes]) -> usize {
pub fn import_queued_transactions(&self, transactions: &[Bytes], peer_id: usize) -> usize {
trace!(target: "external_tx", "Importing queued");
let _timer = PerfTimer::new("import_queued_transactions");
self.queue_transactions.fetch_sub(transactions.len(), AtomicOrdering::SeqCst);
let txs = transactions.iter().filter_map(|bytes| UntrustedRlp::new(bytes).as_val().ok()).collect();
let txs: Vec<SignedTransaction> = transactions.iter().filter_map(|bytes| UntrustedRlp::new(bytes).as_val().ok()).collect();
let hashes: Vec<_> = txs.iter().map(|tx| tx.hash()).collect();
self.notify(|notify| {
notify.transactions_received(hashes.clone(), peer_id);
});
let results = self.miner.import_external_transactions(self, txs);
results.len()
}
@ -1264,14 +1268,14 @@ impl BlockChainClient for Client {
(*self.build_last_hashes(self.chain.read().best_block_hash())).clone()
}
fn queue_transactions(&self, transactions: Vec<Bytes>) {
fn queue_transactions(&self, transactions: Vec<Bytes>, peer_id: usize) {
let queue_size = self.queue_transactions.load(AtomicOrdering::Relaxed);
trace!(target: "external_tx", "Queue size: {}", queue_size);
if queue_size > MAX_TX_QUEUE_SIZE {
debug!("Ignoring {} transactions: queue is full", transactions.len());
} else {
let len = transactions.len();
match self.io_channel.lock().send(ClientIoMessage::NewTransactions(transactions)) {
match self.io_channel.lock().send(ClientIoMessage::NewTransactions(transactions, peer_id)) {
Ok(_) => {
self.queue_transactions.fetch_add(len, AtomicOrdering::SeqCst);
}

2
ethcore/src/client/test_client.rs
View File

@ -657,7 +657,7 @@ impl BlockChainClient for TestBlockChainClient {
unimplemented!();
}
fn queue_transactions(&self, transactions: Vec<Bytes>) {
fn queue_transactions(&self, transactions: Vec<Bytes>, _peer_id: usize) {
// import right here
let txs = transactions.into_iter().filter_map(|bytes| UntrustedRlp::new(&bytes).as_val().ok()).collect();
self.miner.import_external_transactions(self, txs);

2
ethcore/src/client/traits.rs
View File

@ -200,7 +200,7 @@ pub trait BlockChainClient : Sync + Send {
fn last_hashes(&self) -> LastHashes;
/// Queue transactions for importing.
fn queue_transactions(&self, transactions: Vec<Bytes>);
fn queue_transactions(&self, transactions: Vec<Bytes>, peer_id: usize);
/// list all transactions
fn pending_transactions(&self) -> Vec<SignedTransaction>;

6
ethcore/src/service.rs
View File

@ -39,7 +39,7 @@ pub enum ClientIoMessage {
/// A block is ready
BlockVerified,
/// New transaction RLPs are ready to be imported
NewTransactions(Vec<Bytes>),
NewTransactions(Vec<Bytes>, usize),
/// Begin snapshot restoration
BeginRestoration(ManifestData),
/// Feed a state chunk to the snapshot service
@ -196,7 +196,9 @@ impl IoHandler<ClientIoMessage> for ClientIoHandler {
match *net_message {
ClientIoMessage::BlockVerified => { self.client.import_verified_blocks(); }
ClientIoMessage::NewTransactions(ref transactions) => { self.client.import_queued_transactions(transactions); }
ClientIoMessage::NewTransactions(ref transactions, peer_id) => {
self.client.import_queued_transactions(transactions, peer_id);
}
ClientIoMessage::BeginRestoration(ref manifest) => {
if let Err(e) = self.snapshot.init_restore(manifest.clone(), true) {
warn!("Failed to initialize snapshot restoration: {}", e);

2
js/package.json
View File

@ -1,6 +1,6 @@
{
"name": "parity.js",
"version": "0.2.116",
"version": "0.2.119",
"main": "release/index.js",
"jsnext:main": "src/index.js",
"author": "Parity Team <admin@parity.io>",

1
js/src/dapps/localtx/Transaction/transaction.js
View File

@ -48,7 +48,6 @@ class BaseTransaction extends Component {
<IdentityIcon
address={ transaction.from }
/>
0x{ transaction.nonce.toString(16) }
</div>
);
}

2
js/src/dapps/localtx/Transaction/transaction.spec.js
View File

@ -34,7 +34,7 @@ describe('dapps/localtx/Transaction', () => {
it('renders without crashing', () => {
const transaction = {
hash: '0x1234567890',
nonce: 15,
nonce: new BigNumber(15),
gasPrice: new BigNumber(10),
gas: new BigNumber(10)
};

158
js/src/modals/AddAddress/addAddress.js
View File

@ -14,31 +14,29 @@
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
import React, { Component, PropTypes } from 'react';
import ContentAdd from 'material-ui/svg-icons/content/add';
import ContentClear from 'material-ui/svg-icons/content/clear';
import { observer } from 'mobx-react';
import React, { Component, PropTypes } from 'react';
import { FormattedMessage } from 'react-intl';
import { Button, Modal, Form, Input, InputAddress } from '~/ui';
import { ERRORS, validateAddress, validateName } from '~/util/validation';
import { Button, Form, Input, InputAddress, Modal } from '~/ui';
import Store from './store';
@observer
export default class AddAddress extends Component {
static contextTypes = {
api: PropTypes.object.isRequired
}
static propTypes = {
contacts: PropTypes.object.isRequired,
address: PropTypes.string,
onClose: PropTypes.func
contacts: PropTypes.object.isRequired,
onClose: PropTypes.func.isRequired
};
state = {
address: '',
addressError: ERRORS.invalidAddress,
name: '',
nameError: ERRORS.invalidName,
description: ''
};
store = new Store(this.context.api, this.props.contacts);
componentWillMount () {
if (this.props.address) {
@ -49,109 +47,113 @@ export default class AddAddress extends Component {
render () {
return (
<Modal
visible
actions={ this.renderDialogActions() }
title='add saved address'>
title={
<FormattedMessage
id='addAddress.label'
defaultMessage='add saved address' />
}
visible>
{ this.renderFields() }
</Modal>
);
}
renderDialogActions () {
const { addressError, nameError } = this.state;
const hasError = !!(addressError || nameError);
const { hasError } = this.store;
return ([
<Button
icon={ <ContentClear /> }
label='Cancel'
onClick={ this.onClose } />,
label={
<FormattedMessage
id='addAddress.button.close'
defaultMessage='Cancel' />
}
onClick={ this.onClose }
ref='closeButton' />,
<Button
icon={ <ContentAdd /> }
label='Save Address'
disabled={ hasError }
onClick={ this.onAdd } />
icon={ <ContentAdd /> }
label={
<FormattedMessage
id='addAddress.button.add'
defaultMessage='Save Address' />
}
onClick={ this.onAdd }
ref='addButton' />
]);
}
renderFields () {
const { address, addressError, description, name, nameError } = this.state;
const { address, addressError, description, name, nameError } = this.store;
return (
<Form>
<InputAddress
label='network address'
hint='the network address for the entry'
error={ addressError }
value={ address }
disabled={ !!this.props.address }
allowCopy={ false }
onChange={ this.onEditAddress } />
disabled={ !!this.props.address }
error={ addressError }
hint={
<FormattedMessage
id='addAddress.input.address.hint'
defaultMessage='the network address for the entry' />
}
label={
<FormattedMessage
id='addAddress.input.address.label'
defaultMessage='network address' />
}
onChange={ this.onEditAddress }
ref='inputAddress'
value={ address } />
<Input
label='address name'
hint='a descriptive name for the entry'
error={ nameError }
value={ name }
onChange={ this.onEditName } />
hint={
<FormattedMessage
id='addAddress.input.name.hint'
defaultMessage='a descriptive name for the entry' />
}
label={
<FormattedMessage
id='addAddress.input.name.label'
defaultMessage='address name' />
}
onChange={ this.onEditName }
ref='inputName'
value={ name } />
<Input
multiLine
rows={ 1 }
label='(optional) address description'
hint='an expanded description for the entry'
value={ description }
onChange={ this.onEditDescription } />
hint={
<FormattedMessage
id='addAddress.input.description.hint'
defaultMessage='an expanded description for the entry' />
}
label={
<FormattedMessage
id='addAddress.input.description.label'
defaultMessage='(optional) address description' />
}
onChange={ this.onEditDescription }
ref='inputDescription'
value={ description } />
</Form>
);
}
onEditAddress = (event, _address) => {
const { contacts } = this.props;
let { address, addressError } = validateAddress(_address);
if (!addressError) {
const contact = contacts[address];
if (contact) {
addressError = ERRORS.duplicateAddress;
}
}
this.setState({
address,
addressError
});
onEditAddress = (event, address) => {
this.store.setAddress(address);
}
onEditDescription = (event, description) => {
this.setState({
description
});
this.store.setDescription(description);
}
onEditName = (event, _name) => {
const { name, nameError } = validateName(_name);
this.setState({
name,
nameError
});
onEditName = (event, name) => {
this.store.setName(name);
}
onAdd = () => {
const { api } = this.context;
const { address, name, description } = this.state;
Promise.all([
api.parity.setAccountName(address, name),
api.parity.setAccountMeta(address, {
description,
timestamp: Date.now(),
deleted: false
})
]).catch((error) => {
console.error('onAdd', error);
});
this.store.add();
this.props.onClose();
}

32
js/src/modals/AddAddress/addAddress.spec.js Normal file
View File

@ -0,0 +1,32 @@
// Copyright 2015, 2016 Parity Technologies (UK) Ltd.
// This file is part of Parity.
// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Parity 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 General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
import { shallow } from 'enzyme';
import React from 'react';
import AddAddress from './';
describe('modals/AddAddress', () => {
describe('rendering', () => {
it('renders defaults', () => {
expect(
shallow(
<AddAddress />
)
).to.be.ok;
});
});
});

87
js/src/modals/AddAddress/store.js Normal file
View File

@ -0,0 +1,87 @@
// Copyright 2015, 2016 Parity Technologies (UK) Ltd.
// This file is part of Parity.
// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Parity 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 General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
import { action, computed, transaction, observable } from 'mobx';
import { ERRORS, validateAddress, validateName } from '~/util/validation';
export default class Store {
@observable address = '';
@observable addressError = ERRORS.invalidAddress;
@observable createError = null;
@observable description = '';
@observable name = '';
@observable nameError = ERRORS.invalidName;
constructor (api, contacts) {
this._api = api;
this._contacts = contacts;
}
@computed get hasError () {
return !!(this.addressError || this.nameError);
}
@action setAddress = (_address) => {
let { address, addressError } = validateAddress(_address);
if (!addressError) {
const contact = this._contacts[address];
if (contact) {
addressError = ERRORS.duplicateAddress;
}
}
transaction(() => {
this.address = address;
this.addressError = addressError;
});
}
@action setCreateError = (error) => {
this.createError = error;
}
@action setDescription = (description) => {
this.description = description;
}
@action setName = (_name) => {
const { name, nameError } = validateName(_name);
transaction(() => {
this.name = name;
this.nameError = nameError;
});
}
add () {
return Promise
.all([
this._api.parity.setAccountName(this.address, this.name),
this._api.parity.setAccountMeta(this.address, {
description: this.description,
timestamp: Date.now(),
deleted: false
})
])
.catch((error) => {
console.warn('Store:add', error);
this.setCreateError(error);
});
}
}

128
js/src/modals/AddAddress/store.spec.js Normal file
View File

@ -0,0 +1,128 @@
// Copyright 2015, 2016 Parity Technologies (UK) Ltd.
// This file is part of Parity.
// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Parity 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 General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
import sinon from 'sinon';
import Store from './store';
import { TEST_ADDR_A, TEST_ADDR_B, TEST_CONTACTS } from './store.test.js';
describe('modals/AddAddress/store', () => {
let store;
describe('@action', () => {
beforeEach(() => {
store = new Store(null, TEST_CONTACTS);
});
describe('setAddress', () => {
it('successfully sets non-existent addresses', () => {
store.setAddress(TEST_ADDR_B);
expect(store.addressError).to.be.null;
expect(store.address).to.equal(TEST_ADDR_B);
});
it('fails on invalid addresses', () => {
store.setAddress('0xinvalid');
expect(store.addressError).not.to.be.null;
});
it('fails when an address is already added', () => {
store.setAddress(TEST_ADDR_A);
expect(store.addressError).not.to.be.null;
});
});
describe('setName', () => {
it('sucessfully sets valid names', () => {
const name = 'Test Name';
store.setName(name);
expect(store.nameError).to.be.null;
expect(store.name).to.equal(name);
});
it('fails when name is invalid', () => {
store.setName(null);
expect(store.nameError).not.to.be.null;
});
});
});
describe('@computed', () => {
beforeEach(() => {
store = new Store(null, TEST_CONTACTS);
});
describe('hasError', () => {
beforeEach(() => {
store.setAddress(TEST_ADDR_B);
store.setName('Test Name');
});
it('returns false proper inputs', () => {
expect(store.hasError).to.be.false;
});
it('returns true with addressError', () => {
store.setAddress(TEST_ADDR_A);
expect(store.addressError).not.to.be.null;
expect(store.hasError).to.be.true;
});
it('returns true with nameError', () => {
store.setName(null);
expect(store.nameError).not.to.be.null;
expect(store.hasError).to.be.true;
});
});
});
describe('methods', () => {
let api;
beforeEach(() => {
api = {
parity: {
setAccountMeta: sinon.stub().resolves(true),
setAccountName: sinon.stub().resolves(true)
}
};
store = new Store(api, {});
});
describe('add', () => {
it('calls setAccountMeta', () => {
store.add();
expect(api.parity.setAccountMeta).to.have.been.called;
});
it('calls setAccountName', () => {
store.add();
expect(api.parity.setAccountName).to.have.been.called;
});
});
});
});

28
js/src/modals/AddAddress/store.test.js Normal file
View File

@ -0,0 +1,28 @@
// Copyright 2015, 2016 Parity Technologies (UK) Ltd.
// This file is part of Parity.
// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Parity 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 General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
const TEST_ADDR_A = '0x63Cf90D3f0410092FC0fca41846f596223979195';
const TEST_ADDR_B = '0x00A40dEfa9933e82244bE542Fa7F8748eCCdd457';
const TEST_CONTACTS = {
[TEST_ADDR_A]: { name: 'test', meta: {} }
};
export {
TEST_ADDR_A,
TEST_ADDR_B,
TEST_CONTACTS
};

5
js/src/redux/providers/personalActions.js
View File

@ -19,6 +19,8 @@ import { isEqual } from 'lodash';
import { fetchBalances } from './balancesActions';
import { attachWallets } from './walletActions';
import MethodDecodingStore from '~/ui/MethodDecoding/methodDecodingStore';
export function personalAccountsInfo (accountsInfo) {
const accounts = {};
const contacts = {};
@ -41,6 +43,9 @@ export function personalAccountsInfo (accountsInfo) {
}
});
// Load user contracts for Method Decoding
MethodDecodingStore.loadContracts(contracts);
return (dispatch) => {
const data = {
accountsInfo,

50
js/src/ui/Form/AddressSelect/addressSelect.js
View File

@ -16,6 +16,7 @@
import React, { Component, PropTypes } from 'react';
import { MenuItem } from 'material-ui';
import { isEqual, pick } from 'lodash';
import AutoComplete from '../AutoComplete';
import IdentityIcon from '../../IdentityIcon';
@ -31,19 +32,20 @@ export default class AddressSelect extends Component {
}
static propTypes = {
disabled: PropTypes.bool,
onChange: PropTypes.func.isRequired,
accounts: PropTypes.object,
allowInput: PropTypes.bool,
balances: PropTypes.object,
contacts: PropTypes.object,
contracts: PropTypes.object,
wallets: PropTypes.object,
label: PropTypes.string,
hint: PropTypes.string,
disabled: PropTypes.bool,
error: PropTypes.string,
value: PropTypes.string,
hint: PropTypes.string,
label: PropTypes.string,
tokens: PropTypes.object,
onChange: PropTypes.func.isRequired,
allowInput: PropTypes.bool,
balances: PropTypes.object
value: PropTypes.string,
wallets: PropTypes.object
}
state = {
@ -53,6 +55,9 @@ export default class AddressSelect extends Component {
value: ''
}
// Cache autocomplete items
items = {}
entriesFromProps (props = this.props) {
const { accounts = {}, contacts = {}, contracts = {}, wallets = {} } = props;
@ -76,6 +81,15 @@ export default class AddressSelect extends Component {
return { autocompleteEntries, entries };
}
shouldComponentUpdate (nextProps, nextState) {
const keys = [ 'error', 'value' ];
const prevValues = pick(this.props, keys);
const nextValues = pick(nextProps, keys);
return !isEqual(prevValues, nextValues);
}
componentWillMount () {
const { value } = this.props;
const { entries, autocompleteEntries } = this.entriesFromProps();
@ -143,14 +157,21 @@ export default class AddressSelect extends Component {
renderItem = (entry) => {
const { address, name } = entry;
return {
const _balance = this.getBalance(address);
const balance = _balance ? _balance.toNumber() : _balance;
if (!this.items[address] || this.items[address].balance !== balance) {
this.items[address] = {
text: name && name.toUpperCase() || address,
value: this.renderMenuItem(address),
address
address, balance
};
}
renderBalance (address) {
return this.items[address];
}
getBalance (address) {
const { balances = {} } = this.props;
const balance = balances[address];
@ -164,7 +185,12 @@ export default class AddressSelect extends Component {
return null;
}
const value = fromWei(ethToken.value);
return ethToken.value;
}
renderBalance (address) {
const balance = this.getBalance(address);
const value = fromWei(balance);
return (
<div className={ styles.balance }>

24
js/src/ui/Form/AutoComplete/autocomplete.css Normal file
View File

@ -0,0 +1,24 @@
/* Copyright 2015, 2016 Ethcore (UK) Ltd.
/* This file is part of Parity.
/*
/* Parity is free software: you can redistribute it and/or modify
/* it under the terms of the GNU General Public License as published by
/* the Free Software Foundation, either version 3 of the License, or
/* (at your option) any later version.
/*
/* Parity 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 General Public License for more details.
/*
/* You should have received a copy of the GNU General Public License
/* along with Parity. If not, see <http://www.gnu.org/licenses/>.
*/
.item {
&:last-child {
&.divider {
display: none;
}
}
}

22
js/src/ui/Form/AutoComplete/autocomplete.js
View File

@ -21,13 +21,18 @@ import { PopoverAnimationVertical } from 'material-ui/Popover';
import { isEqual } from 'lodash';
import styles from './autocomplete.css';
// Hack to prevent "Unknown prop `disableFocusRipple` on <hr> tag" error
class Divider extends Component {
static muiName = MUIDivider.muiName;
render () {
return (
<div style={ { margin: '0.25em 0' } }>
<div
style={ { margin: '0.25em 0' } }
className={ [styles.item, styles.divider].join(' ') }
>
<MUIDivider style={ { height: 2 } } />
</div>
);
@ -143,11 +148,16 @@ export default class AutoComplete extends Component {
if (renderItem && typeof renderItem === 'function') {
item = renderItem(entry);
// Add the item class to the entry
const classNames = [ styles.item ].concat(item.value.props.className);
item.value = React.cloneElement(item.value, { className: classNames.join(' ') });
} else {
item = {
text: entry,
value: (
<MenuItem
className={ styles.item }
primaryText={ entry }
/>
)
@ -160,6 +170,7 @@ export default class AutoComplete extends Component {
}
item.divider = currentDivider;
item.entry = entry;
return item;
}).filter((item) => item !== undefined);
@ -215,13 +226,8 @@ export default class AutoComplete extends Component {
return;
}
const { entries } = this.props;
const entriesArray = (entries instanceof Array)
? entries
: Object.values(entries);
const entry = entriesArray[idx];
const { dataSource } = this.state;
const { entry } = dataSource[idx];
this.handleOnChange(entry);
this.setState({ entry, open: false });

55
js/src/ui/Form/Input/input.js
View File

@ -18,6 +18,8 @@ import React, { Component, PropTypes } from 'react';
import { TextField } from 'material-ui';
import { noop } from 'lodash';
import { nodeOrStringProptype } from '~/util/proptypes';
import CopyToClipboard from '../../CopyToClipboard';
import styles from './input.css';
@ -41,18 +43,21 @@ const NAME_ID = ' ';
export default class Input extends Component {
static propTypes = {
children: PropTypes.node,
className: PropTypes.string,
disabled: PropTypes.bool,
readOnly: PropTypes.bool,
allowCopy: PropTypes.oneOfType([
PropTypes.string,
PropTypes.bool
]),
floatCopy: PropTypes.bool,
children: PropTypes.node,
className: PropTypes.string,
disabled: PropTypes.bool,
error: PropTypes.string,
hint: PropTypes.string,
label: PropTypes.string,
readOnly: PropTypes.bool,
floatCopy: PropTypes.bool,
hint: nodeOrStringProptype(),
hideUnderline: PropTypes.bool,
label: nodeOrStringProptype(),
max: PropTypes.any,
min: PropTypes.any,
multiLine: PropTypes.bool,
onBlur: PropTypes.func,
onChange: PropTypes.func,
@ -61,26 +66,26 @@ export default class Input extends Component {
rows: PropTypes.number,
type: PropTypes.string,
submitOnBlur: PropTypes.bool,
hideUnderline: PropTypes.bool,
style: PropTypes.object,
value: PropTypes.oneOfType([
PropTypes.number, PropTypes.string
]),
min: PropTypes.any,
max: PropTypes.any,
style: PropTypes.object
PropTypes.number,
PropTypes.string
])
};
static defaultProps = {
submitOnBlur: true,
readOnly: false,
allowCopy: false,
hideUnderline: false,
floatCopy: false,
readOnly: false,
submitOnBlur: true,
style: {}
}
state = {
value: typeof this.props.value === 'undefined' ? '' : this.props.value
value: typeof this.props.value === 'undefined'
? ''
: this.props.value
}
componentWillReceiveProps (newProps) {
@ -114,38 +119,29 @@ export default class Input extends Component {
autoComplete='off'
className={ className }
errorText={ error }
floatingLabelFixed
floatingLabelText={ label }
fullWidth
hintText={ hint }
id={ NAME_ID }
inputStyle={ inputStyle }
fullWidth
max={ max }
min={ min }
multiLine={ multiLine }
name={ NAME_ID }
onBlur={ this.onBlur }
onChange={ this.onChange }
onKeyDown={ this.onKeyDown }
onPaste={ this.onPaste }
readOnly={ readOnly }
rows={ rows }
style={ textFieldStyle }
type={ type || 'text' }
underlineDisabledStyle={ UNDERLINE_DISABLED }
underlineStyle={ readOnly ? UNDERLINE_READONLY : UNDERLINE_NORMAL }
underlineFocusStyle={ readOnly ? { display: 'none' } : null }
underlineShow={ !hideUnderline }
value={ value }
>
value={ value }>
{ children }
</TextField>
</div>
@ -159,11 +155,14 @@ export default class Input extends Component {
if (!allowCopy) {
return null;
}
const text = typeof allowCopy === 'string'
? allowCopy
: value;
const style = hideUnderline ? {} : { position: 'relative', top: '2px' };
const style = hideUnderline
? {}
: { position: 'relative', top: '2px' };
return (
<div className={ styles.copy } style={ style }>

45
js/src/ui/Form/InputAddress/inputAddress.js
View File

@ -18,28 +18,30 @@ import React, { Component, PropTypes } from 'react';
import { connect } from 'react-redux';
import { bindActionCreators } from 'redux';
import Input from '../Input';
import IdentityIcon from '../../IdentityIcon';
import util from '~/api/util';
import { nodeOrStringProptype } from '~/util/proptypes';
import IdentityIcon from '../../IdentityIcon';
import Input from '../Input';
import styles from './inputAddress.css';
class InputAddress extends Component {
static propTypes = {
accountsInfo: PropTypes.object,
allowCopy: PropTypes.bool,
className: PropTypes.string,
disabled: PropTypes.bool,
error: PropTypes.string,
label: PropTypes.string,
hint: PropTypes.string,
value: PropTypes.string,
accountsInfo: PropTypes.object,
tokens: PropTypes.object,
text: PropTypes.bool,
hideUnderline: PropTypes.bool,
hint: nodeOrStringProptype(),
label: nodeOrStringProptype(),
onChange: PropTypes.func,
onSubmit: PropTypes.func,
hideUnderline: PropTypes.bool,
allowCopy: PropTypes.bool,
small: PropTypes.bool
small: PropTypes.bool,
text: PropTypes.bool,
tokens: PropTypes.object,
value: PropTypes.string
};
static defaultProps = {
@ -49,8 +51,8 @@ class InputAddress extends Component {
};
render () {
const { className, disabled, error, label, hint, value, text } = this.props;
const { small, allowCopy, hideUnderline, onSubmit, accountsInfo, tokens } = this.props;
const { className, disabled, error, hint, label, text, value } = this.props;
const { accountsInfo, allowCopy, hideUnderline, onSubmit, small, tokens } = this.props;
const account = accountsInfo[value] || tokens[value];
@ -68,17 +70,20 @@ class InputAddress extends Component {
return (
<div className={ containerClasses.join(' ') }>
<Input
allowCopy={ allowCopy && (disabled ? value : false) }
className={ classes.join(' ') }
disabled={ disabled }
label={ label }
hint={ hint }
error={ error }
value={ text && account ? account.name : value }
hideUnderline={ hideUnderline }
hint={ hint }
label={ label }
onChange={ this.handleInputChange }
onSubmit={ onSubmit }
allowCopy={ allowCopy && (disabled ? value : false) }
hideUnderline={ hideUnderline }
/>
value={
text && account
? account.name
: value
} />
{ icon }
</div>
);
@ -128,8 +133,8 @@ class InputAddress extends Component {
}
function mapStateToProps (state) {
const { accountsInfo } = state.personal;
const { tokens } = state.balances;
const { accountsInfo } = state.personal;
return {
accountsInfo,

136
js/src/ui/MethodDecoding/methodDecoding.js
View File

@ -17,16 +17,14 @@
import BigNumber from 'bignumber.js';
import React, { Component, PropTypes } from 'react';
import { connect } from 'react-redux';
import { bindActionCreators } from 'redux';
import CircularProgress from 'material-ui/CircularProgress';
import Contracts from '~/contracts';
import { Input, InputAddress } from '../Form';
import MethodDecodingStore from './methodDecodingStore';
import styles from './methodDecoding.css';
const ASCII_INPUT = /^[a-z0-9\s,?;.:/!()-_@'"#]+$/i;
const CONTRACT_CREATE = '0x60606040';
const TOKEN_METHODS = {
'0xa9059cbb': 'transfer(to,value)'
};
@ -38,19 +36,17 @@ class MethodDecoding extends Component {
static propTypes = {
address: PropTypes.string.isRequired,
tokens: PropTypes.object,
token: PropTypes.object,
transaction: PropTypes.object,
historic: PropTypes.bool
}
state = {
contractAddress: null,
method: null,
methodName: null,
methodInputs: null,
methodParams: null,
methodSignature: null,
token: null,
isContract: false,
isDeploy: false,
isReceived: false,
@ -59,14 +55,29 @@ class MethodDecoding extends Component {
inputType: 'auto'
}
componentWillMount () {
const lookupResult = this.lookup();
methodDecodingStore = MethodDecodingStore.get(this.context.api);
if (typeof lookupResult === 'object' && typeof lookupResult.then === 'function') {
lookupResult.then(() => this.setState({ isLoading: false }));
} else {
this.setState({ isLoading: false });
}
componentWillMount () {
const { address, transaction } = this.props;
this
.methodDecodingStore
.lookup(address, transaction)
.then((lookup) => {
const newState = {
methodName: lookup.name,
methodInputs: lookup.inputs,
methodParams: lookup.params,
methodSignature: lookup.signature,
isContract: lookup.contract,
isDeploy: lookup.deploy,
isLoading: false,
isReceived: lookup.received
};
this.setState(newState);
});
}
render () {
@ -116,7 +127,8 @@ class MethodDecoding extends Component {
}
renderAction () {
const { methodName, methodInputs, methodSignature, token, isDeploy, isReceived, isContract } = this.state;
const { token } = this.props;
const { methodName, methodInputs, methodSignature, isDeploy, isReceived, isContract } = this.state;
if (isDeploy) {
return this.renderDeploy();
@ -378,7 +390,7 @@ class MethodDecoding extends Component {
}
renderTokenValue (value) {
const { token } = this.state;
const { token } = this.props;
return (
<span className={ styles.tokenValue }>
@ -436,96 +448,18 @@ class MethodDecoding extends Component {
});
}
lookup () {
const { transaction } = this.props;
if (!transaction) {
return;
}
const { api } = this.context;
const { address, tokens } = this.props;
function mapStateToProps (initState, initProps) {
const { tokens } = initState.balances;
const { address } = initProps;
const isReceived = transaction.to === address;
const contractAddress = isReceived ? transaction.from : transaction.to;
const input = transaction.input || transaction.data;
const token = (tokens || {})[address];
const token = (tokens || {})[contractAddress];
this.setState({ token, isReceived, contractAddress });
if (!input || input === '0x') {
return;
return () => {
return { token };
};
}
const { signature, paramdata } = api.util.decodeCallData(input);
this.setState({ methodSignature: signature, methodParams: paramdata });
if (!signature || signature === CONTRACT_CREATE || transaction.creates) {
this.setState({ isDeploy: true });
return;
}
if (contractAddress === '0x') {
return;
}
return api.eth
.getCode(contractAddress || transaction.creates)
.then((bytecode) => {
const isContract = bytecode && /^(0x)?([0]*[1-9a-f]+[0]*)+$/.test(bytecode);
this.setState({ isContract });
if (!isContract) {
return;
}
return Contracts.get()
.signatureReg
.lookup(signature)
.then((method) => {
let methodInputs = null;
let methodName = null;
if (method && method.length) {
const { methodParams } = this.state;
const abi = api.util.methodToAbi(method);
methodName = abi.name;
methodInputs = api.util
.decodeMethodInput(abi, methodParams)
.map((value, index) => {
const type = abi.inputs[index].type;
return { type, value };
});
}
this.setState({
method,
methodName,
methodInputs,
bytecode
});
});
})
.catch((error) => {
console.warn('lookup', error);
});
}
}
function mapStateToProps (state) {
const { tokens } = state.balances;
return { tokens };
}
function mapDispatchToProps (dispatch) {
return bindActionCreators({}, dispatch);
}
export default connect(
mapStateToProps,
mapDispatchToProps
mapStateToProps
)(MethodDecoding);

216
js/src/ui/MethodDecoding/methodDecodingStore.js Normal file
View File

@ -0,0 +1,216 @@
// Copyright 2015, 2016 Ethcore (UK) Ltd.
// This file is part of Parity.
// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Parity 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 General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
import Contracts from '~/contracts';
import Abi from '~/abi';
import * as abis from '~/contracts/abi';
const CONTRACT_CREATE = '0x60606040';
let instance = null;
export default class MethodDecodingStore {
api = null;
_isContract = {};
_methods = {};
constructor (api, contracts = {}) {
this.api = api;
// Load the signatures from the local ABIs
Object.keys(abis).forEach((abiKey) => {
this.loadFromAbi(abis[abiKey]);
});
this.addContracts(contracts);
}
addContracts (contracts = {}) {
// Load the User defined contracts
Object.values(contracts).forEach((contract) => {
if (!contract || !contract.meta || !contract.meta.abi) {
return;
}
this.loadFromAbi(contract.meta.abi);
});
}
loadFromAbi (_abi) {
const abi = new Abi(_abi);
abi
.functions
.map((f) => ({ sign: f.signature, abi: f.abi }))
.forEach((mapping) => {
const sign = (/^0x/.test(mapping.sign) ? '' : '0x') + mapping.sign;
this._methods[sign] = mapping.abi;
});
}
static get (api, contracts = {}) {
if (!instance) {
instance = new MethodDecodingStore(api, contracts);
}
// Set API if not set yet
if (!instance.api) {
instance.api = api;
}
return instance;
}
static loadContracts (contracts = {}) {
if (!instance) {
// Just create the instance with null API
MethodDecodingStore.get(null, contracts);
} else {
instance.addContracts(contracts);
}
}
/**
* Looks up a transaction in the context of the given
* address
*
* @param {String} address The address contract
* @param {Object} transaction The transaction to lookup
* @return {Promise} The result of the lookup. Resolves with:
* {
* contract: Boolean,
* deploy: Boolean,
* inputs: Array,
* name: String,
* params: Array,
* received: Boolean,
* signature: String
* }
*/
lookup (address, transaction) {
const result = {};
if (!transaction) {
return Promise.resolve(result);
}
const isReceived = transaction.to === address;
const contractAddress = isReceived ? transaction.from : transaction.to;
const input = transaction.input || transaction.data;
result.received = isReceived;
// No input, should be a ETH transfer
if (!input || input === '0x') {
return Promise.resolve(result);
}
const { signature, paramdata } = this.api.util.decodeCallData(input);
result.signature = signature;
result.params = paramdata;
// Contract deployment
if (!signature || signature === CONTRACT_CREATE || transaction.creates) {
return Promise.resolve({ ...result, deploy: true });
}
return this
.isContract(contractAddress || transaction.creates)
.then((isContract) => {
result.contract = isContract;
if (!isContract) {
return result;
}
return this
.fetchMethodAbi(signature)
.then((abi) => {
let methodName = null;
let methodInputs = null;
if (abi) {
methodName = abi.name;
methodInputs = this.api.util
.decodeMethodInput(abi, paramdata)
.map((value, index) => {
const type = abi.inputs[index].type;
return { type, value };
});
}
return {
...result,
name: methodName,
inputs: methodInputs
};
});
})
.catch((error) => {
console.warn('lookup', error);
});
}
fetchMethodAbi (signature) {
if (this._methods[signature] !== undefined) {
return Promise.resolve(this._methods[signature]);
}
this._methods[signature] = Contracts.get()
.signatureReg
.lookup(signature)
.then((method) => {
let abi = null;
if (method && method.length) {
abi = this.api.util.methodToAbi(method);
}
this._methods[signature] = abi;
return this._methods[signature];
});
return Promise.resolve(this._methods[signature]);
}
/**
* Checks (and caches) if the given address is a
* Contract or not, from its fetched bytecode
*/
isContract (contractAddress) {
// If zero address, it isn't a contract
if (/^(0x)?0*$/.test(contractAddress)) {
return Promise.resolve(false);
}
if (this._isContract[contractAddress]) {
return Promise.resolve(this._isContract[contractAddress]);
}
this._isContract[contractAddress] = this.api.eth
.getCode(contractAddress)
.then((bytecode) => {
// Is a contract if the address contains *valid* bytecode
const _isContract = bytecode && /^(0x)?([0]*[1-9a-f]+[0]*)+$/.test(bytecode);
this._isContract[contractAddress] = _isContract;
return this._isContract[contractAddress];
});
return Promise.resolve(this._isContract[contractAddress]);
}
}

21
js/src/ui/Modal/modal.js
View File

@ -42,11 +42,11 @@ class Modal extends Component {
className: PropTypes.string,
compact: PropTypes.bool,
current: PropTypes.number,
waiting: PropTypes.array,
settings: PropTypes.object.isRequired,
steps: PropTypes.array,
title: nodeOrStringProptype(),
visible: PropTypes.bool.isRequired,
settings: PropTypes.object.isRequired
waiting: PropTypes.array
}
render () {
@ -55,23 +55,23 @@ class Modal extends Component {
const contentStyle = muiTheme.parity.getBackgroundStyle(null, settings.backgroundSeed);
const header = (
<Title
current={ current }
busy={ busy }
waiting={ waiting }
current={ current }
steps={ steps }
title={ title } />
title={ title }
waiting={ waiting } />
);
const classes = `${styles.dialog} ${className}`;
return (
<Dialog
className={ classes }
actions={ actions }
actionsContainerClassName={ styles.actions }
actionsContainerStyle={ ACTIONS_STYLE }
autoDetectWindowHeight={ false }
autoScrollBodyContent
actionsContainerClassName={ styles.actions }
bodyClassName={ styles.body }
className={ classes }
contentClassName={ styles.content }
contentStyle={ contentStyle }
modal
@ -82,7 +82,12 @@ class Modal extends Component {
style={ DIALOG_STYLE }
title={ header }
titleStyle={ TITLE_STYLE }>
<Container light compact={ compact } style={ { transition: 'none' } }>
<Container
compact={ compact }
light
style={
{ transition: 'none' }
}>
{ children }
</Container>
</Dialog>

27
js/src/views/Account/Transactions/transactions.js
View File

@ -19,7 +19,7 @@ import { connect } from 'react-redux';
import { bindActionCreators } from 'redux';
import etherscan from '~/3rdparty/etherscan';
import { Container, TxList } from '~/ui';
import { Container, TxList, Loading } from '~/ui';
import styles from './transactions.css';
@ -60,19 +60,32 @@ class Transactions extends Component {
}
render () {
const { address } = this.props;
const { hashes } = this.state;
return (
<Container title='transactions'>
<TxList
address={ address }
hashes={ hashes } />
{ this.renderTransactionList() }
{ this.renderEtherscanFooter() }
</Container>
);
}
renderTransactionList () {
const { address } = this.props;
const { hashes, loading } = this.state;
if (loading) {
return (
<Loading />
);
}
return (
<TxList
address={ address }
hashes={ hashes }
/>
);
}
renderEtherscanFooter () {
const { traceMode } = this.props;

4
js/src/views/WriteContract/writeContract.css
View File

@ -32,6 +32,10 @@
flex: 1;
flex-direction: row;
// Fallback for browsers not supporting `calc`
min-height: 90vh;
min-height: calc(100vh - 8em);
> * {
margin: 0;

4
js/test/mocha.config.js
View File

@ -15,11 +15,13 @@
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
import 'isomorphic-fetch';
import 'mock-local-storage';
import es6Promise from 'es6-promise';
es6Promise.polyfill();
import 'mock-local-storage';
import injectTapEventPlugin from 'react-tap-event-plugin';
injectTapEventPlugin();
import chai from 'chai';
import chaiAsPromised from 'chai-as-promised';

5
rpc/src/v1/impls/signing.rs
View File

@ -18,7 +18,7 @@
use std::sync::{Arc, Weak};
use transient_hashmap::TransientHashMap;
use util::{U256, Mutex};
use util::{U256, Mutex, Hashable};
use ethcore::account_provider::AccountProvider;
use ethcore::miner::MinerService;
@ -180,7 +180,8 @@ impl<C: 'static, M: 'static> EthSigning for SigningQueueClient<C, M> where
C: MiningBlockChainClient,
M: MinerService,
{
fn sign(&self, ready: Ready<RpcH520>, address: RpcH160, hash: RpcH256) {
fn sign(&self, ready: Ready<RpcH520>, address: RpcH160, data: RpcBytes) {
let hash = data.0.sha3().into();
let res = self.active().and_then(|_| self.dispatch(RpcConfirmationPayload::Signature((address, hash).into())));
self.handle_dispatch(res, |response| {
match response {

4
rpc/src/v1/impls/signing_unsafe.rs
View File

@ -17,6 +17,7 @@
//! Unsafe Signing RPC implementation.
use std::sync::{Arc, Weak};
use util::Hashable;
use ethcore::account_provider::AccountProvider;
use ethcore::miner::MinerService;
@ -83,7 +84,8 @@ impl<C: 'static, M: 'static> EthSigning for SigningUnsafeClient<C, M> where
C: MiningBlockChainClient,
M: MinerService,
{
fn sign(&self, ready: Ready<RpcH520>, address: RpcH160, hash: RpcH256) {
fn sign(&self, ready: Ready<RpcH520>, address: RpcH160, data: RpcBytes) {
let hash = data.0.sha3().into();
let result = match self.handle(RpcConfirmationPayload::Signature((address, hash).into())) {
Ok(RpcConfirmationResponse::Signature(signature)) => Ok(signature),
Err(e) => Err(e),

4
rpc/src/v1/tests/helpers/sync_provider.rs
View File

@ -105,13 +105,13 @@ impl SyncProvider for TestSyncProvider {
first_seen: 10,
propagated_to: map![
128.into() => 16
]
],
},
5.into() => TransactionStats {
first_seen: 16,
propagated_to: map![
16.into() => 1
]
],
}
]
}

8
rpc/src/v1/tests/mocked/eth.rs
View File

@ -18,11 +18,11 @@ use std::str::FromStr;
use std::collections::HashMap;
use std::sync::Arc;
use std::time::{Instant, Duration};
use rustc_serialize::hex::ToHex;
use rustc_serialize::hex::{FromHex, ToHex};
use time::get_time;
use rlp;
use util::{Uint, U256, Address, H256, FixedHash, Mutex};
use util::{Uint, U256, Address, H256, FixedHash, Mutex, Hashable};
use ethcore::account_provider::AccountProvider;
use ethcore::client::{TestBlockChainClient, EachBlockWith, Executed, TransactionId};
use ethcore::log_entry::{LocalizedLogEntry, LogEntry};
@ -294,8 +294,8 @@ fn rpc_eth_sign() {
let account = tester.accounts_provider.new_account("abcd").unwrap();
tester.accounts_provider.unlock_account_permanently(account, "abcd".into()).unwrap();
let message = H256::from("0x0cc175b9c0f1b6a831c399e26977266192eb5ffee6ae2fec3ad71c777531578f");
let signed = tester.accounts_provider.sign(account, None, message).unwrap();
let message = "0cc175b9c0f1b6a831c399e26977266192eb5ffee6ae2fec3ad71c777531578f".from_hex().unwrap();
let signed = tester.accounts_provider.sign(account, None, message.sha3()).unwrap();
let req = r#"{
"jsonrpc": "2.0",

8
rpc/src/v1/tests/mocked/signing.rs
View File

@ -26,7 +26,7 @@ use v1::types::ConfirmationResponse;
use v1::tests::helpers::TestMinerService;
use v1::tests::mocked::parity;
use util::{Address, FixedHash, Uint, U256, H256, ToPretty};
use util::{Address, FixedHash, Uint, U256, ToPretty, Hashable};
use ethcore::account_provider::AccountProvider;
use ethcore::client::TestBlockChainClient;
use ethcore::transaction::{Transaction, Action};
@ -186,11 +186,11 @@ fn should_check_status_of_request_when_its_resolved() {
fn should_sign_if_account_is_unlocked() {
// given
let tester = eth_signing();
let hash: H256 = 5.into();
let data = vec![5u8];
let acc = tester.accounts.new_account("test").unwrap();
tester.accounts.unlock_account_permanently(acc, "test".into()).unwrap();
let signature = tester.accounts.sign(acc, None, hash).unwrap();
let signature = tester.accounts.sign(acc, None, data.sha3()).unwrap();
// when
let request = r#"{
@ -198,7 +198,7 @@ fn should_sign_if_account_is_unlocked() {
"method": "eth_sign",
"params": [
""#.to_owned() + format!("0x{:?}", acc).as_ref() + r#"",
""# + format!("0x{:?}", hash).as_ref() + r#""
""# + format!("0x{}", data.to_hex()).as_ref() + r#""
],
"id": 1
}"#;

6
rpc/src/v1/traits/eth_signing.rs
View File

@ -17,14 +17,14 @@
//! Eth rpc interface.
use v1::helpers::auto_args::{WrapAsync, Ready};
use v1::types::{H160, H256, H520, TransactionRequest, RichRawTransaction};
use v1::types::{Bytes, H160, H256, H520, TransactionRequest, RichRawTransaction};
build_rpc_trait! {
/// Signing methods implementation relying on unlocked accounts.
pub trait EthSigning {
/// Signs the data with given address signature.
/// Signs the hash of data with given address signature.
#[rpc(async, name = "eth_sign")]
fn sign(&self, Ready<H520>, H160, H256);
fn sign(&self, Ready<H520>, H160, Bytes);
/// Sends transaction; will block waiting for signer to return the
/// transaction hash.

4
rpc/src/v1/types/sync.rs
View File

@ -157,7 +157,7 @@ impl From<SyncTransactionStats> for TransactionStats {
propagated_to: s.propagated_to
.into_iter()
.map(|(id, count)| (id.into(), count))
.collect()
.collect(),
}
}
}
@ -208,7 +208,7 @@ mod tests {
first_seen: 100,
propagated_to: map![
10.into() => 50
]
],
};
let serialized = serde_json::to_string(&stats).unwrap();

7
sync/src/api.rs
View File

@ -335,6 +335,11 @@ impl ChainNotify for EthSync {
self.sync_handler.snapshot_service.abort_restore();
self.network.stop().unwrap_or_else(|e| warn!("Error stopping network: {:?}", e));
}
fn transactions_received(&self, hashes: Vec<H256>, peer_id: PeerId) {
let mut sync = self.sync_handler.sync.write();
sync.transactions_received(hashes, peer_id);
}
}
/// LES event handler.
@ -344,7 +349,7 @@ struct TxRelay(Arc<BlockChainClient>);
impl LightHandler for TxRelay {
fn on_transactions(&self, ctx: &EventContext, relay: &[::ethcore::transaction::SignedTransaction]) {
trace!(target: "les", "Relaying {} transactions from peer {}", relay.len(), ctx.peer());
self.0.queue_transactions(relay.iter().map(|tx| ::rlp::encode(tx).to_vec()).collect())
self.0.queue_transactions(relay.iter().map(|tx| ::rlp::encode(tx).to_vec()).collect(), ctx.peer())
}
}

9
sync/src/chain.rs
View File

@ -432,6 +432,13 @@ impl ChainSync {
self.transactions_stats.stats()
}
/// Updates transactions were received by a peer
pub fn transactions_received(&mut self, hashes: Vec<H256>, peer_id: PeerId) {
if let Some(mut peer_info) = self.peers.get_mut(&peer_id) {
peer_info.last_sent_transactions.extend(&hashes);
}
}
/// Abort all sync activity
pub fn abort(&mut self, io: &mut SyncIo) {
self.reset_and_continue(io);
@ -1409,7 +1416,7 @@ impl ChainSync {
let tx = rlp.as_raw().to_vec();
transactions.push(tx);
}
io.chain().queue_transactions(transactions);
io.chain().queue_transactions(transactions, peer_id);
Ok(())
}

2
sync/src/transactions_stats.rs
View File

@ -112,7 +112,7 @@ mod tests {
propagated_to: hash_map![
enodeid1 => 2,
enodeid2 => 1
]
],
}));
}

2
util/network/src/lib.rs
View File

@ -99,7 +99,7 @@ pub use stats::NetworkStats;
pub use session::SessionInfo;
use io::TimerToken;
pub use node_table::is_valid_node_url;
pub use node_table::{is_valid_node_url, NodeId};
const PROTOCOL_VERSION: u32 = 4;