# GNUS.AI Docs -- Full Corpus --- source: /about-gnus.ai/introduction/ title: Introduction --- # Introduction GNUS.AI empowers end-users to participate in decentralized processing, earning GNUS tokens—the native token for GNUS.AI—by utilizing the idle cycles of computers, mobile devices, and any other device connected to the internet. Whether you're playing a game, creating and rendering your own content, or solving complex algorithms, your participation in the GNUS.AI network is rewarded.

GNUS Blockchain Workflow

## Purpose and Mission Our mission is to democratize AI/ML processing, allowing individuals to contribute their computing resources and be rewarded. GNUS.AI is creating a seamless ecosystem where users can easily integrate the system into various applications and games, fostering a new era of decentralized and organic growth. --- source: /about-gnus.ai/why-gnus.ai/ title: Why GNUS.ai?: A DePin That's Different and Disruptive --- --- cover: ../../.gitbook/assets/Screen Shot 2024-02-20 at 10.59.45 AM.png coverY: 0 --- # Why GNUS.ai?: A DePin That's Different and Disruptive ### Revolutionizing AI, Ads, and App Monetization with Idle Device Power GNUS.ai is a blockchain-based DePin platform that harnesses idle computing power from everyday devices worldwide: desktops, mobiles, gaming consoles, and IoT systems to power AI and ML workloads. It democratizes AI by enabling efficient processing on low-power devices (e.g., iPhone 8 or older GPUs). It rewards users with GNUS tokens (multichain on Ethereum, Polygon, Bitcoin) for sharing resources in a peer-to-peer ecosystem. The platform runs natively on Windows, macOS, Linux, Android, iOS, XBOX, PlayStation, and IoT devices. It bypasses Docker/container dependencies for seamless AI/ML across ecosystems, with low virtualization overhead for organic growth. At its core is a unique patent (US 11,451,393 B2), filed January 29, 2020 (development from 2019) and granted September 20, 2022. This covers a hybrid blockchain for fast cryptotoken transactions, data verification, and payments using unused device cycles for AI/ML. It prioritizes low-end hardware, offering censorship-resistant, low-cost infrastructure. GNUS.ai disrupts the ads and monetization spaces through SDK embedding in apps and games. Developers integrate AI/ML while users earn GNUS tokens from idle cycles during usage. This creates shared revenue without ads or paywalls. It transforms app income models; no other DePin offers such native, cross-OS in-app earnings. GNUS.ai stands apart from other DePins by focusing on low-power democratization, not high-end compute. True decentralization means access for all, not just those with expensive hardware or limited platforms. Based on analysis, projects like Render, Grass, Filecoin, and Helium are generally considered fully decentralized in the DePin space due to their peer-to-peer structures, global node distribution, and blockchain-based incentives, though they may face criticisms around practical centralization (e.g., hardware barriers or initial bootstrapping). See the updated comparison below: | Project | Focus | Decentralization Level | Workloads | Platforms/OS Support | Key Differentiation from GNUS.ai | | ----------------------------------- | ----------------------------------- | ---------------------- | ------------------------------------ | --------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- | | GNUS.ai | Idle device power for AI/ML | Fully decentralized | AI/ML processing, gaming integration | All major OS/devices (incl. mobiles, consoles, IoT) | Native, non-containerized; rewards low-end hardware; patent-protected crypto payments; app-embedded monetization | | Octa.space | Decentralized GPU cloud/marketplace | Semi-centralized | AI training, rendering, VMs | Docker/VMs on GPUs (Nvidia/AMD/Intel) | Relies on Docker/VMs for high-end nodes; not device-ubiquitous | | Bittensor | Machine intelligence network | Semi-centralized | AI inference/training, predictions | Subnets for miners/validators | Relies on centralized miners/validators; high-stake concentration; less idle consumer device focus | | Render | Distributed rendering/GPU | Fully decentralized | 3D rendering, AI graphics | GPU-focused nodes | High-end GPU competition; no broad OS support | | Grass | Unused bandwidth for AI data | Fully decentralized | AI data scraping/processing | Browser extensions/mobiles | Bandwidth-centric, not compute | | Filecoin | Decentralized storage | Fully decentralized | Storage for AI data | Node-based (not device-native) | Storage-focused; no AI compute | | Helium | Wireless/IoT networks | Fully decentralized | IoT data transmission | Hardware hotspots | Network infrastructure, not AI/ML | | ICP | Decentralized web/compute | Semi-centralized | Web apps, AI hosting | Canister-based VMs | General compute; more centralized governance | | Golem | Idle computing resources | Decentralized | General compute tasks | Node-based | Broader compute but less AI-specific | | DePINed | AI/Rendering SuperCloud | Semi-centralized | AI tasks, rendering | App-based GPU sharing | Separate install required; retail-focused | | io.net | Decentralized GPUs | Semi-centralized | AI/ML workloads | Cloud-like clusters | High-end GPU alternative | | Gensyn | Idle GPUs for AI | Semi-centralized | AI training/inference | GPU marketplaces | High-end focus | | PingPongBuild | Idle hardware for AI/DePin | Decentralized | AI compute, blockchain apps | Multi-Mining app + SDK (likely Windows/Mac/Linux) | SDK integration but narrower OS support; requires high-end hardware/dev skills | | Others (e.g., NuNet, DIMO, Nodepay) | Compute/IoT | Varies | AI tasks, vehicle data | Docker/extensions | Container/extension-dependent; premium resource focus | By tapping billions of idle devices, GNUS.ai scales AI to trillions of operations affordably, avoiding high-end competition. It enables cross-OS democratization, token deflation via burns, and ad-alternative earnings. This positions it as a foundational layer for accessible, community-driven AI. Learn more at docs.gnus.ai or gnus.ai. --- source: /about-gnus.ai/why-gnus.ai/works-everywhere/ title: Works Everywhere --- # Works Everywhere The flexibility of GNUS.AI is evident in its compatibility across a multitude of devices: * Windows, Windows Mobile
* iOS/OSX
* Android
* Linux
* XBOX
* Playstation
* Nintendo
* Any other Internet of things (IoT) device This wide-ranging compatibility ensures that GNUS.AI can seamlessly integrate into existing infrastructure. --- source: /about-gnus.ai/why-gnus.ai/customizable/ title: Customizable --- # Customizable Each user will be able to tailor their A.I. or Machine Learning algorithms according to their unique requirements.
This is facilitated through a user-friendly customer portal, where data can be uploaded securely. --- source: /about-gnus.ai/why-gnus.ai/fast/ title: Fast --- # Fast GNUS.AI utilizes an internal [Directed Acyclic Graph (DAG)](../../resources/glossary.md#directed-acyclic-graph-dag) based blockchain, executing transactions in microseconds.
The emphasis on speed ensures efficient processing of data, making it an ideal solution for real-time applications. --- source: /about-gnus.ai/why-gnus.ai/secure/ title: Secure --- # Secure Each application will include a Two-Factor Authentication system.
The system uses Time-based One-Time Passwords for verification, and the process is made more secure through a technology called Zero-Knowledge Succinct Non-Interactive Arguments of Knowledge (zk-SNARKs). --- source: /about-gnus.ai/why-gnus.ai/secure/secure-2fa-with-totp-and-zk-snarks/ title: Secure 2FA with TOTP and zk-SNARKs --- # Secure 2FA with TOTP and zk-SNARKs In our pursuit of enhancing security within blockchain applications, we've integrated a Two-Factor Authentication (2FA) system using Time-based One-Time Passwords (TOTP) verified through Zero-Knowledge Succinct Non-Interactive Arguments of Knowledge (zk-SNARKs). This approach ensures the authenticity of transactions and actions without compromising user privacy. Furthermore, all user and system data related to 2FA are securely stored in an append-only database using Conflict-Free Replicated Data Types (CRDTs) backed by IPFS DAGs, ensuring data integrity and resilience. ### Overview #### TOTP System The TOTP system generates a temporary code based on a shared secret and the current time. This method is widely used for 2FA, providing an additional layer of security beyond just passwords. * **Secret Generation**: Upon account creation, a unique secret is generated for each user. * **TOTP Generation and Verification**: The TOTP is generated by the user's device and verified by our system to grant access or validate transactions. #### zk-SNARKs Integration zk-SNARKs allow the verification of possession of the TOTP without revealing the TOTP itself or the shared secret, maintaining user privacy. * **Proof Generation**: Users generate a zk-SNARK proof that they have a valid TOTP. * **Proof Verification**: Our system verifies this proof without needing to see the actual TOTP code. #### CRDT Database with IPFS DAG User account information, including 2FA details, is stored in a CRDT database. This structure supports an append-only model, ensuring data is tamper-resistant and decentralized. * **Immutable Storage**: Using IPFS DAG, the database ensures that once data is added, it cannot be altered or removed. * **Decentralization and Resilience**: Leveraging IPFS provides a distributed network, enhancing data availability and resilience against attacks or failures. ### Implementation Steps #### Account Setup 1. **Generate TOTP Secret**: Upon account creation, generate a TOTP secret for the user. 2. **Encrypt and Store Secret**: Encrypt the secret with the user's public key and store it in the CRDT database, along with the account information. #### TOTP Verification with zk-SNARKs 1. **Generate TOTP**: The user generates a TOTP on their device. 2. **Create zk-SNARK Proof**: The user generates a zk-SNARK proof of having a valid TOTP. 3. **Submit Proof**: The user submits the proof for verification. 4. **Verify Proof**: Our system verifies the proof, granting access or approving transactions without ever seeing the TOTP code. #### Data Storage in CRDT with IPFS DAG 1. **Store Account Information**: Account and TOTP information are stored in the CRDT database. 2. **Append-Only Model**: Any updates are appended, maintaining a historical record of changes. 3. **IPFS DAG Storage**: The CRDT database is stored in an IPFS DAG, ensuring decentralized, immutable storage. ### Security Considerations * **Key Management**: Secure management of private keys used for encrypting TOTP secrets is crucial. * **Proof Verification**: Ensure that zk-SNARK proof verification is robust and secure. * **Data Integrity**: Regular audits and checks to ensure the integrity and availability of data stored in the CRDT database on IPFS. ### Conclusion Integrating TOTP with zk-SNARKs and leveraging a CRDT database with IPFS DAG for storage offers a robust, privacy-preserving 2FA solution. This system enhances security for blockchain applications while ensuring data integrity and user privacy. --- source: /about-gnus.ai/features-and-benefits/ title: Features and Benefits --- # Features and Benefits ## Features And Benefits #### Decentralized * GNUS.AI turns your computer, smartphone, or other devices into a powerful team, working together to solve complex problems. * Instead of relying on a single, centralized server, GNUS.AI connects many devices in a decentralized network, utilizing their combined computing power. #### Secure * Each transaction is secured with Zero Knowledge (ZK) encryption, preventing your data from being sold. * Regular smart contract audits will be performed as an integral security measure. #### Integration * App developers can use a special Software Development Kit (SDK) that can be included in their applications, enabling them to tap into the unused processing power of your device for AI tasks. #### Rewards * You get special digital coins (cryptocurrency) as a reward for letting GNUS.AI use your device's brainpower. * When your device helps with AI calculations, you earn GNUS tokens, which you can use to buy things in apps or convert into other cryptocurrency. #### Compatibility * GNUS.AI works with everything from your phone to your game console and everything in between. * It easily fits into various devices, allowing you to contribute to the network regardless of what type of device you're using. --- source: /about-gnus.ai/features-and-benefits/scale-and-cost-efficiency/ title: Scale and cost-efficiency --- # Scale and cost-efficiency Building the GNUS.ai marketplace as a Web3 protocol eliminates centralized overheads, allowing for unprecedented scalability and reduces barriers to entry for new supply participants. This enables GNUS.ai to connect potentially every computing device globally, creating a decentralized network that scales far beyond the limits of traditional providers. By forming a network from the available billions of worldwide consumer compute devices, GNUS.ai offers on-demand access to boundless compute supply at a transparent and minimal cost—often as low as $0.01 per hour or less. GNUS.ai's pricing is driven by an automated supply and demand function, ensuring that costs remain at least 80% lower than other systems. This dynamic pricing structure allows GNUS.ai to stay highly competitive while offering users massive savings. Unlike traditional providers with centralized infrastructure and inflated costs, GNUS.ai operates with no CapEx and minimal OpEx, further driving down prices. Operational expenses are taken as a small percentage of the already low hourly cost, enabling the system to approach near-zero costs. This approach completely redefines cost barriers associated with scaling machine learning workloads, as GNUS.ai guarantees users access to affordable compute without compromising on scalability. By efficiently utilizing global compute resources and capturing latent capacity, GNUS.ai offers a flexible, decentralized solution that meets the needs of both developers and end-users, all while maintaining cost advantages unmatched by other systems. | Provider | Approximate hourly cost for ML training work (V100-equivalent) | Scalability | | ------------------------------- | -------------------------------------------------------------- | ----------- | | GNUS.ai | $.005 | High | | Single personal GPU | $0.28 | None | | Gensyn (projected) | $0.40 | High | | Single GPU in datacenter | $0.40 | None | | GCP spot instances (unreliable) | $0.75 | Medium | | AWS spot instances (unreliable) | $0.90 | Medium | | Vast.ai | $1.10 | Low | | Golem Network | $1.20 | Low | | AWS on-demand | $2 | Medium | | GCP on-demand | $2.50 | Medium | | Truebit (+ Ethereum) | $12 | Low | | Ethereum | $15,700 | Low | #### --- source: /about-gnus.ai/features-and-benefits/gnus.ai-network-vs.-centralized-xai-100k-cluster/ title: GNUS.ai Network vs. Centralized xAI 100k Cluster --- --- description: A Comprehensive Comparison for Prospective Node Operators --- # GNUS.ai Network vs. Centralized xAI 100k Cluster --- source: /about-gnus.ai/features-and-benefits/gnus.ai-network-vs.-centralized-xai-100k-cluster/1.-executive-summary/ title: 1. Executive Summary --- # 1. Executive Summary The GNUS.ai network is a decentralized, cost–efficient processing system that leverages the computing power of millions of end–user nodes. Each node earns GNUS tokens as compensation for contributing compute power. In contrast, a centralized xAI cluster built from high–end chips (such as Nvidia H100 chips) requires massive upfront investments (CAPEX) and ongoing high operating expenses (OPEX). Key highlights include: • Minimal CAPEX for GNUS: Nodes are operated by end users who supply their own hardware, electricity, and network connectivity. • Low OPEX: The GNUS network’s operating costs are limited to software, blockchain, and coordination overhead (only a few million dollars per year). • Profitability via Tokenomics: Node operators are paid $0.005 per hour in GNUS tokens. With a built–in deflationary mechanism (10% token burn per processing cycle and a 10% commission to Genius Ventures), the token’s value is expected to rise significantly over time. • Long-Term Value: Holding GNUS tokens can multiply the effective payout per hour. For example, a token starting at $3.40 on day one could be worth around $25.80 after one year, effectively increasing the hourly payout from $0.005 to approximately $0.0379. • This report explains these concepts in detail and provides tables and projections that compare the GNUS.ai decentralized network with a centralized xAI 100k–node cluster. --- source: /about-gnus.ai/features-and-benefits/gnus.ai-network-vs.-centralized-xai-100k-cluster/2.-introduction/ title: 2. Introduction --- # 2. Introduction Modern AI and machine learning applications require enormous amounts of compute power. Traditional centralized data centers using high–end chips (like Nvidia H100s) demand huge CAPEX and OPEX. These systems often cost billions of dollars in capital investment and incur ongoing expenses for electricity, cooling, network bandwidth, and storage. In contrast, the GNUS.ai network is built on a decentralized model where: • End users operate nodes using their own devices. • The network distributes payouts in GNUS tokens at a nominal rate of $0.005 per hour. • A deflationary mechanism (token burning) and commission structure increase the token’s value over time. This report is designed to explain these differences in simple terms and show how node operators benefit from participating in the GNUS.ai network. --- source: /about-gnus.ai/features-and-benefits/gnus.ai-network-vs.-centralized-xai-100k-cluster/3.-understanding-the-gnus.ai-decentralized-network/ title: 3. Understanding the GNUS.ai Decentralized Network --- # 3. Understanding the GNUS.ai Decentralized Network ### How It Works • Node Operation:
 Node operators contribute compute power from their own devices. Each node provides about 1 TFlop of processing power.

 • Payout Structure:
 Every node earns GNUS tokens at a rate of $0.005 per hour of processing. This payout is made in tokens rather than fiat dollars.

 • Token Distribution & Deflation:

 • Of the $0.005 per hour, 10% (i.e., $0.0005) is captured by Genius Ventures (GV) as a commission. • Additionally, 10% of the GNUS tokens paid for processing are burned (removed from circulation).
This deflationary mechanism reduces the total token supply over time. ### Why Decentralization Matters • No Centralized Hardware Investment: Unlike a centralized cluster, GNUS nodes are operated by individuals. There is no need for billions in capital investments.

 • Lower Operating Expenses: The network’s actual OPEX is very low—mostly just the cost to maintain the software, blockchain, and coordination functions.

 • Scalability: The system scales by adding more nodes organically, with each new node further reducing the circulating supply through deflation.

 --- source: /about-gnus.ai/features-and-benefits/gnus.ai-network-vs.-centralized-xai-100k-cluster/4.-the-centralized-xai-100k-cluster-explained/ title: 4. The Centralized xAI 100k Cluster Explained --- # 4. The Centralized xAI 100k Cluster Explained ### What It Is A centralized xAI cluster is a traditional data center approach that uses high–end chips—such as Nvidia H100 GPUs—to deliver massive compute power. For example: • Compute Performance: Each chip delivers about 67 TFlops. • Scale: A 100k–chip cluster would provide immense processing power. ### Cost Structure • CAPEX: • Estimated at around $6 billion to build a 100k–chip cluster (including hardware, data centers, cooling systems, etc.). • OPEX: • Compute Cost: Approximately $1.75 per chip per hour is charged to cover operating costs. • Electricity, Cooling, Network, and Storage: Additional high–cost items add hundreds of millions per year to the operating budget. • Total Annual OPEX: Could reach $1.7 billion per year. ### Limitations • High Capital Requirements: A centralized cluster requires enormous upfront investments and heavy financing.

 • Operational Complexity: Managing a centralized cluster involves dealing with high electricity usage, significant network costs, and storage complexities.

 • Scalability Issues: Scaling a centralized system requires even more capital and increases operational risks. --- source: /about-gnus.ai/features-and-benefits/gnus.ai-network-vs.-centralized-xai-100k-cluster/5.-comparing-capex-and-opex/ title: 5. Comparing CAPEX and OPEX --- # 5. Comparing CAPEX and OPEX ### CAPEX Comparison
MetricCentralized xAI ClusterGNUS.ai Decentralized Network
Hardware InvestmentApproximately $6 billion for a 100k–chip clusterMinimal nodes are owned by end users
Data Center InfrastructureRequires extensive investment (cooling, racks, etc.)Software–based; no centralized data center needed
Overall CAPEXExtremely highNegligible (only software and coordination CAPEX, e.g., $2M over 8 years)
### OPEX Comparison
MetricCentralized xAI ClusterGNUS.ai Decentralized Network
Compute Payment (Hourly)$1.75 per chip × 100,000 chips ≈ $175,000 per hour$0.005 per node × ~6.7 million nodes ≈ $33,500 per hour
Annual Compute Cost~$1.53 billion per year~$293 million per year (paid directly to node operators)
Electricity & CoolingHigh estimated ~$61 million per year for electricity aloneBorne by individual node operators (minimal impact on GNUS)
Network & Storage CostsAdditional expenses (~$100 million/year)Minimal—local connectivity and distributed storage
Total Annual OPEXApproximately $1.7 billion per yearOn the order of $2–$10 million per year (true OPEX for coordination)
_Note:_ For GNUS.ai, the $293 million figure represents the total “compute payment” distributed in tokens, which is a pass–through payment to node operators and not an overhead cost for the GNUS network itself. --- source: /about-gnus.ai/features-and-benefits/gnus.ai-network-vs.-centralized-xai-100k-cluster/6.-payout-structure-and-profitability/ title: 6. Payout Structure and Profitability --- # 6. Payout Structure and Profitability ### Centralized Model Profitability • Revenue Per Chip: Charging an effective $1.75 per chip per hour, with a 10% profit margin, results in a profit of approximately $0.175 per hour per chip.

 • Annual Profit:
 For each chip:
 0.175 × 8,760 ≈ $1,533 per year For 100,000 chips, this equates to roughly $153.3 million per year in compute–level profit.

 • Challenges: Despite these numbers, the centralized system must cover its enormous CAPEX and high OPEX, limiting its scalability and increasing financial risk.

 ### GNUS.ai Payout Structure • Base Payout: Each node earns $0.005 per hour in GNUS tokens.

 • Distribution Breakdown:

 • Node Operator Receives: 90% of $0.005, or $0.0045 per hour. • Genius Ventures (GV) Receives: 10% commission (i.e., $0.0005 per hour) plus 10% of the tokens are burned (a deflationary measure that increases token value). • Annual Gross Payout:
 With approximately 6.7 million nodes:
 6,700,000 × 0.005 × 8,760 ≈ $293 million per year (gross distributed value) • Conversion Fees (if converting to USD):
 Should operators choose to convert their tokens, a 2.5% fee plus an additional 1% fee (total of 3.5%) is applied.

 • Effective Annual Payout after Fees: $293 million × 0.965 ≈ $282.7 million • However, most operators are expected to hold their tokens because of the deflationary benefits. --- source: /about-gnus.ai/features-and-benefits/gnus.ai-network-vs.-centralized-xai-100k-cluster/7.-the-deflationary-token-mechanism/ title: 7. The Deflationary Token Mechanism --- # 7. The Deflationary Token Mechanism ### How It Works • Token Burn:
 Every processing cycle, 10% of the GNUS tokens used in the payout are burned (removed from circulation). • Commission:
 Genius Ventures also takes a 10% commission from the payout. • Net Effect:
 The circulating supply of GNUS tokens decreases over time, which—assuming constant or increasing demand—drives up the value per token. ### Benefits for Node Operators • Increased Token Value:
 Even though the hourly payout remains nominally at $0.005, the deflationary burn means that if tokens are held rather than immediately converted, their value increases. • Long-Term Appreciation:
 For example, if the token price increases from $3.40 on day one to $25.80 after one year (a 7.59× increase), the effective hourly payout in USD becomes: 0.005 × 7.59 ≈ $0.0379 per hour • Incentive to Hold:
 Conversion fees (a total of 3.5%) further discourage immediate conversion, incentivizing operators to hold tokens and benefit from long–term appreciation. --- source: /about-gnus.ai/features-and-benefits/gnus.ai-network-vs.-centralized-xai-100k-cluster/8.-projected-token-price-appreciation/ title: 8. Projected Token Price Appreciation --- # 8. Projected Token Price Appreciation Let’s illustrate a simplified projection over 5 years for the GNUS token. This model assumes: • A fixed annual processing value that yields $29.35 million in value burned each year. • A starting circulating supply of 20 million tokens priced at $3.40 each. • No new node additions—the model focuses solely on the deflationary impact. ### Year-by-Year Projection (Simplified)
YearCirculating Supply (Million Tokens)Tokens Burned (Million)Effective Price MultiplierProjected Token Price
020.00–1×$3.40
1~11.37~8.63~1.76×$3.40 × 1.76 ≈ $5.98
2~6.46~4.91~1.76×$5.98 × 1.76 ≈ $10.51
3~3.67~2.79~1.76×$10.51 × 1.76 ≈ $18.52
4~2.08~1.59~1.76×$18.52 × 1.76 ≈ $32.60
5~1.18~0.90~1.76×$32.60 × 1.76 ≈ $57.25
### Earnings-Adjusted Valuation If we apply a Price-to-Earnings (P/E) ratio (common in technology companies) to the annual profit captured by Genius Ventures, we get an additional multiplier. For example, if: • Annual profit (from commissions and burns) is $29.35 million. • A modest P/E of 10× is applied, the earnings–based market cap would be $293.5 million. • With the deflated token supply (for instance, 11.37 million tokens after Year 1), the earnings–adjusted price per token would be: $293.5 million​\ \---------------------— ≈ $25.80 per token.\ 11.37 million tokens This means a node operator who holds tokens for one year sees the effective hourly payout multiply by a factor of approximately 7.59 (i.e., $25.80/$3.40). --- source: /about-gnus.ai/features-and-benefits/gnus.ai-network-vs.-centralized-xai-100k-cluster/9.-summary-comparison-tables/ title: 9. Summary Comparison Tables --- # 9. Summary Comparison Tables ### CAPEX & OPEX Comparison
MetricCentralized xAI 100k ClusterGNUS.ai Decentralized Network
CAPEX Investment~$6 billion upfront (hardware, data centers, cooling, etc.)Minimal—nodes provided by end users; software CAPEX ≈ $2M total
Compute Cost (Hourly)$1.75 per chip × 100,000 chips = $175,000 per hour$0.005 per node × ~6.7 million nodes = $33,500 per hour
Annual Compute Cost~$1.53 billion/year~$293 million/year (paid as a pass-through to node operators)
Electricity & Cooling~$61 million/yearBorne by node operators (negligible to GNUS)
Network & Storage Costs~$100 million/yearMinimal—local and distributed storage
Total Annual OPEX~$1.7 billion/yearTrue OPEX for GNUS: $2–$10 million/year
### Profitability and Token Economics
MetricCentralized xAI ClusterGNUS.ai Decentralized Network
Hourly Payout/Charge$1.75 per chip$0.005 per node
Compute-Level Profit Margin~10% (i.e., $0.175 per chip per hour)Genius Ventures: 10% commission + 10% token burn
Annual Gross Processing Value~$1.53 billion for compute (with high CAPEX/OPEX)~$293 million distributed in tokens
Annual Profit Captured (GV)~$153 million total (compute–level)~$29.35 million via commission and burns
Conversion Fees (if converting)N/A (typically internal accounting)3.5% (2.5% + 1% on token-to-USD conversion)
Effective Payout if ConvertedBased on contract pricing$293 million × 0.965 ≈ $282.7 million total USD value
Incentive to Hold TokensNot applicableDeflationary mechanism may increase token value (e.g., from $3.40 to $25.80 over 1 year)
--- source: /about-gnus.ai/features-and-benefits/gnus.ai-network-vs.-centralized-xai-100k-cluster/10.-conclusion-and-next-steps/ title: 10. Conclusion and Next Steps --- # 10. Conclusion and Next Steps ### Key Takeaways • Decentralized Advantage:
 The GNUS.ai network uses end–user resources to achieve massive compute power without the need for enormous CAPEX. Operating expenses are minimal because node operators supply hardware, electricity, and network connectivity.

 • Profitable Model for Node Operators:
 With a base payout of $0.005 per hour, node operators benefit from both a 10% commission mechanism (captured by Genius Ventures) and a deflationary token burn that reduces the circulating supply. Over time, this deflation is projected to significantly increase the token’s value. For example, while the nominal hourly payout is $0.005, holding tokens for one year (assuming a price increase from $3.40 to $25.80) boosts the effective hourly payout to approximately $0.0379.

 • Comparison with Centralized Systems:
 Centralized xAI clusters demand huge CAPEX (around $6 billion) and high OPEX (approaching $1.7 billion per year) to operate, resulting in high risks and limited scalability. In contrast, GNUS.ai offers a low–cost, scalable alternative with dramatically lower operating expenses and potential for long–term token appreciation.

 • Long-Term Growth Potential:
 With modest earnings–based valuation (using a P/E ratio common for technology companies), projections indicate that the GNUS token’s price could multiply several–fold over 5 years. This appreciation is driven by the deflationary token burn mechanism and the network’s steady annual processing value.

 ### Next Steps for Node Operators 1\. Review the Model: Understand the key elements of the payout structure and the deflationary mechanism. Recognize that while the base payout is fixed at $0.005 per hour, holding the tokens rather than converting immediately can multiply your effective earnings significantly.

 2\. Consider the Long-Term Benefits: Evaluate the benefits of holding GNUS tokens over the long term. With the projected appreciation (potentially 7.59× increase after one year, and even higher over 5 years), patience can yield substantial rewards.

 3\. Get Involved: If you’re interested in joining the GNUS.ai network, ensure you understand the technical requirements and the steps needed to connect your device as a node operator. Training and documentation are available to guide you through the onboarding process.

 4\. Stay Informed: Keep up with GNUS.ai network updates, token economics revisions, and market trends. Regular updates will help you maximize your benefits and participate in community governance.

 --- source: /about-gnus.ai/features-and-benefits/gnus.ai-network-vs.-centralized-xai-100k-cluster/final-thoughts/ title: Final Thoughts --- # Final Thoughts The GNUS.ai network represents a paradigm shift from traditional, centralized computing clusters to a scalable, decentralized model. By leveraging the computing power of millions of end-user nodes and a deflationary token mechanism, GNUS.ai dramatically reduces CAPEX and OPEX while offering potentially significant long–term rewards for node operators. This report has compared the centralized xAI 100k cluster model with the GNUS.ai decentralized network across key dimensions such as CAPEX, OPEX, payout structure, and token appreciation. We hope this information helps you understand the benefits and economics of joining the GNUS.ai network. Thank you for considering participation in the GNUS.ai network. We look forward to building a future of efficient, decentralized AI processing together. --- source: /about-gnus.ai/features-and-benefits/tokenomics/ title: Tokenomics --- # Tokenomics Disclosure of Funds Raised, Token Distributions, and Funds Usage

Tokenomics for Token Raise Distribution

## Compute-Driven Token Growth The following graph shows our [Monte Carlo](https://my.machinations.io/d/gnus-economy/8683592da7e911eda2330626ff1c9bc8) simulation using two Enterprises buying AI/ML processing and three games with 12 online players. * Multiple Revenue Streams * AI/ML Processing revenue, as well as Crypto & NFT trading fee revenue * Crypto Token Advantages * Mint & Burn allows configurable profits. * Investments Scale the Network * Investments are used to scale the network by adding nodes. * Monte Carlo Analysis Simulation * Monte Carlo Analysis shows the network effect. Faster network scaling increases GNUS token price faster.

Compute-Driven Token Growth over 700 days

Circulating Supply

The GNUS token is itself subdivided into units called "Minions". 1 GNUS = 10^9 Minions. Internal SuperGenius ledgers use 64 bit values to hold Minions, which translates to a single GNUS wallet address being able to hold a max balance of 18.4 billion GNUS (with a fractional/decimal precision of 10^9). --- source: /about-gnus.ai/public-roadmap/ title: Public Roadmap --- # Public Roadmap * [ ] **Q2 2026 -** SuperGenius Blockchain Main Net released. * [x] **Q1 2026 -** SuperGenius Blockchain Beta Phase 3 * [x] **Q4 2025 -** SuperGenius Blockchain Beta Phase 2 and Security Audits. * [x] **Q2-Q3 2025 -** SuperGenius Blockchain Beta Phase 1 and Security Audits. * [x] **Q1-Q2 2025 -** SuperGenius Blockchain Alpha Phases. * [x] **Q4 2024 -** Official Test Net Launch and release to the public. 200+ games and other apps integrated into the SuperGenius blockchain * [x] **Q1 2024**- Customer portal complete. Presale customers can now redeem or buy more GNUS tokens for A.I. and. M.L. processing. * [x] **October 2023**- App user interface development. App enters Beta phase. * [x] **August 2023-** App development, including mobile wallet, mobile SDK for game integration, and a standalone app for desktops. * [x] **2021-2022**- The COVID-19 pandemic and the Russian/Ukrainian war hinder development. * [x] **June 2021-** Minimally viable product (MVP) and Initial Coin Offering (ICO) allow for continual development. * [x] **May 2021**- Dapps on the Ethereum network complete and ready for Initial Coin Offering (ICO) * [x] **April 2021**- Hybrid blockchain development begins implementing fast and slow blockchain. * [x] **October 2020**- Coding begins on implementing the Directed Acyclic Graph (DAG) fast blockchain. * [x] **January 2018**- Integration of blockchain into A.I. processing is started. Sample game, shaders, and SDK development begin. --- source: /about-gnus.ai/how-does-it-work/ title: How Does It Work? --- --- description: >- GNUS.AI combines Artificial Intelligence (AI) and the blockchain to create a powerful and flexible system. --- # How Does It Work? When a user interacts with an application or system integrated with GNUS.ai, their data is processed on a decentralized network of nodes. These nodes, distributed across the network, collectively contribute to data processing, ensuring efficiency and security. *** {% hint style="info" %} For example, let's assume you download and play a game using GNUS.ai: During your game, the device you are using experiences periods of downtime or **Idle Central Processing Unit** (CPU) capacity, especially when the game's demands vary. This means that your device has the potential to process a lot more information than the game itself demands at certain intervals. Typically, this processing power goes unused; however, GNUS.ai can tap into these idle CPU cycles for various computational tasks. This includes tasks related to AI processing, data analysis, and other functions within the GNUS.ai ecosystem. This is called **Distributed Computation** and forms the foundation of the rewards system: the more computing power your device provides and for longer intervals, the larger portion of GNUS tokens will be rewarded. This incentivizes users to actively participate in the decentralized network, fostering a collaborative ecosystem As the network scales and demand for CPU resources increases or decreases, **Dynamically Adjusted Resource Allocation** adapts based on these network demands. This ensures scalability and responsiveness, allowing the network to adapt to varying computational requirements. As you can see, this approach optimizes the use of your device's resources while allowing you to enjoy your gaming experience. {% endhint %} --- source: /about-gnus.ai/how-does-it-work/idle-central-processing-gpu/ title: Idle Central Processing (GPU) --- --- description: '-Where devices rests, but A.I. awakens.' --- # Idle Central Processing (GPU) *** \ Any application can have periods of idle GPU, regardless of the device running it. If your device can download and process the information fast enough to run the application, it will inevitably have idle CPU and GPU periods. This is where GNUS.AI steps in. Let's revisit the game application example: A user is playing a resource-intensive game on their device, utilizing the GPU for graphics rendering and the CPU for game logic. While the user is exploring less demanding areas of the game or during loading screens, the GPU may experience idle capacity, triggering: 1. **Task Activation:** GNUS.AI detects these idle moments and activates its tasks, such as processing AI-related computations, blockchain transactions, or other decentralized network activities. 2. **Background Operation:** Tasks run in the background, utilizing the available GPU capacity without affecting the gaming experience. The user continues to play the game seamlessly. 3. **Efficient Resource Allocation:** GNUS.AI intelligently scales its operations based on available resources, ensuring that it never interferes with the game's real-time requirements [(Dynamically Adjusted Resource Allocation)](dynamically-adjusted-resource-allocation.md). 4. **No Overrun or Interruption:** The user enjoys uninterrupted gameplay, and when the game demands full GPU power again, Gnus.ai gracefully reduces its activity, allowing the game to take priority. --- source: /about-gnus.ai/how-does-it-work/distributed-computation/ title: Distributed Computation --- --- description: '-Transforming latency into computational synergy.' --- # Distributed Computation Distributed Computation involves breaking down a task into smaller sub-tasks that can be processed concurrently across multiple nodes within a network. This is especially relevant when larger tasks, demanding substantial processing power, can be divided and distributed among the processing capacities of multiple users. **How GNUS.AI Utilizes Distributed Computation:** 1. **Task Division:** * GNUS.AI identifies tasks that require computational power, such as complex AI computations, blockchain transactions, or data processing. 2. **Task Distribution:** * The identified tasks are divided into smaller sub-tasks and distributed among the nodes. Each node independently processes its assigned sub-task. 3. **Parallel Processing:** * Nodes work simultaneously on their allocated sub-tasks, leveraging parallel processing capabilities. This significantly accelerates the overall task completion time. Managing computational resources highlights the flexibility of GNUS.AI to operate opportunistically during periods of device inactivity. --- source: /about-gnus.ai/how-does-it-work/dynamically-adjusted-resource-allocation/ title: Dynamically Adjusted Resource Allocation --- --- description: '-Empowering systems to adapt and thrive in the face of dynamic challenges' --- # Dynamically Adjusted Resource Allocation Dynamically adjusted resource allocation refers to a system or mechanism that allocates resources based on changing demands or conditions. In the context of GNUS.AI, it involves the intelligent distribution of resources such as processing power and memory to optimize performance and responsiveness. This concept works synergistically with distributed computation. Think of one as monitoring the demand for resources, while the other breaks down the available resources to efficiently complete the tasks. The result ensures efficient utilization of resources, scalability, and responsiveness to varying requirements. This approach helps in preventing resource bottlenecks, improving overall system performance, and enhancing the user experience. --- source: /technical-information/MASTER_ARCHITECTURE/ title: Master Architecture --- # GNUS.ai Master Platform Architecture **Canonical repository:** `GeniusVentures/documentation` **Composition repository:** `GeniusVentures/GeniusNetwork` **Role:** Canonical composition and integration map for the GNUS.ai platform **Audience:** Application developers, game developers, platform engineers, maintainers, reviewers, coding agents, and LLMs **Last architecture review:** 2026-07-28 --- ## 1. Purpose This document defines how the Genius Ventures repositories and submodules fit together when building a GNUS.ai application, game, wallet, cognitive service, node, smart-contract feature, or third-party integration. Its main purpose is to prevent developers and coding agents from rebuilding infrastructure that already exists. Before creating a new subsystem, library, protocol, wallet implementation, game adapter, token contract, networking layer, AI job service, proof system, or dependency wrapper, search the repositories identified here and determine whether the capability already exists. This document is the platform-level ownership map. Detailed implementation documentation remains in the repository that owns each subsystem. ### 1.1 Normative rules 1. **Reuse before creating.** Search the owner repository and its submodules before adding a new implementation. 2. **Use the highest stable abstraction available.** Applications should normally use `GeniusSDK`; Unity applications should normally use `UnityGeniusSDK`; applications should not reach directly into `SuperGenius` internals unless they are extending the runtime itself. 3. **Put changes in the owning repository.** Do not implement a runtime feature in a sample application or a token rule in an SDK wrapper. 4. **Treat samples as examples, not authorities.** `GeniusWallet` and `Space-Force-War` demonstrate integration patterns, but the public SDK and runtime contracts are authoritative. 5. **Distinguish architecture from deployed implementation.** `GeniusCognitiveSystem` contains the cognitive architecture and implementation inventory. A documented GCS component may still require implementation or integration work. 6. **Do not silently fork common dependencies.** Shared native dependencies belong in `thirdparty` unless there is an explicit reason to isolate them. 7. **Do not update a parent submodule pointer before the child change exists.** Implement, test, and merge in the child repository first; then update the pointer in the parent composition repository. 8. **Preserve branch and submodule intent.** The branch and pinned commit referenced by `GeniusNetwork` define the tested composition. A child repository's latest default branch is not automatically the version used by the platform. --- ## 2. Platform at a Glance ```mermaid flowchart TB User[User / Player / Developer / API Client] subgraph Applications[Application and Product Layer] Wallet[GeniusWallet
Flutter reference application] UnityGame[Space-Force-War
Unity sample game] NativeApp[Native or third-party app] CognitiveApp[GCS-powered application] end subgraph Adapters[Application Integration Layer] UnitySDK[UnityGeniusSDK
C# and Unity adapter] SDK[GeniusSDK
C-compatible native SDK boundary] GCSAPI[GCS API / orchestration boundary
OpenAI-compatible or native job ingress] end subgraph Runtime[Distributed Runtime Layer] SG[SuperGenius
node, ledger, processing, P2P, storage] Processing[SGProcessingManager] GRPC[gRPCForSuperGenius] KDF[GeniusKDF] Proof[ProofSystem] Relay[evmrelay] end subgraph Cognitive[Genius Cognitive System] Orchestration[Router / Planner / Executive Controller] ELM[Semantic Core and ELMs] Memory[GAML / Objective Memory / VTG] Verify[EIS / grounding / verification / arbitration] end subgraph Trust[Proof and On-chain Trust Layer] ZK[zkLLVM] Contracts[TokenContracts
GNUS, child tokens, settlement, bridge] end subgraph Foundation[Build and Test Foundation] Third[thirdparty
shared native dependencies] VMs[TestVMs] Downloader[GithubReleaseDownloader] end User --> Wallet User --> UnityGame User --> NativeApp User --> CognitiveApp UnityGame --> UnitySDK --> SDK Wallet --> SDK NativeApp --> SDK CognitiveApp --> GCSAPI SDK --> SG GCSAPI --> Orchestration Orchestration --> ELM Orchestration --> Memory Orchestration --> Verify Orchestration --> SG SG --> Processing SG --> GRPC SG --> KDF SG --> Proof SG --> Relay Proof --> ZK Relay --> Contracts SDK --> Contracts SG --> Third SDK --> Third Wallet --> Third ZK --> Third VMs --> SG Downloader --> Third ``` ### 2.1 The shortest correct mental model - **`GeniusNetwork` composes and pins the platform.** - **`documentation` owns the canonical published platform documentation.** - **`SuperGenius` runs the decentralized native node and processing network.** - **`GeniusSDK` is the native application-facing API boundary.** - **`UnityGeniusSDK` adapts `GeniusSDK` for Unity and C#.** - **`GeniusWallet` is the reference cross-platform wallet/application integration.** - **`Space-Force-War` is the reference Unity game integration.** - **`TokenContracts` owns on-chain GNUS and child-token behavior.** - **`GeniusCognitiveSystem` defines and coordinates the cognitive architecture that runs locally or across GNUS nodes.** - **`zkLLVM` and `ProofSystem` own proof compilation and proof workflows.** - **`thirdparty` owns shared native dependency acquisition and builds.** --- ## 3. Composition Repository: GeniusNetwork `GeniusNetwork` is the umbrella repository. It is not where every subsystem should be implemented. Its responsibilities are: - pin compatible subsystem versions through Git submodules; - provide installation and composition guidance; - coordinate cross-repository releases and integration testing; - record platform-wide architecture, conventions, risks, and ownership through the pinned `documentation` submodule; - provide a stable entry point for developers cloning the complete system. ### 3.1 Direct submodules on `develop` | Path | Repository role | Application developers should use it for | | --- | --- | --- | | `SuperGenius/` | Core distributed node/runtime | Runtime development, networking, ledger, processing, storage, proofs, node APIs | | `GeniusSDK/` | Native SDK boundary | Embedding GNUS node, account, balance, transfer, pricing, and processing features in apps | | `GeniusWallet/` | Flutter reference application | Wallet UX, account lifecycle, secure storage, cross-platform packaging, job submission patterns | | `TokenContracts/` | EVM smart contracts | GNUS and child-token rules, bridge contracts, settlement, escrow, access control, upgrades | | `thirdparty/` | Shared dependency build system | Adding or updating common native libraries and platform builds | | `zkLLVM/` | Zero-knowledge compiler/toolchain | Circuit compilation, assignment, proof-related tooling, verifier generation | | `TestVMs/` | Test environments | Reproducible VM-based platform testing | | `GithubReleaseDownloader/` | Release support utility | Downloading GitHub release artifacts used by builds/installers | | `documentation/` | Canonical platform documentation and docs.gnus.ai build | Platform architecture, developer documentation, navigation, LLM catalogs, and published reference material | ### 3.2 Architecturally connected repositories not currently direct submodules These repositories are part of the platform architecture even when they are not pinned directly by the current `GeniusNetwork/develop` `.gitmodules` file. | Repository | Role | Relationship to GeniusNetwork | | --- | --- | --- | | `GeniusCognitiveSystem` | Cognitive architecture, specifications, module inventory, and GCS documentation | Defines how AI reasoning, memory, routing, verification, tools, and swarm cognition use GNUS infrastructure | | `UnityGeniusSDK` | Unity/C# adapter and packaged game integration | Wraps native `GeniusSDK` artifacts for Unity applications | | `Space-Force-War` | Reference Unity game | Demonstrates how a game consumes `UnityGeniusSDK` and replaces ad-centric monetization with GNUS participation | Their absence from the root `.gitmodules` file does not authorize recreating their functionality inside another repository. --- ## 4. Repository and Subsystem Ownership ## 4.1 SuperGenius: distributed native runtime `SuperGenius` owns the C++ native runtime. It is the core implementation for: - node startup and lifecycle; - account and transaction processing; - the block-lattice ledger; - peer discovery and peer-to-peer communication; - distributed processing jobs; - CRDT state and replicated storage; - IPFS-based content exchange; - RocksDB-backed persistence; - subscriptions and message watching; - proof generation and verification integration; - gRPC-facing node services; - EVM relay integration; - local secure storage used by the runtime. ### Do not reimplement outside SuperGenius Do not create a second P2P network, ledger, job network, node database, proof coordinator, CRDT store, or peer-discovery stack in an application repository when the work belongs in `SuperGenius`. ### Direct consumers - `GeniusSDK` links to and wraps the runtime. - `GeniusWallet` consumes packaged runtime/SDK functionality. - GCS execution services use the runtime's processing, networking, storage, and trust capabilities. - proof and relay submodules connect the native runtime to ZK and EVM systems. ## 4.2 SuperGenius nested submodules | Submodule | Ownership | | --- | --- | | `gRPCForSuperGenius/` | Protocol Buffer definitions and generated gRPC interfaces for node communication | | `GeniusKDF/` | Key-derivation functionality shared by the runtime and account/security flows | | `ProofSystem/` | GNUS-specific proof circuits, proof orchestration, and verification integration | | `SGProcessingManager/` | Distributed processing job schemas, generated interfaces, and processing-manager behavior | | `docs/` | SuperGenius developer/runtime documentation maintained as its own repository | | `evmrelay/` | Native-to-EVM relay and bridge-facing runtime integration | A change to one of these capabilities should normally be made in its nested repository, followed by a `SuperGenius` pointer update and then, when required, a `GeniusNetwork` pointer update. ## 4.3 GeniusSDK: canonical application boundary `GeniusSDK` is the embeddable native library that exposes GNUS runtime functionality to applications. Its public C-compatible API exists so that C++, C#, Dart FFI, Unity, mobile, desktop, and other language bindings can use the runtime without depending on internal C++ classes. The public API includes or is intended to include: - SDK/node initialization and shutdown; - initialization progress and node state; - account creation, recovery, selection, and secure key-based initialization; - address and token identifiers; - balances and token-value conversion; - transfers and transaction status; - developer payment flows; - processing job submission and processing status; - native memory ownership helpers for FFI consumers. ### Boundary rule An application should use `GeniusSDK` rather than link directly to internal `SuperGenius/src` classes unless the application is explicitly a runtime-development tool. ### Binding rule Language and engine adapters must wrap the public `GeniusSDK` ABI. They must not duplicate account, balance, pricing, transaction, processing, or node-lifecycle logic in managed code. ## 4.4 UnityGeniusSDK: Unity adapter `UnityGeniusSDK` owns the Unity-facing integration: - C# P/Invoke declarations for the native GeniusSDK library; - Unity lifecycle initialization and shutdown; - persistent application data paths and developer configuration; - Unity components for balance display; - GNUS-to-display-price calculation; - purchase and developer-payment components; - UnityEvents and scene-friendly wrappers; - platform packaging for Android, iOS, macOS, Windows, and Linux; - Unity example scenes and prefabs. ### Unity rule Do not create a new independent Unity networking, wallet, or token implementation. Extend `UnityGeniusSDK` and keep it aligned with the current `GeniusSDK` ABI. ### ABI warning The Unity wrapper and the native SDK can evolve at different rates. Before changing P/Invoke signatures, compare them against the exact `GeniusSDK` commit being packaged. The native header is authoritative; stale sample signatures must not become a second API. ## 4.5 Space-Force-War: reference Unity game `Space-Force-War` is a sample product, not a foundational SDK. It demonstrates: - importing the Unity SDK into a real Unity project; - initializing GNUS services from a persistent game object; - displaying a player's Minion/GNUS-derived balance; - calculating token-denominated item prices; - triggering in-game rewards after successful purchases; - replacing or reducing advertising with GNUS compute participation and token utility. Reusable Unity integration improvements belong in `UnityGeniusSDK`, not only in `Space-Force-War`. Game-specific scenes, assets, progression, UI, and mechanics remain in `Space-Force-War`. ## 4.6 GeniusWallet: reference wallet and application `GeniusWallet` is the cross-platform Flutter reference application. It shows how product code composes wallet, network, and GNUS capabilities. It owns or demonstrates: - Flutter application lifecycle and navigation; - wallet creation, recovery, selection, and display; - secure local storage and platform keychain integration; - token lists, balances, transactions, and token detail screens; - runtime/network configuration assets; - GNUS processing-job submission UI; - WalletConnect/Reown integration; - fiat on-ramp and token-routing integrations; - desktop and mobile packaging; - application observability and UI state management. ### Wallet rule Use `GeniusWallet` as the product-level reference for a Flutter or wallet application, but put reusable native runtime functionality in `GeniusSDK` or `SuperGenius`. Do not copy a complete wallet implementation into every new application. Reuse its packages, patterns, or extracted shared components where appropriate. ## 4.7 TokenContracts: on-chain policy and settlement `TokenContracts` owns the Ethereum/EVM smart contracts and their tests, deployment, upgrade, and verification workflows. Its scope includes: - GNUS token contracts; - ERC-20 compatibility and proxy behavior; - hierarchical and child-token behavior; - ERC-1155 token functionality; - mint, burn, escrow, payment split, and settlement rules; - access control and ownership; - upgradeable diamond facets and storage; - bridge-facing contracts and events; - on-chain proof verifiers; - token lifecycle, transfer policy, and reserve-backed behavior when approved; - deployment scripts, ABI generation, tests, and security analysis. ### Contract boundary rule Business rules that must be trustless, globally consistent, or economically enforceable belong in `TokenContracts`. UI behavior, local caching, node networking, AI inference, and game mechanics do not belong in Solidity merely because they use tokens. ### Source-of-truth rule For deployed behavior, the deployed contract, verified source, ABI, storage layout, and deployment records outrank older prose summaries. ## 4.8 GeniusCognitiveSystem: cognitive operating architecture `GeniusCognitiveSystem` defines the integrated distributed cognitive platform built on GNUS.ai infrastructure. It separates cognitive functions into independently evolvable components, including: - ingress, identity, session, policy, and privacy context; - Executive Controller, Router, Planner, and execution graph compilation; - Semantic Core and role/domain Expert Language Models; - GAML governed long-term memory; - Objective Memory and Verified Transition Graphs; - grounding and retrieval; - verification, arbitration, synthesis, and reputation-weighted consensus; - Execution Integrity System attestations; - secure Tool Intermediary and capability enforcement; - local, private, swarm, verified-swarm, and agent execution modes; - retraining/adaptation systems such as EGGROLL; - OpenAI-compatible API routing into GNUS jobs; - local Second Brain and enterprise/private deployment modes. ### GCS relationship to the native platform GCS is not a replacement for `SuperGenius`, `GeniusSDK`, `TokenContracts`, or `thirdparty`. It uses them: - `SuperGenius` supplies distributed compute, networking, job execution, replicated state, and node identity. - `GeniusSDK` supplies local application access to a GNUS node. - `SGProcessingManager` supplies low-level processing job structures and runtime coordination. - `thirdparty` supplies inference, networking, storage, cryptography, and platform libraries. - `ProofSystem` and `zkLLVM` supply proof and execution-verification foundations. - `TokenContracts` supplies economic settlement and on-chain policy where required. ### Specification warning The GCS repository is an architecture and product/technical specification as well as an implementation inventory. Do not assume every documented component already exists as a production service. Before implementing a GCS item, search all Genius Ventures repositories for an existing module, prototype, schema, or service. ## 4.9 zkLLVM and ProofSystem These layers are related but not interchangeable. - `zkLLVM` is the general compiler/toolchain layer for translating supported computation into proof-oriented circuit representations and verifier artifacts. - `SuperGenius/ProofSystem` owns GNUS-specific proof circuits and runtime proof workflows. - `SuperGenius` integrates proof creation and validation into node and processing behavior. - `TokenContracts` contains on-chain verifier integration when a proof must be checked by an EVM contract. Do not create a separate proof compiler in `SuperGenius`, a separate GNUS proof workflow in an application, or duplicate verifier logic without first checking these layers. ## 4.10 thirdparty: shared dependency foundation `thirdparty` centralizes native dependency versions and platform builds used by the runtime and SDK. It includes or orchestrates libraries for: - Boost and common C++ utilities; - gRPC and Protocol Buffers; - libp2p and asynchronous networking; - IPFS and pub/sub; - RocksDB, SQLite, and CRDT dependencies; - OpenSSL, CryptoPP, secp256k1, Ed25519, and wallet-core; - MNN and GPU/runtime dependencies; - logging, formatting, JSON, YAML, testing, and build utilities; - Android, iOS, macOS, Windows, and Linux targets. ### Dependency rule If more than one native subsystem needs a library, add and pin it in `thirdparty`. Do not vendor separate copies into `SuperGenius`, `GeniusSDK`, `UnityGeniusSDK`, or an application unless platform isolation is explicitly required and documented. ## 4.11 TestVMs and release support - `TestVMs` provides reproducible operating-system environments for integration testing. - `GithubReleaseDownloader` supports consumption of prebuilt release artifacts. - Root `util/` scripts support installation and environment setup. These are support systems. Application business logic does not belong in them. --- ## 5. Canonical Application Architectures ## 5.1 Native C or C++ application ```text Application UI and business logic -> GeniusSDK public C ABI -> SuperGenius runtime -> P2P, ledger, processing, storage, proofs -> TokenContracts through approved EVM/bridge paths ``` Recommended steps: 1. Clone `GeniusNetwork` recursively or use compatible release artifacts. 2. Build `thirdparty` for the target platform. 3. Build `SuperGenius` for the target platform and ABI. 4. Build and link `GeniusSDK`. 5. Initialize through the public SDK API. 6. Keep application state and UX in the application. 7. Add reusable runtime behavior to `SuperGenius`, not the application. 8. Add reusable app-facing behavior to `GeniusSDK`, not a private wrapper. ## 5.2 Unity game ```text Unity game scripts and scenes -> UnityGeniusSDK components and C# wrapper -> packaged GeniusSDK native library -> SuperGenius runtime -> GNUS network and processing -> token/settlement path ``` Use `Space-Force-War` to see a complete game integration. A Unity game should generally contain only: - game-specific configuration; - player-facing UI; - reward mapping; - calls into `UnityGeniusSDK`; - game-specific success/failure handling. It should not contain its own GNUS node, P2P protocol, wallet cryptography, token ledger, price oracle framework, or duplicated native ABI. ## 5.3 Flutter or wallet-style application ```text Flutter product UI -> Dart packages / FFI / gRPC integration -> GeniusSDK and SuperGenius -> native secure storage, accounts, network, processing -> EVM wallet and external service adapters ``` Use `GeniusWallet` as the reference for: - platform packaging; - secure storage; - wallet and account UX; - network configuration; - token and transaction screens; - processing-job submission; - external wallet and on-ramp integrations. Reusable native functionality still belongs below the Flutter layer. ## 5.4 Third-party application or service A third-party integrator should choose the smallest supported boundary: 1. **Packaged application SDK** when embedding a local node is appropriate. 2. **gRPC node API** when integrating with a separately managed GNUS node. 3. **GCS/OpenAI-compatible API** when requesting cognitive work rather than low-level node operations. 4. **EVM ABI** when interacting only with deployed token contracts. Do not require third parties to understand internal C++ classes or submodule layout. ## 5.5 GCS-powered application ```text Client or application request -> GCS ingress/API -> identity, policy, privacy, and budgeting -> Router / Planner / Executive Controller -> GAML context and memory -> Semantic Core and selected ELMs -> optional tools through Tool Intermediary -> optional distributed work through SuperGenius -> verification / EIS / arbitration / consensus -> response and memory-write evaluation -> optional TokenContracts settlement ``` A GCS-powered app should not create its own parallel: - model router if the request should use the GCS router; - agent permission system if the capability system applies; - long-term memory format if GAML applies; - execution-attestation format if EIS applies; - swarm scheduler if SuperGenius/GCS scheduling applies; - token billing contract if `TokenContracts` already supports the economic model. --- ## 6. Runtime Data Flows ## 6.1 Node and account startup ```text Application -> GeniusSDKInit / key or mnemonic initialization -> GeniusSDK creates or restores account context -> SuperGenius initializes storage, processing, blockchain, transactions, and DHT -> SDK reports initialization and node state -> application enables GNUS features when ready ``` Private keys and mnemonic phrases must stay inside approved secure-storage and SDK/runtime boundaries. A sample application must not log or transmit them. ## 6.2 Token purchase or in-app utility ```text User selects item or service -> application calculates product requirement -> SDK retrieves balance and relevant pricing -> approved token transfer/payment call -> runtime and/or EVM settlement path executes -> application grants product only after confirmed success ``` The application owns the product entitlement. The SDK owns the integration call. The contract owns on-chain economic enforcement. ## 6.3 Distributed processing job ```text Application or GCS -> SDK, gRPC, or GCS ingress -> SGProcessingManager job representation -> SuperGenius processing engine -> peer selection and distributed execution -> proof/verification path when required -> result delivery -> accounting and settlement path ``` Do not create a second ad hoc job schema inside a game if the processing manager already defines the required job type. ## 6.4 GCS cognitive request ```text Request -> deterministic ingress and policy -> smallest effective cognitive execution set -> local or distributed expert execution -> grounding, memory, tools, and verification as required -> deterministic or reputation-weighted synthesis -> response, attestations, and governed memory update ``` Model workers propose cognitive output. Deterministic services remain authoritative for authorization, privacy, schemas, cryptographic verification, side effects, attestations, retention, billing, and settlement. --- ## 7. Where New Code Belongs | Change | Owning repository | | --- | --- | | New peer protocol or discovery behavior | `SuperGenius` or the appropriate nested networking repository | | Node lifecycle, ledger, CRDT, storage, processing engine | `SuperGenius` | | Processing job schema or generated processing interfaces | `SGProcessingManager` | | Public node gRPC method or protobuf schema | `gRPCForSuperGenius` | | Key derivation primitive | `GeniusKDF` | | GNUS-specific proof circuit or runtime proof workflow | `ProofSystem` | | General circuit compiler/toolchain feature | `zkLLVM` | | New EVM relay behavior | `evmrelay` | | Public native app API | `GeniusSDK` | | Unity/C# wrapper, component, prefab, or package | `UnityGeniusSDK` | | Flutter wallet UX or wallet product integration | `GeniusWallet` | | Unity game-specific mechanic or sample scene | `Space-Force-War` | | Smart-contract economics, token lifecycle, escrow, bridge event, upgrade | `TokenContracts` | | Cognitive routing, memory, capability, verification, EIS, ELM, or agent architecture | `GeniusCognitiveSystem` plus the implementation repository identified during planning | | Shared native library version or platform build | `thirdparty` | | Platform composition and submodule pins | `GeniusNetwork` | | Canonical platform documentation and docs.gnus.ai integration | `documentation` | ### 7.1 Decision tree ```text Is the change product-specific UI or gameplay? yes -> product/sample repository no -> continue Is it a Unity-specific binding or reusable Unity component? yes -> UnityGeniusSDK no -> continue Is it an app-facing native capability? yes -> GeniusSDK, backed by SuperGenius where needed no -> continue Is it node, P2P, ledger, storage, processing, or runtime behavior? yes -> SuperGenius or its owning nested submodule no -> continue Is it trustless token or settlement behavior? yes -> TokenContracts no -> continue Is it cognitive orchestration, memory, agents, verification, or model behavior? yes -> consult GeniusCognitiveSystem inventory, then use the designated implementation repo no -> continue Is it a shared native dependency? yes -> thirdparty no -> document the missing ownership decision before creating a new repository ``` --- ## 8. LLM and Coding-Agent Instructions Every coding agent working in the GNUS.ai platform or a child repository must follow this sequence. ### 8.1 Required discovery sequence 1. Read this document. 2. Read `.gitmodules` at the target branch. 3. Read `.planning/codebase/ARCHITECTURE.md`, `STRUCTURE.md`, `INTEGRATIONS.md`, `CONVENTIONS.md`, `TESTING.md`, and `CONCERNS.md` where present. 4. Identify the repository that owns the requested behavior. 5. Search that repository and its nested submodules for existing APIs, schemas, classes, tests, examples, and unfinished work. 6. Check `GeniusWallet` or `Space-Force-War` for reference usage. 7. Check `GeniusCognitiveSystem` before inventing an AI, agent, memory, verification, routing, capability, or orchestration subsystem. 8. Check `TokenContracts` before inventing token, entitlement, settlement, escrow, bridge, or lifecycle logic. 9. Check `thirdparty` before adding a dependency directly. 10. State which existing component will be extended before proposing new architecture. ### 8.2 Prohibited shortcuts An agent must not: - create a new SDK because an existing binding is inconvenient; - duplicate SuperGenius networking in an app; - implement wallet cryptography in game scripts; - copy smart-contract accounting into an off-chain database and call it authoritative; - copy sample code into a second reusable library without updating the owner SDK; - add a native dependency independently when `thirdparty` already owns it; - treat all GCS specification components as already deployed; - assume a repository's default branch matches the submodule commit; - update submodule pointers to unreviewed commits; - change public ABI signatures in one binding without checking all consumers; - invent a new token type or lifecycle without checking the hierarchical token contracts; - invent a new agent memory or capability format without checking GAML and the GCS capability architecture. ### 8.3 Required proposal format Before a cross-repository implementation, document: ```text requested capability existing owner repository existing implementation or nearest reusable component public interface affected nested submodules affected application/sample consumers affected contract or token implications GCS implications thirdparty dependency implications migration and compatibility requirements tests required in each repository submodule pointer update order ``` --- ## 9. Versioning and Submodule Workflow ### 9.1 Correct update order For a change originating in a nested component: ```text nested repository change -> tests and merge in nested repository -> parent repository submodule pointer update -> parent integration tests -> GeniusNetwork pointer update -> platform integration tests ``` Example: ```text gRPCForSuperGenius -> SuperGenius -> GeniusSDK -> UnityGeniusSDK and/or GeniusWallet -> GeniusNetwork ``` Not every change touches every level, but pointer updates must follow dependency direction. ### 9.2 Branch authority - Use the branch named by the task or the active integration branch. - Read the pinned submodule commit from that branch. - Do not substitute `main`, `develop`, or the newest tag without checking compatibility. - Protect long-lived integration branches. - Open reviewable PRs for platform composition changes. ### 9.3 Public API compatibility Changes to the `GeniusSDK` C ABI, gRPC schemas, processing schemas, contract ABIs, or persisted data require explicit compatibility review. Consumers may include: - Unity C# P/Invoke; - Flutter/Dart FFI; - native applications; - released binary artifacts; - gRPC clients; - wallet packages; - GCS services; - external third-party integrations. --- ## 10. Source-of-Truth Hierarchy When documentation conflicts, use this order: 1. Deployed contract bytecode, verified source, storage layout, and deployment records for on-chain behavior. 2. Pinned source commit and tests for runtime behavior. 3. Public headers, protobuf schemas, ABI files, and generated interfaces. 4. Current repository-specific architecture and implementation plans. 5. This platform architecture document. 6. Sample applications and example code. 7. Historical README text, presentations, and product summaries. A sample that calls an obsolete function is evidence that the sample needs updating, not evidence that the obsolete function is still canonical. --- ## 11. Known Boundaries and Documentation Caveats 1. `GeniusNetwork/develop` and `main` may pin different subsystem commits. This document is authored from the `develop` integration line. 2. `UnityGeniusSDK`, `Space-Force-War`, and `GeniusCognitiveSystem` are architecturally connected but are not direct submodules in the current `develop` root `.gitmodules` file. 3. The Unity wrapper must be checked against the current native SDK header before release; examples may lag ABI evolution. 4. GCS documents describe both implemented foundations and planned modules. Implementation status must be confirmed per component. 5. Token economics and contract architecture have evolved. Use current contract code, tests, deployment records, and approved phase plans rather than relying solely on early README descriptions. 6. Third-party versions must be taken from pinned submodules and build definitions, not approximate versions in narrative documents. 7. Security-sensitive operations must remain inside their defined trust boundary even when moving them into an application would appear simpler. --- ## 12. Canonical References ### Documentation - `MASTER_ARCHITECTURE.md` — this canonical platform ownership and integration map - `gendoc.yml` — docs.gnus.ai source, navigation, deployment, and LLM configuration - `llms-meta.json` — document catalog metadata used by LLM and retrieval pipelines ### GeniusNetwork - `.gitmodules` — direct composition - `.planning/codebase/ARCHITECTURE.md` — generated codebase architecture analysis - `.planning/codebase/STRUCTURE.md` — detailed directory map - `.planning/codebase/INTEGRATIONS.md` — external service and infrastructure map - `.planning/codebase/CONVENTIONS.md` — coding and repository conventions - `.planning/codebase/TESTING.md` — test infrastructure - `.planning/codebase/CONCERNS.md` — technical risks and known concerns - `INSTALL.md` — installation and dependency setup - `ThirdParty_Libraries_Integration.md` — dependency catalog ### Runtime and SDK - `SuperGenius/Readme.md` - `SuperGenius/src/` - `SuperGenius/.gitmodules` - `GeniusSDK/Readme.md` - `GeniusSDK/src/GeniusSDK.h` ### Applications and samples - `GeniusWallet/README.md` - `GeniusVentures/UnityGeniusSDK` - `GeniusVentures/Space-Force-War` ### Cognitive system - `GeniusVentures/GeniusCognitiveSystem/docs/architecture/README.md` - `GeniusVentures/GeniusCognitiveSystem/docs/architecture/agent-module-development-inventory.md` ### Contracts, proofs, and dependencies - `TokenContracts/README.md` - current `TokenContracts` planning and contract documentation - `zkLLVM/README.md` - `SuperGenius/ProofSystem/` - `thirdparty/README.md` - `ThirdParty_Libraries_Integration.md` --- ## 13. Architecture Review Checklist Before approving a new application or subsystem, verify: - [ ] The owner repository is identified. - [ ] Existing code and unfinished plans were searched. - [ ] The public SDK or protocol boundary is reused. - [ ] Sample code is not being mistaken for the canonical implementation. - [ ] Native dependencies are routed through `thirdparty` where appropriate. - [ ] Wallet and key operations stay inside approved security boundaries. - [ ] Token and settlement rules use `TokenContracts` where trustless enforcement is required. - [ ] GCS features align with the GCS component inventory. - [ ] Unity work extends `UnityGeniusSDK` rather than creating a parallel wrapper. - [ ] Cross-repository ABI and schema consumers are identified. - [ ] Tests are planned at the owning layer and integration layer. - [ ] Submodule pointer updates follow dependency order. - [ ] Documentation clearly labels implemented, reference, experimental, and planned behavior. --- ## 14. Final Rule **Do not solve a platform problem inside the nearest application merely because that application exposed the problem first.** Find the owning layer, extend the existing implementation, update its public boundary, update the reference consumers, and then pin the tested composition in `GeniusNetwork`. --- source: /technical-information/app-howto/ title: How to Build an App on the GeniusNetwork --- # How to Build a Native App on the GNUS / SuperGenius Platform This is the recipe for creating a new application (like Genius Tube, Genius AI Boss, or GeniusWallet) that runs as a native peer on the GNUS and SuperGenius networks. It is written for both humans and LLM agents: follow it top to bottom and you get a buildable, correctly-integrated app. ## 1. What an app is An app is a **native C++17 core plus an optional Flutter presentation layer**. The C++ core owns networking, identity, cryptography, distributed state, payments, and protocol validation by linking the platform libraries. Flutter (if present) renders screens and forwards user intent across an FFI boundary. The app talks to the world through SuperGenius (peer network, GlobalDB/CRDT, transactions) and GeniusSDK (the C ABI apps consume), and reads entitlement/ownership truth from the TokenContracts on EVM. **Golden rule (from MASTER_ARCHITECTURE.md):** when a capability already exists in SuperGenius, GeniusSDK, GeniusWallet, or thirdparty, link it. Apps own their domain logic and build everything else from the platform. ## 2. Workspace layout Apps live in a shared workspace next to the platform repos: ``` GeniusNetwork/ <- workspace root ("super root") SuperGenius/ <- peer network, GlobalDB, accounts, processing GeniusSDK/ <- C ABI + cmake umbrella for platform deps GeniusWallet/ <- Flutter wallet, reusable packages, ffigen configs TokenContracts/ <- EVM contracts (entitlement truth) thirdparty/ <- ALL dependencies, pinned commits, built from source documentation/ <- platform docs (you are here) apps/ your-app/ <- the new app genius-ai-boss/ <- reference app (plugin framework, codegen patterns) ``` Every dependency comes from `thirdparty/` at a pinned commit and is built by CMake, which makes builds auditable and identical across macOS, Linux, Windows, Android, and iOS. ## 3. The universal build pattern Every repo in the workspace — libraries and apps alike — builds the same way: ```bash cd build/ # OSX | Linux | Windows | iOS | Android mkdir Debug && cd Debug # or Release, RelWithDebInfo cmake .. -G Ninja -DCMAKE_BUILD_TYPE=Debug ninja ninja install ``` `build/` is the **cmaketemplate** submodule shared by all repos. Its `build//CMakeLists.txt` is the configure entry point; it sets the toolchain, platform variables, and `PROJECT_ROOT`, then includes `cmake/CommonBuildParameters.cmake` from the repo, which descends into `src/`. Build order for a fresh machine: `thirdparty` -> `SuperGenius` -> `GeniusSDK` -> your app. ## 4. App repository skeleton ``` your-app/ build/ <- cmaketemplate submodule cmake/ CommonBuildParameters.cmake <- project settings; included by build/ GeniusDependencies.cmake <- locates workspace (GeniusSDK/SuperGenius/thirdparty) include/your_app/ <- public headers, snake_case dir src/ CMakeLists.txt platform//platform/Platform.hpp <- one dir per OS, names match build/ generated/CMakeLists.txt <- codegen targets; output regenerates at build time ffi/ <- C ABI facade (.h + .cpp) tools/ffigen/ <- ffigen yaml configs tests/ ``` Key conventions: * **Naming**: targets `your_app_*`, include root `include/your_app/`. * **C++17** — set in the root cmake for every target. * **Platform abstraction**: source does `#include "platform/Platform.hpp"`. The `build//` entry point adds exactly one `src/platform//` include dir, so platform knowledge lives in one directory per OS. * **Generated code** regenerates under `src/generated/` via CMake stamp-file targets on every build that needs it; the tree stays out of git. ## 5. Consuming the platform Your `cmake/CommonBuildParameters.cmake` locates the workspace (walk up from the checkout until a dir containing GeniusSDK, SuperGenius, and thirdparty is found), prepends each platform repo's installed build tree (`/build///`) to `CMAKE_PREFIX_PATH`, and then `find_package(... CONFIG REQUIRED)`s the platform packages (`GeniusSDK`, `SuperGenius`, ...). Your targets link the imported targets (e.g. `sgns::GeniusSDK`). GeniusWallet's `cmake/CommonBuildParameters.cmake` is the reference consumer. Platform code is consumed **only** as installed CMake packages. Every repo builds and installs itself with the universal pattern, and consumers use `find_package` against that installed tree. Do not `add_subdirectory()` or `include()` another repository's source-level CMake — that builds a second, divergent copy of the platform inside your app and breaks the moment the two repos drift. Rules of engagement: * **Wire messages and signing authority come from the platform.** Chain signed transactions are the signature of record. App-persisted values are plain C++ structs; use nlohmann/json (from thirdparty) where serialization is needed. * **Errors**: follow SuperGenius's `outcome::result` + per-service error enums. Retryability is a fixed property of each error code, declared with the enum. * **Logging**: spdlog for all diagnostic output. * **Extensibility**: register capabilities as plugins keyed by the FNV-1a hash of a versioned string (e.g. `hpke/x25519/aes256gcm/v1`), looked up through a typed service locator — see `apps/genius-ai-boss/backend/scaffold/src/singleton/` for the pattern. ## 6. Flutter (optional) Add Flutter when the app has a UI. * Flutter owns screens, navigation, and rendering. * The C++ core exposes a **C ABI** (`extern "C"` facade header under `include/your_app/ffi/`). All exceptions are caught at the boundary and returned as error structs. * Dart bindings are generated by **ffigen** from that C header. Copy the config pattern from `GeniusWallet/packages/genius_api/gen_sgns_ffi.yaml`; drive it from a `src/generated/` CMake target. Error codes and strings are exposed as FFI functions so Dart reads the taxonomy straight from the core. * For wallet flows, the reusable **GeniusWallet packages** cover first-party identity; **reown_appkit** (the maintained WalletConnect successor) covers external EVM wallets. ## 7. Testing and quality gates * Google Test (from thirdparty), >= 80% coverage target. * Use the project wait-condition templates (condition_variable/polling) for asynchronous test synchronization. * Crypto test vectors are deterministic and run in both the C++ and Dart harnesses from shared versioned fixtures. * FFI boundary tests run under ASan/UBSan; LeakSanitizer watches key buffers. Fuzz the parsers and validators your app owns. * clang-format / clang-tidy before commit (Allman braces, workspace naming). All code follows the workspace coding standards in [`software-engineering-handbook/`](software-engineering-handbook/): [C++ Coding Standards](software-engineering-handbook/c++-coding-standards.md) for the native core and [Dart Coding Standards](software-engineering-handbook/dart-coding-standards.md) for the Flutter layer. The Dart standard is a small delta on the C++ one — read the C++ standard first, then the delta. ## 8. Checklist for a new app 1. Create `apps/your-app/` with the skeleton above; add the cmaketemplate submodule at `build/`. 2. Set C++17, target naming, and the platform-include selection in `cmake/CommonBuildParameters.cmake`. 3. Add `src/platform//platform/Platform.hpp` for each target OS. 4. Verify: `cd build/OSX && mkdir Debug && cd Debug && cmake .. -G Ninja -DCMAKE_BUILD_TYPE=Debug && ninja && ninja install` on a clean checkout. 5. Add the C ABI facade + ffigen config (if Flutter), regenerate bindings. 6. Register your app's plugins/services through the locator; write the smoke test that assembles your versioned capability strings. 7. Then start domain phases (data model, services, UI). ## Where to read more * `documentation/MASTER_ARCHITECTURE.md` — repo ownership, trust boundaries, how the platform fits together. * `documentation/docs/technical-information/super-genius-blockchain-technical-details/` — GlobalDB key grammar, account/address derivation, ElGamal keys. * `apps/genius-ai-boss/` — plugin/singleton framework and Jinja2 codegen patterns. * `GeniusWallet/packages/genius_api/` — ffigen + Flutter FFI consumption pattern. * `apps/genius-tube/.planning/phases/00-architecture-schema-freeze/00-CONTEXT.md` — a worked example of freezing these decisions for a real app. --- source: /technical-information/software-engineering-handbook/ title: Software Engineering Handbook --- # Software Engineering Handbook This handbook outlines core software engineering principles, coding standards, and best practices for the GNUS.AI team. It is designed to be language-agnostic, applicable to technologies like TypeScript, Java, C++, Solidity, React, and others used in our blockchain and cryptography projects. These guidelines emphasize maintainable, readable code, adherence to SOLID principles, data-driven design, thorough unit testing, and responsible use of AI and code generation tools with human oversight. They align with expectations from engineer job descriptions (e.g., Senior Engineers mentoring on architecture, Junior Engineers building foundational habits) and project prompts emphasizing clear requirements, modularity, and iterative development. ### Preferred contributor guidelines * Use the develop branch unless you are working on a major change that you think will be hard to fix breaking the develop branch, or is a major feature then use a feature branch and do a pull request to the develop branch. * Use git rebase instead of merge [Here's Why](https://spin.atomicobject.com/2017/04/23/maintain-clean-git-history/) * Pulls to master will be done on as-needed, since we operate on develop branches, this won't be very often. ### Git Rebase Workflows Please read this blog about the appropriate way to use git rebase workflows. [Git Rebase Workflow](https://nvie.com/posts/a-successful-git-branching-model/) ### Coding Standards Follow these standards to ensure consistency, readability, and maintainability across all languages: * **Naming Conventions**: Use descriptive, meaningful names. Prefer camelCase for variables/functions in TypeScript/Java; snake\_case for C++ where idiomatic. Constants should be UPPERCASE\_WITH\_UNDERSCORES. * **Indentation and Formatting**: Use 4-space indentation (no tabs). Limit lines to 80-100 characters. Use tools like Prettier (TypeScript/JavaScript), clang-format (C++), or equivalent. * **Comments and Documentation**: Write comments explaining "why," not "what." Use JSDoc (TypeScript), Javadoc (Java), or Doxygen (C++) for public APIs. Document Solidity contracts clearly. * **Error Handling**: Handle errors explicitly with try-catch or equivalent. Avoid silent failures. In Solidity, use require/revert for preconditions. * **Modularity**: Write small, reusable functions/modules (aim for <20-30 lines per function). * **Performance**: Optimize only when profiling indicates need, especially in performance-critical C++ (e.g., cryptography). Prioritize security in blockchain code. * **Version Control**: Commit frequently with descriptive messages. Use feature/bug branches, following Git Flow or similar. These apply similarly to TypeScript, Java, C++, and other structured languages, adjusted for language idioms. ### SOLID Principles Adhere to SOLID principles for flexible, maintainable object-oriented design: * **Single Responsibility Principle (SRP)**: A class should have one reason to change. E.g., separate data access, business logic, and UI in React or Solidity contracts. * **Open-Closed Principle (OCP)**: Classes should be open for extension, closed for modification. Use interfaces/abstract classes in Java/C++ or TypeScript types. * **Liskov Substitution Principle (LSP)**: Subtypes must be substitutable for base types without breaking correctness. Ensure derived classes honor contracts. * **Interface Segregation Principle (ISP)**: Prefer small, specific interfaces over large ones. In Solidity, design focused contract interfaces. * **Dependency Inversion Principle (DIP)**: Depend on abstractions, not concretions. Program to interfaces, using design patterns or data-driven approaches (see below) to decouple dependencies. Senior Engineers should mentor on SOLID in architectural decisions; Junior Engineers apply them daily. ### Data-Driven Design Principle Prefer **data-driven design** over code-driven approaches to enhance flexibility and maintainability: * **Programming to Interfaces**: Always code to interfaces or abstract types (e.g., `interface` in TypeScript/Java, pure virtual classes in C++). This supports loose coupling and aligns with DIP. * **Loosely Coupled, Self-Contained Classes**: Design classes to minimize dependencies. Each class should manage its own data and behavior, interacting via well-defined interfaces. * **Hierarchical Object Creation via Serialization**: Use data formats like XML or JSON to instantiate objects by ID or type, avoiding hardcoded type information. Classes should serialize/deserialize their own data, enabling child classes to do the same hierarchically. * **Example**: A C++ cryptography module could load a JSON config specifying an algorithm ID (e.g., AES), instantiate the corresponding class, and let it handle its own data serialization. In TypeScript/React, a component might load its state from JSON. * **Benefits**: Reduces tight coupling, supports dynamic object creation, and simplifies cross-language integration in blockchain systems. * **Application**: Use this approach where possible, especially for systems requiring flexibility (e.g., plugin architectures, API-driven components). ### Design Pattern Standards Design patterns from the Gang of Four (GoF) book complement SOLID principles, providing reusable solutions that promote loosely coupled, maintainable code. Use patterns judiciously to support project needs and SOLID goals: * **Factory Method/Abstract Factory**: Supports OCP by enabling object creation without specifying concrete classes. Useful for creating families of related objects (e.g., cryptographic algorithms in C++). * **Strategy**: Aligns with SRP and DIP by encapsulating interchangeable algorithms. E.g., switch between encryption strategies via an interface. * **Observer**: Facilitates loose coupling for event-driven systems (e.g., React state updates, Solidity event listeners). * **Adapter**: Bridges incompatible interfaces, supporting ISP and DIP (e.g., adapting legacy C++ code to a new TypeScript API). * **Data-Driven Patterns**: Combine patterns like Factory with data-driven design. For example, use a Factory to instantiate objects from XML/JSON configs, ensuring classes are self-contained and serialize/deserialize their data. Apply patterns that naturally fit the problem domain, prioritizing interface-driven, loosely coupled designs over rigid implementations. ### Code Generation Principle Use **code generation tools** to accelerate development and ensure consistency across languages: * **OpenAPI Specifications**: Define API schemas using OpenAPI (or similar) to generate client/server code for TypeScript, Java, C++, Solidity, etc. This ensures consistent interfaces and reduces manual coding errors. * **Example**: Generate TypeScript client code for a REST API or Solidity contract bindings from an OpenAPI spec, speeding up development significantly (up to 10x for cross-language projects). * **Benefits**: Promotes standardization, reduces boilerplate, and supports rapid iteration in multi-language environments like blockchain systems. * **Best Practices**: Write clear, comprehensive schemas. Validate generated code and customize as needed. Integrate with CI/CD for automation. ### Unit Testing Unit tests ensure code reliability and prevent regressions: * **Coverage**: Target 80%+ coverage for critical paths, including edge cases, happy paths, and failures. * **Frameworks**: Use Jest (TypeScript/React), JUnit (Java), Google Test (C++), Hardhat/Truffle (Solidity). * **Best Practices**: Prefer Test-Driven Development (TDD) where feasible. Keep tests isolated, fast, deterministic. Mock dependencies. * **AI Tools**: Use Grok, Claude.ai, or ChatGPT to generate test skeletons or ideas, but always review manually—AI can miss edge cases or context. Human intervention is critical. * **Integration**: Run tests in CI/CD pipelines. Fail builds on test failures. ### Leveraging AI Tools AI accelerates development but requires responsibility: * **Usage**: Use AI for code generation, debugging suggestions, or crafting project prompts. Follow our prompt engineering guidelines: specify requirements, constraints, and expected outputs clearly. * **Human Oversight**: Always verify AI outputs, especially for unit tests, cryptography, or complex logic, as AI may produce errors or hallucinations. * **Prompt Engineering**: Write detailed prompts (as per past project examples) to ensure accurate outputs. ### General Software Development Principles From engineer job descriptions and project expectations: * **Proactive Problem-Solving**: Anticipate issues and propose solutions independently. * **Collaboration**: Engage in code reviews, providing constructive feedback. * **Continuous Learning**: Stay current with technologies (React, Solidity, C++ cryptography). * **Maintainability**: Prioritize clean, modular code over quick fixes. ### Language-Specific Standards #### C++ Coding Standards {% content-ref url="c++-coding-standards.md" %} [c++-coding-standards.md](c++-coding-standards.md) {% endcontent-ref %} ### Python Coding Standards {% content-ref url="python-coding-standards.md" %} [python-coding-standards.md](python-coding-standards.md) {% endcontent-ref %} ### Typescript Coding Standards {% content-ref url="typescript-coding-standards.md" %} [typescript-coding-standards.md](typescript-coding-standards.md) {% endcontent-ref %} #### Dart Coding Standards {% content-ref url="dart-coding-standards.md" %} [dart-coding-standards.md](dart-coding-standards.md) {% endcontent-ref %} #### Smart Contract Projects {% content-ref url="smart-contract-projects.md" %} [smart-contract-projects.md](smart-contract-projects.md) {% endcontent-ref %} --- source: /technical-information/software-engineering-handbook/c++-coding-standards/ title: C++ Coding Standards --- # SuperGenius C++ Coding Standards Revision 2.0 — June 2026 Adapted from the Corelinux Consortium C++ Coding Standards (2000), modernized for C++17. --- ## 1. Scope This document defines the coding standards for the SuperGenius C++ codebase. Rules are classified as: | Classification | Meaning | Enforcement | |---|---|---| | **Required** | Mandatory. Deviations must be approved by the team lead. | clang-tidy check (should pass clean) | | **Recommended** | Should be followed unless there is a compelling reason to deviate. | clang-tidy check (warnings may exist) | The automated enforcement configuration lives in `.clang-tidy` and `.clang-format` at the repository root. See [§12 Tooling](#12-tooling) for usage. ### 1.1 General Principles The primary goal is **maintainability**. Other considerations in priority order: correctness, readability, consistency, clarity, portability, simplicity, and finally efficiency. When in doubt, strive for clarity first, then efficiency. Think of the reader. Keep it simple. Break down complexity. Be explicit — avoid implicit or obscure language features. Be consistent. Minimize scope, both logical and visual. --- ## 2. Comments ### 2.1 File Headers **Required:** Every source and header file shall have a top-of-file comment. Use Doxygen-compatible format. ```cpp /** * @file MyClass.hpp * @brief Brief description of the file's purpose. * @author Jane Smith */ ``` ### 2.2 Function and Interface Comments **Required:** All public functions and interfaces shall have header comments in the `.hpp` file. The comment size should match the function's size and complexity. ```cpp /** * @brief Attaches a rendering window to the context. * @param rendWin The window to attach. * @return false on failure. */ virtual bool AttachRenderWindow(IRenderWindow *rendWin) = 0; ``` ### 2.3 Inline Comments **Required:** Use C++ single-line comments (`//`) for inline comments. **Recommended:** Prefer block comments (on their own line) over trailing comments. Use trailing comments only for special annotations. **Required:** Trailing comments at a closing brace are indented one level from the brace. **Required:** Block comments are at the same indentation level as the code they describe. --- ## 3. Code Layout ### 3.1 Braces **Required:** Use Allman / Ullman brace style. Braces are always on their own line, at the same indentation level as the statement that precedes them. The code within braces is indented one level. ```cpp void DoSomething() { if ( x != y ) { y = x; } else { // ... } } ``` > **Enforced by:** `clang-format` (`BreakBeforeBraces: Allman`) **Required:** Always use braces on `if`, `for`, `while`, and `do`/`while` statements, even when the body is a single statement. ```cpp // Correct if ( condition ) { DoWork(); } // Incorrect if ( condition ) DoWork(); ``` > **Enforced by:** `clang-tidy` (`readability-braces-around-statements`) [Required] **Required:** Put the `while` in a `do`/`while` statement on the same line as the closing brace. ```cpp do { ++x; } while ( x < y ); ``` ### 3.2 Indentation and Spacing **Required:** Indentation is 4 spaces. Do not use tabs. > **Enforced by:** `clang-format` (`IndentWidth: 4`, `UseTab: Never`) **Required:** Balance spacing inside parentheses — space after `(` and before `)` when arguments are present. No spaces in empty argument lists. ```cpp void DoFunction(); // no args — no spaces void DoFunction( ObjectRef aRef ); // args — spaces inside parens ``` **Required:** Do not space between a function name and the opening parenthesis. ```cpp DoFunction( arg ); // correct DoFunction ( arg ); // incorrect ``` > **Enforced by:** `clang-format` (`SpacesInParentheses: true`, `SpaceBeforeParens: ControlStatements`) **Required:** Do not use spaces between a dereference operator and its operand. ```cpp val = *pFoo; // correct val = * pFoo; // incorrect ``` > **Enforced by:** `clang-format` (`PointerAlignment: Left`) **Required:** Balance spacing on either side of binary operators. **Required:** Do not space before separators (semicolon, comma) but do space after them. ### 3.3 Column Limit **Recommended:** Lines should not exceed 120 columns. > **Enforced by:** `clang-format` (`ColumnLimit: 120`) > > *Historical note: The original 2000 standard specified 78 columns. This was revised to 120 for modern displays and C++17 code density.* ### 3.4 Line Wrapping **Required:** When wrapping a line, indent the continuation past the current indent column. **Required:** Wrap conditional expressions after the logical operators. ```cpp if ( theNameOfTheGame == aGameName && theTimeBeingPlayed > aLimit ) { // ... } ``` > **Enforced by:** `clang-format` (`BreakBeforeBinaryOperators: None`) **Required:** Wrap long function signatures after a parameter comma, with indentation. ```cpp void ClassMethod::SetValues( ObjectCref a1, ObjectCref a2, StringCref aName, IntCref aValue ) { // ... } ``` > **Enforced by:** `clang-format` (`BinPackParameters: false`) ### 3.5 Declarations **Required:** Start each declaration on a new line. **Required:** Put one statement per line (except for trivial in-line accessors in headers). ### 3.6 Switch Statements **Required:** All `switch` statements shall have a `default` case. **Required:** Indent `case` labels one level from the `switch`. Indent the case body one level from the `case`. The `break` is at the same indentation as the body. ```cpp switch ( variable ) { case 1: DoSomething(); break; case 2: DoOther(); break; default: break; } ``` > **Enforced by:** `clang-format` (`IndentCaseLabels: true`) ### 3.7 Access Modifiers **Required:** `public`, `protected`, and `private` appear flush with the `class` keyword (no additional indentation). > **Enforced by:** `clang-format` (`AccessModifierOffset: 0`) **Required:** Access controls appear in this order: `public`, `protected`, `private` (methods), then `protected`, `private` (data members). Empty access-control sections may be omitted. ### 3.8 Namespaces **Required:** Namespace bodies are indented one level. Use nested namespace syntax (C++17). ```cpp namespace sgns::storage { // indented one level } ``` > **Enforced by:** `clang-format` (`NamespaceIndentation: All`, `CompactNamespaces: false`) ### 3.9 Blank Lines **Recommended:** Use blank lines before and after block comments to visually separate code chunks. > **Enforced by:** `clang-format` (`MaxEmptyLinesToKeep: 1`) --- ## 4. Naming Conventions ### 4.1 Summary Table | Entity | Case | Prefix | Example | Enforced | |---|---|---|---|---| | Classes | PascalCase | — | `ProcessingNode` | Required | | Structs | PascalCase | — | `CrdtOptions` | Required | | Enums | PascalCase | — | `DatabaseError` | Required | | Enum constants | `UPPER_CASE` | — | `NOT_FOUND` | Recommended | | Functions (free) | PascalCase | — | `CreateLogger` | Recommended | | Methods (member) | PascalCase | — | `GetValue()` | Recommended | | Variables (local) | camelCase | — | `localVar` | Recommended | | Parameters | camelCase | — | `nodeId` | Recommended | | Member variables | camelCase | `m_` | `m_nodeId` | Recommended | | Compile-time constants | PascalCase | `k` | `kMaxRetryCount` | Recommended | | Global constants | PascalCase | `k` | `kDefaultPort` | Recommended | > **Enforced by:** `clang-tidy` (`readability-identifier-naming`) [Recommended] > > *Note: Naming is classified as Recommended because the codebase is transitioning. Some files still use trailing-underscore members (`node_id_`) or camelCase free functions (`createLogger`). New code shall follow this table.* ### 4.2 Type Names **Required:** Types start with an uppercase letter and use PascalCase (also known as UpperCamelCase). ```cpp class TokenAmount { }; struct CrdtOptions { }; enum class DatabaseError : uint8_t { }; ``` ### 4.3 Variables and Parameters **Recommended:** Local variables and parameters use camelCase (lowerCamelCase) — first word lowercase, subsequent words capitalized. ```cpp int itemCount = 0; void Process( const std::string &nodeId ); ``` **Recommended:** Do not use Hungarian notation or type prefixes (`a`, `p`, `l`, etc.). ### 4.4 Member Variables **Recommended:** Non-public member variables use `m_` prefix followed by camelCase. ```cpp class ProcessingNode { private: std::string m_nodeId; std::chrono::seconds m_ttl; }; ``` **Recommended:** Do not use `m_` prefix for public members of simple structs used as data carriers. ```cpp struct Point { double x; double y; }; ``` ### 4.5 Compile-Time Constants **Recommended:** Compile-time constants use `k` prefix followed by PascalCase. ```cpp constexpr int kMaxRetryCount = 3; inline constexpr size_t kPublicKeySize = 32; static constexpr uint64_t kDefaultPort = 3000; ``` Do not use `#define` for value constants. Do not use `UPPER_CASE` for constants. > **Enforced by:** `clang-tidy` (`cppcoreguidelines-avoid-magic-numbers`) [Required], with `0`, `1`, `-1`, and `2` allowed in trivial contexts. ### 4.6 Functions and Methods **Recommended:** Functions and methods use PascalCase with a verb-noun pattern. ```cpp void SetName( const std::string &name ); bool IsEmpty() const; int GetCount() const; std::shared_ptr CreateThread(); void DestroyThread( std::shared_ptr t ); ``` **Required:** Accessor methods (returning a value) start with `Get` and should be `const`. **Recommended:** Boolean accessor methods start with `Is` or `Has` and return `bool`. **Required:** Mutator methods (setting a value) start with `Set` and do not return values. **Required:** Factory creation functions start with `Create`. Factory destruction functions start with `Destroy`. ### 4.7 Spelling and Clarity **Required:** Use correct English spelling. Avoid abbreviations except for well-known domain terms. **Recommended:** Make names clearly unique within their scope. Avoid similar-sounding names. **Required:** Make all identifiers unique within a function. --- ## 5. Language Usage ### 5.1 C++ Standard **Required:** Code targets C++17. Do not use C++20 (or later) features. ### 5.2 Initialization **Required:** All variables must be initialized at the point of declaration. If the value is not yet known, initialize pointers to `nullptr` and arithmetic types to `0`. ```cpp int count = 0; std::string name; Logger logger = nullptr; ``` > **Enforced by:** `clang-tidy` (`cppcoreguidelines-init-variables`) [Required] **Recommended:** Prefer member initializer lists over assignment in the constructor body. ```cpp // Preferred MyClass::MyClass( int value, const std::string &name ) : m_value( value ) , m_name( name ) { } // Acceptable but not preferred MyClass::MyClass( int value, const std::string &name ) { m_value = value; m_name = name; } ``` > **Enforced by:** `clang-tidy` (`cppcoreguidelines-prefer-member-initializer`) [Recommended] **Required:** List members in a constructor initialization list in the order they are declared in the class header. > **Enforced by:** `clang-format` (`BreakConstructorInitializers: BeforeComma`, `ConstructorInitializerIndentWidth: 4`) ### 5.3 Pointers and Null **Required:** Use `nullptr`, never `NULL`, `0`, or `NULLPTR` for null pointers. > **Enforced by:** `clang-tidy` (`modernize-use-nullptr`) [Required] ### 5.4 Casts **Required:** Use explicit C++-style casts. Never rely on implicit compiler conversions for pointer or arithmetic narrowing. ```cpp auto value = static_cast( rawValue ); auto ptr = dynamic_cast( basePtr ); ``` > **Enforced by:** `clang-tidy` (`google-readability-casting`) [Required] ### 5.5 `const` Correctness **Required:** Use `const` on every function, parameter, return value, and variable that will not be modified. **Recommended:** All accessor (getter) member functions should be `const`. > **Enforced by:** `clang-tidy` (`readability-make-member-function-const`) [Recommended] **Required:** Pass non-modifiable objects by `const` reference, not by value. ```cpp void Process( const Transaction &txn ); ``` **Required:** Never return handles (references, pointers, iterators) to private object internals from `const` member functions. If a handle must be returned, make it `const`. ### 5.6 `noexcept` **Recommended:** Declare functions `noexcept` if they are guaranteed not to throw. This is especially important for move constructors, move assignment, destructors, and simple accessors. ```cpp uint64_t Value() const noexcept; ~MyClass() = default; // destructors are implicitly noexcept ``` > **Enforced by:** `clang-tidy` (`modernize-use-noexcept`) [Recommended] > > *Note: The project uses `outcome::result` for error propagation rather than exceptions in hot paths. Functions using `outcome::result` should still be declared `noexcept` when they don't throw.* ### 5.7 `auto` **Recommended:** Prefer `auto` for variable declarations where the type is obvious from the initializer. Avoid `auto` where the type is not immediately clear to the reader. ```cpp auto logger = base::createLogger( "Tag" ); // clear auto it = map.find( key ); // clear uint64_t count = GetCount(); // better than auto when type matters ``` ### 5.8 Range-Based `for` and Algorithms **Recommended:** Prefer range-based `for` loops over iterator-based loops where possible. **Recommended:** Prefer standard algorithms over hand-written loops. ### 5.9 Enums **Required:** Prefer `enum class` (scoped enumerations) over unscoped `enum`. **Recommended:** Specify the underlying type for `enum class` when size matters. ```cpp enum class DatabaseError : uint8_t { OK, NOT_FOUND, CORRUPTION }; ``` **Recommended:** Enum constant names use `UPPER_CASE`. > **Enforced by:** `clang-tidy` (`readability-identifier-naming.EnumConstantCase`) [Recommended] > > *Note: Some code uses PascalCase for scoped enum constants (e.g., `ParseMode::Strict`). This produces warnings under the current tooling; new code should use `UPPER_CASE`.* ### 5.10 `goto` **Required:** `goto` is never permitted. > **Enforced by:** `clang-tidy` (`cppcoreguidelines-avoid-goto`) [Required] ### 5.11 Switch Statements **Required:** All `switch` statements shall have a `default` case. **Required:** Each non-empty `case` shall end with a `break`, `return`, or explicit comment documenting intentional fall-through. ### 5.12 Conditional Expressions **Required:** All non-boolean comparison expressions shall use an explicit comparison operator. Do not rely on implicit conversion to `bool`. ```cpp if ( ptr != nullptr ) // correct if ( ptr ) // incorrect ``` > **Enforced by:** `clang-tidy` (`readability-implicit-bool-conversion`) [Required] **Recommended:** Minimize negative comparisons; prefer positive logic. **Recommended:** Use `if`/`else` blocks rather than the ternary operator (`?:`) when the intent is to execute code for side effects, not just to select a value. ### 5.13 Loops **Recommended:** Use `for` loops when the loop control needs initialization or recalculation; otherwise use `while`. **Recommended:** Count `for` loops in ascending order. **Recommended:** Minimize use of `break` in loops. Use it only for abnormal early exit. **Recommended:** Use `continue` sparingly, with a comment explaining why. ### 5.14 Operators **Recommended:** Default to pre-increment (`++i`) and pre-decrement (`--i`) unless post-increment/decrement semantics are logically required. ### 5.15 Floating-Point **Required:** Do not compare floating-point numbers for equality. **Recommended:** Use floating-point numbers only where necessary (graphics, physics). ### 5.16 Macros **Required:** Replace `#define` value constants with `constexpr` or `inline constexpr`. Use macros only for include guards and unavoidable platform/compiler integration. **Required:** Multi-statement macros shall have one statement per line, properly backslash-continued. ### 5.17 Stack vs Heap **Required:** Match `new` with `delete` and `new[]` with `delete[]`. **Required:** Prefer stack allocation. When heap allocation is needed, use `std::unique_ptr` (or `std::shared_ptr` when shared ownership is required). Never use raw `new`/`delete` in application code — wrap in smart pointers at the point of allocation. --- ## 6. Class Design ### 6.1 Interfaces **Required:** Program to an interface, not an implementation. Define abstract interfaces (pure virtual classes) and depend on them. **Required:** Keep class interfaces minimal and complete. A developer should only need the `.hpp` file to use the class. **Required:** Data members shall never be `public`. > **Enforced by:** `clang-tidy` (`misc-non-private-member-variables-in-classes`) [Required] **Required:** Prefer non-member, non-friend free functions over member functions to increase encapsulation. Member functions should only be used when they need access to private data. ### 6.2 Special Member Functions **Recommended:** Follow the Rule of Zero/Five: - **Rule of Zero:** If a class does not manage resources directly, do not declare any of the special member functions (destructor, copy/move constructors, copy/move assignment). Let the compiler generate them. - **Rule of Five:** If a class manages resources directly, declare all five: destructor, copy constructor, copy assignment, move constructor, and move assignment. > **Enforced by:** `clang-tidy` (`cppcoreguidelines-special-member-functions`) [Recommended] **Required:** Declare destructors `virtual` in all polymorphic base classes. > **Enforced by:** `clang-tidy` (`bugprone-*` virtual-destructor checks) [Required] ### 6.3 Inheritance **Required:** Public inheritance shall model "is-a" relationships. **Required:** Never redefine an inherited non-virtual function. > **Enforced by:** `clang-tidy` (`modernize-use-override`) [Required] **Required:** Never redefine an inherited default parameter value. **Recommended:** Differentiate between inheritance of interface and inheritance of implementation. Prefer composition over implementation inheritance. ### 6.4 Composition over Inheritance **Recommended:** Favor object composition over class inheritance. Composition allows behavior to be combined at runtime and reduces rigid dependencies. ### 6.5 Encapsulation **Required:** Keep internal class structure hidden. Do not expose implementation details in the public interface. **Required:** Do not traverse multiple links or member functions in a single statement. Use named temporaries. ```cpp // Incorrect — hard to read and debug auto name = obj->GetDepartment()->GetManager()->GetName(); // Correct auto *dept = obj->GetDepartment(); auto *mgr = dept->GetManager(); auto name = mgr->GetName(); ``` --- ## 7. Error Handling ### 7.1 Outcome Pattern **Required:** The project uses `outcome::result` for fallible operations rather than C++ exceptions in hot paths. ```cpp outcome::result> Blob::fromHex( std::string_view hex ); ``` All functions returning `outcome::result` shall be declared `noexcept` unless they have a specific reason to throw. ### 7.2 Assertions **Recommended:** Use assertions liberally to document invariants and detect programming errors. ### 7.3 Exception Safety **Required:** Destructors must never throw exceptions. Catch and handle any exceptions that could escape a destructor. **Required:** If a constructor fails, it shall leave the object in a well-defined state. In `outcome::result`-based code, use factory functions that return `outcome::result` rather than throwing from constructors. --- ## 8. File Layout ### 8.1 File Extensions **Required:** Use `.hpp` for C++ header files and `.cpp` for C++ source files. **Recommended:** Use `.h` and `.c` for C-style files only (discouraged). ### 8.2 One Class Per Header **Required:** A class shall have a single header file. Closely related helper types may be co-located. **Recommended:** Classes with a large number of member functions may split their implementation across multiple `.cpp` files organized by functional area. ### 8.3 Include Order **Recommended:** Order includes as: (1) own header, (2) project headers, (3) third-party headers, (4) standard library headers. > **Enforced by:** `clang-format` (`SortIncludes: true`, `IncludeBlocks: Preserve`) **Required:** Minimize header file interdependence. Use forward declarations where possible instead of `#include`. ### 8.4 Function Length **Recommended:** Functions should fit within approximately 100 lines. **Recommended:** Module files should not exceed 10–15 pages. --- ## 9. Header File Layout ### 9.1 Include Guards **Required:** All headers must be guarded against multiple inclusion. ```cpp #ifndef SUPERGENIUS_MYCLASS_HPP #define SUPERGENIUS_MYCLASS_HPP // ... #endif // SUPERGENIUS_MYCLASS_HPP ``` `#pragma once` is an acceptable alternative for headers that are not part of the public API, but traditional guards are preferred for portability. ### 9.2 Header Content **Required:** Do not allocate memory (define static storage) in header files. **Required:** Include only what the header directly needs. Forward-declare types that are used only by reference or pointer. ### 9.3 Order Within a Class **Required:** Within a class definition, members appear in this order: 1. `public:` — constructors, destructor, operator overloads, accessors, mutators 2. `protected:` — protected methods 3. `private:` — private methods 4. `protected:` — protected data members 5. `private:` — private data members --- ## 10. Platform Abstraction **Required:** Do not use `#ifdef` OS-specific checks (`WINDOWS`, `OSX`, `ANDROID`, etc.) in source files. Instead, include a `Platform.hpp` header that provides platform-specific abstractions. ```cpp // Incorrect #ifdef WINDOWS // Windows-specific code #elif __APPLE__ // Mac-specific code #endif // Correct #include "Platform.hpp" // Platform.hpp handles the OS-specific includes ``` Use the build system (CMake) to select per-platform include directories and source files. --- ## 11. Includes **Required:** Use project-root-relative paths for internal includes. ```cpp #include "base/logger.hpp" #include "storage/face/readable.hpp" ``` **Required:** Use angle-bracket includes for third-party and standard library headers. ```cpp #include #include #include ``` --- ## 12. Tooling ### 12.1 clang-format The repository root contains `.clang-format` encoding the formatting rules from [§3 Code Layout](#3-code-layout) and [§8–9 File Layout](#8-file-layout). Run: ```bash clang-format -i # apply formatting clang-format --dry-run # check only ``` All code shall be formatted before commit. Most IDEs can be configured to run clang-format on save. ### 12.2 clang-tidy The repository root contains `.clang-tidy` encoding the static analysis rules from [§4–7](#4-naming-conventions). Each check is annotated as `[Required]` or `[Recommended]` and mapped to the corresponding standard section. Run: ```bash clang-tidy -- -std=c++17 ``` For full project analysis, use the CMake-generated `compile_commands.json`: ```bash cd build/OSX/Debug cmake .. -G "Ninja" -DCMAKE_EXPORT_COMPILE_COMMANDS=ON ninja run-clang-tidy -p . ``` Required checks should pass clean on new and modified code. Recommended checks may produce warnings; developers should address warnings where practical but are not required to clear all warnings in legacy files. ### 12.3 Build Verification Before committing, always: 1. Format with clang-format 2. Run clang-tidy on changed files 3. Build without errors or warnings 4. Run tests Use the repository's build instructions in `README.md` for platform-specific commands. --- ## 13. References - The Corelinux Consortium. *The Corelinux C++ Coding Standards*. Version 1.6, May 2000. - Gamma, E., Helm, R., Johnson, R., and Vlissides, J. *Design Patterns: Elements of Reusable Object-Oriented Software*. Addison Wesley, 1995. - Meyers, S. *Effective C++*, *More Effective C++*, *Effective STL*, and *Effective Modern C++*. Addison Wesley. - Reddy, M. *API Design for C++*. Morgan Kaufmann, 2011. - ISO/IEC 14882:2017 — *Programming Language C++* (C++17 Standard). --- *Revision 2.0 — June 2026. This document supersedes Revision 1.0 (June 2000, last revised March 2020).* --- source: /technical-information/software-engineering-handbook/python-coding-standards/ title: Python Coding Standards --- ## Python Coding Standards This section extends the SuperGenius C++ Coding Standards to Python source files (e.g. `gnus-poc/`, tooling, test harnesses). The classifications are identical: **Required** rules must be followed (enforced by `ruff` + `mypy`, which play the roles of `clang-format` and `clang-tidy`); **Recommended** rules should be followed unless there is a compelling reason to deviate. The §1.1 General Principles apply unchanged: maintainability first, think of the reader, be explicit, minimize scope. ### 1 Comments and Docstrings **Required:** Every module shall have a top-of-file docstring stating its purpose (the analogue of the §2.1 top-of-file comment). **Required:** All public classes, functions, and modules shall have docstrings (Google style). Comment size should match the function's size and complexity. **Required:** Use `#` single-line comments for inline comments. Block comments sit on their own line, at the same indentation level as the code they describe. ### 2 Code Layout **Required:** Indentation is 4 spaces. Never tabs (PEP 8; enforced by `ruff format`). **Recommended:** Lines should not exceed 100 columns (the C++ limit of 120 is acceptable where the team prefers consistency with C++). **Required:** One statement per line. Each declaration on a new line. **Required:** Break long lines inside parentheses, brackets, or braces rather than with backslash continuations. Indent the continuation past the current indent column. Wrap conditional expressions after the logical operators. **Recommended:** Two blank lines between top-level definitions, one between method definitions. At most one blank line within a function body. ### 3 Naming Conventions | Entity | Case | Example | Enforced | | --- | --- | --- | --- | | Modules / packages | snake_case | `sgfp4_format.py` | Required | | Classes / Exceptions | PascalCase | `QuadtreeEncoder` | Required | | Functions / methods | snake_case, verb-noun | `decode_v2()` | Required | | Variables / parameters | snake_case | `leaf_index` | Required | | Compile-time constants | `UPPER_CASE` | `SPLIT_MAP_BYTES` | Required | | Enum types | PascalCase | `class CodeMode(IntEnum)` | Required | | Enum members | `UPPER_CASE` | `FP4_AFFINE` | Recommended | | Non-public members | single leading `_` | `_build_split_map` | Required | **Required:** No Hungarian notation or type prefixes. **Recommended:** Boolean-returning functions start with `is_` or `has_` (the analogue of §4.6). Factory functions start with `create_`; teardown functions with `destroy_`. **Required:** Wire-format and protocol "magic numbers" shall be named exactly once in a dedicated constants module (the analogue of §4.5 `avoid-magic-numbers`), imported by every producer and consumer of the format. Do not duplicate literal masks, shifts, or sizes across files. ### 4 Language Usage **Required:** Use `enum.Enum` / `enum.IntEnum` for closed sets of values. Bare integer constants with a comment are not an enum (analogue of §5.9 `enum class`). **Required:** All non-boolean conditional expressions shall be explicit (analogue of §5.12). Test `None` with `is` / `is not`; test bit flags with `!= 0`; do not rely on truthiness of objects whose falsy value is ambiguous. ``` if flags & RESERVED_MASK != 0: # correct if flags & RESERVED_MASK: # incorrect if node is None: # correct if not node: # incorrect ``` **Required:** No mutable default arguments (`def f(items=[])`). Use `Optional[...] = None` and initialize in the body. **Required:** Acquire resources with context managers (`with`) — the RAII analogue. Files, sockets, and locks shall not rely on `__del__`. **Required:** Type hints on all public function signatures. `mypy` (or equivalent) must pass on new code. **Recommended:** Prefer `pathlib.Path` over `os.path` string manipulation. Prefer f-strings over `%` or `.format()`. Prefer dataclasses for simple data carriers. **Recommended:** Use `nonlocal`/`class` state instead of single-element list closure hacks (`idx = [0]`). **Recommended:** Minimize `break`/`continue` in loops, as in §5.13. Count loops ascending. ### 5 Class Design **Required:** Data members shall not be public (§6.1 analogue): prefix with `_`; expose behavior through methods or `@property`. **Recommended:** Prefer composition over inheritance (§6.4 applies unchanged). Use `abc.ABC` for interfaces. **Required:** A class's public surface shall be documented in its docstring; `__all__` shall be defined in package `__init__.py` files that re-export. ### 6 Error Handling **Required:** Raise specific exception types, never bare `except:` and never `except Exception` without re-raising or wrapping. Define a small custom exception hierarchy per package (e.g. `SGFP4FormatError(ValueError)`). **Required:** `assert` documents invariants only (§7.2 analogue). Never use `assert` for input validation or error handling — it is stripped under `python -O`. **Recommended:** Functions should document raised exceptions in their docstrings. ### 7 Module and File Layout **Required:** Import order: (1) standard library, (2) third-party, (3) project-local (the analogue of §8.3; enforced by `ruff` isort rules). **Required:** No circular imports. Shared constants/types live in a leaf module (e.g. `*_format.py`) that imports nothing from the package. **Required:** Executable module code guarded by `if __name__ == "__main__":`. **Recommended:** Functions should fit within approximately 100 lines (§8.4 applies unchanged). Extract helpers rather than nesting logic. **Recommended:** Avoid monkey-patching and runtime modification of other modules' objects. ### 8 Platform Abstraction **Required:** No scattered `sys.platform` checks in source files (§10 analogue). Isolate platform differences in a single `platform_utils` module. ### 9 Testing **Required:** New logic ships with `pytest` tests in the same change. **Recommended:** Tests use seeded RNGs (`np.random.default_rng(seed)`) for determinism. Binary-format code shall include hand-constructed golden vectors, not only round-trip self-consistency checks. ### 10 Tooling | C++ tool | Python analogue | Purpose | | --- | --- | --- | | clang-format | `ruff format` (or `black`) | Layout enforcement | | clang-tidy | `ruff check` | Static analysis, naming, import order | | — | `mypy` | Type checking (Required checks must pass clean) | Before committing, always: format, lint, type-check, and run tests (§12.3 applies unchanged). --- source: /technical-information/software-engineering-handbook/typescript-coding-standards/ title: TypeScript Coding Standards --- # SuperGenius TypeScript Coding Standards Revision 1.0 — July 2026 Adapted from the SuperGenius C++ Coding Standards (Rev 2.0), restated for TypeScript 5.x / ECMAScript 2022+ codebases. * * * ## 1. Scope This document defines the coding standards for SuperGenius TypeScript and JavaScript source files (frontends, Node services, tooling). Rules are classified as: | Classification | Meaning | Enforcement | | --- | --- | --- | | **Required** | Mandatory. Deviations must be approved by the team lead. | `eslint` check (should pass clean) | | **Recommended** | Should be followed unless there is a compelling reason to deviate. | `eslint` check (warnings may exist) | The automated enforcement configuration lives in `eslint.config.js`, `.prettierrc`, and `tsconfig.json` at the repository root. See §12 Tooling for usage. `prettier` + `eslint` + `tsc --strict` play the roles of `clang-format` and `clang-tidy` in the C++ standard. ### 1.1 General Principles The primary goal is **maintainability**. Other considerations in priority order: correctness, readability, consistency, clarity, portability, simplicity, and finally efficiency. When in doubt, strive for clarity first, then efficiency. Think of the reader. Keep it simple. Break down complexity. Be explicit — avoid implicit or obscure language features. Be consistent. Minimize scope, both logical and visual. * * * ## 2. Comments ### 2.1 File Comments **Required:** Every source file shall have a top-of-file comment. Use TSDoc/JSDoc-compatible format. ``` /** * @fileoverview Brief description of the file's purpose. * @author Jane Smith */ ``` ### 2.2 Function and Interface Comments **Required:** All exported functions, classes, interfaces, and type aliases shall have TSDoc comments. The comment size should match the function's size and complexity. ``` /** * Attaches a rendering window to the context. * @param rendWin The window to attach. * @returns false on failure. */ attachRenderWindow(rendWin: RenderWindow): boolean; ``` **Required:** Use `//` single-line comments for inline comments. **Recommended:** Prefer block comments (on their own line) over trailing comments. Use trailing comments only for special annotations (e.g. `// eslint-disable-next-line`, `// istanbul ignore next`). **Required:** Block comments are at the same indentation level as the code they describe. **Recommended:** Document workarounds and non-obvious decisions with a linked issue or spec reference, not folklore. * * * ## 3. Code Layout ### 3.1 Braces **Required:** Opening braces go on the **same line** as the statement (1TBS / K&R style). Allman braces are *not* used in TypeScript code. ``` function doSomething(): void { if (x !== y) { y = x; } else { // ... } } ``` > Enforced by: `prettier` (default `bracketSameLine` behavior for control > statements). **Required:** Always use braces on `if`, `for`, `while`, and `do`/`while` statements, even when the body is a single statement. ``` // Correct if (condition) { doWork(); } // Incorrect if (condition) doWork(); ``` > Enforced by: `eslint` (`curly: ["error", "all"]`) [Required] **Required:** Arrow function bodies that exceed one expression use a block with an explicit `return`; single-expression bodies omit braces and return. ### 3.2 Indentation and Spacing **Required:** Indentation is 2 spaces. Do not use tabs. (This matches the dominant TypeScript ecosystem convention; the C++ 4-space rule does not carry over.) > Enforced by: `prettier` (`tabWidth: 2`, `useTabs: false`) **Required:** No space between a function name and the opening parenthesis. Single space after keywords (`if`, `for`, `while`, `switch`, `catch`). **Required:** Balance spacing on either side of binary operators. Do not space before separators (semicolon, comma) but do space after them. **Recommended:** Use semicolons at statement ends. Be consistent — never mix styles within a file. > Enforced by: `prettier` (`semi: true`) ### 3.3 Column Limit **Recommended:** Lines should not exceed 100 columns. > Enforced by: `prettier` (`printWidth: 100`) ### 3.4 Line Wrapping **Required:** When wrapping a line, indent the continuation past the current indent column. Wrap conditional expressions after the logical operators. ``` if (theNameOfTheGame === aGameName && theTimeBeingPlayed > aLimit) { // ... } ``` **Required:** Wrap long function signatures after a parameter comma, with indentation. ``` function setValues(a1: ObjectRef, a2: ObjectRef, aName: string, aValue: number): void { // ... } ``` ### 3.5 Declarations **Required:** Start each declaration on a new line. One statement per line. **Required:** Use `const` by default; `let` only when reassignment is required; `var` is never permitted. > Enforced by: `eslint` (`prefer-const`, `no-var`) [Required] ### 3.6 Switch Statements **Required:** All `switch` statements shall have a `default` case. **Required:** Each non-empty `case` shall end with `break`, `return`, `throw`, or an explicit `// fallthrough` comment documenting intent. > Enforced by: `eslint` (`default-case`, `no-fallthrough`) [Required] ### 3.7 Blank Lines **Recommended:** Use blank lines before and after block comments and between logical sections to visually separate code chunks. At most one consecutive blank line. * * * ## 4. Naming Conventions ### 4.1 Summary Table | Entity | Case | Example | Enforced | | --- | --- | --- | --- | | Classes / Interfaces / Types / Enums | PascalCase | `ProcessingNode` | Required | | Enum members | `UPPER_CASE` | `DatabaseError.NotFound` | Recommended | | Functions / methods | camelCase, verb-noun | `getValue()` | Required | | Variables / parameters | camelCase | `nodeId` | Required | | Compile-time constants | `UPPER_CASE` | `MAX_RETRY_COUNT` | Required | | Module-level constants | `UPPER_CASE` | `DEFAULT_PORT` | Required | | Files (component/class) | kebab-case | `processing-node.ts` | Recommended | | Boolean variables/functions | `is`/`has`/`can` prefix | `isReady` | Recommended | > Enforced by: `eslint` (`@typescript-eslint/naming-convention`) [Recommended] ### 4.2 Type Names **Required:** Types, classes, and interfaces start with an uppercase letter and use PascalCase. **Required:** Do **not** prefix interfaces with `I` (`IUserService` is incorrect; `UserService` is correct). No Hungarian notation or type prefixes anywhere. ### 4.3 Variables and Parameters **Recommended:** Local variables and parameters use camelCase. **Required:** Make all identifiers unique within a function. Avoid similar-sounding names within a scope. **Recommended:** Boolean names read as predicates: `isReady`, `hasError`, `canRetry`, `shouldUpdate`. ### 4.4 Constants **Required:** Compile-time and module constants use `UPPER_CASE` (the analogue of the C++ `k` prefix rule). Do not use magic numbers; wire-format and protocol constants shall be named exactly once in a dedicated constants module, imported by every producer and consumer of the format. ``` export const MAX_RETRY_COUNT = 3; export const PUBLIC_KEY_SIZE = 32; ``` ### 4.5 Functions and Methods **Required:** Functions and methods use camelCase with a verb-noun pattern: `getName`, `isEmpty`, `createThread`, `destroyThread`. Accessor/mutator/ factory verb conventions match the C++ standard: `get*`/`set*` pairs, `is*`/`has*` for booleans, `create*`/`destroy*` for factories. ### 4.6 Spelling and Clarity **Required:** Use correct English spelling. Avoid abbreviations except for well-known domain terms. * * * ## 5. Language Usage ### 5.1 Strictness **Required:** `strict: true` in `tsconfig.json`. No new file may disable strict flags (`strictNullChecks`, `noImplicitAny`, etc.) locally or globally. **Required:** `any` is not permitted in new code. Use `unknown` and narrow explicitly. `// @ts-ignore` / `@ts-expect-error` require a comment explaining why and a linked issue. > Enforced by: `eslint` (`@typescript-eslint/no-explicit-any`) [Required] ### 5.2 Initialization **Required:** All variables must be initialized at the point of declaration (the analogue of the C++ init rule). **Required:** Use `readonly` on class members and object properties that are not reassigned (the analogue of C++ `const` correctness). ### 5.3 Null and Undefined **Required:** Use `undefined` for absent values; reserve `null` for interoperability with APIs that require it. Never use `==` / `!=`; always `===` / `!==`. The only tolerated loose comparison is `== null` where both `null` and `undefined` are meant — prefer explicit `x === null || x === undefined`. > Enforced by: `eslint` (`eqeqeq: ["error", "always"]`) [Required] **Recommended:** Prefer optional chaining (`?.`) and nullish coalescing (`??`) over `&&` chains and `||` defaults when the value may be `0`, `""`, or `false`. ### 5.4 Casts and Type Assertions **Required:** Avoid type assertions (`as T`). When unavoidable (e.g. after narrowing the compiler cannot follow), add a comment justifying the invariant. Double assertions (`as unknown as T`) are effectively never permitted. > Enforced by: `eslint` (`@typescript-eslint/consistent-type-assertions`) [Recommended] ### 5.5 Immutability and `const` Correctness **Required:** Function parameters shall not be reassigned. > Enforced by: `eslint` (`no-param-reassign`) [Required] **Recommended:** Prefer immutable patterns: spread over mutation, `Readonly` / `ReadonlyArray` in public signatures where mutation by callers would be a bug. ### 5.6 Enums and Union Types **Required:** Prefer `const` objects with `as const` plus a union type, or string enums, over numeric enums. Closed value sets shall be explicit — bare numbers/strings with a comment are not an enum (the analogue of the C++ `enum class` rule). ``` export const CodeMode = { Fp4Affine: 0, T158Affine: 1 } as const; export type CodeMode = typeof CodeMode[keyof typeof CodeMode]; ``` ### 5.7 Conditionals and Truthiness **Required:** All non-boolean conditional expressions shall use an explicit comparison. Do not rely on implicit truthiness for numbers, strings, or nullable values whose falsy state is ambiguous (the analogue of the C++ implicit-bool rule). ``` if (count !== 0) { ... } // correct if (count) { ... } // incorrect if (node !== undefined) { ... } // correct if (node) { ... } // incorrect for nullable objects ``` **Recommended:** Minimize negative comparisons; prefer positive logic. Use `if`/`else` over nested ternaries; a single simple ternary for value selection is acceptable. ### 5.8 Loops and Iteration **Recommended:** Prefer `for...of` and array methods (`map`, `filter`, `reduce`, `find`) over index loops. Count index loops ascending. **Recommended:** Minimize `break` in loops; use it only for abnormal early exit. Use `continue` sparingly with a comment. **Required:** Never use `for...in` on arrays. ### 5.9 Asynchronous Code **Required:** Use `async`/`await` over raw `.then()` chains. Every promise chain must have error handling; floating promises are not permitted. > Enforced by: `eslint` (`@typescript-eslint/no-floating-promises`, > `@typescript-eslint/no-misused-promises`) [Required] **Required:** In async iteration, prefer `for await...of`. Do not fire-and- forget promises without an explicit `void` operator and a comment. **Recommended:** Default to pre-increment (`++i`) where a choice exists, matching the C++ convention. ### 5.10 Regular `function` vs Arrow **Recommended:** Use arrow functions for callbacks and inline functions; use named `function` declarations for top-level functions (hoisting, stack-trace readability). Do not use `this` in module-scope arrow functions. ### 5.11 goto, Labels, and Obscure Features **Required:** Labeled statements (the JS `goto` analogue) are never permitted. The comma operator, `with`, and implicit globals are never permitted. ### 5.12 Floating-Point **Required:** Do not compare floating-point numbers for equality. Compare against an epsilon or use integer/fixed-point representations. ### 5.13 Globals and Side Effects **Required:** No mutable module-level state. Configuration and shared state are injected via constructors or parameters (dependency injection), never imported as mutable singletons. * * * ## 6. Class Design ### 6.1 Interfaces **Required:** Program to an interface: depend on `interface` types (or abstract classes) at module boundaries, not concrete implementations. **Required:** Keep class interfaces minimal and complete. A developer should only need the type declarations to use the class. **Required:** Data members shall never be public without a reason. Use `private`/`protected` and accessors. `#private` fields are acceptable; `private` (compile-time) is preferred for ecosystem compatibility. > Enforced by: `eslint` (`@typescript-eslint/explicit-member-accessibility`) [Required] **Required:** Explicit accessibility modifiers on all class members. **Recommended:** Prefer non-member, non-friend free functions over member functions when private access is not needed (matches the C++ standard). ### 6.2 Special Member Functions **Recommended:** Rule of Zero applies: classes that manage no resources directly need no explicit lifecycle methods. Resource-owning classes implement explicit cleanup (`close()`, `dispose()`, or `Symbol.dispose`/`Symbol.asyncDispose` where supported) and document the ownership contract. **Recommended:** Use `using` declarations for `Disposable` resources where the runtime supports them (the RAII analogue). ### 6.3 Inheritance **Required:** Public inheritance shall model "is-a" relationships. Never redefine an inherited non-virtual method without `override` semantics — use the `override` keyword. > Enforced by: `tsc` (`noImplicitOverride: true`) [Required] **Recommended:** Prefer composition over implementation inheritance (the C++ standard applies unchanged). ### 6.4 Encapsulation **Required:** Do not traverse multiple links in a single statement. Use named temporaries. ``` // Incorrect — hard to read and debug const name = obj.getDepartment().getManager().getName(); // Correct const dept = obj.getDepartment(); const mgr = dept.getManager(); const name = mgr.getName(); ``` * * * ## 7. Error Handling ### 7.1 Exceptions and Result Types **Required:** Throw `Error` subclasses, never string or object literals. Define a small custom error hierarchy per package (`class Sgf4FormatError extends Error`). **Recommended:** In hot paths and at API boundaries, a `Result` discriminated union return (the analogue of the C++ `outcome::result` rule) is preferred over throwing. One style per module — do not mix throwing and result-returning for the same failure modes. ``` type Result = { ok: true; value: T } | { ok: false; error: E }; ``` ### 7.2 Assertions **Recommended:** Use assertions (`invariant`-style helpers, Node `assert`) liberally to document invariants and detect programming errors. **Required:** Assertions document invariants only. Input validation at trust boundaries uses explicit checks with typed errors. ### 7.3 Exception Safety **Required:** Cleanup paths (`finally`, `dispose`) must never throw unhandled exceptions. Catch and handle anything that could escape. **Required:** A failed constructor leaves no partially-usable object: prefer factory functions returning `Result` over throwing constructors for fallible construction. * * * ## 8. File and Module Layout ### 8.1 Files **Required:** One primary class/component per file. Closely related helper types may be co-located. **Recommended:** Files should not exceed roughly 400 lines; functions should fit within approximately 100 lines (the C++ §8.4 rule applies unchanged). ### 8.2 Import Order **Required:** Order imports as: (1) node/built-in modules, (2) third-party packages, (3) project-internal modules, (4) relative imports. Alphabetize within groups. > Enforced by: `eslint` (`import/order`) [Required] **Required:** No circular imports. Shared constants/types live in a leaf module that imports nothing from the package. ### 8.3 Exports **Required:** Package entry points (`index.ts`) define the public surface explicitly. Avoid `export *` except in deliberate barrel files. **Recommended:** Use named exports over default exports (refactor-safe renaming, clearer imports). ### 8.4 Side Effects **Required:** Importing a module shall not trigger observable side effects (network, filesystem, global mutation) other than constant initialization. Initialization happens in an explicit `init()`/`main()` called by the entry point. * * * ## 9. Type Design ### 9.1 Interfaces vs Type Aliases **Recommended:** Use `interface` for object shapes that may be extended; use `type` for unions, intersections, mapped types, and function types. ### 9.2 Narrowing **Required:** Validate untrusted input (network, filesystem, user) with runtime schema validators (e.g. `zod`, `valibot`) and let types flow from the schema (`z.infer`). Never cast `JSON.parse` output directly. ### 9.3 Generics **Recommended:** Name generic parameters meaningfully (`TValue`, `TError`) when a single letter is unclear. Constrain generics (``) rather than accepting everything. ### 9.4 Utility Types **Recommended:** Prefer built-in utility types (`Partial`, `Required`, `Pick`, `Omit`, `Record`, `Readonly`) over hand-rolled mapped types. * * * ## 10. Platform Abstraction **Required:** Do not scatter environment checks (`typeof window`, `process.env`, `Deno`, `Bun`) through source files. Isolate platform and environment differences behind a single `platform` module, selected at build time or via dependency injection (the C++ §10 rule applies unchanged). **Required:** Environment variables are read exactly once, in a typed config module with validation and defaults — never ad hoc `process.env.*` throughout the code. * * * ## 11. Testing **Required:** New logic ships with tests in the same change (vitest or jest, colocated `*.test.ts` or a `tests/` tree matching source layout). **Recommended:** Tests are deterministic: seeded RNGs, fake timers, no network. Binary-format code shall include hand-constructed golden vectors, not only round-trip self-consistency checks. **Recommended:** Name tests as behavior statements (`it("decodes a MIXED record via the split map")`). * * * ## 12. Tooling ### 12.1 prettier The repository root contains `.prettierrc` encoding the formatting rules from §3. Run: ``` prettier --write # apply formatting prettier --check # check only ``` All code shall be formatted before commit. Most editors can format on save. ### 12.2 eslint The repository root contains `eslint.config.js` (flat config) encoding the static analysis rules from §4–§7, with `@typescript-eslint` type-checked rules enabled. Each rule is annotated `[Required]` or `[Recommended]`. Run: ``` eslint ``` Required rules should pass clean on new and modified code. Recommended rules may produce warnings; address them where practical. ### 12.3 TypeScript compiler ``` tsc --noEmit ``` Type checking is part of every build. `strict` mode is non-negotiable. ### 12.4 Build Verification Before committing, always: 1. Format with prettier 2. Run eslint on changed files 3. Run `tsc --noEmit` without errors 4. Run tests * * * ## 13. References - SuperGenius C++ Coding Standards, Revision 2.0 (this document's parent). - Microsoft. _TypeScript Handbook_. - Google. _TypeScript Style Guide_. - typescript-eslint project. _Recommended and stylistic rule sets_. * * * _Revision 1.0 — July 2026._ --- source: /technical-information/software-engineering-handbook/smart-contract-projects/ title: Smart Contract Projects --- # Smart Contract Projects: Git Workflow ## Repository Structure ```bash main-project/ (Node/TypeScript/Hardhat) ├── contracts// (Git submodule - Solidity contracts) ├── diamonds// (Git submodule - Deployment records & config) ├── scripts/ ├── tests/ ├── package.json ├── tsconfig.json └── hardhat.config.ts ``` ## Branch Strategy ### Main Repositories (Parent + Both Submodules) #### Core Branches - **`main`** - Production-ready code, always deployable - **`staging`** - Pre-release testing and validation (deployed to testnets) - **`develop`** - Integration branch for ongoing development #### Supporting Branches - **`feature/CONTRACT-123-add-staking`** - New features - **`hotfix/fix-critical-vulnerability`** - Critical production fixes - **`release/v1.2.0`** - Release preparation ## Naming Conventions ### Branch Names ```bash feature/ISSUE-123-brief-description hotfix/critical-issue-description release/v1.2.0 chore/update-dependencies docs/update-readme ``` ### Commit Messages ```bash feat(contracts): add staking reward mechanism (#123) fix(deployment): correct mainnet contract address (#456) test(staking): add comprehensive staking tests docs(readme): update deployment instructions chore(deps): bump hardhat to v2.19.0 ``` ### Tags ```bash v1.0.0 - Major release v1.1.0 - Minor release v1.1.1 - Patch release v1.0.0-beta.1 - Pre-release ``` ## Workflow Process ### 1. Feature Development ```bash # Start from develop git checkout develop git pull origin develop # Create feature branch git checkout -b feature/ISSUE-123-add-governance # Update submodules to latest develop git submodule update --remote --merge # Work on feature... # Make commits following conventional commit format # Push feature branch git push -u origin feature/ISSUE-123-add-governance ``` ### 2. Pull Request Requirements #### PR Title Format ```bash feat: Add governance token staking mechanism (#123) fix: Resolve deployment configuration for Polygon (#456) ``` #### Required PR Checks - [ ] All tests pass (unit + integration) - [ ] Smart contracts compile without warnings - [ ] Gas optimization review completed - [ ] Security considerations documented - [ ] Deployment plan updated (if applicable) - [ ] Documentation updated - [ ] Submodule versions properly updated #### PR Template ```markdown ## Description Brief description of changes ## Type of Change - [ ] Bug fix - [ ] New feature - [ ] Breaking change - [ ] Documentation update ## Smart Contract Impact - [ ] New contracts added - [ ] Existing contracts modified - [ ] Deployment configuration changed - [ ] Gas cost implications ## Testing - [ ] Unit tests added/updated - [ ] Integration tests pass - [ ] Mainnet fork testing completed ## Deployment Checklist - [ ] Deployment scripts updated - [ ] Configuration files updated - [ ] Migration strategy documented ## Security Review - [ ] No new attack vectors introduced - [ ] Access controls reviewed - [ ] Third-party integrations validated ``` ### 3. Submodule Management #### Updating Submodules in Parent ```bash # Option A: Update to latest commit on develop git submodule update --remote --merge # Option B: Update to specific commit cd contracts git checkout feature/new-contract cd .. git add contracts git commit -m "feat: update contracts submodule to include new staking contract" ``` #### Submodule Workflow Rules 1. **Contracts submodule**: Always merge to develop first, then update parent 2. **Deployments submodule**: Updated immediately after successful deployments 3. **Atomic updates**: Submodule updates should be separate commits with clear messages ### 4. Release Process #### Creating a Release ```bash # Create release branch from develop git checkout develop git pull origin develop git checkout -b release/v1.2.0 # Update version numbers, changelogs # Final testing and bug fixes only # Merge to main git checkout main git merge --no-ff release/v1.2.0 git tag -a v1.2.0 -m "Release version 1.2.0" # Merge back to develop git checkout develop git merge --no-ff release/v1.2.0 # Clean up git branch -d release/v1.2.0 ``` ## GitHub Integration ### Branch Protection Rules #### Main Branch - Require pull request reviews (min 1 reviewer) - Require status checks to pass - Require branches to be up to date - Require conversation resolution - Restrict pushes to admins only #### Develop Branch - Require pull request reviews (min 1 reviewer) - Require status checks to pass - Allow force pushes for admins ### GitHub Actions Workflow ```yaml # Example CI/CD triggers on: push: branches: [main, develop] pull_request: branches: [main, develop] jobs: test: # Run tests, linting, security checks deploy-testnet: if: github.ref == 'refs/heads/develop' # Auto-deploy to testnet deploy-mainnet: if: github.ref == 'refs/heads/main' # Manual deployment to mainnet ``` ### Issue and Project Integration #### Issue Labels ```bash Type: - bug - feature - security - gas-optimization - documentation Priority: - critical - high - medium - low Component: - contracts - deployment - testing - infrastructure ``` --- source: /technical-information/software-engineering-handbook/recommended-pattern-for-llm-usage-in-team-gpt/ title: Recommended Pattern for LLM Usage in Team-GPT --- --- description: >- This page outlines best practices for leveraging Large Language Models (LLMs) within Team-GPT to optimize software engineering workflows, particularly for architecture design, code generation, and pro --- # Recommended Pattern for LLM Usage in Team-GPT ### Architecture Planning When planning the high-level architecture or summary design of a project: * Use the following LLMs in this preferred order for generating architectural summaries: 1. **gpt-oss-20b** (primary choice for open-source efficiency). 2. **Grok 4** (reliable and versatile). 3. **Claude Opus 4.1** (strong for complex reasoning). 4. **ChatGPT 5** (as a fallback for advanced capabilities). * Instruct these LLMs explicitly **not to generate code**. Their role is limited to providing architectural overviews, diagrams, or high-level designs without delving into implementation details. * If the initial architecture needs refinement or you encounter limitations, switch to **Grok Code Fast** for quick iterations. This model is extremely cost-effective but may be less accurate, so validate outputs carefully. * For troubleshooting or alternative perspectives, cycle through these models: * **Qwen Code 3** (free, but slower with a good parameter size for detailed reasoning). * **Grok Code Fast** (fast and inexpensive, though prone to occasional errors). * **Claude Sonnet 4** (moderately priced and reliable for balanced performance). Avoid using **Claude Opus**, **GROK 4**, or **ChatGPT 5** for any code-related tasks, as they are not optimized for code generation and incur higher costs. ### Code Generation Once the architecture is outlined: * Switch to specialized code generation LLMs, such as **Grok Code Fast** or **Qwen Code 3**, for producing actual code. * Instruct these LLMs to **generate code without placeholders**. This ensures complete, ready-to-use code rather than partial or templated outputs. * Do not use architecture-focused models (e.g., Claude Opus, GROK 4, or ChatGPT 5) for this step, as they are inefficient and expensive for code tasks. #### Integration with Project Knowledge * When creating a new chat for code generation, ensure it includes **project instructions**. Copy these from existing practices for a C++ senior software engineer (e.g., coding standards, best practices, and guidelines) and add them to the project's knowledge base. * Reference the **ThirdParty\_Libraries\_Integration.md** file to inform the LLM about approved C++ libraries and integration patterns. Include this file in the project knowledge for any new projects to maintain consistency. ### Testing and Validation * After code generation, use the coding LLM (e.g., Grok Code Fast or Qwen Code 3) to **write GTests** (Google Test framework tests) for the generated code. * Ensure tests are comprehensive, drawing from the project's knowledge base, including architecture summaries and library integrations. ### Project and Chat Setup * **New Projects**: When starting a new project, populate the project knowledge with: * A description of the project. * Copied instructions from established C++ senior software engineer practices. * The **ThirdParty\_Libraries\_Integration.md** file for library details. * Any relevant files or linked chats. * **Chats Under Projects**: If creating sub-chats within an existing project, they will automatically source context from: * The project's knowledge description. * Attached files (e.g., architecture docs, library integrations). * Linked chats for continuity and shared context. This pattern promotes a structured workflow: start with high-level architecture using cost-effective reasoning models, transition to efficient code generators, and ensure testing and project consistency through integrated knowledge. Always monitor for accuracy and switch models as needed to balance speed, cost, and quality. --- source: /technical-information/super-genius-blockchain-technical-details/ title: Super Genius Blockchain Technical Details --- # Super Genius Blockchain Technical Details The code is based on the following patent: [Distributed General Purpose Computing System with CryptoToken Payment System - Patent #US11451393](https://github.com/GeniusVentures/GeniusTokens/files/10827213/US11451393-final.pdf) ## This is the general flow of the Genius Tokens system ![Genius CryptoToken Process-Flow](<../../.gitbook/assets/Process Flow print.jpg>) ## These are the components of the System
* Generic BlockChain CryptoToken = Ethereum based smart contract using an Escrow like system that feeds the “Real” POW hash codes to Smart Contract to check consensus. Wiki/Repo * Communication Component = ipfs pub/sub using Gossip protocol. Wiki/Repo * Proof of Work Component = partially built, but gathers all “real” POW from all nodes and passes them to the smart contract for consensus check * Directed Acyclic CryptoToken = Partially built DAG system built off of IPFS DAG, POW/POS Blended Consensys. Wiki/Repo * Distributed File System = ipfs-lite (already built) Wiki/Repo * Delivery/Storage Component – RocksDB with ipfs backing, CRDT library needs to be integrated as full DAG is stored on ifps and branch roots and sub-branches need to be synchronized * https://arxiv.org/abs/2004.00107 paper on similar system * CRDT cpp library is available. [Repo](https://github.com/CBaquero/delta-enabled-crdts), ipfs-lite, [RocksDB](https://github.com/facebook/rocksdb/), ifps pub/sub gossip are already integrated. * CryptoToken Wallet = Flutter/Parabeac design and Dart code in development, Wallet is actually Wallet for two Crypto’s Genius Token (GNUS) and SuperGenius Token (SGNUS) and DApp combined. Wiki/Repo * Processing Component = Work to be done by for integration with Games/App GPU/Shader processing will be part of SDK. Wiki/Repo * Software Development Kit API = work to be done for interface to Processing Component and checking wallet balance for In-App Purchases. Wiki/Repo * (Not Shown) Third Party support library, includes cross Platform libraries for Boost, GSL, GTest, Curl, Cryptopp, 25519, flutter, Parabeac, gnostic, grpc, hat-trie, ipfs-lite-cpp, openssl, json, leveldb, libp2p, lmdb rapidjson, restclient-cpp, spdlog Repo --- source: /technical-information/super-genius-blockchain-technical-details/supergenius-db-layout/ title: SuperGenius DB Layout --- --- description: This page explains the SuperGenius Layout of the CRDT database --- # SuperGenius DB Layout The storing of processing data, transaction data, proof data and blockchain data of SuperGenius is done in CRDT database. The storage is accessed by a Key-Value mechanism, where each type of data has a specific format of key, making sure that each SuperGenius node instantly knows how to construct the key to search for a specific value. The processing data comes from splitting a Job into Macro and Micro Jobs. Their key format is expected to be: ``` Processing/${JobID}/${SubTaskID}/${ProtocolType}/Output ``` The IDs are assigned when the input data is split into workable packets, as for the Protocol Type is associated with the kind of protocol used for the processing (IPFS, MNN, file...) The remainder of key types formats start with "bc-" followed by the 3 digit ID of the type of net being used. ```bash bc-${net_iD}/ ``` The blockchain data is store in the format: ``` bc-${net_ID}/blockchain/${blockNumber}/tx/${transactionNumber} ``` --- source: /technical-information/super-genius-blockchain-technical-details/ai-data-blocks/ title: AI Data Blocks --- # AI Data Blocks ## AI Processing Data blocks pulled from ipfs via IPFS CID/UUID Chunk processing is similar to how jpeg blocks are processed but block size can be anything 4x4, 8x8, 12x16, etc.
It also is very similar to how a GPU handles tiling. ![GPU-Tiling](<../../.gitbook/assets/GPU Tiling.png>) ## Job Data Structure. (Picture of Soccer Player in Picture Above) ``` typedef struct _JOB { IPFSCID ipfsBlock; // source block data to be processed IPFSCID ipfsProgramBlock; // can be an array unsigned long BlockLen; // and ipfs block's length in bytes unsigned long BlockStride; // Stride to use for access pattern unsigned long BlockLineStride; // Line stride in bytes to get to next block start float randomSeed; // used to randomly choose verifier block UUID resultsChannelUUID; // results written to CRDT database unique ID (/blockchain/{BlockChainID}/{resultsChannelUUID}/{MacroJobUUID}/{MicrojobUUID} } JOB; ``` ## Chunk (Macro & Micro Job) Data Structure (Macro -> Grid in picture Block-n, Block m are Macro jobs, AC01, AC07 & Tiles in second picture are Microjobs) ``` typedef struct PROCESSCHUNK { IPFSCID dataChunkID; // the UUID of the data chunk to be processed IFPSCID programChunkID; // the UUID of the program to run on the data (ipfs CID) unsigned long Offset; // offset into data unsigned long SubChunkWidth; // width of subchunk/subblock unsigned long SubChunkHeight; // height of chunk/block unsigned long Stride; // stride to use for overall data chunk unsigned long LineStride; // stride of one line of data unsigned long nSubChunks; // number of chunks to process (this breaks down into microjobs) UUID chunkUUID; // the macro/micro job id to use for writing results } PROCESSCHUNK; ``` ## Access Patterns of the Chunk/Blocks of Data The block stride is the number of bytes to get you to the next block. * if block stride = width of block in bytes, then processing of blocks source the blocks horizontally. * if block stride = line width of data \* height of block, then processing of blocks source the blocks vertically * Other access patterns can be achieved * for instance if block stride = 2 \* width of data \* height of block, then processing of blocks will source every 2nd block in the horizontal direction Those parameters allow you sample in any pattern. Blocks could be top to bottom in a column, you can sample in a row or even diagonally given block stride value The line stride is the number of bytes to get you to the next line in the block (usually the width of the data). The block width is the number of bytes in single line of a block. Height of the block is the number of lines of the block. Offset is starting byte position of ipfs data. --- source: /technical-information/super-genius-blockchain-technical-details/slicing-data-for-macro-microjobs/ title: Slicing Data for Macro MicroJobs --- # Slicing Data for Macro MicroJobs MacroJobs and Microjobs using slicing parameters for access patterns. One of the nodes (randomly chosen) uses a slicing pattern that includes an extra block to skip so that verifier node grabs 1/10th of the blocks from the each of the other nodes. ``` // temporary testing RanomSeed(gettime() ^ 0xdeadc0de); int getContractRandom() { // call ETH contract to get RandomSeed // return eth.call.getContractRandom(); // dummy for now return Random(); } RandomSeed(getContractRandom()); for (int i=0; i< nMacroJobs; i++) { macroJob[i].randomSeed = Random() + i; macroJob[i].UUID = GetUUUD(); } #define MICROJOB_COUNT 10 // create Microjobs void CreateMicroJobs(MacroJob *macroJob) { RandomSeed(macroJob.randomSeed); int verifier_node = Random(1, MICROJOB_COUNT); for (int i=0; i< MICROJOB_COUNT + 1; i++) { if(i != verifier_node) { SliceData(¯oJob->sliceParameters, µjob[i], 0, MICROJOB_COUNT); } else { uint offset = Random(1, MICROJOB_COUNT) * microJobBlockSize; SliceRandomData(¯oJob->sliceparameters, µjob[i], offset, MICROJOB_COUNT+1); } // SliceData creates slicing parameters for Microjob SliceData(SliceParameters *sliceParameters, MicroJob *microJob, uint offset, uint nextBlock) { microjob->slicingParameters.offset = offset; microjob->slicingParameters.nextBlock = nextBlock; // Copy macroJob->slicingParameters or calculate rest of them } ``` --- source: /technical-information/super-genius-blockchain-technical-details/verification-and-hash-results-from-processing/ title: Verification and Hash Results from Processing --- # Verification and Hash Results from Processing ## Jobs/Macro Jobs/Micro Jobs, oh my! A job is a set of data that will be processed using AI/ML learning/inference models and the results stored back into a stream (IPFS, websockets, FTP, etc). Currently, we will only support IFPS. #### Job Creation and Escrow When a Job request is started via the Wallet/Dapp, that node/device is responsible for opening an Escrow and depositing GNUS tokens to be distributed to the nodes that process the jobs. (Job Requestor) The Job Requestor will first make a read-only call to get a unique ID to be used as a pseudo random seed. This will be used as the starting point of a pseudo random number generator for slicing and selecting the verifier node of the JOB The Job Requestor then makes a call to the EVM contract (Polygon RPC call) to open up an Escrow. This will cost MATIC gas fees and GNUS tokens, TODO: Gasless fees how to do that? #### Slicing A slicer slices the Job into Macro Jobs, Micro jobs using block size that as predefined default values. The slicing code will produce N+1 Microjobs. The +1 is the verification data in which the slicer selects 1 block from each of the other microjob blocks randomly and places them into the N+1 microjob. Nodes will not know if they are verifying or processing data. The N+1 blocks use the same GPU code so will generate a hash for a block. The micro job saves hashes, not a single hash of the microjob, it saves a hash per block of the microjob. The slicer will have predefine defines for the size of blocks in the code which can be overridden/changed in the dapp. For instance. This is an example of the default values that can be used to slice the AI/ML data to be processed ```C++ #define MICROJOB_BLOCK_WIDTH = 256; #define MCROJOB_BLOCK_HEIGHT = 256; #define MICROJOB_X_BLOCK_COUNT = 4; #define MICROJOB_Y_BLOCK_COUNT = 4; #define MICROJOB_BLOCK_SIZE = (MICROJOB_BLOCK_WIDTH*MCROJOB_BLOCK_HEIGHT * sizeof(FLOAT32)) #define MICROJOB_SIZE = (MICROJOB_X_BLOCK_COUNT * MCROJOB__Y_BLOCK_COUNT) * MICROJOB_BLOCK_SIZE ``` This would make 1024x1024 \* 32-bit float data (4 MegaBytes of data) to process for a microjob. A macro job could have 10 of these for 40 Megabytes of data. A Job could have 5 of these for 200 Megabytes of data The number of hashes generated would be 16 (MICROJOB\_X\_BLOCK\_COUNT \* MICROJOB\_Y\_BLOCK\_COUNT) for each microjob. These values are store with the processed data in the data storage (currently only IPFS). ## Finalization (Signing) of Microblocks Once an Escrow is opened for a Job to be completed on the EVM blockchain (Ethereum, Polygon, etc). There are a few parameters stored in the blockchain for the job. These will all be used with [Zokrates](https://github.com/Zokrates/ZoKrates) Solidity code for verification ```Solidity struct EscrowAIJob { uint256 ownerAddress; uint256 SliceParameterEncoding; // zkSnark encoding of slicing parameters & timestamp & previous Super Genius block hash bool isFinalized; }; ``` Storage in Super Genius Blockchain DB/chain ```Solidity struct ProcessedJobInfo { uint microJobBlockNumber; // the index of the microjob processed uint256 hashOfDataProcessed; // hash of the data processed struct Hashes { uint256 blockHash; // hash of base struct not including hashes & SliceParameterEncoding from AI Escrow Job & previous block hash uint256 signature; // signature of everything except signedBlock } } ``` When calling Zokrates (ZKSnark) solidity code for signing of microjobs sets. Zokrates Implementation Info * Assumes 10 microjob(s) \* 10 blocks processes + 1 verify job \* 10 blocks processed * Last node of this job, sends all hashes in an array and internal Zokrates code gets JOB id and starting pseudo random number to pick out the verifier nodes hashes and can index other nodes hashes for verification. * The Solidity contract can also verify the merkle nodes match back up to the root hash of microjobs processed * This constructs the indices of the matches, step must be odd * i.e. Found matching hashOfDataProcessed in microjob 1 at index 5 etc., indices should match SliceParameterEncoding * Example (5, 6, 7, 8, 9, 0, 1, 2, 3, 4) hashed, step 1 * Another Example (5, 8, 1, 4, 7, 0, 3, 6, 9, 2) hashed, step 3 Pseudo Code function call in EVM contract. Zokrates encodes this into ZKSnark Solidity Code. Calls to RPC blockchain will be gas free since these are just public view (read-only) functions. ```Solidity // Close Escrow Code CloseEscrow(uint256 jobID, uint256 signature, uint256 prevBlockHash, ProcessedJobInfo[] jobInfo, address nodeProcessors[], uint256 amounts[]) public { require(EscrowAI.Jobs[jobID].finalized != true); require(verifyZKSignature(jobInfo, prevBlockHash)); _mintBatch(nodeProcessors, amounts); // set internal job finalized and EscrowAI.Jobs[jobID].finalized = true; } ``` ```Solidity // Zokrates code function getZKSignature(ProcessedJobInfo[] jobInfo, uint256 indexHash) public view returns (uint256 signature) { uint256 indexStart, step = decode(EscrowAIJob.SliceParameterEncoding); uint256 verifiedHashStart = (indexStart * step * 10) % 11; uint verifiedIndex = 0; uint matchingBlocks = 0; for (uint i = indexStart; i < 10; i += step) { if (jobInfo[i].hashOfDataProcessed == jobInfo[verifiedIndex++].hashOfDataProcessed) { matchingBlocks++; } return keccak256(indexHash, matchingBlocks); } ``` ```Solidity function verifyZKSignature(ProcessedJobInfo jobInfo, uint256 previousBlockHash) public view returns (boolean) { return wasSigned(jobInfo.signature, EscrowAIJob.SlicingParameterEncoding, jobInfo.Hashes.blockHash, previousBlockHash); } ``` --- source: /technical-information/super-genius-blockchain-technical-details/diagram-of-the-internal-blockchain-blocks-and-processing-functionality/ title: Diagram of the internal blockchain, blocks and processing functionality --- # Diagram of the internal blockchain, blocks and processing functionality ![Processing-Diagram](<../../.gitbook/assets/Processing Diagram.png>) --- source: /technical-information/super-genius-blockchain-technical-details/ipfs-pub-sub/ title: IPFS Pub Sub --- # IPFS Pub Sub ## Description Pub/Sub in general uses ifps-pubsub library which is using the libp2p [gossip protocol](https://docs.libp2p.io/concepts/publish-subscribe/) All communications should be defined in OpenAPI yaml files under the project gRPCForSuperGenius. The readme for how to generate C++ code is in the README.md in that project ## Processing pub/sub After a processing block is in the database, the processing nodes (clients device), syncs to the database using CRDT system. Once they find a node to be processed they use pub/sub to Join or Create pub/sub room for processing a set of blocks. On the SGNUS SDK side, it should be fairly straightforward to make functions for multiple devices, basically using pub/sub over ipfs to communicate to find microjobs. The node grabbing the job can break it up into 10 microjobs and publish a channel. The channel could have jobprocessing\_%BLOCKID% in which BLOCKID is the CRDT database node that contains the processing information. Each of these rooms would then have a sub-room which is the microjobs #. For instance, if there are 1,000 sub-blocks to process, then there would be 100 1,000/10 microjob rooms. jobprocessing\_%BLOCKID%\_%MICROJOB% pub/sub channel/room The pub/sub ARE nodes to find microjobs, this is very similar to a game player looking for a lobby to join a peer-to-peer game. The pub/sub to find jobs is basically a cache of jobs in the queue eventually. Each processing node will use the function in Genius SDK to get MicroJob and then publish the results. Right now the processing can be stubbed out like this. ```cpp // This comes from the Dapp and randomSeed if used to choose verifier block. typedef struct _JOB { UUID ipfsBlock; // source block data to be processed unsigned long BlockLen; // and ipfs block's length in bytes unsigned long BlockStride; // Stride to use for access pattern unsigned long BlockLineStride; // Line stride in bytes to get to next block start float randomSeed; // used to randomly choose verifier block PUBSUBCHANNEL resultsChannel; // which channel to publish results to. } JOB; typedef struct _PROCESSSUBCHUNKS { UUID chunkID; // unique process chunk ID unsigned long Offset; // offset into data unsigned long SubChunkWidth; // width of subchunk/subblock unsigned long SubChunkHeight; // height of chunk/block unsigned long Stride; // stride to use for overall data chunk unsigned long LineStride; // stride of one line of data unsigned long nSubChunks; // number of chunks to process } PROCESSSUBCHUNKS; typedef struct _MICROJOB { UUID ipfsBlock; // source block data to be processed PROCESSSUBCHUNK chunksToProcess[]; // array of chunks to process unsigned long datalen; // length of ipfs Block? PUBSUBCHANNEL resultsChannel; // channel to publish results to } MICROJOB; typedef struct _RESULTSMICROJOB { unsigned long resultHash; // hash of results unsigned long chunkHashes[]; // the hashes for each chunk UUID ipfsResultsData; // UUID of the results data on ipfs } RESULTSMICROJOB; // node that created processing channel DoProcessing(JOB *job) { MICROJOBS microJobs[] = SplitJob(job); for (unsigned long i = 0; i < microjobs; i++) { PublishMessage(DoProcessing, micrfoJobs[i], uniquePeerID); } } // each Peer ID DoProcessing(MICROJOB *mjob, UUID peerID) { if (peerID != myUUID) { // won't validate because hash will be incorrect return; } RESULTSMICROJOB resultsMicroJob = ProcessSubChunks(chunksToProcess[i], peerID); unsigned long hashCode = peerID; for (unsigned long i = 0; i< resultsMicroJob->chunkHashes.size; i+=) { hashCode ^= resultsMicroJob->chunkHashes[i]; } resultsMicroJob->results = hashCode; AddSGNUSPendingBlock(resultsMicroJob); PublishResults(resultsMicroJob); } } ``` ## Handling of processing grid structure changes If a host leaves, somebody else will have to take the position by either recreating the microjob list or grabbing it on the first entry into the room. Also if a peer leaves the room (drops connection) or doesn't respond within XX timelimit for processing, they get kicked out of the room so another can process the data. Each room (pub/sub topic) also has a limit of # processors to join. Probably 11 to start. 10 processors and 1 verifier node. The verifier is randomly chosen and it is unknown by anybody even the verifier until all processing is done and they have to submit to SGNUS node that processing is complete and verified. ## Processing Chunks. A Chunk structure is defined to allow widths and strides (line and block) to be able to define sub-blocks within a data stream. --- source: /technical-information/super-genius-blockchain-technical-details/sg-consensus-algorithm-implementation/ title: SG Consensus Algorithm Implementation --- # SG Consensus Algorithm Implementation * SG Consensus algorithm is based on GOSSIP protocol. * System uses libp2p library for P2P Gossip messaging. **Gossip Message Types** * BLOCK ANNOUNCE * VERIFICATION * TRANSACTIONS * STATUS * BLOCK REQUEST Consensus protocol uses `VERIFICATION` gossip message for consensus process. There are two different types of VERIFICATION message 1. VOTE message 2. FIN message There are three different types of Vote Messages\ \ **Primary Propose**\ Primary node broadcasts Primary Propose message to all nodes to validate a transaction.\ **Pre Vote**\ Nodes after receiving Primary Propose send Pre-Vote message (initial vote) to all other nodes.\ **Pre Commit**\ Nodes after receiving pre-votes from other nodes sends stronger commitment using pre-commit vote.
**Vote Message Format**\ \| `Voting Round Number` | `Membership Counter` | `Message Data` | ## Consensus Protocol Message Sequences ```mermaid sequenceDiagram PN->>N1: Primary Propose PN->>N2: Primary Propose N1->>N2: Pre-Vote PN->>N1: Pre-Vote PN->>N2: Pre-Vote N2->>N1: Pre-vote N2->>PN: Pre-Vote N1->>PN: Pre-Vote N2->>PN: Pre-Commit PN->>N1: Pre-Commit N2->>N1: Pre-Commit N1->>PN: Pre-Commit N1->>N2: Pre-Commit PN->>N2: Pre-Commit N1->>N2: Fin PN->>N2: Fin PN->>N1: Fin N2->>PN: Fin N1->>PN: Fin N2->>N1: Fin ``` --- source: /technical-information/super-genius-blockchain-technical-details/account-creation-with-ecsda-and-el-gamal/ title: Account creation with ECSDA and El Gamal --- # Account creation with ECSDA and El Gamal #### System Overview This system utilizes ECDSA (Elliptic Curve Digital Signature Algorithm) keys from a user's current wallet to initiate a multi-step process that securely manages and encrypts wallet keys and signatures. Specifically the Trust Wallet core functionality, upon which the GNUS wallet is based, initializes by importing addresses (e.g. BTC, ETH) or, otherwise, creating new ECDSA keys and addresses for these (non-GNUS) L1s. These will be called "Original Keys" and "Original Addresses". With each Original Key so imported or created, the GNUS wallet then generates additional keys and addresses ("Proxy Keys" and "Proxy Addresses") that, among other things, provides privacy of Original Addresses. That is, for tokens bridged in or out of the GNUS network, only Proxy Addresses appear on the GNUS network. #### Step-by-Step Process 1. **ECDSA Proxy Address Generation**: * Whenever a new Original Key is imported or created, the GNUS wallet will then generate a corresponding L1 proxy ECDSA key-pair and address ("Proxy Keys"). For this, the GNUS network retains a fixed set of predefined ElGamal key pairs ("Gate Keys"). The system signs (with the current private Original Key) a public Gate Key, selected as a function of the user's Original Key, and feeds this "K-Seed" into a [key-derivation-function.md](key-derivation-function.md "mention") (KDF), which deterministically returns a value ("Key Gen") to be used to generate the Proxy Key pairs and addresses. 2. **ElGamal Key Generation**: * The KDF-derived Key Gen value is then also used to generate ElGamal encryption keys. This step introduces an additional layer of cryptographic security, enabling secure message encryption and decryption capabilities. 3. **Encryption with ElGamal Keys**: * The system then utilizes one Gate Key to encrypt the K-Seed (ECDSA signature) and the private Proxy Key. This encrypted data ensures that sensitive information, such as signatures and private keys, is securely stored and transmitted. 4. **Regeneration of KDF Keys**: * Users do not need to store their KDF keys across sessions. Instead, these keys can be deterministically regenerated using the original ECDSA signature. This feature simplifies key management and enhances security by reducing the need to store sensitive information. 5. **Integration with zk-SNARKs**: * Although the newly derived KDF could theoretically be used in various cryptographic applications, its direct use as a prover key in a zk-SNARK system is unlikely due to the circuit-specific nature of zk-SNARK proofs and the requirement for a Universal Common Reference String (CRS). However, this does not preclude its use in other aspects of a zk-SNARK-based system or in ensuring privacy and security through other means. A pseudo-code of the account creation is shown below: ```cpp BitcoinNode CreateAccount( const ECDSA &prvt_key ) { auto elgamal_pubkey_predefined = GetAddressFromTable(); auto cypher_signature = prvt_key.sign(elgamal_pubkey_predefined); auto new_derived_key_value = GenerateKDF(cypher_signature); BitcoinNode proxy_bitcoin_node(new_derived_key_value); ELGamal new_keys_elgamal(new_derived_key_value); auto encrypted_signature = new_keys_elgamal.encrypt(cypher_signature); auto encrypted_kdf = new_keys_elgamal.encrypt(new_derived_key_value); CRDT.store(encrypted_signature); CRDT.store(encrypted_kdf); return proxy_bitcoin_node; } ``` #### Security and Privacy Implications This system is designed with a focus on security and privacy, leveraging the strengths of ECDSA, KDF, and ElGamal encryption to protect user data and transactions. The ability to encrypt key information and signatures with ElGamal keys, coupled with the privacy offered by proxy addresses and the security of deterministic KDF key regeneration, provides a robust framework for secure and private cryptocurrency transactions. #### Conclusion The described cryptographic system offers a comprehensive approach to enhancing security and privacy in cryptocurrency transactions. By integrating ECDSA, KDF, and ElGamal encryption, and acknowledging the potential (though circuit-specific) integration with zk-SNARKs, it presents a sophisticated model for secure cryptographic operations within the blockchain ecosystem. --- source: /technical-information/super-genius-blockchain-technical-details/key-derivation-function/ title: Key Derivation Function --- # Key Derivation Function This module creates a new derived value from an input data vector. The creation is deterministic and fast, aiming to generate a new value by hashing the input data. The output value derives new keys and consequently addresses. The input data must map to a relation between a private ECDSA key and a public key value. ``` uint256_t GenerateKDF(const vector &data); ``` --- source: /technical-information/super-genius-blockchain-technical-details/el-gamal-encryption/ title: El Gamal encryption --- --- description: The El Gamal scheme is used to provide asymmetric and homomorphic encryption --- # El Gamal encryption To enable safe sensitive data communication El Gamal was chosen due to its ability to have homomorphism and its asymmetric nature. For each input number $$r$$ El Gamal encryption generates a pair of cypher text data $$C_1C_2$$using the public parameters prime $$p$$, generator $$g$$ and public key value $$x$$. The cypher text is not deterministic, meaning a randomness factor is inserted in the encryption, which increases the security of the encrypted data. The decryption process also uses the public parameters $$p$$ and $$g$$ but needs the private key $$y$$ which defines the scheme as asymmetric. El Gamal scheme by default has multiplicative homomorphism, meaning that the encryption of the multiplication of raw data is equal to the multiplication of encrypted data, i.e: $$C_1C_2(x*y) = C_1C_2(x) * C_1C_2(y)$$ Although the application for this characteristic is not directly useful for this project, it indirectly allows additive homomorphism if we use the input data as exponents, being that multiplication of same base operands result in addition of its exponents, so this result in the following scheme for additive homomorphism: $$C_1C_2(g^{x+y}) = C_1C_2(g^x) * C_1C_2(g^y)$$ This process has a downside as the resulting decryption will retrieve $$g^{x+y}$$instead of $$x+y$$. To retrieve the original data the ECDLP would have to be solved, which depending on size of $$x$$and $$y$$ is not feasible. However in zkSnarks context we intend to prove the validity of a transaction without needing to reveal the actual value, thus attending to the project's needs. For data that doesn't require additive homomorphism there's no need to encode the original input as exponents, meaning the decryption will avoid having to solve the ECDLP. In this project the raw data encryption will also be used on other sensitive data, such as the KDF secret sharing. --- source: /technical-information/super-genius-blockchain-technical-details/prover-specification/ title: Prover specification --- --- description: The prover specification (variables, types, general structure) --- # Prover specification For each SuperGenius set of keys, the prover will generate a KDF, deriving a new shared secret to be used by the Verifier and Revealer. This secret can be used to derive a new Bitcoin/Ethereum address to avoid using the original address. As mentioned in the KDF explanation, the account key will be composed of the currency address and the SuperGenius KDF private key: ```cpp struct{ uint256 publicAddress; ///< Public BTC/ETH address uint256 KDFPrivateKey; ///< KDF private key std::Array proof; ///< proof of correctly created account } EncryptedAccount; ``` The encryption of the data would then be verified in zkSnark and stored in SuperGenius in CRDT, under /Accounts/\/EncryptedAccount. The transaction's structure will hold the number of transactions, GNUS token IDs, an El Gamal encrypted amount field, and a proof or an aggregate proof (folding, etc): ```cpp struct { uint256 nTransactions; ///< Non-encrypted number of tokenIDs and Amounts uint256 tokenID[]; ///< Non-encrypted GNUS ERC1155 token IDs (could be child tokens array) uint256 Amount[]; ///< Exponential El Gamal encrypted amounts std::Array proof; ///< proof of valid account transfer } Transactions; ``` --- source: /technical-information/super-genius-blockchain-technical-details/supergenius-processing-component-information/ title: SuperGenius processing component information --- # SuperGenius processing component information The SuperGenius processing component uses the ifps-pubsub gossip protocol, similar to how a game has a lobby system for a peer-to-peer game. All SuperGenius nodes subscribe to the processing channel. To begin processing a request is made to the channel for any open processing requests with a slot open. If a slot is open, the node joins the sub-channel processing- where UUID is a unique ID created by a processor node; see next section. If no slots are open, the processing node grabs the block-lattice branch (database records) of their synced database records which have block data of request to process. The node grabs the UUID from the db record and then opens up a processing- channel, and publishes the UUID to the main channel. The channel publish/subscribe system uses ipfs-pubsub with communication protocol using gRPC. --- source: /technical-information/super-genius-blockchain-technical-details/supergenius-processing-component-information/processing-worker-app-workflow/ title: Processing worker app workflow --- # Processing worker app workflow 1. The application starts a local gRPC processing service to allow other processing peers to communicate with it. ``` processingServiceServer = new ProcessingServiceServer("localHost:port"); processingServiceServer->Run(); ``` 2. Application connects to the local GRPC processing service. ``` processingServiceClient = new ProcessingServiceClient("localHost:port"); ``` 3. The application requests a list of available processing room names (IDs) from a database. ``` roomList = processingServiceClient->GetRoomList(); ``` 4. Application sequentially tries to join a room from the room list. ``` foreach( room in roomList) if (processingServiceClient->RoomJoin(room) == OK) break; ``` 5. If a room is joined, the application receives data to process and starts local data processing. Once a result is calculated, the worker publishes it to the room. ``` if (processingServiceClient->RequestProcessingData("room", out data) == OK) { result = Calculation(); processingServiceClient->PublishProcessingResult(roomName, result); } ``` NOTE: Since data processing is implemented on the application side, requesting a new processing sub-block from the application is easier than initiating the processing from the room host. 6. The worker replicates the room creator job if the processing data request fails. See details in [Paragraph 2](https://github.com/GeniusVentures/SuperGenius/wiki/2-Processing-Workflow#2processing-room-workflow) ``` if (processingServiceClient->RequestProcessingData("room", out data) != OK); { // Becomes a room manager } ``` ### 2 Processing room workflow Assumptions: any processing node participles in a single processing room simultaneously. 1. If a room joining process fails, the application should create a new processing room and manage the processing. ``` data = RetrieveDataToProcess(); dataSubBlocks = SplitDataToChunks(); processingServiceClient->PublishDataToProcess(roomName, dataSubBlocks); ``` 2. Once PublishDataToProcess() method is called the local gRPC service starts the room managing. Initially, it notifies other peers that the room host has changed: ``` PublishDataRoProcess(roomName, dataSubBlock) { SaveDataSublocks(); foreach(peer in peerList); peer.processingService->OnHostChanged(currentPeerInfo); } ``` 3. When any peer joins the room, it sends the join request to the room Pub/Sub channel. The room host checks if the room peers' limit is not reached and either accepts the request or rejects it. See details in [Paragraph 4](https://github.com/GeniusVentures/SuperGenius/wiki/2-Processing-Workflow#4room-join-process) ``` RoomJoin(roomName, remotePeer) { channel = SubscribeToPubSubChannel(roomName); peerList = channel.GetlPeerList(); if (peerList.size() <= 1) ROOM_DOES_NOT_EXIST; else { channel.Publish("Room join request") { CHECK_ASYNC_RESPONSE } } } // On room host side OnJoinRequestMessageReceived(message, peer) { if (peerList.size() < roomSizeLimit) { peerList.push_back(remotePeer); createDirectConnection(remotePeer); foreach(peer in peerList); peer.processingService->OnPeerListChanged(peerList); } } ``` 4. The room host keeps connections to remote peers. If a connection error occurs, the host removes the failed peer from the room peer list and notifies other peers about the list changes. ``` OnConnectionError(peer): peerList.remove(peer); peer.processingService->OnPeerListChanged(peerList); ``` 5. When a data sub-block is requested, the host tracks the request time and peer. If a processing time limit is reached but the corresponding result is not received, the host excludes the peer from the processing room and notifies other peers about the peer list change. 6. If the room host leaves the room (due to a connection error, for instance), any other peer from the room should be able to take responsibility. Thus, another peer in the room should be notified when a worker requests data for processing. ``` RequestProcessingData(roomName, dataSubBlock) { dataSubBlock = FindDataSubBlock(out subBlockID); foreach(peer in peerList); peer.processingService->OnSubBlockProcessingStarted(subBlockID, currentTime); } ``` ### 3 Results accumulation and verification 1. On the gPRC service side, once a PublishProcessingResult(roomName, result) is called, the service gets a list of peers connected to the room and sends the result to all of them using direct gRPC connections. ``` foreach(peer in peerList); peer.processingService->OnProcessed(result); ``` 2. TODO: if results should be accumulated on the DApp side it is necessary to decide how to pass them to DApp from the gRPC service. I haven’t found a way to declare streams in YAML while Proto supports them. A stream could be passed as an input parameter to a service call, and results could be obtained from the stream on the DApp side. ### 4 Room join process When a peer tries to join a room with a specified name (ID) it subscribes to the corresponding Pub/Sub channel with a topic=ID. Once it is subscribed, it can get a list of peers subscribed to the same topic. If the list contains more than one peer, the room exists. In general, not all peers subscribed to a channel can participate in processing because there is a limit to the number of workers that can be included in a processing room. To join the room, it is necessary to publish a message to the channel: "Room join request" Once a room host receives the message, it decides whether the peer can be joined. If the answer is "yes" the host is directly connected to the peer and sends it a list of the room peers. --- source: /technical-information/super-genius-blockchain-technical-details/supergenius-processing-component-information/job-processing-flow/ title: Job Processing Flow --- # Job Processing Flow
All queueing of Jobs/MacroJobs/MicroJobs uses a locking queue with a timeout to handle node dropouts/disconnects when joining a room for a MicroJob or creating a MacroJob room. When querying open jobs (Jobs, MacroJobs, MicroJobs), it is the union of jobs that have exceeded the timestamp lock & jobs that have not been previously locked. ### Job Placement DApp creates a Job: 1. DApp specifies the job code (shader/Tensorflow/OpenCL) and the URI to source from (IPFS/SFTP/WS/HTTPS). 2. DApp specifies Job data URI to source from (IPFS/SFTP/WS/HTTPS). 3. DApp fills a JobInfo structure, including Job slicing parameters and seed for the random number generator, and places it into CRDT. 4. Dapp Slices Job with slicing parameters and creates MacroJobs & MicroJobs with random IDs from random seed saving into the CRDT DB. 5. DApp doesn't need to wait until job completion as the Super Genius BlockChain will create blocks verified using zkSnarks. ### Processing node initialization 1. Once a Job processor is started, it is linked/synced to CRDT DB. 2. Create or Join Jobs PubSub Channel (first bootstrap node should do this) ### Job Processing 1. The job processor asks for open jobs via the PubSub Channel. If none exist, loop here (step 3) 2. Join Job{ID}/MacroJob PubSub channel ### MacroJob Processing 1. The Job processor asks for open MacroJobs from the PubSub Channel. CRDT is not used as MacroJobs storage. 2. if MacroJob open, Join Job{id}/MacroJob{id} Channel, goto 'MicroJob Processing'. \*\*\* This can also, in the future, check for the locality of processing nodes 3. If no MacroJobs are open, go to 'Job Processing'. 4. **Create an in-memory MicroJob queue and set itself as the current queue owner. To create a validation MicroJob, a random number generator should be used with a seed equal to Job input seed + MacroJob index {id}** 5. **Create PubSub channel Job{id}/MacroJob{id} and notify the Job PubSub channel about the created MacroJob channel.** 6. Job Processor joins MacroJob PubSub Channel. 7. Go to MicroJob Processing ### MicroJob Processing 1. Job Processor requests for in-memory MicroJob queue via PubSub. Once a Microjob queue owner receives the request, it marks the requestor as the current queue owner and sends the queue to PubSub. Note: All Processors receive the updated in-memory queue, but only the current queue owner can operate with it. 2. The job processor receives the MicrJobs queue. If it is marked as the current queue, it checks for an open Microjob, marks it with timeout timestamp/lock, and notifies PubSub Channel. 3. The Job processor applies the coding algorithm for data blocks specified in the MicroJob. 4. The job processor writes MicroJob processing results into CRDT when the MicroJob processing is finished. a. Data should be written to IPFS b. CRDT record should be written with Job{ID}/MacroJob{ID}/MicroJob{ID} = data: { wallet address, hashes of processed blocks } + hash (Job{ID}/MacroJob{ID}/MicroJob{ID} & data) c. Job processor publishes to Job channel, 1 MicroJob is complete 5. Job Processor checks if the final MicroJob for a Job. If so, jump to Job Finalization. 6. Job processor checks if there are non-processed Micro Jobs and repeats p.1-6 until all Micro Jobs are processed. 7. Go to 'Macro Job Processing' ### Job Finalization. 1. When a Job processor finishes a MicroJob processing, it checks if the Job's MicroJob count finished equals the MicroJob count. 2. if not, go to Job Processing 3. Last, MicroJob scans MacroJobs and finds verifier hashes by checking all MicroJob hashes to see which matches the other ten nodes' hashes. 4. It sends this hash to the Smart Contract along with wallet addresses to release the Escrow 5. Smart Contract ZkSnark algorithm can verify because {ID}'s are generated from RandomSeed, encrypted with zkSnark \*\*\* If the smart contract fails to verify. The culprit can be figured out by getting the index of the MacroJob verifier node and checking hashes against other non-verifier nodes to find the mismatch. --- source: /technical-information/super-genius-blockchain-technical-details/super-genius-dag-blockchain/ title: Super Genius DAG Blockchain --- # Super Genius DAG Blockchain ## Understanding the Super Genius Blockchain: An Optimized DAG-like Structure The Super Genius blockchain introduces a groundbreaking way of organizing and verifying transactions. While not a conventional Directed Acyclic Graph (DAG) like IOTA or Nano, its structure is an **Optimized DAG-like System** designed for simplicity, efficiency, and the specific needs of the Super Genius token ecosystem. Let’s break it down for both developers and non-technical audiences. *** ### What is a DAG? A Directed Acyclic Graph (DAG) is a data structure often used in blockchain and distributed systems that: * **Directs**: Information flows in a single direction (parent to child). * **Acyclic**: No loops or cycles are possible. * **Graph**: Nodes (blocks or transactions) are connected by edges (relationships). Traditional DAGs allow multiple parents and concurrent branches, enabling scalability and faster transaction processing. Our approach builds on these ideas with an **optimized, hierarchical design**. *** ### The Super Genius Blockchain Design #### Hierarchical Structure 1. **Genesis Block**:\ The Genesis Block serves as the root and trusted foundation for the entire blockchain. 2. **Account Creation**:\ Each account creation is recorded as a transaction linked directly under the Genesis Block. These account blocks form independent branches. 3. **Transactions Under Accounts**:\ Each account becomes the root for a series of transactions, organized sequentially in a **linked list format** under that account. #### Directionality and Parent-Child Relationships Each transaction maintains a **parent-child relationship**: * A "previous pointer" links each block to its parent. * This unidirectional flow allows for easy traversal and ensures the structure remains acyclic (no loops). #### Proof-Carrying Data for Validation * Each block carries **Proof-Carrying Data** from its parent, enabling independent validation. * To verify the validity of a block, only the current block and its parent need to be checked. * The Genesis Block contains a **trusted proof**, ensuring that all subsequent transactions inherit its trustworthiness without requiring a full traversal. *** ### Why Call It an Optimized DAG-like Structure? The Super Genius blockchain embodies key principles of DAGs while optimizing them for simplicity and efficiency: * **Directed**: Blocks and transactions always reference their parent in a one-way flow. * **Acyclic**: Cycles are impossible due to the parent-child structure and proof mechanism. * **Graph-like**: The tree-like organization of accounts and transactions forms a specialized graph. While traditional DAGs focus on parallel processing and multiple parent nodes, the Super Genius design simplifies this by organizing transactions into **hierarchical, account-based branches**. This provides the best of both worlds: the scalability and efficiency of a DAG with the clarity of a tree-like structure. *** ### Advantages of the Optimized DAG-like Design 1. **Efficient Validation**:\ By leveraging Proof-Carrying Data, only the current block and its parent need verification, significantly reducing computational overhead. 2. **Scalability**:\ Transactions are grouped by accounts, isolating them into independent chains. This reduces bottlenecks and simplifies processing. 3. **Trust and Security**:\ The Genesis Block acts as a trusted root, with validation cascading through its child blocks via Proof-Carrying Data. 4. **Developer-Friendly**:\ The clear hierarchical structure makes it easy for developers to build and maintain integrations. *** ### Key Takeaways for Developers and Non-Technical Audiences * The Super Genius blockchain is an **Optimized DAG-like System** that combines linked lists, trees, and DAG principles into a streamlined, efficient design. * This structure ensures faster, cheaper, and secure transactions while maintaining trust through Proof-Carrying Data. * Developers benefit from its simplicity and efficiency, while end-users enjoy better performance and reliability. *** By adopting this **Optimized DAG-like Structure**, the Super Genius blockchain sets a new standard for decentralized systems, offering a practical, high-performance solution for modern applications and token ecosystems. --- source: /technical-information/super-genius-blockchain-technical-details/minimal-proof-mountain/ title: Minimal MMR Proof System with UTXOs --- # Minimal MMR Proof System with UTXOs The GNUS.ai blockchain architecture leverages a combination of Merkle Mountain Range (MMR) with Unspent Transaction Outputs (UTXOs) and Nova over PLONK for Incrementally Verifiable Computations (IVC). This design enhances scalability, security, and efficiency within the blockchain ecosystem. ### Key Components 1. **Merkle Mountain Range (MMR) with UTXOs:** * MMR provides an efficient, append-only data structure via a CRDT database * Nodes store only the Genesis Node, their branch node, and the last two UTXOs. 2. **Nova over PLONK for IVC:** * Using Placeholder Proof System in C++ * Nova enables efficient folding schemes. * PLONK provides succinct, zero-knowledge proofs. * Proofs are incrementally updated from the Genesis block through branch nodes to individual UTXOs. ```mermaid fullWidth="false" graph TD A[Genesis Proof] B["Account 1 (Branch) Proof"] C["Account 2 (Branch) Proof"] D[UTXO 1A Proof] E[UTXO 1B Proof] F[UTXO 2A Proof] G[UTXO 2B Proof] A --> B A --> C B --> D D --> E C --> F F --> G ``` ### Detailed Mechanism 1. **Genesis Node and Proof:** * The Genesis Node contains the initial state. * An IVC proof is established at the Genesis Node using Nova over PLONK. 2. **Branch Node (Account Creation):** * New accounts create branch nodes from the Genesis Node. * The proof for the branch node is an incremental proof based on the Genesis proof. 3. **Transaction and UTXO Handling:** * Each transaction creates a new UTXO, generating an incremental proof. * Nodes store the last two unspent UTXOs, reducing storage requirements. * Each UTXO transaction is verifiable within the branch’s incremental proof chain. 4. **Incremental Verification:** * New proofs build on previous proofs, ensuring efficiency. * Only the Genesis proof, branch proof, and recent UTXOs are needed for verification. ### Benefits 1. **Scalability:** * Reduced storage requirements per node. * Efficient verification without storing the entire chain. 2. **Security:** * Zero-knowledge proofs ensure data privacy. * Incremental proofs maintain integrity and trust. 3. **Efficiency:** * Fast proof generation and verification. * Simplified storage and data retrieval. --- source: /technical-information/super-genius-blockchain-technical-details/cross-chain-bridging-to-supergenius/ title: Cross-chain Bridging through SuperGenius --- # Cross-chain Bridging to SuperGenius The GNUS.ai cross-chain watcher and minting system employs a decentralized network of nodes to monitor and interact with multiple blockchains, including EVM-compatible chains and Bitcoin ordinals. Using IPFS-lite and libp2p for communication, the system processes relevant transactions, initiates minting requests, and handles cross-chain bridging. A Proof of Reputation mechanism, involving high-reputation nodes, verifies and approves these requests before execution on a custom L1 blockchain. The system now includes bridging capabilities, allowing for the burning of tokens on the L1 SuperGenius C++ blockchain and minting of corresponding tokens on EVM chains or Bitcoin Ordinals. This architecture enables seamless interaction and token transfer across different blockchain ecosystems, with built-in scalability for future expansion to additional networks. 1. Decentralized Watcher Group: * Composed of nodes that watch multiple blockchains via RPC. * Monitors EVM-compatible chains, Bitcoin ordinals, and potentially other chains in the future. * When a relevant transaction is detected, it prepares a minting, bridging in, or bridging out request. * Nodes reach consensus on the latest transaction ID for all operations. 2. IPFS-lite and libp2p: * Provides the decentralized communication infrastructure. * Sets up pub/sub channels for nodes to communicate. 3. Consensus and Verification System: * Receives minting, bridging in, and bridging out requests from the watcher group. * Nodes agree on the latest transaction ID for each operation. * Uses zkSnarks to verify the validity of transactions. * zkSnarks and recursive snarks are employed to aggregate and validate transaction data from previous transactions. 4. L1 SuperGenius Blockchain (in C++): * The underlying blockchain where minting occurs and tokens can be burned for bridging out. * Receives and processes approved minting and bridging transactions. 5. Solidity Contracts: * Deployed on multiple EVM chains. * Interact with the main system, possibly triggering events that the watcher group monitors. * Include ERC-1155 smart contracts for hierarchical token management. 6. Bridging Functionality: * Bridging In: Allows for burning tokens on external chains and minting on the L1 SuperGenius blockchain. * Bridging Out: Facilitates burning tokens on the L1 SuperGenius blockchain and minting on target chains. * Trusted nodes have gas fees and signing authority to mint tokens on the target EVM chain or Bitcoin Ordinals. * Manages bridging of child tokens in the EVM contract, maintaining a hierarchical token system under the Genius Tokens & NFT Collections contract. Here's how the process flows, including bridging out: 1. The watcher group monitors transactions on various blockchains (EVM-compatible chains, Bitcoin ordinals, etc.). 2. When a relevant transaction is detected (minting, bridging in, or bridging out), a watcher node prepares the appropriate request. 3. The request is sent through the IPFS-lite/libp2p pub/sub channel, including: * The function call (mint, bridge in, or bridge out) * The source chain ID * The transaction ID * For bridging out: the target chain ID and token details 4. Nodes in the network reach consensus on the latest transaction ID for the operation. 5. zkSnarks are used to verify the validity of the transaction, including aggregating data from previous transactions. 6. If the verification passes: * For minting or bridging in: the approved transaction is sent to the L1 SuperGenius blockchain for execution. * For bridging out: the burn transaction is executed on the L1 SuperGenius blockchain. 7. For bridging out: * Trusted nodes with appropriate permissions receive the bridge out request. * These nodes use their gas fees and signing authority to mint the corresponding tokens on the target chain (EVM or Bitcoin Ordinals). * The minting includes creating the appropriate hierarchical structure in the ERC-1155 smart contract on the target chain. For our implementation of this architecture, we have: 1. Implemented a robust RPC client in C++ capable of interacting with various blockchains. 2. Developed an efficient consensus mechanism for nodes to agree on the latest transaction IDs. 3. Implemented zkSnark verification for transaction validation and data aggregation. 4. Designed and built a flexible pub/sub system using IPFS-lite and libp2p that handles different types of messages (e.g., minting requests, bridging in/out requests, verification results). 5. Created a standardized format for minting and bridging (in/out) requests that includes all necessary information. 6. Implemented proper error handling and recovery mechanisms throughout the system. 7. Ensured the system's scalability to handle future expansion to other chains like Solana. 8. Developed secure mechanisms for trusted nodes to hold and manage gas fees and signing authorities for different target chains. 9. Implemented a secure system for managing and updating the list of trusted nodes with bridging out permissions. 10. Created a mechanism to track and maintain the hierarchical token structure across different chains during bridging operations. We are now in the process of integrating these subcomponents into a cohesive system, fine-tuning their interactions, and conducting comprehensive testing to ensure smooth operation across various blockchain ecosystems. ```mermaid graph TD A[EVM Compatible Blockchain] -->|Watch via RPC| B[Decentralized Watcher Group] C[Bitcoin Ordinals] -->|Watch via RPC| B B -->|Send mint/bridge function| D[IPFS-lite/libp2p Pub/Sub Channel] D -->|Mint/Bridge request| E[Proof of Reputation System] E -->|Pre-check| F[RPC Verification] F -->|Verify transaction| E E -->|Agree on minting/bridging| G[L1 SuperGenius Blockchain in C++] H[Solidity Contracts] -->|Interact| A I[Other Non-EVM Chains] -.->|Future expansion| B G -->|Burn tokens| J[Bridging Process] J -->|Mint tokens| K[EVM Contract/Bitcoin Ordinals] K -->|Hierarchical Tokens| L[ERC-1155 Smart Contract] E -->|Authorize and Sign| J ``` --- source: /technical-information/super-genius-blockchain-technical-details/cross-chain-bridging-to-supergenius/overview/ title: Overview of Technical Details for Cross-Chain Bridging Flow --- # Overview of Cross-Chain Bridging Flow The cross-chain bridging mechanism facilitates a secure and decentralized message verification across multiple chains. The flow includes ownership acquisition, leader election, message verification, and the final submission to the destination chain. Each part of the system has specific roles for ensuring scalability, decentralization, and resilience. ## Flow Components 1. **Message Creation and Leader Election** 2. **Leader Ownership and Verification Channel Creation** 3. **Node Verification and Voting** 4. **Signature Collection and Aggregation** 5. **Destination Chain Submission and Validation** We'll start with the **Message Creation and Leader Election** process and build upon that progressively. --- source: /technical-information/super-genius-blockchain-technical-details/cross-chain-bridging-to-supergenius/message-creation-leader-election/ title: Message Creation and Leader Election --- # Message Creation and Leader Election ## Message Creation - **Trigger Event**: The message verification process starts when a new event (e.g., a token burn) occurs on the source chain. - **Queue Job Creation**: The event is recorded as a job in a distributed CRDT-based queue that manages subtasks. - **Job State**: Jobs in the queue have states such as "pending", "in progress", and "completed". ## Leader Election - **Leader Election Trigger**: Nodes connected to the network observe the pending jobs and attempt to acquire ownership using a distributed lock. - **Lock Mechanism**: Ownership is requested through a CRDT lock, which guarantees that only one node successfully acquires the job to proceed as the leader. ```cpp // Function to attempt leader election for a message job bool attemptOwnership(Job job) { bool lockAcquired = job_lock.tryAcquire(job.id); if (lockAcquired) { log("Node " + nodeId + " has become the leader for job " + job.id); becomeLeader(job); } return lockAcquired; } ``` ## Topic Creation by Leader - **Leader Creates Channel**: The node that acquires ownership becomes the leader and creates a new IPFS pub/sub topic for message verification. - **Announcement**: The leader node announces the creation of the channel, inviting other nodes to join. ```cpp void becomeLeader(Job job) { std::string topic = createVerificationTopic(job); setupPubSubChannel(topic); inviteNodesToChannel(topic); } ``` ## Diagram: Leader Election Flow ```mermaid sequenceDiagram participant Node A participant Node B participant Node C participant CRDT Queue Node A->>CRDT Queue: Request ownership of Job X Node B->>CRDT Queue: Request ownership of Job X Node C->>CRDT Queue: Request ownership of Job X CRDT Queue-->>Node A: Ownership Granted Node A->>Node B & Node C: Announce Leadership and Invite Node B->>Node A: Join Verification Channel Node C->>Node A: Join Verification Channel ``` --- source: /technical-information/super-genius-blockchain-technical-details/cross-chain-bridging-to-supergenius/verification-channel-creation/ title: Leader Ownership and Verification Channel Creation --- # Leader Ownership and Verification Channel Creation ## Channel Creation - **Pub/Sub Setup**: Once the leader is determined, it creates a verification channel on IPFS pub/sub. This channel acts as the communication medium for all selected nodes participating in verification. - **Inviting Participants**: The leader sends out an invitation to other nodes to join the channel and contribute to verification. ## Ownership Persistence - **Lock Persistence**: The job remains in the queue with the leader’s node ID. If the leader fails or disconnects, the job remains, and other nodes can attempt to acquire the ownership. ```cpp void setupPubSubChannel(std::string topic) { log("Leader setting up verification channel: " + topic); pubsub.createTopic(topic); } void inviteNodesToChannel(std::string topic) { log("Inviting nodes to channel: " + topic); pubsub.inviteToTopic(topic, selectedNodes); } ``` --- source: /technical-information/super-genius-blockchain-technical-details/cross-chain-bridging-to-supergenius/node-verification-voting/ title: Node Verification and Voting --- # Node Verification and Voting ## Node Participation in Verification - **Joining the Channel**: Nodes that receive an invitation from the leader join the IPFS pub/sub channel. - **Verification Task**: Each node verifies the message according to predefined criteria (e.g., checking transaction validity, ensuring it meets consensus rules). ## Voting on Message Validity - **Vote Casting**: Once verification is complete, nodes cast their vote on whether the message is valid. - **Vote Signing**: Nodes sign their vote using their private keys to ensure authenticity. ```cpp void participateInVerification(std::string topic, Message message) { log("Node " + nodeId + " joining verification channel: " + topic); pubsub.subscribeToTopic(topic); bool isValid = verifyMessage(message); std::string vote = isValid ? "valid" : "invalid"; std::string signedVote = signVote(vote); pubsub.publishVote(topic, signedVote); } ``` ## Verification Flow Diagram ```mermaid sequenceDiagram participant Node A participant Verification Channel Node A->>Verification Channel: Subscribe to Topic Verification Channel->>Node A: Verification Task Node A->>Verification Channel: Publish Signed Vote ``` --- source: /technical-information/super-genius-blockchain-technical-details/cross-chain-bridging-to-supergenius/signature-collection-aggregation/ title: Signature Collection and Aggregation --- # Signature Collection and Aggregation ## Collecting Votes - **Leader Collects Votes**: The leader collects signed votes from all participating nodes in the verification channel. - **Threshold for Consensus**: A predefined threshold (e.g., majority or supermajority) is used to determine if the message is valid. ## Signature Aggregation - **Aggregating Signatures**: To reduce data size, signatures are aggregated using schemes like BLS (Boneh–Lynn–Shacham) signatures, resulting in a single compact signature that represents the collective votes. ```cpp void collectAndAggregateVotes(std::string topic) { log("Leader collecting votes on topic: " + topic); std::vector votes = pubsub.collectVotes(topic); std::string aggregatedSignature = aggregateSignatures(votes); log("Aggregated Signature: " + aggregatedSignature); } ``` ## Vote Collection Flow Diagram ```mermaid sequenceDiagram participant Leader participant Node A participant Node B Leader->>Node A: Request Vote Node A->>Leader: Send Signed Vote Leader->>Node B: Request Vote Node B->>Leader: Send Signed Vote Leader->>Leader: Aggregate Signatures ``` --- source: /technical-information/super-genius-blockchain-technical-details/cross-chain-bridging-to-supergenius/destination-chain-submission-validation/ title: Destination Chain Submission and Validation --- # Destination Chain Submission and Validation ## Submission to Destination Chain - **Sending the Proof**: The aggregated signature and verification results are packaged and sent to the destination chain for processing. - **Transaction Creation**: A transaction is created on the destination chain that includes the message, the aggregated signature, and any supporting data. ```cpp void submitToDestinationChain(Message message, std::string aggregatedSignature) { log("Submitting verification result to destination chain"); Transaction tx = createTransaction(message, aggregatedSignature); destinationChain.submitTransaction(tx); } ``` ## Validation on Destination Chain - **Smart Contract Validation**: A smart contract on the destination chain verifies the aggregated signature to ensure that the message was validated by the required number of nodes. - **State Update**: If the verification is successful, the state on the destination chain is updated accordingly (e.g., minting tokens, updating balances). ```solidity function validateAndProcess(bytes memory message, bytes memory aggregatedSignature) public { require(verifyAggregatedSignature(message, aggregatedSignature), "Invalid signature"); // Proceed with state update } ``` ## Submission and Validation Flow Diagram ```mermaid sequenceDiagram participant Leader participant Destination Chain Leader->>Destination Chain: Submit Aggregated Signature Destination Chain->>Destination Chain: Verify Signature Destination Chain->>Destination Chain: Update State ``` --- source: /technical-information/hybrid-smart-contract/ title: Hybrid Smart Contract --- # Hybrid Smart Contract The GNUS.ai smart contract is a hierarchical container for ERC-1155 tokens, and the GNUS token is an ERC-20 token.
--- source: /technical-information/hybrid-smart-contract/gnus.ai-ecosystem-a-unified-network-of-intelligence/ title: GNUS.ai Ecosystem: A Unified Network of Intelligence --- # GNUS.ai Ecosystem: A Unified Network of Intelligence #### **Table 1: GNUS.ai Ecosystem Overview** | **Component** | **Description** | **Relationship** | | ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | | **Super Genius Token (SGNUS)** | The top-tier token, operating on its own **Super Fast DAG blockchain**. Bridges seamlessly to multiple L1s like Ethereum, Polygon, and Bitcoin. | Acts as the **L0 orchestrator**, managing interoperability and acting as the central hub for GNUS tokens and Genius Savant Tokens. | | **GNUS Token** | Parent token operating on traditional L1 blockchains (e.g., Ethereum, Polygon). Represents the intelligence core on these platforms. | Converts 1:1 with SGNUS tokens via the bridging mechanism and is subdivided into **Minions** for micro-interactions. | | **Minions (Subunits)** | The smallest divisible unit of GNUS tokens, allowing for microtransactions and precise value representation. | **Subunits of GNUS/SGNUS tokens**. Savant Tokens use Minions for conversion rates, enabling flexibility in their value relative to GNUS/SGNUS. | | **Genius Savant Tokens** | Specialized tokens (e.g., Game, Energy Efficiency) designed for specific tasks within the GNUS.ai ecosystem. | Can utilize **multiple Minions** or a fraction of them to define conversion rates to GNUS/SGNUS, reflecting their value or task-specific utility. | *** #### **Table 2: Genius Savant Token Examples** | **Savant Token** | **Use Case** | **Description** | **Minion Conversion** | | ---------------------------------- | ------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- | | **Game Savant Token** | Gaming companies like Graffiti Entertainment. | Facilitates gaming-related tasks such as player reward systems, in-game transactions, and blockchain-based game integrations. | Conversion based on in-game activity or compute tasks, e.g., 1 Game Savant Token = 10,000 Minions. | | **Energy Efficiency Savant Token** | Energy management companies like Energy Cloud, Inc. | Powers tasks related to energy optimization, smart grid management, and decentralized energy data collection. | Conversion tied to energy usage metrics or verified data contributions. | | **Healthcare Savant Token** | AI-focused healthcare applications or companies. | Supports tasks such as medical imaging analysis, patient data processing, or telemedicine services. | Conversion reflects AI processing time or verified patient data contributions. | | **Education Savant Token** | Educational apps and platforms. | Enables gamified learning experiences, AI-based tutoring, or decentralized certificate verification. | Conversion linked to student engagement or completed tasks. | | **Creative Savant Token** | Creative companies handling design, media, and content generation. | Facilitates AI-powered creative tools such as image generation, video editing, or animation. | Conversion based on the compute intensity of creative outputs. | | **Finance Savant Token** | Fintech platforms leveraging decentralized AI and blockchain tools. | Supports fraud detection, risk analysis, and decentralized financial data modeling. | Conversion based on the value of financial transactions or analysis performed. | *** #### **System Design** **Hierarchy and Token Relationships** 1. **Super Genius Token (SGNUS)**: * Operates as the **L0 orchestrator**, bridging and coordinating across multiple L1 blockchains (e.g., Ethereum, Polygon, Bitcoin). * Enables interoperability and global coordination for GNUS Tokens and Savant Tokens. 2. **GNUS Token**: * The parent token on traditional L1 blockchains. * Acts as a localized instance of the Genius network and converts 1:1 with SGNUS via bridging. 3. **Minions**: * Subunits of GNUS/SGNUS tokens, allowing for precision in transactions and representing micro-units of value. * Serve as the universal conversion medium between Genius Savant Tokens and GNUS/SGNUS tokens. 4. **Genius Savant Tokens**: * Specialized tokens tied to specific applications or industries. * Use **Minions** to define conversion rates, reflecting their value and task-specific utility. **Conversion Mechanism** * **Minions as Universal Subunits**: * Example: 1 Genius Savant Token = 10,000 Minions. * 1 GNUS Token = 1,000,000 Minions. * Savant Tokens leverage Minions to reflect task complexity, usage metrics, or demand. --- source: /technical-information/hybrid-smart-contract/structure/ title: Structure --- # Structure Structure for the Smart Contract Token/NFT Collection (ERC-1155) ```solidity struct NFT { string name; // Token/NFT Name string symbol; // Token/NFT Symbol string uri; // Token/NFT URI for metadata uint256 exchangeRate; // Only for withdrawing to GNUS uint256 maxSupply; // Maximum supply of NFTs address creator; // The creator of the token, as an ERC-20 address uint128 childCurIndex; // The current childNFT count created bool nftCreated; // If there is a mapping/token created } ``` Hierarchical Structure ``` - GNUS Token (ID 0) - Game Studio 1 Token (ID 0.1) - Game 1 Token (ID 1.2) - NFT 3 (ID 2.3) - Game 3 Token (ID 1.4) - NFT 6 (ID 4.5) - Assistance App Token (ID 0.6) - Solo Game 1 Token (ID 0.7) - NFT 1 (ID 7.8) - NFT 2 (ID 7.9) - Healthcare App Token (ID 0.A) - Country 1 Token (ID 0.B) - Game Studio 2 Token (ID B.C) - Game 2 Token (ID C.D) - NFT 4 (ID D.E) - Game 4 Token (ID C.F) - NFT 5 (ID F.10) - ISP Token (ID B.11) - Finance App Token (ID 0.12) ``` --- source: /technical-information/hybrid-smart-contract/structure/structure-details/ title: Structure Details --- # Structure Details #### Sample Details for Each Token/NFT 1. **GNUS Token (ID 0)** * Name: GNUS * Symbol: GNUS * URI: URI for GNUS metadata * Exchange Rate: (set value) * Max Supply: (set value) * Creator: (creator address) * ChildCurIndex: (current child count) * nftCreated: true 2. **Game Studio 1 Token (ID 0.1)** * Name: Game Studio 1 * Symbol: GST * URI: URI for Game Studio 1 metadata * Exchange Rate: (set value) * Max Supply: (set value) * Creator: (creator address) * ChildCurIndex: (current child count) * nftCreated: true 3. **Game 1 Token (ID 1.2)** * Name: Game 1 * Symbol: G1T * URI: URI for Game 1 metadata * Exchange Rate: (set value) * Max Supply: (set value) * Creator: (creator address) * ChildCurIndex: (current child count) * nftCreated: true 4. **NFT 3 (ID 2.3)** * Name: NFT 3 * Symbol: NFT3 * URI: URI for NFT 3 metadata * Exchange Rate: (set value) * Max Supply: (set value) * Creator: (creator address) * ChildCurIndex: (current child count) * nftCreated: true 5. **Game 3 Token (ID 1.4)** * Name: Game 3 * Symbol: G3T * URI: URI for Game 3 metadata * Exchange Rate: (set value) * Max Supply: (set value) * Creator: (creator address) * ChildCurIndex: (current child count) * nftCreated: true 6. **NFT 6 (ID 4.5)** * Name: NFT 6 * Symbol: NFT6 * URI: URI for NFT 6 metadata * Exchange Rate: (set value) * Max Supply: (set value) * Creator: (creator address) * ChildCurIndex: (current child count) * nftCreated: true 7. **Assistance App 1 Token (ID 0.6)** * Name: App 1 * Symbol: A1T * URI: URI for App 1 metadata * Exchange Rate: (set value) * Max Supply: (set value) * Creator: (creator address) * ChildCurIndex: 0 * nftCreated: true 8. **Solo Game 1 Token (ID 0.7)** * Name: Solo Game 1 * Symbol: SGT * URI: URI for Solo Game 1 metadata * Exchange Rate: (set value) * Max Supply: (set value) * Creator: (creator address) * ChildCurIndex: (current child count) * nftCreated: true 9. **NFT 1 (ID 7.8)** * Name: NFT 1 * Symbol: NFT1 * URI: URI for NFT 1 metadata * Exchange Rate: (set value) * Max Supply: (set value) * Creator: (creator address) * ChildCurIndex: (current child count) * nftCreated: true 10. **NFT 2 (ID 7.9)** * Name: NFT 2 * Symbol: NFT2 * URI: URI for NFT 2 metadata * Exchange Rate: (set value) * Max Supply: (set value) * Creator: (creator address) * ChildCurIndex: (current child count) * nftCreated: true 11. Healthcare (0.A) * Name: Healthcare * Symbol: HCA * URI: URI for Country 1 metadata * Exchange Rate: (set value) * Max Supply: (set value) * Creator: (creator address) * ChildCurIndex: (current child count) * nftCreated: true 12. **Country 1 Token (ID 0.B)** * Name: Country 1 * Symbol: C1T * URI: URI for Country 1 metadata * Exchange Rate: (set value) * Max Supply: (set value) * Creator: (creator address) * ChildCurIndex: (current child count) * nftCreated: true 13. **Game Studio 2 Token (ID B.C)** * Name: Game Studio 2 * Symbol: GS2T * URI: URI for Game Studio 2 metadata * Exchange Rate: (set value) * Max Supply: (set value) * Creator: (creator address) * ChildCurIndex: (current child count) * nftCreated: true 14. **Game 2 Token (ID C.D)** * Name: Game 2 * Symbol: G2T * URI: URI for Game 2 metadata * Exchange Rate: (set value) * Max Supply: (set value) * Creator: (creator address) * ChildCurIndex: (current child count) * nftCreated: true 15. **NFT 4 (ID D.E)** * Name: NFT 4 * Symbol: NFT4 * URI: URI for NFT 4 metadata * Exchange Rate: (set value) * Max Supply: (set value) * Creator: (creator address) * ChildCurIndex: (current child count) * nftCreated: true 16. **Game 4 Token (ID C.F)** * Name: Game 4 * Symbol: G4T * URI: URI for Game 4 metadata * Exchange Rate: (set value) * Max Supply: (set value) * Creator: (creator address) * ChildCurIndex: (current child count) * nftCreated: true 17. **NFT 5 (ID F.10)** * Name: NFT 5 * Symbol: NFT5 * URI: URI for NFT 5 metadata * Exchange Rate: (set value) * Max Supply: (set value) * Creator: (creator address) * ChildCurIndex: (current child count) * nftCreated: true 18. **ISP (ID B.11)** * Name: ISP * Symbol: ISP * URI: URI for ISP metadata * Exchange Rate: (set value) * Max Supply: (set value) * Creator: (creator address) * ChildCurIndex: 0 * nftCreated: true 19. **Finance App Token (ID 0.12)** * Name: App 2 * Symbol: A2T * URI: URI for App 2 metadata * Exchange Rate: (set value) * Max Supply: (set value) * Creator: (creator address) * ChildCurIndex: 0 * nftCreated: true --- source: /technical-information/hybrid-smart-contract/encoded-ids/ title: Encoded IDs --- # Encoded IDs #### Explanation * **Upper 128 bits**: Represent the parent token ID in the hierarchy. This ensures that each child token can trace its parent. * **Lower 128 bits**: Represent the child token ID. This uniquely identifies the child token within the context of its parent. In this representation, each token and NFT has a globally unique lower 128-bit ID, ensuring no placeholders are used. Each new token or NFT increments a global counter to maintain uniqueness. 1. **GNUS Token** * ID: `0x0000000000000000000000000000000000000000000000000000000000000000` 2. **Game Studio 1 Token (Child of GNUS)** * ID: `0x0000000000000000000000000000000000000000000000000000000000000001` 3. **Game 1 Token (Child of Game Studio 1)** * ID: `0x0000000000000000000000000000000100000000000000000000000000000002` 4. **NFT 3 (Child of Game 1)** * ID: `0x0000000000000000000000000000000100000000000000000000000000000003` 5. **Game 3 Token (Child of Game Studio 1)** * ID: `0x0000000000000000000000000000000100000000000000000000000000000004` 6. **NFT 6 (Child of Game 3)** * ID: `0x0000000000000000000000000000000100000000000000000000000000000005` 7. **Assistance App 1 Token (Child of GNUS)** * ID: `0x0000000000000000000000000000000000000000000000000000000000000006` 8. **Solo Game 1 Token (Child of GNUS)** * ID: `0x0000000000000000000000000000000000000000000000000000000000000007` 9. **NFT 1 (Child of Solo Game 1)** * ID: `0x0000000000000000000000000000000300000000000000000000000000000008` 10. **NFT 2 (Child of Solo Game 1)** * ID: `0x0000000000000000000000000000000300000000000000000000000000000009` 11. **Healthcare App Token (Child of GNUS)** * ID: `0x000000000000000000000000000000000000000000000000000000000000000A` 12. **Country 1 Token (Child of GNUS)** * ID: `0x000000000000000000000000000000000000000000000000000000000000000B` 13. **Game Studio 2 Token (Child of Country 1)** * ID: `0x000000000000000000000000000000050000000000000000000000000000000C` 14. **Game 2 Token (Child of Game Studio 2)** * ID: `0x000000000000000000000000000000050000000000000000000000000000000D` 15. **NFT 4 (Child of Game 2)** * ID: `0x000000000000000000000000000000050000000000000000000000000000000E` 16. **Game 4 Token (Child of Game Studio 2)** * ID: `0x000000000000000000000000000000050000000000000000000000000000000F` 17. **NFT 5 (Child of Game 4)** * ID: `0x0000000000000000000000000000000500000000000000000000000000000010` 18. **ISP App Token (Child of Country 1)** * ID: `0x0000000000000000000000000000000500000000000000000000000000000011` 19. Finance App * ID: `0x0000000000000000000000000000000000000000000000000000000000000012` --- source: /technical-information/our-smart-contract-testing-philosophy/ title: Our Smart Contract Testing Philosophy --- # Our Smart Contract Testing Philosophy ### Our Smart Contract Testing Philosophy At Genius Ventures, we don't stop at just unit testing. While many engineers focus solely on unit testing their smart contracts, we take a more comprehensive approach by combining both **Unit** and **Functional Testing** to ensure our smart contracts work in real-world applications. #### Why TypeScript for Testing? We use **TypeScript** for our smart contract tests. Here's why: * **Comprehensive Testing**: With TypeScript, we can perform both unit tests (validating the internal logic of the contract) and functional tests (simulating real-world scenarios). * **Real-World Interactions**: TypeScript allows us to interact with actual wallets like Metamask, run transactions, and test user flows. *** #### Traditional Frameworks: What's Missing? Traditional Solidity testing frameworks like Truffle, Brownie, and Forge Foundry are excellent for fast unit testing but often miss the mark when it comes to full functional testing. * **Unit Testing**: These frameworks are great for creating mocks or stubs for unit tests. * **Functional Testing**: They usually lack built-in support for real-world integrations, requiring external tools for wallet interactions, private keys, and more. ```mermaid graph TD A[Traditional Testing Frameworks] --> B[Unit Testing Only] A --> C[Mock Contracts, Internal Logic] D[Our Approach: TypeScript] --> E[Unit Testing + Functional Testing] E --> F[Simulates Real-World Scenarios] E --> G[Integrates Wallet Interactions] F --> H[Transaction Flow Tested] G --> I[Real Users and Private Keys Simulated] ``` *** #### Benefits of Functional Testing By using TypeScript and frameworks like **Hardhat** and **ethers.js**, we can: * Simulate real-world usage scenarios. * Ensure full contract functionality beyond isolated unit tests. * Test wallet interactions and transaction flows. ```mermaid sequenceDiagram participant Tester participant SmartContract participant Blockchain participant Wallet Tester->>SmartContract: Deploy contract SmartContract->>Blockchain: Save on chain Tester->>Wallet: Simulate User Interaction (e.g., transfer) Wallet->>SmartContract: Sign and Send Transaction SmartContract->>Blockchain: Transaction executed Blockchain-->>Tester: Confirm transaction ``` *** #### Wallet Integration and Real-World Usage Using **private keys** directly in our tests allows us to simulate actual user actions, from signing transactions to transferring tokens. This is something that unit testing frameworks like Truffle or Foundry don't handle natively, making our testing process more aligned with real-world operations. ```mermaid flowchart LR A[TypeScript Testing] --> B[Metamask Wallet] B --> C[Sign Transaction] C --> D[Blockchain Node] D --> E[Contract Interaction] E --> F[Validate Functionality] F --> G[Send Back Response] G --> A ``` *** #### Conclusion: TypeScript Testing Done Right Our philosophy is simple: **real-world scenarios need real-world testing**. While traditional testing frameworks like Forge Foundry, Truffle, and Brownie are excellent for unit tests, they don't provide the comprehensive coverage we need for full integration. That's why we chose TypeScript to ensure our smart contracts not only work in isolation but also in the live environments where they’ll be used. ```mermaid pie title Smart Contract Testing Coverage "Traditional Unit Testing": 30 "Functional Testing": 70 ``` --- source: /technical-information/ai-systems/ title: AI Systems --- # AI Systems --- source: /technical-information/ai-systems/overview/ title: Overview --- # Overview The GNUS.ai system integrates multiple open-source technologies to build a fully decentralized Retrieval-Augmented Generation (RAG) architecture. It leverages: - **RocksDB over IPFS** for distributed storage and CRDT-based synchronization. - **Vulkan shaders and ggml** for high-performance inference on GPUs. - **MNN (Mobile Neural Network)** to dynamically load and execute models at the edge nodes. - **Pub/Sub communication over libP2P** for distributed query handling across nodes. - **Federated learning principles** to allow local model retraining and fine-tuning on each node. This architecture ensures scalability, fault tolerance, and security while minimizing latency in both data access and inference. ```mermaid graph TD; SystemArchitecture -->|Data Storage| RocksDB[Edge Nodes using RocksDB + IPFS] SystemArchitecture -->|Inference| Vulkan[Vulkan Accelerated Inference] SystemArchitecture -->|Communication| PubSub[libP2P Pub/Sub Channels] SystemArchitecture -->|Retraining| FL[Federated Learning Nodes] RocksDB -->|CRDT Syncing| IPFS[IPFS Cache] FL -->|Model Updates| EdgeNode1[Edge Node 1] FL -->|Model Updates| EdgeNode2[Edge Node 2] ``` --- source: /technical-information/ai-systems/query-workflow/ title: Query Workflow --- # Query Workflow ## Detailed Query Workflow 1. **Query Reception**: - Queries are broadcasted via **pub/sub channels** to all relevant nodes. - Each node decides if it has the matching vector slice to respond. 2. **Vector Search and Model Inference**: - Nodes execute **vector similarity searches** with Vulkan-accelerated GPUs using **ggml libraries**. - **MNN models** are loaded dynamically based on the type of query. 3. **Response Generation and Aggregation**: - Partial responses from each node are aggregated into a final response by a designated aggregator node or function. ```mermaid sequenceDiagram User ->> PubSub: Sends Query PubSub ->> Node1: Broadcast Query PubSub ->> Node2: Broadcast Query Node1 ->> Node1: Search Vectors (Vulkan + ggml) Node2 ->> Node2: Inference (MNN Model) Node1 -->> Aggregator: Partial Response 1 Node2 -->> Aggregator: Partial Response 2 Aggregator ->> User: Final Response ``` --- source: /technical-information/ai-systems/data-storage/ title: Data Storage --- # Data Storage ## RocksDB over IPFS with CRDT Syncing ### Architecture - **RocksDB** is used for local storage of vector slices on each node. - **IPFS** ensures distributed storage with content-addressed paths for retrieval. - **CRDTs** manage synchronization across nodes to avoid conflicts during updates. ```mermaid flowchart TD RocksDB[Local RocksDB Storage] --> CRDT[CRDT Synchronization] CRDT --> IPFS[IPFS Distributed Storage] Node1[Edge Node 1] --> RocksDB Node2[Edge Node 2] --> RocksDB ``` --- source: /technical-information/ai-systems/pub-sub-communication/ title: Pub/Sub Communication --- # Pub/Sub Communication ## Communication Workflow - Queries and updates are handled through **libP2P pub/sub channels**. - Fault-tolerant message propagation ensures that even if some nodes fail, others can handle the query. ```mermaid graph LR PubSubChannel --> Node1[Edge Node 1] PubSubChannel --> Node2[Edge Node 2] Node1 --> Aggregator Node2 --> Aggregator Aggregator --> PubSubChannel ``` --- source: /technical-information/ai-systems/retraining-mechanism/ title: Retraining Mechanism --- # Retraining Mechanism ## Federated Learning and Model Updates Each node performs **local model retraining** based on new data and shares relevant updates across the network. 1. **Local Training**: - Nodes collect interaction data and retrain models locally. 2. **zk-SNARK Validation**: - Model updates are validated and signed before sharing. 3. **Selective Sharing**: - Updates are broadcasted only to relevant nodes. ```mermaid sequenceDiagram Node1 ->> Node1: Local Model Retraining Node1 ->> zkSNARK: Validate Update zkSNARK -->> Node2: Validated Update Node2 ->> Node2: Incorporate Update ``` --- source: /technical-information/zero-knowledge-proofs/ title: Zero Knowledge Proofs --- # Zero Knowledge Proofs Proofs in the context of zk-rollups (zero-knowledge rollups) are a form of cryptographic evidence that validates all transactions in a rollup block without revealing the actual data of those transactions. Here’s a simplified breakdown: > **What Are zk-Rollups?** > > zk-Rollups are a type of Layer 2 scaling solution for blockchains like Ethereum. They help in scaling by processing transactions off the main chain (Layer 1) while ensuring the security and decentralization of the network. ### Zero-Knowledge Proofs In blockchain, there are several types of zero-knowledge proofs (ZKPs) which vary in their interaction model and cryptographic techniques:​**zk-SNARKs**zk-SNARKs are the most well-known ZKP protocol, valued for their quick verification times and minimal proof sizes. Initially, they required a "trusted setup," posing potential security risks, but newer versions have mitigated these concerns with trustless implementations using Multi-Party Computation (MPC). **Bulletproofs** Introduced as a scalable solution, Bulletproofs' proof sizes increase logarithmically with the number of inputs, improving over linear-sized proofs. They eliminate the need for a trusted setup, enhancing security, although they lack quantum resistance.**Zk-STARKs: The latest ZKP technology, zk-STARKs, offers transparency and quantum resistance** without needing a trusted setup. They are considered more scalable with more straightforward assumptions at the cost of larger proof sizes than zk-SNARKs.​ | Feature | zk-SNARKs | Bulletproofs | zk-STARKs | | -------------- | ----------------------------------------- | ---------------------------- | -------------------------------- | | Trusted Setup | Required (traditional), optional (recent) | Not required | Not required | | Proof Size | Small (\~0.2kB) | Medium (logarithmic scaling) | Large (\~50kB) | | Quantum Safety | No (traditional), Yes (recent) | No | Yes | | Computational | Fast proving, very fast verifying | Slower proving and verifying | Faster proving, slower verifying | | Transparency | No (traditional), Yes (recent) | Yes | Yes | | Scalability | High (with trustless setup) | High | Higher due to simple assumptions | #### Why we choose zk-SNARKs 1. **Efficiency**: zk-SNARKs enable high-speed proof verification, crucial for maintaining performance on a blockchain network where many transactions must be verified quickly. 2. **Compact Proofs**: They generate small proof sizes, making them ideal for blockchains where conserving space is essential for scalability. 3. **Privacy**: zk-SNARKs provide strong privacy guarantees, allowing for the verification of transactions without revealing any underlying sensitive data. 4. **Adoption**: zk-SNARKs have been widely adopted and are supported by many blockchain projects, offering a mature ecosystem for developers. ### zk-SNARK A zk-SNARK (Zero-Knowledge Succinct Non-Interactive Argument of Knowledge) is an advanced cryptographic technique that allows someone to prove they possess certain information without revealing what that information is. This proof of knowledge satisfies a known mathematical statement yet maintains the inputs' secrecy. It's a powerful tool for maintaining privacy and security within various digital interactions. The process of verifying a zk-SNARK is designed to be efficient, with computational demands growing very slowly (logarithmically) relative to the complexity of the statement being proved. This efficiency is what gives zk-SNARKs their 'succinct' characteristic. Furthermore, the verification process does not require any back-and-forth communication between the prover and the verifier. The prover presents their proof to the verifier for validation. When the requirement for succinctness is set aside, and zero knowledge is adjusted to a more lenient standard known as Honest Verifier Zero Knowledge, similar concepts can be seen in digital signature algorithms like ECDSA and EdDSA. These algorithms, derived from the Schnorr Identification Protocol, prove the knowledge of a discrete logarithm without revealing it. While verifying such signatures is not costly and aligns with the non-interactive nature of zk-SNARKs, they do not fulfill the succinctness criterion, a defining feature of zk-SNARKs.​ ### Definition of a zk-SNARK A zk-SNARK involves three core components: a key **generator** (`G`), a **prover** (`P`), and a **verifier** (`V`). The process begins with `G`, which, using a secret parameter _lambda_ and a specific program `C`, \ outputs a pair of keys: a **proving key** (pk) and a **verification key** (vk). These keys, once generated, are public and tied to the program `C.`\ \ Next, the prover `P`, utilizing the proving key `pk`, public inputs `x`, and a secret witness `w`, produces proof `prf` that they know a witness `w,` which conforms to the constraints of program `C.` \ \ Finally, the verifier `V` checks the validity of the proof by executing `V(vk, w.pub(), prf)`, which confirms the truth of the claim if the proof prf is valid.
### Circuit From a user's perspective, a circuit functions similarly to a program written in a language like Go. It defines the logic or computation you want to prove has been executed correctly. Internally, however, a circuit is not a typical program but a system of algebraic constraints. These constraints represent the steps of the computation, and each one must be satisfied for the overall computation to be considered valid. This unique structure allows zk-SNARKs to prove complex computations efficiently. #### Purpose of Circuits A zk-SNARK circuit defines the computations that a prover wants to prove knowledge of without disclosing the underlying data. These circuits play a pivotal role in zk-SNARK protocols, ensuring that the prover can provide convincing evidence of the correctness of their computations while keeping the sensitive data private. #### Components of a zk-SNARK Circuit A zk-SNARK circuit consists of several key components: * **Input Variables**: These are the data that the prover aims to prove knowledge of, often referred to as the witness. * **Output Variables**: These represent the result of the computation the prover tries to prove. * **Constraints**: Constraints are mathematical equations that define the rules the computation must adhere to. They ensure that computations are performed correctly. * **Witness**: The witness comprises the private information known to the prover. It is used in the computation and is kept secret. * **Public Inputs**: These are pieces of information that are publicly known and are used to validate the proof. #### Arithmetic Circuits Arithmetic operations, such as addition, multiplication, and comparison, are frequently used in zk-SNARK circuits to define computations. Here's a simplified example in JavaScript. ```cpp #include using namespace nil::crypto3::algebra::curves; [[circuit]] typename pallas::base_field_type::value_type field_arithmetic_example([[private_input]] typename pallas::base_field_type::value_type a, typename pallas::base_field_type::value_type b) { return a + b; } ``` #### Constraints Constraints in zk-SNARK circuits are crucial for enforcing the correctness of the computation. They are formulated as mathematical equations involving input and output variables. Examples of constraints include equality constraints and inequality constraints. #### Constraint System The entire collection of constraints in a zk-SNARK circuit forms a constraint system, a fundamental element in generating zk-SNARK proofs. #### Prover and Verifier In zk-SNARK protocols, there are two main roles: * **Prover**: The prover's role is to create a zk-SNARK proof demonstrating knowledge of the correct computation while keeping the witness secret. * **Verifier**: The verifier's role is to check the validity of the proof provided by the prover without knowing the underlying data. ​ --- source: /technical-information/zero-knowledge-proofs/proof-schemes-and-elliptical-curves/ title: Proof schemes and Elliptical Curves --- # Proof schemes and Elliptical Curves Proof schemes, also known as proof systems or protocols, are cryptographic techniques that allow one party (the prover) to convince another party (the verifier) that a specific statement or claim is true without revealing any additional information beyond the statement's truth. There are several proof schemes, each with its characteristics and use cases.\ \ Since we are utilizing [zkLLVM](https://github.com/NilFoundation/zkLLVM) to create cryptographic circuits, it's important to note that it supports multiple proving schemes and Elliptical Curve Cryptography (ECC): Groth16, PlonK and its variants (HyperPlonk, Halo2), and even Nova and its variants (SuperNova, HyperNova).\ \ These schemes can be implemented using a variety of elliptic curves, including BN254, BLS12-381, BLS12-377, BLS24-315, BW6-633, BW6-761, and Pallas and Vesta. To specify the desired proving scheme and the corresponding elliptic curve, we use templates from the [=Nil Crypto3](https://github.com/NilFoundation/crypto3) C++ library. ### Arithmetization of Proofs Proofs are generated into circuits that perform multiple arithmetization operations using arithmetic functions in what are known as gates of the circuits. Those gates are then connected to form the proof. There are several circuit arithmetization systems, including Rank One Constraint Systems (R1CS), Algebraic Intermediate Representation (AIR), Plonkish arithmetization (PLONK), and Customizable Constraint System (CCS) that can capture R1CS, Plonkish and AIR arithmetization without overhead. ### Choosing an Arithmetization Circuit System #### Arithmetization Circuit Systems Considered **R1CS**: Rank-One Constraint System, is a mathematical construct used to encode polynomial equations in matrices 𝐴, 𝐵, and 𝐶, where each row of the matrices corresponds to a system of equations of the form: $$ Az * Bz = Cz $$ > While R1CS is a powerful tool, it has some limitations. One of the main issues is that it does not work with folding schemes. **AIR:** Algebraic Intermediate Representation (AIR) is the arithmetization procedure used by StarkWare in their virtual machine, CAIRO (CPU AIR) **PLONKish**: PLONK is an arithmetization system with a universal and continuously updatable trusted setup. This innovation facilitates its use across multiple circuits, ensuring versatility and security. With faster proving time and succinct verification, PLONK stands out as a significant advancement in cryptographic protocols. **CCS**: Customizable Constraint System is a generalization of R1CS that can simultaneously capture R1CS, Plonkish, and AIR without overheads. The arithmetization adds significant overhead to the computation time. Using SNARK-friendly operations can increase computation time by nearly two orders of magnitude, and for non-friendly operations, it can be more. Recently, many different optimizations have been presented to reduce the overhead, such as: * Lookup tables (PlookUP). * SNARK-friendly cryptographic primitives (such as [Rescue](https://eprint.iacr.org/2020/1143.pdf?ref=blog.lambdaclass.com), [SAVER](https://eprint.iacr.org/2019/1270.pdf?ref=blog.lambdaclass.com), [Poseidon](https://eprint.iacr.org/2019/458?ref=blog.lambdaclass.com), [Reinforced Concrete](https://eprint.iacr.org/2021/1038.pdf), and [Monoli](https://medium.com/@horizenlabs-tech/introducing-monolith-for-faster-hashing-in-zk-settings-6980f406af0e)[th](https://medium.com/@horizenlabs-tech/introducing-monolith-for-faster-hashing-in-zk-settings-6980f406af0e)[ ](https://medium.com/@horizenlabs-tech/introducing-monolith-for-faster-hashing-in-zk-settings-6980f406af0e)Hashing ). * Concurrent proof generation. * Hardware acceleration (such as using GPU or FPGA). We can also prove that we executed thousands of transactions or operations using recursive proof composition, [proof aggregation](https://blog.zk.link/nova-studies-i-exploring-aggregation-recursion-and-folding-23b9a67000cd), [folding schemes](https://medium.com/veridise/introduction-to-nova-and-zk-folding-schemes-4ef717574484), or [incrementally verifiable computing](https://blog.lambdaclass.com/incrementally-verifiable-computation-nova/). ### Our Proving Scheme's Architecture 1. **Performance Efficiency**: Performance is critical in blockchain applications, especially those involving frequent transactions or operations that require repeated proving of the same computational logic. We choose C++ and utilize the GPU for efficiency and cross-platform compatibility.\ \ **Plonkish Arithmetization** was chosen because it can be highly optimized using PLONK Lookup tables (PLookUp) and optimized for GPU devices. This efficiency is crucial for maintaining fast transaction times and lower computational costs.\ \ **Monolith Hashing** was chosen because it is efficient, comparable to SHA3-256 hash rate speed, can be highly optimized for GPU devices, and is highly efficient to implement in PLONK circuits. 2. **Succinct Proofs**: The Plonkish-based proofs generated by ZKLLVM are notably concise, especially when designed to leverage specific elliptic curves like Pallas and Vesta (PaSTA), known for their succinctness and efficiency in zero-knowledge proof systems. The commitment scheme is similar to the Halo2 and is more broadly called a Polynomial Commitment Scheme (PCS).\ \ The number of group elements in a PLONK proof can vary depending on the specific implementation details and optimizations applied. However, for a typical PLONK setup, the proof size is generally characterized by a few main components: 1. **Commitments to the polynomials** used in the protocol are usually represented as points on the elliptic curve. 2. **Evaluation Points** at which these polynomials are evaluated are also represented as elliptic curve points. 3. **The Opening Proof** for these polynomial commitments at the evaluation points involve elements from the base and scalar fields of the elliptic curve. \\ 3. **Zero-Knowledge Property**: PLONK provides strong zero-knowledge guarantees, allowing the prover to validate the truth of a statement without revealing any underlying data. This is essential in blockchain applications where privacy and confidentiality are paramount, such as in the case of private transactions or confidential contracts. 4. **Security and Soundness**: The cryptographic strength of PLONK, which relies on the hardness of problems on elliptic curves, ensures a high degree of security. This aligns with the need for robust security in blockchain applications, where the integrity and trustworthiness of transactions are critical. 5. **Aggregate/Folding/IVC Proofs:** Incrementally Verifiable Computing (**I**VC) is a technique that allows proving that a function was repeatedly applied to some initial state, producing a sequence of states,\ \ PLONK can do IVC using the Pallas and Vesta (PaSTA) Elliptical Curve Pair. 1. PLONK is used with PaSTA curves defined over a finite field, which were chosen to aggregate proofs similar to the [Halo2 commitment scheme](https://zcash.github.io/halo2/index.html?ref=blog.lambdaclass.com). 2. Parts of the [Kimchi Proving System](https://minaprotocol.com/blog/kimchi-the-latest-update-to-minas-proof-system) were also adopted to minimize the blockchain's storage requirements. 6. **Compatibility with Ethereum and Other Platforms**: Since zkLLVM can also generate Solidity Smart Contract code for Ethereum Virtual Machines (EVMs) to verify via the Solidity Smart Contract, it can verify the aggregated proofs. The verifier Smart Contract is compatible with major blockchains like Ethereum, which is crucial. ### Final Decision on Proving System Finally, after all the research, we decided that all these choices led us to use the [Placeholder Prover System](https://nil.foundation/blog/post/placeholder-proofsystem) that the =nil Foundation developed. The Placeholder Prover System is a modular approach to a robust zkSnark proving system, which allowed us to build a fast custom proving system. --- source: /resources/contact-us/ title: Contact Us --- # Contact Us **Mailing Address:** 30 N Gould St., Suite R, Sheridan WY 82801 **Phone:** +1 (307) 763-5958 **Email:** support@geniusventures.io You may also contact the team by visiting your preferred social platform and dropping us a question or comment. All official links can be found [here](official-links.md). --- source: /resources/contracts/ title: Contracts --- # Contracts Part of GNUS.AI uses the Diamond Standard, a versatile proxy outlined in [EIP-2535](https://eips.ethereum.org/EIPS/eip-2535). This proxy can incorporate functionalities from various Facet contracts. ### GNUS.AI Main Network Smart Contracts
NetworkGenius (GNUS) Contract AddressDiamond Inspector
Polygon0x127E47abA094a9a87D084a3a93732909Ff031419Link
Ethereum0x614577036F0a024DBC1C88BA616b394DD65d105aLink
Binance
Smart
Chain		0x614577036F0a024DBC1C88BA616b394DD65d105aLink
Base0x614577036F0a024DBC1C88BA616b394DD65d105aLink
CardanoComing SoonN/A
SolanaComing SoonN/A
### GNUS.AI Test Network Smart Contracts
NetworkGenius (GNUS) Contract AddressDiamond Inspector
Polygon
Amoy		0xeC20bDf2f9f77dc37Ee8313f719A3cbCFA0CD1eBLink
Ethereum
Sepolia		0x9af8050220D8C355CA3c6dC00a78B474cd3e3c70Link
BSC
Testnet		0xeC20bDf2f9f77dc37Ee8313f719A3cbCFA0CD1eBLink
Base0xeC20bDf2f9f77dc37Ee8313f719A3cbCFA0CD1eBLink
CardanoComing SoonN/A
SolanaComing SoonN/A
### GNUS.AI on Bitcoin (BRC-20) [https://ordinals.hiro.so/protocols/brc-20/BGNS](https://ordinals.hiro.so/protocols/brc-20/BGNS)
SYMBOLTreasury Wallet
BGNUSbc1p47jz7ss5s8j9w09cfvk5jklece7v96uc0slasqp5lklkdcq35y4s56r8ny
### Audits {% file src="../.gitbook/assets/SmartContract_Audit_Solidproof_GNUSai.pdf" %} February 24, 2024 Audit {% endfile %} --- source: /resources/faqs/ title: FAQS --- # FAQS **What is a GNUS Token?** GNUS Tokens are tokens used in a unique, secure, smart, and easy-to-use platform that completely disrupts the way businesses do AI/ML Processing. It is the purchasing unit for AI/ML processing requests. **What blockchain are the GNUS Tokens on?** GNUS tokens are slated to launch on Bitcoin as (BGNS BRC-20), Ethereum, and Polygon, and others as (GNUS ERC-20/ERC-1155 Hybrid), Solana (SPL Token), and Cardano Native Token. **What benefits do I gain from GNUS Token?** The initial value of GNUS tokens is for prepurchasing AI/ML processing and will be used as the reserve currency for Games and applications that integrate with the GNUS blockchain. Once the ecosystem is in full swing, GNUS tokens used for AI/ML processing are paid to anybody who has installed the App or is playing a game with the system integrated. Once GNUS is distributed, it can be used for in-app purchases and becomes part of a gaming ecosystem. **Why are GNUS Tokens multichain?** GNUS tokens are a bridging mechanism between other Cryptocurrencies and Fiat currency and a bridge to the SGNUS (Super Genius) private blockchain. This allows AI processing payments earned by app and game developers to be converted to any currency. **Are GNUS Tokens traded on a big exchange?** GNUS Tokens are not yet trading on a major exchange. We plan on listing to a major CEX exchange after the launch around March 31, 2024 **How do GNUS and SGNUS relate?** GNUS Tokens are blockchain tokens that are used to open AI/ML requests and act as a payment channel. SGNUS tokens are created and mapped one-to-one for GNUS tokens and are part of a rollup and bridging system that uses zkSnarks. They then enter their very own economic system for fast transaction processing. **What is the difference between GNUS and SGNUS tokens?** GNUS (Genius) tokens are currently on the Polygon mainnet, and SGNUS (Super Genius) Tokens are used in a private network for fast transactions. The SGNUS Tokens will roll up to multiple blockchains for cross-chain compatibility. **Why is there a burn function in the smart contract?** We implemented a burn function so that when AI/ML processing is done, the GNUS tokens will increase in value by destroying 10% of the GNUS tokens. This may seem counterintuitive, but from our research, doing this increases the value of your tokens by 12%. **Will this token be considered a security?** We don’t believe it will. We’ve been cautious not to do the ICO until we have the software in a minimally viable state. The tokens are also for prepurchasing AI/ML processing, so the token has a utility value. We’ve analyzed our offering based on the Howey test and scored very well not to be considered a security. **Can I invest in the company by buying these tokens?** No, these tokens are being used for AI/ML processing. However, please don’t hesitate to use the contact form if you are interested in investing in the company, as we do have a prospectus for a SAFE & SAFT offering for accredited investors. **Would anybody be able to buy your tokens?** Anyone can purchase the tokens, as they are utility tokens for use in AI/ML processing and not securities. **Are you worried about the U.S. crackdown on Cryptocurrencies?** Not in the slightest. Cryptocurrencies and Cryptotokens have been adopted by major corporations and have grown significantly over the last few years. The Genie is already out of the bottle! --- source: /resources/faqs/technical-deep-dive-how-gnus.ai-works/ title: Technical Deep Dive: How GNUS.ai Works --- # Technical Deep Dive: How GNUS.ai Works ### 1. How does GNUS.ai enable users in emerging markets to offset device costs by contributing to the AI network through apps? GNUS.ai allows users in emerging markets to earn $GNUS tokens by sharing idle device computing power, primarily GPU resources, through a decentralized AI network. The GNUS SDK integrates into apps, games, and platforms, enabling participation without technical expertise. Users can convert tokens into fiat currency, in-app purchases, or other cryptocurrencies to offset costs of devices like smartphones, laptops, or IoT gadgets. For example, while using apps on Android, iOS, Windows, macOS, or consoles like Xbox and PlayStation, idle resources process AI/ML workloads such as data analysis or model training. This passive income stream makes devices more affordable in regions where upfront costs are high. The mobile-first design ensures low-power devices contribute efficiently, broadening access to AI compute and reducing reliance on costly cloud services. ### 2. What are the key differences between GNUS.ai's Cognitive Mining and traditional proof-of-work mining, particularly in AI-focused rewards? GNUS.ai’s documentation doesn’t explicitly use “Cognitive Mining” but describes a system combining decentralized GPU mining with federated learning, where devices process AI/ML tasks instead of cryptographic puzzles. Key differences from traditional proof-of-work (PoW) mining, like Bitcoin’s hash computations, include: * **Purpose and Output**: PoW secures blockchains with no utility beyond consensus. GNUS.ai processes AI/ML workloads like model training or inference, producing tangible outputs for developers and enterprises. * **Resource Utilization**: PoW relies on specialized hardware (e.g., ASICs), consuming significant energy inefficiently. GNUS.ai uses idle GPUs across devices (desktops, mobiles, IoT) for federated learning, training models locally without sharing raw data to preserve privacy. * **AI-Focused Rewards**: GNUS.ai rewards are based on AI contribution quality and volume, with 80% of $GNUS tokens allocated to developers and users, 10% burned for scarcity, and 10% retained by the network. PoW rewards are fixed per block, tied to speculative value rather than utility. * **Efficiency and Sustainability**: GNUS.ai leverages underutilized resources, using zero-knowledge proofs for secure validation, unlike PoW’s energy-intensive, non-productive computation. This shifts mining from speculative to AI-driven utility, aligning rewards with machine learning contributions. ### 3. What challenges in scaling AI does GNUS.ai address through its distributed web interface and cryptocurrency conversion system? Scaling AI involves challenges like device variability, data privacy, workload distribution, payment accessibility, and network reliability. GNUS.ai addresses these through its distributed web interface and cryptocurrency conversion system: * **Workload Distribution and Scalability**: The web interface divides AI/ML tasks into time-based subtasks, distributed via libP2P pub/sub protocols, allowing devices to contribute at varying GPU levels (e.g., 10% or 0.0001%). Future private networks will use the JSON compute specification for intelligent task allocation based on device capabilities. * **Device Variability and Reliability**: Federated learning enables local task processing, preserving privacy and managing performance differences via load balancing and parity checks for result validation. * **Payment Accessibility**: The conversion system supports fiat-to-$GNUS exchanges, reducing barriers in emerging markets and enabling payments in any currency via smart contracts on the Super Genius blockchain, with bridging to Layer 1 chains (e.g., Ethereum, Polygon, Solana) secured by zk-SNARK proofs and Solidity verification. * **Resilience and Cost Efficiency**: The distributed file system with encrypted uploads ensures uptime, while low CapEx/OpEx compared to centralized clusters (e.g., xAI’s 100k GPU setup) offers competitive pricing without massive infrastructure. These features create a scalable, accessible network that grows with user participation, overcoming centralized AI limitations. ### 4. How does GNUS.ai handle performance and reliability variability across devices, from high-end GPUs to low-power mobiles? GNUS.ai manages device variability with a mobile-first SDK and adaptive networking system for heterogeneous environments: * **Task Allocation**: Workloads are sliced by time and distributed via libP2P pub/sub, allowing flexible GPU utilization (e.g., 10% for bursts, 0.0001% for minimal impact). This supports high-end GPUs and low-power mobiles or IoT, with future private networks using the JSON compute specification for capability-based allocation. * **Low-Power Efficiency**: Federated learning processes tasks locally, minimizing bandwidth and energy use. Idle CPU/GPU cycles are used without disrupting user experience (e.g., during gaming). Mobile Neural Networks (MNN) optimize model execution on edge devices. * **Reliability**: Parity checks and zero-knowledge proofs verify results for accuracy and uptime. Unreliable nodes face reputation slashing, while reliable ones earn more $GNUS. The “Always Available” design redistributes failed tasks, ensuring 99%+ uptime. * **Compatibility**: The SDK supports Windows, macOS, Linux, Android, iOS, Xbox, PlayStation, and IoT, with automatic scaling to prevent overload. Testnet phases incorporate community feedback to optimize performance. This approach enables broad participation without compromising network integrity. ### 5. Your vision states “no high is high enough.” What does the ultimate high look like: GNUS.ai as a cheaper AWS or an invisible layer powering apps, games, and devices? GNUS.ai’s vision, per founder Kenneth Hurley (@SuperGeniusEth), is to empower individuals over corporations with a collaborative ecosystem. The ultimate high is becoming an invisible layer powering apps, games, and devices, rather than just a cheaper AWS. While GNUS.ai offers 80% cost savings through low CapEx/OpEx, its goal is ubiquity: integrating the SDK into billions of devices for passive earning, like electricity powers homes. This makes AI a shared utility, enabling breakthroughs like cancer research via idle resources, with token burns and rewards sustaining the economy. It’s about seamless AI access, not just cost reduction. ### 6. How does GNUS.ai’s networking system orchestrate complex AI/ML workloads across diverse devices while ensuring uptime, resilience, and accuracy? GNUS.ai’s networking system uses federated learning, smart routing, and blockchain verification for workload orchestration: * **Orchestration**: Tasks are divided into time-based subtasks, distributed via libP2P pub/sub, enabling devices to process at varying GPU levels (e.g., 10% or 0.0001%). Real-time adaptation uses MNN for efficient model loading, with future private networks leveraging the JSON compute specification for capability-based division. * **Device Adaptation**: The SDK supports cross-platform compatibility, with federated learning enabling local training to reduce bandwidth. Load balancing prioritizes idle resources to avoid disruption. * **Uptime and Resilience**: The “Always Available” architecture redistributes tasks from failing nodes. The 10% $GNUS token burn per compute cycle increases value by 11.1%, functioning like automated staking. Nodes vote on consensus using reputation (e.g., Genesis transaction: 1,000,000 reputation, AI processing: 1 reputation, bridging/archiving: 10,000 reputation), with a 2/3 reputation points voting system. The Super Genius blockchain ensures fast, secure transactions, with bridging to Layer 1 chains (e.g., Ethereum, Polygon, Solana) secured by zk-SNARK proofs and Solidity verification. * **Accuracy**: Parity checks, zero-knowledge proofs, and cryptographic commitments ensure tamper-proof results, with rewards tied to verified contributions. This creates a scalable network for complex workloads like LLM training across diverse devices. ### 7. Beyond cost savings, does GNUS.ai aim to shift AI control from corporations, and is it about cheaper compute or broader empowerment? GNUS.ai seeks to democratize AI control, moving power from corporations with billion-dollar CapEx (e.g., xAI’s 100k GPU clusters) to individuals. While offering 70-80% cost savings through low OpEx and idle resource use, it prioritizes: * **Decentralized Infrastructure**: GNUS.ai uses global idle GPUs, reducing reliance on centralized providers and risks like insolvency. * **User and Developer Empowerment**: Participants earn $GNUS, fostering collaboration. Federated learning preserves privacy, and the SDK enables indie developers and emerging market users to access AI. * **Sustainable Tokenomics**: The 10% token burn per compute cycle increases value by 11.1%, with 80% of rewards to users, creating incentives unlike corporate models. Monte Carlo simulations on Machinations.io predict token appreciation. * **Broader Impact**: Open AI for research (e.g., protein folding) promotes ethical access. Founder Kenneth Hurley calls this a movement for community control, not just affordability. Cheaper compute is a byproduct of empowering users to shape AI’s future. ### 8. How does GNUS.ai prevent Sybil attacks where one entity creates fake nodes to gain disproportionate rewards or manipulate the network? GNUS.ai prevents Sybil attacks through a security framework in its system architecture (US Patent 11,451,393 B2, covering the distributed computing and cryptotoken payment system). Tokenomics, simulated on Machinations.io, ensure fairness. Key measures include: * **Reputation-Based Security**: Any node can join, with security via a reputation system. Nodes vote on consensus based on transactions processed (e.g., Genesis transaction: 1,000,000 reputation, AI processing: 1 reputation, bridging/archiving: 10,000 reputation). A 2/3 reputation points voting system ensures reputable nodes dominate. Fake nodes risk reputation slashing if detected, reducing Sybil attack influence. * **Zero-Knowledge Proofs and Verification**: zk-SNARKs and parity checks validate contributions, preventing fake nodes from earning rewards. * **Identity Systems**: Device fingerprinting, IP diversity checks, and on-chain verification (via ERC-20/1155 tokens) detect anomalies. The Super Genius blockchain handles secure transactions, with bridging to Layer 1 chains (e.g., Ethereum, Polygon, Solana) secured by zk-SNARK proofs and Solidity verification. * **Economic Disincentives**: Rewards are proportional to verified output, with 10% token burn per transaction for scarcity, increasing value by 11.1% per cycle. Sybil attempts are uneconomical due to reputation slashing and verification overhead. * **GNUS.ai DAO Governance**: The soon-to-launch GNUS.ai DAO uses GNUS Governance Tokens on an Ethereum-compatible blockchain for decentralized decision-making. Proposals, such as token transfers or supply increases, require a 50% quorum of total token voting power and a 2/3 majority of votes cast, ensuring community oversight to prevent Sybil attacks. These mechanisms maintain a fair, resilient network. For updates, check docs.gnus.ai or Telegram (t.me/geniustokens). ### 9. How can a beginner join as a compute provider, and are there guides to help? Becoming a compute provider is simple for beginners, using the Genius Wallet software. Steps include: 1. **Sign Up and Download**: Visit gnus.ai or docs.gnus.ai to download the Genius Wallet app (Windows, macOS, Linux, Android, iOS). It’s an easy installer, requiring no blockchain expertise. Join the public Testnet via the sign-up form (Phase 3 testers earn real $GNUS). 2. **Install and Connect**: Run the wallet, create a secure account (supports MetaMask), and connect your device. The app detects idle GPU/CPU resources and joins the network. 3. **Contribute and Earn**: Use apps or games with the GNUS SDK to share power passively. The wallet manages task allocation and rewards $GNUS based on contributions, viewable in the dashboard. 4. **Guides and Support**: Resources include: * Tutorials in docs.gnus.ai’s FAQ and “How Does It Work?” sections. * YouTube videos (e.g., Super Genius Chronicles by CEO Kenneth Hurley). * Telegram community (t.me/geniustokens) for support, with testers noting minimal resource impact. * GitHub repo for advanced users, but beginners use the wallet. Start with Testnet to earn risk-free; mainnet (Q4 2025) will enable full rewards. No upfront costs beyond your device. ### 10. Has GNUS.ai undergone security audits, and how are funds kept secure? GNUS.ai prioritizes security with robust mechanisms and testing during Testnet phases, including bug bounties via GitHub. Key features include: * **Smart Contract Security**: Built on the ERC-2535 Diamond Standard for modular contracts (fungible $GNUS ERC-20 and ERC-1155 NFTs), using burn-on-mint and facet-based logic to isolate risks. The Super Genius blockchain ensures secure transactions, with bridging to Layer 1 chains (e.g., Ethereum, Polygon, Solana) secured by zk-SNARK proofs and Solidity verification. * **Privacy and Verification**: zk-SNARKs enable privacy-preserving federated learning, with secure 2FA via TOTP and encrypted transactions using SSL/public keys. * **Fund Protection**: The 10% token burn per compute cycle increases value by 11.1%, with tokens held in non-custodial wallets. Distributed nodes eliminate single points of failure. * **Audits and Roadmap**: GNUS.ai completed two third-party smart contract audits, with results on docs.gnus.ai. Internal C++ code audits are ongoing, and a comprehensive third-party audit is planned before the Q4 2025 mainnet launch to validate the Super Genius blockchain and SDK integrations. Phase 3 Testnet (live since July 2025) includes public stress-testing, with community bug bounties via GitHub enhancing security. The GNUS.ai DAO, launching soon, strengthens governance, and partnerships like Volume for automated payments add trust. Funds are secured via user-controlled wallets and on-chain transparency. Check docs.gnus.ai or Telegram for audit details. ### 11. Is a physical GNUS.ai device planned soon? Based on GNUS.ai’s roadmap and announcements (up to September 2025), no dedicated physical device is planned. The focus is software-driven, using existing hardware (smartphones, PCs, consoles, IoT) via the GNUS SDK and Genius Wallet for accessibility. The roadmap (docs.gnus.ai) prioritizes mainnet launch (Q4 2025), SDK integrations (200+ apps/games), and ecosystem growth. Founder Kenneth Hurley emphasizes partnerships for mobile/IoT GPUs (e.g., Volume on Paloma Blockchain), enhancing existing devices. Future demand may lead to optimized hardware, but currently, it’s about software leveraging user-owned devices. Check Telegram or X for updates. --- source: /resources/multisig-wallets/ title: Multisig Wallets --- # Multisig Wallets GNUS.AI Gnosis Safe Multisignature Wallets to protect against malicious attacks on the treasury and to deploy smart contracts and updates. These wallets are public and can be viewed on any blockchain scanners, i.e., [https://www.etherscan.io](https://www.etherscan.io), [https://www.polygonscan.com](https://www.polygonscan.com). ### GNUS.AI Multisig Wallets
Multisig Address TypeNetworkAddress
Main TreasuryEthereum / Polygon / BNB0x45A920727578222B6AFA5ce4044dd35A2218c900
Secondary TreasuryPolygon0xA390c06D129A0B0288FE4E33B2540bD9f99DC333
Main TreasuryBase0x70E78057Ffdb0Cfc5B2923C741A67Ca4A41E4b18
DeploymentEthereum0xc365BaC723295e0d56DB30219d249FDbc19B63CF
DeploymentPolygon0x3ab2620db18DB01F064613F13665297C87E95ee9
DeploymentSepolia Test0x34cF9B07A7703d82689D28f2200067c050e7a861
--- source: /resources/glossary/ title: Glossary --- # Glossary #### Artificial Intelligence (A.I.) Creating computer systems capable of human-like tasks, such as learning, problem-solving, and understanding language, aiming to mimic cognitive functions. #### **Blockchain** A decentralized ledger recording transactions transparently. #### **Cloud Computing** Getting computing services (storage, processing) over the internet for flexibility and cost-effectiveness. #### **Decentralized Application (DApp)** An app running on a decentralized network (blockchain). It uses smart contracts for secure operations. #### **Directed Acyclic Graph (DAG)** A data structure without loops. In blockchains, it's an alternative to the traditional chain structure. #### **Fog Computing** A decentralized computing setup extending cloud capabilities to the network's edge, closer to data sources. #### **Hybrid Cryptocurrency/Crypto-Token System** A mix of cryptocurrencies and tokens for fast transactions. #### **Initial Token Offering (ITO)** A way to fundraise for new crypto projects. It involves offering a percentage of tokens in exchange for currencies. #### Machine Learning (M.L.) A subset of A.I. focused on developing algorithms that enable computers to learn from data, improving their performance over time without explicit programming. #### **Proof of Work (PoW)** A way to secure blockchains where participants solve problems to add new transactions. #### **Smart Contracts** Self-executing contracts written in code. They run automatically when specific conditions are met. #### **Zero Knowledge (ZK) Encryption** A method that allows one party (the prover) to prove to another party (the verifier) that they possess a certain piece of information or knowledge without revealing the actual content of that information. --- source: /resources/official-links/ title: Official Links --- # Official Links Website:[ ](https://www.gnus.ai/)[https://www.gnus.ai/](https://www.gnus.ai/) Github:[ ](https://github.com/GeniusVentures)[https://github.com/GeniusVentures](https://github.com/GeniusVentures) Discord: [https://discord.gg/gnusai](https://discord.gg/gnusai) Facebook: [https://www.facebook.com/geniusventures.io/](https://www.facebook.com/geniusventures.io/) Twitter (X):[ ](https://twitter.com/GNUSAI)[https://twitter.com/GNUSAI](https://twitter.com/GNUSAI) LinkedIn:[ ](https://www.linkedin.com/company/geniusventuresio)[https://www.linkedin.com/company/geniusventuresio](https://www.linkedin.com/company/geniusventuresio) Youtube:[ ](https://www.youtube.com/channel/UC6UmxSK3U8DGzXEe7eguCkA)[https://www.youtube.com/@gnusai](https://www.youtube.com/@gnusai) Telegram:[ ](https://t.me/geniustokens)[https://t.me/gnusai](https://t.me/gnusai) ## GNUS Trading Pairs Information DexTools: [https://www.dextools.io/app/en](https://www.dextools.io/app/en) DexScreener: [https://www.dexscreener.com](https://www.dexscreener.com) CoinMarketCap: [https://coinmarketcap.com/currencies/genius-token-nft-collections/](https://coinmarketcap.com/currencies/genius-token-nft-collections/) --- source: /SuperGenius/Classes/df/da1/structeth_1_1abi_1_1_abi_param/ title: eth::abi::AbiParam (struct) --- Members: kind indexed — true → value appears in topics name — optional parameter name --- source: /SuperGenius/Classes/dc/db1/structeth_1_1codec_1_1_access_list_entry/ title: eth::codec::AccessListEntry (struct) --- An EIP-2930 access list entry: contract address + storage slots. Members: address storage_keys --- source: /SuperGenius/Classes/d5/d74/classsgns_1_1_account_messenger/ title: sgns::AccountMessenger (class) --- Members: Error — Account Messenger errors. BlockResponseHandler HeadRequestHandler RequestType BlockQuery ACCOUNT_COMM — Basis of the account receiving topic. REQUESTS_COMM — Basis of the global requests topic. address_ — Own address. account_comm_topic_ — Account receiving topic. requests_topic_ — Global requests topic. pubsub_ — Pubsub instance. subs_acc_future_ — Future of the subscription to the receiving topic. subs_requests_future_ — Future of the subscription to the requests topic. nonce_responses_ — All current nonce responses. no_nonce_responses_ — Addresses that responded with no nonce. first_response_time_ — Timestamp of the first response. nonce_responses_mutex_ — Mutex of the nonce_responses_. block_responses_ — collected block CIDs per req_id block_first_response_time_ — Timestamp of the first block response. block_responses_mutex_ — Mutex protecting block_responses_. utxo_responses_ utxo_first_response_time_ utxo_responses_mutex_ methods_ — Interface methods. rd_ — Random device for request IDs. global_block_handler_ — Global block response handler. global_handler_mutex_ head_request_handler_ — Global head request handler. head_handler_mutex_ worker_thread_ queue_mutex_ queue_cv_ request_queue_ stop_worker_ logger_ — The logger instance. New — Factory constructor of new AccountMessenger. ~AccountMessenger — Destroy the Account Messenger object. GetLatestNonce — Get the Latest Nonce from the network. RequestGenesis — Request genesis block from the network (retries until timeout) RequestAccountCreation — Request account creation from the network and invoke callback with found CIDs. RequestValidatorRegistry RequestRegularBlock — Request a block by CID from the network (retries until timeout) RequestTransaction — Request a transaction by hash from the network (retries until timeout) RequestUTXOs — Request UTXOs for a specific address and return the selected response. RegisterBlockResponseHandler — Register global block response handler. ClearBlockResponseHandler — Clears the block response handler. RegisterHeadRequestHandler — Register handler for incoming head requests. ClearHeadRequestHandler — Clears the head request handler. RequestHeads — Request heads broadcast for specific topics. WorkerLoop EnqueueTask PerformNonceRequest PerformBlockRequest PerformUTXORequest HasRequestPeers AccountMessenger — Private constructor of the Account Messenger. RequestNonce — Requests the nonce to the network. RequestBlock — Request a block (by index) from the network (no callback) RequestBlockByCid — Request a block (by CID) from the network (no callback) RequestBlockByHash RequestUTXO OnResponse — Callback of pubsub message when a response was received. OnRequest — Callback of pubsub message when a request was received. SendAccountMessage — Sends a pubsub message to a set of topics. HandleNonceRequest — Handles the Nonce request package. HandleNonceResponse — Handles the Nonce response package. HandleBlockRequest — Handles the Genesis request package. HandleBlockCidRequest — Handles the Block-by-CID request package. HandleBlockResponse — Handles the Block response package (calls global handler) HandleTransactionRequest HandleBlockLikeRequest HandleHeadRequest — Handles the Head request package (calls registered handler) HandleUTXORequest — Handles the UTXO request package. HandleUTXOResponse — Handles the UTXO response package. --- source: /SuperGenius/Classes/d2/d93/structsgns_1_1_transaction_manager_1_1_account_u_t_x_o_state/ title: sgns::TransactionManager::AccountUTXOState (struct) --- Members: version root initialized --- source: /SuperGenius/Classes/de/daa/classsgns_1_1_validator_registry_1_1_active_batch_handler_guard/ title: sgns::ValidatorRegistry::ActiveBatchHandlerGuard (class) --- Members: registry_ active_ ActiveBatchHandlerGuard ~ActiveBatchHandlerGuard operator bool --- source: /SuperGenius/Classes/d3/df9/classrlpx_1_1crypto_1_1_aes/ title: rlpx::crypto::Aes (class) --- Members: Aes encrypt_ctr decrypt_ctr encrypt_ctr_inplace decrypt_ctr_inplace --- source: /SuperGenius/Classes/da/d2f/structrlpx_1_1_aes_block/ title: rlpx::AesBlock (struct) --- RLPx wire structs — sizes are derived via sizeof() rather than magic numbers. 16-byte AES block (AES-128 / AES-256 share the same block size). Members: bytes --- source: /SuperGenius/Classes/d2/da2/class_a_e_s_encryption/ title: AESEncryption (class) --- Derived AES256 Encryption class. Members: EncryptData — AES256 Encrytion method. DecryptData — AES256 Decryption method. CheckEqual — Checks if two AESEncryption instances are equal. --- source: /SuperGenius/Classes/d5/d83/classsgns_1_1_android_secure_storage/ title: sgns::AndroidSecureStorage (class) --- Members: jvm_ key_store_helper_class_ load_method_ save_method_ delete_method_ AndroidSecureStorage ~AndroidSecureStorage GetName LoadJSON SaveJSON GetJNIEnv --- source: /SuperGenius/Classes/d9/d1f/classsgns_1_1_apple_secure_storage/ title: sgns::AppleSecureStorage (class) --- Members: identifier_ AppleSecureStorage GetName LoadJSON SaveJSON --- source: /SuperGenius/Classes/d2/deb/structsgns_1_1_genius_assigner_1_1_assigner_output/ title: sgns::GeniusAssigner::AssignerOutput (struct) --- Members: constrains table AssignerOutput --- source: /SuperGenius/Classes/d8/da6/classsgns_1_1crdt_1_1_atomic_transaction/ title: sgns::crdt::AtomicTransaction (class) --- AtomicTransaction provides atomic multi-key operations for CRDT datastore All operations within a transaction are combined into a single delta and published atomically to ensure consistency. Members: Operation Buffer Delta datastore_ operations_ modified_keys_ stored_topics_ is_committed_ mutex_ AtomicTransaction — Constructor for AtomicTransaction. ~AtomicTransaction — Destructor ensures rollback if not committed. Put — Add a key-value pair to the transaction. Remove — Delete a key in the transaction. Get — Get a value for a key. Erase — Erase a key from the transaction (alias for Remove) HasKey — Check if a key has been modified in this transaction. AddTopic — Add a single topic to this transaction's internal topic set. AddTopics — Add multiple topics to this transaction's internal topic set. Commit — Commits all pending operations atomically. Combines all pending operations into a single Delta and publishes it. Rollback — Rollback all pending operations. FindLatestOperation — Find the most recent operation for a given key. --- source: /SuperGenius/Classes/dc/d19/structeth_1_1rpc_1_1_audit_finding/ title: eth::rpc::AuditFinding (struct) --- Members: severity chain_name chain_id message --- source: /SuperGenius/Classes/d3/df0/structeth_1_1rpc_1_1_audit_summary/ title: eth::rpc::AuditSummary (struct) --- Members: passed findings --- source: /SuperGenius/Classes/d6/dcc/classrlpx_1_1auth_1_1_auth_handshake/ title: rlpx::auth::AuthHandshake (class) --- Authentication handshake coordinator. Members: config_ transport_ AuthHandshake — Construct handshake with config and an already-connected transport. execute — Execute full handshake (auth + hello exchange). is_initiator — State query. derive_frame_secrets — Derive RLPx frame secrets from authenticated handshake key material. perform_auth — Internal auth phase (sends/receives auth messages). exchange_hello — Internal hello exchange (capability negotiation). --- source: /SuperGenius/Classes/da/d07/structrlpx_1_1auth_1_1_auth_key_material/ title: rlpx::auth::AuthKeyMaterial (struct) --- Members: peer_public_key peer_ephemeral_public_key local_ephemeral_public_key local_ephemeral_private_key initiator_nonce recipient_nonce initiator_auth_message recipient_ack_message --- source: /SuperGenius/Classes/d2/d0e/class_prime_numbers_1_1_baby_step_giant_step/ title: PrimeNumbers::BabyStepGiantStep (class) --- Members: g_n_inv step_size prime_number value_table BabyStepGiantStep SolveECDLP --- source: /SuperGenius/Classes/d9/dfe/classstd_1_1back__insert__iterator_3_01_buffer_01_4/ title: std::back_insert_iterator< Buffer > (class) --- Members: value_type difference_type pointer reference iterator_category buf_ back_insert_iterator back_insert_iterator operator= operator= operator= operator= operator= operator= operator* operator++ operator++ --- source: /SuperGenius/Classes/d3/d2a/structsgns_1_1crdt_1_1_global_d_b_1_1_backup_options/ title: sgns::crdt::GlobalDB::BackupOptions (struct) --- Members: enabled interval_minutes keep_count auto_restore_on_repair_failure --- source: /SuperGenius/Classes/d8/d2c/classsgns_1_1storage_1_1rocksdb_1_1_batch/ title: sgns::storage::rocksdb::Batch (class) --- Class that is used to implement efficient bulk (batch) modifications of the Map. Members: db_ batch_ Batch put put remove commit — Writes batch. clear — Clear batch. --- source: /SuperGenius/Classes/de/d2d/structsgns_1_1storage_1_1face_1_1_batchable/ title: sgns::storage::face::Batchable (struct) --- A mixin for a map that supports batching for efficiency of modifications. K key type V value type Members: ~Batchable batch — Creates new Write Batch - an object, which can be used to efficiently write bulk data. --- source: /SuperGenius/Classes/d3/df4/structsgns_1_1storage_1_1face_1_1_batch_write_map/ title: sgns::storage::face::BatchWriteMap (struct) --- An abstraction over a writeable key-value map with batching support. K key type V value type --- source: /SuperGenius/Classes/d5/d79/classbitcoin_1_1_bitcoin_key_generator_1_1_bitcoin_e_c_d_s_a_public_key/ title: bitcoin::BitcoinKeyGenerator::BitcoinECDSAPublicKey (class) --- Bitcoin ECDSA public key derived class. Members: CalcPubkeyUsedValue — Implements the calculation for the public key value used for bitcoin. ECDSAPublicKey — Constructs a new ECDSAPublicKey object. --- source: /SuperGenius/Classes/d6/d9d/classbitcoin_1_1_bitcoin_key_generator/ title: bitcoin::BitcoinKeyGenerator (class) --- Creates a pair of ECDSA keys and a Bitcoin address from a compressed key. Members: PubKeyPair_t key_gen — Bitcoin random key generator. MAIN_NETWORK_ID — ID of the Main Bitcoin network. PARITY_EVEN_ID — If even, the compressed address is prepend this. PARITY_ODD_ID — If odd, the compressed address is prepend this. CHECKSUM_SIZE_BYTES — Number of used checksum bytes. privkey — The ECDSA private key. pubkey — The ECDSA public key. pubkey_info — Instance of public key information class. address — The Bitcoin Address in string form. BitcoinKeyGenerator — Constructs a new randomly generated Bitcoin key and address. BitcoinKeyGenerator — Import private key string data to construct Bitcoin key and address. BitcoinKeyGenerator — Import a private key scalar value to construct Bitcoin key and address. get_private_key — Returns the private key reference. get_public_key — Returns the public key reference. get_address — Returns the bitcoin base58 address. GetUsedPubKeyValue — Get the public key value used for bitcoin address derivation. GetEntirePubValue — Get entire key value of the public key. ExtractPubKeyFromField — Extract the key vector data from the ECDSA public key. DeriveAddress — Derive the bitcoin address from de X coordinate of the public key. CreateKeys — Create the ECDSA key pair. DeriveAddress — Derive the bitcoin address from own key. --- source: /SuperGenius/Classes/d8/dea/structsgns_1_1crdt_1_1_graphsync_d_a_g_syncer_1_1_blacklist_entry/ title: sgns::crdt::GraphsyncDAGSyncer::BlacklistEntry (struct) --- Members: timestamp failures ever_connected backoff_attempts BlacklistEntry --- source: /SuperGenius/Classes/d4/dc6/classsgns_1_1base_1_1_blob/ title: sgns::base::Blob (class) --- Base type which represents blob of fixed size. std::string is convenient to use but it is not safe. We can not specify the fixed length for string. For std::array it is possible, so we prefer it over std::string. Members: Blob Blob — constructor enabling initializer list toString toReadableString toHex ToVec size fromString fromReadableString fromHex fromHexWithPrefix fromSpan --- source: /SuperGenius/Classes/da/d14/structeth_1_1_block_bodies_message/ title: eth::BlockBodiesMessage (struct) --- Response to GetBlockBodies (message id 0x06). Members: request_id bodies --- source: /SuperGenius/Classes/d2/df2/structeth_1_1_block_body/ title: eth::BlockBody (struct) --- A single block body: transactions + ommers (uncle headers). Members: transactions ommers --- source: /SuperGenius/Classes/de/da2/classsgns_1_1_blockchain/ title: sgns::Blockchain (class) --- Manages genesis/account-creation blocks and consensus integration. This class coordinates CRDT-backed persistence of blockchain bootstrap blocks, validates signatures, tracks authoritative CIDs, and exposes a high-level interface to submit and verify consensus subjects/proposals. Members: Error — Error class of the Blockchain module. BlockchainCallback — Callback invoked when blockchain initialization/processing finishes. Migration3_5_0To3_6_0 Migration3_6_0To3_7_0 MultiAccountTestAccess BLOCKCHAIN_TOPIC — Topic used for blockchain CRDT data. DEFAULT_FULL_NODE_PUB_ADDRESS — Default authorized full-node public key. GENESIS_KEY — Datastore key for genesis block payload. GENESIS_CID_KEY — Datastore key for selected genesis CID. ACCOUNT_CREATION_KEY_PREFIX — Prefix for account-creation payload keys. ACCOUNT_CREATION_CID_KEY_PREFIX — Prefix for account-creation CID keys. TIMEOUT_GENESIS_BLOCK_MS — Genesis CID download timeout in milliseconds. TIMEOUT_ACC_CREATION_BLOCK_MS — Account-creation CID download timeout in milliseconds. db_ — CRDT database instance. account_ — GeniusAccount instance. blockchain_processed_callback_ — Callback when the processing of the blockchain is done. genesis_block_ — Cached genesis block for easy access. account_creation_block_ — Cached account creation block. cids_ — Cached CID selection state. validator_registry_ — Validator registry component. logger_ — Logger instance. created_successfully_ — Indicates successful initialization/creation flow. filters_registered_ — Indicates CRDT filters were registered. callbacks_registered_ — Indicates CRDT callbacks were registered. stop_started_ — Makes account-bound teardown one-shot. validator_registry_initialized_ — Signals registry initialization completion. start_deferred_ — Start() returned BLOCKCHAIN_NOT_INITIALIZED; retry once the registry is ready. genesis_ready_ — Indicates genesis block is ready. account_creation_ready_ — Indicates account-creation block is ready. consensus_manager_ — Consensus manager used for proposals/certificates. New — Factory method to create Blockchain as shared_ptr. SetAuthorizedFullNodeAddress — Set the authorized full node public address (for testing purposes) GetAuthorizedFullNodeAddress — Get the current authorized full node public address. SetAdditionalGenesisValidatorAddresses — Registers additional validator addresses to include in the genesis registry. GetAdditionalGenesisValidatorAddresses — Returns additional genesis validator addresses previously set. CreateConsensusNonceSubject — Creates a consensus subject for nonce/transaction transition. ~Blockchain — Destroys the blockchain instance. Start — Start the blockchain with async genesis block handling. Stop — Stops blockchain background processing and callbacks. OnGenesisBlockReceived — Handle received genesis block from pubsub. OnAccountCreationBlockReceived — Handle received account creation block from pubsub. GetGenesisCID — Returns the stored CID of the selected genesis block. GetAccountCreationCID — Returns the stored CID of the selected account-creation block. GetValidatorRegistry — Returns validator registry owned by this blockchain instance. SetFullNodeMode — Forces full-node mode behavior for bootstrap/generation flow. RegisterSubjectHandler — Registers a consensus subject handler by canonical subject type string. UnregisterSubjectHandler — Unregisters a consensus subject handler by canonical subject type string. RegisterCertificateHandler — Registers a consensus certificate handler by canonical subject type string. UnregisterCertificateHandler — Unregisters a consensus certificate handler by canonical subject type string. RegisterProposalCleanupHandler — Registers a proposal cleanup callback by canonical subject type string. RegisterSlotKeyHandler — Registers a slot key handler for a specific embedded transaction oneof case. SetSlotHashPopulator — Forwards a slot-hash populator to the consensus manager (Phase 6, D-01). UnregisterSlotKeyHandler CreateConsensusProposal — Creates a signed proposal for nonce/transaction transition. SubmitProposal — Submits a proposal through consensus manager. TryResumeProposal — Attempts to resume deferred handling for a subject hash. TryResumePendingDependency — Attempts to resume deferred handling for a typed pending dependency. CheckCertificate — Checks whether any certificate exists for subject hash. CheckCertificateStrict — Performs strict certificate check for a specific subject object. GetCertificateBySubjectHash — Loads certificate by subject hash. BestHash — Chooses the preferred hash among two candidates. MigrateCids — Migrates blockchain-related CIDs between GlobalDB instances. Blockchain — Private constructor. Use New. InitGenesisCID — Initializes cached/stored genesis CID state. InitAccountCreationCID — Initializes account-creation CID state for account address. SaveGenesisCID — Persists selected genesis CID. SaveAccountCreationCID — Persists selected account-creation CID for address. ComputeSignatureData — Builds canonical bytes to verify/sign genesis block. ComputeSignatureData — Builds canonical bytes to verify/sign account-creation block. VerifySignature — Verifies genesis block signature. VerifySignature — Verifies account-creation block signature. CreateGenesisBlock — Creates and publishes a genesis block when needed. VerifyGenesisBlock — Verifies serialized genesis block payload. CreateAccountCreationBlock — Creates and publishes an account-creation block when needed. VerifyAccountCreationBlock — Verifies serialized account-creation block payload. FilterGenesis — Filters CRDT elements to genesis-block entries. FilterAccountCreation — Filters CRDT elements to account-creation entries. ShouldReplaceGenesis — Determines whether candidate genesis should replace existing one. ShouldReplaceAccountCreation — Determines whether candidate account block should replace existing. GenesisReceivedCallback — Callback for incoming genesis CRDT updates. AccountCreationReceivedCallback — Callback for incoming account-creation CRDT updates. InformBlockchainResult — Delivers overall blockchain processing result to callback. InformGenesisResult — Processes/report result of genesis acquisition/creation. InformAccountCreationResponse — Processes/report result of account-creation acquisition/creation. WatchCIDDownload — Watches CID download completion with timeout handling. EnsureValidatorRegistry — Ensures validator registry is initialized and available. AuthorizedFullNodeAddressStorage — Returns mutable process-wide storage for authorized full-node pub key. AdditionalGenesisValidatorAddressesStorage — Returns mutable process-wide storage for additional genesis validator addresses. --- source: /SuperGenius/Classes/d9/d46/structsgns_1_1_blockchain_1_1_blockchain_c_i_ds/ title: sgns::Blockchain::BlockchainCIDs (struct) --- Members: genesis_ — Selected genesis CID. account_creation_ — Selected account-creation CIDs keyed by address. hasGenesis — Checks whether a genesis CID is available. hasAccount — Checks whether an address has account-creation CID. hasAnyAccount — Checks whether any account-creation CID exists. isCompleteFor — Checks whether both genesis and account CID exist for address. --- source: /SuperGenius/Classes/db/d98/structsgns_1_1_account_messenger_1_1_block_cid_request/ title: sgns::AccountMessenger::BlockCidRequest (struct) --- Members: cid --- source: /SuperGenius/Classes/d6/d5c/structeth_1_1codec_1_1_block_header/ title: eth::codec::BlockHeader (struct) --- Members: parent_hash ommers_hash beneficiary state_root transactions_root receipts_root logs_bloom difficulty number gas_limit gas_used timestamp extra_data mix_hash nonce base_fee_per_gas --- source: /SuperGenius/Classes/de/d70/structeth_1_1_block_headers_message/ title: eth::BlockHeadersMessage (struct) --- Members: request_id headers --- source: /SuperGenius/Classes/d1/dae/structsgns_1_1_account_messenger_1_1_block_index_request/ title: sgns::AccountMessenger::BlockIndexRequest (struct) --- Members: block_index --- source: /SuperGenius/Classes/d2/dc2/structeth_1_1_block_range_update_message/ title: eth::BlockRangeUpdateMessage (struct) --- Members: earliest_block latest_block latest_block_hash --- source: /SuperGenius/Classes/dd/d2b/structdiscv4_discovery_1_1_bootstrap_node/ title: discv4Discovery::BootstrapNode (struct) --- Members: ip port node_id_hex --- source: /SuperGenius/Classes/d2/d31/structsgns_1_1_genius_node_1_1_bootstrap_reconnect_config/ title: sgns::GeniusNode::BootstrapReconnectConfig (struct) --- Members: base_delay max_delay health_check_interval health_check_disconnected_interval background_multiplier --- source: /SuperGenius/Classes/d0/d96/classsgns_1_1evmwatcher_1_1_bridge_catchup_watcher/ title: sgns::evmwatcher::BridgeCatchupWatcher (class) --- Polling watcher that scans bridge chains for historical burn events and forwards them to the node for parsing + minting. Owns its own boost::thread (via MessagingWatcher). The watch() loop polls eth_getLogs at a configurable interval, tracks the last processed block per chain, and forwards discovered logs through a typed BurnProcessor callback. The callback implementation (provided by GeniusNode) handles ABI parsing and minting — the watcher itself only decodes the raw log. Members: ChainsProvider — Callback that returns the current set of chains to scan. RpcUrlResolver — Callback that resolves a chain-id string to an RPC URL. BurnProcessor — Callback invoked for each discovered burn event. config_ — Polling and start-block configuration. chains_provider_ — Returns the current chain list. rpc_resolver_ — Resolves chain-id → RPC URL. burn_processor_ — Called for each discovered burn log. last_block_per_chain_ — Per-chain last processed block number (chain_id → block). mutex_ BridgeCatchupWatcher — Constructs a BridgeCatchupWatcher. startWatching stopWatching GetLastProcessedBlock — Returns the last processed block for a specific chain. watch poll_once --- source: /SuperGenius/Classes/d7/d85/structeth_1_1_bridge_event_claim/ title: eth::BridgeEventClaim (struct) --- Transport-neutral bridge event claim signed by watcher nodes. Members: src_chain_id dest_chain_id block_number block_hash tx_hash log_index bridge_contract event_topic0 topics data sender token_id_or_nonce amount recipient observed_at finality_depth --- source: /SuperGenius/Classes/db/d36/structeth_1_1_bridge_event_key/ title: eth::BridgeEventKey (struct) --- Dedupe/consumption key for a bridge event. Members: src_chain_id tx_hash log_index --- source: /SuperGenius/Classes/d0/d03/structeth_1_1_bridge_event_observation/ title: eth::BridgeEventObservation (struct) --- Watcher signature over a normalized bridge event claim. Members: claim observer signature --- source: /SuperGenius/Classes/dd/d0d/classsgns_1_1_bridge_relayer/ title: sgns::BridgeRelayer (class) --- 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). Members: ::BridgeRelayerTestAccess — Friend accessor for unit testing OnWatchEvent and chain_watches_. tx_manager_ — Weak reference to TransactionManager for calling MintFunds. watch_service_ — Shared EthWatchService for event detection. logger_ chain_watches_ — Per-chain watch IDs, keyed by chain name. Populated by Start(). .first is the v1 (BridgeSourceBurned) watch_id; .second is the v2 (BridgeOutInitiated) watch_id. Both registered unconditionally per chain (D-15); the wrong-version watch simply never fires. Create — Factory method to create a BridgeRelayer instance with weak TransactionManager reference. ParseBurnEventValues — Parse decoded ABI values into BurnEventParams for bridging. Start — Register both v1 (BridgeSourceBurned) and v2 (BridgeOutInitiated) watches on all provided chains. OnRpcEndpointsReady — IBridgeInitObserver callback — self-starts when the provider signals readiness. Stop — Stop watching (currently a no-op — EthWatchService lifecycle is external). BridgeRelayer — Construct a BridgeRelayer. OnWatchEvent — Processes a matched burn event and calls MintFunds. --- source: /SuperGenius/Classes/d1/d21/classsgns_1_1evmwatcher_1_1_bridge_rpc_watcher/ title: sgns::evmwatcher::BridgeRpcWatcher (class) --- RPC-based bridge event watcher that polls eth_getLogs, verifies receipts, and produces normalized BridgeEventClaim objects. Unlike EvmMessagingWatcher (which uses WebSocket eth_subscribe), this watcher uses eth::rpc::RpcHttpTransport for JSON-RPC over HTTP. It polls at a configurable interval, fetches logs for the bridge contract, verifies each event through eth_getTransactionReceipt, and emits eth::BridgeEventClaim objects via a typed callback. Members: BridgeClaimCallback config_ — Configuration parameters for the watcher. claim_callback_ — Callback for handling parsed bridge event claims. transport_ — RPC transport for making HTTP requests. last_block_ — Last processed block number. BridgeRpcWatcher — Constructs a BridgeRpcWatcher with the specified configuration and callbacks. startWatching stopWatching GetConfig — Returns the watcher's configuration. GetLastProcessedBlock — Returns the last processed block number. watch poll_once — Performs a single polling cycle: fetches logs from the RPC, verifies receipts, and emits claims. --- source: /SuperGenius/Classes/d9/de2/classsgns_1_1crdt_1_1_broadcaster/ title: sgns::crdt::Broadcaster (class) --- A Broadcaster provides a way to send (notify) an opaque payload to all replicas and to retrieve payloads broadcasted. Members: ErrorCode ~Broadcaster Broadcast Next HasTopic — Checks whether the broadcaster is subscribed to the specified topic. GetDagSyncer — Get the underlying DAG syncer (if available). --- source: /SuperGenius/Classes/de/dd5/classsgns_1_1base_1_1_buffer/ title: sgns::base::Buffer (class) --- Class represents arbitrary (including empty) byte buffer. Members: iterator reverse_iterator const_reverse_iterator const_iterator value_type pointer const_pointer data_ Buffer — Allocates a buffer of the given size, filled with a byte value. ~Buffer Buffer — lvalue construct buffer from a byte vector Buffer Buffer Buffer Buffer Buffer Buffer reserve resize operator= operator= operator+= operator[] — Accessor of byte elements given an index in the byte array. operator[] — Accessor of byte elements given an index in the byte array. operator== — Lexicographical comparison of two buffers. operator== — Lexicographical comparison of buffer and vector of bytes. operator== — Lexicographical comparison of buffer and vector of bytes. operator< — Lexicographical comparison of two buffers. begin — Iterator, which points to begin of this buffer. end — Iterator, which points to the element next to the last in this buffer. rbegin — Iterator, which points to last of this buffer. rend — Iterator, which points to the element previous to first in this buffer. rbegin — Iterator, which points to last of this buffer. rend — Iterator, which points to the element previous to first in this buffer. begin — Iterator, which points to begin of this buffer. end — Iterator, which points to the element next to the last in this buffer. size — Getter for size of this buffer. putUint8 — Put an 8-bit value into this buffer. putUint32 — Put a 32-bit value into this buffer. putUint64 — Put a 64-bit value into this buffer. put — Put a string into the byte buffer. put — Put a vector of bytes into the byte buffer. put — Put a sequence of bytes into the byte buffer. putBytes — Put an array of bytes bounded by pointers into the byte buffer. putBuffer — Put another buffer content at the end of current one. clear data — getter for raw array of bytes data toVector — getter for vector of bytes toVector subbuffer toHex — encode bytearray as hex empty toString — return content of bytearray as string fromHex — Construct Buffer from hex string. putRange --- source: /SuperGenius/Classes/de/d56/classsgns_1_1account_1_1_burn_config/ title: sgns::account::BurnConfig (class) --- Genesis-seeded, in-memory-cached, quorum-updatable BURN_BASIS_POINTS value. Delegates ALL signature/quorum logic to SecureCrdt/SecureCrdtRegistry no bespoke signature/quorum logic exists here (mirrors TPR-03 precedent). Members: RefreshCallback GENESIS_DEFAULT_BASIS_POINTS — Known genesis default burn-basis-points value (BURN-03 pre-quorum fallback). secure_crdt_ db_ trusted_peer_registry_ quorum_threshold_ account_ base_key_ cached_basis_points_ refresh_callbacks_mutex_ refresh_callbacks_ registry_token_ logger_ BurnConfig ~BurnConfig GetCachedBasisPoints — Returns the currently-cached, quorum-confirmed basis-points value (relaxed atomic load) no live CRDT read. RegisterRefreshCallback — Registers a callback invoked whenever the cached basis-points value changes as a result of a fresh quorum-re-derivation. Unregister — Unregisters this instance's signer-set-source from SecureCrdtRegistry (test-fixture teardown helper). New — Constructs a BurnConfig, registers its signer-set-source and CRDT change-callback, and auto-seeds the genesis default exactly once if eligible. RegisterSignerSetSource — Registers this instance's signer-set-source with SecureCrdtRegistry under base_key_. RegisterCrdtChangeCallback — Registers the GlobalDB new-element callback that re-derives quorum on every base_key OR sig/ child element. OnCrdtElementChanged — Re-runs SecureCrdt::ReadIfQuorum(base_key_) fresh NEVER trusts the callback's positionally-supplied new_data (Pitfall 2) and updates the cache + invokes registered refresh callbacks if the freshly-confirmed value differs from the current cache. Never signs anything. TrySeedGenesisIfEligible — Proposes+signs the KNOWN GENESIS DEFAULT ONLY, exactly once, iff no value is yet confirmed at base_key_ AND this node's account address is among the current trusted peers (D-01, D-02, D-03). Never runs for any other proposed value. --- source: /SuperGenius/Classes/d6/df5/classsgns_1_1account_1_1_burn_config_payload/ title: sgns::account::BurnConfigPayload (class) --- ISignedCRDTData payload type carrying the burn-basis-points value. Serialization/verification mirrors TrustedPeerListPayload's structural-only-verify convention (never diffs against cached state). Members: BASIS_POINTS_TOTAL — Total basis points representing 100% any decoded value above this is semantically invalid. basis_points_ applied_ BurnConfigPayload BurnConfigPayload — Constructs a payload directly from a basis-points value (used by callers that need to serialize a proposed value). SerializeToBytes — Serializes this instance's payload to raw bytes (codec, encode side). DeserializeFromBytes — Deserializes raw bytes into this instance's payload (codec, decode side). Verify — Performs type-specific semantic validation of payload beyond signature/quorum checks (e.g. field-range checks). Apply — Applies the side effect of this value once the caller has independently confirmed quorum (e.g. via SecureCrdt::ReadIfQuorum). Apply() itself does NOT check quorum. GetBasisPoints — Returns the decoded/constructed basis-points value. --- source: /SuperGenius/Classes/da/d8d/structsgns_1_1_burn_event_params/ title: sgns::BurnEventParams (struct) --- Parsed burn event parameters shared between real-time watch (OnWatchEvent) and startup catch-up scan (PerformStartupCatchupScan). Members: token_id — Token identifier from event [1]. amount — Burn amount from event [2]. destination — 128-char hex recipient from event [5] (decompressed if v2) --- source: /SuperGenius/Classes/d4/d5a/structrlpx_1_1protocol_1_1_capability/ title: rlpx::protocol::Capability (struct) --- Members: name version --- source: /SuperGenius/Classes/df/d07/class_c_component_factory/ title: CComponentFactory (class) --- Members: ComponentTable SINGLETON Register GetComponent --- source: /SuperGenius/Classes/d8/dd7/structsgns_1_1_validator_registry_1_1_certificate_votes/ title: sgns::ValidatorRegistry::CertificateVotes (struct) --- Partitioned vote extraction from a certificate. Members: approved — Validators that approved the certificate. unregistered — Unregistered voters observed in certificate. registered_votes — Vote decisions by registered validators. unregistered_votes — Vote decisions by unregistered validators. --- source: /SuperGenius/Classes/d7/d91/structsgns_1_1evmwatcher_1_1_evm_messaging_watcher_1_1_chain_config/ title: sgns::evmwatcher::EvmMessagingWatcher::ChainConfig (struct) --- Members: rpc_url chain_id chain_name ws_url --- source: /SuperGenius/Classes/d5/d01/structsgns_1_1_chain_contract_pair/ title: sgns::ChainContractPair (struct) --- Represents a chain name and its GNUS bridge contract address. Members: chain_name contract_address chain_id creation_block — Block at which the bridge contract was deployed (0 = unknown). --- source: /SuperGenius/Classes/df/d1c/structeth_1_1_chain_head_snapshot/ title: eth::ChainHeadSnapshot (struct) --- Members: finalized_number safe_number latest_number --- source: /SuperGenius/Classes/db/d52/structdiscv4_1_1_chain_peer_cache_refresh_result/ title: discv4::ChainPeerCacheRefreshResult (struct) --- Result of refreshing the local chain peer cache from a remote URL. Members: cache_path cache_available cache_updated --- source: /SuperGenius/Classes/db/dfc/structdiscv4_1_1_chain_peer_cache_signature_verification_result/ title: discv4::ChainPeerCacheSignatureVerificationResult (struct) --- Verification result for a signed chain peer cache JSON document. Members: has_signature signature_valid signer_address --- source: /SuperGenius/Classes/de/d85/structdiscv4_1_1_chain_peer_config/ title: discv4::ChainPeerConfig (struct) --- Parsed chain configuration shared across peer discovery and ETH session setup. Members: canonical_name network_id genesis_hash nodes bootnodes discv5_bootnodes enr_trees discovery_default discovery_fork_filter fork_id eth_message_schemas signature signer_address --- source: /SuperGenius/Classes/d9/dab/classsgns_1_1_chain_rpc_endpoint_provider/ title: sgns::ChainRpcEndpointProvider (class) --- Encapsulates ChainList RPC endpoint loading and validator wiring. Reads bridge_chains_config.json at the path provided, extracts chain_id and bridge_contract_address for each chain entry, runtime-fetches public RPC URLs from the chainid.network chainlist dataset (filter: bridge_contract_address + topic0 attached per chain), wires them into PublicChainInputValidator with consensus weights, calls IInputValidator::Register per chain, and notifies IBridgeInitObserver subscribers on success. Members: CancelChecker — Loads RPC endpoints from bridge_chains_config.json + a runtime chainlist fetch, wires them into the validator, then calls IInputValidator::Register per chain. ObserverCallback observers_ observer_callbacks_ chainlist_fetcher_ ChainRpcEndpointProvider AddObserver — Registers an observer to receive the chain/contract list on Init success. SetChainlistFetcher — Overrides the chainlist dataset fetcher (for tests; no network). Initialize AddObserverCallback --- source: /SuperGenius/Classes/da/d95/struct_chain_runtime/ title: ChainRuntime (struct) --- Members: target genesis fork_id stats pool scheduler dv4 peers_count chain_peers_loaded bootstrap_peers on_connection_activity --- source: /SuperGenius/Classes/d4/d04/struct_chain_target/ title: ChainTarget (struct) --- Members: chain_key chain_peer_cache_key network_id genesis_hex fork_hash_fallback --- source: /SuperGenius/Classes/d9/d25/classeth_1_1_chain_tracker/ title: eth::ChainTracker (class) --- Tracks the chain tip and deduplicates block processing requests. Responsibilities: Record which blocks have already had their receipts requested so duplicate GetReceipts messages are never emitted for the same block. Track the highest known block number (the "tip"). Detect when a block arrives that is lower than the current tip (potential reorg or redundant announcement). This class is intentionally minimal — it does not store headers or receipts; it only tracks identity (hash) and height (number). Thread-safety: not thread-safe. All calls must be externally synchronized. Members: kDefaultWindowSize — Maximum number of block hashes to remember for deduplication. Older entries beyond this window are evicted (FIFO order by insertion, not by block number). window_size_ tip_number_ tip_hash_ seen_set_ — Ordered set for O(log n) lookup. eviction_queue_ — FIFO queue for eviction — stores hashes in insertion order. eviction_head_ — Index of oldest entry. ChainTracker — Construct with an optional custom deduplication window size. ~ChainTracker ChainTracker operator= ChainTracker operator= mark_seen — Attempt to mark a block as "receipts requested". is_seen — Return true if this block hash has already been seen. tip — Return the highest block number seen so far (0 if none). tip_hash — Return the hash of the highest block seen, if any. seen_count — Return the number of blocks currently in the deduplication window. reset — Reset all state (tip, seen set, eviction queue). --- source: /SuperGenius/Classes/d9/de6/structdiscv5_1_1discv5__client_1_1_challenge_state/ title: discv5::discv5_client::ChallengeState (struct) --- Members: remote_node_addr challenge_data request_nonce id_nonce record_seq --- source: /SuperGenius/Classes/db/da1/struct_cmp/ title: Cmp (struct) --- Members: operator() --- source: /SuperGenius/Classes/d9/da9/classsgns_1_1_coin_gecko_price_retriever/ title: sgns::CoinGeckoPriceRetriever (class) --- Members: PriceError m_logger CoinGeckoPriceRetriever formatDate getCurrentPrices getHistoricalPrices getHistoricalPriceRange getCurrentPricesOnce --- source: /SuperGenius/Classes/d7/d37/structeth_1_1_common_status_fields/ title: eth::CommonStatusFields (struct) --- Fields common to both ETH/68 and ETH/69 Status messages. Members: protocol_version network_id genesis_hash fork_id --- source: /SuperGenius/Classes/d4/d56/structdiscv5_1_1_compressed_pub_key_wire/ title: discv5::CompressedPubKeyWire (struct) --- Wire layout of a compressed secp256k1 public key. Members: bytes — 33-byte compressed point (02/03 prefix + X) --- source: /SuperGenius/Classes/d9/d04/structsgns_1_1evmwatcher_1_1_bridge_catchup_watcher_1_1_config/ title: sgns::evmwatcher::BridgeCatchupWatcher::Config (struct) --- Configuration for the catch-up scan watcher. Members: TransportFactory poll_interval — Interval between polling cycles. start_block — Earliest block to scan (0 = genesis). Test-injected (D-20). max_blocks_per_query — Max block range per eth_getLogs call (matches provider limit). max_chunks — Max backward chunks per poll (0 = unlimited). Tests use 3. transport_factory — null = use default RpcHttpTransport. --- source: /SuperGenius/Classes/d3/d68/structsgns_1_1evmwatcher_1_1_bridge_rpc_watcher_1_1_config/ title: sgns::evmwatcher::BridgeRpcWatcher::Config (struct) --- Configuration structure for BridgeRpcWatcher. Members: rpc_url — URL of the RPC. chain_id — The source chain ID. dest_chain_id — The destination chain ID (Genius) contract_address — The address of the bridge contract. event_signature — The signature of the event to listen for. confirmation_depth — The number of blocks to wait before considering an event confirmed. poll_interval — The interval at which to poll for new events. max_log_range — The maximum range of blocks to query for logs. --- source: /SuperGenius/Classes/d5/d51/structsgns_1_1_genius_account_1_1_confirmed_tx_record/ title: sgns::GeniusAccount::ConfirmedTxRecord (struct) --- Members: nonce hash --- source: /SuperGenius/Classes/d1/d8a/classsgns_1_1_consensus_manager/ title: sgns::ConsensusManager (class) --- Implements Consensus with weighted voting. This class implements a consensus algorithm using pubsub messages. A subject needs to be created and with it a proposal as well. The proposal gets sent to the network and gets voted by peers who receive it. This class has hooks to be filled by the caller to register methods to handle subject and proposal. The idea is to leave out the validation of specific data (transaction, job result and etc) for whomever creates the subject. It relies on ValidatorRegistry class to get the voters and their weights. Once consensus is reached a round scheme determines who amongst the validators will create the certificate which is the finality of the subject. The certificate also enabled registry updates to register new validators according to peer who voted correctly or penalize people who votes incorrectly. Members: Check — Object checking values. Proposal — Alias for Consensus Proposal protobuf type. Vote — Alias for Consensus Vote protobuf type. VoteBundle — Alias for Consensus Vote Bundle protobuf type. Certificate — Alias for Consensus Certificate protobuf type. Subject — Alias for Consensus Subject protobuf type. Signer — Alias for a signer method type. SlotHashPopulator — Callback invoked during CreateVote to populate slot_N_hash fields before signing (Phase 6, D-01). SubjectHandler — Alias for a subject handler method type. CertificateSubjectHandler — Alias for a certificate handler method type. ProposalCleanupHandler — Alias for a proposal cleanup handler method type Callback invoked when a proposal slot is cleaned up due to timeout. Receives the transaction hash so the handler can clean up associated tracking entries. SlotKeyHandler — Alias for a slot key handler — produces a deterministic slot key for a proposal. Takes the raw subject, called from GetSlotKey by subject type hash. AggregatorRole — Local node's certificate aggregation role for a proposal round. ConsensusManagerTestAccess ConsensusPendingLifecycleTestAccess ConsensusSlotKeyTestAccess CONSENSUS_CHANNEL_PREFIX — Prefix for pubsub consensus channels. CERTIFICATE_BASE_PATH_KEY — Datastore key prefix for certificates. DEFAULT_TIMESTAMP_WINDOW — Default timestamp acceptance window. DEFAULT_ROUND_DURATION — Default consensus round duration. DEFAULT_ROUND_SKEW — Default round skew tolerance. NO_ROUND — Sentinel for uninitialized round. CERT_KEY_PATTERN — Regex for certificate CRDT keys. slot_key_handlers_ — Slot key handlers keyed by subject type hash. slot_key_handlers_mutex_ — Guards slot_key_handlers_. registry_ — Validator registry dependency. db_ — GlobalDB dependency for persistence and CRDT operations. certificate_work_journal_ — Work journal for certificate processing. subject_handlers_ — Subject handlers keyed by subject type hash. subject_handlers_mutex_ — Guards subject_handlers_. certificate_subject_handlers_ — Certificate handlers by subject type hash. certificate_handlers_mutex_ — Guards certificate_subject_handlers_. proposal_cleanup_handlers_ — Proposal cleanup handlers by subject type hash. cleanup_handlers_mutex_ — Guards proposal_cleanup_handlers_. signer_ — Local signing callback. slot_hash_populator_ — Optional slot-hash populator (Phase 6, D-01). slot_hash_populator_mutex_ — Guards callback replacement/copy at shutdown. account_address_ — Local validator/account id. proposals_ — Proposal state map keyed by proposal id. slot_states_ — Slot arbitration state keyed by slot key. pending_entries_ — Canonical pending proposals keyed by proposal id. pending_by_dependency_ — Proposal ids queued by typed dependency key. pending_count_by_proposer_ — Pending proposal count by proposer id. pending_retained_bytes_ — Total retained pending proposal bytes. pending_config_ — Local pending lifecycle bounds. pending_votes_ — Pending votes keyed by proposal id. proposals_mutex_ — Guards proposal and pending maps. pubsub_ — PubSub transport dependency. consensus_messages_topic_ — PubSub topic for live consensus messages. consensus_datastore_topic_ — Datastore namespace/topic for persisted data. consensus_subs_future_ — Async subscription handle. timestamp_window_ — Accepted timestamp window. certificate_delay_ — Delay before certificate processing. round_duration_ — Consensus round duration. round_skew_ — Round skew tolerance. close_started_ — Makes Close one-shot across Stop/destruction. certificate_filter_registered_ — Owns the CRDT certificate filter. certificate_callback_registered_ — Owns the CRDT certificate callback. stop_timer_ — Signals the round timer thread to stop. certificates_pending_ — Indicates pending certificate processing. timer_cv_ — Condition variable used by the round timer. timer_mutex_ — Mutex paired with timer_cv_. round_timer_ — Background thread driving round-based retries. New — Creates a ConsensusManager instance. RegisterSlotKeyHandler — Registers a slot key handler for a canonical subject type. UnregisterSlotKeyHandler — Unregisters the slot key handler for a canonical subject type. CreateProposal — Builds and signs a proposal using an explicit signer. IsBridgeMintSubject — Phase 6 (D-06): classifies a proposal's subject as a bridge mint. ProposalSigningBytes — Computes canonical bytes to sign a proposal. VoteSigningBytes — Computes canonical bytes to sign a vote. VoteBundleSigningBytes — Computes canonical bytes to sign a vote bundle. ComputeSubjectId — Computes deterministic subject id/hash. ComputeSubjectTypeHash — Computes deterministic bytes for a canonical subject type string. DecodeNonceSubject DecodeTaskResultSubject DecodeRegistryBatchSubject SubjectTypeMatches CreateNonceSubject — Creates a nonce subject. CreateTaskResultSubject — Creates a task-result subject. CreateRegistryBatchSubject — Creates a registry-batch subject. CreateGenericSubject — Creates a generic typed subject for application-owned payload schemas. BestHash — Returns the lexicographically better hash among two values. ~ConsensusManager — Destroys the Consensus Manager object. Close — Close and cleanup members of the Consensus Manager. RegisterSubjectHandler — Registers a subject validation/handling callback by canonical subject type string. UnregisterSubjectHandler — Unregisters a subject handler by canonical subject type string. RegisterCertificateHandler — Registers a certificate handling callback by canonical subject type string. UnregisterCertificateHandler — Unregisters a certificate handler by canonical subject type string. RegisterProposalCleanupHandler — Registers a proposal cleanup callback by canonical subject type string. UnregisterProposalCleanupHandler — Unregisters all proposal cleanup handlers for a canonical subject type string. SetPendingLifecycleConfig — Overrides local pending lifecycle limits for deterministic tests/configuration. Publish — Publishes a consensus envelope to pubsub. CreateProposal — Builds and signs a proposal using the manager signer. CreateVote — Builds and signs a vote for a proposal. SetSlotHashPopulator — Injects the slot-hash populator used by CreateVote (Phase 6, D-01). CreateVoteBundle — Builds and signs an aggregated vote bundle. CreateCertificate — Creates a certificate from a proposal and votes. TallyVotes — Tallies votes against an explicit registry snapshot. TallyVotes — Tallies votes using the manager registry source. EvaluateQuorum — Phase 6 (D-06): single quorum dispatcher. SubmitProposal — Submits a proposal for local handling and broadcast. SubmitVote — Submits a vote for local handling and broadcast. SubmitCertificate — Submits a certificate for local handling and broadcast. ResumeProposalHandling — Retries proposal handling once its subject becomes ready. WakePendingDependency — Retries pending proposals waiting on a typed dependency key. ProcessCertificates — Processes queued certificate work entries. ConfigureCertificateDelay — Configures local delayed processing for received certificates. GetCertificateBySubjectHash — Retrieves a certificate by subject hash. CheckCertificateForSubject — Checks whether a certificate exists for a subject hash. CheckCertificateForSubject — Checks whether a certificate exists for a subject. ConfigureTimestampWindow — Sets timestamp validation window for received objects. ConfigureRoundDuration — Sets consensus round duration. ConfigureRoundSkew — Sets allowable round skew tolerance. ConsensusManager — Constructs a consensus manager. StartRoundTimer — Starts the background round timer loop. HandleProposal — Handles an incoming proposal. HandleVote — Handles an incoming vote. HandleVoteBundle — Handles an incoming vote bundle. HandleCertificate — Handles an incoming certificate. FireProposalCleanupCallbacks — Fires all registered proposal cleanup callbacks for a proposal being cleaned up. Decodes the NonceSubject payload, extracts tx_hash, and dispatches to all handlers registered for the subject type under a shared lock. IsBetterProposal — Compares competing proposals for the same slot. IsTimestampSane — Validates whether a timestamp is inside acceptable drift bounds. GetAggregatorRole — Evaluates the local node's aggregation role for a proposal round. GetOrderedActiveValidators — Returns active validators in deterministic ordering. GetCurrentRound — Computes current round number relative to proposal timestamp. FetchProposalState — Loads proposal state associated with a certificate. CreateProposalState — Creates an initial proposal state from a certificate payload. ValidateCertificateBestProposal — Validates whether certificate points to the best known proposal in slot. CollectCertificateVotes — Extracts certificate votes into normalized vote objects. ClearProposalSlot — Clears local slot bookkeeping for a proposal. ContinueProposalAfterSubject — Continues deferred proposal processing after subject validation. AddPendingProposal — Stores proposal pending subject readiness. RemovePendingProposal — Removes one pending proposal and its local indexes/accounting. TakePendingProposals — Removes and returns pending proposals for a subject hash. RemovePendingProposalLocked CanAdmitPendingProposalLocked NormalizePendingDependencies NextPendingRetryDelayLocked RetryPendingProposal ProcessDuePendingRetries ExpirePendingProposals AddPendingVote — Stores vote pending proposal availability. TakePendingVotes — Removes and returns pending votes for a proposal id. RegisterCertificateFilter — Registers CRDT filter used for certificate keys. FilterCertificate — Filters CRDT entries to certificate payloads. CertificateReceived — Callback for new certificate data received from CRDT. RecoverPendingCertificateWork — Recovers unfinished certificate-processing work from journal. ValidateCertificate — Validates a certificate semantic and quorum constraints. OnConsensusMessage — Callback for incoming consensus pubsub messages. UpdateCertificatesPending — Recomputes local pending-certificate flag. GetSlotKey — Computes proposal slot key used for conflict resolution. GetSubjectHash — Computes subject hash from a subject object. CreateProposalId — Computes deterministic proposal identifier. SubjectHasValidTypeHash — Checks if a subject has a valid type hash. ValidateSubject — Performs basic subject sanity validation. CheckSubject — Performs lightweight subject checks. CheckProposal — Performs lightweight proposal checks. CheckVote — Performs lightweight vote checks. GetPrintableSubjectHash — Produces printable subject hash representation for logs. --- source: /SuperGenius/Classes/d3/dce/structdiscv5_1_1_crawler_stats/ title: discv5::CrawlerStats (struct) --- Snapshot of crawler activity counters. Returned by discv5_crawler::stats() for monitoring / reporting. Members: queued — Peers currently in the outbound query queue. measured — Peers that returned at least one NODES reply. failed — Peers that timed out or returned an error. discovered — Unique valid peers forwarded to the callback. invalid_enr — Records rejected due to parse/signature failure. wrong_chain — Records dropped by the fork-id filter. no_eth_entry — Records without an "eth" entry when filter active. duplicates — Records deduplicated against known node_ids. --- source: /SuperGenius/Classes/d7/d42/classsgns_1_1crdt_1_1_c_r_d_t_callback_manager/ title: sgns::crdt::CRDTCallbackManager (class) --- Members: NewDataPair NewDataCallback NewDataCallbackRegistry DeletedDataCallback DeletedDataCallbackRegistry work_journal_ new_data_callback_registry_mutex_ — Mutex to manipulate new_data_callback_registry_. new_data_callback_registry_ — New data callback registry. deleted_data_callback_registry_mutex_ — Mutex to manipulate deleted_data_callback_registry_. deleted_data_callback_registry_ — Deleted data callback registry. logger_ — Logger instance. CRDTCallbackManager — Construct a new CRDTCallbackManager object. ~CRDTCallbackManager — Destroy the CRDTCallbackManager object. RegisterNewDataCallback — Registers a callback for when new data gets recorded to a specific pattern. RegisterDeletedDataCallback — Registers a callback for when data gets deleted to a specific pattern. UnregisterNewDataCallback — Removes a previously registered new data callback. UnregisterDeletedDataCallback — Removes a previously registered deleted data callback. PutDataCallback — Executes a registered new data callback that matches the key. DeleteDataCallback — Executes a registered deleted data callback that matches the key. --- source: /SuperGenius/Classes/dd/d9b/classsgns_1_1crdt_1_1_c_r_d_t_data_filter/ title: sgns::crdt::CRDTDataFilter (class) --- Members: ElementFilterCallback — Element filtering callback definition. FilterCallbackRegistry work_journal_ accept_by_default_ — The default behavior for values not matching any filter. element_registry_mutex_ — Mutex for the element registry. tombstone_registry_mutex_ — Mutex for the tombstone registry. element_registry_ — Element filter callback registry. tombstone_registry_ — Tombstone filter callback registry. CRDTDataFilter — Construct a new CRDTDataFilter object. ~CRDTDataFilter — Destroy the CRDTDataFilter object. RegisterElementFilter — Registers an element filter callback. RegisterTombstoneFilter — Registers a tombstone filter callback. UnregisterElementFilter — Removes the registration of an element filter that corresponds to a pattern. UnregisterTombstoneFilter — Removes the registration of a tombstone filter that corresponds to a pattern. FilterElementsOnDelta — Tries to filter the elements on delta according to stored filters. FilterTombstonesOnDelta — Tries to filter the tombstones on delta according to stored filters. --- source: /SuperGenius/Classes/db/dbb/classsgns_1_1crdt_1_1_crdt_datastore/ title: sgns::crdt::CrdtDatastore (class) --- Forward declaration of CRDT Set class. CRDT datastore class based on https://github.com/ipfs/go-ds-crdt Members: JobStatus Error Buffer Logger RocksDB QueryResult Delta Element IPLDNode CRDTElementFilterCallback CRDTNewElementCallback CRDTDeletedElementCallback PubSubBroadcasterExt ::sgns::Blockchain ::sgns::ValidatorRegistry dataStore_ options_ namespaceKey_ set_ heads_ broadcaster_ dagSyncer_ logger_ numberOfDagWorkers handleNextFuture_ handleNextThreadRunning_ rebroadcastFuture_ rebroadcastThreadRunning_ dagWorkers_ workerThreadIdsMutex_ handleNextThreadId_ rebroadcastThreadId_ closeStarted_ dagWorkerJobListThreadRunning_ dagWorkerMutex_ dagWorkerCv_ rootCIDJobList_ selfCreatedJobList_ pendingHeadsByRootCID_ pendingHeadsMutex_ pendingRootQueue_ activeRootCID_ work_journal_ crdt_filter_ started_ broadcast_enabled_ root_cid_sync_enabled_ rebroadcastMutex_ dagWorkerCvMutex_ rebroadcastCv_ topicNames_ topicNamesMutex_ pendingBroadcastTopics_ crdt_cb_manager_ pending_jobs_ has_full_node_topic_ shutdown_started_ cid_string_cache_ cid_string_cache_mutex_ threadSleepTimeInMilliseconds_ headsNamespace_ setsNamespace_ New — Factory method to create a shared_ptr to a CrdtDatastore. DeltaMerge GetValueSuffix DecodeBroadcast CreateDeltaToAdd Start — Starts the datastore threads. StartCIDProcessing StartRebroadcastHeads ~CrdtDatastore — Destructor of the CRDT datastore. GetKey QueryKeyValues QueryKeyValues — Queries with a middle part that can be a wildcard, negated string or normal string. GetKeysPrefix PutKey — Stores the given value in the CRDT store. HasKey DeleteKey Publish — Publishes a Delta. Creates a DAG node from the given Delta, merges it into the CRDT, and broadcasts the node. PrintDAG CreateDeltaToRemove PrintDataStore Close CancelAndCloseNow — Immediately cancels CRDT work and closes all worker threads. Safe to call multiple times. RegisterElementFilter RegisterNewElementCallback RegisterDeletedElementCallback UnregisterElementFilter UnregisterNewElementCallback UnregisterDeletedElementCallback GetWorkJournal AddTopicName — Configure which topic this datastore should filter on. GetHeadList RemoveHead GetHeadHeight AddHead GetJobStatus BroadcastHeadsForTopics — Broadcast heads for the specified topics. IsBroadcastEnabled — Query whether outgoing head broadcasts are enabled. GetTopicNames GetILPDNodeContent HandleCIDBroadcast — Handles when a CID broadcast gets received If the CID is not known triggers HandleRootCIDBlock. HandleRootCIDBlock — Handles a root CID block by creating a job to fetch and process its content. CreateRootJob — Creates a RootCIDJob for the given root CID. GetLinksToFetch — Gets the links to fetch for a given node in a job. FetchNodes — Fetches the nodes for the given links and root job. GetDeltaFromNode — Gets the Delta from a given IPLD node, filtering it if it wasn't created by self. MergeDataFromDelta — Merges the data from a given Delta into the CRDT set. ProcessJobIteration — Processes A Root CID job. Sync PrintDAGRec RebroadcastHeads Broadcast — Broadcasts a set of CIDs. Encodes and broadcasts the provided list of CIDs. EncodeBroadcast CreateIPLDNode CreateDAGNode AddDAGNode SyncDatastore PutElementsCallback DeleteElementsCallback UpdateCRDTHeads EnqueueRootCID WaitForJob EncodeBroadcastStatic CrdtDatastore CrdtDatastore ShouldContinueWorkerThread ProcessJobs SeedNextExternalRoot StopWorkerLoops IsCurrentThreadInternalWorker WaitForWorkersToExit IsRootCIDPendingOrActive IsRootCIDPendingOrActiveLocked HandleJobProcessingFailure HandleJobProcessingSuccess CleanupFailedJob MarkJobPending MarkJobFailed --- source: /SuperGenius/Classes/d5/dea/classsgns_1_1crdt_1_1_crdt_heads/ title: sgns::crdt::CrdtHeads (class) --- CrdtHeads manages the current Merkle-CRDT heads. Members: DataStore Buffer CRDTHeadList CRDTListResult mutex_ dataStore_ cache_ namespaceKey_ logger_ CrdtHeads CrdtHeads ~CrdtHeads — Destroy the Crdt Heads object. operator== operator!= operator= GetNamespaceKey GetKey IsHead GetHeadHeight GetLength Add Remove Replace GetList PrimeCache Write Delete CrdtHeads --- source: /SuperGenius/Classes/db/d77/structsgns_1_1crdt_1_1_crdt_options/ title: sgns::crdt::CrdtOptions (struct) --- Options holds configurable values for CrdtDatastore. Members: VerifyErrorCode Buffer Logger logger rebroadcastIntervalMilliseconds dagSyncerTimeoutSec numWorkers DefaultOptions Verify operator== operator!= --- source: /SuperGenius/Classes/dd/d80/classsgns_1_1crdt_1_1_crdt_set/ title: sgns::crdt::CrdtSet (class) --- CrdtSet implements an Add-Wins Observed-Remove Set using delta-CRDTs (https://arxiv.org/abs/1410.2803) and backing all the data in a datastore. It is fully agnostic to MerkleCRDTs or the delta distribution layer. It chooses the Value with most priority for a Key as the current Value. When two values have the same priority, it chooses by alphabetically sorting their unique IDs alphabetically. Members: QuerySuffix Delta Element Buffer DataStore QueryResult PutHookPtr DeleteHookPtr dataStore_ namespaceKey_ mutex_ putHookFunc_ deleteHookFunc_ elemsNamespace_ tombsNamespace_ keysNamespace_ valueSuffix_ prioritySuffix_ CrdtSet CrdtSet ~CrdtSet operator== operator!= operator= GetValueFromDatastore CreateDeltaToRemove GetElement QueryElements QueryElements — Queries with a middle part that can be a wildcard, negated string or normal string. IsValueInSet InElemsNotTombstoned KeyPrefix ElemsPrefix TombsPrefix KeysKey ValueKey PriorityKey GetPriority SetPriority SetValue SetValue PutElems PutTombs Merge InTombsKeyID SetPutHook SetDeleteHook DataStoreSync PrintDataStore GetPrioritySuffix GetValueSuffix CreateDeltaToAdd CrdtSet SetPriority PrintTombs --- source: /SuperGenius/Classes/d9/dc9/classsgns_1_1crdt_1_1_c_r_d_t_work_journal/ title: sgns::crdt::CRDTWorkJournal (class) --- Tracks key processing lifecycle persisted in RocksDB. Entries are stored under the internal work namespace and can be recovered across process restarts. Members: State — Processing state for a tracked key. NAMESPACE_PREFIX — Storage key namespace. datastore_ — Backing datastore for journal state. mutex_ — Synchronizes public journal operations. New — Creates a work journal backed by RocksDB. MarkSeen — Marks a key as seen and pending processing. MarkProcessing — Marks an existing key as processing with a lease. MarkStalled — Marks an existing key as stalled with a lease. MarkDone — Removes a key from the journal. GetEntry — Retrieves one entry by logical key. ListUnfinished — Lists all unfinished entries, optionally filtered by key regex. RecoverStaleProcessing — Converts stale processing entries to stalled. CRDTWorkJournal — Constructs a work journal. BuildStorageKey — Builds the internal storage key for a logical key. GetEntryUnlocked — Retrieves an entry without taking the mutex. PutEntryUnlocked — Stores an entry without taking the mutex. NowMs — Returns current Unix time in milliseconds. DeserializeEntry — Parses a serialized entry payload. SerializeEntry — Serializes an entry payload. Split — Splits a string by a separator. --- source: /SuperGenius/Classes/dc/d29/struct_crypto3_util/ title: Crypto3Util (struct) --- Members: BytesToCppInt CppIntToBytes --- source: /SuperGenius/Classes/de/daf/class_c_singleton/ title: CSingleton (class) --- Elemental Engine Copyright (C) 2013 Social Systems Technology, Inc. This code is redistributable under the terms of the EE License. This code is distributed without warranty or implied warranty of merchantability or fitness for a particular purpose. See the EE License for more details. You should have received a copy of the EE License along with this code; If not, write to Social Systems Technology, Inc., 109 East 17th Street Suite 4210 Cheyenne, WY 82001 USA Members: isInitialized _instance Instance CSingleton ~CSingleton CSingleton operator= --- source: /SuperGenius/Classes/d1/d14/classsgns_1_1storage_1_1rocksdb_1_1_cursor/ title: sgns::storage::rocksdb::Cursor (class) --- Instance of cursor can be used as bidirectional iterator over key-value bindings of the Map. Members: i_ ~Cursor Cursor seekToFirst — Same as std::begin(...);. seek seekToLast — Same as std::rbegin(...);, e.g. points to the last valid element. isValid — Is iterator valid? next — Make step forward. prev — Make step backwards. key — Getter for key. value — Getter for value. --- source: /SuperGenius/Classes/d5/d05/classsgns_1_1crdt_1_1_d_a_g_syncer/ title: sgns::crdt::DAGSyncer (class) --- A DAGSyncer is an abstraction to an IPLD-based p2p storage layer. A DAGSyncer is a DAGService with the ability to publish new ipld nodes to the network, and retrieving others from it. Members: LinkInfoPair LinkInfoSet HasBlock GetNodeWithoutRequest TraverseCIDsLinks InitCIDBlock IsCIDInCache DeleteCIDBlock Stop markResolved isResolved --- source: /SuperGenius/Classes/db/d23/structsgns_1_1crdt_1_1_crdt_datastore_1_1_dag_worker/ title: sgns::crdt::CrdtDatastore::DagWorker (struct) --- DAG worker structure to keep track of worker threads Members: dagWorkerFuture_ dagWorkerThreadRunning_ threadId_ --- source: /SuperGenius/Classes/de/d54/structsgns_1_1crdt_1_1_c_r_d_t_callback_manager_1_1_deleted_data_callback_entry/ title: sgns::crdt::CRDTCallbackManager::DeletedDataCallbackEntry (struct) --- Members: pattern regex callback --- source: /SuperGenius/Classes/d5/d9e/structrlpx_1_1crypto_1_1_kdf_1_1_derived_keys/ title: rlpx::crypto::Kdf::DerivedKeys (struct) --- Members: aes_key mac_key --- source: /SuperGenius/Classes/de/d39/struct_dev_config/ title: DevConfig (struct) --- Runtime configuration values used to bootstrap a Genius node instance. Members: Addr — Developer payout address. Cut — Developer or peer cut encoded as a string. TokenValueInGNUS — Conversion rate used for child-token. TokenID — Child token identifier configured for this node. BaseWritePath — Base directory for node databases, logs, and account storage. --- source: /SuperGenius/Classes/d4/dae/classdiscv4_1_1_dial_history/ title: discv4::DialHistory (class) --- Tracks recently-dialed peers and suppresses retry attempts until a configurable cooldown expires. Mirrors go-ethereum's expHeap-backed dial history in p2p/dial.go. The default expiry (35 s) matches go-ethereum's dialHistoryExpiration (inboundThrottleTime 30 s + 5 s guard). Not thread-safe — callers must serialise access if needed. Members: Clock TimePoint Duration kDefaultExpiry — Default expiry duration matching go-ethereum's dialHistoryExpiration. expiry_ entries_ DialHistory add — Record that a node has just been dialed. contains — Returns true if the node was recently dialed and the cooldown has not yet expired. Does NOT call expire() automatically — call expire() first if you want stale entries pruned. expire — Remove all entries whose expiry time has passed. size — Number of active (non-expired) entries. key — Derive a stable string key from a node_id for use in the map. --- source: /SuperGenius/Classes/db/dc2/structdiscv4_1_1_dial_scheduler/ title: discv4::DialScheduler (struct) --- Per-chain dial scheduler mirroring go-ethereum's dialScheduler. Maintains up to pool->max_per_chain concurrent dial coroutines, respecting the global pool->max_total cap across all chains. All methods run on the single io_context thread — no mutex needed. Members: io pool dial_fn feedback_fn filter_fn — Optional peer filter; nullptr = accept all. dial_history active validated_count — currently active validated connections total_validated — cumulative count (never decrements) stopping queue active_sessions DialScheduler enqueue — Enqueue a validated peer for dialing. If a slot is free (both per-chain and global caps), spawns immediately. Otherwise queues for later drain. release — Called by every dial exit path. Recycles the slot and drains the queue up to the available capacity. stop — Async stop — disconnect all active sessions immediately. Returns immediately; fds are freed on the next io_context cycle. spawn_dial --- source: /SuperGenius/Classes/de/dc8/struct_dial_stats/ title: DialStats (struct) --- Members: dialed — total dial attempts started connect_failed — TCP / auth / pre-HELLO Disconnect. wrong_chain — Status received but wrong network_id. status_timeout — no Status within timeout (not TooManyPeers) too_many_peers — TooManyPeers before chain confirmed. too_many_peers_right_chain — TooManyPeers after chain confirmed. connected — right chain, Status validated eth_messages — post-handshake ETH messages observed connected_seeded connected_discv5 filtered_bad_peers --- source: /SuperGenius/Classes/d2/d8d/structrlpx_1_1protocol_1_1_disconnect_message/ title: rlpx::protocol::DisconnectMessage (struct) --- Members: reason encode decode --- source: /SuperGenius/Classes/d0/d12/structdiscv4_1_1_discovered_peer/ title: discv4::DiscoveredPeer (struct) --- Members: node_id ip udp_port tcp_port last_seen eth_fork_id — ENR-derived ForkId; empty if eth entry absent or ENR failed. --- source: /SuperGenius/Classes/df/d4a/classdiscv4_1_1discv4__client/ title: discv4::discv4_client (class) --- Discovery v4 protocol client. Implements the Ethereum Discovery v4 protocol for peer discovery. Uses UDP for communication with bootstrap nodes and discovered peers. Protocol flow: Send PING to bootstrap nodes Receive PONG responses Send FIND_NODE to discover more peers Receive NEIGHBOURS responses with peer lists Maintain K-bucket routing table Members: io_context_ config_ socket_ logger_ peers_mutex_ peers_ peer_callback_ error_callback_ running_ pending_replies_ bonded_set_ — Endpoints that completed PING→PONG bond. key: "ip:port". discovered_set_ — Endpoints already queued for recursive PING+FIND_NODE (prevents duplicate work). key: "ip:port". discv4_client ~discv4_client start stop ping — Send PING to a specific node. find_node — Send FIND_NODE to discover peers near a target. request_enr — Send ENRRequest to a bonded peer and return the raw ENR record bytes. get_peers set_peer_discovered_callback set_error_callback local_node_id bound_port — Return the local UDP port the socket is bound to. Useful in tests where bind_port=0 (OS-assigned ephemeral port). receive_loop handle_packet handle_ping handle_pong handle_find_node handle_neighbours handle_enr_request handle_enr_response send_packet sign_packet verify_packet ensure_bond — Ensure a PING→PONG bond exists before sending FIND_NODE. Calls ping() if the endpoint is not yet in bonded_set_. compute_node_id reply_key — Build the pending-reply map key. --- source: /SuperGenius/Classes/d2/d8f/structdiscv4_1_1discv4__enr__request/ title: discv4::discv4_enr_request (struct) --- ENRRequest packet — discv4 wire type 0x05 (EIP-868). Mirrors go-ethereum v4wire.ENRRequest: ENRRequeststruct{ Expirationuint64 Rest[]rlp.RawValue`rlp:"tail"` } Wire layout (after signing): hash(32) || sig(65) || packet-type(1) || RLP([expiration]) Members: expiration — Unix timestamp after which the packet expires. RlpPayload — Encode as packet-type byte || RLP([expiration]), ready for signing. --- source: /SuperGenius/Classes/d6/db4/structdiscv4_1_1discv4__enr__response/ title: discv4::discv4_enr_response (struct) --- Parsed ENRResponse — discv4 wire type 0x06 (EIP-868). Mirrors go-ethereum v4wire.ENRResponse: ENRResponsestruct{ ReplyTok[]byte//HashoftheENRRequestpacket. Recordenr.Record Rest[]rlp.RawValue`rlp:"tail"` } Wire layout (incoming): hash(32) || sig(65) || type(1) || RLP([reply_tok(32), record_rlp]) Members: request_hash — Hash of the originating ENRRequest packet (the ReplyTok field). record_rlp Parse — Parse a full discv4 wire packet into a discv4_enr_response. ParseEthForkId — Extract the ForkId from the eth ENR entry in record_rlp. --- source: /SuperGenius/Classes/dd/da0/classdiscv4_1_1discv4__packet/ title: discv4::discv4_packet (class) --- Base class for all Discovery V4 packets. Members: packetType_ version_ name_ ~discv4_packet RlpPayload PacketType Version Name ValidateHash Keccak256 — Compute the Keccak-256 digest of payload. discv4_packet --- source: /SuperGenius/Classes/d4/d59/classdiscv4_1_1discv4__ping/ title: discv4::discv4_ping (class) --- Members: fromEp toEp expires discv4_ping RlpPayload FromEndpoint ToEndpoint Expiration --- source: /SuperGenius/Classes/d6/d87/structdiscv4_1_1discv4__pong/ title: discv4::discv4_pong (struct) --- Members: toEndpoint pingHash expiration ersErq Parse ParseEndpoint --- source: /SuperGenius/Classes/d6/dd3/structdiscv4_1_1discv4_config/ title: discv4::discv4Config (struct) --- Members: bind_ip — Local UDP bind address. bind_port tcp_port private_key public_key ping_timeout peer_expiry --- source: /SuperGenius/Classes/d7/da5/classdiscv4_discovery/ title: discv4Discovery (class) --- Members: io_context_ socket_ ctx_ bootstrap_nodes_ peers_ discv4Discovery ~discv4Discovery SendPing GetNodeID HandlePacket Run ParseNodeID --- source: /SuperGenius/Classes/d7/d2f/classdiscv5_1_1discv5__client/ title: discv5::discv5_client (class) --- Discovery v5 protocol client. Owns the UDP socket, drives the receive loop, and delegates peer lifecycle management to an internal discv5_crawler. The public interface is deliberately narrow and mirrors the discv4_client shape so that callers can adopt either protocol with minimal friction: discv5::discv5Configcfg; cfg.bootstrap_enrs=chain_config.discv5_bootnodes; autoclient=std::make_unique(io,cfg); client->set_peer_discovered_callback([](constdiscovery::ValidatedPeer&p){…}); client->start(); io.run(); Thread safety All public methods must be called from the thread that drives the supplied io_context. The peer-discovered callback is invoked on that same thread. Members: io_context_ config_ socket_ crawler_ logger_ sessions_ pending_requests_ sent_challenges_ running_ received_packets_ dropped_undersized_packets_ send_findnode_failures_ whoareyou_packets_ handshake_packets_ outbound_handshake_attempts_ outbound_handshake_failures_ inbound_handshake_reject_auth_ inbound_handshake_reject_challenge_ inbound_handshake_reject_record_ inbound_handshake_reject_crypto_ inbound_handshake_reject_decrypt_ inbound_handshake_seen_ inbound_message_seen_ inbound_message_decrypt_fail_ nodes_packets_ discv5_client — Construct the client. ~discv5_client discv5_client operator= discv5_client operator= add_bootnode — Add a single bootstrap ENR URI. set_peer_discovered_callback — Register the callback invoked for each newly discovered peer. set_error_callback — Register the error callback. start — Bind the UDP socket and start the receive + crawler loops. stop — Close the UDP socket and signal the crawler to stop. stats — Return a snapshot of current crawler activity counters. local_node_id — Return the local node identifier (64-byte public key). is_running — Returns true when the client has been started and not yet stopped. bound_port — Return the local UDP port the socket is currently bound to. Useful in tests when bind_port is 0 (ephemeral OS-assigned port). received_packet_count — Return the number of non-undersized UDP packets accepted by the receive loop. dropped_undersized_packet_count — Return the number of undersized UDP packets dropped by the receive loop. send_findnode_failure_count — Return the number of FINDNODE send attempts that failed. whoareyou_packet_count — Return the number of valid WHOAREYOU packets parsed by the receive path. handshake_packet_count — Return the number of successfully decrypted handshake packets. outbound_handshake_attempt_count — Return the number of outbound handshake send attempts. outbound_handshake_failure_count — Return the number of outbound handshake send attempts that failed. inbound_handshake_reject_auth_count — Return the number of inbound handshake packets rejected during auth parsing. inbound_handshake_reject_challenge_count — Return the number of inbound handshake packets rejected due to missing/mismatched challenge state. inbound_handshake_reject_record_count — Return the number of inbound handshake packets rejected during ENR/identity validation. inbound_handshake_reject_crypto_count — Return the number of inbound handshake packets rejected during shared-secret/key derivation. inbound_handshake_reject_decrypt_count — Return the number of inbound handshake packets rejected due to message decrypt failure. inbound_handshake_seen_count — Return the number of inbound handshake packets observed before validation. inbound_message_seen_count — Return the number of inbound MESSAGE packets observed before validation/decrypt. inbound_message_decrypt_fail_count — Return the number of inbound MESSAGE packets that failed decrypt with a matching session. nodes_packet_count — Return the number of successfully decoded NODES packets. receive_loop — Async receive loop — reads UDP packets and dispatches them. crawler_loop — Async crawler loop — drains the queued peer set and issues FINDNODE requests at the configured interval. handle_packet — Handle a raw incoming UDP packet. send_findnode — Send a FINDNODE request to target. send_packet — Send a raw UDP packet to a peer endpoint. send_whoareyou — Send a WHOAREYOU challenge in response to a packet from sender. handle_findnode_request — Process a decrypted FINDNODE request and send a NODES response. build_local_enr — Build the local ENR record used in handshake/NODES responses. --- source: /SuperGenius/Classes/db/d16/classdiscv5_1_1discv5__crawler/ title: discv5::discv5_crawler (class) --- Discv5 peer crawler: seed → FINDNODE loop → ValidatedPeer emission. Manages four peer sets that mirror the nim dcrawl pattern: queued: nodes to be queried next (FINDNODE not yet sent) measured: nodes that responded to at least one FINDNODE query failed: nodes that timed out or returned an error discovered: deduplication set; node_ids already forwarded downstream Protocol implementation note The first iteration keeps the network I/O intentionally simple: it pings bootstrap nodes with ENR-sourced addresses and processes NODES replies. A full WHOAREYOU/HANDSHAKE session layer will be added in a future sprint. Thread safety start() and stop() must be called from the same thread that drives the provided asio::io_context. The stats() accessor is lock-protected. Members: config_ state_mutex_ queued_peers_ — Peers waiting to be queried (dequeue → FINDNODE). measured_ids_ — node_id keys of peers that have responded at least once. failed_ids_ — node_id keys of peers that failed to respond. discovered_ids_ — node_id keys of peers already forwarded to the callback (dedup). stat_discovered_ stat_invalid_enr_ stat_wrong_chain_ stat_no_eth_entry_ stat_duplicates_ running_ peer_callback_ error_callback_ discv5_crawler — Construct the crawler with a fully-populated configuration. ~discv5_crawler discv5_crawler operator= discv5_crawler operator= add_bootstrap — Seed the crawler with an additional bootstrap ENR record. set_peer_discovered_callback — Register the callback invoked for each newly discovered peer. set_error_callback — Register the error callback for non-fatal diagnostics. start — Enqueue all bootstrap seeds and transition to running state. stop — Stop the crawler and clear the running flag. process_found_peers — Manually enqueue a set of ValidatedPeer entries from an external source (e.g. a NODES reply decoded by the client layer). ingest_discovered_peers — Accept peers decoded from a live NODES response. stats — Return a snapshot of current activity counters (thread-safe). is_running — Returns true if the crawler has been started and not yet stopped. mark_measured — Mark a peer as measured (responded to a query). mark_failed — Mark a peer as failed (query timed out or returned error). dequeue_next — Return the next queued NodeId to probe, or nullopt if queue empty. is_discovered — True if node_id has already been forwarded to the callback. enqueue_enr_uri — Attempt to parse and enqueue a single ENR URI string. enqueue_enode_uri — Attempt to parse and enqueue a single enode URI string. emit_peer — Forward a valid peer through the fork-id filter and callback. node_key — Convert a NodeId to a string key for use in sets/maps. --- source: /SuperGenius/Classes/de/df2/structdiscv5_1_1discv5_config/ title: discv5::discv5Config (struct) --- Configuration for the discv5 client and crawler. All numeric fields default to the values defined in discv5_constants.hpp. Members: bind_ip — Bind address for the local UDP socket. bind_port — UDP port to bind. 0 → OS-assigned ephemeral port. tcp_port — TCP port advertised to peers (for RLPx dial-back). private_key — secp256k1 private key (32 bytes). Must be set before start(). public_key — secp256k1 public key (64 bytes, uncompressed, no 0x04 prefix). bootstrap_enrs — Bootstrap ENR URI strings ("enr:…"). At least one is required. max_concurrent_queries — Maximum number of concurrent FINDNODE queries. query_interval_sec — Seconds between full crawler sweeps. peer_expiry_sec — Seconds before a discovered peer is considered stale and evicted. required_fork_id --- source: /SuperGenius/Classes/d7/dab/structdiscv5_1_1_discv5_peer/ title: discv5::Discv5Peer (struct) --- A peer discovered by the discv5 crawler. Owns the source enr, derives the peer handoff record from it, and tracks the last-contact timestamp for eviction bookkeeping. Members: enr — Full parsed ENR. peer — Handoff record for DialScheduler. last_seen — Time of most recent contact. --- source: /SuperGenius/Classes/d2/d3c/structintx_1_1div__result/ title: intx::div_result (struct) --- Division. Members: quot rem operator std::tuple< QuotT &, RemT & > — Conversion to tuple of references, to allow usage with std::tie(). --- source: /SuperGenius/Classes/da/d28/classrlpx_1_1crypto_1_1_ecdh/ title: rlpx::crypto::Ecdh (class) --- Members: Ecdh compute_shared_secret generate_ephemeral_keypair verify_public_key --- source: /SuperGenius/Classes/d5/db7/class_e_c_d_h_encryption/ title: ECDHEncryption (class) --- Elliptic-curve Diffie-Hellman class using AES 256 Encryption. Members: session_secret — The session secret used in encryption and decryption. EncryptData — Encrypts a vector of data using the session secret. DecryptData — Decrypts a vector of data using the session secret. CheckEqual — Checks if two ECDHEncryption instances are equal. ECDHEncryption — Constructs an ECDHEncryption object and creates a session secret. --- source: /SuperGenius/Classes/de/d81/class_e_c_d_s_a_public_key/ title: ECDSAPublicKey (class) --- Base class to organize public key values of ECDSA. Members: X — String representation of X coordinate. Y — String representation of Y coordinate. X_vect — Vector representation of X coordinate. Y_vect — Vector representation of Y coordinate. pubkey_used_value — Used value of the public key (compressed, uncompressed..) ECDSAPublicKey — Constructs a new ECDSAPublicKey object. ~ECDSAPublicKey — Virtual destructor to prevent memory leak. operator std::string & — Overloads the assignment to string. GetEntireKey CalcPubkeyUsedValue — Calculates the single data used key value. --- source: /SuperGenius/Classes/de/d75/class_e_c_el_gamal_key_generator/ title: ECElGamalKeyGenerator (class) --- Members: cpp_int private_key — Private key instance. public_key — Public key instance. ECElGamalKeyGenerator GetPrivateKey EncryptData DecryptData --- source: /SuperGenius/Classes/df/d3c/struct_e_c_el_gamal_point/ title: ECElGamalPoint (struct) --- Members: cpp_int curve_point_type coeff_type a_coeff b_coeff prime_number curve_point ECElGamalPoint ECElGamalPoint operator+ operator- UnMap CalcPossibleYSquared --- source: /SuperGenius/Classes/dd/d23/classrlpx_1_1auth_1_1_ecies_cipher/ title: rlpx::auth::EciesCipher (class) --- Members: EciesCipher encrypt decrypt estimate_encrypted_size compute_shared_secret derive_aes_key derive_mac_key --- source: /SuperGenius/Classes/de/dda/structrlpx_1_1auth_1_1_ecies_decrypt_params/ title: rlpx::auth::EciesDecryptParams (struct) --- Members: ciphertext recipient_private_key shared_mac_data --- source: /SuperGenius/Classes/d8/d5d/structrlpx_1_1auth_1_1_ecies_encrypt_params/ title: rlpx::auth::EciesEncryptParams (struct) --- Members: plaintext recipient_public_key shared_mac_data --- source: /SuperGenius/Classes/da/d91/class_key_generator_1_1_el_gamal/ title: KeyGenerator::ElGamal (class) --- Members: CypherTextType SAFE_PRIME GENERATOR private_key — Private key instance. public_key — Public key instance. bsgs_instance DecryptDataAdditive ElGamal ElGamal ElGamal ElGamal ~ElGamal GetPublicKey GetPrivateKey DecryptData DecryptData CreateGeneratorParams — Create prime number and generator. EncryptData EncryptData EncryptDataAdditive DecryptData DecryptDataAdditive --- source: /SuperGenius/Classes/d7/d5e/class_encryption/ title: Encryption (class) --- Base class for Encryption scheme. Members: ~Encryption — Virtual destructor to prevent memory leakage. EncryptData — Interface function to Encrypt data. DecryptData — Interface function to Decrypt data. CheckEqual — Interface function to check if two Encryption instances are equal. operator== — Overloads equality operator to CheckEqual. --- source: /SuperGenius/Classes/d3/d8e/structdiscv4_1_1discv4__ping_1_1_endpoint/ title: discv4::discv4_ping::Endpoint (struct) --- Members: ipBv ipBytes udpPort tcpPort Endpoint Endpoint encode --- source: /SuperGenius/Classes/d5/d01/structdiscv4_1_1discv4__pong_1_1_endpoint/ title: discv4::discv4_pong::Endpoint (struct) --- Members: ip udpPort tcpPort --- source: /SuperGenius/Classes/d7/de7/classdiscv5_1_1_enr_parser/ title: discv5::EnrParser (class) --- Parses and validates Ethereum Node Records (EIP-778). Responsibilities: Decode the base64url body of an "enr:…" URI. RLP-decode the record into signature + key–value content. Verify the secp256k1-v4 ECDSA signature. Extract all standard fields into an EnrRecord. Reject incomplete records that cannot yield a dialable ValidatedPeer. The class is stateless and all public methods are const/noexcept-safe. Members: parse — Parse and validate an ENR URI of the form "enr:". decode_uri — Decode the base64url body of an ENR URI into raw bytes. base64url_decode — Base64url-decode a raw body string (without the "enr:" prefix). decode_rlp — RLP-decode raw bytes into an EnrRecord (no signature verification). verify_signature — Verify the secp256k1-v4 signature embedded in record. to_validated_peer — Convert a fully-parsed EnrRecord into a ValidatedPeer. decode_ipv4 — Decode a single 4-byte "ip" field into a dotted-decimal string. decode_ipv6 — Decode a 16-byte "ip6" field into a compressed IPv6 string. decode_port — Decode a big-endian uint16 from up to 2 bytes. decode_eth_entry — Decode the "eth" key–value entry into a ForkId. decompress_pubkey — Derive the 64-byte uncompressed node_id from a 33-byte compressed key. --- source: /SuperGenius/Classes/d2/db1/structdiscv5_1_1_enr_record/ title: discv5::EnrRecord (struct) --- Parsed Ethereum Node Record as defined by EIP-778. All fields are optional except seq, raw_rlp, and node_id (which are populated whenever a record is successfully parsed by EnrParser). Key–value pairs that are not natively understood are stored verbatim in extra_fields so that the record can be re-serialised without loss. Members: seq — Sequence number. Higher value → more recent record. raw_rlp — Raw RLP bytes of the complete record (signature + content). Stored so that the signature can be re-verified later. node_id — 64-byte uncompressed node public key (sans 0x04 prefix). Derived from the "secp256k1" (compressed) field. compressed_pubkey — 33-byte compressed secp256k1 public key as stored in the record. ip — IPv4 address string (empty if absent). ip6 — IPv6 address string (empty if absent). udp_port — UDP discovery port (0 if absent). tcp_port — TCP RLPx port (0 if absent). udp6_port — UDP discovery port for IPv6 endpoint (0 if absent). tcp6_port — TCP port for IPv6 endpoint (0 if absent). identity_scheme — ENR identity scheme name, e.g. "v4" for secp256k1-v4. eth_fork_id — Optional Ethereum fork identifier parsed from the "eth" entry. extra_fields — Unknown key–value pairs preserved verbatim (key → raw bytes). --- source: /SuperGenius/Classes/db/dea/structdiscv5_1_1_enr_sig_wire/ title: discv5::EnrSigWire (struct) --- Wire layout of an ENR compact secp256k1 signature (no recovery id). Members: bytes — 64-byte compact signature (R || S) --- source: /SuperGenius/Classes/d2/d7c/classdiscv5_1_1_enr_tree_resolver/ title: discv5::EnrTreeResolver (class) --- Resolve EIP-1459 DNS discovery trees into ENR URI seed records. Members: lookup_ EnrTreeResolver resolve is_enr_tree_url parse_url system_txt_lookup resolve_url resolve_entry --- source: /SuperGenius/Classes/d4/de2/structdiscv5_1_1_enr_tree_url/ title: discv5::EnrTreeUrl (struct) --- Parsed EIP-1459 ENR-tree URL. Members: public_key domain --- source: /SuperGenius/Classes/d6/db5/structsgns_1_1crdt_1_1_c_r_d_t_work_journal_1_1_entry/ title: sgns::crdt::CRDTWorkJournal::Entry (struct) --- Serialized work-journal entry for a key. Members: key — Logical key being tracked. state — Current processing state. attempt_count — Number of processing/stall transitions. updated_at_ms — Last update time in Unix milliseconds. lease_until_ms — Processing lease deadline in Unix milliseconds. --- source: /SuperGenius/Classes/db/d70/classsgns_1_1_escrow_transaction/ title: sgns::EscrowTransaction (class) --- Transaction that reserves funds for a job escrow while tracking peer payout metadata. Members: utxo_params_ — Signed inputs and outputs for the escrow hold. amount_ — Total amount locked in escrow. dev_addr_ — Developer payout address for escrow remainder. peers_cut_ — Peer payout multiplier used during escrow release. registered — Forces static initialization of the escrow-hold transaction deserializer. New — Creates a new escrow-hold transaction from signed UTXO parameters. DeSerializeByteVector — Deserializes a serialized escrow transaction. ~EscrowTransaction — Destroys the escrow transaction. SerializeByteVector — Serializes the transaction into a byte vector, including the DAG metadata. SerializeToEmbeddedTransaction — Serializes the transaction into an EmbeddedTransaction proto with the appropriate oneof field set. GetNumChunks — Returns the number of chunks reserved for peer payouts. GetTransactionSpecificPath — Returns the transaction-specific path component for storage and retrieval. GetUTXOParameters — Returns the escrow transaction UTXO inputs and outputs. HasUTXOParameters — Returns if transaction supports UTXOs. GetUTXOParametersOpt — Returns the UTXOs. GetDevAddress — Returns the developer payout address. GetAmount — Returns the total amount locked in escrow. GetPeersCut — Returns the configured peer-share multiplier. SerializeByteVector — Serializes the transaction into a byte vector, including the DAG metadata. SerializeByteVector — Serializes the transaction using the internal DAG metadata. SerializeToEmbeddedTransaction — Serializes the transaction into an EmbeddedTransaction proto with the appropriate oneof field set. SerializeToEmbeddedTransaction — Serializes using internal DAG metadata. EscrowTransaction — Constructs an escrow-hold transaction from its payload and DAG metadata. Register — Registers the deserializer for the escrow-hold transaction type. --- source: /SuperGenius/Classes/d7/db6/classethereum_1_1_ethereum_key_generator_1_1_ethereum_e_c_d_s_a_public_key/ title: ethereum::EthereumKeyGenerator::EthereumECDSAPublicKey (class) --- Ethereum ECDSA public key derived class. Members: CalcPubkeyUsedValue — Implements the calculation for the public key value used for ethereum. ECDSAPublicKey — Constructs a new ECDSAPublicKey object. --- source: /SuperGenius/Classes/dc/dc0/classethereum_1_1_ethereum_key_generator/ title: ethereum::EthereumKeyGenerator (class) --- Creates a pair of ECDSA keys and a ethereum address. Members: PubKeyPair_t key_gen — Ethereum random key generator. ADDRESS_HEADER — Ethereum address header. KECCAK_RES_VALID_POS — Start position for address derivation. ADDRESS_VALID_POS — Start position of the address. ADDRESS_SIZE_CHARS — Size of the address in characters. privkey — Private key pointer. pubkey — Public key pointer. pubkey_info — Instance of public key information class. address — Ethereum address. EthereumKeyGenerator — Construct a new Ethereum Key Generator. EthereumKeyGenerator — Import a private key and construct a new Ethereum Key Generator. EthereumKeyGenerator — Import a private key and construct a new Ethereum Key Generator. get_private_key — Getter for private key (be careful with security implications) get_public_key — Getter for public key. get_address — Getter for the Ethereum address. GetUsedPubKeyValue — Get the single public key value used by ethereum addressing. GetEntirePubValue — Get all key value of the public key. ExtractPubKeyFromField — Extract the key vector data from the ECDSA public key. DeriveAddress — Derive the ethereum address from de XY concatenated coordinates. CreateKeys — Create the ECDSA key pair. BuildPublicKey DeriveAddress — Derive the Ethereum address from own key. --- source: /SuperGenius/Classes/d7/da3/structeth_1_1_eth_message_field_schema/ title: eth::EthMessageFieldSchema (struct) --- Members: name type size offset --- source: /SuperGenius/Classes/dd/df0/structeth_1_1_eth_message_schema/ title: eth::EthMessageSchema (struct) --- Members: name message_id protocol_version fields --- source: /SuperGenius/Classes/d8/ddf/structeth_1_1_eth_peer_disconnect_feedback/ title: eth::EthPeerDisconnectFeedback (struct) --- Feedback from a completed or disconnected peer session. Members: peer reason was_connected --- source: /SuperGenius/Classes/da/d7f/classeth_1_1_eth_peer_queue/ title: eth::EthPeerQueue (class) --- Producer/consumer boundary for eth-watch peer candidates. Cached chain peers and live discovery both feed this queue. Discovery seeds are retained separately and are never consumed as direct RLPx/ETH peers. Members: scheduler_ config_ discovery_bootnodes_ seen_node_ids_ disconnect_counts_ backoff_until_ cached_peer_count_ discovered_peer_count_ requeued_peer_count_ duplicate_peer_drop_count_ capacity_drop_count_ flaky_peer_drop_count_ too_many_peers_backoff_count_ backoff_drop_count_ disconnect_feedback_count_ disconnected_before_connected_count_ disconnected_after_connected_count_ too_many_peers_before_connected_count_ too_many_peers_after_connected_count_ tcp_failure_count_ timeout_count_ subprotocol_error_count_ EthPeerQueue ~EthPeerQueue preload_cached_peers — Enqueue pre-cached RLPx/ETH peer candidates from chain_enodes.json.nodes. set_discovery_bootnodes — Store discovery-only seed nodes from chain_enodes.json.bootnodes. enqueue_discovered_peer — Enqueue a live peer produced by discovery. enqueue_validated_discovery_peer — Enqueue a validated live peer produced by ENR/discv5 discovery. report_peer_disconnected — Requeue eligible disconnected peers without letting flaky nodes cycle forever. discovery_bootnodes needs_discovery cached_peer_count discovered_peer_count requeued_peer_count duplicate_peer_drop_count capacity_drop_count flaky_peer_drop_count too_many_peers_backoff_count backoff_drop_count stats scheduler enqueue_candidate rotate_cached_peers spread_cached_peers_for_dial_slots node_key is_requeueable_disconnect --- source: /SuperGenius/Classes/d4/d87/structeth_1_1_eth_peer_queue_config/ title: eth::EthPeerQueueConfig (struct) --- Bounded peer producer queue policy. Members: max_pending_peers — Maximum peers waiting in the scheduler queue. max_disconnect_requeues — Maximum requeues after disconnect feedback before a peer is considered flaky. too_many_peers_backoff — How long a peer that reports TooManyPeers is suppressed. cache_peer_start_offset — Rotate cached peers by this many entries before dial-slot spreading. --- source: /SuperGenius/Classes/d7/d96/structeth_1_1_eth_peer_queue_stats_snapshot/ title: eth::EthPeerQueueStatsSnapshot (struct) --- Members: cached_peer_count discovered_peer_count requeued_peer_count duplicate_peer_drop_count capacity_drop_count flaky_peer_drop_count too_many_peers_backoff_count backoff_drop_count disconnect_feedback_count disconnected_before_connected_count disconnected_after_connected_count too_many_peers_before_connected_count too_many_peers_after_connected_count tcp_failure_count timeout_count subprotocol_error_count --- source: /SuperGenius/Classes/d6/d62/classeth_1_1_eth_receipt_source_bridge/ title: eth::EthReceiptSourceBridge (class) --- Connects a transport-neutral receipt source to the existing EthWatchService path. Members: service_ source_ subscriptions_ EthReceiptSourceBridge watch_event unwatch process_receipt_batch --- source: /SuperGenius/Classes/da/daa/structeth_1_1_eth_status_handshake_result/ title: eth::EthStatusHandshakeResult (struct) --- Result of the ETH Status startup handshake owned by the ETH layer. Members: remote_status --- source: /SuperGenius/Classes/d1/d5b/structeth_1_1_eth_status_handshake_start/ title: eth::EthStatusHandshakeStart (struct) --- Parameters for starting the ETH Status handshake on a negotiated session. Members: channel network_id genesis_hash fork_id eth_message_schemas accepted_status_handler remote_disconnect_handler inbound_message_handler --- source: /SuperGenius/Classes/df/d1a/structeth_1_1_eth_watch_connection_config/ title: eth::EthWatchConnectionConfig (struct) --- Connection pool limits for eth watch peer sessions. Defaults keep three active dial/watch slots per chain. Members: max_total_connections max_connections_per_chain --- source: /SuperGenius/Classes/d5/d8d/structeth_1_1_eth_watch_event_spec/ title: eth::EthWatchEventSpec (struct) --- Event filter registration consumed by the production watch runtime. Members: contract_address event_signature params from_block to_block --- source: /SuperGenius/Classes/d4/def/classeth_1_1_eth_watch_runner/ title: eth::EthWatchRunner (class) --- Per-session ETH watch runner layered above RLPx and EthWatchService. Members: session_ channel_ chain_name_ network_id_ genesis_hash_ fork_id_ eth_message_schemas_ watch_service_ event_callback_ EthWatchRunner — Construct a runner for one RLPx session. EthWatchRunner set_event_callback — Set the top-level callback for enriched filtered events. service — Access the underlying watch service for subscription setup. send_local_status — Send local ETH Status for the negotiated protocol version. install_session_bridge — Install the session ETH message bridge into the underlying RLPx session. watch_event — Register a watch and emit enriched notifications through the runner callback. context — Access the enriched event context. notify_event --- source: /SuperGenius/Classes/d7/ddf/structeth_1_1_eth_watch_runtime_stats_snapshot/ title: eth::EthWatchRuntimeStatsSnapshot (struct) --- Members: tcp_connect_failures — TCP/socket connection attempts that failed before RLPx auth produced any peer reason. tcp_connected auth_success local_hello_sent peer_disconnect_before_hello — Peer sent RLPx Disconnect as its first post-auth message, before peer HELLO. peer_hello_accepted eth_status_sent remote_status_accepted remote_status_rejected remote_status_rejected_disconnect_reasons remote_status_rejected_validation_errors peer_queue --- source: /SuperGenius/Classes/d0/d0a/classeth_1_1_eth_watch_service/ title: eth::EthWatchService (class) --- Ties together EventWatcher, ABI decoding, and eth message dispatch. Usage: Call set_send_callback() so the service can emit GetReceipts requests. Register subscriptions via watch_event(). Feed incoming eth wire messages via process_message(). Matching logs trigger the registered DecodedEventCallback. Thread-safety: not thread-safe; all calls must be externally synchronized. Members: send_cb_ chain_tracker_ watcher_ subscriptions_ next_id_ next_req_id_ stats_ eth_message_schemas_ pending_requests_ — Outstanding GetReceipts requests keyed by request_id. orchestration_initialized_ orchestration_running_ orchestration_config_ orchestration_callback_ runtime_chains_ active_runners_ runtime_stats_by_chain_ EthWatchService ~EthWatchService EthWatchService operator= EthWatchService operator= initialize — Initialize production orchestration from chain/watch config. run — Start production eth-watch orchestration on io. stop — Stop schedulers and discovery clients created by run(). initialized runtime_chain_count scheduler_count peer_queue_count discovery_client_count discv4_fallback_count active_runner_count aggregate_runtime_stats aggregate_connection_stats peer_queue set_send_callback — Provide a callback used to send outgoing eth messages. set_eth_message_schemas — Configure schema-aware runtime decoders for this service/session. watch_event — Register a watch for a specific contract event. tip — Return the highest block number seen so far (0 if none). tip_hash — Return the hash of the highest block seen, if any. unwatch — Remove a previously registered subscription. subscription_count — Return the number of active subscriptions. stats — Return a snapshot of the live watcher counters. process_message — Process a raw eth wire message payload. process_receipts — Directly process a batch of receipts for a known block. process_new_block — Directly process a NewBlock message. request_receipts — Request receipts for a block by hash. make_default_dial_fn start_discv4_fallback start_enr_tree_discovery start_discv5_discovery --- source: /SuperGenius/Classes/db/dc5/structeth_1_1_eth_watch_service_config/ title: eth::EthWatchServiceConfig (struct) --- Production eth-watch orchestration config. Members: connection peer_queue chains watches discovery_mode enable_discv4_fallback enable_enr_tree_discovery attach_peer_dialer discovery discv5_discovery dial_fn_factory — Optional test seam for replacing live RLPx dialing. discovery_client_factory — Optional test seam for replacing live discv4 client construction/startup. discv5_client_factory — Optional test seam for replacing live discv5 client construction/startup. enr_tree_resolver — Optional test seam for resolving configured ENR trees to ENR URI seeds. discv4_fallback_starter — Optional test seam for replacing live discv4 fallback startup. discv5_enr_tree_starter — Optional test seam for replacing live discv5 ENR-tree startup. --- source: /SuperGenius/Classes/de/dd9/classeth_1_1_event_deduper/ title: eth::EventDeduper (class) --- In-memory event deduper keyed by source chain, transaction hash, and log index. Members: seen_ contains mark_seen size clear --- source: /SuperGenius/Classes/d1/d46/structeth_1_1_event_filter/ title: eth::EventFilter (struct) --- Specifies which logs to accept: by emitting address(es) and/or topic(s). Topic matching follows the eth_getLogs semantics: An empty topics vector matches any log. topics[i] == std::nullopt matches any value at position i. topics[i] == some_hash matches only that exact value at position i. Address matching: An empty addresses vector matches logs from any contract. Otherwise only logs whose emitting address appears in the list are accepted. Members: addresses — Contracts to watch; empty means "any contract". topics from_block — Optional inclusive block range. to_block matches — Test whether a log entry matches this filter. --- source: /SuperGenius/Classes/d9/dc4/classeth_1_1cli_1_1_event_registry/ title: eth::cli::EventRegistry (class) --- Registry mapping event signatures to their ABI parameter descriptors. Pre-populated with common GNUS/ERC-20/bridge events. External code can call event_registry().register_event(sig, params) to add project-specific events before starting the watcher. Example — adding a custom event: eth::cli::event_registry().register_event( "MyEvent(address,uint256)", {{eth::abi::AbiParamKind::kAddress,true,"owner"}, {eth::abi::AbiParamKind::kUint,false,"value"}}); Members: map_ register_event — Register (or overwrite) the ABI parameter list for sig. lookup — Look up ABI parameters for sig. params_for — Convenience: return params for sig, or empty vector if unknown. --- source: /SuperGenius/Classes/d4/d57/classeth_1_1_event_watcher/ title: eth::EventWatcher (class) --- Registers filters and dispatches matching logs to callbacks. Thread-safety: not thread-safe. All calls must be made from the same thread (or externally synchronised). Members: subscriptions_ next_id_ EventWatcher ~EventWatcher EventWatcher operator= EventWatcher operator= watch — Register a new filter+callback pair. unwatch — Remove a previously registered subscription. process_block_logs — Process a slice of logs from a single block and trigger callbacks. process_receipt — Process a single receipt and trigger callbacks for matching logs. subscription_count — Return the number of active subscriptions. --- source: /SuperGenius/Classes/d5/d52/class_evm_messaging_dapp/ title: EvmMessagingDapp (class) --- Members: evmWatcher EvmMessagingDapp start stop --- source: /SuperGenius/Classes/d6/d4c/classsgns_1_1evmwatcher_1_1_evm_messaging_watcher/ title: sgns::evmwatcher::EvmMessagingWatcher (class) --- Members: Context TopicFilter contract_address topic_filters ws_client ws_context chain EvmMessagingWatcher getContractAddress setContractAddress getTopicFilters setTopicFilters setupWebSocketListener getChain startWatching stopWatching parseConfig --- source: /SuperGenius/Classes/dc/d20/structnil_1_1crypto3_1_1pubkey_1_1ext__private__key/ title: nil::crypto3::pubkey::ext_private_key (struct) --- Forward declaration of class. --- source: /SuperGenius/Classes/d9/dd9/structnil_1_1crypto3_1_1pubkey_1_1ext__private__key_3_01ecdsa_3_01_curve_type_00_01_padding_00_04592937b2016ef21d2ba9ad8549745c7/ title: nil::crypto3::pubkey::ext_private_key< ecdsa< CurveType, Padding, GeneratorType, DistributionType >, typename std::enable_if< std::is_same< GeneratorType, random::rfc6979< typename CurveType::scalar_field_type::value_type, typename ecdsa< CurveType, Padding, GeneratorType, DistributionType >::hash_type > >::value >::type > (struct) --- Extended private key class with deterministic generator and operator modifications. Members: private_key_data operator* — Multiplication overload to derive public key from private key multiplication. --- source: /SuperGenius/Classes/df/d7c/structsgns_1_1crdt_1_1_c_r_d_t_data_filter_1_1_filter_callback_entry/ title: sgns::crdt::CRDTDataFilter::FilterCallbackEntry (struct) --- Members: pattern regex filter --- source: /SuperGenius/Classes/d1/d4c/structeth_1_1_finality_decision/ title: eth::FinalityDecision (struct) --- Members: kind block_number confirmation_depth operator bool --- source: /SuperGenius/Classes/db/ddb/structeth_1_1_finality_policy/ title: eth::FinalityPolicy (struct) --- Members: prefer_finalized prefer_safe confirmation_depth --- source: /SuperGenius/Classes/da/d4a/structdiscovery_1_1_fork_id/ title: discovery::ForkId (struct) --- Ethereum EIP-2124 fork identifier used for chain-correctness filtering. Mirrors the go-ethereum forkid.ID type: hash — CRC-32 of the canonical chain's genesis hash XOR'd with all activated fork block numbers up to the current block. next — the next scheduled fork block (0 if none is known). Members: hash — 4-byte CRC-32 fork hash next — next fork block number (0 = none) --- source: /SuperGenius/Classes/dd/dec/structdiscv4_1_1_fork_id/ title: discv4::ForkId (struct) --- Fork identifier per EIP-2124. Mirrors go-ethereum forkid.ID: typeIDstruct{ Hash[4]byte//CRC32checksumofgenesis+appliedforkblocks Nextuint64//Nextupcomingforkblock/timestamp;0=none } Wire encoding inside an ENR eth entry: RLP(enrEntry) = RLP([ RLP([hash4, next]) ]) (outer list = enrEntry struct, inner = ForkId struct) Members: hash — CRC32 checksum of genesis + applied fork blocks. next — Block/timestamp of the next upcoming fork; 0 = none. operator== --- source: /SuperGenius/Classes/dd/d93/structeth_1_1_fork_id/ title: eth::ForkId (struct) --- Members: fork_hash next_fork --- source: /SuperGenius/Classes/d5/d76/structfmt_1_1formatter_3_01sgns_1_1_transaction_manager_1_1_state_01_4/ title: fmt::formatter< sgns::TransactionManager::State > (struct) --- Members: format --- source: /SuperGenius/Classes/df/dd2/classsgns_1_1face_1_1_forward_iterator/ title: sgns::face::ForwardIterator (class) --- As GenericIterator is abstract and cannot be instantiated, there is a concrete object that wraps a pointer to a generic iterator Container over which the iterator would iterate Members: iterator_category pointer const_pointer reference const_reference value_type it_ ForwardIterator ForwardIterator ForwardIterator ~ForwardIterator get_iterator get_iterator operator= operator= operator!= operator== operator* operator-> operator++ --- source: /SuperGenius/Classes/d2/d07/classrlpx_1_1framing_1_1_frame_cipher/ title: rlpx::framing::FrameCipher (class) --- Members: secrets_ impl_ — Pimpl for OpenSSL CTR and hashMAC state. FrameCipher ~FrameCipher encrypt_frame decrypt_header decrypt_frame — Decrypt a complete frame (header + body) in one call. decrypt_frame_body — Decrypt the frame body only, after decrypt_header has already been called. secrets update_egress_mac update_ingress_mac compute_header_mac compute_frame_mac --- source: /SuperGenius/Classes/d0/d8a/structrlpx_1_1framing_1_1_frame_cipher_1_1_frame_cipher_impl/ title: rlpx::framing::FrameCipher::FrameCipherImpl (struct) --- Members: enc dec egress_mac ingress_mac --- source: /SuperGenius/Classes/d9/d0c/structrlpx_1_1framing_1_1_frame_decrypt_params/ title: rlpx::framing::FrameDecryptParams (struct) --- Members: header_ciphertext header_mac frame_ciphertext frame_mac --- source: /SuperGenius/Classes/d3/de7/structrlpx_1_1framing_1_1_frame_encrypt_params/ title: rlpx::framing::FrameEncryptParams (struct) --- Members: frame_data is_first_frame --- source: /SuperGenius/Classes/df/d3e/structrlpx_1_1_frame_header_wire/ title: rlpx::FrameHeaderWire (struct) --- 16-byte RLPx frame header: 3-byte length || 13-byte header-data (RLP list). Members: bytes --- source: /SuperGenius/Classes/d0/ded/structrlpx_1_1auth_1_1_frame_secrets/ title: rlpx::auth::FrameSecrets (struct) --- Members: aes_secret mac_secret egress_mac_seed — Raw bytes written to egress MAC Keccak accumulator. ingress_mac_seed — Raw bytes written to ingress MAC Keccak accumulator. --- source: /SuperGenius/Classes/dc/d90/structsgns_1_1_from_mnemonic/ title: sgns::FromMnemonic (struct) --- Restore from a BIP39 mnemonic. Members: mnemonic --- source: /SuperGenius/Classes/d2/d53/structsgns_1_1_from_private_key/ title: sgns::FromPrivateKey (struct) --- Restore from an Ethereum hex private key. Members: eth_private_key --- source: /SuperGenius/Classes/d6/d1a/structsgns_1_1_from_public_key/ title: sgns::FromPublicKey (struct) --- Load from storage by public address (read-only). Members: public_address --- source: /SuperGenius/Classes/d3/d86/structdiscv5_1_1_gcm_nonce_wire/ title: discv5::GcmNonceWire (struct) --- AES-GCM nonce embedded in the discv5 static header. Members: bytes — 12-byte GCM nonce --- source: /SuperGenius/Classes/d3/dd5/classsgns_1_1face_1_1_generic_iterator/ title: sgns::face::GenericIterator (class) --- An interface for an iterator Container over which the iterator would iterate Members: value_type ~GenericIterator clone get get operator* operator* operator++ operator-> operator!= operator== --- source: /SuperGenius/Classes/d4/dc6/classsgns_1_1face_1_1_generic_list/ title: sgns::face::GenericList (class) --- An interface for a generic list. Members: size_type value_type iterator ~GenericList push_back push_back push_front push_front pop_back pop_front erase begin end empty size --- source: /SuperGenius/Classes/d4/d01/structsgns_1_1storage_1_1face_1_1_generic_map/ title: sgns::storage::face::GenericMap (struct) --- An abstraction over a readable, writeable, iterable key-value map. K key type V value type --- source: /SuperGenius/Classes/da/d5d/structsgns_1_1storage_1_1face_1_1_generic_storage/ title: sgns::storage::face::GenericStorage (struct) --- An abstraction over readable, writeable, iterable key-value storage that supports write batches. K key type V value type --- source: /SuperGenius/Classes/dc/d64/classsgns_1_1_genius_account/ title: sgns::GeniusAccount (class) --- Members: StorageWithAddress SecureStorageFactory — Factory function type for creating secure storage instances. ELGAMAL_PUBKEY_PREDEFINED — Legacy deterministic seed bytes. NONCE_CACHE_DURATION_MS — Cache nonce results for 5 seconds. Blockchain TransactionManager LOCAL_CONFIRMED_TX_HISTORY_LIMIT NONCE_KEY_PREFIX LOCAL_CONFIRMED_TX_HISTORY_KEY_PREFIX token — Token ID of the account. storage_ — Secure storage instance. is_full_node_ — Whether this account is a full node. signer_ — In-memory signing identity. confirmed_nonces_ — Map of the confirmed nonces from peers. nonce_mutex_ — Mutex for the nonce map. pending_nonces_ — Reserved but not confirmed nonces. local_confirmed_nonce_ — Highest locally confirmed nonce. local_confirmed_transactions_ — Recent local confirmed txs. messenger_ — Messenger instance. utxo_manager_ nonce_request_mutex_ — Mutex for nonce request tracking. nonce_request_cv_ — Condition variable for waiting on nonce requests. nonce_request_in_progress_ — Flag indicating if a nonce request is in progress. cached_nonce_result_ — Cached result from in-progress request. cached_nonce_timestamp_ — Timestamp when cached nonce was obtained. get_cids_mutex_ — Mutex for the genesis method. get_cids_method_ — Function to get blockchain CIDs. has_cid_method_ — Function to check CID presence. get_utxos_method_ — Function to get UTXOs for an address. get_validator_weight_method_ — Function to get validator weight for an address. get_transaction_cid_method_ — Function to get transaction CID by hash. nonce_db_mutex_ — Mutex for nonce database pointer access. nonce_db_ — RocksDB for nonce persistence. SetSecureStorageFactory — Sets the secure storage factory used by all GeniusAccount factory methods. GetSecureStorageFactory — Returns the current secure storage factory (default if none set). New — Try creating an account by first loading it from storage, and if failure, create one with NewFromRandomMnemonic. NewEphemeral — Create a fresh account whose key exists only in memory. NewFromPrivateKey — Creates an account from an Ethereum private key. NewFromPublicKey — Creates an account by loading directly from storage. If the account wasn't previously stored, returns nullptr. NewFromMnemonic — Creates an account from a BIP39 mnemonic phrase. NewFromRandomMnemonic — Creates an account with a newly generated random BIP39 mnemonic. GetAvailableAccounts DeleteAccount NormalizeAddress — Strips the "0x" prefix from an address if present. Stored addresses are prefix-free; this normalizes user input for lookups. IsValidPublicKey — Validates that a string is a valid 512-bit public key in hex format. A valid key is exactly 128 hex characters with no prefix. VerifySignature — Verify a signature using the Genius account's public key. VerifySignature — Verify a byte-vector signature using the Genius account's public key. GenerateGeniusAddress GenerateGeniusAddress InitMessenger — Initialize the messenger for the account. ConfigureDatabaseDependencies — Configures database dependencies: nonce store, block response handler, head request handler, and block CID lookup method. DeconfigureDatabaseDependencies — Clears handlers and methods set by ConfigureDatabaseDependencies. ~GeniusAccount — Destroy the Genius Account object. GetAddress — Get the Address object. GetToken — Get the account's token. GetNonce — Get the proposed (next available) nonce as a string. Sign — Sign data using the Genius account's private key. CreateInputsFromUTXOs — Build signed transaction inputs from UTXOs. SetPeerConfirmedNonce — Set the confirmed nonce for an address. RollBackPeerConfirmedNonce — Rollback the confirmed nonce for the given address. Also rolls back local confirmed nonce and tx history when the address is local. GetPeerNonce — Get the confirmed nonce for a peer. GetLocalConfirmedNonce — Get the local confirmed nonce. GetLocalConfirmedTxHash — Get a locally persisted confirmed transaction hash by nonce. GetConfirmedNonce — Get confirmed nonce from the network. FetchNetworkNonce — Fetch the latest nonce from the network without relying on cached values. GetProposedNonce — Get the next available nonce without reserving it. ReserveNextNonce — Reserve the next available nonce. ReleaseNonce — Release a previously reserved nonce. RequestGenesis RequestAccountCreation RequestValidatorRegistry RequestRegularBlock RequestTransaction RequestUTXOs — Request UTXOs for a specific address and return the selected response. RequestHeads — Request heads broadcast for specific topics. SaveInSecureStorage LoadFromSecureStorage GetUTXOManager GetUTXOManager SetGetBlockChainCIDMethod ClearGetBlockChainCIDMethod SetHasBlockCidMethod ClearHasBlockCidMethod SetGetValidatorWeightMethod ClearGetValidatorWeightMethod SetGetTransactionCIDMethod ClearGetTransactionCIDMethod SetNonceStore LoadGeniusAccount LoadGeniusAccount CreateInstanceFromResponse SerializeConfirmedTxHistory DeserializeConfirmedTxHistory LoadConfirmedNonces PersistConfirmedNonce UpdateLocalConfirmedTxHistoryLocked RollbackLocalConfirmedTxHistoryLocked GetNextNonceLocked GeniusAccount — Private constructor for a new GeniusAccount. --- source: /SuperGenius/Classes/d6/d8b/classsgns_1_1_genius_assigner/ title: sgns::GeniusAssigner (class) --- Members: AssignerError TableDescriptionType PlonkConstraintSystemType PlonkAssignTableType PrintTableKind BlueprintFieldType AssignerEndianess ArithmetizationType ConstraintSystemType AssignmentTableType WITNESS_COLUMNS PUBLIC_INPUT_COLUMNS COMPONENT_CONSTANT_COLUMNS LOOKUP_CONSTANT_COLUMNS COMPONENT_SELECTOR_COLUMNS LOOKUP_SELECTOR_COLUMNS STACK_SIZE LOG_LEVEL MAX_NUM_PROVERS TARGET_PROVER POLICY CHECK_VALIDITY gen_mode_ assigner_instance_ GeniusAssigner ~GeniusAssigner GenerateCircuitAndTable GenerateCircuitAndTable PrintCircuitAndTable GetPlonkTableDescription BuildPlonkAssignmentTable GetTableVectors BuildPlonkConstraintSystem FillVectorValue GetUsableRowsAmount --- source: /SuperGenius/Classes/dd/d55/classsgns_1_1_genius_input_validator/ title: sgns::GeniusInputValidator (class) --- Validator for native Genius-chain transactions. Members: ValidateUTXOParameters — Validates UTXO ownership and signatures for Genius-native inputs. ValidateWitness — Validates witness data against Genius-chain consensus state. RequiresConsensusUTXOData — Genius-native validation requires consensus UTXO context. Register --- source: /SuperGenius/Classes/d1/d00/classsgns_1_1_genius_node/ title: sgns::GeniusNode (class) --- High-level facade that initializes and coordinates account, networking, transaction, blockchain, and processing subsystems. Members: NodeState — Lifecycle states reported while the node is bootstrapping. Error — Error codes returned by GeniusNode operations. NodeType — Deployment node role, read from sgns_config.json ("node_type"). TIMEOUT_ESCROW_PAY — Escrow payout timeout. TIMEOUT_TRANSFER — Transfer timeout. TIMEOUT_MINT — Mint timeout. TransactionSyncTest MultiAccountTestAccess GeniusNodeTestAccess write_base_path_ — Base path for node databases, logs, and account storage. account_ — Active account used by node services. io_ — Shared IO context for async services. io_work_guard_ — Keeps io_ alive. tx_globaldb_ — Transaction/global state CRDT DB. pubsub_ — PubSub networking service. bitswap_event_bus_ — Event bus for bitswap. bitswap_ — IPFS bitswap service for content-addressed data. transaction_manager_ — Transaction service. migration_manager_ — Migration engine (valid during MIGRATING_DATABASE). migration_mutex_ — Guards migration_manager_ reads from const methods. eth_watch_service_ — Shared EVM event watcher. bridge_relayer_ — Bridge burn→mint relayer. task_queue_ — Processing task queue. my_task_ids_ — Recent task IDs submitted by this node (capped in memory). processing_core_ — Processing engine core. processing_service_ — Processing network service. task_result_storage_ — Subtask result store. logging_system_ — libp2p logging system. autodht_ — Whether DHT discovery is enabled. isprocessor_ — Whether processing service should run. is_full_node_ — Whether this node runs in full-node mode. node_type_ — Role from sgns_config.json (default Light; derived in the AccountSource ctor). node_logger_ — Main node logger. dev_config_ — Runtime node configuration. ipfs_cache_dir_ — Directory for IPFS block flat-file cache. mirror_results_ — Whether to mirror processing results from other nodes. result_retention_hours_ — Hours to retain results before GC (0 = keep forever). result_retention_max_mb_ — Max MB for result cache (0 = no space cap). catchup_chains_ — Populated by OnRpcEndpointsReady for catch-up scan (D-02). catchup_mutex_ rpc_endpoint_provider_ — Shared so the posted Initialize() job can hold it across an account switch. catchup_watcher_ — Polling watcher that scans historical blocks for bridge burns (replaces PerformStartupCatchupScan). chainlist_fetcher_ bridge_init_generation_ gnus_network_full_path_ — Versioned network DB path. processing_channel_topic_ — Processing task channel topic. processing_grid_chanel_topic_ — Processing grid topic. subnet_id_ rpc_catchup_ — Starts the catchup scan watcher at bridge init (default true). Set false in sgns_config.json to disable. bootstrap_peers_ bootstrap_fullnodes_ trusted_peers_genesis_ — Genesis trusted-peer list (BURN-02/BURN-03). bootstrapper_node_address_ trusted_peer_quorum_threshold_ burn_config_quorum_threshold_ — Quorum threshold for BurnConfig updates; 0 = unset (defaulted the same way). bootstrap_fullnode_infos_ bootstrap_fullnode_ids_ bootstrap_peer_infos_ bootstrap_peer_ids_ pubsubport_ — Active PubSub TCP port. blockchain_ — Blockchain service. secure_crdt_ — BURN-02: quorum-signing wrapper. trusted_peer_registry_ — BURN-02: signer-set source. burn_config_ — BURN-02/BURN-03: live burn-rate source. gc_timer_ — Periodic GC timer for result cache cleanup. m_tokenPriceCache — Cached token price data by token id. m_cacheValidityDuration — Price cache TTL. m_lastApiCall — Last external price API call time. io_thread_count_ — IO thread count. io_threads_ — Threads running io_. upnp_thread — Background UPnP refresh thread. stop_upnp — UPnP thread stop flag. base58key_ — Base58 key suffix for DB paths. scheduler_ — libp2p scheduler. generator_ — GraphSync request ID generator. graphsyncnetwork_ — GraphSync network. state_ — Current node lifecycle state. shutdown_started_ — Whether shutdown has been initiated. reconnect_config_ bootstrap_disconnect_subscription_ health_check_handle_ reconnect_attempts_ reconnect_mutex_ crdt_backup_config_ kMyTasksMemoryLimit — Max task IDs kept in my_task_ids_. MIN_API_CALL_INTERVAL — Minimum price API interval. DEFAULT_IO_THREADS — Default IO thread count. DB_PATH — Blockchain DB path format. MAIN_NET — Main network identifier. TEST_NET — Test network identifier. MAX_NODES_COUNT — Processing service node count limit. PROCESSING_GRID_CHANNEL — Processing job topic. PROCESSING_CHANNEL — Processing result topic. GNUS_NETWORK_PATH — Base network DB path. New — Canonical node factory (INTF-01). Account identity is chosen via AccountSource; node role (is_full_node_) is derived from node_type in sgns_config.json, not a param. Old factories are retained this phase (deleted in Phase 3 per 02-CONTEXT.md D-01). WriteNetworkConfig — Writes a minimal network_config.json for test/example setup (MIG-02). WriteSgnsConfig — Writes a minimal sgns_config.json for test/example setup; validates node_type (MIG-02). GetBurnBasisPoints — Basis points of an escrow payout burned to the zero address during release. GetBasisPointsTotal — Total basis points denominator used with GetBurnBasisPoints. ~GeniusNode — Stops node services, joins background threads, and releases processing callbacks. GetAvailableAccounts — Lists the account addresses currently available in local storage. GetPubsubPort — Returns the resolved PubSub listening port. IsAutodhtEnabled — Returns whether DHT discovery is enabled after config resolution. IsFullNode — Returns whether this node runs in full-node mode after config resolution. GetNodeType — Returns the resolved node role. AddAccountWithKey — Adds an account to local storage using an Ethereum private key. AddAccountWithMnemonic — Adds an account to local storage using a BIP39 mnemonic phrase. AddAccountWithRandomMnemonic — Adds an account to local storage using a newly generated random BIP39 mnemonic. SelectAccount — Selects the active account for subsequent node operations. TransferAccount — Transfers node ownership to another stored account address. DeleteAccount — Deletes a locally stored account. MergeAccount — Merges the active account into another stored account. SetPayoutAddress — Updates the payout address used by processing rewards. ProcessImage — Submits an image-processing request described by JSON input. GetMyTaskIds — Returns the task IDs of jobs submitted by the active account. GetTaskResult — Retrieves the completed result for a specific job by its task ID. GetProcessCost — Estimates the GNUS cost of a processing request manager. GetGNUSPrice — Retrieves the current GNUS market price from the configured pricing service. GetName — Returns the component name used by the component framework. GetVersion — Returns the full SuperGenius version string. LoadLogConfig MintTokens — Creates and submits a mint transaction. MintTokens — Creates a mint transaction and waits for it to finalize. AddPeer — Adds a peer to PubSub and starts connecting to it. AddPeers — Adds peers to PubSub and starts connecting to them. RefreshUPNP — Starts or restarts the background UPnP port refresh thread. GetBalance — Returns the active account balance across all tokens. GetBalance — Returns the active account balance for a token. GetBalance — Returns an address balance across all tokens. GetBalance — Returns an address balance for a token. GetInTransactions — Returns serialized incoming transactions known to the transaction manager. GetOutTransactions — Returns serialized outgoing transactions known to the transaction manager. CountTransactions — Counts known transactions filtered by optional status. GetAddress — Returns the active account public address. GetMnemonicOfActiveAccount — Retrieves the BIP39 mnemonic of the active account from secure storage. GetTokenID — Returns the configured child token identifier. GetInitializationStatus — Returns the current node initialization progress as a percentage and description. The percentage ranges from 0.0 (CREATING) to 1.0 (READY), with sub-progress reported during database migration and transaction manager initialization. GetProcessingStatus — Returns the current processing service status. TransferFunds — Transfers funds and waits for the transaction to finalize. TransferFunds — Transfers funds without waiting for finalization. PayDev — Transfers funds to the configured developer address. PayDev — Transfers funds to the configured developer address and waits for finalization. WaitForFinalized — Waits until an outgoing transaction reaches a terminal state. IsFinalized — Checks whether an outgoing transaction has reached a terminal state. GetPubSub — Returns the underlying PubSub service. ResetProcessingMembers — Releases processing service, core, queue, and result-storage references. FormatTokens — Formats a fixed-point amount into a human-readable string. ParseTokens — Parses a human-readable string into a fixed-point amount. PrintDataStore — Prints the transaction GlobalDB datastore for debugging. StopProcessing — Stops the processing service if it is initialized. StartProcessing — Starts the processing service on the configured processing grid channel. GetCoinprice — Retrieves current USD prices for token identifiers, using a short local cache. GetCoinPriceByDate — Retrieves historical USD prices for token identifiers at exact timestamps. GetCoinPricesByDateRange — Retrieves historical USD prices for token identifiers over a date range. WaitForTransactionIncoming — Waits for an incoming transaction to be processed. WaitForTransactionOutgoing — Waits for an outgoing transaction to be processed. WaitForEscrowRelease — Waits until an escrow hold output is consumed. GetTransactionManagerState — Returns the current transaction manager lifecycle state. GetTransactionManager — Returns the transaction manager when initialized. ConfigureRpcEndpoint — Configures RPC endpoints for a specific EVM chain on the public-chain input validator. SetChainlistFetcher — Injects a custom chainlist fetcher for RPC endpoint discovery (test injection point). GetTransactionStatus — Returns a tracked transaction status by transaction hash. SetAuthorizedFullNodeAddress — Sets the authorized full-node address for blockchain genesis verification. GetAuthorizedFullNodeAddress — Gets the current authorized full-node public address. GetState — Returns the current GeniusNode lifecycle state. SendTransactionAndProof — Enqueues a transaction and its proof directly through the transaction manager. GeniusNode — Constructs a node, creating the account from source AFTER LoadSgnsConfig() resolves node_type_ -> is_full_node_ (the init-order hinge fix, INTF-03). InitOpenSSL — Initializes OpenSSL library state used by networking dependencies. LoadSgnsConfig — Loads sgns_config.json which contains net_id, subnet_id, bootstrap_fullnodes, authorized_full_node, and is_processor. All fields are optional and default to safe values (DEV net, empty bootstrap, is_processor=true). StartResultGC — Starts periodic garbage collection of expired processing results from disk cache. RunResultGC — Runs one GC pass: evicts expired result files and enforces space cap. InitLoggers — Initializes application and dependency loggers. ConfigureLogger — Creates a tagged logger with the requested sink and level. InitNetwork — Initializes PubSub, GraphSync networking, and optional DHT discovery. LoadCrdtConfig — Loads the CRDT configuration. InitUPNP — Attempts initial UPnP port mapping for the PubSub port. InitDatabase — Initializes and starts the transaction GlobalDB. InitProcessingModules — Initializes processing queue, core, and result storage components. BeginDBInitialization — Begins the asynchronous database migration and initialization state flow. StateTransition — Moves the node to the next lifecycle state and runs state-specific work. MigrateDatabase — Runs versioned database migrations on a detached thread. ScheduleMigrationRetry — Schedules a delayed migration retry after migration bootstrap failure. ScheduleBlockchainRetry — Schedules a delayed blockchain initialization retry. ResolveBridgeChainsConfigPath — Resolves the bridge_chains_config.json path using D-01 priority: BaseWritePath → binary-relative → CWD fallback. InitializeAndStartBridge — Async bridge initialization launched from INITIALIZING_TRANSACTIONS. OnRpcEndpointsReady — IBridgeInitObserver callback — stores chain list for catch-up scan. ShutdownForDestruction — Shuts down node services: cancels health-check timer, unsubscribes disconnect events, and stops the transaction GlobalDB. ShutdownAccountBoundServices — Stops account-bound runtime services in dependency order. ResetQuorumMembers — Unregisters and releases quorum services while GlobalDB and account dependencies are alive. ReleaseRuntimeMembersAfterIoStopped — Releases the runtime object graph after all node I/O threads have stopped. CreateEscrowInfoCRDTTransaction DHTInit — Starts DHT provider discovery for the processing grid topic. ConnectPeer — Connect to a peer on the PubSub I/O thread, retrying transient failures. InitBootstrapReconnect — Subscribe to libp2p disconnect events for bootstrap fullnodes. StartBootstrapHealthCheck — Start the periodic health-check polling for bootstrap fullnode connections. ScheduleBootstrapReconnect — Schedule a reconnection attempt with exponential backoff. DoReconnectToBootstrapPeer — Perform the actual reconnection to a bootstrap peer. ScheduleNextHealthCheck — Schedule the next periodic health check. PerformHealthCheck — Perform a health check on all bootstrap fullnode connections. ProcessingDone — Handles successful processing completion and triggers escrow payout. ProcessingError — Handles processing failure notifications. RotateLogFiles — Rotates existing node log files before logger initialization. ParseBlockSize — Parse and sum all "block_len" values from the JSON. TransactionStateChanged — Reacts to transaction manager state changes by starting or stopping processing. MyTasksFilePath — Returns the path to the local task-ID persistence file. LoadMyTaskIds — Loads previously-submitted task IDs from the local JSON file. PersistMyTaskIds — Writes the current task ID list to the local JSON file. ParsePeerInfoFromString — Parse a multiaddr string into a PeerInfo, replicating ipfs_pubsub::PeerInfoFromString. GetLoggingSystem — Builds the YAML logging configuration used by the node. --- source: /SuperGenius/Classes/d0/d7f/structsgns_1_1_genius_prover_1_1_genius_proof/ title: sgns::GeniusProver::GeniusProof (struct) --- Members: proof constrains table GeniusProof --- source: /SuperGenius/Classes/da/da5/classsgns_1_1_genius_prover/ title: sgns::GeniusProver (class) --- Prover class of SuperGenius. Members: ProverError ProofSnarkType ProofType ConstraintMarshallingType PlonkMarshalledTableType ParameterType BlueprintFieldType HashType ProverEndianess ConstraintSystemType TableDescriptionType PlonkColumn AssignmentTableType PublicTableType LpcParams Lpc LpcScheme FriParams CircuitParams PlaceholderParams PublicPreprocessor PublicPreprocessedData PrivatePreprocessor PrivatePreprocessedData ProverType PlonkTablePair COMPONENT_CONSTANT_COLUMNS_DEFAULT EXPAND_FACTOR_DEFAULT GeniusProver — Constructs a GeniusProver with default settings. CreateProof CreateProof WriteProofToFile WriteProofToVector VerifyProof VerifyProof VerifyProof MakePlonkConstraintSystem MakePlonkTableDescription MakeFRIParams GenerateRandomStepList FillPlaceholderProof --- source: /SuperGenius/Classes/df/df2/classsgns_1_1_genius_signer/ title: sgns::GeniusSigner (class) --- Owns a Genius keypair without imposing account persistence or lifecycle concerns. GeniusAccount composes this type, while short-lived signing workflows can use it directly without touching secure storage. The keypair is held as a raw secp256k1 secret key so that this component depends only on libsecp256k1, not on the crypto3-based ProofSystem. Members: PrivateKey — Big-endian secp256k1 secret key, matching libsecp256k1's own encoding. PRIVATE_KEY_SIZE SIGNATURE_SIZE private_key_ address_ — Derived once on construction; empty on an invalid key. Generate — Generate a fresh, in-memory-only keypair. VerifySignature — Verify a canonical Genius signature. VerifySignature — Verify a canonical Genius signature supplied as bytes. GeniusSigner — Take ownership of an existing secret key. GetAddress — Return the 128-character hexadecimal Genius public address. Sign — Sign bytes using the canonical Genius signature encoding. --- source: /SuperGenius/Classes/d6/dc8/classsgns_1_1_genius_transaction/ title: sgns::GeniusTransaction (class) --- Base class of the GeniusTransaction. Members: TransactionDeserializeFn — Alias for the de-serializer method type to be implemented in derived classes. GENIUS_CHAIN_ID — The chain ID used for transactions that are not associated with a specific external chain. dag_st — The DAG metadata struct that is included in all transactions, containing common fields such as source address, hashes, timestamp, nonce, and signature. deserializers_map — Static map that holds registered deserializer functions for different transaction types, allowing dynamic deserialization based on the type field in the DAG metadata. transaction_type — The transaction type string that identifies the specific type of transaction (e.g., "transfer", "mint", "escrow-hold"). GeniusTransaction — Constructs a GeniusTransaction with the specified type and DAG metadata. ~GeniusTransaction — Virtual destructor to avoid leakage when deleting derived classes through a base pointer. GetType — Returns the transaction type. SerializeByteVector — Serializes the transaction into a byte vector, including the DAG metadata. SerializeToEmbeddedTransaction — Serializes the transaction into an EmbeddedTransaction proto with the appropriate oneof field set. SerializeToEmbeddedTransaction — Serializes using internal DAG metadata. SerializeByteVector — Serializes the transaction using the internal DAG metadata. HasUTXOParameters — Returns if transaction supports UTXOs. GetUTXOParametersOpt — Returns the UTXOs. GetChainId — Returns the source chain id for input validation routing. GetTransactionSpecificPath — Returns the transaction-specific path component for storage and retrieval. GetTransactionFullPath — Returns the full storage path for the transaction based on its hash. GetProofFullPath — Returns the full storage path for the proof based on the transaction hash. GetSrcAddress — Returns the source address for the transaction. GetHash — Returns the hash of the transaction. GetPreviousHash — Returns the hash of the previous transaction. GetUncleHash — Returns the hash of the uncle transaction. GetTimestamp — Returns the timestamp of the transaction. GetNonce — Returns the nonce of the transaction. GetTopics — Returns the destination topics associated with the transaction. FillHash — Fills the data hash field in the DAG metadata based on the transaction content. CheckHash — Checks the integrity of the transaction by verifying that the hash field matches the calculated hash. MakeSignature — Creates a signature for the transaction using the provided GeniusAccount. CheckSignature — Verifies the transaction signature using the source address and the serialized transaction content. CheckDAGSignatureLegacy — Legacy method to verify the transaction signature using the DAG metadata. This method may be used for backward compatibility with older transaction formats. GetSlotID — Generates a slot ID used by consensus to identify competing transactions. DeSerializeDAGStruct — Deserializes the DAG metadata from a byte vector. DeSerializeDAGStruct — Deserializes the DAG metadata from a string. SetDAGWithType — Sets the transaction type in the DAG metadata and returns the modified DAGStruct. GetTransactionFullPath — Returns the full storage path for the transaction based on its hash. RegisterDeserializer — Registers a deserializer function for a specific transaction type. GetDeSerializers — Returns the map of registered deserializer functions for transaction types. --- source: /SuperGenius/Classes/da/da7/classsgns_1_1_genius_u_t_x_o/ title: sgns::GeniusUTXO (class) --- Immutable-style UTXO value object containing ownership, token, amount, and outpoint metadata. Members: outpoint_ — Producing transaction hash and output index. amount_ — Amount carried by the output. token_id_ — Token identifier carried by the output. owner_address_ — Address that owns or can spend the output. GeniusUTXO — Constructs an empty UTXO placeholder. GeniusUTXO — Constructs a UTXO without an owner address. GeniusUTXO — Constructs a fully specified UTXO. SetOwnerAddress — Sets the owner address associated with this UTXO. GetOwnerAddress — Returns the owner address associated with this UTXO. GetOutPoint — Returns the full outpoint descriptor. GetTxID — Returns the originating transaction id. GetOutputIdx — Returns the output index within the originating transaction. GetAmount — Returns the unencrypted amount represented by the UTXO. GetTokenID — Returns the token identifier associated with the UTXO. --- source: /SuperGenius/Classes/d3/dcd/structeth_1_1_get_block_bodies_message/ title: eth::GetBlockBodiesMessage (struct) --- Request for block bodies by hash (message id 0x05). Members: request_id block_hashes --- source: /SuperGenius/Classes/de/d19/structeth_1_1_get_block_headers_message/ title: eth::GetBlockHeadersMessage (struct) --- Members: request_id start_hash start_number max_headers skip reverse --- source: /SuperGenius/Classes/dd/dee/structeth_1_1_get_pooled_transactions_message/ title: eth::GetPooledTransactionsMessage (struct) --- Members: request_id transaction_hashes --- source: /SuperGenius/Classes/d0/d41/structeth_1_1_get_receipts_message/ title: eth::GetReceiptsMessage (struct) --- Members: request_id block_hashes --- source: /SuperGenius/Classes/da/d32/classsgns_1_1crdt_1_1_global_d_b/ title: sgns::crdt::GlobalDB (class) --- Members: Error — Enumeration of error codes used in the proof classes. Buffer QueryResult RocksDB CRDTHeadListResult DataPair — Pair of key and value to be stored in CRDT. GlobalDBFilterCallback — CRDT Filter callback type. GlobalDBNewElementCallback GlobalDBDeletedElementCallback m_context m_databasePath m_dagSyncPort m_graphSyncAddrs m_pubsub m_broadcaster m_datastore started_ cid_sync_started_ cid_receiving_started_ head_broadcasting_started_ backup_options_ backup_directory_ stop_backup_thread_ shutdown_started_ backup_thread_ backup_wait_mutex_ backup_wait_cv_ obsAddrRetries m_crdtDatastore lifecycle_mutex_ — Guards service pointers during shutdown. m_logger New — Factory method to create a GlobalDB instance. ~GlobalDB — Destructor or GlobalDB. Put — Puts key-value pair to the CRDT store, optionally specifying a broadcast topic. Put — Writes a batch of CRDT data all at once. Get Remove QueryKeyValues QueryKeyValues — Queries with a middle part that can be a wildcard, negated string or normal string. KeyToString BeginTransaction AddBroadcastTopic AddTopicName AddListenTopic PrintDataStore GetDataStore GetBroadcaster GetWorkJournal RegisterElementFilter RegisterNewElementCallback RegisterDeletedElementCallback UnregisterElementFilter UnregisterNewElementCallback — Unregisters the new element callback for a pattern. UnregisterDeletedElementCallback — Unregisters the deleted element callback for a pattern. Start — Starts the GlobalDB instance. ShutdownNow — Immediately quiesce and shut down CRDT intake and workers. Safe to call multiple times. StartCIDReceiving — Starts receiving CIDs. StartCICSync — Starts CIC synchronization. StartRebroadcastHeads — Starts rebroadcasting heads. GetCRDTHeadList GetCRDTHeadHeight CRDTHeadRemove CRDTHeadAdd GetCIDJobStatus RequestHeadBroadcast — Request head broadcast for specified topics. GetMonitoredTopics — Get the topics that are being listened to. GetCRDTDataStore GetCIDContent GlobalDB — Constructs a new Global D B object. Init — Initializes the GlobalDB instance by creating the CRDT datastore and broadcaster. scheduleBootstrap ActiveCRDTDataStore ActiveBroadcaster ResolveBackupDirectory — Resolves the backup directory path based on the database path. CreateBackupNow — Creates a backup immediately. StartBackupLoop — Starts the backup loop in a separate thread. StopBackupLoop — Stops the backup loop and waits for the thread to finish. --- source: /SuperGenius/Classes/d0/d05/classsgns_1_1crdt_1_1_graphsync_d_a_g_syncer/ title: sgns::crdt::GraphsyncDAGSyncer (class) --- A DAGSyncer is an abstraction to an IPLD-based p2p storage layer. A DAGSyncer is a DAGService with the ability to publish new ipld nodes to the network, and retrieving others from it. Members: Error IpfsDatastore Graphsync ResponseMetadata Extension ResponseStatusCode Multiaddress Multihash PeerId Subscription Logger BlockCallback PeerKey PeerEntry RouteMapType TIMEOUT_SECONDS MAX_FAILURES started_ unexpected_blocks dagMutex_ dagService_ graphsync_ host_ logger_ requests_ peer_registry_ peer_index_ registry_mutex_ routing_ routing_mutex_ blacklist_ blacklist_mutex_ cid_failures_ cid_failures_mutex_ request_status_ request_status_mutex_ received_blocks_ lru_cid_cache_ is_stopped_ GraphsyncDAGSyncer ~GraphsyncDAGSyncer Listen StartSync AddRoute addNode getNode removeNode select fetchGraph fetchGraphOnDepth HasBlock GetNodeWithoutRequest GetNodeFromMerkleDAG TraverseCIDsLinks markResolved isResolved GetId GetPeerInfo AddToBlackList IsOnBlackList InitCIDBlock IsCIDInCache DeleteCIDBlock Stop RequestNode RequestProgressCallback BlockReceivedCallback StopSync RegisterPeer GetPeerById AddCIDBlock GrabCIDBlock BlackListPeer GetRouteKeys GetRoute MoveRoutePeerToFront EraseRoutesFromPeerID EraseRoute SetRequestStatus GetRequestStatus ClearRequestStatus RecordSuccessfulConnection — record successful connections RecordCIDFailure — CID-specific failure tracking methods. HasRecentCIDFailure ClearCIDFailure IsConnectionFailureStatus GetCurrentTimestamp getBackoffTimeout — Using exponential backoff for both cases but with different base values. --- source: /SuperGenius/Classes/d0/d2d/structrlpx_1_1auth_1_1_handshake_config/ title: rlpx::auth::HandshakeConfig (struct) --- Members: local_public_key local_private_key client_id listen_port peer_public_key --- source: /SuperGenius/Classes/d1/d9f/structrlpx_1_1auth_1_1_handshake_result/ title: rlpx::auth::HandshakeResult (struct) --- Members: key_material frame_secrets peer_client_id peer_listen_port transport — Socket to hand off to MessageStream after handshake. keys secrets --- source: /SuperGenius/Classes/d9/d75/structstd_1_1hash_3_01sgns_1_1base_1_1_blob_3_01_n_01_4_01_4/ title: std::hash< sgns::base::Blob< N > > (struct) --- Members: operator() --- source: /SuperGenius/Classes/d0/dcb/structstd_1_1hash_3_01sgns_1_1base_1_1_buffer_01_4/ title: std::hash< sgns::base::Buffer > (struct) --- Members: operator() --- source: /SuperGenius/Classes/d4/d33/structstd_1_1hash_3_01sgns_1_1base_1_1_wrapper_3_01_t_00_01_tag_01_4_01_4/ title: std::hash< sgns::base::Wrapper< T, Tag > > (struct) --- Members: operator() --- source: /SuperGenius/Classes/dd/d53/structrlp_1_1_header/ title: rlp::Header (struct) --- Members: list payload_size_bytes header_size_bytes --- source: /SuperGenius/Classes/d1/da4/structrlpx_1_1protocol_1_1_hello_message/ title: rlpx::protocol::HelloMessage (struct) --- Members: protocol_version client_id capabilities listen_port node_id encode decode --- source: /SuperGenius/Classes/d6/dfe/classsgns_1_1crdt_1_1_hierarchical_key/ title: sgns::crdt::HierarchicalKey (class) --- A Key represents the unique identifier of an object, inspired by file systems and Google App Engine key model. Keys are meant to be unique across a system. Keys are hierarchical, incorporating more and more specific namespaces. Thus keys can be deemed 'children' or 'ancestors' of other keys:: Key("/Comedy") Key("/Comedy/MontyPython") Also, every namespace can be parametrized to embed relevant object information. For example, the Key name (most specific namespace) could include the object type:: Key("/Comedy/MontyPython/Actor:JohnCleese") Key("/Comedy/MontyPython/Sketch:CheeseShop") Key("/Comedy/MontyPython/Sketch:CheeseShop/Character:Mousebender") Members: key_ HierarchicalKey HierarchicalKey SetKey GetKey ChildString — Appends s to the key. GetList IsTopLevel operator== operator!= --- source: /SuperGenius/Classes/dc/de2/classrlpx_1_1crypto_1_1_hmac/ title: rlpx::crypto::Hmac (class) --- Members: Hmac compute compute_mac verify --- source: /SuperGenius/Classes/d9/dbe/classsgns_1_1_i_basic_proof/ title: sgns::IBasicProof (class) --- Base proof class header file. This class provides methods for generating full proofs and verifying them, along with virtual methods for derived proofs Members: Error — Enumeration of error codes used in the proof classes. PublicParamDeserializeFn — Alias for the de-serializer method type to be implemented in derived classes. PublicParamDeSerializers — A map of deserialization functions for public parameters by proof type. ByteCodeMap — A map of bytecodes associated with each proof type. bytecode_payload_ — The bytecode generated by the modified clang. IBasicProof — Constructs a proof and informs the bytecode that will be used. ~IBasicProof — Virtual destructor for IBasicProof. GetProofType — Pure virtual function to get the proof type. GenerateFullProof — Generates a full proof using the internal class values. VerifyFullProof — Verifies the proof with the public parameters. VerifyFullProof — Verifies the proof with parameters and bytecode. GenerateIntParameter — Generates a JSON object for an integer parameter. GenerateArrayParameter — Generates a JSON object for an array parameter. GenerateFieldParameter — Generates a JSON object for a field parameter. RegisterDeserializer — Registers a deserializer function for a specific proof type. RegisterBytecode — Registers a bytecode for a specific proof type. DeSerializeBaseProof — Deserializes a BaseProofProto from the provided proof data. SerializeFullProof — Pure virtual function to serialize a full proof using the snark and internal public parameters. GenerateProof — Generates the base proof (snark) structure using the internal class data. GenerateJsonParameters — Pure virtual function to generate the parameters in JSON form. --- source: /SuperGenius/Classes/d7/db1/classsgns_1_1_i_bridge_init_observer/ title: sgns::IBridgeInitObserver (class) --- Observer interface notified when RPC endpoints have been loaded and wired. Subscribers (e.g. BridgeRelayer) implement this interface and call ChainRpcEndpointProvider::AddObserver() before Initialize() is posted to the io_context. The callback fires synchronously inside Initialize() after all endpoints are wired and IInputValidator::Register has been called for each discovered chain. Members: OnRpcEndpointsReady — Called when RPC endpoint initialization completes successfully. ~IBridgeInitObserver --- source: /SuperGenius/Classes/d1/dbf/class_i_component/ title: IComponent (class) --- Members: ~IComponent GetName --- source: /SuperGenius/Classes/d0/d47/class_i_component_factory/ title: IComponentFactory (class) --- Members: ~IComponentFactory Register GetComponent --- source: /SuperGenius/Classes/d4/d4b/classeth_1_1_i_eth_receipt_source/ title: eth::IEthReceiptSource (class) --- Transport-neutral source of receipt/log evidence for EthWatchService. Members: ~IEthReceiptSource add_filter — Let the source optimize acquisition around the same filter used by EthWatchService. remove_filter — Remove a previously registered acquisition filter. set_receipt_batch_handler — Set the handler that receives normalized receipt batches. get_receipt — Fetch one receipt by transaction hash when the source supports lookup verification. --- source: /SuperGenius/Classes/d5/d94/classeth_1_1_i_eth_session_channel/ title: eth::IEthSessionChannel (class) --- Minimal session-facing seam used by ETH runner logic and tests. Members: ~IEthSessionChannel negotiated_eth_version negotiated_eth_offset peer_info post_message receive_message receive_message_with_timeout set_eth_message_handler --- source: /SuperGenius/Classes/de/d6f/classsgns_1_1_i_input_validator/ title: sgns::IInputValidator (class) --- Strategy interface for validating transaction inputs and their witness data. Members: ValidatorPtr ~IInputValidator — Destroys the input validator. ValidateUTXOParameters — Validates ownership and structure of the supplied UTXO parameters. ValidateWitness — Validates the chain-specific witness data associated with a transaction input set. RequiresConsensusUTXOData — Indicates whether this validator requires consensus-provided UTXO data. Register — Register a validator for a chain if the chain is currently unowned. UnregisterIf — Remove a chain's registration only if it currently points to expected (compare-and-remove). This prevents a non-owner from removing the current registration and lets a validator self-clean on destruction. Get registryState --- source: /SuperGenius/Classes/d7/d29/classsgns_1_1sgprocessing_1_1_image_splitter/ title: sgns::sgprocessing::ImageSplitter (class) --- Members: splitparts_ partwidth_ partheight_ blockstride_ blocklinestride_ blocklen_ channels_ inputImage imageSize chunkWidthActual_ chunkHeightActual_ cids_ ImageSplitter ImageSplitter ImageSplitter ImageSplitter ~ImageSplitter GetPart GetPartByCid GetPartSize GetPartStride GetPartWidthActual GetPartHeightActual GetPartCount GetImageSize GetPartCID SplitImageData --- source: /SuperGenius/Classes/d5/d0d/classsgns_1_1_i_migration_step/ title: sgns::IMigrationStep (class) --- Interface for a migration step between two schema versions. Members: ~IMigrationStep FromVersion — Get the version from which the migration starts. ToVersion — Get the version to which the migration applies. Init — Initializes internal variables after constructor. Apply — Execute the migration logic. ShutDown — Shuts down internal variables. IsRequired — Check if migration is required. ParseVersion IsVersionLessThan --- source: /SuperGenius/Classes/d6/d09/classsgns_1_1sgprocessing_1_1_input_types/ title: sgns::sgprocessing::InputTypes (class) --- Members: Error InputTypes ~InputTypes GetImageChannels --- source: /SuperGenius/Classes/d3/dbc/structsgns_1_1_input_u_t_x_o_info/ title: sgns::InputUTXOInfo (struct) --- Raw UTXO input data included in a spend request. Members: txid_hash_ — Hash of the transaction that created the output. output_idx_ — Zero-based output index within the originating transaction. signature_ — Signature authorizing the spend of this outpoint. SerializeForSigning — Serializes the input fields that must be signed by the owner. --- source: /SuperGenius/Classes/d5/d0e/structsgns_1_1_transaction_manager_1_1_input_validator_selection/ title: sgns::TransactionManager::InputValidatorSelection (struct) --- Members: chain_id validator --- source: /SuperGenius/Classes/dd/d3e/structsgns_1_1_account_messenger_1_1_interface_methods/ title: sgns::AccountMessenger::InterfaceMethods (struct) --- Interface methods the user needs to define. Members: sign_ — Signing method. verify_signature_ — Verify signature method. get_local_nonce_ — Get local nonce method. get_block_cid_ — Get local genesis block method. has_block_cid_ — Check if a CID is locally available. get_utxos_ — Get local UTXOs as a list of strings for a given address. get_validator_weight_ — Get validator weight for an address (empty if not a validator) get_transaction_cid_ — Get transaction CID by hash. --- source: /SuperGenius/Classes/d0/d33/classsgns_1_1_ipfs_d_h_t/ title: sgns::IpfsDHT (class) --- Members: kademlia_ bootstrapAddresses_ logger_ IpfsDHT Start FindProviders FindPeer GetBootstrapNodes --- source: /SuperGenius/Classes/d5/d3e/structdiscv5_1_1_i_pv4_wire/ title: discv5::IPv4Wire (struct) --- Wire layout of a 4-byte IPv4 address as stored in an ENR "ip" field. Members: msb — Most-significant octet. b1 — Second octet. b2 — Third octet. lsb — Least-significant octet. --- source: /SuperGenius/Classes/d9/dc3/structdiscv5_1_1_i_pv6_wire/ title: discv5::IPv6Wire (struct) --- Wire layout of a 16-byte IPv6 address as stored in an ENR "ip6" field. Members: bytes — 16 raw octets (network byte order) --- source: /SuperGenius/Classes/d5/db7/classsgns_1_1_i_secure_storage/ title: sgns::ISecureStorage (class) --- Members: SecureBufferType ~ISecureStorage Load Save DeleteKey --- source: /SuperGenius/Classes/d8/d89/classsgns_1_1securecrdt_1_1_i_signed_c_r_d_t_data/ title: sgns::securecrdt::ISignedCRDTData (class) --- Interface implemented by every CRDT-backed value that requires a quorum of authorized signers to create/update. Members: ~ISignedCRDTData SerializeToBytes — Serializes this instance's payload to raw bytes (codec, encode side). DeserializeFromBytes — Deserializes raw bytes into this instance's payload (codec, decode side). Verify — Performs type-specific semantic validation of payload beyond signature/quorum checks (e.g. field-range checks). Apply — Applies the side effect of this value once the caller has independently confirmed quorum (e.g. via SecureCrdt::ReadIfQuorum). Apply() itself does NOT check quorum. --- source: /SuperGenius/Classes/d4/d27/structsgns_1_1storage_1_1face_1_1_iterable/ title: sgns::storage::face::Iterable (struct) --- A mixin for an iterable map. K key type V value type Members: ~Iterable cursor — Returns new key-value iterator. --- source: /SuperGenius/Classes/d9/d71/classsgns_1_1_j_s_o_n_backend/ title: sgns::JSONBackend (class) --- Members: JSONBackend ~JSONBackend GetName Load Save DeleteKey LoadJSON SaveJSON --- source: /SuperGenius/Classes/d0/d06/structrlp_1_1base_1_1json_1_1_json_error/ title: rlp::base::json::JsonError (struct) --- Members: code field --- source: /SuperGenius/Classes/d0/d30/structrlp_1_1base_1_1json_1_1_json_parsed_array/ title: rlp::base::json::JsonParsedArray (struct) --- Members: values --- source: /SuperGenius/Classes/d9/d87/structrlp_1_1base_1_1json_1_1_json_parsed_object/ title: rlp::base::json::JsonParsedObject (struct) --- Members: fields find --- source: /SuperGenius/Classes/de/dcc/structrlp_1_1base_1_1json_1_1_json_parsed_size/ title: rlp::base::json::JsonParsedSize (struct) --- Members: value --- source: /SuperGenius/Classes/da/d8c/structrlp_1_1base_1_1json_1_1_json_parsed_value/ title: rlp::base::json::JsonParsedValue (struct) --- Members: Storage type value --- source: /SuperGenius/Classes/d3/d97/classeth_1_1rpc_1_1_json_rpc_transport/ title: eth::rpc::JsonRpcTransport (class) --- Members: ~JsonRpcTransport call --- source: /SuperGenius/Classes/d6/de7/structrlp_1_1base_1_1json_1_1_json_schema_array/ title: rlp::base::json::JsonSchemaArray (struct) --- Members: element_type object_schema array_schema --- source: /SuperGenius/Classes/d7/dad/structrlp_1_1base_1_1json_1_1_json_schema_field/ title: rlp::base::json::JsonSchemaField (struct) --- Members: name type required default_value object_schema array_schema --- source: /SuperGenius/Classes/d5/d93/structrlp_1_1base_1_1json_1_1_json_schema_object/ title: rlp::base::json::JsonSchemaObject (struct) --- Members: fields --- source: /SuperGenius/Classes/d4/dd2/classsgns_1_1_j_s_o_n_secure_storage/ title: sgns::JSONSecureStorage (class) --- Members: directory_ JSONSecureStorage ~JSONSecureStorage Load Save DeleteKey GetName LoadJSON GetInstance --- source: /SuperGenius/Classes/d8/d69/classrlpx_1_1crypto_1_1_kdf/ title: rlpx::crypto::Kdf (class) --- Members: Kdf derive derive_aes_key derive_mac_key derive_keys --- source: /SuperGenius/Classes/d7/db7/class_k_d_f_generator/ title: KDFGenerator (class) --- KDF Generator class. Members: HashType SignatureType ECDSAPubKey EXPECTED_SECRET_SIZE — Expected size of the signature in bytes. encryptor — The encryptor used by KDF to hide the shared secret. KDFGenerator — Constructs a new KDFGenerator object. GenerateSharedSecret — Generates a shared secret with a new derived key. GetNewKeyFromSecret — Extracts the derived new key from the signed secret. operator== — Checks if the encryptor is the same for the KDF. BuildPublicKeyECDSA — Builds the public key data type from the data. GenerateKDF — Generates a shared secret with a new derived key. --- source: /SuperGenius/Classes/d5/d6a/structdiscv5_1_1_keccak256_wire/ title: discv5::Keccak256Wire (struct) --- Wire layout of a Keccak-256 hash. Members: bytes — 32-byte hash digest --- source: /SuperGenius/Classes/d0/d38/structrlpx_1_1crypto_1_1_ecdh_1_1_key_pair/ title: rlpx::crypto::Ecdh::KeyPair (struct) --- Members: public_key private_key --- source: /SuperGenius/Classes/d6/d1e/classsgns_1_1crdt_1_1_key_pair_file_storage/ title: sgns::crdt::KeyPairFileStorage (class) --- Members: m_keyPath m_logger KeyPairFileStorage GetKeyPair --- source: /SuperGenius/Classes/d0/d1b/classai_1_1gnus_1_1sdk_1_1_key_store_helper/ title: ai::gnus::sdk::KeyStoreHelper (class) --- Members: TAG ANDROID_KEYSTORE KEY_ALIAS TRANSFORMATION GCM_TAG_LENGTH PREFS_NAME PREFS_KEY sInstance sLock context KeyStoreHelper initializeKeyStore getSecretKey loadInternal saveInternal deleteInternal encrypt decrypt initialize isInitialized load save delete nativeInit getInstance --- source: /SuperGenius/Classes/dc/d78/structsgns_1_1lambda__visitor_3_01_lambda_01_4/ title: sgns::lambda_visitor< Lambda > (struct) --- Members: lambda_visitor --- source: /SuperGenius/Classes/d2/d5d/structsgns_1_1lambda__visitor_3_01_lambda_00_01_lambdas_8_8_8_01_4/ title: sgns::lambda_visitor< Lambda, Lambdas... > (struct) --- Members: lambda_visitor --- source: /SuperGenius/Classes/dd/de8/classsgns_1_1_linux_secure_storage/ title: sgns::LinuxSecureStorage (class) --- Members: identifier_ schema_ LinuxSecureStorage ~LinuxSecureStorage GetName LoadJSON SaveJSON --- source: /SuperGenius/Classes/dd/d85/structeth_1_1codec_1_1_log_entry/ title: eth::codec::LogEntry (struct) --- EVM log entry emitted by a CALL or CREATE instruction. Members: address topics data --- source: /SuperGenius/Classes/d9/d91/classsgns_1_1crdt_1_1_graphsync_d_a_g_syncer_1_1_l_r_u_c_i_d_cache/ title: sgns::crdt::GraphsyncDAGSyncer::LRUCIDCache (class) --- Members: MAX_CACHE_SIZE cache_map_ lru_list_ mutex_ init add get remove contains hasContent size --- source: /SuperGenius/Classes/da/d9b/structrlpx_1_1_mac_digest_wire/ title: rlpx::MacDigestWire (struct) --- 16-byte frame-level MAC digest (first 16 bytes of the running Keccak state). Members: bytes --- source: /SuperGenius/Classes/df/df2/structsgns_1_1storage_1_1face_1_1_map_cursor/ title: sgns::storage::face::MapCursor (struct) --- An abstraction over generic map cursor. K key type V value type Members: ~MapCursor seekToFirst — Same as std::begin(...);. seek — Find given key and seek iterator to this key. seekToLast — Same as std::rbegin(...);, e.g. points to the last valid element. isValid — Is iterator valid? next — Make step forward. prev — Make step backwards. key — Getter for key. value — Getter for value. --- source: /SuperGenius/Classes/d8/d65/structdiscv5_1_1_masking_iv_wire/ title: discv5::MaskingIvWire (struct) --- Masking IV that precedes the static packet header. Members: bytes — 16-byte AES-128 IV --- source: /SuperGenius/Classes/da/d2f/structeth_1_1_matched_event/ title: eth::MatchedEvent (struct) --- A matched event: the original log decorated with block context. Members: log — The raw log entry. block_number — Block the log appeared in. block_hash — Hash of that block (if known) tx_hash — Transaction hash (if known) log_index — Position within the block's log set. receipt_log_index — Absolute zero-based position in receipt.logs. --- source: /SuperGenius/Classes/d0/d0d/classsgns_1_1_memory_secure_storage/ title: sgns::MemorySecureStorage (class) --- In-memory JSON backend for tests. Stores data in a map — no OS keychain access, no password prompts, no cleanup needed. Members: identifier_ store_ MemorySecureStorage GetName LoadJSON SaveJSON --- source: /SuperGenius/Classes/d9/da4/structrlpx_1_1framing_1_1_message/ title: rlpx::framing::Message (struct) --- Members: id payload --- source: /SuperGenius/Classes/d3/d51/structrlpx_1_1protocol_1_1_message/ title: rlpx::protocol::Message (struct) --- Members: id payload is_hello is_disconnect is_ping is_pong --- source: /SuperGenius/Classes/de/d48/classrlpx_1_1_rlpx_session_1_1_message_channel/ title: rlpx::RlpxSession::MessageChannel (class) --- Members: mutex_ queue_ MessageChannel push try_pop empty --- source: /SuperGenius/Classes/d6/dea/structrlpx_1_1framing_1_1_message_send_params/ title: rlpx::framing::MessageSendParams (struct) --- Members: message_id payload compress --- source: /SuperGenius/Classes/d4/d77/classrlpx_1_1framing_1_1_message_stream/ title: rlpx::framing::MessageStream (class) --- Message stream handles framing, encryption, and compression. Members: cipher_ transport_ compression_enabled_ send_buffer_ recv_buffer_ MessageStream — Takes ownership of cipher and socket transport. send_message — Send message (encodes, compresses if enabled, frames, encrypts). receive_message — Receive message (decrypts, deframes, decompresses, decodes). enable_compression — Enable compression after hello exchange. close — Close the underlying socket, unblocking any pending receive_message call. is_compression_enabled — Query state. cipher_secrets — Access cipher secrets (grouped values). send_frame receive_frame --- source: /SuperGenius/Classes/d9/deb/classsgns_1_1watcher_1_1_messaging_watcher/ title: sgns::watcher::MessagingWatcher (class) --- Members: MessageCallback messageCallback running running_mutex watcherThread m_watchers ~MessagingWatcher startWatching stopWatching isRunning addWatcher startAll stopAll MessagingWatcher watch --- source: /SuperGenius/Classes/d9/d5c/classsgns_1_1_migration0__2__0_to1__0__0/ title: sgns::Migration0_2_0To1_0_0 (class) --- Migration step for version 0.2.0 to 1.0.0. Copies transactions and proofs from legacy DB (“out” and “in”) into the new CRDT store. Members: db_1_0_0_ — Target GlobalDB. db_0_0_2_out_ — Target GlobalDB. db_0_0_2_in_ — Target GlobalDB. ioContext_ — IO context for DB I/O. pubSub_ — PubSub instance for legacy DB. graphsync_ — GraphSync network. scheduler_ — libp2p scheduler. generator_ — Request ID generator. crdt_transaction_ — CRDT transaction to make it all atomic. writeBasePath_ — Base path for writing DB files. base58key_ — Key to build legacy paths. topics_ m_logger — Logger for this step. Migration0_2_0To1_0_0 — Construct the step with all resources needed to open legacy DBs. FromVersion — Get the source version for this step. ToVersion — Get the target version for this step. Init — Initializes internal variables after constructor. IsRequired — Check if this migration should run. Apply — Apply the migration: initialize legacy DBs and migrate data. ShutDown — Shuts down internal variables. InitTargetDb — Opens the target database to migrate into. InitLegacyDb — Open a legacy GlobalDB given a suffix ("out" or "in"). MigrateDb — Migrate all transactions and proofs from oldDb into newDb. --- source: /SuperGenius/Classes/d0/d09/classsgns_1_1_migration1__0__0_to3__4__0/ title: sgns::Migration1_0_0To3_4_0 (class) --- Migration step for version 1.0.0 to 3.4.0. Changes the full node topic from CRDT heads. Members: ioContext_ — IO context for DB I/O. pubSub_ — PubSub instance for legacy DB. graphsync_ — GraphSync network. scheduler_ — libp2p scheduler. generator_ — Request ID generator. writeBasePath_ — Base path for writing DB files. base58key_ — Key to build legacy paths. logger_ — Logger for this step. db_3_4_0_ — Target GlobalDB. db_1_0_0_ — Legacy GlobalDB. Migration1_0_0To3_4_0 ~Migration1_0_0To3_4_0 FromVersion — Get the source version for this step. ToVersion — Get the target version for this step. Init — Initializes internal variables after constructor. IsRequired — Check if this migration should run. Apply — Apply the migration: initialize legacy DBs and migrate data. ShutDown — Shuts down internal variables. InitLegacyDb — Open a legacy GlobalDB from 1.0.0. InitTargetDb --- source: /SuperGenius/Classes/d1/dd2/classsgns_1_1_migration3__4__0_to3__5__0/ title: sgns::Migration3_4_0To3_5_0 (class) --- Migration step for version 3.4.0 to 3.5.0. Updates persisted data required by the 3.5.0 node layout. Members: Status — Internal status used while waiting for blockchain-backed migration tasks. ioContext_ — IO context for GlobalDB services. pubSub_ — PubSub service for CRDT sync. graphsync_ — GraphSync network. scheduler_ — libp2p scheduler. generator_ — GraphSync request ID generator. writeBasePath_ — Base path for versioned DBs. base58key_ — Node key suffix for DB paths. logger_ — Logger for this step. db_3_5_0_ — Target 3.5.0 database. db_3_4_0_ — Legacy 3.4.0 database. blockchain_ — Blockchain instance used during migration. account_ — Local account being migrated. blockchain_status_ — Async blockchain startup status. Migration3_4_0To3_5_0 — Constructs the migration step with the services required to read and write both database versions. ~Migration3_4_0To3_5_0 — Destroys the migration step. FromVersion — Returns the source schema version handled by this step. ToVersion — Returns the target schema version produced by this step. Init — Initializes migration resources before the step is applied. IsRequired — Determines whether the 3.4.0 to 3.5.0 migration must run. Apply — Applies the migration and writes the upgraded transaction state. ShutDown — Releases resources allocated during migration. InitLegacyDb — Opens the legacy 3.4.0 database view. InitTargetDb — Opens the target 3.5.0 database view. --- source: /SuperGenius/Classes/d8/d7f/classsgns_1_1_migration3__5__0_to3__6__0/ title: sgns::Migration3_5_0To3_6_0 (class) --- Executes the storage migration from database version 3.5.1 to 3.6.0. Members: logger_ — Logger for migration progress and errors. ioContext_ — IO context for GlobalDB services. pubSub_ — PubSub service for CRDT sync. graphsync_ — GraphSync network. scheduler_ — libp2p scheduler. generator_ — GraphSync request ID generator. writeBasePath_ — Base path for versioned DBs. base58key_ — Node key suffix for DB paths. db_3_5_1_ — Legacy 3.5.1 database. db_3_6_0_ — Target 3.6.0 database. Migration3_5_0To3_6_0 — Constructs the migration step with the services required to read and write both database versions. FromVersion — Returns the source schema version handled by this step. ToVersion — Returns the target schema version produced by this step. Init — Initializes migration resources before the step is applied. Apply — Applies the migration logic and persists the upgraded data. ShutDown — Releases any temporary migration resources. IsRequired — Determines whether the migration needs to run for the current node state. InitLegacyDb — Opens the legacy 3.5.1 database view. InitTargetDb — Opens the target 3.6.0 database view. --- source: /SuperGenius/Classes/db/d7d/classsgns_1_1_migration3__6__0_to3__7__0/ title: sgns::Migration3_6_0To3_7_0 (class) --- Executes the 3.6.0 to 3.7.0 migration, including legacy balance recovery. Members: Status — Internal status used while waiting for blockchain-backed migration tasks. AddressBalance — Address and balance pair recovered from the legacy database. logger_ — Logger for migration progress and errors. ioContext_ — IO context for GlobalDB services. pubSub_ — PubSub service for CRDT sync. graphsync_ — GraphSync network. scheduler_ — libp2p scheduler. generator_ — GraphSync request ID generator. writeBasePath_ — Base path for versioned DBs. base58key_ — Node key suffix for DB paths. db_3_6_0_ — Legacy 3.6.0 database. db_3_7_0_ — Target 3.7.0 database. blockchain_ — Blockchain instance used during migration. transaction_manager_ — Transaction manager used for the migration claim. account_ — Local account being migrated. is_full_node_ — Whether this node is a full node. blockchain_status_ — Async blockchain startup status. Migration3_6_0To3_7_0 — Constructs the migration step with access to legacy and target storage plus account services. FromVersion — Returns the source schema version handled by this step. ToVersion — Returns the target schema version produced by this step. Init — Initializes migration resources before applying the step. Apply — Applies the migration and writes the upgraded balance state. ShutDown — Releases resources allocated during migration. IsRequired — Determines whether the 3.6.0 to 3.7.0 migration must run. InitLegacyDb — Opens the legacy 3.6.0 database view. InitTargetDb — Opens the target 3.7.0 database view. ComputeLegacyBalances — Scans the legacy dataset and computes the balances to migrate. --- source: /SuperGenius/Classes/d9/dcf/classsgns_1_1_migration_allow_list/ title: sgns::MigrationAllowList (class) --- Stores observed legacy balances and validates migration claim eligibility. Members: AddressBalance — Address and observed balance pair stored in the migration allow-list. ::MigrationParamTest db_ — Database storing allow-list entries. migration_version_ — Source migration version namespace. prefix_ — Cached key prefix for migration_version_. logger_ — Component logger. MigrationAllowList — Creates an allow-list view scoped to a specific migration version. StoreObservedBalance — Persists the observed legacy balance for a single address. StoreObservedBalances — Persists observed legacy balances for multiple addresses. LoadObservedBalance — Loads the observed legacy balance for a single address when present. IsEligible — Checks whether an address may claim the provided migrated balance. ListObservedBalances — Lists every stored observed balance in the current migration namespace. BuildPrefix — Builds the RocksDB key prefix used for a migration version namespace. BuildKey — Builds the RocksDB key used for a specific address inside a migration namespace. SetEligibilityCheckEnabledForTests — Enables or disables eligibility checks for migration tests. IsEligibilityCheckEnabledForTests — Returns whether eligibility checks are enabled for migration tests. DecodeBalance — Decodes a stored observed balance from its serialized database value. --- source: /SuperGenius/Classes/dd/d2f/classsgns_1_1_migration_input_validator/ title: sgns::MigrationInputValidator (class) --- Implements the InputValidator for a Migration type. Members: ValidateUTXOParameters — Validates ownership and structure of the supplied UTXO parameters. ValidateWitness — Validates the chain-specific witness data associated with a transaction input set. RequiresConsensusUTXOData — Indicates whether this validator requires consensus-provided UTXO data. Register — Registers this validator in the global registry for the "migration" chain ID. --- source: /SuperGenius/Classes/d6/d9a/classsgns_1_1_migration_manager/ title: sgns::MigrationManager (class) --- Executes a sequence of migration steps to update a CRDT store. Members: Error VERSION_INFO_KEY steps_ — Queue of registered migration steps. m_logger — Logger instance. current_step_index_ — 1-based index of the step currently being migrated. total_steps_ — Total number of steps (set before migration begins). New — Factory function to create a MigrationManager and register all known steps. RegisterStep — Register a migration step. Migrate — Perform all registered migration steps in sequence. GetCurrentStepIndex GetTotalSteps GetCurrentStepDescription MigrationManager — Private default constructor. --- source: /SuperGenius/Classes/d3/d30/classsgns_1_1_migration_transaction/ title: sgns::MigrationTransaction (class) --- Members: utxo_params_ from_version_ token_id_ registered SerializeToEmbeddedTransaction — Serializes the transaction into an EmbeddedTransaction proto with the appropriate oneof field set. ~MigrationTransaction SerializeByteVector — Serializes the transaction into a byte vector, including the DAG metadata. GetAmount GetTokenID GetChainId — Returns the source chain id for input validation routing. GetUTXOParameters HasUTXOParameters — Returns if transaction supports UTXOs. GetUTXOParametersOpt — Returns the UTXOs. GetFromVersion GetTransactionSpecificPath — Returns the transaction-specific path component for storage and retrieval. GetTopics — Returns the destination topics associated with the transaction. SerializeByteVector — Serializes the transaction into a byte vector, including the DAG metadata. SerializeByteVector — Serializes the transaction using the internal DAG metadata. SerializeToEmbeddedTransaction — Serializes the transaction into an EmbeddedTransaction proto with the appropriate oneof field set. SerializeToEmbeddedTransaction — Serializes using internal DAG metadata. DeSerializeByteVector New DeriveUniqueSourceKey MigrationTransaction Register --- source: /SuperGenius/Classes/d7/d9c/classsgns_1_1_mint_transaction/ title: sgns::MintTransaction (class) --- Transaction that mints tokens after proving a corresponding source-chain event. Members: amount — Amount of token units minted by this transaction. chain_id — Source chain identifier associated with the mint event. token_id — Token identifier for the asset being minted. registered — Forces static initialization of the mint transaction deserializer. ~MintTransaction — Destroys the mint transaction. SerializeToEmbeddedTransaction — Serializes the transaction into an EmbeddedTransaction proto with the appropriate oneof field set. SerializeByteVector — Serializes the mint transaction payload and DAG metadata. GetAmount — Returns the minted amount. GetTokenID — Returns the minted token identifier. GetChainId — Returns the source chain identifier associated with the mint. GetTransactionSpecificPath — Returns the transaction-specific storage path component. SerializeByteVector — Serializes the transaction into a byte vector, including the DAG metadata. SerializeByteVector — Serializes the transaction using the internal DAG metadata. SerializeToEmbeddedTransaction — Serializes the transaction into an EmbeddedTransaction proto with the appropriate oneof field set. SerializeToEmbeddedTransaction — Serializes using internal DAG metadata. DeSerializeByteVector — Deserializes a serialized mint transaction. New — Creates a new mint transaction instance. MintTransaction — Constructs a mint transaction from its payload and DAG metadata. Register — Registers the deserializer for the mint transaction type. --- source: /SuperGenius/Classes/db/d6b/classsgns_1_1_mint_transaction_v2/ title: sgns::MintTransactionV2 (class) --- Implements a Mint Version 2 transaction. Members: utxo_params_ — The UTXOs (inputs and outputs) chain_id_ — The chain ID from the bridge. token_id_ — The ID of the token minted. registered — Forces the static initialization of the Deserializer. SerializeToEmbeddedTransaction — Serializes the transaction into an EmbeddedTransaction proto with the appropriate oneof field set. ~MintTransactionV2 — Destroy the Mint Transaction V 2 object. SerializeByteVector — Serializes the transaction. GetAmount — Get the amount of the mint. GetTokenID — Get the Token ID. GetChainId — Get source chain identifier for bridge mint validation routing. GetUTXOParameters — Returns the UTXOs. HasUTXOParameters — Returns if transaction supports UTXOs. GetUTXOParametersOpt — Returns the UTXOs. GetTransactionSpecificPath — Gets the transaction specific path. GetTopics — Returns the topics of interest of this transaction. GetSlotID — Generates a slot ID for consensus slot key determination. SerializeByteVector — Serializes the transaction into a byte vector, including the DAG metadata. SerializeByteVector — Serializes the transaction using the internal DAG metadata. SerializeToEmbeddedTransaction — Serializes the transaction into an EmbeddedTransaction proto with the appropriate oneof field set. SerializeToEmbeddedTransaction — Serializes using internal DAG metadata. DeSerializeByteVector — Deserializes a MintV2 serialized byte vector into an object. New — Creates a new MintV2 transaction. MintTransactionV2 — Construct a new Mint Transaction V2. Register — Registers a deserializer for MintV2 transactions. --- source: /SuperGenius/Classes/dc/dbb/classsgns_1_1sgprocessing_1_1_m_n_n___audio/ title: sgns::sgprocessing::MNN_Audio (class) --- Members: MNN_Audio ~MNN_Audio StartProcessing Process --- source: /SuperGenius/Classes/db/d36/classsgns_1_1sgprocessing_1_1_m_n_n___bool/ title: sgns::sgprocessing::MNN_Bool (class) --- Members: MNN_Bool ~MNN_Bool StartProcessing Process --- source: /SuperGenius/Classes/d4/d8e/classsgns_1_1sgprocessing_1_1_m_n_n___buffer/ title: sgns::sgprocessing::MNN_Buffer (class) --- Members: MNN_Buffer ~MNN_Buffer StartProcessing Process --- source: /SuperGenius/Classes/d6/d8a/classsgns_1_1sgprocessing_1_1_m_n_n___float/ title: sgns::sgprocessing::MNN_Float (class) --- Members: MNN_Float ~MNN_Float StartProcessing Process --- source: /SuperGenius/Classes/d8/d19/classsgns_1_1sgprocessing_1_1_m_n_n___image/ title: sgns::sgprocessing::MNN_Image (class) --- Members: MNN_Image ~MNN_Image StartProcessing Process --- source: /SuperGenius/Classes/d8/db6/classsgns_1_1sgprocessing_1_1_m_n_n___int/ title: sgns::sgprocessing::MNN_Int (class) --- Members: MNN_Int ~MNN_Int StartProcessing Process --- source: /SuperGenius/Classes/d2/d5f/classsgns_1_1sgprocessing_1_1_m_n_n___mat2/ title: sgns::sgprocessing::MNN_Mat2 (class) --- Members: MNN_Mat2 ~MNN_Mat2 StartProcessing Process --- source: /SuperGenius/Classes/dc/d83/classsgns_1_1sgprocessing_1_1_m_n_n___mat3/ title: sgns::sgprocessing::MNN_Mat3 (class) --- Members: MNN_Mat3 ~MNN_Mat3 StartProcessing Process --- source: /SuperGenius/Classes/dc/da0/classsgns_1_1sgprocessing_1_1_m_n_n___mat4/ title: sgns::sgprocessing::MNN_Mat4 (class) --- Members: MNN_Mat4 ~MNN_Mat4 StartProcessing Process --- source: /SuperGenius/Classes/d4/dac/classsgns_1_1sgprocessing_1_1_m_n_n___m_l/ title: sgns::sgprocessing::MNN_ML (class) --- Members: StartProcessing Process --- source: /SuperGenius/Classes/da/df7/classsgns_1_1sgprocessing_1_1_m_n_n___string/ title: sgns::sgprocessing::MNN_String (class) --- Members: MNN_String ~MNN_String StartProcessing Process --- source: /SuperGenius/Classes/d8/d23/classsgns_1_1sgprocessing_1_1_m_n_n___tensor/ title: sgns::sgprocessing::MNN_Tensor (class) --- Members: MNN_Tensor ~MNN_Tensor StartProcessing Process --- source: /SuperGenius/Classes/da/dc9/classsgns_1_1sgprocessing_1_1_m_n_n___texture1_d/ title: sgns::sgprocessing::MNN_Texture1D (class) --- Members: MNN_Texture1D ~MNN_Texture1D StartProcessing Process --- source: /SuperGenius/Classes/d6/d91/classsgns_1_1sgprocessing_1_1_m_n_n___texture_cube/ title: sgns::sgprocessing::MNN_TextureCube (class) --- Members: MNN_TextureCube ~MNN_TextureCube StartProcessing Process --- source: /SuperGenius/Classes/d7/d04/classsgns_1_1sgprocessing_1_1_m_n_n___vec2/ title: sgns::sgprocessing::MNN_Vec2 (class) --- Members: ~MNN_Vec2 StartProcessing Process --- source: /SuperGenius/Classes/df/de7/classsgns_1_1sgprocessing_1_1_m_n_n___vec3/ title: sgns::sgprocessing::MNN_Vec3 (class) --- Members: ~MNN_Vec3 StartProcessing Process --- source: /SuperGenius/Classes/db/d4d/classsgns_1_1sgprocessing_1_1_m_n_n___vec4/ title: sgns::sgprocessing::MNN_Vec4 (class) --- Members: ~MNN_Vec4 StartProcessing Process --- source: /SuperGenius/Classes/d3/d6e/classsgns_1_1sgprocessing_1_1_m_n_n___volume/ title: sgns::sgprocessing::MNN_Volume (class) --- Members: MNN_Volume ~MNN_Volume StartProcessing Process --- source: /SuperGenius/Classes/da/dbf/classsgns_1_1multisig_1_1_multi_sig/ title: sgns::multisig::MultiSig (class) --- Configured N-of-M signature evaluator. The constructor fixes the quorum policy for the evaluator's lifetime: required_signatures is N and the number of unique addresses in signer_set is M. A configuration is valid only when 1 <= N <= M. Members: signer_set_ required_signatures_ MultiSig IsValid RequiredSignatures AuthorizedSignerCount EvaluateQuorum — Evaluates collected signatures against this instance's N-of-M policy. --- source: /SuperGenius/Classes/dd/d27/structsgns_1_1_new_account/ title: sgns::NewAccount (struct) --- Account-creation source for GeniusNode::New(dev_config, AccountSource).Generate a new identity. Owned std::string payloads — a std::variant owns its active alternative, so non-owning views such as const char* or std::string_view would dangle once the variant is stored or passed. TokenID and other dev_config fields are NOT part of the variant; they come from dev_config. --- source: /SuperGenius/Classes/dd/de0/structeth_1_1_new_block_hash_entry/ title: eth::NewBlockHashEntry (struct) --- Members: hash number --- source: /SuperGenius/Classes/d9/dce/structeth_1_1_new_block_hashes_message/ title: eth::NewBlockHashesMessage (struct) --- Members: entries --- source: /SuperGenius/Classes/d9/d30/structeth_1_1_new_block_message/ title: eth::NewBlockMessage (struct) --- Full new block announcement (message id 0x07). Members: header transactions ommers total_difficulty --- source: /SuperGenius/Classes/d3/d91/structsgns_1_1crdt_1_1_c_r_d_t_callback_manager_1_1_new_data_callback_entry/ title: sgns::crdt::CRDTCallbackManager::NewDataCallbackEntry (struct) --- Members: pattern regex callback --- source: /SuperGenius/Classes/df/d5f/structeth_1_1_new_pooled_transaction_hashes_message/ title: eth::NewPooledTransactionHashesMessage (struct) --- Members: types sizes hashes --- source: /SuperGenius/Classes/d4/d4f/classsgns_1_1_nil_file_helper/ title: sgns::NilFileHelper (class) --- Members: PrintMarshalledData GetMarshalledData DecodeMarshalledData WriteAsHex WriteAsBin ReadFromHex ReadFromBin --- source: /SuperGenius/Classes/dc/d38/struct_node_i_d_hash/ title: NodeIDHash (struct) --- Members: operator() --- source: /SuperGenius/Classes/dd/da3/structintx_1_1internal_1_1normalized__div__args/ title: intx::internal::normalized_div_args (struct) --- Members: divisor numerator num_divisor_words num_numerator_words shift --- source: /SuperGenius/Classes/d4/d12/structstd_1_1numeric__limits_3_01intx_1_1uint_3_01_n_01_4_01_4/ title: std::numeric_limits< intx::uint< N > > (struct) --- Members: type is_specialized is_integer is_signed is_exact has_infinity has_quiet_NaN has_signaling_NaN has_denorm has_denorm_loss round_style is_iec559 is_bounded is_modulo digits digits10 max_digits10 radix min_exponent min_exponent10 max_exponent max_exponent10 traps tinyness_before min lowest max epsilon round_error infinity quiet_NaN signaling_NaN denorm_min --- source: /SuperGenius/Classes/d6/dfe/structsgns_1_1_out_point/ title: sgns::OutPoint (struct) --- Unique identifier for a transaction output. Members: txid_hash_ — Hash of the transaction that produced the output. output_idx_ — Output index within the producing transaction. operator== — Compares two outpoints for exact transaction-and-index equality. --- source: /SuperGenius/Classes/d5/d40/structsgns_1_1_out_point_hash/ title: sgns::OutPointHash (struct) --- Hash functor for using OutPoint keys in unordered containers. Members: operator() — Computes a combined hash for a transaction id and output index pair. --- source: /SuperGenius/Classes/dc/dfd/structsgns_1_1_output_dest_info/ title: sgns::OutputDestInfo (struct) --- Single UTXO output destination entry. Members: encrypted_amount — El Gamal encrypted amount. dest_address — Destination node address. token_id — Token identifier. --- source: /SuperGenius/Classes/da/d9a/structsgns_1_1processing_1_1_processing_sub_task_queue_manager_1_1_ownership_request/ title: sgns::processing::ProcessingSubTaskQueueManager::OwnershipRequest (struct) --- Members: node_id timestamp --- source: /SuperGenius/Classes/dc/dc6/classdiscv4_1_1_packet_factory/ title: discv4::PacketFactory (class) --- Members: SendPingAndWait SignAndBuildPacket SendPacket --- source: /SuperGenius/Classes/d3/d38/struct_key_generator_1_1_el_gamal_1_1_params/ title: KeyGenerator::ElGamal::Params (struct) --- Prime and generator parameter struct. Members: prime_number — The safe prime number used by El Gamal. generator — The generator used by El Gamal. Params — Construct a new Params object. --- source: /SuperGenius/Classes/d5/d51/structeth_1_1rpc_1_1_rpc_http_transport_1_1_parsed_url/ title: eth::rpc::RpcHttpTransport::ParsedUrl (struct) --- Members: scheme host port target is_https --- source: /SuperGenius/Classes/d5/db2/struct_peer/ title: Peer (struct) --- Members: ip udp_port tcp_port node_id last_seen xor_distance --- source: /SuperGenius/Classes/da/d68/structrlpx_1_1_peer_info/ title: rlpx::PeerInfo (struct) --- Members: public_key client_id listen_port remote_address remote_port --- source: /SuperGenius/Classes/d9/d37/structsgns_1_1_consensus_manager_1_1_pending_dependency_key/ title: sgns::ConsensusManager::PendingDependencyKey (struct) --- Local-only dependency key for deferred subject validation. Members: Type type value operator== Certificate --- source: /SuperGenius/Classes/d3/dbe/structsgns_1_1_consensus_manager_1_1_pending_dependency_key_hash/ title: sgns::ConsensusManager::PendingDependencyKeyHash (struct) --- Hash functor for PendingDependencyKey unordered containers. Members: operator() --- source: /SuperGenius/Classes/d4/dbf/structsgns_1_1_consensus_manager_1_1_pending_lifecycle_config/ title: sgns::ConsensusManager::PendingLifecycleConfig (struct) --- Local pending proposal lifecycle limits. Members: max_pending_proposals max_pending_per_proposer max_retained_pending_bytes pending_ttl min_dependency_retry_interval scheduled_retry_delays --- source: /SuperGenius/Classes/d5/db9/structsgns_1_1crdt_1_1_atomic_transaction_1_1_pending_operation/ title: sgns::crdt::AtomicTransaction::PendingOperation (struct) --- Members: type key value --- source: /SuperGenius/Classes/d7/d3b/structsgns_1_1_consensus_manager_1_1_pending_proposal_entry/ title: sgns::ConsensusManager::PendingProposalEntry (struct) --- Canonical local pending proposal entry. Members: proposal dependencies admitted_at expires_at next_retry_at last_retry_at retry_after retained_bytes proposer_id scheduled_retry_count --- source: /SuperGenius/Classes/d9/df8/structsgns_1_1_validator_registry_1_1_pending_registry_write/ title: sgns::ValidatorRegistry::PendingRegistryWrite (struct) --- Members: subject_hash update --- source: /SuperGenius/Classes/d7/dd5/structdiscv4_1_1discv4__client_1_1_pending_reply/ title: discv4::discv4_client::PendingReply (struct) --- Members: timer pong — filled by handle_pong; null for non-ping entries enr_response — filled by handle_enr_response; null for non-ENR entries expected_hash — outbound PING/ENRRequest wire hash; used for PONG/ReplyTok verification --- source: /SuperGenius/Classes/dd/d3e/structdiscv5_1_1discv5__client_1_1_pending_request/ title: discv5::discv5_client::PendingRequest (struct) --- Members: peer req_id request_nonce challenge_data id_nonce record_seq have_challenge --- source: /SuperGenius/Classes/da/db8/structeth_1_1_eth_watch_service_1_1_pending_request/ title: eth::EthWatchService::PendingRequest (struct) --- Context stored for an outstanding GetReceipts request. Members: block_hash block_number --- source: /SuperGenius/Classes/d5/d5f/structsgns_1_1_transaction_manager_1_1_pending_transaction_wait/ title: sgns::TransactionManager::PendingTransactionWait (struct) --- Members: timer tx_id callback started_at completed PendingTransactionWait --- source: /SuperGenius/Classes/da/da7/structrlpx_1_1protocol_1_1_ping_message/ title: rlpx::protocol::PingMessage (struct) --- Members: encode decode --- source: /SuperGenius/Classes/dc/d90/class_ping_session/ title: PingSession (class) --- Members: host_ pingSession_ ping_ subsOnNewConnection_ PingSession Init OnSessionPing OnNewConnection --- source: /SuperGenius/Classes/d4/d97/structplaceholder__verifier_1_1placeholder__challenges__type/ title: placeholder_verifier::placeholder_challenges_type (struct) --- Members: eta perm_beta perm_gamma lookup_theta lookup_gamma lookup_beta lookup_alphas gate_theta alphas fri_alphas fri_x_indices lpc_theta xi --- source: /SuperGenius/Classes/de/d77/structplaceholder__verifier_1_1placeholder__permutation__argument__input__type/ title: placeholder_verifier::placeholder_permutation_argument_input_type (struct) --- Members: xi_values id_perm sigma_perm thetas --- source: /SuperGenius/Classes/d7/d95/structplaceholder__verifier_1_1placeholder__proof__type/ title: placeholder_verifier::placeholder_proof_type (struct) --- Members: commitments challenge z fri_roots initial_proof_values round_proof_values initial_proof_positions initial_proof_hashes round_merkle_proof_positions round_proof_hashes final_polynomial --- source: /SuperGenius/Classes/da/d79/structrlpx_1_1protocol_1_1_pong_message/ title: rlpx::protocol::PongMessage (struct) --- Members: encode decode --- source: /SuperGenius/Classes/d4/d2d/structeth_1_1_pooled_transactions_message/ title: eth::PooledTransactionsMessage (struct) --- Members: request_id encoded_transactions --- source: /SuperGenius/Classes/d2/d00/structeth_1_1rpc_1_1_rpc_manager_1_1_pool_entry/ title: eth::rpc::RpcManager::PoolEntry (struct) --- Members: group pool --- source: /SuperGenius/Classes/d2/d79/structplaceholder__verifier_1_1precomputed__values__type/ title: placeholder_verifier::precomputed_values_type (struct) --- Members: l0 Z_at_xi F_consolidated T_consolidated --- source: /SuperGenius/Classes/d7/da3/structsgns_1_1_genius_node_1_1_price_info/ title: sgns::GeniusNode::PriceInfo (struct) --- Members: price — Cached USD token price. lastUpdate — Time when price was fetched. --- source: /SuperGenius/Classes/df/d94/class_prime_numbers/ title: PrimeNumbers (class) --- Members: cpp_int GenerateSafePrime GetRandomNumber GetGeneratorFromPrime ModInverseEuclideanDivision SqrtMod PowHighPrec --- source: /SuperGenius/Classes/d6/d88/struct_key_generator_1_1_el_gamal_1_1_private_key/ title: KeyGenerator::ElGamal::PrivateKey (struct) --- Members: private_key_scalar CreatePrivateScalar PrivateKey GetPrivateKeyScalar --- source: /SuperGenius/Classes/d9/dc0/struct_private_key/ title: PrivateKey (struct) --- Members: base_type curve_type padding_policy generator_type distribution_type hash_type internal_accumulator_type scalar_field_value_type g1_value_type base_integral_type scalar_modular_type private_key_type public_key_type signature_type privkey PrivateKey GetPrivateKeyScalar generate_public_key --- source: /SuperGenius/Classes/d9/d95/structeth_1_1rpc_1_1_probe_result/ title: eth::rpc::ProbeResult (struct) --- Members: url expected_chain_id status detail --- source: /SuperGenius/Classes/d6/da7/classsgns_1_1processing_1_1_processing_core/ title: sgns::processing::ProcessingCore (class) --- Processing core interface. Implementations encapsulate specific processing algorithms for subtasks. Members: ~ProcessingCore ProcessSubTask — Processes a subtask and returns the result. GetProgress — Returns the progress of the processing core as a float between 0.0 and 100.0. --- source: /SuperGenius/Classes/d0/d7f/classsgns_1_1processing_1_1_processing_core_impl/ title: sgns::processing::ProcessingCoreImpl (class) --- Default implementation of ProcessingCore backed by GlobalDB. Members: Error — Error codes for ProcessingCoreImpl operations. task_queue_ — Shared pointer to the task queue for retrieving tasks and subtasks. token_ID_ — The Token ID to be used on the results of the processed subtasks. max_processing_subtask_count_ — The maximum number of subtasks that can be processed concurrently. subtask_count_mutex_ — Mutex to protect access to the processing subtask count. processing_subtask_count_ — The current count of subtasks being processed. processing_manager_ — The last processing manager used for processing a subtask, kept here to allow progress retrieval during processing. New — Factory method to create a new instance of ProcessingCoreImpl. ~ProcessingCoreImpl ProcessSubTask — Processes a subtask and returns the result. GetProgress — Returns the progress of the processing core as a float between 0.0 and 100.0. ProcessingCoreImpl — Private constructor for ProcessingCoreImpl. Use the static New method to create instances. IncProcessingSubTaskCount — Increments the count of currently processing subtasks. Returns failure if the count exceeds the maximum allowed. DecProcessingSubTaskCount — Decrements the count of currently processing subtasks. Called whenever a processing finished. --- source: /SuperGenius/Classes/dc/d00/classsgns_1_1processing_1_1_processing_engine/ title: sgns::processing::ProcessingEngine (class) --- Handles subtask processing and result aggregation. Members: m_nodeId m_processingCore m_processingErrorSink m_processingDoneSink m_subTaskQueueAccessor m_mutexSubTaskQueue m_logger ProcessingEngine ~ProcessingEngine StartQueueProcessing StopQueueProcessing IsQueueProcessingStarted GetProgress OnSubTaskGrabbed ProcessSubTask --- source: /SuperGenius/Classes/d7/d85/classsgns_1_1sgprocessing_1_1_processing_manager/ title: sgns::sgprocessing::ProcessingManager (class) --- Members: Error m_logger processing_ m_processor m_processorFactories m_inputMap ~ProcessingManager ParseBlockSize CheckProcessValidity Process RegisterProcessorFactory GetProcessingData GetInputIndex GetProgress Create IsProcessingValid — Checks whether a processing json is valid by attempting to create a ProcessingManager instance with it. IsProcessingModelValid — Checks if a json encoded data contains a valid ModelNode structure by attempting to parse it. GetModelNodeFromJson — Gets the ModelNode structure parsed from a json string. ProcessingManager Init GetCidForProc GetSubCidForProc SetProcessorByName --- source: /SuperGenius/Classes/d2/d5b/classsgns_1_1processing_1_1_processing_node/ title: sgns::processing::ProcessingNode (class) --- Node for distributed computation. Coordinates subtask queue ownership, processing, and result publication. Members: WorkGuard m_gossipPubSub m_nodeId m_escrowId m_processingCore m_subTaskResultStorage m_processingEngine m_queueChannel m_subtaskQueueManager m_subTaskQueueAccessor m_bitswap — Cached for accessor when created. m_taskResultProcessingSink m_processingErrorSink m_processingDoneSink m_creationTime m_ttl m_ttlTimer m_selfDestructCallback m_localContext m_localWorkGuard m_localIoThread m_logger New — Creates a processing node instance. ~ProcessingNode HasQueueOwnership setMirrorResultCallback setBitswap GetProgress ProcessingNode AttachTo CreateSubTaskQueue Initialize InitTTL StartTTLTimer CheckTTL --- source: /SuperGenius/Classes/dc/d66/classsgns_1_1sgprocessing_1_1_processing_processor/ title: sgns::sgprocessing::ProcessingProcessor (class) --- Members: m_progress m_logger ~ProcessingProcessor StartProcessing GetProgress --- source: /SuperGenius/Classes/df/df1/classsgns_1_1_processing_proof/ title: sgns::ProcessingProof (class) --- A class for generating and verifying processing proofs. ProcessingProof is a derived class from IBasicProof, providing the specific implementation for handling processing of funds proof generation and verification. Members: subtask_id_m — Subtask identifier associated with the processing proof. PROCESSING_TYPE_NAME — Constant representing the processing proof type name. registered — Static variable to ensure registration happens on inclusion of header file. ProcessingProof — Constructor for the ProcessingProof class. ~ProcessingProof — Destructor for the ProcessingProof class. GetProofType — Retrieves the type of proof for processings. SerializeFullProof — Serializes the full proof data and parameters. GenerateJsonParameters — Generates the parameters in JSON array form. DeSerializePublicParams — Deserializes public parameters from the provided proof data. Register — Registers the deserializer and bytecode for the processing proof type. --- source: /SuperGenius/Classes/db/dbc/structsgns_1_1sgprocessing_1_1_processing_result/ title: sgns::sgprocessing::ProcessingResult (struct) --- Members: hash output_buffers output_locations — Output locations for each saved result (file paths, IPFS CIDs, URLs, etc.) --- source: /SuperGenius/Classes/dd/d81/classsgns_1_1processing_1_1_processing_service_impl/ title: sgns::processing::ProcessingServiceImpl (class) --- Members: Status m_gossipPubSub m_context m_context_work io_thread m_maximalNodesCount m_subTaskEnqueuer m_subTaskResultStorage m_processingCore m_gridChannel m_processingNodes m_timerChannelListRequestTimeout m_channelListRequestTimeout m_waitingChannelRequest m_isStopped m_mutexNodes userCallbackSuccess_ userCallbackError_ node_address_ m_mirrorResultCallback — Mirror callback propagated to all nodes. m_bitswap — Bitswap for data availability checks. m_competingPeers m_pendingCreationTimestamp m_pendingCreationTimeout m_nodeCreationTimer m_nodeCreationTimeout m_pendingSubTaskQueueId m_pendingSubTasks m_pendingTask m_mutexPendingCreation m_blacklistedChannels m_mutexBlacklist m_logger ProcessingServiceImpl — Constructs a processing service with user callbacks. ~ProcessingServiceImpl StartProcessing StopProcessing GetProcessingNodesCount SetChannelListRequestTimeout GetProcessingStatus setMirrorResultCallback — Set callback for mirroring processing results. When set, results with mirror_result=true trigger a fetch. setBitswap — Set bitswap instance propagated to all processing nodes for data availability checks. Listen SendChannelListRequest OnMessage OnQueueProcessingCompleted OnProcessingError OnProcessingDone AcceptProcessingChannel PublishLocalChannelList HandleRequestTimeout BroadcastNodeCreationIntent HandleNodeCreationTimeout OnNodeCreationIntent HasLowestAddress IsPendingCreationStale CancelPendingCreation --- source: /SuperGenius/Classes/d7/d27/structsgns_1_1processing_1_1_processing_service_impl_1_1_processing_status/ title: sgns::processing::ProcessingServiceImpl::ProcessingStatus (struct) --- Members: status percentage ProcessingStatus --- source: /SuperGenius/Classes/d8/d64/classsgns_1_1processing_1_1_processing_sub_task_queue/ title: sgns::processing::ProcessingSubTaskQueue (class) --- Distributed subtask queue implementation. Members: TimestampProvider m_localNodeId m_queue m_enabledItemIndices m_logger m_timestampProvider ProcessingSubTaskQueue CreateQueue GrabItem MoveOwnershipTo RollbackOwnership HasOwnership UpdateQueue UnlockExpiredItems GetLastLockTimestamp AddOwnershipRequest ProcessNextOwnershipRequest ChangeOwnershipTo LockItem LogQueue --- source: /SuperGenius/Classes/d7/d2b/classsgns_1_1processing_1_1_processing_sub_task_queue_channel/ title: sgns::processing::ProcessingSubTaskQueueChannel (class) --- Subtask queue channel interface which is used for in-memory queue synchronization Members: ~ProcessingSubTaskQueueChannel RequestQueueOwnership PublishQueue GetActiveNodesCount GetActiveNodes --- source: /SuperGenius/Classes/dd/d85/classsgns_1_1processing_1_1_processing_sub_task_queue_channel_pub_sub/ title: sgns::processing::ProcessingSubTaskQueueChannelPubSub (class) --- Subtask queue channel implementation that uses pubsub as a data transport protocol Members: QueueRequestSink QueueUpdateSink m_processingQueueChannel m_gossipPubSub m_context m_queueRequestSink m_queueUpdateSink m_logger ProcessingSubTaskQueueChannelPubSub ~ProcessingSubTaskQueueChannelPubSub RequestQueueOwnership PublishQueue SetQueueRequestSink SetQueueUpdateSink Listen GetActiveNodesCount GetActiveNodes OnProcessingChannelMessage HandleSubTaskQueueRequest HandleSubTaskQueue --- source: /SuperGenius/Classes/d4/d2b/classsgns_1_1processing_1_1_processing_sub_task_queue_manager/ title: sgns::processing::ProcessingSubTaskQueueManager (class) --- Distributed subtask queue manager. Members: SubTaskGrabbedCallback m_queueChannel m_context m_localNodeId m_queue m_queueMutex m_onSubTaskGrabbedCallbacks m_subTaskQueueAssignmentEventSink m_processedSubTaskIds m_dltQueueResponseTimeout m_queueResponseTimeout m_dltGrabSubTaskTimeout m_processingQueue m_processingTimeout m_processingErrorSink m_queue_timestamp_ m_ownership_acquired_at_ m_ownership_last_delta_time_ m_ownershipRequestQueue m_logger m_lastQueueUpdateTime m_processedSubtasksInCurrentOwnership m_defaultMaxSubtasksPerOwnership m_maxSubtasksPerOwnership m_delayBetweenProcessingMs m_lastActiveCountCheck m_activeCountElapsed — Elapsed time since last active node count reset m_processedSubtasksInCurrentOwnership. m_waitTimeBeforeReset m_initialDelayPassed ProcessingSubTaskQueueManager ~ProcessingSubTaskQueueManager SetProcessingTimeout CreateQueue GrabSubTask MoveOwnershipTo HasOwnership ProcessSubTaskQueueMessage ProcessSubTaskQueueRequestMessage GetQueueSnapshot ChangeSubTaskProcessingStates IsQueueInit IsProcessed SetSubTaskQueueAssignmentEventSink GetCurrentQueueTimestamp SetMaxSubtasksPerOwnership UpdateQueue HandleQueueRequestTimeout PublishSubTaskQueue ProcessPendingSubTaskGrabbing GrabSubTasks HandleGrabSubTaskTimeout LogQueue HasAvailableWork UpdateQueueTimestamp CheckActiveCount CalculateGrabSubTaskTimeout UpdateUnprocessedSubTaskIndices --- source: /SuperGenius/Classes/d3/d40/classsgns_1_1processing_1_1_processing_task_queue/ title: sgns::processing::ProcessingTaskQueue (class) --- Members: ~ProcessingTaskQueue — Distributed task queue interface. EnqueueTask — Stores a task with its subtasks. EnqueueTask — Stores a task with its subtasks within an atomic transaction. GetTask — Returns a task by task id, returns failure if task not found or invalid. GetSubTasks — Retrieves the subtasks for a given task ID. GrabTask — Grabs task from the storage, returning its ID and data. CompleteTask — Completes a task with its result returning an atomic transaction to commit the completion. IsTaskCompleted — Checks if the task is completed. MarkTaskBad — Mark a task key as bad to be skipped. ListTaskKeys — Lists all known task IDs in the queue. GetTaskResult — Retrieves the completed task result, if available. --- source: /SuperGenius/Classes/d0/d2c/classsgns_1_1processing_1_1_processing_validation_core/ title: sgns::processing::ProcessingValidationCore (class) --- Members: Error — Enumeration of error codes used in the processing validation class. m_logger — Logger instance for logging within the ProcessingValidationCore class. ProcessingValidationCore ValidateResults ValidateIndividualResult CheckSubTaskResultHashes — Checks the result hashes for a given subtask against the provided chunks. --- source: /SuperGenius/Classes/d7/de8/classsgns_1_1processing_1_1_process_task_splitter/ title: sgns::processing::ProcessTaskSplitter (class) --- Members: ProcessTaskSplitter SplitTask --- source: /SuperGenius/Classes/d4/d56/structsgns_1_1_consensus_manager_1_1_proposal_state/ title: sgns::ConsensusManager::ProposalState (struct) --- Runtime state tracked for one proposal. Members: proposal — Proposal currently tracked. votes — Votes accepted for the proposal. slot_key — Slot key grouping competing proposals. total_weight — Total eligible weight for tally. approved_weight — Approved weight accumulated so far. seen_voters — Voter ids already counted. quorum_reached — Whether quorum has been reached. quorum_reached_ts_ms — Timestamp when quorum was reached. last_attempt_round — Last certificate-attempt round. --- source: /SuperGenius/Classes/d5/d75/classsgns_1_1_public_chain_input_validator/ title: sgns::PublicChainInputValidator (class) --- Validator for transactions that reference external public-chain proofs. Members: ::PublicChainInputValidatorTestAccess — Friend accessor for unit testing VerifyPublicChainSmartContract and the wired rpc_endpoints_ (mirrors BridgeRelayerTestAccess). rpc_endpoints_ registered_chain_ids_ — Chain IDs this validator registered for (self-deregistered on destruction). transport_factory_ — Pluggable transport factory for DI-based mock injection (D-07, D-14). When empty, VerifyPublicChainSmartContract uses the default RpcHttpTransport factory. RegisterForChain — Attempts to claim chain_id in the global registry and records successful claims for self-removal on destruction. ~PublicChainInputValidator SetRpcEndpoints — Configure weighted RPC endpoints for a source chain. AddRpcEndpoints — Merge weighted RPC endpoints into a source chain's existing list. ValidateUTXOParameters — Validates local UTXO structure for externally sourced claims. ValidateWitness — Validates the external witness data supplied by consensus. RequiresConsensusUTXOData — Public-chain validation does not require local UTXO witness data. SetTransportFactory — Inject a custom transport factory for DI-based mock support. GetFirstRpcUrl — Returns the first RPC endpoint URL for a given chain ID, if any exist. GetSlotHash — Returns the SHA-256 hash of an endpoint URL for a vote slot (Phase 6, D-01). GetFirstConfiguredChainId — Returns the first configured chain id, if any (Phase 6, D-01). VerifyPublicChainSmartContract — Verifies that the referenced public-chain smart-contract event matches the transaction using a weighted multi-provider RPC quorum. --- source: /SuperGenius/Classes/d1/d45/struct_key_generator_1_1_el_gamal_1_1_public_key/ title: KeyGenerator::ElGamal::PublicKey (struct) --- Members: params public_key_value — The value of the public key. PublicKey PublicKey --- source: /SuperGenius/Classes/d5/dd7/struct_public_key/ title: PublicKey (struct) --- Members: curve_type padding_policy internal_accumulator_type scalar_field_type scalar_field_value_type g1_type g1_value_type base_integral_type scalar_modular_type public_key_type signature_type pubkey PublicKey PublicKey pubkey_data --- source: /SuperGenius/Classes/da/d80/classsgns_1_1crdt_1_1_pub_sub_broadcaster_ext/ title: sgns::crdt::PubSubBroadcasterExt (class) --- Extended PubSub broadcaster that integrates with a CRDT datastore and Graphsync DAG syncer. Manages multiple gossip topics, broadcasting messages and processing incoming payloads. Members: GossipPubSub topicsToListen_ topicsToBroadcast_ dagSyncer_ messageQueue_ pubSub_ — Pubsub used to broadcast/receive messages. queueMutex_ — protects messageQueue_ listenTopicsMutex_ — protects topicsToListen_ broadcastTopicsMutex_ — protects topicsToListen_ subscriptionMutex_ — protects subscriptionFutures_ started_ m_logger subscriptionFutures_ ~PubSubBroadcasterExt Broadcast — Sends the given buffer as a broadcast to peers. Next — Retrieves the next incoming broadcast payload. Start — Subscribes to all configured topics and starts message processing. Must be called before using Next() to receive incoming messages. AddBroadcastTopic — Adds a new topic by name. AddListenTopic — Subscribe to a given topic and store its future. HasTopic — Checks whether the given topic is already registered. GetDagSyncer — Get the underlying GraphsyncDAGSyncer instance. Stop AddSingleCIDInfo New — Factory method to create a broadcaster for multiple topics. PubSubBroadcasterExt — Private constructor initializing members with provided topics and syncer. OnMessage AddMultiCIDInfo --- source: /SuperGenius/Classes/db/d65/struct_quality_filter_state/ title: QualityFilterState (struct) --- Members: fail_counts ip_fail_counts port_fail_counts subnet_enqueue_counts blocked_pubkeys blocked_ips blocked_ports block_threshold ip_block_threshold port_block_threshold subnet_enqueue_limit --- source: /SuperGenius/Classes/d9/dc6/structsgns_1_1multisig_1_1_quorum_result/ title: sgns::multisig::QuorumResult (struct) --- Result of an N-of-M quorum evaluation. Members: has_quorum — True when valid_unique_count >= required signatures. valid_unique_count — Count of distinct authorized signers with a valid signature. --- source: /SuperGenius/Classes/d1/dce/structsgns_1_1_consensus_manager_1_1_quorum_tally/ title: sgns::ConsensusManager::QuorumTally (struct) --- Quorum tally structure. Members: total_weight — The total maximum weight of the quorum. approved_weight — The weight which was already approved. has_quorum — Flag indicating if quorum was reached. qualified_sum — Slot-weighted qualified contribution. slot_threshold — total_voting_reputation * 0.75 (D-06). --- source: /SuperGenius/Classes/dc/d9e/structsgns_1_1storage_1_1face_1_1_readable/ title: sgns::storage::face::Readable (struct) --- A mixin for read-only map. K key type V value type Members: ~Readable get — Get value by key. contains — Returns true if given key-value binding exists in the storage. empty — Returns true if the storage is empty. --- source: /SuperGenius/Classes/d6/d8f/structsgns_1_1storage_1_1face_1_1_read_only_map/ title: sgns::storage::face::ReadOnlyMap (struct) --- An abstraction over a readable and iterable key-value map. K key type V value type --- source: /SuperGenius/Classes/d4/df7/structeth_1_1codec_1_1_receipt/ title: eth::codec::Receipt (struct) --- Members: state_root status cumulative_gas_used bloom logs --- source: /SuperGenius/Classes/d2/d2a/structeth_1_1_receipt_batch/ title: eth::ReceiptBatch (struct) --- Receipts from one block, normalized across RLPx, RPC, or certified sources. Members: receipts tx_hashes log_indices block_number block_hash --- source: /SuperGenius/Classes/d8/d15/structeth_1_1_receipt_log_verification_result/ title: eth::ReceiptLogVerificationResult (struct) --- Members: error operator bool --- source: /SuperGenius/Classes/dc/d62/structeth_1_1_receipt_result/ title: eth::ReceiptResult (struct) --- Receipt plus the chain context needed to verify and deduplicate a log. Members: receipt tx_hash block_number block_hash log_indices --- source: /SuperGenius/Classes/db/d41/structeth_1_1_receipts_message/ title: eth::ReceiptsMessage (struct) --- Members: request_id receipts --- source: /SuperGenius/Classes/d3/d2f/classsgns_1_1_recursive_transfer_proof/ title: sgns::RecursiveTransferProof (class) --- A class for generating a recursive Transfer Proof. RecursiveTransferProof is a derived class from IBasicProof, providing the specific implementation for generating the parameters to create a recursive snark Members: RECURSIVE_TRANSFER_TYPE_NAME — Constant representing the transfer proof type name. registered — Static variable to ensure registration happens on inclusion of header file. RecursiveTransferProof — Constructor for the RecursiveTransferProof class. ~RecursiveTransferProof — Destructor for the RecursiveTransferProof class. GetProofType — Retrieves the type of proof for recursive transfers. SerializeFullProof — Serializes the full proof data and parameters. GenerateJsonParameters — Generates the parameters in JSON array form. DeSerializePublicParams — Deserializes public parameters from the provided proof data. Register — Registers the deserializer and bytecode for the recursive transfer proof type. --- source: /SuperGenius/Classes/d3/d7a/structeth_1_1rpc_1_1_rpc_receipt_source_1_1_registered_filter/ title: eth::rpc::RpcReceiptSource::RegisteredFilter (struct) --- Members: id filter --- source: /SuperGenius/Classes/df/dd6/structsgns_1_1_i_input_validator_1_1_registry_state/ title: sgns::IInputValidator::RegistryState (struct) --- Members: mutex validators --- source: /SuperGenius/Classes/d5/da9/structsgns_1_1_transaction_manager_1_1_replay_protection_result/ title: sgns::TransactionManager::ReplayProtectionResult (struct) --- Members: validation --- source: /SuperGenius/Classes/dc/d28/structsgns_1_1_account_messenger_1_1_request_task/ title: sgns::AccountMessenger::RequestTask (struct) --- Members: type timeout_ms silent_time_ms block_index cid utxo_address callback nonce_promise utxo_promise --- source: /SuperGenius/Classes/d0/d41/structintx_1_1result__with__carry/ title: intx::result_with_carry (struct) --- Contains result of add/sub/etc with a carry flag. Members: value carry operator std::tuple< T &, bool & > — Conversion to tuple of references, to allow usage with std::tie(). --- source: /SuperGenius/Classes/db/d5d/classrlp_1_1_rlp_chunked_list_decoder/ title: rlp::RlpChunkedListDecoder (class) --- Members: view_ list_payload_ total_size_ total_chunks_ chunk_index_ initialized_ RlpChunkedListDecoder RlpChunkedListDecoder peekTotalSize peekChunkCount readChunk currentChunkIndex totalChunks totalSize isFinished isInitialized remaining --- source: /SuperGenius/Classes/df/d25/classrlp_1_1_rlp_chunked_list_encoder/ title: rlp::RlpChunkedListEncoder (class) --- Members: encoder_ chunk_size_ buffer_ chunk_count_ total_bytes_ finished_ list_started_ create ~RlpChunkedListEncoder addChunk finish chunkCount totalBytes isFinished RlpChunkedListEncoder operator= RlpChunkedListEncoder operator= RlpChunkedListEncoder flushBuffer --- source: /SuperGenius/Classes/d6/db2/classrlp_1_1_rlp_decoder/ title: rlp::RlpDecoder (class) --- Members: view_ RlpDecoder IsFinished Remaining IsList IsString PeekPayloadSizeBytes PeekHeader read read read ReadListHeaderBytes SkipItem read check_payload read_vector read read read PeekPayload decode read_integral read_bool read_uint256 decode_header_internal skip_header_internal --- source: /SuperGenius/Classes/d7/d55/classrlp_1_1_rlp_encoder/ title: rlp::RlpEncoder (class) --- Members: buffer_ list_start_positions_ RlpEncoder add AddRaw add add BeginList EndList add add add GetBytes GetBytes MoveBytes clear size reserve add_integral --- source: /SuperGenius/Classes/de/ddd/classrlp_1_1_rlp_large_string_decoder/ title: rlp::RlpLargeStringDecoder (class) --- Members: view_ payload_size_ bytes_read_ initialized_ RlpLargeStringDecoder RlpLargeStringDecoder peekPayloadSize readChunk currentPosition totalSize isFinished isInitialized remaining --- source: /SuperGenius/Classes/d6/d32/classrlp_1_1_rlp_large_string_encoder/ title: rlp::RlpLargeStringEncoder (class) --- Members: encoder_ header_start_ payload_start_ payload_size_ finished_ create addChunk finish payloadSize isFinished ~RlpLargeStringEncoder RlpLargeStringEncoder operator= RlpLargeStringEncoder operator= RlpLargeStringEncoder --- source: /SuperGenius/Classes/dd/d5d/classeth_1_1_rlpx_eth_session_channel/ title: eth::RlpxEthSessionChannel (class) --- RlpxSession adapter implementing the minimal ETH session seam. Members: session_ RlpxEthSessionChannel negotiated_eth_version negotiated_eth_offset peer_info post_message receive_message receive_message_with_timeout set_eth_message_handler --- source: /SuperGenius/Classes/d4/de4/classrlpx_1_1_rlpx_session/ title: rlpx::RlpxSession (class) --- RLPx session managing encrypted P2P communication. Members: state_ stream_ peer_info_ negotiated_eth_version_ negotiated_eth_offset_ is_initiator_ send_channel_ recv_channel_ hello_handler_ disconnect_handler_ ping_handler_ pong_handler_ generic_handler_ eth_message_handler_ connect — Factory for outbound connections. connect — Factory for outbound connections, returning a peer disconnect reason if the peer sends Disconnect before HELLO. accept — Factory for inbound connections. negotiate_eth_version_for_test — Test helper that selects the highest supported ETH version from capabilities. negotiate_eth_offset_for_test — Test helper that computes the negotiated ETH wire offset from capabilities. normalize_eth_message_id_for_test — Test helper that normalizes a wire-level ETH message id using the negotiated offset. ~RlpxSession RlpxSession operator= RlpxSession operator= post_message — Send message (takes ownership via move). receive_message_with_timeout — Receive message with timeout during protocol startup handshakes. receive_message — Receive message (stackful coroutine pull model). disconnect — Graceful disconnect (sync, callable from callbacks). disconnect — Graceful disconnect (coroutine overload). set_hello_handler set_disconnect_handler set_ping_handler set_pong_handler set_generic_handler set_eth_message_handler state is_active peer_info negotiated_eth_version — Return the negotiated ETH subprotocol version from HELLO capability matching. negotiated_eth_offset — Return the negotiated ETH subprotocol message-id base offset. cipher_secrets RlpxSession run_send_loop run_receive_loop route_message try_transition_state is_terminal_state force_error_state --- source: /SuperGenius/Classes/d5/dbf/classsgns_1_1storage_1_1rocksdb/ title: sgns::storage::rocksdb (class) --- An implementation of PersistentBufferMap interface, which uses rocksdb as underlying storage. Members: Iterator Options ReadOptions WriteOptions DB Status Slice QueryResult KeyValuePair db_ ro_ wo_ logger_ options_ path_ ~rocksdb setReadOptions — Set read options, which are used in. setWriteOptions — Set write options, which are used in. cursor — Returns new key-value iterator. batch — Creates new Write Batch - an object, which can be used to efficiently write bulk data. get query query — Queries with a middle part that can be a wildcard, negated string or normal string. contains empty — Returns true if the storage is empty. put put remove GetName getDB GetAll — Gets all key value pairs on rocksdb. create — Factory method to create an instance of rocksdb class. create — Factory method to create an instance of rocksdb class. --- source: /SuperGenius/Classes/d1/de1/structsgns_1_1crdt_1_1_crdt_datastore_1_1_root_c_i_d_job/ title: sgns::crdt::CrdtDatastore::RootCIDJob (struct) --- Members: node_ — Current node to process. root_node_ — Root node of the Job. created_by_self_ — True if the root node was created by self. --- source: /SuperGenius/Classes/d1/d1e/structeth_1_1rpc_1_1_rpc_endpoint/ title: eth::rpc::RpcEndpoint (struct) --- Members: chain_name chain_id url priority weight rate_limit_per_second is_paid is_public verified state last_failure_time failure_count backoff_until --- source: /SuperGenius/Classes/d5/df4/structeth_1_1rpc_1_1_rpc_endpoint_config/ title: eth::rpc::RpcEndpointConfig (struct) --- One configured RPC endpoint for a chain. Members: chain_name chain_id url_template api_key_env_var api_key_literal priority weight rate_limit_per_second is_paid is_public verified --- source: /SuperGenius/Classes/da/d25/structeth_1_1rpc_1_1_rpc_endpoint_error/ title: eth::rpc::RpcEndpointError (struct) --- Members: code detail --- source: /SuperGenius/Classes/dc/d23/structeth_1_1rpc_1_1_rpc_endpoint_group/ title: eth::rpc::RpcEndpointGroup (struct) --- Members: chain_name chain_id endpoints --- source: /SuperGenius/Classes/d7/d02/classeth_1_1rpc_1_1_rpc_endpoint_pool/ title: eth::rpc::RpcEndpointPool (class) --- Members: kMaxBackoff kBaseBackoff kEscalationWindow kEscalationThreshold endpoints_ RpcEndpointPool RpcEndpointPool endpoints endpoints next_endpoint next_endpoint mark_temporary_failure disable reset_temporary_failures is_usable --- source: /SuperGenius/Classes/d5/d90/classeth_1_1rpc_1_1_rpc_http_transport/ title: eth::rpc::RpcHttpTransport (class) --- Members: endpoint_url_ options_ RpcHttpTransport call endpoint_url HttpsGet — Perform a one-shot HTTPS GET and return the response body. parse_url --- source: /SuperGenius/Classes/d2/dad/structeth_1_1rpc_1_1_rpc_http_transport_options/ title: eth::rpc::RpcHttpTransportOptions (struct) --- Members: timeout verify_peer --- source: /SuperGenius/Classes/dd/d5a/structeth_1_1rpc_1_1_rpc_log/ title: eth::rpc::RpcLog (struct) --- Members: log block_number block_hash tx_hash log_index --- source: /SuperGenius/Classes/d5/d8b/classeth_1_1rpc_1_1_rpc_manager/ title: eth::rpc::RpcManager (class) --- Members: groups_ pools_ RpcManager endpoint_groups pool pool make_chain_key --- source: /SuperGenius/Classes/d3/d20/structeth_1_1rpc_1_1_rpc_manager_config/ title: eth::rpc::RpcManagerConfig (struct) --- Top-level RPC manager configuration. Members: max_endpoints_per_chain endpoints --- source: /SuperGenius/Classes/d8/d01/classeth_1_1rpc_1_1_rpc_receipt_source/ title: eth::rpc::RpcReceiptSource (class) --- Members: transport_ finality_policy_ last_processed_block_ max_log_range_ next_rpc_id_ next_watch_id_ filters_ handler_ RpcReceiptSource add_filter — Let the source optimize acquisition around the same filter used by EthWatchService. remove_filter — Remove a previously registered acquisition filter. set_receipt_batch_handler — Set the handler that receives normalized receipt batches. get_receipt — Fetch one receipt by transaction hash when the source supports lookup verification. last_processed_block finality_head poll_once backfill next_request_id get_block_number backfill_filter emit_receipt --- source: /SuperGenius/Classes/de/d1b/structeth_1_1rpc_1_1_rpc_receipt_source_handle/ title: eth::rpc::RpcReceiptSourceHandle (struct) --- Members: transport source --- source: /SuperGenius/Classes/dc/d12/structeth_1_1_eth_watch_service_1_1_runtime_chain/ title: eth::EthWatchService::RuntimeChain (struct) --- Members: config scheduler peer_queue discovery_client discv5_client discv4_fallback_started discv5_enr_tree_started discv5_cache_enr_started stats --- source: /SuperGenius/Classes/d3/d10/classsgns_1_1_scaled_integer/ title: sgns::ScaledInteger (class) --- Represents a decimal value using an integer scaled by 10^precision. Internally stores the decimal as an integer multiplied by 10^precision. Example: raw_value = 12345, precision = 2 => decimal value 123.45 Members: ParseMode — Controls handling of extra fractional digits when parsing. value_ precision_ New — Create a ScaledInteger from a raw integer and precision. New — Create a ScaledInteger from a double and precision. New — Create a ScaledInteger from a string and precision. New — Create a ScaledInteger from a decimal string by inferring precision. ScaleFactor — Compute 10^precision as the scale factor. FromString — Convert a numeric string to a raw scaled integer. ToString — Convert a scaled integer to a string representation. FromDouble — Convert a double to a raw scaled integer. Multiply — Multiply two raw scaled integers. Divide — Divide two raw scaled integers. ConvertPrecision — Change the precision of a raw scaled integer. Value — Get the raw scaled integer value. Precision — Get the precision (number of decimal places). ToString — Return this value as a string. Add — Add another ScaledInteger with matching precision. Subtract — Subtract another ScaledInteger with matching precision. Multiply — Multiply by another ScaledInteger with matching precision. Divide — Divide by another ScaledInteger with matching precision. ConvertPrecision — Convert this ScaledInteger to a different precision. ScaledInteger — Private constructor storing raw scaled integer and precision. --- source: /SuperGenius/Classes/dd/da9/classsgns_1_1securecrdt_1_1_secure_crdt/ title: sgns::securecrdt::SecureCrdt (class) --- Mandatory wrapper for reading/writing registered SecureCrdt keys. `ProposeValue`/`AddSignature` are the only sanctioned callers of `GlobalDB::Put` for a registered key (D-03). `ReadIfQuorum` never writes and always re-derives trust from the current base_key value plus all `sig/` children (D-04) -- no "final" marker key is ever written or read by this class. Members: Error — Error codes returned by SecureCrdt's write/read operations. db_ topic_ logger_ SecureCrdt — Constructs a SecureCrdt wrapper over an existing GlobalDB instance. ProposeValue — Proposes a value for a registered base_key. Runs the SAME codec/semantic check the remote filter callback runs on a base_key element (DeserializeFromBytes + Verify) BEFORE ever calling Put closes the local/remote asymmetry gap (T-09-10). Proposing a value has no signature requirement by itself; it only becomes trusted once quorum-worth of sig-entries exist (D-04), so this is not a bypass of D-03. AddSignature — Adds a signature over the CURRENT value at base_key. Fetches the value fresh via GlobalDB::Get each call (never a cached/stale value, closing the replay threat T-09-07) and verifies it via multisig::VerifyPayloadSignature before ever calling Put an invalid signature is never persisted (D-03 local-write gate). ReadIfQuorum — Returns the current value at base_key only once the required number of valid unique signatures from the registered signer set are present (D-04 quorum re-derivation); returns std::nullopt if quorum is not yet met. RegisterFilters — Self-registration entry point: registers the element filter (D-03 second, independent enforcement layer for remote- originated deltas) for every currently-registered SecureCrdtRegistry entry. Must be called once after construction (e.g. from a New(...)-style factory), mirroring ValidatorRegistry::RegisterFilter's call-from-factory convention. FilterSecureCrdtUpdate — Filter callback re-running the identical enforcement logic as AddSignature's/ProposeValue's local gate, for remote-originated deltas only (crdt_datastore.cpp, !created_by_self). Rejects (returns an empty vector) on parse failure or invalid signature/value, accepts (returns std::nullopt) otherwise. Derives the concrete base key from element.key() so registry patterns containing regular expressions are never used as datastore keys. --- source: /SuperGenius/Classes/d1/dfb/classsgns_1_1securecrdt_1_1_secure_crdt_registry/ title: sgns::securecrdt::SecureCrdtRegistry (class) --- Static registry resolving a CRDT key to its SecureCrdtRegistryEntry. Members: Register — Registers (or replaces) the policy entry for key_pattern. Compiles compiled_pattern as "/?" + key_pattern + "(/sig/[^/]+)?" so both the base key and a valid sig/ child resolve to the same entry - mirrors CRDTDataFilter::RegisterElementFilter's regex shape (src/crdt/impl/crdt_data_filter.cpp). UnregisterIf — Removes the registration for key_pattern only if the caller's token matches the token supplied at Register() time (compare-and-remove, prevents a second unrelated registration from clobbering removal). Resolve — Resolves key against all registered patterns, returning the first matching entry (base_key or any sig/ child). AllEntries — Returns a snapshot copy of every currently-registered entry. Used by SecureCrdt::RegisterFilters to self-register a filter callback for each registered base_key pattern at startup. registry registryMutex --- source: /SuperGenius/Classes/d6/d12/structsgns_1_1securecrdt_1_1_secure_crdt_registry_entry/ title: sgns::securecrdt::SecureCrdtRegistryEntry (struct) --- Policy entry describing how a registered key pattern is verified and instantiated. Members: key_pattern signer_set_source make_instance compiled_pattern owner_token — Opaque token supplied by the caller at Register() time; must be presented verbatim to UnregisterIf() to remove this entry. --- source: /SuperGenius/Classes/d6/ded/class_session/ title: Session (class) --- Members: stream_ incoming_ Session read write close operator< --- source: /SuperGenius/Classes/d5/dec/structrlpx_1_1_session_accept_params/ title: rlpx::SessionAcceptParams (struct) --- Members: local_public_key local_private_key client_id listen_port --- source: /SuperGenius/Classes/d5/d37/structrlpx_1_1_session_connect_params/ title: rlpx::SessionConnectParams (struct) --- Members: remote_host remote_port local_public_key local_private_key peer_public_key client_id listen_port progress_handler --- source: /SuperGenius/Classes/d9/d14/structdiscv5_1_1discv5__client_1_1_session_state/ title: discv5::discv5_client::SessionState (struct) --- Members: write_key read_key remote_node_addr remote_node_id last_req_id --- source: /SuperGenius/Classes/d0/d9a/structsha3__context__/ title: sha3_context_ (struct) --- Members: saved byteIndex wordIndex capacityWords --- source: /SuperGenius/Classes/dc/dbf/structsgns_1_1securecrdt_1_1_signer_set_snapshot/ title: sgns::securecrdt::SignerSetSnapshot (struct) --- Snapshot of an authorized signer set and its required signature count, as produced by an injected SignerSetSource. Members: signer_set required_signatures --- source: /SuperGenius/Classes/dd/d8c/structsgns_1_1_validator_registry_1_1_slot_quorum_result/ title: sgns::ValidatorRegistry::SlotQuorumResult (struct) --- Result of the Phase 6 cumulative slot-quorum tally (D-06). Deterministic across peers: computed ONLY from the vote vector and a registry snapshot (REQ-DETERM-01). No clocks, no local config, no node state is consulted. Members: qualified_sum — Sum of slot-weighted contributions (D-06). total_voting_reputation — Sum of weight of ALL approve voters. threshold — ceil(total * slot_quorum_numerator_ / slot_quorum_denominator_). has_quorum — qualified_sum > threshold (STRICT, D-06). --- source: /SuperGenius/Classes/df/d49/structsgns_1_1_consensus_manager_1_1_slot_state/ title: sgns::ConsensusManager::SlotState (struct) --- Runtime slot arbitration state. Members: best_proposal_id — Current best proposal id in the slot. best_tx_hash — Hash used for deterministic tie-breaking. voted_proposal_ids — Local proposal ids already voted for. --- source: /SuperGenius/Classes/d0/d01/classrlpx_1_1socket_1_1_socket_transport/ title: rlpx::socket::SocketTransport (class) --- Transport layer abstraction over TCP socket. Provides async read/write operations with proper error handling. Members: tcp Strand socket_ strand_ — Ensures thread-safe sequential operations. SocketTransport — Create transport from connected socket. SocketTransport operator= SocketTransport operator= read_exact — Async read exact number of bytes. write_all — Async write all bytes. close — Close socket gracefully. is_open — Query connection state. remote_address remote_port local_address local_port --- source: /SuperGenius/Classes/de/d6c/structdiscv5_1_1_static_header_wire/ title: discv5::StaticHeaderWire (struct) --- discv5 static packet header, as defined by the EIP-8020 spec. Mirrors go-ethereum's v5wire.StaticHeader struct. Sits immediately after the MaskingIvWire in every packet. All multi-byte integers are big-endian on the wire. Members: protocol_id — "discv5" magic (0x64 69 73 63 76 35) version — Protocol version (current = 1) flag — Packet type flag (0=msg, 1=WHOAREYOU, 2=handshake) nonce — AES-GCM nonce. auth_size — Byte count of the auth-data section. --- source: /SuperGenius/Classes/dd/db6/structeth_1_1_status_message68/ title: eth::StatusMessage68 (struct) --- ETH/68 Status message. Wire: [version, networkid, td, blockhash, genesis, forkid]. Members: protocol_version network_id td blockhash genesis_hash fork_id --- source: /SuperGenius/Classes/d0/d02/structeth_1_1_status_message69/ title: eth::StatusMessage69 (struct) --- ETH/69 Status message. Wire: [version, networkid, genesis, forkid, earliestBlock, latestBlock, latestBlockHash]. Members: protocol_version network_id genesis_hash fork_id earliest_block latest_block latest_block_hash --- source: /SuperGenius/Classes/d4/de2/classsgns_1_1subscription_1_1_subscriber/ title: sgns::subscription::Subscriber (class) --- Is a wrapper class, which provides subscription to events from SubscriptionEngine Key is a type of a subscription Key. Type is a type of an object to receive notifications in. Arguments is a set of types of objects needed to construct Type. Members: KeyType ValueType HashType SubscriptionSetId SubscriptionEngineType SubscriptionEnginePtr CallbackFnType SubscriptionsContainer SubscriptionsSets next_id_ engine_ object_ subscriptions_cs_ subscriptions_sets_ on_notify_callback_ Subscriber ~Subscriber Subscriber operator= Subscriber operator= setCallback generateSubscriptionSetId subscribe unsubscribe unsubscribe unsubscribe on_notify --- source: /SuperGenius/Classes/dd/d2b/structeth_1_1_eth_receipt_source_bridge_1_1_subscription/ title: eth::EthReceiptSourceBridge::Subscription (struct) --- Members: service_id source_id --- source: /SuperGenius/Classes/dd/ddd/structeth_1_1_eth_watch_service_1_1_subscription/ title: eth::EthWatchService::Subscription (struct) --- Members: id event_signature params callback --- source: /SuperGenius/Classes/d1/d66/structeth_1_1_event_watcher_1_1_subscription/ title: eth::EventWatcher::Subscription (struct) --- Members: id filter callback --- source: /SuperGenius/Classes/d7/d3a/classsgns_1_1subscription_1_1_subscription_engine/ title: sgns::subscription::SubscriptionEngine (class) --- Members: KeyType ValueType SubscriberType SubscriberPtr SubscriberWPtr SubscribersContainer IteratorType KeyValueContainer Subscriber subscribers_map_cs_ subscribers_map_ SubscriptionEngine ~SubscriptionEngine SubscriptionEngine operator= SubscriptionEngine operator= size notify subscribe unsubscribe --- source: /SuperGenius/Classes/d2/d46/classsgns_1_1processing_1_1_sub_task_enqueuer/ title: sgns::processing::SubTaskEnqueuer (class) --- Members: ~SubTaskEnqueuer EnqueueSubTasks MarkTaskBad --- source: /SuperGenius/Classes/d1/d37/classsgns_1_1processing_1_1_sub_task_enqueuer_impl/ title: sgns::processing::SubTaskEnqueuerImpl (class) --- Members: m_taskQueue m_logger SubTaskEnqueuerImpl EnqueueSubTasks MarkTaskBad --- source: /SuperGenius/Classes/dd/d1c/classsgns_1_1processing_1_1_sub_task_queue_accessor/ title: sgns::processing::SubTaskQueueAccessor (class) --- Subtask queue accessor interface Members: SubTaskGrabbedCallback ~SubTaskQueueAccessor ConnectToSubTaskQueue AssignSubTasks GrabSubTask CompleteSubTask CreateResultsChannel --- source: /SuperGenius/Classes/d0/dab/classsgns_1_1processing_1_1_sub_task_queue_accessor_impl/ title: sgns::processing::SubTaskQueueAccessorImpl (class) --- Subtask queue accessor implementation. Members: FinalizationRetVal WorkGuard m_gossipPubSub m_subTaskQueueManager m_subTaskResultStorage m_taskResultProcessingSink m_processingErrorSink m_localContext m_localWorkGuard m_localThread m_stateTimer m_resultChannel m_mirrorResultCallback — Invoked when a mirrored result arrives. m_mutexMirrorCallback m_bitswap — For data availability checks on IPFS results. m_mutexResults m_results m_validationCore m_logger SubTaskQueueAccessorImpl ~SubTaskQueueAccessorImpl ConnectToSubTaskQueue AssignSubTasks GrabSubTask CompleteSubTask CreateResultsChannel setMirrorResultCallback — Set callback invoked when a mirrored result arrives. The callback receives the ipfs_results_data_id string. setBitswap — Set bitswap instance for data availability checks on IPFS results. GetResults OnResultReceived OnSubTaskQueueAssigned UpdateResultsFromStorage FinalizeQueueProcessing StartPeriodicStateBroadcast ScheduleStateBroadcast PublishExistingResults FindSubTaskById ValidateResultData — Validate result output scheme (9a) and optionally check IPFS data availability (9b). OnResultChannelMessage --- source: /SuperGenius/Classes/d0/d47/classsgns_1_1processing_1_1_sub_task_result_storage/ title: sgns::processing::SubTaskResultStorage (class) --- Handles subtask results storage Members: ~SubTaskResultStorage AddSubTaskResult RemoveSubTaskResult GetSubTaskResults --- source: /SuperGenius/Classes/d3/df7/classsgns_1_1processing_1_1_sub_task_result_storage_impl/ title: sgns::processing::SubTaskResultStorageImpl (class) --- Handles subtask result storage. Members: m_db m_processing_topic SubTaskResultStorageImpl ~SubTaskResultStorageImpl AddSubTaskResult RemoveSubTaskResult GetSubTaskResults --- source: /SuperGenius/Classes/d6/dea/structsgns_1_1_genius_assigner_1_1_table_vectors/ title: sgns::GeniusAssigner::TableVectors (struct) --- Members: witness_values public_input_values constant_values selector_values --- source: /SuperGenius/Classes/d9/df3/classsgns_1_1processing_1_1_task_keys/ title: sgns::processing::TaskKeys (class) --- Members: PROCESSING_PREFIX_BASE TASK_LIST_SUFFIX SUBTASK_LIST_SUFFIX CLAIMABLE_LIST_SUFFIX RESULTS_SUFFIX LOCK_KEY_PREFIX ProcessingPrefix — Returns the processing base prefix for the task queue. TaskListKey SubTaskListKey SubTaskListKey TaskKey SubTaskKey ClaimableListKey ClaimableTaskKey ResultTaskKey LockKey --- source: /SuperGenius/Classes/dd/ddf/classsgns_1_1processing_1_1_task_queue_impl/ title: sgns::processing::TaskQueueImpl (class) --- Implements the task storage on CRDT. Members: LOCK_TIMEOUT db_ — The CRDT database instance used for storing tasks and subtasks. processing_topic_ — The topic used by CRDT to share tasks and subtasks across the network. incompatible_jobs_ — Jobs (tasks) that are incompatible with ProcessingManager. New — Factory method to create a TaskQueueImpl instance. ~TaskQueueImpl EnqueueTask — Stores a task with its subtasks within an atomic transaction. GetTask — Returns a task by task id, returns failure if task not found or invalid. GetSubTasks — Retrieves the subtasks for a given task ID. GrabTask — Grabs task from the storage, returning its ID and data. CompleteTask — Completes a task with its result returning an atomic transaction to commit the completion. IsTaskCompleted — Checks if the task is completed. MarkTaskBad — Mark a task key as bad to be skipped. ListTaskKeys — Lists all known task IDs in the queue. GetTaskResult — Retrieves the completed task result, if available. TaskQueueImpl — Constructs a task queue implementation with the given database and processing topic. IsTaskLocked — Checks if a task is currently locked. LockTask — Locks a task for processing by creating a lock entry in the database. MoveExpiredTaskLock — Try to aquire lock for an expired task, if successful, loads the task data and returns true, otherwise returns false. --- source: /SuperGenius/Classes/dd/dd7/classsgns_1_1_token_amount/ title: sgns::TokenAmount (class) --- Utility for GNUS token fixed-point parsing, formatting and cost calculation. Members: PRECISION — Fixed-point precision (1 minion = 10^-6 GNUS) PRICE_PER_FLOP — USD per FLOP rate scaled by 10^15. PRICE_PER_FLOP_FRACTIONAL_DIGITS — Fractional digits used in USD/FLOP rate. FLOPS_PER_BYTE — Estimated number of FLOPs required per byte. MIN_MINION_UNITS — Minimum representable non-zero minion units. minions_ — Internal representation in minion units (GNUS * 10^6) New — Creates a TokenAmount from already-scaled minion units. New — Creates a TokenAmount from a floating point value. The value is rounded to 6 decimal digits internally. New — Creates a TokenAmount from a decimal string. ParseMinions — Parses a token amount string into raw minion units. FormatMinions — Converts raw minion units to a token string. CalculateCostMinions — Calculates token cost for a given byte size and USD price. ConvertToChildToken ConvertFromChildToken Multiply — Multiplies this TokenAmount by another. Divide — Divides this TokenAmount by another. Value — Returns the raw scaled integer (minion) value. TokenAmount — Constructs a TokenAmount directly from raw minion units. --- source: /SuperGenius/Classes/d9/dd1/classsgns_1_1_token_i_d/ title: sgns::TokenID (class) --- Represents a 32-byte token identifier while preserving legacy GNUS semantics. Members: Endianness — Byte order used when converting integer token identifiers. ByteArray — Fixed-size byte storage used for token identifiers. data_ — Raw 32-byte token identifier storage. valid_ — Whether the identifier was constructed from non-empty byte input. TokenID — Constructs an invalid or legacy-default token identifier. TokenID — Copy-constructs a token identifier. TokenID — Move-constructs a token identifier. operator= — Copy-assigns a token identifier. operator= — Move-assigns a token identifier. bytes — Returns the raw 32-byte storage buffer. size — Returns 32 for valid token identifiers or 0 for legacy-invalid ones. operator== — Tests exact equality including validity state. operator!= — Tests exact inequality including validity state. operator< — Orders token identifiers by raw byte value. ToHex — Converts the token identifier to a lowercase hexadecimal string. IsGNUS — Returns true when this identifier refers to the default GNUS token. Equals — Compares token identifiers while treating all GNUS representations as equivalent. FromBytes — Builds a token identifier from a byte initializer list. FromBytes — Builds a token identifier from up to 32 bytes, left-padding shorter inputs. FromUint256 — Builds a token identifier from a 256-bit integer value. ResolveEndianness — Resolves HOST to the actual runtime byte order. --- source: /SuperGenius/Classes/d1/dc6/structsgns_1_1_transaction_manager_1_1_tracked_tx/ title: sgns::TransactionManager::TrackedTx (struct) --- Members: tx status cached_nonce --- source: /SuperGenius/Classes/d2/dc7/structeth_1_1codec_1_1_transaction/ title: eth::codec::Transaction (struct) --- Full Ethereum transaction covering legacy, EIP-2930 and EIP-1559 formats. Members: type nonce gas_limit to — Empty for contract creation. value data gas_price max_priority_fee_per_gas max_fee_per_gas access_list chain_id v r s --- source: /SuperGenius/Classes/d8/da8/structsgns_1_1_transaction_manager_1_1_transaction_completion/ title: sgns::TransactionManager::TransactionCompletion (struct) --- Value delivered when an asynchronous outgoing-transaction wait completes. A terminal transaction status has an empty error. Timeouts and manager shutdown report timed_out and operation_aborted, respectively. Members: transaction_id status elapsed error --- source: /SuperGenius/Classes/df/d45/structsgns_1_1_account_messenger_1_1_transaction_hash_request/ title: sgns::AccountMessenger::TransactionHashRequest (struct) --- Members: tx_hash --- source: /SuperGenius/Classes/d2/d58/classsgns_1_1_transaction_manager/ title: sgns::TransactionManager (class) --- Coordinates transaction creation, CRDT propagation, verification, and status tracking. Members: State — State of the Transaction Manager. TransactionStatus — Status of a transaction. WitnessValidationResult TransactionPair TransactionBatch TransactionItem StateChangeCallback TransactionCompletionCallback TransactionParserFn GNUS_FULL_NODES_TOPIC GNUS_FULL_NODES_TOPIC_LEGACY NONCE_REQUEST_TIMEOUT_MS — Unified timeout for all nonce requests. BURN_BASIS_POINTS_DEFAULT BASIS_POINTS_TOTAL GeniusNode Migration3_6_0To3_7_0 CertificateFallbackTestAccess TransactionManagerPendingLifecycleTestAccess TRANSACTION_BASE_FORMAT PERIODIC_SYNC_INTERVAL INITIAL_PERIODIC_SYNC_INTERVAL TIMESTAMP_TOLERANCE MUTABILITY_WINDOW DEFAULT_NONCE_WINDOW k_init_tx_request_cooldown_ms kBridgeExecutedPrefix — Bridge mint reservation/persistence constants. kBridgeKeySeparator transaction_parsers GENIUS_CHAIN_ID globaldb_m ctx_m account_m blockchain_ full_node_m subnet_id_ — Subnet ID from config (reserved). full_node_topic_m — formatted full-node topic state_m state_change_callback_mutex_ state_change_callback_ last_head_request_time_ last_periodic_sync_time_ received_first_periodic_sync_response_ mutex_m tx_queue_m tx_mutex_m tx_processed_m account_utxo_state_mutex_ account_utxo_state_ utxo_state_tracking_suppression_ pending_proposals_ task_m stopped_ payout_submission_mutex_ transaction_waits_mutex_ transaction_waits_ timestamp_tolerance_m mutability_window_m nonce_window_m metrics_cert_fallback_success_ metrics_cert_fallback_failure_ metrics_validation_approve_ metrics_validation_reject_ metrics_tracking_insert_ metrics_tracking_confirm_ metrics_tracking_fail_ burn_basis_points_ — Live, cached burn-rate basis-points value (BURN-02, BURN-03). Refreshed via BurnConfig::RegisterRefreshCallback; never a direct CRDT read. cv_mutex_ cv_ new_data_queue_ deleted_data_queue_ last_loop_time_ topic_names_registered_ listening_topics_started_ core_started_ missing_tx_mutex_ missing_tx_hashes_ last_init_tx_request_time_ last_nonce_request_time_ m_logger genius_input_validator_ public_chain_input_validator_ New — Factory constructor of the TransactionManager. GetTransactionPath GetTransactionPath GetTransactionPath GetTransactionProofPath FetchTransaction — Fetches and deserializes a transaction from the CRDT by key. DeSerializeTransaction StateToString GetBlockChainBase — Builds the blockchain key prefix "/bc-/" for the given network. GetBlockChainBase — Overload using the current network ID. DeSerializeTransaction DeSerializeEmbeddedTransaction — Deserializes from EmbeddedTransaction proto oneof field. Dispatches on the oneof case instead of manual type string lookup. ~TransactionManager Start RegisterTopicNames StartListeningTopics StartCore GetOutTransactions GetInTransactions CountTransactions TransferFunds — Creates and enqueues a transfer transaction. MintFunds — Creates and enqueues a mint transaction. MigrationFunds — Creates and enqueues a one-time migration mint transaction. HoldEscrow — Creates and enqueues an escrow-hold transaction. PayEscrow AsyncPayEscrow — Submits an escrow payout and observes it without blocking for confirmation. AsyncWaitForTransactionOutgoing — Asynchronously observes an already-tracked outgoing transaction. WaitForTransactionIncoming WaitForTransactionOutgoing WaitForEscrowRelease — Polls until an EscrowReleaseTransaction referencing originalEscrowId reaches a terminal state or timeout expires. GetState GetTransactionStatusByTxId GetOutgoingStatusByTxId GetConflictingTransaction — Finds a tracked transaction that shares the same nonce and source address as element. Stop — Idempotent stop. Sets the stopped flag and wakes the tick loop. RegisterStateChangeCallback UnregisterStateChangeCallback QueryTransactions — Queries all transaction keys from the CRDT across monitored networks and processes each one via FetchAndProcessTransaction. FetchAndProcessTransaction — Deserializes, parses, and adds a single transaction to the processed map. GetTransactionCID — Looks up the CID associated with a transaction hash in RocksDB, searching across all monitored networks. HandleNonceConsensusSubject ValidateTransactionForConsensus CheckTransactionWellFormed CheckTransactionAuthorization CheckTransactionTimestamp CheckTransactionReplayProtection EvaluateTransactionReplayProtection CheckTransactionTypeRules BuildUTXOTransitionCommitment BuildUTXOWitness ApplyTransactionToUTXOSnapshot ValidateWitnessForConsensus ValidateUTXOParametersForConsensus SetNonceWindow ChangeTransactionState HasConfirmedInputConflict KeyExistsInDB GetPublicChainInputValidator — Obtains the public-chain input validator for RPC endpoint wiring. GetPublicChainInputValidator — Obtains the public-chain input validator for RPC endpoint wiring (const). EnqueueTransaction EnqueueTransaction SetTimeFrameToleranceMs SetMutabilityWindowMs TransactionManager TransactionManager FillDAGStruct GetOutgoingPreviousHash GetTrackedOutgoingPreviousHash GetPersistedOutgoingPreviousHash QueryOutgoingPreviousHashFromCRDT SendTransactionItem — Commits a TransactionItem to the CRDT. RollbackTransactions — Rolls back a failed TransactionItem. ParseTransaction — Dispatches to the type-specific parser registered in transaction_parsers. RevertTransaction — Dispatches to the type-specific reverter registered in transaction_parsers. UpdateAccountUTXOState InitializeUTXOs — Loads UTXOs from local storage and/or the network, then processes the parent transactions of each UTXO. Any transactions that cannot be found are added to missing hashes for later resolution. Falls back to a full QueryTransactions when neither source has data. InitTransactions — Attempts to resolve missing hashes by requesting them from the network. Transitions to READY when none remain and the nonce check passes. CheckNonce — Verifies that the local nonce is not behind the network nonce. Full nodes are allowed through even when the network is unreachable. SyncNonce — Compares the local proposed nonce with the network-confirmed nonce. Transitions back to READY when they match, checks validity when ahead, or requests heads when behind. RequestRelevantHeads — Request heads for relevant topics when we detect we're behind. CheckTransactionValidity — Validates signatures of outgoing transactions at the given nonces. DeleteTransaction — Removes a transaction key from the CRDT within an atomic transaction, publishing to topics. GetTransactionByHash — Thread-safe lookup of an outgoing transaction by hash. GetTransactionByHashNoLock — Same as GetTransactionByHash but assumes tx_mutex_m is already held. GetTransactionByNonceAndAddress GetTrackedTxByNonceAndAddress GetTrackedTxByHash GetStatusByTxId SetOutgoingStatusByNonce NotifyTransactionStatusChanged CompleteTransactionWait CancelPendingTransactionWaits TickOnce — Single iteration of the main processing loop. OnConsensusCertificate OnProposalTimeoutCleanup — Handles proposal timeout cleanup for VERIFYING tracking entries. Called via ProposalCleanupHandler from ConsensusManager when a proposal slot is cleaned up due to timeout. Local outgoing entries become UNCONFIRMED; remote temporary entries are removed. CONFIRMED entries are left untouched. Missing entries are skipped silently. ParseTransferTransaction ParseMintTransaction ParseEscrowTransaction RevertTransferTransaction RevertMintTransaction RevertEscrowTransaction PutProducedUTXOs DeleteProducedUTXOs FilterTransaction — CRDT element filter for incoming transactions. FilterProof — CRDT element filter for incoming proofs. ShouldReplaceTransaction — Decides whether new_tx should replace existing_tx. GetElapsedTime — Computes current_timestamp − timestamp in milliseconds. Result may be negative when the timestamp is in the future. GetElapsedTime IsTransactionImmutable — Returns true when the transaction's age exceeds mutability window. A window of zero means transactions are always mutable. Future-timestamped transactions are never considered immutable. RemoveTransactionFromProcessedMaps — Removes a transaction from map, reverts its UTXO side-effects, rolls back the peer nonce, and optionally deletes the key from the CRDT. AddTransactionToProcessedMaps — Deserializes, conflict-checks, parses, and inserts a new transaction into tx_processed_m. Conflicting transactions are removed (with CRDT deletion) before the new one is applied. StoreTransactionCID — Persists a tx-key → CID mapping in the RocksDB datastore so that the CID can be retrieved later via GetTransactionCID. ProcessDeletion ProcessNewData NewElementCallback — CRDT new-element callback. Stores the CID, pushes the data onto new_data_queue_, and wakes the tick loop. DeleteElementCallback — CRDT deleted-element callback. Pushes the key onto deleted_data_queue_ and wakes the tick loop. ChangeState — Updates state_m and fires the state change callback when the state actually changes. SelectInputValidator GetMonitoredNetworkIDs — Returns the set of network IDs to monitor. On DEV_NET (144), also includes TEST_NET (963) and MAIN_NET (369). GetExpectedProofKey — Derives the proof key that corresponds to a transaction key by replacing "/tx/" with "/proof/". GetExpectedTxKey — Inverse of GetExpectedProofKey — derives the tx key from a proof key. IsTerminalTransactionStatus GetCurrentTimestamp --- source: /SuperGenius/Classes/d6/d6b/structplaceholder__verifier_1_1transcript__state__type/ title: placeholder_verifier::transcript_state_type (struct) --- Members: state cur --- source: /SuperGenius/Classes/d5/d48/classsgns_1_1_transfer_proof/ title: sgns::TransferProof (class) --- A class for generating and verifying transfer proofs. TransferProof is a derived class from IBasicProof, providing the specific implementation for handling transfer of funds proof generation and verification. Members: generator_X_point — X coordinate of the generator point. generator_Y_point — Y coordinate of the generator point. base_seed — Base seed. provided_totp — Provided TOTP. ranges — Array of range values used in transfer proofs. balance_ — The balance associated with the transfer. amount_ — The amount to be transferred. TRANSFER_TYPE_NAME — Constant representing the transfer proof type name. registered — Static variable to ensure registration happens on inclusion of header file. TransferProof — Constructor for the TransferProof class. ~TransferProof — Destructor for the TransferProof class. GetProofType — Retrieves the type of proof for transfers. GenerateCurveParameter GenerateCurveParameter — Generates a JSON object for a curve parameter. SerializeFullProof — Serializes the full proof data and parameters. GenerateJsonParameters — Generates the parameters in JSON array form. DeSerializePublicParams — Deserializes public parameters from the provided proof data. Register — Registers the deserializer and bytecode for the transfer proof type. --- source: /SuperGenius/Classes/de/d98/classsgns_1_1_transfer_transaction/ title: sgns::TransferTransaction (class) --- Transaction for transferring funds between UTXO inputs and outputs. Members: input_tx_ outputs_ registered — Static variable to ensure registration happens on inclusion of header file. New DeSerializeByteVector — Deserializes a TransferTransaction from bytes. ~TransferTransaction — Default Transfer Transaction destructor. SerializeByteVector — Serializes the transaction into a byte vector, including the DAG metadata. SerializeToEmbeddedTransaction — Serializes the transaction into an EmbeddedTransaction proto with the appropriate oneof field set. GetDstInfos GetInputInfos HasUTXOParameters — Returns if transaction supports UTXOs. GetUTXOParametersOpt — Returns the UTXOs. GetTransactionSpecificPath — Returns the transaction-specific path component for storage and retrieval. GetTopics — Returns the destination topics associated with the transaction. SerializeByteVector — Serializes the transaction into a byte vector. SerializeByteVector — Serializes the transaction into a byte vector. SerializeToEmbeddedTransaction — Serializes the transaction into an EmbeddedTransaction proto with the appropriate oneof field set. SerializeToEmbeddedTransaction — Serializes using internal DAG metadata. TransferTransaction — Construct a new TransferTransaction object. Register — Registers the deserializer for the transfer transaction type. --- source: /SuperGenius/Classes/da/dda/classsgns_1_1trustedpeer_1_1_trusted_peer_list_payload/ title: sgns::trustedpeer::TrustedPeerListPayload (class) --- ISignedCRDTData payload type carrying the trusted-peer list. Serialization is a newline-joined encoding of the peer address list (addresses are 128-char hex strings and never contain ' '). Verify() performs structural validation ONLY (non-empty, no duplicates, each entry exactly 128 lowercase-hex characters) it never diffs against any cached/mutable state (Pitfall 4). Members: peers_ TrustedPeerListPayload TrustedPeerListPayload — Constructs a payload directly from a peer list (used by callers that need to serialize a proposed value). SerializeToBytes — Serializes this instance's payload to raw bytes (codec, encode side). DeserializeFromBytes Verify — Performs type-specific semantic validation of payload beyond signature/quorum checks (e.g. field-range checks). Apply — Applies the side effect of this value once the caller has independently confirmed quorum (e.g. via SecureCrdt::ReadIfQuorum). Apply() itself does NOT check quorum. GetPeers — Returns the decoded/constructed peer list. FromBytes — Decodes a trusted-peer list into a fully-constructed payload. --- source: /SuperGenius/Classes/d7/dec/classsgns_1_1trustedpeer_1_1_trusted_peer_registry/ title: sgns::trustedpeer::TrustedPeerRegistry (class) --- Genesis-seeded, in-memory-cached, quorum-updatable trusted-peer set. Delegates ALL signature/quorum logic to SecureCrdt / SecureCrdtRegistry no bespoke signature/quorum logic exists here (TPR-03). Members: secure_crdt_ base_key_ bootstrapper_address_ quorum_threshold_ cache_mutex_ cached_peers_ genesis_confirmed_ registry_token_ logger_ TrustedPeerRegistry — Constructs a TrustedPeerRegistry. The genesis peer list is cached immediately (D-05) GetCurrentPeers() reflects it even before SeedGenesis/TryConfirm are called. ~TrustedPeerRegistry SeedGenesis — Seeds the genesis trusted-peer list: proposes the genesis payload then adds exactly one ephemeral-bootstrapper signature. The signature is PRECOMPUTED this method never signs live (D-02). ProposeMembershipChange — Proposes a membership-change value (new full peer list). SignMembershipChange — Adds a signature over the currently-proposed value. TryConfirm — Attempts to confirm the currently-proposed value against quorum. On confirmation, decodes/verifies/applies the payload and overwrites the cached peer set never speculatively before quorum is independently confirmed. GetCurrentPeers — Returns a copy of the current cached trusted-peer set. IsGenesisConfirmed — Reports whether genesis has been confirmed. Unregister — Unregisters this instance's signer-set-source from SecureCrdtRegistry (test-fixture teardown helper). New — Constructs a TrustedPeerRegistry and registers its signer-set-source with SecureCrdtRegistry. RegisterSignerSetSource — Registers this instance's signer-set-source with SecureCrdtRegistry under "trusted-peer-registry". ResolveSignerSet — Resolves the current authorized signer set: the sole bootstrapper (threshold 1) before genesis confirmation, or the current cached peer set (at quorum_threshold_) afterwards. Reads ONLY cached_peers_/genesis_confirmed_ NEVER re-enters the SecureCrdt quorum-read path (Pitfall 2). --- source: /SuperGenius/Classes/d7/daf/structintx_1_1uint/ title: intx::uint (struct) --- Members: word_type word_num_bits num_bits num_words words_ uint uint — Implicit converting constructor for any smaller uint type. uint operator[] operator[] operator bool operator uint< M > operator Int — Explicit converting operator for all builtin integral types. --- source: /SuperGenius/Classes/d9/db9/structintx_1_1uint_3_01128_01_4/ title: intx::uint< 128 > (struct) --- The 128-bit unsigned integer. This type is defined as a specialization of uint<> to easier integration with full intx package, however, uint128 may be used independently. Members: word_type word_num_bits num_bits num_words words_ uint uint uint operator[] operator[] operator bool operator Int — Explicit converting operator for all builtin integral types. --- source: /SuperGenius/Classes/d7/d76/structdiscv5_1_1_uncompressed_pub_key_wire/ title: discv5::UncompressedPubKeyWire (struct) --- Wire layout of an uncompressed secp256k1 public key (with 0x04 prefix). Members: prefix — Always 0x04. xy — 64-byte X || Y coordinate pair --- source: /SuperGenius/Classes/d5/d2f/class_unreachable___at___line/ title: Unreachable_At_Line (class) --- This file declares UNREACHABLE macro. Use it to prevent compiler warnings. --- source: /SuperGenius/Classes/da/dac/structsgns_1_1_unused/ title: sgns::Unused (struct) --- Special zero-size-type for some things (e.g., unsupported and experimental). Members: index operator== --- source: /SuperGenius/Classes/d8/d41/structeth_1_1_upgrade_status_message/ title: eth::UpgradeStatusMessage (struct) --- Members: disable_peer_tx_broadcast --- source: /SuperGenius/Classes/dc/d6b/structsgns_1_1_u_t_x_o_manager_1_1_u_t_x_o_checkpoint/ title: sgns::UTXOManager::UTXOCheckpoint (struct) --- Persisted checkpoint snapshot used to audit finalized UTXO state at a given epoch. Members: owner_address — Owner address associated with this checkpoint. epoch — Epoch number when the checkpoint was created. last_finalized_tx — Transaction ID of the last finalized transaction at the time of checkpointing. registry_hash — Hash of the full UTXO registry state at the time of checkpointing. utxo_merkle_root — Merkle root of the unspent UTXOs at the time of checkpointing. utxo_count — Total number of UTXOs included in the checkpoint. created_at_ms — Timestamp in milliseconds when the checkpoint was created. --- source: /SuperGenius/Classes/d5/d7d/structsgns_1_1_u_t_x_o_manager_1_1_u_t_x_o_entry/ title: sgns::UTXOManager::UTXOEntry (struct) --- Metadata tracked for each outpoint in the local registry. Members: state — Current lifecycle state of the UTXO. utxo — The actual UTXO data. created_epoch — Epoch when the UTXO was created. spent_epoch — Epoch when the UTXO was consumed, if applicable. spent_by_txid — Transaction ID that consumed this UTXO, if applicable. type — Type classification for the UTXO. --- source: /SuperGenius/Classes/d0/dac/classsgns_1_1_u_t_x_o_manager/ title: sgns::UTXOManager (class) --- Owns the local UTXO set, supports coin selection, validation, persistence, reservations, and deterministic snapshot hashing. Members: UTXOState — Lifecycle state stored for each tracked UTXO. UTXOType — Type classification for UTXOs to distinguish standard UTXOs from cross-chain bridge burns. UTXOData — UTXO state paired with the actual UTXO. UTXOOutPointMap — Maps an outpoint to its UTXO Entry. AddressOutPointList — Maps an owner address to a list of outpoints they own. SignFunc — Method to sign a vector of bytes, returning the signature bytes. VerifySignatureFunc — Method to verify a signature given an address, signature bytes, and original data. DB_PREFIX — Prefix for UTXO-related keys in RocksDB. CHECKPOINT_PREFIX logger_ — Logger instance for UTXOManager. address_ — Address of the account this manager is responsible for. sign_ — Signer method for authorizing UTXO spends. verify_signature_ — Verifier method for validating signatures on UTXO spends. db_ — Database handle for persisting UTXO state and checkpoints. utxos_mutex_ — Mutex for UTXO state structures. utxo_outpoints_ — Maps outpoints to their UTXO entries for efficient lookup. address_outpoints_ local_reservations_ — Transient local ownership for reservations; never persisted or used for consensus validity. UTXOManager — Construct a new UTXOManager object. GetBalance — Get the account's balance. GetBalance — Get the informed address balance. GetBalance — Get the accounts balance for a specific token. GetBalance — Get the balance of the informed address for a specific token. PutUTXO — Add a new UTXO to the account. PutUTXO — Adds a new UTXO to the account using the manager's default address. DeleteUTXO — Delete a UTXO from the account. ConsumeUTXOs — Consume UTXOs from the account. RestoreConsumedUTXOs — Restores previously consumed inputs when their consuming transaction is reverted. ConsumeUTXOs — Consume UTXOs from the default owner address tracked by this manager. GetUTXOs — Get UTXOs for a specific address. GetUTXOs — Returns spendable UTXOs owned by the manager's default address. GetUnconsumedUTXOs — Get all unconsumed UTXOs for a specific address. GetUnconsumedUTXO — Returns an unconsumed UTXO by its exact outpoint. GetAllUTXOs — Get all UTXOs tracked by the manager, grouped by owner address. SetUTXOs — Set UTXOs for a specific address (replaces existing UTXOs) SetUTXOs — Set UTXOs for the manager's default address (replaces existing UTXOs) CreateTxParameter — Create the input and output parameters for a single-output transfer, selecting from available UTXOs. CreateTxParameter — Selects and signs inputs for a multi-output transfer. ReserveUTXOs — Marks inputs as reserved so they are not reused by concurrent transaction assembly. RollbackUTXOs — Releases a previous reservation without consuming the inputs. VerifyParameters — Verifies ownership and signatures for UTXO transaction parameters using the default address. VerifyParameters — Verifies ownership and signatures for UTXO transaction parameters using an explicit address. GetOutPointState — Returns the tracked state of a specific outpoint when present. IsOutPointConsumed — Indicates whether a specific outpoint has already been consumed. IsOutPointReserved — Indicates whether a specific outpoint is in the RESERVED state (burn UTXO awaiting consensus). ComputeUTXOMerkleRoot — Compute a deterministic Merkle root for unspent UTXOs owned by this node address. ComputeUTXOMerkleRoot — Compute a deterministic Merkle root for unspent UTXOs from a specific address. ComputeUTXOMerkleRootFromSnapshot — Compute deterministic UTXO Merkle root from an explicit UTXO snapshot. LoadUTXOs — Loads the UTXO state for the manager's default address from persistent storage. ReleaseStorage — Releases the current RocksDB handle used for persistence. StoreUTXOs — Stores the current UTXO state for the manager's default address to persistent storage. CreateCheckpoint — Creates a checkpoint for the manager's default address. CreateCheckpoint — Creates a checkpoint for an explicit owner address. LoadLatestCheckpoint — Loads the latest checkpoint for the default owner address. LoadLatestCheckpoint — Loads the latest checkpoint for the provided owner address. AcquireStorage — Grabs the current storage as a shared pointer copy. SelectUTXOs — Selects UTXOs to cover a required amount for a specific token, excluding reserved outpoints, and returns the selected inputs along with the total selected amount. SignInputs — Signs the provided UTXO inputs using the configured signing function. --- source: /SuperGenius/Classes/d4/d67/structsgns_1_1_account_messenger_1_1_u_t_x_o_response_data/ title: sgns::AccountMessenger::UTXOResponseData (struct) --- Members: responder_address utxos has_utxos --- source: /SuperGenius/Classes/d1/d90/structdiscovery_1_1_validated_peer/ title: discovery::ValidatedPeer (struct) --- Minimal peer descriptor produced by both discv4 and discv5 crawlers. Contains only the information that the downstream dial scheduler needs to attempt an RLPx TCP connection and to apply an optional per-chain filter. Intentionally kept narrow — it is the stable handoff contract between the discovery layer and the connection layer. Neither the scheduler nor the caller should need to know which discovery protocol produced this record. Members: node_id — 64-byte secp256k1 public key ip — IPv4 dotted-decimal or IPv6 string. udp_port — UDP port used by the discovery protocol. tcp_port — TCP port for RLPx (devp2p) last_seen — Wallclock of last discovery contact. eth_fork_id — Present when parsed from ENR "eth" entry. --- source: /SuperGenius/Classes/d9/d3b/structdiscv4_1_1_validated_peer/ title: discv4::ValidatedPeer (struct) --- A discovered peer whose public key has already been validated. Members: peer pubkey --- source: /SuperGenius/Classes/da/d26/structsgns_1_1_consensus_manager_1_1_validation_result/ title: sgns::ConsensusManager::ValidationResult (struct) --- Local structured validation result for subject handlers. Pending metadata is local bookkeeping only. It is not serialized, broadcast, or counted toward quorum. Members: check dependencies retry_after ValidationResult ValidationResult Approve Reject Stalled Pending --- source: /SuperGenius/Classes/dc/db9/classsgns_1_1_validator_registry/ title: sgns::ValidatorRegistry (class) --- Maintains validator registry state and applies certificate-driven updates. This component stores the active validator set in GlobalDB/CRDT, computes quorum thresholds, validates registry updates, and derives next registry snapshots from consensus certificates. Members: BatchSubjectDecision — Decision result when evaluating a registry-batch subject. BatchCertificateDecision — Decision result when handling a registry-batch certificate. ValidatorEntry Registry SignatureEntry RegistryUpdate Role Status InitCallback BlockRequestMethod DefaultMaxNewValidatorsPerUpdate — Default cap for new validators added per update. DefaultCertificatesPerBatch — Default number of certificates grouped per batch. sgns::Migration3_5_0To3_6_0 db_ — Backing GlobalDB instance. quorum_numerator_ — Quorum numerator. quorum_denominator_ — Quorum denominator. weight_config_ — Weight and penalty configuration. genesis_authority_ — Genesis authority validator id. logger_ — Component logger. cache_mutex_ — Guards cached registry/update state. cached_registry_ — Cached active registry snapshot. cached_update_ — Cached active registry update. cached_registry_id_ — Cached active registry CID. cache_initialized_ — Indicates whether cache has been initialized. max_new_validators_per_update_ — Cap for new validators per update. certificates_per_batch_ — Certificates required per batch subject. batch_mutex_ — Guards batch-tracking collections. pending_certificate_subjects_by_base_ — Pending subject hashes keyed by base registry. pending_batch_subject_ids_ — Batch subject ids pending finalization. finalized_batch_subject_ids_ — Batch subject ids already finalized. applying_batch_subject_ids_ — Batch subject ids currently being applied. submit_batch_subject_ — Callback used to submit batch subjects. persistence_mutex_ — Guards the persistence queue and shutdown state. persistence_cv_ — Wakes the persistence worker during work/shutdown. persistence_queue_ — Registry updates waiting to be persisted. persistence_stopping_ — Rejects work after Close starts. active_batch_handlers_ — Batch handlers still using GlobalDB. persistence_worker_ — Owned registry persistence worker. close_mutex_ — Serializes idempotent Close calls. close_started_ — Makes Close one-shot. init_callback_ — Optional initialization callback. request_block_by_cid_ — Callback to request blocks by CID. New — Creates and initializes a validator registry instance. TotalWeight — Computes total effective weight in a registry snapshot. EvaluateSlotQuorumStatic — Pure (stateless) slot-quorum tally for deterministic unit testing. EvaluateRegularPromotionStatic — Pure (stateless) REGULAR -> FULL promotion decision (D-08). RegistryKey — Registry object key used in datastore. ValidatorTopic — Topic used to publish/subscribe validator registry updates. RegistryCidKey — Key used to persist the current registry CID. FindValidator — Finds validator entry by id in a registry snapshot. ~ValidatorRegistry — Destroys the registry instance. Close — Stops accepting registry work and waits for queued persistence to finish. ComputeWeight — Computes default weight for a validator role. QuorumThreshold — Computes minimum accumulated weight required for quorum. IsQuorum — Checks whether accumulated weight satisfies quorum. EvaluateSlotQuorum — Phase 6 cumulative slot-quorum tally for bridge-mint subjects (D-06). CreateGenesisRegistry — Creates an in-memory genesis registry snapshot. StoreGenesisRegistry — Persists a signed genesis registry update. LoadCurrentRegistry — Loads the currently active registry. LoadRegistryByCid — Loads a registry by CID. LoadRegistryUpdate — Loads the currently active registry update payload. GetValidatorWeight — Looks up validator weight by validator id. RegisterFilter — Registers CRDT filter/callbacks for registry updates. CreateUpdateFromCertificate — Builds a registry update from a finalized certificate. StoreRegistryUpdate — Persists a registry update. BeginRegistryUpdateTransaction — Starts an atomic transaction to apply a registry update. SetMaxNewValidatorsPerUpdate — Sets the maximum number of unregistered validators added per update. SerializeRegistry — Serializes a registry protobuf. DeserializeRegistry — Deserializes a registry protobuf. SerializeRegistryUpdate — Serializes a registry update protobuf. DeserializeRegistryUpdate — Deserializes a registry update protobuf. GetRegistryCid — Returns cached/current registry CID. GetRegistryEpoch — Returns cached/current registry epoch. SetCertificatesPerBatch — Sets certificate count threshold used when creating batch subjects. SetBatchSubjectSubmitter — Sets callback used to submit generated batch subjects. OnFinalizedCertificate — Handles a finalized consensus certificate. EvaluateBatchSubject — Evaluates a registry-batch subject payload. HandleBatchCertificate — Handles certificate associated with a registry-batch subject. RetryInitializationIfNeeded — Re-attempts genesis-registry head-CID discovery when initialization has not yet completed (bug fix, D-01/2-of-11-nodes-start-bridge). MigrateCids — Migrates registry-related CIDs from old to new datastore. ValidatorRegistry — Constructs a ValidatorRegistry instance. FilterRegistryUpdate — Filters CRDT elements to registry-update entries. RegistryUpdateReceived — Callback invoked when a registry update element is received. ComputeUpdateSigningBytes — Computes canonical bytes used to sign a registry update. VerifyUpdate — Verifies registry update signatures and consistency. ValidateCertificate — Validates certificate against current registry constraints. ValidateCertificateForUpdate — Validates certificate suitability for generating a registry update. ExtractCertificateVotes — Extracts registered/unregistered vote partitions from certificate. BuildRegistryFromCertificate — Builds next registry snapshot using a certificate-derived vote set. BuildRegistryFromAggregatedVotes — Builds next registry snapshot from aggregated vote maps. InsertNewValidators — Inserts eligible unregistered validators into registry. ApplyVoteEffects — Applies registered vote effects (approvals/penalties) to entries. ApplyInactivityDecay — Applies inactivity decay to validators absent from participants. ApplyTotalWeightCap — Enforces total-weight cap across entries. InitializeCache — Initializes local cache from persistent storage. ComputeBatchRoot — Computes deterministic batch root from subject hashes. SelectBatchSubjects — Selects subjects eligible for a registry batch proposal. LoadCertificateBySubjectHash — Loads certificate referenced by subject hash. TryCreateAndSubmitBatchProposal — Attempts to create and submit a registry batch proposal. NotifyInitialized — Notifies initialization completion to callback. PersistLocalState — Persists local cache metadata/state. RequestHeadCids — Requests head blocks for the provided CIDs. PersistenceWorkerLoop EnqueueRegistryWrite NormalizeRegistry — Sorts and normalizes registry structure deterministically. BuildBatchKey — Builds map key for pending certificate subjects by base registry. --- source: /SuperGenius/Classes/d6/def/structdiscv4_1_1_watcher_pool/ title: discv4::WatcherPool (struct) --- Global resource pool shared across all chain DialSchedulers. Enforces a two-level fd cap: total across all chains, and per chain. Members: max_total max_per_chain active_total WatcherPool WatcherPool --- source: /SuperGenius/Classes/d2/d51/structdiscv4_1_1_watcher_pool_config/ title: discv4::WatcherPoolConfig (struct) --- Configurable connection limits for a WatcherPool. Defaults keep three active dial/watch slots per chain. Members: max_total max_per_chain --- source: /SuperGenius/Classes/db/df0/structeth_1_1_watch_event_context/ title: eth::WatchEventContext (struct) --- Context metadata attached to a filtered watch event. Members: chain_name network_id peer_client_id peer_address --- source: /SuperGenius/Classes/d7/da8/structeth_1_1_watch_event_notification/ title: eth::WatchEventNotification (struct) --- Enriched event payload emitted by EthWatchRunner and EthWatchService. Members: context event values event_signature --- source: /SuperGenius/Classes/df/d95/structeth_1_1cli_1_1_watch_spec/ title: eth::cli::WatchSpec (struct) --- One watch subscription specified on the command line. Members: contract_hex — 40 hex chars (20 bytes), empty = any contract event_signature — e.g. "Transfer(address,address,uint256)" --- source: /SuperGenius/Classes/d0/db9/structeth_1_1_watch_stats_snapshot/ title: eth::WatchStatsSnapshot (struct) --- Snapshot of live EthWatchService traffic counters. Members: eth_messages_seen new_block_hashes_messages new_block_messages receipts_messages decode_failures receipts_requested receipts_processed logs_seen matched_logs discarded_logs --- source: /SuperGenius/Classes/dd/d71/structsgns_1_1_validator_registry_1_1_weight_config/ title: sgns::ValidatorRegistry::WeightConfig (struct) --- Weight policy used to score validators and update penalties. Members: genesis_weight_ — Base weight for genesis authority validators. full_weight_ — Base weight for full validators. regular_weight_ — Base weight for regular validators. sharded_weight_ — Base weight for sharded validators. genesis_max_weight_ — Max weight allowed for genesis validators. full_max_weight_ — Max weight allowed for full validators. regular_max_weight_ — Max weight allowed for regular validators. sharded_max_weight_ — Max weight allowed for sharded validators. approval_increment_ — Weight increment applied for approved behavior. penalty_threshold_ — Penalty score threshold before harsher actions. penalty_cap_ — Maximum accumulated penalty score. blacklist_bump_ — Penalty increment applied for severe failures. missed_epoch_threshold_ — Missed-epoch threshold used for inactivity decisions. inactivity_decrement_ — Weight decrement for inactive validators. total_weight_cap_multiplier_ — Multiplier controlling global weight-cap normalization. certificate_timestamp_window_ms_ — Allowed timestamp drift for certificates. slot_direct_numerator_ — Slot 0 (DIRECT_API) weight numerator. 0.50 = 1/2 (D-02). slot_direct_denominator_ — Slot 0 (DIRECT_API) weight denominator. 0.50 = 1/2 (D-02). slot_public_numerator_ — Slots 1-2 (PUBLIC) weight numerator. 0.25 = 1/4 (D-03). slot_public_denominator_ — Slots 1-2 (PUBLIC) weight denominator. 0.25 = 1/4 (D-03). slot_quorum_numerator_ — Cumulative quorum threshold numerator. 0.75 = 3/4 (D-06). slot_quorum_denominator_ — Cumulative quorum threshold denominator.0.75 = 3/4 (D-06). slot_public_min_group_ — D-03: minimum distinct validators per PUBLIC hash group. full_promotion_weight_ — Weight at which a REGULAR validator is promoted to FULL (D-08). --- source: /SuperGenius/Classes/d4/d8c/structsgns_1_1_weighted_rpc_endpoint/ title: sgns::WeightedRpcEndpoint (struct) --- Weighted RPC endpoint used for multi-provider consensus verification. Direct (api-key) endpoints contribute 50% weight. Public endpoints from ChainList contribute 25% weight. Verification requires >= 75% weighted consensus across queried endpoints. Members: url consensus_weight bridge_contract_address accepted_topic0_hashes --- source: /SuperGenius/Classes/da/dc7/structdiscv5_1_1_whoareyou_auth_data_wire/ title: discv5::WhoareyouAuthDataWire (struct) --- WHOAREYOU auth-data layout: id-nonce + highest ENR sequence. Members: id_nonce — 16-byte identity challenge nonce record_seq — Highest known ENR sequence (big-endian) --- source: /SuperGenius/Classes/db/d24/classsgns_1_1_windows_secure_storage/ title: sgns::WindowsSecureStorage (class) --- Members: identifier_ WindowsSecureStorage GetName LoadJSON SaveJSON --- source: /SuperGenius/Classes/df/d5a/structsgns_1_1base_1_1_wrapper/ title: sgns::base::Wrapper (struct) --- Make strongly typed structures from different concepts of the equal types. E.g. block height and round number are both uint64_t, but better to be different types. Or, ID and Signature both vectors. T wrapped type Tag unique tag Members: data_ Wrapper unwrap unwrap unwrap_mutable operator== --- source: /SuperGenius/Classes/d7/dc2/structsgns_1_1storage_1_1face_1_1_writeable/ title: sgns::storage::face::Writeable (struct) --- An mixin for modifiable map. K key type V value type Members: ~Writeable put — Store value by key. put remove — Remove value by key. --- source: /SuperGenius/Classes/d9/d69/structsgns_1_1storage_1_1face_1_1_write_batch/ title: sgns::storage::face::WriteBatch (struct) --- An abstraction over a storage, which can be used for batch writes. K key type V value type Members: commit — Writes batch. clear — Clear batch. --- source: /SuperGenius/Classes/d2/d26/classsgns_1_1api_1_1_ws_client_impl/ title: sgns::api::WsClientImpl (class) --- Members: Context ExecutorType StreamSocket PlainWebSocketStream SSLStream SecureWebSocketStream sslContext stream strand resolver buffer host port secure WsClientImpl start setMessageHandler send stop parseUrl onWebSocketConnect reportError --- source: /SuperGenius/Namespaces/d6/da1/namespace_0d480/ title: @480 (namespace) --- Members: StopReason RunStatus --- source: /SuperGenius/Namespaces/d5/d9c/namespacebitcoin/ title: bitcoin (namespace) --- Members: CurveType — Curve type used by Ethereum keys. base_field_type — Ethereum base field type. scalar_field_type — Ethereum scalar field type. scalar_field_value_type — Ethereum value from the scalar field type. random_generator_type — Random generator type, to generate new Ethereum keys/addresses. hash_type — The hash type used by Ethereum address derivation. generator_type — The deterministic generator used by Ethereum key pair. padding_policy — Ethereum passing policy. policy_type — Ethereum policy type. signature_type — Random generator type, to generate new Bitcoin keys/addresses. derivation_hash_type — The hash type used by Ethereum address derivation. BitcoinKeyGenerator::ExtractPubKeyFromField< std::vector< std::uint8_t > > BitcoinKeyGenerator::ExtractPubKeyFromField< BitcoinKeyGenerator::PubKeyPair_t > --- source: /SuperGenius/Namespaces/d6/d94/namespacediscovery/ title: discovery (namespace) --- Members: NodeId — Node identifier — 64-byte uncompressed secp256k1 public key (without the 0x04 prefix). --- source: /SuperGenius/Namespaces/d6/dcc/namespacediscv4/ title: discv4 (namespace) --- Members: ChainDiscoveryDefault DiscoveryForkFilter discv4Error — Discovery v4 protocol error codes. PacketError BootstrapCacheRefreshResult BootstrapChainConfig BootstrapSignatureVerificationResult DialFn DialFeedbackFn — Callback signature for dial/session exit feedback. FilterFn — Predicate applied to a DiscoveredPeer before it is enqueued for dialing. Return true to allow dialing, false to drop. When unset (nullptr), all peers are accepted. Mirrors go-ethereum UDPv4::NewNodeFilter (eth/protocols/eth/discovery.go). udp NodeId PeerDiscoveredCallback ErrorCallback Result — Result type for Discovery v4 operations. VoidResult — Result type for Discovery v4 operations without return value. PacketResult SendCallback kHashSize kSigSize kPacketTypeSize kPacketHeaderSize kPacketTypeOffset kUncompressedPubKey kEthKey kWireHashSize — Outer Keccak-256 hash. kWireSigSize — Recoverable ECDSA signature. kWirePacketTypeSize — Single packet-type byte. kWireRecoveryIdSize — Recoverable ECDSA recovery id. kWireCompactSigSize kWireHeaderSize kWirePacketTypeOffset kNodeIdSize — Node identity. kNodeIdHexSize kUncompressedPubKeySize — 0x04 prefix + 64 bytes kIPv4Size — Network. kUdpBufferSize kPacketTypePing — Packet type identifiers. kPacketTypePong kPacketTypeFindNode kPacketTypeNeighbours kPacketTypeEnrRequest kPacketTypeEnrResponse kProtocolVersion — Protocol version advertised in PING packets. kPacketExpirySeconds — Default packet expiry window (seconds) kDefaultPingTimeout — Default networking timers. kDefaultPeerExpiry kDefaultDialHistoryExpiry kEnrSeqSize — ENR sequence number field size in PONG (optional, 6-byte big-endian uint48) bootstrap_cache_json_path find_bootstrap_peers_json_path download_bootstrap_json write_bootstrap_cache_json_if_changed refresh_bootstrap_cache_json load_bootstrap_peers_from_json_text load_bootstrap_peers_from_json load_bootstrap_fork_id_hash_from_json_text load_bootstrap_fork_id_hash_from_json load_bootstrap_chain_config_from_json_text load_bootstrap_chain_config_from_json verify_bootstrap_json_signature make_validated_peer_from_enode — Parse an enode:// peer URI into a validated peer entry. make_validated_peer_from_enr — Parse an enr: peer URI into a validated peer entry. chain_peer_cache_json_path — Return the default local cache path for chain_enodes.json next to the executable. find_chain_peer_cache_json_path — Locate a local chain peer cache JSON file. download_chain_peer_cache_json — Download the chain peer cache JSON payload from a remote URL. Supports either raw JSON or gzip-compressed JSON bodies. write_chain_peer_cache_json_if_changed — Write the chain peer JSON cache only when the contents changed. refresh_chain_peer_cache_json — Refresh a local chain peer cache from a remote URL. load_chain_peers_from_json_text — Load cached peers for a specific chain from JSON text. load_chain_peers_from_json — Load cached peers for a specific chain from a JSON or gzip-compressed JSON file. load_chain_fork_id_hash_from_json_text — Load the first available peer fork hash for a specific chain from JSON text. load_chain_fork_id_hash_from_json — Load the first available peer fork hash for a specific chain from a JSON or gzip-compressed JSON file. load_chain_peer_config_from_json_text — Load the parsed chain configuration from JSON text. load_chain_peer_config_from_json — Load the parsed chain configuration from a JSON or gzip-compressed JSON file. verify_chain_peer_cache_json_signature — Verify the top-level chain_enodes.json signature. to_string — Convert error code to human-readable string. make_fork_id_filter — Create a FilterFn that accepts only peers whose ENR eth entry carries a ForkId with the given 4-byte hash (CRC32 of genesis + applied forks). --- source: /SuperGenius/Namespaces/d0/dec/namespacediscv5/ title: discv5 (namespace) --- Members: discv5Error — Enumeration of all error conditions that can be returned by the discv5 module. udp Result — Result type for discv5 operations that return a value. VoidResult — Result type for discv5 operations that return nothing on success. PeerDiscoveredCallback — Invoked when a new valid peer has been discovered and passed all configured filters (chain filter, address validation, dedup). ErrorCallback — Invoked when a non-fatal error occurs inside the crawler (e.g. a malformed ENR from a remote node). DnsTxtLookupFn — DNS TXT lookup callback used by the ENR-tree resolver. kBase64UrlTable — Static decode table for the base64url alphabet (RFC-4648 §5). Index = ASCII code, value = 6-bit group (or kBase64Invalid). Built from the named constants in discv5_constants.hpp so that no bare literals appear in the initialiser. kDefaultUdpPort — Default UDP port for discv5 (IANA-assigned). kDefaultTcpPort — Default TCP/RLPx port advertised to discovered peers. kNodeIdBytes — Bytes in an uncompressed secp256k1 public key WITHOUT the 0x04 prefix. This is the 64-byte "node id" used by discv4 and passed to DialHistory. kCompressedKeyBytes — Bytes in a compressed secp256k1 public key (03/02 prefix + 32 bytes). kPrivateKeyBytes — Bytes in a secp256k1 private key. kUncompressedPrefixLen — Bytes in the 0x04 uncompressed-point prefix. kUncompressedPubKeyPrefix kUncompressedPubKeyDataOffset kKeccak256Bytes — Keccak-256 (legacy) digest size in bytes. kIPv4Bytes — IPv4 address wire size in bytes. kIPv6Bytes — IPv6 address wire size in bytes. kIPv4OctetMsb — Byte offset of the most-significant octet in a 4-byte IPv4 field. kIPv4Octet1 — Byte offset of the second octet. kIPv4Octet2 — Byte offset of the third octet. kIPv4OctetLsb — Byte offset of the least-significant octet. kIPv4MsbShift — Left-shift amount to place the MSB octet in a uint32 (big-endian). kIPv4Octet1Shift — Left-shift amount for the second octet. kIPv4Octet2Shift — Left-shift amount for the third octet. kIPv4LsbShift — Left-shift amount for the least-significant octet (no shift). kMaxPortBytes — Maximum bytes an RLP-encoded UDP/TCP port occupies (big-endian uint16). kForkHashBytes — Byte count of the fork-hash field inside an ENR "eth" entry. kProtocolIdBytes — Byte length of the "discv5" protocol-ID magic string. kProtocolId — The discv5 packet protocol-ID string. kGcmNonceBytes — Byte length of the AES-GCM nonce used for message encryption. kMaskingIvBytes — Byte length of the masking IV that precedes the static header. kWhoareyouIdNonceBytes — Byte length of the WHOAREYOU id-nonce field. kMinPacketBytes — Minimum valid discv5 packet size (go-ethereum minPacketSize). kMaxPacketBytes — Maximum valid discv5 packet size in bytes. kAes128KeyBytes — AES-128 session key size in bytes. kGcmTagBytes — AES-GCM authentication tag size in bytes. kRandomMessageCiphertextBytes — Random encrypted payload size used for pre-handshake message placeholders. kFindNodeDistanceAll — FINDNODE distance that requests the full routing table (log2 space upper bound + 1). kHkdfFirstBlockCounter — Single-byte HKDF expansion block counter used for the first output block. kMessageTypePrefixBytes — Byte size of the leading message-type prefix in decrypted discv5 payloads. kNodesResponseCountSingle — Number of ENR records returned by the local single-record NODES reply helper. kEnrMaxBytes — Maximum total size of a serialised ENR record (EIP-778 SizeLimit). kEnrSigBytes — Compact secp256k1 ECDSA signature size stored in an ENR (no recid). kEnrPrefixLen — Byte length of the "enr:" URI prefix. kEnrPrefix — The "enr:" URI prefix string. kInitialEnrSeq — Initial ENR sequence number for locally generated records. kIdentitySchemeV4 — ENR identity scheme string for secp256k1-v4. kIdentitySchemeV4Bytes kEnrKeyId — Common ENR field key strings and lengths. kEnrKeyIdBytes kEnrKeyIp kEnrKeyIpBytes kEnrKeySecp256k1 kEnrKeySecp256k1Bytes kEnrKeyTcp kEnrKeyTcpBytes kEnrKeyUdp kEnrKeyUdpBytes kBase64UpperCount — Number of upper-case letters (A–Z) in the base64url alphabet. kBase64LowerCount — Number of lower-case letters (a–z) in the base64url alphabet. kBase64DigitCount — Number of decimal digits (0–9) in the base64url alphabet. kBase64LowerStart — Start index of the lower-case letter block (after A–Z). kBase64DigitStart — Start index of the digit block (after A–Z and a–z). kBase64DashIndex — Table index for the '-' character in base64url. kBase64UnderIndex — Table index for the '_' character in base64url. kBase64Invalid — Sentinel value meaning "not a valid base64url character". kBase64BitsPerChar — Number of bits encoded by one base64 character. kBase64BitsPerByte — Number of bits in one output byte. kDefaultMaxConcurrent — Default maximum concurrent outbound FINDNODE queries. kDefaultQueryIntervalSec — Default interval between crawler sweep rounds (seconds). kDefaultPeerExpirySec — Seconds before an unseen peer is evicted from the peer table. kMaxBootnodeEnrs — Maximum bootstrap ENR entries accepted per chain source. kUncompressedKeyBytes — Total byte count of an uncompressed public key including the 0x04 prefix. kStaticHeaderBytes — Byte count of the static header (derived from wire struct, NOT a magic literal). kStaticHeaderVersionOffset kStaticHeaderFlagOffset kStaticHeaderNonceOffset kStaticHeaderAuthSizeOffset kWhoareyouAuthDataBytes — Byte count of WHOAREYOU auth data. kHandshakeAuthSizeFieldBytes — HANDSHAKE auth-data layout prefixes. kHandshakeAuthSizeFieldCount kHandshakeAuthSigSizeOffset kHandshakeAuthPubkeySizeOffset kHandshakeAuthFixedBytes kStaticPacketBytes — Total fixed bytes at the front of every discv5 packet: masking IV + static header. kFlagMessage — Flag value for an ordinary encrypted message packet. kFlagWhoareyou — Flag value for a WHOAREYOU session-challenge packet. kFlagHandshake — Flag value for a HANDSHAKE message. kMsgPing — PING message type byte. kMsgPong — PONG message type byte. kMsgFindNode — FINDNODE message type byte. kMsgNodes — NODES message type byte. kMsgTalkReq — TALKREQ message type byte. kMsgTalkResp — TALKRESP message type byte. kProtocolVersion — discv5 protocol version (current). to_string — Convert a discv5Error code to a human-readable C string. --- source: /SuperGenius/Namespaces/df/d3b/namespaceecdsa__t/ title: ecdsa_t (namespace) --- Members: CurveType — ECDSA uses secp256k curve. base_field_type — The base field type is dependant on the curve. scalar_field_type — The scalar field type is dependant on the curve. scalar_field_value_type — The value type fo the scalar field type. random_generator_type — A random algebraic generator. hash_type — The deterministic generator used by Ethereum key pair. generator_type — RFC6979 deterministic generator. padding_policy — Ethereum passing policy. policy_type — Ethereum policy type. signature_type --- source: /SuperGenius/Namespaces/d5/d69/namespaceelgamal/ title: elgamal (namespace) --- Members: CurveType — ECDSA uses secp256k curve. base_field_type — The base field type is dependant on the curve. scalar_field_type — The scalar field type is dependant on the curve. scalar_field_value_type — The value type fo the scalar field type. random_generator_type — A random algebraic generator. hash_type — The deterministic generator used by Ethereum key pair. generator_type — RFC6979 deterministic generator. padding_policy — Ethereum passing policy. policy_type — Ethereum policy type. signature_type --- source: /SuperGenius/Namespaces/da/ddf/namespaceeth/ title: eth (namespace) --- Members: ReceiptLogVerificationError HandshakeMessageDisposition — Result of processing one inbound ETH handshake-phase message. EthMessageFieldType StatusValidationError — Errors returned by validate_status(), mirroring go-ethereum's readStatus error values from eth/protocols/eth/handshake.go. EthWatchDiscoveryMode — Peer source strategy for production eth-watch startup. FinalityHeadKind EthStatusAcceptedHandler — Callback invoked when the remote ETH Status message is accepted. EthStatusRemoteDisconnectHandler — Callback invoked when the remote sends an RLPx Disconnect during ETH Status. ReceiptBatchHandler Hash256 Address Bloom StatusMessage — Dual-version Status message (ETH/68 or ETH/69). EventWatchId — Subscription handle returned by EthWatchService::watch_event(). WatchEventNotificationCallback — Callback invoked for each decoded filtered event with chain/session metadata. DecodedEventCallback — Typed callback for a decoded event log. SendCallback — Callback used by EthWatchService to send an outgoing eth message. WatchId — Registration handle returned by EventWatcher::watch(). Passed back to EventWatcher::unwatch() to remove a subscription. EventCallback — Callback invoked for every log that matches a registered filter. Secp256k1PrivateKey kAbiWordSize — EVM ABI encoding constants (ABI spec: https://docs.soliditylang.org/en/latest/abi-spec.html) kAbiAddressSize — Ethereum address is 20 bytes. kAbiAddressPadding — 12 bytes of left-padding kAbiBoolByteIndex — Canonical bool lives in rightmost byte (index 31) kRlpListPrefixMin — EVM / RLP encoding thresholds. kTypedTxPrefixSize — EIP-2718 typed transaction envelope. kDefaultChainId — Default chain ID used when none is specified (Ethereum mainnet) kKeccak256Size — Keccak-256 digest size (bytes) kEthProtocolVersion66 kEthProtocolVersion67 kEthProtocolVersion68 kEthProtocolVersion69 operator== operator< bridge_event_key verify_receipt_log compute_bridge_message_id — Canonical message identifier for an EVM bridge source event. bridge_event_claim_payload — Canonical bytes for bridge-event consensus payloads and watcher signatures. decode_bridge_event_claim_payload bridge_event_domain_separator bridge_event_claim_hash observer_address_from_private_key sign_bridge_event_claim verify_bridge_event_observation PerformEthStatusHandshake — Execute the ETH Status startup handshake for a negotiated ETH session. NormalizeEthWireMessageId — Return the ETH-local message id for a wire-level message. ExtractLatestBlockNumber — Return the latest block number from a validated ETH Status message. DecodeValidatedStatusMessage — Decode and validate an inbound ETH Status message. HandleEthHandshakeMessage — Process one inbound ETH handshake-phase message. make_eth_peer_queue — Create an eth-watch peer queue and preload the chain cache split. BuildLocalStatusMessage — Build the local ETH Status message for the negotiated ETH protocol version. ValidateRemoteStatusMessage — Validate a remote ETH Status message against negotiated version and chain. StartEthStatusHandshake — Install post-handshake ETH inbound handling on a negotiated session. checked_receipt_log_ordinal — Narrow a receipt-local log ordinal without truncation. make_event_filter make_eth_watcher_pool — Create the shared watcher connection pool used by chain peer dialers. start_eth_watch_chain_peer_dialing — Create a per-chain dial scheduler and enqueue the provided peer candidates. finality_policy_for_chain_id choose_finality_head is_final_under_policy get_common_fields — Extract fields common to both ETH/68 and ETH/69 Status messages. secp256k1_address_from_private_key secp256k1_recover_address secp256k1_sign_recoverable DecompressXOnlyPubkey — Decompress a 32-byte X-only secp256k1 public key to a 128-char hex destination. bridge_message_id — Convenience overload that extracts canonical fields from a claim. --- source: /SuperGenius/Namespaces/d7/d56/namespaceeth_1_1abi/ title: eth::abi (namespace) --- Members: AbiParamKind — Identifies one parameter in an event/function signature. AbiValue — A decoded ABI value. Only the types needed for common ERC-20/ERC-721 events are included: address, uint256, bytes32, bool, bytes, string. keccak256 — Compute Keccak-256 of an arbitrary byte sequence. keccak256 — Compute Keccak-256 of a string (e.g. an event signature). event_signature_hash — Compute the event topic[0] hash from a human-readable signature. decode_abi_word — Decode a single 32-byte ABI word from a topic or head slot. decode_indexed_param — Decode an indexed event parameter from a topic hash. decode_log_data — Decode the ABI-encoded data field of a log entry. decode_log — Fully decode a log entry given its event descriptor. --- source: /SuperGenius/Namespaces/d7/d8d/namespaceeth_1_1cli/ title: eth::cli (namespace) --- Members: parse_address — Parse a 0x-prefixed or bare 40-hex-char Ethereum address. event_registry — Process-wide singleton registry, pre-populated with well-known events. infer_params — Convenience wrapper: look up sig in the global registry. Replaces the old infer_params() free function. build_service_watch_specs — Convert CLI watch flags into service-level watch specs. build_service_config — Build the production service config used by cache-backed CLI modes. --- source: /SuperGenius/Namespaces/d7/da3/namespaceeth_1_1codec/ title: eth::codec (namespace) --- Members: TransactionType — Ethereum transaction types per EIP-2718. Hash256 Address Bloom ByteBuffer EncodeResult DecodeResult encode_log_entry decode_log_entry encode_access_list_entry decode_access_list_entry encode_transaction — Encode a transaction. Typed transactions (EIP-2930, EIP-1559) are prefixed with their type byte before the RLP payload, per EIP-2718. decode_transaction encode_receipt decode_receipt encode_block_header decode_block_header --- source: /SuperGenius/Namespaces/df/dfe/namespaceeth_1_1protocol/ title: eth::protocol (namespace) --- Members: ByteBuffer EncodeResult DecodeResult ValidationResult — Result type for Status validation (void on success, error on mismatch). Uses boost::outcome with StatusValidationError — mirrors go-ethereum's readStatus() return values from eth/protocols/eth/handshake.go. kStatusMessageId kStatusHandshakeTimeout — Maximum time to wait for a peer's ETH Status after sending ours. Matches go-ethereum's handshakeTimeout (eth/protocols/eth/handshake.go). If the peer does not reply within this window it is dropped as malicious or mismatched (e.g. a Polygon bor node on the Ethereum P2P network). kNewBlockHashesMessageId kTransactionsMessageId kGetBlockHeadersMessageId kBlockHeadersMessageId kGetBlockBodiesMessageId kBlockBodiesMessageId kNewBlockMessageId kNewPooledTransactionHashesMessageId kGetPooledTransactionsMessageId kPooledTransactionsMessageId kUpgradeStatusMessageId kGetReceiptsMessageId kReceiptsMessageId kBlockRangeUpdateMessageId encode_status decode_status decode_status validate_status — Validate a decoded StatusMessage against our expected chain parameters. encode_new_block_hashes decode_new_block_hashes encode_new_pooled_tx_hashes decode_new_pooled_tx_hashes encode_block_range_update decode_block_range_update encode_upgrade_status decode_upgrade_status encode_get_block_headers decode_get_block_headers encode_block_headers decode_block_headers encode_get_receipts decode_get_receipts decode_get_receipts encode_receipts decode_receipts decode_receipts encode_get_pooled_transactions decode_get_pooled_transactions encode_pooled_transactions decode_pooled_transactions encode_get_block_bodies decode_get_block_bodies encode_block_bodies decode_block_bodies decode_block_bodies encode_new_block decode_new_block decode_new_block --- source: /SuperGenius/Namespaces/d8/d41/namespaceeth_1_1rpc/ title: eth::rpc (namespace) --- Members: RpcBlockTag AuditSeverity RpcEndpointState RpcEndpointErrorCode ProbeStatus RpcResult RpcEnvLookup load_chainlist_from_json_text — Parse chainid.network chains.json into normalized RPC endpoint configs. filter_to_configured_chains — Filter endpoint configs to only those matching configured chain IDs. block_tag_name make_json_rpc_request make_eth_chain_id_request parse_chain_id_response make_get_block_by_number_request make_get_logs_request make_get_transaction_receipt_request parse_block_number_response parse_get_logs_response parse_transaction_receipt_response audit_rpc_config to_string to_string render_rpc_endpoint_url — Resolve a URL template into a concrete endpoint URL. build_rpc_endpoint — Materialize a runtime endpoint from configuration. group_rpc_endpoints — Group endpoints by chain name and chain id with deterministic ordering. make_receipt_source load_rpc_manager_config_result_from_json_text — Load RPC manager configuration from JSON text. load_rpc_manager_config_result_from_json — Load RPC manager configuration from a JSON file. load_rpc_manager_config_from_json_text — Load RPC manager configuration from JSON text. load_rpc_manager_config_from_json — Load RPC manager configuration from a JSON file. to_string probe_endpoint_chain_id probe_endpoint_pool to_string --- source: /SuperGenius/Namespaces/df/dc1/namespaceethereum/ title: ethereum (namespace) --- Members: CurveType — Curve type used by Ethereum keys. base_field_type — Ethereum base field type. scalar_field_type — Ethereum scalar field type. scalar_field_value_type — Ethereum value from the scalar field type. random_generator_type — Random generator type, to generate new Ethereum keys/addresses. hash_type — The hash type used by Ethereum address derivation. generator_type — The deterministic generator used by Ethereum key pair. padding_policy — Ethereum passing policy. policy_type — Ethereum policy type. signature_type — Ethereum signature type. derivation_hash_type — The hash type used by Ethereum address derivation. EthereumKeyGenerator::ExtractPubKeyFromField< std::vector< std::uint8_t > > EthereumKeyGenerator::ExtractPubKeyFromField< EthereumKeyGenerator::PubKeyPair_t > --- source: /SuperGenius/Namespaces/d1/d45/namespaceevmrelay_1_1examples/ title: evmrelay::examples (namespace) --- Members: parse_chain_discovery_default parse_discovery_fork_filter load_chain_config_root load_chain_config_entry load_default_all_chains load_fork_hash — Load the latest fork hash from generated chain_enodes.json/.gz. load_chain_peer_config load_enr_tree_url — Return the configured EIP-1459 ENR-tree root URL for chain. apply_chain_discovery_config — Apply data-driven discovery defaults from chains_config.json. --- source: /SuperGenius/Namespaces/d1/d93/namespaceintx/ title: intx (namespace) --- Members: add_with_carry add_with_carry operator+ operator+ sub_with_carry sub_with_carry operator- operator- operator++ operator-- operator++ operator-- fast_add operator== operator!= operator< operator<= operator> operator>= operator~ operator| operator& operator^ operator<< operator<< operator>> operator>> umul — Full unsigned multiplication 64 x 64 -> 128. operator* operator+= operator-= operator*= operator|= operator&= operator^= operator<<= operator>>= reciprocal_2by1 reciprocal_3by2 udivrem_2by1 udivrem_3by2 udivrem sdivrem operator/ operator% operator/= operator%= uint128 uint192 uint256 uint320 uint384 uint512 is_constant_evaluated clz_generic clz_generic clz clz clz bswap bswap bswap bswap bswap bswap throw_ from_dec_digit from_hex_digit from_string from_string operator""_u128 to_string hex operator== operator== operator== operator!= operator!= operator!= operator< operator< operator< operator< operator> operator> operator> operator>= operator>= operator>= operator<= operator<= operator<= slt operator| operator& operator^ operator~ operator<< operator<< operator>> operator>> operator<< operator>> operator<< operator>> operator>>= as_words as_words as_words as_words as_bytes as_bytes operator+ operator- operator- operator+= operator-= umul operator* operator*= exp count_significant_words count_significant_bytes count_significant_bytes clz udivrem sdivrem operator/ operator% operator/= operator%= bswap operator+ operator+ operator- operator- operator* operator* operator/ operator/ operator% operator% operator| operator| operator& operator& operator^ operator^ operator|= operator&= operator^= operator<<= operator>>= addmod mulmod operator""_u256 operator""_u512 --- source: /SuperGenius/Namespaces/de/d01/namespaceintx_1_1be/ title: intx::be (namespace) --- Members: load load store — Stores an uint value in a bytes array in big-endian order. store trunc trunc — Stores the truncated value of an uint in the .bytes field of an object of type T. --- source: /SuperGenius/Namespaces/d6/d76/namespaceintx_1_1be_1_1unsafe/ title: intx::be::unsafe (namespace) --- Members: load store --- source: /SuperGenius/Namespaces/d5/df7/namespaceintx_1_1internal/ title: intx::internal (namespace) --- Members: reciprocal_table — Reciprocal lookup table. reciprocal_table_item clz_nonzero — Counts the number of zero leading bits in nonzero argument x. normalize udivrem_by1 udivrem_by2 add — s = x + y. submul — r = x - multiplier * y. udivrem_knuth --- source: /SuperGenius/Namespaces/d7/df0/namespaceintx_1_1le/ title: intx::le (namespace) --- Members: load store --- source: /SuperGenius/Namespaces/dd/d15/namespace_key_generator/ title: KeyGenerator (namespace) --- Members: cpp_int uint256_t --- source: /SuperGenius/Namespaces/d4/dd1/namespaceplaceholder__verifier/ title: placeholder_verifier (namespace) --- Members: placeholder_verifier use_lookups batches_num commitments_num points_num poly_num initial_proof_points_num round_proof_points_num fri_roots_num initial_merkle_proofs_num initial_merkle_proofs_position_num initial_merkle_proofs_hash_num round_merkle_proofs_position_num round_merkle_proofs_hash_num final_polynomial_size lambda rows_amount rows_log total_columns sorted_columns permutation_size zero_indices table_values_num gates_amount gates_selector_indices constraints_amount quotient_polys_start quotient_polys_amount lookup_sorted_polys_start D0_size D0_log D0_omega omega fri_rounds gates_sizes unique_points singles_amount batches_amount_list L0_IND Z_AT_XI_IND F_CONSOLIDATED_IND T_CONSOLIDATED_IND transcript transcript_challenge pow_rows_amount pow2 pow3 pow4 pow5 pow6 pow7 pow8 pow9 pow fill_singles generate_challenges xi_polys calculate_constraints gate_argument_verifier calculate_leaf_hash --- source: /SuperGenius/Namespaces/dd/d79/namespacerlp/ title: rlp (namespace) --- Members: Leftover EncodingError DecodingError StreamingError EncodingResult EncodingOperationResult Result DecodingResult StreamingResult StreamingOperationResult Address Hash256 Signature Bloom Bytes ByteView kEmptyStringCode kEmptyListCode kMaxShortStringLen kMaxShortListLen kShortStringOffset kLongStringOffset kShortListOffset kLongListOffset kRlpSingleByteThreshold kLongPrefixByteSize — Size of the single prefix byte prepended before the big-endian length field in long strings/lists. kSingleByteStringSize — Minimum encoded size of a single-byte RLP string (prefix byte + payload byte). is_unsigned_integral_v is_rlp_encodable_v is_rlp_decodable_v encoding_error_to_string decoding_error_to_string streaming_error_to_string hexToString addAddress addHash addSignature addBloom readAddress readHash readSignature readBloom encodeLargeString encodeChunkedList decodeLargeString decodeChunkedList decodeChunkedListFull --- source: /SuperGenius/Namespaces/d0/dc4/namespacerlp_1_1base/ title: rlp::base (namespace) --- Members: Logger createLogger — Create a logger instance. --- source: /SuperGenius/Namespaces/d9/d8b/namespacerlp_1_1base_1_1byte__encoding/ title: rlp::base::byte_encoding (namespace) --- Members: ByteBuffer append_u32_be append_u64_be append_uint256_be append_array append_length_prefixed_bytes append_length_prefixed_arrays --- source: /SuperGenius/Namespaces/d8/d3f/namespacerlp_1_1base_1_1json/ title: rlp::base::json (namespace) --- Members: JsonErrorCode JsonFieldType JsonResult JsonParsedObjectPtr JsonParsedArrayPtr to_string parse_object get_value get_string parse_string parse_string get_optional_string get_bool parse_bool parse_bool get_array get_u8 get_u32 get_u64 parse_size_t parse_u8 parse_u8 parse_u32 parse_u32 parse_u64 parse_u64 parse_schema_object parse_schema_object parse_schema_value get_parsed_value get_parsed_string get_parsed_bool get_parsed_u8 get_parsed_u32 get_parsed_u64 get_parsed_size get_parsed_array get_parsed_object --- source: /SuperGenius/Namespaces/d9/dc2/namespacerlp_1_1base_1_1parse/ title: rlp::base::parse (namespace) --- Members: kHexCharsPerByte hex_nibble trim_hex_prefix uint16_decimal uint64_decimal uint64_hex uint64_hex_quantity hex_bytes hex_bytes ascii_lower hex_array_string hex_array --- source: /SuperGenius/Namespaces/d6/de3/namespacerlp_1_1endian/ title: rlp::endian (namespace) --- Members: to_big_compact from_big_compact to_big_compact from_big_compact to_big_compact< uint8_t > to_big_compact< uint16_t > to_big_compact< uint32_t > to_big_compact< uint64_t > from_big_compact< uint8_t > from_big_compact< uint16_t > from_big_compact< uint32_t > from_big_compact< uint64_t > --- source: /SuperGenius/Namespaces/dd/d2d/namespacerlpx/ title: rlpx (namespace) --- Members: SessionError AuthError FramingError CryptoError ConnectProgressPhase SessionState DisconnectReason tcp Result AuthResult FramingResult CryptoResult VoidResult AuthVoidResult FramingVoidResult CryptoVoidResult MessageHandler HelloHandler DisconnectHandler PingHandler PongHandler EthMessageHandler ConnectProgressHandler PublicKey PrivateKey Nonce SharedSecret AesKey MacKey MacDigest FrameHeader ByteBuffer ByteView MutableByteView kPublicKeySize kPrivateKeySize kNonceSize kSharedSecretSize kAesKeySize kMacKeySize kUncompressedPubKeyPrefixSize — Uncompressed secp256k1 public key: 0x04 prefix byte + 64 bytes = 65 bytes total. kUncompressedPubKeySize kUncompressedPubKeyPrefix kHmacSha256Size — HMAC-SHA256 full digest output size. kAesBlockSize kMacSize kFrameHeaderSize kEciesMacSize — ECIES / EIP-8 wire constants. kEciesOverheadSize kEip8LengthPrefixSize kEip8AuthPaddingSize kMaxEip8HandshakePacketSize kFrameLengthSize — Number of bytes used to encode the frame length inside the frame header. kFrameHeaderDataOffset kFrameHeaderWithMacSize kFramePaddingAlignment kFrameLengthMsbOffset kFrameLengthMiddleOffset kFrameLengthLsbOffset kFrameLengthMsbShift kFrameLengthMiddleShift kFrameLengthLsbShift kFrameHeaderStaticRlpBytes kEcdsaCompactSigSize kEcdsaRecoveryIdSize kEcdsaSigSize kAuthVersionSize — Version byte appended to auth/ack messages (RLPx v4 EIP-8). kAuthVersion kMaxFrameSizeMiB — Maximum RLPx frame payload: 16 MiB. kMaxFrameSize kHelloMessageId kDisconnectMessageId kPingMessageId kPongMessageId kProtocolVersion kTcpConnectionTimeout kProtocolHandshakeTimeout kSendLoopPollInterval to_string to_string to_string to_string --- source: /SuperGenius/Namespaces/d7/df1/namespacerlpx_1_1auth/ title: rlpx::auth (namespace) --- Members: kAuthSize kAckSize — ack plaintext = eph_pubkey(64) + nonce(32) + ver(1) = 97 derive_frame_secrets — Derive RLPx frame secrets from authenticated handshake key material. --- source: /SuperGenius/Namespaces/d0/d85/namespacerlpx_1_1detail/ title: rlpx::detail (namespace) --- Members: to_rlp_view from_rlp_view to_rlp_bytes from_rlp_bytes --- source: /SuperGenius/Namespaces/d4/d7a/namespacerlpx_1_1protocol/ title: rlpx::protocol (namespace) --- Members: reason_to_byte byte_to_reason --- source: /SuperGenius/Namespaces/d7/dc1/namespacerlpx_1_1socket/ title: rlpx::socket (namespace) --- Members: tcp connect_with_timeout connect_with_timeout — Connect to remote endpoint with timeout. --- source: /SuperGenius/Namespaces/d2/d2b/namespacesgns/ title: sgns (namespace) --- Members: ChainlistFetcher — Fetches the chainlist dataset (JSON text) used to discover public RPC URLs at startup. AccountSource TransportFactory — Factory callable that produces a JsonRpcTransport from a URL and timeout. EscrowDataPair UTXOTxParameters — Pair of signed inputs and destination outputs that make up a UTXO transaction payload. kBridgeSourceBurnedSig — Canonical Solidity event signatures for bridge events. Single source of truth — shared by watch registration, catch-up scan, and RPC endpoint validation. kBridgeOutInitiatedSig kGeniusValidatorRegistered kMigrationValidatorRegistered — Static instance to trigger registration of the MigrationInputValidator before main() starts. MAX_PUBSUB_TX_BYTES NONCE_SUBJECT_TYPE TASK_RESULT_SUBJECT_TYPE REGISTRY_BATCH_SUBJECT_TYPE FILE_NAME BridgeRelayerLogger — Returns a new instance of the BridgeRelayer logger. InputValidatorLogger GeniusNodeLogger generate_uuid_with_ipfs_id operator<< operator>> to_string — Convert a byte array to a hexadecimal string. isLittleEndian — Checks if the architecture is little endian. Vector2Num — Converts a little-endian byte vector into a number. Vector2Num Vector2Num Num2Vector — Converts a number into a byte vector (little-endian). HexASCII2Num — Converts a hexadecimal ASCII char array into a number. HexASCII2NumStr — Converts a hexadecimal ASCII char array into a vector of numbers. AdjustEndianess — Adjust endianess if needed. Uint256ToString make_visitor — Creates a compile-time visitor from a set of lambdas. visit_in_place — Applies an in-place visitor to a boost::variant. match — apply Matcher to optional T match_in_place — construct visitor from Fs and apply it to optional T ConsensusManagerLogger ProposalSigningBytes — Builds canonical bytes used to sign a consensus proposal. VoteSigningBytes — Builds canonical bytes used to sign a consensus vote. VoteBundleSigningBytes — Builds canonical bytes used to sign a consensus vote bundle. ComputeProposalId — Computes deterministic proposal id from proposal content. ValidateProposal — Validates proposal basic shape, signature, and computed id. decodeChunkedTransfer InitGeniusSDKAndroid GetSnarkFromProto --- source: /SuperGenius/Namespaces/d4/dcb/namespacesgns_1_1base/ title: sgns::base (namespace) --- Members: BlobError UnhexError — error codes for exceptions that may occur during unhexing Hash64 Hash128 Hash256 Hash512 Logger operator<< — scale-encodes blob instance to stream operator>> — decodes blob instance from stream operator<< operator<< operator<< — override operator<< for all streams except std::ostream operator>> — decodes buffer object from stream hex_upper — Converts bytes to uppercase hex representation. hex_lower — Converts bytes to hex representation. IsHexAddress — Checks whether a string is a 128-character lowercase hexadecimal address. unhex — Converts hex representation to bytes. unhexWith0x — Unhex hex-string with 0x in the begining. createLogger — Create a logger instance. raise — throws outcome::result error as boost exception raise — throws outcome::result error made of error as boost exception operator< --- source: /SuperGenius/Namespaces/d4/dd0/namespacesgns_1_1crdt/ title: sgns::crdt (namespace) --- Members: CrdtOptions CrdtDatastore HierarchicalKey GraphsyncDAGSyncer RocksdbDatastore IpfsRocksDb GossipPubSub GraphsyncImpl CryptoProvider KeyMarshaller KeyValidator CRDTBroadcast CRDTSet --- source: /SuperGenius/Namespaces/df/d6e/namespacesgns_1_1crypto/ title: sgns::crypto (namespace) --- Members: twox_64 twox_128 blake2b_128 twox_256 blake2b_256 keccak_256 blake2s_256 sha2_256 sha2_256 sha256 sha256 sha256 make_twox64 make_twox64 make_twox128 make_twox128 make_twox256 make_twox256 --- source: /SuperGenius/Namespaces/d1/dec/namespacesgns_1_1input__validator__constants/ title: sgns::input_validator_constants (namespace) --- Members: HASH256_BYTES SERIALIZED_UINT32_BYTES SERIALIZED_UINT64_BYTES OUTPUT_INDEX_OFFSET OWNER_ADDRESS_LENGTH_OFFSET OWNER_ADDRESS_OFFSET TOKEN_ID_BYTES_IN_PAYLOAD AMOUNT_BYTES_IN_PAYLOAD ESCROW_LOCK_OUTPUT_INDEX TRANSFER_TX_TYPE --- source: /SuperGenius/Namespaces/d6/d25/namespacesgns_1_1ipfs__bitswap/ title: sgns::ipfs_bitswap (namespace) --- Header file for the distrubuted processing node creativeid00 Header file for subtask queue accessor implementation creativeid00 --- source: /SuperGenius/Namespaces/d4/d75/namespacesgns_1_1ipfs__pubsub/ title: sgns::ipfs_pubsub (namespace) --- Header file for subtask queue channel implementation creativeid00 --- source: /SuperGenius/Namespaces/d1/db4/namespacesgns_1_1multisig/ title: sgns::multisig (namespace) --- Members: SignatureBytes CollectedSignatures VerifyPayloadSignature — Verifies a signature over an arbitrary raw-byte payload. Delegates entirely to GeniusAccount::VerifySignature; no custom crypto or signing-bytes construction is performed here (the payload is assumed already-canonical). --- source: /SuperGenius/Namespaces/df/d6a/namespacesgns_1_1processing/ title: sgns::processing (namespace) --- Header file for the distrubuted processing Room creativeid00 Header file for the distributed processing Room creativeid00 Header file for the distributed subtasks queue creativeid00 Header file for subtask queue accessor interface creativeid00 Header file for subtask queue channel interface creativeid00 Header file for the distributed subtasks queue SuperGenius/Creative00 Header file for the distrubuted task queue creativeid00 Members: TaskQueueImplLogger generate_uuid_with_ipfs_id --- source: /SuperGenius/Namespaces/d9/d4e/namespacesgns_1_1securecrdt/ title: sgns::securecrdt (namespace) --- Members: SignerSetSource — Injectable callback resolving the current authorized signer set for a given base_key. NOT hard-wired to TrustedPeerRegistry (which does not exist until Phase 10) - tests inject a fixed-list lambda. ValidateQuorumThreshold — Validates that threshold is at or above the majority-safety floor for a signer set of size signer_set_size (ceil(0.51*signer_set_size), computed via integer arithmetic). --- source: /SuperGenius/Namespaces/d1/dc7/namespacesgns_1_1sgprocessing/ title: sgns::sgprocessing (namespace) --- Header file for base class for processors. Derived classes will handle processing various types of AI/ML processing as needed. Give this to a ProcessingCoreImpl. Justin Church Header file for processing bool inputs using MNN Header file for processing buffer inputs using MNN Header file for processing float inputs using MNN Header file for processing int inputs using MNN Header file for processing mat2 inputs using MNN Header file for processing mat3 inputs using MNN Header file for processing mat4 inputs using MNN Header file for processing tensor inputs using MNN Header file for processing texture1D inputs using MNN Header file for processing textureCube inputs using MNN Members: ProcessingProcessor --- source: /SuperGenius/Namespaces/da/d41/namespacesgns_1_1sgprocessing_1_1_0d324/ title: sgns::sgprocessing::@324 (namespace) --- Members: VolumeLayout --- source: /SuperGenius/Namespaces/d6/d05/namespacesgns_1_1sgprocessing_1_1_0d325/ title: sgns::sgprocessing::@325 (namespace) --- Members: CubeLayout --- source: /SuperGenius/Namespaces/de/d65/namespacesgns_1_1sgprocessing_1_1_0d329/ title: sgns::sgprocessing::@329 (namespace) --- Members: VolumeLayout --- source: /SuperGenius/Namespaces/d6/ded/namespacesgns_1_1sgprocmanager/ title: sgns::sgprocmanager (namespace) --- Members: Logger createLogger --- source: /SuperGenius/Namespaces/d1/de3/namespacesgns_1_1sgprocmanagersha/ title: sgns::sgprocmanagersha (namespace) --- Members: sha256 --- source: /SuperGenius/Namespaces/d0/dbf/namespacesgns_1_1storage/ title: sgns::storage (namespace) --- This file contains convenience typedefs for interfaces from face/, as they are mostly used with Buffer key and value types Members: DatabaseError — universal database interface error Buffer BufferMap BufferBatch ReadOnlyBufferMap BatchWriteBufferMap BufferStorage BufferMapCursor BlockBasedTableOptions error_from_rocksdb GetAuthoritySetKey GetSetStateKey GetGenesisBlockHashLookupKey GetLastFinalizedBlockHashLookupKey error_as_result error_as_result make_slice make_span make_buffer --- source: /SuperGenius/Namespaces/dd/de2/namespacesgns_1_1utxo__address/ title: sgns::utxo_address (namespace) --- Members: IsEscrowLockAddress — Checks if the address is a valid escrow lock address (0x-prefixed 64 hex chars) IsAccountPublicKeyAddress — Checks if the address is a public key. --- source: /SuperGenius/Namespaces/d5/d58/namespacesgns_1_1utxo__merkle/ title: sgns::utxo_merkle (namespace) --- Utilities for building deterministic Merkle roots over ordered UTXO payloads. Members: kLeafPrefix — Domain separator prefix used for hashed leaf payloads. kNodePrefix — Domain separator prefix used for hashed internal nodes. AppendUInt32BE — Appends a 32-bit unsigned integer in big-endian order. AppendUInt64BE — Appends a 64-bit unsigned integer in big-endian order. ReadUInt32BE — Reads a 32-bit unsigned integer from big-endian bytes. ReadUInt64BE — Reads a 64-bit unsigned integer from big-endian bytes. OutPointKey — Generates a canonical key for a UTXO outpoint, used for deterministic ordering in Merkle tree construction. SerializeUTXOLeafPayload — Serializes a UTXO into the canonical leaf payload used for Merkle hashing. HashLeaf — Hashes a serialized UTXO leaf payload with the leaf domain separator. HashNode — Hashes two child nodes with the internal-node domain separator. EmptyUTXOMerkleRoot — Returns the canonical root used for an empty UTXO set. ComputeMerkleRootFromLeafHashes — Reduces a list of leaf hashes into a single Merkle root. ComputeMerkleRootFromPayloads — Sorts canonical payloads, hashes them as leaves, and computes the Merkle root. ComputeMerkleRootFromUTXOs — Computes the Merkle root for a given set of UTXOs by serializing them into canonical payloads and hashing them. --- source: /SuperGenius/Namespaces/d8/d5b/namespacesgns_1_1version/ title: sgns::version (namespace) --- Members: MAIN_NET_ID TEST_NET_ID DEV_NET_ID NET_ID_APPENDIX SGNS_VERSION_APPENDIX SuperGeniusVersionNum — Retrieves the complete version number of SuperGenius. SuperGeniusVersionMajor — Retrieves the major version of SuperGenius. SuperGeniusVersionMinor — Retrieves the minor version of SuperGenius. SuperGeniusVersionPatch — Retrieves the patch version of SuperGenius. ProcessingVersion — Retrieves the processing version used by processing task storage keys. SuperGeniusVersionString — Retrieves the short version string of SuperGenius. SuperGeniusVersionFullString — Retrieves the full version string of SuperGenius. SuperGeniusVersionText — Retrieves the display version text of SuperGenius. GetNetworkID GetNetAndVersionAppendix GetNetAndVersionAppendix SetNetworkId --- source: /SuperGenius/Namespaces/d8/dcc/namespacestd/ title: std (namespace) --- STL namespace. --- source: /SuperGenius/Namespaces/d6/d72/namespaceutil/ title: util (namespace) --- Members: to_string — Convert a byte array to a hexadecimal string. isLittleEndian — Checks if the architecture is little endian. HexASCII2Num — Converts a hexadecimal ASCII char array into a number. HexASCII2NumStr — Converts a hexadecimal ASCII char array into a vector of numbers. AdjustEndianess — Adjust endianess if needed. --- source: /SuperGenius/Files/de/d47/chain__config_8hpp/ title: chain_config.hpp (file) --- Members: parse_chain_discovery_default parse_discovery_fork_filter load_chain_config_root load_chain_config_entry load_default_all_chains load_fork_hash — Load the latest fork hash from generated chain_enodes.json/.gz. load_chain_peer_config load_enr_tree_url — Return the configured EIP-1459 ENR-tree root URL for chain. apply_chain_discovery_config — Apply data-driven discovery defaults from chains_config.json. --- source: /SuperGenius/Files/d5/dae/test__discovery_8cpp/ title: test_discovery.cpp (file) --- Members: kMainnetNetworkId kEthOffset kForkHashChainKey kChainPeerCacheChainKey kChainPeersUrlDefault kMainnetForkHashFallback hex_to_nibble hash256_from_hex all_chain_targets mainnet_genesis dial_connect_only load_chain_fork_id enqueue_chain_peers seed_bootnodes load_bootstrap_peers create_chain_runtime main --- source: /SuperGenius/Files/d8/d72/test__discv5__connect_8cpp/ title: test_discv5_connect.cpp (file) --- Members: kSepoliaNetworkId kEthOffset kSepoliaRlpxPort kSepoliaForkHashFallback pubkey_to_hex sepolia_genesis is_publicly_routable_ip subnet_key_v4_24 is_candidate_blocked dial_connect_only main --- source: /SuperGenius/Files/dd/d72/test__enr__survey_8cpp/ title: test_enr_survey.cpp (file) --- Members: format_hash4 — Format a 4-byte array as "aa bb cc dd". main --- source: /SuperGenius/Files/dc/d28/discv5__crawl_8cpp/ title: discv5_crawl.cpp (file) --- Members: main --- source: /SuperGenius/Files/d6/dd4/eth__watch_8cpp/ title: eth_watch.cpp (file) --- Members: main --- source: /SuperGenius/Files/d5/d3f/eth__watch__example__test_8cpp/ title: eth_watch_example_test.cpp (file) --- Members: main --- source: /SuperGenius/Files/db/dc8/byte__encoding_8hpp/ title: byte_encoding.hpp (file) --- Members: ByteBuffer append_u32_be append_u64_be append_uint256_be append_array append_length_prefixed_bytes append_length_prefixed_arrays --- source: /SuperGenius/Files/df/d62/json__utility_8hpp/ title: json_utility.hpp (file) --- Members: JsonErrorCode JsonFieldType JsonResult JsonParsedObjectPtr JsonParsedArrayPtr to_string parse_object get_value get_string parse_string parse_string get_optional_string get_bool parse_bool parse_bool get_array get_u8 get_u32 get_u64 parse_size_t parse_u8 parse_u8 parse_u32 parse_u32 parse_u64 parse_u64 parse_schema_object parse_schema_object parse_schema_value get_parsed_value get_parsed_string get_parsed_bool get_parsed_u8 get_parsed_u32 get_parsed_u64 get_parsed_size get_parsed_array get_parsed_object --- source: /SuperGenius/Files/da/d0a/parse__utility_8hpp/ title: parse_utility.hpp (file) --- Members: kHexCharsPerByte hex_nibble trim_hex_prefix uint16_decimal uint64_decimal uint64_hex uint64_hex_quantity hex_bytes hex_bytes ascii_lower hex_array_string hex_array --- source: /SuperGenius/Files/da/dfc/rlp-logger_8hpp/ title: rlp-logger.hpp (file) --- Members: Logger createLogger — Create a logger instance. --- source: /SuperGenius/Files/d9/df1/discovered__peer_8hpp/ title: discovered_peer.hpp (file) --- Members: NodeId — Node identifier — 64-byte uncompressed secp256k1 public key (without the 0x04 prefix). --- source: /SuperGenius/Files/d0/d86/bootstrap__peers_8hpp/ title: bootstrap_peers.hpp (file) --- Members: BootstrapCacheRefreshResult BootstrapChainConfig BootstrapSignatureVerificationResult bootstrap_cache_json_path find_bootstrap_peers_json_path download_bootstrap_json write_bootstrap_cache_json_if_changed refresh_bootstrap_cache_json load_bootstrap_peers_from_json_text load_bootstrap_peers_from_json load_bootstrap_fork_id_hash_from_json_text load_bootstrap_fork_id_hash_from_json load_bootstrap_chain_config_from_json_text load_bootstrap_chain_config_from_json verify_bootstrap_json_signature --- source: /SuperGenius/Files/dc/dba/chain__peers_8hpp/ title: chain_peers.hpp (file) --- Members: ChainDiscoveryDefault DiscoveryForkFilter chain_peer_cache_json_path — Return the default local cache path for chain_enodes.json next to the executable. find_chain_peer_cache_json_path — Locate a local chain peer cache JSON file. download_chain_peer_cache_json — Download the chain peer cache JSON payload from a remote URL. Supports either raw JSON or gzip-compressed JSON bodies. write_chain_peer_cache_json_if_changed — Write the chain peer JSON cache only when the contents changed. refresh_chain_peer_cache_json — Refresh a local chain peer cache from a remote URL. make_validated_peer_from_enode — Parse an enode:// peer URI into a validated peer entry. make_validated_peer_from_enr — Parse an enr: peer URI into a validated peer entry. load_chain_peers_from_json_text — Load cached peers for a specific chain from JSON text. load_chain_peers_from_json — Load cached peers for a specific chain from a JSON or gzip-compressed JSON file. load_chain_fork_id_hash_from_json_text — Load the first available peer fork hash for a specific chain from JSON text. load_chain_fork_id_hash_from_json — Load the first available peer fork hash for a specific chain from a JSON or gzip-compressed JSON file. load_chain_peer_config_from_json_text — Load the parsed chain configuration from JSON text. load_chain_peer_config_from_json — Load the parsed chain configuration from a JSON or gzip-compressed JSON file. verify_chain_peer_cache_json_signature — Verify the top-level chain_enodes.json signature. --- source: /SuperGenius/Files/d6/d8a/dial__scheduler_8hpp/ title: dial_scheduler.hpp (file) --- Members: DialFn DialFeedbackFn — Callback signature for dial/session exit feedback. FilterFn — Predicate applied to a DiscoveredPeer before it is enqueued for dialing. Return true to allow dialing, false to drop. When unset (nullptr), all peers are accepted. Mirrors go-ethereum UDPv4::NewNodeFilter (eth/protocols/eth/discovery.go). make_fork_id_filter — Create a FilterFn that accepts only peers whose ENR eth entry carries a ForkId with the given 4-byte hash (CRC32 of genesis + applied forks). --- source: /SuperGenius/Files/d6/d86/discovery_8hpp/ title: discovery.hpp (file) --- Members: udp NodeID IPAddress ec DEFAULT_discv4_PORT EncodePing EncodeEndpoint EncodePing test_ping --- source: /SuperGenius/Files/db/d6a/discv4__client_8hpp/ title: discv4_client.hpp (file) --- Members: udp NodeId PeerDiscoveredCallback ErrorCallback --- source: /SuperGenius/Files/d2/dfa/discv4__constants_8hpp/ title: discv4_constants.hpp (file) --- Members: kWireHashSize — Outer Keccak-256 hash. kWireSigSize — Recoverable ECDSA signature. kWirePacketTypeSize — Single packet-type byte. kWireRecoveryIdSize — Recoverable ECDSA recovery id. kWireCompactSigSize kWireHeaderSize kWirePacketTypeOffset kNodeIdSize — Node identity. kNodeIdHexSize kUncompressedPubKeySize — 0x04 prefix + 64 bytes kIPv4Size — Network. kUdpBufferSize kPacketTypePing — Packet type identifiers. kPacketTypePong kPacketTypeFindNode kPacketTypeNeighbours kPacketTypeEnrRequest kPacketTypeEnrResponse kProtocolVersion — Protocol version advertised in PING packets. kPacketExpirySeconds — Default packet expiry window (seconds) kDefaultPingTimeout — Default networking timers. kDefaultPeerExpiry kDefaultDialHistoryExpiry kEnrSeqSize — ENR sequence number field size in PONG (optional, 6-byte big-endian uint48) --- source: /SuperGenius/Files/d5/d36/discv4__error_8hpp/ title: discv4_error.hpp (file) --- Members: discv4Error — Discovery v4 protocol error codes. Result — Result type for Discovery v4 operations. VoidResult — Result type for Discovery v4 operations without return value. to_string — Convert error code to human-readable string. --- source: /SuperGenius/Files/dc/dea/discv4__packet_8hpp/ title: discv4_packet.hpp (file) --- Members: udp --- source: /SuperGenius/Files/d3/d8c/packet__factory_8hpp/ title: packet_factory.hpp (file) --- Members: PacketError udp PacketResult SendCallback --- source: /SuperGenius/Files/d4/db4/discv5__client_8hpp/ title: discv5_client.hpp (file) --- Members: udp --- source: /SuperGenius/Files/d9/df8/discv5__constants_8hpp/ title: discv5_constants.hpp (file) --- Members: kDefaultUdpPort — Default UDP port for discv5 (IANA-assigned). kDefaultTcpPort — Default TCP/RLPx port advertised to discovered peers. kNodeIdBytes — Bytes in an uncompressed secp256k1 public key WITHOUT the 0x04 prefix. This is the 64-byte "node id" used by discv4 and passed to DialHistory. kCompressedKeyBytes — Bytes in a compressed secp256k1 public key (03/02 prefix + 32 bytes). kPrivateKeyBytes — Bytes in a secp256k1 private key. kUncompressedPrefixLen — Bytes in the 0x04 uncompressed-point prefix. kUncompressedPubKeyPrefix kUncompressedPubKeyDataOffset kKeccak256Bytes — Keccak-256 (legacy) digest size in bytes. kIPv4Bytes — IPv4 address wire size in bytes. kIPv6Bytes — IPv6 address wire size in bytes. kIPv4OctetMsb — Byte offset of the most-significant octet in a 4-byte IPv4 field. kIPv4Octet1 — Byte offset of the second octet. kIPv4Octet2 — Byte offset of the third octet. kIPv4OctetLsb — Byte offset of the least-significant octet. kIPv4MsbShift — Left-shift amount to place the MSB octet in a uint32 (big-endian). kIPv4Octet1Shift — Left-shift amount for the second octet. kIPv4Octet2Shift — Left-shift amount for the third octet. kIPv4LsbShift — Left-shift amount for the least-significant octet (no shift). kMaxPortBytes — Maximum bytes an RLP-encoded UDP/TCP port occupies (big-endian uint16). kForkHashBytes — Byte count of the fork-hash field inside an ENR "eth" entry. kProtocolIdBytes — Byte length of the "discv5" protocol-ID magic string. kProtocolId — The discv5 packet protocol-ID string. kGcmNonceBytes — Byte length of the AES-GCM nonce used for message encryption. kMaskingIvBytes — Byte length of the masking IV that precedes the static header. kWhoareyouIdNonceBytes — Byte length of the WHOAREYOU id-nonce field. kMinPacketBytes — Minimum valid discv5 packet size (go-ethereum minPacketSize). kMaxPacketBytes — Maximum valid discv5 packet size in bytes. kAes128KeyBytes — AES-128 session key size in bytes. kGcmTagBytes — AES-GCM authentication tag size in bytes. kRandomMessageCiphertextBytes — Random encrypted payload size used for pre-handshake message placeholders. kFindNodeDistanceAll — FINDNODE distance that requests the full routing table (log2 space upper bound + 1). kHkdfFirstBlockCounter — Single-byte HKDF expansion block counter used for the first output block. kMessageTypePrefixBytes — Byte size of the leading message-type prefix in decrypted discv5 payloads. kNodesResponseCountSingle — Number of ENR records returned by the local single-record NODES reply helper. kEnrMaxBytes — Maximum total size of a serialised ENR record (EIP-778 SizeLimit). kEnrSigBytes — Compact secp256k1 ECDSA signature size stored in an ENR (no recid). kEnrPrefixLen — Byte length of the "enr:" URI prefix. kEnrPrefix — The "enr:" URI prefix string. kInitialEnrSeq — Initial ENR sequence number for locally generated records. kIdentitySchemeV4 — ENR identity scheme string for secp256k1-v4. kIdentitySchemeV4Bytes kEnrKeyId — Common ENR field key strings and lengths. kEnrKeyIdBytes kEnrKeyIp kEnrKeyIpBytes kEnrKeySecp256k1 kEnrKeySecp256k1Bytes kEnrKeyTcp kEnrKeyTcpBytes kEnrKeyUdp kEnrKeyUdpBytes kBase64UpperCount — Number of upper-case letters (A–Z) in the base64url alphabet. kBase64LowerCount — Number of lower-case letters (a–z) in the base64url alphabet. kBase64DigitCount — Number of decimal digits (0–9) in the base64url alphabet. kBase64LowerStart — Start index of the lower-case letter block (after A–Z). kBase64DigitStart — Start index of the digit block (after A–Z and a–z). kBase64DashIndex — Table index for the '-' character in base64url. kBase64UnderIndex — Table index for the '_' character in base64url. kBase64Invalid — Sentinel value meaning "not a valid base64url character". kBase64BitsPerChar — Number of bits encoded by one base64 character. kBase64BitsPerByte — Number of bits in one output byte. kDefaultMaxConcurrent — Default maximum concurrent outbound FINDNODE queries. kDefaultQueryIntervalSec — Default interval between crawler sweep rounds (seconds). kDefaultPeerExpirySec — Seconds before an unseen peer is evicted from the peer table. kMaxBootnodeEnrs — Maximum bootstrap ENR entries accepted per chain source. kUncompressedKeyBytes — Total byte count of an uncompressed public key including the 0x04 prefix. kStaticHeaderBytes — Byte count of the static header (derived from wire struct, NOT a magic literal). kStaticHeaderVersionOffset kStaticHeaderFlagOffset kStaticHeaderNonceOffset kStaticHeaderAuthSizeOffset kWhoareyouAuthDataBytes — Byte count of WHOAREYOU auth data. kHandshakeAuthSizeFieldBytes — HANDSHAKE auth-data layout prefixes. kHandshakeAuthSizeFieldCount kHandshakeAuthSigSizeOffset kHandshakeAuthPubkeySizeOffset kHandshakeAuthFixedBytes kStaticPacketBytes — Total fixed bytes at the front of every discv5 packet: masking IV + static header. kFlagMessage — Flag value for an ordinary encrypted message packet. kFlagWhoareyou — Flag value for a WHOAREYOU session-challenge packet. kFlagHandshake — Flag value for a HANDSHAKE message. kMsgPing — PING message type byte. kMsgPong — PONG message type byte. kMsgFindNode — FINDNODE message type byte. kMsgNodes — NODES message type byte. kMsgTalkReq — TALKREQ message type byte. kMsgTalkResp — TALKRESP message type byte. kProtocolVersion — discv5 protocol version (current). --- source: /SuperGenius/Files/d4/dde/discv5__error_8hpp/ title: discv5_error.hpp (file) --- Members: discv5Error — Enumeration of all error conditions that can be returned by the discv5 module. Result — Result type for discv5 operations that return a value. VoidResult — Result type for discv5 operations that return nothing on success. to_string — Convert a discv5Error code to a human-readable C string. --- source: /SuperGenius/Files/d3/d65/discv5__types_8hpp/ title: discv5_types.hpp (file) --- Members: PeerDiscoveredCallback — Invoked when a new valid peer has been discovered and passed all configured filters (chain filter, address validation, dedup). ErrorCallback — Invoked when a non-fatal error occurs inside the crawler (e.g. a malformed ENR from a remote node). --- source: /SuperGenius/Files/d9/d91/enr__tree_8hpp/ title: enr_tree.hpp (file) --- Members: DnsTxtLookupFn — DNS TXT lookup callback used by the ENR-tree resolver. --- source: /SuperGenius/Files/d2/d58/abi__decoder_8hpp/ title: abi_decoder.hpp (file) --- Members: AbiParamKind — Identifies one parameter in an event/function signature. AbiValue — A decoded ABI value. Only the types needed for common ERC-20/ERC-721 events are included: address, uint256, bytes32, bool, bytes, string. keccak256 — Compute Keccak-256 of an arbitrary byte sequence. keccak256 — Compute Keccak-256 of a string (e.g. an event signature). event_signature_hash — Compute the event topic[0] hash from a human-readable signature. decode_abi_word — Decode a single 32-byte ABI word from a topic or head slot. decode_indexed_param — Decode an indexed event parameter from a topic hash. decode_log_data — Decode the ABI-encoded data field of a log entry. decode_log — Fully decode a log entry given its event descriptor. --- source: /SuperGenius/Files/dd/dcc/bridge__event_8hpp/ title: bridge_event.hpp (file) --- Members: ReceiptLogVerificationError operator== operator< bridge_event_key compute_bridge_message_id — Canonical message identifier for an EVM bridge source event. bridge_message_id — Convenience overload that extracts canonical fields from a claim. verify_receipt_log --- source: /SuperGenius/Files/d4/dc0/bridge__observation_8hpp/ title: bridge_observation.hpp (file) --- Members: bridge_event_claim_payload — Canonical bytes for bridge-event consensus payloads and watcher signatures. decode_bridge_event_claim_payload bridge_event_domain_separator bridge_event_claim_hash observer_address_from_private_key sign_bridge_event_claim verify_bridge_event_observation --- source: /SuperGenius/Files/d4/dff/chainlist__provider_8hpp/ title: chainlist_provider.hpp (file) --- Members: load_chainlist_from_json_text — Parse chainid.network chains.json into normalized RPC endpoint configs. filter_to_configured_chains — Filter endpoint configs to only those matching configured chain IDs. --- source: /SuperGenius/Files/dc/d57/eth__constants_8hpp/ title: eth_constants.hpp (file) --- Members: kAbiWordSize — EVM ABI encoding constants (ABI spec: https://docs.soliditylang.org/en/latest/abi-spec.html) kAbiAddressSize — Ethereum address is 20 bytes. kAbiAddressPadding — 12 bytes of left-padding kAbiBoolByteIndex — Canonical bool lives in rightmost byte (index 31) kRlpListPrefixMin — EVM / RLP encoding thresholds. kTypedTxPrefixSize — EIP-2718 typed transaction envelope. kDefaultChainId — Default chain ID used when none is specified (Ethereum mainnet) kKeccak256Size — Keccak-256 digest size (bytes) --- source: /SuperGenius/Files/d2/daa/eth__handshake_8hpp/ title: eth_handshake.hpp (file) --- Members: PerformEthStatusHandshake — Execute the ETH Status startup handshake for a negotiated ETH session. --- source: /SuperGenius/Files/d9/d07/eth__handshake__guard_8hpp/ title: eth_handshake_guard.hpp (file) --- Members: HandshakeMessageDisposition — Result of processing one inbound ETH handshake-phase message. HandleEthHandshakeMessage — Process one inbound ETH handshake-phase message. NormalizeEthWireMessageId — Return the ETH-local message id for a wire-level message. ExtractLatestBlockNumber — Return the latest block number from a validated ETH Status message. DecodeValidatedStatusMessage — Decode and validate an inbound ETH Status message. --- source: /SuperGenius/Files/d5/d79/eth__peer__queue_8hpp/ title: eth_peer_queue.hpp (file) --- Members: make_eth_peer_queue — Create an eth-watch peer queue and preload the chain cache split. --- source: /SuperGenius/Files/da/dbe/eth__peer__session_8hpp/ title: eth_peer_session.hpp (file) --- Members: EthStatusAcceptedHandler — Callback invoked when the remote ETH Status message is accepted. EthStatusRemoteDisconnectHandler — Callback invoked when the remote sends an RLPx Disconnect during ETH Status. BuildLocalStatusMessage — Build the local ETH Status message for the negotiated ETH protocol version. ValidateRemoteStatusMessage — Validate a remote ETH Status message against negotiated version and chain. StartEthStatusHandshake — Install post-handshake ETH inbound handling on a negotiated session. --- source: /SuperGenius/Files/dd/d48/eth__receipt__source_8hpp/ title: eth_receipt_source.hpp (file) --- Members: ReceiptBatchHandler checked_receipt_log_ordinal — Narrow a receipt-local log ordinal without truncation. make_event_filter --- source: /SuperGenius/Files/de/d8d/eth__types_8hpp/ title: eth_types.hpp (file) --- Members: EthMessageFieldType StatusValidationError — Errors returned by validate_status(), mirroring go-ethereum's readStatus error values from eth/protocols/eth/handshake.go. Hash256 Address Bloom StatusMessage — Dual-version Status message (ETH/68 or ETH/69). kEthProtocolVersion66 kEthProtocolVersion67 kEthProtocolVersion68 kEthProtocolVersion69 get_common_fields — Extract fields common to both ETH/68 and ETH/69 Status messages. --- source: /SuperGenius/Files/d8/d9d/eth__watch__cli_8hpp/ title: eth_watch_cli.hpp (file) --- Members: parse_address — Parse a 0x-prefixed or bare 40-hex-char Ethereum address. event_registry — Process-wide singleton registry, pre-populated with well-known events. infer_params — Convenience wrapper: look up sig in the global registry. Replaces the old infer_params() free function. build_service_watch_specs — Convert CLI watch flags into service-level watch specs. build_service_config — Build the production service config used by cache-backed CLI modes. --- source: /SuperGenius/Files/d7/d88/eth__watch__dialer_8hpp/ title: eth_watch_dialer.hpp (file) --- Members: make_eth_watcher_pool — Create the shared watcher connection pool used by chain peer dialers. start_eth_watch_chain_peer_dialing — Create a per-chain dial scheduler and enqueue the provided peer candidates. --- source: /SuperGenius/Files/d9/ddf/eth__watch__service_8hpp/ title: eth_watch_service.hpp (file) --- Members: EthWatchDiscoveryMode — Peer source strategy for production eth-watch startup. EventWatchId — Subscription handle returned by EthWatchService::watch_event(). WatchEventNotificationCallback — Callback invoked for each decoded filtered event with chain/session metadata. DecodedEventCallback — Typed callback for a decoded event log. SendCallback — Callback used by EthWatchService to send an outgoing eth message. --- source: /SuperGenius/Files/d9/d92/event__filter_8hpp/ title: event_filter.hpp (file) --- Members: WatchId — Registration handle returned by EventWatcher::watch(). Passed back to EventWatcher::unwatch() to remove a subscription. EventCallback — Callback invoked for every log that matches a registered filter. --- source: /SuperGenius/Files/d1/dfe/finality__policy_8hpp/ title: finality_policy.hpp (file) --- Members: FinalityHeadKind finality_policy_for_chain_id choose_finality_head is_final_under_policy --- source: /SuperGenius/Files/de/d8e/json__rpc_8hpp/ title: json_rpc.hpp (file) --- Members: RpcBlockTag block_tag_name make_json_rpc_request make_get_block_by_number_request make_get_logs_request make_get_transaction_receipt_request make_eth_chain_id_request parse_chain_id_response parse_block_number_response parse_get_logs_response parse_transaction_receipt_response --- source: /SuperGenius/Files/d8/dde/eth_2messages_8hpp/ title: eth/messages.hpp (file) --- Members: ByteBuffer EncodeResult DecodeResult ValidationResult — Result type for Status validation (void on success, error on mismatch). Uses boost::outcome with StatusValidationError — mirrors go-ethereum's readStatus() return values from eth/protocols/eth/handshake.go. kStatusMessageId kStatusHandshakeTimeout — Maximum time to wait for a peer's ETH Status after sending ours. Matches go-ethereum's handshakeTimeout (eth/protocols/eth/handshake.go). If the peer does not reply within this window it is dropped as malicious or mismatched (e.g. a Polygon bor node on the Ethereum P2P network). kNewBlockHashesMessageId kTransactionsMessageId kGetBlockHeadersMessageId kBlockHeadersMessageId kGetBlockBodiesMessageId kBlockBodiesMessageId kNewBlockMessageId kNewPooledTransactionHashesMessageId kGetPooledTransactionsMessageId kPooledTransactionsMessageId kUpgradeStatusMessageId kGetReceiptsMessageId kReceiptsMessageId kBlockRangeUpdateMessageId validate_status — Validate a decoded StatusMessage against our expected chain parameters. encode_status decode_status decode_status encode_new_block_hashes decode_new_block_hashes encode_new_pooled_tx_hashes decode_new_pooled_tx_hashes encode_block_range_update decode_block_range_update encode_upgrade_status decode_upgrade_status encode_get_block_headers decode_get_block_headers encode_block_headers decode_block_headers encode_get_block_bodies decode_get_block_bodies encode_block_bodies decode_block_bodies decode_block_bodies encode_new_block decode_new_block decode_new_block encode_get_receipts decode_get_receipts decode_get_receipts encode_receipts decode_receipts decode_receipts encode_get_pooled_transactions decode_get_pooled_transactions encode_pooled_transactions decode_pooled_transactions --- source: /SuperGenius/Files/d9/da0/objects_8hpp/ title: objects.hpp (file) --- Members: TransactionType — Ethereum transaction types per EIP-2718. Hash256 Address Bloom ByteBuffer EncodeResult DecodeResult encode_log_entry decode_log_entry encode_access_list_entry decode_access_list_entry encode_transaction — Encode a transaction. Typed transactions (EIP-2930, EIP-1559) are prefixed with their type byte before the RLP payload, per EIP-2718. decode_transaction encode_receipt decode_receipt encode_block_header decode_block_header --- source: /SuperGenius/Files/df/dbc/rpc__config__audit_8hpp/ title: rpc_config_audit.hpp (file) --- Members: AuditSeverity audit_rpc_config to_string --- source: /SuperGenius/Files/de/da2/rpc__manager_8hpp/ title: rpc_manager.hpp (file) --- Members: RpcEndpointState RpcEndpointErrorCode RpcResult RpcEnvLookup to_string to_string render_rpc_endpoint_url — Resolve a URL template into a concrete endpoint URL. build_rpc_endpoint — Materialize a runtime endpoint from configuration. group_rpc_endpoints — Group endpoints by chain name and chain id with deterministic ordering. make_receipt_source --- source: /SuperGenius/Files/d3/d1c/rpc__manager__config_8hpp/ title: rpc_manager_config.hpp (file) --- Members: load_rpc_manager_config_result_from_json_text — Load RPC manager configuration from JSON text. load_rpc_manager_config_result_from_json — Load RPC manager configuration from a JSON file. load_rpc_manager_config_from_json_text — Load RPC manager configuration from JSON text. load_rpc_manager_config_from_json — Load RPC manager configuration from a JSON file. --- source: /SuperGenius/Files/d1/d3d/rpc__probe_8hpp/ title: rpc_probe.hpp (file) --- Members: ProbeStatus to_string probe_endpoint_chain_id probe_endpoint_pool --- source: /SuperGenius/Files/dd/df0/secp256k1__utility_8hpp/ title: secp256k1_utility.hpp (file) --- Members: Secp256k1PrivateKey secp256k1_address_from_private_key secp256k1_recover_address secp256k1_sign_recoverable DecompressXOnlyPubkey — Decompress a 32-byte X-only secp256k1 public key to a 128-char hex destination. --- source: /SuperGenius/Files/dd/d3a/common_8hpp/ title: common.hpp (file) --- Members: hexToString --- source: /SuperGenius/Files/d3/dad/constants_8hpp/ title: constants.hpp (file) --- Members: Leftover kEmptyStringCode kEmptyListCode kMaxShortStringLen kMaxShortListLen kShortStringOffset kLongStringOffset kShortListOffset kLongListOffset kRlpSingleByteThreshold kLongPrefixByteSize — Size of the single prefix byte prepended before the big-endian length field in long strings/lists. kSingleByteStringSize — Minimum encoded size of a single-byte RLP string (prefix byte + payload byte). --- source: /SuperGenius/Files/df/d89/endian_8hpp/ title: endian.hpp (file) --- Members: to_big_compact from_big_compact to_big_compact from_big_compact --- source: /SuperGenius/Files/df/d52/errors_8hpp/ title: errors.hpp (file) --- Members: EncodingError DecodingError StreamingError encoding_error_to_string decoding_error_to_string streaming_error_to_string --- source: /SuperGenius/Files/df/df9/intx_8hpp/ title: intx.hpp (file) --- Members: add_with_carry add_with_carry operator+ operator+ sub_with_carry sub_with_carry operator- operator- operator++ operator-- operator++ operator-- fast_add operator== operator!= operator< operator<= operator> operator>= operator~ operator| operator& operator^ operator<< operator<< operator>> operator>> umul — Full unsigned multiplication 64 x 64 -> 128. operator* operator+= operator-= operator*= operator|= operator&= operator^= operator<<= operator>>= reciprocal_2by1 reciprocal_3by2 udivrem_2by1 udivrem_3by2 udivrem sdivrem operator/ operator% operator/= operator%= __has_builtin __has_feature INTX_UNREACHABLE INTX_UNLIKELY INTX_REQUIRE INTX_HAS_BUILTIN_INT128 REPEAT4 REPEAT32 REPEAT256 uint128 uint192 uint256 uint320 uint384 uint512 reciprocal_table — Reciprocal lookup table. is_constant_evaluated clz_generic clz_generic clz clz clz bswap bswap bswap bswap bswap bswap reciprocal_table_item throw_ from_dec_digit from_hex_digit from_string from_string operator""_u128 to_string hex operator== operator== operator== operator!= operator!= operator!= operator< operator< operator< operator< operator> operator> operator> operator>= operator>= operator>= operator<= operator<= operator<= slt operator| operator& operator^ operator~ operator<< operator<< operator>> operator>> operator<< operator>> operator<< operator>> operator>>= as_words as_words as_words as_words as_bytes as_bytes operator+ operator- operator- operator+= operator-= umul operator* operator*= exp count_significant_words count_significant_bytes count_significant_bytes clz clz_nonzero — Counts the number of zero leading bits in nonzero argument x. normalize udivrem_by1 udivrem_by2 add — s = x + y. submul — r = x - multiplier * y. udivrem_knuth udivrem sdivrem operator/ operator% operator/= operator%= bswap operator+ operator+ operator- operator- operator* operator* operator/ operator/ operator% operator% operator| operator| operator& operator& operator^ operator^ operator|= operator&= operator^= operator<<= operator>>= addmod mulmod operator""_u256 operator""_u512 load store load load store — Stores an uint value in a bytes array in big-endian order. store trunc trunc — Stores the truncated value of an uint in the .bytes field of an object of type T. load store --- source: /SuperGenius/Files/de/d80/result_8hpp/ title: result.hpp (file) --- Members: EncodingResult EncodingOperationResult Result DecodingResult StreamingResult StreamingOperationResult --- source: /SuperGenius/Files/d9/de7/rlp__ethereum_8hpp/ title: rlp_ethereum.hpp (file) --- Members: Address Hash256 Signature Bloom addAddress addHash addSignature addBloom readAddress readHash readSignature readBloom --- source: /SuperGenius/Files/d1/d25/rlp__streaming_8hpp/ title: rlp_streaming.hpp (file) --- Members: encodeLargeString encodeChunkedList decodeLargeString decodeChunkedList decodeChunkedListFull --- source: /SuperGenius/Files/df/d73/traits_8hpp/ title: traits.hpp (file) --- Members: is_unsigned_integral_v is_rlp_encodable_v is_rlp_decodable_v --- source: /SuperGenius/Files/dd/de3/types_8hpp/ title: types.hpp (file) --- Members: Bytes ByteView --- source: /SuperGenius/Files/d4/da4/auth__handshake_8hpp/ title: auth_handshake.hpp (file) --- Members: kAuthSize kAckSize — ack plaintext = eph_pubkey(64) + nonce(32) + ver(1) = 97 derive_frame_secrets — Derive RLPx frame secrets from authenticated handshake key material. --- source: /SuperGenius/Files/da/db6/rlpx__error_8hpp/ title: rlpx_error.hpp (file) --- Members: SessionError AuthError FramingError CryptoError Result AuthResult FramingResult CryptoResult VoidResult AuthVoidResult FramingVoidResult CryptoVoidResult to_string to_string to_string to_string --- source: /SuperGenius/Files/d6/da6/rlpx__session_8hpp/ title: rlpx_session.hpp (file) --- Members: ConnectProgressPhase MessageHandler HelloHandler DisconnectHandler PingHandler PongHandler EthMessageHandler ConnectProgressHandler --- source: /SuperGenius/Files/da/d9c/rlpx__types_8hpp/ title: rlpx_types.hpp (file) --- Members: SessionState DisconnectReason PublicKey PrivateKey Nonce SharedSecret AesKey MacKey MacDigest FrameHeader ByteBuffer ByteView MutableByteView kPublicKeySize kPrivateKeySize kNonceSize kSharedSecretSize kAesKeySize kMacKeySize kUncompressedPubKeyPrefixSize — Uncompressed secp256k1 public key: 0x04 prefix byte + 64 bytes = 65 bytes total. kUncompressedPubKeySize kUncompressedPubKeyPrefix kHmacSha256Size — HMAC-SHA256 full digest output size. kAesBlockSize kMacSize kFrameHeaderSize kEciesMacSize — ECIES / EIP-8 wire constants. kEciesOverheadSize kEip8LengthPrefixSize kEip8AuthPaddingSize kMaxEip8HandshakePacketSize kFrameLengthSize — Number of bytes used to encode the frame length inside the frame header. kFrameHeaderDataOffset kFrameHeaderWithMacSize kFramePaddingAlignment kFrameLengthMsbOffset kFrameLengthMiddleOffset kFrameLengthLsbOffset kFrameLengthMsbShift kFrameLengthMiddleShift kFrameLengthLsbShift kFrameHeaderStaticRlpBytes kEcdsaCompactSigSize kEcdsaRecoveryIdSize kEcdsaSigSize kAuthVersionSize — Version byte appended to auth/ack messages (RLPx v4 EIP-8). kAuthVersion kMaxFrameSizeMiB — Maximum RLPx frame payload: 16 MiB. kMaxFrameSize kHelloMessageId kDisconnectMessageId kPingMessageId kPongMessageId kProtocolVersion kTcpConnectionTimeout kProtocolHandshakeTimeout kSendLoopPollInterval to_rlp_view from_rlp_view to_rlp_bytes from_rlp_bytes --- source: /SuperGenius/Files/d7/dcc/socket__transport_8hpp/ title: socket_transport.hpp (file) --- Members: connect_with_timeout — Connect to remote endpoint with timeout. --- source: /SuperGenius/Files/d3/d72/json__utility_8cpp/ title: json_utility.cpp (file) --- Members: to_string parse_object get_value get_string parse_string parse_string get_optional_string get_bool parse_bool parse_bool get_array get_u8 get_u32 get_u64 parse_size_t parse_u8 parse_u8 parse_u32 parse_u32 parse_u64 parse_u64 parse_schema_object parse_schema_object parse_schema_value get_parsed_value get_parsed_string get_parsed_bool get_parsed_u8 get_parsed_u32 get_parsed_u64 get_parsed_size get_parsed_array get_parsed_object --- source: /SuperGenius/Files/da/d8d/parse__utility_8cpp/ title: parse_utility.cpp (file) --- Members: hex_nibble trim_hex_prefix uint16_decimal uint64_decimal uint64_hex uint64_hex_quantity hex_bytes hex_bytes ascii_lower --- source: /SuperGenius/Files/da/dc1/rlp-logger_8cpp/ title: rlp-logger.cpp (file) --- Members: createLogger — Create a logger instance. --- source: /SuperGenius/Files/d1/df8/bootstrap__peers_8cpp/ title: bootstrap_peers.cpp (file) --- Members: bootstrap_cache_json_path find_bootstrap_peers_json_path download_bootstrap_json write_bootstrap_cache_json_if_changed refresh_bootstrap_cache_json load_bootstrap_peers_from_json_text load_bootstrap_peers_from_json load_bootstrap_fork_id_hash_from_json_text load_bootstrap_fork_id_hash_from_json load_bootstrap_chain_config_from_json_text load_bootstrap_chain_config_from_json verify_bootstrap_json_signature --- source: /SuperGenius/Files/d4/d52/chain__peers_8cpp/ title: chain_peers.cpp (file) --- Members: make_validated_peer_from_enode — Parse an enode:// peer URI into a validated peer entry. make_validated_peer_from_enr — Parse an enr: peer URI into a validated peer entry. chain_peer_cache_json_path — Return the default local cache path for chain_enodes.json next to the executable. find_chain_peer_cache_json_path — Locate a local chain peer cache JSON file. download_chain_peer_cache_json — Download the chain peer cache JSON payload from a remote URL. Supports either raw JSON or gzip-compressed JSON bodies. write_chain_peer_cache_json_if_changed — Write the chain peer JSON cache only when the contents changed. refresh_chain_peer_cache_json — Refresh a local chain peer cache from a remote URL. load_chain_peers_from_json_text — Load cached peers for a specific chain from JSON text. load_chain_peers_from_json — Load cached peers for a specific chain from a JSON or gzip-compressed JSON file. load_chain_fork_id_hash_from_json_text — Load the first available peer fork hash for a specific chain from JSON text. load_chain_fork_id_hash_from_json — Load the first available peer fork hash for a specific chain from a JSON or gzip-compressed JSON file. load_chain_peer_config_from_json_text — Load the parsed chain configuration from JSON text. load_chain_peer_config_from_json — Load the parsed chain configuration from a JSON or gzip-compressed JSON file. verify_chain_peer_cache_json_signature — Verify the top-level chain_enodes.json signature. --- source: /SuperGenius/Files/db/dd3/discv4__client_8cpp/ title: discv4_client.cpp (file) --- Members: kHashSize kSigSize kPacketTypeSize kPacketHeaderSize kPacketTypeOffset kUncompressedPubKey --- source: /SuperGenius/Files/d6/d4d/discv4__enr__response_8cpp/ title: discv4_enr_response.cpp (file) --- Members: kEthKey --- source: /SuperGenius/Files/d1/dbe/discv4__error_8cpp/ title: discv4_error.cpp (file) --- Members: to_string — Convert error code to human-readable string. --- source: /SuperGenius/Files/dc/dbf/discv5__enr_8cpp/ title: discv5_enr.cpp (file) --- Members: kBase64UrlTable — Static decode table for the base64url alphabet (RFC-4648 §5). Index = ASCII code, value = 6-bit group (or kBase64Invalid). Built from the named constants in discv5_constants.hpp so that no bare literals appear in the initialiser. --- source: /SuperGenius/Files/dd/d76/discv5__error_8cpp/ title: discv5_error.cpp (file) --- Members: to_string — Convert a discv5Error code to a human-readable C string. --- source: /SuperGenius/Files/d1/d2e/abi__decoder_8cpp/ title: abi_decoder.cpp (file) --- Members: keccak256 — Compute Keccak-256 of an arbitrary byte sequence. keccak256 — Compute Keccak-256 of a string (e.g. an event signature). event_signature_hash — Compute the event topic[0] hash from a human-readable signature. decode_abi_word — Decode a single 32-byte ABI word from a topic or head slot. decode_indexed_param — Decode an indexed event parameter from a topic hash. decode_log_data — Decode the ABI-encoded data field of a log entry. decode_log — Fully decode a log entry given its event descriptor. --- source: /SuperGenius/Files/da/d4c/bridge__event_8cpp/ title: bridge_event.cpp (file) --- Members: operator== operator< bridge_event_key verify_receipt_log compute_bridge_message_id — Canonical message identifier for an EVM bridge source event. --- source: /SuperGenius/Files/de/d9d/bridge__observation_8cpp/ title: bridge_observation.cpp (file) --- Members: bridge_event_claim_payload — Canonical bytes for bridge-event consensus payloads and watcher signatures. decode_bridge_event_claim_payload bridge_event_domain_separator bridge_event_claim_hash observer_address_from_private_key sign_bridge_event_claim verify_bridge_event_observation --- source: /SuperGenius/Files/d5/dbe/chainlist__provider_8cpp/ title: chainlist_provider.cpp (file) --- Members: load_chainlist_from_json_text — Parse chainid.network chains.json into normalized RPC endpoint configs. filter_to_configured_chains — Filter endpoint configs to only those matching configured chain IDs. --- source: /SuperGenius/Files/dc/d87/eth__handshake_8cpp/ title: eth_handshake.cpp (file) --- Members: PerformEthStatusHandshake — Execute the ETH Status startup handshake for a negotiated ETH session. --- source: /SuperGenius/Files/d7/d79/eth__handshake__guard_8cpp/ title: eth_handshake_guard.cpp (file) --- Members: NormalizeEthWireMessageId — Return the ETH-local message id for a wire-level message. ExtractLatestBlockNumber — Return the latest block number from a validated ETH Status message. DecodeValidatedStatusMessage — Decode and validate an inbound ETH Status message. HandleEthHandshakeMessage — Process one inbound ETH handshake-phase message. --- source: /SuperGenius/Files/da/dad/eth__peer__queue_8cpp/ title: eth_peer_queue.cpp (file) --- Members: make_eth_peer_queue — Create an eth-watch peer queue and preload the chain cache split. --- source: /SuperGenius/Files/d7/d2b/eth__peer__session_8cpp/ title: eth_peer_session.cpp (file) --- Members: BuildLocalStatusMessage — Build the local ETH Status message for the negotiated ETH protocol version. ValidateRemoteStatusMessage — Validate a remote ETH Status message against negotiated version and chain. PerformEthStatusHandshake — Execute the ETH Status startup handshake for a negotiated ETH session. StartEthStatusHandshake — Install post-handshake ETH inbound handling on a negotiated session. --- source: /SuperGenius/Files/da/d64/eth__receipt__source_8cpp/ title: eth_receipt_source.cpp (file) --- Members: checked_receipt_log_ordinal — Narrow a receipt-local log ordinal without truncation. make_event_filter --- source: /SuperGenius/Files/d5/d7e/eth__watch__service_8cpp/ title: eth_watch_service.cpp (file) --- Members: make_eth_watcher_pool — Create the shared watcher connection pool used by chain peer dialers. start_eth_watch_chain_peer_dialing — Create a per-chain dial scheduler and enqueue the provided peer candidates. --- source: /SuperGenius/Files/df/dc5/finality__policy_8cpp/ title: finality_policy.cpp (file) --- Members: finality_policy_for_chain_id choose_finality_head is_final_under_policy --- source: /SuperGenius/Files/d3/dd1/json__rpc_8cpp/ title: json_rpc.cpp (file) --- Members: block_tag_name make_json_rpc_request make_eth_chain_id_request parse_chain_id_response make_get_block_by_number_request make_get_logs_request make_get_transaction_receipt_request parse_block_number_response parse_get_logs_response parse_transaction_receipt_response --- source: /SuperGenius/Files/da/d6d/eth_2messages_8cpp/ title: eth/messages.cpp (file) --- Members: get_common_fields — Extract fields common to both ETH/68 and ETH/69 Status messages. encode_status decode_status decode_status validate_status — Validate a decoded StatusMessage against our expected chain parameters. encode_new_block_hashes decode_new_block_hashes encode_new_pooled_tx_hashes decode_new_pooled_tx_hashes encode_block_range_update decode_block_range_update encode_upgrade_status decode_upgrade_status encode_get_block_headers decode_get_block_headers encode_block_headers decode_block_headers encode_get_receipts decode_get_receipts decode_get_receipts encode_receipts decode_receipts decode_receipts encode_get_pooled_transactions decode_get_pooled_transactions encode_pooled_transactions decode_pooled_transactions encode_get_block_bodies decode_get_block_bodies encode_block_bodies decode_block_bodies decode_block_bodies encode_new_block decode_new_block decode_new_block --- source: /SuperGenius/Files/d1/d46/rlpx_2protocol_2messages_8cpp/ title: rlpx/protocol/messages.cpp (file) --- Members: reason_to_byte byte_to_reason --- source: /SuperGenius/Files/d5/dbd/objects_8cpp/ title: objects.cpp (file) --- Members: encode_log_entry decode_log_entry encode_access_list_entry decode_access_list_entry encode_transaction — Encode a transaction. Typed transactions (EIP-2930, EIP-1559) are prefixed with their type byte before the RLP payload, per EIP-2718. decode_transaction encode_receipt decode_receipt encode_block_header decode_block_header --- source: /SuperGenius/Files/d6/ddb/rpc__config__audit_8cpp/ title: rpc_config_audit.cpp (file) --- Members: audit_rpc_config --- source: /SuperGenius/Files/dc/d20/rpc__manager_8cpp/ title: rpc_manager.cpp (file) --- Members: to_string to_string render_rpc_endpoint_url — Resolve a URL template into a concrete endpoint URL. build_rpc_endpoint — Materialize a runtime endpoint from configuration. group_rpc_endpoints — Group endpoints by chain name and chain id with deterministic ordering. make_receipt_source --- source: /SuperGenius/Files/db/d95/rpc__manager__config_8cpp/ title: rpc_manager_config.cpp (file) --- Members: load_rpc_manager_config_result_from_json_text — Load RPC manager configuration from JSON text. load_rpc_manager_config_result_from_json — Load RPC manager configuration from a JSON file. load_rpc_manager_config_from_json_text — Load RPC manager configuration from JSON text. load_rpc_manager_config_from_json — Load RPC manager configuration from a JSON file. --- source: /SuperGenius/Files/d5/d69/rpc__probe_8cpp/ title: rpc_probe.cpp (file) --- Members: to_string probe_endpoint_chain_id probe_endpoint_pool --- source: /SuperGenius/Files/db/d7d/secp256k1__utility_8cpp/ title: secp256k1_utility.cpp (file) --- Members: secp256k1_address_from_private_key secp256k1_recover_address secp256k1_sign_recoverable DecompressXOnlyPubkey — Decompress a 32-byte X-only secp256k1 public key to a 128-char hex destination. --- source: /SuperGenius/Files/d9/df9/common_8cpp/ title: common.cpp (file) --- Members: encoding_error_to_string decoding_error_to_string streaming_error_to_string hexToString --- source: /SuperGenius/Files/d7/d87/endian_8cpp/ title: endian.cpp (file) --- Members: to_big_compact from_big_compact to_big_compact from_big_compact to_big_compact< uint8_t > to_big_compact< uint16_t > to_big_compact< uint32_t > to_big_compact< uint64_t > from_big_compact< uint8_t > from_big_compact< uint16_t > from_big_compact< uint32_t > from_big_compact< uint64_t > --- source: /SuperGenius/Files/db/d57/auth__handshake_8cpp/ title: auth_handshake.cpp (file) --- Members: derive_frame_secrets — Derive RLPx frame secrets from authenticated handshake key material. --- source: /SuperGenius/Files/d3/d0f/rlpx__error_8cpp/ title: rlpx_error.cpp (file) --- Members: to_string to_string to_string to_string --- source: /SuperGenius/Files/df/d13/rlpx__session_8cpp/ title: rlpx_session.cpp (file) --- Members: tcp --- source: /SuperGenius/Files/d1/d09/socket__transport_8cpp/ title: socket_transport.cpp (file) --- Members: tcp connect_with_timeout --- source: /SuperGenius/Files/d4/d13/globaldb__app_8cpp/ title: globaldb_app.cpp (file) --- Members: Buffer HierarchicalKey SubscriptionData PutHook DeleteHook main --- source: /SuperGenius/Files/de/d25/echo__client_8cpp/ title: echo_client.cpp (file) --- Members: main --- source: /SuperGenius/Files/d2/db7/evm__messaging__dapp_8cpp/ title: evm_messaging_dapp.cpp (file) --- Members: configArray topicFilters contractAddresses configs return keepRunning signalHandler customMessageHandler main Parse if if for --- source: /SuperGenius/Files/dd/de5/ipfs_8cpp/ title: ipfs.cpp (file) --- Members: main findprovhandler --- source: /SuperGenius/Files/df/d21/testipfs_8cpp/ title: testipfs.cpp (file) --- Members: self_id sessions handleIncomingStream handleOutgoingStream main --- source: /SuperGenius/Files/d0/db1/ipfs__pubsub_8cpp/ title: ipfs_pubsub.cpp (file) --- Members: GossipPubSub logger_config main --- source: /SuperGenius/Files/d6/d1c/multi_pose_8cpp/ title: multiPose.cpp (file) --- Members: STB_IMAGE_IMPLEMENTATION STB_IMAGE_WRITE_IMPLEMENTATION MNN_OPEN_TIME_TRACE MODEL_IMAGE_SIZE OUTPUT_STRIDE MAX_POSE_DETECTIONS NUM_KEYPOINTS SCORE_THRESHOLD MIN_POSE_SCORE NMS_RADIUS LOCAL_MAXIMUM_RADIUS OFFSET_NODE_NAME DISPLACE_FWD_NODE_NAME DISPLACE_BWD_NODE_NAME HEATMAPS CIRCLE_RADIUS MNNProcess loadFileToByteArray main --- source: /SuperGenius/Files/d1/d7d/_pose_names_8hpp/ title: PoseNames.hpp (file) --- Members: PoseNames PoseChain --- source: /SuperGenius/Files/dd/d95/_node_example_8cpp/ title: NodeExample.cpp (file) --- 2024-04-18 Henrique A. Klein (hklein@gnus.ai) Members: CmdFunc logger keyboard_mutex cv events current_input original_term POSENET_JSON COMMANDS DEV_CONFIG finished enable_raw_mode disable_raw_mode clear_line redraw_prompt trim to_lower keyboard_input_thread check_arg_count check_arg_count_min cmd_info cmd_balance cmd_ds cmd_mint cmd_transfer cmd_price cmd_process cmd_peer cmd_stopprocessing cmd_quit cmd_help split_string process_events status_polling_thread periodic_processing generate_eth_private_key main --- source: /SuperGenius/Files/d1/d5f/processing__json_8cpp/ title: processing_json.cpp (file) --- Members: STB_IMAGE_IMPLEMENTATION replaceExtensionWithData processImage main --- source: /SuperGenius/Files/db/d26/processing__app_8cpp/ title: processing_app.cpp (file) --- Members: main --- source: /SuperGenius/Files/d3/d4f/_k_d_f_generator_8cpp/ title: KDFGenerator.cpp (file) --- 2024-06-07 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/db/d6c/_a_e_s_encryption_8hpp/ title: AESEncryption.hpp (file) --- AES256 Encryption class file. 2024-01-05 Henrique A. Klein (henryaklein@gmail.com) --- source: /SuperGenius/Files/dd/dd3/_bitcoin_key_generator_8hpp/ title: BitcoinKeyGenerator.hpp (file) --- Bitcoin address generator header file. 2023-12-08 Super Genius (ken@gnus.ai) Henrique A. Klein (henryaklein@gmail.com) --- source: /SuperGenius/Files/da/d4f/_bitcoin_key_pair_params_8hpp/ title: BitcoinKeyPairParams.hpp (file) --- Bitcoin types header file. 2023-12-06 Super Genius (ken@gnus.ai) Henrique A. Klein (henryaklein@gmail.com) Members: CurveType — Curve type used by Ethereum keys. base_field_type — Ethereum base field type. scalar_field_type — Ethereum scalar field type. scalar_field_value_type — Ethereum value from the scalar field type. random_generator_type — Random generator type, to generate new Ethereum keys/addresses. hash_type — The hash type used by Ethereum address derivation. generator_type — The deterministic generator used by Ethereum key pair. padding_policy — Ethereum passing policy. policy_type — Ethereum policy type. signature_type — Random generator type, to generate new Bitcoin keys/addresses. derivation_hash_type — The hash type used by Ethereum address derivation. --- source: /SuperGenius/Files/d4/d45/_crypto3_util_8hpp/ title: Crypto3Util.hpp (file) --- Crypto3 utilities module. 2024-01-30 Henrique A. Klein (henryaklein@gmail.com) --- source: /SuperGenius/Files/d4/df8/_e_c_d_h_encryption_8hpp/ title: ECDHEncryption.hpp (file) --- Elliptic-curve Diffie-Hellman Encryption header file. 2024-01-05 Henrique A. Klein (henryaklein@gmail.com) --- source: /SuperGenius/Files/d8/ddd/_e_c_d_s_a_public_key_8hpp/ title: ECDSAPublicKey.hpp (file) --- ECDSA public key base class. 2023-12-26 Henrique A. Klein (henryaklein@gmail.com) --- source: /SuperGenius/Files/db/da9/_e_c_d_s_a_types_8hpp/ title: ECDSATypes.hpp (file) --- Common types and definitions of ECDSA. 2024-01-04 Henrique A. Klein (henryaklein@gmail.com) Members: CurveType — ECDSA uses secp256k curve. base_field_type — The base field type is dependant on the curve. scalar_field_type — The scalar field type is dependant on the curve. scalar_field_value_type — The value type fo the scalar field type. random_generator_type — A random algebraic generator. hash_type — The deterministic generator used by Ethereum key pair. generator_type — RFC6979 deterministic generator. padding_policy — Ethereum passing policy. policy_type — Ethereum policy type. signature_type --- source: /SuperGenius/Files/d7/d68/_e_c_el_gamal_key_generator_8hpp/ title: ECElGamalKeyGenerator.hpp (file) --- Header file of EC ElGamal module. 2024-02-01 Henrique A. Klein (henryaklein@gmail.com) --- source: /SuperGenius/Files/d3/dd4/_e_c_el_gamal_types_8hpp/ title: ECElGamalTypes.hpp (file) --- 2024-02-16 Henrique A. Klein (henryaklein@gmail.com) --- source: /SuperGenius/Files/df/d7b/_el_gamal_key_generator_8hpp/ title: ElGamalKeyGenerator.hpp (file) --- Members: cpp_int uint256_t --- source: /SuperGenius/Files/d3/d01/_el_gamal_types_8hpp/ title: ElGamalTypes.hpp (file) --- Header file of El Gamal types. 2024-01-17 Henrique A. Klein (henryaklein@gmail.com) Members: CurveType — ECDSA uses secp256k curve. base_field_type — The base field type is dependant on the curve. scalar_field_type — The scalar field type is dependant on the curve. scalar_field_value_type — The value type fo the scalar field type. random_generator_type — A random algebraic generator. hash_type — The deterministic generator used by Ethereum key pair. generator_type — RFC6979 deterministic generator. padding_policy — Ethereum passing policy. policy_type — Ethereum policy type. signature_type --- source: /SuperGenius/Files/d7/d2d/_encryption_8hpp/ title: Encryption.hpp (file) --- Interface class header for encryption. 2024-01-05 Henrique A. Klein (henryaklein@gmail.com) --- source: /SuperGenius/Files/d9/dd7/_ethereum_key_generator_8hpp/ title: EthereumKeyGenerator.hpp (file) --- Ethereum address generator header file. 2023-12-08 Super Genius (ken@gnus.ai) Henrique A. Klein (henryaklein@gmail.com) --- source: /SuperGenius/Files/dc/d35/_ethereum_key_pair_params_8hpp/ title: EthereumKeyPairParams.hpp (file) --- Ethereum types header file. 2023-12-06 Super Genius (ken@gnus.ai) Henrique A. Klein (henryaklein@gmail.com) Members: CurveType — Curve type used by Ethereum keys. base_field_type — Ethereum base field type. scalar_field_type — Ethereum scalar field type. scalar_field_value_type — Ethereum value from the scalar field type. random_generator_type — Random generator type, to generate new Ethereum keys/addresses. hash_type — The hash type used by Ethereum address derivation. generator_type — The deterministic generator used by Ethereum key pair. padding_policy — Ethereum passing policy. policy_type — Ethereum policy type. signature_type — Ethereum signature type. derivation_hash_type — The hash type used by Ethereum address derivation. --- source: /SuperGenius/Files/df/d62/ext__private__key_8hpp/ title: ext_private_key.hpp (file) --- Extented private key class header file. 2023-12-16 Super Genius (ken@gnus.ai) Henrique A. Klein (henryaklein@gmail.com) --- source: /SuperGenius/Files/dc/dff/_genius_k_d_f_2src_2_k_d_f_generator_2_k_d_f_generator_8hpp/ title: GeniusKDF/src/KDFGenerator/KDFGenerator.hpp (file) --- Key Derivation Function Generator. 2024-01-08 Henrique A. Klein (henryaklein@gmail.com) --- source: /SuperGenius/Files/d1/dec/_proof_system_2include_2_proof_system_2_k_d_f_generator_8hpp/ title: ProofSystem/include/ProofSystem/KDFGenerator.hpp (file) --- Key Derivation Function Generator. 2024-01-08 Henrique A. Klein (henryaklein@gmail.com) --- source: /SuperGenius/Files/d0/d90/_prime_numbers_8hpp/ title: PrimeNumbers.hpp (file) --- Handles prime number generation/checking. 2024-01-26 Henrique A. Klein (henryaklein@gmail.com) Members: _USE_CRYPTO3_ --- source: /SuperGenius/Files/d4/d5d/_m_p_c_verifier_circuit_8hpp/ title: MPCVerifierCircuit.hpp (file) --- Members: MPCValidateTransaction --- source: /SuperGenius/Files/d0/d6b/_transaction_validator_8hpp/ title: TransactionValidator.hpp (file) --- Header file of functions used to validate a transaction. 2025-01-29 Henrique A. Klein (hklein@gnus.ai) Members: MAX_RANGES GeneratePointFromSeedAndTotp — Generates a point from the seed, TOTP and generator. ValidateTransactionValues — Validates the transaction values. --- source: /SuperGenius/Files/de/de1/_transaction_verifier_circuit_t_o_t_p_8hpp/ title: TransactionVerifierCircuitTOTP.hpp (file) --- Header file of the circuit that validate the transaction as well as TOTP. 2025-01-30 Henrique A. Klein (hklein@gnus.ai) Members: ValidateTransactionTOTP — Validates the transaction and TOTP. --- source: /SuperGenius/Files/d9/d71/_m_p_c_verifier_circuit_8cpp/ title: MPCVerifierCircuit.cpp (file) --- Members: MPCValidateTransaction --- source: /SuperGenius/Files/d9/db0/_recursive_transaction_circuit_8cpp/ title: RecursiveTransactionCircuit.cpp (file) --- Automatically generated circuit with the TransactionVerifierCircuit as an input. 2025-01-28 Henrique A. Klein (hklein@gnus.ai) This file was generated using a combo of assigner + recursive_gen tools from zkLLVM Members: placeholder_verifier witness_amount public_input_amount constant_amount selector_amount public_input_sizes full_public_input_size use_lookups batches_num commitments_num points_num poly_num initial_proof_points_num round_proof_points_num fri_roots_num initial_merkle_proofs_num initial_merkle_proofs_position_num initial_merkle_proofs_hash_num round_merkle_proofs_position_num round_merkle_proofs_hash_num final_polynomial_size lambda rows_amount rows_log total_columns sorted_columns permutation_size zero_indices table_values_num gates_amount gates_selector_indices constraints_amount quotient_polys_start quotient_polys_amount lookup_sorted_polys_start D0_size D0_log D0_omega omega fri_rounds gates_sizes unique_points singles_amount batches_amount_list L0_IND Z_AT_XI_IND F_CONSOLIDATED_IND T_CONSOLIDATED_IND transcript transcript_challenge pow_rows_amount pow2 pow3 pow4 pow5 pow6 pow7 pow8 pow9 pow fill_singles generate_challenges xi_polys calculate_constraints gate_argument_verifier calculate_leaf_hash --- source: /SuperGenius/Files/db/ddf/_transaction_validator_8cpp/ title: TransactionValidator.cpp (file) --- 2025-01-29 Henrique A. Klein (hklein@gnus.ai) Members: GeneratePointFromSeedAndTotp — Generates a point from the seed, TOTP and generator. ValidateTransactionValues — Validates the transaction values. --- source: /SuperGenius/Files/de/d5d/_transaction_verifier_circuit_8cpp/ title: TransactionVerifierCircuit.cpp (file) --- Members: ValidateTransaction — Circuit that validates the transaction. --- source: /SuperGenius/Files/dc/d00/_transaction_verifier_circuit_t_o_t_p_8cpp/ title: TransactionVerifierCircuitTOTP.cpp (file) --- Source file of the circuit that validate the transaction as well as TOTP. 2025-01-30 Henrique A. Klein (hklein@gnus.ai) Members: ValidateTransactionTOTP — Validates the transaction and TOTP. --- source: /SuperGenius/Files/d1/d46/_bitcoin_key_generator_8cpp/ title: BitcoinKeyGenerator.cpp (file) --- Bitcoin address generator source file. 2023-12-07 Super Genius (ken@gnus.ai) Henrique A. Klein (henryaklein@gmail.com) Members: BitcoinKeyGenerator::ExtractPubKeyFromField< std::vector< std::uint8_t > > BitcoinKeyGenerator::ExtractPubKeyFromField< BitcoinKeyGenerator::PubKeyPair_t > --- source: /SuperGenius/Files/d6/dff/_el_gamal_key_generator_8cpp/ title: ElGamalKeyGenerator.cpp (file) --- Source file of El Gamal Key Generator module. 2024-01-29 Henrique A. Klein (henryaklein@gmail.com) --- source: /SuperGenius/Files/da/d43/_ethereum_key_generator_8cpp/ title: EthereumKeyGenerator.cpp (file) --- Members: EthereumKeyGenerator::ExtractPubKeyFromField< std::vector< std::uint8_t > > EthereumKeyGenerator::ExtractPubKeyFromField< EthereumKeyGenerator::PubKeyPair_t > --- source: /SuperGenius/Files/d9/dcf/_processing_manager_8hpp/ title: ProcessingManager.hpp (file) --- Members: ProcessingProcessor --- source: /SuperGenius/Files/df/d3c/processing__processor__mnn__audio_8hpp/ title: processing_processor_mnn_audio.hpp (file) --- Members: MNN_OPEN_TIME_TRACE --- source: /SuperGenius/Files/d6/db5/processing__processor__mnn__image_8hpp/ title: processing_processor_mnn_image.hpp (file) --- Members: MNN_OPEN_TIME_TRACE MODEL_IMAGE_SIZE OUTPUT_STRIDE MAX_POSE_DETECTIONS NUM_KEYPOINTS SCORE_THRESHOLD MIN_POSE_SCORE NMS_RADIUS LOCAL_MAXIMUM_RADIUS OFFSET_NODE_NAME DISPLACE_FWD_NODE_NAME DISPLACE_BWD_NODE_NAME HEATMAPS CIRCLE_RADIUS --- source: /SuperGenius/Files/d4/daa/processing__processor__mnn__ml_8hpp/ title: processing_processor_mnn_ml.hpp (file) --- Members: MNN_OPEN_TIME_TRACE --- source: /SuperGenius/Files/d3/d07/processing__processor__mnn__string_8hpp/ title: processing_processor_mnn_string.hpp (file) --- Members: MNN_OPEN_TIME_TRACE --- source: /SuperGenius/Files/d3/dd8/processing__processor__mnn__volume_8hpp/ title: processing_processor_mnn_volume.hpp (file) --- Members: MNN_OPEN_TIME_TRACE --- source: /SuperGenius/Files/d7/d6b/sgprocmgr-logger_8hpp/ title: sgprocmgr-logger.hpp (file) --- Members: Logger createLogger --- source: /SuperGenius/Files/d3/d84/_image_splitter_8cpp/ title: ImageSplitter.cpp (file) --- Members: STB_IMAGE_IMPLEMENTATION STB_IMAGE_WRITE_IMPLEMENTATION --- source: /SuperGenius/Files/d8/d50/_processing_manager_8cpp/ title: ProcessingManager.cpp (file) --- Members: OUTCOME_CPP_DEFINE_CATEGORY_3 --- source: /SuperGenius/Files/d3/dfa/_input_types_8cpp/ title: InputTypes.cpp (file) --- Members: OUTCOME_CPP_DEFINE_CATEGORY_3 --- source: /SuperGenius/Files/de/d95/sgprocmgr-logger_8cpp/ title: sgprocmgr-logger.cpp (file) --- Members: createLogger --- source: /SuperGenius/Files/d0/d58/_account_messenger_8cpp/ title: AccountMessenger.cpp (file) --- 2025-07-22 Henrique A. Klein (hklein@gnus.ai) Members: OUTCOME_CPP_DEFINE_CATEGORY_3 --- source: /SuperGenius/Files/d8/d7a/_account_messenger_8hpp/ title: AccountMessenger.hpp (file) --- Header file of the account messenger class. 2025-07-21 Henrique A. Klein (hklein@gnus.ai) Members: OUTCOME_HPP_DECLARE_ERROR_2 — Macro for declaring error handling in the AccountMessenger class. --- source: /SuperGenius/Files/d6/de2/_bridge_event_types_8hpp/ title: BridgeEventTypes.hpp (file) --- Lightweight bridge event types and signature constants. No heavy dependencies — safe to include from tests and watchers. 2026-06-22 Members: kBridgeSourceBurnedSig — Canonical Solidity event signatures for bridge events. Single source of truth — shared by watch registration, catch-up scan, and RPC endpoint validation. kBridgeOutInitiatedSig --- source: /SuperGenius/Files/d5/de1/_bridge_relayer_8cpp/ title: BridgeRelayer.cpp (file) --- Wires evmrelay burn events to MintFunds via shared EthWatchService. 2026-05-30 Members: BridgeRelayerLogger — Returns a new instance of the BridgeRelayer logger. --- source: /SuperGenius/Files/db/da8/_bridge_relayer_8hpp/ title: BridgeRelayer.hpp (file) --- Wires evmrelay burn events to MintFunds via shared EthWatchService. 2026-05-30 --- source: /SuperGenius/Files/d1/d7b/_burn_config_8cpp/ title: BurnConfig.cpp (file) --- Implementation of the genesis-seeded, quorum-signed, cache-refresh-via-quorum-re-derivation BURN_BASIS_POINTS value (BURN-01, BURN-02, BURN-03). 2026-07-24 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/da/d28/_burn_config_8hpp/ title: BurnConfig.hpp (file) --- Genesis-seeded, quorum-signed, cache-refresh-via-quorum- re-derivation BURN_BASIS_POINTS value, built entirely on top of SecureCrdt/SecureCrdtRegistry/TrustedPeerRegistry (BURN-01, BURN-02, BURN-03). Direct structural template of TrustedPeerRegistry (Phase 10), replacing TransactionManager's hardcoded BURN_BASIS_POINTS constant. 2026-07-24 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d0/dba/_chain_contract_pair_8hpp/ title: ChainContractPair.hpp (file) --- Shared struct linking a chain name to its bridge contract address and numeric chain ID. 2025-06-17 SuperGenius This is the shared leaf type consumed by ChainRpcEndpointProvider (as observer payload) and by BridgeRelayer (as a Start() parameter). Extracting it into its own header breaks the include cycle that would otherwise exist between those two headers when BridgeRelayer inherits IBridgeInitObserver from the provider header. --- source: /SuperGenius/Files/da/d58/_chain_rpc_endpoint_provider_8cpp/ title: ChainRpcEndpointProvider.cpp (file) --- Implementation of the ChainList RPC endpoint loading and validator wiring. 2026-05-27 SuperGenius --- source: /SuperGenius/Files/d1/df6/_chain_rpc_endpoint_provider_8hpp/ title: ChainRpcEndpointProvider.hpp (file) --- Loads RPC endpoints from the evmrelay ChainList provider and wires them into PublicChainInputValidator with weighted consensus support. 2026-05-27 SuperGenius Members: ChainlistFetcher — Fetches the chainlist dataset (JSON text) used to discover public RPC URLs at startup. --- source: /SuperGenius/Files/d7/d12/_escrow_transaction_8cpp/ title: EscrowTransaction.cpp (file) --- 2024-04-24 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/df/df3/_escrow_transaction_8hpp/ title: EscrowTransaction.hpp (file) --- Transaction type used to lock UTXO funds into an escrow address. 2024-04-24 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/dd/dd9/_genius_account_8cpp/ title: GeniusAccount.cpp (file) --- Members: SECURE_STORAGE_PREFIX PUBLIC_KEY_HEX_LENGTH --- source: /SuperGenius/Files/d0/dad/_genius_account_8hpp/ title: GeniusAccount.hpp (file) --- Header file of the Genius account class. 2024-03-11 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/dd/dce/_genius_input_validator_8cpp/ title: GeniusInputValidator.cpp (file) --- Input validation strategy for native Genius-chain transactions. 2026-06-02 Members: InputValidatorLogger --- source: /SuperGenius/Files/d3/d86/_genius_input_validator_8hpp/ title: GeniusInputValidator.hpp (file) --- Input validation strategy for native Genius-chain transactions. 2026-06-02 Henrique A. Klein (hklein@gnus.ai) Members: kGeniusValidatorRegistered --- source: /SuperGenius/Files/df/de0/_genius_node_8cpp/ title: GeniusNode.cpp (file) --- 2024-04-18 Henrique A. Klein (hklein@gnus.ai) Members: OUTCOME_CPP_DEFINE_CATEGORY_3 GeniusNodeLogger generate_uuid_with_ipfs_id --- source: /SuperGenius/Files/d3/d63/_genius_node_8hpp/ title: GeniusNode.hpp (file) --- Top-level node orchestration API for account, transaction, blockchain, and processing services. 2024-03-11 Henrique A. Klein (hklein@gnus.ai) Members: OUTGOING_TIMEOUT_MILLISECONDS INCOMING_TIMEOUT_MILLISECONDS GeniusNodeConfig — Runtime configuration values used to bootstrap a Genius node instance. AccountSource DEV_CONFIG kDefaultTimestampToleranceMs OUTCOME_HPP_DECLARE_ERROR_2 --- source: /SuperGenius/Files/d5/dc7/_genius_signer_8hpp/ title: GeniusSigner.hpp (file) --- In-memory Genius keypair and canonical signature operations. --- source: /SuperGenius/Files/dd/d5e/_genius_transaction_8hpp/ title: GeniusTransaction.hpp (file) --- Header file of the base GeniusTransaction class. 2024-03-11 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d6/d74/_genius_u_t_x_o_8hpp/ title: GeniusUTXO.hpp (file) --- Lightweight value type representing a spendable UTXO entry and its outpoint. 2024-04-25 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/db/dc3/_input_validators_8cpp/ title: InputValidators.cpp (file) --- Input validation strategy interface translation unit. 2026-06-02 --- source: /SuperGenius/Files/db/de6/_input_validators_8hpp/ title: InputValidators.hpp (file) --- Input validation strategy interface for transaction inputs. 2026-03-23 Henrique A. Klein (hklein@gnus.ai) Members: HASH256_BYTES SERIALIZED_UINT32_BYTES SERIALIZED_UINT64_BYTES OUTPUT_INDEX_OFFSET OWNER_ADDRESS_LENGTH_OFFSET OWNER_ADDRESS_OFFSET TOKEN_ID_BYTES_IN_PAYLOAD AMOUNT_BYTES_IN_PAYLOAD ESCROW_LOCK_OUTPUT_INDEX TRANSFER_TX_TYPE --- source: /SuperGenius/Files/de/d45/_migration_allow_list_8hpp/ title: MigrationAllowList.hpp (file) --- Persistent allow-list used to track balances eligible for migration claims. 2026-05-01 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d0/d4d/_migration_input_validator_8cpp/ title: MigrationInputValidator.cpp (file) --- Input validation strategy for one-time migration claims. 2026-06-12 --- source: /SuperGenius/Files/d2/d7f/_migration_input_validator_8hpp/ title: MigrationInputValidator.hpp (file) --- Input validation strategy for one-time migration claims. 2026-06-12 Members: kMigrationValidatorRegistered — Static instance to trigger registration of the MigrationInputValidator before main() starts. --- source: /SuperGenius/Files/d5/d25/_migration_transaction_8cpp/ title: MigrationTransaction.cpp (file) --- One-time migration mint transaction implementation. 2026-04-29 --- source: /SuperGenius/Files/d1/dd1/_migration_transaction_8hpp/ title: MigrationTransaction.hpp (file) --- Header file for a Migration transaction that mint tokens on the destination chain based on observed legacy balances on the source chain. 2026-04-29 --- source: /SuperGenius/Files/d8/d70/_mint_transaction_8cpp/ title: MintTransaction.cpp (file) --- 2024-04-10 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d2/d0f/_mint_transaction_8hpp/ title: MintTransaction.hpp (file) --- Transaction type used to mint tokens from an external chain reference. 2024-03-15 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d0/df5/_mint_transaction_v2_8cpp/ title: MintTransactionV2.cpp (file) --- UTXO-aware mint transaction implementation. 2026-03-18 --- source: /SuperGenius/Files/d8/de4/_mint_transaction_v2_8hpp/ title: MintTransactionV2.hpp (file) --- Header file of the Version 2 of the Mint transaction class. 2026-03-19 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/dd/d91/_public_chain_input_validator_8cpp/ title: PublicChainInputValidator.cpp (file) --- Input validation strategy for public-chain source proofs. 2026-06-02 --- source: /SuperGenius/Files/d9/d3b/_public_chain_input_validator_8hpp/ title: PublicChainInputValidator.hpp (file) --- Input validation strategy for public-chain source proofs. 2026-06-02 Henrique A. Klein (hklein@gnus.ai) Members: TransportFactory — Factory callable that produces a JsonRpcTransport from a URL and timeout. --- source: /SuperGenius/Files/d2/d28/_token_amount_8cpp/ title: TokenAmount.cpp (file) --- Implementation of TokenAmount arithmetic helpers. --- source: /SuperGenius/Files/d9/d19/_token_amount_8hpp/ title: TokenAmount.hpp (file) --- Fixed-precision (6 decimals) token amount type with arithmetic helpers. 2025 --- source: /SuperGenius/Files/df/d5f/_token_i_d_8hpp/ title: TokenID.hpp (file) --- Fixed-size token identifier wrapper with GNUS compatibility helpers. 2025-06-19 Henrique A. Klein (hklein@gnus.ai) Members: operator<< — Streams a token identifier as hexadecimal text. --- source: /SuperGenius/Files/d0/dcc/_transaction_manager_8cpp/ title: TransactionManager.cpp (file) --- 2024-04-12 Henrique A. Klein (hklein@gnus.ai) Members: MAX_PUBSUB_TX_BYTES --- source: /SuperGenius/Files/de/d54/_transaction_manager_8hpp/ title: TransactionManager.hpp (file) --- Transaction coordination, CRDT sync, and lifecycle tracking for outgoing and incoming account activity. 2024-03-13 Henrique A. Klein (hklein@gnus.ai) Members: EscrowDataPair --- source: /SuperGenius/Files/db/dbb/_transfer_transaction_8cpp/ title: TransferTransaction.cpp (file) --- 2024-04-10 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/dd/d70/_transfer_transaction_8hpp/ title: TransferTransaction.hpp (file) --- Transaction of currency transfer. 2024-03-11 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d1/dac/_u_t_x_o_manager_8hpp/ title: UTXOManager.hpp (file) --- In-memory and persisted UTXO state manager with reservation and checkpoint helpers. 2026-01-20 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d6/d16/_u_t_x_o_merkle_8hpp/ title: UTXOMerkle.hpp (file) --- Helpers for deterministic serialization and Merkle hashing of UTXO snapshots. 2026-03-18 Henrique A. Klein (hklein@gnus.ai) Members: kLeafPrefix — Domain separator prefix used for hashed leaf payloads. kNodePrefix — Domain separator prefix used for hashed internal nodes. AppendUInt32BE — Appends a 32-bit unsigned integer in big-endian order. AppendUInt64BE — Appends a 64-bit unsigned integer in big-endian order. ReadUInt32BE — Reads a 32-bit unsigned integer from big-endian bytes. ReadUInt64BE — Reads a 64-bit unsigned integer from big-endian bytes. OutPointKey — Generates a canonical key for a UTXO outpoint, used for deterministic ordering in Merkle tree construction. SerializeUTXOLeafPayload — Serializes a UTXO into the canonical leaf payload used for Merkle hashing. HashLeaf — Hashes a serialized UTXO leaf payload with the leaf domain separator. HashNode — Hashes two child nodes with the internal-node domain separator. EmptyUTXOMerkleRoot — Returns the canonical root used for an empty UTXO set. ComputeMerkleRootFromLeafHashes — Reduces a list of leaf hashes into a single Merkle root. ComputeMerkleRootFromPayloads — Sorts canonical payloads, hashes them as leaves, and computes the Merkle root. ComputeMerkleRootFromUTXOs — Computes the Merkle root for a given set of UTXOs by serializing them into canonical payloads and hashing them. --- source: /SuperGenius/Files/d1/dd1/_u_t_x_o_structs_8hpp/ title: UTXOStructs.hpp (file) --- Shared UTXO transaction input and output data structures. 2026-01-20 Henrique A. Klein (hklein@gnus.ai) Members: UTXOTxParameters — Pair of signed inputs and destination outputs that make up a UTXO transaction payload. IsEscrowLockAddress — Checks if the address is a valid escrow lock address (0x-prefixed 64 hex chars) IsAccountPublicKeyAddress — Checks if the address is a public key. --- source: /SuperGenius/Files/dd/dc0/blob_8cpp/ title: blob.cpp (file) --- Members: OUTCOME_CPP_DEFINE_CATEGORY_3 --- source: /SuperGenius/Files/d4/d16/blob_8hpp/ title: blob.hpp (file) --- Members: BlobError Hash64 Hash128 Hash256 Hash512 operator<< — scale-encodes blob instance to stream operator>> — decodes blob instance from stream operator<< OUTCOME_HPP_DECLARE_ERROR_2 --- source: /SuperGenius/Files/dd/d85/buffer_8cpp/ title: buffer.cpp (file) --- Members: operator<< --- source: /SuperGenius/Files/da/d1d/buffer_8hpp/ title: buffer.hpp (file) --- Members: operator<< — override operator<< for all streams except std::ostream operator>> — decodes buffer object from stream operator<< --- source: /SuperGenius/Files/d1/d4c/hexutil_8cpp/ title: hexutil.cpp (file) --- Members: OUTCOME_CPP_DEFINE_CATEGORY_3 hex_upper — Converts bytes to uppercase hex representation. hex_lower — Converts bytes to hex representation. IsHexAddress — Checks whether a string is a 128-character lowercase hexadecimal address. unhex — Converts hex representation to bytes. unhexWith0x — Unhex hex-string with 0x in the begining. --- source: /SuperGenius/Files/df/d28/hexutil_8hpp/ title: hexutil.hpp (file) --- Members: UnhexError — error codes for exceptions that may occur during unhexing hex_upper — Converts bytes to uppercase hex representation. hex_lower — Converts bytes to hex representation. IsHexAddress — Checks whether a string is a 128-character lowercase hexadecimal address. unhex — Converts hex representation to bytes. unhexWith0x — Unhex hex-string with 0x in the begining. OUTCOME_HPP_DECLARE_ERROR_2 --- source: /SuperGenius/Files/d3/d30/logger_8cpp/ title: logger.cpp (file) --- Members: createLogger — Create a logger instance. --- source: /SuperGenius/Files/d6/da3/logger_8hpp/ title: logger.hpp (file) --- Members: Logger createLogger — Create a logger instance. --- source: /SuperGenius/Files/d6/d8d/outcome__throw_8hpp/ title: outcome_throw.hpp (file) --- Members: raise — throws outcome::result error as boost exception raise — throws outcome::result error made of error as boost exception --- source: /SuperGenius/Files/dc/d4f/_scaled_integer_8cpp/ title: ScaledInteger.cpp (file) --- Fixed-point arithmetic utilities (Implementation file) Luiz Guilherme Rizzatto Zucchi (luizgrz@gmail.com) 1.1 2025-06-10 Copyright (c) 2025 --- source: /SuperGenius/Files/d5/daa/_scaled_integer_8hpp/ title: ScaledInteger.hpp (file) --- Utilities for decimal arithmetic using scaled integers. Luiz Guilherme Rizzatto Zucchi (luizgrz@gmail.com) 1.1 2025-06-10 Copyright (c) 2025 --- source: /SuperGenius/Files/d4/d36/sgns__version_8cpp/ title: sgns_version.cpp (file) --- Implementation of version retrieval functions for SuperGenius. This file provides functions to retrieve version information for SuperGenius. All version-related macros (e.g. SUPERGENIUS_VERSION_NUMBER) are defined via CMake. Members: network_id_ --- source: /SuperGenius/Files/de/d68/sgns__version_8hpp/ title: sgns_version.hpp (file) --- Members: MAIN_NET_ID TEST_NET_ID DEV_NET_ID NET_ID_APPENDIX SGNS_VERSION_APPENDIX SuperGeniusVersionNum — Retrieves the complete version number of SuperGenius. SuperGeniusVersionMajor — Retrieves the major version of SuperGenius. SuperGeniusVersionMinor — Retrieves the minor version of SuperGenius. SuperGeniusVersionPatch — Retrieves the patch version of SuperGenius. ProcessingVersion — Retrieves the processing version used by processing task storage keys. SuperGeniusVersionString — Retrieves the short version string of SuperGenius. SuperGeniusVersionFullString — Retrieves the full version string of SuperGenius. SuperGeniusVersionText — Retrieves the display version text of SuperGenius. GetNetworkID GetNetAndVersionAppendix GetNetAndVersionAppendix SetNetworkId --- source: /SuperGenius/Files/dd/d26/unused_8hpp/ title: unused.hpp (file) --- Members: operator<< operator>> --- source: /SuperGenius/Files/d1/d14/_proof_system_2include_2_proof_system_2util_8hpp/ title: ProofSystem/include/ProofSystem/util.hpp (file) --- Utilities functions header file. 2024-01-12 Super Genius (ken@gnus.ai) Henrique A. Klein (henryaklein@gmail.com) Members: to_string — Convert a byte array to a hexadecimal string. isLittleEndian — Checks if the architecture is little endian. HexASCII2Num — Converts a hexadecimal ASCII char array into a number. HexASCII2NumStr — Converts a hexadecimal ASCII char array into a vector of numbers. AdjustEndianess — Adjust endianess if needed. --- source: /SuperGenius/Files/d1/d54/src_2base_2util_8hpp/ title: src/base/util.hpp (file) --- Utilities functions header file. 2024-01-12 Super Genius (ken@gnus.ai) Henrique A. Klein (henryaklein@gmail.com) Members: to_string — Convert a byte array to a hexadecimal string. isLittleEndian — Checks if the architecture is little endian. Vector2Num — Converts a little-endian byte vector into a number. Vector2Num Vector2Num Num2Vector — Converts a number into a byte vector (little-endian). HexASCII2Num — Converts a hexadecimal ASCII char array into a number. HexASCII2NumStr — Converts a hexadecimal ASCII char array into a vector of numbers. AdjustEndianess — Adjust endianess if needed. Uint256ToString waitForCondition --- source: /SuperGenius/Files/d2/df0/visitor_8hpp/ title: visitor.hpp (file) --- Members: make_visitor — Creates a compile-time visitor from a set of lambdas. visit_in_place — Applies an in-place visitor to a boost::variant. match — apply Matcher to optional T match_in_place — construct visitor from Fs and apply it to optional T --- source: /SuperGenius/Files/d8/d7c/wrapper_8hpp/ title: wrapper.hpp (file) --- Members: operator< --- source: /SuperGenius/Files/dc/d59/_blockchain_8hpp/ title: Blockchain.hpp (file) --- Header file for the Blockchain class, which provides an interface for block storage operations. 2025-10-16 Henrique A. Klein (hklein@gnus.ai) Members: OUTCOME_HPP_DECLARE_ERROR_2 — Macro for declaring error handling in the IBasicProof class. --- source: /SuperGenius/Files/d3/d45/_consensus_8cpp/ title: Consensus.cpp (file) --- Consensus proposal/vote/certificate helpers. 2025-10-16 Henrique A. Klein (hklein@gnus.ai) Members: ConsensusManagerLogger --- source: /SuperGenius/Files/d0/dc1/_consensus_8hpp/ title: Consensus.hpp (file) --- Consensus proposal/vote/certificate helpers. 2025-10-16 Henrique A. Klein (hklein@gnus.ai) Members: NONCE_SUBJECT_TYPE TASK_RESULT_SUBJECT_TYPE REGISTRY_BATCH_SUBJECT_TYPE --- source: /SuperGenius/Files/d5/d9f/_consensus_auth_8hpp/ title: ConsensusAuth.hpp (file) --- Header-only helpers for consensus signing and validation. 2026-02-07 Henrique A. Klein (hklein@gnus.ai) Members: ProposalSigningBytes — Builds canonical bytes used to sign a consensus proposal. VoteSigningBytes — Builds canonical bytes used to sign a consensus vote. VoteBundleSigningBytes — Builds canonical bytes used to sign a consensus vote bundle. ComputeProposalId — Computes deterministic proposal id from proposal content. ValidateProposal — Validates proposal basic shape, signature, and computed id. --- source: /SuperGenius/Files/da/d8c/_blockchain_8cpp/ title: Blockchain.cpp (file) --- Header file for the Blockchain class, which provides an interface for block storage operations. 2025-10-28 Henrique A. Klein (hklein@gnus.ai) Members: OUTCOME_CPP_DEFINE_CATEGORY_3 --- source: /SuperGenius/Files/df/d00/_validator_registry_8cpp/ title: ValidatorRegistry.cpp (file) --- Validator registry and quorum logic for governance. 2025-10-16 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/df/df1/_validator_registry_8hpp/ title: ValidatorRegistry.hpp (file) --- Validator registry and quorum logic for governance. 2025-10-16 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d4/d1b/coinprices_8cpp/ title: coinprices.cpp (file) --- Members: OUTCOME_CPP_DEFINE_CATEGORY_3 decodeChunkedTransfer --- source: /SuperGenius/Files/dc/d0f/crdt__callback__manager_8hpp/ title: crdt_callback_manager.hpp (file) --- CRDT callback manager header for when an element gets added/removed. 2025-09-05 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d9/dc5/crdt__data__filter_8hpp/ title: crdt_data_filter.hpp (file) --- Header file of the CRDT Filter class. 2025-04-07 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d5/d29/crdt__datastore_8hpp/ title: crdt_datastore.hpp (file) --- CRDT datastore class source file. 2025-04-04 devcareer0 Henrique A. Klein (hklein@gnus.ai) Members: OUTCOME_HPP_DECLARE_ERROR_2 — Macro for declaring error handling in the CrdtDatastore class. --- source: /SuperGenius/Files/d1/d85/crdt__work__journal_8hpp/ title: crdt_work_journal.hpp (file) --- Persistent work-journal for CRDT key processing state. 2026-04-21 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d6/de2/globaldb_8cpp/ title: globaldb.cpp (file) --- Members: CrdtOptions CrdtDatastore HierarchicalKey GraphsyncDAGSyncer RocksdbDatastore IpfsRocksDb GossipPubSub GraphsyncImpl OUTCOME_CPP_DEFINE_CATEGORY_3 --- source: /SuperGenius/Files/d0/d0e/globaldb_8hpp/ title: globaldb.hpp (file) --- Members: OUTCOME_HPP_DECLARE_ERROR_2 — Macro for declaring error handling in the GlobalDB class. --- source: /SuperGenius/Files/d7/dda/keypair__file__storage_8cpp/ title: keypair_file_storage.cpp (file) --- Members: CryptoProvider KeyMarshaller KeyValidator --- source: /SuperGenius/Files/d6/dea/graphsync__dagsyncer_8hpp/ title: graphsync_dagsyncer.hpp (file) --- Members: OUTCOME_HPP_DECLARE_ERROR_2 — Macro for declaring error handling in the IBasicProof class. --- source: /SuperGenius/Files/d2/d51/crdt__callback__manager_8cpp/ title: crdt_callback_manager.cpp (file) --- CRDT callback manager header for when an element gets added/removed. 2025-09-06 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d0/df2/crdt__data__filter_8cpp/ title: crdt_data_filter.cpp (file) --- Source file of the CRDT Filter class. 2025-05-12 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d9/d51/crdt__datastore_8cpp/ title: crdt_datastore.cpp (file) --- Members: CRDTBroadcast OUTCOME_CPP_DEFINE_CATEGORY_3 --- source: /SuperGenius/Files/d4/d84/crdt__set_8cpp/ title: crdt_set.cpp (file) --- Members: CRDTSet --- source: /SuperGenius/Files/d5/d9b/graphsync__dagsyncer_8cpp/ title: graphsync_dagsyncer.cpp (file) --- Members: OUTCOME_CPP_DEFINE_CATEGORY_3 --- source: /SuperGenius/Files/d1/d21/hasher_8cpp/ title: hasher.cpp (file) --- Members: twox_64 twox_128 blake2b_128 twox_256 blake2b_256 keccak_256 blake2s_256 sha2_256 --- source: /SuperGenius/Files/da/d6b/hasher_8hpp/ title: hasher.hpp (file) --- Members: twox_64 twox_128 blake2b_128 twox_256 blake2b_256 keccak_256 blake2s_256 sha2_256 sha2_256 --- source: /SuperGenius/Files/d5/d47/keccak_8c/ title: keccak.c (file) --- Members: SHA3_ASSERT SHA3_TRACE SHA3_TRACE_BUF SHA3_USE_KECCAK_FLAG SHA3_CW SHA3_CONST SHA3_ROTL64 KECCAK_ROUNDS keccakf_rndc keccakf_rotc keccakf_piln keccakf sha3_Init sha3_Init256 sha3_Init384 sha3_Init512 sha3_SetFlags sgns_sha3_Update sha3_Finalize sha3_HashBuffer --- source: /SuperGenius/Files/d6/dd8/keccak_8h/ title: keccak.h (file) --- Members: SHA3_KECCAK_SPONGE_WORDS SHA3_FLAGS SHA3_RETURN sha3_context sha3_return_t sha3_Init sha3_Init256 sha3_Init384 sha3_Init512 sha3_SetFlags sgns_sha3_Update sha3_Finalize sha3_HashBuffer --- source: /SuperGenius/Files/d4/d0d/_s_g_processing_manager_2src_2util_2sha256_8cpp/ title: SGProcessingManager/src/util/sha256.cpp (file) --- Members: sha256 --- source: /SuperGenius/Files/d5/df5/src_2crypto_2sha_2sha256_8cpp/ title: src/crypto/sha/sha256.cpp (file) --- Members: sha256 sha256 sha256 --- source: /SuperGenius/Files/d8/d69/_s_g_processing_manager_2include_2util_2sha256_8hpp/ title: SGProcessingManager/include/util/sha256.hpp (file) --- Members: sha256 --- source: /SuperGenius/Files/d7/d61/src_2crypto_2sha_2sha256_8hpp/ title: src/crypto/sha/sha256.hpp (file) --- Members: sha256 sha256 sha256 --- source: /SuperGenius/Files/d8/d88/twox_8cpp/ title: twox.cpp (file) --- Members: make_twox64 make_twox64 make_twox128 make_twox128 make_twox256 make_twox256 --- source: /SuperGenius/Files/d9/ded/twox_8hpp/ title: twox.hpp (file) --- Members: make_twox64 make_twox128 make_twox256 --- source: /SuperGenius/Files/dc/dbd/_android_8cpp/ title: Android.cpp (file) --- Members: LOG_TAG LOGI LOGE InitGeniusSDKAndroid Java_ai_gnus_sdk_KeyStoreHelper_nativeInit JNI_OnLoad --- source: /SuperGenius/Files/d7/d37/_j_s_o_n_secure_storage_8cpp/ title: JSONSecureStorage.cpp (file) --- 2024-06-06 Henrique A. Klein (hklein@gnus.ai) Members: FILE_NAME --- source: /SuperGenius/Files/d3/dfa/_j_s_o_n_secure_storage_8hpp/ title: JSONSecureStorage.hpp (file) --- 2024-06-06 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d6/db5/_memory_secure_storage_8hpp/ title: MemorySecureStorage.hpp (file) --- In-memory JSON backend for testing — no keychain access. 2026-06-01 --- source: /SuperGenius/Files/dd/d1a/_i_secure_storage_8hpp/ title: ISecureStorage.hpp (file) --- Secure Storage Interface class. 2024-06-05 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d7/d10/unreachable_8hpp/ title: unreachable.hpp (file) --- Members: UNREACHABLE --- source: /SuperGenius/Files/d5/da7/_i_migration_step_8hpp/ title: IMigrationStep.hpp (file) --- Versioned migration manager and migration step interface. 2025-05-29 Luiz Guilherme Rizzatto Zucchi Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/dc/dfe/_migration0__2__0_to1__0__0_8cpp/ title: Migration0_2_0To1_0_0.cpp (file) --- Implementation of MigrationManager and migration steps. 2025-05-29 Luiz Guilherme Rizzatto Zucchi Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d1/d31/_migration0__2__0_to1__0__0_8hpp/ title: Migration0_2_0To1_0_0.hpp (file) --- Versioned migration manager and migration step interface. 2025-05-29 Luiz Guilherme Rizzatto Zucchi Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d8/d30/_migration1__0__0_to3__4__0_8cpp/ title: Migration1_0_0To3_4_0.cpp (file) --- 2025-10-03 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/dc/db1/_migration1__0__0_to3__4__0_8hpp/ title: Migration1_0_0To3_4_0.hpp (file) --- Header file for Migration1_0_0To3_4_0 class. 2025-10-03 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d6/d71/_migration3__4__0_to3__5__0_8cpp/ title: Migration3_4_0To3_5_0.cpp (file) --- 2025-11-14 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/de/d71/_migration3__4__0_to3__5__0_8hpp/ title: Migration3_4_0To3_5_0.hpp (file) --- Migration step that upgrades account data from schema version 3.4.0 to 3.5.0. 2025-11-11 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d3/d7e/_migration3__5__0_to3__6__0_8hpp/ title: Migration3_5_0To3_6_0.hpp (file) --- Migration step that upgrades account data from schema version 3.5.1 to 3.6.0. 2026-01-22 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d6/dd1/_migration3__6__0_to3__7__0_8hpp/ title: Migration3_6_0To3_7_0.hpp (file) --- Migration step that upgrades account and balance data from schema version 3.6.0 to 3.7.0. 2026-05-06 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d2/d4b/_migration_manager_8cpp/ title: MigrationManager.cpp (file) --- Implementation of MigrationManager and migration steps. 2025-05-29 Luiz Guilherme Rizzatto Zucchi Henrique A. Klein (hklein@gnus.ai) Members: OUTCOME_CPP_DEFINE_CATEGORY_3 --- source: /SuperGenius/Files/dc/d31/_migration_manager_8hpp/ title: MigrationManager.hpp (file) --- Versioned migration manager. 2025-05-29 Luiz Guilherme Rizzatto Zucchi Henrique A. Klein (hklein@gnus.ai) Members: OUTCOME_HPP_DECLARE_ERROR_2 --- source: /SuperGenius/Files/dd/dff/_multi_sig_8cpp/ title: MultiSig.cpp (file) --- Implementation of the standalone multi-signature primitive. 2026-07-21 Henrique A. Klein (hklein@gnus.ai) Members: VerifyPayloadSignature — Verifies a signature over an arbitrary raw-byte payload. Delegates entirely to GeniusAccount::VerifySignature; no custom crypto or signing-bytes construction is performed here (the payload is assumed already-canonical). --- source: /SuperGenius/Files/d8/da6/_multi_sig_8hpp/ title: MultiSig.hpp (file) --- Standalone multi-signature primitive: payload signature verification and N-of-M quorum evaluation over a signer set. No CRDT, node, or pubsub dependency (MSIG-03). 2026-07-21 Henrique A. Klein (hklein@gnus.ai) Members: SignatureBytes CollectedSignatures VerifyPayloadSignature — Verifies a signature over an arbitrary raw-byte payload. Delegates entirely to GeniusAccount::VerifySignature; no custom crypto or signing-bytes construction is performed here (the payload is assumed already-canonical). --- source: /SuperGenius/Files/db/d83/processing__core__impl_8cpp/ title: processing_core_impl.cpp (file) --- Members: OUTCOME_CPP_DEFINE_CATEGORY_3 --- source: /SuperGenius/Files/dd/da6/processing__core__impl_8hpp/ title: processing_core_impl.hpp (file) --- Header file of the Processing Core implementation that uses the ProcessingManager to execute subtasks. 2024-03-28 Justin Church (jchurch@gnus.ai) Henrique A. Klein (hklein@gnus.ai) Members: OUTCOME_HPP_DECLARE_ERROR_2 --- source: /SuperGenius/Files/d7/dfe/_task_keys_8hpp/ title: TaskKeys.hpp (file) --- 2026-05-19 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d1/dcf/_task_queue_impl_8cpp/ title: TaskQueueImpl.cpp (file) --- Members: TaskQueueImplLogger --- source: /SuperGenius/Files/d2/d7b/_task_queue_impl_8hpp/ title: TaskQueueImpl.hpp (file) --- Header file for the implementation of the task queue using CRDT. 2026-05-18 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d8/d06/processing__tasksplit_8cpp/ title: processing_tasksplit.cpp (file) --- 2024-04-23 Henrique A. Klein (hklein@gnus.ai) Members: generate_uuid_with_ipfs_id --- source: /SuperGenius/Files/df/d74/processing__tasksplit_8hpp/ title: processing_tasksplit.hpp (file) --- 2024-04-23 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d4/deb/processing__validation__core_8cpp/ title: processing_validation_core.cpp (file) --- Source file of core implementation of processing task results validation. 2022-05-08 creativeid00 This was mostly rewritten by Henrique A. Klein (hklein@gnus.ai) and Justin Church (jchurch@gnus.ai) Members: OUTCOME_CPP_DEFINE_CATEGORY_3 --- source: /SuperGenius/Files/d1/dd9/processing__validation__core_8hpp/ title: processing_validation_core.hpp (file) --- Header file of core implementation of processing task results validation. 2022-05-08 creativeid00 This was mostly rewritten by Henrique A. Klein (hklein@gnus.ai) and Justin Church (jchurch@gnus.ai) Members: OUTCOME_HPP_DECLARE_ERROR_2 — Macro for declaring error handling in the IBasicProof class. --- source: /SuperGenius/Files/dc/d87/_recursive_transaction_circuit_8hpp/ title: RecursiveTransactionCircuit.hpp (file) --- The circuit bytecode in string form. 2025-01-28 Henrique A. Klein (hklein@gnus.ai) Members: RecursiveTransactionCircuit --- source: /SuperGenius/Files/db/d30/_proof_system_2_s_g_proof_circuits_2include_2_transaction_verifier_circuit_8hpp/ title: ProofSystem/SGProofCircuits/include/TransactionVerifierCircuit.hpp (file) --- Members: ValidateTransaction — Circuit that validates the transaction. --- source: /SuperGenius/Files/d6/db4/src_2proof_2circuits_2_transaction_verifier_circuit_8hpp/ title: src/proof/circuits/TransactionVerifierCircuit.hpp (file) --- 2024-10-03 Henrique A. Klein (hklein@gnus.ai) Members: TransactionCircuit TransactionCircuitDebug --- source: /SuperGenius/Files/d7/da6/_genius_assigner_8cpp/ title: GeniusAssigner.cpp (file) --- Source file of the assigner from bytecode to circuit. 2024-09-09 Henrique A. Klein (hklein@gnus.ai) Members: OUTCOME_CPP_DEFINE_CATEGORY_3 --- source: /SuperGenius/Files/d1/d19/_genius_assigner_8hpp/ title: GeniusAssigner.hpp (file) --- Header file of the assigner from bytecode to circuit. 2024-09-09 Henrique A. Klein (hklein@gnus.ai) Members: OUTCOME_HPP_DECLARE_ERROR_2 --- source: /SuperGenius/Files/dc/dfd/_genius_prover_8cpp/ title: GeniusProver.cpp (file) --- Source file of the prover from circuit to zkproof. 2024-09-13 Henrique A. Klein (hklein@gnus.ai) Members: OUTCOME_CPP_DEFINE_CATEGORY_3 --- source: /SuperGenius/Files/d9/d35/_genius_prover_8hpp/ title: GeniusProver.hpp (file) --- Header file of the prover from circuit to zkproof. 2024-09-13 Henrique A. Klein (hklein@gnus.ai) Members: OUTCOME_HPP_DECLARE_ERROR_2 --- source: /SuperGenius/Files/dc/d19/_i_basic_proof_8cpp/ title: IBasicProof.cpp (file) --- 2024-10-08 Henrique A. Klein (hklein@gnus.ai) Members: OUTCOME_CPP_DEFINE_CATEGORY_3 GetSnarkFromProto --- source: /SuperGenius/Files/de/d4a/_i_basic_proof_8hpp/ title: IBasicProof.hpp (file) --- Base proof class header file. 2024-09-29 Henrique A. Klein (hklein@gnus.ai) Members: OUTCOME_HPP_DECLARE_ERROR_2 — Macro for declaring error handling in the IBasicProof class. --- source: /SuperGenius/Files/d2/d6c/_nil_file_helper_8hpp/ title: NilFileHelper.hpp (file) --- 2024-09-19 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/dc/dc6/_processing_proof_8cpp/ title: ProcessingProof.cpp (file) --- 2024-09-29 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d8/d51/_processing_proof_8hpp/ title: ProcessingProof.hpp (file) --- Derived class for generating and verifying processing proofs. 2024-09-29 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/df/db6/_recursive_transfer_proof_8cpp/ title: RecursiveTransferProof.cpp (file) --- Source file of the Recursive Transfer Proof. 2025-01-29 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d7/d6d/_recursive_transfer_proof_8hpp/ title: RecursiveTransferProof.hpp (file) --- Header file of the RecursiveTransferProof. 2025-01-29 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d5/dcb/_transfer_proof_8cpp/ title: TransferProof.cpp (file) --- 2024-09-29 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d5/d20/_transfer_proof_8hpp/ title: TransferProof.hpp (file) --- Derived class for generating and verifying transfer proofs. 2024-09-29 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d4/dbc/_i_signed_c_r_d_t_data_8hpp/ title: ISignedCRDTData.hpp (file) --- Per-type interface for CRDT-backed values that require quorum-signed updates. Every future registered type (TrustedPeerRegistry, BurnConfig, migrated ValidatorRegistry) implements this. No template - mirrors IInputValidator's per-type virtual-interface style exactly. 2026-07-23 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/db/dee/_quorum_threshold_validation_8hpp/ title: QuorumThresholdValidation.hpp (file) --- Shared majority-floor quorum-threshold validation helper (D-07, security-critical). Both TrustedPeerRegistry::New and BurnConfig::New call this at construction time to reject any locally-configured quorum_threshold below ceil(0.51*N) preventing a malicious node operator from locally lowering a registry's threshold to trivially self-confirm an under-signed value. 2026-07-24 Henrique A. Klein (hklein@gnus.ai) Members: ValidateQuorumThreshold — Validates that threshold is at or above the majority-safety floor for a signer set of size signer_set_size (ceil(0.51*signer_set_size), computed via integer arithmetic). --- source: /SuperGenius/Files/d8/df4/_secure_crdt_8cpp/ title: SecureCrdt.cpp (file) --- Implementation of the SecureCrdt local-write gate (D-03) and reader-side quorum re-derivation (D-04). 2026-07-23 Henrique A. Klein (hklein@gnus.ai) Members: OUTCOME_CPP_DEFINE_CATEGORY_3 --- source: /SuperGenius/Files/d9/da5/_secure_crdt_8hpp/ title: SecureCrdt.hpp (file) --- Mandatory wrapper (D-03) for writing to a registered CRDT key and the reader-side logic (D-04) that always re-derives trust from base_key + sig/ children rather than trusting any "final" marker. This is the ONLY sanctioned write entry point for keys registered via SecureCrdtRegistry. 2026-07-23 Henrique A. Klein (hklein@gnus.ai) Members: OUTCOME_HPP_DECLARE_ERROR_2 --- source: /SuperGenius/Files/d4/dc2/_secure_crdt_registry_8hpp/ title: SecureCrdtRegistry.hpp (file) --- Static registry mapping a base_key pattern to {signer-set source, required signature count, ISignedCRDTData factory}, resolvable at startup/runtime by key. Header-only, mirrors IInputValidator's static Register/UnregisterIf/Get idiom. 2026-07-23 Henrique A. Klein (hklein@gnus.ai) Members: SignerSetSource — Injectable callback resolving the current authorized signer set for a given base_key. NOT hard-wired to TrustedPeerRegistry (which does not exist until Phase 10) - tests inject a fixed-list lambda. --- source: /SuperGenius/Files/d8/db2/_c_component_factory_8cpp/ title: CComponentFactory.cpp (file) --- 2024-02-23 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d3/d74/_c_component_factory_8hpp/ title: CComponentFactory.hpp (file) --- 2024-02-23 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/df/dec/_i_component_8hpp/ title: IComponent.hpp (file) --- Component interface class. 2024-02-23 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d3/d4b/_i_component_factory_8hpp/ title: IComponentFactory.hpp (file) --- 2024-02-23 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d3/d91/_singleton_8hpp/ title: Singleton.hpp (file) --- Members: SINGLETONINSTANCE SINGLETON SINGLETONCONSTRUCTOROVERRIDE --- source: /SuperGenius/Files/d8/dcc/buffer__map__types_8hpp/ title: buffer_map_types.hpp (file) --- Members: Buffer BufferMap BufferBatch ReadOnlyBufferMap BatchWriteBufferMap BufferStorage BufferMapCursor --- source: /SuperGenius/Files/dd/d5f/database__error_8cpp/ title: database_error.cpp (file) --- Members: OUTCOME_CPP_DEFINE_CATEGORY_3 error_from_rocksdb --- source: /SuperGenius/Files/d9/da2/database__error_8hpp/ title: database_error.hpp (file) --- Members: DatabaseError — universal database interface error error_from_rocksdb OUTCOME_HPP_DECLARE_ERROR_2 --- source: /SuperGenius/Files/dc/df7/predefined__keys_8hpp/ title: predefined_keys.hpp (file) --- Members: GetAuthoritySetKey GetSetStateKey GetGenesisBlockHashLookupKey GetLastFinalizedBlockHashLookupKey --- source: /SuperGenius/Files/dc/d6d/rocksdb_8cpp/ title: rocksdb.cpp (file) --- Members: BlockBasedTableOptions --- source: /SuperGenius/Files/d8/d00/rocksdb__util_8hpp/ title: rocksdb_util.hpp (file) --- Members: error_as_result error_as_result make_slice make_span make_buffer --- source: /SuperGenius/Files/d5/d4a/_trusted_peer_registry_8cpp/ title: TrustedPeerRegistry.cpp (file) --- Implementation of the genesis-seeded, quorum-updatable trusted-peer set (TPR-01, TPR-02, TPR-03). 2026-07-24 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/d4/d4c/_trusted_peer_registry_8hpp/ title: TrustedPeerRegistry.hpp (file) --- Genesis-seeded, quorum-updatable trusted-peer set built entirely on top of Phase 9's SecureCrdt/SecureCrdtRegistry/ISignedCRDTData machinery. This is the first real (non-test) consumer of the SecureCRDT layer, and the signer-set-source dependency Phase 11 (BURN_BASIS_POINTS) will build on (TPR-01, TPR-02, TPR-03). 2026-07-24 Henrique A. Klein (hklein@gnus.ai) --- source: /SuperGenius/Files/df/d19/bridge__catchup__watcher_8cpp/ title: bridge_catchup_watcher.cpp (file) --- Implementation of the bridge catch-up scan watcher. 2026-07-12 SuperGenius (ken@gnus.ai) Copyright 2026 Genius Ventures, Inc. SPDX-License-Identifier: MIT --- source: /SuperGenius/Files/de/d09/bridge__catchup__watcher_8hpp/ title: bridge_catchup_watcher.hpp (file) --- Header file for the bridge catch-up scan watcher. 2026-07-12 SuperGenius (ken@gnus.ai) Copyright 2026 Genius Ventures, Inc. SPDX-License-Identifier: MIT Polling watcher that scans historical blocks for unprocessed bridge burn events and forwards them to the node for parsing + minting. Follows the BridgeRpcWatcher / MessagingWatcher pattern. The watcher keeps its dependency surface small: it decodes raw event logs and passes the ABI values to a BurnProcessor callback provided by the node. The node (which already links the full account / transaction stack) handles ParseBurnEventValues + MintTokens. This avoids pulling BridgeRelayer → TransactionManager → ipfs_lite into the watcher target. --- source: /SuperGenius/Files/d6/d6b/bridge__rpc__watcher_8cpp/ title: bridge_rpc_watcher.cpp (file) --- Implementation of the bridge RPC watcher. 2026-02-03 SuperGenius (ken@gnus.ai) Copyright 2026 Genius Ventures, Inc. SPDX-License-Identifier: MIT --- source: /SuperGenius/Files/d5/de8/bridge__rpc__watcher_8hpp/ title: bridge_rpc_watcher.hpp (file) --- Header file for the bridge RPC watcher. 2026-06-03 SuperGenius (ken@gnus.ai) Copyright 2026 Genius Ventures, Inc. SPDX-License-Identifier: MIT