Wallet transaction history and rescanning

751    if (!pwallet) return UniValue::VNULL;
752
753    // Make sure the results are valid at least up to the most recent block
754    // the user could have gotten from another RPC command prior to now
755    pwallet->BlockUntilSyncedToCurrentChain();
756
757    LOCK(pwallet->cs_wallet);
758
759    Txid hash{Txid::FromUint256(ParseHashV(request.params[0], "txid"))};
760
761    bool verbose = request.params[2].isNull() ? false : request.params[2].get_bool();
762
763    UniValue entry(UniValue::VOBJ);
764    auto it = pwallet->mapWallet.find(hash);
765    if (it == pwallet->mapWallet.end()) {
766        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid or non-wallet transaction id");
767    }
768    const CWalletTx& wtx = it->second;
769
770    CAmount nCredit = CachedTxGetCredit(*pwallet, wtx, /*avoid_reuse=*/false);
771    CAmount nDebit = CachedTxGetDebit(*pwallet, wtx, /*avoid_reuse=*/false);
772    CAmount nNet = nCredit - nDebit;
773    CAmount nFee = (CachedTxIsFromMe(*pwallet, wtx) ? wtx.GetTx()->GetValueOut() - nDebit : 0);
774
775    entry.pushKV("amount", ValueFromAmount(nNet - nFee));
776    if (CachedTxIsFromMe(*pwallet, wtx))
777        entry.pushKV("fee", ValueFromAmount(nFee));
778
779    WalletTxToJSON(*pwallet, wtx, entry);
780
781    UniValue details(UniValue::VARR);
782    ListTransactions(*pwallet, wtx, 0, false, details, /*filter_label=*/std::nullopt);
783    entry.pushKV("details", std::move(details));
784
785    entry.pushKV("hex", EncodeHexTx(*wtx.GetTx()));
786
787    if (verbose) {
788        UniValue decoded(UniValue::VOBJ);
789        TxToUniv(*wtx.GetTx(),
790                /*block_hash=*/uint256(),
791                /*entry=*/decoded,
792                /*include_hex=*/false,
793                /*txundo=*/nullptr,
794                /*verbosity=*/TxVerbosity::SHOW_DETAILS,
795                /*is_change_func=*/[&pwallet](const CTxOut& txout) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
796                                        AssertLockHeld(pwallet->cs_wallet);
797                                        return OutputIsChange(*pwallet, txout);
798                                    });
799        entry.pushKV("decoded", std::move(decoded));
800    }
801
802    AppendLastProcessedBlock(entry, *pwallet);
803    return entry;
804},
805    };
806}
807
808RPCMethod abandontransaction()
809{
810    return RPCMethod{
811        "abandontransaction",
812        "Mark in-wallet transaction <txid> as abandoned\n"
813                "This will mark this transaction and all its in-wallet descendants as abandoned which will allow\n"
814                "for their inputs to be respent.  It can be used to replace \"stuck\" or evicted transactions.\n"
815                "It only works on transactions which are not included in a block and are not currently in the mempool.\n"
816                "It has no effect on transactions which are already abandoned.\n",
817                {
818                    {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
819                },
820                RPCResult{RPCResult::Type::NONE, "", ""},
821                RPCExamples{
822                    HelpExampleCli("abandontransaction", "\"1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d\"")
823            + HelpExampleRpc("abandontransaction", "\"1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d\"")
824                },
825        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
826{
827    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
828    if (!pwallet) return UniValue::VNULL;
829
830    // Make sure the results are valid at least up to the most recent block
831    // the user could have gotten from another RPC command prior to now
832    pwallet->BlockUntilSyncedToCurrentChain();
833
834    LOCK(pwallet->cs_wallet);
835
836    Txid hash{Txid::FromUint256(ParseHashV(request.params[0], "txid"))};
837
838    if (!pwallet->mapWallet.contains(hash)) {
839        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid or non-wallet transaction id");
840    }
841    if (!pwallet->AbandonTransaction(hash)) {
842        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not eligible for abandonment");
843    }
844
845    return UniValue::VNULL;
846},
847    };
848}
849
850RPCMethod rescanblockchain()
851{
852    return RPCMethod{
853        "rescanblockchain",
854        "Rescan the local blockchain for wallet related transactions.\n"
855                "Note: Use \"getwalletinfo\" to query the scanning progress.\n"
856                "The rescan is significantly faster if block filters are available\n"
857                "(using startup option \"-blockfilterindex=1\").\n",
858                {
859                    {"start_height", RPCArg::Type::NUM, RPCArg::Default{0}, "block height where the rescan should start"},
860                    {"stop_height", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "the last block height that should be scanned. If none is provided it will rescan up to the tip at return time of this call."},
861                },
862                RPCResult{
863                    RPCResult::Type::OBJ, "", "",
864                    {
865                        {RPCResult::Type::NUM, "start_height", "The block height where the rescan started (the requested height or 0)"},
866                        {RPCResult::Type::NUM, "stop_height", "The height of the last rescanned block. May be null in rare cases if there was a reorg and the call didn't scan any blocks because they were already scanned in the background."},
867                    }
868                },
869                RPCExamples{
870                    HelpExampleCli("rescanblockchain", "100000 120000")
871            + HelpExampleRpc("rescanblockchain", "100000, 120000")
872                },
873        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
874{
875    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
876    if (!pwallet) return UniValue::VNULL;
877    CWallet& wallet{*pwallet};
878
879    // Make sure the results are valid at least up to the most recent block
880    // the user could have gotten from another RPC command prior to now
881    wallet.BlockUntilSyncedToCurrentChain();
882
883    WalletRescanReserver reserver(*pwallet);
884    if (!reserver.reserve(/*with_passphrase=*/true)) {
885        throw JSONRPCError(RPC_WALLET_ERROR, "Wallet is currently rescanning. Abort existing rescan or wait.");
886    }
887
888    int start_height = 0;
889    std::optional<int> stop_height;
890    uint256 start_block;
891
892    LOCK(pwallet->m_relock_mutex);
893    {
894        LOCK(pwallet->cs_wallet);
895        EnsureWalletIsUnlocked(*pwallet);
896        int tip_height = pwallet->GetLastBlockHeight();
897
898        if (!request.params[0].isNull()) {
899            start_height = request.params[0].getInt<int>();
900            if (start_height < 0 || start_height > tip_height) {
901                throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid start_height");
902            }
903        }
904
905        if (!request.params[1].isNull()) {
906            stop_height = request.params[1].getInt<int>();
907            if (*stop_height < 0 || *stop_height > tip_height) {
908                throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid stop_height");
909            } else if (*stop_height < start_height) {
910                throw JSONRPCError(RPC_INVALID_PARAMETER, "stop_height must be greater than start_height");
911            }
912        }
913
914        // We can't rescan unavailable blocks, stop and throw an error
915        if (!pwallet->chain().hasBlocks(pwallet->GetLastBlockHash(), start_height, stop_height)) {
916            if (pwallet->chain().havePruned() && pwallet->chain().getPruneHeight() >= start_height) {
917                throw JSONRPCError(RPC_MISC_ERROR, "Can't rescan beyond pruned data. Use RPC call getblockchaininfo to determine your pruned height.");
918            }
919            if (pwallet->chain().hasAssumedValidChain()) {
920                throw JSONRPCError(RPC_MISC_ERROR, "Failed to rescan unavailable blocks likely due to an in-progress assumeutxo background sync. Check logs or getchainstates RPC for assumeutxo background sync progress and try again later.");
921            }
922            throw JSONRPCError(RPC_MISC_ERROR, "Failed to rescan unavailable blocks, potentially caused by data corruption. If the issue persists you may want to reindex (see -reindex option).");
923        }
924
925        CHECK_NONFATAL(pwallet->chain().findAncestorByHeight(pwallet->GetLastBlockHash(), start_height, FoundBlock().hash(start_block)));
926    }
927
928    CWallet::ScanResult result =
929        pwallet->ScanForWalletTransactions(start_block, start_height, stop_height, reserver, /*save_progress=*/false);
930    switch (result.status) {
931    case CWallet::ScanResult::SUCCESS:
932        break;
933    case CWallet::ScanResult::FAILURE:
934        throw JSONRPCError(RPC_MISC_ERROR, "Rescan failed. Potentially corrupted data files.");
935    case CWallet::ScanResult::USER_ABORT:
936        throw JSONRPCError(RPC_MISC_ERROR, "Rescan aborted.");
937    } // no default case, so the compiler can warn about missing cases
938    UniValue response(UniValue::VOBJ);
939    response.pushKV("start_height", start_height);
940    response.pushKV("stop_height", result.last_scanned_height ? *result.last_scanned_height : UniValue());
941    return response;
942},
943    };
944}
945
946RPCMethod abortrescan()
947{
948    return RPCMethod{"abortrescan",
949                "Stops current wallet rescan triggered by an RPC call, e.g. by a rescanblockchain call.\n"
950                "Note: Use \"getwalletinfo\" to query the scanning progress.\n",
951                {},
952                RPCResult{RPCResult::Type::BOOL, "", "Whether the abort was successful"},
953                RPCExamples{
954            "\nImport a private key\n"
955            + HelpExampleCli("rescanblockchain", "") +
956            "\nAbort the running wallet rescan\n"
957            + HelpExampleCli("abortrescan", "") +
958            "\nAs a JSON-RPC call\n"
959            + HelpExampleRpc("abortrescan", "")
960                },
961        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
962{
963    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
964    if (!pwallet) return UniValue::VNULL;
965
966    if (!pwallet->IsScanning() || pwallet->IsAbortingRescan()) return false;
967    pwallet->AbortRescan();
968    return true;
969},
970    };
971}
972} // namespace wallet
973