//! critical section to protect the inner data structures

mutable RecursiveMutex cs;

//! Serialization versions.

enum Format : uint8_t {

V0_HISTORICAL = 0, //!< historic format, before commit e6b343d88

V1_DETERMINISTIC = 1, //!< for pre-asmap files

V2_ASMAP = 2, //!< for files including asmap version

V3_BIP155 = 3, //!< same as V2_ASMAP plus addresses are in BIP155 format

};

//! The maximum format this software knows it can unserialize. Also, we always serialize

//! in this format.

//! The format (first byte in the serialized stream) can be higher than this and

//! still this software may be able to unserialize the file - if the second byte

//! (see `lowest_compatible` in `Unserialize()`) is less or equal to this.

static constexpr Format FILE_FORMAT = Format::V3_BIP155;

//! The initial value of a field that is incremented every time an incompatible format

//! change is made (such that old software versions would not be able to parse and

//! understand the new file format). This is 32 because we overtook the "key size"

//! field which was 32 historically.

//! @note Don't increment this. Increment `lowest_compatible` in `Serialize()` instead.

static constexpr uint8_t INCOMPATIBILITY_BASE = 32;

//! last used nId

int nIdCount GUARDED_BY(cs);

//! table with information about all nIds

std::map<int, CAddrInfo> mapInfo GUARDED_BY(cs);

//! find an nId based on its network address

std::map<CNetAddr, int> mapAddr GUARDED_BY(cs);

//! randomly-ordered vector of all nIds

std::vector<int> vRandom GUARDED_BY(cs);

// number of "tried" entries

int nTried GUARDED_BY(cs);

//! list of "tried" buckets

int vvTried[ADDRMAN_TRIED_BUCKET_COUNT][ADDRMAN_BUCKET_SIZE] GUARDED_BY(cs);

//! number of (unique) "new" entries

int nNew GUARDED_BY(cs);

//! list of "new" buckets

int vvNew[ADDRMAN_NEW_BUCKET_COUNT][ADDRMAN_BUCKET_SIZE] GUARDED_BY(cs);

//! last time Good was called (memory only)

int64_t nLastGood GUARDED_BY(cs);

//! Holds addrs inserted into tried table that collide with existing entries. Test-before-evict discipline used to resolve these collisions.

std::set<int> m_tried_collisions;

//! secret key to randomize bucket select with

uint256 nKey;

//! Source of random numbers for randomization in inner loops

FastRandomContext insecure_rand;

//! Find an entry.

CAddrInfo* Find(const CNetAddr& addr, int *pnId = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs);

//! find an entry, creating it if necessary.

//! nTime and nServices of the found node are updated, if necessary.

CAddrInfo* Create(const CAddress &addr, const CNetAddr &addrSource, int *pnId = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs);

//! Swap two elements in vRandom.

void SwapRandom(unsigned int nRandomPos1, unsigned int nRandomPos2) EXCLUSIVE_LOCKS_REQUIRED(cs);

//! Move an entry from the "new" table(s) to the "tried" table

void MakeTried(CAddrInfo& info, int nId) EXCLUSIVE_LOCKS_REQUIRED(cs);

//! Delete an entry. It must not be in tried, and have refcount 0.

void Delete(int nId) EXCLUSIVE_LOCKS_REQUIRED(cs);

//! Clear a position in a "new" table. This is the only place where entries are actually deleted.

void ClearNew(int nUBucket, int nUBucketPos) EXCLUSIVE_LOCKS_REQUIRED(cs);

//! Mark an entry "good", possibly moving it from "new" to "tried".

void Good_(const CService &addr, bool test_before_evict, int64_t time) EXCLUSIVE_LOCKS_REQUIRED(cs);

//! Add an entry to the "new" table.

bool Add_(const CAddress &addr, const CNetAddr& source, int64_t nTimePenalty) EXCLUSIVE_LOCKS_REQUIRED(cs);

//! Mark an entry as attempted to connect.

void Attempt_(const CService &addr, bool fCountFailure, int64_t nTime) EXCLUSIVE_LOCKS_REQUIRED(cs);

//! Select an address to connect to, if newOnly is set to true, only the new table is selected from.

CAddrInfo Select_(bool newOnly) EXCLUSIVE_LOCKS_REQUIRED(cs);

//! See if any to-be-evicted tried table entries have been tested and if so resolve the collisions.

void ResolveCollisions_() EXCLUSIVE_LOCKS_REQUIRED(cs);

//! Return a random to-be-evicted tried table address.

CAddrInfo SelectTriedCollision_() EXCLUSIVE_LOCKS_REQUIRED(cs);

#ifdef DEBUG_ADDRMAN

//! Perform consistency check. Returns an error code or zero.

int Check_() EXCLUSIVE_LOCKS_REQUIRED(cs);

#endif

/**

void GetAddr_(std::vector<CAddress>& vAddr, size_t max_addresses, size_t max_pct, std::optional<Network> network) EXCLUSIVE_LOCKS_REQUIRED(cs);

/** We have successfully connected to this peer. Calling this function

void Connected_(const CService& addr, int64_t nTime) EXCLUSIVE_LOCKS_REQUIRED(cs);

//! Update an entry's service bits.

void SetServices_(const CService &addr, ServiceFlags nServices) EXCLUSIVE_LOCKS_REQUIRED(cs);

friend class CAddrManCorrupted;

friend class CAddrManDeterministic;

friend class CAddrManSerializationMock;

friend class CAddrManTest;