Zenova Platform Documentation

What is Zenova?

Zenova redefines how companies go public and trade stocks using **AI** and **blockchain technology**. It's an AI-powered, decentralized platform that allows private companies to bypass traditional IPOs through autonomous evaluation and tokenization processes.

AI agents autonomously evaluate companies, determine valuations, and mint ERC-20 tokens representing shares. Trading and pricing are also AI-governed, creating a fully autonomous marketplace for tokenized company equity.

The `AI_ROLE`: The Engine of Zenova

Zenova implements an **ultra-simplified** role-based access control system centered around a single, all-powerful role: the `AI_ROLE`. This design philosophy underpins Zenova's commitment to being a fully autonomous, AI-driven platform.

The `onlyAI` modifier restricts critical functions to entities holding the `AI_ROLE`, ensuring that only authorized AI agents can perform evaluations, price updates, and asset management.

`ZenovaAssetFactory.sol`: The Asset Genesis Engine

The central factory contract responsible for creating and managing `ZenovaAsset` instances representing tokenized company shares. It leverages the clone pattern for efficient asset deployment and serves as the main administrative hub for platform-level operations and analytics.

Core Functions:

Key State Variables & Mappings:

• `zenovaAssetImplementation`: Address of the master `ZenovaAsset` contract.
• `acceptedCurrency`: Address of the currency (e.g., USDTMock) used for valuations and trading.
• `assetInitialValuations`: Mapping from company wallet to their `CompanyInitialValuation` struct.
• `allAssets`: Array of all created `ZenovaAsset` contract addresses.
• `companyToAssets`: Mapping from company wallet to an array of their associated `ZenovaAsset` addresses.

Analytics & View Functions:

The factory provides comprehensive analytics for off-chain consumption and platform monitoring:

• `getCompanyComprehensiveDetails()`: Complete data for a company including pending valuations and all its live assets.
• `getPlatformSnapshot()`: Platform-wide statistics like total assets, market cap, trading volume, etc.
• `getUserPortfolioDetails()`: Aggregated portfolio information for a specific user across all Zenova assets.
• `getMultipleAssetAnalytics()`: Batch retrieval of full details, trading metrics, and market analysis for multiple assets.
• `getAssetFullDetails()`: Detailed information for a single asset, callable from the factory.
• `getAllAssets()`, `getAssetsByCompany()`, `getSubmittedValuation()`, `totalAssets()`: Various utility views for asset and valuation data.

`ZenovaAsset.sol`: The Digital Share

Represents a company's tokenized shares as an ERC20-compliant token. It inherits from OpenZeppelin's `ERC20`, `AccessControlEnumerable`, `Pausable`, and Zenova's internal `ZenovaRoles` and `Initializable` (for clone pattern).

Core Roles & Permissions:

• `DEFAULT_ADMIN_ROLE`: General administrative control, typically held by the creating AI.
• `AI_ROLE`: The primary operational role, assigned to the AI agent responsible for managing the asset. This role can update prices, manage liquidity, activate/deactivate trading, and withdraw fees.
• `PAUSER_ROLE`: Can pause and unpause the contract, also typically held by the AI.

Key Data Structures:

Token Supply Calculation:

AI-Controlled Functions (requiring `AI_ROLE`):

Pausable Functions (requiring `PAUSER_ROLE`):

Trading Mechanism:

**AI-Determined Pricing**: Prices are set by AI agents, not peer-to-peer auctions.

`IZenovaAsset.sol`: The Asset Contract Interface

Defines the complete public Application Programming Interface (API) for the `ZenovaAsset` contract, including all functions, events, errors, and data structures. This ensures interoperability and clear contract boundaries.

Key Information Structures (Structs):

`USDTMock.sol`: The Test Currency Backbone

`USDTMock.sol` is an essential ERC20 token contract specifically designed for testing and development within the Zenova ecosystem. It emulates the behavior of Tether (USDT) by implementing **6 decimal places**, a standard for many stablecoins. This mock token serves as the primary `acceptedCurrency` for company valuations, token pricing, and trading simulations on test networks.

Core Features & Purpose:

• **Standard Compliance**: Inherits from OpenZeppelin's `ERC20` for robust and secure token functionality, and `Ownable` for administrative control by its deployer.
• **Decimal Precision**: Strictly uses 6 decimals, aligning with real-world USDT and ensuring calculations involving it are representative.
• **Controlled Minting**: Provides flexible minting capabilities crucial for setting up diverse testing scenarios:
  • `MAX_MINT_PER_TRANSACTION`: A constant (e.g., 1,000,000 USDT) to prevent accidental minting of excessive amounts in a single public transaction.
• **Test Environment Focus**: Enables rigorous testing of Zenova's economic model, trading mechanics, and fee collection without risking real assets.

Key Functions:

Events & Errors:

• **Events**: `TokensMinted`, `BulkTokensMinted` to log minting activities.
• **Custom Errors**: `USDTMock__ZeroAddress`, `USDTMock__ZeroAmount`, `USDTMock__ExceedsMaxMint`, `USDTMock__ArrayLengthMismatch`, `USDTMock__InvalidArrayLength` for clear revert reasons.

The Zenova AI Agent: Autonomous Platform Orchestrator

At the heart of Zenova's autonomous operations is the **Zenova AI Agent**, defined in `src/mastra/agents/ZenovaAgent.ts`. This sophisticated agent, built using the Mastra SDK, is responsible for intelligent decision-making, smart contract interactions, and overall platform management. It embodies the `AI_ROLE` discussed in the smart contracts.

Core Technologies:

Key Responsibilities & Workflow:

• Company Onboarding & Valuation:

  Guides companies through data submission. Performs rigorous due diligence using its analytical capabilities and the `tavilySearchTool` to verify information, analyze market comparables, and identify risks. Adopts a conservative approach to determine fair valuation and initial token price (in USDT), then uses `zenovaFactory_submitCompanyValuationTool`.

• Zenova Asset Creation:

  Post-valuation, the same AI agent is solely authorized to create the `ZenovaAsset` using `zenovaFactory_createZenovaAssetTool`. The agent automatically receives the `AI_ROLE` and admin control over the new asset. Critically, it immediately activates trading for the new asset using `zenovaAsset_activateTradingTool`.

• Autonomous Asset Management:

  Continuously manages live assets. This includes updating token prices (`zenovaAsset_updatePriceTool`), adjusting liquidity parameters like fees (`zenovaAsset_updateLiquidityParamsTool`), managing trading states (defaulting to active), withdrawing fees (`zenovaAsset_withdrawFeesTool`), and handling critical situations with `pause/unpause` tools.

• User Interaction & Information Provision:

  Serves as the primary interface for user queries about the platform, companies, or specific assets. Utilizes a suite of getter tools for both the Factory and individual Assets to provide accurate, on-chain information.

Operational Principles:

The agent operates under strict guidelines defined in its instruction set:

• **Precision & Transparency**: Reflects Zenova's core values in all interactions.
• **Conservative Valuation**: Prioritizes realistic, evidence-backed valuations over speculation.
• **AI-Driven Automation**: Manages the platform with minimal human intervention.
• **Contextual Awareness**: Leverages its memory system with a structured working memory template (tracking user profiles, company onboarding status, platform interactions, and internal operational notes) for coherent and informed interactions.

The Zenova AI Toolkit: Empowering Autonomous Operations

The Zenova AI Agent is equipped with a comprehensive suite of tools, located in `src/mastra/tools/`, to interact with the Zenova smart contracts, external services, and manage data. These tools are essential for its autonomous operation and decision-making processes. They are built using `createTool` from `@mastra/core` and often use Zod for schema validation.