# Introduction to HeLa Introducing HeLa Blockchain **HeLa Chain** is a next-generation Layer-1 blockchain purpose-built to solve the limitations of legacy blockchains and power real-world adoption across both Web2 and Web3 sectors. From gaming and DeFi to DePIN and enterprise use cases, HeLa is designed to be the foundational layer that unites performance with usability. HeLa’s **modular architecture** separates concerns across multiple specialized layers, ensuring high performance, enhanced flexibility, and easier innovation. * The **Execution Layer** manages smart contract execution and state transitions. * The **Consensus Layer** secures the network and ensures deterministic finality. * The **Guardian Layer** adds an additional layer of integrity and network accountability. * The **AI Layer** opens the door for intelligent contract interactions and protocol-level reasoning in real time. This separation ensures that each component can evolve independently, enabling future upgrades without disrupting the ecosystem. HeLa’s modular stack is designed to evolve alongside emerging technologies. Whether you're building Web2 integrations with on-chain logic or native Web3 apps, HeLa provides the flexibility and throughput required for production-grade applications. As needs change, HeLa adapts—making it an ideal foundation for everything from enterprise deployments to decentralized ecosystems.

HeLa Chain Deployment Layers


# Why do we need? HeLa is a modular, EVM-compatible Layer 1 blockchain purpose-built for advanced use cases that require privacy, multichain interoperability, and scalable computation. It enables developers to build more powerful applications without having to compromise on performance, security, or flexibility. Key capabilities include: * **EVM-Compatible Smart Contracts**: Developers can deploy and interact with smart contracts using existing Ethereum-based tools and languages, such as Solidity, Hardhat, and Foundry. * **Privacy-Preserving Computation**: Through trusted execution environments (TEEs), developers can build applications that require confidential logic, including privacy-enabled DeFi, identity systems, or AI-powered dApps. * **Resource-Efficient Execution**: The modular architecture supports scalable parallel execution, making it suitable for high-throughput applications with predictable performance. ## **Why would I use HeLa?** HeLa is designed for developers who are building beyond traditional smart contracts and require a robust, forward-compatible infrastructure. It brings together three core features, modular design, cross-chain interoperability, and privacy-first computation , in a single environment. Reasons to build on HeLa: * **Modularity:** HeLa’s modular architecture separates key layers—consensus, execution, asset integration, and storage—delivering unmatched flexibility and scalability. This design enables effortless customization and upgrades while maintaining system integrity. * One Stable Token: HeLa uses a singular stablecoin, HLUSD, as the native gas token. By anchoring fees to a stable asset, we ensure predictable transaction costs, a critical step for real-world adoption and long-term network stability. * **Developer-Centric Tooling**: Continue using the Ethereum development stack, while unlocking additional capabilities through HeLa-specific SDKs and APIs. * **Asset Integrity :** The modular asset integration layer allows for seamless integration of diverse assets across different runtimes, ensuring efficient and flexible asset management. * **Scalability and Performance**: The modular execution layer allows for efficient handling of workloads, reducing bottlenecks and improving transaction throughput. * **Decentralized Digital Identity (DID) :** HeLa’s advanced DID management system gives users precise control over their digital identity, ensuring transparency and accountability across the network. * AI Agent Tokenization: HeLa provides the infrastructure to tokenize AI agents, making them portable, composable, and usable across chains. This allows developers and users to securely interact with AI agents while leveraging interoperability and privacy features of HeLa * **Security:** With a robust consensus protocol and a professional validator network, HeLa prioritizes security, protecting the ecosystem from vulnerabilities and ensuring a safe environment for all participants. HeLa is particularly suited for developers working on cross-chain DeFi protocols, privacy-preserving identity systems, AI-enhanced dApps, and other complex applications that require more than basic L1 functionality. ## **What is the difference between HeLa and other L1s?**
## **What about HeLa’s energy consumption?** HeLa is committed to energy efficiency and sustainable blockchain design. The network is built on principles that reduce computational waste and improve energy utilization. * **Proof-of-Stake Consensus**: HeLa uses a PoS-based consensus mechanism, which eliminates the high energy demands typically associated with Proof-of-Work systems. * **Computation Offloading**: By separating onchain execution from heavy offchain compute (e.g., AI inference), HeLa ensures that computational resources are used where they are most efficient. * **Modular Architecture**: The separation of execution, consensus, and data availability layers allows the system to scale without centralizing workload or consuming unnecessary power. * **Parallel Execution**: HeLa’s design supports concurrent transaction processing, further improving throughput without increasing energy overhead. This architecture not only ensures minimal environmental impact but also supports the scalability required for future-ready applications.\
# Consensus Mechanism The **Consensus Layer** ensures that all participants in the Hela network agree on the same history of transactions. In other words, it defines *what actually happened* and guarantees finality. Hela currently leverages **Tendermint Core**, a proven **Byzantine Fault Tolerant (BFT)** consensus engine that is fast, secure, and production-tested across multiple blockchains. Combined with **Proof of Stake (PoS)**, this design enables high throughput, instant finality, and strong security guarantees. ### What is Tendermint Core? **Tendermint Core** is a consensus engine that solves one of the hardest problems in distributed systems: > “How can thousands of computers agree on the same data, even if some of them are faulty or malicious?” This is known as the **Byzantine Generals Problem**. Tendermint achieves **Byzantine Fault Tolerance (BFT)**, meaning the system can keep running and reach agreement **as long as less than 1/3 of the validators are dishonest or offline**. ### **How It Works** 1. **Validators Join by Staking HELA:** Validators are like referees. To join, they lock up HELA tokens (stake). Only qualified entities (those who have passed requirements like KYC) can become validators. 2. **Delegators Support Validators:** Not everyone has to run a validator node. Regular users can delegate their HELA tokens to validators. In return, they earn a share of the validator’s rewards. 3. **Block Proposals & Voting:** Validators take turns proposing new blocks of transactions. The other validators vote to approve or reject. Once more than two-thirds agree, the block is finalized instantly. 4. **Incentives & Penalties:** * Honest validators earn **rewards in HELA tokens**. * Misbehaving validators (e.g., going offline, double signing, or trying to cheat) face **slashing** losing part of their stake. This balance of rewards and penalties ensures validators act in the best interest of the network. ### **Key Properties of Tendermint on Hela** 1. **Instant Finality** Transactions are considered final as soon as they are included in a block. Unlike Bitcoin or Ethereum (PoW era), there is no need to wait for multiple block confirmations. 2. **Fault Tolerance** * The system can handle up to **33% of validators misbehaving** without halting. * If more than one-third act maliciously, consensus safety is threatened. 3. **Slashing & Accountability** Validators who act against protocol rules (e.g., double-signing, prolonged downtime) can be **slashed**, losing part of their staked tokens. This ensures honesty and reliability. 4. **Modularity** The **Consensus Layer** is separate from the **Execution Layer**. This separation means Hela can upgrade consensus or execution independently without disrupting the whole chain. ### **Consensus Roles in Hela** * **Validators:** * Run consensus nodes. * Propose and validate blocks. * Earn rewards for honest behavior. * **Delegators:** * Stake HELA by delegating to validators. * Share in validator rewards. * Help promote decentralization by choosing diverse validators.\ \
# What is HLUSD? HLUSD, the synthetic dollar of HeLa Chain, plays a crucial role in facilitating seamless and efficient transactions within the ecosystem. As a synthetic dollar backed by a basket of assets, HLUSD ensures a redemption of 1 USD, providing users with a stable and reliable means of value exchange. The stability and predictability of HLUSD are achieved through its backing with assets held in secure custody. This rigorous custodial arrangement ensures transparency and trust, assuring users that their HLUSD holdings are fully backed and secure. ## Properties
FieldValue
NameHeLa Synthetic Dollar
SymbolHLUSD
Peg1 HLUSD = 1 USDC
BackingFully backed by custodial USDC
UsageGas fees, contract execution
CustodyRegulated custodians
### Multi-Currency Extension HeLa supports additional stablecoins: * HLEUR (Euro) * HLSGD (Singapore Dollar) * HLINR (Indian Rupee) Any of the above may be used to pay network fees in supported regions. > Note : This extension is not yet available. However, the team is actively working on extending support, and a multi-currency module is planned for future releases. ### Developer Quick Start * HLUSD is only enforced for **HeLa official runtimes**. * Third-party runtimes may: * Define their own native tokens. * Override fee currency denomination. * HLUSD smart contract interface follows the ERC-20 standard with extensions for fee integration. Overall, HLUSD stands as a foundational pillar of the HeLa Chain, providing a robust and reliable stable coin solution. With its backing of 1 USD for every HLUSD, safeguarded by a regulated custodian, and its integral role in powering all transactions, HLUSD exemplifies the commitment of HeLa Chain to offer a user-friendly and secure blockchain platform that bridges the gap between traditional finance and the decentralized world. ### Next Steps for Developers * [How to Get HLUSD Test Tokens](/network-endpoints-and-explorer/images-and-media) * [Paying Gas Fees with HLUSD ](/build-on-hela/estimate-gas) # Benefits of HLUSD HLUSD is an **asset-backed synthetic dollar** designed for stability, compliance, and usability within the **HeLa Chain ecosystem**. Unlike volatile native cryptocurrencies, HLUSD ensures **1:1 redemption with USD** and is governed under **regulated financial oversight**. This makes HLUSD not just a stablecoin, but a **core enabler of HeLa Chain’s unique design** all gas fees on HeLa Chain are paid in HLUSD. **Moreover, by holding HLUSD, projects and dApps unlock a 4% airdrop, a token of appreciation for supporting and growing the HeLa ecosystem** ## Key Features #### 1. **Asset-Backed Stability** * HLUSD is fully backed by **USDC reserves**. * Reserves are managed by a **licensed financial institution in Australia**. * Users can redeem **1 HLUSD = 1 USD** at any time. This ensures **predictability and trust**, removing the risks of price swings common in native cryptocurrencies. #### 2. **Regulatory Governance** * Managed under **strict regulatory frameworks**. * Oversight ensures transparency, user protection, and financial compliance. * Audited reserve holdings further **increase trust** in HLUSD. #### 3. **HLUSD as the Gas Token** Unlike most blockchains where fees are paid in volatile native tokens (e.g., ETH, SOL), **HeLa Chain uses HLUSD for all gas fees**. **Benefits:** * **Predictable fee calculation** → developers can estimate costs in dollars. * **Simplified onboarding** → Web2 projects transitioning to Web3 don’t need to manage multiple tokens. * **No need for multiple wallets/coins** → one stable token (HLUSD) powers all interactions. #### 4. **Developer & User Benefits** #### For Users: * Shielded from volatility. * Can transact across dApps with just **one stable token**. * Smooth user experience without juggling multiple coins. #### For Developers & Businesses: * **Lower integration friction** for Web2 enterprises. * Predictable fee structures for **dApp economics & scaling**. * Easier to explain to mainstream users ("Pay your blockchain fees in dollars"). ### Use Cases of HLUSD * **Transaction Fees** → HLUSD is the exclusive token for gas payments on HeLa Chain. * **Stable Transactions** → Peer-to-peer transfers, commerce, and cross-border payments. * **Institutional Adoption** → Businesses can use HLUSD without worrying about crypto volatility. ### Why HLUSD Matters in HeLa Chain By embedding stability directly into the **core of the protocol layer**, HLUSD: * Eliminates volatility from transaction costs. * Bridges **Web2 familiarity with Web3 innovation**. * Makes HeLa Chain a **developer- and institution-friendly L1**. In short, HLUSD is not “just another stablecoin.” It’s the **foundation of user experience and adoption** on HeLa Chain. ### Next Steps for Developers * [How to Get HLUSD Test Tokens](/network-endpoints-and-explorer/images-and-media) * [Paying Gas Fees with HLUSD \
](/build-on-hela/estimate-gas) # Stablecoin Governance HLUSD Stablecoin Governance HeLa introduces **HLUSD**, a stablecoin with **on-chain governance** to ensure transparency, decentralization, and community-driven decision-making. This document explains how governance works, what roles exist, and how developers can interact with the governance system. Most stablecoins today are governed **centrally** (by one company or team). HeLa changes this with a **decentralized voting system**, where decisions about minting, burning, whitelisting, blacklisting, and configuration are made **on-chain by multiple roles**. Key Features: * **On-chain proposals & voting** for all actions. * **Multiple roles** for checks and balances. * **Transparent process** (all actions recorded on-chain). * **Community insurance fund** as a safety net. Before you begin, please ensure that you have set up the command line wallet with the appropriate network and default account. ### Chain Initiator Chain Initiator is an HeLa address (`hela01qrmyx4d...`), hard-coded in `paratime/src/libs/chain_initiator` field. Its primary function is to initiate the chain roles, as defined below. Please note that the Chain Initiator can only be used once, and after initiation, the address will be set to that of a normal user. Subsequently, all roles management should be carried out through the propose-voting system. Currently, this action can only be executed via the command line using the following Command: ``` ./hela managest initowners [addr1 role1] [addr2 role2] ... ``` **Note** : Each address can only hold **one role**. If multiple roles are assigned, the **last one overrides** the previous. ### Roles : Roles define **who can propose** and **who can vote**. There are 12 kinds of roles defined in our system, which are as follows. | Role | Capabilities | | --------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Admin** | Only admin can `propose` and `vote` for all other roles and config the values for `mintQuorum`, `burnQuorum`, `whitelistQuorum`, `blacklistQuorum` and `configQuorum`. | | **MintProposer** | Both mint proposer and mint voter can propose to mint stable coins to a `WhitelistedUser` user. | | **MintVoter** | Only mint voter can vote the proposals from the `MintProposer`, and only the `mintQuorum` is reached, the `mint` action can take effect. | | **BurnProposer** | Both burn proposer and burn voter can propose to burn stable coins from a `WhitelistedUser` user. | | **BurnVoter** | Only burn voter can vote the proposals from the `BurnProposer`, and only the `burnQuorum` is reached, the `burn` action can take effect. | | **WhitelistProposer** | Both whitelist proposer and whitelist voter can propose addresses to be a `WhitelistedUser` user, but this proposed address should not be `BlacklistedUser` user | | **WhitelistVoter** | Only whitelist voter can vote the proposals from the `WhitelistProposer`, and only the `whitelistQuorum` is reached, the `whitelist` action can take effect. | | **BlacklistProposer** | Both blacklist proposer and blacklist voter can propose addresses to be a `BlacklistedUser`, but this proposed address can only be a normal `User`. | | **BlacklistVoter** | Only blacklist voter can vote the proposals from the `BlacklistProposer`, and only the `blacklistQuorum` is reached, the `blacklist` action can take effect. | | **WhitelistedUser** | The `WhitelistedUser` can be the beneficiary address of minting and burning besides the functions of a normal user. | | **BlacklistedUser** | The `BlacklistedUser` can not send any transactions to change the state of the specific runtime, even query. | | **User** | Normal users can exercise general functions provided by our system, like transferring money, deploying smart contracts etc. | **Update:** All the voters' role can also raise proposals as proposers'. ### 3. Action The governance system supports **6 on-chain actions**. Each action is submitted as a **proposal** in JSON format, then voted on. #### a) SetRoles `SetRoles` action allows `Admin` to propose a role to some address, the proposal is like the following which should follow the json format (the role is in the snake manner, e.g., mint\_proposer, mint\_voter, burn\_proposer, whitelist\_proposer, blacklist\_proposer, whitelisted\_user etc.). ``` { "action": "setroles", "data": { "address": "hela01qq3slqgrp55hshh7znra4j9dskjvy55n6crgf0lk", "role": "admin" } } ``` #### b) Mint **Mint** `Mint` action allows `MintProposer` to propose minting specific amount `5000000000000000` to a `WhitelistedUser`. ``` { "action": "mint", "data": { "address": "hela01qrfp4gltu9h5433zm434mtvzezsrj3uytqts2x6x", "amount": "5000" } } ``` Note: HLUSD has 18 decimals. or the exponent for the runtime is 18, which means 1 HLUSD = 10^18 base units. #### c) Burn `Burn` action allows `BurnProposer` to propose burning specific amount `5000000000000000` from a `WhitelistedUser`. The proposal json file is similar with the Mint one. #### d) Whitelist `Whitelist` action allows `WhitelistProposer` to propose whitelisting some address. ``` { "action": "whitelist", "data": { "address": "hela01qrfp4gltu9h5433zm434mtvzezsrj3uytqts2x6x" } } ``` #### e) Blacklist `Blacklist` action allows `BlacklistProposer` to propose an address with a normal `User` role to be a `BlacklistedUser`. The proposal json file is similar with the Whitelist one. #### f) Config **Config** `Config` action allows `Admin` to propose new values for `mintQuorum`, `burnQuorum`, `whitelistQuorum`, `blacklistQuorum` and `configQuorum`, at least one value is required in the data field, otherwise, this proposal will be declined. ``` { "action": "config", "data": { "mint_quorum": 90, "burn_quorum": 90, "blacklist_quorum": 90, "config_quorum": 90 } } ``` ## Proposal and Voting ### Propose: All proposals can be made with the following command: ```bash ./hela managest propose proposal.json ``` View proposals: After the proposal is broadcast, the users can show the proposals with the command: ```bash ./hela managest show [number] ``` By default, the latest proposal will be displayed if the `[number]` is left blank. ### Vote: The voters with the specific role can vote proposals with the following command: `./hela managest vote [proposal ID] [options]`. Each proposal gets a unique ID, which can be found by the `./hela managest show [number]`command. The `[options]` field can be `yes`, `no` or `abstain`. Rules: * Only correct role holders can vote. * Proposal passes if quorum (threshold %) is reached. * \[ Update ] Voters can not vote for the same proposal many times. ```bash ./hela managest vote [proposalID] [yes|no|abstain] ``` The users can look up the vote result by the same `./hela managest show [number]` command, where the latest result of the voting is shown in the `Results` row. *** ## Insurance on HeLa Chain HeLa also creates a **community-controlled insurance fund** to protect users from unexpected disasters (like hacks). #### How it works: * Every time you pay a transaction fee, **90% goes to compute nodes**, and **10% goes into the insurance fund**. * The fund is governed by the **HeLa DAO (community)**. * In case of a loss event: * A **community proposal** can be submitted to use funds. * If passed, funds can **compensate affected users**. **This adds an extra layer of protection for everyone** using HeLa. ### Countermeasure to Stablecoin Devaluation What if Stablecoins Lose Value? Here’s a real problem, **fiat-backed stablecoins** like HLUSD are pegged to dollars, but dollars **lose value over time** due to inflation. This creates two issues: * Compute nodes receive **less real-world value** over time. * Insurance fund assets slowly **devalue**. ### HeLa's Fix : The **HeLa DAO** can **vote to adjust transaction fees** over time. * If HLUSD becomes weaker, fees can be **raised** slightly to keep node rewards fair. * This helps maintain a balance between **cost for users** and **incentives for validators**.\
# Minting/Redemption of HLUSD Trading of HLUSD Let's look at the minting and redemption of HLUSD, the synthetic dollar of HeLa Chain. **Centralized Exchange (CEX)** * **Biconomy**: [Trade HLUSD/USDT](https://www.biconomy.com/exchange/HLUSD_USDT) **Decentralized Exchange (DEX)** * **Cytoswap**: [Trade on Cytoswap](https://cytoswap.com/) Choose the platform that best fits your trading preferences. *** ## Stablehodl StableHODL is a **stablecoin yield generation platform powered by HeLa Network**. The protocol leverages **delta neutral portfolio** to optimize returns and generates sustainable yields, rewarding stakers with **HLUSD/USDC/USDT.**
* **Stable-to-Stable Earning:** Users stake stablecoins (HLUSD/USDT/USDC) and earn yield in HLUSD * **No Volatility Risk:** Provides liquidity in stablecoins, the "fiat" of crypto * **Accessible Design:** No minimum amount required, user-friendly UI for all users * **Substained Yield:** Through a delta-neutral mechanism, balancing risk and maintaining stable returns regardless of underlying price movements.\
# Network Endpoints and Explorer Here is the HeLa Network information for developers to efficiently configure and deploy their applications on HeLa's testnet and mainnet. ### **Network Endpoints** Connect to HeLa networks using the following endpoints. You can add these networks to your wallet by clicking the "Add to Wallet" button or manually entering the details.
**HeLa Testnet (General Purpose Testnet) :** | Network Name | HeLa Testnet | | -------------- | ------------------------------------------------------------------------------------------- | | RPC | [https://testnet-rpc.helachain.com](https://testnet-rpc.helachain.com/) | | Chain ID | 666888 | | SYMBOL | HLUSD | | Block Explorer | [https://testnet-blockexplorer.helachain.com](https://testnet-blockexplorer.helachain.com/) | **HeLa Mainnet:** | Network Name | HeLa Official Runtime | | -------------- | ----------------------------------------------------------------------- | | RPC | [https://mainnet-rpc.helachain.com](https://mainnet-rpc.helachain.com/) | | Chain ID | 8668 | | SYMBOL | HLUSD | | Block Explorer | | ## HeLa Explorer : The HeLa Explorer allows you to view transactions, accounts, and other blockchain data. Use the explorer to verify transactions, check account balances, and explore the HeLa network. ### **Explorer URLs** * **HeLa Testnet (General Purpose Testnet) :** [https://testnet-blockexplorer.helachain.com](https://testnet-blockexplorer.helachain.com/) * **HeLa Mainnet :** ### Explore Features : #### **Transaction Overview** The explorer provides general details for transactions, including sender, receiver, amount, gas used, and timestamps.
#### **Account Data** Select an account on the HeLa Explorer to see all the details for that account, including balance, transaction history, gas used and more.
# Testnet Faucet (HLUSD) HLUSD Faucet The HLUSD (HeLa Stable Coin) Faucet is a valuable tool designed for use on the HeLa testnet. As a stable coin, HLUSD ensures a 1-to-1 peg with USD, providing stability for testing purposes. The faucet allows users to easily acquire HLUSD tokens for testing their applications and transactions on the HeLa testnet. By providing a convenient source of HLUSD tokens, the faucet enables developers to experiment, simulate real-world scenarios, and validate their projects without the need for actual funds. With the HLUSD Faucet, testing on the HeLa testnet becomes a seamless and efficient process, empowering developers to fine-tune and optimize their applications with confidence. {% hint style="info" %} You can get some HLUSD for testnet here: {% endhint %} {% hint style="info" %} HELA smart contact address should be : 0xBE75FDe9DeDe700635E3dDBe7e29b5db1A76C125 {% endhint %} **Note:** The above mentioned HeLa token contract address is utilized within the Execution Layer.\ \ \ \
# HeLa Scanner With HeLa Blockscanner, users can easily verify their transactions on both the testnet and mainnet. The scanner is designed to provide comprehensive insights into the HeLa blockchain's consensus layer and runtime activities. Whether you're testing transactions during development or conducting real-world transactions, HeLa Blockscanner empowers users with a transparent view of their transaction statuses and the overall network activity. Rest assured, with HeLa Blockscanner, you can confidently track and verify your transactions on both the testnet and mainnet with ease. | Testnet Scanner | | | --------------- | ---------------------------------------------- | | Mainnet Scanner | | \
# HeLa Architecture Hela is a modular blockchain protocol composed of **four primary layers**: 1. **Consensus Layer** – Secures the network and finalizes transactions. 2. **Execution Layer** – Processes user transactions and applications. 3. **Integration Layer** – Enables cross-runtime and cross-chain interoperability. 4. **Storage Layer** – Guarantees data availability and integrity. This layered design separates concerns, ensuring scalability, security, and flexibility for future upgrades. ### 1. Consensus Layer The Consensus Layer ensures **agreement on the canonical state** of the blockchain. Hela currently leverages the **Tendermint Byzantine Fault Tolerant (BFT) consensus protocol**, providing fast finality and resilience against malicious behavior. #### Responsibilities * Finalize transactions into canonical blocks. * Enforce validator participation rules and slashing conditions. * Maintain liveness and safety of the network even in adversarial settings. #### Key Properties * **Instant Finality**: Transactions are finalized in one block (no need for multiple confirmations). * **Fault Tolerance**: Secure against up to **1/3 malicious or faulty validators**. * **Slashing**: Validators engaging in double-signing, downtime, or other misbehavior are penalized. * **Delegated Proof of Stake (DPoS)**: Non-validator token holders (delegators) can delegate stake to validators and earn rewards, ensuring power is not concentrated. #### Security Considerations Validators act as referees of the system. Misbehavior is disincentivized through slashing and possible removal from the validator set. ### 2. Execution Layer The Execution Layer is responsible for **processing transactions and executing application logic**. It is modular and runtime-based, allowing different types of applications to run in isolated environments. #### Responsibilities * Execute smart contracts and application logic. * Maintain runtime-specific state machines. * Support confidential and public applications. #### Structure * **Runtimes (ParaTimes)**: Independent execution environments (mini blockchains) on top of consensus. * Each runtime has: * Its own **state machine** (rules and logic). * **Compute nodes** (to process transactions). * Isolated application environments. #### Execution Flow 1. User submits a transaction to a runtime. 2. Compute nodes process the transaction and update local state. 3. Results + new state are bundled into a block. 4. Block is submitted to the **Consensus Layer**. 5. Consensus finalizes and stores the block in the canonical chain. #### Security Considerations * Compute nodes must **stake HeLa tokens** to participate. * Malicious or incorrect execution leads to **slashing**. * Separation of consensus and execution layers allows independent upgrades. ### 3. Integration Layer The Integration Layer provides **secure interoperability** between runtimes and external chains. Unlike traditional “bridges,” Hela avoids moving assets physically; instead, it uses **message passing and abstraction of ownership**. #### Responsibilities * Enable **cross-runtime asset management**. * Provide **cross-runtime communication protocols**. * Support integration with external chains. * Offer privacy, identity, and other services “as-a-service” to external ecosystems. #### Key Innovations * **Abstracted Assets**: Tokens remain anchored in one place; ownership is virtually represented across runtimes. * **Cross-Runtime Protocols**: Enables interactions like “execute contract in runtime A, trigger action in runtime B.” * **Atomic Multi-Runtime Operations**: Supports cross-runtime flash loans, atomic swaps, and multi-contract workflows. #### As-a-Service Layer Other blockchains can leverage Hela’s integration layer for: * **Privacy-as-a-Service** * **Decentralized Identity (DID)-as-a-Service** * **Cross-chain execution logic** #### Security Considerations * Integration relies on the **Consensus Layer** for safety. * If consensus security is compromised, interoperability guarantees are weakened. ### 4. Storage Layer The Storage Layer ensures **data availability, redundancy, and integrity** across the network. It provides verifiable guarantees that all necessary data is stored, retrievable, and tamper-proof. #### Responsibilities * Store the full blockchain ledger and runtime states. * Ensure **data availability** for all participants. * Detect and prevent tampering or withholding attacks. #### Techniques Used * **Data Availability Sampling** * Nodes check random subsets of data to probabilistically ensure full availability. * **Erasure Coding** * Data is split and redundantly distributed, ensuring recoverability even if parts are lost. * **Merkle Trees** * Cryptographic structure for verifying data integrity. Even a single altered transaction can be detected. #### Security Considerations * Protects against **withholding attacks** where data is selectively hidden. * Ensures historical immutability and tamper resistance. ### Please Note : > At present, HeLa Chain does not maintain a dedicated integration layer as a separate architectural component. Instead, certain elements of the integration layer are embedded within the storage layer, functioning collectively as a unified system. > > While this design provides stability and efficiency in the current phase, our long-term roadmap includes the development of a fully independent integration layer. This planned separation will allow HeLa Chain to deliver advanced functionalities, improve modularity, and enable smoother interoperability across external ecosystems. > > By evolving towards a distinct integration layer, HeLa Chain aims to enhance scalability, streamline system operations, and unlock broader use cases for developers and applications building on the network. # HeLa Runtime (EVM) HeLa Chain adopts a **multi-layered architecture**, deliberately separating **consensus** and **runtime** functionalities into distinct layers. This design provides modularity, security, and scalability — ensuring that the consensus engine and execution environment operate independently but cohesively. At the core of this architecture lies the **HeLa Runtime Layer**, which has been purposefully engineered to be **EVM (Ethereum Virtual Machine) compatible**. This decision carries significant benefits for developers, projects, and the broader ecosystem. ### EVM Compatibility The **HeLa Runtime Layer** is fully **Ethereum Virtual Machine (EVM) compatible**. This compatibility is a deliberate design choice, enabling seamless integration with the vast developer and project ecosystem already established on Ethereum. #### Key Advantages 1. **Effortless Migration of Existing dApps**\ The primary motivation behind this compatibility is to enable the effortless deployment of existing EVM-based projects onto the HeLa Chain. A substantial portion of decentralized applications (dApps) are written in **Solidity**, the most widely used programming language for smart contracts on Ethereum. EVM compatibility allows these applications to be deployed on HeLa Chain with little to no modification, lowering friction for adoption. 2. **Faster Development Cycles**\ Developers can leverage their existing skillsets, frameworks, and workflows. This reduces onboarding time, shortens the development lifecycle, and accelerates the creation of new projects and use cases on HeLa Chain. 3. **Enhancing Existing dApps with HeLa Features**\ Beyond compatibility, developers can enrich their existing Ethereum-based dApps by integrating HeLa’s **unique platform-specific features**. This unlocks opportunities for creativity and innovation without requiring teams to abandon their established tools. ### Ecosystem Alignment By introducing an **EVM-compatible runtime layer**, HeLa Chain creates a familiar and accessible environment for Ethereum developers to transition and build upon. This alignment achieves two key outcomes: * **Welcoming Ethereum’s Global Developer Community**: The ecosystem can directly leverage the knowledge, resources, and momentum of one of the world’s largest blockchain developer bases. * **Accelerated Ecosystem Growth**: Lower entry barriers allow projects to deploy rapidly, driving experimentation, adoption, and the emergence of pioneering blockchain solutions. In effect, HeLa’s EVM compatibility not only ensures continuity with Ethereum but also positions the platform as a **hub of innovation**, bridging the established Ethereum ecosystem with the new opportunities available exclusively on HeLa. ## Block Production Specification This describes the block production behavior in the **Consensus Layer** and **Runtime Layer** of the chain, including timing, transaction handling, and epoch transition mechanics. ### 1. Consensus Layer * **Block Interval:** The consensus layer produces a block every **5 seconds**. * **Transaction Requirement:** Block production occurs **independently of transaction availability**. Empty blocks are finalized on schedule. * **Determinism:** This ensures a predictable and consistent chain growth rate of **\~12 blocks per minute**. ### 2. Runtime Layer The runtime layer executes state transitions and produces runtime blocks subject to the following rules: 1. **Block Frequency Constraint** * Runtime blocks **cannot be produced faster** than the consensus block interval (1 block / 5s). 2. **Transaction-Dependent Behavior** * **With transactions:** A runtime block is produced every 5s. * **Without transactions:** No runtime blocks are produced unless triggered by an epoch transition. ### 3. Epoch Transition * **Epoch Duration:** 600 consensus blocks. * **Nominal Epoch Length:** **50 minutes**. * **Observed Duration:** Due to propagation and scheduling delays, the effective duration is approximately **52 minutes**. During each epoch transition: * The runtime layer produces **two empty runtime blocks**, even in the absence of transactions. * These blocks are required to finalize **committee member updates** and ensure validator set correctness. Therefore, if there are continuous transactions, runtime layer generate block every 5 second. If no transactions, runtime layer generate 2 block every 52 minutes. # Estimate Gas When user engage with blockchains, their attention often goes to the coins, the contracts, the outcomes. But underneath all that, something subtle yet essential is always in motion: **gas**. Recently, Hela introduced a fundamental improvement to how gas fees work, one that not only corrects an old inefficiency but also significantly improves user experience. In this post, we’ll walk through what gas is, why it matters, how fees are calculated, and what Hela’s update has changed. ## **What are gas fees?** Gas is the **computational cost of doing anything on a blockchain**. Whenever you perform an action whether it’s transferring tokens, interacting with a smart contract, or minting an NFT you’re asking the network to process your request. That processing power isn’t free. Gas is the unit that measures how much effort it takes to complete your action. If you think of HeLa as a large computer network where people can do tasks like sending messages or running programs, gas is what keeps it running. Just like in the real world, these tasks require energy to get done. **Why do we need gas?** Gas is a critical element in keeping HeLa secure and processing transactions. Gas helps in many ways: * Gas keeps HeLa sybil-resistant by preventing malicious actors from overwhelming the network with fraudulent activities. * Because computation costs gas, spamming HeLa with expensive transactions, either accidentally and maliciously, is financially disincentivized. * A hard-limit on the amount of computation that can be done at any one time prevents HeLa from being overwhelmed, helping to ensure the network is always accessible. ## **How Are Gas Fees Calculated on Hela?** On HelaChain, gas fees are calculated using a simple formula: > Total Gas Fee (HLUSD) = Gas Used × Gas Price Here’s what each part means: * **Gas Used**: The actual amount of gas consumed by your transaction. * **Gas Price**: The cost you’re willing to pay per unit of gas, usually denominated in HLUSD. * **Gas Limit**: A user-defined cap the maximum amount of gas you’re allowing your transaction to consume. > Calculate unuse gas: Unuse gas = Gas Limit – Gas Used > > Create function refund unuse fee to sender: **Unuse Fee = Unuse gas x Gas Price** Before a transaction is executed, you set a Gas Limit and a Gas Price. The chain deducts your total fee *upfront* based on that limit. After execution, if less gas was used, the difference (unused gas) is refunded. ## **What Was the Problem with Refunds Before?** Hela’s earlier fee model had an asymmetry: * If your transaction **succeeded**, the unused gas was refunded as expected. * But if your transaction **failed**, all the gas even the part that wasn’t used was retained by the network. In other words, users were **penalized for failed transactions, regardless of how much computation was actually consumed.** This introduced an unnecessary penalty for users, particularly developers and curious explorers testing decentralized applications. Even if only a small portion of the gas was used before the transaction failed, the entire allocated fee was consumed. > success: use functions to add and sub amount when handle fee in many other functions. ```jsx ctx.value::(CONTEXT_KEY_FEE_ACCUMULATOR) .or_default() .sub(amount) .map_err(|_| modules::core::Error::InsufficientFeeBalance)?; Self::add_amount(ctx.runtime_state(), to, amount) .map_err(|_| modules::core::Error::InsufficientFeeBalance)?; ``` We knew this needed to change. ## What’s New: Gas Refunds for Both Success and Failure Our engineering team has implemented a key protocol improvement that ensures **unused gas is now refunded even when a transaction fails.** This change brings the gas accounting model in line with what’s fair and efficient: * The system now accurately tracks the **gas actually used**, whether a transaction succeeds or fails. * Any **remaining (unused) gas** is refunded by multiplying it with the gas price. * The refund is automatically credited back to the sender’s wallet. This update brings **symmetry and fairness** to how gas fees are treated, success or failure, you only pay for the computation that was actually performed. > with update version use function handle refund fee both success and fail result: ```jsx fn after_handle_call( ctx: &mut C, result: module::CallResult, ) -> Result { // Check whether unused part of the fee should be refunded. let refund_fee = if Self::take_refund_unused_tx_fee(ctx) { let remaining_gas = ::Core::remaining_tx_gas(ctx); let gas_price = ctx.tx_auth_info().fee.gas_price(); gas_price.saturating_mul(remaining_gas.into()) } else { 0 }; let mgr = ctx .value::(CONTEXT_KEY_FEE_MANAGER) .or_default(); // Update the per-tx fee accumulator. State must be updated in `after_dispatch_tx` as // otherwise any state updates may be reverted in case call result is a failure. mgr.record_refund(refund_fee); // Emit event for paid fee. let tx_fee = mgr.tx_fee().cloned().unwrap_or_default(); if tx_fee.amount() > 0 { ctx.emit_unconditional_event(Event::Transfer { from: tx_fee.payer(), to: *ADDRESS_FEE_ACCUMULATOR, amount: token::BaseUnits::new(tx_fee.amount(), tx_fee.denomination()), }); } Ok(result) } ``` Build more, explore contracts, and join the [HeLa Developer Discord](https://discord.gg/NEBtTztJCj) for help and ideas! # Build on Testnet ## **HeLa Chain Developer Quickstart Guide** If you have developed dApps on Ethereum or `any EVM compatible chain` before, you will feel at home. It is exactly the same. But if you are new, don’t worry, this document will help you embark on your first dApp development on HeLa chain. > **Please, keep in mind we currently only support 0.8.9 solidity version.** ### **Prerequisites** 1. **Remix IDE** * Open this in your browser: [https://remix.ethereum.org](https://remix.ethereum.org/)
2. **HeLa Testnet Wallet + Tokens** * Use MetaMask or any EVM wallet. * Add HeLa Testnet RPC: | Network name | HeLa Testnet | | -------------- | ------------------------------------------------------------------------------------------- | | RPC | [https://testnet-rpc.helachain.com](https://testnet-rpc.helachain.com/) | | Chain ID | 666888 | | SYMBOL | HLUSD | | Block Explorer | [https://testnet-blockexplorer.helachain.com](https://testnet-blockexplorer.helachain.com/) | * Get test tokens from the Faucet To fund your wallet with transaction gas fee, go to HeLa Testnet Faucet. You will receive 10 HLUSD every 24 hours. Claim HLUSD Testnet Faucet: [https://testnet-faucet.helachain.com](https://testnet-faucet.helachain.com/) 3. **Switch MetaMask to HeLa Testnet** ### Step 1: Write the Smart Contract We’ll start with a **Hello World Contract**. 1. Open Remix 2. Create a new file: `HelloHeLa.sol` 3. Paste this code: > **Please, keep in mind we currently only support 0.8.9 solidity version.** ```jsx // SPDX-License-Identifier: MIT pragma solidity ^0.8.9; contract HelloHeLa { string public message; constructor(string memory _msg) { message = _msg; } function setMessage(string memory _msg) public { message = _msg; } function getMessage() public view returns (string memory) { return message; } } ``` 4. Save it. ### Step 2: Compile the Contract 1. In Remix, go to the **Solidity Compiler** tab 2. Click **Compile HelloHeLa.sol** * If no errors, you’re good to go. ### Step 3: Deploy to HeLa Testnet 1. Go to **Deploy & Run Transactions** tab 2. Change Environment to `Injected Provider - MetaMask` (it will auto-connect your wallet) 3. Make sure MetaMask is set to **HeLa Testnet** 4. Under Contract, select `HelloHeLa` 5. Add `"Hello from HeLa!"` in the constructor input 6. Click **Deploy** 7. Approve the transaction in MetaMask **Your contract is now live on HeLa Testnet!** ### Step 4: Interact with Your Contract 1. After deploying, Remix will show a panel with your contract. 2. Click `getMessage` — it should return `"Hello from HeLa!"` 3. Try `setMessage("Welcome to HeLa")` 4. Call `getMessage` again to see the updated message. ### Step 5: Verify on HeLa Explorer (Optional) 1. Copy your contract address from Remix 2. Open Transaction and smart contracts can be observed and verfied in Testnet Block Explorer. 3. Paste the address and see your live contract Build more, explore contracts, and join the [HeLa Developer Discord](https://discord.gg/NEBtTztJCj) for help and ideas! # Deploy Smart Contracts with Remix In this tutorial, we’ll walk you through **creating and deploying a basic ERC-20 token dApp** on the HeLa testnet using **Remix IDE,** which is an open source web and desktop application that provides a fast development cycle with intuitive GUIs and a rich set of plugins. ### **Prerequisites** Before we start, let’s make sure you’ve got the right setup: 1. **Browser**: Chrome, Brave, or Firefox (latest versions work best). 2. **Wallet** : [MetaMask installed.](/wallet/metamask) * Add the HeLa [testnet RPC](/network-endpoints-and-explorer/network-endpoints-and-explorer) (details will be shared by the chain team). * Fund your wallet with testnet tokens ([faucet link](/network-endpoints-and-explorer/images-and-media)). 3. **Remix IDE**: No install required. Just open Remix in your browser. \ Visit [https://remix.ethereum.org](https://remix.ethereum.org/) ### **Step 1: Create ERC-20 Token Contract** 1. In the file explorer, create a new file under the `contracts` folder named `MyToken.sol` 2. Copy and paste the following ERC-20 token contract code: ```jsx // SPDX-License-Identifier: MIT pragma solidity ^0.8.9; import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; /// @title MyToken - A basic ERC20 Token on HeLa Chain /// @custom:dev-run-script ./scripts/deploy.js contract MyToken is ERC20 { constructor(uint256 initialSupply) ERC20("MyFirstHeLaToken", "HLT") { _mint(msg.sender, initialSupply * 10 ** decimals()); } } ``` **Customizing Your Token** You can customize your token by changing: * `"MyFirstHelaToken"` - The token name * `"HLT"` - The token symbol (appears in MetaMask, max 5 characters) * `5000` - The initial token supply minted to your wallet \ ### Step 2: Adding a Deploy Script Remix uses **NatSpec annotations** to link contracts with scripts. 1. In Remix’s File Explorer, create a folder: `scripts/`. 2. Create `deploy.js` inside it. 3. Paste this code: ```jsx // scripts/deploy.js async function main() { // Get the signer (the deployer wallet from Remix environment) const [deployer] = await ethers.getSigners(); console.log("Deploying contracts with account:", deployer.address); // Compile + get contract factory const Token = await ethers.getContractFactory("MyToken"); // Deploy contract const token = await Token.deploy(); await token.deployed(); console.log("MyToken deployed to:", token.address); } // Run the script with error handling main() .then(() => process.exit(0)) .catch((error) => { console.error(error); process.exit(1); }); ``` ### **Step 3: Compile the Contract** Before deploying, we’ll make one important tweak to avoid compilation errors. 1. Go to the **Solidity Compiler** tab in the left sidebar 2. Expand **Advanced Configurations**. * Under **EVM Version**, select **Homestead** (this ensures smooth compatibility with HeLa’s runtime). **Your settings should look like this:**
3. Now click **Compile**. 4. If the compilation succeeds, you’ll see a green check. ### **Step 4: Deploy to HeLa** 1. Navigate to the **Deploy & Run Transactions** tab 2. In the **Environment** dropdown, select **Browser** **Extension** > **Injected Provider - MetaMask** > **Network Detection** > > If Injected Provider cannot detect the network, refresh the Remix IDE page and switch between networks in MetaMask. 3. Select your **MyToken** contract from the dropdown 4. Enter an initial supply (e.g., `100000`) 5. Click **Deploy** to deploy your ERC-20 token contract 6. Confirm the deployment transaction in MetaMask
### **Step 5: Get Contract Address** 1. After successful deployment, copy the **Contract Address** from Remix, from the terminal. ### **Step 6: Verify on Block Explorer** 1. In MetaMask, click on the transaction and select [**View on block explorer**](https://testnet-blockexplorer.helachain.com/) 2. Verify that the ERC-20 token transfer is displayed correctly on the explorer ### **Step 7: Import Token to MetaMask** 1. In MetaMask, go to **Tokens** tab and click **Import Tokens.**
2. Paste the contract address from Remix into the **Token Contract Address** field 3. The token information should auto-populate (Token Symbol and Decimals) 4. Click **Add Custom Token** and then **Import Tokens** ### **Step 8: Verify Token Balance** 1. Check your **Tokens** tab in MetaMask to see your newly minted tokens 2. You should see 100000 tokens (or your custom amount) in your wallet ### **Step 9: Transfer Tokens** 1. Select your token in MetaMask and click **Send** 2. Enter the recipient address and amount 3. Click **Next** and confirm the transaction 4. Wait for the transaction to be confirmed > **Testing Tips** > > * Test token transfers between different MetaMask accounts > * Verify all transactions appear correctly on the block explorer > * If you encounter issues, try resetting MetaMask via settings ### **Troubleshooting** If you encounter issues: * **Network not detected**: Refresh Remix and switch networks in MetaMask * **Transaction fails**: Ensure you have sufficient HLUSD for gas fees * **Token not appearing**: Double-check the contract address when importing * **MetaMask issues**: Reset MetaMask via settings if problems persist ## Support : If you encounter any issues during setup or require assistance, please join the [**HeLa Developer Community**](https://discord.gg/NEBtTztJCj) for direct support and guidance.
# Deploy Smart Contracts with Hardhat ### **Prerequisites** Before you begin, ensure you have: * VS Code: code-editor * Node.js : This is like the secret language that lets you talk to the blockchain world. Open your terminal/CLI and type: ```jsx node -v ``` If it answers you with a version number, you’re good. If it gives you the silent treatment, go to [**https://nodejs.org/**](https://nodejs.org/) **an**d d[**ownload it.**](https://nodejs.org/)
* Metamask wallet Think of this like your wallet, but to store your crypto instead of real cash. Get it here: [https://metamask.io/](https://metamask.io/**)
Set it up. Save your seed phrase. Hide it like treasure. (*Seriously. Don't lose it. Don't share it. Ever.*)
* HeLa Testnet faucet You’ll need some fake money (test tokens) to pay for gas while we play. ### **Create your project folder:** Developing Your First Token on HeLa Chain If you have developed dApps on Ethereum or `any EVM compatible chain` before, you will feel at home. It is exactly the same. But if you are new, don’t worry, this document will help you embark on your first token development on HeLa chain. There many platforms and utilities that you can use to develop token. For example: REMIX, Truffle, HardHat, Foundry, etc. We will use Hardhat for our first token. Visit Our first program is to develop our first Token on HeLa Chain Step:1 Install Hardhat: ```jsx mkdir hela-token cd hela-token npm init -y npm install --save-dev hardhat npx hardhat ``` Choose "Create a basic sample project" It will give you options like: ```jsx ✔ What do you want to do? - Create a JavaScript project - Create a TypeScript project - ... ``` Select: **“Create a JavaScript project”** (use arrow keys and hit enter) #### **It will create some files for you.** Once done, you should see a folder structure like: ```jsx contracts/ scripts/ hardhat.config.js package.json ... ``` **Pause. Take a breath. You’ve done a LOT already, and and** > Congrats. You just built yourself a smart contract workspace without writing a single line of code. ### **Install OpenZeppelin Contracts** OpenZeppelin is a library of pre-built, secure smart contracts. We’ll use it to create your token. Since we’re building a token, use OpenZeppelin’s ERC20 standard: ```jsx npm install @openzeppelin/contracts ``` * OpenZeppelin gives us pre-built secure templates. * Because honestly, you don’t want to write token code from scratch. * 99% of crypto projects use these same templates. ### **Go to your project folder. Inside, you will see a contracts/ folder.** Inside `contracts/`, create a new file called: ```jsx MyToken.sol ``` ### Write your TOKEN Contract Inside `contracts/`, create a new file `MyToken.sol`: ```jsx // SPDX-License-Identifier: MIT pragma solidity ^0.8.9; import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; contract MyToken is ERC20 { constructor(uint256 initialSupply) ERC20("MyFirstHeLaToken", "HLT") { _mint(msg.sender, initialSupply); } } ``` Currently, they only support 0.8.9 solidity version. For Ref: [\*\*](https://docs.helalabs.com/build-on-us/build-on-testnet) **Explanation:** * `ERC20("MyFirstHeLaToken", "HLT")` — this is your token name and symbol. * `initialSupply` — how many tokens you want to create at the start. * `msg.sender` — the wallet address that deploys the contract will receive all tokens. **You can change the token name and symbol to whatever you want.** For example: ```jsx ERC20("BananaCoin", "BAN") ``` ### **Write deployment script** Let’s write instructions for Hardhat to deploy this contract. ```jsx npm install ethers ``` * We import `{ ethers }` from `"ethers"` (not from hardhat directly) * In Ethers v6+, `parseEther` is now used like: `ethers.parseEther("1000000")` (no `utils`) Inside `scripts/`, edit `deploy.js` (or create it if not present): ```jsx const hre = require("hardhat"); const { ethers } = require("ethers"); async function main() { const initialSupply = ethers.parseEther("1000000"); // 1 million tokens const Token = await hre.ethers.getContractFactory("MyToken"); const token = await Token.deploy(initialSupply); // Wait for the contract to be mined await token.waitForDeployment(); console.log("Token deployed to:", await token.getAddress()); } main().catch((error) => { console.error(error); process.exitCode = 1; }); ``` **Explanation:** * `initialSupply` — we're creating **1 million tokens** (you can change this amount). * `hre.ethers.utils.parseEther("1000000")` — converts "1 million tokens" into the smallest units ("wei"). * `getContractFactory("MyToken")` — tells Hardhat to deploy the `MyToken.sol`contract you wrote. ### **Configure Hardhat to connect to HeLa Chain** Now we need to tell Hardhat where HeLa Testnet lives. Edit `hardhat.config.js` and add the network config for HeLa. #### **1. Install dotenv package** It’s safer to store your private key in a `.env` file, even for testnet practice: ```jsx npm install dotenv ``` #### **2. Create a file called `.env` in your project root folder.** Inside `.env`, paste: ```jsx PRIVATE_KEY=27015ed9348599b64f1c5f56389e2105072a3a061a64611 ``` Where do you get this private key? Open Metamask → Account Details → Export Private Key. (*Never share your private key with anyone except your trusted computer.*) #### **3. Edit your `hardhat.config.js`** Open `hardhat.config.js` and replace the contents with this: ```jsx require("@nomicfoundation/hardhat-toolbox"); require("dotenv").config(); module.exports = { solidity: "0.8.20", networks: { hela: { url: "", chainId: 666888, accounts: [process.env.PRIVATE_KEY] } } }; ``` Explanation: * We loaded your private key securely from `.env` * We added HeLa Testnet RPC URL & Chain ID * Now Hardhat knows exactly how to deploy to HeLa Testnet. #### 4. Deploy Your Token on HeLa Testnet Make sure: * You’re inside the project folder * Your `.env` file exists * You have some testnet $HELA (for gas) From here you can get some $HELA token for your gas : [**https://testnet-faucet.helachain.com**](https://testnet-faucet.helachain.com/) what you need to do is just simple paste your wallet address, make sure you have setup the custom network in your wallet ( in our case we used metamask wallet ) \ Ref : [https://docs.helalabs.com/build-on-us/metamask](https://docs.helalabs.com/build-on-us/metamask**)
1. Run the deployment command: ```jsx npx hardhat run scripts/deploy.js --network hela ``` What you should see in your terminal: ```jsx Token deployed to: 0xYourContractAddressHere ``` 2. Go check it on HeLa Testnet Explorer : [https://testnet-blockexplorer.helachain.com/](https://testnet-blockexplorer.helachain.com/**) ## Support : If you encounter any issues during setup or require assistance, please join the [**HeLa Developer Community**](https://discord.gg/NEBtTztJCj) for direct support and guidance. # Deploy Smart Contracts with Foundry We’ll create a simple SplitWise app, a contract where friends can track and settle debts. #### Prerequisites * Install **Foundry**: ```bash curl -L | bash foundryup ``` * **Node.js & npm** (for optional frontend) * **Hela Node/Web3 Gateway** running locally or using testnet RPC URL * **Wallet (Metamask)** configured to connect to Hela RPC **Check the version:** ```jsx forge --version ``` ### Initialize Foundry Project: Let’s create a new project: ```bash forge init hello-hela cd hello-hela ``` Inside this folder, you now have: * `src/` → your contracts * `test/` → your tests ## Write the Smart Contract: We’ll create a simple **SplitWise app,** a contract where friends can track and settle debts. Create :(`src/SplitWise.sol`) ```solidity // SPDX-License-Identifier: MIT pragma solidity ^0.8.9; contract SplitWise { mapping(address => mapping(address => int256)) public debts; event ExpenseAdded(address indexed payer, address indexed to, uint256 amount); event DebtCleared(address indexed from, address indexed to, uint256 amount); // Record an expense function addExpense(address friend, uint256 amount) public { debts[friend][msg.sender] -= int256(amount); debts[msg.sender][friend] += int256(amount); emit ExpenseAdded(msg.sender, friend, amount); } // Check balance between two friends function checkBalance(address friend) public view returns (int256) { return debts[msg.sender][friend]; } // Clear a debt function clearDebt(address friend, uint256 amount) public { require(debts[msg.sender][friend] >= int256(amount), "Not enough debt!"); debts[msg.sender][friend] -= int256(amount); debts[friend][msg.sender] += int256(amount); emit DebtCleared(msg.sender, friend, amount); } } ``` ### Write a Simple Test (`test/SplitWise.t.sol`) Tests are super important to confirm things work before spending gas. ```solidity pragma solidity ^0.8.9; import "forge-std/Test.sol"; import "../src/SplitWise.sol"; contract SplitWiseTest is Test { SplitWise splitwise; address alice = address(1); address bob = address(2); function setUp() public { splitwise = new SplitWise(); } function testAddExpense() public { vm.prank(alice); splitwise.addExpense(bob, 100); int256 balance = splitwise.checkBalance(bob); assertEq(balance, 100); } } ``` Run the tests: ```bash forge test ``` *** ### Deploy to HeLa Open `foundry.toml` and add your Hela testnet endpoint: ```toml [rpc_endpoints] hela = "" # replace with actual endpoint ``` Deploy with: ```bash forge create --rpc-url hela --private-key src/SplitWise.sol:SplitWise ``` #### Interact with Your Contract * Add an expense: ```bash cast send "addExpense(address,uint256)" 100 --rpc-url hela --private-key ``` * Check balance: ```bash cast call "checkBalance(address)" --rpc-url hela ``` You’ll see a number: * Positive → your friend owes you * Negative → you owe them ## Support : If you encounter any issues during setup or require assistance, please join the [**HeLa Developer Community**](https://discord.gg/NEBtTztJCj) for direct support and guidance. # HeLa Network Information Here are the HeLa Network information for developers to efficiently configure and deploy their applications on HeLa's testnet and mainnet. These essential details include network setup specifics, deployment guidelines, and essential network parameters. By utilizing this information, developers can seamlessly integrate their projects onto HeLa's blockchain platform, ensuring a smooth and successful deployment process on both the testnet for experimentation and the mainnet for real-world use. \ A
SettingTestnetMainnet
Network NameHeLa TestnetHeLa Official Runtime
RPChttps://testnet-rpc.helachain.com https://mainnet-rpc.helachain.com
Chain ID666888 8668
SYMBOLHLUSD HLUSD
Block Explorerhttps://testnet-blockexplorer.helachain.comhttps://helascan.io/
# REMIX - IDE Let's build with REMIX IDE! Developing Your First\ Decentralized Applications `dApps` On HeLa Chain If you have developed dApps on Ethereum or `any EVM compatible chain` before, you will feel at home. It is exactly the same. But if you are new, don’t worry, this document will help you embark on your first dApp development on HeLa chain.\ There many platforms and utilities that you can use to develop dAPP. For example: REMIX, Truffle, HardHat, Foundry, etc.\ We will use REMIX for our first dAPP.\ Visit [http://remix.ethereum.org](http://remix.ethereum.org/) Our first program is `HelloWorld.sol`

Hello World!

In Remix IDE, you will need to compile with a compatible compiler. Remember to select `Injected provider- MetaMask` in the deployment tab.
**Other Recommended Development Tools** **Hardhat:** [https://hardhat.org ]() **Truffe:** [https://archive.trufflesuite.com/docs/truffle/ ]() # Build on Testnet Developing Applications dApps on HeLa Chain If you have developed dApps on Ethereum or `any EVM compatible chain` before, you will feel at home. It is exactly the same. But if you are new, don’t worry, this document will help you embark on your first dApp development on HeLa chain. 1. **Metamask Wallet Setup**\ If you are using Chrome Browser, Metamask extension can easily be installed from the Chrome Extension. Once it is installed it will show up at the top panel of your browser. Once it is installed, it will show up at the top panel of your browser. 2. **Network Setup** Open your Metamask > Network > Add a Network > Add a Network Manually and enter the following:
SettingTestnet
Network name HeLa Testnet
RPChttps://testnet-rpc.helachain.com
Chain ID666888
SYMBOLHLUSD
Block Explorerhttps://testnet-blockexplorer.helachain.com
3. **Funding Your Wallet** To fund your wallet with transaction gas fee, go to HeLa Testnet Faucet. You will receive 10 HLUSD every 24 hours. Claim HLUSD Testnet Faucet: 4. **First dApp** There are many platforms and utilities that you can use to develop dApp. Examples include: REMIX, Truffle, HardHat, Foundry etc. Visit [http://remix.ethereum.org](http://remix.ethereum.org/) for more information. \ Currently, we only support 0.8.9 solidity version.

Our first program is HelloWorld.sol

In Remix IDE, you will need to compile with a compatible compiler. Remember to select Injected provider- MetaMask in the deployment tab.

5. **HeLa Scan** Transaction and smart contracts can be observed and verfied in Testnet Block Explorer. [https://testnet-blockexplorer.helachain.com/
]() # Metamask Available as a browser extension and as a mobile app, MetaMask equips you with a key vault, secure login, token wallet, and token exchange—everything you need to manage your digital assets. MetaMask provides the simplest yet most secure way to connect to blockchain-based applications. You are always in control when interacting on the new decentralized web. MetaMask generates passwords and keys on your device, so only you have access to your accounts and data. You always choose what to share and what to keep private. ## **Installing** Click [here](https://metamask.io/download/) to install the MetaMask extension on your browser. It can be installed on most desktop browsers. Just click on the installation button to begin the process. Once installed, continue to the next section to add the Shardeum network to your new wallet. Remember to save a backup of your private key(s) but never share it with anyone unless that person is to be trusted with full access to your cryptocurrency assets. ## **Create Account** 1. In order to create a new account, click on the account icon on the top right of MetaMask:
2. Log in with your password (or create a new wallet if you’re setting it up for the first time).
3. This is how it looks once you follow the above process, and create your wallet . It usually shows “Ethereum Mainnet” by default). 4. Now Click on the three arrows on your top right. As shown in the image below :
### **Adding HeLa Network to MetaMask** 1. Click the " Network".
### **Adding HeLa Network to MetaMask** 1. Scroll down the dropdown and click **“Add a custom Network”** (or *Add network manually*).
2. A new screen will open asking for RPC details
### **Fill the Endpoint Information** 1. Enter HeLa RPC Details. Refer [Network Endpoints & Explorer Document](/network-endpoints-and-explorer/network-endpoints-and-explorer) 2. Choose "Custom RPC" to add a new network.
3. Save your settings. \ *(Make sure the RPC and Chain ID values match the latest docs. If you type them wrong, MetaMask won’t connect.)*
### **Switch** * MetaMask will now switch you to **HeLa Chain** network. * You should see the `HELA` token symbol at the top.
Now, you're ready to start interacting with HeLa Chain using Metamask. Enjoy the enhanced experience of the HeLa blockchain with your preferred wallet. # Supported Wallets ### **MetaMask** MetaMask is a self-custodial wallet extension for EVM chains. A safe and simple way to access blockchain applications and web3. Trusted by millions of users worldwide. ### **OKX** OKX Wallet is a non-custodial decentralized multi-chain wallet that supports EVM chains as well as non-EVM chains. Secure and transfer your assets, swap crypto, trade NFTs, earn yield, and more with the most ease. ### **Trust Wallet** Trust Wallet is a non-custodial, multi-chain wallet available as both a mobile app and browser extension. With Trust Wallet, you can easily buy, swap, manage, and store your favorite crypto assets cross chain. Discover new blockchains and securely explore Web3 dApps with confidence. ### **Are other wallets supported?** Wallets that follow the Metamask RPC API specification and allow users to connect to the HeLa network are supported as well: # HeLa Wallet The **HeLa Wallet** is currently under **active development**, with several key features in the pipeline. Designed with a **user-friendly interface**, the wallet will enable **seamless transfers of HeLa tokens** across the two layers of the HeLa blockchain. In addition to token transfer functionality, the HeLa Wallet integrates **Decentralized Identifier (DID)** capabilities. These features are aimed at strengthening **user identity management** and providing enhanced **security** within the ecosystem. Further updates will be provided as development progresses, with the objective of continually improving and expanding the overall **HeLa Wallet experience**. ### In the meantime, we encourage you to : **Join our Discord community** to connect with other builders and community members. **Stay in the loop with bi-weekly office hours**, where the team shares progress updates and answers live questions.
Join the Discord → [HeLa Community Discord](https://discord.gg/NEBtTztJCj) for help and ideas. # HeLa Runtime Node The **HeLa Runtime Node** is a core component of the HeLa blockchain infrastructure. Its primary responsibility is the execution of smart contracts and the processing of transactions within the **EVM-compatible runtime layer**. As an integral part of the network, the Runtime Node facilitates seamless interactions with decentralized applications, ensuring smooth user experiences. By running a HeLa Runtime Node, users play an active role in supporting the **operation, stability, and security** of the HeLa network. In addition to these responsibilities, Runtime Nodes help maintain the performance of the network by distributing workload across multiple participants. This ensures that applications built on HeLa provide users with a **fast, secure, and consistent experience**. > Note: The HeLa Runtime Node is under active enhancement. Additional features and optimizations will be introduced as the ecosystem evolves. Future updates will further expand the capabilities of Runtime Nodes, ensuring continuous improvements in scalability, efficiency, and developer usability. Stay tuned for upcoming releases and documentation updates as we continue to build and optimize the **HeLa blockchain ecosystem**.
# Build and Run a Node on HeLa Chain Hela Chain supports two primary types of nodes: **non-validator nodes** and **validator nodes**. This document provides a complete, step-by-step guide to building, deploying, and running both types of nodes on Hela Chain. The guide is designed to be beginner-friendly, by following it closely, you should be able to set up a node successfully with minimal chances of error. ### 1. Prerequisites Before you begin, ensure the following prerequisites are installed and configured on your system: * **Operating System:** Linux (Ubuntu 20.04+ recommended). * **Go:** Version **1.18.x** or **1.19**. ( Later versions may cause compatibility issues.) * **Git:** Latest version. * System packages: * [Bubblewrap](https://github.com/projectatomic/bubblewrap) (at least version 0.3.3). * [GCC](http://gcc.gnu.org/) (including C++ subpackage). * [Clang](https://clang.llvm.org/) (including development package). * [Protobuf](https://github.com/protocolbuffers/protobuf) compiler. * [GNU Make](https://www.gnu.org/software/make/). * [CMake](https://cmake.org/). * [pkg-config](https://www.freedesktop.org/wiki/Software/pkg-config). * [OpenSSL](https://www.openssl.org/) development package. * [libseccomp](https://github.com/seccomp/libseccomp) development package. * **Docker & Docker Compose (optional):** For containerized deployments. Reference: [Oasis Core Development Setup Prerequisites](https://docs.oasis.io/core/development-setup/prerequisites) ### 2. Building Hela Chain Components Hela Chain is built on top of Oasis Core. To run a node, you must build and install the following components: 1. **Oasis Core (Hela Node)** 2. **Emerald ParaTime & Oasis SDK (Hela EVM runtime)** 3. **Web3 Gateway** #### 2.1 Build Oasis Core (Hela Node) Clone the repository and build from source: 1. Oasis Core go to oasis-core folder and build from source to binary ``` make all ``` The binary file: `/oasis-core/go/oasis-node/hela-node`
2.2 Build Emerald ParaTime & Oasis SDK The ParaTime runtime enables EVM compatibility on Hela Chain. Build it from source: ``` make ``` This will export the runtime artifact: `hela-evm.orc` #### 2.3 Build Web3 Gateway The Web3 Gateway connects external applications to Hela Chain using Ethereum-compatible RPC APIs. ``` make ``` The build will produce the binary: `hela-web3-gateway` ### 3. Deploying a Hela Node Hela supports **non-validator nodes** and **validator nodes**. \ Below are deployment steps for non-validator nodes first, followed by validator configuration. #### 3.1 Prepare the Working Directory : Non-validator nodes * ParaTime client node: Follow the Oasis documentation for setting up your node directory structure: **Create the directory with required permissions:** use config.yml here: /mainnet/client\ \ create folder node with: `mkdir -m700 -p ./node/{etc,bin,runtimes,data}` and copy the following files into the `./node` folder: * `config.yml` (example: `/mainnet/client/config.yml`) * Genesis file * `hela-evm` runtime #### 3.2 Run a Non-Validator (Client) Node Start the node: ```bash hela-node --config ./node/etc/config.yml & ``` Check node status: ```bash hela-node control status -a unix:./node/data/internal.sock ``` #### 3.3 Run the Web3 Gateway Use the Web3 Gateway documentation: [Oasis Web3 Gateway](https://docs.oasis.io/node/web3) Prepare a config file (example: `/mainnet/web3-gateway/config.yml`) and run: ```bash hela-web3-gateway --config & ``` Test RPC interaction using QuickNode reference: [eth\_getBlockByNumber](https://www.quicknode.com/docs/ethereum/eth_getBlockByNumber) ### 4. Running Specialized Nodes #### 4.1 ParaTime Node Runs specific runtimes (EVM, confidential compute, etc.). Setup follows the same steps as client nodes, but requires ParaTime runtime registration. #### 4.2 Key Manager Node Dedicated node for handling key management operations. Requires additional configuration (to be documented separately). #### 4.3 Validator Node Validators participate in consensus and secure the network. Setting up a validator requires: * Key generation * Stake delegation * Validator-specific configuration in `config.yml` *(Full validator setup documentation to follow in the dedicated Validator Guide.)* ### 5. Running a Node with Docker For users preferring containerized environments, Hela supports Docker-based deployment. #### 5.1 Install Docker and Docker Compose Ensure both are installed and functional: ```bash docker --version docker-compose --version ``` #### 5.2 Build the Docker Image ```bash docker-compose build hela-core ``` #### 5.3 Start Node Service ```bash docker run --name=hela-node -d -v /node:/node -p 3000:3000 ubuntu_hela-core:latest ``` #### 5.4 Attach to the Container Access the container shell: ```bash docker exec -it hela-node bash ``` #### 5.5 Run Web3 Gateway inside Docker Once inside the container, configure and run the Web3 Gateway as per: [Oasis Web3 Gateway Documentation](https://docs.oasis.io/node/web3)
## Support : If you encounter any issues during setup or require assistance, please join the [**HeLa Community**](https://discord.gg/NEBtTztJCj) for direct support and guidance. # HeLa Consensus Node The **HeLa Consensus Node** is powered by **Tendermint Core**, a proven Byzantine Fault Tolerant (BFT) consensus engine that is widely recognized for its robustness and reliability. Within the HeLa architecture, the Consensus Node forms the backbone of the **consensus layer**, ensuring both the security and integrity of the network. A Consensus Node is responsible for: * **Validating transactions** submitted to the network. * **Participating in consensus** to agree on the ordering of blocks across all active nodes. * **Maintaining immutability and accuracy** of transaction history. By leveraging Tendermint Core, HeLa ensures: * **Fast and deterministic finality** of transactions. * **Resilience against Byzantine faults**, enabling the system to function correctly even in the presence of malicious or faulty actors. * **High stability and predictable performance**, critical for supporting both developers and end-users. As HeLa continues to evolve, additional details and specifications regarding Consensus Node operation and its utilization of Tendermint Core will be shared. These enhancements are aimed at further strengthening the HeLa blockchain ecosystem. Stay connected for upcoming updates and advancements as we refine the consensus infrastructure powering HeLa Chain. # HeLa Guardian Node A **HeLa Guardian Node** is a critical component of the HeLa blockchain ecosystem. It plays a key role in ensuring the **security, stability, and governance** of the network. Guardian Nodes make the network **resilient, trustworthy, and decentralized**, creating a safer and more reliable environment for developers, users, and ecosystem partners. Moreover, ensure the smooth functioning of decentralized applications (DApps) and the broader **DePIN (Decentralized Physical Infrastructure Network)** sector. By validating data, monitoring system health, and detecting anomalies, Guardian Nodes provide the foundation of trust upon which the **HeLa ecosystem** thrives. Future upgrades envision **AI-powered Guardian Nodes** with adaptive intelligence, enhancing network **resilience, randomness, and efficiency**. ### Why Run a Guardian Node? Running a Guardian Node brings both **responsibility** and **rewards**: * **Network Security**: Protects the HeLa network by validating blocks and detecting malicious activities. * **Stability**: Ensures DApps and smart contracts on HeLa run reliably without downtime. * **Decentralization**: Contributes to the global distribution of network trust. * **Rewards**: Earn **HeLa tokens** as incentives for securing and validating the network. * **Perks**: Access to exclusive benefits from ecosystem partners and DApps. ### Key Roles of Guardian Nodes 1. **Server Health Monitoring** * Continuously check assigned servers for uptime, latency, CPU, memory, and disk usage. 2. **Data Validation** * Verify correctness and integrity of network transactions and real-world asset integrations. 3. **Anomaly Detection** * Detect unusual activity, fraudulent behavior, or server instabilities in real-time. 4. **Reporting & Rewarding** * Submit verified data to the **Guardian Node Smart Contract**. * Rewards distributed daily based on **task completion rate** and **accuracy**. ### Rewards & Incentives Guardian Node operators receive: * **HeLa Token Rewards** → distributed proportionally for participation and uptime. * **Network Participation Incentives** → incentives linked to uptime, task completion, and active support of the network. * **Ecosystem Benefits** → early access, airdrops, and partner perks. ### Guardian Node Supply & Ownership * **Total Supply**: 50,000 Guardian Nodes * **Distribution**: Released in tiered sales, with **early supporters receiving exclusive pricing** * **Representation**: Each Guardian Node is tied to a **Guardian Node NFT**, signifying ownership and enabling delegation ### Conclusion Running a **HeLa Guardian Node** means you’re not just a participant, you’re a **guardian of trust**, **stability, and security** in the HeLa ecosystem. It is a way to contribute to d**ecentralized infrastructure** while accessing ecosystem participation benefits. \ For more detailed technical information, please visit this [link](https://guardian.helalabs.com/). # Introduction to Guardian Nodes Cornerstone of HeLa Chain Guardian nodes are the cornerstone of the HeLa chain, serving as the vigilant protectors of the network's integrity and performance. These specialized nodes play a critical role in ensuring the smooth operation of the blockchain and its associated decentralized applications (DApps). By continuously monitoring and validating network data, Guardian nodes form the bedrock of trust and security upon which the HeLa ecosystem is built. A key focus of Guardian nodes is to bolster the burgeoning DePIN (Decentralized Physical Infrastructure Network) sector. By providing robust infrastructure and data validation services, these nodes facilitate the seamless integration of physical assets into the digital realm. This empowers DApps to leverage real-world data and resources, unlocking new possibilities for innovation and utility. Beyond their core functions, Guardian nodes are envisioned as adaptable entities capable of evolving with the network. Future developments include the integration of trainable AI bots, granting each node unique capabilities and decision-making abilities. This introduction of artificial intelligence will enhance the network's resilience, randomness, and overall efficiency. By fostering a diverse ecosystem of Guardian nodes, HeLa aims to create a more robust and dynamic blockchain platform.
# How to purchase the node? To acquire a Guardian Node, simply visit our [sales page](https://guardian.helalabs.com/) and connect your HeLa-compatible wallet. Once your purchase is confirmed, you will be able to mint your corresponding NFT on the Hela Network's Guardian Node NFT mint page. With your Guardian Node NFT in hand, you can then connect your wallet to your newly acquired node, embarking on a journey to contribute to the HeLa ecosystem and earn rewards. ## To become a Guardian Node Operator and Contribute to the HeLa network, follow these steps: 1. Access the [Sales](https://guardian.helalabs.com/) \ Page: Visit the designated sales page on the HeLa platform : 2. **Check Node Availability:** Review the available Guardian Node tiers, including their pricing and release schedule. Each tier represents a batch of nodes with specific characteristics and costs. 3. **Wallet Connection:** Connect your HeLa-compatible wallet to the sales platform. Ensure your wallet is funded with sufficient funds to cover the node purchase. 4. **Purchase Node:** Select the desired Guardian Node tier and proceed with the purchase. 5. **Purchase Confirmation:** Once the purchase is successful, you will receive a confirmation message and the node will be added to your node list. 6. **NFT Minting:** Navigate to the HeLa Network's Guardian Node NFT mint page. Connect your wallet and initiate the minting process for your purchased node. This will generate a unique NFT representing your ownership of the Guardian Node. 7. **Node Connection:** After obtaining the NFT, you can select which Node you want to delegate to a node operator and participate in network operations. By following these steps, you will successfully acquire and activate your Guardian Node, becoming an integral part of the HeLa ecosystem. \ Support : If you encounter any issues during setup or require assistance, please join the [**HeLa Community**](https://discord.gg/NEBtTztJCj) for direct support and guidance. # How Guardian Node works? The Hela Guardian Node network comprises up to 50,000 decentralized nodes tasked with monitoring and validating the health and performance of various servers and systems within the Hela ecosystem. Each node operates independently, interacting with designated machines and tasks, and reporting its findings to a central backend system. This data is subsequently integrated into the Guardian Node Smart Contract, providing a real-time snapshot of the network's health. **Guardian Node vs. Validator Node vs. Client Node** | Feature | Validator Node | Guardian Node | Client Node | | ------------------------ | ------------------------------ | ------------------------------------------ | --------------------------------------- | | **Produces Blocks** | ✅ Yes | ❌ No | ❌ No | | **Validates Consensus** | ✅ Yes | ✅ Yes (indirectly, by checking validators) | ❌ No | | **Supports ParaTime** | ✅ Yes | ✅ Yes | ✅ Yes | | **Slashing Risk** | ✅ Yes | ❌ No (only watches) | ❌ No | | **Hardware Requirement** | High (CPU, RAM, uptime) | Medium | Low | | **Best For** | Stakers, heavy infra providers | Security-conscious devs, watchdogs | dApp developers, explorers, light users | # Core functionality Guardian Nodes perform four main functions: 1. **Server Health Monitoring** * Track CPU usage, consumption, disk usage, network latency, and uptime. * Ensure critical HeLa infrastructure remains operational 2. **Data Validation** * Verify accuracy and integrity of data across the network * Prevent errors, inconsistencies, and fraudulent activity 3. **Anomaly Detection** * Detect unusual behavior or failures in real time * Report anomalies to backend systems for further action 4. **Reporting & Rewards** * Nodes submit their findings to a centralized backend, which processes the data and updates the Guardian Node Smart Contract. * Contract maintains a record of each node's performance, serving as the basis for reward distribution and performance evaluation. ## Interaction with the HeLa Ecosystem Guardian nodes interact with various components of the HeLa ecosystem: * Servers: Nodes directly communicate with the servers they are assigned to monitor. * Backend System: Nodes transmit collected data to the backend for processing and analysis. * Guardian Node Smart Contract: Nodes contribute to the updating of the smart contract with their findings. * Other Nodes: Nodes can potentially collaborate with other nodes to enhance monitoring capabilities or share information.
# Task Completion and Rewards Guardian nodes are required to maintain a 100% task completion rate to qualify for network rewards. This metric is assessed on a daily basis, ensuring consistent performance and accountability. * Task Completion: Nodes must successfully execute all assigned tasks within the specified timeframe to achieve a 100% completion rate. Any missed or failed tasks will result in a reduced reward or disqualification. * Daily Evaluation: The node's performance is evaluated at the end of each day. Nodes that meet the 100% task completion criteria will receive their full reward allocation. * Reward Distribution: Rewards are distributed based on the node's contribution to the network, including factors such as task accuracy, response time, and overall performance. By enforcing strict task completion requirements, the Hela network guarantees the highest level of service and reliability from its Guardian nodes.
# HeLa Guardian Node Delegation Guardian Node NFT holders may appoint an operational node operator to perform the required technical node functions on their behalf within the HeLa network. Delegation is designed to allow broader participation in the Guardian Node ecosystem while ensuring that network-supporting activities are carried out by an operational node. Delegation does not remove the NFT holder’s participation obligations. Node incentives are conditional on compliance with the Guardian Node Terms, including eligibility, continued NFT holding, required stake or lock-up conditions, governance participation, uptime or activity attestations, and operator performance. These obligations are conditions of eligibility, and failure to satisfy them may have the consequences set out below. ### Delegation Process 1. **Access Node Management Page.** Navigate to the Guardian Node section of the HeLa platform and connect your wallet. 2. **View NFT List.** A list of all Guardian Node NFTs owned by your wallet will be displayed, including their current delegation status. 3. **Select NFT for Delegation.** Choose the Guardian Node NFT you wish to delegate. 4. **Choose Technical Node Operator.** A list of available operational node operators and their applicable service fees will be presented. Node operators are responsible for performing the required technical node operations, including running the necessary infrastructure and meeting applicable performance requirements. 5. **Confirm Delegation.** Select the desired node operator and confirm the delegation process. Once delegation is complete, node incentives are available only if the delegated node meets its performance, uptime, task-completion and network requirements, and the NFT holder continues to satisfy the participation obligations set out below. These obligations include maintaining the relevant NFT and any required stake, participating in governance where required, satisfying eligibility requirements, and complying with the programme terms. Failure by the NFT holder or the delegated node operator to meet these requirements results in one or more of reduced incentives, forfeiture, slashing or suspension of eligibility, as set out in the Guardian Node Terms. ### Node Operator Service Fees Node operators may charge a service fee for performing technical node operations on behalf of delegated Guardian Node NFTs. This service fee compensates the operator for infrastructure, maintenance, uptime, monitoring, and other technical services provided to support the network. The service fee is a fixed or variable fee or published rate charged to the NFT holder for those services, and is not calculated as a percentage or share of the node incentives generated by the delegated NFT. The service fee is not a revenue-share, profit-share, or participation in a common reward pool. NFT holders may compare available operators based on service fee, uptime history, performance, technical capacity, and other relevant operational factors before selecting a node operator. ### NFT Holder Participation Obligations Guardian Node NFT holders who delegate to a node operator must satisfy ongoing participation obligations as conditions of eligibility for node incentives. These include: * maintaining ownership or lock-up of the relevant Guardian Node NFT; * maintaining any required stake or eligibility status; * participating in governance or protocol-related processes where applicable; * confirming or attesting to continued delegation status; * complying with applicable jurisdictional, eligibility, and programme terms; * avoiding prohibited conduct, abuse, Sybil activity, or manipulation. If these requirements are not satisfied, the NFT holder will lose eligibility for some or all applicable node incentives. ### Self-Operation Users who wish to perform the technical node functions themselves may choose to operate their own Guardian Node. By installing and running the required software, users can list their node on the network and perform the applicable operational tasks directly. Self-operated nodes must meet the same technical, uptime, security, task-completion, and network participation requirements applicable to other node operators. **Note:** The specific delegation mechanics, including operator service fees, eligibility requirements, performance requirements, forfeiture or slashing rules, and security measures, will be outlined in detail in the platform’s technical documentation and Guardian Node Terms.
# Node Rewards Benefits from being a node owner ### Initial Reward All Tier 1 Guardian Node NFTs purchased during the pre-sale in September 2024 will receive a one-time bonus of **288 HeLa** **tokens** **airdropped** into their wallets! These tokens can be claimed within the HeLa dApp. Guardian Node NFT holders in the public sale will only be allocated 12% of total supply of HeLa tokens through at 4-year linear vesting model. ### Weekly Rewards All HeLa Guardian Node owners who have minted and staked their Node NFTs will also qualify for promotional airdrops if any. ### Daily Rewards 12% of total supply of HeLa tokens are distributed to Guardian Node holders, through a 4-year linear vesting model. Guardian Node operators earn HeLa tokens based on their daily performance. The reward pool is calculated daily and distributed proportionally to nodes that achieve a 100% task completion rate.
### Partner Rewards Receive airdrops from HeLa ecosystem partners. By owning HeLa Guardian nodes, you represent an integral part of HeLa ecosystem and community. You can expect airdrop of partner tokens and whitelisted to be the first to be part of any core products on HeLa Chain.

Benefits for buying a HeLa Guardian Node!

### Reward Claim To claim earned HeLa tokens, node operators must interact with the Guardian Node smart contract. The claimed tokens will be transferred to the node owner's designated wallet address. # Interaction with the HeLa Ecosystem Guardian nodes interact with various components of the HeLa ecosystem: * Servers: Nodes directly communicate with the servers they are assigned to monitor. * Backend System: Nodes transmit collected data to the backend for processing and analysis. * Guardian Node Smart Contract: Nodes contribute to the updating of the smart contract with their findings. * Other Nodes: Nodes can potentially collaborate with other nodes to enhance monitoring capabilities or share information. # FAQs FAQs on HeLa Node Sale ## Why purchase the HeLa Guardian Node? ### What benefits do I get from buying a HeLa Guardian Node? By running a HeLa Guardian Node, you directly contribute to the ecosystem by enhancing network security and supporting its growth. HeLa node owners will receive token rewards, including airdrops during listing events, and enjoy additional benefits from future collaborations with HeLa and its partners. ### How do I get started and how can I set up my node? Follow this guide for a step-by-step guide to help you get started: ### Where can I buy Node? You can buy a HeLa Guardian Node through the HeLa Labs node sales page. Check it here: ### What unique features does the HeLa node offer compared to others? * Early Participant Allocation: Early Guardian Node participants receive part of their scheduled $HELA node allocation at TGE, with the remaining allocation released progressively over 48 months. * NFT License: Get an NFT for node ownership. * Additional Ecosystem Incentives: Stake NFTs to earn tokens from partnered projects. * One Node for All: Exclusive platform for staking future NFTs. * Stake for Incentives: Get more HeLa tokens for rewards. * Delegation: Greater incentives from others staking their NFTs to your node. * Potential Airdrop Incentives: Potentially earn fees from future NFTs staked on the nodes. ### Are we guaranteed rewards? There are some promotional airdrops, but other perks depend on HeLa securing more partnerships. Please refer to the node deck for detailed participation benefits, allocation information, and tier details. ### What ecosystem benefits can Guardian Node participants receive? * Earn Rewards: Get HeLa Chain Rewards for network contribution. * Early Access: Access new NFT launches for project tokens. * Extra Incentives: Stake HeLa tokens for more rewards. * Delegation Service Fees: Provide node operation services for delegated Guardian Node NFTs. * Airdrop Incentives: Earn incentives from future NFTs staked on the nodes. ## Node Sale Pricing ### What is the initial price for a HeLa node? The initial price is 330 HLUSD. #### 2. How many Guardian Nodes are available in each tier? There are 2,500 Guardian Nodes available in each tier. #### 3. What is the total number of Guardian Nodes available for sale? A total of 50,000 Guardian Nodes are available for sale. #### 4. Through which network will the node sale be conducted? The sale will be conducted on HeLa network via a public sale. You will be able to use USDT/USDC/HLUSD on HeLa network to purchase the nodes. Currently, as of November 2024, we support HLUSD only. #### 5. Can you buy fractions of a node? No, nodes will be sold in whole units only. #### 6. When can nodes be transferred after purchase? Nodes can be transferred only after all the 50,000 nodes have been fully sold. #### 7. What is the difference per each tier? Each tier has different pricing, access terms, and participation benefits. #### 8. What will I receive alongside the token node reward? You will receive a total of 864 HeLa tokens per node vested over a period of 4 years. Besides HeLa tokens, node owners are on the priority list to receive perks from all partnerships and campaigns within the HeLa ecosystem. #### 9. What is the initial price of the Guardian Nodes? The price is 330 HLUSD, equivalent to 330 USD (given that 1 HLUSD = 1 USDT/USDC). #### 10. How many token rewards does each node receive? Each node receives 864 HeLa tokens rewards, vested over a period of 4 years. ### Referral Programme #### 1. How and when will referral rewards be processed? Eligible referral rewards will be reviewed and processed approximately two weeks after the relevant sale has been completed and verified. Referral rewards are subject to programme terms, successful verification, and completion of any required KYC, AML, sanctions, or eligibility checks. Participation in the referral programme does not grant any right to HELA token rewards, node incentives, revenue share, yield, or investment returns. #### 2. What if I want to refer a larger community? Users with an established community, audience, or partner network may apply for the Partner Referral Programme. Approved partners may be eligible to receive a separate referral support fee or promotional credit for verified introductions, subject to the applicable partner terms, eligibility checks, and programme approval. The Partner Referral Programme is a marketing and community growth programme only. It is separate from Guardian Node operation, HELA token utility, node incentives, staking, and any network participation rewards. #### 3. Where do I apply for the Partner Referral Scheme? You may apply for the Partner Referral Programme using this link: **Apply here**. Applicants will generally be required to provide: * Telegram ID; * email address; * proof of community or social media presence; * relevant audience or community information; * any other information required for verification and eligibility review. Approval is not guaranteed and remains subject to HeLa’s review, programme terms, compliance checks, and applicable restrictions \ Support : If you encounter any other issues during setup or require assistance, please join the [**HeLa Developer Community**](https://discord.gg/NEBtTztJCj) for direct support and guidance. # Whitepaper {% embed url="" %} # Litepaper {% embed url="" %} # HeLa Tokenomics Overview of our Tokenomics! The HeLa tokenomics has been carefully crafted with a single, overarching objective: to create an economical system that aligns the incentives of all participants within the HeLa ecosystem. This tokenomics paper details the core components of HeLa's economy. For an in-depth look at HeLa’s technical design, please take a look at the HeLa documentation. ## Core Participants of HeLa ### Users Users perform various actions on HeLa, such as managing digital assets, engaging with smart contracts, and using advanced applications. HeLa offers stable gas fees in HLUSD, which is vital for sustaining Web3 ecosystems by shielding them from the fluctuations in gas fees. Additionally, HeLa’s modular architecture provides both scalability and flexibility, enabling developers to integrate different modules to build tailored solutions with consistent and low transaction costs. ### Validators Validators are integral to HeLa Chain, responsible for processing and executing transactions while maintaining the platform’s integrity and efficiency. As part of HeLa Chain’s proof-of-stake model, validators are required to stake $HELA in order to participate in validation, support consensus, process transactions, and help secure the network. This aligns validator participation with the long-term health, reliability, and security of the HeLa ecosystem. Validators are compensated with network-based rewards for supporting transaction processing, consensus participation, and network reliability. Unlike many blockchain systems, HLUSD is non-inflationary, preventing validators from creating tokens at will. This key difference ensures that validators are motivated to increase network activity, as their rewards grow with higher transaction volumes. By aligning their incentives with the network’s expansion, validators play a crucial role in driving HeLa’s success. ### $HELA Token HeLa’s native token, $HELA, has a finite supply, distinct from HLUSD, which is a stablecoin backed by a basket of currencies and used as the gas token on HeLa Chain. Holders of $HELA can participate in HeLa’s network participation and ecosystem incentive programs, offering them ecosystem participation benefits. Additionally, $HELA holders are granted governance rights, allowing them to participate in crucial decision-making processes for HeLa Chain, such as approving builder grants, protocol upgrades, and fee adjustments. $HELA holders will be pivotal in shaping the future of HeLa Chain! ## Critical Roles of $HELA in HeLa Chain $HELA is a scarce asset with a fixed supply of 360 million. The core utility of $HELA can be split into three components. ### Incentives HeLa Chain plans to introduce $HELA incentive programs designed to identify, motivate, and reward exemplary behavior among its participants. This includes builders who develop applications, community members who contribute to the ecosystem, and validators who maintain the network. These programs aim to encourage transparency, integrity, and positive engagement, ensuring that those who demonstrate honesty and contribute constructively to the ecosystem are recognized and incentivized. By aligning rewards with desirable actions and contributions, HeLa Chain fosters a thriving, collaborative environment for all its ecosystem members. ### Proof-of-Stake Validator Participation $HELA supports HeLa Chain’s proof-of-stake validator model. Validators are required to stake $HELA in order to participate in network validation, process transactions, support consensus, and help maintain the security and reliability of HeLa Chain. By requiring validators to stake $HELA, the network aligns validator participation with the long-term health of the ecosystem. Validators are incentivized to act honestly, maintain uptime, and contribute to the stability of the network. ### Governance $HELA token holders play an active role in influencing the core dApps (protocols) via governance processes, which include: * Voting on core dApp bribes and emissions * Allocating grant incentives from the Governance Fund * Awarding grants to developers of third-party dApps on HeLa Chain This open and equitable decentralized governance model guarantees that the interests of $HELA token holders are well-represented. ## $HELA Token Distribution **The total supply of $Hela tokens is capped at 360,000,000.**
| Category | Percentage | Description | | --------------------------------- | ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **HeLa Guardian Node Incentives** | 12% | A series of airdrops and 48-months linear vesting model of $HELA emission. Find out more in [HeLa Guardian Node](https://docs.helalabs.com/hela-node/hela-guardian-node) section. | | **Ecosystem & Community** | 38% | Proactive programs, developer contributions, grants, and incentives designed to stimulate community participation and ecosystem development. | | **Early Backer** | 15% | Early backers who supported the HeLa Chain vision and provided the necessary funding to build and grow the ecosystem. Linearly vested over 48 months. | | **Partner & Advisor** | 10% | Distributed to advisors, developers, partners and individuals who actively contribute to HeLa’s growth. Linearly vested over 48 months. | | **Team & Founders** | 10% | Tokens allocated to the core team and founders through a 48-months distribution cycle. | | **Foundation** | 15% | Tokens allocated to providing initial and ongoing liquidity into DEXs & CEXs, as well as allocation for marketing & partnership expenditure. Vested immediately. | # Roadmap Our Vision & Roadmap HeLa Blockchain envisions a future where data confidentiality and decentralization adoption align with real-world applications. Our mission is to address the limitations of current blockchain transparency by providing robust data confidentiality solutions that mimic the privacy standards of traditional real-world systems. We aim to empower individuals and businesses with a secure and decentralized platform, ensuring sensitive data remains confidential while enabling seamless integration into existing applications. HeLa Blockchain is committed to driving the widespread adoption of decentralization, where privacy and confidentiality are not compromised, revolutionizing how data is handled and protected in the digital age. Join us as we redefine the boundaries of data confidentiality and usher in a new era of decentralized solutions for the real world. *** The following roadmap represents a timeline that has been carefully crafted based on estimations and assumptions, considering our current available resources. It is important to note that collaboration with additional partners and research institutes may influence the timeframe, potentially leading to adjustments in the duration. Nonetheless, our unwavering commitment remains centered on progressing towards meaningful and applicable outcomes. Our ultimate objective is to continually strive towards delivering solutions that are valuable and practical. For more detailed understanding, read our litepaper [here](https://helalabs.com/hela-whitepaper.pdf).
# HeLa Accelerate Grant Program The **HeLa Accelerate Grant Program** is a **$10M fund** established to support projects and developers building on the **HeLa Chain Mainnet**. The program is designed to strengthen the HeLa ecosystem by empowering innovative teams and builders. The program prioritizes decentralized applications (**dApps**) in the areas of **DeFi, Gaming, and NFTs**, while also welcoming innovative use cases that leverage HeLa’s unique architecture. ### Application Process Developers and teams interested in participating in the program are invited to submit their applications through the official HeLa website. The process has been designed to be **transparent, streamlined, and developer-friendly**, ensuring that qualified projects can begin their journey on HeLa with minimal friction. ### Further Information & Q\&A For additional details regarding the **application process, support, evaluation and frequently asked questions,** please refer to the official documentation available on the [HeLa website.](https://helalabs.com/grant/) **Apply today.** Be among the first to access these exceptional benefits and take part in building the future of the **HeLa ecosystem**. ## Important Links : * Grant Page : * Discord Community : # Developer Support Get developer support for Across via Discord and explore helpful resources on Twitter, Telegram, and Medium. Reach out on [Discord](https://discord.gg/NEBtTztJCj) or [Telegram](https://t.me/hela_official) Other helpful resources: * Linkedin : * Twitter : # Q\&A Frequently asked questions about HeLa Labs and its layer 1 solutions. ## Introduction **Q: What is HeLa Labs?**\ A: HeLa Labs is hi tech company developing a next-generation Layer-1 blockchain protocol. It is designed for real-world adoption together with renowned scientists and engineers. **Q: Who are the engineers and scientists behind HeLa Labs?**\ A: HeLa was built by many renowned scientists and engineers. Those are from reputable firms including one of the popular research firms in Singapore. **Q: What is the mission of HeLa Labs?**\ A: HeLa, a next-generation layer 1 blockchain protocol with the mission of bringing Web3 to the real world. To achieve this, we leverage innovative features such as the use of stablecoins as gas fees, providing users with data sovereignty and the privacy through advanced cryptographic techniques such as zero-knowledge proofs and homomorphic encryption. These features are built upon a modular architecture that balances security, scalability, and decentralization. **Q: Where can I find more information about HeLa Labs?**\ A: You can find more information here: ## **HeLa Layer-1 Solution** **Q: What is the Layer-1 solution provided by HeLa Labs?**\ A: The Layer-1 solution provided by HeLa Labs is the HeLa Chain. It features a modular design with an asset integration layer that facilitates the seamless integration of assets across runtimes in a modular blockchain environment. It also includes an execution, a consensus, and a storage layer that makes the chain highly flexible and scalable. One of the special features is built-in stable coin token that plays gas fees. **Q: What is so special about the Layer-1 solution by HeLa Labs?**\ A: HeLa Chain is unique in its design and features. It offers a built-in stable coin token that serves as the gas fee for transactions, reducing volatility and increasing real-world user adoption. It also features a multi-level decentralized identity for enhanced security and privacy-preserving transactions for added confidentiality. **Q: Does the chain support EIP-1559?**\ A: Yes, we have implemented a header that supports EIP-1559 to be EVM compatible. **Q: How do I get the price feed oracle? Do you have Chainlink or Pyth.network?**\ A: We have created our own price oracle, which is currently free. We are also working on integrating other price oracles. **Q: How much are the gas fees?**\ A: We are adjusting them to average USD 0.02. HeLa chain uses its native stable coin as payment for the gas fee. **Q: Where can I get HeLa coin?**\ A: Currently, it is not publicly available. ## **Getting Started** **Q: Where can I find HeLa Labs documents?**\ A : HeLa Labs documents can be found on official website: **Q: Where is the HeLa Labs token used?**\ A: HeLa is the first Layer 1 blockchain powered by a fiat-backed stablecoin (HLUSD). Currently only HeLa USD token called HLUSD is available. This suggests that the HeLa Labs token (HLUSD) is used within the HeLa blockchain. **Q: Where can I find information about HeLa Lab's tokenomics?**\ A: **Q: In what way are HeLa Labs blockchain transactions processed, and which consensus mechanism does HeLa Labs use?**\ A: At HeLa Labs, we've developed HeLa, our next-generation layer 1 blockchain protocol, with the clear mission of bridging the gap between the cutting-edge technology of Web3 and the real world's needs. We've realized that despite the impressive advancements in blockchain technology, mass adoption has been elusive. That's why we've focused on addressing key challenges like scalability, interoperability, privacy, and user experience. Our approach is built on innovative features like Modular Design, the use of Stablecoin as Gas Fee, Decentralized Identity (DID), and EVM Compatibility. These elements work together to make our blockchain more accessible and practical for everyday use.\ As for our consensus mechanism, we've adopted the Tendermint protocol, utilizing a Byzantine-Fault-Tolerant (BFT) system. This method ensures that transactions are processed securely and efficiently, enabling trust and collaboration on our network. **Q: How can I apply for a grant to build on HeLa Labs?**\ A: HeLa offers grant program to various start-ups. To apply for a grant program, please go here to apply link. ## **Use Cases** **Q: What are some use cases for HeLa Labs' solutions?**\ A: HeLa chain focuses on use cases that are relevant to the real world, such as supply chain management in the healthcare industry, banking and finance, real estate, and many more. HeLa's DID management system expands its usability across a variety of application situations, including credit lending, online ticketing, and other KYC-required applications. HeLa's integrated stable coin and gas charge characteristics also make it simpler for users to respond to real-world situations. ## **Guides and Tutorials** **Q: How to troubleshoot common issues?**\ A: You can join our discord to go to the support section and create tickets. ## **Community and Support** **Q: How to get involved with the HeLa Labs community?**\ A: You can get involved with the HeLa Labs community by visiting the official website or via email, Telegram, Discord and Twitter. HeLa Website: \ HeLa Telegram Announcements: \ HeLa Telegram Community: \ HeLa LinkedIn: \ HeLa Twitter: \ HeLa Discord: \ HeLa Medium: **Q: Is there any ambassador program available?**\ A: At HeLa Labs, we are thrilled to announce that we will be launching an ambassador program very soon. This program reflects our commitment to community engagement and our desire to build strong connections with individuals who share our passion for blockchain technology. The HeLa Ambassador Program will be designed to empower individuals who want to represent HeLa Labs and advocate for our mission of bringing Web3 to the real world. Our ambassadors will play a crucial role in growing our community, spreading awareness of our innovative solutions, and fostering a spirit of collaboration and innovation. **Q: I would like to participate in developer discussions or provide technical feedback. What should I do?**\ A: We will have a separate channel for developer discussions in our discord server. **Q: Is there a faucet for the mainnet and testnet?**\ A: For those interested in exploring and testing the HeLa blockchain, we provide access to both the HeLa Testnet Explorer and the HeLa Testnet Faucet. These resources are essential for developers, testers, and enthusiasts who want to interact with the HeLa chain without using real assets. **HeLa Testnet Explorer:** \ **HeLa Testnet Faucet:** There will be official announcement, therefore, please make sure you to stay in our community channel. **Q: Are there any bug bounty programs?**\ A: Yes, at HeLa Labs, we recognize the importance of continuous improvement and community engagement in our quest to build a secure and robust blockchain protocol. As part of our commitment to security and transparency, we are in the process of launching a bug bounty program, which will be released soon. **Q: Are there any job openings at HeLa Labs right now?**\ A: Absolutely! At HeLa Labs, we are actively expanding our team and seeking talented blockchain developers who share our passion for innovation and excellence. As we continue to grow and develop the HeLa Chain, we recognize the importance of bringing on board skilled individuals who can contribute to our vision of bringing Web3 to the real world. Please visit our website to check on the careers section. {% embed url="" %}