 |
Bitcoin Core 29.99.0
P2P Digital Currency
|
|
Bitcoin Core 29.99.0
P2P Digital Currency
|
Namespaces | |
| namespace | DBKeys |
| namespace | feebumper |
| namespace | wallet_crypto_tests |
| namespace | WalletTool |
Classes | |
| struct | Balance |
| class | BerkeleyROBatch |
| RAII class that provides access to a BerkeleyRODatabase. More... | |
| class | BerkeleyROCursor |
| class | BerkeleyRODatabase |
| A class representing a BerkeleyDB file from which we can only read records. More... | |
| struct | BytePrefix |
| struct | CachableAmount |
| Cachable amount subdivided into watchonly and spendable parts. More... | |
| struct | CAddressBookData |
| Address book data. More... | |
| class | CCoinControl |
| Coin Control Features. More... | |
| class | CCrypter |
| Encryption/decryption context with key information. More... | |
| class | CHDChain |
| class | CKeyMetadata |
| class | CMasterKey |
| Private key encryption is done based on a CMasterKey, which holds a salt and random encryption key. More... | |
| class | CMerkleTx |
| Legacy class used for deserializing vtxPrev for backwards compatibility. More... | |
| struct | CoinEligibilityFilter |
| Parameters for filtering which OutputGroups we may use in coin selection. More... | |
| struct | CoinFilterParams |
| struct | CoinSelectionParams |
| Parameters for one iteration of Coin Selection. More... | |
| struct | CoinsResult |
| COutputs available for spending, stored by OutputType. More... | |
| struct | COutput |
| A UTXO under consideration for use in funding a new transaction. More... | |
| struct | COutputEntry |
| struct | CreatedTransactionResult |
| struct | CRecipient |
| class | CWallet |
| A CWallet maintains a set of transactions and balances, and provides the ability to create new transactions. More... | |
| class | CWalletTx |
| A transaction with a bunch of additional info that only the owner cares about. More... | |
| class | DatabaseBatch |
| RAII class that provides access to a WalletDatabase. More... | |
| class | DatabaseCursor |
| struct | DatabaseOptions |
| class | DataRecord |
| Class for data in the record directly. More... | |
| class | DbExecBlocker |
| struct | DbTxnListener |
| class | DescribeWalletAddressVisitor |
| class | DescriptorScriptPubKeyMan |
| class | DummyDescriptor |
| class | ExternalSignerScriptPubKeyMan |
| struct | FuzzedWallet |
| Wraps a descriptor wallet for fuzzing. More... | |
| struct | Groups |
| class | GroupVerifier |
| struct | InitWalletDirTestingSetup |
| class | InternalPage |
| A page of records in the database. More... | |
| class | InternalRecord |
| Class for records representing internal nodes of the BTree. More... | |
| class | LegacyDataSPKM |
| class | LegacySigningProvider |
| Wraps a LegacyScriptPubKeyMan so that it can be returned in a new unique_ptr. More... | |
| class | ListCoinsTestingSetup |
| struct | LoadResult |
| class | MetaPage |
| Berkeley DB BTree metadata page layout. More... | |
| struct | MigrationData |
| struct containing information needed for migrating legacy wallets to descriptor wallets More... | |
| struct | MigrationResult |
| class | MinOutputGroupComparator |
| class | MockableBatch |
| class | MockableCursor |
| class | MockableDatabase |
| A WalletDatabase whose contents and return values can be modified as needed for testing. More... | |
| struct | OutputGroup |
| A group of UTXOs paid to the same output script. More... | |
| struct | OutputGroupTypeMap |
| Stores several 'Groups' whose were mapped by output type. More... | |
| class | OverflowPage |
| A page containing overflow data. More... | |
| class | OverflowRecord |
| Class for records representing overflow records of the BTree. More... | |
| class | PageHeader |
| A generic data page in the database. More... | |
| class | PreselectedInput |
| struct | PreSelectedInputs |
| class | RecordHeader |
| General class for records in a BDB BTree database. More... | |
| class | RecordsPage |
| A page of records in the database. More... | |
| class | ReserveDestination |
| A wrapper to reserve an address from a wallet. More... | |
| class | ScriptPubKeyMan |
| struct | SelectionFilter |
| struct | SelectionResult |
| class | SQLiteBatch |
| RAII class that provides access to a WalletDatabase. More... | |
| class | SQLiteCursor |
| RAII class that provides a database cursor. More... | |
| class | SQLiteDatabase |
| An instance of this class represents one SQLite3 database. More... | |
| class | SQliteExecHandler |
| Class responsible for executing SQL statements in SQLite databases. More... | |
| struct | tallyitem |
| class | TestCrypter |
| struct | TxSize |
| struct | TxStateBlockConflicted |
| State of rejected transaction that conflicts with a confirmed block. More... | |
| struct | TxStateConfirmed |
| State of transaction confirmed in a block. More... | |
| struct | TxStateInactive |
| State of transaction not confirmed or conflicting with a known block and not in the mempool. More... | |
| struct | TxStateInMempool |
| State of transaction added to mempool. More... | |
| struct | TxStateUnrecognized |
| State of transaction loaded in an unrecognized state with unexpected hash or index values. More... | |
| class | WalletBatch |
| Access to the wallet database. More... | |
| struct | WalletContext |
| WalletContext struct containing references to state shared between CWallet instances, like the reference to the chain interface, and the list of opened wallets. More... | |
| class | WalletDatabase |
| An instance of this class represents one database. More... | |
| class | WalletDescriptor |
| Descriptor with some wallet metadata. More... | |
| struct | WalletDestination |
| class | WalletInit |
| class | WalletRescanReserver |
| RAII object to check and reserve a wallet rescan. More... | |
| class | WalletStorage |
| struct | WalletTestingSetup |
| Testing setup and teardown for wallet. More... | |
| struct | WalletTxOrderComparator |
Typedefs | |
| using | isminefilter = std::underlying_type_t< isminetype > |
| used for bitflags of isminetype More... | |
| typedef std::map< CoinEligibilityFilter, OutputGroupTypeMap > | FilteredOutputGroups |
| using | LoadWalletFn = std::function< void(std::unique_ptr< interfaces::Wallet > wallet)> |
| typedef std::vector< unsigned char, secure_allocator< unsigned char > > | CKeyingMaterial |
| using | BerkeleyROData = std::map< SerializeData, SerializeData, std::less<> > |
| typedef std::vector< unsigned char > | valtype |
| typedef std::set< std::shared_ptr< COutput > > | CoinSet |
| using | MockableData = std::map< SerializeData, SerializeData, std::less<> > |
| using | TxState = std::variant< TxStateConfirmed, TxStateInMempool, TxStateBlockConflicted, TxStateInactive, TxStateUnrecognized > |
| All possible CWalletTx states. More... | |
| using | SyncTxState = std::variant< TxStateConfirmed, TxStateInMempool, TxStateInactive > |
| Subset of states transaction sync logic is implemented to handle. More... | |
| typedef std::map< std::string, std::string > | mapValue_t |
| using | LoadFunc = std::function< DBErrors(CWallet *pwallet, DataStream &key, DataStream &value, std::string &err)> |
Functions | |
| static void | WalletBalance (benchmark::Bench &bench, const bool set_dirty, const bool add_mine) |
| static void | WalletBalanceDirty (benchmark::Bench &bench) |
| static void | WalletBalanceClean (benchmark::Bench &bench) |
| static void | WalletBalanceMine (benchmark::Bench &bench) |
| static void | WalletBalanceWatch (benchmark::Bench &bench) |
| BENCHMARK (WalletBalanceDirty, benchmark::PriorityLevel::HIGH) | |
| BENCHMARK (WalletBalanceClean, benchmark::PriorityLevel::HIGH) | |
| BENCHMARK (WalletBalanceMine, benchmark::PriorityLevel::HIGH) | |
| BENCHMARK (WalletBalanceWatch, benchmark::PriorityLevel::HIGH) | |
| static void | WalletCreate (benchmark::Bench &bench, bool encrypted) |
| static void | WalletCreatePlain (benchmark::Bench &bench) |
| static void | WalletCreateEncrypted (benchmark::Bench &bench) |
| BENCHMARK (WalletCreatePlain, benchmark::PriorityLevel::LOW) | |
| BENCHMARK (WalletCreateEncrypted, benchmark::PriorityLevel::LOW) | |
| static void | WalletIsMine (benchmark::Bench &bench, int num_combo=0) |
| static void | WalletIsMineDescriptors (benchmark::Bench &bench) |
| static void | WalletIsMineMigratedDescriptors (benchmark::Bench &bench) |
| BENCHMARK (WalletIsMineDescriptors, benchmark::PriorityLevel::LOW) | |
| BENCHMARK (WalletIsMineMigratedDescriptors, benchmark::PriorityLevel::LOW) | |
| static void | AddTx (CWallet &wallet) |
| static void | WalletLoadingDescriptors (benchmark::Bench &bench) |
| BENCHMARK (WalletLoadingDescriptors, benchmark::PriorityLevel::HIGH) | |
| static void | WalletMigration (benchmark::Bench &bench) |
| BENCHMARK (WalletMigration, benchmark::PriorityLevel::LOW) | |
| static util::Result< SelectionResult > | ErrorMaxWeightExceeded () |
| util::Result< SelectionResult > | SelectCoinsBnB (std::vector< OutputGroup > &utxo_pool, const CAmount &selection_target, const CAmount &cost_of_change, int max_selection_weight) |
| util::Result< SelectionResult > | CoinGrinder (std::vector< OutputGroup > &utxo_pool, const CAmount &selection_target, CAmount change_target, int max_selection_weight) |
| util::Result< SelectionResult > | SelectCoinsSRD (const std::vector< OutputGroup > &utxo_pool, CAmount target_value, CAmount change_fee, FastRandomContext &rng, int max_selection_weight) |
| Select coins by Single Random Draw. More... | |
| static void | ApproximateBestSubset (FastRandomContext &insecure_rand, const std::vector< OutputGroup > &groups, const CAmount &nTotalLower, const CAmount &nTargetValue, std::vector< char > &vfBest, CAmount &nBest, int max_selection_weight, int iterations=1000) |
| Find a subset of the OutputGroups that is at least as large as, but as close as possible to, the target amount; solve subset sum. More... | |
| util::Result< SelectionResult > | KnapsackSolver (std::vector< OutputGroup > &groups, const CAmount &nTargetValue, CAmount change_target, FastRandomContext &rng, int max_selection_weight) |
| CAmount | GenerateChangeTarget (const CAmount payment_value, const CAmount change_fee, FastRandomContext &rng) |
| Choose a random change target for each transaction to make it harder to fingerprint the Core wallet based on the change output values of transactions it creates. More... | |
| std::string | GetAlgorithmName (const SelectionAlgorithm algo) |
| bool | EncryptSecret (const CKeyingMaterial &vMasterKey, const CKeyingMaterial &vchPlaintext, const uint256 &nIV, std::vector< unsigned char > &vchCiphertext) |
| bool | DecryptSecret (const CKeyingMaterial &master_key, const std::span< const unsigned char > ciphertext, const uint256 &iv, CKeyingMaterial &plaintext) |
| bool | DecryptKey (const CKeyingMaterial &master_key, const std::span< const unsigned char > crypted_secret, const CPubKey &pub_key, CKey &key) |
| bool | operator< (BytePrefix a, std::span< const std::byte > b) |
| bool | operator< (std::span< const std::byte > a, BytePrefix b) |
| std::vector< std::pair< fs::path, std::string > > | ListDatabases (const fs::path &path) |
| Recursively list database paths in directory. More... | |
| fs::path | BDBDataFile (const fs::path &wallet_path) |
| fs::path | SQLiteDataFile (const fs::path &path) |
| bool | IsBDBFile (const fs::path &path) |
| bool | IsSQLiteFile (const fs::path &path) |
| void | ReadDatabaseArgs (const ArgsManager &args, DatabaseOptions &options) |
| std::unique_ptr< WalletDatabase > | MakeDatabase (const fs::path &path, const DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error) |
| bool | DumpWallet (const ArgsManager &args, WalletDatabase &db, bilingual_str &error) |
| static void | WalletToolReleaseWallet (CWallet *wallet) |
| bool | CreateFromDump (const ArgsManager &args, const std::string &name, const fs::path &wallet_path, bilingual_str &error, std::vector< bilingual_str > &warnings) |
| static feebumper::Result | PreconditionChecks (const CWallet &wallet, const CWalletTx &wtx, bool require_mine, std::vector< bilingual_str > &errors) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) |
| Check whether transaction has descendant in wallet or mempool, or has been mined, or conflicts with a mined transaction. More... | |
| static feebumper::Result | CheckFeeRate (const CWallet &wallet, const CMutableTransaction &mtx, const CFeeRate &newFeerate, const int64_t maxTxSize, CAmount old_fee, std::vector< bilingual_str > &errors) |
| Check if the user provided a valid feeRate. More... | |
| static CFeeRate | EstimateFeeRate (const CWallet &wallet, const CWalletTx &wtx, const CAmount old_fee, const CCoinControl &coin_control) |
| CAmount | GetRequiredFee (const CWallet &wallet, unsigned int nTxBytes) |
| Return the minimum required absolute fee for this size based on the required fee rate. More... | |
| CAmount | GetMinimumFee (const CWallet &wallet, unsigned int nTxBytes, const CCoinControl &coin_control, FeeCalculation *feeCalc) |
| Estimate the minimum fee considering user set parameters and the required fee. More... | |
| CFeeRate | GetRequiredFeeRate (const CWallet &wallet) |
| Return the minimum required feerate taking into account the minimum relay feerate and user set minimum transaction feerate. More... | |
| CFeeRate | GetMinimumFeeRate (const CWallet &wallet, const CCoinControl &coin_control, FeeCalculation *feeCalc) |
| Estimate the minimum fee rate considering user set parameters and the required fee. More... | |
| CFeeRate | GetDiscardRate (const CWallet &wallet) |
| Return the maximum feerate for discarding change. More... | |
| bool | VerifyWallets (WalletContext &context) |
| Responsible for reading and validating the -wallet arguments and verifying the wallet database. More... | |
| bool | LoadWallets (WalletContext &context) |
| Load wallet databases. More... | |
| void | StartWallets (WalletContext &context) |
| Complete startup of wallets. More... | |
| void | StopWallets (WalletContext &context) |
| Stop all wallets. Wallets will be flushed first. More... | |
| void | UnloadWallets (WalletContext &context) |
| Close all wallets. More... | |
| static void | SeekToPage (AutoFile &s, uint32_t page_num, uint32_t page_size) |
| std::unique_ptr< BerkeleyRODatabase > | MakeBerkeleyRODatabase (const fs::path &path, const DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error) |
| Return object giving access to Berkeley Read Only database at specified path. More... | |
| isminetype | InputIsMine (const CWallet &wallet, const CTxIn &txin) |
| bool | AllInputsMine (const CWallet &wallet, const CTransaction &tx, const isminefilter &filter) |
| Returns whether all of the inputs match the filter. More... | |
| CAmount | OutputGetCredit (const CWallet &wallet, const CTxOut &txout, const isminefilter &filter) |
| CAmount | TxGetCredit (const CWallet &wallet, const CTransaction &tx, const isminefilter &filter) |
| bool | ScriptIsChange (const CWallet &wallet, const CScript &script) |
| bool | OutputIsChange (const CWallet &wallet, const CTxOut &txout) |
| CAmount | OutputGetChange (const CWallet &wallet, const CTxOut &txout) |
| CAmount | TxGetChange (const CWallet &wallet, const CTransaction &tx) |
| static CAmount | GetCachableAmount (const CWallet &wallet, const CWalletTx &wtx, CWalletTx::AmountType type, const isminefilter &filter) |
| CAmount | CachedTxGetCredit (const CWallet &wallet, const CWalletTx &wtx, const isminefilter &filter) |
| CAmount | CachedTxGetDebit (const CWallet &wallet, const CWalletTx &wtx, const isminefilter &filter) |
| filter decides which addresses will count towards the debit More... | |
| CAmount | CachedTxGetChange (const CWallet &wallet, const CWalletTx &wtx) |
| CAmount | CachedTxGetImmatureCredit (const CWallet &wallet, const CWalletTx &wtx, const isminefilter &filter) |
| CAmount | CachedTxGetAvailableCredit (const CWallet &wallet, const CWalletTx &wtx, const isminefilter &filter) |
| void | CachedTxGetAmounts (const CWallet &wallet, const CWalletTx &wtx, std::list< COutputEntry > &listReceived, std::list< COutputEntry > &listSent, CAmount &nFee, const isminefilter &filter, bool include_change) |
| bool | CachedTxIsFromMe (const CWallet &wallet, const CWalletTx &wtx, const isminefilter &filter) |
| bool | CachedTxIsTrusted (const CWallet &wallet, const CWalletTx &wtx, std::set< uint256 > &trusted_parents) |
| bool | CachedTxIsTrusted (const CWallet &wallet, const CWalletTx &wtx) |
| Balance | GetBalance (const CWallet &wallet, const int min_depth, bool avoid_reuse) |
| std::map< CTxDestination, CAmount > | GetAddressBalances (const CWallet &wallet) |
| std::set< std::set< CTxDestination > > | GetAddressGroupings (const CWallet &wallet) |
| RPCHelpMan | getnewaddress () |
| RPCHelpMan | getrawchangeaddress () |
| RPCHelpMan | setlabel () |
| RPCHelpMan | listaddressgroupings () |
| RPCHelpMan | keypoolrefill () |
| static UniValue | DescribeWalletAddress (const CWallet &wallet, const CTxDestination &dest) |
| RPCHelpMan | getaddressinfo () |
| RPCHelpMan | getaddressesbylabel () |
| RPCHelpMan | listlabels () |
| RPCHelpMan | walletdisplayaddress () |
| RPCHelpMan | importprunedfunds () |
| RPCHelpMan | removeprunedfunds () |
| static int64_t | GetImportTimestamp (const UniValue &data, int64_t now) |
| static UniValue | ProcessDescriptorImport (CWallet &wallet, const UniValue &data, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) |
| RPCHelpMan | importdescriptors () |
| RPCHelpMan | listdescriptors () |
| RPCHelpMan | backupwallet () |
| RPCHelpMan | restorewallet () |
| static CAmount | GetReceived (const CWallet &wallet, const UniValue ¶ms, bool by_label) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) |
| RPCHelpMan | getreceivedbyaddress () |
| RPCHelpMan | getreceivedbylabel () |
| RPCHelpMan | getbalance () |
| RPCHelpMan | getunconfirmedbalance () |
| RPCHelpMan | lockunspent () |
| RPCHelpMan | listlockunspent () |
| RPCHelpMan | getbalances () |
| RPCHelpMan | listunspent () |
| RPCHelpMan | walletpassphrase () |
| RPCHelpMan | walletpassphrasechange () |
| RPCHelpMan | walletlock () |
| RPCHelpMan | encryptwallet () |
| RPCHelpMan | signmessage () |
| std::vector< CRecipient > | CreateRecipients (const std::vector< std::pair< CTxDestination, CAmount > > &outputs, const std::set< int > &subtract_fee_outputs) |
| static void | InterpretFeeEstimationInstructions (const UniValue &conf_target, const UniValue &estimate_mode, const UniValue &fee_rate, UniValue &options) |
| std::set< int > | InterpretSubtractFeeFromOutputInstructions (const UniValue &sffo_instructions, const std::vector< std::string > &destinations) |
| static UniValue | FinishTransaction (const std::shared_ptr< CWallet > pwallet, const UniValue &options, const CMutableTransaction &rawTx) |
| static void | PreventOutdatedOptions (const UniValue &options) |
| UniValue | SendMoney (CWallet &wallet, const CCoinControl &coin_control, std::vector< CRecipient > &recipients, mapValue_t map_value, bool verbose) |
| static void | SetFeeEstimateMode (const CWallet &wallet, CCoinControl &cc, const UniValue &conf_target, const UniValue &estimate_mode, const UniValue &fee_rate, bool override_min_fee) |
| Update coin control with fee estimation based on the given parameters. More... | |
| RPCHelpMan | sendtoaddress () |
| RPCHelpMan | sendmany () |
| RPCHelpMan | settxfee () |
| static std::vector< RPCArg > | FundTxDoc (bool solving_data=true) |
| CreatedTransactionResult | FundTransaction (CWallet &wallet, const CMutableTransaction &tx, const std::vector< CRecipient > &recipients, const UniValue &options, CCoinControl &coinControl, bool override_min_fee) |
| static void | SetOptionsInputWeights (const UniValue &inputs, UniValue &options) |
| RPCHelpMan | fundrawtransaction () |
| RPCHelpMan | signrawtransactionwithwallet () |
| static std::vector< RPCArg > | OutputsDoc () |
| static RPCHelpMan | bumpfee_helper (std::string method_name) |
| RPCHelpMan | bumpfee () |
| RPCHelpMan | psbtbumpfee () |
| RPCHelpMan | send () |
| RPCHelpMan | sendall () |
| RPCHelpMan | walletprocesspsbt () |
| RPCHelpMan | walletcreatefundedpsbt () |
| static void | WalletTxToJSON (const CWallet &wallet, const CWalletTx &wtx, UniValue &entry) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) |
| static UniValue | ListReceived (const CWallet &wallet, const UniValue ¶ms, const bool by_label, const bool include_immature_coinbase) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) |
| RPCHelpMan | listreceivedbyaddress () |
| RPCHelpMan | listreceivedbylabel () |
| static void | MaybePushAddress (UniValue &entry, const CTxDestination &dest) |
| template<class Vec > | |
| static void | ListTransactions (const CWallet &wallet, const CWalletTx &wtx, int nMinDepth, bool fLong, Vec &ret, const isminefilter &filter_ismine, const std::optional< std::string > &filter_label, bool include_change=false) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) |
| List transactions based on the given criteria. More... | |
| static std::vector< RPCResult > | TransactionDescriptionString () |
| RPCHelpMan | listtransactions () |
| RPCHelpMan | listsinceblock () |
| RPCHelpMan | gettransaction () |
| RPCHelpMan | abandontransaction () |
| RPCHelpMan | rescanblockchain () |
| RPCHelpMan | abortrescan () |
| bool | GetAvoidReuseFlag (const CWallet &wallet, const UniValue ¶m) |
| bool | ParseIncludeWatchonly (const UniValue &include_watchonly, const CWallet &wallet) |
| Used by RPC commands that have an include_watchonly parameter. More... | |
| bool | GetWalletNameFromJSONRPCRequest (const JSONRPCRequest &request, std::string &wallet_name) |
| std::shared_ptr< CWallet > | GetWalletForJSONRPCRequest (const JSONRPCRequest &request) |
| Figures out what wallet, if any, to use for a JSONRPCRequest. More... | |
| void | EnsureWalletIsUnlocked (const CWallet &wallet) |
| WalletContext & | EnsureWalletContext (const std::any &context) |
| std::string | LabelFromValue (const UniValue &value) |
| void | PushParentDescriptors (const CWallet &wallet, const CScript &script_pubkey, UniValue &entry) |
| Fetch parent descriptors of this scriptPubKey. More... | |
| void | HandleWalletError (const std::shared_ptr< CWallet > wallet, DatabaseStatus &status, bilingual_str &error) |
| void | AppendLastProcessedBlock (UniValue &entry, const CWallet &wallet) |
| bool | HaveKey (const SigningProvider &wallet, const CKey &key) |
| Checks if a CKey is in the given CWallet compressed or otherwise. More... | |
| static RPCHelpMan | getwalletinfo () |
| static RPCHelpMan | listwalletdir () |
| static RPCHelpMan | listwallets () |
| static RPCHelpMan | loadwallet () |
| static RPCHelpMan | setwalletflag () |
| static RPCHelpMan | createwallet () |
| static RPCHelpMan | unloadwallet () |
| static RPCHelpMan | upgradewallet () |
| RPCHelpMan | simulaterawtransaction () |
| static RPCHelpMan | migratewallet () |
| RPCHelpMan | gethdkeys () |
| static RPCHelpMan | createwalletdescriptor () |
| std::span< const CRPCCommand > | GetWalletRPCCommands () |
| static bool | ExtractPubKey (const CScript &dest, CPubKey &pubKeyOut) |
| std::vector< CKeyID > | GetAffectedKeys (const CScript &spk, const SigningProvider &provider) |
| static bool | IsSegwit (const Descriptor &desc) |
| Whether the descriptor represents, directly or not, a witness program. More... | |
| static bool | UseMaxSig (const std::optional< CTxIn > &txin, const CCoinControl *coin_control) |
| Whether to assume ECDSA signatures' will be high-r. More... | |
| static std::optional< int64_t > | MaxInputWeight (const Descriptor &desc, const std::optional< CTxIn > &txin, const CCoinControl *coin_control, const bool tx_is_segwit, const bool can_grind_r) |
| Get the size of an input (in witness units) once it's signed. More... | |
| int | CalculateMaximumSignedInputSize (const CTxOut &txout, const COutPoint outpoint, const SigningProvider *provider, bool can_grind_r, const CCoinControl *coin_control) |
| int | CalculateMaximumSignedInputSize (const CTxOut &txout, const CWallet *pwallet, const CCoinControl *coin_control) |
| Get the marginal bytes if spending the specified output from this transaction. More... | |
| static std::unique_ptr< Descriptor > | GetDescriptor (const CWallet *wallet, const CCoinControl *coin_control, const CScript script_pubkey) |
| Infer a descriptor for the given output script. More... | |
| static std::optional< int64_t > | GetSignedTxinWeight (const CWallet *wallet, const CCoinControl *coin_control, const CTxIn &txin, const CTxOut &txo, const bool tx_is_segwit, const bool can_grind_r) |
| Infer the maximum size of this input after it will be signed. More... | |
| TxSize | CalculateMaximumSignedTxSize (const CTransaction &tx, const CWallet *wallet, const std::vector< CTxOut > &txouts, const CCoinControl *coin_control=nullptr) |
| Calculate the size of the transaction using CoinControl to determine whether to expect signature grinding when calculating the size of the input spend. More... | |
| TxSize | CalculateMaximumSignedTxSize (const CTransaction &tx, const CWallet *wallet, const CCoinControl *coin_control) |
| static OutputType | GetOutputType (TxoutType type, bool is_from_p2sh) |
| util::Result< PreSelectedInputs > | FetchSelectedInputs (const CWallet &wallet, const CCoinControl &coin_control, const CoinSelectionParams &coin_selection_params) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) |
| Fetch and validate coin control selected inputs. More... | |
| CoinsResult | AvailableCoins (const CWallet &wallet, const CCoinControl *coinControl=nullptr, std::optional< CFeeRate > feerate=std::nullopt, const CoinFilterParams ¶ms={}) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) |
| Populate the CoinsResult struct with vectors of available COutputs, organized by OutputType. More... | |
| CoinsResult | AvailableCoinsListUnspent (const CWallet &wallet, const CCoinControl *coinControl=nullptr, CoinFilterParams params={}) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) |
Wrapper function for AvailableCoins which skips the feerate and CoinFilterParams::only_spendable parameters. More... | |
| const CTxOut & | FindNonChangeParentOutput (const CWallet &wallet, const COutPoint &outpoint) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) |
| Find non-change parent output. More... | |
| std::map< CTxDestination, std::vector< COutput > > | ListCoins (const CWallet &wallet) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) |
| Return list of available coins and locked coins grouped by non-change output address. More... | |
| FilteredOutputGroups | GroupOutputs (const CWallet &wallet, const CoinsResult &coins, const CoinSelectionParams &coin_sel_params, const std::vector< SelectionFilter > &filters, std::vector< OutputGroup > &ret_discarded_groups) |
| FilteredOutputGroups | GroupOutputs (const CWallet &wallet, const CoinsResult &coins, const CoinSelectionParams &coin_sel_params, const std::vector< SelectionFilter > &filters) |
| Group coins by the provided filters. More... | |
| static bool | HasErrorMsg (const util::Result< SelectionResult > &res) |
| util::Result< SelectionResult > | AttemptSelection (interfaces::Chain &chain, const CAmount &nTargetValue, OutputGroupTypeMap &groups, const CoinSelectionParams &coin_selection_params, bool allow_mixed_output_types) |
| Attempt to find a valid input set that preserves privacy by not mixing OutputTypes. More... | |
| util::Result< SelectionResult > | ChooseSelectionResult (interfaces::Chain &chain, const CAmount &nTargetValue, Groups &groups, const CoinSelectionParams &coin_selection_params) |
| Attempt to find a valid input set that meets the provided eligibility filter and target. More... | |
| util::Result< SelectionResult > | SelectCoins (const CWallet &wallet, CoinsResult &available_coins, const PreSelectedInputs &pre_set_inputs, const CAmount &nTargetValue, const CCoinControl &coin_control, const CoinSelectionParams &coin_selection_params) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) |
| Select all coins from coin_control, and if coin_control 'm_allow_other_inputs=true', call 'AutomaticCoinSelection' to select a set of coins such that nTargetValue - pre_set_inputs.total_amount is met. More... | |
| util::Result< SelectionResult > | AutomaticCoinSelection (const CWallet &wallet, CoinsResult &available_coins, const CAmount &nTargetValue, const CoinSelectionParams &coin_selection_params) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) |
| Select a set of coins such that nTargetValue is met; never select unconfirmed coins if they are not ours param@[in] wallet The wallet which provides data necessary to spend the selected coins param@[in] available_coins The struct of coins, organized by OutputType, available for selection prior to filtering param@[in] nTargetValue The target value param@[in] coin_selection_params Parameters for this coin selection such as feerates, whether to avoid partial spends, and whether to subtract the fee from the outputs. More... | |
| static bool | IsCurrentForAntiFeeSniping (interfaces::Chain &chain, const uint256 &block_hash) |
| static void | DiscourageFeeSniping (CMutableTransaction &tx, FastRandomContext &rng_fast, interfaces::Chain &chain, const uint256 &block_hash, int block_height) |
| Set a height-based locktime for new transactions (uses the height of the current chain tip unless we are not synced with the current chain. More... | |
| size_t | GetSerializeSizeForRecipient (const CRecipient &recipient) |
| bool | IsDust (const CRecipient &recipient, const CFeeRate &dustRelayFee) |
| static util::Result< CreatedTransactionResult > | CreateTransactionInternal (CWallet &wallet, const std::vector< CRecipient > &vecSend, std::optional< unsigned int > change_pos, const CCoinControl &coin_control, bool sign) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) |
| util::Result< CreatedTransactionResult > | CreateTransaction (CWallet &wallet, const std::vector< CRecipient > &vecSend, std::optional< unsigned int > change_pos, const CCoinControl &coin_control, bool sign=true) |
| Create a new transaction paying the recipients with a set of coins selected by SelectCoins(); Also create the change output, when needed. More... | |
| util::Result< CreatedTransactionResult > | FundTransaction (CWallet &wallet, const CMutableTransaction &tx, const std::vector< CRecipient > &recipients, std::optional< unsigned int > change_pos, bool lockUnspents, CCoinControl) |
| Insert additional inputs into the transaction by calling CreateTransaction();. More... | |
| static std::span< const std::byte > | SpanFromBlob (sqlite3_stmt *stmt, int col) |
| static void | ErrorLogCallback (void *arg, int code, const char *msg) |
| static int | TraceSqlCallback (unsigned code, void *context, void *param1, void *param2) |
| static bool | BindBlobToStatement (sqlite3_stmt *stmt, int index, std::span< const std::byte > blob, const std::string &description) |
| static std::optional< int > | ReadPragmaInteger (sqlite3 *db, const std::string &key, const std::string &description, bilingual_str &error) |
| static void | SetPragma (sqlite3 *db, const std::string &key, const std::string &value, const std::string &err_msg) |
| std::unique_ptr< SQLiteDatabase > | MakeSQLiteDatabase (const fs::path &path, const DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error) |
| std::string | SQLiteDatabaseVersion () |
| static CoinSelectionParams | init_default_params () |
| Default coin selection parameters (dcsp) allow us to only explicitly set parameters when a diverging value is relevant in the context of a test. More... | |
| static OutputGroup | MakeCoin (const CAmount &amount, bool is_eff_value=true, CoinSelectionParams cs_params=default_cs_params, int custom_spending_vsize=68) |
Make one OutputGroup with a single UTXO that either has a given effective value (default) or a given amount (is_eff_value = false). More... | |
| static void | AddCoins (std::vector< OutputGroup > &utxo_pool, std::vector< CAmount > coins, CoinSelectionParams cs_params=default_cs_params) |
| Make multiple OutputGroups with the given values as their effective value. More... | |
| static void | AddDuplicateCoins (std::vector< OutputGroup > &utxo_pool, int count, int amount, CoinSelectionParams cs_params=default_cs_params) |
| Make multiple coins that share the same effective value. More... | |
| static bool | HaveEquivalentValues (const SelectionResult &a, const SelectionResult &b) |
| Check if SelectionResult a is equivalent to SelectionResult b. More... | |
| static std::string | InputAmountsToString (const SelectionResult &selection) |
| static void | TestBnBSuccess (std::string test_title, std::vector< OutputGroup > &utxo_pool, const CAmount &selection_target, const std::vector< CAmount > &expected_input_amounts, const CoinSelectionParams &cs_params=default_cs_params, int custom_spending_vsize=68) |
| static void | TestBnBFail (std::string test_title, std::vector< OutputGroup > &utxo_pool, const CAmount &selection_target) |
| BOOST_AUTO_TEST_CASE (bnb_test) | |
| BOOST_AUTO_TEST_CASE (bnb_feerate_sensitivity_test) | |
| static void | add_coin (const CAmount &nValue, int nInput, SelectionResult &result) |
| static void | add_coin (const CAmount &nValue, int nInput, SelectionResult &result, CAmount fee, CAmount long_term_fee) |
| static void | add_coin (CoinsResult &available_coins, CWallet &wallet, const CAmount &nValue, CFeeRate feerate=CFeeRate(0), int nAge=6 *24, bool fIsFromMe=false, int nInput=0, bool spendable=false, int custom_size=0) |
| std::optional< SelectionResult > | KnapsackSolver (std::vector< OutputGroup > &groups, const CAmount &nTargetValue, CAmount change_target, FastRandomContext &rng) |
| std::optional< SelectionResult > | SelectCoinsBnB (std::vector< OutputGroup > &utxo_pool, const CAmount &selection_target, const CAmount &cost_of_change) |
| static bool | EquivalentResult (const SelectionResult &a, const SelectionResult &b) |
| Check if SelectionResult a is equivalent to SelectionResult b. More... | |
| static bool | EqualResult (const SelectionResult &a, const SelectionResult &b) |
| Check if this selection is equal to another one. More... | |
| std::vector< OutputGroup > & | GroupCoins (const std::vector< COutput > &available_coins, bool subtract_fee_outputs=false) |
| std::vector< OutputGroup > & | KnapsackGroupOutputs (const CoinsResult &available_coins, CWallet &wallet, const CoinEligibilityFilter &filter) |
| static std::unique_ptr< CWallet > | NewWallet (const node::NodeContext &m_node, const std::string &wallet_name="") |
| BOOST_AUTO_TEST_CASE (bnb_search_test) | |
| BOOST_AUTO_TEST_CASE (bnb_sffo_restriction) | |
| BOOST_AUTO_TEST_CASE (knapsack_solver_test) | |
| BOOST_AUTO_TEST_CASE (ApproximateBestSubset) | |
| BOOST_AUTO_TEST_CASE (SelectCoins_test) | |
| BOOST_AUTO_TEST_CASE (waste_test) | |
| BOOST_AUTO_TEST_CASE (bump_fee_test) | |
| BOOST_AUTO_TEST_CASE (effective_value_test) | |
| static util::Result< SelectionResult > | CoinGrinder (const CAmount &target, const CoinSelectionParams &cs_params, const node::NodeContext &m_node, int max_selection_weight, std::function< CoinsResult(CWallet &)> coin_setup) |
| BOOST_AUTO_TEST_CASE (coin_grinder_tests) | |
| static util::Result< SelectionResult > | SelectCoinsSRD (const CAmount &target, const CoinSelectionParams &cs_params, const node::NodeContext &m_node, int max_selection_weight, std::function< CoinsResult(CWallet &)> coin_setup) |
| BOOST_AUTO_TEST_CASE (srd_tests) | |
| static util::Result< SelectionResult > | select_coins (const CAmount &target, const CoinSelectionParams &cs_params, const CCoinControl &cc, std::function< CoinsResult(CWallet &)> coin_setup, const node::NodeContext &m_node) |
| static bool | has_coin (const CoinSet &set, CAmount amount) |
| BOOST_AUTO_TEST_CASE (check_max_selection_weight) | |
| BOOST_AUTO_TEST_CASE (SelectCoins_effective_value_test) | |
| BOOST_FIXTURE_TEST_CASE (wallet_coinsresult_test, BasicTestingSetup) | |
| std::span< const std::byte > | StringBytes (std::string_view str) |
| static SerializeData | StringData (std::string_view str) |
| static void | CheckPrefix (DatabaseBatch &batch, std::span< const std::byte > prefix, MockableData expected) |
| static std::vector< std::unique_ptr< WalletDatabase > > | TestDatabases (const fs::path &path_root) |
| BOOST_AUTO_TEST_CASE (db_cursor_prefix_range_test) | |
| BOOST_AUTO_TEST_CASE (db_cursor_prefix_byte_test) | |
| BOOST_AUTO_TEST_CASE (db_availability_after_write_error) | |
| BOOST_AUTO_TEST_CASE (erase_prefix) | |
| BOOST_AUTO_TEST_CASE (txn_close_failure_dangling_txn) | |
| BOOST_AUTO_TEST_CASE (concurrent_txn_dont_interfere) | |
| static void | AddCoin (const CAmount &value, int n_input, int n_input_bytes, int locktime, std::vector< COutput > &coins, CFeeRate fee_rate) |
| static void | GroupCoins (FuzzedDataProvider &fuzzed_data_provider, const std::vector< COutput > &coins, const CoinSelectionParams &coin_params, bool positive_only, std::vector< OutputGroup > &output_groups) |
| static CAmount | CreateCoins (FuzzedDataProvider &fuzzed_data_provider, std::vector< COutput > &utxo_pool, CoinSelectionParams &coin_params, int &next_locktime) |
| static SelectionResult | ManualSelection (std::vector< COutput > &utxos, const CAmount &total_amount, const bool &subtract_fee_outputs) |
| static bool | HasErrorMsg (const util::Result< SelectionResult > &res) |
| FUZZ_TARGET (coin_grinder) | |
| FUZZ_TARGET (coin_grinder_is_optimal) | |
| template<CoinSelectionAlgorithm Algorithm> | |
| void | FuzzCoinSelectionAlgorithm (std::span< const uint8_t > buffer) |
| FUZZ_TARGET (coinselection_bnb) | |
| FUZZ_TARGET (coinselection_srd) | |
| FUZZ_TARGET (coinselection_knapsack) | |
| static std::shared_ptr< CWallet > | NewWallet (const node::NodeContext &m_node) |
| static void | addCoin (CoinsResult &coins, CWallet &wallet, const CTxDestination &dest, const CAmount &nValue, bool is_from_me, CFeeRate fee_rate=CFeeRate(0), int depth=6) |
| CoinSelectionParams | makeSelectionParams (FastRandomContext &rand, bool avoid_partial_spends) |
| BOOST_AUTO_TEST_CASE (outputs_grouping_tests) | |
| BOOST_AUTO_TEST_CASE (walletinit_verify_walletdir_default) | |
| BOOST_AUTO_TEST_CASE (walletinit_verify_walletdir_custom) | |
| BOOST_AUTO_TEST_CASE (walletinit_verify_walletdir_does_not_exist) | |
| BOOST_AUTO_TEST_CASE (walletinit_verify_walletdir_is_not_directory) | |
| BOOST_AUTO_TEST_CASE (walletinit_verify_walletdir_is_not_relative) | |
| BOOST_AUTO_TEST_CASE (walletinit_verify_walletdir_no_trailing) | |
| BOOST_AUTO_TEST_CASE (walletinit_verify_walletdir_no_trailing2) | |
| BOOST_AUTO_TEST_CASE (ismine_standard) | |
| static void | import_descriptor (CWallet &wallet, const std::string &descriptor) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) |
| BOOST_AUTO_TEST_CASE (psbt_updater_test) | |
| BOOST_AUTO_TEST_CASE (parse_hd_keypath) | |
| BOOST_AUTO_TEST_CASE (DescriptorScriptPubKeyManTests) | |
| BOOST_FIXTURE_TEST_CASE (SubtractFee, TestChain100Setup) | |
| BOOST_FIXTURE_TEST_CASE (wallet_duplicated_preset_inputs_test, TestChain100Setup) | |
| std::unique_ptr< CWallet > | CreateSyncedWallet (interfaces::Chain &chain, CChain &cchain, const CKey &key) |
| std::shared_ptr< CWallet > | TestLoadWallet (std::unique_ptr< WalletDatabase > database, WalletContext &context, uint64_t create_flags) |
| std::shared_ptr< CWallet > | TestLoadWallet (WalletContext &context) |
| void | TestUnloadWallet (std::shared_ptr< CWallet > &&wallet) |
| std::unique_ptr< WalletDatabase > | DuplicateMockDatabase (WalletDatabase &database) |
| std::string | getnewaddress (CWallet &w) |
| Returns a new encoded destination from the wallet (hardcoded to BECH32) More... | |
| CTxDestination | getNewDestination (CWallet &w, OutputType output_type) |
| Returns a new destination, of an specific type, from the wallet. More... | |
| std::unique_ptr< WalletDatabase > | CreateMockableWalletDatabase (MockableData records) |
| MockableDatabase & | GetMockableDatabase (CWallet &wallet) |
| wallet::ScriptPubKeyMan * | CreateDescriptor (CWallet &keystore, const std::string &desc_str, const bool success) |
| BOOST_AUTO_TEST_CASE (passphrase) | |
| BOOST_AUTO_TEST_CASE (encrypt) | |
| BOOST_AUTO_TEST_CASE (decrypt) | |
| static CMutableTransaction | TestSimpleSpend (const CTransaction &from, uint32_t index, const CKey &key, const CScript &pubkey) |
| static void | AddKey (CWallet &wallet, const CKey &key) |
| BOOST_FIXTURE_TEST_CASE (scan_for_wallet_transactions, TestChain100Setup) | |
| BOOST_FIXTURE_TEST_CASE (write_wallet_settings_concurrently, TestingSetup) | |
| BOOST_FIXTURE_TEST_CASE (coin_mark_dirty_immature_credit, TestChain100Setup) | |
| static int64_t | AddTx (ChainstateManager &chainman, CWallet &wallet, uint32_t lockTime, int64_t mockTime, int64_t blockTime) |
| BOOST_AUTO_TEST_CASE (ComputeTimeSmart) | |
| void | TestLoadWallet (const std::string &name, DatabaseFormat format, std::function< void(std::shared_ptr< CWallet >)> f) |
| BOOST_FIXTURE_TEST_CASE (LoadReceiveRequests, TestingSetup) | |
| BOOST_FIXTURE_TEST_CASE (ListCoinsTest, ListCoinsTestingSetup) | |
| void | TestCoinsResult (ListCoinsTest &context, OutputType out_type, CAmount amount, std::map< OutputType, size_t > &expected_coins_sizes) |
| BOOST_FIXTURE_TEST_CASE (BasicOutputTypesTest, ListCoinsTest) | |
| BOOST_FIXTURE_TEST_CASE (wallet_disableprivkeys, TestChain100Setup) | |
| static size_t | CalculateNestedKeyhashInputSize (bool use_max_sig) |
| BOOST_FIXTURE_TEST_CASE (dummy_input_size_test, TestChain100Setup) | |
| bool | malformed_descriptor (std::ios_base::failure e) |
| BOOST_FIXTURE_TEST_CASE (wallet_descriptor_test, BasicTestingSetup) | |
| BOOST_FIXTURE_TEST_CASE (CreateWallet, TestChain100Setup) | |
| Test CWallet::Create() and its behavior handling potential race conditions if it's called the same time an incoming transaction shows up in the mempool or a new block. More... | |
| BOOST_FIXTURE_TEST_CASE (CreateWalletWithoutChain, BasicTestingSetup) | |
| BOOST_FIXTURE_TEST_CASE (RemoveTxs, TestChain100Setup) | |
| BOOST_FIXTURE_TEST_CASE (wallet_sync_tx_invalid_state_test, TestingSetup) | |
| Checks a wallet invalid state where the inputs (prev-txs) of a new arriving transaction are not marked dirty, while the transaction that spends them exist inside the in-memory wallet tx map (not stored on db due a db write failure). More... | |
| BOOST_AUTO_TEST_CASE (roundtrip) | |
| BOOST_AUTO_TEST_CASE (walletdb_readkeyvalue) | |
| BOOST_FIXTURE_TEST_CASE (wallet_load_descriptors, TestingSetup) | |
| static TxState | TxStateInterpretSerialized (TxStateUnrecognized data) |
| Try to interpret deserialized TxStateUnrecognized data as a recognized state. More... | |
| static uint256 | TxStateSerializedBlockHash (const TxState &state) |
| Get TxState serialized block hash. Inverse of TxStateInterpretSerialized. More... | |
| static int | TxStateSerializedIndex (const TxState &state) |
| Get TxState serialized block index. Inverse of TxStateInterpretSerialized. More... | |
| template<typename T > | |
| std::string | TxStateString (const T &state) |
| Return TxState or SyncTxState as a string for logging or debugging. More... | |
| bool | AddWalletSetting (interfaces::Chain &chain, const std::string &wallet_name) |
| Add wallet name to persistent configuration so it will be loaded on startup. More... | |
| bool | RemoveWalletSetting (interfaces::Chain &chain, const std::string &wallet_name) |
| Remove wallet name from persistent configuration so it will not be loaded on startup. More... | |
| static void | UpdateWalletSetting (interfaces::Chain &chain, const std::string &wallet_name, std::optional< bool > load_on_startup, std::vector< bilingual_str > &warnings) |
| static void | RefreshMempoolStatus (CWalletTx &tx, interfaces::Chain &chain) |
| Refresh mempool status so the wallet is in an internally consistent state and immediately knows the transaction's status: Whether it can be considered trusted and is eligible to be abandoned ... More... | |
| bool | AddWallet (WalletContext &context, const std::shared_ptr< CWallet > &wallet) |
| bool | RemoveWallet (WalletContext &context, const std::shared_ptr< CWallet > &wallet, std::optional< bool > load_on_start, std::vector< bilingual_str > &warnings) |
| bool | RemoveWallet (WalletContext &context, const std::shared_ptr< CWallet > &wallet, std::optional< bool > load_on_start) |
| std::vector< std::shared_ptr< CWallet > > | GetWallets (WalletContext &context) |
| std::shared_ptr< CWallet > | GetDefaultWallet (WalletContext &context, size_t &count) |
| std::shared_ptr< CWallet > | GetWallet (WalletContext &context, const std::string &name) |
| std::unique_ptr< interfaces::Handler > | HandleLoadWallet (WalletContext &context, LoadWalletFn load_wallet) |
| void | NotifyWalletLoaded (WalletContext &context, const std::shared_ptr< CWallet > &wallet) |
| static std::set< std::string > g_loading_wallet_set | GUARDED_BY (g_loading_wallet_mutex) |
| static std::set< std::string > g_unloading_wallet_set | GUARDED_BY (g_wallet_release_mutex) |
| static void | FlushAndDeleteWallet (CWallet *wallet) |
| void | WaitForDeleteWallet (std::shared_ptr< CWallet > &&wallet) |
| Explicitly delete the wallet. More... | |
| std::shared_ptr< CWallet > | LoadWallet (WalletContext &context, const std::string &name, std::optional< bool > load_on_start, const DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error, std::vector< bilingual_str > &warnings) |
| std::shared_ptr< CWallet > | CreateWallet (WalletContext &context, const std::string &name, std::optional< bool > load_on_start, DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error, std::vector< bilingual_str > &warnings) |
| std::shared_ptr< CWallet > | RestoreWallet (WalletContext &context, const fs::path &backup_file, const std::string &wallet_name, std::optional< bool > load_on_start, DatabaseStatus &status, bilingual_str &error, std::vector< bilingual_str > &warnings, bool load_after_restore) |
| static bool | EncryptMasterKey (const SecureString &wallet_passphrase, const CKeyingMaterial &plain_master_key, CMasterKey &master_key) |
| static bool | DecryptMasterKey (const SecureString &wallet_passphrase, const CMasterKey &master_key, CKeyingMaterial &plain_master_key) |
| void | MaybeResendWalletTxs (WalletContext &context) |
| Called periodically by the schedule thread. More... | |
| static util::Result< fs::path > | GetWalletPath (const std::string &name) |
| std::unique_ptr< WalletDatabase > | MakeWalletDatabase (const std::string &name, const DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error_string) |
| bool | DoMigration (CWallet &wallet, WalletContext &context, bilingual_str &error, MigrationResult &res) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) |
| util::Result< MigrationResult > | MigrateLegacyToDescriptor (const std::string &wallet_name, const SecureString &passphrase, WalletContext &context) |
| Do all steps to migrate a legacy wallet to a descriptor wallet. More... | |
| util::Result< MigrationResult > | MigrateLegacyToDescriptor (std::shared_ptr< CWallet > local_wallet, const SecureString &passphrase, WalletContext &context, bool was_loaded) |
| Requirement: The wallet provided to this function must be isolated, with no attachment to the node's context. More... | |
| std::string | PurposeToString (AddressPurpose p) |
| std::optional< AddressPurpose > | PurposeFromString (std::string_view s) |
| bool | LoadKey (CWallet *pwallet, DataStream &ssKey, DataStream &ssValue, std::string &strErr) |
| bool | LoadCryptedKey (CWallet *pwallet, DataStream &ssKey, DataStream &ssValue, std::string &strErr) |
| bool | LoadEncryptionKey (CWallet *pwallet, DataStream &ssKey, DataStream &ssValue, std::string &strErr) |
| bool | LoadHDChain (CWallet *pwallet, DataStream &ssValue, std::string &strErr) |
| static DBErrors | LoadMinVersion (CWallet *pwallet, DatabaseBatch &batch) EXCLUSIVE_LOCKS_REQUIRED(pwallet -> cs_wallet) |
| static DBErrors | LoadWalletFlags (CWallet *pwallet, DatabaseBatch &batch) EXCLUSIVE_LOCKS_REQUIRED(pwallet -> cs_wallet) |
| static LoadResult | LoadRecords (CWallet *pwallet, DatabaseBatch &batch, const std::string &key, DataStream &prefix, LoadFunc load_func) |
| static LoadResult | LoadRecords (CWallet *pwallet, DatabaseBatch &batch, const std::string &key, LoadFunc load_func) |
| bool | HasLegacyRecords (CWallet &wallet) |
| Returns true if there are any DBKeys::LEGACY_TYPES record in the wallet db. More... | |
| bool | HasLegacyRecords (CWallet &wallet, DatabaseBatch &batch) |
| static DBErrors | LoadLegacyWalletRecords (CWallet *pwallet, DatabaseBatch &batch, int last_client) EXCLUSIVE_LOCKS_REQUIRED(pwallet -> cs_wallet) |
| template<typename... Args> | |
| static DataStream | PrefixStream (const Args &... args) |
| static DBErrors | LoadDescriptorWalletRecords (CWallet *pwallet, DatabaseBatch &batch, int last_client) EXCLUSIVE_LOCKS_REQUIRED(pwallet -> cs_wallet) |
| static DBErrors | LoadAddressBookRecords (CWallet *pwallet, DatabaseBatch &batch) EXCLUSIVE_LOCKS_REQUIRED(pwallet -> cs_wallet) |
| static DBErrors | LoadTxRecords (CWallet *pwallet, DatabaseBatch &batch, std::vector< uint256 > &upgraded_txs, bool &any_unordered) EXCLUSIVE_LOCKS_REQUIRED(pwallet -> cs_wallet) |
| static DBErrors | LoadActiveSPKMs (CWallet *pwallet, DatabaseBatch &batch) EXCLUSIVE_LOCKS_REQUIRED(pwallet -> cs_wallet) |
| static DBErrors | LoadDecryptionKeys (CWallet *pwallet, DatabaseBatch &batch) EXCLUSIVE_LOCKS_REQUIRED(pwallet -> cs_wallet) |
| static bool | RunWithinTxn (WalletBatch &batch, std::string_view process_desc, const std::function< bool(WalletBatch &)> &func) |
| bool | RunWithinTxn (WalletDatabase &database, std::string_view process_desc, const std::function< bool(WalletBatch &)> &func) |
| Executes the provided function 'func' within a database transaction context. More... | |
| fs::path | GetWalletDir () |
| Get the path of the wallet directory. More... | |
| bool | IsFeatureSupported (int wallet_version, int feature_version) |
| WalletFeature | GetClosestWalletFeature (int version) |
| WalletDescriptor | GenerateWalletDescriptor (const CExtPubKey &master_key, const OutputType &addr_type, bool internal) |
Variables | |
| const int | DEFAULT_MIN_DEPTH = 0 |
| const int | DEFAULT_MAX_DEPTH = 9999999 |
| static constexpr bool | DEFAULT_AVOIDPARTIALSPENDS = false |
| Default for -avoidpartialspends. More... | |
| struct { | |
| } | descending |
| struct { | |
| } | descending_effval_weight |
| static const size_t | TOTAL_TRIES = 100000 |
| static constexpr CAmount | CHANGE_LOWER {50000} |
| lower bound for randomly-chosen target change amount More... | |
| static constexpr CAmount | CHANGE_UPPER {1000000} |
| upper bound for randomly-chosen target change amount More... | |
| const unsigned int | WALLET_CRYPTO_KEY_SIZE = 32 |
| const unsigned int | WALLET_CRYPTO_SALT_SIZE = 8 |
| const unsigned int | WALLET_CRYPTO_IV_SIZE = 16 |
| static const std::string | DUMP_MAGIC = "BITCOIN_CORE_WALLET_DUMP" |
| uint32_t | DUMP_VERSION = 1 |
| constexpr uint32_t | BTREE_MAGIC = 0x00053162 |
| constexpr uint32_t | BTREE_MAGIC_OE = 0x62310500 |
| static const std::vector< std::byte > | SUBDATABASE_NAME = {std::byte{'m'}, std::byte{'a'}, std::byte{'i'}, std::byte{'n'}} |
| static const std::string | WALLET_ENDPOINT_BASE = "/wallet/" |
| const std::string | HELP_REQUIRING_PASSPHRASE {"\nRequires wallet passphrase to be set with walletpassphrase call if wallet is encrypted.\n"} |
| static const RPCResult | RESULT_LAST_PROCESSED_BLOCK |
| static const std::map< uint64_t, std::string > | WALLET_FLAG_CAVEATS |
| static constexpr int64_t | UNKNOWN_TIME = std::numeric_limits<int64_t>::max() |
| Constant representing an unknown spkm creation time. More... | |
| static const unsigned int | DEFAULT_KEYPOOL_SIZE = 1000 |
| Default for -keypool. More... | |
| static const std::unordered_set< OutputType > | LEGACY_OUTPUT_TYPES |
| OutputTypes supported by the LegacyScriptPubKeyMan. More... | |
| static constexpr size_t | OUTPUT_GROUP_MAX_ENTRIES {100} |
| static constexpr int32_t | WALLET_SCHEMA_VERSION = 0 |
| static int | next_lock_time = 0 |
| static FastRandomContext | default_rand |
| static const CoinSelectionParams | default_cs_params = init_default_params() |
| static const CoinEligibilityFilter | filter_standard (1, 6, 0) |
| static const CoinEligibilityFilter | filter_confirmed (1, 1, 0) |
| static const CoinEligibilityFilter | filter_standard_extra (6, 6, 0) |
| static int | nextLockTime = 0 |
| constexpr int | TEST_SQLITE_ERROR = -999 |
| static int | nextLockTime = 0 |
| static const DatabaseFormat | DATABASE_FORMATS [] |
| const std::string | ADDRESS_BCRT1_UNSPENDABLE = "bcrt1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3xueyj" |
| static GlobalMutex | g_loading_wallet_mutex |
| static GlobalMutex | g_wallet_release_mutex |
| static std::condition_variable | g_wallet_release_cv |
| constexpr CAmount | DEFAULT_PAY_TX_FEE = 0 |
| -paytxfee default More... | |
| static const CAmount | DEFAULT_FALLBACK_FEE = 0 |
| -fallbackfee default More... | |
| static const CAmount | DEFAULT_DISCARD_FEE = 10000 |
| -discardfee default More... | |
| static const CAmount | DEFAULT_TRANSACTION_MINFEE = 1000 |
| -mintxfee default More... | |
| static const CAmount | DEFAULT_CONSOLIDATE_FEERATE {10000} |
| -consolidatefeerate default More... | |
| static const CAmount | DEFAULT_MAX_AVOIDPARTIALSPEND_FEE = 0 |
| maximum fee increase allowed to do partial spend avoidance, even for nodes with this feature disabled by default More... | |
| constexpr CAmount | HIGH_APS_FEE {COIN / 10000} |
| discourage APS fee higher than this amount More... | |
| static const CAmount | WALLET_INCREMENTAL_RELAY_FEE = 5000 |
| minimum recommended increment for replacement txs More... | |
| static const bool | DEFAULT_SPEND_ZEROCONF_CHANGE = true |
| Default for -spendzeroconfchange. More... | |
| static const bool | DEFAULT_WALLET_REJECT_LONG_CHAINS {true} |
| Default for -walletrejectlongchains. More... | |
| static const unsigned int | DEFAULT_TX_CONFIRM_TARGET = 6 |
| -txconfirmtarget default More... | |
| static const bool | DEFAULT_WALLET_RBF = true |
| -walletrbf default More... | |
| static const bool | DEFAULT_WALLETBROADCAST = true |
| static const bool | DEFAULT_DISABLE_WALLET = false |
| static const bool | DEFAULT_WALLETCROSSCHAIN = false |
| constexpr CAmount | DEFAULT_TRANSACTION_MAXFEE {COIN / 10} |
| -maxtxfee default More... | |
| constexpr CAmount | HIGH_TX_FEE_PER_KB {COIN / 100} |
| Discourage users to set fees higher than this amount (in satoshis) per kB. More... | |
| constexpr CAmount | HIGH_MAX_TX_FEE {100 * HIGH_TX_FEE_PER_KB} |
| -maxtxfee will warn if called with a higher fee than this amount (in satoshis) More... | |
| static constexpr size_t | DUMMY_NESTED_P2WPKH_INPUT_SIZE = 91 |
| Pre-calculated constants for input size estimation in virtual size More... | |
| constexpr OutputType | DEFAULT_ADDRESS_TYPE {OutputType::BECH32} |
| Default for -addresstype. More... | |
| static constexpr uint64_t | KNOWN_WALLET_FLAGS |
| static constexpr uint64_t | MUTABLE_WALLET_FLAGS |
| static const std::map< std::string, WalletFlags > | WALLET_FLAG_MAP |
| using wallet::BerkeleyROData = typedef std::map<SerializeData, SerializeData, std::less<> > |
| typedef std::vector<unsigned char, secure_allocator<unsigned char> > wallet::CKeyingMaterial |
| typedef std::set<std::shared_ptr<COutput> > wallet::CoinSet |
Definition at line 33 of file coinselector_tests.cpp.
| typedef std::map<CoinEligibilityFilter, OutputGroupTypeMap> wallet::FilteredOutputGroups |
Definition at line 295 of file coinselection.h.
| typedef std::underlying_type_t< isminetype > wallet::isminefilter |
| using wallet::LoadFunc = typedef std::function<DBErrors(CWallet* pwallet, DataStream& key, DataStream& value, std::string& err)> |
Definition at line 480 of file walletdb.cpp.
| using wallet::LoadWalletFn = typedef std::function<void(std::unique_ptr<interfaces::Wallet> wallet)> |
| typedef std::map<std::string, std::string> wallet::mapValue_t |
Definition at line 149 of file transaction.h.
| using wallet::MockableData = typedef std::map<SerializeData, SerializeData, std::less<> > |
| using wallet::SyncTxState = typedef std::variant<TxStateConfirmed, TxStateInMempool, TxStateInactive> |
Subset of states transaction sync logic is implemented to handle.
Definition at line 81 of file transaction.h.
| using wallet::TxState = typedef std::variant<TxStateConfirmed, TxStateInMempool, TxStateBlockConflicted, TxStateInactive, TxStateUnrecognized> |
All possible CWalletTx states.
Definition at line 78 of file transaction.h.
| typedef std::vector<unsigned char> wallet::valtype |
Definition at line 29 of file scriptpubkeyman.cpp.
|
strong |
Address purpose field that has been been stored with wallet sending and receiving addresses since BIP70 payment protocol support was added in https://github.com/bitcoin/bitcoin/pull/2539.
This field is not currently used for any logic inside the wallet, but it is still shown in RPC and GUI interfaces and saved for new addresses. It is basically redundant with an address's IsMine() result.
| Enumerator | |
|---|---|
| RECEIVE | |
| SEND | |
| REFUND | Never set in current code may be present in older wallet databases. |
|
strong |
| Enumerator | |
|---|---|
| SUBDB | |
Definition at line 51 of file migrate.cpp.
|
strong |
| Enumerator | |
|---|---|
| BNB | |
| SRD | |
| KNAPSACK | |
Definition at line 220 of file coinselection.cpp.
|
strong |
|
strong |
|
strong |
Overview of wallet database classes:
| Enumerator | |
|---|---|
| LOAD_OK | |
| NEED_RESCAN | |
| NEED_REWRITE | |
| EXTERNAL_SIGNER_SUPPORT_REQUIRED | |
| NONCRITICAL_ERROR | |
| TOO_NEW | |
| UNKNOWN_DESCRIPTOR | |
| LOAD_FAIL | |
| UNEXPECTED_LEGACY_ENTRY | |
| LEGACY_WALLET | |
| CORRUPT | |
Definition at line 39 of file walletdb.h.
| enum wallet::isminetype : unsigned int |
IsMine() return codes, which depend on ScriptPubKeyMan implementation.
Not every ScriptPubKeyMan covers all types, please refer to https://github.com/bitcoin/bitcoin/blob/master/doc/release-notes/release-notes-0.21.0.md#ismine-semantics for better understanding.
For LegacyScriptPubKeyMan, ISMINE_NO: the scriptPubKey is not in the wallet; ISMINE_WATCH_ONLY: the scriptPubKey has been imported into the wallet; ISMINE_SPENDABLE: the scriptPubKey corresponds to an address owned by the wallet user (can spend with the private key); ISMINE_USED: the scriptPubKey corresponds to a used address owned by the wallet user; ISMINE_ALL: all ISMINE flags except for USED; ISMINE_ALL_USED: all ISMINE flags including USED; ISMINE_ENUM_ELEMENTS: the number of isminetype enum elements.
For DescriptorScriptPubKeyMan and future ScriptPubKeyMan, ISMINE_NO: the scriptPubKey is not in the wallet; ISMINE_SPENDABLE: the scriptPubKey matches a scriptPubKey in the wallet. ISMINE_USED: the scriptPubKey corresponds to a used address owned by the wallet user.
| Enumerator | |
|---|---|
| ISMINE_NO | |
| ISMINE_WATCH_ONLY | |
| ISMINE_SPENDABLE | |
| ISMINE_USED | |
| ISMINE_ALL | |
| ISMINE_ALL_USED | |
| ISMINE_ENUM_ELEMENTS | |
|
strong |
| Enumerator | |
|---|---|
| BTREE_INTERNAL | |
| BTREE_LEAF | |
| OVERFLOW_DATA | |
| BTREE_META | |
Definition at line 22 of file migrate.cpp.
|
strong |
| Enumerator | |
|---|---|
| KEYDATA | |
| OVERFLOW_DATA | |
| DELETE | |
Definition at line 44 of file migrate.cpp.
|
strong |
| Enumerator | |
|---|---|
| BNB | |
| KNAPSACK | |
| SRD | |
| CG | |
| MANUAL | |
Definition at line 313 of file coinselection.h.
(client) version numbers for particular wallet features
| Enumerator | |
|---|---|
| FEATURE_BASE | |
| FEATURE_WALLETCRYPT | |
| FEATURE_COMPRPUBKEY | |
| FEATURE_HD | |
| FEATURE_HD_SPLIT | |
| FEATURE_NO_DEFAULT_KEY | |
| FEATURE_PRE_SPLIT_KEYPOOL | |
| FEATURE_LATEST | |
Definition at line 15 of file walletutil.h.
| enum wallet::WalletFlags : uint64_t |
| Enumerator | |
|---|---|
| WALLET_FLAG_AVOID_REUSE | |
| WALLET_FLAG_KEY_ORIGIN_METADATA | |
| WALLET_FLAG_LAST_HARDENED_XPUB_CACHED | |
| WALLET_FLAG_DISABLE_PRIVATE_KEYS | |
| WALLET_FLAG_BLANK_WALLET | Flag set when a wallet contains no HD seed and no private keys, scripts, addresses, and other watch only things, and is therefore "blank.". The main function this flag serves is to distinguish a blank wallet from a newly created wallet when the wallet database is loaded, to avoid initialization that should only happen on first run. A secondary function of this flag, which applies to descriptor wallets only, is to serve as an ongoing indication that descriptors in the wallet should be created manually, and that the wallet should not generate automatically generate new descriptors if it is later encrypted. To support this behavior, descriptor wallets unlike legacy wallets do not automatically unset the BLANK flag when things are imported. This flag is also a mandatory flag to prevent previous versions of bitcoin from opening the wallet, thinking it was newly created, and then improperly reinitializing it. |
| WALLET_FLAG_DESCRIPTORS | Indicate that this wallet supports DescriptorScriptPubKeyMan. |
| WALLET_FLAG_EXTERNAL_SIGNER | Indicates that the wallet needs an external signer. |
Definition at line 36 of file walletutil.h.
| RPCHelpMan wallet::abandontransaction | ( | ) |
Definition at line 809 of file transactions.cpp.
| RPCHelpMan wallet::abortrescan | ( | ) |
Definition at line 946 of file transactions.cpp.
|
static |
|
static |
Definition at line 40 of file coinselector_tests.cpp.
|
static |
|
static |
Definition at line 29 of file group_outputs_tests.cpp.
|
static |
Definition at line 20 of file coinselection.cpp.
|
static |
Make multiple OutputGroups with the given values as their effective value.
Definition at line 58 of file coinselection_tests.cpp.
|
static |
Make multiple coins that share the same effective value.
Definition at line 66 of file coinselection_tests.cpp.
Definition at line 60 of file wallet_tests.cpp.
|
static |
Definition at line 258 of file wallet_tests.cpp.
|
static |
Definition at line 25 of file wallet_loading.cpp.
| bool wallet::AddWallet | ( | WalletContext & | context, |
| const std::shared_ptr< CWallet > & | wallet | ||
| ) |
Definition at line 149 of file wallet.cpp.
| bool wallet::AddWalletSetting | ( | interfaces::Chain & | chain, |
| const std::string & | wallet_name | ||
| ) |
Add wallet name to persistent configuration so it will be loaded on startup.
Definition at line 94 of file wallet.cpp.
| bool wallet::AllInputsMine | ( | const CWallet & | wallet, |
| const CTransaction & | tx, | ||
| const isminefilter & | filter | ||
| ) |
Returns whether all of the inputs match the filter.
Definition at line 22 of file receive.cpp.
|
static |
Find a subset of the OutputGroups that is at least as large as, but as close as possible to, the target amount; solve subset sum.
param@[in] groups OutputGroups to choose from, sorted by value in descending order. param@[in] nTotalLower Total (effective) value of the UTXOs in groups. param@[in] nTargetValue Subset sum target, not including change. param@[out] vfBest Boolean vector representing the subset chosen that is closest to nTargetValue, with indices corresponding to groups. If the ith entry is true, that means the ith group in groups was selected. param@[out] nBest Total amount of subset chosen that is closest to nTargetValue. paramp[in] max_selection_weight The maximum allowed weight for a selection result to be valid. param@[in] iterations Maximum number of tries.
Definition at line 602 of file coinselection.cpp.
| util::Result< SelectionResult > wallet::AttemptSelection | ( | interfaces::Chain & | chain, |
| const CAmount & | nTargetValue, | ||
| OutputGroupTypeMap & | groups, | ||
| const CoinSelectionParams & | coin_selection_params, | ||
| bool | allow_mixed_output_types | ||
| ) |
Attempt to find a valid input set that preserves privacy by not mixing OutputTypes.
ChooseSelectionResult() will be called on each OutputType individually and the best the solution (according to the waste metric) will be chosen. If a valid input cannot be found from any single OutputType, fallback to running ChooseSelectionResult() over all available coins.
param@[in] chain The chain interface to get information on unconfirmed UTXOs bump fees param@[in] nTargetValue The target value param@[in] groups The grouped outputs mapped by coin eligibility filters param@[in] coin_selection_params Parameters for the coin selection param@[in] allow_mixed_output_types Relax restriction that SelectionResults must be of the same OutputType returns If successful, a SelectionResult containing the input set If failed, returns (1) an empty error message if the target was not reached (general "Insufficient funds") or (2) an specific error message if there was something particularly wrong (e.g. a selection result that surpassed the tx max weight size).
Definition at line 661 of file spend.cpp.
| util::Result< SelectionResult > wallet::AutomaticCoinSelection | ( | const CWallet & | wallet, |
| CoinsResult & | available_coins, | ||
| const CAmount & | nTargetValue, | ||
| const CoinSelectionParams & | coin_selection_params | ||
| ) |
Select a set of coins such that nTargetValue is met; never select unconfirmed coins if they are not ours param@[in] wallet The wallet which provides data necessary to spend the selected coins param@[in] available_coins The struct of coins, organized by OutputType, available for selection prior to filtering param@[in] nTargetValue The target value param@[in] coin_selection_params Parameters for this coin selection such as feerates, whether to avoid partial spends, and whether to subtract the fee from the outputs.
returns If successful, a SelectionResult containing the selected coins If failed, returns (1) an empty error message if the target was not reached (general "Insufficient funds") or (2) an specific error message if there was something particularly wrong (e.g. a selection result that surpassed the tx max weight size).
Definition at line 825 of file spend.cpp.
| CoinsResult wallet::AvailableCoins | ( | const CWallet & | wallet, |
| const CCoinControl * | coinControl, | ||
| std::optional< CFeeRate > | feerate, | ||
| const CoinFilterParams & | params | ||
| ) |
Populate the CoinsResult struct with vectors of available COutputs, organized by OutputType.
Definition at line 314 of file spend.cpp.
| CoinsResult wallet::AvailableCoinsListUnspent | ( | const CWallet & | wallet, |
| const CCoinControl * | coinControl = nullptr, |
||
| CoinFilterParams | params = {} |
||
| ) |
Wrapper function for AvailableCoins which skips the feerate and CoinFilterParams::only_spendable parameters.
Use this function to list all available coins (e.g. listunspent RPC) while not intending to fund a transaction.
Definition at line 478 of file spend.cpp.
| RPCHelpMan wallet::backupwallet | ( | ) |
Definition at line 576 of file backup.cpp.
| wallet::BENCHMARK | ( | WalletBalanceClean | , |
| benchmark::PriorityLevel::HIGH | |||
| ) |
| wallet::BENCHMARK | ( | WalletBalanceDirty | , |
| benchmark::PriorityLevel::HIGH | |||
| ) |
| wallet::BENCHMARK | ( | WalletBalanceMine | , |
| benchmark::PriorityLevel::HIGH | |||
| ) |
| wallet::BENCHMARK | ( | WalletBalanceWatch | , |
| benchmark::PriorityLevel::HIGH | |||
| ) |
| wallet::BENCHMARK | ( | WalletCreateEncrypted | , |
| benchmark::PriorityLevel::LOW | |||
| ) |
| wallet::BENCHMARK | ( | WalletCreatePlain | , |
| benchmark::PriorityLevel::LOW | |||
| ) |
| wallet::BENCHMARK | ( | WalletIsMineDescriptors | , |
| benchmark::PriorityLevel::LOW | |||
| ) |
| wallet::BENCHMARK | ( | WalletIsMineMigratedDescriptors | , |
| benchmark::PriorityLevel::LOW | |||
| ) |
| wallet::BENCHMARK | ( | WalletLoadingDescriptors | , |
| benchmark::PriorityLevel::HIGH | |||
| ) |
| wallet::BENCHMARK | ( | WalletMigration | , |
| benchmark::PriorityLevel::LOW | |||
| ) |
|
static |
| wallet::BOOST_AUTO_TEST_CASE | ( | ApproximateBestSubset | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | bnb_feerate_sensitivity_test | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | bnb_search_test | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | bnb_sffo_restriction | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | bnb_test | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | bump_fee_test | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | check_max_selection_weight | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | coin_grinder_tests | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | ComputeTimeSmart | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | concurrent_txn_dont_interfere | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | db_availability_after_write_error | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | db_cursor_prefix_byte_test | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | db_cursor_prefix_range_test | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | decrypt | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | DescriptorScriptPubKeyManTests | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | effective_value_test | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | encrypt | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | erase_prefix | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | ismine_standard | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | knapsack_solver_test | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | outputs_grouping_tests | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | parse_hd_keypath | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | passphrase | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | psbt_updater_test | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | roundtrip | ) |
Definition at line 14 of file wallet_transaction_tests.cpp.
| wallet::BOOST_AUTO_TEST_CASE | ( | SelectCoins_effective_value_test | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | SelectCoins_test | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | srd_tests | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | txn_close_failure_dangling_txn | ) |
| wallet::BOOST_AUTO_TEST_CASE | ( | walletdb_readkeyvalue | ) |
When ReadKeyValue() reads from either a "key" or "wkey" it first reads the DataStream into a CPrivKey or CWalletKey respectively and then reads a hash of the pubkey and privkey into a uint256. Wallets from 0.8 or before do not store the pubkey/privkey hash, trying to read the hash from old wallets throws an exception, for backwards compatibility this read is wrapped in a try block to silently fail. The test here makes sure the type of exception thrown from DataStream::read() matches the type we expect, otherwise we need to update the "key"/"wkey" exception type caught.
Definition at line 17 of file walletdb_tests.cpp.
| wallet::BOOST_AUTO_TEST_CASE | ( | walletinit_verify_walletdir_custom | ) |
Definition at line 26 of file init_tests.cpp.
| wallet::BOOST_AUTO_TEST_CASE | ( | walletinit_verify_walletdir_default | ) |
Definition at line 16 of file init_tests.cpp.
| wallet::BOOST_AUTO_TEST_CASE | ( | walletinit_verify_walletdir_does_not_exist | ) |
Definition at line 36 of file init_tests.cpp.
| wallet::BOOST_AUTO_TEST_CASE | ( | walletinit_verify_walletdir_is_not_directory | ) |
Definition at line 46 of file init_tests.cpp.
| wallet::BOOST_AUTO_TEST_CASE | ( | walletinit_verify_walletdir_is_not_relative | ) |
Definition at line 56 of file init_tests.cpp.
| wallet::BOOST_AUTO_TEST_CASE | ( | walletinit_verify_walletdir_no_trailing | ) |
Definition at line 66 of file init_tests.cpp.
| wallet::BOOST_AUTO_TEST_CASE | ( | walletinit_verify_walletdir_no_trailing2 | ) |
Definition at line 76 of file init_tests.cpp.
| wallet::BOOST_AUTO_TEST_CASE | ( | waste_test | ) |
| wallet::BOOST_FIXTURE_TEST_CASE | ( | BasicOutputTypesTest | , |
| ListCoinsTest | |||
| ) |
| wallet::BOOST_FIXTURE_TEST_CASE | ( | coin_mark_dirty_immature_credit | , |
| TestChain100Setup | |||
| ) |
| wallet::BOOST_FIXTURE_TEST_CASE | ( | CreateWallet | , |
| TestChain100Setup | |||
| ) |
Test CWallet::Create() and its behavior handling potential race conditions if it's called the same time an incoming transaction shows up in the mempool or a new block.
It isn't possible to verify there aren't race condition in every case, so this test just checks two specific cases and ensures that timing of notifications in these cases doesn't prevent the wallet from detecting transactions.
In the first case, block and mempool transactions are created before the wallet is loaded, but notifications about these transactions are delayed until after it is loaded. The notifications are superfluous in this case, so the test verifies the transactions are detected before they arrive.
In the second case, block and mempool transactions are created after the wallet rescan and notifications are immediately synced, to verify the wallet must already have a handler in place for them, and there's no gap after rescanning where new transactions in new blocks could be lost.
Definition at line 592 of file wallet_tests.cpp.
| wallet::BOOST_FIXTURE_TEST_CASE | ( | CreateWalletWithoutChain | , |
| BasicTestingSetup | |||
| ) |
| wallet::BOOST_FIXTURE_TEST_CASE | ( | dummy_input_size_test | , |
| TestChain100Setup | |||
| ) |
| wallet::BOOST_FIXTURE_TEST_CASE | ( | ListCoinsTest | , |
| ListCoinsTestingSetup | |||
| ) |
| wallet::BOOST_FIXTURE_TEST_CASE | ( | LoadReceiveRequests | , |
| TestingSetup | |||
| ) |
| wallet::BOOST_FIXTURE_TEST_CASE | ( | RemoveTxs | , |
| TestChain100Setup | |||
| ) |
| wallet::BOOST_FIXTURE_TEST_CASE | ( | scan_for_wallet_transactions | , |
| TestChain100Setup | |||
| ) |
| wallet::BOOST_FIXTURE_TEST_CASE | ( | SubtractFee | , |
| TestChain100Setup | |||
| ) |
| wallet::BOOST_FIXTURE_TEST_CASE | ( | wallet_coinsresult_test | , |
| BasicTestingSetup | |||
| ) |
| wallet::BOOST_FIXTURE_TEST_CASE | ( | wallet_descriptor_test | , |
| BasicTestingSetup | |||
| ) |
| wallet::BOOST_FIXTURE_TEST_CASE | ( | wallet_disableprivkeys | , |
| TestChain100Setup | |||
| ) |
| wallet::BOOST_FIXTURE_TEST_CASE | ( | wallet_duplicated_preset_inputs_test | , |
| TestChain100Setup | |||
| ) |
| wallet::BOOST_FIXTURE_TEST_CASE | ( | wallet_load_descriptors | , |
| TestingSetup | |||
| ) |
| wallet::BOOST_FIXTURE_TEST_CASE | ( | wallet_sync_tx_invalid_state_test | , |
| TestingSetup | |||
| ) |
Checks a wallet invalid state where the inputs (prev-txs) of a new arriving transaction are not marked dirty, while the transaction that spends them exist inside the in-memory wallet tx map (not stored on db due a db write failure).
Definition at line 740 of file wallet_tests.cpp.
| wallet::BOOST_FIXTURE_TEST_CASE | ( | write_wallet_settings_concurrently | , |
| TestingSetup | |||
| ) |
| RPCHelpMan wallet::bumpfee | ( | ) |
|
static |
| void wallet::CachedTxGetAmounts | ( | const CWallet & | wallet, |
| const CWalletTx & | wtx, | ||
| std::list< COutputEntry > & | listReceived, | ||
| std::list< COutputEntry > & | listSent, | ||
| CAmount & | nFee, | ||
| const isminefilter & | filter, | ||
| bool | include_change | ||
| ) |
Definition at line 194 of file receive.cpp.
| CAmount wallet::CachedTxGetAvailableCredit | ( | const CWallet & | wallet, |
| const CWalletTx & | wtx, | ||
| const isminefilter & | filter | ||
| ) |
Definition at line 159 of file receive.cpp.
| CAmount wallet::CachedTxGetCredit | ( | const CWallet & | wallet, |
| const CWalletTx & | wtx, | ||
| const isminefilter & | filter | ||
| ) |
Definition at line 109 of file receive.cpp.
| CAmount wallet::CachedTxGetDebit | ( | const CWallet & | wallet, |
| const CWalletTx & | wtx, | ||
| const isminefilter & | filter | ||
| ) |
filter decides which addresses will count towards the debit
Definition at line 126 of file receive.cpp.
| CAmount wallet::CachedTxGetImmatureCredit | ( | const CWallet & | wallet, |
| const CWalletTx & | wtx, | ||
| const isminefilter & | filter | ||
| ) |
Definition at line 148 of file receive.cpp.
| bool wallet::CachedTxIsFromMe | ( | const CWallet & | wallet, |
| const CWalletTx & | wtx, | ||
| const isminefilter & | filter | ||
| ) |
Definition at line 251 of file receive.cpp.
| bool wallet::CachedTxIsTrusted | ( | const CWallet & | wallet, |
| const CWalletTx & | wtx, | ||
| std::set< uint256 > & | trusted_parents | ||
| ) |
Definition at line 257 of file receive.cpp.
| int wallet::CalculateMaximumSignedInputSize | ( | const CTxOut & | txout, |
| const COutPoint | outpoint, | ||
| const SigningProvider * | provider, | ||
| bool | can_grind_r, | ||
| const CCoinControl * | coin_control | ||
| ) |
| int wallet::CalculateMaximumSignedInputSize | ( | const CTxOut & | txout, |
| const CWallet * | pwallet, | ||
| const CCoinControl * | coin_control | ||
| ) |
Get the marginal bytes if spending the specified output from this transaction.
Use CoinControl to determine whether to expect signature grinding when calculating the size of the input spend.
Definition at line 103 of file spend.cpp.
| TxSize wallet::CalculateMaximumSignedTxSize | ( | const CTransaction & | tx, |
| const CWallet * | wallet, | ||
| const CCoinControl * | coin_control | ||
| ) |
| TxSize wallet::CalculateMaximumSignedTxSize | ( | const CTransaction & | tx, |
| const CWallet * | wallet, | ||
| const std::vector< CTxOut > & | txouts, | ||
| const CCoinControl * | coin_control | ||
| ) |
|
static |
Definition at line 513 of file wallet_tests.cpp.
|
static |
Check if the user provided a valid feeRate.
Definition at line 62 of file feebumper.cpp.
|
static |
Definition at line 41 of file db_tests.cpp.
| util::Result< SelectionResult > wallet::ChooseSelectionResult | ( | interfaces::Chain & | chain, |
| const CAmount & | nTargetValue, | ||
| Groups & | groups, | ||
| const CoinSelectionParams & | coin_selection_params | ||
| ) |
Attempt to find a valid input set that meets the provided eligibility filter and target.
Multiple coin selection algorithms will be run and the input set that produces the least waste (according to the waste metric) will be chosen.
param@[in] chain The chain interface to get information on unconfirmed UTXOs bump fees param@[in] nTargetValue The target value param@[in] groups The struct containing the outputs grouped by script and divided by (1) positive only outputs and (2) all outputs (positive + negative). param@[in] coin_selection_params Parameters for the coin selection returns If successful, a SelectionResult containing the input set If failed, returns (1) an empty error message if the target was not reached (general "Insufficient funds") or (2) an specific error message if there was something particularly wrong (e.g. a selection result that surpassed the tx max weight size).
Definition at line 688 of file spend.cpp.
|
static |
| util::Result< SelectionResult > wallet::CoinGrinder | ( | std::vector< OutputGroup > & | utxo_pool, |
| const CAmount & | selection_target, | ||
| CAmount | change_target, | ||
| int | max_selection_weight | ||
| ) |
Definition at line 325 of file coinselection.cpp.
|
static |
Definition at line 50 of file coinselection.cpp.
| ScriptPubKeyMan * wallet::CreateDescriptor | ( | CWallet & | keystore, |
| const std::string & | desc_str, | ||
| const bool | success | ||
| ) |
| bool wallet::CreateFromDump | ( | const ArgsManager & | args, |
| const std::string & | name, | ||
| const fs::path & | wallet_path, | ||
| bilingual_str & | error, | ||
| std::vector< bilingual_str > & | warnings | ||
| ) |
| std::unique_ptr< WalletDatabase > wallet::CreateMockableWalletDatabase | ( | MockableData | records | ) |
| std::vector< CRecipient > wallet::CreateRecipients | ( | const std::vector< std::pair< CTxDestination, CAmount > > & | outputs, |
| const std::set< int > & | subtract_fee_outputs | ||
| ) |
| std::unique_ptr< CWallet > wallet::CreateSyncedWallet | ( | interfaces::Chain & | chain, |
| CChain & | cchain, | ||
| const CKey & | key | ||
| ) |
| util::Result< CreatedTransactionResult > wallet::CreateTransaction | ( | CWallet & | wallet, |
| const std::vector< CRecipient > & | vecSend, | ||
| std::optional< unsigned int > | change_pos, | ||
| const CCoinControl & | coin_control, | ||
| bool | sign = true |
||
| ) |
Create a new transaction paying the recipients with a set of coins selected by SelectCoins(); Also create the change output, when needed.
Definition at line 1368 of file spend.cpp.
|
static |
|
static |
Definition at line 338 of file wallet.cpp.
| std::shared_ptr< CWallet > wallet::CreateWallet | ( | WalletContext & | context, |
| const std::string & | name, | ||
| std::optional< bool > | load_on_start, | ||
| DatabaseOptions & | options, | ||
| DatabaseStatus & | status, | ||
| bilingual_str & | error, | ||
| std::vector< bilingual_str > & | warnings | ||
| ) |
Definition at line 379 of file wallet.cpp.
|
static |
Definition at line 838 of file wallet.cpp.
| bool wallet::DecryptKey | ( | const CKeyingMaterial & | master_key, |
| const std::span< const unsigned char > | crypted_secret, | ||
| const CPubKey & | pub_key, | ||
| CKey & | key | ||
| ) |
Definition at line 132 of file crypter.cpp.
| bool wallet::DecryptSecret | ( | const CKeyingMaterial & | master_key, |
| const std::span< const unsigned char > | ciphertext, | ||
| const uint256 & | iv, | ||
| CKeyingMaterial & | plaintext | ||
| ) |
Definition at line 121 of file crypter.cpp.
|
static |
Definition at line 351 of file addresses.cpp.
|
static |
| bool wallet::DoMigration | ( | CWallet & | wallet, |
| WalletContext & | context, | ||
| bilingual_str & | error, | ||
| MigrationResult & | res | ||
| ) |
Definition at line 4075 of file wallet.cpp.
| bool wallet::DumpWallet | ( | const ArgsManager & | args, |
| WalletDatabase & | db, | ||
| bilingual_str & | error | ||
| ) |
| std::unique_ptr< WalletDatabase > wallet::DuplicateMockDatabase | ( | WalletDatabase & | database | ) |
| bool wallet::EncryptSecret | ( | const CKeyingMaterial & | vMasterKey, |
| const CKeyingMaterial & | vchPlaintext, | ||
| const uint256 & | nIV, | ||
| std::vector< unsigned char > & | vchCiphertext | ||
| ) |
Definition at line 111 of file crypter.cpp.
| RPCHelpMan wallet::encryptwallet | ( | ) |
Definition at line 216 of file encrypt.cpp.
| WalletContext & wallet::EnsureWalletContext | ( | const std::any & | context | ) |
| void wallet::EnsureWalletIsUnlocked | ( | const CWallet & | wallet | ) |
|
static |
Check if this selection is equal to another one.
Equal means same inputs (i.e same value and prevout)
Definition at line 118 of file coinselector_tests.cpp.
|
static |
Check if SelectionResult a is equivalent to SelectionResult b.
Equivalent means same input values, but maybe different inputs (i.e. same value, different prevout)
Definition at line 100 of file coinselector_tests.cpp.
|
static |
Definition at line 35 of file sqlite.cpp.
|
static |
Definition at line 22 of file coinselection.cpp.
|
static |
Definition at line 120 of file feebumper.cpp.
Definition at line 357 of file scriptpubkeyman.cpp.
| util::Result< PreSelectedInputs > wallet::FetchSelectedInputs | ( | const CWallet & | wallet, |
| const CCoinControl & | coin_control, | ||
| const CoinSelectionParams & | coin_selection_params | ||
| ) |
|
static |
|
static |
| RPCHelpMan wallet::fundrawtransaction | ( | ) |
| CreatedTransactionResult wallet::FundTransaction | ( | CWallet & | wallet, |
| const CMutableTransaction & | tx, | ||
| const std::vector< CRecipient > & | recipients, | ||
| const UniValue & | options, | ||
| CCoinControl & | coinControl, | ||
| bool | override_min_fee | ||
| ) |
| util::Result< CreatedTransactionResult > wallet::FundTransaction | ( | CWallet & | wallet, |
| const CMutableTransaction & | tx, | ||
| const std::vector< CRecipient > & | vecSend, | ||
| std::optional< unsigned int > | change_pos, | ||
| bool | lockUnspents, | ||
| CCoinControl | coinControl | ||
| ) |
Insert additional inputs into the transaction by calling CreateTransaction();.
Definition at line 1422 of file spend.cpp.
|
static |
| wallet::FUZZ_TARGET | ( | coin_grinder | ) |
| wallet::FUZZ_TARGET | ( | coin_grinder_is_optimal | ) |
| wallet::FUZZ_TARGET | ( | coinselection_bnb | ) |
Definition at line 348 of file coinselection.cpp.
| wallet::FUZZ_TARGET | ( | coinselection_knapsack | ) |
Definition at line 356 of file coinselection.cpp.
| wallet::FUZZ_TARGET | ( | coinselection_srd | ) |
Definition at line 352 of file coinselection.cpp.
| void wallet::FuzzCoinSelectionAlgorithm | ( | std::span< const uint8_t > | buffer | ) |
| CAmount wallet::GenerateChangeTarget | ( | const CAmount | payment_value, |
| const CAmount | change_fee, | ||
| FastRandomContext & | rng | ||
| ) |
Choose a random change target for each transaction to make it harder to fingerprint the Core wallet based on the change output values of transactions it creates.
Change target covers at least change fees and adds a random value on top of it. The random value is between 50ksat and min(2 * payment_value, 1milsat) When payment_value <= 25ksat, the value is just 50ksat.
Making change amounts similar to the payment value may help disguise which output(s) are payments are which ones are change. Using double the payment value may increase the number of inputs needed (and thus be more expensive in fees), but breaks analysis techniques which assume the coins selected are just sufficient to cover the payment amount ("unnecessary input" heuristic).
| [in] | payment_value | Average payment value of the transaction output(s). |
| [in] | change_fee | Fee for creating a change output. |
Definition at line 809 of file coinselection.cpp.
| WalletDescriptor wallet::GenerateWalletDescriptor | ( | const CExtPubKey & | master_key, |
| const OutputType & | addr_type, | ||
| bool | internal | ||
| ) |
Definition at line 49 of file walletutil.cpp.
| std::map< CTxDestination, CAmount > wallet::GetAddressBalances | ( | const CWallet & | wallet | ) |
Definition at line 322 of file receive.cpp.
| RPCHelpMan wallet::getaddressesbylabel | ( | ) |
Definition at line 509 of file addresses.cpp.
| std::set< std::set< CTxDestination > > wallet::GetAddressGroupings | ( | const CWallet & | wallet | ) |
Definition at line 360 of file receive.cpp.
| RPCHelpMan wallet::getaddressinfo | ( | ) |
Definition at line 363 of file addresses.cpp.
| std::vector< CKeyID > wallet::GetAffectedKeys | ( | const CScript & | spk, |
| const SigningProvider & | provider | ||
| ) |
| std::string wallet::GetAlgorithmName | ( | const SelectionAlgorithm | algo | ) |
Definition at line 961 of file coinselection.cpp.
| RPCHelpMan wallet::getbalance | ( | ) |
Definition at line 293 of file receive.cpp.
| RPCHelpMan wallet::getbalances | ( | ) |
|
static |
Definition at line 99 of file receive.cpp.
| WalletFeature wallet::GetClosestWalletFeature | ( | int | version | ) |
| std::shared_ptr< CWallet > wallet::GetDefaultWallet | ( | WalletContext & | context, |
| size_t & | count | ||
| ) |
|
static |
| RPCHelpMan wallet::gethdkeys | ( | ) |
Definition at line 730 of file wallet.cpp.
|
static |
Definition at line 125 of file backup.cpp.
| CAmount wallet::GetMinimumFee | ( | const CWallet & | wallet, |
| unsigned int | nTxBytes, | ||
| const CCoinControl & | coin_control, | ||
| FeeCalculation * | feeCalc | ||
| ) |
| CFeeRate wallet::GetMinimumFeeRate | ( | const CWallet & | wallet, |
| const CCoinControl & | coin_control, | ||
| FeeCalculation * | feeCalc | ||
| ) |
| MockableDatabase & wallet::GetMockableDatabase | ( | CWallet & | wallet | ) |
| RPCHelpMan wallet::getnewaddress | ( | ) |
Definition at line 21 of file addresses.cpp.
| std::string wallet::getnewaddress | ( | CWallet & | w | ) |
| CTxDestination wallet::getNewDestination | ( | CWallet & | w, |
| OutputType | output_type | ||
| ) |
|
static |
| RPCHelpMan wallet::getrawchangeaddress | ( | ) |
Definition at line 71 of file addresses.cpp.
| RPCHelpMan wallet::getreceivedbyaddress | ( | ) |
| RPCHelpMan wallet::getreceivedbylabel | ( | ) |
| size_t wallet::GetSerializeSizeForRecipient | ( | const CRecipient & | recipient | ) |
|
static |
| RPCHelpMan wallet::gettransaction | ( | ) |
Definition at line 695 of file transactions.cpp.
| RPCHelpMan wallet::getunconfirmedbalance | ( | ) |
| std::shared_ptr< CWallet > wallet::GetWallet | ( | WalletContext & | context, |
| const std::string & | name | ||
| ) |
| fs::path wallet::GetWalletDir | ( | ) |
Get the path of the wallet directory.
Definition at line 13 of file walletutil.cpp.
| std::shared_ptr< CWallet > wallet::GetWalletForJSONRPCRequest | ( | const JSONRPCRequest & | request | ) |
Figures out what wallet, if any, to use for a JSONRPCRequest.
| [in] | request | JSONRPCRequest that wishes to access a wallet |
Definition at line 57 of file util.cpp.
|
static |
Definition at line 42 of file wallet.cpp.
| bool wallet::GetWalletNameFromJSONRPCRequest | ( | const JSONRPCRequest & | request, |
| std::string & | wallet_name | ||
| ) |
|
static |
Definition at line 2791 of file wallet.cpp.
| std::span< const CRPCCommand > wallet::GetWalletRPCCommands | ( | ) |
Definition at line 1004 of file wallet.cpp.
| std::vector< std::shared_ptr< CWallet > > wallet::GetWallets | ( | WalletContext & | context | ) |
|
inline |
|
static |
| FilteredOutputGroups wallet::GroupOutputs | ( | const CWallet & | wallet, |
| const CoinsResult & | coins, | ||
| const CoinSelectionParams & | params, | ||
| const std::vector< SelectionFilter > & | filters | ||
| ) |
| FilteredOutputGroups wallet::GroupOutputs | ( | const CWallet & | wallet, |
| const CoinsResult & | coins, | ||
| const CoinSelectionParams & | coin_sel_params, | ||
| const std::vector< SelectionFilter > & | filters, | ||
| std::vector< OutputGroup > & | ret_discarded_groups | ||
| ) |
|
static |
|
static |
| std::unique_ptr< interfaces::Handler > wallet::HandleLoadWallet | ( | WalletContext & | context, |
| LoadWalletFn | load_wallet | ||
| ) |
Definition at line 213 of file wallet.cpp.
| void wallet::HandleWalletError | ( | const std::shared_ptr< CWallet > | wallet, |
| DatabaseStatus & | status, | ||
| bilingual_str & | error | ||
| ) |
|
static |
|
static |
| bool wallet::HasLegacyRecords | ( | CWallet & | wallet | ) |
Returns true if there are any DBKeys::LEGACY_TYPES record in the wallet db.
Definition at line 525 of file walletdb.cpp.
| bool wallet::HasLegacyRecords | ( | CWallet & | wallet, |
| DatabaseBatch & | batch | ||
| ) |
|
static |
Check if SelectionResult a is equivalent to SelectionResult b.
Two results are equivalent if they are composed of the same input values, even if they have different inputs (i.e., same value, different prevout)
Definition at line 74 of file coinselection_tests.cpp.
| bool wallet::HaveKey | ( | const SigningProvider & | wallet, |
| const CKey & | key | ||
| ) |
Checks if a CKey is in the given CWallet compressed or otherwise.
Definition at line 35 of file wallet.cpp.
|
static |
Definition at line 20 of file psbt_wallet_tests.cpp.
| RPCHelpMan wallet::importdescriptors | ( | ) |
Definition at line 298 of file backup.cpp.
| RPCHelpMan wallet::importprunedfunds | ( | ) |
Definition at line 37 of file backup.cpp.
|
static |
Default coin selection parameters (dcsp) allow us to only explicitly set parameters when a diverging value is relevant in the context of a test.
We use P2WPKH input and output weights for the change weights.
Definition at line 21 of file coinselection_tests.cpp.
|
static |
Definition at line 91 of file coinselection_tests.cpp.
| isminetype wallet::InputIsMine | ( | const CWallet & | wallet, |
| const CTxIn & | txin | ||
| ) |
Definition at line 12 of file receive.cpp.
| std::set< int > wallet::InterpretSubtractFeeFromOutputInstructions | ( | const UniValue & | sffo_instructions, |
| const std::vector< std::string > & | destinations | ||
| ) |
| bool wallet::IsBDBFile | ( | const fs::path & | path | ) |
|
static |
| bool wallet::IsDust | ( | const CRecipient & | recipient, |
| const CFeeRate & | dustRelayFee | ||
| ) |
| bool wallet::IsFeatureSupported | ( | int | wallet_version, |
| int | feature_version | ||
| ) |
|
static |
| bool wallet::IsSQLiteFile | ( | const fs::path & | path | ) |
| RPCHelpMan wallet::keypoolrefill | ( | ) |
Definition at line 214 of file addresses.cpp.
|
inline |
Definition at line 140 of file coinselector_tests.cpp.
| std::optional< SelectionResult > wallet::KnapsackSolver | ( | std::vector< OutputGroup > & | groups, |
| const CAmount & | nTargetValue, | ||
| CAmount | change_target, | ||
| FastRandomContext & | rng | ||
| ) |
| util::Result< SelectionResult > wallet::KnapsackSolver | ( | std::vector< OutputGroup > & | groups, |
| const CAmount & | nTargetValue, | ||
| CAmount | change_target, | ||
| FastRandomContext & | rng, | ||
| int | max_selection_weight | ||
| ) |
Definition at line 652 of file coinselection.cpp.
| std::string wallet::LabelFromValue | ( | const UniValue & | value | ) |
| RPCHelpMan wallet::listaddressgroupings | ( | ) |
Definition at line 154 of file addresses.cpp.
| std::map< CTxDestination, std::vector< COutput > > wallet::ListCoins | ( | const CWallet & | wallet | ) |
| RPCHelpMan wallet::listdescriptors | ( | ) |
Definition at line 463 of file backup.cpp.
| RPCHelpMan wallet::listlabels | ( | ) |
Definition at line 569 of file addresses.cpp.
| RPCHelpMan wallet::listlockunspent | ( | ) |
|
static |
Definition at line 75 of file transactions.cpp.
| RPCHelpMan wallet::listreceivedbyaddress | ( | ) |
Definition at line 206 of file transactions.cpp.
| RPCHelpMan wallet::listreceivedbylabel | ( | ) |
Definition at line 259 of file transactions.cpp.
| RPCHelpMan wallet::listsinceblock | ( | ) |
Definition at line 550 of file transactions.cpp.
| RPCHelpMan wallet::listtransactions | ( | ) |
Definition at line 441 of file transactions.cpp.
|
static |
List transactions based on the given criteria.
| wallet | The wallet. |
| wtx | The wallet transaction. |
| nMinDepth | The minimum confirmation depth. |
| fLong | Whether to include the JSON version of the transaction. |
| ret | The vector into which the result is stored. |
| filter_ismine | The "is mine" filter flags. |
| filter_label | Optional label string to filter incoming transactions. |
Definition at line 323 of file transactions.cpp.
| RPCHelpMan wallet::listunspent | ( | ) |
|
static |
Definition at line 139 of file wallet.cpp.
|
static |
Definition at line 176 of file wallet.cpp.
|
static |
Definition at line 1103 of file walletdb.cpp.
|
static |
Definition at line 946 of file walletdb.cpp.
| bool wallet::LoadCryptedKey | ( | CWallet * | pwallet, |
| DataStream & | ssKey, | ||
| DataStream & | ssValue, | ||
| std::string & | strErr | ||
| ) |
Definition at line 362 of file walletdb.cpp.
|
static |
Definition at line 1132 of file walletdb.cpp.
|
static |
Definition at line 775 of file walletdb.cpp.
| bool wallet::LoadEncryptionKey | ( | CWallet * | pwallet, |
| DataStream & | ssKey, | ||
| DataStream & | ssValue, | ||
| std::string & | strErr | ||
| ) |
| bool wallet::LoadHDChain | ( | CWallet * | pwallet, |
| DataStream & | ssValue, | ||
| std::string & | strErr | ||
| ) |
Definition at line 428 of file walletdb.cpp.
| bool wallet::LoadKey | ( | CWallet * | pwallet, |
| DataStream & | ssKey, | ||
| DataStream & | ssValue, | ||
| std::string & | strErr | ||
| ) |
Definition at line 296 of file walletdb.cpp.
|
static |
Definition at line 554 of file walletdb.cpp.
|
static |
Definition at line 444 of file walletdb.cpp.
|
static |
Definition at line 481 of file walletdb.cpp.
|
static |
Definition at line 518 of file walletdb.cpp.
|
static |
Definition at line 1007 of file walletdb.cpp.
|
static |
Definition at line 207 of file wallet.cpp.
| std::shared_ptr< CWallet > wallet::LoadWallet | ( | WalletContext & | context, |
| const std::string & | name, | ||
| std::optional< bool > | load_on_start, | ||
| const DatabaseOptions & | options, | ||
| DatabaseStatus & | status, | ||
| bilingual_str & | error, | ||
| std::vector< bilingual_str > & | warnings | ||
| ) |
Definition at line 366 of file wallet.cpp.
|
static |
Definition at line 456 of file walletdb.cpp.
| bool wallet::LoadWallets | ( | WalletContext & | context | ) |
| RPCHelpMan wallet::lockunspent | ( | ) |
| std::unique_ptr< BerkeleyRODatabase > wallet::MakeBerkeleyRODatabase | ( | const fs::path & | path, |
| const DatabaseOptions & | options, | ||
| DatabaseStatus & | status, | ||
| bilingual_str & | error | ||
| ) |
Return object giving access to Berkeley Read Only database at specified path.
Definition at line 771 of file migrate.cpp.
|
static |
Make one OutputGroup with a single UTXO that either has a given effective value (default) or a given amount (is_eff_value = false).
Definition at line 44 of file coinselection_tests.cpp.
| std::unique_ptr< WalletDatabase > wallet::MakeDatabase | ( | const fs::path & | path, |
| const DatabaseOptions & | options, | ||
| DatabaseStatus & | status, | ||
| bilingual_str & | error | ||
| ) |
Definition at line 1342 of file walletdb.cpp.
| CoinSelectionParams wallet::makeSelectionParams | ( | FastRandomContext & | rand, |
| bool | avoid_partial_spends | ||
| ) |
| std::unique_ptr< SQLiteDatabase > wallet::MakeSQLiteDatabase | ( | const fs::path & | path, |
| const DatabaseOptions & | options, | ||
| DatabaseStatus & | status, | ||
| bilingual_str & | error | ||
| ) |
Definition at line 694 of file sqlite.cpp.
| std::unique_ptr< WalletDatabase > wallet::MakeWalletDatabase | ( | const std::string & | name, |
| const DatabaseOptions & | options, | ||
| DatabaseStatus & | status, | ||
| bilingual_str & | error_string | ||
| ) |
Definition at line 2813 of file wallet.cpp.
| bool wallet::malformed_descriptor | ( | std::ios_base::failure | e | ) |
|
static |
Definition at line 68 of file coinselection.cpp.
|
static |
Get the size of an input (in witness units) once it's signed.
| desc | The output script descriptor of the coin spent by this input. |
| txin | Optionally the txin to estimate the size of. Used to determine the size of ECDSA signatures. |
| coin_control | Information about the context to determine the size of ECDSA signatures. |
| tx_is_segwit | Whether the transaction has at least a single input spending a segwit coin. |
| can_grind_r | Whether the signer will be able to grind the R of the signature. |
Definition at line 67 of file spend.cpp.
|
static |
Definition at line 304 of file transactions.cpp.
| void wallet::MaybeResendWalletTxs | ( | WalletContext & | context | ) |
Called periodically by the schedule thread.
Prompts individual wallets to resend their transactions. Actual rebroadcast schedule is managed by the wallets themselves.
Definition at line 2060 of file wallet.cpp.
| util::Result< MigrationResult > wallet::MigrateLegacyToDescriptor | ( | const std::string & | wallet_name, |
| const SecureString & | passphrase, | ||
| WalletContext & | context | ||
| ) |
Do all steps to migrate a legacy wallet to a descriptor wallet.
Definition at line 4192 of file wallet.cpp.
| util::Result< MigrationResult > wallet::MigrateLegacyToDescriptor | ( | std::shared_ptr< CWallet > | local_wallet, |
| const SecureString & | passphrase, | ||
| WalletContext & | context, | ||
| bool | was_loaded | ||
| ) |
Requirement: The wallet provided to this function must be isolated, with no attachment to the node's context.
Definition at line 4250 of file wallet.cpp.
|
static |
Definition at line 662 of file wallet.cpp.
|
static |
|
static |
Definition at line 159 of file coinselector_tests.cpp.
| void wallet::NotifyWalletLoaded | ( | WalletContext & | context, |
| const std::shared_ptr< CWallet > & | wallet | ||
| ) |
Definition at line 220 of file wallet.cpp.
| bool wallet::operator< | ( | BytePrefix | a, |
| std::span< const std::byte > | b | ||
| ) |
| bool wallet::operator< | ( | std::span< const std::byte > | a, |
| BytePrefix | b | ||
| ) |
Definition at line 78 of file receive.cpp.
| CAmount wallet::OutputGetCredit | ( | const CWallet & | wallet, |
| const CTxOut & | txout, | ||
| const isminefilter & | filter | ||
| ) |
Definition at line 31 of file receive.cpp.
Definition at line 73 of file receive.cpp.
|
static |
|
static |
Check whether transaction has descendant in wallet or mempool, or has been mined, or conflicts with a mined transaction.
Return a feebumper::Result.
Definition at line 24 of file feebumper.cpp.
|
static |
Definition at line 768 of file walletdb.cpp.
|
static |
|
static |
Definition at line 139 of file backup.cpp.
| RPCHelpMan wallet::psbtbumpfee | ( | ) |
|
inline |
|
inline |
| void wallet::ReadDatabaseArgs | ( | const ArgsManager & | args, |
| DatabaseOptions & | options | ||
| ) |
|
static |
Definition at line 81 of file sqlite.cpp.
|
static |
Refresh mempool status so the wallet is in an internally consistent state and immediately knows the transaction's status: Whether it can be considered trusted and is eligible to be abandoned ...
Definition at line 140 of file wallet.cpp.
| RPCHelpMan wallet::removeprunedfunds | ( | ) |
Definition at line 93 of file backup.cpp.
| bool wallet::RemoveWallet | ( | WalletContext & | context, |
| const std::shared_ptr< CWallet > & | wallet, | ||
| std::optional< bool > | load_on_start | ||
| ) |
Definition at line 185 of file wallet.cpp.
| bool wallet::RemoveWallet | ( | WalletContext & | context, |
| const std::shared_ptr< CWallet > & | wallet, | ||
| std::optional< bool > | load_on_start, | ||
| std::vector< bilingual_str > & | warnings | ||
| ) |
Definition at line 161 of file wallet.cpp.
| bool wallet::RemoveWalletSetting | ( | interfaces::Chain & | chain, |
| const std::string & | wallet_name | ||
| ) |
Remove wallet name from persistent configuration so it will not be loaded on startup.
Definition at line 107 of file wallet.cpp.
| RPCHelpMan wallet::rescanblockchain | ( | ) |
Definition at line 850 of file transactions.cpp.
| RPCHelpMan wallet::restorewallet | ( | ) |
Definition at line 610 of file backup.cpp.
| std::shared_ptr< CWallet > wallet::RestoreWallet | ( | WalletContext & | context, |
| const fs::path & | backup_file, | ||
| const std::string & | wallet_name, | ||
| std::optional< bool > | load_on_start, | ||
| DatabaseStatus & | status, | ||
| bilingual_str & | error, | ||
| std::vector< bilingual_str > & | warnings, | ||
| bool | load_after_restore | ||
| ) |
Definition at line 491 of file wallet.cpp.
|
static |
Definition at line 1241 of file walletdb.cpp.
| bool wallet::RunWithinTxn | ( | WalletDatabase & | database, |
| std::string_view | process_desc, | ||
| const std::function< bool(WalletBatch &)> & | func | ||
| ) |
Executes the provided function 'func' within a database transaction context.
This function ensures that all db modifications performed within 'func()' are atomically committed to the db at the end of the process. And, in case of a failure during execution, all performed changes are rolled back.
| database | The db connection instance to perform the transaction on. |
| process_desc | A description of the process being executed, used for logging purposes in the event of a failure. |
| func | The function to be executed within the db txn context. It returns a boolean indicating whether to commit or roll back the txn. |
Definition at line 1264 of file walletdb.cpp.
Definition at line 51 of file receive.cpp.
|
static |
|
static |
Definition at line 1244 of file coinselector_tests.cpp.
| util::Result< SelectionResult > wallet::SelectCoins | ( | const CWallet & | wallet, |
| CoinsResult & | available_coins, | ||
| const PreSelectedInputs & | pre_set_inputs, | ||
| const CAmount & | nTargetValue, | ||
| const CCoinControl & | coin_control, | ||
| const CoinSelectionParams & | coin_selection_params | ||
| ) |
Select all coins from coin_control, and if coin_control 'm_allow_other_inputs=true', call 'AutomaticCoinSelection' to select a set of coins such that nTargetValue - pre_set_inputs.total_amount is met.
Definition at line 773 of file spend.cpp.
| std::optional< SelectionResult > wallet::SelectCoinsBnB | ( | std::vector< OutputGroup > & | utxo_pool, |
| const CAmount & | selection_target, | ||
| const CAmount & | cost_of_change | ||
| ) |
| util::Result< SelectionResult > wallet::SelectCoinsBnB | ( | std::vector< OutputGroup > & | utxo_pool, |
| const CAmount & | selection_target, | ||
| const CAmount & | cost_of_change, | ||
| int | max_selection_weight | ||
| ) |
Definition at line 93 of file coinselection.cpp.
|
static |
| util::Result< SelectionResult > wallet::SelectCoinsSRD | ( | const std::vector< OutputGroup > & | utxo_pool, |
| CAmount | target_value, | ||
| CAmount | change_fee, | ||
| FastRandomContext & | rng, | ||
| int | max_selection_weight | ||
| ) |
Select coins by Single Random Draw.
OutputGroups are selected randomly from the eligible outputs until the target is satisfied
| [in] | utxo_pool | The positive effective value OutputGroups eligible for selection |
| [in] | target_value | The target value to select for |
| [in] | rng | The randomness source to shuffle coins |
| [in] | max_selection_weight | The maximum allowed weight for a selection result to be valid |
Definition at line 536 of file coinselection.cpp.
| RPCHelpMan wallet::send | ( | ) |
| RPCHelpMan wallet::sendall | ( | ) |
| RPCHelpMan wallet::sendmany | ( | ) |
| UniValue wallet::SendMoney | ( | CWallet & | wallet, |
| const CCoinControl & | coin_control, | ||
| std::vector< CRecipient > & | recipients, | ||
| mapValue_t | map_value, | ||
| bool | verbose | ||
| ) |
| RPCHelpMan wallet::sendtoaddress | ( | ) |
|
static |
Update coin control with fee estimation based on the given parameters.
| [in] | wallet | Wallet reference |
| [in,out] | cc | Coin control to be updated |
| [in] | conf_target | UniValue integer; confirmation target in blocks, values between 1 and 1008 are valid per policy/fees.h; |
| [in] | estimate_mode | UniValue string; fee estimation mode, valid values are "unset", "economical" or "conservative"; |
| [in] | fee_rate | UniValue real; fee rate in sat/vB; if present, both conf_target and estimate_mode must either be null, or "unset" |
| [in] | override_min_fee | bool; whether to set fOverrideFeeRate to true to disable minimum fee rate checks and instead verify only that fee_rate is greater than 0 |
| a | JSONRPCError if conf_target, estimate_mode, or fee_rate contain invalid values or are in conflict |
Definition at line 203 of file spend.cpp.
| RPCHelpMan wallet::setlabel | ( | ) |
Definition at line 116 of file addresses.cpp.
|
static |
| RPCHelpMan wallet::settxfee | ( | ) |
|
static |
| RPCHelpMan wallet::signmessage | ( | ) |
Definition at line 14 of file signmessage.cpp.
| RPCHelpMan wallet::signrawtransactionwithwallet | ( | ) |
| RPCHelpMan wallet::simulaterawtransaction | ( | ) |
Definition at line 553 of file wallet.cpp.
|
static |
| std::string wallet::SQLiteDatabaseVersion | ( | ) |
| void wallet::StartWallets | ( | WalletContext & | context | ) |
| void wallet::StopWallets | ( | WalletContext & | context | ) |
|
inline |
|
static |
Definition at line 35 of file db_tests.cpp.
|
static |
Definition at line 112 of file coinselection_tests.cpp.
|
static |
Definition at line 96 of file coinselection_tests.cpp.
| void wallet::TestCoinsResult | ( | ListCoinsTest & | context, |
| OutputType | out_type, | ||
| CAmount | amount, | ||
| std::map< OutputType, size_t > & | expected_coins_sizes | ||
| ) |
Definition at line 461 of file wallet_tests.cpp.
|
static |
Definition at line 58 of file db_tests.cpp.
| void wallet::TestLoadWallet | ( | const std::string & | name, |
| DatabaseFormat | format, | ||
| std::function< void(std::shared_ptr< CWallet >)> | f | ||
| ) |
Definition at line 309 of file wallet_tests.cpp.
| std::shared_ptr< CWallet > wallet::TestLoadWallet | ( | std::unique_ptr< WalletDatabase > | database, |
| WalletContext & | context, | ||
| uint64_t | create_flags | ||
| ) |
| std::shared_ptr< CWallet > wallet::TestLoadWallet | ( | WalletContext & | context | ) |
|
static |
Definition at line 46 of file wallet_tests.cpp.
| void wallet::TestUnloadWallet | ( | std::shared_ptr< CWallet > && | wallet | ) |
|
static |
|
static |
| CAmount wallet::TxGetChange | ( | const CWallet & | wallet, |
| const CTransaction & | tx | ||
| ) |
Definition at line 86 of file receive.cpp.
| CAmount wallet::TxGetCredit | ( | const CWallet & | wallet, |
| const CTransaction & | tx, | ||
| const isminefilter & | filter | ||
| ) |
Definition at line 39 of file receive.cpp.
|
inlinestatic |
Try to interpret deserialized TxStateUnrecognized data as a recognized state.
Definition at line 84 of file transaction.h.
Get TxState serialized block hash. Inverse of TxStateInterpretSerialized.
Definition at line 99 of file transaction.h.
|
inlinestatic |
Get TxState serialized block index. Inverse of TxStateInterpretSerialized.
Definition at line 111 of file transaction.h.
| std::string wallet::TxStateString | ( | const T & | state | ) |
Return TxState or SyncTxState as a string for logging or debugging.
Definition at line 124 of file transaction.h.
|
static |
Definition at line 429 of file wallet.cpp.
| void wallet::UnloadWallets | ( | WalletContext & | context | ) |
|
static |
Definition at line 122 of file wallet.cpp.
|
static |
Definition at line 491 of file wallet.cpp.
|
static |
| bool wallet::VerifyWallets | ( | WalletContext & | context | ) |
| void wallet::WaitForDeleteWallet | ( | std::shared_ptr< CWallet > && | wallet | ) |
Explicitly delete the wallet.
Blocks the current thread until the wallet is destructed.
Definition at line 251 of file wallet.cpp.
|
static |
Definition at line 27 of file wallet_balance.cpp.
|
static |
|
static |
|
static |
|
static |
|
static |
Definition at line 25 of file wallet_create.cpp.
|
static |
| RPCHelpMan wallet::walletcreatefundedpsbt | ( | ) |
|
static |
| RPCHelpMan wallet::walletdisplayaddress | ( | ) |
Definition at line 625 of file addresses.cpp.
|
static |
Definition at line 28 of file wallet_ismine.cpp.
|
static |
|
static |
|
static |
| RPCHelpMan wallet::walletlock | ( | ) |
Definition at line 174 of file encrypt.cpp.
|
static |
| RPCHelpMan wallet::walletpassphrase | ( | ) |
Definition at line 11 of file encrypt.cpp.
| RPCHelpMan wallet::walletpassphrasechange | ( | ) |
Definition at line 115 of file encrypt.cpp.
| RPCHelpMan wallet::walletprocesspsbt | ( | ) |
|
static |
|
static |
Definition at line 18 of file transactions.cpp.
| const std::string wallet::ADDRESS_BCRT1_UNSPENDABLE = "bcrt1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3xueyj" |
|
constexpr |
Definition at line 16 of file migrate.cpp.
|
constexpr |
Definition at line 17 of file migrate.cpp.
|
staticconstexpr |
lower bound for randomly-chosen target change amount
Definition at line 23 of file coinselection.h.
|
staticconstexpr |
upper bound for randomly-chosen target change amount
Definition at line 25 of file coinselection.h.
|
static |
|
constexpr |
|
staticconstexpr |
Default for -avoidpartialspends.
Definition at line 25 of file coincontrol.h.
|
static |
|
static |
Definition at line 41 of file coinselection_tests.cpp.
|
static |
|
static |
|
static |
Default for -keypool.
Definition at line 64 of file scriptpubkeyman.h.
|
static |
maximum fee increase allowed to do partial spend avoidance, even for nodes with this feature disabled by default
A value of -1 disables this feature completely. A value of 0 (current default) means to attempt to do partial spend avoidance, and use its results if the fees remain unchanged A value > 0 means to do partial spend avoidance if the fee difference against a regular coin selection instance is in the range [0..value].
| const int wallet::DEFAULT_MAX_DEPTH = 9999999 |
Definition at line 22 of file coincontrol.h.
| const int wallet::DEFAULT_MIN_DEPTH = 0 |
Definition at line 21 of file coincontrol.h.
|
constexpr |
|
static |
Definition at line 16 of file coinselection_tests.cpp.
|
static |
|
static |
|
static |
|
static |
|
static |
| struct { ... } wallet::descending |
| struct { ... } wallet::descending_effval_weight |
|
staticconstexpr |
|
static |
|
static |
|
static |
|
static |
|
static |
Definition at line 228 of file wallet.cpp.
|
static |
Definition at line 230 of file wallet.cpp.
|
static |
Definition at line 229 of file wallet.cpp.
| const std::string wallet::HELP_REQUIRING_PASSPHRASE {"\nRequires wallet passphrase to be set with walletpassphrase call if wallet is encrypted.\n"} |
|
constexpr |
|
staticconstexpr |
|
static |
OutputTypes supported by the LegacyScriptPubKeyMan.
Definition at line 181 of file scriptpubkeyman.h.
|
staticconstexpr |
|
static |
Definition at line 15 of file coinselection_tests.cpp.
|
static |
Definition at line 38 of file coinselector_tests.cpp.
|
static |
Definition at line 17 of file group_outputs_tests.cpp.
|
staticconstexpr |
|
static |
|
static |
Definition at line 20 of file migrate.cpp.
|
constexpr |
Definition at line 205 of file db_tests.cpp.
|
static |
Definition at line 91 of file coinselection.cpp.
|
staticconstexpr |
Constant representing an unknown spkm creation time.
Definition at line 61 of file scriptpubkeyman.h.
|
static |
|
static |
Definition at line 27 of file wallet.cpp.
|
static |
|
static |
|
staticconstexpr |
Definition at line 27 of file sqlite.cpp.
1.9.4