# About ICB Network ## **What is ICB Network?** In October 2020, **ICB Labs** was founded as the innovation arm of **ICB Crypto Services**, marking the company’s first decisive step into the blockchain industry. Created to tackle emerging challenges in the decentralized space, the division focuses on applying proven, modern technologies to solve real-world problems. Its core mission is to eliminate intermediaries and enable real-time, trustless transactions by leveraging widely adopted blockchain platforms. From these beginnings, the **ICB Network** emerged as one of the most advanced and forward-thinking blockchain projects on the market. What sets it apart is its status as a **Layer 1 blockchain**, built from the ground up to overcome the limitations of traditional blockchain architectures. By rethinking the network’s foundational structure, **ICB Network** introduces core-level improvements in scalability, data handling, and smart contract efficiency. **ICB Network** is a cutting-edge platform designed to empower developers with the tools needed to build scalable, secure, and storage-efficient decentralized applications. Featuring near-instant response times and a Proof-of-Stake consensus mechanism, **ICB** offers fast, energy-efficient blockchain interactions on one of the highest-performing networks in the space. But **ICB Network** is more than just a technological achievement — it represents a bold vision for the future of decentralization. By prioritizing speed, sustainability, and security, it is uniquely positioned to transform a wide range of industries and make blockchain more accessible and practical for real-world adoption. At its core, **ICB Network** is driven by a dynamic and passionate team committed to continuous innovation. This dedicated group actively explores, tests, and deploys cutting-edge solutions that enhance performance and deliver a seamless experience to both users and developers. **ICB Network** doesn’t just keep pace with innovation — it helps shape it. As it grows, **ICB Network** is helping redefine what a truly modern Layer 1 blockchain should be — one that supports the Web3 revolution with real-world utility, sustainable infrastructure, and a developer-first mindset. By removing legacy barriers and empowering community-driven development, the ICB ecosystem is laying the foundation for a decentralized, efficient, and equitable digital future. {% embed url="" %} # Technical overview Built and optimized from the ground up, **ICB Network** is a Layer 1 blockchain designed with first principles in mind. It leverages a highly efficient **Proof-of-Stake** consensus algorithm, specifically tailored to meet the performance and security demands of a modern Layer 1 infrastructure. Both the consensus layer and networking stack have been meticulously engineered to ensure low-latency communication, rapid finality, and high throughput — making **ICB Network** an ideal foundation for scalable decentralized applications. **ICBX**, the network’s native coin, is tightly integrated into the core architecture and governance model. It plays a central role in staking, validator incentives, and overall ecosystem sustainability. Advanced data retrieval capabilities empower high-performance dApps, especially those requiring storage-heavy operations or real-time interaction. Smart contract execution on **ICB Network** is finely optimized to overcome critical limitations found in traditional blockchains — including constrained transaction throughput and inefficient gas models. The average transaction confirmation time is reduced to just **4.9 seconds**, ensuring a fast and seamless user experience — ideal for time-sensitive applications such as DeFi, gaming, and real-time messaging. # What is Proof of Stake? ## 1. Definition **Proof of Stake (PoS)** is a consensus protocol used by blockchain networks to secure the system, validate transactions, and produce new blocks. Unlike **Proof of Work (PoW)**, which relies on computational power, PoS assigns validation rights to participants—called validators—based on the amount of cryptocurrency they lock (stake) into the network. In this model, the probability of being selected to validate or propose a block increases proportionally with the amount staked. This approach dramatically reduces energy consumption and supports greater scalability compared to traditional PoW systems. To maintain network integrity, validators are held accountable: if they act maliciously or fail to fulfill their duties, they risk losing a portion of their stake as a penalty. ## 2. Core components | **Component** | **Description** | | ------------------ | ----------------------------------------------------------------------------- | | **Validators** | Participants who lock up coins to secure the network and validate blocks. | | **Block Proposal** | Validators are pseudo-randomly chosen to propose the next block. | | **Attestation** | Other validators vote to confirm the proposed block is valid. | | **Finality** | When a block becomes irreversible, often after multiple confirmations. | | **Stake** | The amount of cryptocurrency a validator locks in the protocol as collateral. | ## 3. How it works **Proof of Stake (PoS)** operates through a structured series of steps that ensure secure, decentralized, and efficient block production. It replaces the energy-intensive mining process of Proof of Work with a more scalable, capital-based model. Here’s how it works in most modern PoS systems: ### **3.1. Staking** Users lock a certain amount of cryptocurrency (e.g., ICBX) into a smart contract to become eligible for participation as validators. This process is called **staking**. Key aspects include: **Minimum stake requirement**: Networks may set a minimum token amount required to participate. **Lock-up period**: Tokens are locked for a defined period, during which they cannot be withdrawn. **Delegation (in some systems)**: Users can delegate their tokens to trusted validators without directly validating blocks themselves. The more a validator (or their delegators) stake, the higher the chance of being selected to produce or validate blocks. ### **3.2. Validator Selection** Validators are selected to propose or attest to new blocks based on a **weighted random selection**. The most common factors include: **Randomness**: Many networks use a Verifiable Random Function (VRF) or RANDAO to introduce cryptographic randomness. **Amount staked**: Higher stakes increase the chances of being selected. **Staking duration or history**: Some networks factor in how long tokens have been staked or validator reliability. **Performance score**: Past behavior (uptime, correctness) may impact selection weight. ### **3.3. Block Proposal and Voting** Once selected: The **proposer** creates a block containing transactions and metadata. A **committee of validators (attesters)** vote on whether the proposed block is valid. If a **quorum** is reached (i.e., enough validators attest), the block is added to the chain. This process ensures Byzantine Fault Tolerance (BFT), where the system remains secure even if a minority of validators behave maliciously. ### **3.4. Rewards** Validators are compensated for their work through: **Transaction fees**: Collected from users who include them in their transactions. **Block rewards**: Newly minted tokens, if the protocol supports inflationary rewards. **MEV (Miner/Validator Extractable Value)**: In some cases, validators can prioritize high-value transactions for additional income. Rewards are often distributed proportionally based on stake and **validator uptime** or **performance metrics**. ### **3.5. Slashing (Penalties)** To maintain network trust and accountability, PoS includes a **slashing mechanism**: Validators who act maliciously (e.g., **double-signing**, **surround voting**, or proposing invalid blocks) are penalized. Penalties range from **minor loss of rewards** to **partial or total loss of staked tokens**. Validators who are **offline or non-responsive** for long periods may be **ejected** from the active set or **fined**. ## 4. Advantages of Proof of Stake ### **4.1. High Throughput for Scalable Applications** PoS accelerates transaction processing and supports higher data capacity across the network. This makes it particularly effective for platforms that require rapid execution and can handle large transaction volumes, such as DeFi, gaming, and real-time applications. ### **4.2. Instant Transaction Finality** Through validator consensus, blocks achieve finality almost instantly without requiring multiple confirmations. This provides fast, seamless transaction approvals with strong consistency and security guarantees. ### **4.3. Minimal Resource Usage** By removing the need for energy-intensive mining, PoS dramatically reduces energy consumption. Its lightweight and efficient design is environmentally sustainable while maintaining high security. ### **4.4. Fair and Adaptive Incentive Structure** Validator rewards are distributed through a collective and transparent model that aligns incentives with active participation. This fair structure encourages decentralization and fosters long-term network engagement. ### **4.5. Decentralized Governance and Decision-Making** Token holders can participate in selecting validators and influencing protocol upgrades. This delegation-based governance model supports informed decision-making, increases operational resilience, and strengthens overall protocol integrity. # ICBX Token ## ICBX Token Utility and Tokenomics **ICBX** is the native utility token of the **ICB Network**. It plays a central role in powering and securing the ecosystem, serving multiple purposes across network operations. ICBX is used to: * Pay for transaction fees * Stake assets to support consensus * Run validator nodes * Participate in on-chain governance Beyond its core functions, **ICBX** also enables access to decentralized applications built on the network and acts as an incentive mechanism to reward contributors and strengthen network security. As the **ICB** **Network** evolves, so does the utility of **ICBX** — driving innovation and supporting the sustainable growth of the ecosystem. Holding **ICBX** not only grants access to network services but also provides a voice in shaping its future direction. ## Tokenomics * **Total Supply**: 100,000,000,000 ICBX (100B) ## **Allocation Breakdown** **Public Distribution: 35% (35B tokens)**\ Intended to be distributed over several phases or rounds to promote a fair and decentralized launch. **Team: 10% (10B tokens)**\ Allocated for core contributors with long-term vesting schedules to ensure alignment with the project’s future. **Advisors: 5% (5B tokens)**\ Reserved for strategic advisors supporting project growth and development. **Ecosystem Development Fund: 30% (30B tokens)**\ Used to support partnerships, integrations, grants, developer programs, and dApp growth. **Reserve Fund: 5% (5B tokens)**\ Maintained as a strategic reserve for future needs or unforeseen opportunities. **Staking Rewards: 12% (12B tokens)**\ Allocated to incentivize validator participation and network security over time. **Community Grants & Airdrops: 3% (3B tokens)**\ Distributed to early adopters, contributors, and community participants through events and programs.
## Network Fee Every time a user interacts with the **ICB Network**—whether by sending a transaction, deploying a smart contract, or using a decentralized application—a small network fee, also known as gas, is required. These fees are essential for maintaining the network’s performance and security. The gas fees collected are distributed among active validators, creating a fair and incentivized ecosystem. Each validator receives a proportional share of the fees based on their participation. This fee structure not only supports the long-term sustainability of the network, but also promotes decentralization by aligning incentives among users, validators, and token holders.
# ICB Consensus vs POW Consensus Detailed technical exploration of our blockchain platform. This guide is designed to provide insights into the sophisticated features and capabilities that power our network, echoing advanced function The **ICB Network** is a next-generation Layer 1 blockchain built with a strong focus on security, decentralized governance, and energy-efficient operations. Powered by a **Proof of Stake (PoS)** consensus mechanism, ICB offers a scalable infrastructure for modern decentralized applications. Its ecosystem is designed to foster transparent and democratic governance, empowering all stakeholders — including the core development team, community delegators, and investors — to actively shape the future of the network. ## Key Advantages of ICB Network ### 1. Blazing-Fast Transactions **PoS-A** consensus eliminates the need for energy-intensive mining. Transactions are validated in real-time, ensuring high throughput and ultra-low latency. Ideal for applications that demand instant confirmations, such as DeFi, gaming, and messaging. ### 2. Low Energy Consumption Unlike **Proof of Work (PoW)**, which relies on high-powered mining hardware, **PoS-A** uses a lightweight consensus mechanism. This drastically reduces the network’s carbon footprint, aligning **ICB** with modern sustainability goals. ### 3. Decentralized Governance & Participation Token holders can vote for delegates or participate directly in governance proposals. This fosters a dynamic and democratic ecosystem, enabling faster decision-making and more inclusive development. ### 4. Enhanced Security & Validator Integrity By using stake-based validation, **ICB** ensures strong network security and decentralization, leveraging token holder incentives to maintain integrity. The validator set is both reliable and incentivized to act in the network’s best interest. ## Challenges of Legacy PoW Systems ### **Slow Transactions** Block confirmations on PoW networks can take several minutes, making them unsuitable for real-time applications. ### **High Energy Usage** PoW consumes massive amounts of electricity due to computationally intensive mining. This raises environmental concerns and long-term scalability issues. ### **Centralization Risks** The reliance on expensive mining hardware often leads to the centralization of mining power in a few large pools, undermining decentralization. ## Evaluating the ICB Consensus Mechanism Against Existing Alternatives
# How to connect with ICBNetowork? {% hint style="success" %} ICB MAINNET {% endhint %} **RPC** **URL:** **Chain ID:** 73115 **RPC:** **Explorer:** **Symbol:** ICBX {% hint style="success" %} **ICB TESTNET** {% endhint %} **RPC** **URL:** **Chain ID:** 73114 **RPC:** **Explorer:** **Symbol:** ICBT {% hint style="info" %} **Other available RPC URLs for the mainnet can be found here:** {% endhint %} ## You can also follow the tutorial below to help you add the network to **MetaMask**: {% embed url="" %} # Wallets ## MetaMask **MetaMask**, one of the most widely used wallets for EVM-compatible blockchains, can be easily configured to support the **ICB Network**. Since **ICB** is not added by default in MetaMask, users need to manually add the network to interact with ICB-based applications. To connect MetaMask to the ICB Mainnet, users can add the following network details: **RPC** **URL:** **Chain ID:** 73115 **RPC:** **Explorer:** **Symbol:** ICBX ### For testing and development purposes, the ICB Testnet can be added using: **RPC** **URL:** **Chain ID:** 73114 **RPC:** **Explorer:** **Symbol:** ICBT Once added, users can seamlessly interact with dApps deployed on the ICB Network using MetaMask, whether on the mainnet or testnet. MetaMask also supports features like token import, custom gas settings, and transaction history, making it a reliable and accessible choice for both developers and end users. **MetaMask Wallet:** ## Rabby **Rabby Wallet** includes a feature that automatically switches the wallet to the appropriate EVM-compatible chain based on the site you visit. As such, it should switch to the **ICB Network** automatically when you access a dApp built on this chain, offering a seamless onboarding experience. In addition to automatic network switching, Rabby Wallet is designed with security and usability in mind. It supports all major EVM chains out of the box and can detect which chain a dApp is running on, preventing incorrect network selections that could lead to failed transactions. Rabby also features **transaction simulation**, allowing users to preview the actual outcome of a transaction before signing it. This makes it a safer option for interacting with unfamiliar contracts. Furthermore, Rabby provides **multi-chain visibility**—users can view balances and recent activity across multiple EVM chains from a unified interface, improving transparency and user experience. Thanks to its open-source codebase and regular updates, Rabby Wallet is gaining traction among advanced users who prioritize both safety and convenience when managing digital assets across multiple networks. **Rabby Wallet:** ## Coinbase Wallet **Coinbase Wallet** is a user-friendly and secure mobile and browser-extension wallet that supports a wide range of EVM-compatible chains. Although it does not offer the same level of automatic network switching as Rabby Wallet, it can be configured to work with the **ICB Network**. If the **ICB** **Network** is integrated into your dApp using the standard `ethereum.request({ method: 'wallet_addEthereumChain' })` call, Coinbase Wallet will prompt users to approve the network configuration the first time they connect—making the onboarding process simple and intuitive. Once added, Coinbase Wallet will remember the ICB Network configuration and automatically switch to it when revisiting the app. For reference, the network configuration details are as follows:\ Coinbase Wallet also allows users to manage tokens, NFTs, and interact with DeFi apps directly from their mobile devices or browser, making it a great choice for users seeking a secure and intuitive experience on the ICB Network. **Coinbase Wallet Extension:** [https://chromewebstore.google.com/detail/coinbase-wallet-extension/hnfanknocfeofbddgcijnmhnfnkdnaad](https://chromewebstore.google.com/detail/coinbase-wallet-extension/hnfanknocfeofbddgcijnmhnfnkdnaad?hl=en\&source=wallet_coinbase_com&_branch_match_id=1316386243809622262&_branch_referrer=H4sIAAAAAAAAAyXIwQqAIAwA0L%2FpZt4D6dCHiM6lgrrYjN369oJuj1fmvGSzNtMK0egK1K2G1nCaRDoahbQL3Qzo%2FvZAdcQg%2BKEvD%2BOJzHVkH5lUkN1RmDq%2BP%2FZNvFgAAAA%3D) ## Ledger Hardware **Ledger hardware wallets**, such as the Ledger Nano S and Nano X, offer a secure way to manage digital assets on EVM-compatible networks — including the **ICB Network**. While Ledger does not provide a native ICB app, users can utilize the **Ethereum application** to interact with **ICB**. ### Setting Up Ledger for ICB Network #### **1. Install the Ethereum App on Ledger** \- Open **Ledger Live**\ \- Navigate to **My Ledger**\ \- In the App Catalog, find and install the **Ethereum** application #### **2. Add ICB Account** \- After installing the Ethereum app, click on **Add Account**\ \- Select **Ethereum** as the account type\ \- Complete the process to add the account ### Connecting Ledger to Web3 Wallets To interact with dApps on the ICB Network, connect your Ledger device to a Web3 wallet such as **MetaMask** or **Rabby**. #### **Using MetaMask** \- Open the MetaMask extension\ \- Click the account icon → **Connect Hardware Wallet**\ \- Choose **Ledger**, click **Continue**, and select your Ledger device\ \- Select the desired account and connect\ \- Add the ICB Network to MetaMask: **RPC** **URL:** **Chain ID:** 73115 **RPC:** **Explorer:** **Symbol:** ICBX #### **Using Rabby Wallet** \- Open the Rabby Wallet extension\ \- Click your wallet address → **Add New Address**\ \- Select **Connect Hardware Wallets** → Choose **Ledger**\ \- Connect and choose the account\ \- Add the ICB Network using the same details as above #### Using Ledger with ICB dApps Once your Ledger is connected to a Web3 wallet and the ICB Network is configured, you can safely interact with ICB-based dApps. Each transaction will require **physical confirmation** on your Ledger device, offering strong protection against unauthorized actions. **Ledger Live:**
# Tools, Libraries, and Frameworks ## ICB Network Overview **ICB Network** offers developers an exceptional environment for building decentralized applications, thanks to its high performance, scalability, and low transaction costs, all powered by its innovative PoS-based architecture and modern technology stack. With an average transaction confirmation time of just 4.9 seconds, **ICB Network** ensures a smooth and responsive experience for users — a critical advantage for real-time applications. Its full compatibility with the **Ethereum Virtual Machine (EVM)** makes it easy for developers to migrate or extend their existing Ethereum-based projects to **ICB** with minimal adjustments. Beyond performance, **ICB Network** is deeply committed to decentralization, sustainability, and future-proof design. Its architecture is optimized to support a wide variety of use cases, from DeFi and NFTs to data-intensive dApps, making it a flexible and powerful platform for building the next generation of Web3 applications. ## **Foundry** Foundry is a fast, developer-friendly smart contract toolkit written in Rust, optimized for Solidity-based development. It includes **forge** (a command-line tool for compiling, testing, and deploying smart contracts), **cast** (for sending transactions and making RPC calls), and **anvil** (a local Ethereum node). Foundry is known for its speed, native Solidity testing, and seamless CI integration, making it a favorite among power users and auditors. **Language:** Rust-based CLI, Solidity-focused\ **Best for:** Power users and speed-focused workflows #### Key Features * Ultra-fast testing and deployment (native binary) * Fuzz testing and property-based testing built-in * **forge** for testing, **cast** for scripting/chain interaction * Can run Solidity directly, no JavaScript needed * Easily integrates into CI/CD pipelines #### Use Case Power users, security researchers, audit preparation. #### Useful Link [Getting Started with Foundry](https://getfoundry.sh/introduction/getting-started) ## Hardhat Hardhat is a powerful development environment designed for building, testing, and deploying smart contracts on Ethereum-compatible blockchains. It offers built-in support for Solidity compilation, contract debugging, and local network simulation. With features like stack traces, Solidity console logs, and plugin extensibility, Hardhat provides developers with a robust workflow for full-stack dApp development. **Language:** TypeScript/JavaScript\ **Best for:** Local development, testing, debugging #### Key Features * Built-in Ethereum network for fast local testing * Powerful plugin ecosystem (e.g., Ethers.js, Waffle, OpenZeppelin) * Great for integrating with frontends and deployment scripts * Stack traces for Solidity errors #### Use Case Full-featured dApp development, custom scripting, and advanced debugging. #### Useful Link [Hardhat Official Website](https://hardhat.org/) ## Truffle Truffle is a well-established smart contract development framework that includes a testing suite, deployment pipeline, and asset management system. It integrates seamlessly with **Ganache**, a local blockchain simulator, and **Drizzle** for front-end development, offering an end-to-end development stack for Ethereum applications. **Language:** JavaScript\ **Best for:** Developers looking for a mature, integrated development suite #### Key Features * Automated contract migrations * Built-in testing with Mocha/Chai * Integration with Ganache (personal blockchain) * Drizzle for front-end integration #### Use Case Developers building dApps from scratch with a need for structured migrations and front-end support #### Useful Link [Truffle Suite (Archive)](https://archive.trufflesuite.com/) ## Remix Remix is a web-based integrated development environment (IDE) used for writing, compiling, deploying, and debugging Solidity smart contracts. **Language:** Solidity (Web-based interface, no local language dependencies)\ **Best for:** Beginners, educators, quick prototyping, and smart contract experimentation #### Key Features * Runs entirely in the browser — no installation required * Real-time Solidity compiler and runtime environment * Modular plugin architecture (e.g., static analysis, gas profiler, debugger) * Direct deployment to Ethereum mainnet or testnets via MetaMask * Supports multiple Solidity compiler versions * Integration with GitHub and IPFS for contract storage #### Use Case Educational purposes, rapid prototyping, hands-on learning of Solidity #### Useful Link [Remix IDE](https://remix.ethereum.org/) ## OpenZeppelin OpenZeppelin Contracts is a trusted library of modular, reusable, and audited smart contracts. It includes standard implementations for ERC20, ERC721, and upgradeable contracts, as well as tools for access control, governance, and security best practices. It is widely used in production-grade Ethereum applications. OpenZeppelin Contracts is a library of modular, reusable, and battle-tested smart contracts designed for building secure Ethereum-based applications. **Language:** Solidity\ **Best for:** Developers building production-grade contracts with standardized and secure implementations #### Key Features * Prebuilt, audited implementations for ERC20, ERC721, ERC1155, and more * Modules for access control, pausability, upgradeability, and role management * Actively maintained by OpenZeppelin with frequent security audits * Compatible with upgradeable proxy patterns via OpenZeppelin Upgrades * Integrates with Hardhat, Truffle, Foundry, and Tenderly #### Use Case DeFi protocols, NFT projects, DAOs, and any smart contract requiring security and standards compliance #### Useful Link [OpenZeppelin Contracts](https://www.openzeppelin.com/) ## Tenderly Tenderly is a powerful all-in-one platform for observing, debugging, monitoring, and simulating smart contract executions on Ethereum and EVM-compatible chains. **Language:** Platform-agnostic (supports Solidity contracts; integrates via APIs, SDKs, and UI)\ **Best for:** Real-time monitoring, debugging, and simulation of smart contracts in production or testing environments #### Key Features * Transaction-level debugging with step-by-step trace * Error decoding and revert reason display * Real-time smart contract monitoring and alerting * Gas usage insights and optimizations * Fork any network to simulate changes before deploying * Integrates with Hardhat, Foundry, Truffle, and more #### Use Case Developers and DevOps teams needing deep visibility into contract behavior, especially for post-deployment debugging, monitoring DeFi protocols, and simulating contract changes safely #### Useful Link [Tenderly Platform](https://tenderly.co/) # How to deploy? **ICB Network** is fully compatible with the **Ethereum Virtual Machine (EVM)**, meaning smart contracts written in Solidity can run on **ICB Network** just as they do on Ethereum, without requiring major changes. To deploy a smart contract on the **ICB Network**, you send a transaction containing the contract’s compiled bytecode without specifying a recipient address. This process consumes **ICBX tokens** as gas fees, which are required for deploying and interacting with contracts on the network. For development and testing purposes, you can request testnet **ICBX** tokens from the official faucet on the **ICB Testnet.** Once deployed, the smart contract becomes accessible to all users of the **ICB Network**. Just like user accounts, smart contracts are assigned a unique ICB Network address, allowing anyone to interact with them through standard transaction calls or web3 interfaces. ## Requirements for Deployment * **Compiled Bytecode**: The output of your Solidity contract compilation (`.bin` or `.json`), typically generated using tools like Hardhat, Foundry, Truffle, or Remix. * **ICBX Tokens**: A small amount of **ICBX** (the native token) is required to cover gas fees for deployment and interaction. * **Deployment Script or Tool**: Use a deployment framework such as **Hardhat, Foundry, Truffle**, or **thirdweb** to automate and manage the deployment process. * **Access to an ICB Node**: * Run your own ICB Network node locally or in the cloud, or * Use public [RPC access](https://chainlist.org/?search=icb\&testnets=true) (e.g., [`https://rpc1-mainnet.icbnetwork.info`](https://rpc1-mainnet.icbnetwork.info) or testnet endpoints). * **(Optional but Recommended) Verified Source Code**: For transparency and trust, consider verifying your contract on the [**ICBScan**](https://icbscan.io/) block explorer. # HardHat This section will guide you through deploying the Counter smart contract on the ICB Network using [Hardhat](https://hardhat.org/). Hardhat is a powerful development environment for Ethereum and EVM-compatible blockchains like **ICB**. It offers a robust framework for compiling, testing, deploying, and debugging smart contracts. With features like a built-in local Ethereum network, Solidity stack traces, and seamless plugin integration (e.g., with Ethers.js and OpenZeppelin), Hardhat simplifies the entire smart contract development workflow. ## Objectives By the end of this tutorial, you should be able to do the following: * Set up Hardhat for the **ICB Network** * Create a simple Counter smart contract * Compile the smart contract for deployment on **ICB** * Deploy the Counter contract to the **ICB Mainnet** and **Testnet** * Interact with the deployed contract using Hardhat scripts This tutorial will help you understand the end-to-end workflow of building and deploying smart contracts on an EVM-compatible blockchain like **ICB**. # Prerequisites ## **Node v18+** You'll need to have Node.js version 18 or higher installed to follow this tutorial.\ Download link: [Node v18+](https://nodejs.org/en/download/) ## Wallet funds To deploy smart contracts to the blockchain, you’ll need to pay a gas fee, which requires holding the network’s native token — **ICBX** in the case of the ICB Network. In this tutorial, we’ll be deploying the contract either to the **ICB Mainnet** or the **ICB Testnet**. * If you're using the **mainnet**, you’ll need to fund your wallet with ICBX tokens. These can be purchased from supported exchanges — visit the ICB Network page on CoinMarketCap to view available options. * If you’re deploying to the **ICB Testnet**, no real funds are needed. A faucet for acquiring free testnet tokens (ICBT) will be made available soon, enabling developers to test and experiment without any cost. Make sure your wallet is properly funded depending on which network you plan to deploy to before continuing with the tutorial. Before you can view your **ICBX** or **ICBT** balances in your wallet, you’ll need to **add the ICB Network to your wallet** by following the steps in the [*How to Connect with ICB Network*](/getting-started/how-to-connect-with-icbnetowork) section. Additionally, make sure you're using a compatible wallet — refer to the [*Wallets*](/getting-started/wallets) section for supported options like **MetaMask**, **Rabby**, or **Coinbase Wallet**. Before you can start deploying smart contracts to the ICB Network, you need to prepare your development environment by setting up a new Node.js project. To initialize a Node.js project, run the following command: ```bash npm init --y ``` Next, you’ll need to install Hardhat and set up a new project using it. To get started with Hardhat, run the following command to install it: ```bash npm install --save-dev hardhat ``` To initialize a new Hardhat project, use the following command: ```bash npx hardhat init ``` Choose **"Create a TypeScript project"** and press **Enter** to confirm the current directory as the project root. When prompted, select **"y"** to add a `.gitignore` file and to load the sample project. The setup process will take a few moments to complete. # Configuring Hardhat for ICB To deploy smart contracts to the ICB Network, you'll need to update your Hardhat project settings and include the ICB network configuration. To do this, open your `hardhat.config.ts` file and add the ICB network under the `networks` section: ```js require("@nomicfoundation/hardhat-toolbox"); require("dotenv").config(); module.exports = { solidity: { version: "0.8.20", settings: { optimizer: { enabled: true, runs: 1000, }, evmVersion: "paris", }, }, networks: { ICBTestnet: { url: "https://rpc1-testnet.icbnetwork.info", chainId: 73114, accounts: process.env.PRIVATE_KEY ? [process.env.PRIVATE_KEY] : [], }, ICBMainnet: { url: "https://rpc2-mainnet.icbnetwork.info", chainId: 73115, accounts: process.env.PRIVATE_KEY ? [process.env.PRIVATE_KEY] : [], }, }, }; ``` ## Installing Hardhat Toolbox The configuration relies on the **@nomicfoundation/hardhat-toolbox** plugin, which conveniently bundles essential packages and plugins commonly used in Hardhat development. To install it, run the following command: ```bash npm install --save-dev @nomicfoundation/hardhat-toolbox ``` ## Managing Environment Variables The configuration also utilizes the **dotenv** package to securely load the `PRIVATE_KEY` environment variable from a `.env` file into `process.env.PRIVATE_KEY`. This approach helps keep your private keys out of your source code and version control. To install **dotenv**, run the following command: ```bash npm install --save-dev dotenv ``` # Compiling the Smart Contract Here’s a basic Counter smart contract implemented using the Solidity programming language: ```solidity // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.13; contract Counter { uint256 public number; function setNumber(uint256 newNumber) public { number = newNumber; } function increment() public { number++; } } ``` The Solidity code shown above declares a smart contract called `Counter`. To compile the contract with Hardhat, execute the following command: ```bash npx hardhat compile ``` # Deploying the Smart Contract After successfully compiling your contract, you can proceed to deploy it to the **ICB Testnet**. To do so, update the `ignition/modules/Counter.js` file in your project with the necessary deployment logic: ```js const { buildModule } = require("@nomicfoundation/hardhat-ignition/modules"); module.exports = buildModule("CounterModule", (m) => { const initialNumber = m.getParameter("initialNumber", 0); const counter = m.contract("Counter", []); if (initialNumber !== 0) { m.call(counter, "setNumber", [initialNumber]); } return { counter }; }); ``` You'll also need to have **testnet ICBT** or **ICBX tokens** in your wallet. If you haven't obtained them yet, refer to the [Prerequisites](https://app.gitbook.com/o/jGflGFSUbio8Lp3Wxw6k/s/NGHmFVO7DlELOLs4PSVs/~/changes/81/build-on-icb-network/hardhat/prerequisites/~/page) section. Without sufficient funds, the deployment will not succeed! Once ready, execute the following command to deploy your Counter contract: ## ICB Mainnet ```bash npx hardhat ignition deploy ./ignition/modules/Counter.js --network ICBMainnet ```
## ICB Testnet
The contract will be deployed to either the **ICB Mainnet** or **ICB Testnet**, depending on the network specified in your deployment command. Once deployed, you can check the status and details of the contract using the appropriate block explorer — [**ICBScan Mainnet** ](https://icbscan.io/)or [**ICBScan Testnet**.](https://testnet.icbscan.io/) Simply search for the contract address returned by your deploy script. To interact with your contract via the block explorer, it must first be **verified** — either by you or someone else. Since the contract provided above is already verified, you should be able to view and interact with your deployed version right away. # Debugging smart contract using Hardhat? In this guide, you'll explore how to debug smart contracts using Hardhat's built-in debugging tools. ## Learning Goals By the end of this guide, you will be able to: * Utilize `console.log` to output debugging information * Identify common errors and understand how to resolve them * Distinguish between errors originating from the contract and those caused by the test code ## Overview Debugging smart contracts can be complex, particularly in the context of decentralized applications and blockchain systems. Fortunately, **Hardhat** offers robust tools that make the process more manageable. In this tutorial, you'll dive into Hardhat's core debugging features and learn practical techniques for identifying and fixing common issues in your smart contracts. # Your First console.log A standout feature of Hardhat is the ability to use console.log for debugging directly within your smart contracts. To enable this, you need to import hardhat/console.sol into the contract you want to debug. For instance, in the Lock.sol contract, you can import hardhat/console.sol and add a few console.log statements in the constructor—such as printing "Creating" and displaying the contract’s Ether balance. This not only confirms that the contract was deployed successfully but also allows you to log useful information, like the balance right after deployment. ```solidity // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.20; import "hardhat/console.sol"; contract Counter { uint256 public number; function setNumber(uint256 newNumber) public { number = newNumber; console.log("Number set to", newNumber); } function increment() public { number++; console.log("Number incremented to", number); } } ``` To test the contract, create a new file named Counter.js inside the test directory and add the following content: ```javascript const { time, loadFixture, } = require("@nomicfoundation/hardhat-toolbox/network-helpers"); const { anyValue } = require("@nomicfoundation/hardhat-chai-matchers/withArgs"); const { expect } = require("chai"); describe("Counter", function () { async function deployCounterFixture() { const [owner, otherAccount] = await ethers.getSigners(); const Counter = await ethers.getContractFactory("Counter"); const counter = await Counter.deploy(); return { counter, owner, otherAccount }; } describe("Deployment", function () { it("Should set the initial number to 0", async function () { const { counter } = await loadFixture(deployCounterFixture); expect(await counter.number()).to.equal(0); }); }); describe("Functions", function () { describe("setNumber", function () { it("Should set the number to the provided value", async function () { const { counter } = await loadFixture(deployCounterFixture); const newNumber = 42; await counter.setNumber(newNumber); expect(await counter.number()).to.equal(newNumber); }); it("Can be called by any account", async function () { const { counter, otherAccount } = await loadFixture(deployCounterFixture); const newNumber = 100; await counter.connect(otherAccount).setNumber(newNumber); expect(await counter.number()).to.equal(newNumber); }); }); describe("increment", function () { it("Should increment the number by 1", async function () { const { counter } = await loadFixture(deployCounterFixture); expect(await counter.number()).to.equal(0); await counter.increment(); expect(await counter.number()).to.equal(1); }); it("Should work with non-zero initial values", async function () { const { counter } = await loadFixture(deployCounterFixture); const initialValue = 41; await counter.setNumber(initialValue); await counter.increment(); expect(await counter.number()).to.equal(initialValue + 1); }); it("Can be called by any account", async function () { const { counter, otherAccount } = await loadFixture(deployCounterFixture); expect(await counter.number()).to.equal(0); await counter.connect(otherAccount).increment(); expect(await counter.number()).to.equal(1); }); }); }); }); ``` Then you can run: ```bash npx hardhat test ``` You should see the following in the terminal:
# A note on console.log In the previous example, you used console.log to output basic debugging information. Keep in mind that Solidity’s console.log is more limited than what you might be used to in other programming languages, where nearly any data type can be logged. In Solidity, console.log supports up to four parameters of the following types: 1\. uint\ 2\. string\ 3\. bool\ 4\. address Hardhat also provides additional logging functions to support other types, including: \- console.logInt(int i)\ \- console.logBytes(bytes memory b)\ \- console.logBytes1(bytes1 b)\ \- console.logBytes2(bytes2 b)\ \- ...\ \- console.logBytes32(bytes32 b) These functions are useful when you need to log values outside the basic supported types. For more information, consult the official console.log documentation. # Identifying Common Errors When working with smart contracts, especially on the ICB Network, it's important to recognize and understand common errors that may occur during development. Being able to identify and resolve these issues efficiently is a key part of the debugging process. In our ICB Learn tutorial series, we address several compile-time errors in the Error Triage section. However, other issues—such as transaction reverts or out-of-bounds array access—can surface unexpectedly during contract execution. In the sections below, you'll explore proven techniques to help you debug and troubleshoot these runtime errors effectively. ## Revert Errors When a transaction fails because of a require or revert statement, it's essential to investigate why the condition wasn't satisfied. This often means checking input parameters, contract state variables, or specific conditions within the logic. For example, in the `Counter.sol` contract, there's a require statement that ensures the newNumber parameter is less than 100. To debug this type of error, a practical approach is to log newNumber: ```solidity // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.20; import "hardhat/console.sol"; contract CounterError { uint256 public number; uint256 public constant MAX_NUMBER = 100; address public owner; constructor() { owner = msg.sender; console.log("Contract deployed by:", owner); console.log("Initial number:", number); console.log("MAX_NUMBER:", MAX_NUMBER); } function setNumber(uint256 newNumber) public { console.log("setNumber called with:", newNumber); console.log("Current number:", number); console.log("Caller:", msg.sender); console.log("Owner:", owner); console.log("MAX_NUMBER:", MAX_NUMBER); require(msg.sender == owner, "Only owner can set the number"); require(newNumber <= MAX_NUMBER, "Number cannot exceed maximum limit"); number = newNumber; console.log("Number successfully set to:", newNumber); } function increment() public { console.log("increment called"); console.log("Current number:", number); console.log("Caller:", msg.sender); require(msg.sender == owner, "Only owner can increment"); require(number < MAX_NUMBER, "Cannot increment: would exceed maximum"); number++; console.log("Number incremented to:", number); } function getState() public view returns ( uint256 currentNumber, uint256 maxNumber, address currentOwner ) { return (number, MAX_NUMBER, owner); } } ``` When you run the tests with `npx hardhat test`, you'll then see the following:
You can now clearly see the value of newNumber, which makes it easier to identify the issue. In this case, it's evident that newNumber is less than 100, which explains why the condition fails. ## Unintended Behavior Errors ```solidity // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.19; import "hardhat/console.sol"; import {Counter} from "./Counter.sol"; contract CounterCreator { Counter[] internal counters; function createCounter(uint256 _initialNumber) external payable { Counter newCounter = new Counter(); newCounter.setNumber(_initialNumber); counters.push(newCounter); console.log("Ether received but stuck in CounterCreator:", msg.value); } function getCountersCount() external view returns (uint256) { return counters.length; } function getCounter(uint256 index) external view returns (address) { require(index < counters.length, "Counter index out of bounds"); return address(counters[index]); } } ``` You can write a test file named `CounterCreat.test.js` to help detect the issue and implement a solution. ```javascript const { expect } = require("chai"); const { ethers } = require("hardhat"); describe.only("CounterCreator Tests", function () { const INITIAL_NUMBER = 42; const VALUE_SENT = ethers.parseEther("0.01"); let counterCreatorInstance; let ownerSigner; let userSigner; before(async () => { const signers = await ethers.getSigners(); ownerSigner = signers[0]; userSigner = signers[1]; const CounterCreatorFactory = await ethers.getContractFactory("CounterCreator"); counterCreatorInstance = await CounterCreatorFactory.connect(ownerSigner).deploy(); }); it("should demonstrate the stuck Ether problem", async () => { const initialBalance = await ethers.provider.getBalance(counterCreatorInstance.target); expect(initialBalance).to.equal(0); await counterCreatorInstance.connect(userSigner).createCounter(1, { value: VALUE_SENT, }); const contractBalance = await ethers.provider.getBalance(counterCreatorInstance.target); expect(contractBalance).to.equal(VALUE_SENT); const targetContract = await counterCreatorInstance.getCounter(0); const targetContractBalance = await ethers.provider.getBalance(targetContract); console.log("ETH received by target contract", ethers.formatEther(targetContractBalance)); expect(targetContractBalance).to.equal(0); }); }); ``` The terminal output below shows that the balance is 0:
Although this issue can be caught by writing more comprehensive test cases with proper assertions, the missing transfer of Ether from CounterCreator to the Counter contract is an important detail that might have been unintentionally overlooked. To resolve this, you should update the `createCounter` function as follows: ```solidity function createCounter(uint256 _initialValue) external payable { Counter newCounter = new Counter{ value: msg.value }(_initialValue); counters.push(newCounter); } ``` ## Out-of-Bounds Errors Accessing an array with an invalid index can result in runtime errors. For example, in a `CounterCreator` contract, you might use a custom function like this to retrieve all `Counter` contract instances: ```solidity function getAllCounters() external view returns (Counter[] memory result) { result = new Counter[](counters.length); for (uint i = 0; i <= counters.length; i++) { result[i] = counters[i]; } } ``` However, this implementation contains a common mistake: the loop condition `i <= counters.length` causes an out-of-bounds access on the last iteration. It should be `i < counters.length` instead. While you could make the `counters` array public to access the data directly, using a custom function like `getAllCounters` is useful for illustrating and controlling how the data is exposed. You can verify the function using the following test case: ```javascript it("should get all counters", async () => { await counterCreatorInstance.connect(userSigner).createCounter(10, { value: VALUE_SENT, }); const allCounters = await counterCreatorInstance.getAllCounters(); console.log("All counter addresses:", allCounters); expect(allCounters.length).to.equal(1); for (let i = 0; i < allCounters.length; i++) { expect(allCounters[i]).to.not.equal(ethers.ZeroAddress); console.log(`Counter ${i} address:`, allCounters[i]); } for (let i = 0; i < allCounters.length; i++) { const individualAddress = await counterCreatorInstance.getCounter(i); expect(allCounters[i]).to.equal(individualAddress); } }); ``` Which will then throw an error:
You can include some debugging logs to identify the issue: ```solidity function getAllCounters() external view returns (address[] memory result) { result = new address[](counters.length); console.log("Counters length %s", counters.length); for (uint i = 0; i <= counters.length; i++) { console.log("Counter index %s", i); result[i] = address(counters[i]); } } ``` Then, you see the following in the terminal:
Since arrays in Solidity are zero-indexed, an array containing one item stores that item at index 0. In the example above, the if statement uses `<=` in the loop condition, which causes it to attempt access at index 1—an invalid position—resulting in a crash. Here's a straightforward fix: ```solidity function getAllCounters() external view returns (address[] memory result) { result = new address[](counters.length); console.log("Counter length %s", counters.length); for (uint i = 0; i < counters.length; i++) { console.log("Counter index %s", i); result[i] = address(counters[i]); } } ``` Which immediately solves the problem:
# Enhancing Smart Contract Efficiency by Optimizing Gas Usage In this guide, you’ll discover how to analyze and reduce your smart contract's gas consumption using Hardhat and the Hardhat Gas Reporter plugin. ## Objectives By the end of this tutorial, you will be able to:\ \- Utilize the Hardhat Gas Reporter plugin to analyze gas consumption\ \- Identify and explain common techniques for optimizing a smart contract’s gas usage ## **Overview** In smart contract development, optimizing gas consumption is crucial for improving efficiency and reducing costs. Contracts that are more compact and efficient not only deploy faster but also execute with lower gas fees, providing a better experience and significant savings for end users. This tutorial will guide you through using the Hardhat Gas Reporter plugin to profile and optimize your smart contract's gas usage. By analyzing gas consumption at the function level, you'll gain insights into which parts of your code are the most expensive and learn how to refactor them for better performance. The sections below will cover key techniques for gas optimization, common pitfalls to avoid, and how to interpret gas usage reports to make informed decisions when writing or improving smart contracts. # Configuring the Hardhat Gas Reporter Plugin The Hardhat Gas Reporter plugin is a powerful utility for analyzing the gas consumption of your smart contracts. It provides detailed insights into the gas costs of individual functions, helping you spot areas where optimizations can significantly reduce expenses. This makes it especially valuable during the development phase, when efficiency is a priority. To get started, install the plugin by running: ```bash npm install -D hardhat-gas-reporter ``` Next, import the plugin in your `hardhat.config.ts` file: ```bash require("hardhat-gas-reporter"); ``` # Getting Started with Gas Profiling Begin by creating a smart contract named `Inventory` with the following configuration: ```solidity // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.20; contract Inventory { address public manager; uint256 public totalProducts; struct Product { uint256 id; string description; uint256 price; } mapping(uint256 => Product) public products; constructor() { manager = msg.sender; } function addProduct(string memory description, uint256 price) external { require(msg.sender == manager, "invalid manager"); totalProducts++; products[totalProducts] = Product( totalProducts, description, price ); } } ``` Add a test file named `Inventory.js` to evaluate the gas reporter plugin. This file should include the following content: ```javascript const { expect } = require("chai"); const { ethers } = require("hardhat"); describe.only("Inventory tests", function () { let instance; let owner; before(async () => { const Inventory = await ethers.getContractFactory("Inventory"); instance = await Inventory.deploy(); await instance.waitForDeployment(); const signers = await ethers.getSigners(); owner = signers[0]; }); it("should add a product", async () => { const description = "Laptop"; const price = ethers.parseEther("1.5"); await instance.addProduct(description, price); expect(await instance.totalProducts()).to.equal(1); }); it("should store product details correctly", async () => { const description = "Mouse"; const price = ethers.parseEther("0.05"); await instance.addProduct(description, price); const product = await instance.products(2); expect(product.id).to.equal(2); expect(product.description).to.equal(description); expect(product.price).to.equal(price); }); it("should only allow manager to add products", async () => { const signers = await ethers.getSigners(); const nonManager = signers[1]; const description = "Keyboard"; const price = ethers.parseEther("0.1"); await expect( instance.connect(nonManager).addProduct(description, price) ).to.be.revertedWith("invalid manager"); }); it("should verify manager is set correctly", async () => { expect(await instance.manager()).to.equal(owner.address); }); }); ``` Run `npx hardhat test` to execute the tests. A gas usage report will be generated as shown below:
# Typical Approaches to Reduce Contract Size and Gas Costs Once you’ve completed your initial gas profiling, you can begin exploring strategies to reduce gas usage. There are numerous optimization techniques available, and this tutorial will highlight just a few foundational examples. ## Enabling and Tuning the Optimizer The gas report reveals that the Solidity optimizer is currently configured with 1,000 runs. While this setting can reduce runtime gas costs, it also increases the deployment cost of the contract. By lowering the number of optimizer runs—for example, to 200—you can reduce deployment costs. Here’s what that change looks like: You can update `hardhat.config.js:` ```javascript solidity: { version: "0.8.20", settings: { optimizer: { enabled: true, runs: 200 } } } ``` After that run again n`px hardhat test:`
This change provides immediate improvements in deployment gas costs, although it may slightly increase the gas used during transaction execution. ## Leveraging Immutable Variables Within the Inventory contract, you may notice certain variables that are only assigned during contract deployment. These are ideal candidates for the `immutable` keyword, which allows variables to be set once at construction time and then remain unchanged—offering gas savings by reducing storage reads. By updating the `Inventory` contract as follows: ```solidity // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.20; contract Inventory { address public immutable manager; uint256 public totalProducts; struct Product { uint256 id; string description; uint256 price; } mapping(uint256 => Product) public products; constructor() { manager = msg.sender; } function addProduct(string memory description, uint256 price) external { require(msg.sender == manager, "invalid manager"); totalProducts++; products[totalProducts] = Product( totalProducts, description, price ); } } ``` Next, run the gas reporter again. You should observe the following output:
This already shows noticeable improvements. ## Minimize Unnecessary Data Storage Storing data directly on-chain within a smart contract is a key design decision that comes with both advantages and trade-offs. On the pro side, keeping data in the contract ensures that all critical information is readily accessible and verifiable on-chain. This eliminates the need to rely on external services, off-chain databases, or event logs to retrieve or reconstruct the contract's state, which can enhance transparency and reliability. However, the cons are significant. Storing large amounts of data on-chain increases gas consumption, making contract interactions more expensive for users. This can lead to high costs for both deployment and function execution, especially if frequent updates or large datasets are involved. As a best practice, only essential data that must remain on-chain for security or verifiability should be stored in the contract. For non-critical or large data, consider using off-chain storage solutions (like IPFS or traditional databases) and referencing them via hashes or identifiers stored in the contract. This hybrid approach helps reduce gas costs while maintaining trust and transparency. In the `Inventory` smart contract, the following code is present: ```solidity struct Product { uint256 id; string description; uint256 price; } mapping(uint256 => Product) public products; ``` Upon closer inspection, you'll notice that the `id` field within the `Product` struct and the key used in the mapping serve the same purpose. To eliminate redundancy, you can remove the `id` from the `Product` struct, as it's already represented by the mapping key. The updated contract would look like this: ```solidity // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.20; contract Inventory { address public immutable manager; uint256 public totalProducts; struct Product { string description; uint256 price; } mapping(uint256 => Product) public products; constructor() { manager = msg.sender; } function addProduct(string memory description, uint256 price) external { require(msg.sender == manager, "invalid manager"); totalProducts++; products[totalProducts] = Product(description, price); } } ``` When you execute the gas reporter again, the output will be:
This results in a further reduction in the gas consumption of the `Inventory` smart contract. However, you can optimize even more by avoiding on-chain storage entirely for certain data. Instead of saving items in a mapping, you can emit events and treat them as a lightweight, cost-effective form of storage. For example, you can update the contract as follows: ```solidity // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.20; contract Inventory { address public immutable manager; uint256 public totalProducts; struct Product { string description; uint256 price; } event ProductCreated(uint256 id, Product product); constructor() { manager = msg.sender; } function addProduct(string memory description, uint256 price) external { require(msg.sender == manager, "invalid manager"); totalProducts++; emit ProductCreated(totalProducts, Product(description, price)); } } ``` Notice that, rather than storing the items in state, the contract now emits an `ItemCreated` event. This approach significantly lowers gas costs for both deployment and function execution:
As demonstrated, the gas savings from this approach are substantial. However, the trade-off is that to retrieve all items, you'll now need to parse through all `ItemCreated` events emitted by the contract, as the data is no longer stored on-chain. ## Using Custom Errors Another effective method to reduce gas costs is to replace `require` statements with custom errors. Custom errors are more gas-efficient, especially when used frequently. For example, you can refactor your code like this: ```solidity // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.20; contract Inventory { address public immutable manager; uint256 public totalProducts; error InvalidManager(); struct Product { string description; uint256 price; } event ProductCreated(uint256 id, Product product); constructor() { manager = msg.sender; } function addProduct(string memory description, uint256 price) external { if (msg.sender != manager) { revert InvalidManager(); } totalProducts++; emit ProductCreated(totalProducts, Product(description, price)); } } ``` This generates the following gas usage report:
Observe the reduction in deployment gas costs as a result of this change. ## Conclusion In this tutorial, you explored several practical strategies for profiling and optimizing the gas usage of your smart contracts using the Hardhat development framework and the Hardhat Gas Reporter plugin. By applying these techniques, you can build smarter, more efficient contracts that reduce transaction costs and improve the user experience. Lower gas fees not only make your contracts more accessible but also contribute to the overall scalability and sustainability of your decentralized application. # Hardhat: Reducing Smart Contract Size In this tutorial, you’ll discover how to analyze and minimize the size of your smart contracts using Hardhat and the Hardhat Contract Sizer plugin. ## Goals By the end of this tutorial, you will be able to: \- Use the Hardhat Contract Sizer plugin to evaluate contract size\ \- Explain common techniques for keeping contract size within limits\ \- Understand how inheritance affects the compiled bytecode size\ \- Identify how external contract references contribute to overall bytecode\ \- Assess how the use of libraries influences contract size\ \- Evaluate the role of the Solidity optimizer in reducing bytecode size ## Overview In the Ethereum and broader blockchain ecosystem, minimizing smart contract size is essential. Smaller contracts require less gas to deploy and execute, resulting in lower costs for users. Thankfully, Hardhat offers the `hardhat-contract-sizer` plugin, a useful tool for analyzing and optimizing your smart contract sizes efficiently. # Installing and Configuring the Hardhat Contract Sizer Plugin The Hardhat Contract Sizer is a plugin developed by the community that helps you measure the size of your smart contracts by displaying their compiled bytecode size directly in the terminal. This is particularly useful during development, as it allows you to quickly spot contracts that may exceed the permitted size limit. Keep in mind that, on the Ethereum mainnet, the maximum allowed size for a deployed smart contract is **24 KiB (24,576 bytes)**. Exceeding this limit will cause deployment to fail. To install the plugin, run the following command: ```bash npm install --save-dev hardhat-contract-sizer ``` Next, import the plugin in your `hardhat.config.js` file: ```javascript require("hardhat-contract-sizer"); ``` # Your First Size Profiling Just like in earlier tutorials, you'll start by checking the size of a smart contract—this time, `Counter.sol`. Once you’ve installed and configured the `hardhat-contract-sizer` plugin, run the following command: ```bash npx hardhat size-contracts ``` This command, added by the plugin, will analyze your contracts and display their compiled bytecode size directly in the terminal. You’ll then see the size report for `Counter`, along with any other compiled contracts in your project.
Although the contract is straightforward, the effectiveness of the `hardhat-contract-sizer` plugin becomes clear right away—it provides instant feedback on the size of your compiled contracts. # Common Techniques for Reducing Contract Size To demonstrate several strategies for optimizing contract size, start by creating two contracts: `OptimizedCalculator.sol` and `AdvancedCalculator.sol`, using the following structure: ```solidity // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.19; contract OptimizedCalculator { function add(uint256 a, uint256 b) external pure returns (uint256) { require(a > 0 && b > 0, "Invalid values"); return a + b; } function sub(uint256 a, uint256 b) external pure returns (uint256) { require(a > 0 && b > 0, "Invalid values"); return a - b; } function mul(uint256 a, uint256 b) external pure returns (uint256) { require(a > 0 && b > 0, "Invalid values"); return a * b; } function div(uint256 a, uint256 b) external pure returns (uint256) { require(a > 0 && b > 0, "Invalid values"); return a / b; } } ``` ```solidity // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.19; import "./OptimizedCalculator.sol"; contract AdvancedCalculator is OptimizedCalculator { function power(uint256 base, uint256 exponent) public pure returns (uint256) { require(base > 0 && exponent > 0, "Invalid values"); return base ** exponent; } } ``` Next, execute the command `npx hardhat size-contracts` once more, and you should see the following output:
Observe that the size of `AdvancedCalculator` is larger than that of `OptimizedCalculator`. This increase is due to `AdvancedCalculator` inheriting from `OptimizedCalculator`, meaning it includes all the functionality and code from the parent contract—which directly impacts its overall size. ## Code Abstraction and Modifiers At this stage, as a smart contract developer, it's a good idea to review your code and identify opportunities for optimization. One of the first things you'll likely observe in the codebase is the frequent use of `require` statements. Instead of writing `require(a > 0 && b > 0, "Invalid values");` multiple times, a more efficient approach is to abstract this repetitive logic into a modifier, like the example below: ```solidity // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.19; contract OptimizedCalculator { error InvalidInput(); function add(uint256 a, uint256 b) external pure onlyValidInputs(a, b) returns (uint256) { return a + b; } function sub(uint256 a, uint256 b) external pure onlyValidInputs(a, b) returns (uint256) { return a - b; } function mul(uint256 a, uint256 b) external pure onlyValidInputs(a, b) returns (uint256) { return a * b; } function div(uint256 a, uint256 b) external pure onlyValidInputs(a, b) returns (uint256) { return a / b; } modifier onlyValidInputs(uint256 a, uint256 b) { if (a == 0 || b == 0) { revert InvalidInput(); } _; } } ``` And for `AdvancedCalculator`: ```solidity // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.19; import "./OptimizedCalculator.sol"; contract AdvancedCalculator is OptimizedCalculator { function power(uint256 base, uint256 exponent) public pure onlyValidInputs(base, exponent) returns (uint256) { return base ** exponent; } } ``` Take note of how the modifier is used along with the replacement of the `require` statement by a custom error, which is a more gas-efficient approach. After running the `npx hardhat size-contracts` command again, you should see the updated size output:
Even though the size reduction is minor, you can already observe some improvement.\ This optimization process can be repeated until you’re satisfied with the contract’s final size. ## Splitting Into Multiple Contracts A common practice in smart contract development is to break down larger contracts into smaller, modular ones. This isn’t just useful for staying within size limits—it also improves code clarity, promotes better abstraction, and helps avoid redundancy. From a size optimization standpoint, splitting a large contract into smaller, standalone ones helps ensure each individual contract remains under the Solidity size limit. For instance, if an initial contract is 30 KiB, dividing it into two separate contracts could yield two contracts of around 15 KiB each—both within acceptable limits. However, it’s important to note that this approach may increase gas costs during execution, as calls to external contracts are more expensive. To demonstrate this, let’s create a contract named `Car` with a function called `startJourney`: ```solidity // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.20; contract Car { function startJourney() external pure returns (string memory) { return "The journey has started!"; } } ``` In this example, the `startJourney` function of the `Car` contract depends on specific functionality provided by two separate contracts: `Dashboard` for handling speed display logic and `Engine` for starting the vehicle. Engine contract: ```solidity // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.19; import "hardhat/console.sol"; contract Engine { function ignite() external view { console.log("Engine started"); } } ``` Dashboard contract: ```solidity // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.19; contract Dashboard { function showSpeed(uint256 speed) external pure returns (uint256) { require(speed > 0, "Speed must be greater than 0"); return speed; } } ``` The simplest way for the `Car` contract to access both the `Dashboard` and `Engine` functionalities would be through inheritance. However, as these contracts continue to grow with added features, the overall size of the compiled code will increase. Eventually, you may hit the contract size limit, since all the inherited logic is copied into the `Car` contract. A better approach is to keep each functionality within its own dedicated contract. If the `Car` needs to use those features, it can interact with the `Dashboard` and `Engine` contracts via external calls. In this scenario, the `startJourney` function within the `Car` contract needs to call both the `Dashboard` and `Engine` to complete its operation. ```solidity // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.20; import "./Engine.sol"; import "./Dashboard.sol"; contract Car { Engine private engine; Dashboard private dashboard; constructor(address _engine, address _dashboard) { engine = Engine(_engine); dashboard = Dashboard(_dashboard); } function startJourney() external view { engine.ignite(); dashboard.showSpeed(100); } } ``` When you run the contract sizer plugin, you'll see the following output:
Observe how the `Car` contract remains relatively small in size, yet it can still access the full functionality provided by both the `Engine` and `Dashboard` contracts. While this modular approach helps keep each contract within size limits, it's important to note that it may lead to increased gas costs due to external calls—this trade-off is explored in more detail in the Gas Optimization article. ## Leveraging Libraries Libraries are a widely used method for encapsulating and reusing common logic across multiple smart contracts. They can play a major role in reducing contract size and improving code maintainability. In Solidity, libraries can be categorized as either **internal** or **external**. Internal libraries function similarly to inherited contracts—when you use them, their code is copied into the final contract during compilation, which increases the contract’s bytecode size. On the other hand, external libraries behave differently. Solidity interacts with them through a special low-level operation called `delegatecall`, allowing the calling contract to execute the library's code in its own context. Because external libraries are stateless, they behave much like pure functions and can be deployed once and reused by multiple contracts. In the following example, the `Car` contract will make use of a `Calculator` library only. Here’s how that would look: ```solidity // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.20; library Calculator { error InvalidInput(); modifier onlyValidInputs(uint256 a, uint256 b) { if (a == 0 || b == 0) { revert InvalidInput(); } _; } function add(uint256 a, uint256 b) external pure onlyValidInputs(a, b) returns (uint256) { return a + b; } function sub(uint256 a, uint256 b) external pure onlyValidInputs(a, b) returns (uint256) { return a - b; } function mul(uint256 a, uint256 b) external pure onlyValidInputs(a, b) returns (uint256) { return a * b; } function div(uint256 a, uint256 b) external pure onlyValidInputs(a, b) returns (uint256) { return a / b; } } ``` Than Car is: ```solidity // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.19; import "./Engine.sol"; import "./Dashboard.sol"; import "./Calculator.sol"; contract Car { using Calculator for uint256; Engine private engine; Dashboard private dashboard; uint256 private speed; constructor(address _engine, address _dashboard) { engine = Engine(_engine); dashboard = Dashboard(_dashboard); } function startJourney() external { engine.ignite(); uint256 localSpeed = dashboard.showSpeed(100); speed = speed.add(localSpeed); } function getSpeed() external view returns (uint256) { return speed; } } ``` Observe how the contract is instructed to use the `Calculator` library for `uint256` types. This allows the `add` function from the `Calculator` library to be used directly on any `uint256` value within the `startJourney` function. After running the `npx hardhat size-contracts` command, you will see the following output:
## Enabling the Solidity Compiler Optimizer An additional method to reduce smart contract size is by enabling the Solidity optimizer. According to the official Solidity documentation:\ The optimizer works by simplifying complex expressions, which helps lower both the size of the compiled code and its execution cost. To activate the optimizer in Hardhat, simply add the following configuration to your `hardhat.config.ts` file: ```javascript require("@nomicfoundation/hardhat-toolbox"); require("hardhat-contract-sizer"); require("dotenv").config(); module.exports = { solidity: { version: "0.8.20", settings: { optimizer: { enabled: true, runs: 200, }, evmVersion: "paris", }, }, gasReporter: { enabled: true, }, networks: { ICBTestnet: { url: "https://rpc1-testnet.icbnetwork.info", chainId: 73114, accounts: process.env.PRIVATE_KEY ? [process.env.PRIVATE_KEY] : [], }, ICBMainnet: { url: "https://rpc2-mainnet.icbnetwork.info", chainId: 73115, accounts: process.env.PRIVATE_KEY ? [process.env.PRIVATE_KEY] : [], }, }, }; ``` With 1,000 runs result will be:
We decrease the number of runs from 1,000 to 200 and you can see some improvements for the `Car` contract:
The contract size may have increased, but this trade-off typically leads to better runtime efficiency. A higher `runs` value in the optimizer setting makes execution cheaper, although it results in a more expensive deployment. For more details, refer to the official [Solidity documentation](https://docs.soliditylang.org/en/latest/). ## Final Thoughts In this tutorial, you explored how to analyze and reduce smart contract sizes using the Hardhat development environment alongside the Hardhat Contract Sizer plugin. By understanding the impact of contract size, you've gained practical tools and techniques to write more efficient and maintainable Solidity code. As you progress in your smart contract development journey, remember that optimizing for size is an ongoing process. Balancing bytecode size, gas costs, and code readability requires thoughtful design decisions throughout the development lifecycle. # How to verify a smart contract? In the next part of this tutorial, we’ll guide you through the process of verifying your own smart contract on the ICB Mainnet and ICB Testnet. **ICB Mainnet verification:**\ Contract address: `0x6171cB11F6137c47730415e806D61C101883f16A` **Steps to verify:** 1. Go to the deployed contract address on [icbscan.io](https://icbscan.io). 2. Search for the contract address. 3. Press the **Contract** tab, then click **Verify & Publish**. 4. Select the contract license. 5. Select the verification model or compiler type. 6. Select the compiler version. 7. Select the EVM version. 8. Enable or disable **“Optimization enable”**. If enabled, provide the number of runs. 9. Add the contract source code. 10. Press **Verify & Publish** after checking all the information. In our case will be:
After you verified it successfully, a green checkmark will appear next to your contract on ICBScan.
You can start interacting with the contract directly from ICBScan. To do this, go to the **Read / Write Contract** tab.
Connect your wallet and start interacting with the contract! # POS (Proof of Stake & authority) ### Proof of Stake (PoS) Explained PoS stands for Proof of Stake, a blockchain consensus mechanism that combines elements of both Proof of Stake (PoS) and Proof of Work (PoW) to achieve faster transaction speeds, lower energy consumption, and more efficient governance. Here's how it works: **1. Token Staking:** PoS participants stake their tokens to secure the network. Staking involves locking up a portion of your tokens in a smart contract, essentially indicating your commitment to the network's stability. **2. Block Production:** Block producers compete to create the next block on the blockchain. This competition can involve solving cryptographic puzzles (similar to PoW) or using an alternative consensus algorithm depending on the specific PoS implementation. **3. Rewards:** Block producers who successfully create blocks receive rewards in the form of newly minted tokens or transaction fees. This incentivizes them to act honestly and maintain the network's security. **Advantages of PoS:** * **Faster Transaction Speeds:** PoS eliminates the need for all stakers to participate in consensus, leading to faster block times and higher transaction throughput compared to standard PoS. * **Lower Energy Consumption:** PoS avoids the energy-intensive mining process of PoW, making it a more sustainable and environmentally friendly option. * **Improved Governance:** Voting allows for more direct participation in network governance, potentially leading to faster decision-making and increased community involvement. * **Scalability:** PoS has the potential to scale efficiently as the network grows due to its limited number of block producers. # Delegators and Fee Sharing **ICB Token Staking: Understanding the Different Delegator Categories** Welcome to our comprehensive guide on ICB Token Staking. In this section, we'll explore the different types of delegators in our ecosystem: Non-KYC Delegator, KYC Delegator, and Slot Delegator. Each category has unique features and rewards structures, designed to cater to various user preferences and requirements. #### Non-KYC Delegator * **Stake:** Native ICB Tokens. * **Reward Token:** Receives GICB Tokens (Governance Token). * **Rewards:** No project-specific rewards. * **Limit:** No cap on the number of delegators. * **Fees Share:** 10% of the fees. * **Reward Calculation:** For example, if Validator1 mines X blocks and collects fees, 10% of these fees are distributed among the connected delegators. * **Staking Reward Percentage:** Adjusted via contract. E.g., 10% for 6 months, 25% for 1 year. * **Fee Burn Rate:** 10% of block fees are burned. #### KYC Delegator * **Stake:** Native ICB Tokens. * **Reward Token:** Receives GICB Tokens (Governance Token). * **Rewards:** No project-specific rewards. * **Limit:** Unlimited number of delegators. * **Fees Share:** 40% of the fees. * **Reward Calculation:** E.g., Validator1 mines X blocks, 40% of these fees go to the connected delegators. * **Staking Reward Percentage:** Managed through contract. E.g., 15% for 6 months, 30% for 1 year. * **Fee Burn Rate:** 10% of block fees are burned. #### Slot Delegator * **Stake:** Native ICB Tokens. * **Reward Token:** Receives GICB Tokens (Governance Token). * **Rewards:** Project-specific rewards available. * **Limit:** A fixed number of slots for delegators. * **Fees Share:** 40% of the fees. * **Additional Benefit:** 75% of transaction fees used in project operations are allocated to the Slot Delegator's address (or registered project owner's address). * **Reward Calculation:** For instance, if Validator1 mines X blocks, 40% of these fees are divided among the linked delegators. * **Staking Reward Percentage:** Set via contract. E.g., 10% for 6 months, 25% for 1 year. * **Fee Burn Rate:** 5% of block fees are burned.
# Architecture
**JSON-RPC :** is a simple protocol that allows data to be encoded and transported using JSON (JavaScript Object Notation) between client apps and blockchain nodes. It's a common interface by which apps can communicate with blockchain nodes. **GRPC :** is a cutting-edge, high-performance RPC framework that is becoming more and more popular in the blockchain space because of its cross-platform compatibility, efficiency, and scalability. JSON-RPC is still commonly used, although for some blockchain applications, gRPC has clear advantages.
**TXPool :** a temporary holding space on individual blockchain nodes where pending transactions wait to be included in a block; sometimes referred to as mempool in several blockchains. Transactions wait in line to be processed and permanently recorded on the blockchain, much as in a staging area. **LIBP2P :** is a framework for modular, adaptable peer-to-peer networking that is essential to creating robust, decentralized blockchain networks. It offers a strong platform that enables direct data exchange and communication between blockchain nodes without the need for centralized servers. # Smart Contract Details # White Paper
In October 2020, ICB Labs was established, marking the first concrete step for the company (ICB Crypto Services) into the blockchain industry. The goal is to broaden the company's perspective, find new areas of problems to solve, and address recent challenges in the blockchain and cryptocurrency space using well-known modern technologies. Under the guise of Ideal Cooperation Blockchain (ICB), this division set out to design smart contracts and enable instantaneous, middleman-free transactions using widely used blockchain platforms. As a result of its rapid expansion, the ICB Network is now among the most notable and cutting-edge blockchain initiatives in existence. The fact that it is the initial project layer is one of its distinguishing features. By causing significant modifications to the blockchain's structure, this feature enables the ICB Network to emerge as a first-layer network by tackling issues and concerns with current blockchain services.\ \ Notable among ICB Network features is the ICBX. Thanks to its clever design and the inclusion of the project's schematic technical symbol, this feature enables the network to adapt the size of its blocks according to requirements, which can range from 700 bytes to 820 bytes. The network's capacity to store and retrieve data effectively and respond rapidly to user queries is guaranteed by this unequaled capability. On top of that, the ICB Network is all about smart contract development to fix the biggest issues with current blockchain services. These updates boost the effectiveness of the network and make using it more pleasant for everyone.\ \ By prioritizing efficiency, security, and innovation, ICB Crypto Services has risen to the position of industry leader in the blockchain space. In the absence of middlemen, this business is building a better, more adaptable future. ### Problem Statement The creation of services and programs based on blockchain technology, as well as the execution of transactions, are now hindered by significant hurdles. Here, the scalability of blockchain technology is a big issue. In the near future, blockchain network traffic may reach critical mass, similar to the increasing number of stationary automobiles on a highway. Long acknowledgment intervals and scalability problems in the blockchain might result from this issue, which arises from the inability to execute several transactions at once. This will lead to a congested network and a poor user experience. As a result, the overall efficiency of the blockchain will be affected. Gas cost increase in blockchain architecture is another issue. Actually, the gas charge is quite similar to the toll that users must pay in order to access blockchain services. \ \ These costs can be prohibitive for certain users on certain networks. Because of this, it will no longer be profitable to use the blockchain network. Consequently, the network will only support transactions with large fees. Another issue with transaction speeds arises in this context. Users may be dissatisfied with the sluggish transaction speeds due to the fact that blockchain networks may be slow to operate, particularly in high-volume request situations. Programs and services that rely on instantaneous financial transactions are particularly vulnerable to this issue. These issues can be resolved with the use of a remedy. \ \ As a cutting-edge blockchain platform, the ICB Network is renowned for its increased speed, decreased gas charge, and improved scalability. Decentralized applications (DApps) and blockchain-based services may be more easily developed with the help of this network. The ICB network can build a blockchain ecosystem with more features after integrating its specific capabilities into EVM compatibility. Improving the user experience and providing assistance to blockchain developers are the primary goals of developing a more robust, affordable, and extensively utilized blockchain platform. ### ICBX Blockchain Platform with POS Consensus Algorithm The ICB Blockchain, built on a **Proof of Stake (PoS)** consensus algorithm, stands as a leading blockchain platform pioneering unique and intricate theoretical concepts. These pioneering theories empower our developers to craft a framework underpinned by **identity value**, where network members directly contribute to blockchain validity. This validity, unlike traditional systems reliant on trust in central authorities, is rooted in the **collective identity and active participation** of its community. ### Environmental Friendliness The ICB Network, when combined with the **PoS** consensus process, has the notable benefit of being environmentally friendly. The ICB **PoS** systems help preserve the environment by utilizing optimal algorithms and reducing energy consumption, in contrast to the traditional financial transaction procedures that are marked by high rates of resource and energy consumption. By facilitating safe and transparent transactions in blockchain systems, these platforms contribute to the attainment of environmental objectives. ### Blockchain Validity **A defining feature of the ICBNetwork PoS consensus mechanism is the focus on identity value and its direct impact on delegate selection.** Instead of individual token holdings solely determining their influence, the network considers factors like **community reputation, contributions, and past performance.** This incentivizes members to actively engage in the ICB ecosystem and contribute meaningfully, shaping the direction of the blockchain through **participatory governance structures.** ### Scalability Solution Blockchain platform development faces the formidable obstacle of scalability. Scalability issues, mostly relating to network security, plagued early blockchain networks like Bitcoin and Ethereum. While this is certainly a plus, there were restrictions on the amount of transactions that could be processed in a given time frame. Because of the scalability issue, networks are less efficient and run more slowly. Because of this, networks are unable to handle extremely high transaction throughput (TPS).\ Here we will now talk about modern standards. By 2015, the Ethereum network has adopted the ERC-20 protocol. In accordance with this standard, programmers can build several interchangeable tokens on a blockchain network. Essential features of tokens, including as their names, total supply, symbols, and decimal places, and fundamental operations, such as token transfers and balance inquiries, are also highlighted in this standard. You won't find a more secure smart standard than this one. Think about the ICB Network's incredible speed in conjunction with the safety of this standard. You are aware that the ICB Network facilitates the management of many tokens in a digital wallet and that ERC-20 permits the simple transfer of tokens. As a result, this standard can process up to 1200 transactions per second while providing unmatched security. Thus, blockchain technology may be expanded and utilized by a larger audience. More users can be accommodated in a sandbox setting as the developer need grows. As a result, blockchain technology may reveal more of its potential. ### Using ERC-721 for Complicated Transactions in the ICB Network Solving scalability issues and managing complicated NFTs and transactions is vital with the ever-increasing developments in blockchain technology. To address these issues and offer a trustworthy, cutting-edge blockchain platform, the ICB Network implemented the ERC-721 standard. This standard offers distinct features and is a key tool for managing complex tokens on the ICB Network.\ \ Assigning a distinct identifier to every token is a key component of the ERC-721 standard. This identifier goes under several names, including serial number and token number. In this way, every token becomes distinct. So, tokens may be owned and hold important data. Put simply, every ERC-721 coin is uniquely identified from all others.\ \ Large, complicated transactions involving one-of-a-kind items may now be executed with the help of this functionality. Virtual marketplaces, online gaming, and digital asset management are just a few of the numerous uses for these interactions. Also, developers may make their own unique tokens that work with blockchain apps and services thanks to the ERC-721 standard. Due diligence on this secure standard has been exhaustive in light of the project objectives of the organization. To the best of our knowledge, ERC-721 can handle 400 complex transactions per second in its present implementation. Plus, developers may enhance this default speed as the number of requests increases. ### Conducting High-Speed Transactions in the ICB Network Fast and efficient transactions are fundamental to the architecture of every blockchain network. The ICB Network, as used in ICB Crypto Services's projects, has an incredible throughput of **1,200 TPS.** Everyday transactions may be processed quickly on the ICB Network. This characteristic is of paramount importance. This lightning-fast speed makes the ICB Network a universally applicable platform for developers. Various decentralized applications and transactions may be handled using this platform. Some examples include digital financial markets, online gaming, and the Metaverse. ### EVM-Compatible ICBX Building smart contracts and applications on the ICB platform relies heavily on EVM compatibility. In order to guarantee that projects are executed correctly and successfully, it is important to adhere to standards, prioritize safety and security, optimize gas usage, conduct tests and validation, and maintain close supervision and monitoring. Following these guidelines will let developers to build robust, secure smart contracts and applications on the ICBX platform, just like on other networks that are compatible with the EVM and enable interaction and competition. ### Compliance with Standards An important tenet of the ICB Network's EVM compatibility is adherence to legitimate token and smart contract standards. For programming languages that are compatible with EVM, there are several benefits to using the tailored secure standards, such as ERC-20, ERC-721, and ERC-1155. Smart contracts and programs may be accurately defined by developers thanks to these standards, which also facilitate their interaction with other apps and services on the network. ### Safety and Security of ICBX with EVM The security of smart contracts and programs is of utmost importance in the EVM-compatible ICBX. To avoid hacking and other security breaches, programs should have solid security mechanisms. Reliable and legitimate operations, data and input confirmation, and security risk minimization are of the utmost importance. ### Gas Optimization One of the biggest problems with the ICB platform is handling the transaction fees. All monetary transactions on the ICB network are pegged to the local token unit. With the ICB network's cheap gas charge, decentralized apps and optimized smart contracts may cut down on gas use and transaction fees. The network's primary fuel should be the local ICB tokens. ### Test and Validation In order to ensure that smart contracts and programs are error-free, they are tested extensively using EVM utility apps before they are actually run on the ICB blockchain. To guarantee flawless performance, thorough testing and validation are necessary. Once put into place, smart contracts and programs need constant vigilance to avoid malfunctions and mistakes. ### Governance in Blockchain A blockchain platform's governance is obviously crucial. As a kind of decentralized organization, token holders on the ICBX blockchain decide how the network is to be run. Members of the blockchain community will be able to take part in important decision-making processes and make revisions thanks to this mainstream way to managing network relations and making decisions.\ \ The governance aspects of the ICB platform are as follows: * **Democracy** : The ICB platform's governance is based on democracy. Basically, regardless of the amount of tokens possessed, every token holder has a voice in the network's decision-making. With this method, the total quantity of tokens held by each user can influence the network's ultimate decision-making power. * **Leveling and Balance :** The ICBX platform's governance prioritizes equilibrium and fairness. That is to say, decision-making power will mostly rest with the token holders with the most tokens. Nevertheless, decision-making is open to all members of the network. The decision-making process is enhanced by this relatively equal allocation of authority. * **Modifications and Upgrades:** Token holders and developers may make real-time changes and updates on the ICBX network. So, in response to new opportunities and fluctuating market conditions, the network adapts by incorporating the required improvements and adjustments and enhancing its performance. * **Transparency:** Openness in network performance and decision-making is a result of ICBX blockchain governance. Everyone in the network can see every choice and activity. The status and choices of the network may be easily accessed by all members thanks to this function. The ICB blockchain relies heavily on governance, to sum up. Using it helps keep the network's administration and decision-making under check. With this open and democratic method, everyone in the network may play an active part in making the ICB network better all the time. In order to take part, voting is required. ### Voting in the ICBX Blockchain To modify protocols and make pertinent choices, all voting criteria and requirements must be met in the ICBX blockchain. These measures are put in place to ensure that the decision-making process is fair, democratic, and open to all. The following are examples of ICBX blockchain voting criteria and conditions: * **Voting Criteria:** An essential prerequisite for voting on the ICBX blockchain is the establishment of voting criteria. Precisely calculating the proportion of votes in support of a protocol amendment requires the consideration of a criteria. Obtaining 66% of the vote in favor might be one criterion for making a decision. * **Voting Conditions:** Accurate determination of the prerequisites for voting is essential. These requirements could be conditional on the network members' levels of involvement or the quantity of tokens held by token holders. For instance, in order to vote, token holders could need 100 tokens or more. In addition, the circumstances surrounding each voting procedure are unique. * **Voting System:** The ICBX blockchain uses a unique voting mechanism in which the majority of tokens cast determine the outcome. Each token is like a vote in this system. That is to say, the number of tokens that participate in the vote determines the outcome, and each token has one vote. * **Voting Duration:** The length of time for voting is clearly defined. This time frame may be anything from a week to a month or more. During this time, everyone in the network has an equal opportunity to cast a vote and have their say on major decisions. * **Decision-Making Based on Polls:** Polls provide the basis of the decision-making process. In this scenario, the tokens' majority vote determines the outcome. Changing the procedure will be the final decision if 66% of the votes are collected, to be correct. ### Process of Creating and Selecting Blocks ### Bonding in the ICB Network Bonding in the ICB Network refers to the tie that binds projects to their donors. As a security deposit for various apps and initiatives, contributors can lock their tokens. Tokens as bonds allow donors to show their interest in and dedication to the ICB Network's decentralized apps (DApps) and their performance and security. #### Advantages of a Bonding Fund for the ICB Network * Enhancing Trust: By bonding tokens to projects, contributors indicate that they believe in the validity and importance of them and are willing to help develop them. * Improving Security: The tokens used as bonds can be used during transaction validation and block creation. This can improve the network security. * Encouraging in Participation: The concept of bonding encourages contributors to put more efforts into developing and improving decentralized applications and projects, as they play key roles in improving performance as well as having financial commitments. An essential and foundational idea in the ICB Network is the bonding fund. With this money, we can incentivize and reassure investors and developers to work on decentralized application (DApp) and blockchain initiatives. In addition to the monetary benefits of this fund, corporate backers and investors in projects held by corporations can ensure their monetary and economic benefits. Additional investments and financial backing for the creation of ground-breaking DApps may be made possible using this method, which also improves the security and transparency of blockchain apps. ### Features of the First Layer in the ICB Network Utilizing innovative routing, dynamic block size, smart contract optimization, and high-efficiency consensus methods, the ICB Network successfully tackled scaling issues. The speed of processing transactions and the general efficiency of the network were both greatly enhanced as a result of these measures. * **Efficient Smart Contract Optimization in a Range of Sizes:** The ICB optimized smart contracts to maximize efficiency. The processing time might be extended due to the correlation between gas fees and the execution of smart contracts. Spend as little as possible and execute transactions more faster by using the latest optimization techniques. Consequently, the overall performance of the network will be enhanced. * **Advanced Network Routing in Validation Process to Initial Storage :** In order to direct transactions to the correct nodes and branches of the network, the ICB Network employs sophisticated routing algorithms. Thanks to its performance, transaction processing times are significantly reduced, guaranteeing lightning-fast processing. * **High-Efficiency Consensus Algorithm: Block Sharding :** To enhance the validation of transactions and the consensus process, the ICB Network makes use of efficient consensus algorithms. Enhanced iterations of the PoS approach or delegated PoS methods comprise these algorithms. These algorithms and sharding strategies can reduce computing strain, allowing for rapid validation and confirmation of transactions. With this enhancement, the throughput of processing transactions per second is much enhanced. While competing blockchain networks could only manage 100–200 TPS in the benchmark testing, the ICB Network reached a maximum of 1200 TPS. * **Dynamic Block Size: First-Layer ICB Network :** The dynamic block size is advantageous to the ICB Network. To rephrase, block sizes are adjusted to match the needs of the network. Blocks are built bigger to accommodate additional transactions during moments of strong activity. To make the most efficient use of resources during periods of low activity, smaller blocks are utilized. The ICB Network's efficiency and scalability will be enhanced by this precise conformity with the network requirements. ### Gas Fee Reduction in the ICB Network ICB Network gas tariff reductions are a major benefit. This is due to the technological capabilities of the first-layer blockchain technology. The following efforts were made: optimizing network gas cost parameters, improving transaction processing, upgrading smart contract execution, and determining block sizes. New modifications lower transaction fees and establish the ICB Network as a cost-effective blockchain solution. The significant characteristic has an economic and commercial impact on all financial connections using this network. ICB technology offers great efficiency and low fees for secure and cost-effective digital asset exchange, information storage, data sharing, and financial transactions. ### Detailed Management of Gas Fees Firstly, the detailed management of gas fees in the ICB Network was considered a major goal. This management process included the detailed configuration of initial files of development in which the relevant parameters of gas fees were set in detail. **() () ()** ### Optimization of Gas Parameters One of the main ways to lower gas expenses in the ICB Network is to optimize the gas characteristics. As part of the optimization process, smart contracts and transactions are used to establish gas values accurately. Therefore, applicants will pay less to complete their transactions, and transaction costs are decreased. ### Improvement of Transaction Processing Mechanisms The ICB network has enhanced the methods of processing transactions. These enhancements boost efficiency and save transaction-related gas fees. ### Optimization Strategies for implementing smart contract Optimizing the strategies for executing smart contracts has helped reduce gas fees. The resultant-improvements enhance efficiency in the execution of contracts and reduce relevant fees. ### Win-Win Situation Everyone involved has come out ahead thanks to the ICB Network's technically feasible solution for lowering gas expenses. Applicants will see a decrease in the costs associated with their transactions. As compensation, they've developed a more effective blockchain network. This mutually beneficial arrangement demonstrates that the cutting-edge blockchain technology can adjust to the requirements of candidates while efficiently controlling costs. Candidates will have more faith in the ICB Network after these updates. Consequently, there will be an incentive for applicants to engage in additional transactions and activities. ## Technical Explanation ### ***Architecture Overview*** **Consensus**: PoS helps optimize scalability and performance without forgoing Byzantine fault tolerance. It acts as the consensus mechanism of Polygon Edge and features a consensus engine, IBFT 2.0, and a consensus protocol, including bridge, staking, and other utilities. **Networking**: The use of libp2p protocol promotes decentralised communication among peers. It also offers P2P networking primitives such as peer discovery, secure messaging, and connection management. **Blockchain**: This decentralised distributed ledger records transactions and verifies every transaction with end-to-end encryption. It involves new block addition, retrieving blocks using hash value, verifying block headers, updating the chain's average gas price, etc. **Memory Pool:** Acts as a temporary storage area for pending transactions before they get added to a block. After submitting transactions, they are initially held in the memory pool, allowing miners to include them in the next block. **Transaction Pool:** Effectively handles incoming transactions for processing. It manages a list of unprocessed transactions and makes sure they comply with certain restrictions before entering the pool. **JSON-RPC**: Allows seamless communication within the distributed systems and aids developers in developing scalable apps with low-latency communication. This RPC protocol helps clients in making requests to the server and obtaining responses. **gRPC**: gRPC offers exceptionally faster communication and bidirectional streaming while sending and receiving multiple requests and responses. An improved consensus technique that builds on Proof of Stake's foundational principles is Proof of Stake (PoS). The 2014 Proof of Stake (PoS) consensus mechanism was created by BitShares, Steemit, and EOS creator Daniel Larimer. Every staker in a Proof of Stake network has an equal opportunity to take part in the "mintage" process, where they may choose the nodes in layer two that validate blocks further and get rewards for adding them to the blockchain. An election mechanism selects nodes to verify blocks in the Pos system. "Witnesses" or "block producers" are the terms used to describe these nodes. **Delegates:** Delegates are elected by users in PoS systems to manage the governance of the blockchain. When it comes to controlling transactions, they have no role. Any delegate has the right to suggest changes to the block size or the witness payment for verifying a block. The blockchain community votes on whether or not to implement modifications proposed by delegates. In PoS, complete nodes are known as block validators, and their job is to ensure that blocks generated by witnesses adhere to the norms of consensus. The network may be verified by any user running a block validator. Block validators don't get anything out of the job. **Networking:** * **Libp2pp:** The decentralized networking layer used by Pos is built on top of the libp2p protocol. Peer-to-peer networking primitives including connection management, peer discovery, and encrypted messaging are provided by the protocol. To control peer connection and handshaking and guarantee that only legitimate peers may join the network, the network depends on a secure Identity Service. * **Identity:** The Identity Service controls peer handshaking and verifies inbound connections. It communicates with the underlying networking layer through a networkingServer interface and keeps track of pending peer connections. * **Peer discovery:** Pos employs the distributed hash table (DHT) of libp2p, which is based on the Kademlia algorithm. The DHT keeps track of other peers' addresses and availability inside the network. A newly connected node searches for additional peers that are online via the DHT. Periodically, in order to keep a sufficient number of connections in the network, the procedure of utilizing the DHT to find peers and then sending out connection requests is repeated. * **Peer routing:** Bootnodes assist new nodes in finding and connecting to the network by serving as rendezvous servers. When generating the genesis file, you can specify one or more bootnodes using the polygon-edge command. Libp2p multiaddrs, which provide details about the protocol, network address, and node port number, are used to define bootnodes. * **Gossip Sub**: In Polygon Edge, Gossip Sub is a decentralized, peer-to-peer messaging system that facilitates effective message dissemination throughout the network. It is utilized by the ***TxPool,*** among other network components, to broadcast new transactions and transport transaction data across nodes. Gossip Sub reduces network capacity consumption while enabling effective and dependable message dissemination.
### Blockchain Mechanics The foundation of ICB chains is a shared blockchain architecture that efficiently administers and preserves the blockchain data structure, which is made up of a state database and a sequential chain of blocks holding transactions and other metadata. The fundamental blockchain implementation provides a number of features, including: extending the chain with additional blocks. obtaining blocks by their number or hash. Managing reorganizations of chains (that is, transferring to a more challenging chain). checking the gas limitations and block headers. Block headers and receipts are cached to increase retrieval speed. updating the average gas price for the chain. Several sub-components are used by the implementation to deliver these features, including: a consensus mechanism in charge of approving fresh blocks and adding them to the chain. a part of a database that keeps blockchain data permanently. An event component that broadcasts information about fresh block additions and chain reorganizations to other components. a transaction signer component that shows the sender address and confirms transaction signatures. a part of the gas price calculator that figures out the average gas price for the chain. ### Token Utility The ICB token is a versatile tool that can be utilized in a variety of businesses and ecosystems due to its wide but distinctive qualities. This coin has the potential to be extremely important for streamlining transactions, trading assets, and enhancing user satisfaction. **Transaction Fees:** Every transaction in the ICB Network needs transaction fees that are paid by the ICB tokens. These fees will use the ICB tokens with very low decimals approaching zero. They are collected as a part of the token deflation mechanism. These financial resources help develop and maintain the ICB platform. **Governance:** The ICB token holders can participate in the governance of this platform. They can be involved in voting on recommendations and decisions concerning the future of this platform. This feature allows a community to participate in major decisions made in the network and influence the future of the platform. **Ecosystem Rewards:** The ICB token holders can acquire financial rewards by participating in different ecosystem activities, *e.g.*, using tokens as bonds, extracting tokens, and participating in governance. **Delegation Rewards:** One of the distinctive characteristics that will distinguish the ICB Network from other decentralized blocks is the ICB Token fee, which is not just for the project but will also be split among several decelerators [LEARN MORE](/project-technology/delegators-and-fee-sharing). **Growth Potential:** Given the limited supply of tokens ( 100B tokens) and the use of an economical token deflation model, the ICB token has considerable potential for higher values. As there is an upward trend in the demand for the ICB platform and tokens, the value of the ICB token can increase significantly. This can be viewed as an additional motive for the ICB token holders to keep their tokens and participate actively in the network ecosystem **Gaming Industry:** The ICB token can be used as a cryptocurrency in the gaming industry to purchase and sell virtual objects and assets in online games and VR environments. **DeFi (Decentralized Finance) Projects:** The ICB token can be used as a currency in DeFi projects to pay fees, make down payments, and conduct transactions without intermediaries. **Digital and Tech Industry:** The ICB token can be used as a motivational, payable currency in software development projects, engineering services, and data processing. **Asset Exchange Platforms:** The ICB token can be used on asset exchange platforms (*e.g.*, financial marketing, real estate markets, exchange of valuable assets such as stocks and securities) in both the real world and the virtual world. **Metaverse Projects:** In Metaverse projects that present virtual worlds and provide VR experiences, the ICB token can be used as an exchange currency in transactions conducted by users and businesses. **Connection to IoT Devices:** In the IoT industry, the ICB token can be used as a denomination to pay for different services concerning the devices that connect to the Internet. These services include monitoring and managing devices, conducting IoT-connected transactions, and creating secure transactions. **Health and Medicine**: Given the MICB project in health and medicine, the ICB token can be used as a denomination to pay for medical services, manage electronic medical files, and conduct digital commerce in this area. **Supply Chain and Logistics Projects:** In the areas of supply chain and logistics, the ICB token can be used as a denomination to pay transportation fees, manage the supply chain, and improve experiences with virtual transactions. **Energy Industry and Environment:** In the projects of energy management and environmental protection, the ICB token can be used as a currency to pay for the fees of renewable energy, environmental management, and ecological data exchange. ## More information about the ecosystem ahead: ### Part1: Blockchain in Gaming - ICB Ecosystem **Revolution in gaming:** ICB leverages blockchain technology to revolutionize the gaming industry, offering games within its ecosystem that enable players to earn income through Play-to-Earn models and experience ownership of rare and unique digital assets. #### For Example: **Game Name:** Cryptic Conquest **Genre:** MMORPG (Massively Multiplayer Online Role-Playing Game) **Game Introduction:** Cryptic Conquest immerses players in a fantasy world called Eldoria. Players assume roles as warriors, wizards, and strategists from various clans competing to control lands and natural resources. Each player can expand their territory, build armies, forge alliances, or engage in warfare. **Utilizing Blockchain and NFTs:** Every land piece, weapon, magic item, and character in Cryptic Conquest is represented as a unique Non-Fungible Token (NFT). Players can trade these NFTs within the game's internal marketplace, lease them out, or even use them as collateral for in-game decentralized finance (DeFi) loans. **Game Scenario:** Players begin by selecting a tribe and acquiring a small territory. Through missions, resource gathering, and battles, players earn experience and resources necessary to upgrade territories and build formidable armies. Regular tournaments offer opportunities to win rare and valuable NFTs. **Play-to-Earn Mechanism:** Cryptic Conquest implements a Play-to-Earn model where players earn in-game tokens by advancing through the game and participating in various activities and events. These tokens can be exchanged for other cryptocurrencies on external markets, enabling players to earn real income. **Technology and Security:** Built on the ICB blockchain, Cryptic Conquest ensures high transparency and security. All transactions and changes in NFT ownership are securely recorded to prevent fraud and ensure fair play. **Development and Future Plans:** ICB intends to enhance player engagement by expanding the game universe and introducing new features. Continual development aims to provide fresh content and additional earning opportunities for players. **NFT Technology:** ICB is dedicated to developing games utilizing NFTs, allowing players to legitimately buy, trade, and sell digital assets with confidence and security. This approach not only enhances player immersion and enjoyment but also pioneers new avenues for monetization and asset ownership within the gaming community. ### Part2: Blockchain in Metaverse - ICB Ecosystem **Development of the Metaverse:** Leveraging blockchain technology, ICB has created metaverses where users can own and develop their virtual spaces. These spaces are designed for business, entertainment, and social interactions. #### For Example: **Metaverse Name:** AICBVille **Genre:** Simulation of Virtual Society and Business **Introduction to AICBVille:** AICBVille is a metaverse where users can actively participate by starting companies, buying or building houses and land, and engaging in social and recreational activities. This metaverse integrates virtual reality, social networks, and video games, all on the ICB blockchain platform. **Metaverse Scenario:** In AICBVille, each user enters with a digital avatar and can buy or sell land anywhere in this expansive world. These lands are offered as NFTs, with ownership that can be transferred and traded. Users can construct buildings, parks, shopping malls, and even towns, each of which can generate income through rentals or hosting events. **Game Market Development:** \- Assets and Transactions: Users can buy and sell land, buildings, and even cities as NFTs, each with varying economic values based on location, usage, and market demand. \- Business and Economic Activities: Users can create and develop virtual businesses that sell digital services or goods, such as fashion design, virtual furniture, or entertainment services. \- Events and Entertainment: Users can host concerts, theater shows, art exhibitions, and seminars for which digital tickets can be purchased. \- Social Interactions: AICBVille enables networking, making friends, and engaging in virtual interactions that enrich the user experience and help create online communities. **Security and Privacy:** All interactions and transactions in AICBVille are recorded and secured through smart contracts on the ICB blockchain, ensuring the protection of users' data and assets. **Development and Future Plans:** ICB plans to continually enhance user experiences by introducing new features such as advanced augmented reality, social functions, and non-gaming uses in the AICBVille metaverse. **Augmented Reality and Physical Interactions:** \- Augmented Reality: ICB aims to enhance user experiences by incorporating augmented reality technology. This allows users to view virtual elements in their physical environment, such as displaying purchased artwork in their real homes or attending virtual concerts held in their living rooms. \- Physical Interactions: To bridge the real and virtual worlds, AICBVille enables direct communication of avatars with IoT devices, allowing users to receive metaverse news or environmental changes through physical devices in their homes. **Advanced Social Functions:** \- Virtual Learning System: AICBVille offers spaces for virtual courses where students and teachers can participate in virtual classes and enjoy real social interactions. \- Dynamic Classrooms: Classrooms in AICBVille can be set up as amphitheaters, interactive workshops, or open discussion rooms, allowing teachers to adapt the environment to their curricular needs and teaching styles. \- Interactive Boards and Educational Tools: Each class is equipped with digital boards, drawing tools, and interactive educational software, enabling students to work in groups and interact with course materials through their avatars. **Access and convergence:** • **Wide access:** AICBVille's virtual space allows students from anywhere in the world to participate in classes, without the need to be physically present. • **Integration with existing educational systems:** AICBVille collaborates with various universities and educational institutions to offer their existing courses on Metaverse and the educational qualifications offered on AICBVille are globally valid and verifiable. AICBVille virtual education system is provided with the aim of creating an innovative and efficient platform for learning and cultural and knowledge exchange, to create a fundamental transformation in the way of education in the digital age. • **Networking events:** holding special networking events for different industries that users can participate in to establish professional connections and access new job opportunities. **Non-gaming applications:** • **Digital businesses and stores:** ICB allows businesses to create virtual business spaces where physical or digital products can be sold. Also, companies can create their own virtual offices for remote employees. • **Galleries and exhibitions:** holding art exhibitions and digital galleries with the aim of displaying the works of artists from all over the world, which users can view and even buy. **Development and Future Plans:** ICB is committed to maintaining AICBVille as a living and dynamic metaverse. Relying on user feedback and continuous development, ICB Network plans to introduce new features that will continuously improve the user experience and make Metaverse a reference for more and more engaging social and professional interactions. **Progress Evaluation and Follow-Up System:** Blockchain-Based Evaluations: Students' performance and academic records are digitally recorded using blockchain technology, ensuring transparency and accuracy of information. **Certificates and Degrees in NFT Form:** \ Students who successfully complete courses are awarded digital certificates in the form of NFTs, which are easily transferable and valid worldwide. **Social and Educational Interactions:** Study Groups and Workshops: Students can form digital study groups or participate in educational workshops provided by other students or teachers. These activities offer opportunities for collaborative learning and social networking. **Access and Convergence:** Wide Access: AICBVille's virtual space allows students from anywhere in the world to participate in classes without needing to be physically present. **Integration with Existing Educational Systems:** \ AICBVille collaborates with various universities and educational institutions to offer their existing courses on the Metaverse. The educational qualifications provided on AICBVille are globally valid and verifiable. **Purpose and Goals:** The AICBVille virtual education system aims to create an innovative and efficient platform for learning, cultural exchange, and knowledge sharing, fundamentally transforming education in the digital age. **Networking Events:** Special Networking Events: These events cater to different industries, allowing users to establish professional connections and access new job opportunities. **Non-Gaming Applications:** Digital Businesses and Stores: ICB enables businesses to create virtual spaces where physical or digital products can be sold. Companies can also create virtual offices for remote employees. **Galleries and Exhibitions:** ICB hosts art exhibitions and digital galleries to showcase the works of artists from around the world, which users can view and purchase. **Development and Future Plans:** ICB is committed to maintaining AICBVille as a vibrant and dynamic metaverse. By relying on user feedback and continuous development, ICB Network plans to introduce new features that will continuously improve the user experience, making the Metaverse a hub for more engaging social and professional interactions. ## Part3: DeFi - ICB Ecosystem ### DeFi Financial Solutions **DeFi Financial Services:** ICB offers decentralized financial services, including lending, trading, and insurance, through DeFi platforms. These services are universally accessible and highly secure. **DeFi Platform Design and Idea: ICBLoan** **Introducing ICBLoan:** ICBLoan is a DeFi platform developed by ICB that allows users to lend and borrow digital assets. Designed with blockchain transparency and security principles, this platform enables users to conduct financial transactions in a safe and low-risk environment. **Market Mechanism in ICBLoan** **Lending and Borrowing:** **- Lending:** Users can deposit their digital assets in stablecoins or other cryptocurrencies into the platform's smart contracts to earn interest. **- Borrowing:** Users can obtain loans by pledging their collateral, such as NFTs or other digital assets. The interest rate is determined by factors such as the amount of collateral, the loan period, and the borrower's financial history. **DeFi Transactions:** **Digital Asset Trading:** The platform allows users to buy and sell digital assets using Swap technology. This feature facilitates transactions without the need for direct matching between buyers and sellers. **DeFi Insurance** **Insurance Coverage:** ICBLoan provides insurance coverage for users' loans and investments to protect their assets in case of unexpected events, such as hacking or technical errors. This insurance service is managed through smart contracts that handle risks and conditions. **Security Guarantee** **Advanced Security:** All transactions and contracts on the ICBLoan platform are executed using advanced encryption and up-to-date security protocols, ensuring that users' data and assets are protected against unauthorized access.
## Part4: Interchain Exchanges - ICB Ecosystem **Example Platform Name:** InterChain Exchange (ICE) **ICE Platform Introduction** ICE is an inter-chain exchange platform developed by ICB to facilitate the exchange of data and digital assets between various blockchain networks such as Ethereum, Binance Smart Chain, Polygon, Avalanche, and ICB itself. This platform is specially designed with a focus on using bridge technologies like Polkadot and Cosmos to enhance interactions and efficiency. **Working Mechanism of ICE Platform** **Interchain Bridges:** Construction and Use of Digital Bridges: ICE utilizes bridge technologies to establish secure connections between different chains. These bridges enable users to transfer assets and information at minimal cost and in the fastest possible time. **Decentralized Exchange (DEX):** Integration with DEXs: ICE seamlessly integrates with reputable DEXs on any chain, allowing users to exchange their digital assets within minutes. This integration facilitates cross-chain transactions, enabling users to benefit from the features of various blockchains. **Advanced Working Mechanism of ICE Interchain Exchange Platform** **Using Oracles for Two-Way Communication:** Two-Way Communication with Oracles: ICE employs oracles to obtain data and verified prices from outside the blockchain and provide this information to the blockchain. This data helps verify transactions and calculate accurate conversion rates between different chains. **Using Hash Time Locked Contract (HTLC) Protocol:** HTLC Protocol: This protocol is a key mechanism in ICE, ensuring the security and execution of contracts in inter-chain transactions. HTLC allows assets to be transferred only when both parties to the transaction meet the required conditions. **Multi-Signature Approval Process for Transactions:** **Verification of Multiple Signatures:** ICE requires multiple signatures (multisig) to verify significant and large transactions. This process helps prevent unauthorized changes and fraud, providing users with greater confidence. **Programmable Events and Smart Contract Hooks:** **Event Scheduling:** ICE enables the scheduling of specific events and reactions in smart contracts, allowing users to set up automated responses to market conditions or price changes. **Reducing Costs and Increasing Speed through Network Optimizations:** Network Optimization: ICE continuously optimizes network algorithms and protocols to enhance transaction speed and reduce costs, making markets more accessible to all users. **Exchange Security** **Support and Maintenance:** **Continuous Support and Updates:** The ICE development team continually reviews and improves the platform's technologies to ensure security against new threats and maintain optimal performance. **Development and Future Plans** ICB aims to develop ICE into a hub for decentralized financial innovation. By integrating new technologies and fostering international cooperation, ICE intends to push the boundaries of digital exchanges and provide access to digital financial services to a global audience. **Conclusion and Foresight** Committed to innovation and continuous improvement, ICB seeks to enhance and expand its blockchain ecosystems. In the future, ICB plans to optimize its products and services using user feedback and emerging technologies to offer a better and more inclusive experience for all participants.
## Marketing Strategy Given the great potential of this platform, a fundamental strategy must be adopted to promote and accept the local ICB token. Some marketing strategy elements were addressed for the ICB platform, and certain strategies were offered to improve its popularity and acceptance. **Purposive Advertisements:** Using purposive advertisements on the websites and services of blockchain and IT can help extend the acceptance of the ICB platform. These advertisements can intelligently show users how they can participate in this platform and benefit from our network services. **Communicating with Influential People:** One of the earliest steps in the ICB marketing strategy is to communicate with influential people in the blockchain and IT industry. These individuals can be influential users in the blockchain community. Cooperating with these individuals and gaining their support will improve the advertising validity and power of the ICB. These individuals can also act as the ICB brand ambassadors and convey positive messages on this platform to society.3) Airdrop Distribution: Airdrop is a valid method for promoting a blockchain platform. We can increase the number of users by distributing free-of-charge ICB tokens to the users users who actively participate in the ICB community or perform specific tasks. As a result, these users will be encouraged to keep this platform dynamic. These distributions can motivate new customers to join the ICB and actively participate in the ecosystem of our platform. **Advertisements on Social Media and Weblogs:** An important tool in the ICB marketing strategy is to run advertisements on social media (*e.g.*, X, Instagram, and Telegram), official websites, and blogs. Considering the huge communities on these ICB Network-based platforms, designing engaging and targeted advertising campaigns can help grow the ICB and attract new users. Moreover, collaborations with the reputable bloggers and writers of blockchain and IT can help improve the influence and publicity of the ICB platform. **Social Media Campaigns:** In the ICB marketing strategy, a major tool is socialization on social media. We can disseminate more information on the ICB Network and its advantages by creating interesting valid campaigns on social media (*e.g.*, Twitter, Telegram, Instagram, and Google). These campaigns can share articles, videos, and interesting advertisements that show users how the ICB Network can help them solve their financial problems. **Strategic Partnerships:** Other important aspects of the ICB marketing strategy include interaction and cooperation with blockchain platforms and reputable players in the industry. Forming strategic partnerships with these platforms can lead to cross-over advertisements, develop joint smart contracts, and increase inter-platform interactions. These interactions can then help develop the blockchain ecosystem and promote the ICB Network further. **Participation in Blockchain Events:** Participation in blockchain/IT events and conferences can provide the industrial society with a great opportunity to introduce the ICB platform. By participating in these events, the ICB team can be in contact with decision-makers, developers, and potential users and provide them with comprehensive information. **Regional Delegates and Counselors:** Recruiting regional delegates and counselors that know locals and specific conditions in every region can help develop the ICB platform on a global scale. These individuals can be employed to share local ads, provide local users with support, and facilitate communication with different communities. **Referrals**: Another strategy for improving the acceptance of the ICB platform is to make pleasant invitations and develop referral programs. We can increase the number of new users and help expand the ICB community by offering discounts and making special offers to the users who introduce their friends and acquaintances to the ICB platform. **Economic Promotion and Advantages:** Focusing on the economic advantages of the ICB platform can play an effective role in the marketing strategy. We can encourage businesses andindividuals to use this platform by explaining how we intend to reduce the fees and improve efficiency through the ICB platform. It is also possible to enhance the public trust in this platform by showing the real results and achievements of the ICB through witnesses from the blockchain population. ## Tokenomics Given the distribution of the ICB tokens, we can analyze Tokenomics more comprehensively and determine the effects of each class of these distributions on the growth and development of the network. Total supply : 100B Public Sale (Initial Distribution): ● 35% (35B tokens) This portion can be distributed over several phases or rounds to ensure a fair and decentralized launch. ● Team : 10% (10B tokens) ● Advisors: 5% (5B tokens) ● Ecosystem Development Fund: 30% (30B tokens) ● Reserve Fund: 5% (5B tokens) ● Staking Rewards: 12% (12B tokens) ● Community Grants and Airdrops: 3% (3B tokens)
## ICB Network Roadmap **Phase 1 of Train V. 1.2** Testnet is used in the ICB Network to test and validate codes and transactions before they are executed in the main network. This section reviews some of the important features and information on the ICB testnets. Different Testnets: The ICB platform has different testnets, each of which is used to test specific components of the network. **TICB Tokens**: The TICB tokens act quite the same as the real ICB platform on the ICB Network. These tokens are used to send transactions and conduct tests; they have no real value. Applications and Developers: The ICB Network testnet allows developers to test their codes in a virtual environment before running the codes in the main network. This feature helps develop and correct codes. **High Speed:** In the ICB testnet, transactions are conducted very much faster. Given the EVM compatibility, the validation time of each transaction will be minimized. **Development Networks:** The TICB testnet usually benefits from development networks that allow developers to access specific tools and features, *e.g.*, test transactions and test tokens.Free Access: The test tokens are available to the public free of charge; therefore, users can easily select and use testnets. Tetnets are considered the most important phase in the development and validation of projects based on the ICB Network. They allow developers to fully test and troubleshoot their codes before publishing them on the main network ## Phase 1 of Reservoir V. 1.3 **ICB Liquidity Pool** Liquidity pools are considered a fundamental component of the ICB coin exchange and other blockchain cryptocurrencies, *e.g.*, Ethereum, Binance Smart Chain (BSC), Polygon, Avalanche, and all transferrable second layers. These pools act as major sources of accessible liquidity through automated exchange (DEX). In other words, they allow users to give their cryptocurrencies to the local ICB DEX protocol and conduct transactions fast and efficiently. **Performance of the ICB Liquidity Pool** Every liquidity pool consists of two different cryptocurrencies that are used for exchange. There is usually a primary cryptocurrency, *e.g.*, the ICB Coin (ICB), and another cryptocurrency, *e.g.*, Stablecoin (USDT or DAI), in the pool. ***The ICB liquidity pool functions as below:*** **Flexibility:** Users can enter their cryptocurrencies into the liquidity pool for storage. In return, they receive equal ICB Coins. **Income Reward**: The users who have staked their cryptocurrencies in the ICB liquidity pool will benefit from the transaction fees of other users in return for conducting transactions on the ICB platform and using the ICB liquidity. In fact, another form of staking is performed. **Cryptocurrency Exchange:** Users can exchange their cryptocurrencies in different currency classes. For instance, they can exchange the ICB Coin to the USDT, or vice versa. These exchange processes are performed through specific ratios in the liquidity pool. ## Phase 1 of Fuel V. 1.4 : Importance of the ICB Liquidity Pool The ICB liquidity pool plays a key role in the blockchain ecosystem: **Facilitating Exchange:** By supplying sufficient liquidity, the liquidity pool enables fast and efficient cryptocurrency exchanges. **Maintaining Market Robustness:** By striking a balance between the supply and demand for cryptocurrencies, the liquidity pool avoids sharp fluctuations in their prices. **Profitability:** The users who place their cryptocurrencies in the liquidity pool will be rewarded. Their rewards come from the fees of transactions. The type and validation of rewards are determined by smart contracts. ### Importance of ICO in the ICB Project Development Known as a capital collection method in blockchain projects, the ICO operation plays a key role in developing and growing these projects. In the ICB Network project, the ICO bears special importance as a financial resource used for technical development, ecosystem features enhancement, and communication with a community of contributors interested in the ICB blockchain. The ICO is a method to raise capital and it allows the ICB-based projects to quickly supply the necessary financial resources and strive to a more advanced state. These financial resources can be utilized to facilitate the technical development of a blockchain project, recruit developers, create a surrounding ecosystem (*e.g.*, the meta ICB project), implement advertising strategies, and introducing delegates in different markets. In addition, the ICO provides an opportunity to motivate and attract active contributors to the project. Those who work at the ICO and collect the ICB tokens will turn into collaborative entities in the project development. Therefore, they feel that they own something in the digital asset ecosystem of the ICB platform, as the value of the preordered token is lower than its real value in the market. Finally, the ICO acts as an effective tool for developing the local ICB tokens and enhancing the general knowledge on a project of interest. This feature develops the ICB ecosystem and increases the value of tokens. As a result, investors will find an opportunity for profitability on airdrop in this project. In conclusion, the ICO is a vital method for developing blockchain projects and providing financial support, thereby it plays a pivotal role in the ICB project development. This engaging approach brings together investors, developers, and blockchain aficionados to help develop the ICB ecosystem. Therefore, like any other accurate, legal investments, participation in the ICO can provide you with an opportunity to join this advanced ecosystem. ### Phase 1 of Ship V. 1.5 : Mainnet of the ICB Network Mainnet is the main network of the ICB Network. In other words, it is an environment where all transactions and operations are really conducted with their material values in the ICB Network. This Mainnet is known as the core of the ICB Network, in which all transactions and DApps are executed mutually. The following section provides further information on the ICB Mainnet and its role. **Conducting Real Transactions:** The ICB Mainnet is an environment where real transactions and operations, *e.g.*, ICB cryptocurrency exchange and smart contracts executions, are conducted. In this network, users can send their cryptocurrencies to other users or smart contracts and conduct different operations such as validating transactions. **Technological Advance:** ICB Crypto Services Company has a leading role in developing blockchain platforms and providing smart capabilities in smart contracts. The ICB Mainnet is an environment where developers can execute their innovative DApps and programs on this blockchain platform and benefit from its advanced technological capabilities. **Test and Development:** The ICB Mainnet allows developers to execute and test their applications in real-world environments. This phase of test and development plays a key role in ensuring applications run smoothly and preventing unexpected errors. **Project Support:** The ICB Mainnet is an environment where different projects are developed on this blockchain platform. These projects include DApps, ERC-20 cryptocurrencies, and various types of smart contracts. All advantages and tasks that have already been described can be executed on the Mainnet platform in order to enter the real financial digital world. #### **Smart Contracts – ERC-20** A prominent feature of the ICB Mainnet is to support smart contracts. These contracts define certain rules to conduct specific transactions and operations on the ICB platform without any intermediaries. Moreover, ERC-20 is a standard for the cryptocurrencies created on this blockchain. This standard allows developers to generate a wide variety of digital tokens. #### Smart Contracts – ERC-721 ERC-721 is an NFT (non-fungible token) standard in the Ethereum blockchain. Unlike NFTs, the ERC- 921 tokens have a unique feature. Every token can be defined as a unique item or asset. This standard allows developers to create a wide variety of digital tokens that can be used as the ownership certificates of artworks, group assets, and vocations. As a result, this standard has started the NFT Talent marketplace platform. #### Smart Contracts – ERC-1155 ERC-1155 is a multi-fungible token standard that is compatible with the Ethereum blockchain and all blockchain structures that operate on the Ethereum virtual machine. Powered by Enjin, this standard allows for the issuance of diverse digital tokens. Unlike the conventional standards that define tokens as fungible (*e.g.*, ERC-20), ERC-1155 enables developers to combine different digital tokens with various features in a single smart contract. Therefore, developers can create digital tokens with diverse features, *e.g.*, cryptocurrencies, series of cards, and gaming items. As a result, the developing team has decided to use the meta ICB. ERC-1155 has specific features, *e.g.*, limited resource usage (Resource IDs) and additional token exchange. This standard is used widely in DApps and digital games, allowing for the exchange of tokens in the same smart contract. **Explorer:** The comprehensive guidelines on the ICB Network are available to the public. The ICB Network Explorer is a vital tool for the developers and users of the ICB Crypto Services, allowing them to observe and analyze relevant data and transactions. These tools facilitate the processes of developing and testing blockchain-based applications and smart contracts and ensure their correct performance in the ICB Mainnet. **ICB Scan Explorer :** An explorer is considered an important tool in the realm of blockchain, enabling developers, researchers, and casual users to check transactions and network-related information. Explorers play a valuable role in observing and checking the data of a network and pursuing transactions. ***Why Is the ICB Network Explorer Important?*** **Pursuing Transactions:** Developers and users can pursue their transactions in an explorer and see different pieces of information, *e.g.*, transaction status, completion time, and addresses. **Checking Contracts:** If a smart contract is executed on a testnet, it is possible to check its status and information via an explorer. **Running Tests:** An explorer allows users to test their transactions and contracts and check their execution status. ***Human Aspect of the ICB Network Blockchain*** ***ICB*** ***Network*** projects do not only need one group of developers. They need a wide range of experts including the developers of smart contracts, PR experts, and legal experts for development and management. Cooperating under the leadership of ***Mike Verdish*** as an idea creator, all experts try to contribute to the success of ICB blockchain projects. They are considered crucial contributors of advancement in this novel industry. The essential roles of various experts in the ICB blockchain projects will be analyzed. **Developers of Smart Contracts:** The developers of smart contracts play a key role in the ICBS blockchain projects. These developers use Solidity to create and implement smart contracts on the ICBS platform. They can design smart contracts and offer diverse features, *e.g.*, creating exchangeable pre-extracted tokens, distributing tokens, developing DeFi contracts, and creating blockchain-based games. **DApps Developers:** DApps developers (user experience of blockchain applications) play a significant role in the ICBS blockchain projects. They can develop Web-based mobile applications on the ICBS platform. They can also use blockchain resources to develop a wide variety of applications, *e.g.*, wallets, DeFi markets, online games, and other decentralized applications and Metaverse directed applications. **Public Relations Department:** In the ICBS blockchain projects, this department is responsible for communication with the blockchain community, the media and the international community. Members of this department may be responsible for public relations issues within a project and for communicating news about project developments. They can also interact with other coworkers and the blockchain community at large. They also participate in marketing and advertising activities of the project. **Legal Department:** The legal experts are experienced in blockchain services; therefore, they play a key role in the ICB blockchain projects. They are responsible for analyzing rules and regulations concerning the blockchain platform and the ICBS network. They check the legal documents and contracts, preserve the intellectual rights, and settle down legal disputes. **Marketing Department:** The marketing experts can codify and implement marketing and advertising strategies for the ICBS projects. They can help determine the target users, analyze the market and competitions, develop advertising strategies, and increase the project knowledge. Financial and Risk Management Experts: The financial and risk management experts play a key role in the ICBS blockchain projects. They are responsible for analyzing the financial aspects of the project. They can also analyze tokens, distribution mechanisms, economic models, valuation, and other financial aspects to guide project developers and project managers. **Technical Support Team:** The technical support nodes in the ICBS are involved in providing technical support services and troubleshooting technical problems in the network. Network Control Fi-Chain: The network control nodes are responsible for managing and controlling the ICBS Network performance. They manage the network traffic to ensure that the network is operating optimally and reliably. **The ICB Network:** A Positively Effective Breakthrough in the Future of Economy and Technology In brief, the ICB Network is considered an innovative technology that can provide different features for improving economic performance, enhancing security, and offering new opportunities. We employ the blockchain technology to achieve cooperation and development in the digital world and move toward abetter and brighter future. Known as a novel base in technology and economy, blockchain plays a pivotal role in shaping our economic future and leads to new stable features for developments and advancement in society. Not only does this technology bring economic improvement and security to the world, but it also paves the way for reaching a better modern society. Therefore, blockchain is considered a golden opportunity for making positive, sustainable developments in our modern world. **Security Assurance:** Blockchain employs certain security algorithms, *e.g.*, PoS, to prevent fraud and unauthorized use of data. Therefore, it can enhance trust between individuals and businesses and ensure that transactions and information remain intact and safe. **Speed and Efficiency:** Limiting intermediaries and reducing the need for validation by central brokers, blockchain can accelerate transactions. This feature bears special importance in such cases as transferring funds between countries or validating the ICB transactions. **Transparency:** Blockchain operates publicly and transparently. The history logs of transactions are available to the public. This level of transparency reduces the risk of corruption and fraud in transactions and provides further information for the analysis of markets. **Economic Improvement:** The use of blockchain in the ICB projects and other industries will help improve the economy. This novel technology provides new opportunities for businesses and organizations, thereby enhancing efficiency and allowing for fees management. **Optimization of Gas Parameters:** The optimization of gas parameters is a major factor in reducing gas fees in the ICB Network. This optimization process includes the detailed setting of gas values based on smart contracts and transactions. As a result, the fees of transactions will be minimized, and the esteemed clients will incur lower fees for their transactions. **Employment and Development:** Developing the blockchain-based projects can help provide new job opportunities and achieve economic development. This technology allows developers and entrepreneurs to actualize their ideas and experience participation in the novel digital economy. With efforts and collaborations aimed at improving scalability, reducing gas fees, and accelerating transactions, the ICB blockchain is emerging as a powerful platform for developing DApps and innovative blockchain services. It continues to serve honorably as an efficient responsive platform in the digital world. # How to connect with ICBNetowork? {% embed url="" %} ## ICB MAINNET ***URL*** : [https://icbscan.io](#icb-mainnet) ***Chain ID*** : 73115 ***RPC*** : [https://rpc2-mainnet.icbnetwork.info/](https://rpc1-mainnet.icbnetwork.info/) ***Explorer*** : [https://icbscan.io](#icb-mainnet) ***Symbol*** : ICBX ## ICB Testnet ***URL*** : [https://testnet.icbscan.io](#icb-mainnet) ***Chain ID*** : 73114 ***RPC*** : [https://rpc2-testnet.icbnetwork.info/](https://rpc1-mainnet.icbnetwork.info/) ***Explorer*** : [https://testnet.icbscan.io](#icb-mainnet) ***Symbol*** : ICBT # Privacy Policy When you use our services, personal information about you is collected, used, and protected by ICB Network This is explained in this privacy policy (the "Policy"). You accept this Policy by using the Project. ### *Scope* All personal data gathered by the Project is covered by this policy, including: Details that you voluntarily supply, including your name, email address, and wallet address. Device information, transaction history, and IP address are examples of automatically gathered data. Data That We Gather We might gather the personal data listed below: Name, email address, wallet address, and any other information that can be used to identify you personally are examples of identifying information. \ **Transaction data:** Details about the transactions you've made on the Project, such as the sums you paid and the dates they were completed, together with any associated metadata. **Device information:** Details about your device, including its identifiers, operating system, and type of browser. **Usage data:** Details on your usage of the project, including the sites you visit, the features you utilize, and the amount of time you spend working on it. How Your Information Is Used by Us **We make use of your data to:** Supply and uphold the Project. Handle transactions and keep the blockchain ledger updated. Enhance the functionality and features of the project. Make your experience unique. Talk to you regarding the Project. Provide promotional and marketing materials to you (with your permission). **We might divulge your details to:** outside service providers who help us deliver the Project. agencies of law enforcement or other governmental bodies as mandated by legislation. others with your permission. Data Preservation If a longer retention period is mandated or allowed by law, we will keep your information for as long as it takes to achieve the goals stated in this policy. ### Your Right to Privacy *About your personal information, you are entitled to the following rights*: the ability to view your personal data. the ability to have any inaccurate information about you corrected. the ability to ask that your information be deleted. the ability to object to how your information is processed. the ability to limit how your information is processed. the freedom to transfer data. Safety Procedures We implement security protocols to safeguard your confidential data, such as:data that is sensitively encrypted. safe keeping of data. Authorization protocols and access controls. routine examinations of security. Modifications to this Policy This Policy may be revised from time to time. If there are any significant changes, we'll let you know by updating the Policy and publishing it on the Project website. Get in touch with us For any inquiries concerning our Policy, kindly reach out to us at ******. # Terms and conditions #### 1. **Staking Agreement** * **Commitment:** By staking your tokens, you agree to lock them for a predetermined period, during which they cannot be traded or withdrawn. * **Risks:** Be aware that staking involves risks, including market volatility and potential changes in the project's direction. #### 2. **Rewards and Penalties** * **Earning Rewards:** Rewards are distributed in accordance with the amount and duration of your stake. The longer and larger your stake, the greater the potential rewards. * **Penalty Clauses:** Early withdrawal or violation of staking terms may result in penalties, including forfeiture of rewards. #### 3. **Validator Responsibilities** * **Role:** Validators are crucial for maintaining network integrity. If you choose to become a validator, you must ensure your node remains online and performs optimally. * **Penalties for Downtime:** Validators facing frequent downtimes or malicious activities may be penalized, which could include a reduction in staking rewards or even ejection from the network. #### 4. **Governance Participation** * **Voting Rights:** Stakers may receive voting rights, allowing them to participate in key decision-making processes regarding network updates and governance changes. * **Active Involvement:** We encourage participants to actively engage in governance proposals to foster a democratic and transparent ecosystem. #### 5. **Privacy and Security** * **Data Protection:** We are committed to protecting your personal data. However, participants are also responsible for their own digital security, including safeguarding private keys and wallet information. * **Transparency:** While we uphold privacy, certain aspects of transaction history and staking records are public for network transparency. #### 6. **Regulatory Compliance** * **Legal Boundaries:** Participants must comply with their local laws and regulations regarding cryptocurrency and staking. * **Changes in Regulation:** Be aware that changes in regulatory landscapes could impact your participation in the project. #### 7. **Amendments** * **Updates to Terms:** These terms and conditions are subject to change. Any amendments will be communicated clearly to all participants. * **Continued Participation:** Your continued participation after such changes constitutes acceptance of the new terms. # Glossary # FAQS # Roadmap I**CB Network Development Roadmap** Welcome to the ICB Network development roadmap! This comprehensive guide outlines our key milestones and launch phases, providing you with a clear view of our exciting journey ahead. Here's what you can look forward to: **Q1 2024: Start of ICO Platform and Private Sale** * **ICO Platform Launch:** Marking the beginning of our investment phase, the ICO platform will be initiated for our primary investors. * **Private Sale:** We will conduct our inaugural private sale, providing our primary investors with an exclusive opportunity to be a part of the ICB journey. #### **Q1 2024: Presale Rounds** * **First Presale:** Launching our first presale, we'll offer attractive bonuses to early investors, making it an ideal time to get involved. * **Second Presale:** Following the success of the first, our second presale will come with great bonuses, continuing the momentum. #### **Q1 2024: Public Sale** * **Public Sale Launch:** The public sale will be open to all, featuring exciting offers for our wider investor community. This marks a significant step in broadening our investor base. #### **Q1 2024: Launch of Testnet** * **Overview:** The ICB Testnet will be rolled out, offering developers and the public an early glimpse into our innovative platform. This phase is crucial for testing and refining our network's features and capabilities. #### **Q2 2024: Mainnet Launch and Exchange Listings** * **Mainnet Launch:** Our fully operational mainnet will go live, accessible to developers and the public, signifying a major milestone in our project. * **Exchange Listings:** Our tokens will be listed on several exchanges, enabling public trading and increasing accessibility. #### **Q3 2024: Delegation Allotments and DAO Launch** * **Delegation Allotments:** We will assign delegation slots, an important element for governance and network stability. * **DAO and New Projects:** Alongside the DAO launch, we'll introduce several exciting projects on the ICB network, expanding our ecosystem and utility.
# How to connect ICB Network ## TEST NET Network name : ICB Testnet Network URL : ; Chain ID : 73114 Currency symbol : ICBT ## MAIN NET Network name : ICB Network Network URL : ; Chain ID : 73115 Currency symbol : ICBX # ICB Netowork Team