Merge branch 'master' into evm-instructions

Conflicts: evmbin/bench.sh
2016-07-12 10:32:40 +02:00
parent c7a11418bb 7200cfcbc9
commit 2746c1c18c
44 changed files with 559 additions and 536 deletions
--- a/ethcore/src/block.rs
+++ b/ethcore/src/block.rs
@@ -16,8 +16,6 @@

 //! Blockchain block.

-#![cfg_attr(feature="dev", allow(ptr_arg))] // Because of &LastHashes -> &Vec<_>
-
 use common::*;
 use engine::*;
 use state::*;
@@ -76,11 +74,11 @@ pub struct BlockRefMut<'a> {
 	/// Block header.
 	pub header: &'a mut Header,
 	/// Block transactions.
-	pub transactions: &'a Vec<SignedTransaction>,
+	pub transactions: &'a [SignedTransaction],
 	/// Block uncles.
-	pub uncles: &'a Vec<Header>,
+	pub uncles: &'a [Header],
 	/// Transaction receipts.
-	pub receipts: &'a Vec<Receipt>,
+	pub receipts: &'a [Receipt],
 	/// State.
 	pub state: &'a mut State,
 	/// Traces.
@@ -92,11 +90,11 @@ pub struct BlockRef<'a> {
 	/// Block header.
 	pub header: &'a Header,
 	/// Block transactions.
-	pub transactions: &'a Vec<SignedTransaction>,
+	pub transactions: &'a [SignedTransaction],
 	/// Block uncles.
-	pub uncles: &'a Vec<Header>,
+	pub uncles: &'a [Header],
 	/// Transaction receipts.
-	pub receipts: &'a Vec<Receipt>,
+	pub receipts: &'a [Receipt],
 	/// State.
 	pub state: &'a State,
 	/// Traces.
@@ -152,16 +150,16 @@ pub trait IsBlock {
 	fn state(&self) -> &State { &self.block().state }

 	/// Get all information on transactions in this block.
-	fn transactions(&self) -> &Vec<SignedTransaction> { &self.block().base.transactions }
+	fn transactions(&self) -> &[SignedTransaction] { &self.block().base.transactions }

 	/// Get all information on receipts in this block.
-	fn receipts(&self) -> &Vec<Receipt> { &self.block().receipts }
+	fn receipts(&self) -> &[Receipt] { &self.block().receipts }

 	/// Get all information concerning transaction tracing in this block.
 	fn traces(&self) -> &Option<Vec<Trace>> { &self.block().traces }

 	/// Get all uncles in this block.
-	fn uncles(&self) -> &Vec<Header> { &self.block().base.uncles }
+	fn uncles(&self) -> &[Header] { &self.block().base.uncles }
 }

 /// Trait for a object that has a state database.
--- a/ethcore/src/block_queue.rs
+++ b/ethcore/src/block_queue.rs
@@ -104,7 +104,7 @@ struct VerifyingBlock {
 struct QueueSignal {
 	deleting: Arc<AtomicBool>,
 	signalled: AtomicBool,
-	message_channel: IoChannel<NetSyncMessage>,
+	message_channel: IoChannel<ClientIoMessage>,
 }

 impl QueueSignal {
@@ -116,7 +116,7 @@ impl QueueSignal {
 		}

 		if self.signalled.compare_and_swap(false, true, AtomicOrdering::Relaxed) == false {
-			if let Err(e) = self.message_channel.send(UserMessage(SyncMessage::BlockVerified)) {
+			if let Err(e) = self.message_channel.send(ClientIoMessage::BlockVerified) {
 				debug!("Error sending BlockVerified message: {:?}", e);
 			}
 		}
@@ -137,7 +137,7 @@ struct Verification {

 impl BlockQueue {
 	/// Creates a new queue instance.
-	pub fn new(config: BlockQueueConfig, engine: Arc<Box<Engine>>, message_channel: IoChannel<NetSyncMessage>) -> BlockQueue {
+	pub fn new(config: BlockQueueConfig, engine: Arc<Box<Engine>>, message_channel: IoChannel<ClientIoMessage>) -> BlockQueue {
 		let verification = Arc::new(Verification {
 			unverified: Mutex::new(VecDeque::new()),
 			verified: Mutex::new(VecDeque::new()),
--- a/ethcore/src/client/chain_notify.rs
+++ b/ethcore/src/client/chain_notify.rs
@@ -0,0 +1,40 @@
+// 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/>.
+
+use util::numbers::*;
+
+/// Represents what has to be handled by actor listening to chain events
+pub trait ChainNotify : Send + Sync {
+	/// fires when chain has new blocks
+	fn new_blocks(&self,
+		_imported: Vec<H256>,
+		_invalid: Vec<H256>,
+		_enacted: Vec<H256>,
+		_retracted: Vec<H256>,
+		_sealed: Vec<H256>) {
+		// does nothing by default
+	}
+
+	/// fires when chain achieves active mode
+	fn start(&self) {
+		// does nothing by default
+	}
+
+	/// fires when chain achieves passive mode
+	fn stop(&self) {
+		// does nothing by default
+	}
+}
--- a/ethcore/src/client/client.rs
+++ b/ethcore/src/client/client.rs
@@ -28,7 +28,6 @@ use std::time::Instant;
 // util
 use util::numbers::*;
 use util::panics::*;
-use util::network::*;
 use util::io::*;
 use util::rlp;
 use util::sha3::*;
@@ -47,7 +46,7 @@ use state::State;
 use spec::Spec;
 use engine::Engine;
 use views::HeaderView;
-use service::{NetSyncMessage, SyncMessage};
+use service::ClientIoMessage;
 use env_info::LastHashes;
 use verification;
 use verification::{PreverifiedBlock, Verifier};
@@ -60,7 +59,7 @@ use block_queue::{BlockQueue, BlockQueueInfo};
 use blockchain::{BlockChain, BlockProvider, TreeRoute, ImportRoute};
 use client::{BlockID, TransactionID, UncleID, TraceId, ClientConfig,
 	DatabaseCompactionProfile, BlockChainClient, MiningBlockChainClient,
-	TraceFilter, CallAnalytics, BlockImportError, Mode};
+	TraceFilter, CallAnalytics, BlockImportError, Mode, ChainNotify};
 use client::Error as ClientError;
 use env_info::EnvInfo;
 use executive::{Executive, Executed, TransactOptions, contract_address};
@@ -141,7 +140,8 @@ pub struct Client {
 	miner: Arc<Miner>,
 	sleep_state: Mutex<SleepState>,
 	liveness: AtomicBool,
-	io_channel: IoChannel<NetSyncMessage>,
+	io_channel: IoChannel<ClientIoMessage>,
+	notify: RwLock<Option<Weak<ChainNotify>>>,
 	queue_transactions: AtomicUsize,
 	previous_enode: Mutex<Option<String>>,
 }
@@ -178,7 +178,7 @@ impl Client {
 		spec: Spec,
 		path: &Path,
 		miner: Arc<Miner>,
-		message_channel: IoChannel<NetSyncMessage>
+		message_channel: IoChannel<ClientIoMessage>,
 	) -> Result<Arc<Client>, ClientError> {
 		let path = get_db_path(path, config.pruning, spec.genesis_header().hash());
 		let gb = spec.genesis_block();
@@ -228,12 +228,24 @@ impl Client {
 			trie_factory: TrieFactory::new(config.trie_spec),
 			miner: miner,
 			io_channel: message_channel,
+			notify: RwLock::new(None),
 			queue_transactions: AtomicUsize::new(0),
 			previous_enode: Mutex::new(None),
 		};
 		Ok(Arc::new(client))
 	}

+	/// Sets the actor to be notified on certain events
+	pub fn set_notify(&self, target: &Arc<ChainNotify>) {
+		let mut write_lock = self.notify.unwrapped_write();
+		*write_lock = Some(Arc::downgrade(target));
+	}
+
+	fn notify(&self) -> Option<Arc<ChainNotify>> {
+		let read_lock = self.notify.unwrapped_read();
+		read_lock.as_ref().and_then(|weak| weak.upgrade())
+	}
+
 	/// Flush the block import queue.
 	pub fn flush_queue(&self) {
 		self.block_queue.flush();
@@ -327,52 +339,54 @@ impl Client {
 	}

 	/// This is triggered by a message coming from a block queue when the block is ready for insertion
-	pub fn import_verified_blocks(&self, io: &IoChannel<NetSyncMessage>) -> usize {
+	pub fn import_verified_blocks(&self, io: &IoChannel<ClientIoMessage>) -> usize {
 		let max_blocks_to_import = 64;
+		let (imported_blocks, import_results, invalid_blocks, original_best, imported) = {
+			let mut imported_blocks = Vec::with_capacity(max_blocks_to_import);
+			let mut invalid_blocks = HashSet::new();
+			let mut import_results = Vec::with_capacity(max_blocks_to_import);

-		let mut imported_blocks = Vec::with_capacity(max_blocks_to_import);
-		let mut invalid_blocks = HashSet::new();
-		let mut import_results = Vec::with_capacity(max_blocks_to_import);
+			let _import_lock = self.import_lock.lock();
+			let _timer = PerfTimer::new("import_verified_blocks");
+			let blocks = self.block_queue.drain(max_blocks_to_import);

-		let _import_lock = self.import_lock.lock();
-		let _timer = PerfTimer::new("import_verified_blocks");
-		let blocks = self.block_queue.drain(max_blocks_to_import);
+			let original_best = self.chain_info().best_block_hash;

-		let original_best = self.chain_info().best_block_hash;
+			for block in blocks {
+				let header = &block.header;

-		for block in blocks {
-			let header = &block.header;
+				if invalid_blocks.contains(&header.parent_hash) {
+					invalid_blocks.insert(header.hash());
+					continue;
+				}
+				let closed_block = self.check_and_close_block(&block);
+				if let Err(_) = closed_block {
+					invalid_blocks.insert(header.hash());
+					continue;
+				}
+				let closed_block = closed_block.unwrap();
+				imported_blocks.push(header.hash());

-			if invalid_blocks.contains(&header.parent_hash) {
-				invalid_blocks.insert(header.hash());
-				continue;
+				let route = self.commit_block(closed_block, &header.hash(), &block.bytes);
+				import_results.push(route);
+
+				self.report.unwrapped_write().accrue_block(&block);
+				trace!(target: "client", "Imported #{} ({})", header.number(), header.hash());
 			}
-			let closed_block = self.check_and_close_block(&block);
-			if let Err(_) = closed_block {
-				invalid_blocks.insert(header.hash());
-				continue;
+
+			let imported = imported_blocks.len();
+			let invalid_blocks = invalid_blocks.into_iter().collect::<Vec<H256>>();
+
+			{
+				if !invalid_blocks.is_empty() {
+					self.block_queue.mark_as_bad(&invalid_blocks);
+				}
+				if !imported_blocks.is_empty() {
+					self.block_queue.mark_as_good(&imported_blocks);
+				}
 			}
-			let closed_block = closed_block.unwrap();
-			imported_blocks.push(header.hash());
-
-			let route = self.commit_block(closed_block, &header.hash(), &block.bytes);
-			import_results.push(route);
-
-			self.report.unwrapped_write().accrue_block(&block);
-			trace!(target: "client", "Imported #{} ({})", header.number(), header.hash());
-		}
-
-		let imported = imported_blocks.len();
-		let invalid_blocks = invalid_blocks.into_iter().collect::<Vec<H256>>();
-
-		{
-			if !invalid_blocks.is_empty() {
-				self.block_queue.mark_as_bad(&invalid_blocks);
-			}
-			if !imported_blocks.is_empty() {
-				self.block_queue.mark_as_good(&imported_blocks);
-			}
-		}
+			(imported_blocks, import_results, invalid_blocks, original_best, imported)
+		};

 		{
 			if !imported_blocks.is_empty() && self.block_queue.queue_info().is_empty() {
@@ -382,13 +396,15 @@ impl Client {
 					self.miner.chain_new_blocks(self, &imported_blocks, &invalid_blocks, &enacted, &retracted);
 				}

-				io.send(NetworkIoMessage::User(SyncMessage::NewChainBlocks {
-					imported: imported_blocks,
-					invalid: invalid_blocks,
-					enacted: enacted,
-					retracted: retracted,
-					sealed: Vec::new(),
-				})).unwrap_or_else(|e| warn!("Error sending IO notification: {:?}", e));
+				if let Some(notify) = self.notify() {
+					notify.new_blocks(
+						imported_blocks,
+						invalid_blocks,
+						enacted,
+						retracted,
+						Vec::new(),
+					);
+				}
 			}
 		}

@@ -410,7 +426,7 @@ impl Client {
 		};

 		// Commit results
-		let receipts = block.receipts().clone();
+		let receipts = block.receipts().to_owned();
 		let traces = From::from(block.traces().clone().unwrap_or_else(Vec::new));

 		// CHECK! I *think* this is fine, even if the state_root is equal to another
@@ -566,7 +582,9 @@ impl Client {
 	fn wake_up(&self) {
 		if !self.liveness.load(AtomicOrdering::Relaxed) {
 			self.liveness.store(true, AtomicOrdering::Relaxed);
-			self.io_channel.send(NetworkIoMessage::User(SyncMessage::StartNetwork)).unwrap();
+			if let Some(notify) = self.notify() {
+				notify.start();
+			}
 			trace!(target: "mode", "wake_up: Waking.");
 		}
 	}
@@ -576,7 +594,9 @@ impl Client {
 			// only sleep if the import queue is mostly empty.
 			if self.queue_info().total_queue_size() <= MAX_QUEUE_SIZE_TO_SLEEP_ON {
 				self.liveness.store(false, AtomicOrdering::Relaxed);
-				self.io_channel.send(NetworkIoMessage::User(SyncMessage::StopNetwork)).unwrap();
+				if let Some(notify) = self.notify() {
+					notify.stop();
+				}
 				trace!(target: "mode", "sleep: Sleeping.");
 			} else {
 				trace!(target: "mode", "sleep: Cannot sleep - syncing ongoing.");
@@ -901,7 +921,7 @@ impl BlockChainClient for Client {
 			debug!("Ignoring {} transactions: queue is full", transactions.len());
 		} else {
 			let len = transactions.len();
-			match self.io_channel.send(NetworkIoMessage::User(SyncMessage::NewTransactions(transactions))) {
+			match self.io_channel.send(ClientIoMessage::NewTransactions(transactions)) {
 				Ok(_) => {
 					self.queue_transactions.fetch_add(len, AtomicOrdering::SeqCst);
 				}
@@ -969,13 +989,15 @@ impl MiningBlockChainClient for Client {
 			let (enacted, retracted) = self.calculate_enacted_retracted(&[route]);
 			self.miner.chain_new_blocks(self, &[h.clone()], &[], &enacted, &retracted);

-			self.io_channel.send(NetworkIoMessage::User(SyncMessage::NewChainBlocks {
-				imported: vec![h.clone()],
-				invalid: vec![],
-				enacted: enacted,
-				retracted: retracted,
-				sealed: vec![h.clone()],
-			})).unwrap_or_else(|e| warn!("Error sending IO notification: {:?}", e));
+			if let Some(notify) = self.notify() {
+				notify.new_blocks(
+					vec![h.clone()],
+					vec![],
+					enacted,
+					retracted,
+					vec![h.clone()],
+				);
+			}
 		}

 		if self.chain_info().best_block_hash != original_best {
--- a/ethcore/src/client/mod.rs
+++ b/ethcore/src/client/mod.rs
@@ -20,6 +20,7 @@ mod config;
 mod error;
 mod test_client;
 mod trace;
+mod chain_notify;

 pub use self::client::*;
 pub use self::config::{Mode, ClientConfig, DatabaseCompactionProfile, BlockQueueConfig, BlockChainConfig, Switch, VMType};
@@ -29,6 +30,7 @@ pub use self::test_client::{TestBlockChainClient, EachBlockWith};
 pub use types::trace_filter::Filter as TraceFilter;
 pub use executive::{Executed, Executive, TransactOptions};
 pub use env_info::{LastHashes, EnvInfo};
+pub use self::chain_notify::ChainNotify;

 use util::bytes::Bytes;
 use util::hash::{Address, H256, H2048};
--- a/ethcore/src/header.rs
+++ b/ethcore/src/header.rs
@@ -143,7 +143,7 @@ impl Header {
 	/// Get the difficulty field of the header.
 	pub fn difficulty(&self) -> &U256 { &self.difficulty }
 	/// Get the seal field of the header.
-	pub fn seal(&self) -> &Vec<Bytes> { &self.seal }
+	pub fn seal(&self) -> &[Bytes] { &self.seal }

 	// TODO: seal_at, set_seal_at &c.

--- a/ethcore/src/miner/miner.rs
+++ b/ethcore/src/miner/miner.rs
@@ -665,7 +665,7 @@ impl MinerService for Miner {
 		};
 		match (&self.options.pending_set, sealing_set) {
 			(&PendingSet::AlwaysQueue, _) | (&PendingSet::SealingOrElseQueue, None) => queue.top_transactions(),
-			(_, sealing) => sealing.map_or_else(Vec::new, |s| s.transactions().clone()),
+			(_, sealing) => sealing.map_or_else(Vec::new, |s| s.transactions().to_owned()),
 		}
 	}

@@ -702,7 +702,7 @@ impl MinerService for Miner {
 					.iter()
 					.map(|t| t.hash());

-				let receipts = pending.receipts().clone().into_iter();
+				let receipts = pending.receipts().iter().cloned();

 				hashes.zip(receipts).collect()
 			},
--- a/ethcore/src/service.rs
+++ b/ethcore/src/service.rs
@@ -20,67 +20,50 @@ use util::*;
 use util::panics::*;
 use spec::Spec;
 use error::*;
-use client::{Client, ClientConfig};
+use client::{Client, ClientConfig, ChainNotify};
 use miner::Miner;

 /// Message type for external and internal events
 #[derive(Clone)]
-pub enum SyncMessage {
-	/// New block has been imported into the blockchain
-	NewChainBlocks {
-		/// Hashes of blocks imported to blockchain
-		imported: Vec<H256>,
-		/// Hashes of blocks not imported to blockchain (because were invalid)
-		invalid: Vec<H256>,
-		/// Hashes of blocks that were removed from canonical chain
-		retracted: Vec<H256>,
-		/// Hashes of blocks that are now included in cannonical chain
-		enacted: Vec<H256>,
-		/// Hashes of blocks that are sealed by this node
-		sealed: Vec<H256>,
-	},
+pub enum ClientIoMessage {
 	/// Best Block Hash in chain has been changed
 	NewChainHead,
 	/// A block is ready
 	BlockVerified,
 	/// New transaction RLPs are ready to be imported
 	NewTransactions(Vec<Bytes>),
-	/// Start network command.
-	StartNetwork,
-	/// Stop network command.
-	StopNetwork,
 }

-/// IO Message type used for Network service
-pub type NetSyncMessage = NetworkIoMessage<SyncMessage>;
-
 /// Client service setup. Creates and registers client and network services with the IO subsystem.
 pub struct ClientService {
-	net_service: Arc<NetworkService<SyncMessage>>,
+	io_service: Arc<IoService<ClientIoMessage>>,
 	client: Arc<Client>,
 	panic_handler: Arc<PanicHandler>
 }

 impl ClientService {
 	/// Start the service in a separate thread.
-	pub fn start(config: ClientConfig, spec: Spec, net_config: NetworkConfiguration, db_path: &Path, miner: Arc<Miner>, enable_network: bool) -> Result<ClientService, Error> {
+	pub fn start(
+		config: ClientConfig,
+		spec: Spec,
+		db_path: &Path,
+		miner: Arc<Miner>,
+		) -> Result<ClientService, Error>
+	{
 		let panic_handler = PanicHandler::new_in_arc();
-		let net_service = try!(NetworkService::new(net_config));
-		panic_handler.forward_from(&net_service);
-		if enable_network {
-			try!(net_service.start());
-		}
+		let io_service = try!(IoService::<ClientIoMessage>::start());
+		panic_handler.forward_from(&io_service);

 		info!("Configured for {} using {} engine", spec.name.clone().apply(Colour::White.bold()), spec.engine.name().apply(Colour::Yellow.bold()));
-		let client = try!(Client::new(config, spec, db_path, miner, net_service.io().channel()));
+		let client = try!(Client::new(config, spec, db_path, miner, io_service.channel()));
 		panic_handler.forward_from(client.deref());
 		let client_io = Arc::new(ClientIoHandler {
 			client: client.clone()
 		});
-		try!(net_service.io().register_handler(client_io));
+		try!(io_service.register_handler(client_io));

 		Ok(ClientService {
-			net_service: Arc::new(net_service),
+			io_service: Arc::new(io_service),
 			client: client,
 			panic_handler: panic_handler,
 		})
@@ -92,8 +75,8 @@ impl ClientService {
 	}

 	/// Get general IO interface
-	pub fn register_io_handler(&self, handler: Arc<IoHandler<NetSyncMessage> + Send>) -> Result<(), IoError> {
-		self.net_service.io().register_handler(handler)
+	pub fn register_io_handler(&self, handler: Arc<IoHandler<ClientIoMessage> + Send>) -> Result<(), IoError> {
+		self.io_service.register_handler(handler)
 	}

 	/// Get client interface
@@ -102,8 +85,13 @@ impl ClientService {
 	}

 	/// Get network service component
-	pub fn network(&mut self) -> Arc<NetworkService<SyncMessage>> {
-		self.net_service.clone()
+	pub fn io(&self) -> Arc<IoService<ClientIoMessage>> {
+		self.io_service.clone()
+	}
+
+	/// Set the actor to be notified on certain chain events
+	pub fn set_notify(&self, notify: &Arc<ChainNotify>) {
+		self.client.set_notify(notify);
 	}
 }

@@ -121,26 +109,22 @@ struct ClientIoHandler {
 const CLIENT_TICK_TIMER: TimerToken = 0;
 const CLIENT_TICK_MS: u64 = 5000;

-impl IoHandler<NetSyncMessage> for ClientIoHandler {
-	fn initialize(&self, io: &IoContext<NetSyncMessage>) {
+impl IoHandler<ClientIoMessage> for ClientIoHandler {
+	fn initialize(&self, io: &IoContext<ClientIoMessage>) {
 		io.register_timer(CLIENT_TICK_TIMER, CLIENT_TICK_MS).expect("Error registering client timer");
 	}

-	fn timeout(&self, _io: &IoContext<NetSyncMessage>, timer: TimerToken) {
+	fn timeout(&self, _io: &IoContext<ClientIoMessage>, timer: TimerToken) {
 		if timer == CLIENT_TICK_TIMER {
 			self.client.tick();
 		}
 	}

 	#[cfg_attr(feature="dev", allow(single_match))]
-	fn message(&self, io: &IoContext<NetSyncMessage>, net_message: &NetSyncMessage) {
+	fn message(&self, io: &IoContext<ClientIoMessage>, net_message: &ClientIoMessage) {
 		match *net_message {
-			UserMessage(ref message) => match *message {
-				SyncMessage::BlockVerified => { self.client.import_verified_blocks(&io.channel()); }
-				SyncMessage::NewTransactions(ref transactions) => { self.client.import_queued_transactions(&transactions); }
-				_ => {} // ignore other messages
-			},
-			NetworkIoMessage::NetworkStarted(ref url) => { self.client.network_started(url); }
+			ClientIoMessage::BlockVerified => { self.client.import_verified_blocks(&io.channel()); }
+			ClientIoMessage::NewTransactions(ref transactions) => { self.client.import_queued_transactions(&transactions); }
 			_ => {} // ignore other messages
 		}
 	}
@@ -150,7 +134,6 @@ impl IoHandler<NetSyncMessage> for ClientIoHandler {
 mod tests {
 	use super::*;
 	use tests::helpers::*;
-	use util::network::*;
 	use devtools::*;
 	use client::ClientConfig;
 	use std::sync::Arc;
@@ -162,10 +145,8 @@ mod tests {
 		let service = ClientService::start(
 			ClientConfig::default(),
 			get_test_spec(),
-			NetworkConfiguration::new_local(),
 			&temp_path.as_path(),
 			Arc::new(Miner::with_spec(get_test_spec())),
-			false
 		);
 		assert!(service.is_ok());
 	}
--- a/ethcore/src/spec/spec.rs
+++ b/ethcore/src/spec/spec.rs
@@ -143,7 +143,7 @@ impl Spec {
 	}

 	/// Get the known knodes of the network in enode format.
-	pub fn nodes(&self) -> &Vec<String> { &self.nodes }
+	pub fn nodes(&self) -> &[String] { &self.nodes }

 	/// Get the configured Network ID.
 	pub fn network_id(&self) -> U256 { self.params.network_id }