> For the complete documentation index, see [llms.txt](https://hello-fun-1.gitbook.io/hello.fun-docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://hello-fun-1.gitbook.io/hello.fun-docs/architecture.md). # Architecture ## Architecture Hello.Fun combines onchain smart contracts with offchain infrastructure, HELLO Intelligence products and a web interface. The core launch, trading, graduation, fee and liquidity mechanics operate through smart contracts on Robinhood Chain. Supporting infrastructure indexes blockchain activity, stores market data and serves that information to the Hello.Fun interface. HELLO Intelligence adds an application layer around this foundation for AI powered creation, discovery, analysis, monitoring and other intelligence experiences. ### Architecture Overview Hello.Fun can be viewed as four primary layers: ```mermaid flowchart TD A["Hello.Fun Interface"] --> B["HELLO Intelligence"] A --> C["Backend and Data Infrastructure"] A --> D["Smart Contracts"] B --> C B --> A C --> A D --> E["Robinhood Chain"] D --> F["Uniswap v4"] E --> C F --> C ``` Each layer has a different responsibility. ### Smart Contract Layer The smart contract layer controls the core onchain mechanics of Hello.Fun. This includes: * Token creation * Launch registration * Bonding curve trading * Pair configuration * Graduation * Uniswap v4 pool creation * Liquidity locking * Trading fees * Creator fee accounting * Fee claims User funds involved in these processes are handled through the smart contracts rather than through the Hello.Fun backend. ```mermaid flowchart TD A["User Wallet"] --> B["Hello.Fun Smart Contracts"] B --> C["Token Launch"] B --> D["Bonding Curve"] B --> E["Graduation"] E --> F["Uniswap v4"] F --> G["Permanent Liquidity Locker"] ``` ### Robinhood Chain Hello.Fun is deployed on Robinhood Chain mainnet. The network uses: * **Chain ID: 4663** * **Native asset: ETH** Users interact with Hello.Fun using wallets connected to Robinhood Chain. For standard wallet controlled interactions, state changing actions require authorization through the user's wallet. ### Frontend The Hello.Fun frontend is the interface users interact with. It allows users to: * Connect a wallet * Create a token * Select an available pair * Configure a launch * Use supported HELLO Intelligence experiences * Buy and sell * View token markets * Explore launches * View market activity * Claim eligible creator earnings The frontend does not take custody of user wallets or private keys. When a standard user initiated onchain action is required, the user's wallet signs the transaction. ```mermaid sequenceDiagram participant U as User participant F as Hello.Fun participant W as Wallet participant C as Smart Contracts U->>F: Choose action F->>W: Prepare transaction W->>U: Request signature U->>W: Sign W->>C: Submit transaction C-->>W: Onchain result W-->>F: Updated state ``` ### HELLO Intelligence Layer HELLO Intelligence sits around the core Hello.Fun market infrastructure. It is designed as a suite of focused AI powered products rather than a replacement for the underlying protocol. ```mermaid flowchart TD A["Hello.Fun"] --> B["HELLO Intelligence"] B --> C["HELLO Pilot"] B --> D["HELLO Paws"] B --> E["HELLO Lens"] B --> F["HELLO Mate"] B --> G["The Scout"] B --> H["HELLO Match"] B --> I["Say Hello"] ``` Different products can use different combinations of project information, market information, user input and other available data depending on their purpose. HELLO Intelligence can help users create, discover, analyze, ask, watch, connect and understand. The underlying launch and market mechanics continue to operate through the Hello.Fun protocol. ### HELLO Pilot HELLO Pilot provides an AI assisted route through token creation. Pilot can help prepare a launch, but the creator remains responsible for reviewing the final configuration. The launch is approved through the creator's wallet before it is submitted onchain. ```mermaid flowchart LR A["Creator"] --> B["HELLO Pilot"] B --> C["Prepared Launch"] C --> D["Creator Review"] D --> E["Wallet Approval"] E --> F["Hello.Fun Contracts"] ``` Pilot therefore assists with preparation while the existing wallet authorization model remains intact. ### Autonomous Products Some future HELLO Intelligence products are designed for explicitly authorized autonomous activity. HELLO Paws, for example, is designed to operate according to rules configured by the user and to use a separately funded wallet when executing permitted autonomous launches. This is different from the standard Hello.Fun interaction model where a user manually approves an individual transaction through their connected wallet. ```mermaid flowchart TD A["User"] --> B["Define Rules"] A --> C["Fund Operating Wallet"] B --> D["Authorized Autonomous Product"] C --> D D --> E["Permitted Action"] E --> F["Hello.Fun Smart Contracts"] ``` Autonomous functionality does not change the underlying Hello.Fun smart contract mechanics. It changes how an authorized transaction can be initiated. ### Backend Infrastructure Hello.Fun also operates offchain infrastructure for reading, organizing and serving blockchain data. The backend supports the user experience but does not control the onchain launch system. Its primary responsibilities include: * Reading indexed blockchain activity * Organizing market data * Serving data to the frontend * Managing token metadata submissions * Providing realtime updates * Supporting application level experiences The standard Hello.Fun backend does not take custody of user funds or independently initiate ordinary user trades. ### Data Indexing Blockchain events generated by Hello.Fun markets are indexed and stored so that the interface can present useful market information. ```mermaid flowchart LR A["Robinhood Chain"] --> B["Blockchain Events"] B --> C["Hello.Fun Indexer"] C --> D["Market Database"] D --> E["Hello.Fun API"] E --> F["Hello.Fun Interface"] ``` This indexed data powers information including: * Price * Market capitalization * Trading volume * Liquidity * Holders * Transactions * Charts * Pair information The market data shown through Hello.Fun is derived from indexed blockchain activity. ### Data and Intelligence HELLO Intelligence can build on information available through the wider Hello.Fun ecosystem. The distinction between underlying data and AI generated intelligence remains important. ```mermaid flowchart LR A["Indexed Market Data"] --> C["Hello.Fun Experience"] B["Project Information"] --> C A --> D["HELLO Intelligence"] B --> D D --> E["AI Generated Intelligence"] E --> C ``` Indexed market data represents information derived from blockchain activity. AI generated scores, summaries, insights, answers and signals are interpretation layers built around available information. ### Metadata Infrastructure Token metadata is prepared before a launch. This can include: * Token name * Symbol * Description * Image * Website * X * Telegram Hello.Fun provides infrastructure for handling this metadata before the launch transaction. The resulting metadata reference is written into the token when it is created. That reference is immutable after launch. ### Realtime Updates Hello.Fun also provides realtime infrastructure for pushing new market information to the interface. ```mermaid flowchart LR A["Onchain Activity"] --> B["Indexer"] B --> C["Database"] C --> D["Realtime Service"] D --> E["Hello.Fun Interface"] ``` This allows the interface to reflect new activity as markets change. ### Uniswap v4 Integration Hello.Fun integrates with Uniswap v4 for graduated markets. The platform uses the Uniswap v4 deployment available on Robinhood Chain rather than operating a separate fork of the exchange infrastructure. ```mermaid flowchart LR A["Hello.Fun Bonding Curve"] --> B["Graduation"] B --> C["Uniswap v4 Pool"] C --> D["Permanent Liquidity"] C --> E["Open Market Trading"] ``` When a launch graduates, Hello.Fun creates and seeds its Uniswap v4 market through the protocol's graduation infrastructure. ### Onchain and Offchain Responsibilities The distinction between onchain and offchain components is important. | Onchain | Offchain | | -------------------------- | ------------------------------ | | Token creation | Interface | | Bonding curve trading | Market indexing | | Graduation | Market database | | Uniswap v4 market creation | Realtime updates | | Liquidity locking | Metadata preparation | | Fee accounting | HELLO Intelligence experiences | | Fee claims | AI generated intelligence | The offchain infrastructure helps users see, understand and interact with Hello.Fun. The smart contracts determine the onchain state. ### User Controlled Transactions Standard Hello.Fun interactions follow a wallet signed model. ```mermaid flowchart LR A["User"] --> B["Wallet Signature"] B --> C["Robinhood Chain"] C --> D["Hello.Fun Contracts"] ``` The user's wallet remains the authorization point for ordinary user initiated state changing actions. Future products that support autonomous execution operate through separately authorized mechanisms defined for those products rather than silently taking control of the user's connected wallet. ### Non Upgradeable Contracts The deployed Hello.Fun contracts are non upgradeable. They do not use a proxy architecture that allows the underlying contract logic to be replaced after deployment. ```mermaid flowchart LR A["Contract Deployment"] --> B["Fixed Contract Logic"] B --> C["Onchain Operation"] ``` This means the deployed contract logic does not rely on an upgrade mechanism controlled by Hello.Fun. ### How the Layers Work Together The complete architecture can be summarized as: ```mermaid flowchart TD A["User"] --> B["Hello.Fun Interface"] B --> C["HELLO Intelligence"] B --> D["Read Market Data"] B --> E["Prepare Onchain Action"] C --> F["Project and Market Information"] D --> G["Hello.Fun Data Infrastructure"] G --> H["Indexed Blockchain Data"] E --> I["User Wallet"] I --> J["Hello.Fun Smart Contracts"] J --> K["Robinhood Chain"] J --> L["Uniswap v4"] K --> H L --> H H --> F F --> C ``` The interface provides access. The data infrastructure provides indexed information. HELLO Intelligence provides AI powered assistance and interpretation. The wallet provides authorization for standard user initiated transactions. The smart contracts provide execution. Robinhood Chain provides settlement. Uniswap v4 provides the graduated market infrastructure. Together, these components form the technical foundation of Hello.Fun and the intelligence products being built around it. --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation by asking a question. Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters: ``` GET https://hello-fun-1.gitbook.io/hello.fun-docs/architecture.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.