sgns::TransactionManager¶

#include <TransactionManager.hpp>

Inherits from std::enable_shared_from_this< TransactionManager >

Public Types¶

	Name
enum class uint8_t	State { CREATING = 0, INITIALIZING, SYNCING, READY} State of the Transaction Manager.
enum class uint8_t	TransactionStatus { CREATED, SENDING, CONFIRMED, VERIFYING, FAILED, INVALID} Status of a transaction.
using std::pair< std::shared_ptr< IGeniusTransactions >, std::optional< std::vector< uint8_t > > >	TransactionPair
using std::vector< TransactionPair >	TransactionBatch
using std::pair< TransactionBatch, std::optional< std::shared_ptr< crdt::AtomicTransaction > > >	TransactionItem
using std::function< void(const State &previous, const State &current)>	StateChangeCallback

Public Functions¶

	Name
std::shared_ptr< TransactionManager >	New(std::shared_ptr< crdt::GlobalDB > processing_db, std::shared_ptr< boost::asio::io_context > ctx, UTXOManager & utxo_manager, std::shared_ptr< GeniusAccount > account, std::shared_ptr< crypto::Hasher > hasher, bool full_node =false, std::chrono::milliseconds timestamp_tolerance =std::chrono::milliseconds(0), std::chrono::milliseconds mutability_window =std::chrono::milliseconds(0)) Factory constructor of the TransactionManager.
std::string	GetTransactionPath(uint16_t base, const std::string & tx_hash)
std::string	GetTransactionPath(const IGeniusTransactions & element)
std::string	GetTransactionPath(const std::string & tx_hash)
std::string	GetTransactionProofPath(const IGeniusTransactions & element)
outcome::result< std::shared_ptr< IGeniusTransactions > >	FetchTransaction(const std::shared_ptr< crdt::GlobalDB > & db, std::string_view transaction_key)
outcome::result< std::shared_ptr< IGeniusTransactions > >	DeSerializeTransaction(const base::Buffer & tx_data)
std::string	StateToString(State state)
std::string	GetBlockChainBase(uint16_t network_id)
	~TransactionManager()
void	Start()
void	PrintAccountInfo() const
const GeniusAccount &	GetAccount() const
std::vector< std::vector< uint8_t > >	GetOutTransactions() const
std::vector< std::vector< uint8_t > >	GetInTransactions() const
outcome::result< std::string >	TransferFunds(uint64_t amount, const std::string & destination, TokenID token_id)
outcome::result< std::string >	MintFunds(uint64_t amount, std::string transaction_hash, std::string chainid, TokenID tokenid)
outcome::result< std::pair< std::string, EscrowDataPair > >	HoldEscrow(uint64_t amount, const std::string & dev_addr, uint64_t peers_cut, const std::string & job_id)
outcome::result< std::string >	PayEscrow(const std::string & escrow_path, const SGProcessing::TaskResult & task_result, std::shared_ptr< crdt::AtomicTransaction > crdt_transaction)
TransactionStatus	WaitForTransactionIncoming(const std::string & txId, std::chrono::milliseconds timeout) const
TransactionStatus	WaitForTransactionOutgoing(const std::string & txId, std::chrono::milliseconds timeout) const
TransactionStatus	WaitForEscrowRelease(const std::string & originalEscrowId, std::chrono::milliseconds timeout) const
State	GetState() const
TransactionStatus	GetOutgoingStatusByTxId(const std::string & txId) const
TransactionStatus	GetIncomingStatusByTxId(const std::string & txId) const
outcome::result< std::shared_ptr< IGeniusTransactions > >	GetConflictingTransaction(const IGeniusTransactions & element) const
void	Stop() Stops the TransactionManager processing.
void	RegisterStateChangeCallback(StateChangeCallback callback)
void	UnregisterStateChangeCallback()
outcome::result< void >	QueryTransactions()
outcome::result< void >	FetchAndProcessTransaction(const std::string & tx_key, std::optional< base::Buffer > tx_data =std::nullopt)

Protected Functions¶

	Name
void	EnqueueTransaction(TransactionPair element)
void	EnqueueTransaction(TransactionItem element)
void	SetTimeFrameToleranceMs(uint64_t timeframe_tolerance)
void	SetMutabilityWindowMs(uint64_t mutability_window)

Public Attributes¶

	Name
std::string_view	GNUS_FULL_NODES_TOPIC
std::string_view	GNUS_FULL_NODES_TOPIC_LEGACY
uint64_t	NONCE_REQUEST_TIMEOUT_MS Unified timeout for all nonce requests (10 seconds).

Friends¶

	Name
class	GeniusNode

Public Types Documentation¶

enum State¶

Enumerator	Value	Description
CREATING	0	Creating the object.
INITIALIZING		Initializing the object.
SYNCING		Syncing the transactions.
READY		Ready to process transactions.

State of the Transaction Manager.

enum TransactionStatus¶

Enumerator	Value	Description
CREATED		Transaction created but not yet sent.
SENDING		Transaction is being sent.
CONFIRMED		Transaction confirmed.
VERIFYING		Transaction being verified.
FAILED		Transaction failed.
INVALID		Invalid transaction.

Status of a transaction.

using TransactionPair¶

using sgns::TransactionManager::TransactionPair = std::pair<std::shared_ptr<IGeniusTransactions>, std::optional<std::vector<uint8_t>>>;

using TransactionBatch¶

using sgns::TransactionManager::TransactionBatch = std::vector<TransactionPair>;

using TransactionItem¶

using sgns::TransactionManager::TransactionItem = std::pair<TransactionBatch, std::optional<std::shared_ptr<crdt::AtomicTransaction>>>;

using StateChangeCallback¶

using sgns::TransactionManager::StateChangeCallback = std::function<void( const State &previous, const State &current )>;

Public Functions Documentation¶

function New¶

static std::shared_ptr< TransactionManager > New(
    std::shared_ptr< crdt::GlobalDB > processing_db,
    std::shared_ptr< boost::asio::io_context > ctx,
    UTXOManager & utxo_manager,
    std::shared_ptr< GeniusAccount > account,
    std::shared_ptr< crypto::Hasher > hasher,
    bool full_node =false,
    std::chrono::milliseconds timestamp_tolerance =std::chrono::milliseconds(0),
    std::chrono::milliseconds mutability_window =std::chrono::milliseconds(0)
)

Factory constructor of the TransactionManager.

Parameters:

processing_db Database of the CRDT
ctx The io context used to run its inner methods
utxo_manager UTXO manager
account Genius account to be used
hasher Hasher to be used
full_node Parameter to indicate if the account is a full node
timestamp_tolerance Time to analyze a transaction with the same nonce/key
mutability_window Window of time where a transaction can be modified

Return: Instance of the TransactionManager initialized or Error

Note:

Default timestamp_tolerance is 5 minutes (300000 ms)
Default mutability_window is 10 minutes (600000 ms)
timestamp_tolerance must be smaller than mutability_window

function GetTransactionPath¶

static std::string GetTransactionPath(
    uint16_t base,
    const std::string & tx_hash
)

function GetTransactionPath¶

static std::string GetTransactionPath(
    const IGeniusTransactions & element
)

function GetTransactionPath¶

static std::string GetTransactionPath(
    const std::string & tx_hash
)

function GetTransactionProofPath¶

static std::string GetTransactionProofPath(
    const IGeniusTransactions & element
)

function FetchTransaction¶

static outcome::result< std::shared_ptr< IGeniusTransactions > > FetchTransaction(
    const std::shared_ptr< crdt::GlobalDB > & db,
    std::string_view transaction_key
)

function DeSerializeTransaction¶

static outcome::result< std::shared_ptr< IGeniusTransactions > > DeSerializeTransaction(
    const base::Buffer & tx_data
)

function StateToString¶

static inline std::string StateToString(
    State state
)

function GetBlockChainBase¶

static std::string GetBlockChainBase(
    uint16_t network_id
)

function ~TransactionManager¶

~TransactionManager()

function Start¶

void Start()

function PrintAccountInfo¶

void PrintAccountInfo() const

function GetAccount¶

const GeniusAccount & GetAccount() const

function GetOutTransactions¶

std::vector< std::vector< uint8_t > > GetOutTransactions() const

function GetInTransactions¶

std::vector< std::vector< uint8_t > > GetInTransactions() const

function TransferFunds¶

outcome::result< std::string > TransferFunds(
    uint64_t amount,
    const std::string & destination,
    TokenID token_id
)

function MintFunds¶

outcome::result< std::string > MintFunds(
    uint64_t amount,
    std::string transaction_hash,
    std::string chainid,
    TokenID tokenid
)

function HoldEscrow¶

outcome::result< std::pair< std::string, EscrowDataPair > > HoldEscrow(
    uint64_t amount,
    const std::string & dev_addr,
    uint64_t peers_cut,
    const std::string & job_id
)

function PayEscrow¶

outcome::result< std::string > PayEscrow(
    const std::string & escrow_path,
    const SGProcessing::TaskResult & task_result,
    std::shared_ptr< crdt::AtomicTransaction > crdt_transaction
)

function WaitForTransactionIncoming¶

TransactionStatus WaitForTransactionIncoming(
    const std::string & txId,
    std::chrono::milliseconds timeout
) const

function WaitForTransactionOutgoing¶

TransactionStatus WaitForTransactionOutgoing(
    const std::string & txId,
    std::chrono::milliseconds timeout
) const

function WaitForEscrowRelease¶

TransactionStatus WaitForEscrowRelease(
    const std::string & originalEscrowId,
    std::chrono::milliseconds timeout
) const

function GetState¶

inline State GetState() const

function GetOutgoingStatusByTxId¶

TransactionStatus GetOutgoingStatusByTxId(
    const std::string & txId
) const

function GetIncomingStatusByTxId¶

TransactionStatus GetIncomingStatusByTxId(
    const std::string & txId
) const

function GetConflictingTransaction¶

outcome::result< std::shared_ptr< IGeniusTransactions > > GetConflictingTransaction(
    const IGeniusTransactions & element
) const

function Stop¶

void Stop()

Stops the TransactionManager processing.

function RegisterStateChangeCallback¶

void RegisterStateChangeCallback(
    StateChangeCallback callback
)

function UnregisterStateChangeCallback¶

void UnregisterStateChangeCallback()

function QueryTransactions¶

outcome::result< void > QueryTransactions()

function FetchAndProcessTransaction¶

outcome::result< void > FetchAndProcessTransaction(
    const std::string & tx_key,
    std::optional< base::Buffer > tx_data =std::nullopt
)

Protected Functions Documentation¶

function EnqueueTransaction¶

void EnqueueTransaction(
    TransactionPair element
)

function EnqueueTransaction¶

void EnqueueTransaction(
    TransactionItem element
)

function SetTimeFrameToleranceMs¶

void SetTimeFrameToleranceMs(
    uint64_t timeframe_tolerance
)

function SetMutabilityWindowMs¶

void SetMutabilityWindowMs(
    uint64_t mutability_window
)

Public Attributes Documentation¶

variable GNUS_FULL_NODES_TOPIC¶

static std::string_view GNUS_FULL_NODES_TOPIC = "SuperGNUSNode.TestNet.FullNode";

variable GNUS_FULL_NODES_TOPIC_LEGACY¶

static std::string_view GNUS_FULL_NODES_TOPIC_LEGACY = "SuperGNUSNode.TestNet.FullNode.963";

variable NONCE_REQUEST_TIMEOUT_MS¶

static uint64_t NONCE_REQUEST_TIMEOUT_MS                                                        =
10000;

Unified timeout for all nonce requests (10 seconds).

Friends¶

friend GeniusNode¶

friend class GeniusNode(
    GeniusNode 
);

Updated on 2026-03-04 at 13:10:43 -0800