diff --git a/.github/workflows/codegen-v2.yml b/.github/workflows/codegen-v2.yml
index 504467782405..8438d788d56c 100644
--- a/.github/workflows/codegen-v2.yml
+++ b/.github/workflows/codegen-v2.yml
@@ -12,7 +12,7 @@ env:
 
 jobs:
   test:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     if: github.event.pull_request.draft == false
     steps:
       - uses: actions/checkout@v3
diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml
index db3513b2a175..336faa4ce81b 100644
--- a/.github/workflows/docker.yml
+++ b/.github/workflows/docker.yml
@@ -11,7 +11,7 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v3
       - name: Lint Dockerfile
diff --git a/.github/workflows/linux-ci-rust.yml b/.github/workflows/linux-ci-rust.yml
index 36d3e57931a4..7e0889e824af 100644
--- a/.github/workflows/linux-ci-rust.yml
+++ b/.github/workflows/linux-ci-rust.yml
@@ -20,7 +20,7 @@ jobs:
     permissions:
       contents: read
       checks: write
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     if: github.event.pull_request.draft == false
     steps:
       - uses: actions/checkout@v3
@@ -61,7 +61,7 @@ jobs:
 
   # Run Rust tests in WASM.
   test-wasm:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     if: github.event.pull_request.draft == false
     steps:
       - uses: actions/checkout@v3
diff --git a/.github/workflows/linux-ci-sonarcloud.yml b/.github/workflows/linux-ci-sonarcloud.yml
index 775486d741af..83fa3b4f2163 100644
--- a/.github/workflows/linux-ci-sonarcloud.yml
+++ b/.github/workflows/linux-ci-sonarcloud.yml
@@ -13,7 +13,7 @@ concurrency:
 jobs:
   build:
     if: github.event.pull_request.draft == false && github.event.pull_request.head.repo.fork == false
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v3
 
diff --git a/.github/workflows/linux-ci.yml b/.github/workflows/linux-ci.yml
index 653fbf0c135a..1062e02dacb7 100644
--- a/.github/workflows/linux-ci.yml
+++ b/.github/workflows/linux-ci.yml
@@ -12,13 +12,13 @@ concurrency:
 
 jobs:
   build:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     if: github.event.pull_request.draft == false
     steps:
     - uses: actions/checkout@v3
     - name: Install system dependencies
       run: |
-        tools/install-sys-dependencies-linux ci
+        tools/install-sys-dependencies-linux
         tools/install-rust-dependencies
     - name: Cache internal dependencies
       id: internal_cache
diff --git a/.github/workflows/linux-sampleapp-ci.yml b/.github/workflows/linux-sampleapp-ci.yml
index da1aa11656bc..a8c0dbe15da1 100644
--- a/.github/workflows/linux-sampleapp-ci.yml
+++ b/.github/workflows/linux-sampleapp-ci.yml
@@ -12,13 +12,13 @@ concurrency:
 
 jobs:
   build:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     if: github.event.pull_request.draft == false
     steps:
     - uses: actions/checkout@v3
     - name: Install system dependencies
       run: |
-        tools/install-sys-dependencies-linux ci
+        tools/install-sys-dependencies-linux
         tools/install-rust-dependencies
     - name: Cache internal dependencies
       id: internal_cache
@@ -61,13 +61,6 @@ jobs:
       env:
         CC: /usr/bin/clang
         CXX: /usr/bin/clang++
-    - name: Build, run, and test devconsole.ts
-      run: |
-        cd samples/typescript/devconsole.ts
-        npm install
-        npm run build
-        echo -e "help() \n .exit" | npm run start
-        npm run test
     - name: Install Go
       env:
         GO_VERSION: 1.19
diff --git a/.github/workflows/wasm-ci.yml b/.github/workflows/wasm-ci.yml
index da063d565bee..d68b0dcb39db 100644
--- a/.github/workflows/wasm-ci.yml
+++ b/.github/workflows/wasm-ci.yml
@@ -12,7 +12,7 @@ concurrency:
 
 jobs:
   build:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     if: github.event.pull_request.draft == false
     steps:
     - uses: actions/checkout@v3
diff --git a/Package.swift b/Package.swift
index 38e74510f2ff..7e933efe93dc 100644
--- a/Package.swift
+++ b/Package.swift
@@ -12,13 +12,13 @@ let package = Package(
     targets: [
         .binaryTarget(
             name: "WalletCore",
-            url: "https://github.com/trustwallet/wallet-core/releases/download/4.0.33/WalletCore.xcframework.zip",
-            checksum: "2fb8b833047b9697bba6ade66a9bdeede622b2fe0fb7a9b90cb9edb4651ec866"
+            url: "https://github.com/trustwallet/wallet-core/releases/download/4.1.12/WalletCore.xcframework.zip",
+            checksum: "1632bbbab1c6a588689eec77a24e1468d9a6746968652cf0a7e669e996c3d24d"
         ),
         .binaryTarget(
             name: "SwiftProtobuf",
-            url: "https://github.com/trustwallet/wallet-core/releases/download/4.0.33/SwiftProtobuf.xcframework.zip",
-            checksum: "05557735dd607c5a369dc378eb3f299504b880614ef13f136a028ecd320b0e4d"
+            url: "https://github.com/trustwallet/wallet-core/releases/download/4.1.12/SwiftProtobuf.xcframework.zip",
+            checksum: "33d80c20428c9db4fcf99d1272ba19655f7c6ee7e5b1809fa8a7e7d4aa1b222b"
         )
     ]
 )
diff --git a/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/CoinAddressDerivationTests.kt b/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/CoinAddressDerivationTests.kt
index 9064a873e7c7..f99db4e987c2 100644
--- a/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/CoinAddressDerivationTests.kt
+++ b/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/CoinAddressDerivationTests.kt
@@ -154,5 +154,6 @@ class CoinAddressDerivationTests {
         TIA -> assertEquals("celestia142j9u5eaduzd7faumygud6ruhdwme98qpwmfv7", address)
         NATIVEZETACHAIN -> assertEquals("zeta13u6g7vqgw074mgmf2ze2cadzvkz9snlwywj304", address)
         DYDX -> assertEquals("dydx142j9u5eaduzd7faumygud6ruhdwme98qeayaky", address)
+        PACTUS -> assertEquals("pc1r7ys2g5a4xc2qtm0t4q987m4mvs57w5g0v4pvzg", address)
     }
 }
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 000000000000..2c826c0bd4f4
--- /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/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/pactus/TestPactusAddress.kt b/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/pactus/TestPactusAddress.kt
new file mode 100644
index 000000000000..b58b068b8590
--- /dev/null
+++ b/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/pactus/TestPactusAddress.kt
@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+package com.trustwallet.core.app.blockchains.pactus
+
+import com.trustwallet.core.app.utils.toHex
+import com.trustwallet.core.app.utils.toHexByteArray
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import wallet.core.jni.*
+
+class TestPactusAddress {
+
+    init {
+        System.loadLibrary("TrustWalletCore")
+    }
+
+    @Test
+    fun testAddress() {
+        val key = PrivateKey("4e51f1f3721f644ac7a193be7f5e7b8c2abaa3467871daf4eacb5d3af080e5d6".toHexByteArray())
+        val pubkey = key.publicKeyEd25519
+        val address = AnyAddress(pubkey, CoinType.PACTUS)
+        val expected = AnyAddress("pc1rwzvr8rstdqypr80ag3t6hqrtnss9nwymcxy3lr", CoinType.PACTUS)
+
+        assertEquals(pubkey.data().toHex(), "0x95794161374b22c696dabb98e93f6ca9300b22f3b904921fbf560bb72145f4fa")
+        assertEquals(address.description(), expected.description())
+    }
+}
diff --git a/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/pactus/TestPactusSigner.kt b/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/pactus/TestPactusSigner.kt
new file mode 100644
index 000000000000..2cbaaf9635e0
--- /dev/null
+++ b/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/pactus/TestPactusSigner.kt
@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+package com.trustwallet.core.app.blockchains.pactus
+
+import com.google.protobuf.ByteString
+import com.trustwallet.core.app.utils.toHexByteArray
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import wallet.core.jni.PrivateKey
+import wallet.core.java.AnySigner
+import wallet.core.jni.CoinType
+import wallet.core.jni.CoinType.PACTUS
+import wallet.core.jni.proto.Pactus
+import wallet.core.jni.proto.Pactus.SigningOutput
+import com.trustwallet.core.app.utils.Numeric
+import org.junit.Assert.assertArrayEquals
+
+class TestPactusSigner {
+
+    init {
+        System.loadLibrary("TrustWalletCore")
+    }
+
+    @Test
+    fun testPactusTransactionSigning() {
+        val signingInput = Pactus.SigningInput.newBuilder()
+        signingInput.apply {
+            privateKey = ByteString.copyFrom(PrivateKey("4e51f1f3721f644ac7a193be7f5e7b8c2abaa3467871daf4eacb5d3af080e5d6".toHexByteArray()).data())
+            transaction = Pactus.TransactionMessage.newBuilder().apply {
+                lockTime = 0x00030201
+                fee = 1000
+                memo = "test"
+                transfer = Pactus.TransferPayload.newBuilder().apply {
+                    sender = "pc1rwzvr8rstdqypr80ag3t6hqrtnss9nwymcxy3lr"
+                    receiver = "pc1r0g22ufzn8qtw0742dmfglnw73e260hep0k3yra"
+                    amount = 20000
+                }.build()
+            }.build()
+        }
+
+        val output = AnySigner.sign(signingInput.build(), PACTUS, SigningOutput.parser())
+
+        assertEquals(
+            "0x34cd4656a98f7eb996e83efdc384cefbe3a9c52dca79a99245b4eacc0b0b4311",
+            Numeric.toHexString(output.transactionId.toByteArray())
+        )
+
+        assertEquals(
+            "0x50ac25c7125271489b0cd230549257c93fb8c6265f2914a988ba7b81c1bc47fff027412dd59447867911035ff69742d171060a1f132ac38b95acc6e39ec0bd09",
+            Numeric.toHexString(output.signature.toByteArray())
+        )
+
+        assertEquals(
+            "0x000101020300e807047465737401037098338e0b6808119dfd4457ab806b9c2059b89b037a14ae24533816e7faaa6ed28fcdde8e55a7df21a09c0150ac25c7125271489b0cd230549257c93fb8c6265f2914a988ba7b81c1bc47fff027412dd59447867911035ff69742d171060a1f132ac38b95acc6e39ec0bd0995794161374b22c696dabb98e93f6ca9300b22f3b904921fbf560bb72145f4fa",
+            Numeric.toHexString(output.signedTransactionData.toByteArray())
+        )
+    }
+}
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 9b1194bbb688..e26b696fa59d 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/codegen/lib/code_generator.rb b/codegen/lib/code_generator.rb
index 087a75b34c2f..d1fcf3881afd 100644
--- a/codegen/lib/code_generator.rb
+++ b/codegen/lib/code_generator.rb
@@ -136,7 +136,7 @@ def render_kotlin_jni_c
   def render(file, locals = {})
     @locals = locals
     path = File.expand_path(file, File.join(File.dirname(__FILE__), 'templates'))
-    template = ERB.new(File.read(path), nil, '-')
+    template = ERB.new(File.read(path), trim_mode: '-')
     template.result(binding)
   end
 
diff --git a/docs/registry.md b/docs/registry.md
index 7606e14a45bd..a5045889d198 100644
--- a/docs/registry.md
+++ b/docs/registry.md
@@ -99,6 +99,7 @@ This list is generated from [./registry.json](../registry.json)
 | 14001   | WAX              | WAXP   | <img src="https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/wax/info/logo.png" width="32" />          | <http://wax.io>               |
 | 18000   | Meter            | MTR    | <img src="https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/meter/info/logo.png" width="32" />        | <https://meter.io/>           |
 | 19167   | Flux             | FLUX   | <img src="https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/zelcash/info/logo.png" width="32" />      | <https://runonflux.io>        |
+| 21888   | Pactus           | PAC    | <img src="https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/pactus/info/logo.png" width="32" />       | <https://pactus.org>          |
 | 52752   | Celo             | CELO   | <img src="https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/celo/info/logo.png" width="32" />         | <https://celo.org>            |
 | 59144   | Linea            | ETH    | <img src="https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/linea/info/logo.png" width="32" />        | <https://linea.build>         |
 | 81457   | Blast            | ETH    | <img src="https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/blast/info/logo.png" width="32" />        | <https://blast.io>            |
diff --git a/include/TrustWalletCore/TWBlockchain.h b/include/TrustWalletCore/TWBlockchain.h
index faf4c575c1b1..eeb2f7444746 100644
--- a/include/TrustWalletCore/TWBlockchain.h
+++ b/include/TrustWalletCore/TWBlockchain.h
@@ -65,6 +65,8 @@ enum TWBlockchain {
     TWBlockchainInternetComputer = 52,
     TWBlockchainNativeEvmos = 53, // Cosmos
     TWBlockchainNativeInjective = 54, // Cosmos
+    TWBlockchainBitcoinCash = 55,
+    TWBlockchainPactus = 56,
 };
 
 TW_EXTERN_C_END
diff --git a/include/TrustWalletCore/TWCoinType.h b/include/TrustWalletCore/TWCoinType.h
index 388bd270334e..9d2f10e36c93 100644
--- a/include/TrustWalletCore/TWCoinType.h
+++ b/include/TrustWalletCore/TWCoinType.h
@@ -186,6 +186,7 @@ enum TWCoinType {
     TWCoinTypeBlast = 81457,
     TWCoinTypeBounceBit = 6001,
     TWCoinTypeZkLinkNova = 810180,
+    TWCoinTypePactus = 21888,
     // end_of_tw_coin_type_marker_do_not_modify
 };
 
diff --git a/kotlin/wallet-core-kotlin/src/commonTest/kotlin/com/trustwallet/core/test/CoinAddressDerivationTests.kt b/kotlin/wallet-core-kotlin/src/commonTest/kotlin/com/trustwallet/core/test/CoinAddressDerivationTests.kt
index c3d3dbf05270..959fd4821eb0 100644
--- a/kotlin/wallet-core-kotlin/src/commonTest/kotlin/com/trustwallet/core/test/CoinAddressDerivationTests.kt
+++ b/kotlin/wallet-core-kotlin/src/commonTest/kotlin/com/trustwallet/core/test/CoinAddressDerivationTests.kt
@@ -147,5 +147,6 @@ class CoinAddressDerivationTests {
         Tia -> "celestia142j9u5eaduzd7faumygud6ruhdwme98qpwmfv7"
         NativeZetaChain -> "zeta13u6g7vqgw074mgmf2ze2cadzvkz9snlwywj304"
         Dydx -> "dydx142j9u5eaduzd7faumygud6ruhdwme98qeayaky"
+        Pactus -> "pc1r7ys2g5a4xc2qtm0t4q987m4mvs57w5g0v4pvzg"
     }
 }
diff --git a/registry.json b/registry.json
index 1bb8123783af..2c9d8f410df1 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",
@@ -4781,5 +4781,32 @@
       "rpc": "https://rpc.zklink.io",
       "documentation": "https://docs.zklink.io"
     }
+  },
+  {
+    "id": "pactus",
+    "name": "Pactus",
+    "coinId": 21888,
+    "symbol": "PAC",
+    "decimals": 9,
+    "blockchain": "Pactus",
+    "derivation": [
+      {
+        "path": "m/44'/21888'/3'/0'"
+      }
+    ],
+    "curve": "ed25519",
+    "publicKeyType": "ed25519",
+    "hrp": "pc",
+    "explorer": {
+      "url": "https://pacviewer.com",
+      "txPath": "/transaction/",
+      "accountPath": "/address/"
+    },
+    "info": {
+      "url": "https://pactus.org",
+      "source": "https://github.com/pactus-project/pactus",
+      "rpc": "https://docs.pactus.org/api/http",
+      "documentation": "https://docs.pactus.org"
+    }
   }
 ]
diff --git a/rust/Cargo.lock b/rust/Cargo.lock
index 108bb84e1e00..e12cf3ea3759 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",
@@ -1841,6 +1857,7 @@ dependencies = [
  "tw_misc",
  "tw_native_evmos",
  "tw_native_injective",
+ "tw_pactus",
  "tw_ronin",
  "tw_solana",
  "tw_sui",
@@ -2062,6 +2079,20 @@ dependencies = [
  "tw_memory",
 ]
 
+[[package]]
+name = "tw_pactus"
+version = "0.1.0"
+dependencies = [
+ "bech32",
+ "byteorder",
+ "tw_coin_entry",
+ "tw_encoding",
+ "tw_hash",
+ "tw_keypair",
+ "tw_memory",
+ "tw_proto",
+]
+
 [[package]]
 name = "tw_proto"
 version = "0.1.0"
diff --git a/rust/Cargo.toml b/rust/Cargo.toml
index ca41fb6099d5..692beec26920 100644
--- a/rust/Cargo.toml
+++ b/rust/Cargo.toml
@@ -3,12 +3,14 @@ members = [
     "chains/tw_aptos",
     "chains/tw_binance",
     "chains/tw_bitcoin",
+    "chains/tw_bitcoincash",
     "chains/tw_cosmos",
     "chains/tw_ethereum",
     "chains/tw_greenfield",
     "chains/tw_internet_computer",
     "chains/tw_native_evmos",
     "chains/tw_native_injective",
+    "chains/tw_pactus",
     "chains/tw_ronin",
     "chains/tw_solana",
     "chains/tw_sui",
diff --git a/rust/chains/tw_aptos/src/entry.rs b/rust/chains/tw_aptos/src/entry.rs
index f9a46c55049f..e2ef01a6e2fe 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_aptos/src/transaction_payload.rs b/rust/chains/tw_aptos/src/transaction_payload.rs
index aa1c74d02dac..d0105bc949d8 100644
--- a/rust/chains/tw_aptos/src/transaction_payload.rs
+++ b/rust/chains/tw_aptos/src/transaction_payload.rs
@@ -109,10 +109,7 @@ fn serialize_argument(arg: &TransactionArgument) -> EncodingResult<Data> {
         TransactionArgument::U256(v) => bcs::encode(v),
         TransactionArgument::U8Vector(v) => bcs::encode(v),
         TransactionArgument::Bool(v) => bcs::encode(v),
-        TransactionArgument::Address(v) => {
-            let serialized_v = bcs::encode(v)?;
-            bcs::encode(&serialized_v)
-        },
+        TransactionArgument::Address(v) => bcs::encode(v),
     }
 }
 
@@ -220,6 +217,10 @@ mod tests {
 
         let v = EntryFunction::try_from(payload_value.clone()).unwrap();
         assert_eq!(payload_value, v.to_json());
+
+        let tp = TransactionPayload::EntryFunction(v);
+        let serialized = bcs::encode(&tp).unwrap();
+        assert_eq!(hex::encode(serialized, false), "02c23c3b70956ce8d88fb18ad9ed3b463fe873cb045db3f6d2e2fb15b9aab71d500349464f0772656c65617365030748e0e3958d42b8d452c9199d4a221d0d1b15d14655787453dbe77208ced9051705636f696e730442555344000748e0e3958d42b8d452c9199d4a221d0d1b15d14655787453dbe77208ced9051705636f696e730344414900079936836587ca33240d3d3f91844651b16cb07802faf5e34514ed6f78580deb0a0575696e7473025531000120c95db29a67a848940829b3df6119b5e67b788ff0248676e4484c7c6f29c0f5e6");
     }
 
     #[test]
@@ -255,7 +256,8 @@ mod tests {
         );
         let tp = TransactionPayload::EntryFunction(entry);
         let serialized = bcs::encode(&tp).unwrap();
-        assert_eq!(hex::encode(serialized, false), "02000000000000000000000000000000000000000000000000000000000000000104636f696e087472616e73666572010700000000000000000000000000000000000000000000000000000000000000010a6170746f735f636f696e094170746f73436f696e000220eeff357ea5c1a4e7bc11b2b17ff2dc2dcca69750bfef1e1ebcaccf8c8018175b08e803000000000000");
+        let expected_serialized = "02000000000000000000000000000000000000000000000000000000000000000104636f696e087472616e73666572010700000000000000000000000000000000000000000000000000000000000000010a6170746f735f636f696e094170746f73436f696e000220eeff357ea5c1a4e7bc11b2b17ff2dc2dcca69750bfef1e1ebcaccf8c8018175b08e803000000000000";
+        assert_eq!(hex::encode(serialized, false), expected_serialized);
         let payload_value: Value = json!({
                 "function": "0x1::coin::transfer",
                 "type": "entry_function_payload",
@@ -263,5 +265,12 @@ mod tests {
                 "type_arguments": ["0x1::aptos_coin::AptosCoin"]
         });
         assert_eq!(tp.to_json(), payload_value);
+
+        // Rebuild a new EntryFunction object from the JSON above
+        let v = EntryFunction::try_from(payload_value.clone()).unwrap();
+        let tp = TransactionPayload::EntryFunction(v);
+        // Serialize the new EntryFunction object and compare with the expected serialized value
+        let serialized = bcs::encode(&tp).unwrap();
+        assert_eq!(hex::encode(serialized, false), expected_serialized);
     }
 }
diff --git a/rust/chains/tw_binance/src/entry.rs b/rust/chains/tw_binance/src/entry.rs
index 55930473d53a..6552c0e6bd0c 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 000000000000..8ecdd4f8e553
--- /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 5d6b81508ecb..02a728b5d0e8 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 1b6998ea2c61..6f1db4b73ee8 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 398940ec3e7d..e596df15a584 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 21d437f81493..f36669e19318 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 0967e85b75ad..545862d16912 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 f3d63e4c6ca9..5ecac42cae0d 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 1bed884f0531..5db22d32e74d 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 bddbcac4b0c5..8e62b8b6d2b2 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 37c99c33e531..98c05c767aa3 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 0e1a6e374b0d..7b503a0f925f 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 d536915a3c89..aa21a02f41bb 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 000000000000..2ef2ff965c89
--- /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 000000000000..748a8636f0fa
--- /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 000000000000..4d7ebcab0b80
--- /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 000000000000..dd9fbf6c13a3
--- /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 000000000000..f060724fc408
--- /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 000000000000..9a4a0d5c7fa2
--- /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 000000000000..e4eb7b2036d4
--- /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 000000000000..bbe4625aa7de
--- /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 000000000000..0ad18c84e8d0
--- /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 dc2e9de681b8..f77d8ea89911 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 aad3d6f90b50..2b72e1c374c6 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 448cbe54f157..8a5d0e9f6813 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 3e9be8f75cb8..592b9edf0521 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 e3964e6454cd..61cec2c5f7ef 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 bca5b9759dd5..e9d2ec3ad4dc 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_pactus/Cargo.toml b/rust/chains/tw_pactus/Cargo.toml
new file mode 100644
index 000000000000..105b0aa7679a
--- /dev/null
+++ b/rust/chains/tw_pactus/Cargo.toml
@@ -0,0 +1,18 @@
+[package]
+name = "tw_pactus"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+bech32 = "0.9.1"
+byteorder = "1.4"
+tw_coin_entry = { path = "../../tw_coin_entry" }
+tw_keypair = { path = "../../tw_keypair" }
+tw_memory = { path = "../../tw_memory" }
+tw_proto = { path = "../../tw_proto" }
+tw_hash = { path = "../../tw_hash" }
+tw_encoding = { path = "../../tw_encoding" }
+
+[dev-dependencies]
+tw_encoding = { path = "../../tw_encoding" }
+
diff --git a/rust/chains/tw_pactus/src/compiler.rs b/rust/chains/tw_pactus/src/compiler.rs
new file mode 100644
index 000000000000..3433b77d6e28
--- /dev/null
+++ b/rust/chains/tw_pactus/src/compiler.rs
@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use tw_coin_entry::coin_context::CoinContext;
+use tw_coin_entry::coin_entry::{PublicKeyBytes, SignatureBytes};
+use tw_coin_entry::error::prelude::*;
+use tw_coin_entry::signing_output_error;
+use tw_keypair::ed25519;
+use tw_proto::Pactus::Proto;
+use tw_proto::TxCompiler::Proto as CompilerProto;
+
+use crate::modules::tx_builder::TxBuilder;
+
+pub struct PactusCompiler;
+
+impl PactusCompiler {
+    #[inline]
+    pub fn preimage_hashes(
+        coin: &dyn CoinContext,
+        input: Proto::SigningInput<'_>,
+    ) -> CompilerProto::PreSigningOutput<'static> {
+        Self::preimage_hashes_impl(coin, input)
+            .unwrap_or_else(|e| signing_output_error!(CompilerProto::PreSigningOutput, e))
+    }
+
+    fn preimage_hashes_impl(
+        _coin: &dyn CoinContext,
+        input: Proto::SigningInput<'_>,
+    ) -> SigningResult<CompilerProto::PreSigningOutput<'static>> {
+        let trx = TxBuilder::from_proto(&input)?;
+        let sign_bytes = trx.sign_bytes()?;
+
+        let output = CompilerProto::PreSigningOutput {
+            data_hash: trx.id().into(),
+            data: sign_bytes.into(),
+            ..CompilerProto::PreSigningOutput::default()
+        };
+
+        Ok(output)
+    }
+
+    #[inline]
+    pub fn compile(
+        coin: &dyn CoinContext,
+        input: Proto::SigningInput<'_>,
+        signatures: Vec<SignatureBytes>,
+        public_keys: Vec<PublicKeyBytes>,
+    ) -> Proto::SigningOutput<'static> {
+        Self::compile_impl(coin, input, signatures, public_keys)
+            .unwrap_or_else(|e| signing_output_error!(Proto::SigningOutput, e))
+    }
+
+    fn compile_impl(
+        _coin: &dyn CoinContext,
+        input: Proto::SigningInput<'_>,
+        signatures: Vec<SignatureBytes>,
+        public_keys: Vec<PublicKeyBytes>,
+    ) -> SigningResult<Proto::SigningOutput<'static>> {
+        let signature_bytes = signatures
+            .first()
+            .or_tw_err(SigningErrorType::Error_signatures_count)?;
+        let public_key_bytes = public_keys
+            .first()
+            .or_tw_err(SigningErrorType::Error_signatures_count)?;
+
+        let public_key = ed25519::sha512::PublicKey::try_from(public_key_bytes.as_slice())?;
+        let signature = ed25519::Signature::try_from(signature_bytes.as_slice())?;
+
+        let mut trx = TxBuilder::from_proto(&input)?;
+        trx.set_signatory(public_key.to_owned(), signature.to_owned());
+
+        let data = trx.to_bytes()?;
+
+        let output = Proto::SigningOutput {
+            transaction_id: trx.id().into(),
+            signed_transaction_data: data.into(),
+            signature: signature.to_bytes().to_vec().into(),
+            ..Proto::SigningOutput::default()
+        };
+
+        Ok(output)
+    }
+}
diff --git a/rust/chains/tw_pactus/src/encoder/decode.rs b/rust/chains/tw_pactus/src/encoder/decode.rs
new file mode 100644
index 000000000000..f9e2ef80edfb
--- /dev/null
+++ b/rust/chains/tw_pactus/src/encoder/decode.rs
@@ -0,0 +1,138 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use tw_hash::Hash;
+use tw_keypair::ed25519::{sha512::PublicKey, Signature};
+
+use super::error::Error;
+use crate::encoder::var_int::VarInt;
+use crate::encoder::Decodable;
+
+pub(crate) fn decode_var_slice(r: &mut dyn std::io::Read) -> Result<Vec<u8>, Error> {
+    let len = *VarInt::decode(r)?;
+    let mut buf = vec![0; len as usize];
+    r.read_exact(&mut buf)?;
+
+    Ok(buf)
+}
+
+pub(crate) fn decode_fix_slice<const N: usize>(
+    r: &mut dyn std::io::Read,
+) -> Result<[u8; N], Error> {
+    let mut buf: [u8; N] = [0; N];
+    r.read_exact(&mut buf)?;
+
+    Ok(buf)
+}
+
+impl Decodable for Vec<u8> {
+    fn decode(r: &mut dyn std::io::Read) -> Result<Self, Error> {
+        decode_var_slice(r)
+    }
+}
+
+impl Decodable for String {
+    fn decode(r: &mut dyn std::io::Read) -> Result<Self, Error> {
+        let data = decode_var_slice(r)?;
+        String::from_utf8(data).map_err(|_| self::Error::ParseFailed("Invalid String"))
+    }
+}
+
+impl Decodable for PublicKey {
+    fn decode(r: &mut dyn std::io::Read) -> Result<Self, Error> {
+        let data = decode_fix_slice::<{ PublicKey::LEN }>(r)?;
+        PublicKey::try_from(data.as_slice())
+            .map_err(|_| self::Error::ParseFailed("Invalid Public Key"))
+    }
+}
+
+impl Decodable for Signature {
+    fn decode(r: &mut dyn std::io::Read) -> Result<Self, Error> {
+        let data = decode_fix_slice::<{ Signature::LEN }>(r)?;
+        Signature::try_from(data.as_slice())
+            .map_err(|_| self::Error::ParseFailed("Invalid Signature"))
+    }
+}
+
+impl<const N: usize> Decodable for Hash<N> {
+    fn decode(r: &mut dyn std::io::Read) -> Result<Self, Error> {
+        let data = decode_fix_slice::<N>(r)?;
+        Hash::try_from(data.as_slice()).map_err(|_| self::Error::ParseFailed("Invalid Hash"))
+    }
+}
+
+macro_rules! impl_decodable_for_int {
+    ($int:ty, $size:literal) => {
+        impl Decodable for $int {
+            #[inline]
+            fn decode(r: &mut dyn std::io::Read) -> Result<Self, Error> {
+                let mut buf = [0; $size];
+                r.read_exact(&mut buf[..])?;
+                Ok(<$int>::from_le_bytes(buf))
+            }
+        }
+    };
+}
+
+impl_decodable_for_int!(u8, 1);
+impl_decodable_for_int!(i32, 4);
+impl_decodable_for_int!(i64, 8);
+impl_decodable_for_int!(u16, 2);
+impl_decodable_for_int!(u32, 4);
+impl_decodable_for_int!(u64, 8);
+
+#[cfg(test)]
+mod tests {
+    use std::io::Cursor;
+
+    use tw_encoding::hex::DecodeHex;
+
+    use super::*;
+    use crate::encoder::deserialize;
+
+    #[test]
+    fn test_decode_var_slice() {
+        let expected = vec![1, 2, 3, 4];
+        let mut cursor = Cursor::new("0401020304".decode_hex().unwrap());
+        let slice = decode_var_slice(&mut cursor).unwrap();
+
+        assert_eq!(expected, slice);
+    }
+
+    #[test]
+    fn test_decode_fix_slice() {
+        let expected = vec![1, 2, 3, 4];
+        let mut cursor = Cursor::new("01020304".decode_hex().unwrap());
+        let slice = decode_fix_slice::<4>(&mut cursor).unwrap();
+
+        assert_eq!(expected, slice);
+    }
+
+    #[test]
+    fn test_encode_numbers() {
+        let data = vec![1_u8, 2, 0, 3, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0];
+        let mut cursor = Cursor::new(data);
+
+        assert_eq!(1u8, u8::decode(&mut cursor).unwrap());
+        assert_eq!(2u16, u16::decode(&mut cursor).unwrap());
+        assert_eq!(3u32, u32::decode(&mut cursor).unwrap());
+        assert_eq!(4u64, u64::decode(&mut cursor).unwrap());
+    }
+
+    #[test]
+    fn test_decode_bytes() {
+        let expected = "0145".decode_hex().unwrap();
+        let bytes = "020145".decode_hex().unwrap();
+
+        assert_eq!(expected, deserialize::<Vec<u8>>(&bytes).unwrap());
+    }
+
+    #[test]
+    fn test_encode_string() {
+        let expected = "hello".to_string();
+        let bytes = "0568656c6c6f056844656c6c6e".decode_hex().unwrap();
+
+        assert_eq!(expected, deserialize::<String>(&bytes).unwrap());
+    }
+}
diff --git a/rust/chains/tw_pactus/src/encoder/encode.rs b/rust/chains/tw_pactus/src/encoder/encode.rs
new file mode 100644
index 000000000000..9840c1873a87
--- /dev/null
+++ b/rust/chains/tw_pactus/src/encoder/encode.rs
@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use byteorder::{LittleEndian, WriteBytesExt};
+use tw_hash::Hash;
+use tw_keypair::ed25519::{sha512::PublicKey, Signature};
+
+use super::error::Error;
+use crate::encoder::var_int::VarInt;
+use crate::encoder::Encodable;
+
+pub(crate) fn encode_var_slice(data: &[u8], w: &mut dyn std::io::Write) -> Result<(), Error> {
+    VarInt::from(data.len()).encode(w)?;
+    w.write_all(data)?;
+
+    Ok(())
+}
+
+pub(crate) fn encode_fix_slice(data: &[u8], w: &mut dyn std::io::Write) -> Result<(), Error> {
+    w.write_all(data)?;
+
+    Ok(())
+}
+
+impl Encodable for Vec<u8> {
+    fn encode(&self, w: &mut dyn std::io::Write) -> Result<(), Error> {
+        encode_var_slice(self, w)
+    }
+
+    fn encoded_size(&self) -> usize {
+        VarInt::from(self.len()).encoded_size() + self.len()
+    }
+}
+
+impl Encodable for String {
+    fn encode(&self, w: &mut dyn std::io::Write) -> Result<(), Error> {
+        encode_var_slice(self.as_bytes(), w)
+    }
+
+    fn encoded_size(&self) -> usize {
+        VarInt::from(self.len()).encoded_size() + self.len()
+    }
+}
+
+impl Encodable for PublicKey {
+    fn encode(&self, w: &mut dyn std::io::Write) -> Result<(), Error> {
+        encode_fix_slice(self.as_slice(), w)
+    }
+
+    fn encoded_size(&self) -> usize {
+        PublicKey::LEN
+    }
+}
+
+impl Encodable for Signature {
+    fn encode(&self, w: &mut dyn std::io::Write) -> Result<(), Error> {
+        encode_fix_slice(self.to_bytes().as_slice(), w)
+    }
+
+    fn encoded_size(&self) -> usize {
+        Signature::LEN
+    }
+}
+
+impl<const N: usize> Encodable for Hash<N> {
+    fn encode(&self, w: &mut dyn std::io::Write) -> Result<(), Error> {
+        encode_fix_slice(self.as_slice(), w)
+    }
+
+    fn encoded_size(&self) -> usize {
+        N
+    }
+}
+
+impl Encodable for u8 {
+    #[inline]
+    fn encode(&self, w: &mut dyn std::io::Write) -> Result<(), Error> {
+        w.write_u8(*self)?;
+
+        Ok(())
+    }
+
+    #[inline]
+    fn encoded_size(&self) -> usize {
+        1
+    }
+}
+
+macro_rules! impl_encodable_for_int {
+    ($int:ty, $size:literal, $write_fn:tt) => {
+        impl Encodable for $int {
+            #[inline]
+            fn encode(&self, w: &mut dyn std::io::Write) -> Result<(), Error> {
+                w.$write_fn::<LittleEndian>(*self)?;
+
+                Ok(())
+            }
+
+            #[inline]
+            fn encoded_size(&self) -> usize {
+                $size
+            }
+        }
+    };
+}
+
+impl_encodable_for_int!(i32, 4, write_i32);
+impl_encodable_for_int!(i64, 8, write_i64);
+impl_encodable_for_int!(u16, 2, write_u16);
+impl_encodable_for_int!(u32, 4, write_u32);
+impl_encodable_for_int!(u64, 8, write_u64);
+
+#[cfg(test)]
+mod tests {
+    use tw_encoding::hex::DecodeHex;
+
+    use super::*;
+    use crate::encoder::serialize;
+
+    #[test]
+    fn test_encode_var_slice() {
+        let expected = "0401020304".decode_hex().unwrap();
+        let slice = vec![1, 2, 3, 4];
+        let mut w = Vec::new();
+        encode_var_slice(&slice, &mut w).unwrap();
+
+        assert_eq!(expected, w.to_vec());
+    }
+
+    #[test]
+    fn test_encode_fix_slice() {
+        let expected = "01020304".decode_hex().unwrap();
+        let slice = vec![1, 2, 3, 4];
+        let mut w = Vec::new();
+        encode_fix_slice(&slice, &mut w).unwrap();
+
+        assert_eq!(expected, w.to_vec());
+    }
+
+    #[test]
+    fn test_encode_numbers() {
+        let mut w = Vec::new();
+
+        1u8.encode(&mut w).unwrap();
+        2u16.encode(&mut w).unwrap();
+        3u32.encode(&mut w).unwrap();
+        4u64.encode(&mut w).unwrap();
+
+        let expected = vec![1_u8, 2, 0, 3, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0];
+        assert_eq!(w.to_vec(), expected);
+    }
+
+    #[test]
+    fn test_encode_bytes() {
+        let expected = "020145".decode_hex().unwrap();
+        let bytes = "0145".decode_hex().unwrap();
+
+        assert_eq!(expected, serialize(&bytes).unwrap());
+        assert_eq!(expected.len(), bytes.encoded_size());
+    }
+
+    #[test]
+    fn test_encode_string() {
+        let expected = "0568656c6c6f".decode_hex().unwrap();
+        let msg = "hello".to_string();
+
+        assert_eq!(expected, serialize(&msg).unwrap());
+        assert_eq!(expected.len(), msg.encoded_size());
+    }
+}
diff --git a/rust/chains/tw_pactus/src/encoder/error.rs b/rust/chains/tw_pactus/src/encoder/error.rs
new file mode 100644
index 000000000000..b3643854a902
--- /dev/null
+++ b/rust/chains/tw_pactus/src/encoder/error.rs
@@ -0,0 +1,20 @@
+use tw_coin_entry::error::prelude::{SigningError, SigningErrorType};
+
+/// Errors encountered when encoding or decoding data.
+#[derive(Debug)]
+pub enum Error {
+    IoError(std::io::Error),
+    ParseFailed(&'static str),
+}
+
+impl From<std::io::Error> for Error {
+    fn from(err: std::io::Error) -> Self {
+        Error::IoError(err)
+    }
+}
+
+impl From<Error> for SigningError {
+    fn from(_: Error) -> Self {
+        SigningError::new(SigningErrorType::Error_input_parse)
+    }
+}
diff --git a/rust/chains/tw_pactus/src/encoder/mod.rs b/rust/chains/tw_pactus/src/encoder/mod.rs
new file mode 100644
index 000000000000..506c3baec674
--- /dev/null
+++ b/rust/chains/tw_pactus/src/encoder/mod.rs
@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use std::io::Cursor;
+
+use error::Error;
+
+pub mod decode;
+pub mod encode;
+pub mod error;
+pub mod var_int;
+
+pub fn serialize<T: Encodable>(t: &T) -> Result<Vec<u8>, Error> {
+    let mut writer = Vec::with_capacity(t.encoded_size());
+    t.encode(&mut writer)?;
+
+    Ok(writer.to_vec())
+}
+
+pub fn deserialize<T: Decodable>(data: &[u8]) -> Result<T, Error> {
+    let mut cursor = Cursor::new(data);
+    T::decode(&mut cursor)
+}
+
+/// Trait for encoding an object into a consistent byte sequence.
+pub trait Encodable {
+    /// Encode the object in consistent and deterministic way.
+    fn encode(&self, w: &mut dyn std::io::Write) -> Result<(), Error>;
+
+    /// Determine the size of serialized object.
+    fn encoded_size(&self) -> usize;
+}
+
+/// Trait for decoding an object from a byte sequence.
+pub trait Decodable: Sized {
+    /// Decode the object in consistent and deterministic way.
+    fn decode(r: &mut dyn std::io::Read) -> Result<Self, Error>;
+}
diff --git a/rust/chains/tw_pactus/src/encoder/var_int.rs b/rust/chains/tw_pactus/src/encoder/var_int.rs
new file mode 100644
index 000000000000..aba98f95f4fb
--- /dev/null
+++ b/rust/chains/tw_pactus/src/encoder/var_int.rs
@@ -0,0 +1,198 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use std::ops::Deref;
+
+use byteorder::ReadBytesExt;
+
+use super::{error::Error, Decodable};
+use crate::encoder::Encodable;
+
+/// A type of variable-length integer used in the Pactus blockchain to serialize a variable-length integer.
+#[derive(Default, Debug, Clone, Copy, PartialEq)]
+pub struct VarInt(u64);
+
+impl From<usize> for VarInt {
+    fn from(value: usize) -> Self {
+        VarInt(value as u64)
+    }
+}
+
+impl Deref for VarInt {
+    type Target = u64;
+
+    fn deref(&self) -> &u64 {
+        &self.0
+    }
+}
+
+impl Encodable for VarInt {
+    fn encode(&self, w: &mut dyn std::io::Write) -> Result<(), Error> {
+        let mut val = self.0;
+        // Make sure that there is one after this
+        while val >= 0x80 {
+            let n = (val as u8 & 0x7f) | 0x80;
+            w.write_all(&[n])?;
+            val >>= 7; // It should be in multiples of 7, this should just get the next part
+        }
+
+        w.write_all(&[val as u8])?;
+
+        Ok(())
+    }
+
+    fn encoded_size(&self) -> usize {
+        match self.0 {
+            val if val >= 0x8000000000000000 => 10,
+            val if val >= 0x100000000000000 => 9,
+            val if val >= 0x2000000000000 => 8,
+            val if val >= 0x40000000000 => 7,
+            val if val >= 0x800000000 => 6,
+            val if val >= 0x10000000 => 5,
+            val if val >= 0x200000 => 4,
+            val if val >= 0x4000 => 3,
+            val if val >= 0x80 => 2,
+            _ => 1,
+        }
+    }
+}
+
+impl Decodable for VarInt {
+    fn decode(r: &mut dyn std::io::Read) -> Result<Self, Error> {
+        let mut res: Vec<u8> = vec![];
+        loop {
+            let n = r.read_u8()?;
+            // Zero in any position other than the first is invalid
+            // since it is not the shortest encoding.
+            if n == 0 && !res.is_empty() {
+                return Err(Error::ParseFailed("VarInt has a zero in a position other than the first. This is not the shortest encoding."));
+            }
+            res.push(n & 0b0111_1111);
+            if n & 0b1000_0000 == 0 {
+                break;
+            }
+        }
+        let mut int = 0u64;
+        res.reverse();
+        let (last, arr) = res.split_last().unwrap();
+        for bits in arr {
+            int |= *bits as u64;
+            int = if int.leading_zeros() >= 7 {
+                int << 7
+            } else {
+                return Err(Error::ParseFailed("VarInt overflows u64"));
+            };
+        }
+        int |= *last as u64;
+        Ok(VarInt(int))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+    use crate::encoder::deserialize;
+
+    #[test]
+    fn test_var_int_encode_data() {
+        let mut w = Vec::new();
+
+        VarInt::from(0x00_usize).encode(&mut w).unwrap();
+        VarInt::from(0xfc_usize).encode(&mut w).unwrap();
+        VarInt::from(0xfd_usize).encode(&mut w).unwrap();
+        VarInt::from(0xffff_usize).encode(&mut w).unwrap();
+        VarInt::from(0x01_0000_usize).encode(&mut w).unwrap();
+        VarInt::from(0xffff_ffff_usize).encode(&mut w).unwrap();
+        VarInt(0x01_0000_0000_u64).encode(&mut w).unwrap();
+
+        let expected = vec![
+            0x00, // 0x00
+            0xfc, 0x01, // 0xfc
+            0xfd, 0x01, // 0xfd
+            0xff, 0xff, 0x03, // 0xffff
+            0x80, 0x80, 0x04, // 0x01_0000
+            0xff, 0xff, 0xff, 0xff, 0x0f, // 0xffff_ffff
+            0x80, 0x80, 0x80, 0x80, 0x10, // 0x01_0000_0000
+        ];
+
+        assert_eq!(w.to_vec(), expected);
+    }
+
+    // Define the common test cases as a constant
+    const VARINT_TEST_CASES: &[(u64, &[u8])] = &[
+        (0x0u64, &[0x00u8]),
+        (0xffu64, &[0xff, 0x01]),
+        (0x7fffu64, &[0xff, 0xff, 0x01]),
+        (0x3fffffu64, &[0xff, 0xff, 0xff, 0x01]),
+        (0x1fffffffu64, &[0xff, 0xff, 0xff, 0xff, 0x01]),
+        (0xfffffffffu64, &[0xff, 0xff, 0xff, 0xff, 0xff, 0x01]),
+        (
+            0x7ffffffffffu64,
+            &[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01],
+        ),
+        (
+            0x3ffffffffffffu64,
+            &[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01],
+        ),
+        (
+            0x1ffffffffffffffu64,
+            &[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01],
+        ),
+        (
+            0xffffffffffffffffu64,
+            &[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01],
+        ),
+        (0x200u64, &[0x80, 0x04]),
+        (0x027fu64, &[0xff, 0x04]),
+        (0xff00000000u64, &[0x80, 0x80, 0x80, 0x80, 0xf0, 0x1f]),
+        (0xffffffffu64, &[0xff, 0xff, 0xff, 0xff, 0x0f]),
+        (0x100000000u64, &[0x80, 0x80, 0x80, 0x80, 0x10]),
+        (0x7ffffffffu64, &[0xff, 0xff, 0xff, 0xff, 0x7f]),
+        (0x800000000u64, &[0x80, 0x80, 0x80, 0x80, 0x80, 0x01]),
+    ];
+
+    #[test]
+    fn test_var_int_encode() {
+        for (i, (value, encoded)) in VARINT_TEST_CASES.iter().enumerate() {
+            let mut w = Vec::new();
+            let var_int = VarInt(*value);
+            let encoded_size = var_int.encoded_size();
+            var_int.encode(&mut w).unwrap();
+            let out = w.as_slice();
+
+            assert_eq!(out, *encoded, "Test {i} failed: data mismatch");
+            assert_eq!(
+                encoded_size,
+                out.len(),
+                "Test {i} failed: encoded size mismatch"
+            );
+        }
+    }
+
+    #[test]
+    fn test_var_int_decode() {
+        for (i, (value, data)) in VARINT_TEST_CASES.iter().enumerate() {
+            let var_int = deserialize::<VarInt>(data).unwrap();
+
+            assert_eq!(*value, *var_int, "Test {i} failed: value mismatch");
+        }
+    }
+
+    #[test]
+    fn test_var_int_parse_error() {
+        // varint must be shortest encoding
+        let res = deserialize::<VarInt>(&[0x98, 0]);
+        assert!(matches!(res.unwrap_err(), Error::ParseFailed(_)));
+
+        // If the last number is not a 0, it will error with an IO error (UnexpectedEof)
+        let res = deserialize::<VarInt>(&[0xff; 1]);
+        assert!(matches!(res.unwrap_err(), Error::IoError(_)));
+
+        let res = deserialize::<VarInt>(&[
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 1u8,
+        ]);
+        assert!(matches!(res.unwrap_err(), Error::ParseFailed(_)));
+    }
+}
diff --git a/rust/chains/tw_pactus/src/entry.rs b/rust/chains/tw_pactus/src/entry.rs
new file mode 100644
index 000000000000..e9d12f3ac8c3
--- /dev/null
+++ b/rust/chains/tw_pactus/src/entry.rs
@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use std::str::FromStr;
+
+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::plan_builder::NoPlanBuilder;
+use tw_coin_entry::modules::transaction_decoder::NoTransactionDecoder;
+use tw_coin_entry::modules::wallet_connector::NoWalletConnector;
+use tw_coin_entry::prefix::NoPrefix;
+use tw_keypair::tw::PublicKey;
+use tw_proto::Pactus::Proto;
+use tw_proto::TxCompiler::Proto as CompilerProto;
+
+use crate::compiler::PactusCompiler;
+use crate::modules::transaction_util::PactusTransactionUtil;
+use crate::signer::PactusSigner;
+use crate::types::Address;
+
+pub struct PactusEntry;
+
+impl CoinEntry for PactusEntry {
+    type AddressPrefix = NoPrefix;
+    type Address = Address;
+    type SigningInput<'a> = Proto::SigningInput<'a>;
+    type SigningOutput = Proto::SigningOutput<'static>;
+    type PreSigningOutput = CompilerProto::PreSigningOutput<'static>;
+    type TransactionUtil = PactusTransactionUtil;
+
+    // Optional modules:
+    type JsonSigner = NoJsonSigner;
+    type PlanBuilder = NoPlanBuilder;
+    type MessageSigner = NoMessageSigner;
+    type WalletConnector = NoWalletConnector;
+    type TransactionDecoder = NoTransactionDecoder;
+
+    #[inline]
+    fn parse_address(
+        &self,
+        _coin: &dyn CoinContext,
+        address: &str,
+        _prefix: Option<Self::AddressPrefix>,
+    ) -> AddressResult<Self::Address> {
+        Address::from_str(address)
+    }
+
+    #[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_ed25519()
+            .ok_or(AddressError::PublicKeyTypeMismatch)?;
+        Address::from_public_key(public_key)
+    }
+
+    #[inline]
+    fn sign(&self, coin: &dyn CoinContext, input: Self::SigningInput<'_>) -> Self::SigningOutput {
+        PactusSigner::sign(coin, input)
+    }
+
+    #[inline]
+    fn preimage_hashes(
+        &self,
+        coin: &dyn CoinContext,
+        input: Self::SigningInput<'_>,
+    ) -> Self::PreSigningOutput {
+        PactusCompiler::preimage_hashes(coin, input)
+    }
+
+    #[inline]
+    fn compile(
+        &self,
+        coin: &dyn CoinContext,
+        input: Self::SigningInput<'_>,
+        signatures: Vec<SignatureBytes>,
+        public_keys: Vec<PublicKeyBytes>,
+    ) -> Self::SigningOutput {
+        PactusCompiler::compile(coin, input, signatures, public_keys)
+    }
+
+    #[inline]
+    fn transaction_util(&self) -> Option<Self::TransactionUtil> {
+        Some(PactusTransactionUtil)
+    }
+}
diff --git a/rust/chains/tw_pactus/src/lib.rs b/rust/chains/tw_pactus/src/lib.rs
new file mode 100644
index 000000000000..938d9bba25a4
--- /dev/null
+++ b/rust/chains/tw_pactus/src/lib.rs
@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+pub mod compiler;
+pub mod encoder;
+pub mod entry;
+pub mod modules;
+pub mod signer;
+pub mod transaction;
+pub mod types;
diff --git a/rust/chains/tw_pactus/src/modules/mod.rs b/rust/chains/tw_pactus/src/modules/mod.rs
new file mode 100644
index 000000000000..b09e92443b16
--- /dev/null
+++ b/rust/chains/tw_pactus/src/modules/mod.rs
@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+pub mod transaction_util;
+pub mod tx_builder;
diff --git a/rust/chains/tw_pactus/src/modules/transaction_util.rs b/rust/chains/tw_pactus/src/modules/transaction_util.rs
new file mode 100644
index 000000000000..a28e72b8f352
--- /dev/null
+++ b/rust/chains/tw_pactus/src/modules/transaction_util.rs
@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use tw_coin_entry::coin_context::CoinContext;
+use tw_coin_entry::error::prelude::*;
+use tw_coin_entry::modules::transaction_util::TransactionUtil;
+use tw_encoding::hex;
+
+use crate::encoder::deserialize;
+use crate::transaction::Transaction;
+
+pub struct PactusTransactionUtil;
+
+impl TransactionUtil for PactusTransactionUtil {
+    fn calc_tx_hash(&self, coin: &dyn CoinContext, encoded_tx: &str) -> SigningResult<String> {
+        Self::calc_tx_hash_impl(coin, encoded_tx)
+    }
+}
+
+impl PactusTransactionUtil {
+    fn calc_tx_hash_impl(_coin: &dyn CoinContext, encoded_tx: &str) -> SigningResult<String> {
+        let trx_bytes = hex::decode(encoded_tx).map_err(|_| SigningErrorType::Error_input_parse)?;
+
+        let trx = deserialize::<Transaction>(&trx_bytes)?;
+
+        Ok(hex::encode(trx.id(), false))
+    }
+}
diff --git a/rust/chains/tw_pactus/src/modules/tx_builder.rs b/rust/chains/tw_pactus/src/modules/tx_builder.rs
new file mode 100644
index 000000000000..e9e2449be96c
--- /dev/null
+++ b/rust/chains/tw_pactus/src/modules/tx_builder.rs
@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use crate::transaction::payload::{BondPayload, Payload, TransferPayload};
+use crate::transaction::Transaction;
+use crate::types::{Address, Amount, ValidatorPublicKey};
+use std::str::FromStr;
+use tw_coin_entry::error::prelude::*;
+use tw_proto::Pactus;
+
+pub struct TxBuilder;
+
+impl TxBuilder {
+    pub fn from_proto(input: &Pactus::Proto::SigningInput) -> SigningResult<Transaction> {
+        match &input.transaction {
+            None => SigningError::err(SigningErrorType::Error_invalid_params),
+            Some(trx) => {
+                let payload: Box<dyn Payload> = match &trx.payload {
+                    Pactus::Proto::mod_TransactionMessage::OneOfpayload::transfer(pld) => {
+                        let sender = Address::from_str(&pld.sender)?;
+                        let receiver = Address::from_str(&pld.receiver)?;
+                        Box::new(TransferPayload::new(sender, receiver, Amount(pld.amount)))
+                    },
+                    Pactus::Proto::mod_TransactionMessage::OneOfpayload::bond(pld) => {
+                        let sender = Address::from_str(&pld.sender)?;
+                        let receiver = Address::from_str(&pld.receiver)?;
+                        let public_key = if !pld.public_key.is_empty() {
+                            Some(ValidatorPublicKey::from_str(&pld.public_key)?)
+                        } else {
+                            None
+                        };
+
+                        Box::new(BondPayload::new(
+                            sender,
+                            receiver,
+                            Amount(pld.stake),
+                            public_key,
+                        ))
+                    },
+                    Pactus::Proto::mod_TransactionMessage::OneOfpayload::None => {
+                        return SigningError::err(SigningErrorType::Error_invalid_params)
+                    },
+                };
+
+                Ok(Transaction::new(
+                    trx.lock_time,
+                    Amount(trx.fee),
+                    trx.memo.to_string(),
+                    payload,
+                ))
+            },
+        }
+    }
+}
diff --git a/rust/chains/tw_pactus/src/signer.rs b/rust/chains/tw_pactus/src/signer.rs
new file mode 100644
index 000000000000..baf4f0a068b9
--- /dev/null
+++ b/rust/chains/tw_pactus/src/signer.rs
@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use tw_coin_entry::coin_context::CoinContext;
+use tw_coin_entry::error::prelude::*;
+use tw_coin_entry::signing_output_error;
+use tw_keypair::ed25519;
+use tw_keypair::traits::KeyPairTrait;
+use tw_proto::Pactus::Proto;
+
+use crate::modules::tx_builder::TxBuilder;
+
+pub struct PactusSigner;
+
+impl PactusSigner {
+    pub fn sign(
+        coin: &dyn CoinContext,
+        input: Proto::SigningInput<'_>,
+    ) -> Proto::SigningOutput<'static> {
+        Self::sign_impl(coin, input)
+            .unwrap_or_else(|e| signing_output_error!(Proto::SigningOutput, e))
+    }
+
+    fn sign_impl(
+        _coin: &dyn CoinContext,
+        input: Proto::SigningInput<'_>,
+    ) -> SigningResult<Proto::SigningOutput<'static>> {
+        let mut trx = TxBuilder::from_proto(&input)?;
+        let key_pair = ed25519::sha512::KeyPair::try_from(input.private_key.as_ref())?;
+        let signature = trx.sign(key_pair.private())?;
+
+        let data = trx.to_bytes()?;
+
+        let output = Proto::SigningOutput {
+            transaction_id: trx.id().into(),
+            signed_transaction_data: data.into(),
+            signature: signature.to_bytes().to_vec().into(),
+            ..Proto::SigningOutput::default()
+        };
+
+        Ok(output)
+    }
+}
diff --git a/rust/chains/tw_pactus/src/transaction/mod.rs b/rust/chains/tw_pactus/src/transaction/mod.rs
new file mode 100644
index 000000000000..6e00ff376992
--- /dev/null
+++ b/rust/chains/tw_pactus/src/transaction/mod.rs
@@ -0,0 +1,274 @@
+pub mod payload;
+
+use std::fmt::Debug;
+
+use payload::{BondPayload, Payload, PayloadType, TransferPayload};
+use tw_coin_entry::error::prelude::SigningResult;
+use tw_hash::blake2::blake2_b;
+use tw_keypair::ed25519::sha512::{PrivateKey, PublicKey};
+use tw_keypair::ed25519::Signature;
+use tw_keypair::traits::SigningKeyTrait;
+
+use crate::encoder::error::Error as EncoderError;
+use crate::encoder::{deserialize, Decodable, Encodable};
+use crate::types::Amount;
+
+const VERSION_LATEST: u8 = 1;
+const FLAG_NOT_SIGNED: u8 = 0x02;
+
+#[derive(Debug)]
+pub struct Transaction {
+    flags: u8,
+    version: u8,
+    lock_time: u32,
+    fee: Amount,
+    memo: String,
+    payload: Box<dyn Payload>,
+    signature: Option<Signature>,
+    public_key: Option<PublicKey>,
+}
+
+impl Transaction {
+    pub fn new(lock_time: u32, fee: Amount, memo: String, payload: Box<dyn Payload>) -> Self {
+        Transaction {
+            flags: FLAG_NOT_SIGNED,
+            version: VERSION_LATEST,
+            lock_time,
+            fee,
+            memo,
+            payload,
+            public_key: None,
+            signature: None,
+        }
+    }
+
+    pub fn from_bytes(input: &[u8]) -> SigningResult<Self> {
+        Ok(deserialize::<Transaction>(input)?)
+    }
+
+    pub fn sign(&mut self, private_key: &PrivateKey) -> SigningResult<Signature> {
+        let sign_bytes = self.sign_bytes()?;
+        let signature = private_key.sign(sign_bytes)?;
+
+        self.set_signatory(private_key.public(), signature.clone());
+
+        Ok(signature)
+    }
+
+    pub fn set_signatory(&mut self, public_key: PublicKey, signature: Signature) {
+        // Unset "Not Signed" flag
+        self.flags &= !FLAG_NOT_SIGNED;
+
+        self.public_key = Some(public_key);
+        self.signature = Some(signature);
+    }
+
+    pub fn id(&self) -> Vec<u8> {
+        blake2_b(&self.sign_bytes().unwrap_or_default(), 32).unwrap_or_default()
+    }
+
+    pub fn to_bytes(&self) -> SigningResult<Vec<u8>> {
+        let mut w = Vec::with_capacity(self.encoded_size());
+
+        self.encode(&mut w)?;
+
+        Ok(w.to_vec())
+    }
+
+    pub fn sign_bytes(&self) -> SigningResult<Vec<u8>> {
+        let mut w = Vec::new();
+        self.encode_with_no_signatory(&mut w)?;
+        let mut sign_bytes = w.to_vec();
+        sign_bytes.remove(0); // Remove flags
+
+        Ok(sign_bytes)
+    }
+
+    fn encode_with_no_signatory(&self, w: &mut dyn std::io::Write) -> Result<(), EncoderError> {
+        self.flags.encode(w)?;
+        self.version.encode(w)?;
+        self.lock_time.encode(w)?;
+        self.fee.encode(w)?;
+        self.memo.encode(w)?;
+        self.payload.payload_type().encode(w)?;
+        self.payload.encode(w)?;
+
+        Ok(())
+    }
+
+    fn is_signed(&self) -> bool {
+        self.flags & FLAG_NOT_SIGNED == 0
+    }
+}
+
+impl Encodable for Transaction {
+    fn encode(&self, w: &mut dyn std::io::Write) -> Result<(), EncoderError> {
+        self.encode_with_no_signatory(w)?;
+
+        if let Some(sig) = &self.signature {
+            sig.encode(w)?;
+        }
+
+        if let Some(pub_key) = &self.public_key {
+            pub_key.encode(w)?;
+        }
+
+        Ok(())
+    }
+
+    fn encoded_size(&self) -> usize {
+        let mut len = self.flags.encoded_size()
+            + self.version.encoded_size()
+            + self.lock_time.encoded_size()
+            + self.payload.payload_type().encoded_size()
+            + self.fee.encoded_size()
+            + self.memo.encoded_size()
+            + self.payload.encoded_size();
+
+        if let Some(sig) = &self.signature {
+            len += sig.encoded_size();
+        }
+
+        if let Some(pub_key) = &self.public_key {
+            len += pub_key.encoded_size();
+        }
+
+        len
+    }
+}
+
+impl Decodable for Transaction {
+    fn decode(r: &mut dyn std::io::Read) -> Result<Self, EncoderError> {
+        let flags = u8::decode(r)?;
+        let version = u8::decode(r)?;
+        let lock_time = u32::decode(r)?;
+        let fee = Amount::decode(r)?;
+        let memo = String::decode(r)?;
+        let payload_type = PayloadType::decode(r)?;
+        let payload: Box<dyn Payload> = match payload_type {
+            PayloadType::Transfer => Box::new(TransferPayload::decode(r)?),
+            PayloadType::Bond => Box::new(BondPayload::decode(r)?),
+            _ => return Err(EncoderError::ParseFailed("Unsupported payload")),
+        };
+
+        let mut trx = Transaction {
+            flags,
+            version,
+            lock_time,
+            fee,
+            memo,
+            payload,
+            public_key: None,
+            signature: None,
+        };
+
+        if !trx.is_signed() {
+            return Ok(trx);
+        }
+
+        let signature = Signature::decode(r)?;
+        let public_key = PublicKey::decode(r)?;
+
+        trx.signature = Some(signature);
+        trx.public_key = Some(public_key);
+
+        Ok(trx)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::str::FromStr;
+
+    use tw_encoding::hex::DecodeHex;
+
+    use crate::types::Address;
+
+    use super::*;
+
+    #[test]
+    fn test_payload_type_encoding() {
+        let mut stream = Vec::new();
+
+        let payload = PayloadType::Unbond;
+        payload.encode(&mut stream).unwrap();
+        assert_eq!(stream.to_vec(), &[4]);
+    }
+
+    const TRANSACTION_NOT_SIGNED: &str = concat!(
+        "02",                                         // Flags
+        "01",                                         // Version
+        "01020300",                                   // LockTime
+        "e807",                                       // Fee
+        "0474657374",                                 // Memo
+        "01",                                         // PayloadType
+        "037098338e0b6808119dfd4457ab806b9c2059b89b", // Sender
+        "037a14ae24533816e7faaa6ed28fcdde8e55a7df21", // Receiver
+        "a09c01"                                      // Amount
+    );
+
+    const TRANSACTION_SIGNED: &str = concat!(
+        "00",                                                               // Flags
+        "01",                                                               // Version
+        "01020300",                                                         // LockTime
+        "e807",                                                             // Fee
+        "0474657374",                                                       // Memo
+        "01",                                                               // PayloadType
+        "037098338e0b6808119dfd4457ab806b9c2059b89b",                       // Sender
+        "037a14ae24533816e7faaa6ed28fcdde8e55a7df21",                       // Receiver
+        "a09c01",                                                           // Amount
+        "50ac25c7125271489b0cd230549257c93fb8c6265f2914a988ba7b81c1bc47ff", // Signature
+        "f027412dd59447867911035ff69742d171060a1f132ac38b95acc6e39ec0bd09",
+        "95794161374b22c696dabb98e93f6ca9300b22f3b904921fbf560bb72145f4fa" // PublicKey
+    );
+
+    const TX_ID: &str = "34cd4656a98f7eb996e83efdc384cefbe3a9c52dca79a99245b4eacc0b0b4311";
+
+    #[test]
+    fn test_sign_signature() {
+        let expected_data = TRANSACTION_SIGNED.decode_hex().unwrap();
+        let expected_id = TX_ID.decode_hex().unwrap();
+
+        let sender = Address::from_str("pc1rwzvr8rstdqypr80ag3t6hqrtnss9nwymcxy3lr").unwrap();
+        let receiver = Address::from_str("pc1r0g22ufzn8qtw0742dmfglnw73e260hep0k3yra").unwrap();
+        let payload = Box::new(TransferPayload::new(sender, receiver, Amount(20000)));
+        let mut trx = Transaction::new(0x00030201, Amount(1000), "test".to_string(), payload);
+
+        let private_key_data = "4e51f1f3721f644ac7a193be7f5e7b8c2abaa3467871daf4eacb5d3af080e5d6"
+            .decode_hex()
+            .unwrap();
+        let private_key = PrivateKey::try_from(private_key_data.as_slice()).unwrap();
+        trx.sign(&private_key).unwrap();
+
+        assert_eq!(expected_data, trx.to_bytes().unwrap());
+        assert_eq!(expected_id, trx.id());
+    }
+
+    #[test]
+    fn test_encoding_not_signed() {
+        let data = TRANSACTION_NOT_SIGNED.decode_hex().unwrap();
+        let trx = Transaction::from_bytes(&data).unwrap();
+        let expected_id = TX_ID.decode_hex().unwrap();
+
+        let encoded_data = trx.to_bytes().unwrap();
+
+        assert_eq!(encoded_data, data);
+        assert_eq!(expected_id, trx.id());
+        assert_eq!(trx.encoded_size(), data.len());
+        assert!(!trx.is_signed());
+    }
+
+    #[test]
+    fn test_encoding_signed() {
+        let data = TRANSACTION_SIGNED.decode_hex().unwrap();
+        let trx = Transaction::from_bytes(&data).unwrap();
+        let expected_id = TX_ID.decode_hex().unwrap();
+
+        let encoded_data = trx.to_bytes().unwrap();
+
+        assert_eq!(encoded_data, data);
+        assert_eq!(expected_id, trx.id());
+        assert_eq!(trx.encoded_size(), data.len());
+        assert!(trx.is_signed());
+    }
+}
diff --git a/rust/chains/tw_pactus/src/transaction/payload/bond.rs b/rust/chains/tw_pactus/src/transaction/payload/bond.rs
new file mode 100644
index 000000000000..152fa5a6a7b5
--- /dev/null
+++ b/rust/chains/tw_pactus/src/transaction/payload/bond.rs
@@ -0,0 +1,100 @@
+use crate::encoder::error::Error as EncoderError;
+use crate::{
+    encoder::{Decodable, Encodable},
+    types::{Address, Amount, ValidatorPublicKey},
+};
+
+use super::{Payload, PayloadType};
+
+pub const BLS_PUBLIC_KEY_SIZE: usize = 96;
+
+#[derive(Debug)]
+pub struct BondPayload {
+    sender: Address,
+    receiver: Address,
+    stake: Amount,
+    public_key: Option<ValidatorPublicKey>,
+}
+
+impl BondPayload {
+    pub fn new(
+        sender: Address,
+        receiver: Address,
+        stake: Amount,
+        public_key: Option<ValidatorPublicKey>,
+    ) -> Self {
+        BondPayload {
+            sender,
+            receiver,
+            stake,
+            public_key,
+        }
+    }
+}
+
+impl Encodable for BondPayload {
+    fn encode(&self, w: &mut dyn std::io::Write) -> Result<(), EncoderError> {
+        self.sender.encode(w)?;
+        self.receiver.encode(w)?;
+
+        match self.public_key {
+            Some(ref public_key) => {
+                (BLS_PUBLIC_KEY_SIZE as u8).encode(w)?;
+                public_key.encode(w)?;
+            },
+            None => {
+                0u8.encode(w)?;
+            },
+        }
+
+        self.stake.encode(w)?;
+        Ok(())
+    }
+
+    fn encoded_size(&self) -> usize {
+        self.sender.encoded_size()
+            + self.receiver.encoded_size()
+            + self.stake.encoded_size()
+            + match self.public_key {
+                Some(ref public_key) => 1 + public_key.encoded_size(),
+                None => 1,
+            }
+    }
+}
+
+impl Decodable for BondPayload {
+    fn decode(r: &mut dyn std::io::Read) -> Result<Self, EncoderError> {
+        let sender = Address::decode(r)?;
+        let receiver = Address::decode(r)?;
+
+        let mut public_key = None;
+        let public_key_size: u8 = u8::decode(r)?;
+
+        if public_key_size == BLS_PUBLIC_KEY_SIZE as u8 {
+            public_key = Some(ValidatorPublicKey::decode(r)?);
+        } else if public_key_size != 0 {
+            return Err(EncoderError::ParseFailed("invalid public key size"));
+        }
+
+        let stake = Amount::decode(r)?;
+
+        Ok(BondPayload {
+            sender,
+            receiver,
+            stake,
+            public_key,
+        })
+    }
+}
+
+impl Payload for BondPayload {
+    fn signer(&self) -> &Address {
+        &self.sender
+    }
+    fn value(&self) -> Amount {
+        self.stake.clone()
+    }
+    fn payload_type(&self) -> PayloadType {
+        PayloadType::Bond
+    }
+}
diff --git a/rust/chains/tw_pactus/src/transaction/payload/mod.rs b/rust/chains/tw_pactus/src/transaction/payload/mod.rs
new file mode 100644
index 000000000000..110155033ddd
--- /dev/null
+++ b/rust/chains/tw_pactus/src/transaction/payload/mod.rs
@@ -0,0 +1,60 @@
+mod bond;
+mod transfer;
+
+pub use bond::BondPayload;
+pub use transfer::TransferPayload;
+
+use std::fmt::Debug;
+
+use crate::encoder::error::Error as EncoderError;
+use crate::{
+    encoder::{Decodable, Encodable},
+    types::{Address, Amount},
+};
+
+#[derive(Debug, Clone, Copy)]
+#[repr(u8)]
+pub enum PayloadType {
+    Transfer = 1,
+    Bond = 2,
+    Sortition = 3,
+    Unbond = 4,
+    Withdraw = 5,
+}
+
+impl TryFrom<u8> for PayloadType {
+    type Error = EncoderError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            1 => Ok(PayloadType::Transfer),
+            2 => Ok(PayloadType::Bond),
+            3 => Ok(PayloadType::Sortition),
+            4 => Ok(PayloadType::Unbond),
+            5 => Ok(PayloadType::Withdraw),
+            _ => Err(EncoderError::ParseFailed("Invalid PayloadType value")),
+        }
+    }
+}
+
+impl Encodable for PayloadType {
+    fn encode(&self, w: &mut dyn std::io::Write) -> Result<(), EncoderError> {
+        (*self as u8).encode(w)
+    }
+
+    fn encoded_size(&self) -> usize {
+        1
+    }
+}
+
+impl Decodable for PayloadType {
+    fn decode(r: &mut dyn std::io::Read) -> Result<Self, EncoderError> {
+        PayloadType::try_from(u8::decode(r)?)
+    }
+}
+
+pub trait Payload: Debug + Encodable {
+    fn signer(&self) -> &Address;
+    fn value(&self) -> Amount;
+    fn payload_type(&self) -> PayloadType;
+}
diff --git a/rust/chains/tw_pactus/src/transaction/payload/transfer.rs b/rust/chains/tw_pactus/src/transaction/payload/transfer.rs
new file mode 100644
index 000000000000..a39854c04290
--- /dev/null
+++ b/rust/chains/tw_pactus/src/transaction/payload/transfer.rs
@@ -0,0 +1,64 @@
+use crate::encoder::error::Error as EncoderError;
+use crate::{
+    encoder::{Decodable, Encodable},
+    types::{Address, Amount},
+};
+
+use super::{Payload, PayloadType};
+
+#[derive(Debug)]
+pub struct TransferPayload {
+    sender: Address,
+    receiver: Address,
+    amount: Amount,
+}
+
+impl TransferPayload {
+    pub fn new(sender: Address, receiver: Address, amount: Amount) -> Self {
+        TransferPayload {
+            sender,
+            receiver,
+            amount,
+        }
+    }
+}
+
+impl Encodable for TransferPayload {
+    fn encode(&self, w: &mut dyn std::io::Write) -> Result<(), EncoderError> {
+        self.sender.encode(w)?;
+        self.receiver.encode(w)?;
+        self.amount.encode(w)?;
+
+        Ok(())
+    }
+
+    fn encoded_size(&self) -> usize {
+        self.sender.encoded_size() + self.receiver.encoded_size() + self.amount.encoded_size()
+    }
+}
+
+impl Decodable for TransferPayload {
+    fn decode(r: &mut dyn std::io::Read) -> Result<Self, EncoderError> {
+        let sender = Address::decode(r)?;
+        let receiver = Address::decode(r)?;
+        let amount = Amount::decode(r)?;
+
+        Ok(TransferPayload {
+            sender,
+            receiver,
+            amount,
+        })
+    }
+}
+
+impl Payload for TransferPayload {
+    fn signer(&self) -> &Address {
+        &self.sender
+    }
+    fn value(&self) -> Amount {
+        self.amount.clone()
+    }
+    fn payload_type(&self) -> PayloadType {
+        PayloadType::Transfer
+    }
+}
diff --git a/rust/chains/tw_pactus/src/types/address.rs b/rust/chains/tw_pactus/src/types/address.rs
new file mode 100644
index 000000000000..785e82c66395
--- /dev/null
+++ b/rust/chains/tw_pactus/src/types/address.rs
@@ -0,0 +1,335 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use std::fmt;
+use std::str::FromStr;
+
+use bech32::{FromBase32, ToBase32};
+use tw_coin_entry::coin_entry::CoinAddress;
+use tw_coin_entry::error::prelude::*;
+use tw_hash::blake2::blake2_b;
+use tw_hash::ripemd::ripemd_160;
+use tw_hash::H160;
+use tw_keypair::ed25519::sha512::PublicKey;
+use tw_memory::Data;
+
+use crate::encoder::error::Error;
+use crate::encoder::{Decodable, Encodable};
+
+const ADDRESS_HRP: &str = "pc";
+const TREASURY_ADDRESS_STRING: &str = "000000000000000000000000000000000000000000";
+
+/// Enum for Pactus address types.
+#[derive(Debug, Clone, PartialEq)]
+pub enum AddressType {
+    Treasury = 0,
+    Validator = 1,
+    BlsAccount = 2,
+    Ed25519Account = 3,
+}
+
+impl TryFrom<u8> for AddressType {
+    type Error = AddressError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(AddressType::Treasury),
+            1 => Ok(AddressType::Validator),
+            2 => Ok(AddressType::BlsAccount),
+            3 => Ok(AddressType::Ed25519Account),
+            _ => Err(AddressError::Unsupported),
+        }
+    }
+}
+
+impl Encodable for AddressType {
+    fn encode(&self, w: &mut dyn std::io::Write) -> Result<(), Error> {
+        (self.clone() as u8).encode(w)
+    }
+
+    fn encoded_size(&self) -> usize {
+        1
+    }
+}
+
+impl Decodable for AddressType {
+    fn decode(r: &mut dyn std::io::Read) -> Result<Self, Error> {
+        AddressType::try_from(u8::decode(r)?)
+            .map_err(|_| Error::ParseFailed("Invalid address type"))
+    }
+}
+
+/// Pactus addresses are 21 bytes long.
+/// The first byte indicates the address type, and the remaining 20 bytes
+/// represent the hash of the public key.
+/// The hash is computed as RIPEMD160(Blake2b(public key)).
+#[derive(Debug, Clone, PartialEq)]
+pub struct Address {
+    addr_type: AddressType,
+    pub_hash: H160,
+}
+
+impl Address {
+    pub fn from_public_key(public_key: &PublicKey) -> Result<Self, AddressError> {
+        let pud_data = public_key.to_bytes();
+        let pub_hash_data =
+            ripemd_160(&blake2_b(pud_data.as_ref(), 32).map_err(|_| AddressError::Internal)?);
+        let pub_hash = Address::vec_to_pub_hash(pub_hash_data)?;
+
+        Ok(Address {
+            addr_type: AddressType::Ed25519Account,
+            pub_hash,
+        })
+    }
+
+    pub fn is_treasury(&self) -> bool {
+        self.addr_type == AddressType::Treasury && self.pub_hash.is_zero()
+    }
+
+    pub fn vec_to_pub_hash(vec: Vec<u8>) -> Result<H160, AddressError> {
+        H160::try_from(vec.as_slice()).map_err(|_| AddressError::Internal)
+    }
+}
+
+impl CoinAddress for Address {
+    #[inline]
+    fn data(&self) -> Data {
+        let mut data = Vec::with_capacity(21);
+        data.push(self.addr_type.clone() as u8);
+        data.extend_from_slice(self.pub_hash.as_ref());
+
+        data
+    }
+}
+
+// Pactus addresses are encoded into a string format using the Bech32m encoding scheme.
+impl fmt::Display for Address {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.is_treasury() {
+            return f.write_str(TREASURY_ADDRESS_STRING);
+        }
+
+        let mut b32 = Vec::with_capacity(33);
+
+        b32.push(bech32::u5::try_from_u8(self.addr_type.clone() as u8).map_err(|_| fmt::Error)?);
+        b32.extend_from_slice(&self.pub_hash.to_vec().to_base32());
+        bech32::encode_to_fmt(f, ADDRESS_HRP, &b32, bech32::Variant::Bech32m)
+            .map_err(|_| fmt::Error)?
+    }
+}
+
+impl Encodable for Address {
+    fn encode(&self, w: &mut dyn std::io::Write) -> Result<(), Error> {
+        self.addr_type.encode(w)?;
+
+        if self.is_treasury() {
+            return Ok(());
+        }
+
+        self.pub_hash.encode(w)?;
+
+        Ok(())
+    }
+
+    fn encoded_size(&self) -> usize {
+        if self.is_treasury() {
+            return 1;
+        }
+
+        21
+    }
+}
+
+impl Decodable for Address {
+    fn decode(r: &mut dyn std::io::Read) -> Result<Self, Error> {
+        let addr_type = AddressType::decode(r)?;
+        if addr_type == AddressType::Treasury {
+            return Ok(Address {
+                addr_type,
+                pub_hash: H160::new(),
+            });
+        }
+
+        let pub_hash = H160::decode(r)?;
+        Ok(Address {
+            addr_type,
+            pub_hash,
+        })
+    }
+}
+
+impl FromStr for Address {
+    type Err = AddressError;
+
+    fn from_str(s: &str) -> Result<Self, AddressError> {
+        if s == TREASURY_ADDRESS_STRING {
+            return Ok(Address {
+                addr_type: AddressType::Treasury,
+                pub_hash: H160::new(),
+            });
+        }
+
+        let (hrp, b32, _variant) = bech32::decode(s).map_err(|_| AddressError::FromBech32Error)?;
+
+        if hrp != ADDRESS_HRP {
+            return Err(AddressError::InvalidHrp);
+        }
+
+        if b32.len() != 33 {
+            return Err(AddressError::InvalidInput);
+        }
+
+        let addr_type = AddressType::try_from(b32[0].to_u8())?;
+        let b8 = Vec::<u8>::from_base32(&b32[1..]).map_err(|_| AddressError::InvalidInput)?;
+        let pub_hash = Address::vec_to_pub_hash(b8)?;
+
+        Ok(Address {
+            addr_type,
+            pub_hash,
+        })
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use tw_encoding::hex::{DecodeHex, ToHex};
+    use tw_keypair::ed25519::sha512::PrivateKey;
+
+    use super::*;
+    use crate::encoder::{deserialize, Encodable};
+
+    #[test]
+    fn test_treasury_address_encoding() {
+        let addr = Address::from_str(TREASURY_ADDRESS_STRING).unwrap();
+        assert!(addr.is_treasury());
+
+        let mut w = Vec::new();
+        addr.encode(&mut w).unwrap();
+        assert_eq!(w.to_vec(), [0x00]);
+        assert_eq!(addr.encoded_size(), 1);
+    }
+
+    #[test]
+    fn test_treasury_address_decoding() {
+        let data = vec![0u8];
+
+        let addr = deserialize::<Address>(&data).unwrap();
+        assert!(addr.is_treasury());
+        assert_eq!(addr.to_string(), TREASURY_ADDRESS_STRING);
+    }
+
+    #[test]
+    fn test_address_encoding() {
+        let addr = Address::from_str("pc1rqqqsyqcyq5rqwzqfpg9scrgwpuqqzqsr36kkra").unwrap();
+        assert!(!addr.is_treasury());
+
+        let mut w = Vec::new();
+        addr.encode(&mut w).unwrap();
+        assert_eq!(
+            w.to_vec(),
+            "03000102030405060708090a0b0c0d0e0f00010203"
+                .decode_hex()
+                .unwrap()
+        );
+        assert_eq!(addr.encoded_size(), 21);
+    }
+
+    #[test]
+    fn test_address_decoding() {
+        let data = "03000102030405060708090a0b0c0d0e0f00010203"
+            .decode_hex()
+            .unwrap();
+
+        let addr = deserialize::<Address>(&data).unwrap();
+        assert!(!addr.is_treasury());
+        assert_eq!(
+            addr.to_string(),
+            "pc1rqqqsyqcyq5rqwzqfpg9scrgwpuqqzqsr36kkra"
+        );
+    }
+
+    #[test]
+    fn test_address_string() {
+        struct TestCase<'a> {
+            name: &'a str,
+            addr_type: AddressType,
+            pub_hash: &'a str,
+            expected_addr: &'a str,
+        }
+
+        // Define a list of test cases for encoding and decoding
+        let test_cases = vec![
+            TestCase {
+                name: "Type Treasury (0)",
+                addr_type: AddressType::Treasury,
+                pub_hash: "0000000000000000000000000000000000000000",
+                expected_addr: TREASURY_ADDRESS_STRING,
+            },
+            TestCase {
+                name: "Type Validator (1)",
+                addr_type: AddressType::Validator,
+                pub_hash: "000102030405060708090a0b0c0d0e0f00010203",
+                expected_addr: "pc1pqqqsyqcyq5rqwzqfpg9scrgwpuqqzqsr803qet",
+            },
+            TestCase {
+                name: "Type BLS-Account (2)",
+                addr_type: AddressType::BlsAccount,
+                pub_hash: "000102030405060708090a0b0c0d0e0f00010203",
+                expected_addr: "pc1zqqqsyqcyq5rqwzqfpg9scrgwpuqqzqsr6ypawk",
+            },
+            TestCase {
+                name: "Type Secp256k1-Account (3)",
+                addr_type: AddressType::Ed25519Account,
+                pub_hash: "000102030405060708090a0b0c0d0e0f00010203",
+                expected_addr: "pc1rqqqsyqcyq5rqwzqfpg9scrgwpuqqzqsr36kkra",
+            },
+        ];
+
+        for case in test_cases {
+            let pub_hash_data = case.pub_hash.decode_hex().unwrap();
+            let addr = Address {
+                addr_type: case.addr_type,
+                pub_hash: Address::vec_to_pub_hash(pub_hash_data).unwrap(),
+            };
+
+            let addr_str = addr.to_string();
+            assert_eq!(addr_str, case.expected_addr, "test {} failed", case.name);
+        }
+    }
+
+    #[test]
+    fn test_encodable() {
+        let expected_data = "03b281dee7850ca2272d9ba95b16d48030821aaf27"
+            .decode_hex()
+            .unwrap();
+        let private_key = PrivateKey::try_from(
+            "afeefca74d9a325cf1d6b6911d61a65c32afa8e02bd5e78e2e4ac2910bab45f5",
+        )
+        .unwrap();
+        let address = Address::from_public_key(&private_key.public()).unwrap();
+        let mut w = Vec::new();
+
+        address.encode(&mut w).unwrap();
+
+        assert_eq!(expected_data, w.to_vec(),);
+        assert_eq!(expected_data.len(), address.encoded_size());
+    }
+
+    #[test]
+    fn test_address_from_private_key() {
+        let private_key_data = "4e51f1f3721f644ac7a193be7f5e7b8c2abaa3467871daf4eacb5d3af080e5d6"
+            .decode_hex()
+            .unwrap();
+        let private_key = PrivateKey::try_from(private_key_data.as_slice()).unwrap();
+        let public_key = private_key.public();
+        let address = Address::from_public_key(&public_key).unwrap();
+
+        let expected_public_key =
+            "95794161374b22c696dabb98e93f6ca9300b22f3b904921fbf560bb72145f4fa";
+        let expected_address = "pc1rwzvr8rstdqypr80ag3t6hqrtnss9nwymcxy3lr";
+
+        assert_eq!(public_key.to_bytes().to_hex(), expected_public_key);
+        assert_eq!(address.to_string(), expected_address);
+    }
+}
diff --git a/rust/chains/tw_pactus/src/types/amount.rs b/rust/chains/tw_pactus/src/types/amount.rs
new file mode 100644
index 000000000000..84c9e156e6af
--- /dev/null
+++ b/rust/chains/tw_pactus/src/types/amount.rs
@@ -0,0 +1,20 @@
+use crate::encoder::{error::Error, var_int::VarInt, Decodable, Encodable};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Amount(pub i64);
+
+impl Encodable for Amount {
+    fn encode(&self, w: &mut dyn std::io::Write) -> Result<(), Error> {
+        VarInt::from(self.0 as usize).encode(w)
+    }
+
+    fn encoded_size(&self) -> usize {
+        VarInt::from(self.0 as usize).encoded_size()
+    }
+}
+
+impl Decodable for Amount {
+    fn decode(r: &mut dyn std::io::Read) -> Result<Self, Error> {
+        Ok(Amount(*VarInt::decode(r)? as i64))
+    }
+}
diff --git a/rust/chains/tw_pactus/src/types/mod.rs b/rust/chains/tw_pactus/src/types/mod.rs
new file mode 100644
index 000000000000..ff66b91c4f4e
--- /dev/null
+++ b/rust/chains/tw_pactus/src/types/mod.rs
@@ -0,0 +1,7 @@
+pub mod address;
+pub mod amount;
+pub mod validator_public_key;
+
+pub use address::Address;
+pub use amount::Amount;
+pub use validator_public_key::ValidatorPublicKey;
diff --git a/rust/chains/tw_pactus/src/types/validator_public_key.rs b/rust/chains/tw_pactus/src/types/validator_public_key.rs
new file mode 100644
index 000000000000..844257741433
--- /dev/null
+++ b/rust/chains/tw_pactus/src/types/validator_public_key.rs
@@ -0,0 +1,105 @@
+use crate::encoder::error::Error;
+use crate::encoder::{decode::decode_fix_slice, encode::encode_fix_slice};
+use crate::encoder::{Decodable, Encodable};
+use bech32::FromBase32;
+use std::str::FromStr;
+use tw_keypair::KeyPairError;
+
+pub const BLS_PUBLIC_KEY_SIZE: usize = 96;
+pub const PUBLIC_KEY_HRP: &str = "public";
+
+#[derive(Debug)]
+pub struct ValidatorPublicKey(pub [u8; BLS_PUBLIC_KEY_SIZE]);
+
+impl Encodable for ValidatorPublicKey {
+    fn encode(&self, w: &mut dyn std::io::Write) -> Result<(), Error> {
+        encode_fix_slice(&self.0, w)
+    }
+
+    fn encoded_size(&self) -> usize {
+        BLS_PUBLIC_KEY_SIZE
+    }
+}
+
+impl Decodable for ValidatorPublicKey {
+    fn decode(r: &mut dyn std::io::Read) -> Result<Self, Error> {
+        Ok(ValidatorPublicKey(decode_fix_slice::<BLS_PUBLIC_KEY_SIZE>(
+            r,
+        )?))
+    }
+}
+
+impl FromStr for ValidatorPublicKey {
+    type Err = KeyPairError;
+
+    fn from_str(s: &str) -> Result<Self, KeyPairError> {
+        let (hrp, b32, _variant) = bech32::decode(s).map_err(|_| KeyPairError::InvalidPublicKey)?;
+        if hrp != PUBLIC_KEY_HRP {
+            return Err(KeyPairError::InvalidPublicKey);
+        }
+
+        let b8 = Vec::<u8>::from_base32(&b32[1..]).map_err(|_| KeyPairError::InvalidPublicKey)?;
+        let pub_data = b8.try_into().map_err(|_| KeyPairError::InvalidPublicKey)?;
+
+        Ok(ValidatorPublicKey(pub_data))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::str::FromStr;
+
+    use tw_encoding::hex::DecodeHex;
+
+    use crate::types::ValidatorPublicKey;
+
+    #[test]
+    fn test_public_key_string() {
+        struct TestCase<'a> {
+            name: &'a str,
+            pub_key_str: &'a str,
+            pub_key_data: &'a str,
+        }
+
+        // Define a list of test cases for encoding and decoding
+        let test_cases = vec![
+            TestCase {
+                name: "invalid checksum",
+                pub_key_str: "public1p4u8hfytl2pj6l9rj0t54gxcdmna4hq52ncqkkqjf3arha5mlk3x4mzpyjkhmdl20jae7f65aamjrvqcvf4sudcapz52ctcwc8r9wz3z2gwxs38880cgvfy49ta5ssyjut05myd4zgmjqstggmetyuyg7v5jhx470",
+                pub_key_data: "",
+            },
+            TestCase {
+                name: "invalid length: 95",
+                pub_key_str: "public1p4u8hfytl2pj6l9rj0t54gxcdmna4hq52ncqkkqjf3arha5mlk3x4mzpyjkhmdl20jae7f65aamjrvqcvf4sudcapz52ctcwc8r9wz3z2gwxs38880cgvfy49ta5ssyjut05myd4zgmjqstggmetyuyg73y98kl",
+                pub_key_data: "",
+            },
+            TestCase {
+                name: "invalid HRP",
+                pub_key_str: "xxx1p4u8hfytl2pj6l9rj0t54gxcdmna4hq52ncqkkqjf3arha5mlk3x4mzpyjkhmdl20jae7f65aamjrvqcvf4sudcapz52ctcwc8r9wz3z2gwxs38880cgvfy49ta5ssyjut05myd4zgmjqstggmetyuyg7v5evslaq",
+                pub_key_data: "",
+            },
+            TestCase {
+                name: "OK",
+                pub_key_str: "public1p4u8hfytl2pj6l9rj0t54gxcdmna4hq52ncqkkqjf3arha5mlk3x4mzpyjkhmdl20jae7f65aamjrvqcvf4sudcapz52ctcwc8r9wz3z2gwxs38880cgvfy49ta5ssyjut05myd4zgmjqstggmetyuyg7v5jhx47a",
+                pub_key_data: "af0f74917f5065af94727ae9541b0ddcfb5b828a9e016b02498f477ed37fb44d5d882495afb6fd4f9773e4ea9deee436030c4d61c6e3a1151585e1d838cae1444a438d089ce77e10c492a55f6908125c5be9b236a246e4082d08de564e111e65",
+            },
+       ];
+
+        for case in test_cases {
+            let pub_key_data = case.pub_key_data.decode_hex().unwrap().to_vec();
+            let test_result = ValidatorPublicKey::from_str(case.pub_key_str);
+
+            if pub_key_data.is_empty() {
+                assert!(test_result.is_err());
+            } else {
+                assert!(test_result.is_ok());
+                assert_eq!(
+                    test_result.unwrap().0.to_vec(),
+                    pub_key_data,
+                    "test {} failed",
+                    case.name
+                );
+            }
+        }
+    }
+}
diff --git a/rust/chains/tw_ronin/src/entry.rs b/rust/chains/tw_ronin/src/entry.rs
index 49a21c71c0cf..3905a5215173 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 5fd330739fe1..c2a6b46f24f3 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 63bd4e92df78..5c0539c9e29d 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 9f93134601fe..5baa749c8946 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 a2bd5aadc2d7..efc0fc8995c0 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 22def1d3750d..321cd8410eaf 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 8098fc4ad93d..0083a98f2bc2 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 6f582b0976be..53d0967a09f7 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 d0f18810a20b..653c68787e1a 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 0edb5ea65be2..ab0287f42767 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 000000000000..f0fd5e7b1094
--- /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/encode/compact_integer.rs b/rust/frameworks/tw_utxo/src/encode/compact_integer.rs
index 4a95a3786993..ec4e3ae9d2e3 100644
--- a/rust/frameworks/tw_utxo/src/encode/compact_integer.rs
+++ b/rust/frameworks/tw_utxo/src/encode/compact_integer.rs
@@ -64,17 +64,22 @@ mod tests {
         let mut stream = Stream::default();
 
         stream
-            .append(&CompactInteger::from(0_usize))
+            .append(&CompactInteger::from(0x00_usize))
             .append(&CompactInteger::from(0xfc_usize))
             .append(&CompactInteger::from(0xfd_usize))
             .append(&CompactInteger::from(0xffff_usize))
-            .append(&CompactInteger::from(0x10000_usize))
+            .append(&CompactInteger::from(0x01_0000_usize))
             .append(&CompactInteger::from(0xffff_ffff_usize))
-            .append(&CompactInteger(0x1_0000_0000_u64));
+            .append(&CompactInteger(0x01_0000_0000_u64));
 
         let expected = vec![
-            0_u8, 0xfc, 0xfd, 0xfd, 0x00, 0xfd, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x01, 0x00, 0xfe,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+            0x00, // 0x00
+            0xfc, // 0xfc
+            0xfd, 0xfd, 0x00, // 0xfd
+            0xfd, 0xff, 0xff, // 0xffff
+            0xfe, 0x00, 0x00, 0x01, 0x00, // 0x01_0000
+            0xfe, 0xff, 0xff, 0xff, 0xff, // 0xffff_ffff
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // 0x01_0000_0000
         ];
 
         assert_eq!(stream.out(), expected);
diff --git a/rust/frameworks/tw_utxo/src/lib.rs b/rust/frameworks/tw_utxo/src/lib.rs
index 84748580dedf..3e44914ac420 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 079881fcd8c5..7600a1e5ba81 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 f0e83b169c8d..01306025711d 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 85d9cd89f05c..b3a23671893a 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 6983bb99848a..05976df99efb 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 bbbc4d13bf67..059a8c57a8f8 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 b23f576ab7bc..7bff39d1ea01 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" }
@@ -24,6 +25,7 @@ tw_memory = { path = "../tw_memory" }
 tw_misc = { path = "../tw_misc" }
 tw_native_evmos = { path = "../chains/tw_native_evmos" }
 tw_native_injective = { path = "../chains/tw_native_injective" }
+tw_pactus = { path = "../chains/tw_pactus" }
 tw_ronin = { path = "../chains/tw_ronin" }
 tw_solana = { path = "../chains/tw_solana" }
 tw_sui = { path = "../chains/tw_sui" }
diff --git a/rust/tw_coin_registry/src/blockchain_type.rs b/rust/tw_coin_registry/src/blockchain_type.rs
index a91e4172813a..cde37c58cded 100644
--- a/rust/tw_coin_registry/src/blockchain_type.rs
+++ b/rust/tw_coin_registry/src/blockchain_type.rs
@@ -12,12 +12,14 @@ pub enum BlockchainType {
     Aptos,
     Binance,
     Bitcoin,
+    BitcoinCash,
     Cosmos,
     Ethereum,
     Greenfield,
     InternetComputer,
     NativeEvmos,
     NativeInjective,
+    Pactus,
     Ronin,
     Solana,
     Sui,
diff --git a/rust/tw_coin_registry/src/dispatcher.rs b/rust/tw_coin_registry/src/dispatcher.rs
index bda3fdba9311..d08784ccd56d 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;
@@ -18,6 +19,7 @@ use tw_greenfield::entry::GreenfieldEntry;
 use tw_internet_computer::entry::InternetComputerEntry;
 use tw_native_evmos::entry::NativeEvmosEntry;
 use tw_native_injective::entry::NativeInjectiveEntry;
+use tw_pactus::entry::PactusEntry;
 use tw_ronin::entry::RoninEntry;
 use tw_solana::entry::SolanaEntry;
 use tw_sui::entry::SuiEntry;
@@ -31,12 +33,14 @@ 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;
 const INTERNET_COMPUTER: InternetComputerEntry = InternetComputerEntry;
 const NATIVE_EVMOS: NativeEvmosEntry = NativeEvmosEntry;
 const NATIVE_INJECTIVE: NativeInjectiveEntry = NativeInjectiveEntry;
+const PACTUS: PactusEntry = PactusEntry;
 const RONIN: RoninEntry = RoninEntry;
 const SOLANA: SolanaEntry = SolanaEntry;
 const SUI: SuiEntry = SuiEntry;
@@ -50,12 +54,14 @@ 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),
         BlockchainType::InternetComputer => Ok(&INTERNET_COMPUTER),
         BlockchainType::NativeEvmos => Ok(&NATIVE_EVMOS),
         BlockchainType::NativeInjective => Ok(&NATIVE_INJECTIVE),
+        BlockchainType::Pactus => Ok(&PACTUS),
         BlockchainType::Ronin => Ok(&RONIN),
         BlockchainType::Solana => Ok(&SOLANA),
         BlockchainType::Sui => Ok(&SUI),
diff --git a/rust/tw_encoding/src/bech32.rs b/rust/tw_encoding/src/bech32.rs
index c0365763baaa..97e184e5513f 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 410761a24102..5b76d84eeb31 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 000000000000..45dfce10f59c
--- /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 000000000000..16a55185d3da
--- /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 000000000000..8802ca9963df
--- /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 000000000000..7e2ebc4aa6ba
--- /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 000000000000..3fe081a5c606
--- /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 000000000000..f78cc75a1f59
--- /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 000000000000..f3607dc337b9
--- /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 000000000000..fc959a82f8c3
--- /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 0f587a6d26a2..d048ec74a008 100644
--- a/rust/tw_tests/tests/chains/mod.rs
+++ b/rust/tw_tests/tests/chains/mod.rs
@@ -5,14 +5,17 @@
 mod aptos;
 mod binance;
 mod bitcoin;
+mod bitcoincash;
 mod common;
 mod cosmos;
 mod dydx;
+mod ecash;
 mod ethereum;
 mod greenfield;
 mod internet_computer;
 mod native_evmos;
 mod native_injective;
+mod pactus;
 mod solana;
 mod sui;
 mod tbinance;
diff --git a/rust/tw_tests/tests/chains/pactus/mod.rs b/rust/tw_tests/tests/chains/pactus/mod.rs
new file mode 100644
index 000000000000..88e8edb4017d
--- /dev/null
+++ b/rust/tw_tests/tests/chains/pactus/mod.rs
@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+mod pactus_address;
+mod pactus_compile;
+mod pactus_sign;
+mod pactus_transaction_util;
+mod test_cases;
diff --git a/rust/tw_tests/tests/chains/pactus/pactus_address.rs b/rust/tw_tests/tests/chains/pactus/pactus_address.rs
new file mode 100644
index 000000000000..9d64d1590a75
--- /dev/null
+++ b/rust/tw_tests/tests/chains/pactus/pactus_address.rs
@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use tw_any_coin::test_utils::address_utils::{
+    test_address_derive, test_address_get_data, test_address_invalid, test_address_normalization,
+    test_address_valid,
+};
+use tw_coin_registry::coin_type::CoinType;
+
+#[test]
+fn test_pactus_address_derive() {
+    test_address_derive(
+        CoinType::Pactus,
+        "2134ae97465505dfd5a1fd05a8a0f146209c601eb3f1b0363b4cfe4b47ba1ab4",
+        "pc1r7jkvfnegf0rf5ua05fzu9krjhjxcrrygl3v4nl",
+    );
+}
+
+#[test]
+fn test_pactus_address_normalization() {
+    test_address_normalization(
+        CoinType::Pactus,
+        "pc1r7jkvfnegf0rf5ua05fzu9krjhjxcrrygl3v4nl",
+        "pc1r7jkvfnegf0rf5ua05fzu9krjhjxcrrygl3v4nl",
+    );
+}
+
+#[test]
+fn test_pactus_address_is_valid() {
+    test_address_valid(
+        CoinType::Pactus,
+        "000000000000000000000000000000000000000000",
+    );
+    test_address_valid(
+        CoinType::Pactus,
+        "pc1p0hrct7eflrpw4ccrttxzs4qud2axex4dcdzdfr",
+    );
+    test_address_valid(
+        CoinType::Pactus,
+        "pc1zzqkzzu4vyddss052as6c37qrdcfptegquw826x",
+    );
+    test_address_valid(
+        CoinType::Pactus,
+        "pc1r7jkvfnegf0rf5ua05fzu9krjhjxcrrygl3v4nl",
+    );
+}
+
+#[test]
+fn test_pactus_address_invalid() {
+    test_address_invalid(CoinType::Pactus, "");
+    test_address_invalid(CoinType::Pactus, "00");
+    test_address_invalid(CoinType::Pactus, "not_proper_encoded");
+    test_address_invalid(CoinType::Pactus, "pc1ioiooi");
+    test_address_invalid(CoinType::Pactus, "pc19p72rf");
+    test_address_invalid(
+        CoinType::Pactus,
+        "qc1z0hrct7eflrpw4ccrttxzs4qud2axex4dh8zz75",
+    );
+    test_address_invalid(
+        CoinType::Pactus,
+        "pc1p0hrct7eflrpw4ccrttxzs4qud2axex4dg8xaf5",
+    ); // invalid checksum
+    test_address_invalid(
+        CoinType::Pactus,
+        "pc1p0hrct7eflrpw4ccrttxzs4qud2axexs2dhdk8",
+    ); // invalid length
+    test_address_invalid(
+        CoinType::Pactus,
+        "pc1y0hrct7eflrpw4ccrttxzs4qud2axex4dksmred",
+    ); // invalid type
+}
+
+#[test]
+fn test_pactus_address_get_data() {
+    test_address_get_data(
+        CoinType::Pactus,
+        "000000000000000000000000000000000000000000",
+        "000000000000000000000000000000000000000000",
+    );
+    test_address_get_data(
+        CoinType::Pactus,
+        "pc1p0hrct7eflrpw4ccrttxzs4qud2axex4dcdzdfr",
+        "017dc785fb29f8c2eae3035acc28541c6aba6c9aad",
+    );
+    test_address_get_data(
+        CoinType::Pactus,
+        "pc1zzqkzzu4vyddss052as6c37qrdcfptegquw826x",
+        "02102c2172ac235b083e8aec3588f8036e1215e500",
+    );
+    test_address_get_data(
+        CoinType::Pactus,
+        "pc1r7jkvfnegf0rf5ua05fzu9krjhjxcrrygl3v4nl",
+        "03f4acc4cf284bc69a73afa245c2d872bc8d818c88",
+    );
+}
diff --git a/rust/tw_tests/tests/chains/pactus/pactus_compile.rs b/rust/tw_tests/tests/chains/pactus/pactus_compile.rs
new file mode 100644
index 000000000000..df0be68a0cea
--- /dev/null
+++ b/rust/tw_tests/tests/chains/pactus/pactus_compile.rs
@@ -0,0 +1,140 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use crate::chains::pactus::test_cases::PRIVATE_KEY;
+use crate::chains::pactus::test_cases::{bond_test_case, transfer_test_case};
+use tw_any_coin::ffi::tw_transaction_compiler::{
+    tw_transaction_compiler_compile, tw_transaction_compiler_pre_image_hashes,
+};
+use tw_coin_entry::error::prelude::*;
+use tw_coin_registry::coin_type::CoinType;
+use tw_encoding::hex::ToHex;
+use tw_keypair::ed25519;
+use tw_keypair::traits::{KeyPairTrait, SigningKeyTrait};
+use tw_memory::test_utils::tw_data_helper::TWDataHelper;
+use tw_memory::test_utils::tw_data_vector_helper::TWDataVectorHelper;
+use tw_misc::traits::ToBytesVec;
+use tw_proto::Pactus::Proto;
+use tw_proto::TxCompiler::Proto as CompilerProto;
+use tw_proto::{deserialize, serialize};
+
+#[test]
+fn test_pactus_transfer_compile() {
+    // Step 1: Create signing input.
+    let input = transfer_test_case::sign_input();
+
+    // Step 2: Obtain preimage hash
+    let input_data = TWDataHelper::create(serialize(&input).unwrap());
+    let preimage_data = TWDataHelper::wrap(unsafe {
+        tw_transaction_compiler_pre_image_hashes(CoinType::Pactus as u32, input_data.ptr())
+    })
+    .to_vec()
+    .expect("!tw_transaction_compiler_pre_image_hashes returned nullptr");
+
+    let preimage: CompilerProto::PreSigningOutput =
+        deserialize(&preimage_data).expect("Coin entry returned an invalid output");
+
+    assert_eq!(preimage.error, SigningErrorType::OK);
+    assert!(preimage.error_message.is_empty());
+    assert_eq!(preimage.data.to_hex(), transfer_test_case::SIGN_BYTES);
+
+    // Step 3: Sign the data "externally"
+    let private_key = ed25519::sha512::KeyPair::try_from(PRIVATE_KEY).unwrap();
+    let public_key = private_key.public().to_vec();
+
+    let signature = private_key
+        .sign(preimage.data.to_vec())
+        .expect("Error signing data")
+        .to_vec();
+    assert_eq!(signature.to_hex(), transfer_test_case::SIGNATURE);
+
+    // Step 4: Compile transaction info
+
+    let signatures = TWDataVectorHelper::create([signature]);
+    let public_keys = TWDataVectorHelper::create([public_key]);
+
+    let input_data = TWDataHelper::create(serialize(&input).unwrap());
+    let output_data = TWDataHelper::wrap(unsafe {
+        tw_transaction_compiler_compile(
+            CoinType::Pactus as u32,
+            input_data.ptr(),
+            signatures.ptr(),
+            public_keys.ptr(),
+        )
+    })
+    .to_vec()
+    .expect("!tw_transaction_compiler_compile returned nullptr");
+
+    let output: Proto::SigningOutput =
+        deserialize(&output_data).expect("Coin entry returned an invalid output");
+
+    assert_eq!(output.error, SigningErrorType::OK);
+    assert!(output.error_message.is_empty());
+    assert_eq!(output.transaction_id.to_hex(), transfer_test_case::TX_ID);
+    assert_eq!(output.signature.to_hex(), transfer_test_case::SIGNATURE);
+    assert_eq!(
+        output.signed_transaction_data.to_hex(),
+        transfer_test_case::SIGNED_DATA
+    );
+}
+
+#[test]
+fn test_pactus_bond_compile() {
+    // Step 1: Create signing input.
+    let input = bond_test_case::sign_input();
+
+    // Step 2: Obtain preimage hash
+    let input_data = TWDataHelper::create(serialize(&input).unwrap());
+    let preimage_data = TWDataHelper::wrap(unsafe {
+        tw_transaction_compiler_pre_image_hashes(CoinType::Pactus as u32, input_data.ptr())
+    })
+    .to_vec()
+    .expect("!tw_transaction_compiler_pre_image_hashes returned nullptr");
+
+    let preimage: CompilerProto::PreSigningOutput =
+        deserialize(&preimage_data).expect("Coin entry returned an invalid output");
+
+    assert_eq!(preimage.error, SigningErrorType::OK);
+    assert!(preimage.error_message.is_empty());
+    assert_eq!(preimage.data.to_hex(), bond_test_case::SIGN_BYTES);
+
+    // Step 3: Sign the data "externally"
+    let private_key = ed25519::sha512::KeyPair::try_from(PRIVATE_KEY).unwrap();
+    let public_key = private_key.public().to_vec();
+
+    let signature = private_key
+        .sign(preimage.data.to_vec())
+        .expect("Error signing data")
+        .to_vec();
+    assert_eq!(signature.to_hex(), bond_test_case::SIGNATURE);
+
+    // Step 4: Compile transaction info
+
+    let signatures = TWDataVectorHelper::create([signature]);
+    let public_keys = TWDataVectorHelper::create([public_key]);
+
+    let input_data = TWDataHelper::create(serialize(&input).unwrap());
+    let output_data = TWDataHelper::wrap(unsafe {
+        tw_transaction_compiler_compile(
+            CoinType::Pactus as u32,
+            input_data.ptr(),
+            signatures.ptr(),
+            public_keys.ptr(),
+        )
+    })
+    .to_vec()
+    .expect("!tw_transaction_compiler_compile returned nullptr");
+
+    let output: Proto::SigningOutput =
+        deserialize(&output_data).expect("Coin entry returned an invalid output");
+
+    assert_eq!(output.error, SigningErrorType::OK);
+    assert!(output.error_message.is_empty());
+    assert_eq!(output.transaction_id.to_hex(), bond_test_case::TX_ID);
+    assert_eq!(output.signature.to_hex(), bond_test_case::SIGNATURE);
+    assert_eq!(
+        output.signed_transaction_data.to_hex(),
+        bond_test_case::SIGNED_DATA
+    );
+}
diff --git a/rust/tw_tests/tests/chains/pactus/pactus_sign.rs b/rust/tw_tests/tests/chains/pactus/pactus_sign.rs
new file mode 100644
index 000000000000..d7bb20f7836f
--- /dev/null
+++ b/rust/tw_tests/tests/chains/pactus/pactus_sign.rs
@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use crate::chains::pactus::test_cases::PRIVATE_KEY;
+use crate::chains::pactus::test_cases::{
+    bond_test_case,
+    transfer_test_case,
+    bond_without_public_key_test_case,
+};
+use tw_any_coin::ffi::tw_any_signer::tw_any_signer_sign;
+use tw_coin_entry::error::prelude::*;
+use tw_coin_registry::coin_type::CoinType;
+use tw_encoding::hex::{DecodeHex, ToHex};
+use tw_memory::test_utils::tw_data_helper::TWDataHelper;
+use tw_proto::Pactus::Proto;
+use tw_proto::{deserialize, serialize};
+
+#[test]
+fn test_pactus_sign_transfer() {
+    let input = Proto::SigningInput {
+        private_key: PRIVATE_KEY.decode_hex().unwrap().into(),
+        ..transfer_test_case::sign_input()
+    };
+
+    let input_data = TWDataHelper::create(serialize(&input).unwrap());
+
+    let output = TWDataHelper::wrap(unsafe {
+        tw_any_signer_sign(input_data.ptr(), CoinType::Pactus as u32)
+    })
+    .to_vec()
+    .expect("!tw_any_signer_sign returned nullptr");
+
+    let output: Proto::SigningOutput = deserialize(&output).unwrap();
+
+    assert_eq!(output.error, SigningErrorType::OK);
+    assert!(output.error_message.is_empty());
+    assert_eq!(output.transaction_id.to_hex(), transfer_test_case::TX_ID);
+    assert_eq!(output.signature.to_hex(), transfer_test_case::SIGNATURE);
+    assert_eq!(
+        output.signed_transaction_data.to_hex(),
+        transfer_test_case::SIGNED_DATA
+    );
+}
+
+#[test]
+fn test_pactus_sign_bond() {
+    let input = Proto::SigningInput {
+        private_key: PRIVATE_KEY.decode_hex().unwrap().into(),
+        ..bond_test_case::sign_input()
+    };
+
+    let input_data = TWDataHelper::create(serialize(&input).unwrap());
+
+    let output = TWDataHelper::wrap(unsafe {
+        tw_any_signer_sign(input_data.ptr(), CoinType::Pactus as u32)
+    })
+    .to_vec()
+    .expect("!tw_any_signer_sign returned nullptr");
+
+    let output: Proto::SigningOutput = deserialize(&output).unwrap();
+
+    assert_eq!(output.error, SigningErrorType::OK);
+    assert!(output.error_message.is_empty());
+    assert_eq!(output.transaction_id.to_hex(), bond_test_case::TX_ID);
+    assert_eq!(output.signature.to_hex(), bond_test_case::SIGNATURE);
+    assert_eq!(
+        output.signed_transaction_data.to_hex(),
+        bond_test_case::SIGNED_DATA
+    );
+}
+
+#[test]
+fn test_pactus_sign_bond_without_public_key() {
+    let input = Proto::SigningInput {
+        private_key: PRIVATE_KEY.decode_hex().unwrap().into(),
+        ..bond_without_public_key_test_case::sign_input()
+    };
+
+    let input_data = TWDataHelper::create(serialize(&input).unwrap());
+
+    let output = TWDataHelper::wrap(unsafe {
+        tw_any_signer_sign(input_data.ptr(), CoinType::Pactus as u32)
+    })
+        .to_vec()
+        .expect("!tw_any_signer_sign returned nullptr");
+
+    let output: Proto::SigningOutput = deserialize(&output).unwrap();
+
+    assert_eq!(output.error, SigningErrorType::OK);
+    assert!(output.error_message.is_empty());
+    assert_eq!(output.transaction_id.to_hex(), bond_without_public_key_test_case::TX_ID);
+    assert_eq!(output.signature.to_hex(), bond_without_public_key_test_case::SIGNATURE);
+    assert_eq!(
+        output.signed_transaction_data.to_hex(),
+        bond_without_public_key_test_case::SIGNED_DATA
+    );
+}
\ No newline at end of file
diff --git a/rust/tw_tests/tests/chains/pactus/pactus_transaction_util.rs b/rust/tw_tests/tests/chains/pactus/pactus_transaction_util.rs
new file mode 100644
index 000000000000..43cd8c676f03
--- /dev/null
+++ b/rust/tw_tests/tests/chains/pactus/pactus_transaction_util.rs
@@ -0,0 +1,36 @@
+use tw_any_coin::test_utils::transaction_calc_tx_hash_utils::TransactionUtilHelper;
+use tw_coin_registry::coin_type::CoinType;
+
+use crate::chains::pactus::test_cases::{bond_test_case, transfer_test_case};
+
+#[test]
+fn test_pactus_transaction_util_calc_tx_hash() {
+    struct TestCase<'a> {
+        tx_hex: &'a str,
+        tx_id: &'a str,
+    }
+
+    let test_cases = vec![
+        TestCase {
+            tx_hex: transfer_test_case::NOT_SIGNED_DATA,
+            tx_id: transfer_test_case::TX_ID,
+        },
+        TestCase {
+            tx_hex: transfer_test_case::SIGNED_DATA,
+            tx_id: transfer_test_case::TX_ID,
+        },
+        TestCase {
+            tx_hex: bond_test_case::NOT_SIGNED_DATA,
+            tx_id: bond_test_case::TX_ID,
+        },
+        TestCase {
+            tx_hex: bond_test_case::NOT_SIGNED_DATA,
+            tx_id: bond_test_case::TX_ID,
+        },
+    ];
+
+    for case in test_cases {
+        let tx_hash = TransactionUtilHelper::calc_tx_hash(CoinType::Pactus, case.tx_hex);
+        assert_eq!(tx_hash, case.tx_id);
+    }
+}
diff --git a/rust/tw_tests/tests/chains/pactus/test_cases.rs b/rust/tw_tests/tests/chains/pactus/test_cases.rs
new file mode 100644
index 000000000000..4a934c41236b
--- /dev/null
+++ b/rust/tw_tests/tests/chains/pactus/test_cases.rs
@@ -0,0 +1,179 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use tw_proto::Pactus::Proto;
+
+/// A macro to define three constants: `SIGN_BYTES`, `NOT_SIGNED_DATA`, and `SIGNED_DATA`.
+/// Transaction format explained here: https://docs.pactus.org/protocol/transaction/format/
+macro_rules! define_expected_data {
+    (  $tx_id:expr,
+       $signature:expr,
+       $public_key:expr
+       $(, $param:expr)*,
+    ) => {
+        pub const SIGN_BYTES: &str = concat!(
+            $( $param, )*
+        );
+
+        pub const NOT_SIGNED_DATA: &str = concat!(
+            "02", // Not Sign Flag
+            $($param, )*
+        );
+
+        pub const SIGNED_DATA: &str = concat!(
+            "00", // Signed Flag
+            $($param, )*
+            $signature,
+            $public_key
+        );
+
+        pub const TX_ID: &str = $tx_id;
+        pub const SIGNATURE: &str  = $signature;
+    };
+}
+
+// Private key for all the test cases
+pub const PRIVATE_KEY: &str = "4e51f1f3721f644ac7a193be7f5e7b8c2abaa3467871daf4eacb5d3af080e5d6";
+
+// Successfully broadcasted transfer transaction:
+// https://pacviewer.com/transaction/1b6b7226f7935a15f05371d1a1fefead585a89704ce464b7cc1d453d299d235f
+pub mod transfer_test_case {
+    use super::*;
+    use tw_encoding::hex::DecodeHex;
+
+    define_expected_data!(
+        "1b6b7226f7935a15f05371d1a1fefead585a89704ce464b7cc1d453d299d235f", // transaction ID
+        "4ed8fee3d8992e82660dd05bbe8608fc56ceabffdeeee61e3213b9b49d33a0fc\
+         8dea6d79ee7ec60f66433f189ed9b3c50b2ad6fa004e26790ee736693eda8506", // Signature
+        "95794161374b22c696dabb98e93f6ca9300b22f3b904921fbf560bb72145f4fa", // PublicKey
+        "01",                                                               // Version
+        "24a32300",                                                         // LockTime
+        "80ade204",                                                         // Fee
+        "0b77616c6c65742d636f7265",                                         // Memo
+        "01",                                                               // PayloadType
+        "037098338e0b6808119dfd4457ab806b9c2059b89b",                       // Sender
+        "037a14ae24533816e7faaa6ed28fcdde8e55a7df21",                       // Receiver
+        "8084af5f",                                                         // Amount
+    );
+
+    pub fn sign_input() -> Proto::SigningInput<'static> {
+        let transfer_payload = Proto::TransferPayload {
+            sender: "pc1rwzvr8rstdqypr80ag3t6hqrtnss9nwymcxy3lr".into(),
+            receiver: "pc1r0g22ufzn8qtw0742dmfglnw73e260hep0k3yra".into(),
+            amount: 200000000,
+        };
+
+        let transaction = Proto::TransactionMessage {
+            lock_time: 2335524,
+            fee: 10000000,
+            memo: "wallet-core".into(),
+            payload: Proto::mod_TransactionMessage::OneOfpayload::transfer(transfer_payload),
+        };
+
+        let private_key_bytes = PRIVATE_KEY.decode_hex().unwrap();
+
+        Proto::SigningInput {
+            transaction: Some(transaction),
+            private_key: private_key_bytes.into(),
+        }
+    }
+}
+
+// Successfully broadcasted bond transaction:
+// https://pacviewer.com/transaction/d194b445642a04ec78ced4448696e50b733f2f0b517a23871882c0eefaf1c28f
+pub mod bond_test_case {
+    use super::*;
+    use tw_encoding::hex::DecodeHex;
+
+    define_expected_data!(
+        "d194b445642a04ec78ced4448696e50b733f2f0b517a23871882c0eefaf1c28f", // transaction ID
+        "0d7bc6d94927534b89e2f53bcfc9fc849e0e2982438955eda55b4338328adac7\
+         9d4ee3216d143f0e1629764ab650734f8ba188e716d71f9eff65e39ce7006300", // Signature
+        "95794161374b22c696dabb98e93f6ca9300b22f3b904921fbf560bb72145f4fa", // PublicKey
+        "01",                                                               // Version
+        "c1b02300",                                                         // LockTime
+        "80ade204",                                                         // Fee
+        "0b77616c6c65742d636f7265",                                         // Memo
+        "02",                                                               // PayloadType
+        "037098338e0b6808119dfd4457ab806b9c2059b89b",                       // Sender
+        "0129288df0bf7bd4b5e9eeed8b932d0c76f451823d",                       // Receiver
+        "60\
+         98bd4dc20b03460a651c661dd9f10f17797049cac62a9fef228832bbcc3a3935\
+         5cdf15b68bddf432f1ab3eab8debe1300aa43724834650866a9d552827a56bbc\
+         dde32e3c517079589b54e83d16f9435abb3b2de8c3e677067cc0644ccb13833b", // Validator Public key
+        "8094ebdc03",                                                       // Stake
+    );
+
+    pub fn sign_input() -> Proto::SigningInput<'static> {
+        let bond_payload = Proto::BondPayload {
+            sender: "pc1rwzvr8rstdqypr80ag3t6hqrtnss9nwymcxy3lr".into(),
+            receiver: "pc1p9y5gmu9l002tt60wak9extgvwm69rq3a9ackrl".into(),
+            stake: 1000000000,
+            public_key: "public1pnz75msstqdrq5eguvcwanug0zauhqjw2cc4flmez3qethnp68y64ehc4k69amapj7x4na2uda0snqz4yxujgx3jsse4f64fgy7jkh0xauvhrc5ts09vfk48g85t0js66hvajm6xruemsvlxqv3xvkyur8v9v0mtn".into()
+        };
+
+        let transaction = Proto::TransactionMessage {
+            lock_time: 2339009,
+            fee: 10000000,
+            memo: "wallet-core".into(),
+            payload: Proto::mod_TransactionMessage::OneOfpayload::bond(bond_payload),
+        };
+
+        let private_key_bytes = PRIVATE_KEY.decode_hex().unwrap();
+
+        Proto::SigningInput {
+            transaction: Some(transaction),
+            private_key: private_key_bytes.into(),
+        }
+    }
+}
+
+// Successfully broadcasted bond without public key transaction:
+// https://pacviewer.com/transaction/f83f583a5c40adf93a90ea536a7e4b467d30ca4f308d5da52624d80c42adec80
+//
+// If the validator exists and has already been staked, there’s no need to send the public key.
+// If the validator does not exist, the public key is required, as it is not indexed on the chain.
+pub mod bond_without_public_key_test_case {
+    use super::*;
+    use tw_encoding::hex::DecodeHex;
+
+    define_expected_data!(
+        "f83f583a5c40adf93a90ea536a7e4b467d30ca4f308d5da52624d80c42adec80", // transaction ID
+        "9e6279fb64067c7d7316ac74630bbb8589df268aa4548f1c7d85c087a8748ff0\
+         715b9149afbd94c5d8ee6b37c787ec63e963cbb38be513ebc436aa58f9a8f00d", // Signature
+        "95794161374b22c696dabb98e93f6ca9300b22f3b904921fbf560bb72145f4fa", // PublicKey
+        "01",                                                               // Version
+        "5ca32300",                                                         // LockTime
+        "80ade204",                                                         // Fee
+        "0b77616c6c65742d636f7265",                                         // Memo
+        "02",                                                               // PayloadType
+        "037098338e0b6808119dfd4457ab806b9c2059b89b",                       // Sender
+        "01d2fa2a7d560502199995ea260954f064d90278be",                       // Receiver
+        "00",                                                               // Public key zero
+        "8094ebdc03",                                                       // Stake
+    );
+
+    pub fn sign_input() -> Proto::SigningInput<'static> {
+        let bond_payload = Proto::BondPayload {
+            sender: "pc1rwzvr8rstdqypr80ag3t6hqrtnss9nwymcxy3lr".into(),
+            receiver: "pc1p6taz5l2kq5ppnxv4agnqj48svnvsy797xpe6wd".into(),
+            stake: 1000000000,
+            public_key: Default::default(),
+        };
+
+        let transaction = Proto::TransactionMessage {
+            lock_time: 2335580,
+            fee: 10000000,
+            memo: "wallet-core".into(),
+            payload: Proto::mod_TransactionMessage::OneOfpayload::bond(bond_payload),
+        };
+
+        let private_key_bytes = PRIVATE_KEY.decode_hex().unwrap();
+
+        Proto::SigningInput {
+            transaction: Some(transaction),
+            private_key: private_key_bytes.into(),
+        }
+    }
+}
\ No newline at end of file
diff --git a/rust/tw_tests/tests/coin_address_derivation_test.rs b/rust/tw_tests/tests/coin_address_derivation_test.rs
index c0b66f78a961..4f7e27b93759 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",
@@ -155,6 +153,7 @@ fn test_coin_address_derivation() {
             CoinType::Solana => "5sn9QYhDaq61jLXJ8Li5BKqGL4DDMJQvU1rdN8XgVuwC",
             CoinType::Sui => "0x01a5c6c1b74cec4fbd12b3e17252b83448136065afcdf24954dc3a9c26df4905",
             CoinType::TON => "UQCj3jAU_Ec2kXdAqweKt4rYjiwTNwiCfaUnIDHGh7wTwx_G",
+            CoinType::Pactus => "pc1rk2qaaeu9pj3zwtvm49d3d4yqxzpp4te87cx0am",
             // end_of_coin_address_derivation_tests_marker_do_not_modify
             _ => panic!("{:?} must be covered", coin),
         };
diff --git a/samples/typescript/devconsole.ts/.gitignore b/samples/typescript/devconsole.ts/.gitignore
deleted file mode 100644
index 83dbaee65a89..000000000000
--- a/samples/typescript/devconsole.ts/.gitignore
+++ /dev/null
@@ -1,3 +0,0 @@
-node_modules
-lib
-
diff --git a/samples/typescript/devconsole.ts/README.md b/samples/typescript/devconsole.ts/README.md
deleted file mode 100644
index 40ed8e5045d2..000000000000
--- a/samples/typescript/devconsole.ts/README.md
+++ /dev/null
@@ -1,34 +0,0 @@
-# Devconsole.ts
-
-`Devconsole.ts` is a command-line utility to quickly work with `wallet-core` library.
-It is based on `node` `typescript` console, and uses the WASM version of `wallet-core`.
-
-Type `help()` after starting it.
-
-Some wallet-core namespaces are exposed, and methods can be called directly.
-
-Note that auto-completion works in the console.
-
-## Build:
-
-```
-cd samples/typescript/devconsole.ts
-npm install
-npm run build
-npm run start
-```
-
-## Sample usage:
-
-```
-> help()
-This is an interactive typescript shell, to work with wallet-core (wasm)
-You can use:
-...
-> w1 = HDWallet.create(256, '')
-W {}
-> w1.mnemonic()
-'round profit immense ... sniff'
-> w1.getAddressForCoin(CoinType.cosmos)
-'cosmos1kgd25tvkz3jtuee4cl796trc2s0hjsfgqmhmku'
-```
diff --git a/samples/typescript/devconsole.ts/package-lock.json b/samples/typescript/devconsole.ts/package-lock.json
deleted file mode 100644
index aafb3d70d376..000000000000
--- a/samples/typescript/devconsole.ts/package-lock.json
+++ /dev/null
@@ -1,1491 +0,0 @@
-{
-  "name": "cli-wasm",
-  "version": "0.0.1",
-  "lockfileVersion": 2,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "cli-wasm",
-      "version": "0.0.1",
-      "license": "MIT",
-      "dependencies": {
-        "@trustwallet/wallet-core": "3.0.8",
-        "chalk": "^4.1.2",
-        "clear": "^0.1.0",
-        "figlet": "^1.5.2",
-        "inquirer": "^8.2.4"
-      },
-      "bin": {
-        "cli": "index.ts"
-      },
-      "devDependencies": {
-        "@types/node": "^18.7.15",
-        "ts-node": "^10.9.1",
-        "typescript": "^4.8.2"
-      }
-    },
-    "node_modules/@cspotcode/source-map-support": {
-      "version": "0.8.1",
-      "resolved": "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz",
-      "integrity": "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==",
-      "dev": true,
-      "dependencies": {
-        "@jridgewell/trace-mapping": "0.3.9"
-      },
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@jridgewell/resolve-uri": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz",
-      "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==",
-      "dev": true,
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@jridgewell/sourcemap-codec": {
-      "version": "1.4.14",
-      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz",
-      "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw==",
-      "dev": true
-    },
-    "node_modules/@jridgewell/trace-mapping": {
-      "version": "0.3.9",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz",
-      "integrity": "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==",
-      "dev": true,
-      "dependencies": {
-        "@jridgewell/resolve-uri": "^3.0.3",
-        "@jridgewell/sourcemap-codec": "^1.4.10"
-      }
-    },
-    "node_modules/@protobufjs/aspromise": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz",
-      "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ=="
-    },
-    "node_modules/@protobufjs/base64": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz",
-      "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg=="
-    },
-    "node_modules/@protobufjs/codegen": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.4.tgz",
-      "integrity": "sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg=="
-    },
-    "node_modules/@protobufjs/eventemitter": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz",
-      "integrity": "sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q=="
-    },
-    "node_modules/@protobufjs/fetch": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.0.tgz",
-      "integrity": "sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==",
-      "dependencies": {
-        "@protobufjs/aspromise": "^1.1.1",
-        "@protobufjs/inquire": "^1.1.0"
-      }
-    },
-    "node_modules/@protobufjs/float": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz",
-      "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ=="
-    },
-    "node_modules/@protobufjs/inquire": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@protobufjs/inquire/-/inquire-1.1.0.tgz",
-      "integrity": "sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q=="
-    },
-    "node_modules/@protobufjs/path": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz",
-      "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA=="
-    },
-    "node_modules/@protobufjs/pool": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz",
-      "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw=="
-    },
-    "node_modules/@protobufjs/utf8": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.0.tgz",
-      "integrity": "sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw=="
-    },
-    "node_modules/@trustwallet/wallet-core": {
-      "version": "3.0.8",
-      "resolved": "https://registry.npmjs.org/@trustwallet/wallet-core/-/wallet-core-3.0.8.tgz",
-      "integrity": "sha512-u0ST2xZL6oWCAMmZRKQVxBLhNtOu/tYByVl9OEfd8SbAGHVjW/6V+oVmHAqBL/z3fwfZfYg2LY08AW831ZNwoQ==",
-      "dependencies": {
-        "protobufjs": ">=6.11.3"
-      }
-    },
-    "node_modules/@tsconfig/node10": {
-      "version": "1.0.9",
-      "resolved": "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.9.tgz",
-      "integrity": "sha512-jNsYVVxU8v5g43Erja32laIDHXeoNvFEpX33OK4d6hljo3jDhCBDhx5dhCCTMWUojscpAagGiRkBKxpdl9fxqA==",
-      "dev": true
-    },
-    "node_modules/@tsconfig/node12": {
-      "version": "1.0.11",
-      "resolved": "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz",
-      "integrity": "sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==",
-      "dev": true
-    },
-    "node_modules/@tsconfig/node14": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz",
-      "integrity": "sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==",
-      "dev": true
-    },
-    "node_modules/@tsconfig/node16": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.3.tgz",
-      "integrity": "sha512-yOlFc+7UtL/89t2ZhjPvvB/DeAr3r+Dq58IgzsFkOAvVC6NMJXmCGjbptdXdR9qsX7pKcTL+s87FtYREi2dEEQ==",
-      "dev": true
-    },
-    "node_modules/@types/node": {
-      "version": "18.7.15",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.15.tgz",
-      "integrity": "sha512-XnjpaI8Bgc3eBag2Aw4t2Uj/49lLBSStHWfqKvIuXD7FIrZyMLWp8KuAFHAqxMZYTF9l08N1ctUn9YNybZJVmQ=="
-    },
-    "node_modules/acorn": {
-      "version": "8.8.0",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.0.tgz",
-      "integrity": "sha512-QOxyigPVrpZ2GXT+PFyZTl6TtOFc5egxHIP9IlQ+RbupQuX4RkT/Bee4/kQuC02Xkzg84JcT7oLYtDIQxp+v7w==",
-      "dev": true,
-      "bin": {
-        "acorn": "bin/acorn"
-      },
-      "engines": {
-        "node": ">=0.4.0"
-      }
-    },
-    "node_modules/acorn-walk": {
-      "version": "8.2.0",
-      "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.2.0.tgz",
-      "integrity": "sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==",
-      "dev": true,
-      "engines": {
-        "node": ">=0.4.0"
-      }
-    },
-    "node_modules/ansi-escapes": {
-      "version": "4.3.2",
-      "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz",
-      "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==",
-      "dependencies": {
-        "type-fest": "^0.21.3"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/ansi-regex": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
-      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-      "dependencies": {
-        "color-convert": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/arg": {
-      "version": "4.1.3",
-      "resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz",
-      "integrity": "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==",
-      "dev": true
-    },
-    "node_modules/base64-js": {
-      "version": "1.5.1",
-      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
-      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ]
-    },
-    "node_modules/bl": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz",
-      "integrity": "sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==",
-      "dependencies": {
-        "buffer": "^5.5.0",
-        "inherits": "^2.0.4",
-        "readable-stream": "^3.4.0"
-      }
-    },
-    "node_modules/bl/node_modules/inherits": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
-      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
-    },
-    "node_modules/buffer": {
-      "version": "5.7.1",
-      "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz",
-      "integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
-      "dependencies": {
-        "base64-js": "^1.3.1",
-        "ieee754": "^1.1.13"
-      }
-    },
-    "node_modules/chalk": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
-      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
-      "dependencies": {
-        "ansi-styles": "^4.1.0",
-        "supports-color": "^7.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/chalk?sponsor=1"
-      }
-    },
-    "node_modules/chardet": {
-      "version": "0.7.0",
-      "resolved": "https://registry.npmjs.org/chardet/-/chardet-0.7.0.tgz",
-      "integrity": "sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA=="
-    },
-    "node_modules/clear": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/clear/-/clear-0.1.0.tgz",
-      "integrity": "sha512-qMjRnoL+JDPJHeLePZJuao6+8orzHMGP04A8CdwCNsKhRbOnKRjefxONR7bwILT3MHecxKBjHkKL/tkZ8r4Uzw==",
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/cli-cursor": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-3.1.0.tgz",
-      "integrity": "sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==",
-      "dependencies": {
-        "restore-cursor": "^3.1.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/cli-spinners": {
-      "version": "2.7.0",
-      "resolved": "https://registry.npmjs.org/cli-spinners/-/cli-spinners-2.7.0.tgz",
-      "integrity": "sha512-qu3pN8Y3qHNgE2AFweciB1IfMnmZ/fsNTEE+NOFjmGB2F/7rLhnhzppvpCnN4FovtP26k8lHyy9ptEbNwWFLzw==",
-      "engines": {
-        "node": ">=6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/cli-width": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-3.0.0.tgz",
-      "integrity": "sha512-FxqpkPPwu1HjuN93Omfm4h8uIanXofW0RxVEW3k5RKx+mJJYSthzNhp32Kzxxy3YAEZ/Dc/EWN1vZRY0+kOhbw==",
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/clone": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/clone/-/clone-1.0.4.tgz",
-      "integrity": "sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==",
-      "engines": {
-        "node": ">=0.8"
-      }
-    },
-    "node_modules/color-convert": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-      "dependencies": {
-        "color-name": "~1.1.4"
-      },
-      "engines": {
-        "node": ">=7.0.0"
-      }
-    },
-    "node_modules/color-name": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="
-    },
-    "node_modules/create-require": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz",
-      "integrity": "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==",
-      "dev": true
-    },
-    "node_modules/defaults": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/defaults/-/defaults-1.0.3.tgz",
-      "integrity": "sha512-s82itHOnYrN0Ib8r+z7laQz3sdE+4FP3d9Q7VLO7U+KRT+CR0GsWuyHxzdAY82I7cXv0G/twrqomTJLOssO5HA==",
-      "dependencies": {
-        "clone": "^1.0.2"
-      }
-    },
-    "node_modules/diff": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz",
-      "integrity": "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==",
-      "dev": true,
-      "engines": {
-        "node": ">=0.3.1"
-      }
-    },
-    "node_modules/emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="
-    },
-    "node_modules/escape-string-regexp": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
-      "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
-      "engines": {
-        "node": ">=0.8.0"
-      }
-    },
-    "node_modules/external-editor": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-3.1.0.tgz",
-      "integrity": "sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==",
-      "dependencies": {
-        "chardet": "^0.7.0",
-        "iconv-lite": "^0.4.24",
-        "tmp": "^0.0.33"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/figlet": {
-      "version": "1.5.2",
-      "resolved": "https://registry.npmjs.org/figlet/-/figlet-1.5.2.tgz",
-      "integrity": "sha512-WOn21V8AhyE1QqVfPIVxe3tupJacq1xGkPTB4iagT6o+P2cAgEOOwIxMftr4+ZCTI6d551ij9j61DFr0nsP2uQ==",
-      "engines": {
-        "node": ">= 0.4.0"
-      }
-    },
-    "node_modules/figures": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/figures/-/figures-3.2.0.tgz",
-      "integrity": "sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg==",
-      "dependencies": {
-        "escape-string-regexp": "^1.0.5"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/has-flag": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
-      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/iconv-lite": {
-      "version": "0.4.24",
-      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
-      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
-      "dependencies": {
-        "safer-buffer": ">= 2.1.2 < 3"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/ieee754": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
-      "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ]
-    },
-    "node_modules/inherits": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
-      "integrity": "sha512-x00IRNXNy63jwGkJmzPigoySHbaqpNuzKbBOmzK+g2OdZpQ9w+sxCN+VSB3ja7IAge2OP2qpfxTjeNcyjmW1uw=="
-    },
-    "node_modules/inquirer": {
-      "version": "8.2.4",
-      "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-8.2.4.tgz",
-      "integrity": "sha512-nn4F01dxU8VeKfq192IjLsxu0/OmMZ4Lg3xKAns148rCaXP6ntAoEkVYZThWjwON8AlzdZZi6oqnhNbxUG9hVg==",
-      "dependencies": {
-        "ansi-escapes": "^4.2.1",
-        "chalk": "^4.1.1",
-        "cli-cursor": "^3.1.0",
-        "cli-width": "^3.0.0",
-        "external-editor": "^3.0.3",
-        "figures": "^3.0.0",
-        "lodash": "^4.17.21",
-        "mute-stream": "0.0.8",
-        "ora": "^5.4.1",
-        "run-async": "^2.4.0",
-        "rxjs": "^7.5.5",
-        "string-width": "^4.1.0",
-        "strip-ansi": "^6.0.0",
-        "through": "^2.3.6",
-        "wrap-ansi": "^7.0.0"
-      },
-      "engines": {
-        "node": ">=12.0.0"
-      }
-    },
-    "node_modules/is-fullwidth-code-point": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
-      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/is-interactive": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/is-interactive/-/is-interactive-1.0.0.tgz",
-      "integrity": "sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/is-unicode-supported": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz",
-      "integrity": "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/lodash": {
-      "version": "4.17.21",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
-      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="
-    },
-    "node_modules/log-symbols": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz",
-      "integrity": "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==",
-      "dependencies": {
-        "chalk": "^4.1.0",
-        "is-unicode-supported": "^0.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/long": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/long/-/long-5.2.0.tgz",
-      "integrity": "sha512-9RTUNjK60eJbx3uz+TEGF7fUr29ZDxR5QzXcyDpeSfeH28S9ycINflOgOlppit5U+4kNTe83KQnMEerw7GmE8w=="
-    },
-    "node_modules/make-error": {
-      "version": "1.3.6",
-      "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz",
-      "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==",
-      "dev": true
-    },
-    "node_modules/mimic-fn": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz",
-      "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/mute-stream": {
-      "version": "0.0.8",
-      "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.8.tgz",
-      "integrity": "sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA=="
-    },
-    "node_modules/onetime": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz",
-      "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==",
-      "dependencies": {
-        "mimic-fn": "^2.1.0"
-      },
-      "engines": {
-        "node": ">=6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/ora": {
-      "version": "5.4.1",
-      "resolved": "https://registry.npmjs.org/ora/-/ora-5.4.1.tgz",
-      "integrity": "sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ==",
-      "dependencies": {
-        "bl": "^4.1.0",
-        "chalk": "^4.1.0",
-        "cli-cursor": "^3.1.0",
-        "cli-spinners": "^2.5.0",
-        "is-interactive": "^1.0.0",
-        "is-unicode-supported": "^0.1.0",
-        "log-symbols": "^4.1.0",
-        "strip-ansi": "^6.0.0",
-        "wcwidth": "^1.0.1"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/os-tmpdir": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz",
-      "integrity": "sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/protobufjs": {
-      "version": "7.2.5",
-      "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.2.5.tgz",
-      "integrity": "sha512-gGXRSXvxQ7UiPgfw8gevrfRWcTlSbOFg+p/N+JVJEK5VhueL2miT6qTymqAmjr1Q5WbOCyJbyrk6JfWKwlFn6A==",
-      "hasInstallScript": true,
-      "dependencies": {
-        "@protobufjs/aspromise": "^1.1.2",
-        "@protobufjs/base64": "^1.1.2",
-        "@protobufjs/codegen": "^2.0.4",
-        "@protobufjs/eventemitter": "^1.1.0",
-        "@protobufjs/fetch": "^1.1.0",
-        "@protobufjs/float": "^1.0.2",
-        "@protobufjs/inquire": "^1.1.0",
-        "@protobufjs/path": "^1.1.2",
-        "@protobufjs/pool": "^1.1.0",
-        "@protobufjs/utf8": "^1.1.0",
-        "@types/node": ">=13.7.0",
-        "long": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=12.0.0"
-      }
-    },
-    "node_modules/readable-stream": {
-      "version": "3.6.0",
-      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz",
-      "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==",
-      "dependencies": {
-        "inherits": "^2.0.3",
-        "string_decoder": "^1.1.1",
-        "util-deprecate": "^1.0.1"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "node_modules/restore-cursor": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-3.1.0.tgz",
-      "integrity": "sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==",
-      "dependencies": {
-        "onetime": "^5.1.0",
-        "signal-exit": "^3.0.2"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/run-async": {
-      "version": "2.4.1",
-      "resolved": "https://registry.npmjs.org/run-async/-/run-async-2.4.1.tgz",
-      "integrity": "sha512-tvVnVv01b8c1RrA6Ep7JkStj85Guv/YrMcwqYQnwjsAS2cTmmPGBBjAjpCW7RrSodNSoE2/qg9O4bceNvUuDgQ==",
-      "engines": {
-        "node": ">=0.12.0"
-      }
-    },
-    "node_modules/rxjs": {
-      "version": "7.5.6",
-      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.5.6.tgz",
-      "integrity": "sha512-dnyv2/YsXhnm461G+R/Pe5bWP41Nm6LBXEYWI6eiFP4fiwx6WRI/CD0zbdVAudd9xwLEF2IDcKXLHit0FYjUzw==",
-      "dependencies": {
-        "tslib": "^2.1.0"
-      }
-    },
-    "node_modules/safe-buffer": {
-      "version": "5.2.1",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
-      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ]
-    },
-    "node_modules/safer-buffer": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
-      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="
-    },
-    "node_modules/signal-exit": {
-      "version": "3.0.7",
-      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
-      "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ=="
-    },
-    "node_modules/string_decoder": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
-      "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
-      "dependencies": {
-        "safe-buffer": "~5.2.0"
-      }
-    },
-    "node_modules/string-width": {
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-      "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/strip-ansi": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
-      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
-      "dependencies": {
-        "ansi-regex": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/supports-color": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
-      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
-      "dependencies": {
-        "has-flag": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/through": {
-      "version": "2.3.8",
-      "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
-      "integrity": "sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg=="
-    },
-    "node_modules/tmp": {
-      "version": "0.0.33",
-      "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz",
-      "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==",
-      "dependencies": {
-        "os-tmpdir": "~1.0.2"
-      },
-      "engines": {
-        "node": ">=0.6.0"
-      }
-    },
-    "node_modules/ts-node": {
-      "version": "10.9.1",
-      "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.1.tgz",
-      "integrity": "sha512-NtVysVPkxxrwFGUUxGYhfux8k78pQB3JqYBXlLRZgdGUqTO5wU/UyHop5p70iEbGhB7q5KmiZiU0Y3KlJrScEw==",
-      "dev": true,
-      "dependencies": {
-        "@cspotcode/source-map-support": "^0.8.0",
-        "@tsconfig/node10": "^1.0.7",
-        "@tsconfig/node12": "^1.0.7",
-        "@tsconfig/node14": "^1.0.0",
-        "@tsconfig/node16": "^1.0.2",
-        "acorn": "^8.4.1",
-        "acorn-walk": "^8.1.1",
-        "arg": "^4.1.0",
-        "create-require": "^1.1.0",
-        "diff": "^4.0.1",
-        "make-error": "^1.1.1",
-        "v8-compile-cache-lib": "^3.0.1",
-        "yn": "3.1.1"
-      },
-      "bin": {
-        "ts-node": "dist/bin.js",
-        "ts-node-cwd": "dist/bin-cwd.js",
-        "ts-node-esm": "dist/bin-esm.js",
-        "ts-node-script": "dist/bin-script.js",
-        "ts-node-transpile-only": "dist/bin-transpile.js",
-        "ts-script": "dist/bin-script-deprecated.js"
-      },
-      "peerDependencies": {
-        "@swc/core": ">=1.2.50",
-        "@swc/wasm": ">=1.2.50",
-        "@types/node": "*",
-        "typescript": ">=2.7"
-      },
-      "peerDependenciesMeta": {
-        "@swc/core": {
-          "optional": true
-        },
-        "@swc/wasm": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/tslib": {
-      "version": "2.4.0",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.4.0.tgz",
-      "integrity": "sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ=="
-    },
-    "node_modules/type-fest": {
-      "version": "0.21.3",
-      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz",
-      "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/typescript": {
-      "version": "4.8.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.8.2.tgz",
-      "integrity": "sha512-C0I1UsrrDHo2fYI5oaCGbSejwX4ch+9Y5jTQELvovfmFkK3HHSZJB8MSJcWLmCUBzQBchCrZ9rMRV6GuNrvGtw==",
-      "dev": true,
-      "bin": {
-        "tsc": "bin/tsc",
-        "tsserver": "bin/tsserver"
-      },
-      "engines": {
-        "node": ">=4.2.0"
-      }
-    },
-    "node_modules/util-deprecate": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
-      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="
-    },
-    "node_modules/v8-compile-cache-lib": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz",
-      "integrity": "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==",
-      "dev": true
-    },
-    "node_modules/wcwidth": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/wcwidth/-/wcwidth-1.0.1.tgz",
-      "integrity": "sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==",
-      "dependencies": {
-        "defaults": "^1.0.3"
-      }
-    },
-    "node_modules/wrap-ansi": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
-      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
-      "dependencies": {
-        "ansi-styles": "^4.0.0",
-        "string-width": "^4.1.0",
-        "strip-ansi": "^6.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
-      }
-    },
-    "node_modules/yn": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz",
-      "integrity": "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==",
-      "dev": true,
-      "engines": {
-        "node": ">=6"
-      }
-    }
-  },
-  "dependencies": {
-    "@cspotcode/source-map-support": {
-      "version": "0.8.1",
-      "resolved": "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz",
-      "integrity": "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==",
-      "dev": true,
-      "requires": {
-        "@jridgewell/trace-mapping": "0.3.9"
-      }
-    },
-    "@jridgewell/resolve-uri": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz",
-      "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==",
-      "dev": true
-    },
-    "@jridgewell/sourcemap-codec": {
-      "version": "1.4.14",
-      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz",
-      "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw==",
-      "dev": true
-    },
-    "@jridgewell/trace-mapping": {
-      "version": "0.3.9",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz",
-      "integrity": "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==",
-      "dev": true,
-      "requires": {
-        "@jridgewell/resolve-uri": "^3.0.3",
-        "@jridgewell/sourcemap-codec": "^1.4.10"
-      }
-    },
-    "@protobufjs/aspromise": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz",
-      "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ=="
-    },
-    "@protobufjs/base64": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz",
-      "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg=="
-    },
-    "@protobufjs/codegen": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.4.tgz",
-      "integrity": "sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg=="
-    },
-    "@protobufjs/eventemitter": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz",
-      "integrity": "sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q=="
-    },
-    "@protobufjs/fetch": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.0.tgz",
-      "integrity": "sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==",
-      "requires": {
-        "@protobufjs/aspromise": "^1.1.1",
-        "@protobufjs/inquire": "^1.1.0"
-      }
-    },
-    "@protobufjs/float": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz",
-      "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ=="
-    },
-    "@protobufjs/inquire": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@protobufjs/inquire/-/inquire-1.1.0.tgz",
-      "integrity": "sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q=="
-    },
-    "@protobufjs/path": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz",
-      "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA=="
-    },
-    "@protobufjs/pool": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz",
-      "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw=="
-    },
-    "@protobufjs/utf8": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.0.tgz",
-      "integrity": "sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw=="
-    },
-    "@trustwallet/wallet-core": {
-      "version": "3.0.8",
-      "resolved": "https://registry.npmjs.org/@trustwallet/wallet-core/-/wallet-core-3.0.8.tgz",
-      "integrity": "sha512-u0ST2xZL6oWCAMmZRKQVxBLhNtOu/tYByVl9OEfd8SbAGHVjW/6V+oVmHAqBL/z3fwfZfYg2LY08AW831ZNwoQ==",
-      "requires": {
-        "protobufjs": ">=6.11.3"
-      }
-    },
-    "@tsconfig/node10": {
-      "version": "1.0.9",
-      "resolved": "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.9.tgz",
-      "integrity": "sha512-jNsYVVxU8v5g43Erja32laIDHXeoNvFEpX33OK4d6hljo3jDhCBDhx5dhCCTMWUojscpAagGiRkBKxpdl9fxqA==",
-      "dev": true
-    },
-    "@tsconfig/node12": {
-      "version": "1.0.11",
-      "resolved": "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz",
-      "integrity": "sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==",
-      "dev": true
-    },
-    "@tsconfig/node14": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz",
-      "integrity": "sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==",
-      "dev": true
-    },
-    "@tsconfig/node16": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.3.tgz",
-      "integrity": "sha512-yOlFc+7UtL/89t2ZhjPvvB/DeAr3r+Dq58IgzsFkOAvVC6NMJXmCGjbptdXdR9qsX7pKcTL+s87FtYREi2dEEQ==",
-      "dev": true
-    },
-    "@types/node": {
-      "version": "18.7.15",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.15.tgz",
-      "integrity": "sha512-XnjpaI8Bgc3eBag2Aw4t2Uj/49lLBSStHWfqKvIuXD7FIrZyMLWp8KuAFHAqxMZYTF9l08N1ctUn9YNybZJVmQ=="
-    },
-    "acorn": {
-      "version": "8.8.0",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.0.tgz",
-      "integrity": "sha512-QOxyigPVrpZ2GXT+PFyZTl6TtOFc5egxHIP9IlQ+RbupQuX4RkT/Bee4/kQuC02Xkzg84JcT7oLYtDIQxp+v7w==",
-      "dev": true
-    },
-    "acorn-walk": {
-      "version": "8.2.0",
-      "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.2.0.tgz",
-      "integrity": "sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==",
-      "dev": true
-    },
-    "ansi-escapes": {
-      "version": "4.3.2",
-      "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz",
-      "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==",
-      "requires": {
-        "type-fest": "^0.21.3"
-      }
-    },
-    "ansi-regex": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
-      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="
-    },
-    "ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-      "requires": {
-        "color-convert": "^2.0.1"
-      }
-    },
-    "arg": {
-      "version": "4.1.3",
-      "resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz",
-      "integrity": "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==",
-      "dev": true
-    },
-    "base64-js": {
-      "version": "1.5.1",
-      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
-      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA=="
-    },
-    "bl": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz",
-      "integrity": "sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==",
-      "requires": {
-        "buffer": "^5.5.0",
-        "inherits": "^2.0.4",
-        "readable-stream": "^3.4.0"
-      },
-      "dependencies": {
-        "inherits": {
-          "version": "2.0.4",
-          "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
-          "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
-        }
-      }
-    },
-    "buffer": {
-      "version": "5.7.1",
-      "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz",
-      "integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==",
-      "requires": {
-        "base64-js": "^1.3.1",
-        "ieee754": "^1.1.13"
-      }
-    },
-    "chalk": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
-      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
-      "requires": {
-        "ansi-styles": "^4.1.0",
-        "supports-color": "^7.1.0"
-      }
-    },
-    "chardet": {
-      "version": "0.7.0",
-      "resolved": "https://registry.npmjs.org/chardet/-/chardet-0.7.0.tgz",
-      "integrity": "sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA=="
-    },
-    "clear": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/clear/-/clear-0.1.0.tgz",
-      "integrity": "sha512-qMjRnoL+JDPJHeLePZJuao6+8orzHMGP04A8CdwCNsKhRbOnKRjefxONR7bwILT3MHecxKBjHkKL/tkZ8r4Uzw=="
-    },
-    "cli-cursor": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-3.1.0.tgz",
-      "integrity": "sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==",
-      "requires": {
-        "restore-cursor": "^3.1.0"
-      }
-    },
-    "cli-spinners": {
-      "version": "2.7.0",
-      "resolved": "https://registry.npmjs.org/cli-spinners/-/cli-spinners-2.7.0.tgz",
-      "integrity": "sha512-qu3pN8Y3qHNgE2AFweciB1IfMnmZ/fsNTEE+NOFjmGB2F/7rLhnhzppvpCnN4FovtP26k8lHyy9ptEbNwWFLzw=="
-    },
-    "cli-width": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-3.0.0.tgz",
-      "integrity": "sha512-FxqpkPPwu1HjuN93Omfm4h8uIanXofW0RxVEW3k5RKx+mJJYSthzNhp32Kzxxy3YAEZ/Dc/EWN1vZRY0+kOhbw=="
-    },
-    "clone": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/clone/-/clone-1.0.4.tgz",
-      "integrity": "sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg=="
-    },
-    "color-convert": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-      "requires": {
-        "color-name": "~1.1.4"
-      }
-    },
-    "color-name": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="
-    },
-    "create-require": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz",
-      "integrity": "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==",
-      "dev": true
-    },
-    "defaults": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/defaults/-/defaults-1.0.3.tgz",
-      "integrity": "sha512-s82itHOnYrN0Ib8r+z7laQz3sdE+4FP3d9Q7VLO7U+KRT+CR0GsWuyHxzdAY82I7cXv0G/twrqomTJLOssO5HA==",
-      "requires": {
-        "clone": "^1.0.2"
-      }
-    },
-    "diff": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz",
-      "integrity": "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==",
-      "dev": true
-    },
-    "emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="
-    },
-    "escape-string-regexp": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
-      "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg=="
-    },
-    "external-editor": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-3.1.0.tgz",
-      "integrity": "sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==",
-      "requires": {
-        "chardet": "^0.7.0",
-        "iconv-lite": "^0.4.24",
-        "tmp": "^0.0.33"
-      }
-    },
-    "figlet": {
-      "version": "1.5.2",
-      "resolved": "https://registry.npmjs.org/figlet/-/figlet-1.5.2.tgz",
-      "integrity": "sha512-WOn21V8AhyE1QqVfPIVxe3tupJacq1xGkPTB4iagT6o+P2cAgEOOwIxMftr4+ZCTI6d551ij9j61DFr0nsP2uQ=="
-    },
-    "figures": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/figures/-/figures-3.2.0.tgz",
-      "integrity": "sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg==",
-      "requires": {
-        "escape-string-regexp": "^1.0.5"
-      }
-    },
-    "has-flag": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
-      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="
-    },
-    "iconv-lite": {
-      "version": "0.4.24",
-      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
-      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
-      "requires": {
-        "safer-buffer": ">= 2.1.2 < 3"
-      }
-    },
-    "ieee754": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
-      "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA=="
-    },
-    "inherits": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
-      "integrity": "sha512-x00IRNXNy63jwGkJmzPigoySHbaqpNuzKbBOmzK+g2OdZpQ9w+sxCN+VSB3ja7IAge2OP2qpfxTjeNcyjmW1uw=="
-    },
-    "inquirer": {
-      "version": "8.2.4",
-      "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-8.2.4.tgz",
-      "integrity": "sha512-nn4F01dxU8VeKfq192IjLsxu0/OmMZ4Lg3xKAns148rCaXP6ntAoEkVYZThWjwON8AlzdZZi6oqnhNbxUG9hVg==",
-      "requires": {
-        "ansi-escapes": "^4.2.1",
-        "chalk": "^4.1.1",
-        "cli-cursor": "^3.1.0",
-        "cli-width": "^3.0.0",
-        "external-editor": "^3.0.3",
-        "figures": "^3.0.0",
-        "lodash": "^4.17.21",
-        "mute-stream": "0.0.8",
-        "ora": "^5.4.1",
-        "run-async": "^2.4.0",
-        "rxjs": "^7.5.5",
-        "string-width": "^4.1.0",
-        "strip-ansi": "^6.0.0",
-        "through": "^2.3.6",
-        "wrap-ansi": "^7.0.0"
-      }
-    },
-    "is-fullwidth-code-point": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
-      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="
-    },
-    "is-interactive": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/is-interactive/-/is-interactive-1.0.0.tgz",
-      "integrity": "sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w=="
-    },
-    "is-unicode-supported": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz",
-      "integrity": "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw=="
-    },
-    "lodash": {
-      "version": "4.17.21",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
-      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="
-    },
-    "log-symbols": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz",
-      "integrity": "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==",
-      "requires": {
-        "chalk": "^4.1.0",
-        "is-unicode-supported": "^0.1.0"
-      }
-    },
-    "long": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/long/-/long-5.2.0.tgz",
-      "integrity": "sha512-9RTUNjK60eJbx3uz+TEGF7fUr29ZDxR5QzXcyDpeSfeH28S9ycINflOgOlppit5U+4kNTe83KQnMEerw7GmE8w=="
-    },
-    "make-error": {
-      "version": "1.3.6",
-      "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz",
-      "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==",
-      "dev": true
-    },
-    "mimic-fn": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz",
-      "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg=="
-    },
-    "mute-stream": {
-      "version": "0.0.8",
-      "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.8.tgz",
-      "integrity": "sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA=="
-    },
-    "onetime": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz",
-      "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==",
-      "requires": {
-        "mimic-fn": "^2.1.0"
-      }
-    },
-    "ora": {
-      "version": "5.4.1",
-      "resolved": "https://registry.npmjs.org/ora/-/ora-5.4.1.tgz",
-      "integrity": "sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ==",
-      "requires": {
-        "bl": "^4.1.0",
-        "chalk": "^4.1.0",
-        "cli-cursor": "^3.1.0",
-        "cli-spinners": "^2.5.0",
-        "is-interactive": "^1.0.0",
-        "is-unicode-supported": "^0.1.0",
-        "log-symbols": "^4.1.0",
-        "strip-ansi": "^6.0.0",
-        "wcwidth": "^1.0.1"
-      }
-    },
-    "os-tmpdir": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz",
-      "integrity": "sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g=="
-    },
-    "protobufjs": {
-      "version": "7.2.5",
-      "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.2.5.tgz",
-      "integrity": "sha512-gGXRSXvxQ7UiPgfw8gevrfRWcTlSbOFg+p/N+JVJEK5VhueL2miT6qTymqAmjr1Q5WbOCyJbyrk6JfWKwlFn6A==",
-      "requires": {
-        "@protobufjs/aspromise": "^1.1.2",
-        "@protobufjs/base64": "^1.1.2",
-        "@protobufjs/codegen": "^2.0.4",
-        "@protobufjs/eventemitter": "^1.1.0",
-        "@protobufjs/fetch": "^1.1.0",
-        "@protobufjs/float": "^1.0.2",
-        "@protobufjs/inquire": "^1.1.0",
-        "@protobufjs/path": "^1.1.2",
-        "@protobufjs/pool": "^1.1.0",
-        "@protobufjs/utf8": "^1.1.0",
-        "@types/node": ">=13.7.0",
-        "long": "^5.0.0"
-      }
-    },
-    "readable-stream": {
-      "version": "3.6.0",
-      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz",
-      "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==",
-      "requires": {
-        "inherits": "^2.0.3",
-        "string_decoder": "^1.1.1",
-        "util-deprecate": "^1.0.1"
-      }
-    },
-    "restore-cursor": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-3.1.0.tgz",
-      "integrity": "sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==",
-      "requires": {
-        "onetime": "^5.1.0",
-        "signal-exit": "^3.0.2"
-      }
-    },
-    "run-async": {
-      "version": "2.4.1",
-      "resolved": "https://registry.npmjs.org/run-async/-/run-async-2.4.1.tgz",
-      "integrity": "sha512-tvVnVv01b8c1RrA6Ep7JkStj85Guv/YrMcwqYQnwjsAS2cTmmPGBBjAjpCW7RrSodNSoE2/qg9O4bceNvUuDgQ=="
-    },
-    "rxjs": {
-      "version": "7.5.6",
-      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.5.6.tgz",
-      "integrity": "sha512-dnyv2/YsXhnm461G+R/Pe5bWP41Nm6LBXEYWI6eiFP4fiwx6WRI/CD0zbdVAudd9xwLEF2IDcKXLHit0FYjUzw==",
-      "requires": {
-        "tslib": "^2.1.0"
-      }
-    },
-    "safe-buffer": {
-      "version": "5.2.1",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
-      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="
-    },
-    "safer-buffer": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
-      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="
-    },
-    "signal-exit": {
-      "version": "3.0.7",
-      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
-      "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ=="
-    },
-    "string_decoder": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
-      "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
-      "requires": {
-        "safe-buffer": "~5.2.0"
-      }
-    },
-    "string-width": {
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-      "requires": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      }
-    },
-    "strip-ansi": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
-      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
-      "requires": {
-        "ansi-regex": "^5.0.1"
-      }
-    },
-    "supports-color": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
-      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
-      "requires": {
-        "has-flag": "^4.0.0"
-      }
-    },
-    "through": {
-      "version": "2.3.8",
-      "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
-      "integrity": "sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg=="
-    },
-    "tmp": {
-      "version": "0.0.33",
-      "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz",
-      "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==",
-      "requires": {
-        "os-tmpdir": "~1.0.2"
-      }
-    },
-    "ts-node": {
-      "version": "10.9.1",
-      "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.1.tgz",
-      "integrity": "sha512-NtVysVPkxxrwFGUUxGYhfux8k78pQB3JqYBXlLRZgdGUqTO5wU/UyHop5p70iEbGhB7q5KmiZiU0Y3KlJrScEw==",
-      "dev": true,
-      "requires": {
-        "@cspotcode/source-map-support": "^0.8.0",
-        "@tsconfig/node10": "^1.0.7",
-        "@tsconfig/node12": "^1.0.7",
-        "@tsconfig/node14": "^1.0.0",
-        "@tsconfig/node16": "^1.0.2",
-        "acorn": "^8.4.1",
-        "acorn-walk": "^8.1.1",
-        "arg": "^4.1.0",
-        "create-require": "^1.1.0",
-        "diff": "^4.0.1",
-        "make-error": "^1.1.1",
-        "v8-compile-cache-lib": "^3.0.1",
-        "yn": "3.1.1"
-      }
-    },
-    "tslib": {
-      "version": "2.4.0",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.4.0.tgz",
-      "integrity": "sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ=="
-    },
-    "type-fest": {
-      "version": "0.21.3",
-      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz",
-      "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w=="
-    },
-    "typescript": {
-      "version": "4.8.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.8.2.tgz",
-      "integrity": "sha512-C0I1UsrrDHo2fYI5oaCGbSejwX4ch+9Y5jTQELvovfmFkK3HHSZJB8MSJcWLmCUBzQBchCrZ9rMRV6GuNrvGtw==",
-      "dev": true
-    },
-    "util-deprecate": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
-      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="
-    },
-    "v8-compile-cache-lib": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz",
-      "integrity": "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==",
-      "dev": true
-    },
-    "wcwidth": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/wcwidth/-/wcwidth-1.0.1.tgz",
-      "integrity": "sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==",
-      "requires": {
-        "defaults": "^1.0.3"
-      }
-    },
-    "wrap-ansi": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
-      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
-      "requires": {
-        "ansi-styles": "^4.0.0",
-        "string-width": "^4.1.0",
-        "strip-ansi": "^6.0.0"
-      }
-    },
-    "yn": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz",
-      "integrity": "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==",
-      "dev": true
-    }
-  }
-}
diff --git a/samples/typescript/devconsole.ts/package.json b/samples/typescript/devconsole.ts/package.json
deleted file mode 100644
index 64e52dc3f100..000000000000
--- a/samples/typescript/devconsole.ts/package.json
+++ /dev/null
@@ -1,28 +0,0 @@
-{
-  "name": "cli-wasm",
-  "version": "0.0.1",
-  "description": "CLI utility for Wallet Core, through WASM",
-  "main": "index.ts",
-  "bin": {
-    "cli": "index.ts"
-  },
-  "scripts": {
-    "start": "ts-node src/index.ts",
-    "build": "tsc -p .",
-    "test": "cat test/data/privpubkey.testinput.txt | ts-node src/index.ts"
-  },
-  "author": "Trust Wallet",
-  "license": "MIT",
-  "dependencies": {
-    "@trustwallet/wallet-core": "3.0.8",
-    "chalk": "^4.1.2",
-    "clear": "^0.1.0",
-    "figlet": "^1.5.2",
-    "inquirer": "^8.2.4"
-  },
-  "devDependencies": {
-    "@types/node": "^18.7.15",
-    "ts-node": "^10.9.1",
-    "typescript": "^4.8.2"
-  }
-}
diff --git a/samples/typescript/devconsole.ts/samplescripts/bitcoin.addresses.sampleinput.txt b/samples/typescript/devconsole.ts/samplescripts/bitcoin.addresses.sampleinput.txt
deleted file mode 100644
index 9c7201110a7e..000000000000
--- a/samples/typescript/devconsole.ts/samplescripts/bitcoin.addresses.sampleinput.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-// Derive Bitcoin addresses of different flavor
-
-coin = CoinType.bitcoin
-
-privKeyData = '0xafeefca74d9a325cf1d6b6911d61a65c32afa8e02bd5e78e2e4ac2910bab45f5';
-privKey = PrivateKey.createWithData(HexCoding.decode(privKeyData));
-pubKey = privKey.getPublicKeySecp256k1(true);
-address11 = SegwitAddress.createWithPublicKey(HRP.bitcoin, pubKey).description();
-
-// This is not yet possible yet through AnyAddress
-// TWAnyAddressCreateWithPublicKeyDerivation
-address21 = AnyAddress.createWithPublicKey(pubKey, coin);
-address21.description()
-
-// This is not yet possible yet through HDWallet
-// TWHDWalletGetKeyDerivation
-// TWHDWalletGetAddressDerivation
-wallet = HDWallet.createWithMnemonic('ripple scissors kick mammal hire column oak again sun offer wealth tomorrow wagon turn fatal', '');
-address = wallet.getAddressForCoin(coin);
diff --git a/samples/typescript/devconsole.ts/samplescripts/privkeysign.sampleinput.txt b/samples/typescript/devconsole.ts/samplescripts/privkeysign.sampleinput.txt
deleted file mode 100644
index 05a6b7a776f9..000000000000
--- a/samples/typescript/devconsole.ts/samplescripts/privkeysign.sampleinput.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-// Create a private key, sign a message, derive public key from private key, verify signature
-
-privKeyData = '0xafeefca74d9a325cf1d6b6911d61a65c32afa8e02bd5e78e2e4ac2910bab45f5'
-messageDigest = '0001020304050607080910111213141519171819202122232425262728293031'
-
-privkey = PrivateKey.createWithData(HexCoding.decode(privKeyData)); HexCoding.encode(privkey.data())
-
-sig1 = privkey.sign(HexCoding.decode(messageDigest), Curve.secp256k1); HexCoding.encode(sig1)
-
-pubkey = privkey.getPublicKeySecp256k1(true); HexCoding.encode(pubkey.data())
-
-verifyRes = pubkey.verify(sig1, HexCoding.decode(messageDigest))
diff --git a/samples/typescript/devconsole.ts/samplescripts/protoeth.sampleinput.txt b/samples/typescript/devconsole.ts/samplescripts/protoeth.sampleinput.txt
deleted file mode 100644
index 422d16881d46..000000000000
--- a/samples/typescript/devconsole.ts/samplescripts/protoeth.sampleinput.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-// test signing eip1559 erc20 transfer tx
-
-input = TW.Ethereum.Proto.SigningInput.create({
-      toAddress: "0x6b175474e89094c44da98b954eedeac495271d0f",
-      chainId: Buffer.from("01", "hex"),
-      nonce: Buffer.from("00", "hex"),
-      txMode: TW.Ethereum.Proto.TransactionMode.Enveloped,
-      maxInclusionFeePerGas: Buffer.from("0077359400", "hex"),
-      maxFeePerGas: Buffer.from("00b2d05e00", "hex"),
-      gasLimit: Buffer.from("0130B9", "hex"),
-      transaction: TW.Ethereum.Proto.Transaction.create({
-        erc20Transfer: TW.Ethereum.Proto.Transaction.ERC20Transfer.create({
-          to: "0x5322b34c88ed0691971bf52a7047448f0f4efc84",
-          amount: Buffer.from("1bc16d674ec80000", "hex"),
-        }),
-      }),
-      privateKey: HexCoding.decode(
-        "0x608dcb1742bb3fb7aec002074e3420e4fab7d00cced79ccdac53ed5b27138151"
-      ),
-    });
-
-encoded = TW.Ethereum.Proto.SigningInput.encode(input).finish(); HexCoding.encode(encoded)
-
-outputData = AnySigner.sign(encoded, CoinType.ethereum); HexCoding.encode(outputData)
-
-output = TW.Ethereum.Proto.SigningOutput.decode(outputData); HexCoding.encode(output.encoded)
diff --git a/samples/typescript/devconsole.ts/samplescripts/solanaaddress.sampleinput.txt b/samples/typescript/devconsole.ts/samplescripts/solanaaddress.sampleinput.txt
deleted file mode 100644
index c2796a598b8e..000000000000
--- a/samples/typescript/devconsole.ts/samplescripts/solanaaddress.sampleinput.txt
+++ /dev/null
@@ -1,13 +0,0 @@
-// Derive a Solana address directly and through privKey-pubKey
-
-coin = CoinType.solana
-
-wallet = HDWallet.createWithMnemonic('ripple scissors kick mammal hire column oak again sun offer wealth tomorrow wagon turn fatal', '')
-
-address = wallet.getAddressForCoin(coin)
-
-pk = wallet.getKeyForCoin(coin); HexCoding.encode(pk.data())
-pubkey = pk.getPublicKeyEd25519(); HexCoding.encode(pubkey.data())
-a1 = AnyAddress.createWithPublicKey(pubkey, coin); a1.description()
-
-address === a1.description()
diff --git a/samples/typescript/devconsole.ts/samplescripts/wallets.sampleinput.txt b/samples/typescript/devconsole.ts/samplescripts/wallets.sampleinput.txt
deleted file mode 100644
index 415993f3d4e0..000000000000
--- a/samples/typescript/devconsole.ts/samplescripts/wallets.sampleinput.txt
+++ /dev/null
@@ -1,51 +0,0 @@
-// Delete all wallets to start with empty state (commented out not to accidentally remove data)
-//await walletsDeleteAll('deleteall')
-
-// create a wallet
-await walletCreate(256, 'First')
-await walletsList()
-await walletDump()
-
-// add an extra coin to it
-await walletAddCoin(WC.CoinType.solana)
-await walletDump()
-
-// Create a second wallet by mnemonic import
-await walletImport('ripple scissors kick mammal hire column oak again sun offer wealth tomorrow wagon turn fatal', 'Imported')
-await walletsList()
-await walletDump()
-
-// Load first ...
-await walletsList()
-await walletLoad(0)
-await walletDump()
-
-// ... then second
-await walletsList()
-await walletLoad(1)
-await walletDump()
-
-// retrieve private key and verify that it derives the same address
-coin = WC.CoinType.bitcoin
-privkey = wallets.wallet.wallet.privateKey(coin, 'devconsole.ts')
-pubkey = privkey.getPublicKeySecp256k1(true); HexCoding.encode(pubkey.data())
-addrDerived = AnyAddress.createWithPublicKey(pubkey, coin).description()
-addrStored = wallets.wallet.wallet.account(0).address()
-addrDerived === addrStored
-
-// create another wallet
-await walletCreate(256, 'Another')
-await walletsList()
-await walletDump()
-
-// Delete it
-await walletDelete('delete')
-await walletsList()
-await walletDump()
-
-await walletLoad(0)
-await walletDump()
-
-// Delete all wallets (commented out not to accidentally remove data)
-//await walletDeleteAll('deleteall')
-//await walletsList()
diff --git a/samples/typescript/devconsole.ts/src/index.ts b/samples/typescript/devconsole.ts/src/index.ts
deleted file mode 100644
index f08c79bd6c84..000000000000
--- a/samples/typescript/devconsole.ts/src/index.ts
+++ /dev/null
@@ -1,366 +0,0 @@
-#!/usr/bin/env ts-node
-
-const chalk = require('chalk');
-const clear = require('clear');
-const figlet = require('figlet');
-const repl = require('node:repl');
-const { initWasm, TW, KeyStore } = require("@trustwallet/wallet-core");
-const fs = require("fs");
-
-function enumerateNamespaces(topLevelNamespace: any) {
-    const exceptions: string[] = ['AsciiToString', 'ExitStatus', 'ENV', 'ERRNO_CODES', 'ERRNO_MESSAGES', 'DNS', 'Protocols', 'Sockets', 'UNWIND_CACHE', 'PATH', 'PATH_FS', 'SYSCALLS', 'JSEvents', 'JSEvents_requestFullscreen', 'JSEvents_resizeCanvasForFullscreen', 'ExceptionInfo', 'Browser', 'FS', 'MEMFS', 'TTY', 'PIPEFS', 'SOCKFS', 'RegisteredClass', 'Emval'];
-    var ns : string[] = [];
-    for (var member in topLevelNamespace) {
-        if (typeof topLevelNamespace[member] == 'function' || typeof topLevelNamespace[member] == 'object') {
-            ns.push(member);
-        }
-    }
-    return ns
-        .filter(n => { var firstLetter = n[0]; return (firstLetter >= 'A' && firstLetter <= 'Z'); })
-        .filter(n => !n.includes('Error'))
-        .filter(n => !n.startsWith('HEAP'))
-        .filter(n => !n.startsWith('UTF'))
-        .filter(n => !n.startsWith('FS_'))
-        .filter(n => !n.startsWith('ClassHandle'))
-        .filter(n => !n.startsWith('RegisteredPointer'))
-        .filter(n => !exceptions.includes(n));
-}
-
-async function main() {
-    // Wrapper for a wallet stored in keystore
-    class StoredKeyWallet {
-        wallet: any; // StoredKey
-        constructor(w: any) {
-            this.wallet = w;
-        }
-        status(): string {
-            return `Wallet '${this.wallet.name()}', with ${this.wallet.accountCount()} addresses`;
-        }
-        dump(): void {
-            console.error(`Wallet '${this.wallet.name()}', ${this.wallet.isMnemonic() ? 'type mnemonic' : ''}:`);
-
-            if (this.wallet.accountCount() == 0) {
-                console.log('No addresses');
-            } else {
-                console.log('Addresses:');
-                const n = this.wallet.accountCount();
-                for (var i = 0; i < n; ++i) {
-                    const a = this.wallet.account(i);
-                    console.log(`  ${WC.CoinTypeConfiguration.getSymbol(a.coin())}:  ${a.address()}`);
-                }
-            }
-        }
-    }
-
-    // Handles several wallets, with keystore
-    class TestWalletManager {
-        // single opened StoredKeyWallet instance
-        wallet: StoredKeyWallet | null = null;
-        StoreFolderPath = "/tmp/devconsole.ts";
-        StoreFixedPassword = "devconsole.ts";
-        HDWalletPassord = '';
-        DefaultCoins: any[] = [];
-        keystore: any = null;
-        // wallets available in storage
-        storeWallets: any[] = [];
-        
-        init(): void {
-            this.DefaultCoins = [WC.CoinType.bitcoin, WC.CoinType.ethereum, WC.CoinType.binance];
-            this.keystore = null;
-            // check and try to create store folder
-            if (!fs.existsSync(this.StoreFolderPath)) {
-                // try to create, ignore error
-                fs.mkdirSync(this.StoreFolderPath);
-            }
-            // check again
-            if (!fs.existsSync(this.StoreFolderPath)) {
-                console.log(`ERROR: Could not open/create storage folder!  Wallet storage will not work.  '${this.StoreFolderPath}'`);
-                return;
-            }
-            const storage = new KeyStore.FileSystemStorage(this.StoreFolderPath);
-            this.keystore = new KeyStore.Default(WC, storage);
-        }
-        async refreshStoreWallets(): Promise<void> {
-            if (!this.keystore) { return; }
-            process.stdout.write(`Refreshing wallets list ... `);
-            try {
-                this.storeWallets = await this.keystore.loadAll();
-                console.log(`found ${this.storeWallets.length} wallets  (dir: ${this.StoreFolderPath})`);
-            } catch (err) {
-                console.log(`Exception: ${err}`);
-            }
-        }
-        async list(): Promise<void> {
-            if (!this.keystore) {
-                console.log(`Keystore not available!`);
-                return;
-            }
-            await this.refreshStoreWallets();
-            if (!this.storeWallets || this.storeWallets.length == 0) {
-                console.log("No wallets found in storage.");
-            } else {
-                let idx = 0;
-                console.log(`Found ${this.storeWallets.length} wallets in storage, use walletLoad(id) to load:`);
-                this.storeWallets.forEach(w => console.log(`${idx++}:  ${w.name} \t${w.activeAccounts.length} addrs  \t${w.id}`));
-            }
-        }
-        async load(index: number) {
-            this.wallet = null;
-            if (!this.keystore) { return; }
-            try {
-                await this.refreshStoreWallets();
-                if (index >= this.storeWallets.length) {
-                    console.log(`Index out of range, max ${this.storeWallets.length}`);
-                    await walletsList();
-                    return;
-                }
-                const id = this.storeWallets[index].id;
-                process.stdout.write(`Loading wallet ${index} ${id} ... `);
-                const wallet = await this.keystore.load(id);
-                console.log("done");
-                this.wallet = new StoredKeyWallet(this.keystore.mapStoredKey(wallet));
-                this.status();
-            } catch (err) {
-                console.log(`Exception: ${err}`);
-            }
-        }
-        async loadAWallet() {
-            if (this.storeWallets.length > 0) {
-                await this.load(0);
-            }
-        }
-        autoFillName(name: string): string {
-            return (name === '') ? `Wallet${(this.storeWallets.length + 1).toString()}` : name;
-        }
-        async create(strength: number, name: string): Promise<StoredKeyWallet | null> {
-            this.wallet = null;
-            if (!this.keystore) { return null; }
-            try {
-                if (name === '') { name = this.autoFillName(name); }
-                const hdWallet = WC.HDWallet.create(strength, this.HDWalletPassord);
-                const storedKey = WC.StoredKey.importHDWallet(hdWallet.mnemonic(), name, Buffer.from(this.StoreFixedPassword), this.DefaultCoins[0]);
-                this.DefaultCoins.forEach((coin) => {
-                    storedKey.accountForCoin(coin, hdWallet);
-                });
-                let wallet = this.keystore.mapWallet(storedKey);
-                await this.keystore.importWallet(wallet);
-                this.wallet = new StoredKeyWallet(storedKey);
-                console.log(`Wallet ${name} created, mnemonic: ${hdWallet.mnemonic()}`);
-                this.status();
-                return this.wallet;
-            } catch (err) {
-                console.log(`Exception: ${err}`);
-                return null;
-            }
-        }
-        async import(mnemonic: string, name: string): Promise<StoredKeyWallet | null> {
-            this.wallet = null;
-            if (!this.keystore) { return null; }
-            try {
-                if (!WC.Mnemonic.isValid(mnemonic)) {
-                    console.error(`Mnemonic is not valid ${mnemonic}`);
-                    return null;
-                }
-                if (name === '') { name = this.autoFillName(name); }
-                // There are two ways to do this here:
-                // 1. Create HDWallet with mnemonic, create StoroedKey with it (add coins), then map to a KeyStore wallet and import it into the storage, or
-                // 2. Import in KeyStore directly (using mnemonic), and obtain StoredKey from it
-                let wallet = await this.keystore.import(mnemonic, name, this.StoreFixedPassword, this.DefaultCoins);
-                this.wallet = new StoredKeyWallet(this.keystore.mapStoredKey(wallet));
-                console.log(`Wallet ${name} imported, mnemonic: ${mnemonic}`);
-                this.status();
-                return this.wallet;
-            } catch (err) {
-                console.log(`Exception: ${err}`);
-                return null;
-            }
-        }
-        async addCoin(coin: string): Promise<StoredKeyWallet | null> {
-            if (this.wallet == null) {
-                console.error('No wallet open, see walletCreate() / walletLoad() / walletsList()');
-                return null;
-            }
-            if (!this.keystore) { return null; }
-            const wallet = await this.keystore.addAccounts(this.wallet?.wallet.identifier(), this.StoreFixedPassword, [coin]);
-            this.wallet = new StoredKeyWallet(this.keystore.mapStoredKey(wallet));
-            return this.wallet;
-        }
-        // Delete loaded wallet
-        async delete(param: string): Promise<void> {
-            if (!this.wallet) {
-                console.log(`No wallet loaded`);
-                return;
-            }
-            if (!this.keystore) { return; }
-                try {
-                if (param !== 'delete') {
-                    console.log(`Are you sure? Invoke with 'delete' parameter!`);
-                    return;
-                }
-                const name = this.wallet.wallet.name();
-                const id = this.wallet.wallet.identifier();
-                await this.keystore.delete(id, this.StoreFixedPassword);
-                this.wallet = null;
-                console.log(`Wallet '${name}' ${id} deleted.`);
-                await this.refreshStoreWallets();
-            } catch (err) {
-                console.log(`Exception: ${err}`);
-            }
-        }
-        async deleteAll(param: string): Promise<void> {
-            await this.refreshStoreWallets();
-            if (this.storeWallets.length == 0) {
-                console.log(`No wallets found`);
-                return;
-            }
-            if (!this.keystore) { return; }
-            try {
-                if (param !== 'deleteall') {
-                    console.log(`Are you sure? Invoke with 'deleteall' parameter!`);
-                    return;
-                }
-                while (this.storeWallets.length > 0) {
-                    const id = this.storeWallets[0].id;
-                    await this.keystore.delete(id, this.StoreFixedPassword);
-                    await this.refreshStoreWallets();
-                }
-                this.wallet = null;
-                console.log(`All wallets deleted.`)
-            } catch (err) {
-                console.log(`Exception: ${err}`);
-            }
-        }
-        status(): void {
-            if (this.wallet === null) {
-                console.error(`No wallet open, ${this.storeWallets.length} available; see walletCreate() / walletLoad() / walletsList()`);
-            } else {
-                console.error(`Wallet open: ${this.wallet.status()}`);
-            }
-        }
-        dump(): void {
-            this.status();
-            if (this.wallet) {
-                this.wallet.dump();
-            }
-        }
-    };
-
-    // single global TestWalletManager instance
-    let wallets: TestWalletManager = new TestWalletManager();
-
-    async function walletsList() { await wallets.list(); }
-    async function walletLoad(index: number) { await wallets.load(index); }
-    async function walletsDeleteAll(param: string) { await wallets.deleteAll(param); }
-    async function walletCreate(strength: number = 256, name: string = ''): Promise<StoredKeyWallet | null> { return await wallets.create(strength, name); }
-    async function walletImport(mnemonic: string, name: string = ''): Promise<StoredKeyWallet | null> { return await wallets.import(mnemonic, name); }
-    async function walletAddCoin(coin: string): Promise<StoredKeyWallet | null> { return await wallets.addCoin(coin); }
-    function walletDump(): void { wallets.dump(); }
-    async function walletDelete(param: string) { await wallets.delete(param); }
-
-    function help(): void {
-        console.log('This is an interactive typescript shell, to work with wallet-core (wasm)');
-        console.log('You can use:');
-        console.log();
-        console.log("- Any typescript commands                        EXAMPLES");
-        console.log("                                                 'wallet-core'.length");
-        console.log("                                                 x = 5; ++x");
-        console.log();
-        console.log('- Any method from Wallet-Core, through various namespaces, see full list below.  Some examples:');
-        console.log("    CoinType                                     CoinType.bitcoin.value");
-        console.log("    HDWallet                                     wallet = HDWallet.create(256, ''); wallet.mnemonic()");
-        console.log("    PrivateKey                                   pk = PrivateKey.createWithData(HexCoding.decode('afeefca74d9a325cf1d6b6911d61a65c32afa8e02bd5e78e2e4ac2910bab45f5'))");
-        console.log("    PublicKey                                    pubkey = PublicKey.createWithData(HexCoding.decode('0399c6f51ad6f98c9c583f8e92bb7758ab2ca9a04110c0a1126ec43e5453d196c1'), PublicKeyType.secp256k1)");
-        console.log("    AnyAddress                                   AnyAddress.createWithString('EQCTVra3xPXenA1wNFMba2taTsc9XMdfCWC7FJpGXjk7', CoinType.solana).description()");
-        console.log("    CoinTypeConfiguration                        CoinTypeConfiguration.getSymbol(CoinType.bitcoin)");
-        console.log("    Mnemonmic                                    Mnemonic.isValidWord('acid')");
-        console.log("    HexCoding                                    HexCoding.encode(HexCoding.decode('01ab02'))");
-        console.log();
-        console.log("- Convenience methods:");
-        console.log("    walletCreate([strength], [name])             walletCreate(128)");
-        console.log("    walletImport(mnemonic, [name])               walletImport('ripple scissors kick mammal hire column oak again sun offer wealth tomorrow wagon turn fatal', 'Test1')");
-        console.log("    walletDump()                                 walletDump()");
-        console.log("    walletAddCoin(symbol)                        walletAddCoin(CoinType.solana)");
-        console.log("    walletsList()                                walletsList()");
-        console.log("    walletLoad()                                 walletLoad(0)");
-        console.log("    walletDelete()                               walletDelete('delete')");
-        console.log("    walletsDeleteAll()                           walletsDeleteAll('deleteall')");
-        console.log();
-        console.log("See examples in samplescripts folder, e.g.:  cat samplescripts/protoeth.sampleinput.txt | npm run start");
-        console.log();
-        console.log("A longer example:");
-        console.log("    coin = CoinType.solana");
-        console.log("    wallet = HDWallet.createWithMnemonic('ripple scissors kick mammal hire column oak again sun offer wealth tomorrow wagon turn fatal', '')");
-        console.log("    wallet.getAddressForCoin(coin)");
-        console.log("    pk = wallet.getKeyForCoin(coin)");
-        console.log("    HexCoding.encode(pk.data())");
-        console.log("    pubkey = pk.getPublicKeyEd25519()");
-        console.log("    HexCoding.encode(pubkey.data())");
-        console.log("    a1 = AnyAddress.createWithPublicKey(pubkey, coin)");
-        console.log("    a1.description()");
-        console.log();
-        console.log("Full list of exposed Wallet-core namespaces:");
-        console.log(enumerateNamespaces(WC).sort().join(', '));
-        console.log(enumerateNamespaces(TW).sort().map(n => 'TW.' + n).join(', '));
-        console.log();
-    }
-
-    function exit(code: number): void {
-        process.exit(code);
-    }
-
-    clear();
-    console.log(
-        chalk.blue(
-            figlet.textSync('wallet-core', { horizontalLayout: 'full' })
-        )
-    );
-    console.log(chalk.blue('  devconsole.ts, wasm lib'));
-    console.log();
-
-    process.stdout.write("Initializing WalletCore library ...");
-    const WC = await initWasm();
-    console.log(` done.`);
-    console.log();
-    console.log(`Type 'help()' for help`);
-    console.log(`Press Ctrl-C twice to exit`);
-    console.log(chalk.red(`This is a test tool, DO NOT USE WITH REAL FUNDS!`));
-    console.log();
-
-    wallets.init();
-    await wallets.refreshStoreWallets();
-    await wallets.loadAWallet();
-
-    const local = repl.start('> ');
-
-    // Expose WC namespaces, as top-level
-    var nss = enumerateNamespaces(WC);
-    nss.forEach(ns => local.context[ns] = WC[ns]);
-    // also all under WC
-    local.context.WC = WC;
-    // Expose TW namespaces (under TW)
-    local.context.TW = TW;
-    // Expose KeyStore namespace (under KeyStore)
-    local.context.KeyStore = KeyStore;
-
-    // Expose more stuff; utilities
-    local.context.help = help;
-    local.context.exit = exit;
-    local.context.walletsList = walletsList;
-    local.context.walletLoad = walletLoad;
-    local.context.walletsDeleteAll = walletsDeleteAll;
-    local.context.walletCreate = walletCreate;
-    local.context.walletImport = walletImport;
-    local.context.walletAddCoin = walletAddCoin;
-    local.context.walletDump = walletDump;
-    local.context.walletDelete = walletDelete;
-    local.context.wallets = wallets;
-    local.context.wallet = wallets.wallet;
-    local.context.coin = WC.CoinType.bitcoin;
-
-    local.on('exit', () => {
-        console.log('Bye!');
-        process.exit();
-    });
-}
-
-main();
diff --git a/samples/typescript/devconsole.ts/test/data/privpubkey.testinput.txt b/samples/typescript/devconsole.ts/test/data/privpubkey.testinput.txt
deleted file mode 100644
index 8431062b58b9..000000000000
--- a/samples/typescript/devconsole.ts/test/data/privpubkey.testinput.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-// Create a private key, sign a message, derive public key from private key, verify signature
-privKeyData = '0xafeefca74d9a325cf1d6b6911d61a65c32afa8e02bd5e78e2e4ac2910bab45f5'
-pubKeyData = '0x0399c6f51ad6f98c9c583f8e92bb7758ab2ca9a04110c0a1126ec43e5453d196c1'
-messageDigest = '0001020304050607080910111213141519171819202122232425262728293031'
-signature = '0x673b54a91d87cfb9389e54cc55b1a9343a6eb9f2ea1f449cb19a248a86bb904c1efb109f8cf655c4f510211053c1696e52c75843c5c803fa1b78fe0c263f468201'
-
-testAssert = function(expression, text) {
-    if (!expression) { console.log('ERROR: ', text); exit(1); }
-    return 'ok: ' + text;
-}
-
-privkey = PrivateKey.createWithData(HexCoding.decode(privKeyData))
-HexCoding.encode(privkey.data())
-testAssert(HexCoding.encode(privkey.data()) == privKeyData, 'private key match')
-
-HexCoding.encode(sig1 = privkey.sign(HexCoding.decode(messageDigest), Curve.secp256k1))
-testAssert(HexCoding.encode(sig1) == signature, 'signature match')
-
-pubkey = privkey.getPublicKeySecp256k1(true)
-HexCoding.encode(pubkey.data())
-testAssert(HexCoding.encode(pubkey.data()) == pubKeyData, 'pubkey match')
-
-verifyRes = pubkey.verify(sig1, HexCoding.decode(messageDigest))
-testAssert(verifyRes, 'signature verification')
-
-exit(0)
diff --git a/samples/typescript/devconsole.ts/tsconfig.json b/samples/typescript/devconsole.ts/tsconfig.json
deleted file mode 100644
index 701982688002..000000000000
--- a/samples/typescript/devconsole.ts/tsconfig.json
+++ /dev/null
@@ -1,20 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "es5",
-        "module": "commonjs",
-        "lib": [
-            "es6",
-            "es2015",
-            "dom"
-        ],
-        "declaration": true,
-        "outDir": "lib",
-        "rootDir": "src",
-        "strict": true,
-        "types": [
-            "node"
-        ],
-        "esModuleInterop": true,
-        "resolveJsonModule": true
-    }
-}
\ No newline at end of file
diff --git a/src/Bitcoin/Entry.h b/src/Bitcoin/Entry.h
index 9d2c8503097f..d4ea8e4f6191 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 000000000000..cc5e78fe61bc
--- /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 6033666b9ef4..447c5c2f5a04 100644
--- a/src/Coin.cpp
+++ b/src/Coin.cpp
@@ -66,6 +66,8 @@
 #include "InternetComputer/Entry.h"
 #include "NativeEvmos/Entry.h"
 #include "NativeInjective/Entry.h"
+#include "BitcoinCash/Entry.h"
+#include "Pactus/Entry.h"
 // end_of_coin_includes_marker_do_not_modify
 
 using namespace TW;
@@ -125,6 +127,8 @@ Greenfield::Entry GreenfieldDP;
 InternetComputer::Entry InternetComputerDP;
 NativeEvmos::Entry NativeEvmosDP;
 NativeInjective::Entry NativeInjectiveDP;
+BitcoinCash::Entry BitcoinCashDP;
+Pactus::Entry PactusDP;
 // end_of_coin_dipatcher_declarations_marker_do_not_modify
 
 CoinEntry* coinDispatcher(TWCoinType coinType) {
@@ -186,6 +190,8 @@ CoinEntry* coinDispatcher(TWCoinType coinType) {
         case TWBlockchainInternetComputer: entry = &InternetComputerDP; break;
         case TWBlockchainNativeEvmos: entry = &NativeEvmosDP; break;
         case TWBlockchainNativeInjective: entry = &NativeInjectiveDP; break;
+        case TWBlockchainBitcoinCash: entry = &BitcoinCashDP; break;
+        case TWBlockchainPactus: entry = &PactusDP; break;
         // end_of_coin_dipatcher_switch_marker_do_not_modify
 
         default: entry = nullptr; break;
diff --git a/src/Filecoin/Address.cpp b/src/Filecoin/Address.cpp
index 07dc7d7577c2..cae8b677bdb3 100644
--- a/src/Filecoin/Address.cpp
+++ b/src/Filecoin/Address.cpp
@@ -4,6 +4,7 @@
 
 #include "Address.h"
 
+#include <algorithm>
 #include <climits>
 
 #include "../Base32.h"
diff --git a/src/Groestlcoin/Address.cpp b/src/Groestlcoin/Address.cpp
index 7871353d2790..74253e2799ba 100644
--- a/src/Groestlcoin/Address.cpp
+++ b/src/Groestlcoin/Address.cpp
@@ -3,8 +3,9 @@
 // Copyright © 2017 Trust Wallet.
 
 #include "Address.h"
+#include "Base58.h"
 
-#include "../Base58.h"
+#include <algorithm>
 #include <TrezorCrypto/ecdsa.h>
 
 namespace TW::Groestlcoin {
diff --git a/src/Keystore/EncryptionParameters.h b/src/Keystore/EncryptionParameters.h
index 711700d7aec3..d12de1b90a2b 100644
--- a/src/Keystore/EncryptionParameters.h
+++ b/src/Keystore/EncryptionParameters.h
@@ -22,13 +22,13 @@ struct EncryptionParameters {
     static EncryptionParameters getPreset(enum TWStoredKeyEncryptionLevel preset, enum TWStoredKeyEncryption encryption = TWStoredKeyEncryptionAes128Ctr) {
         switch (preset) {
         case TWStoredKeyEncryptionLevelMinimal:
-            return EncryptionParameters(AESParameters::AESParametersFromEncryption(encryption), ScryptParameters::Minimal);
+            return { AESParameters::AESParametersFromEncryption(encryption), ScryptParameters::minimal() };
         case TWStoredKeyEncryptionLevelWeak:
         case TWStoredKeyEncryptionLevelDefault:
         default:
-            return EncryptionParameters(AESParameters::AESParametersFromEncryption(encryption), ScryptParameters::Weak);
+            return { AESParameters::AESParametersFromEncryption(encryption), ScryptParameters::weak() };
         case TWStoredKeyEncryptionLevelStandard:
-            return EncryptionParameters(AESParameters::AESParametersFromEncryption(encryption), ScryptParameters::Standard);
+            return { AESParameters::AESParametersFromEncryption(encryption), ScryptParameters::standard() };
         }
     }
 
@@ -54,7 +54,7 @@ struct EncryptionParameters {
     }
 
     /// Initializes with a JSON object.
-    EncryptionParameters(const nlohmann::json& json);
+    explicit EncryptionParameters(const nlohmann::json& json);
 
     /// Saves `this` as a JSON object.
     nlohmann::json json() const;
@@ -91,7 +91,7 @@ struct EncryptedPayload {
     EncryptedPayload() = default;
 
     /// Initializes with standard values.
-    EncryptedPayload(const EncryptionParameters& params, const Data& encrypted, const Data& mac)
+    EncryptedPayload(EncryptionParameters  params, Data encrypted, Data mac)
         : params(std::move(params))
         , encrypted(std::move(encrypted))
         , _mac(std::move(mac)) {}
@@ -101,7 +101,7 @@ struct EncryptedPayload {
     EncryptedPayload(const Data& password, const Data& data, const EncryptionParameters& params);
 
     /// Initializes with a JSON object.
-    EncryptedPayload(const nlohmann::json& json);
+    explicit EncryptedPayload(const nlohmann::json& json);
 
     /// Decrypts the payload with the given password.
     Data decrypt(const Data& password) const;
diff --git a/src/Keystore/ScryptParameters.cpp b/src/Keystore/ScryptParameters.cpp
index 6f4bedf9a4d5..4ec194dd5e84 100644
--- a/src/Keystore/ScryptParameters.cpp
+++ b/src/Keystore/ScryptParameters.cpp
@@ -11,13 +11,30 @@ using namespace TW;
 
 namespace TW::Keystore {
 
-ScryptParameters ScryptParameters::Minimal = ScryptParameters(Data(), minimalN, defaultR, minimalP, defaultDesiredKeyLength);
-ScryptParameters ScryptParameters::Weak = ScryptParameters(Data(), weakN, defaultR, weakP, defaultDesiredKeyLength);
-ScryptParameters ScryptParameters::Standard = ScryptParameters(Data(), standardN, defaultR, standardP, defaultDesiredKeyLength);
+namespace internal {
 
-ScryptParameters::ScryptParameters()
-    : salt(32) {
+Data randomSalt() {
+    Data salt(32);
     random_buffer(salt.data(), salt.size());
+    return salt;
+}
+
+} // namespace internal
+
+ScryptParameters ScryptParameters::minimal() {
+    return { internal::randomSalt(), minimalN, defaultR, minimalP, defaultDesiredKeyLength };
+}
+
+ScryptParameters ScryptParameters::weak() {
+    return { internal::randomSalt(), weakN, defaultR, weakP, defaultDesiredKeyLength };
+}
+
+ScryptParameters ScryptParameters::standard() {
+    return { internal::randomSalt(), standardN, defaultR, standardP, defaultDesiredKeyLength };
+}
+
+ScryptParameters::ScryptParameters()
+    : salt(internal::randomSalt()) {
 }
 
 #pragma GCC diagnostic ignored "-Wtautological-constant-out-of-range-compare"
diff --git a/src/Keystore/ScryptParameters.h b/src/Keystore/ScryptParameters.h
index 94cf3f1b1f23..8c8a3b3de992 100644
--- a/src/Keystore/ScryptParameters.h
+++ b/src/Keystore/ScryptParameters.h
@@ -21,10 +21,6 @@ enum class ScryptValidationError {
 
 /// Scrypt function parameters.
 struct ScryptParameters {
-    static ScryptParameters Minimal;
-    static ScryptParameters Weak;
-    static ScryptParameters Standard;
-
     /// The N and P parameters of Scrypt encryption algorithm, using 256MB memory and
     /// taking approximately 1s CPU time on a modern processor.
     static const uint32_t standardN = 1 << 18;
@@ -59,13 +55,20 @@ struct ScryptParameters {
     /// Block size factor.
     uint32_t r = defaultR;
 
+    /// Generates Scrypt encryption parameters with the minimal sufficient level (4096), and with a random salt.
+    static ScryptParameters minimal();
+    /// Generates Scrypt encryption parameters with the weak sufficient level (16k), and with a random salt.
+    static ScryptParameters weak();
+    /// Generates Scrypt encryption parameters with the standard sufficient level (262k), and with a random salt.
+    static ScryptParameters standard();
+
     /// Initializes with default scrypt parameters and a random salt.
     ScryptParameters();
 
     /// Initializes `ScryptParameters` with all values.
     ///
     /// @throws ScryptValidationError if the parameters are invalid.
-    ScryptParameters(const Data& salt, uint32_t n, uint32_t r, uint32_t p, std::size_t desiredKeyLength)
+    ScryptParameters(Data salt, uint32_t n, uint32_t r, uint32_t p, std::size_t desiredKeyLength)
         : salt(std::move(salt)), desiredKeyLength(desiredKeyLength), n(n), p(p), r(r) {
         auto error = validate();
         if (error) {
@@ -79,7 +82,7 @@ struct ScryptParameters {
     std::optional<ScryptValidationError> validate() const;
 
     /// Initializes `ScryptParameters` with a JSON object.
-    ScryptParameters(const nlohmann::json& json);
+    explicit ScryptParameters(const nlohmann::json& json);
 
     /// Saves `this` as a JSON object.
     nlohmann::json json() const;
diff --git a/src/NEO/Transaction.cpp b/src/NEO/Transaction.cpp
index 933dc97df501..0c8d7431da8b 100644
--- a/src/NEO/Transaction.cpp
+++ b/src/NEO/Transaction.cpp
@@ -46,7 +46,6 @@ Transaction* Transaction::deserializeFrom(const Data& data, size_t initial_pos)
         break;
     default:
         throw std::invalid_argument("Transaction::deserializeFrom Invalid transaction type");
-        break;
     }
     resp->deserialize(data, initial_pos);
     return resp;
diff --git a/src/Nano/Signer.cpp b/src/Nano/Signer.cpp
index bfac78f141d4..1dc1deeb2289 100644
--- a/src/Nano/Signer.cpp
+++ b/src/Nano/Signer.cpp
@@ -7,8 +7,9 @@
 #include "../BinaryCoding.h"
 #include "../HexCoding.h"
 #include "../uint256.h"
-#include <nlohmann/json.hpp>
 
+#include <algorithm>
+#include <nlohmann/json.hpp>
 #include <google/protobuf/util/json_util.h>
 
 using namespace TW;
diff --git a/src/Pactus/Entry.h b/src/Pactus/Entry.h
new file mode 100644
index 000000000000..2f41bcde4193
--- /dev/null
+++ b/src/Pactus/Entry.h
@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+#pragma once
+
+#include "rust/RustCoinEntry.h"
+
+namespace TW::Pactus {
+
+/// Entry point for Pactus coin.
+/// Note: do not put the implementation here (no matter how simple), to avoid having coin-specific includes in this file
+class Entry : public Rust::RustCoinEntry {
+};
+
+} // namespace TW::Pactus
+
diff --git a/src/interface/TWCardano.cpp b/src/interface/TWCardano.cpp
index 798f8392452f..d4278c593c92 100644
--- a/src/interface/TWCardano.cpp
+++ b/src/interface/TWCardano.cpp
@@ -2,6 +2,7 @@
 //
 // Copyright © 2017 Trust Wallet.
 
+#include <algorithm>
 #include <TrustWalletCore/TWCardano.h>
 
 #include "Cardano/Transaction.h"
diff --git a/src/proto/Pactus.proto b/src/proto/Pactus.proto
new file mode 100644
index 000000000000..ce3f9d3a02e4
--- /dev/null
+++ b/src/proto/Pactus.proto
@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+syntax = "proto3";
+
+package TW.Pactus.Proto;
+option java_package = "wallet.core.jni.proto";
+
+import "Common.proto";
+
+message TransactionMessage {
+  // The lock time for the transaction.
+  uint32 lock_time = 1;
+  // The transaction fee in NanoPAC.
+  int64 fee = 2;
+  // A memo string for the transaction (optional).
+  string memo = 3;
+
+  oneof payload {
+    TransferPayload transfer = 10;
+    BondPayload bond = 11;
+  }
+}
+
+// Transfer payload for creating a Transfer transaction between two accounts.
+message TransferPayload {
+  // The sender's account address.
+  string sender = 1;
+  // The receiver's account address.
+  string receiver = 2;
+  // The amount to be transferred, specified in NanoPAC.
+  int64 amount = 3;
+}
+
+// Bond payload for creating a Bond transaction from an account to a validator.
+message BondPayload {
+  // The sender's account address.
+  string sender = 1;
+  // The receiver's validator address.
+  string receiver = 2;
+  // The stake amount in NanoPAC.
+  int64 stake = 3;
+  // The public key of the validator (only set when creating a new validator).
+  string public_key = 4;
+}
+
+// Input data necessary to create a signed transaction.
+message SigningInput {
+  bytes private_key = 1;
+  TransactionMessage transaction = 2;
+}
+
+// Transaction signing output.
+message SigningOutput {
+  // Transaction ID (Hash).
+  bytes transaction_id = 1;
+  // Signed and encoded transaction bytes.
+  bytes signed_transaction_data = 2;
+  // Signature the signed transaction.
+  bytes signature = 3;
+  // A possible error, `OK` if none.
+  Common.Proto.SigningError error = 4;
+  // Detailed error message, if any.
+  string error_message = 5;
+}
diff --git a/swift/Tests/Blockchains/PactusTests.swift b/swift/Tests/Blockchains/PactusTests.swift
new file mode 100644
index 000000000000..41fbb3d13e65
--- /dev/null
+++ b/swift/Tests/Blockchains/PactusTests.swift
@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+import XCTest
+import WalletCore
+
+class PactusTests: XCTestCase {
+    var privateKey: PrivateKey!
+
+    override func setUp() {
+        super.setUp()
+        privateKey = PrivateKey(data: Data(hexString: "4e51f1f3721f644ac7a193be7f5e7b8c2abaa3467871daf4eacb5d3af080e5d6")!)!
+    }
+
+   func testAddress() {
+        let pubkey = privateKey.getPublicKeyEd25519()
+        let address = AnyAddress(publicKey: pubkey, coin: .pactus)
+        let addressFromString = AnyAddress(string: "pc1rwzvr8rstdqypr80ag3t6hqrtnss9nwymcxy3lr", coin: .pactus)!
+
+        XCTAssertEqual(pubkey.data.hexString, "95794161374b22c696dabb98e93f6ca9300b22f3b904921fbf560bb72145f4fa")
+        XCTAssertEqual(address.description, addressFromString.description)
+    }
+
+    func testTransferSign() {
+        let input = PactusSigningInput.with {
+            $0.privateKey = privateKey.data
+            $0.transaction = PactusTransactionMessage.with {
+                $0.lockTime = 0x24a32300
+                $0.fee = 10000000
+                $0.memo = "wallet-core"
+                $0.transfer = PactusTransferPayload.with {
+                    $0.sender = "pc1rwzvr8rstdqypr80ag3t6hqrtnss9nwymcxy3lr"
+                    $0.receiver = "pc1r0g22ufzn8qtw0742dmfglnw73e260hep0k3yra"
+                    $0.amount = 200000000
+                }
+            }
+        }
+
+        let output: PactusSigningOutput = AnySigner.sign(input: input, coin: .pactus)
+
+        let expectedTransactionID = "1b6b7226f7935a15f05371d1a1fefead585a89704ce464b7cc1d453d299d235f"
+        let expectedSignature = "4ed8fee3d8992e82660dd05bbe8608fc56ceabffdeeee61e3213b9b49d33a0fc8dea6d79ee7ec60f66433f189ed9b3c50b2ad6fa004e26790ee736693eda8506"
+        let expectedSignedData = "000124a3230080ade2040b77616c6c65742d636f726501037098338e0b6808119dfd4457ab806b9c2059b89b037a14ae24533816e7faaa6ed28fcdde8e55a7df218084af5f4ed8fee3d8992e82660dd05bbe8608fc56ceabffdeeee61e3213b9b49d33a0fc8dea6d79ee7ec60f66433f189ed9b3c50b2ad6fa004e26790ee736693eda850695794161374b22c696dabb98e93f6ca9300b22f3b904921fbf560bb72145f4fa"
+        XCTAssertEqual(output.transactionID.hexString, expectedTransactionID)
+        XCTAssertEqual(output.signature.hexString, expectedSignature)
+        XCTAssertEqual(output.signedTransactionData.hexString, expectedSignedData)
+    }
+
+    func testBondSign() {
+        let input = PactusSigningInput.with {
+            $0.privateKey = privateKey.data
+            $0.transaction = PactusTransactionMessage.with {
+                $0.lockTime = 0xc1b02300
+                $0.fee = 10000000
+                $0.memo = "wallet-core"
+                $0.bond = PactusBondPayload.with {
+                    $0.sender = "pc1rwzvr8rstdqypr80ag3t6hqrtnss9nwymcxy3lr"
+                    $0.receiver = "pc1p9y5gmu9l002tt60wak9extgvwm69rq3a9ackrl"
+                    $0.stake = 1000000000
+                    $0.public_key = "public1pnz75msstqdrq5eguvcwanug0zauhqjw2cc4flmez3qethnp68y64ehc4k69amapj7x4na2uda0snqz4yxujgx3jsse4f64fgy7jkh0xauvhrc5ts09vfk48g85t0js66hvajm6xruemsvlxqv3xvkyur8v9v0mtn"
+                }
+            }
+        }
+
+        let output: PactusSigningOutput = AnySigner.sign(input: input, coin: .pactus)
+
+        let expectedTransactionID = "d194b445642a04ec78ced4448696e50b733f2f0b517a23871882c0eefaf1c28f"
+        let expectedSignature = "0d7bc6d94927534b89e2f53bcfc9fc849e0e2982438955eda55b4338328adac79d4ee3216d143f0e1629764ab650734f8ba188e716d71f9eff65e39ce7006300"
+        let expectedSignedData = "0001c1b0230080ade2040b77616c6c65742d636f726502037098338e0b6808119dfd4457ab806b9c2059b89b0129288df0bf7bd4b5e9eeed8b932d0c76f451823d6098bd4dc20b03460a651c661dd9f10f17797049cac62a9fef228832bbcc3a39355cdf15b68bddf432f1ab3eab8debe1300aa43724834650866a9d552827a56bbcdde32e3c517079589b54e83d16f9435abb3b2de8c3e677067cc0644ccb13833b8094ebdc030d7bc6d94927534b89e2f53bcfc9fc849e0e2982438955eda55b4338328adac79d4ee3216d143f0e1629764ab650734f8ba188e716d71f9eff65e39ce700630095794161374b22c696dabb98e93f6ca9300b22f3b904921fbf560bb72145f4fa"
+        XCTAssertEqual(output.transactionID.hexString, expectedTransactionID)
+        XCTAssertEqual(output.signature.hexString, expectedSignature)
+        XCTAssertEqual(output.signedTransactionData.hexString, expectedSignedData)
+    }
+}
diff --git a/swift/Tests/CoinAddressDerivationTests.swift b/swift/Tests/CoinAddressDerivationTests.swift
index 6a572ab6048e..72c611f40834 100644
--- a/swift/Tests/CoinAddressDerivationTests.swift
+++ b/swift/Tests/CoinAddressDerivationTests.swift
@@ -130,7 +130,7 @@ class CoinAddressDerivationTests: XCTestCase {
                     assertCoinDerivation(coin, expectedResult, derivedAddress, address)
                 case .rootstock:
                     let expectedResult = "0xA2D7065F94F838a3aB9C04D67B312056846424Df"
-                    assertCoinDerivation(coin, expectedResult, derivedAddress, address)       
+                    assertCoinDerivation(coin, expectedResult, derivedAddress, address)
                 case .filecoin:
                     let expectedResult = "f1zzykebxldfcakj5wdb5n3n7priul522fnmjzori"
                     assertCoinDerivation(coin, expectedResult, derivedAddress, address)
@@ -400,6 +400,9 @@ class CoinAddressDerivationTests: XCTestCase {
                 case .dydx:
                     let expectedResult = "dydx142j9u5eaduzd7faumygud6ruhdwme98qeayaky"
                     assertCoinDerivation(coin, expectedResult, derivedAddress, address)
+                case .pactus:
+                    let expectedResult = "pc1r7ys2g5a4xc2qtm0t4q987m4mvs57w5g0v4pvzg"
+                    assertCoinDerivation(coin, expectedResult, derivedAddress, address)
                 @unknown default:
                     fatalError()
                 }
diff --git a/tests/chains/BitcoinCash/TWCoinTypeTests.cpp b/tests/chains/BitcoinCash/TWCoinTypeTests.cpp
index e86daa42bb19..20e12d01de1e 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 f6487e721d91..96928e1828e2 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");
diff --git a/tests/chains/Pactus/AddressTests.cpp b/tests/chains/Pactus/AddressTests.cpp
new file mode 100644
index 000000000000..c3bcb0a260da
--- /dev/null
+++ b/tests/chains/Pactus/AddressTests.cpp
@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+#include "HexCoding.h"
+#include "Pactus/Entry.h"
+#include "PrivateKey.h"
+#include "PublicKey.h"
+#include "TestUtilities.h"
+#include <TrustWalletCore/TWAnyAddress.h>
+#include <gtest/gtest.h>
+
+namespace TW::Pactus::tests {
+
+TEST(PactusAddress, AddressData) {
+    auto string = STRING("pc1rspm7ps49gar9ft5g0tkl6lhxs8ygeakq87quh3");
+    auto addr = WRAP(TWAnyAddress, TWAnyAddressCreateWithString(string.get(), TWCoinTypePactus));
+    auto string2 = WRAPS(TWAnyAddressDescription(addr.get()));
+    EXPECT_TRUE(TWStringEqual(string.get(), string2.get()));
+    auto keyHash = WRAPD(TWAnyAddressData(addr.get()));
+    assertHexEqual(keyHash, "038077e0c2a5474654ae887aedfd7ee681c88cf6c0");
+}
+
+TEST(PactusAddress, FromPrivateKey) {
+    auto privateKey = PrivateKey(parse_hex("2134ae97465505dfd5a1fd05a8a0f146209c601eb3f1b0363b4cfe4b47ba1ab4"));
+    auto pubkey = privateKey.getPublicKey(TWPublicKeyTypeED25519);
+    Entry entry;
+    auto address = entry.deriveAddress(TWCoinTypePactus, pubkey, TWDerivationDefault, std::monostate{});
+    ASSERT_EQ(address, "pc1r7jkvfnegf0rf5ua05fzu9krjhjxcrrygl3v4nl");
+}
+
+TEST(PactusAddress, FromPublicKey) {
+    auto publicKey = PublicKey(parse_hex("600d30a4373ae788e2d4a08f4728f45d259593fbdd9632bbe283c4c37ac6a3df"), TWPublicKeyTypeED25519);
+    Entry entry;
+    auto address = entry.deriveAddress(TWCoinTypePactus, publicKey, TWDerivationDefault, std::monostate{});
+    ASSERT_EQ(address, "pc1r7jkvfnegf0rf5ua05fzu9krjhjxcrrygl3v4nl");
+}
+
+} // namespace TW::Pactus::tests
\ No newline at end of file
diff --git a/tests/chains/Pactus/CoinTypeTests.cpp b/tests/chains/Pactus/CoinTypeTests.cpp
new file mode 100644
index 000000000000..cd28ee9de149
--- /dev/null
+++ b/tests/chains/Pactus/CoinTypeTests.cpp
@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+#include "TestUtilities.h"
+#include "Pactus/Entry.h"
+#include "PrivateKey.h"
+#include "PublicKey.h"
+#include <TrustWalletCore/TWCoinTypeConfiguration.h>
+#include <TrustWalletCore/TWAnyAddress.h>
+#include <TrustWalletCore/TWHDWallet.h>
+#include <gtest/gtest.h>
+
+namespace TW::Pactus::tests {
+
+TEST(PactusCoinType, TWCoinType) {
+    const auto coin = TWCoinTypePactus;
+    const auto symbol = WRAPS(TWCoinTypeConfigurationGetSymbol(coin));
+    const auto id = WRAPS(TWCoinTypeConfigurationGetID(coin));
+    const auto name = WRAPS(TWCoinTypeConfigurationGetName(coin));
+    const auto txId = WRAPS(TWStringCreateWithUTF8Bytes(""));
+    const auto txUrl = WRAPS(TWCoinTypeConfigurationGetTransactionURL(coin, txId.get()));
+    const auto accId = WRAPS(TWStringCreateWithUTF8Bytes(""));
+    const auto accUrl = WRAPS(TWCoinTypeConfigurationGetAccountURL(coin, accId.get()));
+
+    assertStringsEqual(id, "pactus");
+    assertStringsEqual(name, "Pactus");
+    assertStringsEqual(symbol, "PAC");
+    ASSERT_EQ(TWCoinTypeConfigurationGetDecimals(coin), 9);
+    ASSERT_EQ(TWCoinTypeBlockchain(coin), TWBlockchainPactus);
+    ASSERT_EQ(TWCoinTypeP2pkhPrefix(coin), 0);
+    ASSERT_EQ(TWCoinTypeP2shPrefix(coin), 0);
+    ASSERT_EQ(TWCoinTypeStaticPrefix(coin), 0);
+    assertStringsEqual(txUrl, "https://pacviewer.com/transaction/");
+    assertStringsEqual(accUrl, "https://pacviewer.com/address/");
+}
+
+}
\ No newline at end of file
diff --git a/tests/chains/Pactus/CompilerTests.cpp b/tests/chains/Pactus/CompilerTests.cpp
new file mode 100644
index 000000000000..160bcf54acc8
--- /dev/null
+++ b/tests/chains/Pactus/CompilerTests.cpp
@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+#include "HexCoding.h"
+#include "PrivateKey.h"
+#include "PublicKey.h"
+#include "TestUtilities.h"
+#include "TransactionCompiler.h"
+#include "proto/Pactus.pb.h"
+#include "proto/TransactionCompiler.pb.h"
+#include "TestCases.h"
+
+#include <gtest/gtest.h>
+
+using namespace TW;
+
+TEST(PactusCompiler, CompileAndSign) {
+    // Set up a signing input.
+
+    auto input = TransferTransaction1::createSigningInput();
+
+    auto inputString = input.SerializeAsString();
+    auto inputStrData = TW::Data(inputString.begin(), inputString.end());
+
+    // Pre-hash the transaction.
+    auto preImageHashesData = TransactionCompiler::preImageHashes(TWCoinTypePactus, inputStrData);
+    TxCompiler::Proto::PreSigningOutput preSigningOutput;
+    preSigningOutput.ParseFromArray(preImageHashesData.data(), static_cast<int>(preImageHashesData.size()));
+    auto actualDataToSign = data(preSigningOutput.data());
+
+    EXPECT_EQ(preSigningOutput.error(), Common::Proto::OK);
+    EXPECT_EQ(hex(actualDataToSign), TransferTransaction1::DATA_TO_SIGN);
+
+    // // Sign the pre-hash data.
+
+    auto privateKey = PrivateKey(parse_hex(TransferTransaction1::PRIVATE_KEY_HEX));
+    auto publicKey = privateKey.getPublicKey(TWPublicKeyTypeED25519).bytes;
+    auto signature = privateKey.sign(actualDataToSign, TWCurveED25519);
+    EXPECT_EQ(hex(signature), "50ac25c7125271489b0cd230549257c93fb8c6265f2914a988ba7b81c1bc47fff027412dd59447867911035ff69742d171060a1f132ac38b95acc6e39ec0bd09");
+
+    // Compile the transaction.
+
+    auto outputData = TransactionCompiler::compileWithSignatures(TWCoinTypePactus, inputStrData, {signature}, {publicKey});
+    TW::Pactus::Proto::SigningOutput output;
+    output.ParseFromArray(outputData.data(), static_cast<int>(outputData.size()));
+
+    EXPECT_EQ(output.error(), Common::Proto::OK);
+    ASSERT_EQ(hex(output.signed_transaction_data()), "000101020300e807047465737401037098338e0b6808119dfd4457ab806b9c2059b89b037a14ae24533816e7faaa6ed28fcdde8e55a7df21a09c0150ac25c7125271489b0cd230549257c93fb8c6265f2914a988ba7b81c1bc47fff027412dd59447867911035ff69742d171060a1f132ac38b95acc6e39ec0bd0995794161374b22c696dabb98e93f6ca9300b22f3b904921fbf560bb72145f4fa");
+    ASSERT_EQ(hex(output.signature()), "50ac25c7125271489b0cd230549257c93fb8c6265f2914a988ba7b81c1bc47fff027412dd59447867911035ff69742d171060a1f132ac38b95acc6e39ec0bd09");
+    ASSERT_EQ(hex(output.transaction_id()), "34cd4656a98f7eb996e83efdc384cefbe3a9c52dca79a99245b4eacc0b0b4311");
+}
diff --git a/tests/chains/Pactus/SignerTests.cpp b/tests/chains/Pactus/SignerTests.cpp
new file mode 100644
index 000000000000..17b46fbce0cc
--- /dev/null
+++ b/tests/chains/Pactus/SignerTests.cpp
@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+#include "HexCoding.h"
+#include "PrivateKey.h"
+#include "PublicKey.h"
+#include "TestUtilities.h"
+#include "TransactionCompiler.h"
+#include "proto/Pactus.pb.h"
+#include "proto/TransactionCompiler.pb.h"
+#include "TestCases.h"
+
+#include <gtest/gtest.h>
+
+using namespace TW;
+
+TEST(PactusSigner, Sign) {
+    // Set up a signing input.
+    auto input = TransferTransaction1::createSigningInput();
+
+    auto privateKey = PrivateKey(parse_hex(TransferTransaction1::PRIVATE_KEY_HEX));
+    input.set_private_key(privateKey.bytes.data(), privateKey.bytes.size());
+
+    TW::Pactus::Proto::SigningOutput output;
+    ANY_SIGN(input, TWCoinTypePactus);
+
+    EXPECT_EQ(output.error(), Common::Proto::OK);
+    ASSERT_EQ(hex(output.signed_transaction_data()), TransferTransaction1::SIGNED_TRANSACTION_DATA);
+    ASSERT_EQ(hex(output.signature()), TransferTransaction1::SIGNATURE);
+    ASSERT_EQ(hex(output.transaction_id()), TransferTransaction1::TRANSACTION_ID);
+}
diff --git a/tests/chains/Pactus/TestCases.h b/tests/chains/Pactus/TestCases.h
new file mode 100644
index 000000000000..4418eb3d5884
--- /dev/null
+++ b/tests/chains/Pactus/TestCases.h
@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+#pragma once
+
+#include "proto/Pactus.pb.h"
+#include "proto/TransactionCompiler.pb.h"
+
+#include <string>
+
+namespace TransferTransaction1 {
+
+static TW::Pactus::Proto::SigningInput createSigningInput() {
+    TW::Pactus::Proto::SigningInput input;
+
+    // Set up the transaction message
+    TW::Pactus::Proto::TransactionMessage* trx = input.mutable_transaction();
+    trx->set_lock_time(0x00030201);
+    trx->set_fee(1000);
+    trx->set_memo("test");
+
+    // Set up the transfer payload
+    TW::Pactus::Proto::TransferPayload* pld = trx->mutable_transfer();
+    pld->set_sender("pc1rwzvr8rstdqypr80ag3t6hqrtnss9nwymcxy3lr");
+    pld->set_receiver("pc1r0g22ufzn8qtw0742dmfglnw73e260hep0k3yra");
+    pld->set_amount(20000);
+
+    return input;
+}
+
+const std::string PRIVATE_KEY_HEX = "4e51f1f3721f644ac7a193be7f5e7b8c2abaa3467871daf4eacb5d3af080e5d6";
+const std::string SIGNATURE =
+    "50ac25c7125271489b0cd230549257c93fb8c6265f2914a988ba7b81c1bc47fff027412dd59447867911035ff69742d171060a1f132ac38b95acc6e39ec0bd09";
+const std::string DATA_TO_SIGN =
+    "0101020300e807047465737401037098338e0b6808119dfd4457ab806b9c2059b89b037a14ae24533816e7faaa6ed28fcdde8e55a7df21a09c01";
+const std::string SIGNED_TRANSACTION_DATA =
+    "000101020300e807047465737401037098338e0b6808119dfd4457ab806b9c2059b89b037a14ae24533816e7faaa6ed28fcdde8e55a7df21a09c0150ac25c7125271489b0cd230549257c93fb8c6265f2914a988ba7b81c1bc47fff027412dd59447867911035ff69742d171060a1f132ac38b95acc6e39ec0bd0995794161374b22c696dabb98e93f6ca9300b22f3b904921fbf560bb72145f4fa";
+const std::string TRANSACTION_ID = "34cd4656a98f7eb996e83efdc384cefbe3a9c52dca79a99245b4eacc0b0b4311";
+} // namespace TransferTransaction1
diff --git a/tests/chains/Pactus/WalletTests.cpp b/tests/chains/Pactus/WalletTests.cpp
new file mode 100644
index 000000000000..bcd3076f3984
--- /dev/null
+++ b/tests/chains/Pactus/WalletTests.cpp
@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+#include "TestUtilities.h"
+#include "Pactus/Entry.h"
+#include "PrivateKey.h"
+#include "PublicKey.h"
+#include <TrustWalletCore/TWCoinTypeConfiguration.h>
+#include <TrustWalletCore/TWAnyAddress.h>
+#include <TrustWalletCore/TWHDWallet.h>
+#include <gtest/gtest.h>
+
+namespace TW::Pactus::tests {
+
+TEST(PactusWallet, DerivationPath) {
+    auto derivationPath = TWCoinTypeDerivationPath(TWCoinTypePactus);
+    assertStringsEqual(WRAPS(derivationPath), "m/44'/21888'/3'/0'");
+}
+
+TEST(PactusWallet, HDWallet) {
+    auto mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon cactus";
+    auto passphrase = "";
+    auto wallet = WRAP(TWHDWallet, TWHDWalletCreateWithMnemonic(STRING(mnemonic).get(), STRING(passphrase).get()));
+
+    auto derivationPath1 = TWStringCreateWithUTF8Bytes("m/44'/21888'/3'/0'");
+    auto privateKey1 = WRAP(TWPrivateKey, TWHDWalletGetKey(wallet.get(), TWCoinTypePactus, derivationPath1));
+    auto publicKey1 = WRAP(TWPublicKey, TWPrivateKeyGetPublicKeyEd25519(privateKey1.get()));
+    auto address1 = WRAP(TWAnyAddress, TWAnyAddressCreateWithPublicKey(publicKey1.get(), TWCoinTypePactus));
+    auto addressStr1 = WRAPS(TWAnyAddressDescription(address1.get()));
+
+    auto derivationPath2 = TWStringCreateWithUTF8Bytes("m/44'/21888'/3'/1'");
+    auto privateKey2 = WRAP(TWPrivateKey, TWHDWalletGetKey(wallet.get(), TWCoinTypePactus, derivationPath2));
+    auto publicKey2 = WRAP(TWPublicKey, TWPrivateKeyGetPublicKeyEd25519(privateKey2.get()));
+    auto address2 = WRAP(TWAnyAddress, TWAnyAddressCreateWithPublicKey(publicKey2.get(), TWCoinTypePactus));
+    auto addressStr2 = WRAPS(TWAnyAddressDescription(address2.get()));
+
+    assertStringsEqual(addressStr1, "pc1rcx9x55nfme5juwdgxd2ksjdcmhvmvkrygmxpa3");
+    assertStringsEqual(addressStr2, "pc1r7aynw9urvh66ktr3fte2gskjjnxzruflkgde94");
+    TWStringDelete(derivationPath1);
+    TWStringDelete(derivationPath2);
+}
+
+}
\ No newline at end of file
diff --git a/tests/common/CoinAddressDerivationTests.cpp b/tests/common/CoinAddressDerivationTests.cpp
index 1273ea427eb6..6df5336c5c09 100644
--- a/tests/common/CoinAddressDerivationTests.cpp
+++ b/tests/common/CoinAddressDerivationTests.cpp
@@ -396,6 +396,9 @@ TEST(Coin, DeriveAddress) {
         case TWCoinTypeDydx:
             EXPECT_EQ(address, "dydx1hkfq3zahaqkkzx5mjnamwjsfpq2jk7z0sz38vk");
             break;
+        case TWCoinTypePactus:
+            EXPECT_EQ(address, "pc1rehvlc6tfn79z0zjqqaj8zas5j5h9c2fe59a4ff");
+            break;
             // end_of_coin_address_derivation_tests_marker_do_not_modify
             // no default branch here, intentionally, to better notice any missing coins
         }
diff --git a/tests/common/Keystore/StoredKeyTests.cpp b/tests/common/Keystore/StoredKeyTests.cpp
index ba189cfe5a13..02c9bed047bd 100644
--- a/tests/common/Keystore/StoredKeyTests.cpp
+++ b/tests/common/Keystore/StoredKeyTests.cpp
@@ -45,13 +45,15 @@ TEST(StoredKey, CreateWithMnemonic) {
     EXPECT_EQ(json["name"], "name");
     EXPECT_EQ(json["type"], "mnemonic");
     EXPECT_EQ(json["version"], 3);
+    // Salt is 32 bytes, encoded as hex.
+    EXPECT_EQ(json["crypto"]["kdfparams"]["salt"].get<std::string>().size(), 64ul);
 }
 
 TEST(StoredKey, CreateWithMnemonicInvalid) {
     try {
         auto key = StoredKey::createWithMnemonic("name", gPassword, "_THIS_IS_NOT_A_VALID_MNEMONIC_", TWStoredKeyEncryptionLevelDefault);
     } catch (std::invalid_argument&) {
-        // expedcted exception OK
+        // expected exception OK
         return;
     }
     FAIL() << "Missing excpected excpetion";
@@ -539,6 +541,7 @@ TEST(StoredKey, CreateMinimalEncryptionParameters) {
 
     EXPECT_EQ(json["crypto"]["kdf"], "scrypt");
     EXPECT_EQ(json["crypto"]["kdfparams"]["n"], 4096);
+    EXPECT_EQ(json["crypto"]["kdfparams"]["salt"].get<std::string>().size(), 64ul);
 
     // load it back
     const auto key2 = StoredKey::createWithJson(json);
@@ -557,6 +560,7 @@ TEST(StoredKey, CreateWeakEncryptionParameters) {
 
     EXPECT_EQ(json["crypto"]["kdf"], "scrypt");
     EXPECT_EQ(json["crypto"]["kdfparams"]["n"], 16384);
+    EXPECT_EQ(json["crypto"]["kdfparams"]["salt"].get<std::string>().size(), 64ul);
 
     // load it back
     const auto key2 = StoredKey::createWithJson(json);
@@ -575,12 +579,23 @@ TEST(StoredKey, CreateStandardEncryptionParameters) {
 
     EXPECT_EQ(json["crypto"]["kdf"], "scrypt");
     EXPECT_EQ(json["crypto"]["kdfparams"]["n"], 262144);
+    EXPECT_EQ(json["crypto"]["kdfparams"]["salt"].get<std::string>().size(), 64ul);
 
     // load it back
     const auto key2 = StoredKey::createWithJson(json);
     EXPECT_EQ(key2.wallet(gPassword).getMnemonic(), string(gMnemonic));
 }
 
+TEST(StoredKey, CreateEncryptionParametersRandomSalt) {
+    const auto key1 = StoredKey::createWithMnemonic("name", gPassword, gMnemonic, TWStoredKeyEncryptionLevelStandard);
+    const auto salt1 = parse_hex(key1.json()["crypto"]["kdfparams"]["salt"]);
+
+    const auto key2 = StoredKey::createWithMnemonic("name", gPassword, gMnemonic, TWStoredKeyEncryptionLevelStandard);
+    const auto salt2 = parse_hex(key2.json()["crypto"]["kdfparams"]["salt"]);
+
+    EXPECT_NE(salt1, salt2) << "salt must be random on every StoredKey creation";
+}
+
 TEST(StoredKey, CreateMultiAccounts) { // Multiple accounts for the same coin
     auto key = StoredKey::createWithMnemonic("name", gPassword, gMnemonic, TWStoredKeyEncryptionLevelDefault);
     EXPECT_EQ(key.type, StoredKeyType::mnemonicPhrase);
diff --git a/tests/interface/TWHRPTests.cpp b/tests/interface/TWHRPTests.cpp
index 14ddb39b6573..d99e81a6bb80 100644
--- a/tests/interface/TWHRPTests.cpp
+++ b/tests/interface/TWHRPTests.cpp
@@ -34,6 +34,7 @@ TEST(TWHRP, StringForHRP) {
     ASSERT_STREQ(stringForHRP(TWHRPCryptoOrg), "cro");
     ASSERT_STREQ(stringForHRP(TWHRPOsmosis), "osmo");
     ASSERT_STREQ(stringForHRP(TWHRPSecret), "secret");
+    ASSERT_STREQ(stringForHRP(TWHRPPactus), "pc");
 }
 
 TEST(TWHRP, HRPForString) {
@@ -62,6 +63,7 @@ TEST(TWHRP, HRPForString) {
     ASSERT_EQ(hrpForString("osmo"), TWHRPOsmosis);
     ASSERT_EQ(hrpForString("ecash"), TWHRPECash);
     ASSERT_EQ(hrpForString("secret"), TWHRPSecret);
+    ASSERT_EQ(hrpForString("pc"), TWHRPPactus);
 }
 
 TEST(TWHPR, HPRByCoinType) {
@@ -89,6 +91,7 @@ TEST(TWHPR, HPRByCoinType) {
     ASSERT_EQ(TWHRPOsmosis, TWCoinTypeHRP(TWCoinTypeOsmosis));
     ASSERT_EQ(TWHRPECash, TWCoinTypeHRP(TWCoinTypeECash));
     ASSERT_EQ(TWHRPSecret, TWCoinTypeHRP(TWCoinTypeSecret));
+    ASSERT_EQ(TWHRPPactus, TWCoinTypeHRP(TWCoinTypePactus));
 
     ASSERT_EQ(TWHRPUnknown, TWCoinTypeHRP(TWCoinTypeAion));
     ASSERT_EQ(TWHRPUnknown, TWCoinTypeHRP(TWCoinTypeCallisto));
diff --git a/tools/install-sys-dependencies-linux b/tools/install-sys-dependencies-linux
index 2f1e7db8e44b..3a2c786eff9b 100755
--- a/tools/install-sys-dependencies-linux
+++ b/tools/install-sys-dependencies-linux
@@ -2,23 +2,13 @@
 
 set -e
 
-# Downgrade libc to temporarily fix https://github.com/actions/runner-images/issues/8659
-if [[ "$1" == "ci" ]]; then
-  LIBSTD_PACKAGE_VERSION="12.3.0-1ubuntu1~22.04"
-  # Bump this version if the CI has been broken due to the packages update.
-  LIBC_PACKAGE_VERSION="2.35-0ubuntu3.8"
-
-  echo "Remove GCC 13 from runner image - runner-images/8659 workaround"
-  echo "NOTE: Bump $LIBC_PACKAGE_VERSION version if the CI has been broken due to the packages update"
-
-  sudo rm -f /etc/apt/sources.list.d/ubuntu-toolchain-r-ubuntu-test-jammy.list
-  sudo apt-get update
-  sudo apt-get install -y --allow-downgrades \
-    libc6=$LIBC_PACKAGE_VERSION \
-    libc6-dev=$LIBC_PACKAGE_VERSION \
-    libstdc++6=$LIBSTD_PACKAGE_VERSION \
-    libgcc-s1=$LIBSTD_PACKAGE_VERSION
-fi
-
 # build-essential clang-14 libc++-dev libc++abi-dev ruby-full cmake
-sudo apt-get update && sudo apt-get install ninja-build lcov llvm-14 clang-tidy-14 libboost-all-dev rustc --fix-missing
+sudo apt-get update && sudo apt-get install ninja-build llvm-14 clang-tidy-14 libboost-all-dev rustc --fix-missing gcc-multilib g++-multilib
+
+# As of now, Ubuntu 24.04 has lcov 2.0-4ubuntu2 only, but we don't support it yet.
+# Install lcov 1.15-1 manually.
+LCOV_TEMP="$(mktemp -d)"
+LCOV_DEB="$LCOV_TEMP/lcov.deb"
+wget -O "$LCOV_DEB" http://mirrors.kernel.org/ubuntu/pool/universe/l/lcov/lcov_1.15-1_all.deb
+sudo apt-get install "$LCOV_DEB"
+rm -rf $LCOV_TEMP
diff --git a/tools/install-wasm-dependencies b/tools/install-wasm-dependencies
index 31fc852b850b..d19611616ce9 100755
--- a/tools/install-wasm-dependencies
+++ b/tools/install-wasm-dependencies
@@ -2,7 +2,7 @@
 
 set -e
 
-emsdk_version=3.1.30
+emsdk_version=3.1.33
 
 git clone https://github.com/emscripten-core/emsdk.git