The wallet state and lifecycle

3001        status = DatabaseStatus::FAILED_BAD_PATH;
3002        return nullptr;
3003    }
3004    return MakeDatabase(*wallet_path, options, status, error_string);
3005}
3006
3007bool CWallet::LoadWalletArgs(std::shared_ptr<CWallet> wallet, const WalletContext& context, bilingual_str& error, std::vector<bilingual_str>& warnings)
3008{
3009    interfaces::Chain* chain = context.chain;
3010    const ArgsManager& args = *Assert(context.args);
3011
3012    if (!args.GetArg("-addresstype", "").empty()) {
3013        std::optional<OutputType> parsed = ParseOutputType(args.GetArg("-addresstype", ""));
3014        if (!parsed) {
3015            error = strprintf(_("Unknown address type '%s'"), args.GetArg("-addresstype", ""));
3016            return false;
3017        }
3018        wallet->m_default_address_type = parsed.value();
3019    }
3020
3021    if (!args.GetArg("-changetype", "").empty()) {
3022        std::optional<OutputType> parsed = ParseOutputType(args.GetArg("-changetype", ""));
3023        if (!parsed) {
3024            error = strprintf(_("Unknown change type '%s'"), args.GetArg("-changetype", ""));
3025            return false;
3026        }
3027        wallet->m_default_change_type = parsed.value();
3028    }
3029
3030    if (const auto arg{args.GetArg("-mintxfee")}) {
3031        std::optional<CAmount> min_tx_fee = ParseMoney(*arg);
3032        if (!min_tx_fee) {
3033            error = AmountErrMsg("mintxfee", *arg);
3034            return false;
3035        } else if (min_tx_fee.value() > HIGH_TX_FEE_PER_KB) {
3036            warnings.push_back(AmountHighWarn("-mintxfee") + Untranslated(" ") +
3037                               _("This is the minimum transaction fee you pay on every transaction."));
3038        }
3039
3040        wallet->m_min_fee = CFeeRate{min_tx_fee.value()};
3041    }
3042
3043    if (const auto arg{args.GetArg("-maxapsfee")}) {
3044        const std::string& max_aps_fee{*arg};
3045        if (max_aps_fee == "-1") {
3046            wallet->m_max_aps_fee = -1;
3047        } else if (std::optional<CAmount> max_fee = ParseMoney(max_aps_fee)) {
3048            if (max_fee.value() > HIGH_APS_FEE) {
3049                warnings.push_back(AmountHighWarn("-maxapsfee") + Untranslated(" ") +
3050                                  _("This is the maximum transaction fee you pay (in addition to the normal fee) to prioritize partial spend avoidance over regular coin selection."));
3051            }
3052            wallet->m_max_aps_fee = max_fee.value();
3053        } else {
3054            error = AmountErrMsg("maxapsfee", max_aps_fee);
3055            return false;
3056        }
3057    }
3058
3059    if (const auto arg{args.GetArg("-fallbackfee")}) {
3060        std::optional<CAmount> fallback_fee = ParseMoney(*arg);
3061        if (!fallback_fee) {
3062            error = strprintf(_("Invalid amount for %s=<amount>: '%s'"), "-fallbackfee", *arg);
3063            return false;
3064        } else if (fallback_fee.value() > HIGH_TX_FEE_PER_KB) {
3065            warnings.push_back(AmountHighWarn("-fallbackfee") + Untranslated(" ") +
3066                               _("This is the transaction fee you may pay when fee estimates are not available."));
3067        }
3068        wallet->m_fallback_fee = CFeeRate{fallback_fee.value()};
3069    }
3070
3071    // Disable fallback fee in case value was set to 0, enable if non-null value
3072    wallet->m_allow_fallback_fee = wallet->m_fallback_fee.GetFeePerK() != 0;
3073
3074    if (const auto arg{args.GetArg("-discardfee")}) {
3075        std::optional<CAmount> discard_fee = ParseMoney(*arg);
3076        if (!discard_fee) {
3077            error = strprintf(_("Invalid amount for %s=<amount>: '%s'"), "-discardfee", *arg);
3078            return false;
3079        } else if (discard_fee.value() > HIGH_TX_FEE_PER_KB) {
3080            warnings.push_back(AmountHighWarn("-discardfee") + Untranslated(" ") +
3081                               _("This is the transaction fee you may discard if change is smaller than dust at this level"));
3082        }
3083        wallet->m_discard_rate = CFeeRate{discard_fee.value()};
3084    }
3085
3086    if (const auto arg{args.GetArg("-maxtxfee")}) {
3087        std::optional<CAmount> max_fee = ParseMoney(*arg);
3088        if (!max_fee) {
3089            error = AmountErrMsg("maxtxfee", *arg);
3090            return false;
3091        } else if (max_fee.value() > HIGH_MAX_TX_FEE) {
3092            warnings.push_back(strprintf(_("%s is set very high! Fees this large could be paid on a single transaction."), "-maxtxfee"));
3093        }
3094
3095        if (chain && CFeeRate{max_fee.value(), 1000} < chain->relayMinFee()) {
3096            error = strprintf(_("Invalid amount for %s=<amount>: '%s' (must be at least the minrelay fee of %s to prevent stuck transactions)"),
3097                "-maxtxfee", *arg, chain->relayMinFee().ToString());
3098            return false;
3099        }
3100
3101        wallet->m_default_max_tx_fee = max_fee.value();
3102    }
3103
3104    if (const auto arg{args.GetArg("-consolidatefeerate")}) {
3105        if (std::optional<CAmount> consolidate_feerate = ParseMoney(*arg)) {
3106            wallet->m_consolidate_feerate = CFeeRate(*consolidate_feerate);
3107        } else {
3108            error = AmountErrMsg("consolidatefeerate", *arg);
3109            return false;
3110        }
3111    }
3112
3113    if (chain && chain->relayMinFee().GetFeePerK() > HIGH_TX_FEE_PER_KB) {
3114        warnings.push_back(AmountHighWarn("-minrelaytxfee") + Untranslated(" ") +
3115                           _("The wallet will avoid paying less than the minimum relay fee."));
3116    }
3117
3118    wallet->m_confirm_target = args.GetIntArg("-txconfirmtarget", DEFAULT_TX_CONFIRM_TARGET);
3119    wallet->m_spend_zero_conf_change = args.GetBoolArg("-spendzeroconfchange", DEFAULT_SPEND_ZEROCONF_CHANGE);
3120    wallet->m_signal_rbf = DEFAULT_WALLET_RBF;
3121    if (auto value{args.GetBoolArg("-walletrbf")}) {
3122        warnings.push_back(_("-walletrbf is deprecated and will be fully removed in the next release."));
3123        wallet->m_signal_rbf = *value;
3124    }
3125
3126    wallet->m_keypool_size = std::max(args.GetIntArg("-keypool", DEFAULT_KEYPOOL_SIZE), int64_t{1});
3127    wallet->m_notify_tx_changed_script = args.GetArg("-walletnotify", "");
3128    wallet->SetBroadcastTransactions(args.GetBoolArg("-walletbroadcast", DEFAULT_WALLETBROADCAST));
3129
3130    return true;
3131}
3132
3133std::shared_ptr<CWallet> CWallet::CreateNew(WalletContext& context, const std::string& name, std::unique_ptr<WalletDatabase> database, uint64_t wallet_creation_flags, bool born_encrypted, bilingual_str& error, std::vector<bilingual_str>& warnings)
3134{
3135    interfaces::Chain* chain = context.chain;
3136    const std::string& walletFile = database->Filename();
3137
3138    const auto start{SteadyClock::now()};
3139    // TODO: Can't use std::make_shared because we need a custom deleter but
3140    // should be possible to use std::allocate_shared.
3141    std::shared_ptr<CWallet> walletInstance(new CWallet(chain, name, std::move(database)), FlushAndDeleteWallet);
3142
3143    if (!LoadWalletArgs(walletInstance, context, error, warnings)) {
3144        return nullptr;
3145    }
3146
3147    // Initialize version key.
3148    if(!WalletBatch(walletInstance->GetDatabase()).WriteVersion(CLIENT_VERSION)) {
3149        error = strprintf(_("Error creating %s: Could not write version metadata."), walletFile);
3150        return nullptr;
3151    }
3152    {
3153        LOCK(walletInstance->cs_wallet);
3154
3155        // Init with passed flags.
3156        // Always set the cache upgrade flag as this feature is supported from the beginning.
3157        walletInstance->InitWalletFlags(wallet_creation_flags | WALLET_FLAG_LAST_HARDENED_XPUB_CACHED);
3158
3159        // Only descriptor wallets can be created
3160        assert(walletInstance->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
3161
3162        // Born encrypted wallets will have their keys generated later
3163        if (!born_encrypted) {
3164            walletInstance->SetupWalletGeneration();
3165        }
3166
3167        if (chain) {
3168            std::optional<int> tip_height = chain->getHeight();
3169            if (tip_height) {
3170                walletInstance->SetLastBlockProcessed(*tip_height, chain->getBlockHash(*tip_height));
3171            }
3172        }
3173    }
3174
3175    walletInstance->WalletLogPrintf("Wallet completed creation in %15dms\n", Ticks<std::chrono::milliseconds>(SteadyClock::now() - start));
3176
3177    // Try to top up keypool. No-op if the wallet is locked.
3178    walletInstance->TopUpKeyPool();
3179
3180    if (chain && !AttachChain(walletInstance, *chain, /*rescan_required=*/false, error, warnings)) {
3181        walletInstance->DisconnectChainNotifications();
3182        return nullptr;
3183    }
3184
3185    return walletInstance;
3186}
3187
3188std::shared_ptr<CWallet> CWallet::LoadExisting(WalletContext& context, const std::string& name, std::unique_ptr<WalletDatabase> database, bilingual_str& error, std::vector<bilingual_str>& warnings)
3189{
3190    interfaces::Chain* chain = context.chain;
3191    const std::string& walletFile = database->Filename();
3192
3193    const auto start{SteadyClock::now()};
3194    std::shared_ptr<CWallet> walletInstance(new CWallet(chain, name, std::move(database)), FlushAndDeleteWallet);
3195
3196    if (!LoadWalletArgs(walletInstance, context, error, warnings)) {
3197        return nullptr;
3198    }
3199
3200    // Load wallet
3201    auto nLoadWalletRet = walletInstance->PopulateWalletFromDB(error, warnings);
3202    bool rescan_required = nLoadWalletRet == DBErrors::NEED_RESCAN;
3203    if (nLoadWalletRet != DBErrors::LOAD_OK && nLoadWalletRet != DBErrors::NONCRITICAL_ERROR && !rescan_required) {
3204        return nullptr;
3205    }
3206
3207    if (walletInstance->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
3208        for (auto spk_man : walletInstance->GetActiveScriptPubKeyMans()) {
3209            if (spk_man->HavePrivateKeys()) {
3210                warnings.push_back(strprintf(_("Warning: Private keys detected in wallet {%s} with disabled private keys"), walletFile));
3211                break;
3212            }
3213        }
3214    }
3215
3216    walletInstance->WalletLogPrintf("Wallet completed loading in %15dms\n", Ticks<std::chrono::milliseconds>(SteadyClock::now() - start));
3217
3218    // Try to top up keypool. No-op if the wallet is locked.
3219    walletInstance->TopUpKeyPool();
3220
3221    if (chain && !AttachChain(walletInstance, *chain, rescan_required, error, warnings)) {
3222        walletInstance->DisconnectChainNotifications();
3223        return nullptr;
3224    }
3225
3226    WITH_LOCK(walletInstance->cs_wallet, walletInstance->LogStats());
3227
3228    return walletInstance;
3229}
3230
3231
3232bool CWallet::AttachChain(const std::shared_ptr<CWallet>& walletInstance, interfaces::Chain& chain, const bool rescan_required, bilingual_str& error, std::vector<bilingual_str>& warnings)
3233{
3234    LOCK(walletInstance->cs_wallet);
3235    // allow setting the chain if it hasn't been set already but prevent changing it
3236    assert(!walletInstance->m_chain || walletInstance->m_chain == &chain);
3237    walletInstance->m_chain = &chain;
3238
3239    // Unless allowed, ensure wallet files are not reused across chains:
3240    if (!gArgs.GetBoolArg("-walletcrosschain", DEFAULT_WALLETCROSSCHAIN)) {
3241        WalletBatch batch(walletInstance->GetDatabase());
3242        CBlockLocator locator;
3243        if (batch.ReadBestBlock(locator) && locator.vHave.size() > 0 && chain.getHeight()) {
3244            // Wallet is assumed to be from another chain, if genesis block in the active
3245            // chain differs from the genesis block known to the wallet.
3246            if (chain.getBlockHash(0) != locator.vHave.back()) {
3247                error = Untranslated("Wallet files should not be reused across chains. Restart bitcoind with -walletcrosschain to override.");
3248                return false;
3249            }
3250        }