diff --git a/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/groestlcoin/TestGroestlcoinSigner.kt b/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/groestlcoin/TestGroestlcoinSigner.kt
new file mode 100644
index 00000000000..64cb6bba4f5
--- /dev/null
+++ b/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/groestlcoin/TestGroestlcoinSigner.kt
@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+package com.trustwallet.core.app.blockchains.groestlcoin
+
+import com.google.protobuf.ByteString
+import com.trustwallet.core.app.utils.Numeric
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+import wallet.core.java.AnySigner
+import wallet.core.jni.BitcoinSigHashType
+import wallet.core.jni.CoinType.GROESTLCOIN
+import wallet.core.jni.proto.Common.SigningError
+import wallet.core.jni.proto.Bitcoin
+import wallet.core.jni.proto.Bitcoin.SigningOutput
+import wallet.core.jni.proto.BitcoinV2
+import wallet.core.jni.proto.Utxo
+
+class TestGroestlcoinSigner {
+
+    init {
+        System.loadLibrary("TrustWalletCore")
+    }
+
+    @Test
+    fun testSignV2P2PKH() {
+        // Successfully broadcasted: https://explorer.zcha.in/transactions/ec9033381c1cc53ada837ef9981c03ead1c7c41700ff3a954389cfaddc949256
+        val privateKeyData = Numeric.hexStringToByteArray("dc334e7347f2f9f72fce789b11832bdf78adf0158bc6617e6d2d2a530a0d4bc6")
+        val dustSatoshis = 546.toLong()
+        val senderAddress = "grs1qw4teyraux2s77nhjdwh9ar8rl9dt7zww8r6lne"
+        val toAddress = "31inaRqambLsd9D7Ke4USZmGEVd3PHkh7P"
+        val changeAddress = "Fj62rBJi8LvbmWu2jzkaUX1NFXLEqDLoZM"
+
+        val txid0 = Numeric.hexStringToByteArray("8f4ecc7844e19aa1d3183e47eee89d795f9e7c875a55ec0203946d6c9eb06895").reversedArray()
+        val utxo0 = BitcoinV2.Input.newBuilder()
+            .setOutPoint(Utxo.OutPoint.newBuilder().apply {
+                hash = ByteString.copyFrom(txid0)
+                vout = 1
+            })
+            .setValue(4774)
+            .setSighashType(BitcoinSigHashType.ALL.value())
+            .setReceiverAddress(senderAddress)
+
+        val out0 = BitcoinV2.Output.newBuilder()
+            .setValue(2500)
+            .setToAddress(toAddress)
+
+        val changeOut = BitcoinV2.Output.newBuilder()
+            .setValue(2048)
+            .setToAddress(changeAddress)
+
+        val builder = BitcoinV2.TransactionBuilder.newBuilder()
+            .setVersion(BitcoinV2.TransactionVersion.UseDefault)
+            .addInputs(utxo0)
+            .addOutputs(out0)
+            .addOutputs(changeOut)
+            .setInputSelector(BitcoinV2.InputSelector.UseAll)
+            .setFixedDustThreshold(dustSatoshis)
+        val signingInput = BitcoinV2.SigningInput.newBuilder()
+            .setBuilder(builder)
+            .addPrivateKeys(ByteString.copyFrom(privateKeyData))
+            .setChainInfo(BitcoinV2.ChainInfo.newBuilder().apply {
+                p2PkhPrefix = 36
+                p2ShPrefix = 5
+            })
+            .build()
+
+        val legacySigningInput = Bitcoin.SigningInput.newBuilder().apply {
+            signingV2 = signingInput
+            coinType = GROESTLCOIN.value()
+        }
+
+        val output = AnySigner.sign(legacySigningInput.build(), GROESTLCOIN, SigningOutput.parser())
+
+        assertEquals(output.error, SigningError.OK)
+        assertEquals(output.signingResultV2.errorMessage, "")
+        assertEquals(output.signingResultV2.error, SigningError.OK)
+        assertEquals(Numeric.toHexString(output.signingResultV2.encoded.toByteArray()), "0x010000000001019568b09e6c6d940302ec555a877c9e5f799de8ee473e18d3a19ae14478cc4e8f0100000000ffffffff02c40900000000000017a9140055b0c94df477ee6b9f75185dfc9aa8ce2e52e48700080000000000001976a91498af0aaca388a7e1024f505c033626d908e3b54a88ac024830450221009bbd0228dcb7343828633ded99d216555d587b74db40c4a46f560187eca222dd022032364cf6dbf9c0213076beb6b4a20935d4e9c827a551c3f6f8cbb22d8b464467012102e9c9b9b76e982ad8fa9a7f48470eafbeeba9bf6d287579318c517db5157d936e00000000")
+        assertEquals(Numeric.toHexString(output.signingResultV2.txid.toByteArray()), "0x40b539c578934c9863a93c966e278fbeb3e67b0da4eb9e3030092c1b717e7a64")
+    }
+}
diff --git a/rust/Cargo.lock b/rust/Cargo.lock
index de309cba3aa..aa28248a982 100644
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -1880,6 +1880,7 @@ dependencies = [
  "tw_ethereum",
  "tw_evm",
  "tw_greenfield",
+ "tw_groestlcoin",
  "tw_hash",
  "tw_internet_computer",
  "tw_keypair",
@@ -1996,6 +1997,21 @@ dependencies = [
  "tw_proto",
 ]
 
+[[package]]
+name = "tw_groestlcoin"
+version = "0.1.0"
+dependencies = [
+ "tw_base58_address",
+ "tw_bitcoin",
+ "tw_coin_entry",
+ "tw_encoding",
+ "tw_hash",
+ "tw_keypair",
+ "tw_memory",
+ "tw_proto",
+ "tw_utxo",
+]
+
 [[package]]
 name = "tw_hash"
 version = "0.1.0"
diff --git a/rust/Cargo.toml b/rust/Cargo.toml
index 435a6f26615..e23a466ecf4 100644
--- a/rust/Cargo.toml
+++ b/rust/Cargo.toml
@@ -8,6 +8,7 @@ members = [
     "chains/tw_cosmos",
     "chains/tw_ethereum",
     "chains/tw_greenfield",
+    "chains/tw_groestlcoin",
     "chains/tw_internet_computer",
     "chains/tw_komodo",
     "chains/tw_native_evmos",
diff --git a/rust/chains/tw_bitcoin/src/modules/compiler.rs b/rust/chains/tw_bitcoin/src/modules/compiler.rs
index a2ce77d7176..c12ed068257 100644
--- a/rust/chains/tw_bitcoin/src/modules/compiler.rs
+++ b/rust/chains/tw_bitcoin/src/modules/compiler.rs
@@ -121,7 +121,7 @@ impl<Context: BitcoinSigningContext> BitcoinCompiler<Context> {
         Ok(Proto::SigningOutput {
             transaction: Context::ProtobufBuilder::tx_to_proto(&signed_tx),
             encoded: Cow::from(signed_tx.encode_out()),
-            txid: Cow::from(signed_tx.txid()),
+            txid: Cow::from(signed_tx.txid(Context::TX_HASHER)),
             // `vsize` could have been changed after the transaction being signed.
             vsize: signed_tx.vsize() as u64,
             weight: signed_tx.weight() as u64,
@@ -146,7 +146,7 @@ impl<Context: BitcoinSigningContext> BitcoinCompiler<Context> {
         Ok(Proto::SigningOutput {
             transaction: Context::ProtobufBuilder::tx_to_proto(&signed_tx),
             encoded: Cow::from(signed_tx.encode_out()),
-            txid: Cow::from(signed_tx.txid()),
+            txid: Cow::from(signed_tx.txid(Context::TX_HASHER)),
             // `vsize` could have been changed after the transaction being signed.
             vsize: signed_tx.vsize() as u64,
             weight: signed_tx.weight() as u64,
diff --git a/rust/chains/tw_bitcoin/src/modules/signer.rs b/rust/chains/tw_bitcoin/src/modules/signer.rs
index db95ceab71e..1a3a7dd7bdc 100644
--- a/rust/chains/tw_bitcoin/src/modules/signer.rs
+++ b/rust/chains/tw_bitcoin/src/modules/signer.rs
@@ -70,7 +70,7 @@ impl<Context: BitcoinSigningContext> BitcoinSigner<Context> {
         Ok(Proto::SigningOutput {
             transaction: Context::ProtobufBuilder::tx_to_proto(&signed_tx),
             encoded: Cow::from(signed_tx.encode_out()),
-            txid: Cow::from(signed_tx.txid()),
+            txid: Cow::from(signed_tx.txid(Context::TX_HASHER)),
             // `vsize` could have been changed after the transaction being signed.
             vsize: signed_tx.vsize() as u64,
             // `fee` should haven't been changed since it's a difference between `sum(inputs)` and `sum(outputs)`.
@@ -107,7 +107,7 @@ impl<Context: BitcoinSigningContext> BitcoinSigner<Context> {
         Ok(Proto::SigningOutput {
             transaction: Context::ProtobufBuilder::tx_to_proto(&signed_tx),
             encoded: Cow::from(signed_tx.encode_out()),
-            txid: Cow::from(signed_tx.txid()),
+            txid: Cow::from(signed_tx.txid(Context::TX_HASHER)),
             // `vsize` could have been changed after the transaction being signed.
             vsize: signed_tx.vsize() as u64,
             fee,
diff --git a/rust/chains/tw_bitcoin/src/modules/tx_builder/output_protobuf.rs b/rust/chains/tw_bitcoin/src/modules/tx_builder/output_protobuf.rs
index 7158d67f9a2..3879cef4ee9 100644
--- a/rust/chains/tw_bitcoin/src/modules/tx_builder/output_protobuf.rs
+++ b/rust/chains/tw_bitcoin/src/modules/tx_builder/output_protobuf.rs
@@ -7,7 +7,7 @@ use crate::modules::tx_builder::BitcoinChainInfo;
 use std::marker::PhantomData;
 use std::str::FromStr;
 use tw_coin_entry::error::prelude::*;
-use tw_hash::hasher::sha256_ripemd;
+use tw_hash::ripemd::sha256_ripemd;
 use tw_hash::sha2::sha256;
 use tw_hash::{Hash, H256};
 use tw_keypair::{ecdsa, schnorr};
diff --git a/rust/chains/tw_bitcoin/src/modules/tx_builder/public_keys.rs b/rust/chains/tw_bitcoin/src/modules/tx_builder/public_keys.rs
index 6c822c686b6..94f344fc868 100644
--- a/rust/chains/tw_bitcoin/src/modules/tx_builder/public_keys.rs
+++ b/rust/chains/tw_bitcoin/src/modules/tx_builder/public_keys.rs
@@ -4,7 +4,7 @@
 
 use std::collections::HashMap;
 use tw_coin_entry::error::prelude::*;
-use tw_hash::hasher::sha256_ripemd;
+use tw_hash::ripemd::sha256_ripemd;
 use tw_hash::H160;
 use tw_keypair::ecdsa;
 use tw_memory::Data;
diff --git a/rust/chains/tw_bitcoin/src/modules/tx_builder/utxo_protobuf.rs b/rust/chains/tw_bitcoin/src/modules/tx_builder/utxo_protobuf.rs
index d3fe32a7e2d..b853e8eb04b 100644
--- a/rust/chains/tw_bitcoin/src/modules/tx_builder/utxo_protobuf.rs
+++ b/rust/chains/tw_bitcoin/src/modules/tx_builder/utxo_protobuf.rs
@@ -211,7 +211,8 @@ impl<'a, Context: UtxoContext> UtxoProtobuf<'a, Context> {
             .prev_index(index)
             .sequence(sequence)
             .amount(self.input.value)
-            .sighash_type(sighash_ty))
+            .sighash_type(sighash_ty)
+            .tx_hasher(Context::TX_HASHER))
     }
 
     pub fn sighash_ty(&self) -> SigningResult<SighashType> {
diff --git a/rust/chains/tw_bitcoincash/src/cash_address/mod.rs b/rust/chains/tw_bitcoincash/src/cash_address/mod.rs
index f060724fc40..96bc91e0815 100644
--- a/rust/chains/tw_bitcoincash/src/cash_address/mod.rs
+++ b/rust/chains/tw_bitcoincash/src/cash_address/mod.rs
@@ -8,7 +8,7 @@ use tw_coin_entry::coin_context::CoinContext;
 use tw_coin_entry::coin_entry::CoinAddress;
 use tw_coin_entry::error::prelude::*;
 use tw_encoding::bech32;
-use tw_hash::hasher::sha256_ripemd;
+use tw_hash::ripemd::sha256_ripemd;
 use tw_hash::H160;
 use tw_keypair::ecdsa;
 use tw_memory::Data;
diff --git a/rust/chains/tw_groestlcoin/Cargo.toml b/rust/chains/tw_groestlcoin/Cargo.toml
new file mode 100644
index 00000000000..6b6c8538e66
--- /dev/null
+++ b/rust/chains/tw_groestlcoin/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "tw_groestlcoin"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+tw_base58_address = { path = "../../tw_base58_address" }
+tw_bitcoin = { path = "../../chains/tw_bitcoin" }
+tw_coin_entry = { path = "../../tw_coin_entry" }
+tw_encoding = { path = "../../tw_encoding" }
+tw_hash = { path = "../../tw_hash" }
+tw_keypair = { path = "../../tw_keypair" }
+tw_memory = { path = "../../tw_memory" }
+tw_proto = { path = "../../tw_proto" }
+tw_utxo = { path = "../../frameworks/tw_utxo" }
diff --git a/rust/chains/tw_groestlcoin/src/address/groestlcoin_legacy.rs b/rust/chains/tw_groestlcoin/src/address/groestlcoin_legacy.rs
new file mode 100644
index 00000000000..31d53cabf52
--- /dev/null
+++ b/rust/chains/tw_groestlcoin/src/address/groestlcoin_legacy.rs
@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use tw_hash::groestl::Groestl512d;
+use tw_hash::ripemd::Sha256Ripemd;
+use tw_utxo::address::legacy::PrefixedBase58Address;
+
+pub type GroestlLegacyAddress = PrefixedBase58Address<Sha256Ripemd, Groestl512d>;
diff --git a/rust/chains/tw_groestlcoin/src/address/mod.rs b/rust/chains/tw_groestlcoin/src/address/mod.rs
new file mode 100644
index 00000000000..fef029fd89d
--- /dev/null
+++ b/rust/chains/tw_groestlcoin/src/address/mod.rs
@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use std::fmt;
+use std::str::FromStr;
+use tw_coin_entry::coin_context::CoinContext;
+use tw_coin_entry::coin_entry::CoinAddress;
+use tw_coin_entry::derivation::Derivation;
+use tw_coin_entry::error::prelude::*;
+use tw_keypair::tw;
+use tw_memory::Data;
+use tw_utxo::address::derivation::BitcoinDerivation;
+use tw_utxo::address::segwit::SegwitAddress;
+use tw_utxo::address::standard_bitcoin::StandardBitcoinPrefix;
+
+pub mod groestlcoin_legacy;
+use groestlcoin_legacy::GroestlLegacyAddress;
+
+pub enum GroestlAddress {
+    Legacy(GroestlLegacyAddress),
+    Segwit(SegwitAddress),
+}
+
+impl GroestlAddress {
+    /// Tries to parse one of the `BitcoinAddress` variants
+    /// and validates if the result address matches the given `prefix` address or belongs to the `coin` network.
+    pub fn from_str_with_coin_and_prefix(
+        coin: &dyn CoinContext,
+        s: &str,
+        prefix: Option<StandardBitcoinPrefix>,
+    ) -> AddressResult<GroestlAddress> {
+        match prefix {
+            Some(StandardBitcoinPrefix::Base58(base58)) => {
+                GroestlLegacyAddress::from_str_with_coin_and_prefix(coin, s, Some(base58))
+                    .map(GroestlAddress::Legacy)
+            },
+            Some(StandardBitcoinPrefix::Bech32(bech32)) => {
+                SegwitAddress::from_str_with_coin_and_prefix(coin, s, Some(bech32))
+                    .map(GroestlAddress::Segwit)
+            },
+            None => GroestlAddress::from_str_checked(coin, s),
+        }
+    }
+
+    /// Tries to parse one of the `BitcoinAddress` variants
+    /// and validates if the result address belongs to the `coin` network.
+    pub fn from_str_checked(coin: &dyn CoinContext, s: &str) -> AddressResult<GroestlAddress> {
+        if let Ok(legacy) = GroestlLegacyAddress::from_str_with_coin_and_prefix(coin, s, None) {
+            return Ok(GroestlAddress::Legacy(legacy));
+        }
+
+        if let Ok(segwit) = SegwitAddress::from_str_with_coin_and_prefix(coin, s, None) {
+            return Ok(GroestlAddress::Segwit(segwit));
+        }
+
+        Err(AddressError::InvalidInput)
+    }
+
+    /// TrustWallet derivation inherited from:
+    /// https://github.com/trustwallet/wallet-core/blob/43235636ad1c97e4e13388afd3db3d6f9d09e1ca/src/Groestlcoin/Entry.cpp#L20-L30
+    pub fn derive_as_tw(
+        coin: &dyn CoinContext,
+        public_key: &tw::PublicKey,
+        derivation: Derivation,
+        maybe_prefix: Option<StandardBitcoinPrefix>,
+    ) -> AddressResult<GroestlAddress> {
+        match maybe_prefix {
+            Some(StandardBitcoinPrefix::Base58(prefix)) => {
+                return GroestlLegacyAddress::p2pkh_with_coin_and_prefix(
+                    coin,
+                    public_key,
+                    Some(prefix),
+                )
+                .map(GroestlAddress::Legacy);
+            },
+            Some(StandardBitcoinPrefix::Bech32(prefix)) => {
+                return SegwitAddress::p2wpkh_with_coin_and_prefix(coin, public_key, Some(prefix))
+                    .map(GroestlAddress::Segwit);
+            },
+            // Derive an address as declared in registry.json.
+            None => (),
+        }
+
+        match BitcoinDerivation::tw_derivation(coin, derivation) {
+            BitcoinDerivation::Legacy => {
+                GroestlLegacyAddress::p2pkh_with_coin_and_prefix(coin, public_key, None)
+                    .map(GroestlAddress::Legacy)
+            },
+            BitcoinDerivation::Segwit => {
+                SegwitAddress::p2wpkh_with_coin_and_prefix(coin, public_key, None)
+                    .map(GroestlAddress::Segwit)
+            },
+            BitcoinDerivation::Taproot => Err(AddressError::InvalidRegistry),
+        }
+    }
+}
+
+impl CoinAddress for GroestlAddress {
+    #[inline]
+    fn data(&self) -> Data {
+        match self {
+            GroestlAddress::Legacy(legacy) => legacy.bytes().to_vec(),
+            GroestlAddress::Segwit(segwit) => segwit.witness_program().to_vec(),
+        }
+    }
+}
+
+impl FromStr for GroestlAddress {
+    type Err = AddressError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if let Ok(legacy) = GroestlLegacyAddress::from_str(s) {
+            return Ok(GroestlAddress::Legacy(legacy));
+        }
+        if let Ok(segwit) = SegwitAddress::from_str(s) {
+            return Ok(GroestlAddress::Segwit(segwit));
+        }
+        Err(AddressError::InvalidInput)
+    }
+}
+
+impl fmt::Display for GroestlAddress {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            GroestlAddress::Legacy(legacy) => write!(f, "{legacy}"),
+            GroestlAddress::Segwit(segwit) => write!(f, "{segwit}"),
+        }
+    }
+}
diff --git a/rust/chains/tw_groestlcoin/src/context.rs b/rust/chains/tw_groestlcoin/src/context.rs
new file mode 100644
index 00000000000..6885fa9db04
--- /dev/null
+++ b/rust/chains/tw_groestlcoin/src/context.rs
@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use crate::address::GroestlAddress;
+use tw_bitcoin::context::BitcoinSigningContext;
+use tw_bitcoin::modules::protobuf_builder::standard_protobuf_builder::StandardProtobufBuilder;
+use tw_bitcoin::modules::psbt_request::standard_psbt_request_builder::StandardPsbtRequestBuilder;
+use tw_bitcoin::modules::signing_request::standard_signing_request::StandardSigningRequestBuilder;
+use tw_coin_entry::error::prelude::SigningResult;
+use tw_hash::hasher::Hasher;
+use tw_hash::hasher::Hasher::Sha256;
+use tw_utxo::context::{AddressPrefixes, UtxoContext};
+use tw_utxo::fee::fee_estimator::StandardFeeEstimator;
+use tw_utxo::script::Script;
+use tw_utxo::transaction::standard_transaction::Transaction;
+
+#[derive(Default)]
+pub struct GroestlContext;
+
+impl UtxoContext for GroestlContext {
+    type Address = GroestlAddress;
+    type Transaction = Transaction;
+    type FeeEstimator = StandardFeeEstimator<Self::Transaction>;
+
+    /// Groestlcoin uses a different hash algorithm.
+    const TX_HASHER: Hasher = Sha256;
+
+    fn addr_to_script_pubkey(
+        addr: &Self::Address,
+        prefixes: AddressPrefixes,
+    ) -> SigningResult<Script> {
+        match addr {
+            GroestlAddress::Legacy(legacy) => {
+                legacy.to_script_pubkey(prefixes.p2pkh_prefix, prefixes.p2sh_prefix)
+            },
+            GroestlAddress::Segwit(segwit) => segwit.to_script_pubkey(),
+        }
+    }
+}
+
+impl BitcoinSigningContext for GroestlContext {
+    type SigningRequestBuilder = StandardSigningRequestBuilder;
+    type ProtobufBuilder = StandardProtobufBuilder;
+    type PsbtRequestBuilder = StandardPsbtRequestBuilder;
+}
diff --git a/rust/chains/tw_groestlcoin/src/entry.rs b/rust/chains/tw_groestlcoin/src/entry.rs
new file mode 100644
index 00000000000..f7c4b26fe97
--- /dev/null
+++ b/rust/chains/tw_groestlcoin/src/entry.rs
@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use crate::address::GroestlAddress;
+use crate::context::GroestlContext;
+use std::str::FromStr;
+use tw_bitcoin::modules::compiler::BitcoinCompiler;
+use tw_bitcoin::modules::planner::BitcoinPlanner;
+use tw_bitcoin::modules::signer::BitcoinSigner;
+use tw_bitcoin::modules::transaction_util::BitcoinTransactionUtil;
+use tw_coin_entry::coin_context::CoinContext;
+use tw_coin_entry::coin_entry::{CoinEntry, PublicKeyBytes, SignatureBytes};
+use tw_coin_entry::derivation::Derivation;
+use tw_coin_entry::error::prelude::*;
+use tw_coin_entry::modules::json_signer::NoJsonSigner;
+use tw_coin_entry::modules::message_signer::NoMessageSigner;
+use tw_coin_entry::modules::transaction_decoder::NoTransactionDecoder;
+use tw_coin_entry::modules::wallet_connector::NoWalletConnector;
+use tw_keypair::tw::PublicKey;
+use tw_proto::BitcoinV2::Proto;
+use tw_utxo::address::standard_bitcoin::StandardBitcoinPrefix;
+
+pub struct GroestlcoinEntry;
+
+impl CoinEntry for GroestlcoinEntry {
+    type AddressPrefix = StandardBitcoinPrefix;
+    type Address = GroestlAddress;
+    type SigningInput<'a> = Proto::SigningInput<'a>;
+    type SigningOutput = Proto::SigningOutput<'static>;
+    type PreSigningOutput = Proto::PreSigningOutput<'static>;
+
+    // Optional modules:
+    type JsonSigner = NoJsonSigner;
+    type PlanBuilder = BitcoinPlanner<GroestlContext>;
+    type MessageSigner = NoMessageSigner;
+    type WalletConnector = NoWalletConnector;
+    type TransactionDecoder = NoTransactionDecoder;
+    type TransactionUtil = BitcoinTransactionUtil;
+
+    #[inline]
+    fn parse_address(
+        &self,
+        coin: &dyn CoinContext,
+        address: &str,
+        prefix: Option<Self::AddressPrefix>,
+    ) -> AddressResult<Self::Address> {
+        GroestlAddress::from_str_with_coin_and_prefix(coin, address, prefix)
+    }
+
+    #[inline]
+    fn parse_address_unchecked(&self, address: &str) -> AddressResult<Self::Address> {
+        GroestlAddress::from_str(address)
+    }
+
+    #[inline]
+    fn derive_address(
+        &self,
+        coin: &dyn CoinContext,
+        public_key: PublicKey,
+        derivation: Derivation,
+        prefix: Option<Self::AddressPrefix>,
+    ) -> AddressResult<Self::Address> {
+        GroestlAddress::derive_as_tw(coin, &public_key, derivation, prefix)
+    }
+
+    #[inline]
+    fn sign(&self, coin: &dyn CoinContext, input: Self::SigningInput<'_>) -> Self::SigningOutput {
+        BitcoinSigner::<GroestlContext>::sign(coin, &input)
+    }
+
+    #[inline]
+    fn preimage_hashes(
+        &self,
+        coin: &dyn CoinContext,
+        input: Self::SigningInput<'_>,
+    ) -> Self::PreSigningOutput {
+        BitcoinCompiler::<GroestlContext>::preimage_hashes(coin, input)
+    }
+
+    #[inline]
+    fn compile(
+        &self,
+        coin: &dyn CoinContext,
+        input: Self::SigningInput<'_>,
+        signatures: Vec<SignatureBytes>,
+        public_keys: Vec<PublicKeyBytes>,
+    ) -> Self::SigningOutput {
+        BitcoinCompiler::<GroestlContext>::compile(coin, input, signatures, public_keys)
+    }
+
+    #[inline]
+    fn plan_builder(&self) -> Option<Self::PlanBuilder> {
+        Some(BitcoinPlanner::<GroestlContext>::default())
+    }
+}
diff --git a/rust/chains/tw_groestlcoin/src/lib.rs b/rust/chains/tw_groestlcoin/src/lib.rs
new file mode 100644
index 00000000000..5d921828cd6
--- /dev/null
+++ b/rust/chains/tw_groestlcoin/src/lib.rs
@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+//! The `tw_groestlcoin` crate provides an implementation of the Groestlcoin blockchain in Rust.
+//!
+//! This crate reuses Bitcoin's transaction Signer, SigHasher, and compiler APIs, ensuring a familiar
+//! and efficient experience for developers who have previously integrated Bitcoin via WalletCore.
+//!
+//! Unlike Bitcoin, Groestlcoin transactions use SHA-256 hashing algorithm for sig-hashing,
+//! and Groestl legacy addresses use `Groestl-512` checksum hashing.
+//!
+//! ## Key Features
+//!
+//! - **Transaction Signer**: Utilizes Bitcoin's transaction signing mechanisms.
+//! - **Pre-image hashing**: Utilizes Bitcoin's hashing algorithms in a specific way for Groestlcoin transaction.
+//! - **Compiler APIs**: Utilizes Bitcoin's compiler APIs to compile a transaction with externally signed signatures.
+//! - **Protobuf-Based Transaction Builder**: Provides a transaction builder based on Protobuf
+//!   definitions, facilitating the creation and manipulation of Groestlcoin transactions.
+//! - **Fee calculation**: Utilizes Bitcoin's transaction fee estimation and UTXO selection.
+//!
+//! ## Rust Usage
+//!
+//! ```rust,no_run
+//! # use std::str::FromStr;
+//! use tw_groestlcoin::address::groestlcoin_legacy::GroestlLegacyAddress;
+//! # use tw_hash::{H256, H32};
+//! # use tw_keypair::ecdsa::secp256k1;
+//! # use tw_utxo::modules::keys_manager::KeysManager;
+//! # use tw_utxo::modules::tx_signer::TxSigner;
+//! # use tw_utxo::sighash::{SighashBase, SighashType};
+//! # use tw_utxo::transaction::standard_transaction::builder::{OutputBuilder, TransactionBuilder, UtxoBuilder};
+//! #
+//! # let private_key: secp256k1::PrivateKey;
+//! # let public_key: secp256k1::PublicKey;
+//! # let branch_id: H32;
+//! # let txid: H256;
+//! # let keys_manager: KeysManager = unimplemented!();
+//!
+//! // Step 1 - Build an unsigned transaction.
+//!
+//! let mut tx_builder = TransactionBuilder::new();
+//!
+//! // Add a P2PKH UTXO.
+//! let (utxo, utxo_args) = UtxoBuilder::new()
+//!     .prev_txid(txid)
+//!     .prev_index(0)
+//!     .sequence(u32::MAX)
+//!     .amount(5000)
+//!     .sighash_type(SighashType::from_base(SighashBase::All))
+//!     .p2pkh(&public_key)
+//!     .unwrap();
+//! tx_builder.push_input(utxo, utxo_args);
+//!
+//! // Add a P2PKH Output.
+//! let recipient_addr = GroestlLegacyAddress::from_str("31inaRqambLsd9D7Ke4USZmGEVd3PHkh7P").unwrap();
+//! let output = OutputBuilder::new(2500).p2pkh_from_hash(&recipient_addr.payload());
+//! tx_builder.push_output(output);
+//!
+//! let unsigned_tx = tx_builder.build().unwrap();
+//!
+//! // Step 2 - Sign the transaction.
+//! let signed_tx = TxSigner::sign_tx(unsigned_tx, &keys_manager).unwrap();
+//! ```
+//!
+//! ## Integration with WalletCore
+//!
+//! If you are using WalletCore in Kotlin, Swift, TypeScript, or Golang, you can seamlessly integrate
+//! Groestlcoin functionality using the `AnySigner` or `TransactionCompiler` modules.
+//! To do this, pass a `BitcoinV2.Proto.SigningInput` to generate a transaction and sign/pre-image hash/compile it.
+//!
+//! ### TypeScript Example
+//!
+//! ```ts
+//! const utxo0 = Proto.Input.create({
+//!     outPoint: {
+//!         hash: utxoTxId,
+//!         vout: 0,
+//!     },
+//!     value: new Long(5000),
+//!     sighashType: BitcoinSigHashType.all.value,
+//!     receiverAddress: "grs1qw4teyraux2s77nhjdwh9ar8rl9dt7zww8r6lne",
+//! });
+//!
+//! const out0 = Proto.Output.create({
+//!     value: new Long(2500),
+//!     toAddress: "31inaRqambLsd9D7Ke4USZmGEVd3PHkh7P",
+//! });
+//!
+//! const changeOut = Proto.Output.create({
+//!     // Send the change amount to a different P2PKH address.
+//!     // The correct amount will be calculated for us.
+//!     toAddress: "Fj62rBJi8LvbmWu2jzkaUX1NFXLEqDLoZM",
+//! });
+//!
+//! const signingInput = Proto.SigningInput.create({
+//!     builder: {
+//!         version: Proto.TransactionVersion.UseDefault,
+//!         inputs: [utxo0],
+//!         outputs: [out0],
+//!         changeOutput: changeOut,
+//!         inputSelector: Proto.InputSelector.SelectDescending,
+//!         fixedDustThreshold: dustAmount,
+//!     },
+//!     privateKeys: [privateKeyData],
+//!     chainInfo: {
+//!         p2pkhPrefix: 36,
+//!         p2shPrefix: 5,
+//!     },
+//! });
+//!
+//! // Wrap `BitcoinV2.Proto.SigningInput` signing request into a legacy `Bitcoin.Proto.SigningInput`.
+//! const legacySigningInput = TW.Bitcoin.Proto.SigningInput.create({
+//!     signingV2: signingInput,
+//!     coinType: CoinType.groestlcoin.value,
+//! });
+//!
+//! const encoded = TW.Bitcoin.Proto.SigningInput.encode(legacySigningInput).finish();
+//! const outputData = AnySigner.sign(encoded, CoinType.groestlcoin);
+//! const output = TW.Bitcoin.Proto.SigningOutput.decode(outputData);
+//!
+//! assert.equal(output.error, TW.Common.Proto.SigningError.OK);
+//! assert.equal(output.signingResultV2!.error, TW.Common.Proto.SigningError.OK);
+//! ```
+
+pub mod address;
+pub mod context;
+pub mod entry;
diff --git a/rust/chains/tw_ripple/src/address/classic_address.rs b/rust/chains/tw_ripple/src/address/classic_address.rs
index dd5c231d85b..28e9cc5d700 100644
--- a/rust/chains/tw_ripple/src/address/classic_address.rs
+++ b/rust/chains/tw_ripple/src/address/classic_address.rs
@@ -8,7 +8,8 @@ use tw_base58_address::Base58Address;
 use tw_coin_entry::coin_entry::CoinAddress;
 use tw_coin_entry::error::prelude::*;
 use tw_encoding::base58::Alphabet;
-use tw_hash::hasher::{sha256_ripemd, Hasher};
+use tw_hash::ripemd::sha256_ripemd;
+use tw_hash::sha2::Sha256d;
 use tw_hash::H160;
 use tw_keypair::ecdsa;
 use tw_memory::Data;
@@ -22,7 +23,9 @@ pub const RIPPLE_ADDRESS_PREFIX: u8 = 0x00;
 pub const ACCOUNT_ZERO_BYTES: [u8; RIPPLE_ADDRESS_SIZE] = [0; RIPPLE_ADDRESS_SIZE];
 
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct ClassicAddress(Base58Address<RIPPLE_ADDRESS_SIZE, RIPPLE_ADDRESS_CHECKSUM_SIZE>);
+pub struct ClassicAddress(
+    Base58Address<RIPPLE_ADDRESS_SIZE, RIPPLE_ADDRESS_CHECKSUM_SIZE, Sha256d>,
+);
 
 serde_as_string!(ClassicAddress);
 
@@ -31,7 +34,7 @@ impl ClassicAddress {
         let bytes: Data = std::iter::once(RIPPLE_ADDRESS_PREFIX)
             .chain(public_key_hash.iter().copied())
             .collect();
-        Base58Address::new(&bytes, Alphabet::Ripple, Hasher::Sha256d).map(ClassicAddress)
+        Base58Address::new(&bytes, Alphabet::Ripple).map(ClassicAddress)
     }
 
     pub fn with_public_key(
@@ -54,13 +57,9 @@ impl ClassicAddress {
 
 impl Default for ClassicAddress {
     fn default() -> Self {
-        Base58Address::new(
-            ACCOUNT_ZERO_BYTES.as_slice(),
-            Alphabet::Ripple,
-            Hasher::Sha256d,
-        )
-        .map(ClassicAddress)
-        .expect("'ACCOUNT_ZERO_BYTES' is expected to be valid address bytes")
+        Base58Address::new(ACCOUNT_ZERO_BYTES.as_slice(), Alphabet::Ripple)
+            .map(ClassicAddress)
+            .expect("'ACCOUNT_ZERO_BYTES' is expected to be valid address bytes")
     }
 }
 
@@ -75,8 +74,7 @@ impl FromStr for ClassicAddress {
     type Err = AddressError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let base58_addr =
-            Base58Address::from_str_with_alphabet(s, Alphabet::Ripple, Hasher::Sha256d)?;
+        let base58_addr = Base58Address::from_str_with_alphabet(s, Alphabet::Ripple)?;
         if base58_addr.bytes[0] != RIPPLE_ADDRESS_PREFIX {
             return Err(AddressError::UnexpectedAddressPrefix);
         }
diff --git a/rust/chains/tw_ripple/src/address/x_address.rs b/rust/chains/tw_ripple/src/address/x_address.rs
index 55aaac3fdef..ab2a9c02180 100644
--- a/rust/chains/tw_ripple/src/address/x_address.rs
+++ b/rust/chains/tw_ripple/src/address/x_address.rs
@@ -11,7 +11,7 @@ use tw_base58_address::Base58Address;
 use tw_coin_entry::coin_entry::CoinAddress;
 use tw_coin_entry::error::prelude::*;
 use tw_encoding::base58::Alphabet;
-use tw_hash::hasher::Hasher;
+use tw_hash::sha2::Sha256d;
 use tw_hash::H160;
 use tw_memory::Data;
 use tw_misc::serde_as_string;
@@ -41,7 +41,7 @@ pub enum TagFlag {
 pub struct XAddress {
     /// Destination tag.
     tag: u32,
-    inner: Base58Address<X_ADDRESS_LEN, X_ADDRESS_CHECKSUM_LEN>,
+    inner: Base58Address<X_ADDRESS_LEN, X_ADDRESS_CHECKSUM_LEN, Sha256d>,
     /// Destination tag flag, none/32/64bit.
     tag_flag: TagFlag,
 }
@@ -81,7 +81,7 @@ impl FromStr for XAddress {
     type Err = AddressError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let inner = Base58Address::from_str_with_alphabet(s, Alphabet::Ripple, Hasher::Sha256d)?;
+        let inner = Base58Address::from_str_with_alphabet(s, Alphabet::Ripple)?;
 
         // Check prefix.
         if inner.bytes[PREFIX_RANGE] != MAINNET_PREFIX {
diff --git a/rust/chains/tw_zcash/src/lib.rs b/rust/chains/tw_zcash/src/lib.rs
index c6f006f0978..7c98f1be7a4 100644
--- a/rust/chains/tw_zcash/src/lib.rs
+++ b/rust/chains/tw_zcash/src/lib.rs
@@ -6,7 +6,8 @@
 //!
 //! This crate reuses Bitcoin's transaction Signer, SigHasher, and compiler APIs, ensuring a familiar
 //! and efficient experience for developers who have previously integrated Bitcoin via WalletCore.
-//! However, `tw_zcash` introduces a different transaction structure (transparent only)
+//!
+//! Unlike Bitcoin, ZCash introduces a different transaction structure (transparent only)
 //! and transaction builder.
 //!
 //! ## Key Features
diff --git a/rust/chains/tw_zcash/src/modules/zcash_sighash.rs b/rust/chains/tw_zcash/src/modules/zcash_sighash.rs
index 019c47dd52b..8c513486a01 100644
--- a/rust/chains/tw_zcash/src/modules/zcash_sighash.rs
+++ b/rust/chains/tw_zcash/src/modules/zcash_sighash.rs
@@ -4,8 +4,7 @@
 
 use crate::transaction::ZcashTransaction;
 use tw_coin_entry::error::prelude::*;
-use tw_hash::blake2::blake2_b_personal;
-use tw_hash::hasher::Blake2bPersonalHasher;
+use tw_hash::blake2::{blake2_b_personal, Blake2bPersonalHasher};
 use tw_hash::{H128, H256};
 use tw_memory::Data;
 use tw_utxo::encode::stream::Stream;
diff --git a/rust/chains/tw_zcash/src/t_address.rs b/rust/chains/tw_zcash/src/t_address.rs
index 6ac40d19032..8c4579a5479 100644
--- a/rust/chains/tw_zcash/src/t_address.rs
+++ b/rust/chains/tw_zcash/src/t_address.rs
@@ -12,7 +12,8 @@ use tw_coin_entry::error::prelude::{
 };
 use tw_coin_entry::prefix::BitcoinBase58Prefix;
 use tw_encoding::base58::Alphabet;
-use tw_hash::hasher::{sha256_ripemd, Hasher};
+use tw_hash::ripemd::sha256_ripemd;
+use tw_hash::sha2::Sha256d;
 use tw_hash::H160;
 use tw_keypair::{ecdsa, tw};
 use tw_memory::Data;
@@ -24,7 +25,7 @@ pub const ZCASH_ADDRESS_CHECKSUM_SIZE: usize = 4;
 /// For now, T-prefix is a constant value.
 pub const ZCASH_T_PREFIX: u8 = 0x1C;
 
-type ZcashBase58Address = Base58Address<ZCASH_ADDRESS_SIZE, ZCASH_ADDRESS_CHECKSUM_SIZE>;
+type ZcashBase58Address = Base58Address<ZCASH_ADDRESS_SIZE, ZCASH_ADDRESS_CHECKSUM_SIZE, Sha256d>;
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct TAddress(ZcashBase58Address);
@@ -37,7 +38,7 @@ impl TAddress {
         bytes.push(prefix);
         bytes.extend_from_slice(data);
 
-        ZcashBase58Address::new(&bytes, Alphabet::Bitcoin, Hasher::Sha256d).map(TAddress)
+        ZcashBase58Address::new(&bytes, Alphabet::Bitcoin).map(TAddress)
     }
 
     pub fn p2pkh_with_public_key(
@@ -132,8 +133,7 @@ impl FromStr for TAddress {
     type Err = AddressError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        ZcashBase58Address::from_str_with_alphabet(s, Alphabet::Bitcoin, Hasher::Sha256d)
-            .map(TAddress)
+        ZcashBase58Address::from_str_with_alphabet(s, Alphabet::Bitcoin).map(TAddress)
     }
 }
 
diff --git a/rust/chains/tw_zcash/src/transaction/mod.rs b/rust/chains/tw_zcash/src/transaction/mod.rs
index 4b75ab3738c..82420967d8d 100644
--- a/rust/chains/tw_zcash/src/transaction/mod.rs
+++ b/rust/chains/tw_zcash/src/transaction/mod.rs
@@ -4,7 +4,7 @@
 
 use crate::modules::zcash_sighash::ZcashSighash;
 use tw_coin_entry::error::prelude::{ResultContext, SigningError, SigningErrorType, SigningResult};
-use tw_hash::hasher::sha256_d;
+use tw_hash::hasher::{Hasher, StatefulHasher};
 use tw_hash::{H256, H32};
 use tw_utxo::encode::compact_integer::CompactInteger;
 use tw_utxo::encode::stream::Stream;
@@ -140,9 +140,9 @@ impl TransactionInterface for ZcashTransaction {
         self.total_size() * SEGWIT_SCALE_FACTOR
     }
 
-    fn txid(&self) -> Vec<u8> {
+    fn txid(&self, hasher: Hasher) -> Vec<u8> {
         let encoded = self.encode_out();
-        let mut tx_hash = sha256_d(&encoded);
+        let mut tx_hash = hasher.hash(&encoded);
         tx_hash.reverse();
         tx_hash
     }
diff --git a/rust/frameworks/tw_utxo/src/address/legacy.rs b/rust/frameworks/tw_utxo/src/address/legacy.rs
index c0d0023d765..9d40bff20b6 100644
--- a/rust/frameworks/tw_utxo/src/address/legacy.rs
+++ b/rust/frameworks/tw_utxo/src/address/legacy.rs
@@ -5,6 +5,7 @@
 use crate::script::standard_script::conditions;
 use crate::script::Script;
 use std::fmt;
+use std::marker::PhantomData;
 use std::str::FromStr;
 use tw_base58_address::Base58Address;
 use tw_coin_entry::coin_context::CoinContext;
@@ -12,7 +13,9 @@ use tw_coin_entry::coin_entry::CoinAddress;
 use tw_coin_entry::error::prelude::*;
 use tw_coin_entry::prefix::BitcoinBase58Prefix;
 use tw_encoding::base58::Alphabet;
-use tw_hash::hasher::{sha256_ripemd, Hasher};
+use tw_hash::hasher::StaticHasher;
+use tw_hash::ripemd::Sha256Ripemd;
+use tw_hash::sha2::Sha256d;
 use tw_hash::H160;
 use tw_keypair::{ecdsa, tw};
 use tw_memory::Data;
@@ -20,27 +23,44 @@ use tw_memory::Data;
 pub const BITCOIN_ADDRESS_SIZE: usize = 21;
 pub const BITCOIN_ADDRESS_CHECKSUM_SIZE: usize = 4;
 
-type BitcoinBase58Address = Base58Address<BITCOIN_ADDRESS_SIZE, BITCOIN_ADDRESS_CHECKSUM_SIZE>;
+pub type BitcoinBase58Address =
+    Base58Address<BITCOIN_ADDRESS_SIZE, BITCOIN_ADDRESS_CHECKSUM_SIZE, Sha256d>;
 
+pub type LegacyAddress = PrefixedBase58Address<Sha256Ripemd, Sha256d>;
+
+/// Bitcoin Legacy address generic implementation.
+/// It can be configured to be used with a custom `PublicKeyHasher` and `ChecksumHasher` algorithms.
+///
+/// Please note [`PublicKeyHasher::HASH_LEN`] must equal to 20.
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct LegacyAddress(BitcoinBase58Address);
+pub struct PrefixedBase58Address<PublicKeyHasher, ChecksumHasher> {
+    inner: Base58Address<BITCOIN_ADDRESS_SIZE, BITCOIN_ADDRESS_CHECKSUM_SIZE, ChecksumHasher>,
+    _phantom: PhantomData<PublicKeyHasher>,
+}
 
-impl LegacyAddress {
-    pub fn new(prefix: u8, data: &[u8]) -> AddressResult<LegacyAddress> {
+impl<PublicKeyHasher, ChecksumHasher> PrefixedBase58Address<PublicKeyHasher, ChecksumHasher>
+where
+    PublicKeyHasher: StaticHasher,
+    ChecksumHasher: StaticHasher,
+{
+    pub fn new(prefix: u8, data: &[u8]) -> AddressResult<Self> {
         let mut bytes = Vec::with_capacity(data.len() + 1);
         // Insert the prefix to the beginning of the address bytes array.
         bytes.push(prefix);
         bytes.extend_from_slice(data);
 
-        BitcoinBase58Address::new(&bytes, Alphabet::Bitcoin, Hasher::Sha256d).map(LegacyAddress)
+        Base58Address::new(&bytes, Alphabet::Bitcoin).map(|inner| PrefixedBase58Address {
+            inner,
+            _phantom: PhantomData,
+        })
     }
 
     pub fn p2pkh_with_public_key(
         p2pkh_prefix: u8,
         public_key: &ecdsa::secp256k1::PublicKey,
-    ) -> AddressResult<LegacyAddress> {
-        let public_key_hash = sha256_ripemd(public_key.compressed().as_slice());
-        LegacyAddress::new(p2pkh_prefix, &public_key_hash)
+    ) -> AddressResult<Self> {
+        let public_key_hash = PublicKeyHasher::hash(public_key.compressed().as_slice());
+        PrefixedBase58Address::new(p2pkh_prefix, &public_key_hash)
     }
 
     /// Tries to parse a `LegacyAddress` and check if
@@ -48,7 +68,7 @@ impl LegacyAddress {
         coin: &dyn CoinContext,
         public_key: &tw::PublicKey,
         prefix: Option<BitcoinBase58Prefix>,
-    ) -> AddressResult<LegacyAddress> {
+    ) -> AddressResult<Self> {
         let p2pkh_prefix = match prefix {
             Some(prefix) => prefix.p2pkh,
             None => coin.p2pkh_prefix().ok_or(AddressError::InvalidRegistry)?,
@@ -58,22 +78,19 @@ impl LegacyAddress {
             .to_secp256k1()
             .ok_or(AddressError::PublicKeyTypeMismatch)?;
 
-        LegacyAddress::p2pkh_with_public_key(p2pkh_prefix, ecdsa_public_key)
+        PrefixedBase58Address::p2pkh_with_public_key(p2pkh_prefix, ecdsa_public_key)
     }
 
-    pub fn p2sh_with_prefix_byte(
-        redeem_script: &Script,
-        p2sh_prefix: u8,
-    ) -> AddressResult<LegacyAddress> {
-        let script_hash = sha256_ripemd(redeem_script.as_slice());
-        LegacyAddress::new(p2sh_prefix, &script_hash)
+    pub fn p2sh_with_prefix_byte(redeem_script: &Script, p2sh_prefix: u8) -> AddressResult<Self> {
+        let script_hash = PublicKeyHasher::hash(redeem_script.as_slice());
+        PrefixedBase58Address::new(p2sh_prefix, &script_hash)
     }
 
     pub fn from_str_with_coin_and_prefix(
         coin: &dyn CoinContext,
         s: &str,
         prefix: Option<BitcoinBase58Prefix>,
-    ) -> AddressResult<LegacyAddress> {
+    ) -> AddressResult<Self> {
         let base58_prefix = match prefix {
             Some(base58_prefix) => base58_prefix,
             None => {
@@ -83,15 +100,11 @@ impl LegacyAddress {
             },
         };
 
-        LegacyAddress::from_str_checked(s, base58_prefix.p2pkh, base58_prefix.p2sh)
+        PrefixedBase58Address::from_str_checked(s, base58_prefix.p2pkh, base58_prefix.p2sh)
     }
 
-    pub fn from_str_checked(
-        s: &str,
-        p2pkh_prefix: u8,
-        p2sh_prefix: u8,
-    ) -> AddressResult<LegacyAddress> {
-        let addr = LegacyAddress::from_str(s)?;
+    pub fn from_str_checked(s: &str, p2pkh_prefix: u8, p2sh_prefix: u8) -> AddressResult<Self> {
+        let addr = PrefixedBase58Address::from_str(s)?;
         if addr.prefix() == p2pkh_prefix || addr.prefix() == p2sh_prefix {
             Ok(addr)
         } else {
@@ -100,12 +113,12 @@ impl LegacyAddress {
     }
 
     pub fn prefix(&self) -> u8 {
-        self.0.as_ref()[0]
+        self.inner.as_ref()[0]
     }
 
     /// Address bytes excluding the prefix (skip first byte).
     pub fn bytes(&self) -> &[u8] {
-        &self.0.as_ref()[1..]
+        &self.inner.as_ref()[1..]
     }
 
     pub fn payload(&self) -> H160 {
@@ -129,30 +142,54 @@ impl LegacyAddress {
     }
 }
 
-impl FromStr for LegacyAddress {
+impl<PublicKeyHasher, ChecksumHasher> FromStr
+    for PrefixedBase58Address<PublicKeyHasher, ChecksumHasher>
+where
+    PublicKeyHasher: StaticHasher,
+    ChecksumHasher: StaticHasher,
+{
     type Err = AddressError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        BitcoinBase58Address::from_str_with_alphabet(s, Alphabet::Bitcoin, Hasher::Sha256d)
-            .map(LegacyAddress)
+        Base58Address::from_str_with_alphabet(s, Alphabet::Bitcoin).map(|inner| {
+            PrefixedBase58Address {
+                inner,
+                _phantom: PhantomData,
+            }
+        })
     }
 }
 
-impl<'a> TryFrom<&'a [u8]> for LegacyAddress {
+impl<'a, PublicKeyHasher, ChecksumHasher> TryFrom<&'a [u8]>
+    for PrefixedBase58Address<PublicKeyHasher, ChecksumHasher>
+where
+    PublicKeyHasher: StaticHasher,
+    ChecksumHasher: StaticHasher,
+{
     type Error = AddressError;
 
     fn try_from(bytes: &'a [u8]) -> Result<Self, Self::Error> {
-        BitcoinBase58Address::new(bytes, Alphabet::Bitcoin, Hasher::Sha256d).map(LegacyAddress)
+        Base58Address::new(bytes, Alphabet::Bitcoin).map(|inner| PrefixedBase58Address {
+            inner,
+            _phantom: PhantomData,
+        })
     }
 }
 
-impl fmt::Display for LegacyAddress {
+impl<PublicKeyHasher, ChecksumHasher> fmt::Display
+    for PrefixedBase58Address<PublicKeyHasher, ChecksumHasher>
+{
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.0)
+        write!(f, "{}", self.inner)
     }
 }
 
-impl CoinAddress for LegacyAddress {
+impl<PublicKeyHasher, ChecksumHasher> CoinAddress
+    for PrefixedBase58Address<PublicKeyHasher, ChecksumHasher>
+where
+    PublicKeyHasher: StaticHasher,
+    ChecksumHasher: StaticHasher,
+{
     fn data(&self) -> Data {
         self.bytes().to_vec()
     }
diff --git a/rust/frameworks/tw_utxo/src/address/segwit.rs b/rust/frameworks/tw_utxo/src/address/segwit.rs
index 0083a98f2bc..3f31740e456 100644
--- a/rust/frameworks/tw_utxo/src/address/segwit.rs
+++ b/rust/frameworks/tw_utxo/src/address/segwit.rs
@@ -10,7 +10,7 @@ use core::fmt;
 use std::str::FromStr;
 use tw_coin_entry::coin_context::CoinContext;
 use tw_coin_entry::error::prelude::*;
-use tw_hash::hasher::sha256_ripemd;
+use tw_hash::ripemd::sha256_ripemd;
 use tw_hash::sha2::sha256;
 use tw_hash::{H160, H256};
 use tw_keypair::tw;
diff --git a/rust/frameworks/tw_utxo/src/context.rs b/rust/frameworks/tw_utxo/src/context.rs
index 0fd07fffd3d..6305dae7232 100644
--- a/rust/frameworks/tw_utxo/src/context.rs
+++ b/rust/frameworks/tw_utxo/src/context.rs
@@ -4,10 +4,12 @@
 
 use crate::fee::fee_estimator::FeeEstimator;
 use crate::script::Script;
+use crate::transaction::standard_transaction::DEFAULT_TX_HASHER;
 use crate::transaction::transaction_interface::TransactionInterface;
 use crate::transaction::TransactionPreimage;
 use std::str::FromStr;
 use tw_coin_entry::error::prelude::*;
+use tw_hash::hasher::Hasher;
 
 pub type ContextTransactionInput<Context> =
     <<Context as UtxoContext>::Transaction as TransactionInterface>::Input;
@@ -24,6 +26,8 @@ pub trait UtxoContext {
     type Transaction: TransactionPreimage + TransactionInterface;
     type FeeEstimator: FeeEstimator<Self::Transaction>;
 
+    const TX_HASHER: Hasher = DEFAULT_TX_HASHER;
+
     fn addr_to_script_pubkey(
         addr: &Self::Address,
         prefixes: AddressPrefixes,
diff --git a/rust/frameworks/tw_utxo/src/transaction/standard_transaction/builder/output.rs b/rust/frameworks/tw_utxo/src/transaction/standard_transaction/builder/output.rs
index 657013bbb55..62b909593a5 100644
--- a/rust/frameworks/tw_utxo/src/transaction/standard_transaction/builder/output.rs
+++ b/rust/frameworks/tw_utxo/src/transaction/standard_transaction/builder/output.rs
@@ -7,7 +7,8 @@ use crate::{
     },
 };
 use tw_coin_entry::error::prelude::*;
-use tw_hash::{ripemd::bitcoin_hash_160, sha2::sha256, H160, H256};
+use tw_hash::ripemd::sha256_ripemd;
+use tw_hash::{sha2::sha256, H160, H256};
 use tw_keypair::{ecdsa, schnorr};
 
 pub const OP_RETURN_DATA_LIMIT: usize = 80;
@@ -33,7 +34,7 @@ impl OutputBuilder {
     }
 
     pub fn p2sh(self, redeem_script: &[u8]) -> TransactionOutput {
-        let h = bitcoin_hash_160(redeem_script);
+        let h = sha256_ripemd(redeem_script);
         let redeem_hash: H160 = h
             .as_slice()
             .try_into()
@@ -57,7 +58,7 @@ impl OutputBuilder {
     }
 
     pub fn p2pkh(self, pubkey: &ecdsa::secp256k1::PublicKey) -> TransactionOutput {
-        let h = bitcoin_hash_160(pubkey.compressed().as_slice());
+        let h = sha256_ripemd(pubkey.compressed().as_slice());
         let pubkey_hash: H160 = h
             .as_slice()
             .try_into()
@@ -88,7 +89,7 @@ impl OutputBuilder {
     }
 
     pub fn p2wpkh(self, pubkey: &ecdsa::secp256k1::PublicKey) -> TransactionOutput {
-        let h = bitcoin_hash_160(pubkey.compressed().as_slice());
+        let h = sha256_ripemd(pubkey.compressed().as_slice());
         let pubkey_hash: H160 = h.as_slice().try_into().expect("hash length is 20 bytes");
 
         self.p2wpkh_from_hash(&pubkey_hash)
diff --git a/rust/frameworks/tw_utxo/src/transaction/standard_transaction/builder/utxo.rs b/rust/frameworks/tw_utxo/src/transaction/standard_transaction/builder/utxo.rs
index cd58dd56d8b..595c06f79e7 100644
--- a/rust/frameworks/tw_utxo/src/transaction/standard_transaction/builder/utxo.rs
+++ b/rust/frameworks/tw_utxo/src/transaction/standard_transaction/builder/utxo.rs
@@ -1,6 +1,7 @@
 use super::TransactionInput;
 use crate::sighash::SighashType;
 use crate::spending_data::{standard_constructor, SpendingDataConstructor};
+use crate::transaction::standard_transaction::DEFAULT_TX_HASHER;
 use crate::transaction::UtxoToSign;
 use crate::{
     script::{standard_script::conditions, Script, Witness},
@@ -10,19 +11,21 @@ use crate::{
 };
 use bitcoin::hashes::Hash;
 use tw_coin_entry::error::prelude::*;
-use tw_hash::{hasher::Hasher, ripemd::bitcoin_hash_160, H160, H256};
+use tw_hash::ripemd::sha256_ripemd;
+use tw_hash::{hasher::Hasher, H160, H256};
 use tw_keypair::{ecdsa, schnorr};
 use tw_memory::Data;
 use tw_misc::traits::ToBytesVec;
 
-pub const DEFAULT_TX_HASHER: Hasher = Hasher::Sha256d;
-
 pub struct UtxoBuilder {
     input: TransactionInput,
     prev_txid: Option<H256>,
     prev_index: Option<u32>,
     amount: Option<Amount>,
     sighash_ty: Option<SighashType>,
+    /// Transaction hasher used to pre-image transaction or get a transaction hash.
+    /// Note it doesn't affect Taproot transactions.
+    tx_hasher: Hasher,
 }
 
 impl UtxoBuilder {
@@ -38,6 +41,7 @@ impl UtxoBuilder {
             prev_index: None,
             amount: None,
             sighash_ty: None,
+            tx_hasher: DEFAULT_TX_HASHER,
         }
     }
 
@@ -66,6 +70,13 @@ impl UtxoBuilder {
         self
     }
 
+    /// Specify a transaction hash algorithm used to pre-image transaction or get a transaction hash.
+    /// Note it doesn't affect Taproot transactions.
+    pub fn tx_hasher(mut self, tx_hasher: Hasher) -> Self {
+        self.tx_hasher = tx_hasher;
+        self
+    }
+
     fn finalize_out_point(&mut self) -> SigningResult<()> {
         // Populate the input with the previous output.
         self.input.previous_output.hash = self
@@ -94,7 +105,7 @@ impl UtxoBuilder {
 
     // TODO next iteration.
     // pub fn p2sh(self, redeem_script: Script) -> SigningResult<(TransactionInput, UtxoToSign)> {
-    //     let h = bitcoin_hash_160(redeem_script.as_slice());
+    //     let h = sha256_ripemd(redeem_script.as_slice());
     //     let redeem_hash: H160 = h.as_slice().try_into().expect("hash length is 20 bytes");
     //
     //     self.p2sh_with_hash(redeem_hash)
@@ -145,7 +156,7 @@ impl UtxoBuilder {
                 spender_public_key: pubkey.compressed().to_vec(),
                 amount,
                 leaf_hash_code_separator: None,
-                tx_hasher: DEFAULT_TX_HASHER,
+                tx_hasher: self.tx_hasher,
                 sighash_ty,
             },
         ))
@@ -155,7 +166,7 @@ impl UtxoBuilder {
         mut self,
         pubkey: &ecdsa::secp256k1::PublicKey,
     ) -> SigningResult<(TransactionInput, UtxoToSign)> {
-        let h = bitcoin_hash_160(pubkey.compressed().as_slice());
+        let h = sha256_ripemd(pubkey.compressed().as_slice());
         let pubkey_hash: H160 = h.as_slice().try_into().expect("hash length is 20 bytes");
 
         self.finalize_out_point()?;
@@ -182,7 +193,7 @@ impl UtxoBuilder {
                 spender_public_key: pubkey.compressed().to_vec(),
                 amount,
                 leaf_hash_code_separator: None,
-                tx_hasher: DEFAULT_TX_HASHER,
+                tx_hasher: self.tx_hasher,
                 sighash_ty,
             },
         ))
@@ -206,7 +217,7 @@ impl UtxoBuilder {
     //             spending_data_constructor: SpendingDataConstructor::ecdsa(todo!()),
     //             amount,
     //             leaf_hash_code_separator: None,
-    //             tx_hasher: DEFAULT_TX_HASHER,
+    //             tx_hasher: self.tx_hasher,
     //             sighash_ty,
     //         },
     //     ))
@@ -216,7 +227,7 @@ impl UtxoBuilder {
         mut self,
         pubkey: &ecdsa::secp256k1::PublicKey,
     ) -> SigningResult<(TransactionInput, UtxoToSign)> {
-        let h = bitcoin_hash_160(pubkey.compressed().as_slice());
+        let h = sha256_ripemd(pubkey.compressed().as_slice());
         let pubkey_hash: H160 = h.as_slice().try_into().expect("hash length is 20 bytes");
 
         self.finalize_out_point()?;
@@ -244,7 +255,7 @@ impl UtxoBuilder {
                 signing_method: SigningMethod::Segwit,
                 amount,
                 leaf_hash_code_separator: None,
-                tx_hasher: DEFAULT_TX_HASHER,
+                tx_hasher: self.tx_hasher,
                 sighash_ty,
             },
         ))
@@ -284,7 +295,7 @@ impl UtxoBuilder {
                 spender_public_key: tweaked_pubkey.bytes().to_vec(),
                 amount,
                 leaf_hash_code_separator: None,
-                // Note that we don't use the default double-hasher.
+                // Note Taproot transactions use Sha256 hash, not [`UtxoToSign::tx_hasher`].
                 tx_hasher: Hasher::Sha256,
                 sighash_ty,
             },
@@ -456,7 +467,7 @@ impl P2TRScriptPathUtxoBuilder {
                 spender_public_key,
                 amount,
                 leaf_hash_code_separator: Some((leaf_hash, u32::MAX)),
-                // Note that we don't use the default double-hasher.
+                // Note Taproot transactions use Sha256 hash, not [`UtxoToSign::tx_hasher`].
                 tx_hasher: Hasher::Sha256,
                 sighash_ty,
             },
diff --git a/rust/frameworks/tw_utxo/src/transaction/standard_transaction/mod.rs b/rust/frameworks/tw_utxo/src/transaction/standard_transaction/mod.rs
index d1f8953ac1a..fc3d25627c8 100644
--- a/rust/frameworks/tw_utxo/src/transaction/standard_transaction/mod.rs
+++ b/rust/frameworks/tw_utxo/src/transaction/standard_transaction/mod.rs
@@ -2,6 +2,8 @@
 //
 // Copyright © 2017 Trust Wallet.
 
+use super::transaction_sighash::taproot1_sighash::Taproot1Sighash;
+use super::UtxoTaprootPreimageArgs;
 use crate::encode::compact_integer::CompactInteger;
 use crate::encode::stream::Stream;
 use crate::encode::Encodable;
@@ -16,11 +18,10 @@ use crate::transaction::transaction_sighash::legacy_sighash::LegacySighash;
 use crate::transaction::transaction_sighash::witness0_sighash::Witness0Sighash;
 use crate::transaction::{TransactionPreimage, UtxoPreimageArgs};
 use tw_coin_entry::error::prelude::*;
-use tw_hash::hasher::sha256_d;
+use tw_hash::hasher::{Hasher, StatefulHasher};
 use tw_hash::H256;
 
-use super::transaction_sighash::taproot1_sighash::Taproot1Sighash;
-use super::UtxoTaprootPreimageArgs;
+pub const DEFAULT_TX_HASHER: Hasher = Hasher::Sha256d;
 
 pub mod builder;
 
@@ -114,9 +115,9 @@ impl TransactionInterface for Transaction {
         self.base_size() * 3 + self.total_size()
     }
 
-    fn txid(&self) -> Vec<u8> {
+    fn txid(&self, hasher: Hasher) -> Vec<u8> {
         let encoded = self.without_witness().encode_out();
-        let mut tx_hash = sha256_d(&encoded);
+        let mut tx_hash = hasher.hash(&encoded);
         tx_hash.reverse();
         tx_hash
     }
diff --git a/rust/frameworks/tw_utxo/src/transaction/transaction_hashing.rs b/rust/frameworks/tw_utxo/src/transaction/transaction_hashing.rs
index 3e9da6fa899..057ada86780 100644
--- a/rust/frameworks/tw_utxo/src/transaction/transaction_hashing.rs
+++ b/rust/frameworks/tw_utxo/src/transaction/transaction_hashing.rs
@@ -7,7 +7,7 @@ use crate::encode::stream::Stream;
 use crate::sighash::{SighashBase, SighashType};
 use crate::transaction::transaction_interface::{TransactionInterface, TxInputInterface};
 use std::marker::PhantomData;
-use tw_hash::hasher::HasherOps;
+use tw_hash::hasher::StatefulHasher;
 use tw_memory::Data;
 
 use super::UtxoTaprootPreimageArgs;
@@ -19,7 +19,7 @@ pub struct TransactionHasher<Transaction> {
 
 impl<Transaction: TransactionInterface> TransactionHasher<Transaction> {
     /// Computes a hash of all [`SignedUtxo::previour_output`].
-    pub fn prevout_hash<Hasher: HasherOps>(tx: &Transaction, tx_hasher: Hasher) -> Data {
+    pub fn prevout_hash<Hasher: StatefulHasher>(tx: &Transaction, tx_hasher: Hasher) -> Data {
         let mut stream = Stream::default();
         for input in tx.inputs() {
             stream.append(input.previous_output());
@@ -29,7 +29,7 @@ impl<Transaction: TransactionInterface> TransactionHasher<Transaction> {
 
     /// Returns a zero hash if [`UtxoPreimageArgs::sighash::anyone_can_pay`] is true,
     /// otherwise returns a hash of all [`TransactionInput::previour_output`].
-    pub fn preimage_prevout_hash<Hasher: HasherOps>(
+    pub fn preimage_prevout_hash<Hasher: StatefulHasher>(
         tx: &Transaction,
         sighash_ty: SighashType,
         tx_hasher: Hasher,
@@ -59,7 +59,7 @@ impl<Transaction: TransactionInterface> TransactionHasher<Transaction> {
     }
 
     /// Computes a hash of all [`SignedUtxo::sequence`].
-    pub fn sequence_hash<Hasher: HasherOps>(tx: &Transaction, tx_hasher: Hasher) -> Data {
+    pub fn sequence_hash<Hasher: StatefulHasher>(tx: &Transaction, tx_hasher: Hasher) -> Data {
         let mut stream = Stream::default();
         for input in tx.inputs() {
             stream.append(&input.sequence());
@@ -69,7 +69,7 @@ impl<Transaction: TransactionInterface> TransactionHasher<Transaction> {
 
     /// Returns a zero hash if [`UtxoPreimageArgs::sighash`] requires it (see the code below),
     /// otherwise returns a hash of all [`TransactionInput::sequence`].
-    pub fn preimage_sequence_hash<Hasher: HasherOps>(
+    pub fn preimage_sequence_hash<Hasher: StatefulHasher>(
         tx: &Transaction,
         sighash_ty: SighashType,
         tx_hasher: Hasher,
@@ -86,7 +86,7 @@ impl<Transaction: TransactionInterface> TransactionHasher<Transaction> {
 
     /// Returns a hash of required [`TransactionOutput`] according to the [`UtxoPreimageArgs::sighash`].
     /// Please note the function can return a zero hash if necessary.
-    pub fn preimage_outputs_hash<Hasher: HasherOps>(
+    pub fn preimage_outputs_hash<Hasher: StatefulHasher>(
         tx: &Transaction,
         input_index: usize,
         sighash_ty: SighashType,
diff --git a/rust/frameworks/tw_utxo/src/transaction/transaction_interface.rs b/rust/frameworks/tw_utxo/src/transaction/transaction_interface.rs
index 178143b7c08..bc53a7dbe20 100644
--- a/rust/frameworks/tw_utxo/src/transaction/transaction_interface.rs
+++ b/rust/frameworks/tw_utxo/src/transaction/transaction_interface.rs
@@ -3,6 +3,7 @@
 // Copyright © 2017 Trust Wallet.
 
 use crate::encode::Encodable;
+use tw_hash::hasher::Hasher;
 use tw_memory::Data;
 
 use crate::script::{Script, Witness};
@@ -42,7 +43,7 @@ pub trait TransactionInterface: Clone + Encodable {
 
     fn weight(&self) -> usize;
 
-    fn txid(&self) -> Data;
+    fn txid(&self, hasher: Hasher) -> Data;
 }
 
 pub trait TxInputInterface: Clone {
diff --git a/rust/frameworks/tw_utxo/src/transaction/transaction_sighash/legacy_sighash.rs b/rust/frameworks/tw_utxo/src/transaction/transaction_sighash/legacy_sighash.rs
index a73144dbdeb..7d0a374f0a9 100644
--- a/rust/frameworks/tw_utxo/src/transaction/transaction_sighash/legacy_sighash.rs
+++ b/rust/frameworks/tw_utxo/src/transaction/transaction_sighash/legacy_sighash.rs
@@ -9,7 +9,7 @@ use crate::transaction::transaction_interface::{TransactionInterface, TxInputInt
 use crate::transaction::UtxoPreimageArgs;
 use std::marker::PhantomData;
 use tw_coin_entry::error::prelude::*;
-use tw_hash::hasher::HasherOps;
+use tw_hash::hasher::StatefulHasher;
 use tw_hash::H256;
 
 /// `LegacySighash` is used to calculate a preimage hash of a P2PK, P2PKH or P2SH unspent output.
diff --git a/rust/frameworks/tw_utxo/src/transaction/transaction_sighash/witness0_sighash.rs b/rust/frameworks/tw_utxo/src/transaction/transaction_sighash/witness0_sighash.rs
index 81e208f0838..5a2b947cbd1 100644
--- a/rust/frameworks/tw_utxo/src/transaction/transaction_sighash/witness0_sighash.rs
+++ b/rust/frameworks/tw_utxo/src/transaction/transaction_sighash/witness0_sighash.rs
@@ -8,7 +8,7 @@ use crate::transaction::transaction_interface::{TransactionInterface, TxInputInt
 use crate::transaction::UtxoPreimageArgs;
 use std::marker::PhantomData;
 use tw_coin_entry::error::prelude::*;
-use tw_hash::hasher::HasherOps;
+use tw_hash::hasher::StatefulHasher;
 use tw_hash::H256;
 
 /// `Witness0Sighash`is used to calculate a preimage hash of a P2WPKH or P2WSH unspent output.
diff --git a/rust/tw_base58_address/src/lib.rs b/rust/tw_base58_address/src/lib.rs
index b8f65aa622a..ea526dc0ea7 100644
--- a/rust/tw_base58_address/src/lib.rs
+++ b/rust/tw_base58_address/src/lib.rs
@@ -8,21 +8,20 @@ use std::marker::PhantomData;
 use tw_coin_entry::error::prelude::*;
 use tw_encoding::base58;
 use tw_encoding::base58::Alphabet;
-use tw_hash::hasher::{Hasher, HasherOps};
+use tw_hash::hasher::StaticHasher;
 
 #[derive(Debug, Clone, Eq, Hash, PartialEq)]
-pub struct Base58Address<const SIZE: usize, const CHECKSUM_SIZE: usize> {
+pub struct Base58Address<const SIZE: usize, const CHECKSUM_SIZE: usize, ChecksumHash> {
     pub bytes: [u8; SIZE],
     pub address_str: String,
-    _phantom: PhantomData<[(); CHECKSUM_SIZE]>,
+    _phantom_size: PhantomData<[(); CHECKSUM_SIZE]>,
+    _phantom_hash: PhantomData<ChecksumHash>,
 }
 
-impl<const SIZE: usize, const CHECKSUM_SIZE: usize> Base58Address<SIZE, CHECKSUM_SIZE> {
-    pub fn from_str_with_alphabet(
-        s: &str,
-        alphabet: Alphabet,
-        hasher: Hasher,
-    ) -> AddressResult<Self> {
+impl<const SIZE: usize, const CHECKSUM_SIZE: usize, ChecksumHash: StaticHasher>
+    Base58Address<SIZE, CHECKSUM_SIZE, ChecksumHash>
+{
+    pub fn from_str_with_alphabet(s: &str, alphabet: Alphabet) -> AddressResult<Self> {
         let bytes = base58::decode(s, alphabet).map_err(|_| AddressError::FromBase58Error)?;
 
         if bytes.len() != SIZE + CHECKSUM_SIZE {
@@ -31,16 +30,16 @@ impl<const SIZE: usize, const CHECKSUM_SIZE: usize> Base58Address<SIZE, CHECKSUM
         let (addr_bytes, checksum) = bytes.split_at(SIZE);
 
         // Validate the checksum.
-        if checksum != calculate_checksum::<CHECKSUM_SIZE>(addr_bytes, hasher)? {
+        if checksum != calculate_checksum::<CHECKSUM_SIZE, ChecksumHash>(addr_bytes)? {
             return Err(AddressError::InvalidChecksum);
         }
 
-        Self::new(addr_bytes, alphabet, hasher)
+        Self::new(addr_bytes, alphabet)
     }
 
-    pub fn new(bytes: &[u8], alphabet: Alphabet, hasher: Hasher) -> AddressResult<Self> {
+    pub fn new(bytes: &[u8], alphabet: Alphabet) -> AddressResult<Self> {
         let bytes: [u8; SIZE] = TryFrom::try_from(bytes).map_err(|_| AddressError::InvalidInput)?;
-        let checksum = calculate_checksum::<CHECKSUM_SIZE>(&bytes, hasher)?;
+        let checksum = calculate_checksum::<CHECKSUM_SIZE, ChecksumHash>(&bytes)?;
 
         let mut bytes_with_checksum = Vec::with_capacity(SIZE + CHECKSUM_SIZE);
         bytes_with_checksum.extend_from_slice(&bytes);
@@ -50,7 +49,8 @@ impl<const SIZE: usize, const CHECKSUM_SIZE: usize> Base58Address<SIZE, CHECKSUM
         Ok(Base58Address {
             bytes,
             address_str,
-            _phantom: PhantomData,
+            _phantom_size: PhantomData,
+            _phantom_hash: PhantomData,
         })
     }
 
@@ -59,16 +59,16 @@ impl<const SIZE: usize, const CHECKSUM_SIZE: usize> Base58Address<SIZE, CHECKSUM
     }
 }
 
-impl<const SIZE: usize, const CHECKSUM_SIZE: usize> AsRef<[u8]>
-    for Base58Address<SIZE, CHECKSUM_SIZE>
+impl<const SIZE: usize, const CHECKSUM_SIZE: usize, ChecksumHash> AsRef<[u8]>
+    for Base58Address<SIZE, CHECKSUM_SIZE, ChecksumHash>
 {
     fn as_ref(&self) -> &[u8] {
         &self.bytes
     }
 }
 
-impl<const SIZE: usize, const CHECKSUM_SIZE: usize> fmt::Display
-    for Base58Address<SIZE, CHECKSUM_SIZE>
+impl<const SIZE: usize, const CHECKSUM_SIZE: usize, ChecksumHasher> fmt::Display
+    for Base58Address<SIZE, CHECKSUM_SIZE, ChecksumHasher>
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.address_str)
@@ -102,10 +102,9 @@ impl<const SIZE: usize, const CHECKSUM_SIZE: usize> fmt::Display
 //     .map_err(|e| DeError::custom(format!("{e:?}")))
 // }
 
-pub fn calculate_checksum<const CHECKSUM_SIZE: usize>(
+pub fn calculate_checksum<const CHECKSUM_SIZE: usize, ChecksumHash: StaticHasher>(
     bytes: &[u8],
-    hasher: Hasher,
 ) -> AddressResult<[u8; CHECKSUM_SIZE]> {
-    let checksum = hasher.hash(bytes);
+    let checksum = ChecksumHash::hash(bytes);
     TryFrom::try_from(&checksum[..CHECKSUM_SIZE]).map_err(|_| AddressError::InvalidChecksum)
 }
diff --git a/rust/tw_bech32_address/src/lib.rs b/rust/tw_bech32_address/src/lib.rs
index afc3619fa80..ed35f0ba8f9 100644
--- a/rust/tw_bech32_address/src/lib.rs
+++ b/rust/tw_bech32_address/src/lib.rs
@@ -10,7 +10,7 @@ use tw_coin_entry::coin_context::CoinContext;
 use tw_coin_entry::coin_entry::CoinAddress;
 use tw_coin_entry::error::prelude::*;
 use tw_encoding::bech32;
-use tw_hash::hasher::{Hasher, HasherOps};
+use tw_hash::hasher::{Hasher, StatefulHasher};
 use tw_hash::H160;
 use tw_keypair::tw::{PrivateKey, PublicKey, PublicKeyType};
 use tw_memory::Data;
diff --git a/rust/tw_coin_registry/Cargo.toml b/rust/tw_coin_registry/Cargo.toml
index 5d78406fdae..77aa9c7a9c6 100644
--- a/rust/tw_coin_registry/Cargo.toml
+++ b/rust/tw_coin_registry/Cargo.toml
@@ -18,6 +18,7 @@ tw_cosmos = { path = "../chains/tw_cosmos" }
 tw_ethereum = { path = "../chains/tw_ethereum" }
 tw_evm = { path = "../tw_evm" }
 tw_greenfield = { path = "../chains/tw_greenfield" }
+tw_groestlcoin = { path = "../chains/tw_groestlcoin" }
 tw_hash = { path = "../tw_hash" }
 tw_internet_computer = { path = "../chains/tw_internet_computer" }
 tw_keypair = { path = "../tw_keypair" }
diff --git a/rust/tw_coin_registry/src/blockchain_type.rs b/rust/tw_coin_registry/src/blockchain_type.rs
index 2f73ef32567..372c8297474 100644
--- a/rust/tw_coin_registry/src/blockchain_type.rs
+++ b/rust/tw_coin_registry/src/blockchain_type.rs
@@ -16,6 +16,7 @@ pub enum BlockchainType {
     Cosmos,
     Ethereum,
     Greenfield,
+    Groestlcoin,
     InternetComputer,
     Komodo,
     Kusama,
diff --git a/rust/tw_coin_registry/src/dispatcher.rs b/rust/tw_coin_registry/src/dispatcher.rs
index 71aa550ac0f..63286c9fc90 100644
--- a/rust/tw_coin_registry/src/dispatcher.rs
+++ b/rust/tw_coin_registry/src/dispatcher.rs
@@ -16,6 +16,7 @@ use tw_cosmos::entry::CosmosEntry;
 use tw_ethereum::entry::EthereumEntry;
 use tw_evm::evm_entry::EvmEntryExt;
 use tw_greenfield::entry::GreenfieldEntry;
+use tw_groestlcoin::entry::GroestlcoinEntry;
 use tw_internet_computer::entry::InternetComputerEntry;
 use tw_komodo::entry::KomodoEntry;
 use tw_native_evmos::entry::NativeEvmosEntry;
@@ -42,6 +43,7 @@ const BITCOIN_CASH: BitcoinCashEntry = BitcoinCashEntry;
 const COSMOS: CosmosEntry = CosmosEntry;
 const ETHEREUM: EthereumEntry = EthereumEntry;
 const GREENFIELD: GreenfieldEntry = GreenfieldEntry;
+const GROESTLCOIN: GroestlcoinEntry = GroestlcoinEntry;
 const INTERNET_COMPUTER: InternetComputerEntry = InternetComputerEntry;
 const KOMODO: KomodoEntry = KomodoEntry;
 const NATIVE_EVMOS: NativeEvmosEntry = NativeEvmosEntry;
@@ -67,6 +69,7 @@ pub fn blockchain_dispatcher(blockchain: BlockchainType) -> RegistryResult<CoinE
         BlockchainType::Cosmos => Ok(&COSMOS),
         BlockchainType::Ethereum => Ok(&ETHEREUM),
         BlockchainType::Greenfield => Ok(&GREENFIELD),
+        BlockchainType::Groestlcoin => Ok(&GROESTLCOIN),
         BlockchainType::InternetComputer => Ok(&INTERNET_COMPUTER),
         BlockchainType::Komodo => Ok(&KOMODO),
         BlockchainType::Kusama => Ok(&POLKADOT),
diff --git a/rust/tw_cosmos_sdk/src/modules/compiler/json_preimager.rs b/rust/tw_cosmos_sdk/src/modules/compiler/json_preimager.rs
index 1b84348c743..278bbabeaec 100644
--- a/rust/tw_cosmos_sdk/src/modules/compiler/json_preimager.rs
+++ b/rust/tw_cosmos_sdk/src/modules/compiler/json_preimager.rs
@@ -8,7 +8,7 @@ use crate::public_key::JsonPublicKey;
 use crate::transaction::UnsignedTransaction;
 use std::marker::PhantomData;
 use tw_coin_entry::error::prelude::*;
-use tw_hash::hasher::{Hasher, HasherOps};
+use tw_hash::hasher::{Hasher, StatefulHasher};
 use tw_memory::Data;
 
 pub struct JsonTxPreimage {
diff --git a/rust/tw_cosmos_sdk/src/modules/compiler/protobuf_preimager.rs b/rust/tw_cosmos_sdk/src/modules/compiler/protobuf_preimager.rs
index 2c69466810b..866fbfd311f 100644
--- a/rust/tw_cosmos_sdk/src/modules/compiler/protobuf_preimager.rs
+++ b/rust/tw_cosmos_sdk/src/modules/compiler/protobuf_preimager.rs
@@ -7,7 +7,7 @@ use crate::modules::serializer::protobuf_serializer::{ProtobufSerializer, SignDi
 use crate::transaction::UnsignedTransaction;
 use std::marker::PhantomData;
 use tw_coin_entry::error::prelude::*;
-use tw_hash::hasher::{Hasher, HasherOps};
+use tw_hash::hasher::{Hasher, StatefulHasher};
 use tw_memory::Data;
 use tw_proto::serialize;
 
diff --git a/rust/tw_cosmos_sdk/src/modules/transaction_util.rs b/rust/tw_cosmos_sdk/src/modules/transaction_util.rs
index a4119c1770b..382454945c4 100644
--- a/rust/tw_cosmos_sdk/src/modules/transaction_util.rs
+++ b/rust/tw_cosmos_sdk/src/modules/transaction_util.rs
@@ -10,7 +10,7 @@ use tw_coin_entry::modules::transaction_util::TransactionUtil;
 use tw_encoding::base64;
 use tw_encoding::base64::STANDARD;
 use tw_encoding::hex::encode;
-use tw_hash::hasher::HasherOps;
+use tw_hash::hasher::StatefulHasher;
 
 pub struct CosmosTransactionUtil<Context: CosmosContext> {
     _phantom: PhantomData<Context>,
diff --git a/rust/tw_hash/src/blake.rs b/rust/tw_hash/src/blake.rs
index 8cf93d8e0cf..d8912112a87 100644
--- a/rust/tw_hash/src/blake.rs
+++ b/rust/tw_hash/src/blake.rs
@@ -2,11 +2,16 @@
 //
 // Copyright © 2017 Trust Wallet.
 
-use blake_hash::{Blake256, Digest};
+use crate::impl_static_hasher;
+use blake_hash::Digest;
 
 pub fn blake_256(input: &[u8]) -> Vec<u8> {
-    let mut hasher = Blake256::new();
+    let mut hasher = blake_hash::Blake256::new();
     hasher.update(input);
     let result = &hasher.finalize()[..];
     result.to_vec()
 }
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Blake256;
+impl_static_hasher!(Blake256, blake_256, 32);
diff --git a/rust/tw_hash/src/blake2.rs b/rust/tw_hash/src/blake2.rs
index 27caecd6410..2f4ba9e929d 100644
--- a/rust/tw_hash/src/blake2.rs
+++ b/rust/tw_hash/src/blake2.rs
@@ -2,9 +2,11 @@
 //
 // Copyright © 2017 Trust Wallet.
 
+use crate::hasher::StatefulHasher;
 use crate::Error;
 use blake2b_ref::Blake2bBuilder;
 use std::ops::RangeInclusive;
+use tw_memory::Data;
 
 pub const OUTPUT_HASH_LEN_RANGE: RangeInclusive<usize> = 1..=64;
 pub const PERSONAL_INPUT_MAX_LEN: usize = 16;
@@ -52,6 +54,34 @@ pub fn verify_personal(personal: &[u8]) -> Result<(), Error> {
     }
 }
 
+pub struct Blake2bPersonalHasher<'a> {
+    pub hash_len: usize,
+    pub personalisation: &'a [u8],
+}
+
+impl<'a> Blake2bPersonalHasher<'a> {
+    pub fn new(hash_len: usize, personalisation: &'a [u8]) -> Result<Self, Error> {
+        verify_hash_size(hash_len)?;
+        verify_personal(personalisation)?;
+        Ok(Blake2bPersonalHasher {
+            hash_len,
+            personalisation,
+        })
+    }
+}
+
+impl StatefulHasher for Blake2bPersonalHasher<'_> {
+    fn hash(&self, data: &[u8]) -> Data {
+        blake2_b_personal(data, self.hash_len, self.personalisation).expect(
+            "'hash_len' and 'personalisation' are checked in `Blake2bPersonalHasher::new()`",
+        )
+    }
+
+    fn hash_len(&self) -> usize {
+        self.hash_len
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/rust/tw_hash/src/groestl.rs b/rust/tw_hash/src/groestl.rs
index 30ec191cd62..c5f79e8043a 100644
--- a/rust/tw_hash/src/groestl.rs
+++ b/rust/tw_hash/src/groestl.rs
@@ -3,8 +3,21 @@
 // Copyright © 2017 Trust Wallet.
 
 use crate::hash_wrapper::hasher;
-use groestl::Groestl512;
+use crate::impl_static_hasher;
+use tw_memory::Data;
 
 pub fn groestl_512(input: &[u8]) -> Vec<u8> {
-    hasher::<Groestl512>(input)
+    hasher::<groestl::Groestl512>(input)
 }
+
+pub fn groestl_512d(data: &[u8]) -> Data {
+    groestl_512(&groestl_512(data))
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Groestl512;
+impl_static_hasher!(Groestl512, groestl_512, 64);
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Groestl512d;
+impl_static_hasher!(Groestl512d, groestl_512d, 64);
diff --git a/rust/tw_hash/src/hasher.rs b/rust/tw_hash/src/hasher.rs
index cce4be2a791..0a036b22340 100644
--- a/rust/tw_hash/src/hasher.rs
+++ b/rust/tw_hash/src/hasher.rs
@@ -2,22 +2,34 @@
 //
 // Copyright © 2017 Trust Wallet.
 
-use crate::blake2::{blake2_b_personal, verify_hash_size, verify_personal};
-use crate::ripemd::ripemd_160;
-use crate::sha2::sha256;
+use crate::ripemd::sha256_ripemd;
+use crate::sha2::{sha256, sha256_d};
 use crate::sha3::keccak256;
-use crate::{Error, H160, H256};
+use crate::{H160, H256};
 use serde::Deserialize;
 use tw_memory::Data;
 
-/// ripemd hash of the SHA256 hash.
-pub fn sha256_ripemd(data: &[u8]) -> Data {
-    ripemd_160(&sha256(data))
-}
+#[macro_export]
+macro_rules! impl_static_hasher {
+    ($name:ty, $hash_fun:ident, $hash_len:literal) => {
+        impl $crate::hasher::StaticHasher for $name {
+            const HASH_LEN: usize = $hash_len;
+
+            fn hash(data: &[u8]) -> Vec<u8> {
+                $hash_fun(data)
+            }
+        }
 
-/// SHA256 hash of the SHA256 hash.
-pub fn sha256_d(data: &[u8]) -> Data {
-    sha256(&sha256(data))
+        impl $crate::hasher::StatefulHasher for $name {
+            fn hash(&self, data: &[u8]) -> Vec<u8> {
+                $hash_fun(data)
+            }
+
+            fn hash_len(&self) -> usize {
+                $hash_len
+            }
+        }
+    };
 }
 
 /// TapSighash, required for Bitcoin Taproot. This function computes
@@ -38,11 +50,27 @@ pub fn tapsighash(data: &[u8]) -> Data {
     sha256(&t)
 }
 
-pub trait HasherOps {
+/// A trait for hashing algorithms that do not require pre-configuration, and can be used statically.
+pub trait StaticHasher {
+    const HASH_LEN: usize;
+
+    fn hash(data: &[u8]) -> Data;
+
+    /// Returns a zeroized hash with a corresponding len.
+    fn zero_hash() -> Data {
+        vec![0; Self::HASH_LEN]
+    }
+}
+
+/// A trait for hashing algorithms that require pre-configuration,
+/// but can also be implemented for stateless hashers like [`Hasher`] enum.
+pub trait StatefulHasher {
     fn hash(&self, data: &[u8]) -> Data;
 
     /// Returns a zeroized hash with a corresponding len.
-    fn zero_hash(&self) -> Data;
+    fn zero_hash(&self) -> Data {
+        vec![0; self.hash_len()]
+    }
 
     /// Returns a corresponding hash len.
     fn hash_len(&self) -> usize;
@@ -68,7 +96,7 @@ pub enum Hasher {
     TapSighash,
 }
 
-impl HasherOps for Hasher {
+impl StatefulHasher for Hasher {
     fn hash(&self, data: &[u8]) -> Data {
         match self {
             Hasher::Sha256 => sha256(data),
@@ -79,11 +107,6 @@ impl HasherOps for Hasher {
         }
     }
 
-    /// Returns a zeroized hash with a corresponding len.
-    fn zero_hash(&self) -> Data {
-        vec![0; self.hash_len()]
-    }
-
     /// Returns a corresponding hash len.
     fn hash_len(&self) -> usize {
         match self {
@@ -93,35 +116,3 @@ impl HasherOps for Hasher {
         }
     }
 }
-
-pub struct Blake2bPersonalHasher<'a> {
-    pub hash_len: usize,
-    pub personalisation: &'a [u8],
-}
-
-impl<'a> Blake2bPersonalHasher<'a> {
-    pub fn new(hash_len: usize, personalisation: &'a [u8]) -> Result<Self, Error> {
-        verify_hash_size(hash_len)?;
-        verify_personal(personalisation)?;
-        Ok(Blake2bPersonalHasher {
-            hash_len,
-            personalisation,
-        })
-    }
-}
-
-impl HasherOps for Blake2bPersonalHasher<'_> {
-    fn hash(&self, data: &[u8]) -> Data {
-        blake2_b_personal(data, self.hash_len, self.personalisation).expect(
-            "'hash_len' and 'personalisation' are checked in `Blake2bPersonalHasher::new()`",
-        )
-    }
-
-    fn zero_hash(&self) -> Data {
-        vec![0; self.hash_len]
-    }
-
-    fn hash_len(&self) -> usize {
-        self.hash_len
-    }
-}
diff --git a/rust/tw_hash/src/ripemd.rs b/rust/tw_hash/src/ripemd.rs
index 1b5c1b9b1de..ddf02828ae8 100644
--- a/rust/tw_hash/src/ripemd.rs
+++ b/rust/tw_hash/src/ripemd.rs
@@ -3,17 +3,24 @@
 // Copyright © 2017 Trust Wallet.
 
 use crate::hash_wrapper::hasher;
-use ripemd::Ripemd160;
-use sha2::Sha256;
+use crate::impl_static_hasher;
+use crate::sha2::sha256;
+use tw_memory::Data;
 
 pub fn ripemd_160(input: &[u8]) -> Vec<u8> {
-    hasher::<Ripemd160>(input)
+    hasher::<ripemd::Ripemd160>(input)
 }
 
 /// Computes the Bitcoin "hash160" of the input data. Respectively, it first
 /// hashes the input with SHA256 and then finally with RIPEMD-160.
-/// TODO remove this function
-pub fn bitcoin_hash_160(input: &[u8]) -> Vec<u8> {
-    let hash = hasher::<Sha256>(input);
-    hasher::<Ripemd160>(&hash)
+pub fn sha256_ripemd(data: &[u8]) -> Data {
+    ripemd_160(&sha256(data))
 }
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Ripemd160;
+impl_static_hasher!(Ripemd160, ripemd_160, 20);
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Sha256Ripemd;
+impl_static_hasher!(Sha256Ripemd, sha256_ripemd, 20);
diff --git a/rust/tw_hash/src/sha1.rs b/rust/tw_hash/src/sha1.rs
index 95262c5ed77..9646f8c19a9 100644
--- a/rust/tw_hash/src/sha1.rs
+++ b/rust/tw_hash/src/sha1.rs
@@ -3,8 +3,12 @@
 // Copyright © 2017 Trust Wallet.
 
 use crate::hash_wrapper::hasher;
-use sha1::Sha1;
+use crate::impl_static_hasher;
 
 pub fn sha1(input: &[u8]) -> Vec<u8> {
-    hasher::<Sha1>(input)
+    hasher::<sha1::Sha1>(input)
 }
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Sha1;
+impl_static_hasher!(Sha1, sha1, 20);
diff --git a/rust/tw_hash/src/sha2.rs b/rust/tw_hash/src/sha2.rs
index dae77d8c8d8..6f13c8cbf20 100644
--- a/rust/tw_hash/src/sha2.rs
+++ b/rust/tw_hash/src/sha2.rs
@@ -3,20 +3,46 @@
 // Copyright © 2017 Trust Wallet.
 
 use crate::hash_wrapper::hasher;
-use sha2::{Sha224, Sha256, Sha512, Sha512_256};
+use crate::impl_static_hasher;
+use tw_memory::Data;
 
 pub fn sha224(input: &[u8]) -> Vec<u8> {
-    hasher::<Sha224>(input)
+    hasher::<sha2::Sha224>(input)
 }
 
 pub fn sha256(input: &[u8]) -> Vec<u8> {
-    hasher::<Sha256>(input)
+    hasher::<sha2::Sha256>(input)
 }
 
 pub fn sha512(input: &[u8]) -> Vec<u8> {
-    hasher::<Sha512>(input)
+    hasher::<sha2::Sha512>(input)
 }
 
 pub fn sha512_256(input: &[u8]) -> Vec<u8> {
-    hasher::<Sha512_256>(input)
+    hasher::<sha2::Sha512_256>(input)
 }
+
+/// SHA256 hash of the SHA256 hash.
+pub fn sha256_d(data: &[u8]) -> Data {
+    sha256(&sha256(data))
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Sha224;
+impl_static_hasher!(Sha224, sha224, 28);
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Sha256;
+impl_static_hasher!(Sha256, sha256, 32);
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Sha512;
+impl_static_hasher!(Sha512, sha512, 64);
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Sha512_256;
+impl_static_hasher!(Sha512_256, sha512_256, 32);
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Sha256d;
+impl_static_hasher!(Sha256d, sha256_d, 32);
diff --git a/rust/tw_hash/src/sha3.rs b/rust/tw_hash/src/sha3.rs
index 1ff8fd38719..85a74d25061 100644
--- a/rust/tw_hash/src/sha3.rs
+++ b/rust/tw_hash/src/sha3.rs
@@ -3,20 +3,36 @@
 // Copyright © 2017 Trust Wallet.
 
 use crate::hash_wrapper::hasher;
-use sha3::{Keccak256, Keccak512, Sha3_256, Sha3_512};
+use crate::impl_static_hasher;
 
 pub fn keccak256(input: &[u8]) -> Vec<u8> {
-    hasher::<Keccak256>(input)
+    hasher::<sha3::Keccak256>(input)
 }
 
 pub fn keccak512(input: &[u8]) -> Vec<u8> {
-    hasher::<Keccak512>(input)
+    hasher::<sha3::Keccak512>(input)
 }
 
 pub fn sha3_256(input: &[u8]) -> Vec<u8> {
-    hasher::<Sha3_256>(input)
+    hasher::<sha3::Sha3_256>(input)
 }
 
 pub fn sha3_512(input: &[u8]) -> Vec<u8> {
-    hasher::<Sha3_512>(input)
+    hasher::<sha3::Sha3_512>(input)
 }
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Keccak256;
+impl_static_hasher!(Keccak256, keccak256, 32);
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Keccak512;
+impl_static_hasher!(Keccak512, keccak512, 64);
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Sha3_256;
+impl_static_hasher!(Sha3_256, sha3_256, 32);
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Sha3_512;
+impl_static_hasher!(Sha3_512, sha3_512, 64);
diff --git a/rust/tw_tests/tests/chains/bitcoin/bitcoin_sign/p2pkh.rs b/rust/tw_tests/tests/chains/bitcoin/bitcoin_sign/p2pkh.rs
index 5b76d84eeb3..1febab9d4ec 100644
--- a/rust/tw_tests/tests/chains/bitcoin/bitcoin_sign/p2pkh.rs
+++ b/rust/tw_tests/tests/chains/bitcoin/bitcoin_sign/p2pkh.rs
@@ -4,7 +4,7 @@ use crate::chains::common::bitcoin::{
 };
 use tw_coin_registry::coin_type::CoinType;
 use tw_encoding::hex::DecodeHex;
-use tw_hash::hasher::sha256_ripemd;
+use tw_hash::ripemd::sha256_ripemd;
 use tw_keypair::ecdsa;
 use tw_misc::traits::ToBytesVec;
 use tw_proto::BitcoinV2::Proto;
diff --git a/rust/tw_tests/tests/chains/bitcoin/bitcoin_sign/p2sh.rs b/rust/tw_tests/tests/chains/bitcoin/bitcoin_sign/p2sh.rs
index 3e5e5854a27..06a4ae11b45 100644
--- a/rust/tw_tests/tests/chains/bitcoin/bitcoin_sign/p2sh.rs
+++ b/rust/tw_tests/tests/chains/bitcoin/bitcoin_sign/p2sh.rs
@@ -4,7 +4,7 @@ use crate::chains::common::bitcoin::{
 };
 use tw_coin_registry::coin_type::CoinType;
 use tw_encoding::hex::DecodeHex;
-use tw_hash::hasher::sha256_ripemd;
+use tw_hash::ripemd::sha256_ripemd;
 use tw_hash::H160;
 use tw_keypair::ecdsa;
 use tw_proto::BitcoinV2::Proto;
diff --git a/rust/tw_tests/tests/chains/bitcoin/bitcoin_sign/p2wsh.rs b/rust/tw_tests/tests/chains/bitcoin/bitcoin_sign/p2wsh.rs
index ffca582c171..8c87696e43b 100644
--- a/rust/tw_tests/tests/chains/bitcoin/bitcoin_sign/p2wsh.rs
+++ b/rust/tw_tests/tests/chains/bitcoin/bitcoin_sign/p2wsh.rs
@@ -4,7 +4,7 @@ use crate::chains::common::bitcoin::{
 };
 use tw_coin_registry::coin_type::CoinType;
 use tw_encoding::hex::DecodeHex;
-use tw_hash::hasher::sha256_ripemd;
+use tw_hash::ripemd::sha256_ripemd;
 use tw_hash::sha2::sha256;
 use tw_hash::H160;
 use tw_keypair::ecdsa;
diff --git a/rust/tw_tests/tests/chains/groestlcoin/groestlcoin_address.rs b/rust/tw_tests/tests/chains/groestlcoin/groestlcoin_address.rs
new file mode 100644
index 00000000000..25ed65752d2
--- /dev/null
+++ b/rust/tw_tests/tests/chains/groestlcoin/groestlcoin_address.rs
@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use tw_any_coin::test_utils::address_utils::{
+    test_address_create_base58_with_public_key, test_address_derive,
+    test_address_derive_with_derivation, test_address_get_data, test_address_invalid,
+    test_address_normalization, test_address_valid, AddressCreateBase58WithPublicKey, KeyType,
+};
+use tw_coin_registry::coin_type::CoinType;
+use tw_coin_registry::tw_derivation::TWDerivation;
+use tw_keypair::tw::PublicKeyType;
+
+#[test]
+fn test_groestlcoin_address_derive() {
+    test_address_derive(
+        CoinType::Groestlcoin,
+        KeyType::PrivateKey("dc334e7347f2f9f72fce789b11832bdf78adf0158bc6617e6d2d2a530a0d4bc6"),
+        "grs1qw4teyraux2s77nhjdwh9ar8rl9dt7zww8r6lne",
+    );
+    test_address_derive_with_derivation(
+        CoinType::Groestlcoin,
+        KeyType::PublicKey("03b85cc59b67c35851eb5060cfc3a759a482254553c5857075c9e247d74d412c91"),
+        "Fj62rBJi8LvbmWu2jzkaUX1NFXLEqDLoZM",
+        TWDerivation::BitcoinLegacy,
+    );
+}
+
+#[test]
+fn test_groestlcoin_address_normalization() {
+    test_address_normalization(
+        CoinType::Groestlcoin,
+        "Fj62rBJi8LvbmWu2jzkaUX1NFXLEqDLoZM",
+        "Fj62rBJi8LvbmWu2jzkaUX1NFXLEqDLoZM",
+    );
+}
+
+#[test]
+fn test_groestlcoin_address_is_valid() {
+    test_address_valid(CoinType::Groestlcoin, "Fj62rBJi8LvbmWu2jzkaUX1NFXLEqDLoZM");
+    test_address_valid(
+        CoinType::Groestlcoin,
+        "grs1qnzhs4t9r3zn7zqj02pwqxd3xmyyw8d22q55nf8",
+    );
+    test_address_valid(
+        CoinType::Groestlcoin,
+        "grs1qw4teyraux2s77nhjdwh9ar8rl9dt7zww8r6lne",
+    );
+    test_address_valid(CoinType::Groestlcoin, "31inaRqambLsd9D7Ke4USZmGEVd3PHkh7P");
+}
+
+#[test]
+fn test_groestlcoin_address_invalid() {
+    // Invalid checksum.
+    test_address_invalid(CoinType::Groestlcoin, "Fj62rBJi8LvbmWu2jzkaUX1NFXLEqDLo");
+    // HEX address.
+    test_address_invalid(
+        CoinType::Groestlcoin,
+        "98af0aaca388a7e1024f505c033626d908e3b5",
+    );
+    // Bitcoin address.
+    test_address_invalid(CoinType::Groestlcoin, "1JAd7XCBzGudGpJQSDSfpmJhiygtLQWaGL");
+    // Bitcoin Segwit address.
+    test_address_invalid(
+        CoinType::Groestlcoin,
+        "bc1qhkfq3zahaqkkzx5mjnamwjsfpq2jk7z00ppggv",
+    );
+    // sha256d checksum instead of groestl512d
+    test_address_invalid(CoinType::Groestlcoin, "Fj62rBJi8LvbmWu2jzkaUX1NFXLEsNpjgw");
+    // valid checksum, but testnet prefix
+    test_address_invalid(CoinType::Groestlcoin, "mvbu1Gdy8SUjTenqerxUaZyYjmvedc787y");
+    // sha256d checksum instead of groestl512d
+    test_address_invalid(CoinType::Groestlcoin, "31inaRqambLsd9D7Ke4USZmGEVd3LVt8yd");
+    // valid checksum, but testnet prefix
+    test_address_invalid(CoinType::Groestlcoin, "2N4Q5FhU2497BryFfUgbqkAJE87aKDv3V3e");
+}
+
+#[test]
+fn test_groestlcoin_address_get_data() {
+    test_address_get_data(
+        CoinType::Groestlcoin,
+        "Fj62rBJi8LvbmWu2jzkaUX1NFXLEqDLoZM",
+        "98af0aaca388a7e1024f505c033626d908e3b54a",
+    );
+    test_address_get_data(
+        CoinType::Groestlcoin,
+        "grs1qnzhs4t9r3zn7zqj02pwqxd3xmyyw8d22q55nf8",
+        "98af0aaca388a7e1024f505c033626d908e3b54a",
+    );
+}
+
+#[test]
+fn test_groestlcoin_address_create_base58_with_public_key() {
+    test_address_create_base58_with_public_key(AddressCreateBase58WithPublicKey {
+        coin: CoinType::Groestlcoin,
+        public_key: "03b85cc59b67c35851eb5060cfc3a759a482254553c5857075c9e247d74d412c91",
+        public_key_type: PublicKeyType::Secp256k1,
+        p2pkh: 36,
+        p2sh: 5,
+        expected: "Fj62rBJi8LvbmWu2jzkaUX1NFXLEqDLoZM",
+    });
+}
diff --git a/rust/tw_tests/tests/chains/groestlcoin/groestlcoin_compile.rs b/rust/tw_tests/tests/chains/groestlcoin/groestlcoin_compile.rs
new file mode 100644
index 00000000000..2f4be5ebb9b
--- /dev/null
+++ b/rust/tw_tests/tests/chains/groestlcoin/groestlcoin_compile.rs
@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use crate::chains::common::bitcoin::{
+    compile, dust_threshold, input, output, preimage, TransactionOneof, DUST, SIGHASH_ALL,
+};
+use crate::chains::groestlcoin::groestl_info;
+use tw_coin_registry::coin_type::CoinType;
+use tw_encoding::hex::{DecodeHex, ToHex};
+use tw_keypair::ecdsa;
+use tw_keypair::traits::SigningKeyTrait;
+use tw_misc::traits::ToBytesVec;
+use tw_proto::BitcoinV2::Proto;
+
+#[test]
+fn test_groestlcoin_compile() {
+    const PRIVATE_KEY: &str = "3c3385ddc6fd95ba7282051aeb440bc75820b8c10db5c83c052d7586e3e98e84";
+    const CHANGE_ADDRESS: &str = "31inaRqambLsd9D7Ke4USZmGEVd3PHkh7P";
+    const TO_ADDRESS: &str = "grs1qw4teyraux2s77nhjdwh9ar8rl9dt7zww8r6lne";
+
+    let private_key = ecdsa::secp256k1::PrivateKey::try_from(PRIVATE_KEY).unwrap();
+    let public_key = private_key.public().compressed();
+
+    // Create transaction with P2PKH as input and output.
+    let txid = "8f4ecc7844e19aa1d3183e47eee89d795f9e7c875a55ec0203946d6c9eb06895";
+    let tx1 = Proto::Input {
+        out_point: input::out_point(txid, 0),
+        value: 5000,
+        sighash_type: SIGHASH_ALL,
+        claiming_script: input::p2pkh(public_key.to_vec()),
+        ..Default::default()
+    };
+
+    let out1 = Proto::Output {
+        value: 2500,
+        to_recipient: output::to_address(TO_ADDRESS),
+    };
+
+    let change_output = Proto::Output {
+        value: 2274,
+        to_recipient: output::to_address(CHANGE_ADDRESS),
+    };
+
+    let builder = Proto::TransactionBuilder {
+        inputs: vec![tx1],
+        outputs: vec![out1, change_output],
+        input_selector: Proto::InputSelector::SelectDescending,
+        dust_policy: dust_threshold(DUST),
+        ..Default::default()
+    };
+
+    let signing = Proto::SigningInput {
+        public_keys: vec![public_key.to_vec().into()],
+        chain_info: groestl_info(),
+        transaction: TransactionOneof::builder(builder),
+        ..Default::default()
+    };
+
+    let sighash_1 = "0fb3da786ad1028574f0b40ff1446515eb85cacccff3f3d0459e191b660597b3"
+        .decode_hex()
+        .unwrap();
+    preimage::BitcoinPreImageHelper::new(&signing)
+        .coin(CoinType::Groestlcoin)
+        .add_expected_legacy(public_key.to_vec(), sighash_1.to_vec())
+        .pre_image();
+
+    let signature_1 = private_key
+        .sign(sighash_1.as_slice().try_into().unwrap())
+        .unwrap();
+    assert_eq!(
+        signature_1.to_vec().to_hex(),
+        "2163ab98b028aa13563f0de00b785d6df81df5eac0b7c91d23f5be7ea674aa372bf6cd7055c6f8f697ce045b1a4f9b997cf6e5761a661d27696ac34064479d1900"
+    );
+
+    compile::BitcoinCompileHelper::new(&signing)
+        .coin(CoinType::Groestlcoin)
+        .add_pubkey_sig(public_key.to_vec(), signature_1.to_vec())
+        .compile(compile::Expected {
+            encoded: "01000000019568b09e6c6d940302ec555a877c9e5f799de8ee473e18d3a19ae14478cc4e8f000000006a47304402202163ab98b028aa13563f0de00b785d6df81df5eac0b7c91d23f5be7ea674aa3702202bf6cd7055c6f8f697ce045b1a4f9b997cf6e5761a661d27696ac34064479d19012103b85cc59b67c35851eb5060cfc3a759a482254553c5857075c9e247d74d412c91ffffffff02c4090000000000001600147557920fbc32a1ef4ef26bae5e8ce3f95abf09cee20800000000000017a9140055b0c94df477ee6b9f75185dfc9aa8ce2e52e48700000000",
+            txid: "74a0dd12bc178cfcc1e0982a2a5b2c01a50e41abbb63beb031bcd21b3e28eac0",
+            inputs: vec![5000],
+            outputs: vec![2500, 2274],
+            // `vsize` is different from the estimated value due to the signatures der serialization.
+            vsize: 220,
+            weight: 880,
+            fee: 226,
+        });
+}
diff --git a/rust/tw_tests/tests/chains/groestlcoin/groestlcoin_sign.rs b/rust/tw_tests/tests/chains/groestlcoin/groestlcoin_sign.rs
new file mode 100644
index 00000000000..816abd74ede
--- /dev/null
+++ b/rust/tw_tests/tests/chains/groestlcoin/groestlcoin_sign.rs
@@ -0,0 +1,150 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use crate::chains::common::bitcoin::{
+    dust_threshold, input, output, plan, sign, TransactionOneof, DUST, SIGHASH_ALL,
+};
+use crate::chains::groestlcoin::groestl_info;
+use tw_coin_registry::coin_type::CoinType;
+use tw_encoding::hex::DecodeHex;
+use tw_keypair::ecdsa::secp256k1;
+use tw_misc::traits::ToBytesVec;
+use tw_proto::BitcoinV2::Proto;
+
+#[test]
+fn test_groestlcoin_sign_p2wpkh() {
+    const PRIVATE_KEY: &str = "dc334e7347f2f9f72fce789b11832bdf78adf0158bc6617e6d2d2a530a0d4bc6";
+    const SENDER_ADDRESS: &str = "grs1qw4teyraux2s77nhjdwh9ar8rl9dt7zww8r6lne";
+    const CHANGE_ADDRESS: &str = "Fj62rBJi8LvbmWu2jzkaUX1NFXLEqDLoZM";
+    const TO_ADDRESS: &str = "31inaRqambLsd9D7Ke4USZmGEVd3PHkh7P";
+
+    // Create transaction with P2PKH as input and output.
+    let txid = "8f4ecc7844e19aa1d3183e47eee89d795f9e7c875a55ec0203946d6c9eb06895";
+    let tx1 = Proto::Input {
+        out_point: input::out_point(txid, 1),
+        value: 4774,
+        sighash_type: SIGHASH_ALL,
+        claiming_script: input::receiver_address(SENDER_ADDRESS),
+        ..Default::default()
+    };
+
+    let out1 = Proto::Output {
+        value: 2500,
+        to_recipient: output::to_address(TO_ADDRESS),
+    };
+
+    let change_output = Proto::Output {
+        value: 2048,
+        to_recipient: output::to_address(CHANGE_ADDRESS),
+    };
+
+    let builder = Proto::TransactionBuilder {
+        version: Proto::TransactionVersion::V1,
+        inputs: vec![tx1],
+        outputs: vec![out1, change_output],
+        input_selector: Proto::InputSelector::SelectDescending,
+        dust_policy: dust_threshold(DUST),
+        ..Default::default()
+    };
+
+    let signing = Proto::SigningInput {
+        private_keys: vec![PRIVATE_KEY.decode_hex().unwrap().into()],
+        chain_info: groestl_info(),
+        transaction: TransactionOneof::builder(builder),
+        ..Default::default()
+    };
+
+    plan::BitcoinPlanHelper::new(&signing)
+        .coin(CoinType::Groestlcoin)
+        .plan(plan::Expected {
+            inputs: vec![4774],
+            outputs: vec![2500, 2048],
+            vsize_estimate: 145,
+            fee_estimate: 226,
+            // Change output has been omitted.
+            change: 0,
+        });
+
+    sign::BitcoinSignHelper::new(&signing)
+        .coin(CoinType::Groestlcoin)
+        .sign(sign::Expected {
+            encoded: "010000000001019568b09e6c6d940302ec555a877c9e5f799de8ee473e18d3a19ae14478cc4e8f0100000000ffffffff02c40900000000000017a9140055b0c94df477ee6b9f75185dfc9aa8ce2e52e48700080000000000001976a91498af0aaca388a7e1024f505c033626d908e3b54a88ac024830450221009bbd0228dcb7343828633ded99d216555d587b74db40c4a46f560187eca222dd022032364cf6dbf9c0213076beb6b4a20935d4e9c827a551c3f6f8cbb22d8b464467012102e9c9b9b76e982ad8fa9a7f48470eafbeeba9bf6d287579318c517db5157d936e00000000",
+            txid: "40b539c578934c9863a93c966e278fbeb3e67b0da4eb9e3030092c1b717e7a64",
+            inputs: vec![4774],
+            outputs: vec![2500, 2048],
+            vsize: 145,
+            weight: 578,
+            fee: 226,
+        });
+}
+
+#[test]
+fn test_groestlcoin_sign_p2pkh() {
+    const PRIVATE_KEY: &str = "3c3385ddc6fd95ba7282051aeb440bc75820b8c10db5c83c052d7586e3e98e84";
+    const CHANGE_ADDRESS: &str = "31inaRqambLsd9D7Ke4USZmGEVd3PHkh7P";
+    const TO_ADDRESS: &str = "grs1qw4teyraux2s77nhjdwh9ar8rl9dt7zww8r6lne";
+
+    let private_key = secp256k1::PrivateKey::try_from(PRIVATE_KEY).unwrap();
+    let public_key = private_key.public();
+
+    // Create transaction with P2PKH as input and output.
+    let txid = "8f4ecc7844e19aa1d3183e47eee89d795f9e7c875a55ec0203946d6c9eb06895";
+    let tx1 = Proto::Input {
+        out_point: input::out_point(txid, 0),
+        value: 5000,
+        sighash_type: SIGHASH_ALL,
+        claiming_script: input::p2pkh(public_key.to_vec()),
+        ..Default::default()
+    };
+
+    let out1 = Proto::Output {
+        value: 2500,
+        to_recipient: output::to_address(TO_ADDRESS),
+    };
+
+    let change_output = Proto::Output {
+        value: 2274,
+        to_recipient: output::to_address(CHANGE_ADDRESS),
+    };
+
+    let builder = Proto::TransactionBuilder {
+        version: Proto::TransactionVersion::V1,
+        inputs: vec![tx1],
+        outputs: vec![out1, change_output],
+        input_selector: Proto::InputSelector::SelectDescending,
+        dust_policy: dust_threshold(DUST),
+        ..Default::default()
+    };
+
+    let signing = Proto::SigningInput {
+        private_keys: vec![PRIVATE_KEY.decode_hex().unwrap().into()],
+        chain_info: groestl_info(),
+        transaction: TransactionOneof::builder(builder),
+        ..Default::default()
+    };
+
+    plan::BitcoinPlanHelper::new(&signing)
+        .coin(CoinType::Groestlcoin)
+        .plan(plan::Expected {
+            inputs: vec![5000],
+            outputs: vec![2500, 2274],
+            vsize_estimate: 222,
+            fee_estimate: 226,
+            // Change output has been omitted.
+            change: 0,
+        });
+
+    sign::BitcoinSignHelper::new(&signing)
+        .coin(CoinType::Groestlcoin)
+        .sign(sign::Expected {
+            encoded: "01000000019568b09e6c6d940302ec555a877c9e5f799de8ee473e18d3a19ae14478cc4e8f000000006a47304402202163ab98b028aa13563f0de00b785d6df81df5eac0b7c91d23f5be7ea674aa3702202bf6cd7055c6f8f697ce045b1a4f9b997cf6e5761a661d27696ac34064479d19012103b85cc59b67c35851eb5060cfc3a759a482254553c5857075c9e247d74d412c91ffffffff02c4090000000000001600147557920fbc32a1ef4ef26bae5e8ce3f95abf09cee20800000000000017a9140055b0c94df477ee6b9f75185dfc9aa8ce2e52e48700000000",
+            txid: "74a0dd12bc178cfcc1e0982a2a5b2c01a50e41abbb63beb031bcd21b3e28eac0",
+            inputs: vec![5000],
+            outputs: vec![2500, 2274],
+            // `vsize` is different from the estimated value due to the signatures der serialization.
+            vsize: 220,
+            weight: 880,
+            fee: 226,
+        });
+}
diff --git a/rust/tw_tests/tests/chains/groestlcoin/mod.rs b/rust/tw_tests/tests/chains/groestlcoin/mod.rs
new file mode 100644
index 00000000000..4ba28a8aca4
--- /dev/null
+++ b/rust/tw_tests/tests/chains/groestlcoin/mod.rs
@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use tw_proto::BitcoinV2::Proto;
+
+mod groestlcoin_address;
+mod groestlcoin_compile;
+mod groestlcoin_sign;
+
+pub fn groestl_info() -> Option<Proto::ChainInfo<'static>> {
+    Some(Proto::ChainInfo {
+        p2pkh_prefix: 36,
+        p2sh_prefix: 5,
+        ..Proto::ChainInfo::default()
+    })
+}
diff --git a/rust/tw_tests/tests/chains/mod.rs b/rust/tw_tests/tests/chains/mod.rs
index 93bd8bcf3c0..b1d711aab51 100644
--- a/rust/tw_tests/tests/chains/mod.rs
+++ b/rust/tw_tests/tests/chains/mod.rs
@@ -12,6 +12,7 @@ mod dydx;
 mod ecash;
 mod ethereum;
 mod greenfield;
+mod groestlcoin;
 mod internet_computer;
 mod komodo;
 mod kusama;
diff --git a/rust/tw_tests/tests/chains/ripple/ripple_address.rs b/rust/tw_tests/tests/chains/ripple/ripple_address.rs
index 788bdd482f4..81b47b78e0a 100644
--- a/rust/tw_tests/tests/chains/ripple/ripple_address.rs
+++ b/rust/tw_tests/tests/chains/ripple/ripple_address.rs
@@ -8,7 +8,7 @@ use tw_any_coin::test_utils::address_utils::{
 };
 use tw_coin_registry::coin_type::CoinType;
 use tw_encoding::hex::{DecodeHex, ToHex};
-use tw_hash::hasher::sha256_ripemd;
+use tw_hash::ripemd::sha256_ripemd;
 
 #[test]
 fn test_ripple_address_derive() {
diff --git a/rust/tw_tests/tests/coin_address_derivation_test.rs b/rust/tw_tests/tests/coin_address_derivation_test.rs
index 2d48cea04cf..b8d07f7ba0e 100644
--- a/rust/tw_tests/tests/coin_address_derivation_test.rs
+++ b/rust/tw_tests/tests/coin_address_derivation_test.rs
@@ -162,6 +162,7 @@ fn test_coin_address_derivation() {
             CoinType::Zelcash => "t1SUmK7UVqTXQDpEAqHcJWBv7pNUFHJRpDx",
             CoinType::Komodo => "RHtMPHweTxYNhBYUN2nJTu9QKyjm7MRKsF",
             CoinType::XRP => "r9cwJ8hM13jodBBGtioB44FUZ5HwWGwqfX",
+            CoinType::Groestlcoin => "grs1qten42eesehw0ktddcp0fws7d3ycsqez35034a2",
             // end_of_coin_address_derivation_tests_marker_do_not_modify
             _ => panic!("{:?} must be covered", coin),
         };
diff --git a/src/Groestlcoin/Signer.cpp b/src/Groestlcoin/Signer.cpp
index 772e816d8bd..6afa90bc8ec 100644
--- a/src/Groestlcoin/Signer.cpp
+++ b/src/Groestlcoin/Signer.cpp
@@ -15,11 +15,18 @@ namespace TW::Groestlcoin {
 using TransactionBuilder = Bitcoin::TransactionBuilder;
 
 TransactionPlan Signer::plan(const SigningInput& input) noexcept {
+    if (input.has_signing_v2()) {
+        return Bitcoin::Signer::planAsV2(input);
+    }
     auto plan = Bitcoin::TransactionSigner<Transaction, TransactionBuilder>::plan(input);
     return plan.proto();
 }
 
 SigningOutput Signer::sign(const SigningInput& input, std::optional<SignaturePubkeyList> optionalExternalSigs) noexcept {
+    if (input.has_signing_v2()) {
+        return Bitcoin::Signer::signAsV2(input);
+    }
+
     SigningOutput output;
     auto result = Bitcoin::TransactionSigner<Transaction, TransactionBuilder>::sign(input, false, optionalExternalSigs);
     if (!result) {
@@ -45,6 +52,10 @@ SigningOutput Signer::sign(const SigningInput& input, std::optional<SignaturePub
 }
 
 PreSigningOutput Signer::preImageHashes(const SigningInput& input) noexcept {
+    if (input.has_signing_v2()) {
+        return Bitcoin::Signer::preImageHashesAsV2(input);
+    }
+
     PreSigningOutput output;
     auto result = Bitcoin::TransactionSigner<Transaction, TransactionBuilder>::preImageHashes(input);
     if (!result) {
diff --git a/tests/chains/Groestlcoin/TWGroestlcoinSigningTests.cpp b/tests/chains/Groestlcoin/TWGroestlcoinSigningTests.cpp
index db0c4dc4702..4d7058410c7 100644
--- a/tests/chains/Groestlcoin/TWGroestlcoinSigningTests.cpp
+++ b/tests/chains/Groestlcoin/TWGroestlcoinSigningTests.cpp
@@ -204,4 +204,68 @@ TEST(GroestlcoinSigning, PlanP2WPKH) {
     EXPECT_EQ(plan.branch_id(), "");
 }
 
+// Tests the BitcoinV2 API through the legacy `SigningInput`.
+// Successfully broadcasted: https://blockbook.groestlcoin.org/tx/40b539c578934c9863a93c966e278fbeb3e67b0da4eb9e3030092c1b717e7a64
+TEST(GroestlcoinSigning, SignV2P2WPKH) {
+    auto privateKey = parse_hex("dc334e7347f2f9f72fce789b11832bdf78adf0158bc6617e6d2d2a530a0d4bc6");
+    auto txId = parse_hex("8f4ecc7844e19aa1d3183e47eee89d795f9e7c875a55ec0203946d6c9eb06895");
+    std::reverse(txId.begin(), txId.end());
+    int64_t inAmount = 4774;
+    int64_t outAmount = 2500;
+    int64_t changeAmount = 2048;
+    auto senderAddress = "grs1qw4teyraux2s77nhjdwh9ar8rl9dt7zww8r6lne";
+    auto toAddress = "31inaRqambLsd9D7Ke4USZmGEVd3PHkh7P";
+    auto changeAddress = "Fj62rBJi8LvbmWu2jzkaUX1NFXLEqDLoZM";
+
+    BitcoinV2::Proto::SigningInput signing;
+    signing.add_private_keys(privateKey.data(), privateKey.size());
+
+    auto& chainInfo = *signing.mutable_chain_info();
+    chainInfo.set_p2pkh_prefix(36);
+    chainInfo.set_p2sh_prefix(5);
+
+    auto& builder = *signing.mutable_builder();
+    builder.set_version(BitcoinV2::Proto::TransactionVersion::UseDefault);
+    builder.set_input_selector(BitcoinV2::Proto::InputSelector::UseAll);
+    builder.set_fixed_dust_threshold(546);
+
+    auto& in = *builder.add_inputs();
+    auto& inOutPoint = *in.mutable_out_point();
+    inOutPoint.set_hash(txId.data(), txId.size());
+    inOutPoint.set_vout(1);
+    in.set_value(inAmount);
+    in.set_receiver_address(senderAddress);
+    in.set_sighash_type(TWBitcoinSigHashTypeAll);
+
+    auto& out = *builder.add_outputs();
+    out.set_value(outAmount);
+    out.set_to_address(toAddress);
+
+    auto& changeOut = *builder.add_outputs();
+    changeOut.set_value(changeAmount);
+    changeOut.set_to_address(changeAddress);
+
+    Bitcoin::Proto::SigningInput legacy;
+    legacy.set_coin_type(TWCoinTypeGroestlcoin);
+    *legacy.mutable_signing_v2() = signing;
+
+    Bitcoin::Proto::TransactionPlan plan;
+    ANY_PLAN(legacy, plan, TWCoinTypeGroestlcoin);
+    EXPECT_EQ(plan.error(), Common::Proto::OK);
+    ASSERT_TRUE(plan.has_planning_result_v2());
+    EXPECT_EQ(plan.planning_result_v2().error(), Common::Proto::SigningError::OK)
+                    << plan.planning_result_v2().error_message();
+    EXPECT_EQ(plan.planning_result_v2().vsize_estimate(), 145);
+
+    Bitcoin::Proto::SigningOutput output;
+    ANY_SIGN(legacy, TWCoinTypeGroestlcoin);
+
+    EXPECT_EQ(output.error(), Common::Proto::OK);
+    ASSERT_TRUE(output.has_signing_result_v2());
+    EXPECT_EQ(output.signing_result_v2().error(), Common::Proto::SigningError::OK)
+                    << output.signing_result_v2().error_message();
+    EXPECT_EQ(hex(output.signing_result_v2().encoded()), "010000000001019568b09e6c6d940302ec555a877c9e5f799de8ee473e18d3a19ae14478cc4e8f0100000000ffffffff02c40900000000000017a9140055b0c94df477ee6b9f75185dfc9aa8ce2e52e48700080000000000001976a91498af0aaca388a7e1024f505c033626d908e3b54a88ac024830450221009bbd0228dcb7343828633ded99d216555d587b74db40c4a46f560187eca222dd022032364cf6dbf9c0213076beb6b4a20935d4e9c827a551c3f6f8cbb22d8b464467012102e9c9b9b76e982ad8fa9a7f48470eafbeeba9bf6d287579318c517db5157d936e00000000");
+    EXPECT_EQ(hex(output.signing_result_v2().txid()), "40b539c578934c9863a93c966e278fbeb3e67b0da4eb9e3030092c1b717e7a64");
+}
+
 } // namespace TW::Bitcoin