DGB v8.22 merge with BTC v26.2 Fixes Part 18

Author: JaredTate

resolve_wallet_conflicts.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""
+Resolve remaining wallet.cpp conflicts for DigiByte v8.22 to Bitcoin v26.2 merge
+This script handles the systematic conflict patterns identified during manual review
+"""
+
+import re
+import sys
+
+def read_file(filename):
+    with open(filename, 'r') as f:
+        return f.read()
+
+def write_file(filename, content):
+    with open(filename, 'w') as f:
+        f.write(content)
+
+def resolve_conflicts(content):
+    """Resolve systematic conflicts based on patterns identified"""
+    
+    # First, restore the complex conflicts that were replaced with placeholders
+    # and resolve them properly based on the patterns we identified
+    
+    # Pattern replacements based on Bitcoin v26.2 improvements:
+    replacements = [
+        # Remove conflict markers and choose Bitcoin version
+        (r'<<<<<<< HEAD\n.*?\n=======\n(.*?)\n>>>>>>> bitcoin-v26-2-converted/digibyte-v26\.2-naming-conversion', r'\1'),
+        
+        # State system improvements
+        (r'wtx\.m_confirm', 'wtx.m_state'),
+        (r'confirm\.status', 'state.index()'),
+        (r'confirm\.hashBlock', 'conf->confirmed_block_hash'),
+        (r'confirm\.block_height', 'conf->confirmed_block_height'),
+        
+        # Function signature updates
+        (r'CWalletTx::Confirmation&?\s+confirm', 'TxState& state'),
+        (r'const\s+CWalletTx::Confirmation&?\s+confirm', 'const TxState& state'),
+        
+        # boost to standard library replacements
+        (r'boost::replace_all', 'ReplaceAll'),
+        
+        # Address tracking improvements
+        (r'IsAddressUsed', 'IsAddressPreviouslySpent'),
+        (r'SetAddressUsed', 'SetAddressPreviouslySpent'),
+        
+        # Mempool status improvements
+        (r'wtx\.fInMempool = chain\(\)\.isInMempool\([^)]+\);', 'RefreshMempoolStatus(wtx, chain());'),
+        
+        # Constructor changes
+        (r'std::forward_as_tuple\(this, tx\)', 'std::forward_as_tuple(tx, state)'),
+        (r'std::forward_as_tuple\(this, nullptr\)', 'std::forward_as_tuple(nullptr, TxStateInactive{})'),
+        
+        # Function parameter additions
+        (r'ComputeTimeSmart\(wtx\)', 'ComputeTimeSmart(wtx, rescanning_old_block)'),
+        (r'AddToSpends\(hash\)', 'AddToSpends(wtx, &batch)'),
+        
+        # Time function updates
+        (r'chain\(\)\.getAdjustedTime\(\)', 'GetTime()'),
+        
+        # Confirmation status checks
+        (r'wtx\.isConflicted\(\)', 'wtx.state<TxStateConflicted>()'),
+        (r'wtx\.isConfirmed\(\)', 'wtx.state<TxStateConfirmed>()'),
+        
+        # Placeholder cleanup
+        (r'# PLACEHOLDER_FOR_BITCOIN_VERSION\n', ''),
+    ]
+    
+    result = content
+    for pattern, replacement in replacements:
+        result = re.sub(pattern, replacement, result, flags=re.MULTILINE | re.DOTALL)
+    
+    return result
+
+def main():
+    if len(sys.argv) != 2:
+        print("Usage: python3 resolve_wallet_conflicts.py <wallet.cpp>")
+        sys.exit(1)
+    
+    filename = sys.argv[1]
+    print(f"Resolving conflicts in {filename}")
+    
+    content = read_file(filename)
+    resolved_content = resolve_conflicts(content)
+    write_file(filename, resolved_content)
+    
+    print("Conflicts resolved successfully")
+
+if __name__ == "__main__":
+    main()

src/wallet/bdb.cpp

@@ -256,15 +256,16 @@ class SafeDbt final
 };
 
 SafeDbt::SafeDbt()
->>>>>>> bitcoin-v26-2-converted/digibyte-v26.2-naming-conversion
 {
     m_dbt.set_flags(DB_DBT_MALLOC);
 }
 
+SafeDbt::SafeDbt(void* data, size_t size)
     : m_dbt(data, size)
 {
 }
 
+SafeDbt::~SafeDbt()
 {
     if (m_dbt.get_data() != nullptr) {
         // Clear memory, e.g. in case it was a private key
@@ -278,29 +279,21 @@ SafeDbt::SafeDbt()
     }
 }
 
+const void* SafeDbt::get_data() const
 {
     return m_dbt.get_data();
 }
 
+uint32_t SafeDbt::get_size() const
 {
     return m_dbt.get_size();
 }
 
+SafeDbt::operator Dbt*()
 {
     return &m_dbt;
 }
 
-<<<<<<< HEAD
-bool BerkeleyDatabase::Verify(bilingual_str& errorStr)
-{
-    fs::path walletDir = env->Directory();
-    fs::path file_path = walletDir / strFile;
-
-    LogPrintf("Using BerkeleyDB version %s\n", BerkeleyDatabaseVersion());
-    LogPrintf("Using wallet %s\n", fs::PathToString(file_path));
-    return {reinterpret_cast<const std::byte*>(dbt.get_data()), dbt.get_size()};
-}
-
 BerkeleyDatabase::BerkeleyDatabase(std::shared_ptr<BerkeleyEnvironment> env, fs::path filename, const DatabaseOptions& options) :
     WalletDatabase(), env(std::move(env)), m_filename(std::move(filename)), m_max_log_mb(options.max_log_mb)
 {
@@ -315,7 +308,6 @@ bool BerkeleyDatabase::Verify(bilingual_str& errorStr)
 
     LogPrintf("Using BerkeleyDB version %s\n", BerkeleyDatabaseVersion());
     LogPrintf("Using wallet %s\n", fs::PathToString(file_path));
->>>>>>> bitcoin-v26-2-converted/digibyte-v26.2-naming-conversion
 
     if (!env->Open(errorStr)) {
         return false;
@@ -345,28 +337,22 @@ void BerkeleyEnvironment::CheckpointLSN(const std::string& strFile)
     dbenv->lsn_reset(strFile.c_str(), 0);
 }
 
+Span<const std::byte> SpanFromDbt(const Dbt& dbt)
+{
+    return {reinterpret_cast<const std::byte*>(dbt.get_data()), dbt.get_size()};
+}
+
 BerkeleyDatabase::~BerkeleyDatabase()
 {
     if (env) {
         LOCK(cs_db);
-<<<<<<< HEAD
-        env->CloseDb(strFile);
-        assert(!m_db);
-        size_t erased = env->m_databases.erase(strFile);
-        assert(erased == 1);
-        env->m_fileids.erase(strFile);
-    }
-}
-
-BerkeleyBatch::BerkeleyBatch(BerkeleyDatabase& database, const bool read_only, bool fFlushOnCloseIn) : pdb(nullptr), activeTxn(nullptr), m_cursor(nullptr), m_database(database)
         size_t erased = env->m_databases.erase(m_filename);
         assert(erased == 1);
         env->m_fileids.erase(fs::PathToString(m_filename));
     }
 }
 
 BerkeleyBatch::BerkeleyBatch(BerkeleyDatabase& database, const bool read_only, bool fFlushOnCloseIn) : m_database(database)
->>>>>>> bitcoin-v26-2-converted/digibyte-v26.2-naming-conversion
 {
     database.AddRef();
     database.Open();
@@ -462,16 +448,11 @@ void BerkeleyBatch::Close()
         Flush();
 }
 
-<<<<<<< HEAD
-void BerkeleyEnvironment::CloseDb(const std::string& strFile)
+void BerkeleyEnvironment::CloseDb(const fs::path& filename)
 {
     {
         LOCK(cs_db);
         auto it = m_databases.find(filename);
-    {
-        LOCK(cs_db);
-        auto it = m_databases.find(filename);
->>>>>>> bitcoin-v26-2-converted/digibyte-v26.2-naming-conversion
         assert(it != m_databases.end());
         BerkeleyDatabase& database = it->second.get();
         if (database.m_db) {
@@ -494,19 +475,12 @@ void BerkeleyEnvironment::ReloadDbEnv()
         return true;
     });
 
-<<<<<<< HEAD
-    std::vector<std::string> filenames;
-    for (auto it : m_databases) {
-        filenames.push_back(it.first);
-    }
-    // Close the individual Db's
-    for (const fs::path& filename : filenames) {
+    std::vector<fs::path> filenames;
     for (const auto& it : m_databases) {
         filenames.push_back(it.first);
     }
     // Close the individual Db's
     for (const fs::path& filename : filenames) {
->>>>>>> bitcoin-v26-2-converted/digibyte-v26.2-naming-conversion
         CloseDb(filename);
     }
     // Reset the environment
@@ -525,7 +499,6 @@ DbTxn* BerkeleyEnvironment::TxnBegin(int flags)
     return ptxn;
 }
 
->>>>>>> bitcoin-v26-2-converted/digibyte-v26.2-naming-conversion
 bool BerkeleyDatabase::Rewrite(const char* pszSkip)
 {
     while (true) {
@@ -744,7 +717,7 @@ BerkeleyCursor::BerkeleyCursor(BerkeleyDatabase& database, const BerkeleyBatch&
     }
     // Transaction argument to cursor is only needed when using the cursor to
     // write to the database. Read-only cursors do not need a txn pointer.
-    int ret = database.m_db->cursor(batch.txn(), &m_cursor, 0);
+    int ret = database.m_db->cursor(batch.activeTxn, &m_cursor, 0);
     if (ret != 0) {
         throw std::runtime_error(STR_INTERNAL_BUG(strprintf("BDB Cursor could not be created. Returned %d", ret)));
     }
@@ -927,7 +900,6 @@ bool BerkeleyBatch::ErasePrefix(Span<const std::byte> prefix)
     return TxnCommit() && (ret == 0 || ret == DB_NOTFOUND);
 }
 
->>>>>>> bitcoin-v26-2-converted/digibyte-v26.2-naming-conversion
 void BerkeleyDatabase::AddRef()
 {
     LOCK(cs_db);