strategy:
matrix:
rust:
- - 1.53.0 # STABLE
+ - 1.56.0 # STABLE
- 1.46.0 # MSRV
features:
- default
- run: sudo apt-get update || exit 1
- run: sudo apt-get install -y libclang-common-10-dev clang-10 libc6-dev-i386 || exit 1
- name: Set default toolchain
- run: rustup default 1.53.0 # STABLE
+ run: rustup default 1.56.0 # STABLE
- name: Set profile
run: rustup set profile minimal
- name: Add target wasm32
let policy_str = matches.value_of("POLICY").unwrap();
info!("Compiling policy: {}", policy_str);
- let policy = Concrete::<String>::from_str(&policy_str)?;
+ let policy = Concrete::<String>::from_str(policy_str)?;
let descriptor = match matches.value_of("TYPE").unwrap() {
"sh" => Descriptor::new_sh(policy.compile()?)?,
let total_cost = headers_cost + filters_cost + PROCESS_BLOCKS_COST;
if let Some(snapshot) = sync::sync_headers(
- Arc::clone(&first_peer),
+ Arc::clone(first_peer),
Arc::clone(&self.headers),
|new_height| {
let local_headers_cost =
let buried_height = synced_height.saturating_sub(sync::BURIED_CONFIRMATIONS);
info!("Synced headers to height: {}", synced_height);
- cf_sync.prepare_sync(Arc::clone(&first_peer))?;
+ cf_sync.prepare_sync(Arc::clone(first_peer))?;
let all_scripts = Arc::new(
database
let mut threads = Vec::with_capacity(self.peers.len());
for peer in &self.peers {
let cf_sync = Arc::clone(&cf_sync);
- let peer = Arc::clone(&peer);
+ let peer = Arc::clone(peer);
let headers = Arc::clone(&self.headers);
let all_scripts = Arc::clone(&all_scripts);
let last_synced_block = Arc::clone(&last_synced_block);
let message_resp = {
let mut lock = responses.write().unwrap();
let message_resp = lock.entry(wait_for).or_default();
- Arc::clone(&message_resp)
+ Arc::clone(message_resp)
};
let (lock, cvar) = &*message_resp;
let message_resp = {
let mut lock = reader_thread_responses.write().unwrap();
let message_resp = lock.entry(in_message.cmd()).or_default();
- Arc::clone(&message_resp)
+ Arc::clone(message_resp)
};
let (lock, cvar) = &*message_resp;
let cf_headers: Vec<FilterHeader> = filter_hashes
.into_iter()
.scan(checkpoint, |prev_header, filter_hash| {
- let filter_header = filter_hash.filter_header(&prev_header);
+ let filter_header = filter_hash.filter_header(prev_header);
*prev_header = filter_header;
Some(filter_header)
.zip(headers.into_iter())
.scan(checkpoint, |prev_header, ((_, filter_content), header)| {
let filter = BlockFilter::new(&filter_content);
- if header != filter.filter_header(&prev_header) {
+ if header != filter.filter_header(prev_header) {
return Some(Err(CompactFiltersError::InvalidFilter));
}
*prev_header = header;
let block_hash = self.headers_store.get_block_hash(height)?.unwrap();
// TODO: also download random blocks?
- if process(&block_hash, &BlockFilter::new(&filter))? {
+ if process(&block_hash, &BlockFilter::new(filter))? {
log::debug!("Downloading block {}", block_hash);
let block = peer
.iter()
.map(|s| ImportMultiRequest {
timestamp: ImportMultiRescanSince::Timestamp(0),
- script_pubkey: Some(ImportMultiRequestScriptPubkey::Script(&s)),
+ script_pubkey: Some(ImportMultiRequestScriptPubkey::Script(s)),
watchonly: Some(true),
..Default::default()
})
txid, confirmation_time
);
known_tx.confirmation_time = confirmation_time;
- db.set_tx(&known_tx)?;
+ db.set_tx(known_tx)?;
}
} else {
//TODO check there is already the raw tx in db?
{
//TODO check descriptors contains only public keys
let descriptor = descriptor
- .into_wallet_descriptor(&secp, network)?
+ .into_wallet_descriptor(secp, network)?
.0
.to_string();
let mut wallet_name = get_checksum(&descriptor[..descriptor.find('#').unwrap()])?;
if let Some(change_descriptor) = change_descriptor {
let change_descriptor = change_descriptor
- .into_wallet_descriptor(&secp, network)?
+ .into_wallet_descriptor(secp, network)?
.0
.to_string();
wallet_name.push_str(
#[cfg_attr(docsrs, doc(cfg(feature = "keys-bip39")))]
impl<Ctx: ScriptContext> DerivableKey<Ctx> for Seed {
fn into_extended_key(self) -> Result<ExtendedKey<Ctx>, KeyError> {
- Ok(bip32::ExtendedPrivKey::new_master(Network::Bitcoin, &self.as_bytes())?.into())
+ Ok(bip32::ExtendedPrivKey::new_master(Network::Bitcoin, self.as_bytes())?.into())
}
fn into_descriptor_key(