// Copyright 2014 Stellar Development Foundation and contributors. Licensed

// under the Apache License, Version 2.0. See the COPYING file at the root

// of this distribution or at http://www.apache.org/licenses/LICENSE-2.0

#include "ledger/LedgerManagerImpl.h"

#include "bucket/BucketManager.h"

#include "bucket/BucketSnapshotManager.h"

#include "bucket/HotArchiveBucketList.h"

#include "bucket/LiveBucketList.h"

#include "catchup/AssumeStateWork.h"

#include "crypto/Hex.h"

#include "crypto/KeyUtils.h"

#include "crypto/SHA.h"

#include "crypto/SecretKey.h"

#include "database/Database.h"

#include "herder/Herder.h"

#include "herder/HerderPersistence.h"

#include "herder/LedgerCloseData.h"

#include "herder/TxSetFrame.h"

#include "herder/Upgrades.h"

#include "history/HistoryManager.h"

#include "invariant/InvariantDoesNotHold.h"

#include "invariant/InvariantManager.h"

#include "ledger/FlushAndRotateMetaDebugWork.h"

#include "ledger/LedgerEntryScope.h"

#include "ledger/LedgerHeaderUtils.h"

#include "ledger/LedgerManager.h"

#include "ledger/LedgerTxn.h"

#include "ledger/LedgerTxnEntry.h"

#include "ledger/LedgerTxnHeader.h"

#include "ledger/LedgerTypeUtils.h"

#include "ledger/P23HotArchiveBug.h"

#include "ledger/SharedModuleCacheCompiler.h"

#include "main/Application.h"

#include "main/Config.h"

#include "main/ErrorMessages.h"

#include "rust/RustBridge.h"

#include "transactions/MutableTransactionResult.h"

#include "transactions/OperationFrame.h"

#include "transactions/ParallelApplyUtils.h"

#include "transactions/TransactionFrameBase.h"

#include "transactions/TransactionMeta.h"

#include "transactions/TransactionUtils.h"

#include "util/DebugMetaUtils.h"

#include "util/Decoder.h"

#include "util/Fs.h"

#include "util/GlobalChecks.h"

#include "util/JitterInjection.h"

#include "util/LogSlowExecution.h"

#include "util/Logging.h"

#include "util/MetricsRegistry.h"

#include "util/ProtocolVersion.h"

#include "util/XDRCereal.h"

#include "util/XDRStream.h"

#include "util/types.h"

#include "work/WorkScheduler.h"

#include "xdr/Stellar-ledger-entries.h"

#include "xdrpp/printer.h"

#include <cstdint>

#include <fmt/format.h>

#ifdef BUILD_TESTS

#include "test/TxTests.h"

#endif

#include "xdr/Stellar-ledger-entries.h"

#include "xdr/Stellar-ledger.h"

#include "xdr/Stellar-transaction.h"

#include "xdrpp/types.h"

#include "medida/buckets.h"

#include "medida/counter.h"

#include "medida/meter.h"

#include "medida/timer.h"

#include <Tracy.hpp>

#include "LedgerManagerImpl.h"

#include <chrono>

#include <memory>

#include <mutex>

#include <optional>

#include <regex>

#include <sstream>

#include <stdexcept>

#include <thread>

/*

The ledger module:

1) gets the externalized tx set

2) applies this set to the last closed ledger

3) sends the changed entries to the BucketList

4) saves the changed entries to SQL

5) saves the ledger hash and header to SQL

6) sends the new ledger hash and the tx set to the history

7) sends the new ledger hash and header to the Herder

catching up to network:

1) Wait for SCP to tell us what the network is on now

2) Pull history log or static deltas from history archive

3) Replay or force-apply deltas, depending on catchup mode

*/

using namespace std;

namespace stellar

{

uint32_t const LedgerManager::GENESIS_LEDGER_SEQ = 1;

uint32_t const LedgerManager::GENESIS_LEDGER_VERSION = 0;

uint32_t const LedgerManager::GENESIS_LEDGER_BASE_FEE = 100;

uint32_t const LedgerManager::GENESIS_LEDGER_BASE_RESERVE = 100000000;

uint32_t const LedgerManager::GENESIS_LEDGER_MAX_TX_SIZE = 100;

int64_t const LedgerManager::GENESIS_LEDGER_TOTAL_COINS = 1000000000000000000;

namespace

{

std::vector<uint32_t>

getModuleCacheProtocols()

{

std::vector<uint32_t> ledgerVersions;

for (uint32_t i = (uint32_t)REUSABLE_SOROBAN_MODULE_CACHE_PROTOCOL_VERSION;

i <= Config::CURRENT_LEDGER_PROTOCOL_VERSION; i++)

{

ledgerVersions.push_back(i);

}

auto extra = getenv("SOROBAN_TEST_EXTRA_PROTOCOL");

if (extra)

{

uint32_t proto = static_cast<uint32_t>(atoi(extra));

if (proto > 0)

{

ledgerVersions.push_back(proto);

}

}

return ledgerVersions;

}

void

setLedgerTxnHeader(LedgerHeader const& lh, Application& app)

{

LedgerTxn ltx(app.getLedgerTxnRoot());

ltx.loadHeader().current() = lh;

ltx.commit();

}

bool

mergeOpInTx(std::vector<Operation> const& ops)

{

for (auto const& op : ops)

{

if (op.body.type() == ACCOUNT_MERGE)

{

return true;

}

}

return false;

}

}

std::unique_ptr<LedgerManager>

LedgerManager::create(Application& app)

{

return std::make_unique<LedgerManagerImpl>(app);

}

std::string

LedgerManager::ledgerAbbrev(LedgerHeader const& header)

{

return ledgerAbbrev(header, xdrSha256(header));

}

std::string

LedgerManager::ledgerAbbrev(uint32_t seq, uint256 const& hash)

{

std::ostringstream oss;

oss << "[seq=" << seq << ", hash=" << hexAbbrev(hash) << "]";

return oss.str();

}

std::string

LedgerManager::ledgerAbbrev(LedgerHeader const& header, uint256 const& hash)

{

return ledgerAbbrev(header.ledgerSeq, hash);

}

std::string

LedgerManager::ledgerAbbrev(LedgerHeaderHistoryEntry const& he)

{

return ledgerAbbrev(he.header, he.hash);

}

LedgerManagerImpl::LedgerApplyMetrics::LedgerApplyMetrics(

MetricsRegistry& registry)

: mSorobanMetrics(registry)

, mTransactionApply(registry.NewTimer({"ledger", "transaction", "apply"}))

, mTotalTxApply(registry.NewTimer({"ledger", "transaction", "total-apply"}))

, mTransactionCount(

registry.NewHistogram({"ledger", "transaction", "count"}))

, mOperationCount(registry.NewHistogram({"ledger", "operation", "count"}))

, mPrefetchHitRate(

registry.NewHistogram({"ledger", "prefetch", "hit-rate"}))

, mLedgerClose(registry.NewTimer({"ledger", "ledger", "close"}))

, mLedgerAgeClosed(registry.NewBuckets({"ledger", "age", "closed"},

{5000.0, 7000.0, 10000.0, 20000.0}))

, mLedgerAge(registry.NewCounter({"ledger", "age", "current-seconds"}))

, mTransactionApplySucceeded(

registry.NewCounter({"ledger", "apply", "success"}))

, mTransactionApplyFailed(

registry.NewCounter({"ledger", "apply", "failure"}))

, mSorobanTransactionApplySucceeded(

registry.NewCounter({"ledger", "apply-soroban", "success"}))

, mSorobanTransactionApplyFailed(

registry.NewCounter({"ledger", "apply-soroban", "failure"}))

, mMaxClustersPerLedger(

registry.NewCounter({"ledger", "apply-soroban", "max-clusters"}))

, mStagesPerLedger(

registry.NewCounter({"ledger", "apply-soroban", "stages"}))

, mMetaStreamBytes(

registry.NewMeter({"ledger", "metastream", "bytes"}, "byte"))

, mMetaStreamWriteTime(registry.NewTimer({"ledger", "metastream", "write"}))

{

}

LedgerManagerImpl::ApplyState::ApplyState(Application& app)

: mMetrics(app.getMetrics())

, mAppConnector(app.getAppConnector())

, mModuleCache(::rust_bridge::new_module_cache())

, mModuleCacheProtocols(getModuleCacheProtocols())

, mNumCompilationThreads(app.getConfig().COMPILATION_THREADS)

{

}

LedgerManagerImpl::LedgerApplyMetrics&

LedgerManagerImpl::ApplyState::getMetrics()

{

return mMetrics;

}

InMemorySorobanState const&

LedgerManagerImpl::ApplyState::getInMemorySorobanState() const

{

releaseAssert(mPhase == Phase::APPLYING ||

mPhase == Phase::SETTING_UP_STATE ||

mPhase == Phase::READY_TO_APPLY);

return mInMemorySorobanState;

}

#ifdef BUILD_TESTS

InMemorySorobanState&

LedgerManagerImpl::ApplyState::getInMemorySorobanStateForTesting()

{

return mInMemorySorobanState;

}

::rust::Box<rust_bridge::SorobanModuleCache> const&

LedgerManagerImpl::ApplyState::getModuleCacheForTesting()

{

return mModuleCache;

}

uint64_t

LedgerManagerImpl::ApplyState::getSorobanInMemoryStateSizeForTesting() const

{

return mInMemorySorobanState.getSize();

}

#endif

void

LedgerManagerImpl::ApplyState::threadInvariant() const

{

if (mAppConnector.getConfig().parallelLedgerClose())

{

releaseAssert(threadIsMain() || mAppConnector.threadIsType(

Application::ThreadType::APPLY));

}

else

{

releaseAssert(threadIsMain());

}

}

::rust::Box<rust_bridge::SorobanModuleCache> const&

LedgerManagerImpl::ApplyState::getModuleCache() const

{

releaseAssert(mPhase == Phase::APPLYING);

return mModuleCache;

}

void

LedgerManagerImpl::markApplyStateReset()

{

mApplyState.resetToSetupPhase();

}

bool

LedgerManagerImpl::ApplyState::isCompilationRunning() const

{

return static_cast<bool>(mCompiler);

}

void

LedgerManagerImpl::ApplyState::updateInMemorySorobanState(

std::vector<LedgerEntry> const& initEntries,

std::vector<LedgerEntry> const& liveEntries,

std::vector<LedgerKey> const& deadEntries, LedgerHeader const& lh,

std::optional<SorobanNetworkConfig const> const& sorobanConfig)

{

assertWritablePhase();

mInMemorySorobanState.updateState(initEntries, liveEntries, deadEntries, lh,

sorobanConfig,

getMetrics().mSorobanMetrics);

}

uint64_t

LedgerManagerImpl::ApplyState::getSorobanInMemoryStateSize() const

{

// This assert is not strictly necessary, but we don't really want to

// access the state size outside of the snapshotting process during the

// LEDGER_CLOSE or SETTING_UP_STATE phase.

assertWritablePhase();

return mInMemorySorobanState.getSize();

}

void

LedgerManagerImpl::ApplyState::manuallyAdvanceLedgerHeader(

LedgerHeader const& lh)

{

assertCommittingPhase();

mInMemorySorobanState.manuallyAdvanceLedgerHeader(lh);

}

LedgerManagerImpl::LedgerManagerImpl(Application& app)

: mApp(app)

, mApplyState(app)

, mLastClosedLedgerState(std::make_shared<CompleteConstLedgerState>(

nullptr, nullptr, LedgerHeaderHistoryEntry(), HistoryArchiveState()))

, mLastClose(mApp.getClock().now())

, mCatchupDuration(

app.getMetrics().NewTimer({"ledger", "catchup", "duration"}))

, mState(LM_BOOTING_STATE)

{

setupLedgerCloseMetaStream();

}

void

LedgerManagerImpl::moveToSynced()

{

setState(LM_SYNCED_STATE);

}

void

LedgerManagerImpl::beginApply()

{

releaseAssert(threadIsMain());

// Go into "applying" state, this will prevent catchup from starting

mCurrentlyApplyingLedger = true;

}

void

LedgerManagerImpl::setState(State s)

{

releaseAssert(threadIsMain());

if (s != getState())

{

std::string oldState = getStateHuman();

mState = s;

mApp.syncOwnMetrics();

CLOG_INFO(Ledger, "Changing state {} -> {}", oldState, getStateHuman());

if (mState != LM_CATCHING_UP_STATE)

{

mApp.getLedgerApplyManager().logAndUpdateCatchupStatus(true);

}

}

}

LedgerManager::State

LedgerManagerImpl::getState() const

{

return mState;

}

std::string

LedgerManagerImpl::getStateHuman() const

{

static std::array<char const*, LM_NUM_STATE> stateStrings = std::array{

"LM_BOOTING_STATE", "LM_SYNCED_STATE", "LM_CATCHING_UP_STATE"};

return std::string(stateStrings[getState()]);

}

LedgerHeader

LedgerManager::genesisLedger()

{

LedgerHeader result;

// all fields are initialized by default to 0

// set the ones that are not 0

result.ledgerVersion = GENESIS_LEDGER_VERSION;

result.baseFee = GENESIS_LEDGER_BASE_FEE;

result.baseReserve = GENESIS_LEDGER_BASE_RESERVE;

result.maxTxSetSize = GENESIS_LEDGER_MAX_TX_SIZE;

result.totalCoins = GENESIS_LEDGER_TOTAL_COINS;

result.ledgerSeq = GENESIS_LEDGER_SEQ;

return result;

}

void

LedgerManagerImpl::startNewLedger(LedgerHeader const& genesisLedger)

{

mApplyState.assertSetupPhase();

auto ledgerTime = mApplyState.getMetrics().mLedgerClose.TimeScope();

SecretKey skey = SecretKey::fromSeed(mApp.getNetworkID());

LedgerTxn ltx(mApp.getLedgerTxnRoot(), false);

auto const& cfg = mApp.getConfig();

ltx.loadHeader().current() = genesisLedger;

if (cfg.USE_CONFIG_FOR_GENESIS)

{

SorobanNetworkConfig::initializeGenesisLedgerForTesting(

cfg.TESTING_UPGRADE_LEDGER_PROTOCOL_VERSION, ltx, mApp);

}

LedgerEntry rootEntry;

rootEntry.lastModifiedLedgerSeq = 1;

rootEntry.data.type(ACCOUNT);

auto& rootAccount = rootEntry.data.account();

rootAccount.accountID = skey.getPublicKey();

rootAccount.thresholds[0] = 1;

rootAccount.balance = genesisLedger.totalCoins;

#ifdef BUILD_TESTS

// If test account creation is enabled, create additional accounts

if (cfg.GENESIS_TEST_ACCOUNT_COUNT > 0)

{

CLOG_INFO(Ledger, "Creating {} test accounts for genesis ledger",

cfg.GENESIS_TEST_ACCOUNT_COUNT);

// Split totalCoins evenly among all accounts (root + test accounts)

uint32_t totalAccounts =

cfg.GENESIS_TEST_ACCOUNT_COUNT + 1; // +1 for root account

int64_t baseAccountBalance = genesisLedger.totalCoins / totalAccounts;

int64_t remainder = genesisLedger.totalCoins % totalAccounts;

// Set root account balance to equal share plus any remainder

// to ensure we don't lose any coins due to rounding

rootAccount.balance = baseAccountBalance + remainder;

// Create accounts using similar approach as TxGenerator::createAccounts

for (uint32_t i = 0; i < cfg.GENESIS_TEST_ACCOUNT_COUNT; i++)

{

auto name = "TestAccount-" + std::to_string(i);

auto account = txtest::getAccount(name.c_str());

LedgerEntry testEntry;

testEntry.lastModifiedLedgerSeq = 1;

testEntry.data.type(ACCOUNT);

auto& testAccount = testEntry.data.account();

testAccount.accountID = account.getPublicKey();

testAccount.thresholds[0] = 1;

testAccount.balance = baseAccountBalance;

ltx.create(testEntry);

}

}

#endif

ltx.create(rootEntry);

CLOG_INFO(Ledger, "Established genesis ledger, closing");

CLOG_INFO(Ledger, "Root account: {}", skey.getStrKeyPublic());

CLOG_INFO(Ledger, "Root account seed: {}", skey.getStrKeySeed().value);

auto& appConnector = mApp.getAppConnector();

auto output = sealLedgerTxnAndStoreInBucketsAndDB(

appConnector.copySearchableLiveBucketListSnapshot(),

appConnector.copySearchableHotArchiveBucketListSnapshot(), ltx,

/*ledgerCloseMeta*/ nullptr,

/*initialLedgerVers*/ 0);

advanceLastClosedLedgerState(output);

ltx.commit();

// Note: We're still not done with LedgerManager initialization here, as we

// still need to call setLastClosedLedger to properly initialize

// LedgerManager after creating the genesis ledger.

}

void

LedgerManagerImpl::startNewLedger()

{

auto ledger = genesisLedger();

auto const& cfg = mApp.getConfig();

if (cfg.USE_CONFIG_FOR_GENESIS)

{

ledger.ledgerVersion = cfg.TESTING_UPGRADE_LEDGER_PROTOCOL_VERSION;

ledger.baseFee = cfg.TESTING_UPGRADE_DESIRED_FEE;

ledger.baseReserve = cfg.TESTING_UPGRADE_RESERVE;

ledger.maxTxSetSize = cfg.TESTING_UPGRADE_MAX_TX_SET_SIZE;

}

startNewLedger(ledger);

}

void

LedgerManagerImpl::loadLastKnownLedgerInternal(bool skipBuildingFullState)

{

ZoneScoped;

mApplyState.assertSetupPhase();

// Step 1. Load LCL state from the DB

HistoryArchiveState has;

has.fromString(mApp.getPersistentState().getState(

PersistentState::kHistoryArchiveState,

mApp.getDatabase().getSession()));

// Step 2. Restore LedgerHeader from storestate

std::optional<LedgerHeader> latestLedgerHeader;

std::string headerEncoded = mApp.getPersistentState().getState(

PersistentState::kLastClosedLedgerHeader,

mApp.getDatabase().getSession());

if (headerEncoded.empty())

{

throw std::runtime_error("Could not load ledger header from database");

}

auto currentLedger = std::make_shared<LedgerHeader>(

LedgerHeaderUtils::decodeFromData(headerEncoded));

if (currentLedger->ledgerSeq != has.currentLedger)

{

throw std::runtime_error("Invalid database state: last known "

"ledger does not agree with HAS");

}

CLOG_INFO(Ledger, "Loaded LCL header from database: {}",

ledgerAbbrev(*currentLedger));

setLedgerTxnHeader(*currentLedger, mApp);

latestLedgerHeader = *currentLedger;

releaseAssert(latestLedgerHeader.has_value());

auto missing = mApp.getBucketManager().checkForMissingBucketsFiles(has);

auto pubmissing =

mApp.getHistoryManager().getMissingBucketsReferencedByPublishQueue();

missing.insert(missing.end(), pubmissing.begin(), pubmissing.end());

if (!missing.empty())

{

CLOG_ERROR(Ledger, "{} buckets are missing from bucket directory '{}'",

missing.size(), mApp.getBucketManager().getBucketDir());

throw std::runtime_error("Bucket directory is corrupt");

}

// Only restart merges in full startup mode. Many modes in core

// (standalone offline commands, in-memory setup) do not need to

// spin up expensive merge processes.

auto assumeStateWork = mApp.getWorkScheduler().executeWork<AssumeStateWork>(

has, latestLedgerHeader->ledgerVersion,

/* restartMerges */ !skipBuildingFullState);

if (assumeStateWork->getState() == BasicWork::State::WORK_SUCCESS)

{

CLOG_INFO(Ledger, "Assumed bucket-state for LCL: {}",

ledgerAbbrev(*latestLedgerHeader));

}

else

{

// Work should only fail during graceful shutdown

releaseAssertOrThrow(mApp.isStopping());

}

// Step 4. Restore LedgerManager's LCL state

advanceLastClosedLedgerState(

advanceBucketListSnapshotAndMakeLedgerState(*latestLedgerHeader, has));

// Maybe truncate checkpoint files if we're restarting after a crash

// in applyLedger (in which case any modifications to the ledger state have

// been rolled back)

mApp.getHistoryManager().restoreCheckpoint(latestLedgerHeader->ledgerSeq);

// Prime module cache with LCL state, not apply-state. This is acceptable

// here because we just started and there is no apply-state yet and no apply

// thread to hold such state.

auto const& snapshot = mLastClosedLedgerState->getBucketSnapshot();

if (!skipBuildingFullState)

{

mApplyState.compileAllContractsInLedger(

snapshot, latestLedgerHeader->ledgerVersion);

mApplyState.populateInMemorySorobanState(

snapshot, latestLedgerHeader->ledgerVersion);

}

if (!skipBuildingFullState)

{

maybeRunSnapshotInvariantFromLedgerState(

mLastClosedLedgerState, maybeCopySorobanStateForInvariant(),

/* runInParallel */ false);

}

mApplyState.markEndOfSetupPhase();

}

void

LedgerManagerImpl::loadLastKnownLedger()

{

loadLastKnownLedgerInternal(/* skipBuildingFullState */ false);

}

void

LedgerManagerImpl::partiallyLoadLastKnownLedgerForUtils()

{

loadLastKnownLedgerInternal(/* skipBuildingFullState */ true);

}

Database&

LedgerManagerImpl::getDatabase()

{

return mApp.getDatabase();

}

uint32_t

LedgerManagerImpl::getLastMaxTxSetSize() const

{

releaseAssert(threadIsMain());

releaseAssert(mLastClosedLedgerState);

return mLastClosedLedgerState->getLastClosedLedgerHeader()

.header.maxTxSetSize;

}

uint32_t

LedgerManagerImpl::getLastMaxTxSetSizeOps() const

{

releaseAssert(threadIsMain());

releaseAssert(mLastClosedLedgerState);

auto n =

mLastClosedLedgerState->getLastClosedLedgerHeader().header.maxTxSetSize;

return protocolVersionStartsFrom(

mLastClosedLedgerState->getLastClosedLedgerHeader()

.header.ledgerVersion,

ProtocolVersion::V_11)

? n

: (n * MAX_OPS_PER_TX);

}

Resource

LedgerManagerImpl::maxLedgerResources(bool isSoroban)

{

ZoneScoped;

if (isSoroban)

{

return getLastClosedSorobanNetworkConfig().maxLedgerResources();

}

else

{

uint32_t maxOpsLedger = getLastMaxTxSetSizeOps();

return Resource(maxOpsLedger);

}

}

Resource

LedgerManagerImpl::maxSorobanTransactionResources()

{

ZoneScoped;

auto const& conf =

mApp.getLedgerManager().getLastClosedSorobanNetworkConfig();

int64_t const opCount = 1;

std::vector<int64_t> limits = {opCount,

conf.txMaxInstructions(),

conf.txMaxSizeBytes(),

conf.txMaxDiskReadBytes(),

conf.txMaxWriteBytes(),

conf.txMaxDiskReadEntries(),

conf.txMaxWriteLedgerEntries()};

return Resource(limits);

}

int64_t

LedgerManagerImpl::getLastMinBalance(uint32_t ownerCount) const

{

releaseAssert(threadIsMain());

releaseAssert(mLastClosedLedgerState);

auto const& lh = mLastClosedLedgerState->getLastClosedLedgerHeader().header;

if (protocolVersionIsBefore(lh.ledgerVersion, ProtocolVersion::V_9))

return (2 + ownerCount) * lh.baseReserve;

else

return (2LL + ownerCount) * int64_t(lh.baseReserve);

}

uint32_t

LedgerManagerImpl::getLastReserve() const

{

releaseAssert(threadIsMain());

releaseAssert(mLastClosedLedgerState);

return mLastClosedLedgerState->getLastClosedLedgerHeader()

.header.baseReserve;

}

uint32_t

LedgerManagerImpl::getLastTxFee() const

{

releaseAssert(threadIsMain());

releaseAssert(mLastClosedLedgerState);

return mLastClosedLedgerState->getLastClosedLedgerHeader().header.baseFee;

}

LedgerHeaderHistoryEntry const&

LedgerManagerImpl::getLastClosedLedgerHeader() const

{

releaseAssert(threadIsMain());

releaseAssert(mLastClosedLedgerState);

return mLastClosedLedgerState->getLastClosedLedgerHeader();

}

HistoryArchiveState

LedgerManagerImpl::getLastClosedLedgerHAS() const

{

releaseAssert(threadIsMain());

releaseAssert(mLastClosedLedgerState);

return mLastClosedLedgerState->getLastClosedHistoryArchiveState();

}

uint32_t

LedgerManagerImpl::getLastClosedLedgerNum() const

{

releaseAssert(threadIsMain());

releaseAssert(mLastClosedLedgerState);

return mLastClosedLedgerState->getLastClosedLedgerHeader().header.ledgerSeq;

}

std::shared_ptr<InMemorySorobanState const>

LedgerManagerImpl::maybeCopySorobanStateForInvariant()

{

std::shared_ptr<InMemorySorobanState const> inMemorySnapshotForInvariant =

nullptr;

if (mApp.getInvariantManager().shouldRunInvariantSnapshot())

{

// The in memory state copy is expensive, so we need to mark

// that start of the invariant scan here, not in the callback, to ensure

// we don't trigger a race condition that creates two copies.

mApp.getInvariantManager().markStartOfInvariantSnapshot();

inMemorySnapshotForInvariant =

std::make_shared<InMemorySorobanState const>(

mApplyState.getInMemorySorobanState());

}

return inMemorySnapshotForInvariant;

}

void

LedgerManagerImpl::maybeRunSnapshotInvariantFromLedgerState(

CompleteConstLedgerStatePtr const& ledgerState,

std::shared_ptr<InMemorySorobanState const> inMemorySnapshotForInvariant,

bool runInParallel) const

{

releaseAssert(threadIsMain());

if (!inMemorySnapshotForInvariant ||

!mApp.getConfig().INVARIANT_EXTRA_CHECKS || mApp.isStopping())

{

return;

}

// Verify consistency of all snapshot state.

auto ledgerSeq = ledgerState->getLastClosedLedgerHeader().header.ledgerSeq;

inMemorySnapshotForInvariant->assertLastClosedLedger(ledgerSeq);

// Copy snapshots from ledgerState to ensure consistency with the

// in-memory Soroban state

auto liveSnapshotCopy =

BucketSnapshotManager::copySearchableLiveBucketListSnapshot(

ledgerState->getBucketSnapshot(), mApp.getMetrics());

auto hotArchiveSnapshotCopy =

BucketSnapshotManager::copySearchableHotArchiveBucketListSnapshot(

ledgerState->getHotArchiveSnapshot(), mApp.getMetrics());

releaseAssertOrThrow(liveSnapshotCopy->getLedgerSeq() == ledgerSeq);

releaseAssertOrThrow(hotArchiveSnapshotCopy->getLedgerSeq() == ledgerSeq);

// Note: No race condition acquiring app by reference, as all worker

// threads are joined before application destruction.

auto cb = [liveSnapshot = liveSnapshotCopy,

hotArchiveSnapshot = hotArchiveSnapshotCopy, &app = mApp,

inMemorySnapshotForInvariant]() {

app.getInvariantManager().runStateSnapshotInvariant(

liveSnapshot, hotArchiveSnapshot, *inMemorySnapshotForInvariant,

[&app]() { return app.isStopping(); });

};

if (runInParallel)

{

mApp.postOnBackgroundThread(std::move(cb), "checkSnapshot");

}

else

{

cb();

}

}

SorobanNetworkConfig const&

LedgerManagerImpl::getLastClosedSorobanNetworkConfig() const

{

releaseAssert(threadIsMain());

releaseAssert(hasLastClosedSorobanNetworkConfig());

return mLastClosedLedgerState->getSorobanConfig();

}

bool

LedgerManagerImpl::hasLastClosedSorobanNetworkConfig() const

{

releaseAssert(threadIsMain());

releaseAssert(mLastClosedLedgerState);

return mLastClosedLedgerState->hasSorobanConfig();

}

std::chrono::milliseconds

LedgerManagerImpl::getExpectedLedgerCloseTime() const

{

releaseAssert(threadIsMain());

auto const& cfg = mApp.getConfig();

if (auto overrideOp = cfg.getExpectedLedgerCloseTimeTestingOverride();

overrideOp.has_value())

{

return *overrideOp;

}

auto const& lcl = getLastClosedLedgerHeader();

if (protocolVersionStartsFrom(lcl.header.ledgerVersion,

ProtocolVersion::V_23))

{

auto const& networkConfig = getLastClosedSorobanNetworkConfig();

return std::chrono::milliseconds(

networkConfig.ledgerTargetCloseTimeMilliseconds());

}

return Herder::TARGET_LEDGER_CLOSE_TIME_BEFORE_PROTOCOL_VERSION_23_MS;

}

#ifdef BUILD_TESTS

std::vector<TransactionMetaFrame> const&

LedgerManagerImpl::getLastClosedLedgerTxMeta()

{

return mLastLedgerTxMeta;

}

std::optional<LedgerCloseMetaFrame> const&

LedgerManagerImpl::getLastClosedLedgerCloseMeta()

{

return mLastLedgerCloseMeta;

}

void

LedgerManagerImpl::storeCurrentLedgerForTest(LedgerHeader const& header)

{

storePersistentStateAndLedgerHeaderInDB(header, true);

}

InMemorySorobanState const&

LedgerManagerImpl::getInMemorySorobanStateForTesting()

{

return mApplyState.getInMemorySorobanStateForTesting();

}

CompleteConstLedgerStatePtr

LedgerManagerImpl::getLastClosedLedgerStateForTesting()

{

return mLastClosedLedgerState;

}

void

LedgerManagerImpl::rebuildInMemorySorobanStateForTesting(uint32_t ledgerVersion)

{

mApplyState.resetToSetupPhase();

mApplyState.getInMemorySorobanStateForTesting().clearForTesting();

mApplyState.populateInMemorySorobanState(

mLastClosedLedgerState->getBucketSnapshot(), ledgerVersion);

mApplyState.markEndOfSetupPhase();

}

::rust::Box<rust_bridge::SorobanModuleCache>

LedgerManagerImpl::getModuleCacheForTesting()

{

releaseAssert(!mApplyState.isCompilationRunning());

return mApplyState.getModuleCacheForTesting()->shallow_clone();

}

uint64_t

LedgerManagerImpl::getSorobanInMemoryStateSizeForTesting()

{

return mApplyState.getSorobanInMemoryStateSizeForTesting();

}

#endif

SorobanMetrics&

LedgerManagerImpl::getSorobanMetrics()

{

return mApplyState.getMetrics().mSorobanMetrics;

}

std::unique_ptr<LedgerTxnRoot>

LedgerManagerImpl::createLedgerTxnRoot(Application& app, size_t entryCacheSize,

size_t prefetchBatchSize

#ifdef BEST_OFFER_DEBUGGING

,

bool bestOfferDebuggingEnabled

#endif

)

{

return std::make_unique<LedgerTxnRoot>(

app, mApplyState.getInMemorySorobanState(), entryCacheSize,

prefetchBatchSize

#ifdef BEST_OFFER_DEBUGGING

,

bestOfferDebuggingEnabled

#endif

);

}

::rust::Box<rust_bridge::SorobanModuleCache>

LedgerManagerImpl::getModuleCache()

{

// There should not be any compilation running when

// anyone calls this function. It is accessed from

// transactions during apply only.

releaseAssert(!mApplyState.isCompilationRunning());

return mApplyState.getModuleCache()->shallow_clone();

}

void

LedgerManagerImpl::handleUpgradeAffectingSorobanInMemoryStateSize(

AbstractLedgerTxn& upgradeLtx)

{

mApplyState.handleUpgradeAffectingSorobanInMemoryStateSize(upgradeLtx);

}

void

LedgerManagerImpl::ApplyState::handleUpgradeAffectingSorobanInMemoryStateSize(

AbstractLedgerTxn& upgradeLtx)

{

assertCommittingPhase();

// Load the current network from the ledger. It might be in some

// intermediate state, which is fine, because we call this only after

// a relevant section has been upgraded and all the remaining sections

// are not relevant for the size computation.

auto currentConfig = SorobanNetworkConfig::loadFromLedger(upgradeLtx);

auto upgradeLedgerVersion = upgradeLtx.loadHeader().current().ledgerVersion;

mInMemorySorobanState.recomputeContractCodeSize(currentConfig,

upgradeLedgerVersion);

// We need to record the updated size, but only when we're in p23+, as

// before that we store BL size instead.

if (protocolVersionStartsFrom(upgradeLedgerVersion, ProtocolVersion::V_23))

{

SorobanNetworkConfig::updateRecomputedSorobanStateSize(

mInMemorySorobanState.getSize(), upgradeLtx);

}

}

void

LedgerManagerImpl::ApplyState::finishPendingCompilation()

{

assertWritablePhase();

releaseAssert(mCompiler);

auto newCache = mCompiler->wait();

getMetrics().mSorobanMetrics.mModuleCacheRebuildBytes.set_count(

(int64)mCompiler->getBytesCompiled());

getMetrics().mSorobanMetrics.mModuleCacheNumEntries.set_count(

(int64)mCompiler->getContractsCompiled());

getMetrics().mSorobanMetrics.mModuleCacheRebuildTime.Update(

mCompiler->getCompileTime());

mModuleCache.swap(newCache);

mCompiler.reset();

}

void

LedgerManagerImpl::ApplyState::compileAllContractsInLedger(

SearchableSnapshotConstPtr snap, uint32_t minLedgerVersion)

{

assertSetupPhase();

startCompilingAllContracts(snap, minLedgerVersion);

finishPendingCompilation();

}

void

LedgerManagerImpl::ApplyState::populateInMemorySorobanState(

SearchableSnapshotConstPtr snap, uint32_t ledgerVersion)

{

assertSetupPhase();

mInMemorySorobanState.initializeStateFromSnapshot(snap, ledgerVersion);

}

void

LedgerManagerImpl::ApplyState::assertCommittingPhase() const

{

threadInvariant();

releaseAssert(mPhase == Phase::COMMITTING);

}

void

LedgerManagerImpl::ApplyState::markStartOfApplying()

{

threadInvariant();