From cd6869bd2b65304f763f6965d40be3ade8027a44 Mon Sep 17 00:00:00 2001
From: satoshiotomakan <127754187+satoshiotomakan@users.noreply.github.com>
Date: Mon, 14 Oct 2024 18:41:22 +0700
Subject: [PATCH] [BCH]: Migrate BitcoinCash to BitcoinV2 (Rust) (#4049)

* feat(bch): Add `BitcoinCash` blockchain type

* feat(bch): Add support for `CashAddress`

* TODO implement `Entry::parse_address_unchecked`

* feat(bch): Finalize BitcoinCash `Address`

* Add `UncheckedCashAddress`
* TODO test `Address::from_str_unchecked`

* feat(bch): Add `UtxoContext` to allow custom Address types

* feat(bch): Add signing test with from/to Cash address

* feat(bch): Add Compiling test

* feat(bch): Fix `CoinEntry::normalize_address` to validate address network

* feat(bch): Add Base58 address prefix to BitcoinCash

* feat(bch): Add `ECash` Blockchain type

* feat(bch): Add Android signing test

* [CI] Trigger CI

* feat(bch): Fix codegen-v2 and ECash CoinType test
---
 .../bitcoincash/TestBitcoinCashSigning.kt     |  81 ++++++
 .../rust/templates/blockchain_crate/entry.rs  |   6 +-
 include/TrustWalletCore/TWBlockchain.h        |   1 +
 registry.json                                 |   4 +-
 rust/Cargo.lock                               |  16 ++
 rust/Cargo.toml                               |   1 +
 rust/chains/tw_aptos/src/entry.rs             |   6 +-
 rust/chains/tw_binance/src/entry.rs           |   6 +-
 rust/chains/tw_bitcoin/src/context.rs         |  28 ++
 rust/chains/tw_bitcoin/src/entry.rs           |  17 +-
 rust/chains/tw_bitcoin/src/lib.rs             |   1 +
 .../chains/tw_bitcoin/src/modules/compiler.rs |  18 +-
 .../tw_bitcoin/src/modules/planner/mod.rs     |  15 +-
 .../src/modules/planner/psbt_planner.rs       |  12 +-
 .../src/modules/psbt_request/mod.rs           |  15 +-
 rust/chains/tw_bitcoin/src/modules/signer.rs  |  13 +-
 .../src/modules/signing_request/mod.rs        |  16 +-
 .../tw_bitcoin/src/modules/tx_builder/mod.rs  |  11 +
 .../src/modules/tx_builder/output_protobuf.rs |  79 ++----
 .../src/modules/tx_builder/utxo_protobuf.rs   |  95 ++-----
 rust/chains/tw_bitcoincash/Cargo.toml         |  15 ++
 rust/chains/tw_bitcoincash/src/address.rs     |  89 +++++++
 .../src/cash_address/cash_base32.rs           |  78 ++++++
 .../src/cash_address/checksum.rs              |  66 +++++
 .../tw_bitcoincash/src/cash_address/mod.rs    | 249 ++++++++++++++++++
 .../src/cash_address/unchecked.rs             | 147 +++++++++++
 rust/chains/tw_bitcoincash/src/context.rs     |  30 +++
 rust/chains/tw_bitcoincash/src/entry.rs       |  95 +++++++
 rust/chains/tw_bitcoincash/src/lib.rs         |   8 +
 rust/chains/tw_cosmos/src/entry.rs            |   6 +-
 rust/chains/tw_ethereum/src/entry.rs          |   6 +-
 rust/chains/tw_greenfield/src/entry.rs        |   6 +-
 rust/chains/tw_internet_computer/src/entry.rs |   6 +-
 rust/chains/tw_native_evmos/src/entry.rs      |   6 +-
 rust/chains/tw_native_injective/src/entry.rs  |   6 +-
 rust/chains/tw_ronin/src/entry.rs             |   6 +-
 rust/chains/tw_solana/src/entry.rs            |   6 +-
 rust/chains/tw_sui/src/entry.rs               |   6 +-
 rust/chains/tw_thorchain/src/entry.rs         |   6 +-
 rust/chains/tw_ton/src/entry.rs               |   6 +-
 rust/frameworks/tw_utxo/src/address/legacy.rs |  18 +-
 rust/frameworks/tw_utxo/src/address/segwit.rs |  25 +-
 .../tw_utxo/src/address/standard_bitcoin.rs   |   2 +-
 .../frameworks/tw_utxo/src/address/taproot.rs |  13 +-
 .../tw_utxo/src/address/witness_program.rs    |   2 +-
 rust/frameworks/tw_utxo/src/context.rs        |  21 ++
 rust/frameworks/tw_utxo/src/lib.rs            |   1 +
 rust/frameworks/tw_utxo/src/script/mod.rs     |   6 +
 rust/tw_any_coin/src/any_address.rs           |  12 +-
 rust/tw_coin_entry/src/coin_entry.rs          |   6 +-
 rust/tw_coin_entry/src/coin_entry_ext.rs      |  33 ++-
 rust/tw_coin_entry/src/prefix.rs              |  11 +
 rust/tw_coin_registry/Cargo.toml              |   1 +
 rust/tw_coin_registry/src/blockchain_type.rs  |   1 +
 rust/tw_coin_registry/src/dispatcher.rs       |   3 +
 rust/tw_encoding/src/bech32.rs                |   2 +-
 .../chains/bitcoin/bitcoin_sign/p2pkh.rs      |  78 ------
 .../chains/bitcoincash/bitcoincash_address.rs | 153 +++++++++++
 .../chains/bitcoincash/bitcoincash_compile.rs |  49 ++++
 .../chains/bitcoincash/bitcoincash_sign.rs    |  37 +++
 rust/tw_tests/tests/chains/bitcoincash/mod.rs |  10 +
 .../tests/chains/bitcoincash/test_cases.rs    |  65 +++++
 .../tests/chains/ecash/ecash_address.rs       |  64 +++++
 .../tw_tests/tests/chains/ecash/ecash_sign.rs |  72 +++++
 rust/tw_tests/tests/chains/ecash/mod.rs       |   6 +
 rust/tw_tests/tests/chains/mod.rs             |   2 +
 .../tests/coin_address_derivation_test.rs     |   6 +-
 src/Bitcoin/Entry.h                           |  18 +-
 src/BitcoinCash/Entry.h                       |  21 ++
 src/Coin.cpp                                  |   3 +
 tests/chains/BitcoinCash/TWCoinTypeTests.cpp  |   2 +-
 tests/chains/ECash/TWCoinTypeTests.cpp        |   2 +-
 72 files changed, 1659 insertions(+), 370 deletions(-)
 create mode 100644 android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/bitcoincash/TestBitcoinCashSigning.kt
 create mode 100644 rust/chains/tw_bitcoin/src/context.rs
 create mode 100644 rust/chains/tw_bitcoincash/Cargo.toml
 create mode 100644 rust/chains/tw_bitcoincash/src/address.rs
 create mode 100644 rust/chains/tw_bitcoincash/src/cash_address/cash_base32.rs
 create mode 100644 rust/chains/tw_bitcoincash/src/cash_address/checksum.rs
 create mode 100644 rust/chains/tw_bitcoincash/src/cash_address/mod.rs
 create mode 100644 rust/chains/tw_bitcoincash/src/cash_address/unchecked.rs
 create mode 100644 rust/chains/tw_bitcoincash/src/context.rs
 create mode 100644 rust/chains/tw_bitcoincash/src/entry.rs
 create mode 100644 rust/chains/tw_bitcoincash/src/lib.rs
 create mode 100644 rust/frameworks/tw_utxo/src/context.rs
 create mode 100644 rust/tw_tests/tests/chains/bitcoincash/bitcoincash_address.rs
 create mode 100644 rust/tw_tests/tests/chains/bitcoincash/bitcoincash_compile.rs
 create mode 100644 rust/tw_tests/tests/chains/bitcoincash/bitcoincash_sign.rs
 create mode 100644 rust/tw_tests/tests/chains/bitcoincash/mod.rs
 create mode 100644 rust/tw_tests/tests/chains/bitcoincash/test_cases.rs
 create mode 100644 rust/tw_tests/tests/chains/ecash/ecash_address.rs
 create mode 100644 rust/tw_tests/tests/chains/ecash/ecash_sign.rs
 create mode 100644 rust/tw_tests/tests/chains/ecash/mod.rs
 create mode 100644 src/BitcoinCash/Entry.h

diff --git a/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/bitcoincash/TestBitcoinCashSigning.kt b/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/bitcoincash/TestBitcoinCashSigning.kt
new file mode 100644
index 00000000000..2c826c0bd4f
--- /dev/null
+++ b/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/bitcoincash/TestBitcoinCashSigning.kt
@@ -0,0 +1,81 @@
+package com.trustwallet.core.app.blockchains.bitcoincash
+
+import com.trustwallet.core.app.utils.Numeric
+import com.trustwallet.core.app.utils.toHexBytesInByteString
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import wallet.core.java.AnySigner
+import wallet.core.jni.BitcoinSigHashType
+import wallet.core.jni.CoinType
+import wallet.core.jni.proto.Bitcoin
+import wallet.core.jni.proto.BitcoinV2
+import wallet.core.jni.proto.Common.SigningError
+
+class TestBitcoinCashSigning {
+
+    init {
+        System.loadLibrary("TrustWalletCore")
+    }
+
+    @Test
+    fun testSignV2P2PKH() {
+        val privateKey = "7fdafb9db5bc501f2096e7d13d331dc7a75d9594af3d251313ba8b6200f4e384".toHexBytesInByteString()
+
+        val utxo1 = BitcoinV2.Input.newBuilder().apply {
+            outPoint = BitcoinV2.OutPoint.newBuilder().apply {
+                hash = "e28c2b955293159898e34c6840d99bf4d390e2ee1c6f606939f18ee1e2000d05".toHexBytesInByteString()
+                vout = 2
+            }.build()
+            value = 5151
+            sighashType = BitcoinSigHashType.ALL.value() + BitcoinSigHashType.FORK.value()
+            receiverAddress = "bitcoincash:qzhlrcrcne07x94h99thved2pgzdtv8ccujjy73xya"
+        }
+
+        val out1 = BitcoinV2.Output.newBuilder().apply {
+            value = 600
+            // Legacy address
+            toAddress = "1Bp9U1ogV3A14FMvKbRJms7ctyso4Z4Tcx"
+        }
+        val changeOutputExplicit = BitcoinV2.Output.newBuilder().apply {
+            value = 4325
+            // Legacy address
+            toAddress = "qz0q3xmg38sr94rw8wg45vujah7kzma3cskxymnw06"
+        }
+
+        val builder = BitcoinV2.TransactionBuilder.newBuilder()
+            .setVersion(BitcoinV2.TransactionVersion.V1)
+            .addInputs(utxo1)
+            .addOutputs(out1)
+            .addOutputs(changeOutputExplicit)
+            .setInputSelector(BitcoinV2.InputSelector.UseAll)
+            .setFixedDustThreshold(546)
+            .build()
+
+        val input = BitcoinV2.SigningInput.newBuilder()
+            .addPrivateKeys(privateKey)
+            .setBuilder(builder)
+            .setChainInfo(BitcoinV2.ChainInfo.newBuilder().apply {
+                p2PkhPrefix = 0
+                p2ShPrefix = 5
+                hrp = "bitcoincash"
+            })
+            .build()
+
+        val legacyInput = Bitcoin.SigningInput.newBuilder()
+            .setSigningV2(input)
+            // `CoinType` must be set to be handled correctly.
+            .setCoinType(CoinType.BITCOINCASH.value())
+            .build()
+
+        val outputLegacy = AnySigner.sign(legacyInput, CoinType.BITCOINCASH, Bitcoin.SigningOutput.parser())
+        assertEquals(outputLegacy.error, SigningError.OK)
+        assert(outputLegacy.hasSigningResultV2())
+
+        val output = outputLegacy.signingResultV2
+        assertEquals(output.error, SigningError.OK)
+        assertEquals(
+            Numeric.toHexString(output.encoded.toByteArray()),
+            "0x0100000001e28c2b955293159898e34c6840d99bf4d390e2ee1c6f606939f18ee1e2000d05020000006b483045022100b70d158b43cbcded60e6977e93f9a84966bc0cec6f2dfd1463d1223a90563f0d02207548d081069de570a494d0967ba388ff02641d91cadb060587ead95a98d4e3534121038eab72ec78e639d02758e7860cdec018b49498c307791f785aa3019622f4ea5bffffffff0258020000000000001976a914769bdff96a02f9135a1d19b749db6a78fe07dc9088ace5100000000000001976a9149e089b6889e032d46e3b915a3392edfd616fb1c488ac00000000"
+        )
+    }
+}
diff --git a/codegen-v2/src/codegen/rust/templates/blockchain_crate/entry.rs b/codegen-v2/src/codegen/rust/templates/blockchain_crate/entry.rs
index 9b1194bbb68..e26b696fa59 100644
--- a/codegen-v2/src/codegen/rust/templates/blockchain_crate/entry.rs
+++ b/codegen-v2/src/codegen/rust/templates/blockchain_crate/entry.rs
@@ -49,11 +49,7 @@ impl CoinEntry for {BLOCKCHAIN}Entry {
     }
 
     #[inline]
-    fn parse_address_unchecked(
-        &self,
-        _coin: &dyn CoinContext,
-        address: &str,
-    ) -> AddressResult<Self::Address> {
+    fn parse_address_unchecked(&self, address: &str) -> AddressResult<Self::Address> {
         {BLOCKCHAIN}Address::from_str(address)
     }
 
diff --git a/include/TrustWalletCore/TWBlockchain.h b/include/TrustWalletCore/TWBlockchain.h
index faf4c575c1b..84cac17e3b4 100644
--- a/include/TrustWalletCore/TWBlockchain.h
+++ b/include/TrustWalletCore/TWBlockchain.h
@@ -65,6 +65,7 @@ enum TWBlockchain {
     TWBlockchainInternetComputer = 52,
     TWBlockchainNativeEvmos = 53, // Cosmos
     TWBlockchainNativeInjective = 54, // Cosmos
+    TWBlockchainBitcoinCash = 55,
 };
 
 TW_EXTERN_C_END
diff --git a/registry.json b/registry.json
index 1bb8123783a..da2c8ef4098 100644
--- a/registry.json
+++ b/registry.json
@@ -1453,7 +1453,7 @@
     "coinId": 145,
     "symbol": "BCH",
     "decimals": 8,
-    "blockchain": "Bitcoin",
+    "blockchain": "BitcoinCash",
     "derivation": [
       {
         "path": "m/44'/145'/0'/0/0",
@@ -3667,7 +3667,7 @@
     "coinId": 899,
     "symbol": "XEC",
     "decimals": 2,
-    "blockchain": "Bitcoin",
+    "blockchain": "BitcoinCash",
     "derivation": [
       {
         "path": "m/44'/899'/0'/0/0",
diff --git a/rust/Cargo.lock b/rust/Cargo.lock
index 108bb84e1e0..dcb26f709ab 100644
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -1800,6 +1800,21 @@ dependencies = [
  "tw_utxo",
 ]
 
+[[package]]
+name = "tw_bitcoincash"
+version = "0.1.0"
+dependencies = [
+ "tw_bitcoin",
+ "tw_coin_entry",
+ "tw_encoding",
+ "tw_hash",
+ "tw_keypair",
+ "tw_memory",
+ "tw_misc",
+ "tw_proto",
+ "tw_utxo",
+]
+
 [[package]]
 name = "tw_coin_entry"
 version = "0.1.0"
@@ -1829,6 +1844,7 @@ dependencies = [
  "tw_aptos",
  "tw_binance",
  "tw_bitcoin",
+ "tw_bitcoincash",
  "tw_coin_entry",
  "tw_cosmos",
  "tw_ethereum",
diff --git a/rust/Cargo.toml b/rust/Cargo.toml
index ca41fb6099d..f6bd5522ea7 100644
--- a/rust/Cargo.toml
+++ b/rust/Cargo.toml
@@ -3,6 +3,7 @@ members = [
     "chains/tw_aptos",
     "chains/tw_binance",
     "chains/tw_bitcoin",
+    "chains/tw_bitcoincash",
     "chains/tw_cosmos",
     "chains/tw_ethereum",
     "chains/tw_greenfield",
diff --git a/rust/chains/tw_aptos/src/entry.rs b/rust/chains/tw_aptos/src/entry.rs
index f9a46c55049..e2ef01a6e2f 100644
--- a/rust/chains/tw_aptos/src/entry.rs
+++ b/rust/chains/tw_aptos/src/entry.rs
@@ -49,11 +49,7 @@ impl CoinEntry for AptosEntry {
     }
 
     #[inline]
-    fn parse_address_unchecked(
-        &self,
-        _coin: &dyn CoinContext,
-        address: &str,
-    ) -> AddressResult<Self::Address> {
+    fn parse_address_unchecked(&self, address: &str) -> AddressResult<Self::Address> {
         Address::from_str(address)
     }
 
diff --git a/rust/chains/tw_binance/src/entry.rs b/rust/chains/tw_binance/src/entry.rs
index 55930473d53..6552c0e6bd0 100644
--- a/rust/chains/tw_binance/src/entry.rs
+++ b/rust/chains/tw_binance/src/entry.rs
@@ -49,11 +49,7 @@ impl CoinEntry for BinanceEntry {
     }
 
     #[inline]
-    fn parse_address_unchecked(
-        &self,
-        _coin: &dyn CoinContext,
-        address: &str,
-    ) -> AddressResult<Self::Address> {
+    fn parse_address_unchecked(&self, address: &str) -> AddressResult<Self::Address> {
         BinanceAddress::from_str(address)
     }
 
diff --git a/rust/chains/tw_bitcoin/src/context.rs b/rust/chains/tw_bitcoin/src/context.rs
new file mode 100644
index 00000000000..8ecdd4f8e55
--- /dev/null
+++ b/rust/chains/tw_bitcoin/src/context.rs
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use tw_coin_entry::error::prelude::SigningResult;
+use tw_utxo::address::standard_bitcoin::StandardBitcoinAddress;
+use tw_utxo::context::{AddressPrefixes, UtxoContext};
+use tw_utxo::script::Script;
+
+#[derive(Default)]
+pub struct StandardBitcoinContext;
+
+impl UtxoContext for StandardBitcoinContext {
+    type Address = StandardBitcoinAddress;
+
+    fn addr_to_script_pubkey(
+        addr: &Self::Address,
+        prefixes: AddressPrefixes,
+    ) -> SigningResult<Script> {
+        match addr {
+            StandardBitcoinAddress::Legacy(legacy) => {
+                legacy.to_script_pubkey(prefixes.p2pkh_prefix, prefixes.p2sh_prefix)
+            },
+            StandardBitcoinAddress::Segwit(segwit) => segwit.to_script_pubkey(),
+            StandardBitcoinAddress::Taproot(taproot) => taproot.to_script_pubkey(),
+        }
+    }
+}
diff --git a/rust/chains/tw_bitcoin/src/entry.rs b/rust/chains/tw_bitcoin/src/entry.rs
index 5d6b81508ec..02a728b5d0e 100644
--- a/rust/chains/tw_bitcoin/src/entry.rs
+++ b/rust/chains/tw_bitcoin/src/entry.rs
@@ -1,3 +1,4 @@
+use crate::context::StandardBitcoinContext;
 use crate::modules::compiler::BitcoinCompiler;
 use crate::modules::planner::BitcoinPlanner;
 use crate::modules::signer::BitcoinSigner;
@@ -26,7 +27,7 @@ impl CoinEntry for BitcoinEntry {
 
     // Optional modules:
     type JsonSigner = NoJsonSigner;
-    type PlanBuilder = BitcoinPlanner;
+    type PlanBuilder = BitcoinPlanner<StandardBitcoinContext>;
     type MessageSigner = NoMessageSigner;
     type WalletConnector = NoWalletConnector;
     type TransactionDecoder = NoTransactionDecoder;
@@ -43,11 +44,7 @@ impl CoinEntry for BitcoinEntry {
     }
 
     #[inline]
-    fn parse_address_unchecked(
-        &self,
-        _coin: &dyn CoinContext,
-        address: &str,
-    ) -> AddressResult<Self::Address> {
+    fn parse_address_unchecked(&self, address: &str) -> AddressResult<Self::Address> {
         StandardBitcoinAddress::from_str(address)
     }
 
@@ -64,7 +61,7 @@ impl CoinEntry for BitcoinEntry {
 
     #[inline]
     fn sign(&self, coin: &dyn CoinContext, proto: Self::SigningInput<'_>) -> Self::SigningOutput {
-        BitcoinSigner::sign(coin, &proto)
+        BitcoinSigner::<StandardBitcoinContext>::sign(coin, &proto)
     }
 
     #[inline]
@@ -73,7 +70,7 @@ impl CoinEntry for BitcoinEntry {
         coin: &dyn CoinContext,
         proto: Proto::SigningInput<'_>,
     ) -> Self::PreSigningOutput {
-        BitcoinCompiler::preimage_hashes(coin, proto)
+        BitcoinCompiler::<StandardBitcoinContext>::preimage_hashes(coin, proto)
     }
 
     #[inline]
@@ -84,12 +81,12 @@ impl CoinEntry for BitcoinEntry {
         signatures: Vec<SignatureBytes>,
         public_keys: Vec<PublicKeyBytes>,
     ) -> Self::SigningOutput {
-        BitcoinCompiler::compile(coin, proto, signatures, public_keys)
+        BitcoinCompiler::<StandardBitcoinContext>::compile(coin, proto, signatures, public_keys)
     }
 
     #[inline]
     fn plan_builder(&self) -> Option<Self::PlanBuilder> {
-        Some(BitcoinPlanner)
+        Some(BitcoinPlanner::<StandardBitcoinContext>::default())
     }
 
     #[inline]
diff --git a/rust/chains/tw_bitcoin/src/lib.rs b/rust/chains/tw_bitcoin/src/lib.rs
index 1b6998ea2c6..6f1db4b73ee 100644
--- a/rust/chains/tw_bitcoin/src/lib.rs
+++ b/rust/chains/tw_bitcoin/src/lib.rs
@@ -2,5 +2,6 @@
 //
 // Copyright © 2017 Trust Wallet.
 
+pub mod context;
 pub mod entry;
 pub mod modules;
diff --git a/rust/chains/tw_bitcoin/src/modules/compiler.rs b/rust/chains/tw_bitcoin/src/modules/compiler.rs
index 398940ec3e7..e596df15a58 100644
--- a/rust/chains/tw_bitcoin/src/modules/compiler.rs
+++ b/rust/chains/tw_bitcoin/src/modules/compiler.rs
@@ -6,6 +6,7 @@ use crate::modules::protobuf_builder::ProtobufBuilder;
 use crate::modules::psbt_request::PsbtRequest;
 use crate::modules::signing_request::SigningRequestBuilder;
 use std::borrow::Cow;
+use std::marker::PhantomData;
 use tw_coin_entry::coin_context::CoinContext;
 use tw_coin_entry::coin_entry::{PublicKeyBytes, SignatureBytes};
 use tw_coin_entry::error::prelude::*;
@@ -15,6 +16,7 @@ use tw_proto::BitcoinV2::Proto::mod_PreSigningOutput::{
     SigningMethod as ProtoSigningMethod, TaprootTweak as ProtoTaprootTweak,
 };
 use tw_proto::BitcoinV2::Proto::mod_SigningInput::OneOftransaction as TransactionType;
+use tw_utxo::context::UtxoContext;
 use tw_utxo::modules::sighash_computer::{SighashComputer, TaprootTweak, TxPreimage};
 use tw_utxo::modules::sighash_verifier::SighashVerifier;
 use tw_utxo::modules::tx_compiler::TxCompiler;
@@ -23,9 +25,11 @@ use tw_utxo::modules::utxo_selector::SelectResult;
 use tw_utxo::signing_mode::SigningMethod;
 use tw_utxo::transaction::transaction_interface::TransactionInterface;
 
-pub struct BitcoinCompiler;
+pub struct BitcoinCompiler<Context: UtxoContext> {
+    _phantom: PhantomData<Context>,
+}
 
-impl BitcoinCompiler {
+impl<Context: UtxoContext> BitcoinCompiler<Context> {
     /// Please note that [`Proto::SigningInput::public_key`] must be set.
     /// If the public key should be derived from a private key, please do it before this method is called.
     #[inline]
@@ -43,10 +47,12 @@ impl BitcoinCompiler {
     ) -> SigningResult<Proto::PreSigningOutput<'static>> {
         let unsigned_tx = match input.transaction {
             TransactionType::builder(ref tx_builder) => {
-                let request = SigningRequestBuilder::build(coin, &input, tx_builder)?;
+                let request = SigningRequestBuilder::<Context>::build(coin, &input, tx_builder)?;
                 TxPlanner::plan(request)?.unsigned_tx
             },
-            TransactionType::psbt(ref psbt) => PsbtRequest::build(&input, psbt)?.unsigned_tx,
+            TransactionType::psbt(ref psbt) => {
+                PsbtRequest::<Context>::build(&input, psbt)?.unsigned_tx
+            },
             TransactionType::None => {
                 return SigningError::err(SigningErrorType::Error_invalid_params)
                     .context("Either `TransactionBuilder` or `Psbt` should be set")
@@ -104,7 +110,7 @@ impl BitcoinCompiler {
         tx_builder_input: &Proto::TransactionBuilder,
         signatures: Vec<SignatureBytes>,
     ) -> SigningResult<Proto::SigningOutput<'static>> {
-        let request = SigningRequestBuilder::build(coin, input, tx_builder_input)?;
+        let request = SigningRequestBuilder::<Context>::build(coin, input, tx_builder_input)?;
         let SelectResult { unsigned_tx, plan } = TxPlanner::plan(request)?;
 
         SighashVerifier::verify_signatures(&unsigned_tx, &signatures)?;
@@ -130,7 +136,7 @@ impl BitcoinCompiler {
         psbt: &Proto::Psbt,
         signatures: Vec<SignatureBytes>,
     ) -> SigningResult<Proto::SigningOutput<'static>> {
-        let PsbtRequest { unsigned_tx, .. } = PsbtRequest::build(input, psbt)?;
+        let PsbtRequest { unsigned_tx, .. } = PsbtRequest::<Context>::build(input, psbt)?;
         let fee = unsigned_tx.fee()?;
 
         SighashVerifier::verify_signatures(&unsigned_tx, &signatures)?;
diff --git a/rust/chains/tw_bitcoin/src/modules/planner/mod.rs b/rust/chains/tw_bitcoin/src/modules/planner/mod.rs
index 21d437f8149..f36669e1931 100644
--- a/rust/chains/tw_bitcoin/src/modules/planner/mod.rs
+++ b/rust/chains/tw_bitcoin/src/modules/planner/mod.rs
@@ -6,19 +6,24 @@ use crate::modules::signing_request::SigningRequestBuilder;
 use crate::modules::tx_builder::utxo_protobuf::parse_out_point;
 use std::borrow::Cow;
 use std::collections::HashMap;
+use std::marker::PhantomData;
 use tw_coin_entry::coin_context::CoinContext;
 use tw_coin_entry::error::prelude::*;
 use tw_coin_entry::modules::plan_builder::PlanBuilder;
 use tw_coin_entry::signing_output_error;
 use tw_proto::BitcoinV2::Proto;
+use tw_utxo::context::UtxoContext;
 use tw_utxo::modules::tx_planner::TxPlanner;
 use tw_utxo::modules::utxo_selector::SelectResult;
 
 pub mod psbt_planner;
 
-pub struct BitcoinPlanner;
+#[derive(Default)]
+pub struct BitcoinPlanner<Context: UtxoContext> {
+    _phantom: PhantomData<Context>,
+}
 
-impl BitcoinPlanner {
+impl<Context: UtxoContext> BitcoinPlanner<Context> {
     pub fn plan_impl<'a>(
         coin: &dyn CoinContext,
         input: &Proto::SigningInput<'a>,
@@ -28,7 +33,7 @@ impl BitcoinPlanner {
         match input.transaction {
             TransactionType::builder(ref tx) => Self::plan_with_tx_builder(coin, input, tx),
             TransactionType::psbt(ref psbt) => {
-                psbt_planner::PsbtPlanner::plan_psbt(coin, input, psbt)
+                psbt_planner::PsbtPlanner::<Context>::plan_psbt(coin, input, psbt)
             },
             TransactionType::None => SigningError::err(SigningErrorType::Error_invalid_params)
                 .context("Either `TransactionBuilder` or `Psbt` should be set"),
@@ -40,7 +45,7 @@ impl BitcoinPlanner {
         input: &Proto::SigningInput<'a>,
         tx_builder: &Proto::TransactionBuilder<'a>,
     ) -> SigningResult<Proto::TransactionPlan<'a>> {
-        let request = SigningRequestBuilder::build(coin, input, tx_builder)?;
+        let request = SigningRequestBuilder::<Context>::build(coin, input, tx_builder)?;
         let SelectResult { unsigned_tx, plan } = TxPlanner::plan(request)?;
 
         // Prepare a map of source Inputs Proto `{ OutPoint -> Input }`.
@@ -93,7 +98,7 @@ impl BitcoinPlanner {
     }
 }
 
-impl PlanBuilder for BitcoinPlanner {
+impl<Context: UtxoContext> PlanBuilder for BitcoinPlanner<Context> {
     type SigningInput<'a> = Proto::SigningInput<'a>;
     type Plan<'a> = Proto::TransactionPlan<'a>;
 
diff --git a/rust/chains/tw_bitcoin/src/modules/planner/psbt_planner.rs b/rust/chains/tw_bitcoin/src/modules/planner/psbt_planner.rs
index 0967e85b75a..545862d1691 100644
--- a/rust/chains/tw_bitcoin/src/modules/planner/psbt_planner.rs
+++ b/rust/chains/tw_bitcoin/src/modules/planner/psbt_planner.rs
@@ -6,25 +6,29 @@ use crate::modules::psbt_request::PsbtRequest;
 use crate::modules::signing_request::SigningRequestBuilder;
 use crate::modules::tx_builder::script_parser::StandardScriptParser;
 use crate::modules::tx_builder::BitcoinChainInfo;
+use std::marker::PhantomData;
 use tw_coin_entry::coin_context::CoinContext;
 use tw_coin_entry::error::prelude::*;
 use tw_proto::BitcoinV2::Proto;
 use tw_proto::BitcoinV2::Proto::mod_Input::OneOfclaiming_script as ClaimingScriptProto;
 use tw_proto::BitcoinV2::Proto::mod_Output::OneOfto_recipient as ToRecipientProto;
+use tw_utxo::context::UtxoContext;
 use tw_utxo::transaction::standard_transaction::{TransactionInput, TransactionOutput};
 use tw_utxo::transaction::transaction_interface::TransactionInterface;
 use tw_utxo::transaction::UtxoToSign;
 
-pub struct PsbtPlanner;
+pub struct PsbtPlanner<Context: UtxoContext> {
+    _phantom: PhantomData<Context>,
+}
 
-impl PsbtPlanner {
+impl<Context: UtxoContext> PsbtPlanner<Context> {
     pub fn plan_psbt(
         coin: &dyn CoinContext,
         input: &Proto::SigningInput,
         psbt_input: &Proto::Psbt,
     ) -> SigningResult<Proto::TransactionPlan<'static>> {
-        let chain_info = SigningRequestBuilder::chain_info(coin, &input.chain_info)?;
-        let PsbtRequest { unsigned_tx, .. } = PsbtRequest::build(input, psbt_input)?;
+        let chain_info = SigningRequestBuilder::<Context>::chain_info(coin, &input.chain_info)?;
+        let PsbtRequest { unsigned_tx, .. } = PsbtRequest::<Context>::build(input, psbt_input)?;
 
         let total_input = unsigned_tx.total_input()?;
         let fee_estimate = unsigned_tx.fee()?;
diff --git a/rust/chains/tw_bitcoin/src/modules/psbt_request/mod.rs b/rust/chains/tw_bitcoin/src/modules/psbt_request/mod.rs
index f3d63e4c6ca..5ecac42cae0 100644
--- a/rust/chains/tw_bitcoin/src/modules/psbt_request/mod.rs
+++ b/rust/chains/tw_bitcoin/src/modules/psbt_request/mod.rs
@@ -6,8 +6,10 @@ use crate::modules::psbt_request::output_psbt::OutputPsbt;
 use crate::modules::psbt_request::utxo_psbt::UtxoPsbt;
 use crate::modules::signing_request::SigningRequestBuilder;
 use bitcoin::psbt::Psbt;
+use std::marker::PhantomData;
 use tw_coin_entry::error::prelude::*;
 use tw_proto::BitcoinV2::Proto;
+use tw_utxo::context::UtxoContext;
 use tw_utxo::transaction::standard_transaction::builder::TransactionBuilder;
 use tw_utxo::transaction::standard_transaction::Transaction;
 use tw_utxo::transaction::unsigned_transaction::UnsignedTransaction;
@@ -15,12 +17,13 @@ use tw_utxo::transaction::unsigned_transaction::UnsignedTransaction;
 pub mod output_psbt;
 pub mod utxo_psbt;
 
-pub struct PsbtRequest {
+pub struct PsbtRequest<Context: UtxoContext> {
     pub psbt: Psbt,
     pub unsigned_tx: UnsignedTransaction<Transaction>,
+    _phantom: PhantomData<Context>,
 }
 
-impl PsbtRequest {
+impl<Context: UtxoContext> PsbtRequest<Context> {
     pub fn build(input: &Proto::SigningInput, psbt_input: &Proto::Psbt) -> SigningResult<Self> {
         let psbt = Psbt::deserialize(&psbt_input.psbt)
             .tw_err(|_| SigningErrorType::Error_input_parse)
@@ -34,7 +37,7 @@ impl PsbtRequest {
             .context("Invalid PSBT transaction version")?;
         let lock_time = psbt.unsigned_tx.lock_time.to_consensus_u32();
 
-        let public_keys = SigningRequestBuilder::get_public_keys(input)?;
+        let public_keys = SigningRequestBuilder::<Context>::get_public_keys(input)?;
 
         let mut builder = TransactionBuilder::default();
         builder.version(version).lock_time(lock_time);
@@ -58,6 +61,10 @@ impl PsbtRequest {
         }
 
         let unsigned_tx = builder.build()?;
-        Ok(PsbtRequest { psbt, unsigned_tx })
+        Ok(PsbtRequest {
+            psbt,
+            unsigned_tx,
+            _phantom: PhantomData,
+        })
     }
 }
diff --git a/rust/chains/tw_bitcoin/src/modules/signer.rs b/rust/chains/tw_bitcoin/src/modules/signer.rs
index 1bed884f053..5db22d32e74 100644
--- a/rust/chains/tw_bitcoin/src/modules/signer.rs
+++ b/rust/chains/tw_bitcoin/src/modules/signer.rs
@@ -7,11 +7,13 @@ use crate::modules::psbt::update_psbt_signed;
 use crate::modules::psbt_request::PsbtRequest;
 use crate::modules::signing_request::SigningRequestBuilder;
 use std::borrow::Cow;
+use std::marker::PhantomData;
 use tw_coin_entry::coin_context::CoinContext;
 use tw_coin_entry::error::prelude::*;
 use tw_coin_entry::signing_output_error;
 use tw_keypair::{ecdsa, schnorr};
 use tw_proto::BitcoinV2::Proto;
+use tw_utxo::context::UtxoContext;
 use tw_utxo::modules::keys_manager::KeysManager;
 use tw_utxo::modules::tx_planner::TxPlanner;
 use tw_utxo::modules::tx_signer::TxSigner;
@@ -21,9 +23,11 @@ use tw_utxo::transaction::standard_transaction::Transaction;
 use tw_utxo::transaction::transaction_interface::TransactionInterface;
 use tw_utxo::transaction::unsigned_transaction::UnsignedTransaction;
 
-pub struct BitcoinSigner;
+pub struct BitcoinSigner<Context: UtxoContext> {
+    _phantom: PhantomData<Context>,
+}
 
-impl BitcoinSigner {
+impl<Context: UtxoContext> BitcoinSigner<Context> {
     pub fn sign(
         coin: &dyn CoinContext,
         input: &Proto::SigningInput<'_>,
@@ -51,7 +55,7 @@ impl BitcoinSigner {
         input: &Proto::SigningInput,
         tx_builder_input: &Proto::TransactionBuilder,
     ) -> SigningResult<Proto::SigningOutput<'static>> {
-        let request = SigningRequestBuilder::build(coin, input, tx_builder_input)?;
+        let request = SigningRequestBuilder::<Context>::build(coin, input, tx_builder_input)?;
         let SelectResult { unsigned_tx, plan } = TxPlanner::plan(request)?;
 
         let keys_manager = Self::keys_manager_for_tx(
@@ -84,7 +88,8 @@ impl BitcoinSigner {
         let PsbtRequest {
             mut psbt,
             unsigned_tx,
-        } = PsbtRequest::build(input, psbt_input)?;
+            ..
+        } = PsbtRequest::<Context>::build(input, psbt_input)?;
 
         let fee = unsigned_tx.fee()?;
 
diff --git a/rust/chains/tw_bitcoin/src/modules/signing_request/mod.rs b/rust/chains/tw_bitcoin/src/modules/signing_request/mod.rs
index bddbcac4b0c..8e62b8b6d2b 100644
--- a/rust/chains/tw_bitcoin/src/modules/signing_request/mod.rs
+++ b/rust/chains/tw_bitcoin/src/modules/signing_request/mod.rs
@@ -6,10 +6,12 @@ use crate::modules::tx_builder::output_protobuf::OutputProtobuf;
 use crate::modules::tx_builder::public_keys::PublicKeys;
 use crate::modules::tx_builder::utxo_protobuf::UtxoProtobuf;
 use crate::modules::tx_builder::BitcoinChainInfo;
+use std::marker::PhantomData;
 use tw_coin_entry::coin_context::CoinContext;
 use tw_coin_entry::error::prelude::*;
 use tw_misc::traits::OptionalEmpty;
 use tw_proto::BitcoinV2::Proto;
+use tw_utxo::context::UtxoContext;
 use tw_utxo::dust::DustPolicy;
 use tw_utxo::modules::tx_planner::{PlanRequest, RequestType};
 use tw_utxo::modules::utxo_selector::InputSelector;
@@ -21,9 +23,11 @@ const DEFAULT_TX_VERSION: u32 = 1;
 
 pub type StandardSigningRequest = PlanRequest<Transaction>;
 
-pub struct SigningRequestBuilder;
+pub struct SigningRequestBuilder<Context: UtxoContext> {
+    _phantom: PhantomData<Context>,
+}
 
-impl SigningRequestBuilder {
+impl<Context: UtxoContext> SigningRequestBuilder<Context> {
     pub fn build(
         coin: &dyn CoinContext,
         input: &Proto::SigningInput,
@@ -43,7 +47,7 @@ impl SigningRequestBuilder {
 
         // Parse all UTXOs.
         for utxo_proto in transaction_builder.inputs.iter() {
-            let utxo_builder = UtxoProtobuf::new(&chain_info, utxo_proto, &public_keys);
+            let utxo_builder = UtxoProtobuf::<Context>::new(&chain_info, utxo_proto, &public_keys);
 
             let (utxo, utxo_args) = utxo_builder
                 .utxo_from_proto()
@@ -53,7 +57,7 @@ impl SigningRequestBuilder {
 
         // If `max_amount_output` is set, construct a transaction with only one output.
         if let Some(max_output_proto) = transaction_builder.max_amount_output.as_ref() {
-            let output_builder = OutputProtobuf::new(&chain_info, max_output_proto);
+            let output_builder = OutputProtobuf::<Context>::new(&chain_info, max_output_proto);
 
             let max_output = output_builder
                 .output_from_proto()
@@ -70,7 +74,7 @@ impl SigningRequestBuilder {
 
         // `max_amount_output` isn't set, parse all Outputs.
         for output_proto in transaction_builder.outputs.iter() {
-            let output = OutputProtobuf::new(&chain_info, output_proto)
+            let output = OutputProtobuf::<Context>::new(&chain_info, output_proto)
                 .output_from_proto()
                 .context("Error creating Output from Proto")?;
             builder.push_output(output);
@@ -81,7 +85,7 @@ impl SigningRequestBuilder {
             .change_output
             .as_ref()
             .map(|change_output_proto| {
-                OutputProtobuf::new(&chain_info, change_output_proto)
+                OutputProtobuf::<Context>::new(&chain_info, change_output_proto)
                     .output_from_proto()
                     .context("Error creating Change Output from Proto")
             })
diff --git a/rust/chains/tw_bitcoin/src/modules/tx_builder/mod.rs b/rust/chains/tw_bitcoin/src/modules/tx_builder/mod.rs
index 37c99c33e53..98c05c767aa 100644
--- a/rust/chains/tw_bitcoin/src/modules/tx_builder/mod.rs
+++ b/rust/chains/tw_bitcoin/src/modules/tx_builder/mod.rs
@@ -2,6 +2,8 @@
 //
 // Copyright © 2017 Trust Wallet.
 
+use tw_utxo::context::AddressPrefixes;
+
 pub mod output_protobuf;
 pub mod public_keys;
 pub mod script_parser;
@@ -13,3 +15,12 @@ pub struct BitcoinChainInfo {
     /// Note that not all Bitcoin forks support HRP (segwit addresses).
     pub hrp: Option<String>,
 }
+
+impl BitcoinChainInfo {
+    pub fn to_address_prefixes(&self) -> AddressPrefixes {
+        AddressPrefixes {
+            p2pkh_prefix: self.p2pkh_prefix,
+            p2sh_prefix: self.p2sh_prefix,
+        }
+    }
+}
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 0e1a6e374b0..7b503a0f925 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
@@ -3,30 +3,33 @@
 // Copyright © 2017 Trust Wallet.
 
 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::sha2::sha256;
-use tw_hash::{Hash, H160, H256};
+use tw_hash::{Hash, H256};
 use tw_keypair::{ecdsa, schnorr};
 use tw_memory::Data;
 use tw_proto::BitcoinV2::Proto;
-use tw_utxo::address::legacy::LegacyAddress;
-use tw_utxo::address::segwit::SegwitAddress;
-use tw_utxo::address::standard_bitcoin::StandardBitcoinAddress;
-use tw_utxo::address::taproot::TaprootAddress;
+use tw_utxo::context::UtxoContext;
 use tw_utxo::script::Script;
 use tw_utxo::transaction::standard_transaction::builder::OutputBuilder;
 use tw_utxo::transaction::standard_transaction::TransactionOutput;
 
-pub struct OutputProtobuf<'a> {
+pub struct OutputProtobuf<'a, Context: UtxoContext> {
     chain_info: &'a BitcoinChainInfo,
     output: &'a Proto::Output<'a>,
+    _phantom: PhantomData<Context>,
 }
 
-impl<'a> OutputProtobuf<'a> {
+impl<'a, Context: UtxoContext> OutputProtobuf<'a, Context> {
     pub fn new(chain_info: &'a BitcoinChainInfo, output: &'a Proto::Output<'a>) -> Self {
-        OutputProtobuf { chain_info, output }
+        OutputProtobuf {
+            chain_info,
+            output,
+            _phantom: PhantomData,
+        }
     }
 
     pub fn output_from_proto(self) -> SigningResult<TransactionOutput> {
@@ -152,68 +155,20 @@ impl<'a> OutputProtobuf<'a> {
         Ok(self.prepare_builder()?.custom_script_pubkey(script))
     }
 
-    pub fn recipient_address(&self, addr: &str) -> SigningResult<TransactionOutput> {
-        let addr = StandardBitcoinAddress::from_str(addr)
+    pub fn recipient_address(&self, addr_str: &str) -> SigningResult<TransactionOutput> {
+        let addr = Context::Address::from_str(addr_str)
             .into_tw()
             .context("Invalid recipient address")?;
-
-        match addr {
-            StandardBitcoinAddress::Legacy(ref legacy) => self.recipient_legacy_address(legacy),
-            StandardBitcoinAddress::Segwit(ref segwit) => self.recipient_segwit_address(segwit),
-            StandardBitcoinAddress::Taproot(ref taproot) => self.recipient_taproot_address(taproot),
-        }
+        let claiming_script_pubkey =
+            Context::addr_to_script_pubkey(&addr, self.chain_info.to_address_prefixes())?;
+        self.custom_script(claiming_script_pubkey.into())
+            .with_context(|| format!("Error handling {addr_str} output address"))
     }
 
     pub fn op_return(&self, op_return_data: &[u8]) -> SigningResult<TransactionOutput> {
         self.prepare_builder()?.op_return(op_return_data)
     }
 
-    pub fn recipient_legacy_address(
-        &self,
-        addr: &LegacyAddress,
-    ) -> SigningResult<TransactionOutput> {
-        let p2pkh_prefix = self.chain_info.p2pkh_prefix;
-        let p2sh_prefix = self.chain_info.p2sh_prefix;
-
-        if addr.prefix() == p2pkh_prefix {
-            Ok(self.prepare_builder()?.p2pkh_from_hash(&addr.payload()))
-        } else if addr.prefix() == p2sh_prefix {
-            Ok(self.prepare_builder()?.p2sh_from_hash(&addr.payload()))
-        } else {
-            // Unknown
-            SigningError::err(SigningErrorType::Error_invalid_address).context(format!(
-                "The given '{addr}' address has unexpected prefix. Expected p2pkh={p2pkh_prefix} p2sh={p2sh_prefix}",
-            ))
-        }
-    }
-
-    pub fn recipient_segwit_address(
-        &self,
-        addr: &SegwitAddress,
-    ) -> SigningResult<TransactionOutput> {
-        if let Ok(pubkey_hash) = H160::try_from(addr.witness_program()) {
-            Ok(self.prepare_builder()?.p2wpkh_from_hash(&pubkey_hash))
-        } else if let Ok(script_hash) = H256::try_from(addr.witness_program()) {
-            Ok(self.prepare_builder()?.p2wsh_from_hash(&script_hash))
-        } else {
-            return SigningError::err(SigningErrorType::Error_invalid_address)
-                .context(format!("The given '{addr}' Segwit address has unexpected witness program. Expected either 20 or 32 bytes"));
-        }
-    }
-
-    pub fn recipient_taproot_address(
-        &self,
-        addr: &TaprootAddress,
-    ) -> SigningResult<TransactionOutput> {
-        let pubkey_x_only = H256::try_from(addr.witness_program())
-            .tw_err(|_| SigningErrorType::Error_invalid_address)
-            .context(format!("The given '{addr}' Taproot address has unexpected witness program. Expected 32 bytes public key"))?;
-
-        Ok(self
-            .prepare_builder()?
-            .p2tr_dangerous_assume_tweaked(&pubkey_x_only))
-    }
-
     /// Tries to convert [`Proto::RedeemScriptOrHash`] to [`Hash<N>`] using a specific `hasher` function.
     /// Please note `P2SH` and `P2WSH` use different hashing functions.
     pub fn redeem_hash_from_proto<const N: usize, F>(
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 d536915a3c8..aa21a02f41b 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
@@ -5,6 +5,7 @@
 use crate::modules::tx_builder::public_keys::PublicKeys;
 use crate::modules::tx_builder::script_parser::{StandardScript, StandardScriptParser};
 use crate::modules::tx_builder::BitcoinChainInfo;
+use std::marker::PhantomData;
 use std::str::FromStr;
 use tw_coin_entry::error::prelude::*;
 use tw_hash::{H160, H256};
@@ -12,10 +13,7 @@ use tw_keypair::{ecdsa, schnorr};
 use tw_memory::Data;
 use tw_misc::traits::ToBytesVec;
 use tw_proto::BitcoinV2::Proto;
-use tw_utxo::address::legacy::LegacyAddress;
-use tw_utxo::address::segwit::SegwitAddress;
-use tw_utxo::address::standard_bitcoin::StandardBitcoinAddress;
-use tw_utxo::address::taproot::TaprootAddress;
+use tw_utxo::context::UtxoContext;
 use tw_utxo::script::Script;
 use tw_utxo::sighash::SighashType;
 use tw_utxo::transaction::standard_transaction::builder::UtxoBuilder;
@@ -23,13 +21,14 @@ use tw_utxo::transaction::standard_transaction::TransactionInput;
 use tw_utxo::transaction::transaction_parts::OutPoint;
 use tw_utxo::transaction::UtxoToSign;
 
-pub struct UtxoProtobuf<'a> {
+pub struct UtxoProtobuf<'a, Context: UtxoContext> {
     chain_info: &'a BitcoinChainInfo,
     input: &'a Proto::Input<'a>,
     public_keys: &'a PublicKeys,
+    _phantom: PhantomData<Context>,
 }
 
-impl<'a> UtxoProtobuf<'a> {
+impl<'a, Context: UtxoContext> UtxoProtobuf<'a, Context> {
     pub fn new(
         chain_info: &'a BitcoinChainInfo,
         input: &'a Proto::Input<'a>,
@@ -39,6 +38,7 @@ impl<'a> UtxoProtobuf<'a> {
             chain_info,
             input,
             public_keys,
+            _phantom: PhantomData,
         }
     }
 
@@ -159,82 +159,17 @@ impl<'a> UtxoProtobuf<'a> {
         }
     }
 
-    pub fn recipient_address(&self, addr: &str) -> SigningResult<(TransactionInput, UtxoToSign)> {
-        let addr = StandardBitcoinAddress::from_str(addr)
-            .into_tw()
-            .context("Invalid claiming script recipient address")?;
-
-        match addr {
-            StandardBitcoinAddress::Legacy(ref legacy) => self.recipient_legacy_address(legacy),
-            StandardBitcoinAddress::Segwit(ref segwit) => self.recipient_segwit_address(segwit),
-            StandardBitcoinAddress::Taproot(ref taproot) => self.recipient_taproot_address(taproot),
-        }
-        .with_context(|| format!("Error handling {addr} input recipient"))
-    }
-
-    pub fn recipient_legacy_address(
-        &self,
-        addr: &LegacyAddress,
-    ) -> SigningResult<(TransactionInput, UtxoToSign)> {
-        let p2pkh_prefix = self.chain_info.p2pkh_prefix;
-        let p2sh_prefix = self.chain_info.p2sh_prefix;
-
-        if p2pkh_prefix == addr.prefix() {
-            // P2PKH
-            let pubkey = self.public_keys.get_ecdsa_public_key(&addr.payload())?;
-            self.prepare_builder()?.p2pkh(&pubkey)
-        } else if p2sh_prefix == addr.prefix() {
-            // P2SH
-            SigningError::err(SigningErrorType::Error_script_redeem).context(
-                "pay-to-script-hash can only be used via 'Input.InputBuilder.p2sh'.\
-                 That is because P2SH address does not provide redeem script but its hash",
-            )
-        } else {
-            // Unknown
-            SigningError::err(SigningErrorType::Error_invalid_address).context(format!(
-                "The given '{addr}' address has unexpected prefix. Expected p2pkh={p2pkh_prefix} p2sh={p2sh_prefix}",
-            ))
-        }
-    }
-
-    pub fn recipient_segwit_address(
+    pub fn recipient_address(
         &self,
-        addr: &SegwitAddress,
+        addr_str: &str,
     ) -> SigningResult<(TransactionInput, UtxoToSign)> {
-        let witness_program = addr.witness_program();
-        match witness_program.len() {
-            // P2WPKH
-            H160::LEN => {
-                let pubkey_hash = H160::try_from(witness_program)
-                    .expect("'witness_program' length must be checked already");
-                let pubkey = self.public_keys.get_ecdsa_public_key(&pubkey_hash)?;
-                self.prepare_builder()?.p2wpkh(&pubkey)
-            },
-            // P2WSH
-            H256::LEN => {
-                SigningError::err(SigningErrorType::Error_script_redeem).context(
-                    "pay-to-witness-script-hash can only be used via 'Input.InputBuilder.p2wsh'.\
-                    That is because P2SH address does not provide redeem script but its hash"
-                )
-            },
-            // Unknown
-            _ => SigningError::err(SigningErrorType::Error_invalid_address)
-                .context(format!("The given '{addr}' segwit address should have 20 or 32 byte length witness program")),
-        }
-    }
-
-    pub fn recipient_taproot_address(
-        &self,
-        addr: &TaprootAddress,
-    ) -> SigningResult<(TransactionInput, UtxoToSign)> {
-        let tweaked_pubkey = schnorr::XOnlyPublicKey::try_from(addr.witness_program())
-            .tw_err(|_| SigningErrorType::Error_invalid_address)
-            .with_context(|| {
-                format!("The given '{addr}' taproot address witness program should be a valid tweaked schnorr public key")
-            })?;
-
-        self.prepare_builder()?
-            .p2tr_key_path_with_tweaked_pubkey(&tweaked_pubkey)
+        let addr = Context::Address::from_str(addr_str)
+            .into_tw()
+            .context("Invalid claiming script recipient address")?;
+        let claiming_script_pubkey =
+            Context::addr_to_script_pubkey(&addr, self.chain_info.to_address_prefixes())?;
+        self.custom_script(claiming_script_pubkey.into())
+            .with_context(|| format!("Error handling {addr_str} input recipient"))
     }
 
     pub fn prepare_builder(&self) -> SigningResult<UtxoBuilder> {
diff --git a/rust/chains/tw_bitcoincash/Cargo.toml b/rust/chains/tw_bitcoincash/Cargo.toml
new file mode 100644
index 00000000000..2ef2ff965c8
--- /dev/null
+++ b/rust/chains/tw_bitcoincash/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "tw_bitcoincash"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+tw_bitcoin = { path = "../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_misc = { path = "../../tw_misc" }
+tw_proto = { path = "../../tw_proto" }
+tw_utxo = { path = "../../frameworks/tw_utxo" }
diff --git a/rust/chains/tw_bitcoincash/src/address.rs b/rust/chains/tw_bitcoincash/src/address.rs
new file mode 100644
index 00000000000..748a8636f0f
--- /dev/null
+++ b/rust/chains/tw_bitcoincash/src/address.rs
@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use crate::cash_address::CashAddress;
+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::error::prelude::{AddressError, AddressResult};
+use tw_coin_entry::prefix::BitcoinBase58Prefix;
+use tw_keypair::ecdsa;
+use tw_memory::Data;
+use tw_utxo::address::legacy::LegacyAddress;
+
+pub enum Address {
+    Cash(CashAddress),
+    Legacy(LegacyAddress),
+}
+
+impl Address {
+    pub fn from_str_with_coin_and_prefix(
+        coin: &dyn CoinContext,
+        address_str: &str,
+        prefix: Option<BitcoinBase58Prefix>,
+    ) -> AddressResult<Self> {
+        // Check whether the prefix is set and specifies the legacy address prefixes.
+        if let Some(prefix) = prefix {
+            return LegacyAddress::from_str_with_coin_and_prefix(coin, address_str, Some(prefix))
+                .map(Address::Legacy);
+        }
+
+        // Otherwise, try to parse address as either Cash or Legacy.
+        if let Ok(cash) = CashAddress::from_str_with_coin_and_hrp(coin, address_str, None) {
+            return Ok(Address::Cash(cash));
+        }
+        if let Ok(legacy) = LegacyAddress::from_str_with_coin_and_prefix(coin, address_str, None) {
+            return Ok(Address::Legacy(legacy));
+        }
+        Err(AddressError::InvalidInput)
+    }
+
+    pub fn p2pkh_with_coin_and_prefix(
+        coin: &dyn CoinContext,
+        public_key: &ecdsa::secp256k1::PublicKey,
+        prefix: Option<BitcoinBase58Prefix>,
+    ) -> AddressResult<Self> {
+        match prefix {
+            // Check whether the prefix is set and specifies the legacy address prefixes.
+            Some(prefix) => {
+                LegacyAddress::p2pkh_with_public_key(prefix.p2pkh, public_key).map(Address::Legacy)
+            },
+            // Otherwise, derive a Cash address by default.
+            None => CashAddress::p2pkh_with_coin(coin, public_key).map(Address::Cash),
+        }
+    }
+}
+
+impl FromStr for Address {
+    type Err = AddressError;
+
+    fn from_str(address_str: &str) -> Result<Self, Self::Err> {
+        if let Ok(cash) = CashAddress::from_str_unchecked(address_str) {
+            return Ok(Address::Cash(cash));
+        }
+        if let Ok(legacy) = LegacyAddress::from_str(address_str) {
+            return Ok(Address::Legacy(legacy));
+        }
+        Err(AddressError::InvalidInput)
+    }
+}
+
+impl CoinAddress for Address {
+    fn data(&self) -> Data {
+        match self {
+            Address::Cash(cash) => cash.data(),
+            Address::Legacy(legacy) => legacy.bytes().to_vec(),
+        }
+    }
+}
+
+impl fmt::Display for Address {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Address::Cash(cash) => write!(f, "{cash}"),
+            Address::Legacy(legacy) => write!(f, "{legacy}"),
+        }
+    }
+}
diff --git a/rust/chains/tw_bitcoincash/src/cash_address/cash_base32.rs b/rust/chains/tw_bitcoincash/src/cash_address/cash_base32.rs
new file mode 100644
index 00000000000..4d7ebcab0b8
--- /dev/null
+++ b/rust/chains/tw_bitcoincash/src/cash_address/cash_base32.rs
@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use tw_encoding::{EncodingError, EncodingResult};
+
+/// Charset for converting from base32.
+const CHARSET_REV: [i8; 128] = [
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    15, -1, 10, 17, 21, 20, 26, 30, 7, 5, -1, -1, -1, -1, -1, -1, -1, 29, -1, 24, 13, 25, 9, 8, 23,
+    -1, 18, 22, 31, 27, 19, -1, 1, 0, 3, 16, 11, 28, 12, 14, 6, 4, 2, -1, -1, -1, -1, -1, -1, 29,
+    -1, 24, 13, 25, 9, 8, 23, -1, 18, 22, 31, 27, 19, -1, 1, 0, 3, 16, 11, 28, 12, 14, 6, 4, 2, -1,
+    -1, -1, -1, -1,
+];
+
+/// Charset for converting to base32.
+const CHARSET: [char; 32] = [
+    'q', 'p', 'z', 'r', 'y', '9', 'x', '8', 'g', 'f', '2', 't', 'v', 'd', 'w', '0', 's', '3', 'j',
+    'n', '5', '4', 'k', 'h', 'c', 'e', '6', 'm', 'u', 'a', '7', 'l',
+];
+
+/// Encodes a 5-bit packed array as BCH base32.
+pub fn encode(input: &[u8]) -> EncodingResult<String> {
+    input
+        .iter()
+        .map(|i| CHARSET.get(*i as usize))
+        .collect::<Option<String>>()
+        .ok_or(EncodingError::InvalidInput)
+}
+
+/// Decods a BCH base32 string as a 5-bit packed array.
+pub fn decode(input: &str) -> EncodingResult<Vec<u8>> {
+    input
+        .chars()
+        .map(|c| {
+            let val = *CHARSET_REV
+                .get(c as usize)
+                .ok_or(EncodingError::InvalidInput)?;
+            if val == -1 {
+                return Err(EncodingError::InvalidInput);
+            }
+            Ok(val as u8)
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tw_encoding::hex::DecodeHex;
+
+    /// `raw` must be 5-bit packed - the condition is required by base32 encode and decode functions.
+    #[track_caller]
+    fn test_base32_impl(raw_hex: &str, encoded: &str) {
+        let raw = raw_hex.decode_hex().unwrap();
+        let actual_encoded = encode(&raw).unwrap();
+        assert_eq!(actual_encoded, encoded);
+        let actual_raw = decode(&actual_encoded).unwrap();
+        assert_eq!(actual_raw, raw);
+    }
+
+    #[test]
+    fn test_base32() {
+        test_base32_impl(
+            "180e0919131e16011c001e1c1607010b120701071317151e1819141b031b1d0a",
+            "cwfen7kpuq7uk8ptj8p8nh47ce5mrma2",
+        );
+        test_base32_impl(
+            "08080f081c1d1002011119051104020811150f140b181d1006140b0216121605",
+            "gg0guaszp3e93yzg3405tcasx5tzkjk9",
+        );
+        test_base32_impl(
+            "0c0215180000050e07061619161f1409120c0a060b1c070e13090f1d0f160b1b",
+            "vz4cqq9w8xkekl5fjv2xtu8wnf0a0ktm",
+        );
+    }
+}
diff --git a/rust/chains/tw_bitcoincash/src/cash_address/checksum.rs b/rust/chains/tw_bitcoincash/src/cash_address/checksum.rs
new file mode 100644
index 00000000000..dd9fbf6c13a
--- /dev/null
+++ b/rust/chains/tw_bitcoincash/src/cash_address/checksum.rs
@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use tw_memory::Data;
+
+pub const CHECKSUM_LEN: usize = 8;
+pub const PHANTOM_CHECKSUM: [u8; CHECKSUM_LEN] = [0; CHECKSUM_LEN];
+
+// CalculateChecksum calculates a BCH checksum for a nibble-packed cashaddress
+// that properly includes the network prefix.
+pub fn calculate_checksum(prefix: &str, payload: &[u8]) -> u64 {
+    // Convert the prefix string to a byte array with each element
+    // being the corresponding character's right-most 5 bits.
+    let mut raw_data: Vec<_> = prefix.as_bytes().iter().map(|x| x & 0b11111).collect();
+    // Add a null termination byte after the prefix.
+    raw_data.push(0);
+    raw_data.extend(payload);
+    poly_mod(&raw_data)
+}
+
+pub fn cacl_and_append_checksum(prefix: &str, payload: &[u8]) -> Data {
+    // The checksum sits in the last eight bytes.
+    // Append the phantom checksum to calculate an actual value.
+    let mut payload_with_checksum: Vec<_> =
+        payload.iter().copied().chain(PHANTOM_CHECKSUM).collect();
+
+    let checksum = calculate_checksum(prefix, &payload_with_checksum);
+
+    let mut checksum_starts_at = payload_with_checksum.len() - CHECKSUM_LEN;
+    // Rewrite the checksum.
+    for i in 0..CHECKSUM_LEN {
+        payload_with_checksum[checksum_starts_at] = ((checksum >> (5 * (7 - i))) & 0x1F) as u8;
+        checksum_starts_at += 1;
+    }
+
+    payload_with_checksum
+}
+
+/// The poly_mod is a BCH-encoding checksum function per the CashAddr specification.
+/// See https://github.com/bitcoincashorg/bitcoincash.org/blob/master/spec/cashaddr.md#checksum
+pub fn poly_mod(raw_data: &[u8]) -> u64 {
+    let mut c = 1u64;
+    for d in raw_data {
+        let c0 = c >> 35;
+        c = ((c & 0x07ffffffff) << 5) ^ (*d as u64);
+
+        if c0 & 0x01 != 0 {
+            c ^= 0x98f2bc8e61;
+        }
+        if c0 & 0x02 != 0 {
+            c ^= 0x79b76d99e2;
+        }
+        if c0 & 0x04 != 0 {
+            c ^= 0xf33e5fb3c4;
+        }
+        if c0 & 0x08 != 0 {
+            c ^= 0xae2eabe2a8;
+        }
+        if c0 & 0x10 != 0 {
+            c ^= 0x1e4f43e470;
+        }
+    }
+
+    c ^ 1
+}
diff --git a/rust/chains/tw_bitcoincash/src/cash_address/mod.rs b/rust/chains/tw_bitcoincash/src/cash_address/mod.rs
new file mode 100644
index 00000000000..f060724fc40
--- /dev/null
+++ b/rust/chains/tw_bitcoincash/src/cash_address/mod.rs
@@ -0,0 +1,249 @@
+// 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::error::prelude::*;
+use tw_encoding::bech32;
+use tw_hash::hasher::sha256_ripemd;
+use tw_hash::H160;
+use tw_keypair::ecdsa;
+use tw_memory::Data;
+use tw_utxo::address::legacy::LegacyAddress;
+
+/// BitcoinCash specific base32 format.
+mod cash_base32;
+mod checksum;
+mod unchecked;
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum CashAddressType {
+    P2PKH,
+    P2SH,
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct CashAddress {
+    hrp: String,
+    ty: CashAddressType,
+    key_hash: H160,
+    /// An address string created from this `hrp`, `ty` and `key_hash`.
+    address_str: String,
+}
+
+impl CashAddress {
+    pub fn p2pkh_with_coin(
+        coin: &dyn CoinContext,
+        public_key: &ecdsa::secp256k1::PublicKey,
+    ) -> AddressResult<CashAddress> {
+        let hrp = coin.hrp().ok_or(AddressError::InvalidRegistry)?;
+        Self::p2pkh_with_hrp(hrp, public_key)
+    }
+
+    pub fn p2pkh_with_hrp(
+        hrp: String,
+        public_key: &ecdsa::secp256k1::PublicKey,
+    ) -> AddressResult<CashAddress> {
+        let public_key_hash = sha256_ripemd(public_key.compressed().as_slice());
+        let key_hash =
+            H160::try_from(public_key_hash.as_slice()).expect("sha256_ripemd returns 20 bytes");
+        let address_str = Self::encode(&hrp, CashAddressType::P2PKH, &key_hash)?;
+        Ok(CashAddress {
+            hrp,
+            ty: CashAddressType::P2PKH,
+            key_hash: H160::try_from(public_key_hash.as_slice())
+                .expect("sha256_ripemd returns 20 bytes"),
+            address_str,
+        })
+    }
+
+    pub fn from_str_with_coin_and_hrp(
+        coin: &dyn CoinContext,
+        address_str: &str,
+        expected_hrp: Option<&str>,
+    ) -> AddressResult<Self> {
+        let expected_hrp = match expected_hrp {
+            Some(hrp) => hrp.to_string(),
+            None => coin.hrp().ok_or(AddressError::InvalidRegistry)?,
+        };
+
+        Self::from_str_with_hrp(address_str, expected_hrp)
+    }
+
+    pub fn from_str_with_hrp(address_str: &str, expected_hrp: String) -> AddressResult<Self> {
+        unchecked::UncheckedCashAddress::from_str(address_str)?.checked_with_prefix(expected_hrp)
+    }
+
+    pub fn from_str_unchecked(address_str: &str) -> AddressResult<Self> {
+        unchecked::UncheckedCashAddress::from_str(address_str)?.partly_checked()
+    }
+
+    pub fn to_legacy(&self, p2pkh_prefix: u8, p2sh_prefix: u8) -> AddressResult<LegacyAddress> {
+        match self.ty {
+            CashAddressType::P2PKH => LegacyAddress::new(p2pkh_prefix, self.key_hash.as_slice()),
+            CashAddressType::P2SH => LegacyAddress::new(p2sh_prefix, self.key_hash.as_slice()),
+        }
+    }
+
+    fn encode(hrp: &str, ty: CashAddressType, key_hash: &H160) -> AddressResult<String> {
+        let mut payload = Vec::with_capacity(1 + H160::LEN + checksum::CHECKSUM_LEN);
+        payload.push(Self::version_byte(ty));
+        payload.extend_from_slice(key_hash.as_slice());
+
+        let payload_u5 = {
+            let from = 8;
+            let to = 5;
+            let pad = true;
+            bech32::convert_bits(&payload, from, to, pad).map_err(|_| AddressError::InvalidInput)?
+        };
+
+        let payload_with_checksum = checksum::cacl_and_append_checksum(hrp, &payload_u5);
+        let encoded_payload =
+            cash_base32::encode(&payload_with_checksum).map_err(|_| AddressError::InvalidInput)?;
+        Ok(format!("{hrp}:{encoded_payload}"))
+    }
+
+    fn version_byte(ty: CashAddressType) -> u8 {
+        let en_address_type: u8 = match ty {
+            CashAddressType::P2PKH => 0,
+            CashAddressType::P2SH => 1,
+        };
+
+        // Please note we always serialize the key hash length as 0 here,
+        // as the length is always 20 (160 bits).
+        // https://github.com/bitcoincashorg/bitcoincash.org/blob/master/spec/cashaddr.md#version-byte
+        let serialized_hash_len = 0;
+
+        let mut version_byte = en_address_type;
+        version_byte <<= 3;
+        version_byte |= serialized_hash_len;
+
+        version_byte
+    }
+}
+
+impl CoinAddress for CashAddress {
+    #[inline]
+    fn data(&self) -> Data {
+        self.key_hash.to_vec()
+    }
+}
+
+impl fmt::Display for CashAddress {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.address_str)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[track_caller]
+    fn test_address_from_str_impl(s: &str, expected: CashAddress) {
+        let actual = CashAddress::from_str_with_hrp(s, expected.hrp.clone()).unwrap();
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_cash_address_from_str() {
+        test_address_from_str_impl(
+            "bitcoincash:pq4ql3ph6738xuv2cycduvkpu4rdwqge5q2uxdfg6f",
+            CashAddress {
+                hrp: "bitcoincash".to_string(),
+                ty: CashAddressType::P2SH,
+                key_hash: H160::from("2a0fc437d7a273718ac130de32c1e546d70119a0"),
+                address_str: "bitcoincash:pq4ql3ph6738xuv2cycduvkpu4rdwqge5q2uxdfg6f".to_string(),
+            },
+        );
+
+        test_address_from_str_impl(
+            "qrplwyx7kueqkrh6dmd3fclta6u32hafp5tnpkchx2",
+            CashAddress {
+                hrp: "bitcoincash".to_string(),
+                ty: CashAddressType::P2PKH,
+                key_hash: H160::from("c3f710deb7320b0efa6edb14e3ebeeb9155fa90d"),
+                address_str: "bitcoincash:qrplwyx7kueqkrh6dmd3fclta6u32hafp5tnpkchx2".to_string(),
+            },
+        );
+
+        test_address_from_str_impl(
+            "BitCoinCash:QRPLWYX7KUEQKRH6DMD3FCLTA6U32HAFP5TNPKCHX2",
+            CashAddress {
+                hrp: "bitcoincash".to_string(),
+                ty: CashAddressType::P2PKH,
+                key_hash: H160::from("c3f710deb7320b0efa6edb14e3ebeeb9155fa90d"),
+                address_str: "bitcoincash:qrplwyx7kueqkrh6dmd3fclta6u32hafp5tnpkchx2".to_string(),
+            },
+        );
+
+        test_address_from_str_impl(
+            "bchtest:qqjr7yu573z4faxw8ltgvjwpntwys08fysk07zmvce",
+            CashAddress {
+                hrp: "bchtest".to_string(),
+                ty: CashAddressType::P2PKH,
+                key_hash: H160::from("243f1394f44554f4ce3fd68649c19adc483ce924"),
+                address_str: "bchtest:qqjr7yu573z4faxw8ltgvjwpntwys08fysk07zmvce".to_string(),
+            },
+        );
+    }
+
+    struct AddressToLegacyTest<'a> {
+        p2pkh_prefix: u8,
+        p2sh_prefixes: u8,
+        hrp: &'a str,
+        address: &'a str,
+        legacy: &'a str,
+    }
+
+    #[track_caller]
+    fn test_address_to_legacy_impl(input: AddressToLegacyTest) {
+        let cash = CashAddress::from_str_with_hrp(input.address, input.hrp.to_string()).unwrap();
+        let legacy = cash
+            .to_legacy(input.p2pkh_prefix, input.p2sh_prefixes)
+            .unwrap();
+        assert_eq!(legacy.to_string(), input.legacy);
+    }
+
+    #[test]
+    fn test_cash_address_to_legacy() {
+        // P2PKH
+        test_address_to_legacy_impl(AddressToLegacyTest {
+            p2pkh_prefix: 0,
+            p2sh_prefixes: 5,
+            hrp: "bitcoincash",
+            address: "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a",
+            legacy: "1BpEi6DfDAUFd7GtittLSdBeYJvcoaVggu",
+        });
+
+        // P2PKH
+        test_address_to_legacy_impl(AddressToLegacyTest {
+            p2pkh_prefix: 0,
+            p2sh_prefixes: 5,
+            hrp: "bitcoincash",
+            address: "qr95sy3j9xwd2ap32xkykttr4cvcu7as4y0qverfuy",
+            legacy: "1KXrWXciRDZUpQwQmuM1DbwsKDLYAYsVLR",
+        });
+
+        // P2SH
+        test_address_to_legacy_impl(AddressToLegacyTest {
+            p2pkh_prefix: 0,
+            p2sh_prefixes: 5,
+            hrp: "bitcoincash",
+            address: "bitcoincash:pqq3728yw0y47sqn6l2na30mcw6zm78dzq5ucqzc37",
+            legacy: "31nwvkZwyPdgzjBJZXfDmSWsC4ZLKpYyUw",
+        });
+
+        // P2PKH testnet
+        test_address_to_legacy_impl(AddressToLegacyTest {
+            p2pkh_prefix: 111,
+            p2sh_prefixes: 196,
+            hrp: "bchtest",
+            address: "bchtest:qpcgc96kles6v35a2525dppaapzk2htdkv72dv08qf",
+            legacy: "mqn3oF7tcju9uqoG1H1AZt4M6CP1PTaELo",
+        });
+    }
+}
diff --git a/rust/chains/tw_bitcoincash/src/cash_address/unchecked.rs b/rust/chains/tw_bitcoincash/src/cash_address/unchecked.rs
new file mode 100644
index 00000000000..9a4a0d5c7fa
--- /dev/null
+++ b/rust/chains/tw_bitcoincash/src/cash_address/unchecked.rs
@@ -0,0 +1,147 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use crate::cash_address::checksum::{calculate_checksum, CHECKSUM_LEN};
+use crate::cash_address::{cash_base32, CashAddress, CashAddressType};
+use std::fmt;
+use std::str::FromStr;
+use tw_coin_entry::error::prelude::{AddressError, AddressResult};
+use tw_encoding::bech32;
+use tw_hash::H160;
+use tw_memory::Data;
+
+/// BitcoinCash address may or may not have a prefix.
+struct CashAddressParts {
+    prefix: Option<String>,
+    payload: String,
+}
+
+impl FromStr for CashAddressParts {
+    type Err = AddressError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let address_str = s.to_lowercase();
+        let tokens: Vec<&str> = address_str.split(':').collect();
+
+        if tokens.len() == 1 {
+            Ok(CashAddressParts {
+                prefix: None,
+                payload: tokens[0].to_string(),
+            })
+        } else if tokens.len() == 2 {
+            Ok(CashAddressParts {
+                prefix: Some(tokens[0].to_string()),
+                payload: tokens[1].to_string(),
+            })
+        } else {
+            Err(AddressError::InvalidInput)
+        }
+    }
+}
+
+impl fmt::Display for CashAddressParts {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.prefix {
+            Some(ref prefix) => write!(f, "{prefix}:{}", self.payload),
+            None => write!(f, "{}", self.payload),
+        }
+    }
+}
+
+/// BitcoinCash address with an unchecked checksum and prefix.
+/// Consider using [`CashAddress`] directly instead.
+pub struct UncheckedCashAddress {
+    parts: CashAddressParts,
+    ty: CashAddressType,
+    key_hash: H160,
+    /// Original 5-bit packed array decoded from base32.
+    /// Used to validate the checksum along with a prefix.
+    unchecked_payload_with_checksum: Data,
+}
+
+impl UncheckedCashAddress {
+    /// Checks whether the address has an expected prefix, and verifies the address checksum.
+    pub fn checked_with_prefix(self, expected_prefix: String) -> AddressResult<CashAddress> {
+        // Validate the prefix if it was present.
+        if let Some(ref prefix) = self.parts.prefix {
+            if *prefix != expected_prefix {
+                return Err(AddressError::InvalidHrp);
+            }
+        }
+
+        // Ensure the checksum is zero when decoding.
+        let checksum = calculate_checksum(&expected_prefix, &self.unchecked_payload_with_checksum);
+        if checksum != 0 {
+            return Err(AddressError::InvalidChecksum);
+        }
+
+        let address_str = format!("{expected_prefix}:{}", self.parts.payload);
+        Ok(CashAddress {
+            hrp: expected_prefix,
+            ty: self.ty,
+            key_hash: self.key_hash,
+            address_str,
+        })
+    }
+
+    /// Tries to verify the address checksum if it contains a prefix, otherwise do not verify at all.
+    /// Please note this method doesn't validate if the prefix belongs to a network.
+    ///
+    /// Consider using [`UncheckedCashAddress::checked_with_prefix`] instead.
+    pub fn partly_checked(self) -> AddressResult<CashAddress> {
+        match self.parts.prefix.clone() {
+            Some(prefix) => self.checked_with_prefix(prefix),
+            // Do not check validity of the address and return as is.
+            None => Ok(CashAddress {
+                hrp: String::default(),
+                ty: self.ty,
+                key_hash: self.key_hash,
+                address_str: self.parts.to_string(),
+            }),
+        }
+    }
+}
+
+impl FromStr for UncheckedCashAddress {
+    type Err = AddressError;
+
+    fn from_str(address_str: &str) -> Result<Self, Self::Err> {
+        let address_parts = CashAddressParts::from_str(address_str)?;
+
+        let payload_with_checksum =
+            cash_base32::decode(&address_parts.payload).map_err(|_| AddressError::InvalidInput)?;
+
+        // Get the payload without the checksum.
+        let payload_u5 = &payload_with_checksum[..payload_with_checksum.len() - CHECKSUM_LEN];
+
+        let payload_data = {
+            let from = 5;
+            let to = 8;
+            let pad = false;
+            bech32::convert_bits(payload_u5, from, to, pad)
+                .map_err(|_| AddressError::InvalidInput)?
+        };
+
+        let version_byte = payload_data[0];
+        let ty = get_address_type(version_byte)?;
+        let key_hash =
+            H160::try_from(&payload_data[1..]).map_err(|_| AddressError::InvalidInput)?;
+
+        // `encoded_payload` is checked already, and it contains the valid checksum at the end.
+        Ok(UncheckedCashAddress {
+            parts: address_parts,
+            ty,
+            key_hash,
+            unchecked_payload_with_checksum: payload_with_checksum,
+        })
+    }
+}
+
+fn get_address_type(version_byte: u8) -> AddressResult<CashAddressType> {
+    match version_byte & 8 {
+        0 => Ok(CashAddressType::P2PKH),
+        8 => Ok(CashAddressType::P2SH),
+        _ => Err(AddressError::UnexpectedAddressPrefix),
+    }
+}
diff --git a/rust/chains/tw_bitcoincash/src/context.rs b/rust/chains/tw_bitcoincash/src/context.rs
new file mode 100644
index 00000000000..e4eb7b2036d
--- /dev/null
+++ b/rust/chains/tw_bitcoincash/src/context.rs
@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use crate::address::Address;
+use tw_coin_entry::error::prelude::*;
+use tw_utxo::context::{AddressPrefixes, UtxoContext};
+use tw_utxo::script::Script;
+
+pub struct BitcoinCashContext;
+
+impl UtxoContext for BitcoinCashContext {
+    type Address = Address;
+
+    fn addr_to_script_pubkey(
+        addr: &Self::Address,
+        prefixes: AddressPrefixes,
+    ) -> SigningResult<Script> {
+        match addr {
+            Address::Cash(cash) => cash
+                .to_legacy(prefixes.p2pkh_prefix, prefixes.p2sh_prefix)
+                .into_tw()
+                .context("Error converting 'CashAddress' to 'LegacyAddress'")?
+                .to_script_pubkey(prefixes.p2pkh_prefix, prefixes.p2sh_prefix),
+            Address::Legacy(legacy) => {
+                legacy.to_script_pubkey(prefixes.p2pkh_prefix, prefixes.p2sh_prefix)
+            },
+        }
+    }
+}
diff --git a/rust/chains/tw_bitcoincash/src/entry.rs b/rust/chains/tw_bitcoincash/src/entry.rs
new file mode 100644
index 00000000000..bbe4625aa7d
--- /dev/null
+++ b/rust/chains/tw_bitcoincash/src/entry.rs
@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use crate::address::Address;
+use crate::context::BitcoinCashContext;
+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_coin_entry::prefix::BitcoinBase58Prefix;
+use tw_keypair::tw::PublicKey;
+use tw_proto::BitcoinV2::Proto;
+
+pub struct BitcoinCashEntry;
+
+impl CoinEntry for BitcoinCashEntry {
+    // TODO `BitcoinCash` should probably have its own prefix enum with Cash and Base58 prefixes.
+    type AddressPrefix = BitcoinBase58Prefix;
+    type Address = Address;
+    type SigningInput<'a> = Proto::SigningInput<'a>;
+    type SigningOutput = Proto::SigningOutput<'static>;
+    type PreSigningOutput = Proto::PreSigningOutput<'static>;
+
+    // Optional modules:
+    type JsonSigner = NoJsonSigner;
+    type PlanBuilder = BitcoinPlanner<BitcoinCashContext>;
+    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> {
+        Address::from_str_with_coin_and_prefix(coin, address, prefix)
+    }
+
+    #[inline]
+    fn parse_address_unchecked(&self, address: &str) -> AddressResult<Self::Address> {
+        Address::from_str(address)
+    }
+
+    #[inline]
+    fn derive_address(
+        &self,
+        coin: &dyn CoinContext,
+        public_key: PublicKey,
+        _derivation: Derivation,
+        prefix: Option<Self::AddressPrefix>,
+    ) -> AddressResult<Self::Address> {
+        let public_key = public_key
+            .to_secp256k1()
+            .ok_or(AddressError::PublicKeyTypeMismatch)?;
+        Address::p2pkh_with_coin_and_prefix(coin, public_key, prefix)
+    }
+
+    #[inline]
+    fn sign(&self, coin: &dyn CoinContext, input: Self::SigningInput<'_>) -> Self::SigningOutput {
+        BitcoinSigner::<BitcoinCashContext>::sign(coin, &input)
+    }
+
+    #[inline]
+    fn preimage_hashes(
+        &self,
+        coin: &dyn CoinContext,
+        input: Self::SigningInput<'_>,
+    ) -> Self::PreSigningOutput {
+        BitcoinCompiler::<BitcoinCashContext>::preimage_hashes(coin, input)
+    }
+
+    #[inline]
+    fn compile(
+        &self,
+        coin: &dyn CoinContext,
+        input: Self::SigningInput<'_>,
+        signatures: Vec<SignatureBytes>,
+        public_keys: Vec<PublicKeyBytes>,
+    ) -> Self::SigningOutput {
+        BitcoinCompiler::<BitcoinCashContext>::compile(coin, input, signatures, public_keys)
+    }
+}
diff --git a/rust/chains/tw_bitcoincash/src/lib.rs b/rust/chains/tw_bitcoincash/src/lib.rs
new file mode 100644
index 00000000000..0ad18c84e8d
--- /dev/null
+++ b/rust/chains/tw_bitcoincash/src/lib.rs
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+pub mod address;
+pub mod cash_address;
+pub mod context;
+pub mod entry;
diff --git a/rust/chains/tw_cosmos/src/entry.rs b/rust/chains/tw_cosmos/src/entry.rs
index dc2e9de681b..f77d8ea8991 100644
--- a/rust/chains/tw_cosmos/src/entry.rs
+++ b/rust/chains/tw_cosmos/src/entry.rs
@@ -49,11 +49,7 @@ impl CoinEntry for CosmosEntry {
     }
 
     #[inline]
-    fn parse_address_unchecked(
-        &self,
-        _coin: &dyn CoinContext,
-        address: &str,
-    ) -> AddressResult<Self::Address> {
+    fn parse_address_unchecked(&self, address: &str) -> AddressResult<Self::Address> {
         Address::from_str(address)
     }
 
diff --git a/rust/chains/tw_ethereum/src/entry.rs b/rust/chains/tw_ethereum/src/entry.rs
index aad3d6f90b5..2b72e1c374c 100644
--- a/rust/chains/tw_ethereum/src/entry.rs
+++ b/rust/chains/tw_ethereum/src/entry.rs
@@ -51,11 +51,7 @@ impl CoinEntry for EthereumEntry {
     }
 
     #[inline]
-    fn parse_address_unchecked(
-        &self,
-        _coin: &dyn CoinContext,
-        address: &str,
-    ) -> AddressResult<Self::Address> {
+    fn parse_address_unchecked(&self, address: &str) -> AddressResult<Self::Address> {
         Address::from_str(address)
     }
 
diff --git a/rust/chains/tw_greenfield/src/entry.rs b/rust/chains/tw_greenfield/src/entry.rs
index 448cbe54f15..8a5d0e9f681 100644
--- a/rust/chains/tw_greenfield/src/entry.rs
+++ b/rust/chains/tw_greenfield/src/entry.rs
@@ -49,11 +49,7 @@ impl CoinEntry for GreenfieldEntry {
     }
 
     #[inline]
-    fn parse_address_unchecked(
-        &self,
-        _coin: &dyn CoinContext,
-        address: &str,
-    ) -> AddressResult<Self::Address> {
+    fn parse_address_unchecked(&self, address: &str) -> AddressResult<Self::Address> {
         GreenfieldAddress::from_str(address)
     }
 
diff --git a/rust/chains/tw_internet_computer/src/entry.rs b/rust/chains/tw_internet_computer/src/entry.rs
index 3e9be8f75cb..592b9edf052 100644
--- a/rust/chains/tw_internet_computer/src/entry.rs
+++ b/rust/chains/tw_internet_computer/src/entry.rs
@@ -52,11 +52,7 @@ impl CoinEntry for InternetComputerEntry {
     }
 
     #[inline]
-    fn parse_address_unchecked(
-        &self,
-        _coin: &dyn CoinContext,
-        address: &str,
-    ) -> AddressResult<Self::Address> {
+    fn parse_address_unchecked(&self, address: &str) -> AddressResult<Self::Address> {
         Self::Address::from_str(address)
     }
 
diff --git a/rust/chains/tw_native_evmos/src/entry.rs b/rust/chains/tw_native_evmos/src/entry.rs
index e3964e6454c..61cec2c5f7e 100644
--- a/rust/chains/tw_native_evmos/src/entry.rs
+++ b/rust/chains/tw_native_evmos/src/entry.rs
@@ -49,11 +49,7 @@ impl CoinEntry for NativeEvmosEntry {
     }
 
     #[inline]
-    fn parse_address_unchecked(
-        &self,
-        _coin: &dyn CoinContext,
-        address: &str,
-    ) -> AddressResult<Self::Address> {
+    fn parse_address_unchecked(&self, address: &str) -> AddressResult<Self::Address> {
         Address::from_str(address)
     }
 
diff --git a/rust/chains/tw_native_injective/src/entry.rs b/rust/chains/tw_native_injective/src/entry.rs
index bca5b9759dd..e9d2ec3ad4d 100644
--- a/rust/chains/tw_native_injective/src/entry.rs
+++ b/rust/chains/tw_native_injective/src/entry.rs
@@ -49,11 +49,7 @@ impl CoinEntry for NativeInjectiveEntry {
     }
 
     #[inline]
-    fn parse_address_unchecked(
-        &self,
-        _coin: &dyn CoinContext,
-        address: &str,
-    ) -> AddressResult<Self::Address> {
+    fn parse_address_unchecked(&self, address: &str) -> AddressResult<Self::Address> {
         Address::from_str(address)
     }
 
diff --git a/rust/chains/tw_ronin/src/entry.rs b/rust/chains/tw_ronin/src/entry.rs
index 49a21c71c0c..3905a521517 100644
--- a/rust/chains/tw_ronin/src/entry.rs
+++ b/rust/chains/tw_ronin/src/entry.rs
@@ -51,11 +51,7 @@ impl CoinEntry for RoninEntry {
     }
 
     #[inline]
-    fn parse_address_unchecked(
-        &self,
-        _coin: &dyn CoinContext,
-        address: &str,
-    ) -> AddressResult<Self::Address> {
+    fn parse_address_unchecked(&self, address: &str) -> AddressResult<Self::Address> {
         Address::from_str(address)
     }
 
diff --git a/rust/chains/tw_solana/src/entry.rs b/rust/chains/tw_solana/src/entry.rs
index 5fd330739fe..c2a6b46f24f 100644
--- a/rust/chains/tw_solana/src/entry.rs
+++ b/rust/chains/tw_solana/src/entry.rs
@@ -48,11 +48,7 @@ impl CoinEntry for SolanaEntry {
     }
 
     #[inline]
-    fn parse_address_unchecked(
-        &self,
-        _coin: &dyn CoinContext,
-        address: &str,
-    ) -> AddressResult<Self::Address> {
+    fn parse_address_unchecked(&self, address: &str) -> AddressResult<Self::Address> {
         SolanaAddress::from_str(address)
     }
 
diff --git a/rust/chains/tw_sui/src/entry.rs b/rust/chains/tw_sui/src/entry.rs
index 63bd4e92df7..5c0539c9e29 100644
--- a/rust/chains/tw_sui/src/entry.rs
+++ b/rust/chains/tw_sui/src/entry.rs
@@ -49,11 +49,7 @@ impl CoinEntry for SuiEntry {
     }
 
     #[inline]
-    fn parse_address_unchecked(
-        &self,
-        _coin: &dyn CoinContext,
-        address: &str,
-    ) -> AddressResult<Self::Address> {
+    fn parse_address_unchecked(&self, address: &str) -> AddressResult<Self::Address> {
         SuiAddress::from_str(address)
     }
 
diff --git a/rust/chains/tw_thorchain/src/entry.rs b/rust/chains/tw_thorchain/src/entry.rs
index 9f93134601f..5baa749c894 100644
--- a/rust/chains/tw_thorchain/src/entry.rs
+++ b/rust/chains/tw_thorchain/src/entry.rs
@@ -48,11 +48,7 @@ impl CoinEntry for ThorchainEntry {
     }
 
     #[inline]
-    fn parse_address_unchecked(
-        &self,
-        _coin: &dyn CoinContext,
-        address: &str,
-    ) -> AddressResult<Self::Address> {
+    fn parse_address_unchecked(&self, address: &str) -> AddressResult<Self::Address> {
         Address::from_str(address)
     }
 
diff --git a/rust/chains/tw_ton/src/entry.rs b/rust/chains/tw_ton/src/entry.rs
index a2bd5aadc2d..efc0fc8995c 100644
--- a/rust/chains/tw_ton/src/entry.rs
+++ b/rust/chains/tw_ton/src/entry.rs
@@ -51,11 +51,7 @@ impl CoinEntry for TheOpenNetworkEntry {
     }
 
     #[inline]
-    fn parse_address_unchecked(
-        &self,
-        _coin: &dyn CoinContext,
-        address: &str,
-    ) -> AddressResult<Self::Address> {
+    fn parse_address_unchecked(&self, address: &str) -> AddressResult<Self::Address> {
         TonAddress::from_str(address).and_then(TonAddress::normalize)
     }
 
diff --git a/rust/frameworks/tw_utxo/src/address/legacy.rs b/rust/frameworks/tw_utxo/src/address/legacy.rs
index 22def1d3750..321cd8410ea 100644
--- a/rust/frameworks/tw_utxo/src/address/legacy.rs
+++ b/rust/frameworks/tw_utxo/src/address/legacy.rs
@@ -2,6 +2,7 @@
 //
 // Copyright © 2017 Trust Wallet.
 
+use crate::script::standard_script::conditions;
 use crate::script::Script;
 use std::fmt;
 use std::str::FromStr;
@@ -19,7 +20,7 @@ pub const BITCOIN_ADDRESS_CHECKSUM_SIZE: usize = 4;
 
 type BitcoinBase58Address = Base58Address<BITCOIN_ADDRESS_SIZE, BITCOIN_ADDRESS_CHECKSUM_SIZE>;
 
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct LegacyAddress(BitcoinBase58Address);
 
 impl LegacyAddress {
@@ -109,6 +110,21 @@ impl LegacyAddress {
         debug_assert_eq!(self.bytes().len(), H160::LEN);
         H160::try_from(self.bytes()).expect("Legacy address must be exactly 20 bytes")
     }
+
+    pub fn to_script_pubkey(&self, p2pkh_prefix: u8, p2sh_prefix: u8) -> SigningResult<Script> {
+        if p2pkh_prefix == self.prefix() {
+            // P2PKH
+            Ok(conditions::new_p2pkh(&self.payload()))
+        } else if p2sh_prefix == self.prefix() {
+            // P2SH
+            Ok(conditions::new_p2sh(&self.payload()))
+        } else {
+            // Unknown
+            SigningError::err(SigningErrorType::Error_invalid_address).context(format!(
+                "The given '{self}' address has unexpected prefix. Expected p2pkh={p2pkh_prefix} p2sh={p2sh_prefix}",
+            ))
+        }
+    }
 }
 
 impl FromStr for LegacyAddress {
diff --git a/rust/frameworks/tw_utxo/src/address/segwit.rs b/rust/frameworks/tw_utxo/src/address/segwit.rs
index 8098fc4ad93..0083a98f2bc 100644
--- a/rust/frameworks/tw_utxo/src/address/segwit.rs
+++ b/rust/frameworks/tw_utxo/src/address/segwit.rs
@@ -4,6 +4,7 @@
 
 use super::Bech32Prefix;
 use crate::address::witness_program::{WitnessProgram, WITNESS_V0};
+use crate::script::standard_script::conditions;
 use crate::script::Script;
 use core::fmt;
 use std::str::FromStr;
@@ -18,7 +19,7 @@ use tw_memory::Data;
 /// Witness program sizes valid for V0 (Segwit).
 const WITNESS_V0_VALID_PROGRAM_SIZES: [usize; 2] = [H160::LEN, H256::LEN];
 
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct SegwitAddress {
     inner: WitnessProgram,
 }
@@ -81,6 +82,28 @@ impl SegwitAddress {
     pub fn witness_program(&self) -> &[u8] {
         self.inner.witness_program()
     }
+
+    pub fn to_script_pubkey(&self) -> SigningResult<Script> {
+        let witness_program = self.witness_program();
+        match witness_program.len() {
+            // P2WPKH
+            H160::LEN => {
+                let pubkey_hash = H160::try_from(witness_program)
+                    .expect("'witness_program' length must be checked already");
+                Ok(conditions::new_p2wpkh(&pubkey_hash))
+            },
+            // P2WSH
+            H256::LEN => {
+                let script_hash = H256::try_from(witness_program)
+                    .expect("'witness_program' length must be checked already");
+                Ok(conditions::new_p2wsh(&script_hash))
+            },
+            // Unknown
+            _ => SigningError::err(SigningErrorType::Error_invalid_address).context(format!(
+                "The given '{self}' segwit address should have 20 or 32 byte length witness program"
+            )),
+        }
+    }
 }
 
 impl FromStr for SegwitAddress {
diff --git a/rust/frameworks/tw_utxo/src/address/standard_bitcoin.rs b/rust/frameworks/tw_utxo/src/address/standard_bitcoin.rs
index 6f582b0976b..53d0967a09f 100644
--- a/rust/frameworks/tw_utxo/src/address/standard_bitcoin.rs
+++ b/rust/frameworks/tw_utxo/src/address/standard_bitcoin.rs
@@ -43,7 +43,7 @@ impl TryFrom<AddressPrefix> for StandardBitcoinPrefix {
 ///
 /// The set of address types can differ for Bitcoin forks.
 /// For example, Zcash does not support segwit addresses.
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum StandardBitcoinAddress {
     Legacy(LegacyAddress),
     Segwit(SegwitAddress),
diff --git a/rust/frameworks/tw_utxo/src/address/taproot.rs b/rust/frameworks/tw_utxo/src/address/taproot.rs
index d0f18810a20..653c68787e1 100644
--- a/rust/frameworks/tw_utxo/src/address/taproot.rs
+++ b/rust/frameworks/tw_utxo/src/address/taproot.rs
@@ -1,5 +1,7 @@
 use super::Bech32Prefix;
 use crate::address::witness_program::WitnessProgram;
+use crate::script::standard_script::conditions;
+use crate::script::Script;
 use bitcoin::key::TapTweak;
 use core::fmt;
 use std::str::FromStr;
@@ -16,7 +18,7 @@ pub const WITNESS_V1: u8 = 1;
 /// cbindgen:ignore
 pub const WITNESS_V1_VALID_PROGRAM_SIZES: [usize; 1] = [H256::LEN];
 
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct TaprootAddress {
     inner: WitnessProgram,
 }
@@ -118,6 +120,15 @@ impl TaprootAddress {
     pub fn witness_program(&self) -> &[u8] {
         self.inner.witness_program()
     }
+
+    pub fn to_script_pubkey(&self) -> SigningResult<Script> {
+        let tweaked_pubkey_hash = H256::try_from(self.witness_program())
+            .tw_err(|_| SigningErrorType::Error_invalid_address)
+            .context("P2TR 'witness_program' should be 32-bytes array")?;
+        Ok(conditions::new_p2tr_dangerous_assume_tweaked(
+            &tweaked_pubkey_hash,
+        ))
+    }
 }
 
 impl FromStr for TaprootAddress {
diff --git a/rust/frameworks/tw_utxo/src/address/witness_program.rs b/rust/frameworks/tw_utxo/src/address/witness_program.rs
index 0edb5ea65be..ab0287f4276 100644
--- a/rust/frameworks/tw_utxo/src/address/witness_program.rs
+++ b/rust/frameworks/tw_utxo/src/address/witness_program.rs
@@ -23,7 +23,7 @@ pub const WITNESS_VALID_PROGRAM_SIZES: RangeInclusive<usize> = 2..=40;
 /// For example:
 /// * witness V0 is Segwit address
 /// * witness V1 is Taproot address
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct WitnessProgram {
     hrp: String,
     witness_version: u8,
diff --git a/rust/frameworks/tw_utxo/src/context.rs b/rust/frameworks/tw_utxo/src/context.rs
new file mode 100644
index 00000000000..f0fd5e7b109
--- /dev/null
+++ b/rust/frameworks/tw_utxo/src/context.rs
@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use crate::script::Script;
+use std::str::FromStr;
+use tw_coin_entry::error::prelude::{AddressError, SigningResult};
+
+pub struct AddressPrefixes {
+    pub p2pkh_prefix: u8,
+    pub p2sh_prefix: u8,
+}
+
+pub trait UtxoContext {
+    type Address: FromStr<Err = AddressError>;
+
+    fn addr_to_script_pubkey(
+        addr: &Self::Address,
+        prefixes: AddressPrefixes,
+    ) -> SigningResult<Script>;
+}
diff --git a/rust/frameworks/tw_utxo/src/lib.rs b/rust/frameworks/tw_utxo/src/lib.rs
index 84748580ded..3e44914ac42 100644
--- a/rust/frameworks/tw_utxo/src/lib.rs
+++ b/rust/frameworks/tw_utxo/src/lib.rs
@@ -4,6 +4,7 @@
 
 pub mod address;
 pub mod constants;
+pub mod context;
 pub mod dust;
 pub mod encode;
 pub mod modules;
diff --git a/rust/frameworks/tw_utxo/src/script/mod.rs b/rust/frameworks/tw_utxo/src/script/mod.rs
index 079881fcd8c..7600a1e5ba8 100644
--- a/rust/frameworks/tw_utxo/src/script/mod.rs
+++ b/rust/frameworks/tw_utxo/src/script/mod.rs
@@ -103,6 +103,12 @@ impl Script {
     }
 }
 
+impl From<Script> for Data {
+    fn from(value: Script) -> Self {
+        value.bytes
+    }
+}
+
 impl From<Data> for Script {
     fn from(bytes: Data) -> Self {
         Script { bytes }
diff --git a/rust/tw_any_coin/src/any_address.rs b/rust/tw_any_coin/src/any_address.rs
index f0e83b169c8..01306025711 100644
--- a/rust/tw_any_coin/src/any_address.rs
+++ b/rust/tw_any_coin/src/any_address.rs
@@ -34,8 +34,7 @@ impl AnyAddress {
         prefix: Option<AddressPrefix>,
     ) -> AddressResult<AnyAddress> {
         let (ctx, entry) = coin_dispatcher(coin).map_err(|_| AddressError::UnknownCoinType)?;
-        entry.validate_address(&ctx, address, prefix)?;
-        let address = entry.normalize_address(&ctx, address)?;
+        let address = entry.normalize_address(&ctx, address, prefix)?;
         Ok(AnyAddress { coin, address })
     }
 
@@ -45,8 +44,8 @@ impl AnyAddress {
         coin: CoinType,
         address: &str,
     ) -> AddressResult<AnyAddress> {
-        let (ctx, entry) = coin_dispatcher(coin).map_err(|_| AddressError::UnknownCoinType)?;
-        let address = entry.normalize_address(&ctx, address)?;
+        let (_ctx, entry) = coin_dispatcher(coin).map_err(|_| AddressError::UnknownCoinType)?;
+        let address = entry.normalize_address_unchecked(address)?;
         Ok(AnyAddress { coin, address })
     }
 
@@ -66,8 +65,9 @@ impl AnyAddress {
     /// Returns underlying data (public key or key hash).
     #[inline]
     pub fn get_data(&self) -> AddressResult<Data> {
-        let (ctx, entry) = coin_dispatcher(self.coin).map_err(|_| AddressError::UnknownCoinType)?;
-        entry.address_to_data(&ctx, &self.address)
+        let (_ctx, entry) =
+            coin_dispatcher(self.coin).map_err(|_| AddressError::UnknownCoinType)?;
+        entry.address_to_data(&self.address)
     }
 
     /// Returns the address string representation.
diff --git a/rust/tw_coin_entry/src/coin_entry.rs b/rust/tw_coin_entry/src/coin_entry.rs
index 85d9cd89f05..b3a23671893 100644
--- a/rust/tw_coin_entry/src/coin_entry.rs
+++ b/rust/tw_coin_entry/src/coin_entry.rs
@@ -82,11 +82,7 @@ pub trait CoinEntry {
 
     /// Tries to parse `Self::Address` from the given `address` string by `coin` type.
     /// Please note that this method does not check if the address belongs to the given chain.
-    fn parse_address_unchecked(
-        &self,
-        coin: &dyn CoinContext,
-        address: &str,
-    ) -> AddressResult<Self::Address>;
+    fn parse_address_unchecked(&self, address: &str) -> AddressResult<Self::Address>;
 
     /// Derives an address associated with the given `public_key` by `coin` context, `derivation` and address `prefix`.
     fn derive_address(
diff --git a/rust/tw_coin_entry/src/coin_entry_ext.rs b/rust/tw_coin_entry/src/coin_entry_ext.rs
index 6983bb99848..05976df99ef 100644
--- a/rust/tw_coin_entry/src/coin_entry_ext.rs
+++ b/rust/tw_coin_entry/src/coin_entry_ext.rs
@@ -30,7 +30,15 @@ pub trait CoinEntryExt {
     ) -> AddressResult<()>;
 
     /// Validates and normalizes the given `address`.
-    fn normalize_address(&self, coin: &dyn CoinContext, address: &str) -> AddressResult<String>;
+    fn normalize_address(
+        &self,
+        coin: &dyn CoinContext,
+        address: &str,
+        prefix: Option<AddressPrefix>,
+    ) -> AddressResult<String>;
+
+    /// Normalizes the given `address` without checking its belonging to the `coin` network.
+    fn normalize_address_unchecked(&self, address: &str) -> AddressResult<String>;
 
     /// Derives an address associated with the given `public_key` by `coin` context, `derivation` and address `prefix`.
     fn derive_address(
@@ -42,7 +50,7 @@ pub trait CoinEntryExt {
     ) -> AddressResult<String>;
 
     /// Returns underlying data (public key or key hash).
-    fn address_to_data(&self, coin: &dyn CoinContext, address: &str) -> AddressResult<Data>;
+    fn address_to_data(&self, address: &str) -> AddressResult<Data>;
 
     /// Signs a transaction declared as the given `input`.
     fn sign(&self, coin: &dyn CoinContext, input: &[u8]) -> ProtoResult<Data>;
@@ -114,11 +122,22 @@ where
         self.parse_address(coin, address, prefix).map(|_| ())
     }
 
-    fn normalize_address(&self, coin: &dyn CoinContext, address: &str) -> AddressResult<String> {
+    fn normalize_address(
+        &self,
+        coin: &dyn CoinContext,
+        address: &str,
+        prefix: Option<AddressPrefix>,
+    ) -> AddressResult<String> {
+        let prefix = prefix.map(T::AddressPrefix::try_from).transpose()?;
         // Parse the address and display it.
         // Please note that `Self::Address::to_string()` returns a normalize address.
-        <Self as CoinEntry>::parse_address_unchecked(self, coin, address)
-            .map(|addr| addr.to_string())
+        <Self as CoinEntry>::parse_address(self, coin, address, prefix).map(|addr| addr.to_string())
+    }
+
+    fn normalize_address_unchecked(&self, address: &str) -> AddressResult<String> {
+        // Parse the address and display it.
+        // Please note that `Self::Address::to_string()` returns a normalize address.
+        <Self as CoinEntry>::parse_address_unchecked(self, address).map(|addr| addr.to_string())
     }
 
     fn derive_address(
@@ -135,8 +154,8 @@ where
             .map(|addr| addr.to_string())
     }
 
-    fn address_to_data(&self, coin: &dyn CoinContext, address: &str) -> AddressResult<Data> {
-        self.parse_address_unchecked(coin, address)
+    fn address_to_data(&self, address: &str) -> AddressResult<Data> {
+        self.parse_address_unchecked(address)
             .map(|addr| addr.data())
     }
 
diff --git a/rust/tw_coin_entry/src/prefix.rs b/rust/tw_coin_entry/src/prefix.rs
index bbbc4d13bf6..059a8c57a8f 100644
--- a/rust/tw_coin_entry/src/prefix.rs
+++ b/rust/tw_coin_entry/src/prefix.rs
@@ -36,6 +36,17 @@ pub struct BitcoinBase58Prefix {
     pub p2sh: u8,
 }
 
+impl TryFrom<AddressPrefix> for BitcoinBase58Prefix {
+    type Error = AddressError;
+
+    fn try_from(value: AddressPrefix) -> Result<Self, Self::Error> {
+        match value {
+            AddressPrefix::BitcoinBase58(base58) => Ok(base58),
+            _ => Err(AddressError::UnexpectedAddressPrefix),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/rust/tw_coin_registry/Cargo.toml b/rust/tw_coin_registry/Cargo.toml
index b23f576ab7b..40e2a51b0ef 100644
--- a/rust/tw_coin_registry/Cargo.toml
+++ b/rust/tw_coin_registry/Cargo.toml
@@ -12,6 +12,7 @@ strum_macros = "0.25"
 tw_aptos = { path = "../chains/tw_aptos" }
 tw_binance = { path = "../chains/tw_binance" }
 tw_bitcoin = { path = "../chains/tw_bitcoin" }
+tw_bitcoincash = { path = "../chains/tw_bitcoincash" }
 tw_coin_entry = { path = "../tw_coin_entry" }
 tw_cosmos = { path = "../chains/tw_cosmos" }
 tw_ethereum = { path = "../chains/tw_ethereum" }
diff --git a/rust/tw_coin_registry/src/blockchain_type.rs b/rust/tw_coin_registry/src/blockchain_type.rs
index a91e4172813..93630d0d66d 100644
--- a/rust/tw_coin_registry/src/blockchain_type.rs
+++ b/rust/tw_coin_registry/src/blockchain_type.rs
@@ -12,6 +12,7 @@ pub enum BlockchainType {
     Aptos,
     Binance,
     Bitcoin,
+    BitcoinCash,
     Cosmos,
     Ethereum,
     Greenfield,
diff --git a/rust/tw_coin_registry/src/dispatcher.rs b/rust/tw_coin_registry/src/dispatcher.rs
index bda3fdba931..b7c3f7751b7 100644
--- a/rust/tw_coin_registry/src/dispatcher.rs
+++ b/rust/tw_coin_registry/src/dispatcher.rs
@@ -10,6 +10,7 @@ use crate::registry::get_coin_item;
 use tw_aptos::entry::AptosEntry;
 use tw_binance::entry::BinanceEntry;
 use tw_bitcoin::entry::BitcoinEntry;
+use tw_bitcoincash::entry::BitcoinCashEntry;
 use tw_coin_entry::coin_entry_ext::CoinEntryExt;
 use tw_cosmos::entry::CosmosEntry;
 use tw_ethereum::entry::EthereumEntry;
@@ -31,6 +32,7 @@ pub type EvmEntryExtStaticRef = &'static dyn EvmEntryExt;
 const APTOS: AptosEntry = AptosEntry;
 const BINANCE: BinanceEntry = BinanceEntry;
 const BITCOIN: BitcoinEntry = BitcoinEntry;
+const BITCOIN_CASH: BitcoinCashEntry = BitcoinCashEntry;
 const COSMOS: CosmosEntry = CosmosEntry;
 const ETHEREUM: EthereumEntry = EthereumEntry;
 const GREENFIELD: GreenfieldEntry = GreenfieldEntry;
@@ -50,6 +52,7 @@ pub fn blockchain_dispatcher(blockchain: BlockchainType) -> RegistryResult<CoinE
         BlockchainType::Aptos => Ok(&APTOS),
         BlockchainType::Binance => Ok(&BINANCE),
         BlockchainType::Bitcoin => Ok(&BITCOIN),
+        BlockchainType::BitcoinCash => Ok(&BITCOIN_CASH),
         BlockchainType::Cosmos => Ok(&COSMOS),
         BlockchainType::Ethereum => Ok(&ETHEREUM),
         BlockchainType::Greenfield => Ok(&GREENFIELD),
diff --git a/rust/tw_encoding/src/bech32.rs b/rust/tw_encoding/src/bech32.rs
index c0365763baa..97e184e5513 100644
--- a/rust/tw_encoding/src/bech32.rs
+++ b/rust/tw_encoding/src/bech32.rs
@@ -5,7 +5,7 @@
 use bech32::{FromBase32, ToBase32, Variant};
 use tw_memory::Data;
 
-pub use bech32::Error as Bech32Error;
+pub use bech32::{convert_bits, CheckBase32, Error as Bech32Error};
 
 pub type Bech32Result<T> = Result<T, Bech32Error>;
 
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 410761a2410..5b76d84eeb3 100644
--- a/rust/tw_tests/tests/chains/bitcoin/bitcoin_sign/p2pkh.rs
+++ b/rust/tw_tests/tests/chains/bitcoin/bitcoin_sign/p2pkh.rs
@@ -114,81 +114,3 @@ fn test_bitcoin_sign_input_p2pkh_public_key_hash() {
 fn test_bitcoin_sign_input_p2pkh_address() {
     test_bitcoin_sign_input_p2pkh(P2PKHClaimingScriptType::P2PKHAddress);
 }
-
-/// TODO consider moving this test to `bitcoin_cash`.
-/// Original test: https://github.com/trustwallet/wallet-core/blob/cd5a27481d2181e63362cb57e2b2160506cce163/tests/chains/BitcoinCash/TWBitcoinCashTests.cpp#L122-L164
-/// *Note* that if we enable change output, current selection algorithm will calculate
-/// different change and fee amounts than in the original test.
-#[test]
-fn test_bitcoin_cash_sign_input_p2pkh_custom_script() {
-    const BCH_SIGHASH_FORK: u32 = 0x40;
-
-    let alice_private_key = "7fdafb9db5bc501f2096e7d13d331dc7a75d9594af3d251313ba8b6200f4e384"
-        .decode_hex()
-        .unwrap();
-
-    // Create transaction with P2PKH as input and output.
-    let utxo_hash_1 = "050d00e2e18ef13969606f1ceee290d3f49bd940684ce39898159352952b8ce2";
-    let utxo_script_1 = "76a914aff1e0789e5fe316b729577665aa0a04d5b0f8c788ac"
-        .decode_hex()
-        .unwrap();
-    let utxo_1 = Proto::Input {
-        out_point: input::out_point(utxo_hash_1, 2),
-        value: 5151,
-        sighash_type: SIGHASH_ALL | BCH_SIGHASH_FORK,
-        claiming_script: input::custom_script(utxo_script_1),
-        ..Default::default()
-    };
-
-    let out_1 = Proto::Output {
-        value: 600,
-        to_recipient: output::to_address("1Bp9U1ogV3A14FMvKbRJms7ctyso4Z4Tcx"),
-    };
-    let explicit_change_out = Proto::Output {
-        value: 4325,
-        to_recipient: output::to_address("1FQc5LdgGHMHEN9nwkjmz6tWkxhPpxBvBU"),
-    };
-
-    let builder = Proto::TransactionBuilder {
-        version: Proto::TransactionVersion::V1,
-        inputs: vec![utxo_1],
-        outputs: vec![out_1, explicit_change_out],
-        change_output: None,
-        // No matter which selector to use.
-        input_selector: Proto::InputSelector::SelectInOrder,
-        dust_policy: dust_threshold(DUST),
-        ..Default::default()
-    };
-
-    let signing = Proto::SigningInput {
-        private_keys: vec![alice_private_key.into()],
-        chain_info: btc_info(),
-        transaction: TransactionOneof::builder(builder),
-        ..Default::default()
-    };
-
-    let expected_encoded = concat!(
-        "01000000",
-        "01",
-            "e28c2b955293159898e34c6840d99bf4d390e2ee1c6f606939f18ee1e2000d05", "02000000", "6b483045022100b70d158b43cbcded60e6977e93f9a84966bc0cec6f2dfd1463d1223a90563f0d02207548d081069de570a494d0967ba388ff02641d91cadb060587ead95a98d4e3534121038eab72ec78e639d02758e7860cdec018b49498c307791f785aa3019622f4ea5b", "ffffffff",
-        "02",
-            "5802000000000000", "1976a914769bdff96a02f9135a1d19b749db6a78fe07dc9088ac",
-            "e510000000000000", "1976a9149e089b6889e032d46e3b915a3392edfd616fb1c488ac",
-        "00000000"
-    );
-    // Successfully broadcasted:
-    // https://blockchair.com/bitcoin-cash/transaction/96ee20002b34e468f9d3c5ee54f6a8ddaa61c118889c4f35395c2cd93ba5bbb4
-    sign::BitcoinSignHelper::new(&signing)
-        .coin(CoinType::Bitcoin)
-        .sign(sign::Expected {
-            encoded: expected_encoded,
-            txid: "96ee20002b34e468f9d3c5ee54f6a8ddaa61c118889c4f35395c2cd93ba5bbb4",
-            inputs: vec![5151],
-            outputs: vec![600, 4325],
-            // `vsize` is different from the estimated value due to the signatures der serialization.
-            vsize: 226,
-            weight: 904,
-            // vsize
-            fee: 226,
-        });
-}
diff --git a/rust/tw_tests/tests/chains/bitcoincash/bitcoincash_address.rs b/rust/tw_tests/tests/chains/bitcoincash/bitcoincash_address.rs
new file mode 100644
index 00000000000..45dfce10f59
--- /dev/null
+++ b/rust/tw_tests/tests/chains/bitcoincash/bitcoincash_address.rs
@@ -0,0 +1,153 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use tw_any_coin::test_utils::address_utils::{
+    test_address_base58_is_valid, test_address_create_base58_with_public_key, test_address_derive,
+    test_address_get_data, test_address_invalid, test_address_normalization, test_address_valid,
+    AddressBase58IsValid, AddressCreateBase58WithPublicKey,
+};
+use tw_coin_registry::coin_type::CoinType;
+use tw_keypair::tw::PublicKeyType;
+
+#[test]
+fn test_bitcoincash_address_derive() {
+    test_address_derive(
+        CoinType::BitcoinCash,
+        "28071bf4e2b0340db41b807ed8a5514139e5d6427ff9d58dbd22b7ed187103a4",
+        "bitcoincash:qruxj7zq6yzpdx8dld0e9hfvt7u47zrw9gfr5hy0vh",
+    );
+}
+
+#[test]
+fn test_bitcoincash_address_normalization() {
+    test_address_normalization(
+        CoinType::BitcoinCash,
+        "BitCoinCash:QRPLWYX7KUEQKRH6DMD3FCLTA6U32HAFP5TNPKCHX2",
+        "bitcoincash:qrplwyx7kueqkrh6dmd3fclta6u32hafp5tnpkchx2",
+    );
+    // Already normalized.
+    test_address_normalization(
+        CoinType::BitcoinCash,
+        "bitcoincash:qruxj7zq6yzpdx8dld0e9hfvt7u47zrw9gfr5hy0vh",
+        "bitcoincash:qruxj7zq6yzpdx8dld0e9hfvt7u47zrw9gfr5hy0vh",
+    );
+    test_address_normalization(
+        CoinType::BitcoinCash,
+        "qqslmu0jxk4st3ldjyuazfpf5thd6vlgfuggqd3re4",
+        "bitcoincash:qqslmu0jxk4st3ldjyuazfpf5thd6vlgfuggqd3re4",
+    );
+    // Legacy address should be normalized as Legacy.
+    test_address_normalization(
+        CoinType::BitcoinCash,
+        "1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2",
+        "1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2",
+    );
+}
+
+#[test]
+fn test_bitcoincash_address_is_valid() {
+    test_address_valid(
+        CoinType::BitcoinCash,
+        "bitcoincash:qr6m7j9njldwwzlg9v7v53unlr4jkmx6eylep8ekg2",
+    );
+    test_address_valid(
+        CoinType::BitcoinCash,
+        "bitcoincash:qqa2qx0d8tegw32xk8u75ws055en4x3h2u0e6k46y4",
+    );
+    test_address_valid(
+        CoinType::BitcoinCash,
+        "bitcoincash:pqx578nanz2h2estzmkr53zqdg6qt8xyqvwhn6qeyc",
+    );
+    test_address_valid(
+        CoinType::BitcoinCash,
+        "pqx578nanz2h2estzmkr53zqdg6qt8xyqvwhn6qeyc",
+    );
+    test_address_valid(
+        CoinType::BitcoinCash,
+        "bitcoincash:qr6m7j9njldwwzlg9v7v53unlr4jkmx6eylep8ekg2",
+    );
+    test_address_valid(
+        CoinType::BitcoinCash,
+        "qq07l6rr5lsdm3m80qxw80ku2ex0tj76vvsxpvmgme",
+    );
+    test_address_valid(
+        CoinType::BitcoinCash,
+        "qqslmu0jxk4st3ldjyuazfpf5thd6vlgfuggqd3re4",
+    );
+    test_address_valid(CoinType::BitcoinCash, "1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2");
+}
+
+#[test]
+fn test_bitcoincash_address_is_valid_base58() {
+    // Litecoin P2PKH
+    test_address_base58_is_valid(AddressBase58IsValid {
+        coin: CoinType::BitcoinCash,
+        address: "LW6HjAU6GL9fK2LZWUA6VZCzomTdrpx3nr",
+        p2pkh: 48,
+        p2sh: 50,
+    });
+    // BitcoinCash P2SH
+    test_address_base58_is_valid(AddressBase58IsValid {
+        coin: CoinType::Bitcoin,
+        address: "35XRC5HRZjih1sML23UXv1Ry1SzTDKSmfQ",
+        p2pkh: 0,
+        p2sh: 5,
+    });
+}
+
+#[test]
+fn test_bitcoincash_address_invalid() {
+    // Wrong checksum
+    test_address_invalid(
+        CoinType::BitcoinCash,
+        "pqx578nanz2h2estzmkr53zqdg6qt8xyqvffffffff",
+    );
+    test_address_invalid(
+        CoinType::BitcoinCash,
+        "bitcoincash:pqx578nanz2h2estzmkr53zqdg6qt8xyqvffffffff",
+    );
+
+    // Valid eCash addresses are invalid for BCH
+    test_address_invalid(
+        CoinType::BitcoinCash,
+        "pqx578nanz2h2estzmkr53zqdg6qt8xyqvh683mrz0",
+    );
+    test_address_invalid(
+        CoinType::BitcoinCash,
+        "ecash:pqx578nanz2h2estzmkr53zqdg6qt8xyqvh683mrz0",
+    );
+
+    // Wrong prefix
+    test_address_invalid(
+        CoinType::BitcoinCash,
+        "bcash:pqx578nanz2h2estzmkr53zqdg6qt8xyqvwhn6qeyc",
+    );
+
+    // Wrong base 32 (characters o, i)
+    test_address_invalid(
+        CoinType::BitcoinCash,
+        "poi578nanz2h2estzmkr53zqdg6qt8xyqvwhn6qeyc",
+    );
+}
+
+#[test]
+fn test_bitcoincash_address_get_data() {
+    test_address_get_data(
+        CoinType::BitcoinCash,
+        "bitcoincash:qpk05r5kcd8uuzwqunn8rlx5xvuvzjqju5rch3tc0u",
+        "6cfa0e96c34fce09c0e4e671fcd43338c14812e5",
+    );
+}
+
+#[test]
+fn test_bitcoincash_address_create_base58_with_public_key() {
+    test_address_create_base58_with_public_key(AddressCreateBase58WithPublicKey {
+        coin: CoinType::BitcoinCash,
+        public_key: "03b49081a4d7ad24b20e209bc6fe10491aadb5607777baf0509a036cce96025db0",
+        public_key_type: PublicKeyType::Secp256k1,
+        p2pkh: 48,
+        p2sh: 50,
+        expected: "LW6HjAU6GL9fK2LZWUA6VZCzomTdrpx3nr",
+    });
+}
diff --git a/rust/tw_tests/tests/chains/bitcoincash/bitcoincash_compile.rs b/rust/tw_tests/tests/chains/bitcoincash/bitcoincash_compile.rs
new file mode 100644
index 00000000000..16a55185d3d
--- /dev/null
+++ b/rust/tw_tests/tests/chains/bitcoincash/bitcoincash_compile.rs
@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use crate::chains::bitcoincash::test_cases::transfer_96ee20;
+use crate::chains::common::bitcoin::{btc_info, compile, preimage, TransactionOneof};
+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_bitcoincash_compile() {
+    let private_key = ecdsa::secp256k1::PrivateKey::try_from(transfer_96ee20::PRIVATE_KEY).unwrap();
+    let public_key = private_key.public().compressed().to_vec();
+
+    let input = Proto::SigningInput {
+        public_keys: vec![public_key.clone().into()],
+        chain_info: btc_info(),
+        transaction: TransactionOneof::builder(transfer_96ee20::transaction_builder()),
+        ..Default::default()
+    };
+
+    let sighash_1 = transfer_96ee20::SIGHASH.decode_hex().unwrap();
+    preimage::BitcoinPreImageHelper::new(&input)
+        .coin(CoinType::BitcoinCash)
+        .add_expected_legacy(public_key.clone(), sighash_1.clone())
+        .pre_image();
+
+    let signature_1 = private_key
+        .sign(sighash_1.as_slice().try_into().unwrap())
+        .unwrap();
+    assert_eq!(signature_1.to_vec().to_hex(), transfer_96ee20::SIGNATURE);
+
+    compile::BitcoinCompileHelper::new(&input)
+        .coin(CoinType::BitcoinCash)
+        .add_pubkey_sig(public_key, signature_1.to_vec())
+        .compile(compile::Expected {
+            encoded: transfer_96ee20::ENCODED_TX,
+            txid: transfer_96ee20::TX_ID,
+            inputs: vec![5151],
+            outputs: vec![600, 4325],
+            vsize: 226,
+            weight: 904,
+            fee: 226,
+        });
+}
diff --git a/rust/tw_tests/tests/chains/bitcoincash/bitcoincash_sign.rs b/rust/tw_tests/tests/chains/bitcoincash/bitcoincash_sign.rs
new file mode 100644
index 00000000000..8802ca9963d
--- /dev/null
+++ b/rust/tw_tests/tests/chains/bitcoincash/bitcoincash_sign.rs
@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use crate::chains::bitcoincash::test_cases::transfer_96ee20;
+use crate::chains::common::bitcoin::{btc_info, sign, TransactionOneof};
+use tw_coin_registry::coin_type::CoinType;
+use tw_encoding::hex::DecodeHex;
+use tw_proto::BitcoinV2::Proto;
+
+/// Original test: https://github.com/trustwallet/wallet-core/blob/cd5a27481d2181e63362cb57e2b2160506cce163/tests/chains/BitcoinCash/TWBitcoinCashTests.cpp#L122-L164
+/// *Note* that if we enable change output, current selection algorithm will calculate
+/// different change and fee amounts than in the original test.
+#[test]
+fn test_bitcoincash_sign_input_p2pkh_from_to_address() {
+    let signing = Proto::SigningInput {
+        private_keys: vec![transfer_96ee20::PRIVATE_KEY.decode_hex().unwrap().into()],
+        chain_info: btc_info(),
+        transaction: TransactionOneof::builder(transfer_96ee20::transaction_builder()),
+        ..Default::default()
+    };
+
+    // Successfully broadcasted:
+    // https://blockchair.com/bitcoin-cash/transaction/96ee20002b34e468f9d3c5ee54f6a8ddaa61c118889c4f35395c2cd93ba5bbb4
+    sign::BitcoinSignHelper::new(&signing)
+        .coin(CoinType::BitcoinCash)
+        .sign(sign::Expected {
+            encoded: transfer_96ee20::ENCODED_TX,
+            txid: transfer_96ee20::TX_ID,
+            inputs: vec![5151],
+            outputs: vec![600, 4325],
+            // `vsize` is different from the estimated value due to the signatures der serialization.
+            vsize: 226,
+            weight: 904,
+            fee: 226,
+        });
+}
diff --git a/rust/tw_tests/tests/chains/bitcoincash/mod.rs b/rust/tw_tests/tests/chains/bitcoincash/mod.rs
new file mode 100644
index 00000000000..7e2ebc4aa6b
--- /dev/null
+++ b/rust/tw_tests/tests/chains/bitcoincash/mod.rs
@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+mod bitcoincash_address;
+mod bitcoincash_compile;
+mod bitcoincash_sign;
+mod test_cases;
+
+pub const BCH_SIGHASH_FORK: u32 = 0x40;
diff --git a/rust/tw_tests/tests/chains/bitcoincash/test_cases.rs b/rust/tw_tests/tests/chains/bitcoincash/test_cases.rs
new file mode 100644
index 00000000000..3fe081a5c60
--- /dev/null
+++ b/rust/tw_tests/tests/chains/bitcoincash/test_cases.rs
@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use crate::chains::bitcoincash::BCH_SIGHASH_FORK;
+use crate::chains::common::bitcoin::{dust_threshold, input, output, DUST, SIGHASH_ALL};
+use tw_proto::BitcoinV2::Proto;
+
+/// Successfully broadcasted:
+/// https://blockchair.com/bitcoin-cash/transaction/96ee20002b34e468f9d3c5ee54f6a8ddaa61c118889c4f35395c2cd93ba5bbb4
+pub(super) mod transfer_96ee20 {
+    use super::*;
+
+    pub const PRIVATE_KEY: &str =
+        "7fdafb9db5bc501f2096e7d13d331dc7a75d9594af3d251313ba8b6200f4e384";
+    pub const ENCODED_TX: &str = concat!(
+        "01000000",
+        "01",
+            "e28c2b955293159898e34c6840d99bf4d390e2ee1c6f606939f18ee1e2000d05", "02000000", "6b483045022100b70d158b43cbcded60e6977e93f9a84966bc0cec6f2dfd1463d1223a90563f0d02207548d081069de570a494d0967ba388ff02641d91cadb060587ead95a98d4e3534121038eab72ec78e639d02758e7860cdec018b49498c307791f785aa3019622f4ea5b", "ffffffff",
+        "02",
+            "5802000000000000", "1976a914769bdff96a02f9135a1d19b749db6a78fe07dc9088ac",
+            "e510000000000000", "1976a9149e089b6889e032d46e3b915a3392edfd616fb1c488ac",
+        "00000000"
+    );
+    pub const SIGHASH: &str = "1136d4975aee4ff6ccf0b8a9c640532f563b48d9856fdc9682c37a071702937c";
+    pub const SIGNATURE: &str = "b70d158b43cbcded60e6977e93f9a84966bc0cec6f2dfd1463d1223a90563f0d7548d081069de570a494d0967ba388ff02641d91cadb060587ead95a98d4e35301";
+    pub const TX_ID: &str = "96ee20002b34e468f9d3c5ee54f6a8ddaa61c118889c4f35395c2cd93ba5bbb4";
+
+    pub fn transaction_builder() -> Proto::TransactionBuilder<'static> {
+        // Create transaction with P2PKH as input and output.
+        let utxo_hash_1 = "050d00e2e18ef13969606f1ceee290d3f49bd940684ce39898159352952b8ce2";
+        let utxo_1 = Proto::Input {
+            out_point: input::out_point(utxo_hash_1, 2),
+            value: 5151,
+            sighash_type: SIGHASH_ALL | BCH_SIGHASH_FORK,
+            // Cash address without prefix.
+            claiming_script: input::receiver_address("qzhlrcrcne07x94h99thved2pgzdtv8ccujjy73xya"),
+            ..Default::default()
+        };
+
+        let out_1 = Proto::Output {
+            value: 600,
+            // Legacy address.
+            to_recipient: output::to_address("1Bp9U1ogV3A14FMvKbRJms7ctyso4Z4Tcx"),
+        };
+        let explicit_change_out = Proto::Output {
+            value: 4325,
+            // Cash address with an explicit prefix.
+            to_recipient: output::to_address(
+                "bitcoincash:qz0q3xmg38sr94rw8wg45vujah7kzma3cskxymnw06",
+            ),
+        };
+
+        Proto::TransactionBuilder {
+            version: Proto::TransactionVersion::V1,
+            inputs: vec![utxo_1],
+            outputs: vec![out_1, explicit_change_out],
+            change_output: None,
+            // No matter which selector to use.
+            input_selector: Proto::InputSelector::SelectInOrder,
+            dust_policy: dust_threshold(DUST),
+            ..Default::default()
+        }
+    }
+}
diff --git a/rust/tw_tests/tests/chains/ecash/ecash_address.rs b/rust/tw_tests/tests/chains/ecash/ecash_address.rs
new file mode 100644
index 00000000000..f78cc75a1f5
--- /dev/null
+++ b/rust/tw_tests/tests/chains/ecash/ecash_address.rs
@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use tw_any_coin::test_utils::address_utils::{
+    test_address_invalid, test_address_normalization, test_address_valid,
+};
+use tw_coin_registry::coin_type::CoinType;
+
+#[test]
+fn test_bitcoincash_address_normalization() {
+    test_address_normalization(
+        CoinType::eCash,
+        "pqx578nanz2h2estzmkr53zqdg6qt8xyqvh683mrz0",
+        "ecash:pqx578nanz2h2estzmkr53zqdg6qt8xyqvh683mrz0",
+    );
+}
+
+#[test]
+fn test_bitcoincash_address_is_valid() {
+    test_address_valid(
+        CoinType::eCash,
+        "pqx578nanz2h2estzmkr53zqdg6qt8xyqvh683mrz0",
+    );
+    test_address_valid(
+        CoinType::eCash,
+        "ecash:qqra3amvnyyhrltyn5h97klwe68cuw3sfcgry9hl9k",
+    );
+}
+
+#[test]
+fn test_bitcoincash_address_invalid() {
+    // Wrong checksum
+    test_address_invalid(
+        CoinType::eCash,
+        "pqx578nanz2h2estzmkr53zqdg6qt8xyqvffffffff",
+    );
+    test_address_invalid(
+        CoinType::eCash,
+        "ecash:pqx578nanz2h2estzmkr53zqdg6qt8xyqvffffffff",
+    );
+
+    // Valid BCH addresses are invalid for eCash
+    test_address_invalid(
+        CoinType::eCash,
+        "pqx578nanz2h2estzmkr53zqdg6qt8xyqvwhn6qeyc",
+    );
+    test_address_invalid(
+        CoinType::eCash,
+        "bitcoincash:pqx578nanz2h2estzmkr53zqdg6qt8xyqvwhn6qeyc",
+    );
+
+    // Wrong prefix
+    test_address_invalid(
+        CoinType::eCash,
+        "fcash:pqx578nanz2h2estzmkr53zqdg6qt8xyqvh683mrz0",
+    );
+
+    // Wrong base 32 (characters o, i)
+    test_address_invalid(
+        CoinType::eCash,
+        "poi578nanz2h2estzmkr53zqdg6qt8xyqvwhn6qeyc",
+    );
+}
diff --git a/rust/tw_tests/tests/chains/ecash/ecash_sign.rs b/rust/tw_tests/tests/chains/ecash/ecash_sign.rs
new file mode 100644
index 00000000000..f3607dc337b
--- /dev/null
+++ b/rust/tw_tests/tests/chains/ecash/ecash_sign.rs
@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use crate::chains::bitcoincash::BCH_SIGHASH_FORK;
+use crate::chains::common::bitcoin::{
+    btc_info, dust_threshold, input, output, sign, TransactionOneof, DUST, SIGHASH_ALL,
+};
+use tw_coin_registry::coin_type::CoinType;
+use tw_encoding::hex::DecodeHex;
+use tw_proto::BitcoinV2::Proto;
+
+#[test]
+fn test_ecash_sign_input_p2pkh_from_to_address() {
+    let private_key = "7fdafb9db5bc501f2096e7d13d331dc7a75d9594af3d251313ba8b6200f4e384"
+        .decode_hex()
+        .unwrap();
+
+    // Create transaction with P2PKH as input and output.
+    let utxo_hash_1 = "050d00e2e18ef13969606f1ceee290d3f49bd940684ce39898159352952b8ce2";
+    let utxo_1 = Proto::Input {
+        out_point: input::out_point(utxo_hash_1, 2),
+        value: 5151,
+        sighash_type: SIGHASH_ALL | BCH_SIGHASH_FORK,
+        // Cash address without prefix.
+        claiming_script: input::receiver_address("qzhlrcrcne07x94h99thved2pgzdtv8ccujjy73xya"),
+        ..Default::default()
+    };
+
+    let out_1 = Proto::Output {
+        value: 600,
+        // Cash address with an explicit prefix.
+        to_recipient: output::to_address("ecash:qpmfhhledgp0jy66r5vmwjwmdfu0up7ujqpvm4v8rm"),
+    };
+    let explicit_change_out = Proto::Output {
+        value: 4325,
+        // Cash address without the prefix.
+        to_recipient: output::to_address("qz0q3xmg38sr94rw8wg45vujah7kzma3cs0tssg5fd"),
+    };
+
+    let builder = Proto::TransactionBuilder {
+        version: Proto::TransactionVersion::V1,
+        inputs: vec![utxo_1],
+        outputs: vec![out_1, explicit_change_out],
+        change_output: None,
+        // No matter which selector to use.
+        input_selector: Proto::InputSelector::SelectInOrder,
+        dust_policy: dust_threshold(DUST),
+        ..Default::default()
+    };
+
+    let input = Proto::SigningInput {
+        private_keys: vec![private_key.into()],
+        chain_info: btc_info(),
+        transaction: TransactionOneof::builder(builder),
+        ..Default::default()
+    };
+
+    // Successfully broadcasted:
+    // https://blockchair.com/ecash/transaction/96ee20002b34e468f9d3c5ee54f6a8ddaa61c118889c4f35395c2cd93ba5bbb4
+    sign::BitcoinSignHelper::new(&input)
+        .coin(CoinType::BitcoinCash)
+        .sign(sign::Expected {
+            encoded: "0100000001e28c2b955293159898e34c6840d99bf4d390e2ee1c6f606939f18ee1e2000d05020000006b483045022100b70d158b43cbcded60e6977e93f9a84966bc0cec6f2dfd1463d1223a90563f0d02207548d081069de570a494d0967ba388ff02641d91cadb060587ead95a98d4e3534121038eab72ec78e639d02758e7860cdec018b49498c307791f785aa3019622f4ea5bffffffff0258020000000000001976a914769bdff96a02f9135a1d19b749db6a78fe07dc9088ace5100000000000001976a9149e089b6889e032d46e3b915a3392edfd616fb1c488ac00000000",
+            txid: "96ee20002b34e468f9d3c5ee54f6a8ddaa61c118889c4f35395c2cd93ba5bbb4",
+            inputs: vec![5151],
+            outputs: vec![600, 4325],
+            vsize: 226,
+            weight: 904,
+            fee: 226,
+        });
+}
diff --git a/rust/tw_tests/tests/chains/ecash/mod.rs b/rust/tw_tests/tests/chains/ecash/mod.rs
new file mode 100644
index 00000000000..fc959a82f8c
--- /dev/null
+++ b/rust/tw_tests/tests/chains/ecash/mod.rs
@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+mod ecash_address;
+mod ecash_sign;
diff --git a/rust/tw_tests/tests/chains/mod.rs b/rust/tw_tests/tests/chains/mod.rs
index 0f587a6d26a..b147a7b83e5 100644
--- a/rust/tw_tests/tests/chains/mod.rs
+++ b/rust/tw_tests/tests/chains/mod.rs
@@ -5,9 +5,11 @@
 mod aptos;
 mod binance;
 mod bitcoin;
+mod bitcoincash;
 mod common;
 mod cosmos;
 mod dydx;
+mod ecash;
 mod ethereum;
 mod greenfield;
 mod internet_computer;
diff --git a/rust/tw_tests/tests/coin_address_derivation_test.rs b/rust/tw_tests/tests/coin_address_derivation_test.rs
index c0b66f78a96..bb6c14842e3 100644
--- a/rust/tw_tests/tests/coin_address_derivation_test.rs
+++ b/rust/tw_tests/tests/coin_address_derivation_test.rs
@@ -103,12 +103,10 @@ fn test_coin_address_derivation() {
             CoinType::Syscoin => "sys1qten42eesehw0ktddcp0fws7d3ycsqez3pwuwme",
             CoinType::Pivx => "DDkFr311AYe6ABMsdSnjv8yoSr1Tppokp8",
             CoinType::Firo => "a9Kd3gVz5vjegicNuG7K8f8iB5QWkUuTxW",
-            // TODO should be "bitcoincash:qp0xw4t8xrxae7ed4hq9a96rekynzqry2ydzeh0jgs"
-            CoinType::BitcoinCash => "19cAJn4Ms8jodBBGtroBNNpCZiHAWGAq7X",
+            CoinType::BitcoinCash => "bitcoincash:qp0xw4t8xrxae7ed4hq9a96rekynzqry2ydzeh0jgs",
             CoinType::BitcoinGold => "btg1qten42eesehw0ktddcp0fws7d3ycsqez3lht33r",
             CoinType::Ravencoin => "RHtMPHweTxYNhBYUN2nJTu9QKyjm7MRKsF",
-            // TODO should be "ecash:qp0xw4t8xrxae7ed4hq9a96rekynzqry2y50du5gw8"
-            CoinType::eCash => "19cAJn4Ms8jodBBGtroBNNpCZiHAWGAq7X",
+            CoinType::eCash => "ecash:qp0xw4t8xrxae7ed4hq9a96rekynzqry2y50du5gw8",
             CoinType::Qtum => "QVD9R5M53bcd4KGJKC7fVebq4yDsnEDwtt",
             CoinType::Stratis => "strax1qten42eesehw0ktddcp0fws7d3ycsqez39n8kr5",
             CoinType::Aptos => "0x9006fa46f038224e8004bdda97f2e7a60c2c3d135bce7cb15541e5c0aae907a4",
diff --git a/src/Bitcoin/Entry.h b/src/Bitcoin/Entry.h
index 9d2c8503097..d4ea8e4f619 100644
--- a/src/Bitcoin/Entry.h
+++ b/src/Bitcoin/Entry.h
@@ -11,18 +11,18 @@ namespace TW::Bitcoin {
 /// Bitcoin entry dispatcher.
 /// Note: do not put the implementation here (no matter how simple), to avoid having coin-specific
 /// includes in this file
-class Entry final : public CoinEntry {
+class Entry : public CoinEntry {
 public:
-    bool validateAddress(TWCoinType coin, const std::string& address, const PrefixVariant& addressPrefix) const;
-    std::string normalizeAddress(TWCoinType coin, const std::string& address) const;
-    std::string deriveAddress(TWCoinType coin, const PublicKey& publicKey, TWDerivation derivation, const PrefixVariant& addressPrefix) const;
-    Data addressToData(TWCoinType coin, const std::string& address) const;
-    void sign(TWCoinType coin, const Data& dataIn, Data& dataOut) const;
-    void plan(TWCoinType coin, const Data& dataIn, Data& dataOut) const;
+    bool validateAddress(TWCoinType coin, const std::string& address, const PrefixVariant& addressPrefix) const final;
+    std::string normalizeAddress(TWCoinType coin, const std::string& address) const final;
+    std::string deriveAddress(TWCoinType coin, const PublicKey& publicKey, TWDerivation derivation, const PrefixVariant& addressPrefix) const final;
+    Data addressToData(TWCoinType coin, const std::string& address) const final;
+    void sign(TWCoinType coin, const Data& dataIn, Data& dataOut) const final;
+    void plan(TWCoinType coin, const Data& dataIn, Data& dataOut) const final;
 
-    Data preImageHashes(TWCoinType coin, const Data& txInputData) const;
+    Data preImageHashes(TWCoinType coin, const Data& txInputData) const final;
     void compile(TWCoinType coin, const Data& txInputData, const std::vector<Data>& signatures,
-                 const std::vector<PublicKey>& publicKeys, Data& dataOut) const;
+                 const std::vector<PublicKey>& publicKeys, Data& dataOut) const final;
     // Note: buildTransactionInput is not implemented for Binance chain with UTXOs
 };
 
diff --git a/src/BitcoinCash/Entry.h b/src/BitcoinCash/Entry.h
new file mode 100644
index 00000000000..cc5e78fe61b
--- /dev/null
+++ b/src/BitcoinCash/Entry.h
@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+#pragma once
+
+#include "Bitcoin/Entry.h"
+
+namespace TW::BitcoinCash {
+
+/// Entry point for BitcoinCash coin.
+/// Note: do not put the implementation here (no matter how simple), to avoid having coin-specific includes in this file
+///
+/// Currently, we must support the legacy `Bitcoin.proto` API,
+/// but `BitcoinV2.proto` still can be used through `Bitcoin.SigningInput.signing_v2`.
+/// TODO inherit Rust::RustCoinEntry directly when `Bitcoin.proto` is deprecated.
+class Entry : public Bitcoin::Entry {
+};
+
+} // namespace TW::BitcoinCash
+
diff --git a/src/Coin.cpp b/src/Coin.cpp
index 6033666b9ef..bb3d3717d54 100644
--- a/src/Coin.cpp
+++ b/src/Coin.cpp
@@ -66,6 +66,7 @@
 #include "InternetComputer/Entry.h"
 #include "NativeEvmos/Entry.h"
 #include "NativeInjective/Entry.h"
+#include "BitcoinCash/Entry.h"
 // end_of_coin_includes_marker_do_not_modify
 
 using namespace TW;
@@ -125,6 +126,7 @@ Greenfield::Entry GreenfieldDP;
 InternetComputer::Entry InternetComputerDP;
 NativeEvmos::Entry NativeEvmosDP;
 NativeInjective::Entry NativeInjectiveDP;
+BitcoinCash::Entry BitcoinCashDP;
 // end_of_coin_dipatcher_declarations_marker_do_not_modify
 
 CoinEntry* coinDispatcher(TWCoinType coinType) {
@@ -186,6 +188,7 @@ CoinEntry* coinDispatcher(TWCoinType coinType) {
         case TWBlockchainInternetComputer: entry = &InternetComputerDP; break;
         case TWBlockchainNativeEvmos: entry = &NativeEvmosDP; break;
         case TWBlockchainNativeInjective: entry = &NativeInjectiveDP; break;
+        case TWBlockchainBitcoinCash: entry = &BitcoinCashDP; break;
         // end_of_coin_dipatcher_switch_marker_do_not_modify
 
         default: entry = nullptr; break;
diff --git a/tests/chains/BitcoinCash/TWCoinTypeTests.cpp b/tests/chains/BitcoinCash/TWCoinTypeTests.cpp
index e86daa42bb1..20e12d01de1 100644
--- a/tests/chains/BitcoinCash/TWCoinTypeTests.cpp
+++ b/tests/chains/BitcoinCash/TWCoinTypeTests.cpp
@@ -21,7 +21,7 @@ TEST(TWBitcoinCashCoinType, TWCoinType) {
     auto name = WRAPS(TWCoinTypeConfigurationGetName(TWCoinTypeBitcoinCash));
 
     ASSERT_EQ(TWCoinTypeConfigurationGetDecimals(TWCoinTypeBitcoinCash), 8);
-    ASSERT_EQ(TWBlockchainBitcoin, TWCoinTypeBlockchain(TWCoinTypeBitcoinCash));
+    ASSERT_EQ(TWBlockchainBitcoinCash, TWCoinTypeBlockchain(TWCoinTypeBitcoinCash));
     ASSERT_EQ(0x5, TWCoinTypeP2shPrefix(TWCoinTypeBitcoinCash));
     ASSERT_EQ(0x0, TWCoinTypeStaticPrefix(TWCoinTypeBitcoinCash));
     assertStringsEqual(symbol, "BCH");
diff --git a/tests/chains/ECash/TWCoinTypeTests.cpp b/tests/chains/ECash/TWCoinTypeTests.cpp
index f6487e721d9..96928e1828e 100644
--- a/tests/chains/ECash/TWCoinTypeTests.cpp
+++ b/tests/chains/ECash/TWCoinTypeTests.cpp
@@ -21,7 +21,7 @@ TEST(TWECashCoinType, TWCoinType) {
     auto name = WRAPS(TWCoinTypeConfigurationGetName(TWCoinTypeECash));
 
     ASSERT_EQ(TWCoinTypeConfigurationGetDecimals(TWCoinTypeECash), 2);
-    ASSERT_EQ(TWBlockchainBitcoin, TWCoinTypeBlockchain(TWCoinTypeECash));
+    ASSERT_EQ(TWBlockchainBitcoinCash, TWCoinTypeBlockchain(TWCoinTypeECash));
     ASSERT_EQ(0x5, TWCoinTypeP2shPrefix(TWCoinTypeECash));
     ASSERT_EQ(0x0, TWCoinTypeStaticPrefix(TWCoinTypeECash));
     assertStringsEqual(symbol, "XEC");