diff --git a/Cargo.toml b/Cargo.toml
index a34105b..a30e317 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -19,12 +19,12 @@ bitcoin_support=["bitcoin","serde","serde_cbor"]
 
 [dependencies]
 rand="0.7"
-byteorder="1.2"
-lru-cache = "0.1.1"
-bitcoin_hashes = "0.7"
-bitcoin = { version= "0.21", features=["serde"], optional = true }
+byteorder="1.3"
+lru-cache = "0.1.2"
+bitcoin_hashes = "0.9"
+bitcoin = { version = "0.25", features=["use-serde"], optional = true }
 serde = { version ="1", optional = true }
-serde_cbor = { version="0.10", optional = true }
+serde_cbor = { version="0.11", optional = true }
 
 [dev-dependencies]
-hex = "0.3"
+hex = "0.4"
diff --git a/src/bitcoin_adaptor.rs b/src/bitcoin_adaptor.rs
index 4e56f6f..8cbe18d 100644
--- a/src/bitcoin_adaptor.rs
+++ b/src/bitcoin_adaptor.rs
@@ -21,11 +21,7 @@ use PRef;
 use HammersbaldAPI;
 use HammersbaldIterator;
 
-use bitcoin_hashes::sha256d;
-
-use bitcoin::{
-    BitcoinHash
-};
+use bitcoin::hashes::sha256d;
 
 use serde::Serialize;
 use serde::de::DeserializeOwned;
@@ -45,15 +41,15 @@ impl BitcoinAdaptor {
     }
 
     /// Store some bitcoin object that has a bitcoin hash
-    pub fn put_hash_keyed<T>(&mut self, encodable: &T) -> Result<PRef, Box<dyn Error>>
-        where T: Serialize + BitcoinHash {
-        Ok(self.hammersbald.put_keyed(&encodable.bitcoin_hash()[..], serde_cbor::to_vec(encodable)?.as_slice())?)
+    pub fn put_hash_keyed<ID: Into<sha256d::Hash>, T>(&mut self, id: ID, encodable: &T) -> Result<PRef, Box<dyn Error>>
+        where T: Serialize {
+        Ok(self.hammersbald.put_keyed(&id.into()[..], serde_cbor::to_vec(encodable)?.as_slice())?)
     }
 
     /// Retrieve a bitcoin_object with its hash
-    pub fn get_hash_keyed<T>(&self, id: &sha256d::Hash) -> Result<Option<(PRef, T)>, Box<dyn Error>>
-        where T: DeserializeOwned + BitcoinHash{
-        if let Some((pref, data)) = self.hammersbald.get_keyed(&id[..])? {
+    pub fn get_hash_keyed<ID: Into<sha256d::Hash>, T>(&self, id: ID) -> Result<Option<(PRef, T)>, Box<dyn Error>>
+        where T: DeserializeOwned {
+        if let Some((pref, data)) = self.hammersbald.get_keyed(&id.into()[..])? {
             return Ok(Some((pref, serde_cbor::from_slice(data.as_slice())?)))
         }
         Ok(None)
@@ -170,7 +166,7 @@ mod test {
     use bitcoin::network::constants::Network;
     use transient;
     use super::*;
-    use bitcoin::consensus::deserialize;
+    use bitcoin::{consensus::deserialize};
 
     #[test]
     pub fn bitcoin_test () {
@@ -189,9 +185,9 @@ mod test {
         assert_eq!(tx, tx2);
 
         // store the transaction with its hash as key
-        let txref2 = bdb.put_hash_keyed(&tx).unwrap();
+        let txref2 = bdb.put_hash_keyed(tx.txid(), &tx).unwrap();
         // retrieve by hash
-        if let Some((pref, tx3)) = bdb.get_hash_keyed::<Transaction>(&tx.bitcoin_hash()).unwrap() {
+        if let Some((pref, tx3)) = bdb.get_hash_keyed::<_, Transaction>(tx.txid()).unwrap() {
             assert_eq!(pref, txref2);
             assert_eq!(tx3, tx);
         }
@@ -201,9 +197,9 @@ mod test {
 
         let genesis = genesis_block(Network::Bitcoin);
         // store the genesist block
-        bdb.put_hash_keyed(&genesis).unwrap();
+        bdb.put_hash_keyed(genesis.block_hash(), &genesis).unwrap();
         // find it
-        if let Some((_, block)) = bdb.get_hash_keyed::<Block>(&genesis.bitcoin_hash()).unwrap() {
+        if let Some((_, block)) = bdb.get_hash_keyed::<_, Block>(genesis.block_hash()).unwrap() {
             assert_eq!(block, genesis);
         }
         else {