sgns

Namespaces

Name
sgns::api
sgns::base
sgns::crdt
sgns::crypto
sgns::evmwatcher
sgns::face
sgns::input_validator_constants
sgns::ipfs_bitswap
sgns::multisig
sgns::processing
sgns::securecrdt
sgns::sgprocessing
sgns::sgprocmanager
sgns::sgprocmanagersha
sgns::storage
sgns::subscription
sgns::utxo_address
sgns::utxo_merkle Utilities for building deterministic Merkle roots over ordered UTXO payloads.
sgns::version
sgns::watcher

Classes

	Name
class	sgns::AccountMessenger
class	sgns::AndroidSecureStorage
class	sgns::AppleSecureStorage
class	sgns::Blockchain Manages genesis/account-creation blocks and consensus integration.
class	sgns::BridgeRelayer Registers both BridgeSourceBurned (v1) and BridgeOutInitiated (v2) watches on a shared EthWatchService across multiple chains and calls MintFunds when burns are detected. OnWatchEvent dispatches on the variant type of values[5] to handle both event formats (D-06).
struct	sgns::BurnEventParams Parsed burn event parameters shared between real-time watch (OnWatchEvent) and startup catch-up scan (PerformStartupCatchupScan).
struct	sgns::ChainContractPair Represents a chain name and its GNUS bridge contract address.
class	sgns::ChainRpcEndpointProvider Encapsulates ChainList RPC endpoint loading and validator wiring.
class	sgns::CoinGeckoPriceRetriever
class	sgns::ConsensusManager Implements Consensus with weighted voting.
class	sgns::EscrowTransaction Transaction that reserves funds for a job escrow while tracking peer payout metadata.
struct	sgns::FromMnemonic Restore from a BIP39 mnemonic.
struct	sgns::FromPrivateKey Restore from an Ethereum hex private key.
struct	sgns::FromPublicKey Load from storage by public address (read-only).
class	sgns::GeniusAccount
class	sgns::GeniusAssigner
class	sgns::GeniusInputValidator Validator for native Genius-chain transactions.
class	sgns::GeniusNode High-level facade that initializes and coordinates account, networking, transaction, blockchain, and processing subsystems.
class	sgns::GeniusProver Prover class of SuperGenius.
class	sgns::GeniusTransaction Base class of the GeniusTransaction.
class	sgns::GeniusUTXO Immutable-style UTXO value object containing ownership, token, amount, and outpoint metadata.
class	sgns::IBasicProof Base proof class header file.
class	sgns::IBridgeInitObserver Observer interface notified when RPC endpoints have been loaded and wired.
class	sgns::IInputValidator Strategy interface for validating transaction inputs and their witness data.
class	sgns::IMigrationStep Interface for a migration step between two schema versions.
struct	sgns::InputUTXOInfo Raw UTXO input data included in a spend request.
class	sgns::IpfsDHT
class	sgns::ISecureStorage
class	sgns::JSONBackend
class	sgns::JSONSecureStorage
struct	sgns::lambda_visitor
struct	sgns::lambda_visitor< Lambda >
struct	sgns::lambda_visitor< Lambda, Lambdas... >
class	sgns::LinuxSecureStorage
class	sgns::MemorySecureStorage In-memory JSON backend for tests. Stores data in a map — no OS keychain access, no password prompts, no cleanup needed.
class	sgns::Migration0_2_0To1_0_0 Migration step for version 0.2.0 to 1.0.0.
class	sgns::Migration1_0_0To3_4_0 Migration step for version 1.0.0 to 3.4.0. Changes the full node topic from CRDT heads.
class	sgns::Migration3_4_0To3_5_0 Migration step for version 3.4.0 to 3.5.0. Updates persisted data required by the 3.5.0 node layout.
class	sgns::Migration3_5_0To3_6_0 Executes the storage migration from database version 3.5.1 to 3.6.0.
class	sgns::Migration3_6_0To3_7_0 Executes the 3.6.0 to 3.7.0 migration, including legacy balance recovery.
class	sgns::MigrationAllowList Stores observed legacy balances and validates migration claim eligibility.
class	sgns::MigrationInputValidator Implements the InputValidator for a Migration type.
class	sgns::MigrationManager Executes a sequence of migration steps to update a CRDT store.
class	sgns::MigrationTransaction
class	sgns::MintTransaction Transaction that mints tokens after proving a corresponding source-chain event.
class	sgns::MintTransactionV2 Implements a Mint Version 2 transaction.
struct	sgns::NewAccount Account-creation source for GeniusNode::New(dev_config, AccountSource).Generate a new identity.
class	sgns::NilFileHelper
struct	sgns::OutPoint Unique identifier for a transaction output.
struct	sgns::OutPointHash Hash functor for using OutPoint keys in unordered containers.
struct	sgns::OutputDestInfo Single UTXO output destination entry.
class	sgns::ProcessingProof A class for generating and verifying processing proofs.
class	sgns::PublicChainInputValidator Validator for transactions that reference external public-chain proofs.
class	sgns::RecursiveTransferProof A class for generating a recursive Transfer Proof.
class	sgns::ScaledInteger Represents a decimal value using an integer scaled by 10^precision.
class	sgns::TokenAmount Utility for GNUS token fixed-point parsing, formatting and cost calculation.
class	sgns::TokenID Represents a 32-byte token identifier while preserving legacy GNUS semantics.
class	sgns::TransactionManager Coordinates transaction creation, CRDT propagation, verification, and status tracking.
class	sgns::TransferProof A class for generating and verifying transfer proofs.
class	sgns::TransferTransaction Transaction for transferring funds between UTXO inputs and outputs.
struct	sgns::Unused
class	sgns::UTXOManager Owns the local UTXO set, supports coin selection, validation, persistence, reservations, and deterministic snapshot hashing.
class	sgns::ValidatorRegistry Maintains validator registry state and applies certificate-driven updates.
struct	sgns::WeightedRpcEndpoint Weighted RPC endpoint used for multi-provider consensus verification.
class	sgns::WindowsSecureStorage

Types

	Name
using std::function< std::optional< std::string >()>	ChainlistFetcher Fetches the chainlist dataset (JSON text) used to discover public RPC URLs at startup.
using std::variant< NewAccount, FromPrivateKey, FromMnemonic, FromPublicKey >	AccountSource
using std::function< std::unique_ptr< eth::rpc::JsonRpcTransport >(const std::string &url, std::chrono::seconds timeout)>	TransportFactory Factory callable that produces a JsonRpcTransport from a URL and timeout.
using std::pair< std::string, base::Buffer >	EscrowDataPair
using std::pair< std::vector< InputUTXOInfo >, std::vector< OutputDestInfo > >	UTXOTxParameters Pair of signed inputs and destination outputs that make up a UTXO transaction payload.

Functions

	Name
base::Logger	BridgeRelayerLogger() Returns a new instance of the BridgeRelayer logger.
base::Logger	InputValidatorLogger()
base::Logger	GeniusNodeLogger()
std::string	generate_uuid_with_ipfs_id(const std::string & ipfs_id)
template <size_t N,class Stream > Stream &	operator<<(Stream & s, const Unused< N > & )
template <size_t N,class Stream > Stream &	operator>>(Stream & s, Unused< N > & )
std::string	to_string(const std::vector< unsigned char > & bytes) Convert a byte array to a hexadecimal string.
bool	isLittleEndian() Checks if the architecture is little endian.
template <typename T > T	Vector2Num(const std::vector< uint8_t > & bytes) Converts a little-endian byte vector into a number.
uint128_t	Vector2Num(const std::vector< uint8_t > & bytes)
uint256_t	Vector2Num(const std::vector< uint8_t > & bytes)
template <typename T > std::vector< uint8_t >	Num2Vector(const T & num, std::size_t num_bytes_resolution =sizeof(T)) Converts a number into a byte vector (little-endian).
template <typename T > T	HexASCII2Num(const char * p_char, std::size_t num_nibbles_resolution =sizeof(T) *2) Converts a hexadecimal ASCII char array into a number.
template <typename T > std::vector< T >	HexASCII2NumStr(const char * p_char, std::size_t char_ptr_size) Converts a hexadecimal ASCII char array into a vector of numbers.
template <typename T > std::enable_if_t< std::is_same_v< typename T::value_type, uint8_t > >	AdjustEndianess(T & data, std::optional< typename T::iterator > start =std::nullopt, std::optional< typename T::iterator > finish =std::nullopt) Adjust endianess if needed.
std::string	Uint256ToString(const uint256_t & value)
template <class... Fs> constexpr auto	make_visitor(Fs &&... fs) Creates a compile-time visitor from a set of lambdas.
template <typename TVariant ,typename... TVisitors> constexpr decltype(auto)	visit_in_place(TVariant && variant, TVisitors &&... visitors) Applies an in-place visitor to a boost::variant.
template <typename T ,typename Matcher > constexpr decltype(auto)	match(T && t, Matcher && m) apply Matcher to optional T
template <typename T ,typename... Fs> constexpr decltype(auto)	match_in_place(T && t, Fs &&... fs) construct visitor from Fs and apply it to optional T
base::Logger	ConsensusManagerLogger()
outcome::result< std::vector< uint8_t > >	ProposalSigningBytes(const ConsensusProposal & proposal) Builds canonical bytes used to sign a consensus proposal.
outcome::result< std::vector< uint8_t > >	VoteSigningBytes(const ConsensusVote & vote) Builds canonical bytes used to sign a consensus vote.
outcome::result< std::vector< uint8_t > >	VoteBundleSigningBytes(const ConsensusVoteBundle & bundle) Builds canonical bytes used to sign a consensus vote bundle.
outcome::result< std::string >	ComputeProposalId(const ConsensusProposal & proposal) Computes deterministic proposal id from proposal content.
bool	ValidateProposal(const ConsensusProposal & proposal) Validates proposal basic shape, signature, and computed id.
std::string	decodeChunkedTransfer(const std::string & chunkedData)
void	InitGeniusSDKAndroid(JavaVM * vm)
GeniusProver::ProofType	GetSnarkFromProto(const SGProof::BaseProofData & proof_proto_data)

Attributes

	Name
constexpr std::string_view	kBridgeSourceBurnedSig Canonical Solidity event signatures for bridge events. Single source of truth — shared by watch registration, catch-up scan, and RPC endpoint validation.
constexpr std::string_view	kBridgeOutInitiatedSig
bool	kGeniusValidatorRegistered
bool	kMigrationValidatorRegistered Static instance to trigger registration of the MigrationInputValidator before main() starts.
constexpr size_t	MAX_PUBSUB_TX_BYTES
constexpr std::string_view	NONCE_SUBJECT_TYPE
constexpr std::string_view	TASK_RESULT_SUBJECT_TYPE
constexpr std::string_view	REGISTRY_BATCH_SUBJECT_TYPE
constexpr std::string_view	FILE_NAME

Types Documentation

using ChainlistFetcher

using sgns::ChainlistFetcher = typedef std::function<std::optional<std::string>()>;

Fetches the chainlist dataset (JSON text) used to discover public RPC URLs at startup.

Return: The chainlist JSON text, or std::nullopt on fetch failure.

Production default: HTTPS GET of https://chainid.network/chains.json. Tests inject a callable returning canned JSON (no network).

using AccountSource

using sgns::AccountSource = typedef std::variant<NewAccount, FromPrivateKey, FromMnemonic, FromPublicKey>;

using TransportFactory

using sgns::TransportFactory = typedef std::function<std::unique_ptr<eth::rpc::JsonRpcTransport>( const std::string &url, std::chrono::seconds timeout )>;

Factory callable that produces a JsonRpcTransport from a URL and timeout.

Parameters:

• url RPC endpoint URL.
• timeout Transport operation timeout.

Return: Unique ownership of a transport implementing JsonRpcTransport.

Injected via SetTransportFactory(). When not set, the default factory creates real RpcHttpTransport instances (production path per D-16). Tests inject a factory that returns MockRpcTransport instances (D-07, D-14).

using EscrowDataPair

using sgns::EscrowDataPair = typedef std::pair<std::string, base::Buffer>;

using UTXOTxParameters

using sgns::UTXOTxParameters = typedef std::pair<std::vector<InputUTXOInfo>, std::vector<OutputDestInfo> >;

Pair of signed inputs and destination outputs that make up a UTXO transaction payload.

Functions Documentation

function BridgeRelayerLogger

base::Logger BridgeRelayerLogger()

Returns a new instance of the BridgeRelayer logger.

Return: Logger instance for BridgeRelayer.

Note: This is used for 2 reasons: (1) to enable logging on static methods, and (2) to avoid static initialization order issues when its created before the one with the same name on GeniusNode, which can have the output configured to file. If we initialize this logger statically it could end up outputing to console instead.

function InputValidatorLogger

base::Logger InputValidatorLogger()

function GeniusNodeLogger

base::Logger GeniusNodeLogger()

function generate_uuid_with_ipfs_id

std::string generate_uuid_with_ipfs_id(
    const std::string & ipfs_id
)

function operator<<

template <size_t N,
class Stream >
Stream & operator<<(
    Stream & s,
    const Unused< N > & 
)

function operator>>

template <size_t N,
class Stream >
Stream & operator>>(
    Stream & s,
    Unused< N > & 
)

function to_string

static std::string to_string(
    const std::vector< unsigned char > & bytes
)

Convert a byte array to a hexadecimal string.

Parameters:

• bytes A vector of bytes to be converted.

Return: A hexadecimal string representation of the bytes.

function isLittleEndian

static bool isLittleEndian()

Checks if the architecture is little endian.

Return: true if little endian, false otherwise

function Vector2Num

template <typename T >
static T Vector2Num(
    const std::vector< uint8_t > & bytes
)

Converts a little-endian byte vector into a number.

Parameters:

• bytes Byte vector to convert.

Template Parameters:

• T uint8_t, uint16_t, uint32_t, uint64_t, or supported multiprecision integer types.

Return: The converted number.

function Vector2Num

uint128_t Vector2Num(
    const std::vector< uint8_t > & bytes
)

function Vector2Num

uint256_t Vector2Num(
    const std::vector< uint8_t > & bytes
)

function Num2Vector

template <typename T >
static std::vector< uint8_t > Num2Vector(
    const T & num,
    std::size_t num_bytes_resolution =sizeof(T)
)

Converts a number into a byte vector (little-endian).

Parameters:

• num Number to convert.
• num_bytes_resolution Optional byte resolution (defaults to sizeof(T)).

Template Parameters:

• T uint8_t, uint16_t, uint32_t or uint64_t

Return: The converted byte vector.

function HexASCII2Num

template <typename T >
static T HexASCII2Num(
    const char * p_char,
    std::size_t num_nibbles_resolution =sizeof(T) *2
)

Converts a hexadecimal ASCII char array into a number.

Parameters:

• p_char Hexadecimal ASCII char array
• num_nibbles_resolution How many nibbles will constitute a number

Template Parameters:

• T uint8_t, uint16_t, uint32_t or uint64_t

Return: The converted number (8-64 bit variable)

function HexASCII2NumStr

template <typename T >
static std::vector< T > HexASCII2NumStr(
    const char * p_char,
    std::size_t char_ptr_size
)

Converts a hexadecimal ASCII char array into a vector of numbers.

Parameters:

• p_char Hexadecimal ASCII char array
• char_ptr_size Size of the char array

Template Parameters:

• T uint8_t, uint16_t, uint32_t or uint64_t

Return: The vector of converted numbers

function AdjustEndianess

template <typename T >
static std::enable_if_t< std::is_same_v< typename T::value_type, uint8_t > > AdjustEndianess(
    T & data,
    std::optional< typename T::iterator > start =std::nullopt,
    std::optional< typename T::iterator > finish =std::nullopt
)

Adjust endianess if needed.

Parameters:

• data The container of data (vector/array)
• start Optional beginning of the valid data
• finish Optional ending of the valid data

Template Parameters:

• T std::vector or std::array

function Uint256ToString

static std::string Uint256ToString(
    const uint256_t & value
)

function make_visitor

template <class... Fs>
constexpr auto make_visitor(
    Fs &&... fs
)

Creates a compile-time visitor from a set of lambdas.

Return: Visitor instance that dispatches to the provided lambdas.

Example: ```cpp

make_visitor(, { return 2; });

This is essentially the same as: ```cpp

struct visitor : public boost::static_visitor<int> {
  int operator()(int a) { return 1; }
  int operator()(std::string b) { return 2; }
};

function visit_in_place

template <typename TVariant ,
typename... TVisitors>
constexpr decltype(auto) visit_in_place(
    TVariant && variant,
    TVisitors &&... visitors
)

Applies an in-place visitor to a boost::variant.

Example: ```cpp

boost::variant value = "1234";

visit_in_place(value, { std::cout << "(int)" << v; }, { std::cout << "(string)" << v; });

### function match

```cpp
template <typename T ,
typename Matcher >
constexpr decltype(auto) match(
    T && t,
    Matcher && m
)

apply Matcher to optional T

function match_in_place

template <typename T ,
typename... Fs>
constexpr decltype(auto) match_in_place(
    T && t,
    Fs &&... fs
)

construct visitor from Fs and apply it to optional T

function ConsensusManagerLogger

base::Logger ConsensusManagerLogger()

function ProposalSigningBytes

inline outcome::result< std::vector< uint8_t > > ProposalSigningBytes(
    const ConsensusProposal & proposal
)

Builds canonical bytes used to sign a consensus proposal.

Parameters:

• proposal Proposal object to serialize for signing.

Return: Serialized signing bytes on success, or std::errc::invalid_argument when protobuf serialization fails.

The signature field is cleared before serialization so signatures are never part of their own signing payload.

function VoteSigningBytes

inline outcome::result< std::vector< uint8_t > > VoteSigningBytes(
    const ConsensusVote & vote
)

Builds canonical bytes used to sign a consensus vote.

Parameters:

• vote Vote object to serialize for signing.

Return: Serialized signing bytes on success, or std::errc::invalid_argument when protobuf serialization fails.

The signature field is cleared before serialization so signatures are never part of their own signing payload.

function VoteBundleSigningBytes

inline outcome::result< std::vector< uint8_t > > VoteBundleSigningBytes(
    const ConsensusVoteBundle & bundle
)

Builds canonical bytes used to sign a consensus vote bundle.

Parameters:

• bundle Vote bundle to serialize for signing.

Return: Serialized signing bytes on success, or std::errc::invalid_argument when protobuf serialization fails.

The signature field is cleared before serialization so signatures are never part of their own signing payload.

function ComputeProposalId

inline outcome::result< std::string > ComputeProposalId(
    const ConsensusProposal & proposal
)

Computes deterministic proposal id from proposal content.

Parameters:

• proposal Proposal used to derive the identifier.

Return: Lowercase hex SHA-256 proposal id on success, or propagated error when signing bytes cannot be produced.

The proposal id field is cleared before hashing to guarantee stable id derivation from the signed payload content only.

function ValidateProposal

inline bool ValidateProposal(
    const ConsensusProposal & proposal
)

Validates proposal basic shape, signature, and computed id.

Parameters:

• proposal Proposal to validate.

Return: true when proposer id/signature/id are present, signature is valid, and computed proposal id matches; otherwise false.

function decodeChunkedTransfer

std::string decodeChunkedTransfer(
    const std::string & chunkedData
)

function InitGeniusSDKAndroid

void InitGeniusSDKAndroid(
    JavaVM * vm
)

function GetSnarkFromProto

static GeniusProver::ProofType GetSnarkFromProto(
    const SGProof::BaseProofData & proof_proto_data
)

Attributes Documentation

variable kBridgeSourceBurnedSig

constexpr std::string_view kBridgeSourceBurnedSig =
        "BridgeSourceBurned(address,uint256,uint256,uint256,uint256,bytes)";

Canonical Solidity event signatures for bridge events. Single source of truth — shared by watch registration, catch-up scan, and RPC endpoint validation.

Note: The old signature with 5 parameters it not supported as it was wrong.

variable kBridgeOutInitiatedSig

constexpr std::string_view kBridgeOutInitiatedSig =
        "BridgeOutInitiated(address,uint256,uint256,uint256,uint256,bytes32,bool)";

variable kGeniusValidatorRegistered

static bool kGeniusValidatorRegistered = GeniusInputValidator::Register();

variable kMigrationValidatorRegistered

static bool kMigrationValidatorRegistered = MigrationInputValidator::Register();

Static instance to trigger registration of the MigrationInputValidator before main() starts.

variable MAX_PUBSUB_TX_BYTES

static constexpr size_t MAX_PUBSUB_TX_BYTES = 64 * 1024;

variable NONCE_SUBJECT_TYPE

static constexpr std::string_view NONCE_SUBJECT_TYPE = "sgns.nonce.v1";

variable TASK_RESULT_SUBJECT_TYPE

static constexpr std::string_view TASK_RESULT_SUBJECT_TYPE = "sgns.task_result.v1";

variable REGISTRY_BATCH_SUBJECT_TYPE

static constexpr std::string_view REGISTRY_BATCH_SUBJECT_TYPE = "sgns.registry_batch.v1";

variable FILE_NAME

constexpr std::string_view FILE_NAME = "secure_storage.json";

---

Updated on 2026-08-06 at 13:59:17 +0000