Add gettransaction

Closes #38.

Author: str4d

zallet/src/components/json_rpc.rs

@@ -17,6 +17,7 @@ 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;

zallet/src/components/json_rpc/balance.rs

@@ -0,0 +1,201 @@
+use rusqlite::named_params;
+use transparent::bundle::TxOut;
+use zaino_state::{FetchServiceSubscriber, MempoolKey};
+use zcash_client_backend::data_api::WalletRead;
+use zcash_client_sqlite::error::SqliteClientError;
+use zcash_primitives::transaction::Transaction;
+use zcash_protocol::{consensus::BlockHeight, value::Zatoshis};
+
+use crate::components::database::DbConnection;
+
+/// Equivalent to `CTransaction::GetValueOut` in `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`] in `zcashd`.
+///
+/// [`CWalletTx::GetDebit`]: https://github.com/zcash/zcash/blob/2352fbc1ed650ac4369006bea11f7f20ee046b84/src/wallet/wallet.cpp#L4822
+pub(super) fn wtx_get_debit(
+    wallet: &DbConnection,
+    tx: &Transaction,
+    is_mine: impl Fn(&DbConnection, &TxOut) -> bool,
+) -> Option<Zatoshis> {
+    match tx.transparent_bundle() {
+        None => Some(Zatoshis::ZERO),
+        Some(bundle) if bundle.vin.is_empty() => Some(Zatoshis::ZERO),
+        // Equivalent to `CWallet::GetDebit(CTransaction)` in `zcashd`.
+        Some(bundle) => bundle
+            .vin
+            .iter()
+            .map(|txin| {
+                // Equivalent to `CWallet::GetDebit(CTxIn)` in `zcashd`.
+                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| is_mine(wallet, txout))
+                    .map(|txout| txout.value)
+                    .unwrap_or(Zatoshis::ZERO)
+            })
+            .sum::<Option<Zatoshis>>(),
+    }
+}
+
+/// Equivalent to [`CWalletTx::GetCredit`] in `zcashd`.
+///
+/// [`CWalletTx::GetCredit`]: https://github.com/zcash/zcash/blob/2352fbc1ed650ac4369006bea11f7f20ee046b84/src/wallet/wallet.cpp#L4853
+pub(super) async fn wtx_get_credit(
+    wallet: &DbConnection,
+    chain: &FetchServiceSubscriber,
+    tx: &Transaction,
+    as_of_height: Option<BlockHeight>,
+    is_mine: impl Fn(&DbConnection, &TxOut) -> bool,
+) -> Result<Option<Zatoshis>, SqliteClientError> {
+    Ok(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()
+                && wtx_get_blocks_to_maturity(wallet, chain, tx, as_of_height).await? > 0 =>
+        {
+            Some(Zatoshis::ZERO)
+        }
+        // Equivalent to `CWallet::GetCredit(CTransaction)` in `zcashd`.
+        Some(bundle) => bundle
+            .vout
+            .iter()
+            .map(|txout| {
+                // Equivalent to `CWallet::GetCredit(CTxOut)` in `zcashd`.
+                if is_mine(wallet, txout) {
+                    txout.value
+                } else {
+                    Zatoshis::ZERO
+                }
+            })
+            .sum::<Option<Zatoshis>>(),
+    })
+}
+
+/// Equivalent to [`CWalletTx::IsFromMe`] in `zcashd`.
+///
+/// [`CWalletTx::IsFromMe`]: https://github.com/zcash/zcash/blob/2352fbc1ed650ac4369006bea11f7f20ee046b84/src/wallet/wallet.cpp#L4967
+pub(super) fn wtx_is_from_me(
+    wallet: &DbConnection,
+    tx: &Transaction,
+    is_mine: impl Fn(&DbConnection, &TxOut) -> bool,
+) -> Result<bool, SqliteClientError> {
+    if wtx_get_debit(wallet, tx, is_mine).ok_or_else(|| {
+        SqliteClientError::BalanceError(zcash_protocol::value::BalanceError::Overflow)
+    })? > Zatoshis::ZERO
+    {
+        return Ok(true);
+    }
+
+    wallet.with_raw(|conn| {
+        if let Some(bundle) = tx.sapling_bundle() {
+            let mut stmt_note_exists = conn.prepare(
+                "SELECT EXISTS(
+                    SELECT 1
+                    FROM sapling_received_notes
+                    WHERE nf = :nf
+                )",
+            )?;
+
+            for spend in bundle.shielded_spends() {
+                if stmt_note_exists
+                    .query_row(named_params! {":nf": spend.nullifier().0}, |row| row.get(0))?
+                {
+                    return Ok(true);
+                }
+            }
+        }
+
+        // TODO: Fix bug in `zcashd` where we forgot to add Orchard here.
+        if let Some(bundle) = tx.orchard_bundle() {
+            let mut stmt_note_exists = conn.prepare(
+                "SELECT EXISTS(
+                    SELECT 1
+                    FROM orchard_received_notes
+                    WHERE nf = :nf
+                )",
+            )?;
+
+            for action in bundle.actions() {
+                if stmt_note_exists.query_row(
+                    named_params! {":nf": action.nullifier().to_bytes()},
+                    |row| row.get(0),
+                )? {
+                    return Ok(true);
+                }
+            }
+        }
+
+        Ok(false)
+    })
+}
+
+/// Equivalent to [`CMerkleTx::GetBlocksToMaturity`] in `zcashd`.
+///
+/// [`CMerkleTx::GetBlocksToMaturity`]: https://github.com/zcash/zcash/blob/2352fbc1ed650ac4369006bea11f7f20ee046b84/src/wallet/wallet.cpp#L6915
+async fn wtx_get_blocks_to_maturity(
+    wallet: &DbConnection,
+    chain: &FetchServiceSubscriber,
+    tx: &Transaction,
+    as_of_height: Option<BlockHeight>,
+) -> Result<u32, SqliteClientError> {
+    Ok(
+        if tx.transparent_bundle().map_or(false, |b| b.is_coinbase()) {
+            if let Some(depth) =
+                wtx_get_depth_in_main_chain(wallet, chain, tx, as_of_height).await?
+            {
+                (COINBASE_MATURITY + 1).saturating_sub(depth)
+            } else {
+                // TODO: Confirm this is what `zcashd` computes for an orphaned coinbase.
+                COINBASE_MATURITY + 2
+            }
+        } else {
+            0
+        },
+    )
+}
+
+/// Returns depth of transaction in blockchain.
+///
+/// - `None`      : not in blockchain, and not in memory pool (conflicted transaction)
+/// - `Some(0)`   : in memory pool, waiting to be included in a block (never returned if `as_of_height` is set)
+/// - `Some(1..)` : this many blocks deep in the main chain
+async fn wtx_get_depth_in_main_chain(
+    wallet: &DbConnection,
+    chain: &FetchServiceSubscriber,
+    tx: &Transaction,
+    as_of_height: Option<BlockHeight>,
+) -> Result<Option<u32>, SqliteClientError> {
+    let chain_height = wallet
+        .chain_height()?
+        .ok_or_else(|| SqliteClientError::ChainHeightUnknown)?;
+
+    let effective_chain_height = chain_height.min(as_of_height.unwrap_or(chain_height));
+
+    let depth = if let Some(mined_height) = wallet.get_tx_height(tx.txid())? {
+        Some(effective_chain_height + 1 - mined_height)
+    } else if as_of_height.is_none()
+        && chain
+            .mempool
+            .contains_txid(&MempoolKey(tx.txid().to_string()))
+            .await
+    {
+        Some(0)
+    } else {
+        None
+    };
+
+    Ok(depth)
+}
+
+const COINBASE_MATURITY: u32 = 100;

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;
@@ -210,6 +211,37 @@ 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;
@@ -441,6 +473,24 @@ 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,
+        )
+        .await
+    }
+
     async fn view_transaction(&self, txid: &str) -> view_transaction::Response {
         view_transaction::call(self.wallet().await?.as_ref(), txid)
     }