chore: fix clippy lints

derive/src/path.rs

@@ -27,7 +27,7 @@ use core::str::FromStr;
 use std::collections::BTreeSet;
 
 use amplify::confinement;
-use amplify::confinement::Confined;
+use amplify::confinement::{Confined, NonEmptyOrdSet};
 
 use crate::{DerivationIndex, Idx, IdxBase, IndexParseError, NormalIndex, Terminal};
 
@@ -41,28 +41,28 @@ pub enum DerivationParseError {
 }
 
 #[derive(Clone, Eq, PartialEq, Hash, Debug)]
-pub struct DerivationSeg<I: IdxBase = NormalIndex>(Confined<BTreeSet<I>, 1, 8>);
+pub struct DerivationSeg<I: IdxBase = NormalIndex>(NonEmptyOrdSet<I, 8>);
 
 impl<I: IdxBase> From<&'static [I]> for DerivationSeg<I> {
     fn from(indexes: &'static [I]) -> Self {
-        Self(Confined::from_iter_unsafe(indexes.iter().copied()))
+        Self(Confined::from_iter_checked(indexes.iter().copied()))
     }
 }
 
 impl<I: IdxBase> From<[I; 2]> for DerivationSeg<I> {
-    fn from(indexes: [I; 2]) -> Self { Self(Confined::from_iter_unsafe(indexes)) }
+    fn from(indexes: [I; 2]) -> Self { Self(Confined::from_iter_checked(indexes)) }
 }
 
 impl<I: IdxBase> From<[I; 3]> for DerivationSeg<I> {
-    fn from(indexes: [I; 3]) -> Self { Self(Confined::from_iter_unsafe(indexes)) }
+    fn from(indexes: [I; 3]) -> Self { Self(Confined::from_iter_checked(indexes)) }
 }
 
 impl<I: IdxBase> From<[I; 4]> for DerivationSeg<I> {
-    fn from(indexes: [I; 4]) -> Self { Self(Confined::from_iter_unsafe(indexes)) }
+    fn from(indexes: [I; 4]) -> Self { Self(Confined::from_iter_checked(indexes)) }
 }
 
 impl<I: IdxBase> DerivationSeg<I> {
-    pub fn new(index: I) -> Self { DerivationSeg(confined_bset![index]) }
+    pub fn new(index: I) -> Self { DerivationSeg(NonEmptyOrdSet::with(index)) }
 
     pub fn with(iter: impl IntoIterator<Item = I>) -> Result<Self, confinement::Error> {
         Confined::try_from_iter(iter).map(DerivationSeg)
@@ -86,17 +86,19 @@ impl<I: IdxBase> DerivationSeg<I> {
     }
 
     #[inline]
-    pub fn into_set(self) -> BTreeSet<I> { self.0.into_inner() }
+    pub fn into_set(self) -> BTreeSet<I> { self.0.release() }
 
     #[inline]
-    pub fn to_set(&self) -> BTreeSet<I> { self.0.to_inner() }
+    pub fn to_set(&self) -> BTreeSet<I> { self.0.to_unconfined() }
 
     #[inline]
-    pub fn as_set(&self) -> &BTreeSet<I> { self.0.as_inner() }
+    pub fn as_set(&self) -> &BTreeSet<I> { self.0.as_unconfined() }
 }
 
 impl DerivationSeg<NormalIndex> {
-    pub fn standard() -> Self { DerivationSeg(confined_bset![NormalIndex::ZERO, NormalIndex::ONE]) }
+    pub fn standard() -> Self {
+        DerivationSeg(NonEmptyOrdSet::from_iter_checked([NormalIndex::ZERO, NormalIndex::ONE]))
+    }
 }
 
 impl<I: IdxBase> Index<u8> for DerivationSeg<I> {

derive/src/xkey.rs

@@ -27,7 +27,7 @@ use std::str::FromStr;
 use amplify::{confinement, hex, ByteArray, Bytes20, Bytes32, Bytes4, Wrapper};
 use bc::secp256k1::{Keypair, PublicKey, SecretKey, SECP256K1};
 use bc::{secp256k1, CompressedPk, InvalidPubkey, LegacyPk, XOnlyPk};
-use commit_verify::{Digest, Ripemd160, Sha256};
+use commit_verify::{Digest, Ripemd160};
 use hmac::{Hmac, Mac};
 use sha2::Sha512;
 
@@ -276,7 +276,7 @@ impl Xpub {
 
     /// Returns the HASH160 of the chaincode
     pub fn identifier(&self) -> XpubId {
-        let hash = Ripemd160::digest(&self.core.public_key.serialize());
+        let hash = Ripemd160::digest(self.core.public_key.serialize());
         XpubId::from_slice_unsafe(hash)
     }
 

psbt/src/data.rs

@@ -103,7 +103,7 @@ impl From<UnsignedTx> for Tx {
     fn from(unsigned_tx: UnsignedTx) -> Tx {
         Tx {
             version: unsigned_tx.version,
-            inputs: VarIntArray::from_collection_unsafe(
+            inputs: VarIntArray::from_checked(
                 unsigned_tx.inputs.into_iter().map(TxIn::from).collect(),
             ),
             outputs: unsigned_tx.outputs,
@@ -117,7 +117,7 @@ impl UnsignedTx {
     pub fn with_sigs_removed(tx: Tx) -> UnsignedTx {
         UnsignedTx {
             version: tx.version,
-            inputs: VarIntArray::from_collection_unsafe(
+            inputs: VarIntArray::from_checked(
                 tx.inputs.into_iter().map(UnsignedTxIn::with_sigs_removed).collect(),
             ),
             outputs: tx.outputs,
@@ -257,12 +257,8 @@ impl Psbt {
     pub fn to_unsigned_tx(&self) -> UnsignedTx {
         UnsignedTx {
             version: self.tx_version,
-            inputs: VarIntArray::from_collection_unsafe(
-                self.inputs().map(Input::to_unsigned_txin).collect(),
-            ),
-            outputs: VarIntArray::from_collection_unsafe(
-                self.outputs().map(Output::to_txout).collect(),
-            ),
+            inputs: VarIntArray::from_iter_checked(self.inputs().map(Input::to_unsigned_txin)),
+            outputs: VarIntArray::from_iter_checked(self.outputs().map(Output::to_txout)),
             lock_time: self.lock_time(),
         }
     }
@@ -479,12 +475,8 @@ impl Psbt {
 
         Ok(Tx {
             version: self.tx_version,
-            inputs: VarIntArray::from_collection_unsafe(
-                self.inputs.iter().map(Input::to_signed_txin).collect(),
-            ),
-            outputs: VarIntArray::from_collection_unsafe(
-                self.outputs.iter().map(Output::to_txout).collect(),
-            ),
+            inputs: VarIntArray::from_iter_checked(self.inputs.iter().map(Input::to_signed_txin)),
+            outputs: VarIntArray::from_iter_checked(self.outputs.iter().map(Output::to_txout)),
             lock_time: self.lock_time(),
         })
     }