Add gettransaction and z_viewtransaction

Closes #38.

Author: str4d

zallet/src/components/json_rpc.rs

@@ -8,6 +8,7 @@
 
 use abscissa_core::tracing::{info, warn};
 use jsonrpsee::tracing::Instrument;
+use zcash_protocol::value::{ZatBalance, Zatoshis, COIN};
 
 use crate::{
     config::ZalletConfig,
@@ -17,11 +18,17 @@ use crate::{
 use super::{TaskHandle, chain_view::ChainView, database::Database, keystore::KeyStore};
 
 mod asyncop;
+mod balance;
 pub(crate) mod methods;
 mod payments;
 pub(crate) mod server;
 pub(crate) mod utils;
 
+// TODO: https://github.com/zcash/wallet/issues/15
+fn value_from_zat_balance(value: ZatBalance) -> f64 {
+    (i64::from(value) as f64) / (COIN as f64)
+}
+
 #[derive(Debug)]
 pub(crate) struct JsonRpc {}
 

zallet/src/components/json_rpc/balance.rs

@@ -0,0 +1,95 @@
+use transparent::bundle::TxOut;
+use zcash_client_backend::data_api::WalletRead;
+use zcash_primitives::transaction::Transaction;
+use zcash_protocol::{consensus::BlockHeight, value::Zatoshis};
+
+use crate::components::database::DbConnection;
+
+/// Equivalent to `CTransaction::GetValueOut` from `zcashd`.
+pub(super) fn wtx_get_value_out(tx: &Transaction) -> Option<Zatoshis> {
+    tx.transparent_bundle()
+        .map(|bundle| bundle.vout.iter().map(|txout| txout.value).sum())
+        .unwrap_or(Some(Zatoshis::ZERO))
+}
+
+/// Equivalent to `CWalletTx::GetDebit` from `zcashd`.
+pub(super) fn wtx_get_debit(
+    wallet: &DbConnection,
+    tx: &Transaction,
+    filter: impl Fn(&TxOut) -> bool,
+) -> Option<Zatoshis> {
+    match tx.transparent_bundle() {
+        None => Some(Zatoshis::ZERO),
+        Some(bundle) if bundle.vin.is_empty() => Some(Zatoshis::ZERO),
+        Some(bundle) => bundle
+            .vin
+            .iter()
+            .map(|txin| {
+                wallet
+                    .get_transaction(*txin.prevout.txid())
+                    .ok()
+                    .flatten()
+                    .as_ref()
+                    .and_then(|prev_tx| prev_tx.transparent_bundle())
+                    .and_then(|bundle| bundle.vout.get(txin.prevout.n() as usize))
+                    .filter(|txout| filter(txout))
+                    .map(|txout| txout.value)
+                    .unwrap_or(Zatoshis::ZERO)
+            })
+            .sum::<Option<Zatoshis>>(),
+    }
+}
+
+/// Equivalent to `CWalletTx::GetCredit` from `zcashd`.
+pub(super) fn wtx_get_credit(
+    wallet: &DbConnection,
+    tx: &Transaction,
+    as_of_height: Option<BlockHeight>,
+    filter: impl Fn(&TxOut) -> bool,
+) -> Option<Zatoshis> {
+    match tx.transparent_bundle() {
+        None => Some(Zatoshis::ZERO),
+        // Must wait until coinbase is safely deep enough in the chain before valuing it.
+        Some(bundle) if bundle.is_coinbase() && GetBlocksToMaturity(as_of_height) > 0 => {
+            Some(Zatoshis::ZERO)
+        }
+        Some(bundle) => bundle
+            .vout
+            .iter()
+            .map(|txout| {
+                if filter(txout) {
+                    txout.value
+                } else {
+                    Zatoshis::ZERO
+                }
+            })
+            .sum::<Option<Zatoshis>>(),
+    }
+}
+
+pub(super) fn wtx_is_from_me(
+    wallet: &DbConnection,
+    tx: &Transaction,
+    filter: impl Fn(&TxOut) -> bool,
+) -> Option<bool> {
+    if wtx_get_debit(wallet, tx, filter)? > Zatoshis::ZERO {
+        return Some(true);
+    }
+
+    if let Some(bundle) = tx.sapling_bundle() {
+        for spend in bundle.shielded_spends() {
+            // TODO: Check wallet for (spent) nullifiers.
+            // spend.nullifier()
+        }
+    }
+
+    // TODO: Fix bug in `zcashd` where we forgot to add Orchard here.
+    if let Some(bundle) = tx.orchard_bundle() {
+        for action in bundle.actions() {
+            // TODO: Check wallet for (spent) nullifiers.
+            // action.nullifier()
+        }
+    }
+
+    Some(false)
+}

zallet/src/components/json_rpc/methods.rs

@@ -19,6 +19,7 @@ mod get_address_for_account;
 mod get_new_account;
 mod get_notes_count;
 mod get_operation;
+mod get_transaction;
 mod get_wallet_info;
 mod help;
 mod list_accounts;
@@ -31,6 +32,7 @@ mod openrpc;
 mod recover_accounts;
 mod unlock_wallet;
 mod z_send_many;
+mod view_transaction;
 
 #[rpc(server)]
 pub(crate) trait Rpc {
@@ -209,6 +211,41 @@ pub(crate) trait Rpc {
     #[method(name = "z_listunifiedreceivers")]
     fn list_unified_receivers(&self, unified_address: &str) -> list_unified_receivers::Response;
 
+    /// Returns detailed information about in-wallet transaction `txid`.
+    ///
+    /// This does not include complete information about shielded components of the
+    /// transaction; to obtain details about shielded components of the transaction use
+    /// `z_viewtransaction`.
+    ///
+    /// # Parameters
+    ///
+    /// - `includeWatchonly` (bool, optional, default=false): Whether to include watchonly
+    ///   addresses in balance calculation and `details`.
+    /// - `verbose`: Must be `false` or omitted.
+    /// - `asOfHeight` (numeric, optional, default=-1): Execute the query as if it were
+    ///   run when the blockchain was at the height specified by this argument. The
+    ///   default is to use the entire blockchain that the node is aware of. -1 can be
+    ///   used as in other RPC calls to indicate the current height (including the
+    ///   mempool), but this does not support negative values in general. A "future"
+    ///   height will fall back to the current height. Any explicit value will cause the
+    ///   mempool to be ignored, meaning no unconfirmed tx will be considered.
+    ///
+    /// # Bitcoin compatibility
+    ///
+    /// Compatible up to three arguments, but can only use the default value for `verbose`.
+    #[method(name = "gettransaction")]
+    async fn get_transaction(
+        &self,
+        txid: &str,
+        include_watchonly: Option<bool>,
+        verbose: Option<bool>,
+        as_of_height: Option<i64>,
+    ) -> get_transaction::Response;
+
+    /// Returns detailed shielded information about in-wallet transaction `txid`.
+    #[method(name = "z_viewtransaction")]
+    async fn view_transaction(&self, txid: &str) -> view_transaction::Response;
+
     /// Returns an array of unspent shielded notes with between minconf and maxconf
     /// (inclusive) confirmations.
     ///
@@ -436,6 +473,27 @@ impl RpcServer for RpcImpl {
         list_unified_receivers::call(unified_address)
     }
 
+    async fn get_transaction(
+        &self,
+        txid: &str,
+        include_watchonly: Option<bool>,
+        verbose: Option<bool>,
+        as_of_height: Option<i64>,
+    ) -> get_transaction::Response {
+        get_transaction::call(
+            self.wallet().await?.as_ref(),
+            self.chain().await?,
+            txid,
+            include_watchonly.unwrap_or(false),
+            verbose.unwrap_or(false),
+            as_of_height.unwrap_or(-1),
+        )
+    }
+
+    async fn view_transaction(&self, txid: &str) -> view_transaction::Response {
+        view_transaction::call(self.wallet().await?.as_ref(), txid)
+    }
+
     async fn list_unspent(&self) -> list_unspent::Response {
         list_unspent::call(self.wallet().await?.as_ref())
     }