diff --git a/.github/workflows/linux-ci-rust.yml b/.github/workflows/linux-ci-rust.yml index 7e0889e824a..377c60ee23d 100644 --- a/.github/workflows/linux-ci-rust.yml +++ b/.github/workflows/linux-ci-rust.yml @@ -59,6 +59,10 @@ jobs: run: | tools/check-coverage rust/coverage.stats rust/coverage.info + - name: Run Doc tests + run: | + tools/rust-test doc + # Run Rust tests in WASM. test-wasm: runs-on: ubuntu-24.04 diff --git a/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/bitcoin/TestBitcoinSigning.kt b/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/bitcoin/TestBitcoinSigning.kt index abd187f8150..40b94298cd7 100644 --- a/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/bitcoin/TestBitcoinSigning.kt +++ b/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/bitcoin/TestBitcoinSigning.kt @@ -17,6 +17,7 @@ import wallet.core.jni.PublicKeyType import wallet.core.jni.proto.Bitcoin import wallet.core.jni.proto.Bitcoin.SigningOutput import wallet.core.jni.proto.BitcoinV2 +import wallet.core.jni.proto.Utxo import wallet.core.jni.proto.Common.SigningError class TestBitcoinSigning { @@ -172,7 +173,7 @@ class TestBitcoinSigning { val publicKey = ByteString.copyFrom(privateKey.getPublicKeySecp256k1(true).data()) val utxo0 = BitcoinV2.Input.newBuilder() - .setOutPoint(BitcoinV2.OutPoint.newBuilder().apply { + .setOutPoint(Utxo.OutPoint.newBuilder().apply { hash = ByteString.copyFrom(txId) vout = 1 }) @@ -238,7 +239,7 @@ class TestBitcoinSigning { val publicKey = ByteString.copyFrom(privateKey.getPublicKeySecp256k1(true).data()) val utxo0 = BitcoinV2.Input.newBuilder() - .setOutPoint(BitcoinV2.OutPoint.newBuilder().apply { + .setOutPoint(Utxo.OutPoint.newBuilder().apply { hash = ByteString.copyFrom(txIdCommit) vout = 0 }) @@ -299,7 +300,7 @@ class TestBitcoinSigning { val bobAddress = "bc1qazgc2zhu2kmy42py0vs8d7yff67l3zgpwfzlpk" val utxo0 = BitcoinV2.Input.newBuilder() - .setOutPoint(BitcoinV2.OutPoint.newBuilder().apply { + .setOutPoint(Utxo.OutPoint.newBuilder().apply { hash = ByteString.copyFrom(txIdInscription) vout = 0 }) @@ -310,7 +311,7 @@ class TestBitcoinSigning { }) val utxo1 = BitcoinV2.Input.newBuilder() - .setOutPoint(BitcoinV2.OutPoint.newBuilder().apply { + .setOutPoint(Utxo.OutPoint.newBuilder().apply { hash = ByteString.copyFrom(txIdForFees) vout = 1 }) 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 index 2c826c0bd4f..5ea76b7f78c 100644 --- 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 @@ -7,6 +7,7 @@ import org.junit.Test import wallet.core.java.AnySigner import wallet.core.jni.BitcoinSigHashType import wallet.core.jni.CoinType +import wallet.core.jni.proto.Utxo import wallet.core.jni.proto.Bitcoin import wallet.core.jni.proto.BitcoinV2 import wallet.core.jni.proto.Common.SigningError @@ -22,7 +23,7 @@ class TestBitcoinCashSigning { val privateKey = "7fdafb9db5bc501f2096e7d13d331dc7a75d9594af3d251313ba8b6200f4e384".toHexBytesInByteString() val utxo1 = BitcoinV2.Input.newBuilder().apply { - outPoint = BitcoinV2.OutPoint.newBuilder().apply { + outPoint = Utxo.OutPoint.newBuilder().apply { hash = "e28c2b955293159898e34c6840d99bf4d390e2ee1c6f606939f18ee1e2000d05".toHexBytesInByteString() vout = 2 }.build() diff --git a/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/zcash/TestZcashSigner.kt b/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/zcash/TestZcashSigner.kt new file mode 100644 index 00000000000..a5e7a434ef2 --- /dev/null +++ b/android/app/src/androidTest/java/com/trustwallet/core/app/blockchains/zcash/TestZcashSigner.kt @@ -0,0 +1,83 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// Copyright © 2017 Trust Wallet. + +package com.trustwallet.core.app.blockchains.zcash + +import com.google.protobuf.ByteString +import com.trustwallet.core.app.utils.Numeric +import org.junit.Assert.assertEquals +import org.junit.Test + +import wallet.core.java.AnySigner +import wallet.core.jni.BitcoinSigHashType +import wallet.core.jni.CoinType.ZCASH +import wallet.core.jni.proto.Common.SigningError +import wallet.core.jni.proto.Bitcoin +import wallet.core.jni.proto.Bitcoin.SigningOutput +import wallet.core.jni.proto.BitcoinV2 +import wallet.core.jni.proto.Utxo +import wallet.core.jni.proto.Zcash + +class TestZcashSigner { + + init { + System.loadLibrary("TrustWalletCore") + } + + @Test + fun testSignZcashV2() { + // Successfully broadcasted: https://explorer.zcha.in/transactions/ec9033381c1cc53ada837ef9981c03ead1c7c41700ff3a954389cfaddc949256 + val privateKeyData = Numeric.hexStringToByteArray("a9684f5bebd0e1208aae2e02bc9e9163bd1965ad23d8538644e1df8b99b99559") + val dustSatoshis = 546.toLong() + val senderAddress = "t1gWVE2uyrET2CxSmCaBiKzmWxQdHhnvMSz" + val toAddress = "t1QahNjDdibyE4EdYkawUSKBBcVTSqv64CS" + val sapplingBranchId = Numeric.hexStringToByteArray("0xbb09b876") + + val txid0 = Numeric.hexStringToByteArray("3a19dd44032dfed61bfca5ba5751aab8a107b30609cbd5d70dc5ef09885b6853").reversedArray() + val utxo0 = BitcoinV2.Input.newBuilder() + .setOutPoint(Utxo.OutPoint.newBuilder().apply { + hash = ByteString.copyFrom(txid0) + vout = 0 + }) + .setValue(494_000) + .setSighashType(BitcoinSigHashType.ALL.value()) + .setReceiverAddress(senderAddress) + + val out0 = BitcoinV2.Output.newBuilder() + .setValue(488_000) + .setToAddress(toAddress) + + val builder = BitcoinV2.TransactionBuilder.newBuilder() + .setVersion(BitcoinV2.TransactionVersion.UseDefault) + .addInputs(utxo0) + .addOutputs(out0) + .setInputSelector(BitcoinV2.InputSelector.UseAll) + .setFixedDustThreshold(dustSatoshis) + // Set ZCash specific extra parameters. + .setZcashExtraData(Zcash.TransactionBuilderExtraData.newBuilder().apply { + branchId = ByteString.copyFrom(sapplingBranchId) + }) + val signingInput = BitcoinV2.SigningInput.newBuilder() + .setBuilder(builder) + .addPrivateKeys(ByteString.copyFrom(privateKeyData)) + .setChainInfo(BitcoinV2.ChainInfo.newBuilder().apply { + p2PkhPrefix = 184 + p2ShPrefix = 189 + }) + .build() + + val legacySigningInput = Bitcoin.SigningInput.newBuilder().apply { + signingV2 = signingInput + coinType = ZCASH.value() + } + + val output = AnySigner.sign(legacySigningInput.build(), ZCASH, SigningOutput.parser()) + + assertEquals(output.error, SigningError.OK) + assertEquals(output.signingResultV2.errorMessage, "") + assertEquals(output.signingResultV2.error, SigningError.OK) + assertEquals(Numeric.toHexString(output.signingResultV2.encoded.toByteArray()), "0x0400008085202f890153685b8809efc50dd7d5cb0906b307a1b8aa5157baa5fc1bd6fe2d0344dd193a000000006b483045022100ca0be9f37a4975432a52bb65b25e483f6f93d577955290bb7fb0060a93bfc92002203e0627dff004d3c72a957dc9f8e4e0e696e69d125e4d8e275d119001924d3b48012103b243171fae5516d1dc15f9178cfcc5fdc67b0a883055c117b01ba8af29b953f6ffffffff0140720700000000001976a91449964a736f3713d64283fd0018626ba50091c7e988ac00000000000000000000000000000000000000") + assertEquals(Numeric.toHexString(output.signingResultV2.txid.toByteArray()), "0xec9033381c1cc53ada837ef9981c03ead1c7c41700ff3a954389cfaddc949256") + } +} diff --git a/codegen-v2/src/codegen/rust/templates/integration_tests/address_tests.rs b/codegen-v2/src/codegen/rust/templates/integration_tests/address_tests.rs index 1d417a77ed4..f3f6f2b5a99 100644 --- a/codegen-v2/src/codegen/rust/templates/integration_tests/address_tests.rs +++ b/codegen-v2/src/codegen/rust/templates/integration_tests/address_tests.rs @@ -4,13 +4,17 @@ use tw_any_coin::test_utils::address_utils::{ test_address_derive, test_address_get_data, test_address_invalid, test_address_normalization, - test_address_valid, + test_address_valid, KeyType, }; use tw_coin_registry::coin_type::CoinType; #[test] fn test_{COIN_ID}_address_derive() { - test_address_derive(CoinType::{COIN_TYPE}, "PRIVATE_KEY", "EXPECTED ADDRESS"); + test_address_derive( + CoinType::{COIN_TYPE}, + KeyType::PrivateKey("PRIVATE_KEY"), + "EXPECTED ADDRESS" + ); } #[test] diff --git a/include/TrustWalletCore/TWBlockchain.h b/include/TrustWalletCore/TWBlockchain.h index eeb2f744474..355134bda05 100644 --- a/include/TrustWalletCore/TWBlockchain.h +++ b/include/TrustWalletCore/TWBlockchain.h @@ -67,6 +67,7 @@ enum TWBlockchain { TWBlockchainNativeInjective = 54, // Cosmos TWBlockchainBitcoinCash = 55, TWBlockchainPactus = 56, + TWBlockchainKomodo = 57, }; TW_EXTERN_C_END diff --git a/registry.json b/registry.json index 72a5e13ce3a..c7abaa1b929 100644 --- a/registry.json +++ b/registry.json @@ -1397,7 +1397,7 @@ "coinId": 141, "symbol": "KMD", "decimals": 8, - "blockchain": "Zcash", + "blockchain": "Komodo", "derivation": [ { "path": "m/44'/141'/0'/0/0", diff --git a/rust/Cargo.lock b/rust/Cargo.lock index cdecec6380b..a3cb2b29049 100644 --- a/rust/Cargo.lock +++ b/rust/Cargo.lock @@ -1882,6 +1882,7 @@ dependencies = [ "tw_hash", "tw_internet_computer", "tw_keypair", + "tw_komodo", "tw_memory", "tw_misc", "tw_native_evmos", @@ -1895,6 +1896,7 @@ dependencies = [ "tw_thorchain", "tw_ton", "tw_utxo", + "tw_zcash", ] [[package]] @@ -2060,6 +2062,18 @@ dependencies = [ "zeroize", ] +[[package]] +name = "tw_komodo" +version = "0.1.0" +dependencies = [ + "tw_bitcoin", + "tw_coin_entry", + "tw_keypair", + "tw_proto", + "tw_utxo", + "tw_zcash", +] + [[package]] name = "tw_macros" version = "0.1.0" @@ -2336,6 +2350,21 @@ dependencies = [ "tw_proto", ] +[[package]] +name = "tw_zcash" +version = "0.1.0" +dependencies = [ + "tw_base58_address", + "tw_bitcoin", + "tw_coin_entry", + "tw_encoding", + "tw_hash", + "tw_keypair", + "tw_memory", + "tw_proto", + "tw_utxo", +] + [[package]] name = "typenum" version = "1.16.0" diff --git a/rust/Cargo.toml b/rust/Cargo.toml index 6449c190126..d84739eb539 100644 --- a/rust/Cargo.toml +++ b/rust/Cargo.toml @@ -9,6 +9,7 @@ members = [ "chains/tw_ethereum", "chains/tw_greenfield", "chains/tw_internet_computer", + "chains/tw_komodo", "chains/tw_native_evmos", "chains/tw_native_injective", "chains/tw_pactus", @@ -18,6 +19,7 @@ members = [ "chains/tw_sui", "chains/tw_thorchain", "chains/tw_ton", + "chains/tw_zcash", "frameworks/tw_substrate", "frameworks/tw_ton_sdk", "frameworks/tw_utxo", diff --git a/rust/chains/tw_bitcoin/src/context.rs b/rust/chains/tw_bitcoin/src/context.rs index 8ecdd4f8e55..5b65c0d0281 100644 --- a/rust/chains/tw_bitcoin/src/context.rs +++ b/rust/chains/tw_bitcoin/src/context.rs @@ -2,16 +2,35 @@ // // Copyright © 2017 Trust Wallet. +use crate::modules::protobuf_builder::standard_protobuf_builder::StandardProtobufBuilder; +use crate::modules::protobuf_builder::ProtobufBuilder; +use crate::modules::psbt_request::standard_psbt_request_builder::StandardPsbtRequestBuilder; +use crate::modules::psbt_request::PsbtRequestBuilder; +use crate::modules::signing_request::standard_signing_request::StandardSigningRequestBuilder; +use crate::modules::signing_request::SigningRequestBuilder; use tw_coin_entry::error::prelude::SigningResult; use tw_utxo::address::standard_bitcoin::StandardBitcoinAddress; use tw_utxo::context::{AddressPrefixes, UtxoContext}; +use tw_utxo::fee::fee_estimator::StandardFeeEstimator; use tw_utxo::script::Script; +use tw_utxo::transaction::standard_transaction::Transaction; + +/// A set of associated modules different from a chain to chain. +/// The modules are mainly used to generate a signing request from a [`BitcoinV2::Proto::SigningInput`], +/// and generate a [`Utxo::Proto::Transaction`] output when the transaction is signed. +pub trait BitcoinSigningContext: UtxoContext + Sized { + type SigningRequestBuilder: SigningRequestBuilder; + type ProtobufBuilder: ProtobufBuilder; + type PsbtRequestBuilder: PsbtRequestBuilder; +} #[derive(Default)] pub struct StandardBitcoinContext; impl UtxoContext for StandardBitcoinContext { type Address = StandardBitcoinAddress; + type Transaction = Transaction; + type FeeEstimator = StandardFeeEstimator; fn addr_to_script_pubkey( addr: &Self::Address, @@ -26,3 +45,9 @@ impl UtxoContext for StandardBitcoinContext { } } } + +impl BitcoinSigningContext for StandardBitcoinContext { + type SigningRequestBuilder = StandardSigningRequestBuilder; + type ProtobufBuilder = StandardProtobufBuilder; + type PsbtRequestBuilder = StandardPsbtRequestBuilder; +} diff --git a/rust/chains/tw_bitcoin/src/modules/compiler.rs b/rust/chains/tw_bitcoin/src/modules/compiler.rs index e596df15a58..a2ce77d7176 100644 --- a/rust/chains/tw_bitcoin/src/modules/compiler.rs +++ b/rust/chains/tw_bitcoin/src/modules/compiler.rs @@ -2,8 +2,9 @@ // // Copyright © 2017 Trust Wallet. +use crate::context::BitcoinSigningContext; use crate::modules::protobuf_builder::ProtobufBuilder; -use crate::modules::psbt_request::PsbtRequest; +use crate::modules::psbt_request::{PsbtRequest, PsbtRequestBuilder}; use crate::modules::signing_request::SigningRequestBuilder; use std::borrow::Cow; use std::marker::PhantomData; @@ -17,6 +18,7 @@ use tw_proto::BitcoinV2::Proto::mod_PreSigningOutput::{ }; use tw_proto::BitcoinV2::Proto::mod_SigningInput::OneOftransaction as TransactionType; use tw_utxo::context::UtxoContext; +use tw_utxo::encode::Encodable; use tw_utxo::modules::sighash_computer::{SighashComputer, TaprootTweak, TxPreimage}; use tw_utxo::modules::sighash_verifier::SighashVerifier; use tw_utxo::modules::tx_compiler::TxCompiler; @@ -29,7 +31,7 @@ pub struct BitcoinCompiler { _phantom: PhantomData, } -impl BitcoinCompiler { +impl BitcoinCompiler { /// 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] @@ -47,11 +49,11 @@ impl BitcoinCompiler { ) -> SigningResult> { let unsigned_tx = match input.transaction { TransactionType::builder(ref tx_builder) => { - let request = SigningRequestBuilder::::build(coin, &input, tx_builder)?; + let request = Context::SigningRequestBuilder::build(coin, &input, tx_builder)?; TxPlanner::plan(request)?.unsigned_tx }, TransactionType::psbt(ref psbt) => { - PsbtRequest::::build(&input, psbt)?.unsigned_tx + Context::PsbtRequestBuilder::build(&input, psbt)?.unsigned_tx }, TransactionType::None => { return SigningError::err(SigningErrorType::Error_invalid_params) @@ -110,15 +112,14 @@ impl BitcoinCompiler { tx_builder_input: &Proto::TransactionBuilder, signatures: Vec, ) -> SigningResult> { - let request = SigningRequestBuilder::::build(coin, input, tx_builder_input)?; + let request = Context::SigningRequestBuilder::build(coin, input, tx_builder_input)?; let SelectResult { unsigned_tx, plan } = TxPlanner::plan(request)?; SighashVerifier::verify_signatures(&unsigned_tx, &signatures)?; let signed_tx = TxCompiler::compile(unsigned_tx, &signatures)?; - let tx_proto = ProtobufBuilder::tx_to_proto(&signed_tx); Ok(Proto::SigningOutput { - transaction: Some(tx_proto), + transaction: Context::ProtobufBuilder::tx_to_proto(&signed_tx), encoded: Cow::from(signed_tx.encode_out()), txid: Cow::from(signed_tx.txid()), // `vsize` could have been changed after the transaction being signed. @@ -136,15 +137,14 @@ impl BitcoinCompiler { psbt: &Proto::Psbt, signatures: Vec, ) -> SigningResult> { - let PsbtRequest { unsigned_tx, .. } = PsbtRequest::::build(input, psbt)?; + let PsbtRequest { unsigned_tx, .. } = Context::PsbtRequestBuilder::build(input, psbt)?; let fee = unsigned_tx.fee()?; SighashVerifier::verify_signatures(&unsigned_tx, &signatures)?; let signed_tx = TxCompiler::compile(unsigned_tx, &signatures)?; - let tx_proto = ProtobufBuilder::tx_to_proto(&signed_tx); Ok(Proto::SigningOutput { - transaction: Some(tx_proto), + transaction: Context::ProtobufBuilder::tx_to_proto(&signed_tx), encoded: Cow::from(signed_tx.encode_out()), txid: Cow::from(signed_tx.txid()), // `vsize` could have been changed after the transaction being signed. diff --git a/rust/chains/tw_bitcoin/src/modules/planner/mod.rs b/rust/chains/tw_bitcoin/src/modules/planner/mod.rs index f36669e1931..ffd2d809c92 100644 --- a/rust/chains/tw_bitcoin/src/modules/planner/mod.rs +++ b/rust/chains/tw_bitcoin/src/modules/planner/mod.rs @@ -2,6 +2,7 @@ // // Copyright © 2017 Trust Wallet. +use crate::context::BitcoinSigningContext; use crate::modules::signing_request::SigningRequestBuilder; use crate::modules::tx_builder::utxo_protobuf::parse_out_point; use std::borrow::Cow; @@ -15,6 +16,9 @@ use tw_proto::BitcoinV2::Proto; use tw_utxo::context::UtxoContext; use tw_utxo::modules::tx_planner::TxPlanner; use tw_utxo::modules::utxo_selector::SelectResult; +use tw_utxo::transaction::transaction_interface::{ + TransactionInterface, TxInputInterface, TxOutputInterface, +}; pub mod psbt_planner; @@ -23,7 +27,7 @@ pub struct BitcoinPlanner { _phantom: PhantomData, } -impl BitcoinPlanner { +impl BitcoinPlanner { pub fn plan_impl<'a>( coin: &dyn CoinContext, input: &Proto::SigningInput<'a>, @@ -45,7 +49,7 @@ impl BitcoinPlanner { input: &Proto::SigningInput<'a>, tx_builder: &Proto::TransactionBuilder<'a>, ) -> SigningResult> { - let request = SigningRequestBuilder::::build(coin, input, tx_builder)?; + let request = Context::SigningRequestBuilder::build(coin, input, tx_builder)?; let SelectResult { unsigned_tx, plan } = TxPlanner::plan(request)?; // Prepare a map of source Inputs Proto `{ OutPoint -> Input }`. @@ -64,23 +68,23 @@ impl BitcoinPlanner { let mut selected_inputs_proto = Vec::with_capacity(unsigned_tx.inputs().len()); for selected_utxo in unsigned_tx.inputs() { let utxo_proto = inputs_map - .get(&selected_utxo.previous_output) + .get(selected_utxo.previous_output()) .or_tw_err(SigningErrorType::Error_internal) .context("Planned transaction contains an unknown UTXO")?; selected_inputs_proto.push((*utxo_proto).clone()); } // Fill out the Output Proto. - let mut outputs_proto = Vec::with_capacity(unsigned_tx.transaction().outputs.len()); - for selected_output in unsigned_tx.transaction().outputs.iter() { + let mut outputs_proto = Vec::with_capacity(unsigned_tx.transaction().outputs().len()); + for selected_output in unsigned_tx.transaction().outputs().iter() { // For now, just provide a scriptPubkey as is. // Later it's probably worth to return the same output builders as in `SigningInput`. let to_recipient = Proto::mod_Output::OneOfto_recipient::custom_script_pubkey( - Cow::from(selected_output.script_pubkey.to_vec()), + Cow::from(selected_output.script_pubkey().to_vec()), ); outputs_proto.push(Proto::Output { - value: selected_output.value, + value: selected_output.value(), to_recipient, }) } @@ -98,7 +102,7 @@ impl BitcoinPlanner { } } -impl PlanBuilder for BitcoinPlanner { +impl PlanBuilder for BitcoinPlanner { 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 545862d1691..3543a5b1fd8 100644 --- a/rust/chains/tw_bitcoin/src/modules/planner/psbt_planner.rs +++ b/rust/chains/tw_bitcoin/src/modules/planner/psbt_planner.rs @@ -2,8 +2,9 @@ // // Copyright © 2017 Trust Wallet. -use crate::modules::psbt_request::PsbtRequest; -use crate::modules::signing_request::SigningRequestBuilder; +use crate::context::BitcoinSigningContext; +use crate::modules::psbt_request::{PsbtRequest, PsbtRequestBuilder}; +use crate::modules::signing_request::standard_signing_request::chain_info; use crate::modules::tx_builder::script_parser::StandardScriptParser; use crate::modules::tx_builder::BitcoinChainInfo; use std::marker::PhantomData; @@ -12,23 +13,26 @@ 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_proto::Utxo::Proto as UtxoProto; +use tw_utxo::context::{ContextTransactionInput, ContextTransactionOutput}; +use tw_utxo::transaction::transaction_interface::{ + TransactionInterface, TxInputInterface, TxOutputInterface, +}; use tw_utxo::transaction::UtxoToSign; -pub struct PsbtPlanner { +pub struct PsbtPlanner { _phantom: PhantomData, } -impl PsbtPlanner { +impl PsbtPlanner { pub fn plan_psbt( coin: &dyn CoinContext, input: &Proto::SigningInput, psbt_input: &Proto::Psbt, ) -> SigningResult> { - let chain_info = SigningRequestBuilder::::chain_info(coin, &input.chain_info)?; - let PsbtRequest { unsigned_tx, .. } = PsbtRequest::::build(input, psbt_input)?; + let chain_info = chain_info(coin, &input.chain_info)?; + let PsbtRequest { unsigned_tx, .. } = + Context::PsbtRequestBuilder::build(input, psbt_input)?; let total_input = unsigned_tx.total_input()?; let fee_estimate = unsigned_tx.fee()?; @@ -62,17 +66,18 @@ impl PsbtPlanner { pub fn utxo_to_proto( unsigned_txin: &UtxoToSign, - txin: &TransactionInput, + txin: &ContextTransactionInput, chain_info: &BitcoinChainInfo, ) -> SigningResult> { - let out_point = Proto::OutPoint { - hash: txin.previous_output.hash.to_vec().into(), - vout: txin.previous_output.index, + let out_point = UtxoProto::OutPoint { + hash: txin.previous_output().hash.to_vec().into(), + vout: txin.previous_output().index, }; let sequence = Proto::mod_Input::Sequence { - sequence: txin.sequence, + sequence: txin.sequence(), }; + // TODO add `UtxoSigningContext::ScriptParser` associative type. let from_address = StandardScriptParser .parse(&unsigned_txin.prevout_script_pubkey)? .try_to_address(chain_info)? @@ -90,20 +95,21 @@ impl PsbtPlanner { } pub fn output_to_proto( - output: &TransactionOutput, + output: &ContextTransactionOutput, chain_info: &BitcoinChainInfo, ) -> SigningResult> { + // TODO add `UtxoSigningContext::ScriptParser` associative type. let to_recipient = match StandardScriptParser - .parse(&output.script_pubkey)? + .parse(output.script_pubkey())? .try_to_address(chain_info)? { Some(to_addr) => ToRecipientProto::to_address(to_addr.to_string().into()), // Cannot convert the output scriptPubkey into an address. Return it as is. - None => ToRecipientProto::custom_script_pubkey(output.script_pubkey.to_vec().into()), + None => ToRecipientProto::custom_script_pubkey(output.script_pubkey().to_vec().into()), }; Ok(Proto::Output { - value: output.value, + value: output.value(), to_recipient, }) } diff --git a/rust/chains/tw_bitcoin/src/modules/protobuf_builder/mod.rs b/rust/chains/tw_bitcoin/src/modules/protobuf_builder/mod.rs index dc25bc975e5..07f4b05b8aa 100644 --- a/rust/chains/tw_bitcoin/src/modules/protobuf_builder/mod.rs +++ b/rust/chains/tw_bitcoin/src/modules/protobuf_builder/mod.rs @@ -2,57 +2,12 @@ // // Copyright © 2017 Trust Wallet. -use std::borrow::Cow; -use tw_proto::BitcoinV2::Proto; -use tw_utxo::script::{Script, Witness}; -use tw_utxo::transaction::standard_transaction::{ - Transaction, TransactionInput, TransactionOutput, -}; -use tw_utxo::transaction::transaction_interface::TransactionInterface; +use tw_utxo::context::UtxoContext; -pub struct ProtobufBuilder; +pub use tw_proto::BitcoinV2::Proto::mod_SigningOutput::OneOftransaction as ProtobufTransaction; -impl ProtobufBuilder { - pub fn tx_to_proto(tx: &Transaction) -> Proto::Transaction<'static> { - let inputs = tx.inputs().iter().map(Self::tx_input_to_proto).collect(); - let outputs = tx.outputs().iter().map(Self::tx_output_to_proto).collect(); +pub mod standard_protobuf_builder; - Proto::Transaction { - version: tx.version(), - lock_time: tx.locktime, - inputs, - outputs, - } - } - - fn tx_input_to_proto( - input: &TransactionInput, - ) -> Proto::mod_Transaction::TransactionInput<'static> { - Proto::mod_Transaction::TransactionInput { - out_point: Some(Proto::OutPoint { - hash: Cow::from(input.previous_output.hash.to_vec()), - vout: input.previous_output.index, - }), - sequence: input.sequence, - script_sig: Self::script_data(&input.script_sig), - witness_items: Self::witness_to_proto(&input.witness), - } - } - - fn tx_output_to_proto( - output: &TransactionOutput, - ) -> Proto::mod_Transaction::TransactionOutput<'static> { - Proto::mod_Transaction::TransactionOutput { - script_pubkey: Self::script_data(&output.script_pubkey), - value: output.value, - } - } - - fn witness_to_proto(witness: &Witness) -> Vec> { - witness.as_items().iter().map(Self::script_data).collect() - } - - fn script_data(script: &Script) -> Cow<'static, [u8]> { - Cow::from(script.to_vec()) - } +pub trait ProtobufBuilder { + fn tx_to_proto(tx: &Context::Transaction) -> ProtobufTransaction<'static>; } diff --git a/rust/chains/tw_bitcoin/src/modules/protobuf_builder/standard_protobuf_builder.rs b/rust/chains/tw_bitcoin/src/modules/protobuf_builder/standard_protobuf_builder.rs new file mode 100644 index 00000000000..a726983064c --- /dev/null +++ b/rust/chains/tw_bitcoin/src/modules/protobuf_builder/standard_protobuf_builder.rs @@ -0,0 +1,61 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// Copyright © 2017 Trust Wallet. + +use crate::modules::protobuf_builder::{ProtobufBuilder, ProtobufTransaction}; +use std::borrow::Cow; +use tw_proto::Utxo::Proto as UtxoProto; +use tw_utxo::context::UtxoContext; +use tw_utxo::script::{Script, Witness}; +use tw_utxo::transaction::standard_transaction::{ + Transaction, TransactionInput, TransactionOutput, +}; +use tw_utxo::transaction::transaction_interface::TransactionInterface; + +pub struct StandardProtobufBuilder; + +impl ProtobufBuilder for StandardProtobufBuilder +where + Context: UtxoContext, +{ + fn tx_to_proto(tx: &Context::Transaction) -> ProtobufTransaction<'static> { + let inputs = tx.inputs().iter().map(Self::tx_input_to_proto).collect(); + let outputs = tx.outputs().iter().map(Self::tx_output_to_proto).collect(); + + ProtobufTransaction::bitcoin(UtxoProto::Transaction { + version: tx.version(), + lock_time: tx.locktime, + inputs, + outputs, + }) + } +} + +impl StandardProtobufBuilder { + pub fn tx_input_to_proto(input: &TransactionInput) -> UtxoProto::TransactionInput<'static> { + UtxoProto::TransactionInput { + out_point: Some(UtxoProto::OutPoint { + hash: Cow::from(input.previous_output.hash.to_vec()), + vout: input.previous_output.index, + }), + sequence: input.sequence, + script_sig: Self::script_data(&input.script_sig), + witness_items: Self::witness_to_proto(&input.witness), + } + } + + pub fn tx_output_to_proto(output: &TransactionOutput) -> UtxoProto::TransactionOutput<'static> { + UtxoProto::TransactionOutput { + script_pubkey: Self::script_data(&output.script_pubkey), + value: output.value, + } + } + + fn witness_to_proto(witness: &Witness) -> Vec> { + witness.as_items().iter().map(Self::script_data).collect() + } + + fn script_data(script: &Script) -> Cow<'static, [u8]> { + Cow::from(script.to_vec()) + } +} diff --git a/rust/chains/tw_bitcoin/src/modules/psbt.rs b/rust/chains/tw_bitcoin/src/modules/psbt.rs index 58bb5d54a58..f752972e4c5 100644 --- a/rust/chains/tw_bitcoin/src/modules/psbt.rs +++ b/rust/chains/tw_bitcoin/src/modules/psbt.rs @@ -3,21 +3,24 @@ // Copyright © 2017 Trust Wallet. use bitcoin::psbt::Psbt; -use tw_utxo::transaction::standard_transaction::Transaction; +use tw_utxo::transaction::transaction_interface::{TransactionInterface, TxInputInterface}; /// Finalizes the [Partially Signed Bitcoin Transaction](Psbt) /// by updating the final `script_sig` and/or `witness`. -pub fn update_psbt_signed(psbt: &mut Psbt, signed_tx: &Transaction) { - for (signed_txin, utxo_psbt) in signed_tx.inputs.iter().zip(psbt.inputs.iter_mut()) { - if !signed_txin.script_sig.is_empty() { +pub fn update_psbt_signed( + psbt: &mut Psbt, + signed_tx: &Transaction, +) { + for (signed_txin, utxo_psbt) in signed_tx.inputs().iter().zip(psbt.inputs.iter_mut()) { + if signed_txin.has_script_sig() { utxo_psbt.final_script_sig = Some(bitcoin::ScriptBuf::from_bytes( - signed_txin.script_sig.to_vec(), + signed_txin.script_sig().to_vec(), )); } - if !signed_txin.witness.is_empty() { + if signed_txin.has_witness() { let mut final_witness = bitcoin::Witness::new(); - for witness_item in signed_txin.witness.as_items() { + for witness_item in signed_txin.witness().as_items() { final_witness.push(bitcoin::ScriptBuf::from_bytes(witness_item.to_vec())); } utxo_psbt.final_script_witness = Some(final_witness); 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 5ecac42cae0..1964243f55a 100644 --- a/rust/chains/tw_bitcoin/src/modules/psbt_request/mod.rs +++ b/rust/chains/tw_bitcoin/src/modules/psbt_request/mod.rs @@ -2,69 +2,38 @@ // // Copyright © 2017 Trust Wallet. -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; pub mod output_psbt; +pub mod standard_psbt_request_builder; pub mod utxo_psbt; +pub trait PsbtRequestBuilder { + fn build( + input: &Proto::SigningInput, + psbt_input: &Proto::Psbt, + ) -> SigningResult>; +} + pub struct PsbtRequest { pub psbt: Psbt, - pub unsigned_tx: UnsignedTransaction, + pub unsigned_tx: UnsignedTransaction, _phantom: PhantomData, } -impl PsbtRequest { - pub fn build(input: &Proto::SigningInput, psbt_input: &Proto::Psbt) -> SigningResult { - let psbt = Psbt::deserialize(&psbt_input.psbt) - .tw_err(|_| SigningErrorType::Error_input_parse) - .context("Error deserializing PSBT")?; - - let version = psbt - .unsigned_tx - .version - .try_into() - .tw_err(|_| SigningErrorType::Error_invalid_params) - .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 mut builder = TransactionBuilder::default(); - builder.version(version).lock_time(lock_time); - - // Add all UTXOs to the unsigned transaction builder. - for (txin, txin_psbt) in psbt.unsigned_tx.input.iter().zip(psbt.inputs.iter()) { - let utxo_builder = UtxoPsbt::new(txin, txin_psbt, &public_keys); - - let (utxo, utxo_args) = utxo_builder - .build() - .context("Error creating UTXO from PSBT")?; - builder.push_input(utxo, utxo_args); - } - - // Add all outputs to the unsigned transaction builder. - for txout in psbt.unsigned_tx.output.iter() { - let output = OutputPsbt::new(txout) - .build() - .context("Error creating Output from PSBT")?; - builder.push_output(output); - } +pub struct NoPsbtRequestBuilder; - let unsigned_tx = builder.build()?; - Ok(PsbtRequest { - psbt, - unsigned_tx, - _phantom: PhantomData, - }) +impl PsbtRequestBuilder for NoPsbtRequestBuilder { + fn build( + _input: &Proto::SigningInput, + _psbt_input: &Proto::Psbt, + ) -> SigningResult> { + SigningError::err(SigningErrorType::Error_not_supported) + .context("PSBT signing is not supported") } } diff --git a/rust/chains/tw_bitcoin/src/modules/psbt_request/standard_psbt_request_builder.rs b/rust/chains/tw_bitcoin/src/modules/psbt_request/standard_psbt_request_builder.rs new file mode 100644 index 00000000000..be05250758d --- /dev/null +++ b/rust/chains/tw_bitcoin/src/modules/psbt_request/standard_psbt_request_builder.rs @@ -0,0 +1,69 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// Copyright © 2017 Trust Wallet. + +use crate::modules::psbt_request::output_psbt::OutputPsbt; +use crate::modules::psbt_request::utxo_psbt::UtxoPsbt; +use crate::modules::psbt_request::{PsbtRequest, PsbtRequestBuilder}; +use crate::modules::signing_request::standard_signing_request::StandardSigningRequestBuilder; +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; + +pub struct StandardPsbtRequestBuilder; + +impl PsbtRequestBuilder for StandardPsbtRequestBuilder +where + Context: UtxoContext, +{ + fn build( + input: &Proto::SigningInput, + psbt_input: &Proto::Psbt, + ) -> SigningResult> { + let psbt = Psbt::deserialize(&psbt_input.psbt) + .tw_err(|_| SigningErrorType::Error_input_parse) + .context("Error deserializing PSBT")?; + + let version = psbt + .unsigned_tx + .version + .try_into() + .tw_err(|_| SigningErrorType::Error_invalid_params) + .context("Invalid PSBT transaction version")?; + let lock_time = psbt.unsigned_tx.lock_time.to_consensus_u32(); + + let public_keys = StandardSigningRequestBuilder::get_public_keys(input)?; + + let mut builder = TransactionBuilder::default(); + builder.version(version).lock_time(lock_time); + + // Add all UTXOs to the unsigned transaction builder. + for (txin, txin_psbt) in psbt.unsigned_tx.input.iter().zip(psbt.inputs.iter()) { + let utxo_builder = UtxoPsbt::new(txin, txin_psbt, &public_keys); + + let (utxo, utxo_args) = utxo_builder + .build() + .context("Error creating UTXO from PSBT")?; + builder.push_input(utxo, utxo_args); + } + + // Add all outputs to the unsigned transaction builder. + for txout in psbt.unsigned_tx.output.iter() { + let output = OutputPsbt::new(txout) + .build() + .context("Error creating Output from PSBT")?; + builder.push_output(output); + } + + let unsigned_tx = builder.build()?; + 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 5db22d32e74..db95ceab71e 100644 --- a/rust/chains/tw_bitcoin/src/modules/signer.rs +++ b/rust/chains/tw_bitcoin/src/modules/signer.rs @@ -2,9 +2,10 @@ // // Copyright © 2017 Trust Wallet. +use crate::context::BitcoinSigningContext; use crate::modules::protobuf_builder::ProtobufBuilder; use crate::modules::psbt::update_psbt_signed; -use crate::modules::psbt_request::PsbtRequest; +use crate::modules::psbt_request::{PsbtRequest, PsbtRequestBuilder}; use crate::modules::signing_request::SigningRequestBuilder; use std::borrow::Cow; use std::marker::PhantomData; @@ -13,21 +14,20 @@ 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::encode::Encodable; use tw_utxo::modules::keys_manager::KeysManager; use tw_utxo::modules::tx_planner::TxPlanner; use tw_utxo::modules::tx_signer::TxSigner; use tw_utxo::modules::utxo_selector::SelectResult; use tw_utxo::signing_mode::SigningMethod; -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 { _phantom: PhantomData, } -impl BitcoinSigner { +impl BitcoinSigner { pub fn sign( coin: &dyn CoinContext, input: &Proto::SigningInput<'_>, @@ -55,7 +55,7 @@ impl BitcoinSigner { input: &Proto::SigningInput, tx_builder_input: &Proto::TransactionBuilder, ) -> SigningResult> { - let request = SigningRequestBuilder::::build(coin, input, tx_builder_input)?; + let request = Context::SigningRequestBuilder::build(coin, input, tx_builder_input)?; let SelectResult { unsigned_tx, plan } = TxPlanner::plan(request)?; let keys_manager = Self::keys_manager_for_tx( @@ -68,7 +68,7 @@ impl BitcoinSigner { TxSigner::sign_tx(unsigned_tx, &keys_manager).context("Error signing transaction")?; Ok(Proto::SigningOutput { - transaction: Some(ProtobufBuilder::tx_to_proto(&signed_tx)), + transaction: Context::ProtobufBuilder::tx_to_proto(&signed_tx), encoded: Cow::from(signed_tx.encode_out()), txid: Cow::from(signed_tx.txid()), // `vsize` could have been changed after the transaction being signed. @@ -89,7 +89,7 @@ impl BitcoinSigner { mut psbt, unsigned_tx, .. - } = PsbtRequest::::build(input, psbt_input)?; + } = Context::PsbtRequestBuilder::build(input, psbt_input)?; let fee = unsigned_tx.fee()?; @@ -105,7 +105,7 @@ impl BitcoinSigner { update_psbt_signed(&mut psbt, &signed_tx); Ok(Proto::SigningOutput { - transaction: Some(ProtobufBuilder::tx_to_proto(&signed_tx)), + transaction: Context::ProtobufBuilder::tx_to_proto(&signed_tx), encoded: Cow::from(signed_tx.encode_out()), txid: Cow::from(signed_tx.txid()), // `vsize` could have been changed after the transaction being signed. @@ -121,7 +121,7 @@ impl BitcoinSigner { fn keys_manager_for_tx

( private_keys: &[P], - unsigned_tx: &UnsignedTransaction, + unsigned_tx: &UnsignedTransaction, dangerous_use_fixed_schnorr_rng: bool, ) -> SigningResult where 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 8e62b8b6d2b..6e38aee9f1c 100644 --- a/rust/chains/tw_bitcoin/src/modules/signing_request/mod.rs +++ b/rust/chains/tw_bitcoin/src/modules/signing_request/mod.rs @@ -2,181 +2,18 @@ // // Copyright © 2017 Trust Wallet. -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; -use tw_utxo::transaction::standard_transaction::builder::TransactionBuilder; -use tw_utxo::transaction::standard_transaction::Transaction; -use Proto::mod_TransactionBuilder::OneOfdust_policy as ProtoDustPolicy; +use tw_utxo::modules::tx_planner::PlanRequest; -const DEFAULT_TX_VERSION: u32 = 1; +pub mod standard_signing_request; -pub type StandardSigningRequest = PlanRequest; - -pub struct SigningRequestBuilder { - _phantom: PhantomData, -} - -impl SigningRequestBuilder { - pub fn build( +pub trait SigningRequestBuilder { + fn build( coin: &dyn CoinContext, input: &Proto::SigningInput, transaction_builder: &Proto::TransactionBuilder, - ) -> SigningResult { - let chain_info = Self::chain_info(coin, &input.chain_info)?; - let dust_policy = Self::dust_policy(&transaction_builder.dust_policy)?; - let fee_per_vbyte = transaction_builder.fee_per_vb; - let version = Self::transaction_version(&transaction_builder.version); - - let public_keys = Self::get_public_keys(input)?; - - let mut builder = TransactionBuilder::default(); - builder - .version(version) - .lock_time(transaction_builder.lock_time); - - // Parse all UTXOs. - for utxo_proto in transaction_builder.inputs.iter() { - let utxo_builder = UtxoProtobuf::::new(&chain_info, utxo_proto, &public_keys); - - let (utxo, utxo_args) = utxo_builder - .utxo_from_proto() - .context("Error creating UTXO from Protobuf")?; - builder.push_input(utxo, utxo_args); - } - - // 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 max_output = output_builder - .output_from_proto() - .context("Error creating Max Output from Protobuf")?; - builder.push_output(max_output); - - let unsigned_tx = builder.build()?; - return Ok(StandardSigningRequest { - ty: RequestType::SendMax { unsigned_tx }, - dust_policy, - fee_per_vbyte, - }); - } - - // `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) - .output_from_proto() - .context("Error creating Output from Proto")?; - builder.push_output(output); - } - - // Parse change output if it was provided. - let change_output = transaction_builder - .change_output - .as_ref() - .map(|change_output_proto| { - OutputProtobuf::::new(&chain_info, change_output_proto) - .output_from_proto() - .context("Error creating Change Output from Proto") - }) - .transpose()?; - - let input_selector = Self::input_selector(&transaction_builder.input_selector); - - let unsigned_tx = builder.build()?; - Ok(StandardSigningRequest { - ty: RequestType::SendExact { - unsigned_tx, - change_output, - input_selector, - }, - dust_policy, - fee_per_vbyte, - }) - } - - pub fn get_public_keys(input: &Proto::SigningInput) -> SigningResult { - let mut public_keys = PublicKeys::default(); - - if input.private_keys.is_empty() { - for public in input.public_keys.iter() { - public_keys.add_public_key(public.to_vec()); - } - } else { - for private in input.private_keys.iter() { - public_keys.add_public_with_ecdsa_private(private)?; - } - } - - Ok(public_keys) - } - - fn input_selector(selector: &Proto::InputSelector) -> InputSelector { - match selector { - Proto::InputSelector::SelectAscending => InputSelector::Ascending, - Proto::InputSelector::SelectInOrder => InputSelector::InOrder, - Proto::InputSelector::SelectDescending => InputSelector::Descending, - Proto::InputSelector::UseAll => InputSelector::UseAll, - } - } - - fn dust_policy(proto: &ProtoDustPolicy) -> SigningResult { - match proto { - ProtoDustPolicy::fixed_dust_threshold(fixed) => Ok(DustPolicy::FixedAmount(*fixed)), - ProtoDustPolicy::None => SigningError::err(SigningErrorType::Error_invalid_params) - .context("No dust policy provided"), - } - } - - fn transaction_version(proto: &Proto::TransactionVersion) -> u32 { - match proto { - Proto::TransactionVersion::UseDefault => DEFAULT_TX_VERSION, - Proto::TransactionVersion::V1 => 1, - Proto::TransactionVersion::V2 => 2, - } - } - - pub fn chain_info( - coin: &dyn CoinContext, - chain_info: &Option, - ) -> SigningResult { - fn prefix_to_u8(prefix: u32, prefix_name: &str) -> SigningResult { - prefix - .try_into() - .tw_err(|_| SigningErrorType::Error_invalid_params) - .with_context(|| format!("Invalid {prefix_name} prefix. It must fit uint8")) - } - - if let Some(info) = chain_info { - let hrp = info.hrp.to_string().empty_or_some(); - return Ok(BitcoinChainInfo { - p2pkh_prefix: prefix_to_u8(info.p2pkh_prefix, "p2pkh")?, - p2sh_prefix: prefix_to_u8(info.p2sh_prefix, "p2sh")?, - hrp, - }); - } - - // Try to get the chain info from the context. - // Note that not all Bitcoin forks support HRP (segwit addresses). - let hrp = coin.hrp(); - match (coin.p2pkh_prefix(), coin.p2sh_prefix()) { - (Some(p2pkh_prefix), Some(p2sh_prefix)) => Ok(BitcoinChainInfo { - p2pkh_prefix, - p2sh_prefix, - hrp, - }), - _ => SigningError::err(SigningErrorType::Error_invalid_params) - .context("Neither 'SigningInput.chain_info' nor p2pkh/p2sh prefixes specified in the registry.json") - } - } + ) -> SigningResult>; } diff --git a/rust/chains/tw_bitcoin/src/modules/signing_request/standard_signing_request.rs b/rust/chains/tw_bitcoin/src/modules/signing_request/standard_signing_request.rs new file mode 100644 index 00000000000..fecb06d7e71 --- /dev/null +++ b/rust/chains/tw_bitcoin/src/modules/signing_request/standard_signing_request.rs @@ -0,0 +1,196 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// Copyright © 2017 Trust Wallet. + +use crate::context::StandardBitcoinContext; +use crate::modules::signing_request::SigningRequestBuilder; +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 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::fee::fee_estimator::StandardFeeEstimator; +use tw_utxo::fee::FeePolicy; +use tw_utxo::modules::tx_planner::{PlanRequest, RequestType}; +use tw_utxo::modules::utxo_selector::InputSelector; +use tw_utxo::transaction::standard_transaction::builder::TransactionBuilder; +use tw_utxo::transaction::standard_transaction::Transaction; +use Proto::mod_TransactionBuilder::OneOfdust_policy as ProtoDustPolicy; + +const DEFAULT_TX_VERSION: u32 = 1; + +pub type StandardSigningRequest = PlanRequest; + +pub struct StandardSigningRequestBuilder; + +impl SigningRequestBuilder for StandardSigningRequestBuilder +where + Context: + UtxoContext>, +{ + fn build( + coin: &dyn CoinContext, + input: &Proto::SigningInput, + transaction_builder: &Proto::TransactionBuilder, + ) -> SigningResult> { + let chain_info = chain_info(coin, &input.chain_info)?; + let dust_policy = Self::dust_policy(&transaction_builder.dust_policy)?; + let fee_estimator = Self::fee_estimator(transaction_builder)?; + let version = Self::transaction_version(&transaction_builder.version); + + let public_keys = Self::get_public_keys(input)?; + + let mut builder = TransactionBuilder::default(); + builder + .version(version) + .lock_time(transaction_builder.lock_time); + + // Parse all UTXOs. + for utxo_proto in transaction_builder.inputs.iter() { + let utxo_builder = UtxoProtobuf::::new(&chain_info, utxo_proto, &public_keys); + + let (utxo, utxo_args) = utxo_builder + .utxo_from_proto() + .context("Error creating UTXO from Protobuf")?; + builder.push_input(utxo, utxo_args); + } + + // 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 max_output = output_builder + .output_from_proto() + .context("Error creating Max Output from Protobuf")?; + builder.push_output(max_output); + + let unsigned_tx = builder.build()?; + return Ok(PlanRequest { + ty: RequestType::SendMax { unsigned_tx }, + dust_policy, + fee_estimator, + }); + } + + // `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) + .output_from_proto() + .context("Error creating Output from Proto")?; + builder.push_output(output); + } + + // Parse change output if it was provided. + let change_output = transaction_builder + .change_output + .as_ref() + .map(|change_output_proto| { + OutputProtobuf::::new(&chain_info, change_output_proto) + .output_from_proto() + .context("Error creating Change Output from Proto") + }) + .transpose()?; + + let input_selector = Self::input_selector(&transaction_builder.input_selector); + + let unsigned_tx = builder.build()?; + Ok(PlanRequest { + ty: RequestType::SendExact { + unsigned_tx, + change_output, + input_selector, + }, + dust_policy, + fee_estimator, + }) + } +} + +impl StandardSigningRequestBuilder { + pub fn get_public_keys(input: &Proto::SigningInput) -> SigningResult { + let mut public_keys = PublicKeys::default(); + + if input.private_keys.is_empty() { + for public in input.public_keys.iter() { + public_keys.add_public_key(public.to_vec()); + } + } else { + for private in input.private_keys.iter() { + public_keys.add_public_with_ecdsa_private(private)?; + } + } + + Ok(public_keys) + } + + pub fn input_selector(selector: &Proto::InputSelector) -> InputSelector { + match selector { + Proto::InputSelector::SelectAscending => InputSelector::Ascending, + Proto::InputSelector::SelectInOrder => InputSelector::InOrder, + Proto::InputSelector::SelectDescending => InputSelector::Descending, + Proto::InputSelector::UseAll => InputSelector::UseAll, + } + } + + pub fn dust_policy(proto: &ProtoDustPolicy) -> SigningResult { + match proto { + ProtoDustPolicy::fixed_dust_threshold(fixed) => Ok(DustPolicy::FixedAmount(*fixed)), + ProtoDustPolicy::None => SigningError::err(SigningErrorType::Error_invalid_params) + .context("No dust policy provided"), + } + } + + pub fn fee_estimator( + proto: &Proto::TransactionBuilder, + ) -> SigningResult> { + let fee_policy = FeePolicy::FeePerVb(proto.fee_per_vb); + Ok(StandardFeeEstimator::new(fee_policy)) + } + + pub fn transaction_version(proto: &Proto::TransactionVersion) -> u32 { + match proto { + Proto::TransactionVersion::UseDefault => DEFAULT_TX_VERSION, + Proto::TransactionVersion::V1 => 1, + Proto::TransactionVersion::V2 => 2, + } + } +} + +pub fn chain_info( + coin: &dyn CoinContext, + chain_info: &Option, +) -> SigningResult { + fn prefix_to_u8(prefix: u32, prefix_name: &str) -> SigningResult { + prefix + .try_into() + .tw_err(|_| SigningErrorType::Error_invalid_params) + .with_context(|| format!("Invalid {prefix_name} prefix. It must fit uint8")) + } + + if let Some(info) = chain_info { + let hrp = info.hrp.to_string().empty_or_some(); + return Ok(BitcoinChainInfo { + p2pkh_prefix: prefix_to_u8(info.p2pkh_prefix, "p2pkh")?, + p2sh_prefix: prefix_to_u8(info.p2sh_prefix, "p2sh")?, + hrp, + }); + } + + // Try to get the chain info from the context. + // Note that not all Bitcoin forks support HRP (segwit addresses). + let hrp = coin.hrp(); + match (coin.p2pkh_prefix(), coin.p2sh_prefix()) { + (Some(p2pkh_prefix), Some(p2sh_prefix)) => Ok(BitcoinChainInfo { + p2pkh_prefix, + p2sh_prefix, + hrp, + }), + _ => SigningError::err(SigningErrorType::Error_invalid_params) + .context("Neither 'SigningInput.chain_info' nor p2pkh/p2sh prefixes specified in the registry.json") + } +} 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 d64c1cbe08d..424016239dd 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 @@ -14,6 +14,7 @@ use tw_keypair::{ecdsa, schnorr}; use tw_memory::Data; use tw_misc::traits::ToBytesVec; use tw_proto::BitcoinV2::Proto; +use tw_proto::Utxo::Proto as UtxoProto; use tw_utxo::context::UtxoContext; use tw_utxo::script::Script; use tw_utxo::sighash::SighashType; @@ -245,7 +246,7 @@ impl<'a, Context: UtxoContext> UtxoProtobuf<'a, Context> { } } -pub fn parse_out_point(maybe_out_point: &Option) -> SigningResult { +pub fn parse_out_point(maybe_out_point: &Option) -> SigningResult { let out_point = maybe_out_point .as_ref() .or_tw_err(SigningErrorType::Error_invalid_params) diff --git a/rust/chains/tw_bitcoincash/src/context.rs b/rust/chains/tw_bitcoincash/src/context.rs index 9190ff463e6..201d25da009 100644 --- a/rust/chains/tw_bitcoincash/src/context.rs +++ b/rust/chains/tw_bitcoincash/src/context.rs @@ -3,15 +3,23 @@ // Copyright © 2017 Trust Wallet. use crate::address::Address; +use tw_bitcoin::context::BitcoinSigningContext; +use tw_bitcoin::modules::protobuf_builder::standard_protobuf_builder::StandardProtobufBuilder; +use tw_bitcoin::modules::psbt_request::standard_psbt_request_builder::StandardPsbtRequestBuilder; +use tw_bitcoin::modules::signing_request::standard_signing_request::StandardSigningRequestBuilder; use tw_coin_entry::error::prelude::*; use tw_utxo::context::{AddressPrefixes, UtxoContext}; +use tw_utxo::fee::fee_estimator::StandardFeeEstimator; use tw_utxo::script::Script; +use tw_utxo::transaction::standard_transaction::Transaction; #[derive(Default)] pub struct BitcoinCashContext; impl UtxoContext for BitcoinCashContext { type Address = Address; + type Transaction = Transaction; + type FeeEstimator = StandardFeeEstimator; fn addr_to_script_pubkey( addr: &Self::Address, @@ -29,3 +37,9 @@ impl UtxoContext for BitcoinCashContext { } } } + +impl BitcoinSigningContext for BitcoinCashContext { + type SigningRequestBuilder = StandardSigningRequestBuilder; + type ProtobufBuilder = StandardProtobufBuilder; + type PsbtRequestBuilder = StandardPsbtRequestBuilder; +} diff --git a/rust/chains/tw_greenfield/src/public_key.rs b/rust/chains/tw_greenfield/src/public_key.rs index 41f4a3cced6..d2f7a1a78fd 100644 --- a/rust/chains/tw_greenfield/src/public_key.rs +++ b/rust/chains/tw_greenfield/src/public_key.rs @@ -20,9 +20,9 @@ impl JsonPublicKey for GreenfieldPublicKey { } impl ProtobufPublicKey for GreenfieldPublicKey { - fn to_proto(&self) -> google::protobuf::Any { + fn to_proto(&self) -> google::protobuf::Any<'static> { let proto = tw_cosmos_sdk::proto::cosmos::crypto::eth::ethsecp256k1::PubKey { - key: self.0.compressed().to_vec(), + key: self.0.compressed().to_vec().into(), }; to_any(&proto) } diff --git a/rust/chains/tw_greenfield/src/transaction/message/transfer_out.rs b/rust/chains/tw_greenfield/src/transaction/message/transfer_out.rs index 00a01116db5..e22b58598a9 100644 --- a/rust/chains/tw_greenfield/src/transaction/message/transfer_out.rs +++ b/rust/chains/tw_greenfield/src/transaction/message/transfer_out.rs @@ -65,8 +65,8 @@ pub struct GreenfieldTransferOut { impl CosmosMessage for GreenfieldTransferOut { fn to_proto(&self) -> SigningResult { let msg = GreenfieldProto::bridge::MsgTransferOut { - from: self.from.to_string(), - to: self.to.to_string(), + from: self.from.to_string().into(), + to: self.to.to_string().into(), amount: Some(build_coin(&self.amount)), }; Ok(to_any(&msg)) diff --git a/rust/chains/tw_komodo/Cargo.toml b/rust/chains/tw_komodo/Cargo.toml new file mode 100644 index 00000000000..7bc4d152a03 --- /dev/null +++ b/rust/chains/tw_komodo/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "tw_komodo" +version = "0.1.0" +edition = "2021" + +[dependencies] +tw_bitcoin = { path = "../../chains/tw_bitcoin" } +tw_coin_entry = { path = "../../tw_coin_entry" } +tw_keypair = { path = "../../tw_keypair" } +tw_proto = { path = "../../tw_proto" } +tw_utxo = { path = "../../frameworks/tw_utxo" } +tw_zcash = { path = "../../chains/tw_zcash" } diff --git a/rust/chains/tw_komodo/src/context.rs b/rust/chains/tw_komodo/src/context.rs new file mode 100644 index 00000000000..4b0cb2ec818 --- /dev/null +++ b/rust/chains/tw_komodo/src/context.rs @@ -0,0 +1,37 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// Copyright © 2017 Trust Wallet. + +use tw_bitcoin::context::BitcoinSigningContext; +use tw_bitcoin::modules::psbt_request::NoPsbtRequestBuilder; +use tw_coin_entry::error::prelude::SigningResult; +use tw_utxo::address::legacy::LegacyAddress; +use tw_utxo::context::{AddressPrefixes, UtxoContext}; +use tw_utxo::script::Script; +use tw_zcash::modules::protobuf_builder::ZcashProtobufBuilder; +use tw_zcash::modules::signing_request::ZcashSigningRequestBuilder; +use tw_zcash::modules::zcash_fee_estimator::ZcashFeeEstimator; +use tw_zcash::transaction::ZcashTransaction; + +/// Komodo chain has a similar context to ZCash but with a legacy address format only. +#[derive(Default)] +pub struct KomodoContext; + +impl UtxoContext for KomodoContext { + type Address = LegacyAddress; + type Transaction = ZcashTransaction; + type FeeEstimator = ZcashFeeEstimator; + + fn addr_to_script_pubkey( + addr: &Self::Address, + prefixes: AddressPrefixes, + ) -> SigningResult