# Genesis of Cycle Network A brief introduction to the origin of Cycle Network. > *In the rapidly evolving realm of web3, the issue “Scaling” has persistently emerged as one of the foremost challenges so far. Developers are shifting different scaling solutions, and wandering plans from bridging to rollups, light clients , and IBC methods. However, those new methods still present roadblocks. Problems with shattered liquidity, overloaded transaction costs, endless deep learning, and trust hypothesis in centralized service still exist, and are still in an unstable status. These limitations reduce access to the broader web3 ecosystem of creativity, users, liquidity, and increase constraints of a particular technology. Inspired by Zelda, a famous open world game, we discuss the possibility of omnichain info/asset communication solution with trustless hypothesis and better developing experience, and introduce our solution, Cycle Network.* **A Tale Inspired by *****#Zeldatotk***** : Web3 Freedom**
We are getting inspired by the game “Zelda: Tears of Kingdom”. As a player, all you need to do is activate “**Skyview Town Open**” to expand the map. Each time you open a tower, you will be given new skills and tools.What’s even better is that you don’t have to go around learning how to fight monsters and collecting potentially useless weapons like in most games. Instead, you can use functions such as “**Ultrahand”** and “**Fuse**”, to grab, rotate, lift, align, attach, and upgrade objects, using your imagination to create the tools and weapons you need from the objects around you. \ **The freedom of creativity is a pivotal aspect of Zelda’s appeal, and is also something the ethos of crypto world.**In the world of Web3, developers find themselves in an experience different from the world of games like Zelda. Developers constantly struggle to balance their desire to create innovative products and improve user experiences, limited by the fragmented Web3 landscape. The reality requires builders to cater to users on various chains in a flustered way. \ **The questions then raise:** *“Why can’t Web3 developers focus on innovating their products and enhancing user experiences based on their desired business experience?”“Rather than reinvent the wheel, can anyone helps developers to build their own transportation, tool, and weapon? ”“Can we build the world of Web3 as Zelda, with developers envisioned as players in the Zelda?”*\ *Inspired by Zelda, a famous open world game, we discuss the possibility of omnichain info/asset communication solution with trustless hypothesis and better developing experience, and introduce our solution, Cycle Network.* \ **Cycle network:** Cycle’s mission is to empower the boundless creativity of Web3. By providing a chains network with seamless liquidity and functionality across all chains, and self custody function, aka settlement layer, shared liquidity model, and AA model, Cycle aims to liberate developers from repetitive tasks, from different layer structures to information/asset synchronization and deployment. Cycle encourages developers to wander uncharted realms, exploring the vast potential of Web3 without the burden of reinventing the wheel at every turn.Imagine a Web3 world that resembles the enchanting realms of Zelda. In this world, developers are like players who possess features like Ultrahand, Fuse, and Skyview Tower Open. Developers can easily create decentralized applications (dApps) through a simplified process. By using simple actions, developers can seamlessly assemble functionalities across the expanse of Web3. Cycle frees users from mastering each blockchain’s intricacies, making it easier to weave their creativity. \ Now, let's dive into Cycle Network! # Understanding Cycle Network Web3 marks a paradigm shift from Web2 by replacing centralized backend servers like IDC or cloud services with decentralized solutions. Over the past 16 years, Web3's development approach has evolved significantly. Initially, the focus was on large Layer 1 blockchains like Ethereum and Solana. However, in recent years, as Rollup technology has matured, developers have begun building their dApps on Layer 2 solutions or using independent Rollups. Despite these advancements, developers encounter increasing platform limitations, which hinder long-term projects and stifle industry innovation. Cycle Network addresses these challenges by offering secure chain abstraction technology. This enables developers to freely program for the entire Web3 user base and data using SDKs and other middleware, achieving true chain abstraction. Cycle Network constructs chain abstraction infrastructure through verifiable state aggregation and combines the Omni State Channel Indexer (OSCI) with a decentralized aggregated Sequencer to realize global state proof of trustless state changes across blockchain networks. It extracts the inherent trustless cross-chain characteristics from Rollup and extends them through the Rollup's Data Availability (DA) layer to a decentralized omni-chain settlement layer. This structure allows Cycle Network to support trustless global state proof across all Layer 1, Layer 2, and application chains. Cycle Network also inherits security from the chosen Rollup's security layer to achieve trustless global state proof. The Omni ZK-Rollup enables verifiers to efficiently confirm the existence of state changes between related chains and the Cycle Network. CycleNetwork further leverages ZK hardware acceleration to continuously optimize latency and enhance the user experience. # Benefits of Cycle Bridgeless Cycle Network introduces a decentralized, bridgeless hub that seamlessly interconnects all blockchains. With the proliferation of Layer 2 solutions and numerous chains, this innovation ensures that end-users and developers are no longer isolated or fragmented. It enables everyone to share liquidity, pay gas fees, and sign transactions without the need for traditional bridges. In the next section, we will explore the impact of Cycle Network's integration on end users and developers—two of the most crucial participants in the Web3 ecosystem.
# For End User Cycle Network’s bridgeless solution addresses the fragmentation in the Web3 experience. Users can seamlessly access and share liquidity across all chains, significantly lowering the costs associated with navigating a multichain environment. This integration greatly enhances the user experience by simplifying participation in multichain dApps and improving overall accessibility. ### **1. Bridgeless UX:**
### **2. Sharing a liquidity layer across all chains dramatically increases yields:**
### **3. Reduced cognitive and mental costs for users across different chains:**
# For Developer Cycle Network addresses key challenges developers face from three critical perspectives: user experience, technology, and cost. **Users：** Cycle Network brings millions of Web3 enthusiasts to your dApp ecosystem in a bridgeless manner. Its seamless user experience, featuring one-click operations and innovative cross-chain integration, significantly lowers the entry barriers for Web3 users. This ease of access enhances user engagement, increasing user volume, transaction volume, asset volume, and liquidity for your project. Additionally, Cycle Network allows users to interact with all blockchains without leaving your dApp, effectively breaking down barriers between different chains.\ **Technology：** Cycle Network introduces the Omni State Channel Indexer, which serializes and aggregates multi-chain states—key for achieving multi-chain abstraction. Compared to other chain abstraction solutions, Cycle offers universality (interconnecting heterogeneous blockchain ecosystems), security (providing Ethereum-equivalent security guarantees), and public verifiability due to its fully decentralized architecture. **Cost：** Cycle Network's unified all-chain liquidity pool brings several cost benefits: 1. Reduced Cross-Chain Transfer Costs: By enabling users to share liquidity from all chains within a single pool, Cycle Network eliminates the need for complex cross-chain operations and multiple inter-chain bridges. 2. Lower Transaction Costs: With assets pooled together, trading pairs become more liquid, reducing slippage and transaction costs. Additionally, Cycle’s intelligent routing algorithms optimize transaction paths, further minimizing expenses. 3. Improved Funding Efficiency: A unified liquidity pool mitigates fragmentation and idleness of funds across different chains, enhancing overall funding efficiency. # Engage with Cycle Community Join our community and stay updated with all our latest news and happenings. Interact with other likeminded people, receive latest platform updates and access exclusive perks. X: Telegram: Blog: Contact Us: # Connect to Cycle Cycle can be connected by using any EVM-supported wallet like MetaMask or can be directly accessed by JavaScript, which imports libraries such as Web3.js, Ether, etc. The recommended way to interact with Cycle is to use [Cycle-JS-SDK](https://docs.cyclenetwork.io/cycle-core-sdk/introduction), which integrates multiple steps into a single function call to let developers easily access cycle's core features without concentrating on coding details. The Cycle-JS-SDK can be acquired from NPM by executing the following commands in your developing environment: ```Plaintext $ yarn add @cyclenetwork/cyclejsor$ npm install @cyclenetwork/cyclejs ``` # Connect to Cycle Mainnet You can check everything about Cycle Network in the following section. **Cycle Network Mainnet (Maritime Transport):** [Cycle Frigate](/developers/connect-to-cycle/connect-to-cycle-mainnet/cycle-frigate) [Cycle Sailboat](/developers/connect-to-cycle/connect-to-cycle-mainnet/cycle-sailboat) # Cycle Frigate ## **Introdction:** Cycle Frigate has been successfully launched on Orctober 24 2025. With Etherum and many other EVM compatible chains' mainnet supported, you can experience Cycle's Multi-Chain Rollup feature on these mainnet with actual mainnet assets, allowing you to start building your multi-chain applications. ## **Network:** Cycle | **ChainId** | **chainName** | **Currency** | **NetworkId** | **RPC** | | ----------- | ------------- | ------------ | ------------- | --------------------------------------------- | | 88688 | Cycle Frigate | ETH | 1 | | Security Layer | **ChainId** | **chainName** | **Currency** | **NetworkId** | | ----------- | ---------------- | ------------ | ------------- | | 1 | Ethereum Mainnet | ETH | 0 | Extend Layer | **ChainId** | **chainName** | **NetworkId** | | ----------- | ----------------------- | ------------- | | 56 | BNB Smart Chain Mainnet | 2 | | 42161 | Arbitrum One | 3 | | 143 | Monad Mainnet | 6 | ## Token List:
Token IDToken SymbolToken NameEthereumCycleBSCArbitrum
1ETHETHNativeNative0x2170Ed0880ac9A755fd29B2688956BD959F933F8Native
2USDTTether USD0xdAC17F958D2ee523a2206206994597C13D831ec70x26Fa0B5eee93209c16a7C885053Eb0846aeaC4c10x55d398326f99059fF775485246999027B31979550xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9
3USDCUSD Coin0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB480x6DEB0Cc25e420cdFC361F72D7878fB24815469750x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d0xaf88d065e77c8cC2239327C5EDb3A432268e5831
4USD1World Liberty Financial USD0x8d0D000Ee44948FC98c9B98A4FA4921476f08B0d0xf548D7D2435eDaba19dA2E26256ADD9CDea31a280x8d0D000Ee44948FC98c9B98A4FA4921476f08B0dNot Available
# Cycle Sailboat ## **Introdction:** Cycle Sailboat has been successfully launched on July 25 2024. With Etherum and many other EVM compatible chains' mainnet supported, you can experience Cycle's Multi-Chain Rollup feature on these mainnet with actual mainnet assets, allowing you to start building your multi-chain applications. ## **Network:** Cycle | **ChainId** | **chainName** | **Currency** | **NetworkId** | **RPC** | | ----------- | -------------- | ------------ | ------------- | ------------------------------------------------------------------------------------------------------------- | | 77677 | Cycle Sailboat | ETH | 1 | [https://sailboat-rpc-mainnet.cyclenetwork.io ]() | Security Layer | **ChainId** | **chainName** | **Currency** | **NetworkId** | | ----------- | ---------------- | ------------ | ------------- | | 1 | Ethereum Mainnet | ETH | 0 | Extend Layer | **ChainId** | **chainName** | **NetworkId** | | ----------- | ----------------------- | ------------- | | 56 | BNB Smart Chain Mainnet | 14 | | 42161 | Arbitrum One | 4 | | 80094 | Berachain | 17 | | 169 | Manta Pacific Mainnet | 16 | ## **Token List:**
Token SymbolToken NameNetworkContractVault
USDTTether USDCycle Network0xbe50f2b9D05fc4f686509c6a8b1AB3F90cbD9D74
USDTTether USDBNB Smart Chain Mainnet0x55d398326f99059fF775485246999027B3197955coming soon
USDTTether USDBerachain0x779Ded0c9e1022225f8E0630b35a9b54bE713736
USDCUSD CoinCycle Network0x799f269f4B473Abc896e5A978Bb1A086B458421f
USDCUSD CoinBNB Smart Chain Mainnet0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d
USDCUSD CoinBerachain0x549943e04f40284185054145c6E4e9568C1D3241
GOOSEGolden GooseCycle Network0x9726C143931B542E7C0c3d327d6899796D51b781
GOOSEGolden GooseBNB Smart Chain Mainnet0x8F2F5AF6Da618023aF152D3245288202AB9c7d14
USD1World Liberty Financial USDCycle Network0xb8d3f184D7Ba36eea06fd83DAbed8a3c4beD7599
USD1World Liberty Financial USDBNB Smart Chain Mainnet0x8d0D000Ee44948FC98c9B98A4FA4921476f08B0d
USD1World Liberty Financial USDEthereum Mainnet0x8d0D000Ee44948FC98c9B98A4FA4921476f08B0d
WLFIWorld Liberty FinancialCycle Network0x4a9180341D547193dB59eeDb113a2B80e2C348F6
WLFIWorld Liberty FinancialEthereum Mainnet0xdA5e1988097297dCdc1f90D4dFE7909e847CBeF6
# Connect to Cycle Testnet **Cycle Network Testnet (Aquatic Creatures):** [Cycle JellyFish](/developers/connect-to-cycle/connect-to-cycle-testnet/cycle-jellyfish-archived)(Archived) [Cycle CuttleFish](/developers/connect-to-cycle/connect-to-cycle-testnet/cycle-cuttlefish-archived)(Archived) [Cycle StarFish](/developers/connect-to-cycle/connect-to-cycle-testnet/cycle-starfish-archived)(Archived) # Cycle JellyFish(Archived) ## **Introdction:** JellyFIsh is a Comprehensive Upgrade of StarFish TestNet. Which launched july 7 2024. With cost-effective DAC integrated and further enhancement of network security, JellyFish has significantly optimized state synchronization efficiency and reduced synchronization costs while enhancing security. ## **Network:** Cycle | **ChainId** | **chainName** | **Currency** | **NetworkId** | | ----------- | --------------- | ------------ | ------------- | | 1223 | Cycle JellyFish | ETH | 1 | Security Layer | **ChainId** | **chainName** | **Currency** | **NetworkId** | | ----------- | ------------- | ------------ | ------------- | | 11155111 | Sepolia | ETH | 0 | Extend Layer | **ChainId** | **chainName** | **NetworkId** | | ----------- | ---------------- | ------------- | | 10143 | Monad Testnet | 16 | | 5611 | opBNB Testnet | 6 | | 421614 | Arbitrum Sepolia | 4 | | 11503 | BEVM Testnet | 10 | | 195 | X Layer Testnet | 9 | {% hint style="info" %} Attention: Testnet is not suitable for long-term data storage as data will be periodically reset. {% endhint %} # Cycle CuttleFish (Archived) ## **Introdction:** CuttleFish testnet is a cycle test network running in parallel with the JellyFish testnet. This network has incorporated additional compatibility upgrades to integrate with various EVM-compatible blockchain networks, although there are some differences in details compared to traditional EVM virtual machines. ## **Network:** Cycle | **ChainId** | **chainName** | **Currency** | **NetworkId** | | ----------- | ---------------- | ------------ | ------------- | | 1228 | Cycle CuttleFish | ETH | 1 | Security Layer | **ChainId** | **chainName** | **Currency** | **NetworkId** | | ----------- | ------------- | ------------ | ------------- | | 11155111 | Sepolia | ETH | 0 | Extend Layer | **ChainId** | **chainName** | **NetworkId** | | ----------- | --------------- | ------------- | | 1802203764 | Kakarot Sepolia | 16 | {% hint style="info" %} Please check the Official Documentations of the extend layers listed above to learn the difference between their VM and standard EVM. {% endhint %} {% hint style="info" %} Attention: Testnet is not suitable for long-term data storage as data will be periodically reset. {% endhint %} # Cycle StarFish (Archived) ## **Introdction:** StarFish is the first testnet of Cycle launched on Jan 25 2024. The purpose of launching startfish is to verify the Feasibility of Cycle's Multi-Chain Rollup Mechanism in Practical Applications. By now, Starfish has supported many Mainstream Ethereum Ecosystem Networks and Bitcoin Layer 2 Solutions. ## **Network:** Cycle | **ChainId** | **chainName** | **Currency** | **NetworkId** | | ----------- | -------------- | ------------ | ------------- | | 1221 | Cycle StarFish | ETH | 1 | Security Layer | **ChainId** | **chainName** | **Currency** | **NetworkId** | | ----------- | ------------- | ------------ | ------------- | | 11155111 | Sepolia | ETH | 0 | Extend Layer | **ChainId** | **chainName** | **NetworkId** | | ----------- | ------------------------------------ | ------------- | | 97 | BNB Smart Chain Testnet (deprecated) |


| | 5611 | opBNB Testnet | 6 | | 421614 | Arbitrum Sepolia | 4 | | 11155420 | op-sepolia | 5 | | 59141 | Linea Sepolia (incoming) |


| | 84532 | Base Sepolia Testnet (incoming) |


| | 80085 | Berachain Artio (incoming) |


| | 11503 | BEVM Testnet | 10 | | 195 | X Layer Testnet | 9 | | 4690 | IoTeX Network Testnet (deprecated) |


| | 80002 | Polygon(Amoy) （deprecated） |


| {% hint style="info" %} Attention: Testnet is not suitable for long-term data storage as data will be periodically reset. {% endhint %} # Testnet Tokens If you are interested in Cycle, you can [**contact us**](https://t.me/+qgZQaNPylrcyYjE9) to get Testnet Token and experience all the features Cycle implements. # Operator Guideline Cycle Network is a universal, secure, and verifiable chain abstraction architecture, which will use the restaking service provided by Symbiotic to run some tasks, improving the security and availability of the system.Operators eligible to provide infrastructure for Cycle will obtain restake from Symbiotic, run DAC (Data Availability Committe) nodes, and provide decentralized DA (Data Availability) services for Cycle Network.This article is an operator operation guideline. ## System Requirements ### Hardware Requirements: * CPU: 4 cores or higher * Memory: 8GB or higher * Storage: 500GB SSD or larger * Network: 10Mbps or higher bandwidth, public IP Address accessible from outside ### Software Requirements * Operating System: Ubuntu 20.04 LTS or higher * Docker, Docker Compose: used to run DAC Node docker mirroring * Database: PostgreSQL, used to store Cycle Network DA data. The database can be a local database or cloud service (AWS RDS PostgreSQL). * Domain name and DNS configuration: Apply for a domain name and map it to a machine IP. ## DAC Node Running Steps ### Prerequisite Before running the DAC Node, it is necessary to ensure that the Operator has completed the following steps: 1. Complete Symbiotic related configuration 1. Register as an Operator in Symbiotic 2. Opt-in Cycle Network 3. Opt-in Vaults that are chosen by Cycle 2. Provide the following information to Cycle Network to register as a Committee member in the DataCommitte contract: 1. Committee member address: This address is used to sign the sequence batch data sent by the cycle node 2. Committee member URL: URL for providing DA services to external parties (obtaining DA data and signing DA data). ### Running Node There are two ways to run the node: using Docker or compiling the code from Github. Below are the details of both methods: #### Running Node via Docker(Recommended) 1. Install Docker, Docker Compose Refer to the following links to install Docker and Docker Compose respectively. [https://docs.docker.com/compose/install//](https://docs.docker.com/compose/install/standalone/) 2. Get DAC Docker image and configuration files Pull official DAC Node mirroring from DockerHub with command: > docker pull cyclenetworklabs/cycle-data-availability:latest \ Docker compose starts configuration file docker-compose.yml, DAC Node starts configuration file config.toml examples can be found in Github repository: 3. Modify the configuration file config.toml Modify the corresponding configuration in config.toml according to the actual situation. The description of each configuration item is mentioned in the following section. 4. Start local PostgreSQL DB (optional, required when using local DB to save data) Modify the environment configuration corresponding to the cdk-data-availability-db in docker-compose.yaml. The configuration information needs to be consistent with the DB configuration configured in config.toml. > environment:- POSTGRES\_USER = committee\_user//Login username- POSTGRES\_PASSWORD = committee\_password//Login password- POSTGRES\_DB = committee\_db//database name Execute the following command to start PostgreSQL DB. > docker-compose -f docker-compose.yml up cdk-data-availability-db -d 5. Running a DAC Node Execute the following command to start the DAC Node. > docker-compose -f docker-compose.yml up cdk-data-availability -d 6. Check DAC Node running status After the DAC Node is started, you can check whether the DAC Node is working properly through docker logs. #### Running Node by Compiling code from Github 1. Clone the code from Github Run the following command to clone the repository: > git clone 2. Navigate to the Repository and Compile Change directory to the cloned repository and build the project > cd cycle-data-availabilitymake build The compiled binary would be located at: `./dist/cycle-data-availability` 3. Modify the configuration file config.toml Modify the corresponding configuration in config.toml according to the actual situation. The description of each configuration item is mentioned in the following section. 4. Running a DAC Node Run the following command to start the DAC Node. > ./dist/cycle-data-availability run --cfg config.toml ## Deployed Contracts ### Mainnet (Ethereum) * ZkEVMAddress : 0xfCE76003936BB8D96DdD4ed403ecF27a1f06a06a * DataCommitteeAddress : 0x7f2Ecde4E92c089B7a0db63fD8A15755BCDF3BF7 ### Testnet (Ethereum Sepolia Testnet) * ZkEVMAddress : 0x3eA5Caf406694dc187DF4668D1ae269d46cE4b8D * DataCommitteeAddress : 0x9ae0FFC3eE870a0a23AcFe0E19c2296f2A4A7875 ## Configuration Instructions The following is an example of a configuration file, and each configuration item will be described in detail later. ```toml PrivateKey = {Path = "/pk/test-member.keystore", Password = "testonly"} [L1] WsURL = "wss://xxxx" RpcURL = "https:xxxx" ZkEVMAddress = "0xxxxx" DataCommitteeAddress = "0xxxxx" Timeout = "3m" RetryPeriod = "5s" BlockBatchSize = 256 [Log] Environment = "development" # "production" or "development" Level = "debug" Outputs = ["stderr"] [DB] User = "postgres" Password = "xxxx" Name = "committee_db_dac" Host = "xxxx" Port = "5432" EnableLog = false MaxConns = 200 [RPC] Host = "0.0.0.0" Port = 8444 ReadTimeout = "60s" WriteTimeout = "60s" MaxRequestsPerIPAndSecond = 500 ``` ### Keystore Configuration Configure the address used by DAC Node for Cycle DA data signing, which needs to be registered in the DataCommittee contract of the Ethereum mainnet/testnet. * PrivateKey: Path is the path to the keystore file, Password is the corresponding password. The keystore format should comply with Ethereum standard. ### L1 Configuration * WsURL: WebSocket URL for accessing the Ethereum mainnet/testnet. * RpcURL: RPC URL for accessing Ethereum mainnet/testnet. * ZkEVMAddress: The ZkEVM contract address deployed on the mainnet/testnet. Check "Deployed Contracts" parts to get the address for mainnet/testnet. * DataCommitteeAddress: DataCommittee contract address deployed on mainnet/testnet. Check "Deployed Contracts" parts to get the address for mainnet/testnet. * Timeout: The time until RPC requests time-out * RetryPeriod: Time Interval for synchronizing contract events * BlockBatchSize: Synchronize contract event block range ### Log Configuration * Environment: Log configuration for production environment or testing environment * Level: Log level * Outputs: Log output path ### DB Configuration * User: DB login username * Password: DB login password * Name: DB database name * Host: DB database host * Port: DB port * EnableLog: Whether to use DB Log * MaxConns: Maximum number of connections for DB ### RPC Configuration * HostRPC: Host IP Address for running RPC service * Port: Port Number on which to run the RPC service * ReadTimeout: HTTP Server read timeout * WriteTimeout: HTTP Server write timeout * MaxRequestsPerIPAndSecond: Maximum requests per second per IP ## Reference Links 1. Dac Github Repository: # Transfer within Cycle Transfer tokens within Cycle can be easily accomplished by using ether.js and web3.js. A coding example can be seen below: ```typescript import { Contract, Wallet, BigNumberish, providers } from 'ethers' const rpc = 'https://rpc-testnet.cyclenetwork.io' const abi = [ 'function transfer(address to, uint256 amount) external returns (bool)' ] async erc20Transfer( privateKey: string, tokenAddress: string, toAddress: string, amount: BigNumberish ) { const provider = new providers.JsonRpcProvider(rpc) const signer = new Wallet(privateKey, provider) const contract = new Contract(tokenAddress, abi, signer) const tx = await contract.transfer(toAddress, amount) const recepit = await tx.wait() } ``` We can also transfer tokens by MetaMask, which is connected to Cycle directly. # How to roll in tokens ## **ERC20 tokens** The most outstanding advantage of Cycle is that it allows assets from multiple chains to be deposited into Cycle, which is named Rollin in our scenario. The most common scene is rolling erc20 tokens to Cycle, which is supported by SDK. Here we show an example of how to rollin ERC20 token from Sepolia to Cycle. ```typescript async function getZkEvmClient( privateKey: string, userAddress: string, network: string = 'testnet', version: string = 'starfish' ) { const zkEvmClient = new ZkEvmClient() return zkEvmClient.init({ log: true, network, version, child: { name: 'cycle', provider: new HDWalletProvider(privateKey, RPC_CYCLE), defaultConfig: { from: userAddress, }, }, parent: { name: 'sepolia', provider: new HDWalletProvider(privateKey, RPC_SEPOLIA), defaultConfig: { from: userAddress, }, }, }) } async function rollin( tokenId: number, amount: BigNumberish, receiverAddress: string ) { const client = await getZkEvmClient() const erc20Token = client.customERC20(tokenId, true) const result = await erc20Token.deposit(amount, receiverAddress) const txHash = await result.getTransactionHash() const receipt = await result.getReceipt() } ``` {% hint style="info" %} Currently, we only have a test ERC20 token named 'CYCLE' used to present Cycle's capacity of all-chain assets management whose tokenId is 1. Soon we will have more origin tokens issued on Cycle and wrap tokens whose original tokens are already issued on Security Layer/Extend Layers. Soon, we will provide a query-API listing all the tokens' information including token address and token id. {% endhint %} {% hint style="info" %} When a new kind of ERC20 token is rolling-in from the origin layer to Cycle for the first time, the rollin smart contract will automatically deploy a wrapped ERC20 token contract that corresponds to the origin token deployed on the origin layer. {% endhint %} # How to roll out tokens ## **ERC20 tokens** As a counterpart of Rollin, we can transfer ERC20 assets from Cycle to any destination layer that Cycle supports, which is defined as rollout. A demonstration of rolling-out ERC20 tokens by using SDK is illustrated below. ```typescript async function rollout( tokenId: number, amount: BigNumberish, receiverAddress: string ) { const client = await getZkEvmClient() const erc20Token = client.customERC20(tokenId) const result = await erc20Token.withdraw(amount, receiverAddress) const txHash = await result.getTransactionHash() const receipt = await result.getReceipt() }type ``` When the rolling-out transaction is fully processed, the token balance of the from-address in Cycle will be reduced as we expected; but on the other hand, the to-address in the destination chain will not have a balance increase. To get the rolling-out assets, we need to [claim](https://app.gitbook.com/o/zsuLq6nkAsruS3oE16NY/s/TzgQbqR8ub1ustDteGf4/~/changes/32/quick-start/claim-assets-on-destination-chain) it on the destination chain. # Claim assets on destination chain As we mentioned in [section.5](https://app.gitbook.com/o/zsuLq6nkAsruS3oE16NY/s/TzgQbqR8ub1ustDteGf4/~/changes/32/quick-start/rollin-erc20-tokens-to-cycle), users need to claim the assets that rolled out from Cycle to be acquired on the destination chain. The procedures of claiming are composed of two parts, getting rollout transactions and claiming assets corresponding to a specific rollout. First, we need to have all unclaimed rollout transactions listed. Thanks to SDK, we just have to call a single function instead of going through all transactions recorded on a Cycle to get them. ```typescript interface ListBridgeTransactionsResult { deposits: Deposit[]; total_cnt: number; } interface NetworkService { listBridgeTransactions) version: string, owner: string, page: number = 0, pageSize: number = 10 ): Promise } service.zkEvmNetwork.listBridgeTransactionsBySender( 'starfish', '0x1234...', ) ``` Then we need to find out which rollout asset we want to acquire, and then claim it by calling SDK method. ```typescript async function claimRollout( transactionHash: string, tokenId: number ) { const client = await getZkEvmClient() const erc20Token = client.customERC20(tokenId) const result = await erc20Token.depositClaim(transactionHash) const txHash = await result.getTransactionHash() const receipt = await result.getReceipt() } ``` # Cycle Core SDK # Introduction CYCLE-CORE-SDK is a highly integrated development tool that allows developers to easily implement their applications empowered by Cycle. It provides JavaScript interfaces to interact with Cycle Network in all aspects. Just two steps Rollin and Rollout to achieve chain abstraction. This section lists the most common used interfaces in CYCLE-CORE-SDK, and will help developers to refer the SDK functions quickly. {% hint style="info" %} CYCLE-CORE-SDK is currently undergoing rapid iteration, and in subsequent version upgrades, some interfaces may not be backward compatible. {% endhint %} # Getting Started ## 1.Installation ``` pnpm i cycle-core-sdk ``` ## **2.Init** {% tabs %} {% tab title="Usage" %} Initialize Cycle SDK client {% endtab %} {% tab title="Parameters" %} network: Specify which cycle network the SDK client should connect to. {% endtab %} {% tab title="Return" %} The Client it self {% endtab %} {% endtabs %} ```typescript import { CycleCoreSDK } from "cycle-core-sdk"; const sdk = new CycleCoreSDK({ // available options: sailboat, jellyfish network: "jellyfish", }); ``` # Onchain Transaction ## **1.rollIn** {% tabs %} {% tab title="Usage" %} Roll your ETH to cycle {% endtab %} {% tab title="Parameters" %} ethersSigner: standard signer of ethers.js fromChainId: the chain id where you initiate rollin transaction receiveAddress: the address you will receive token on cycle amount: its name explained itself {% endtab %} {% tab title="Return" %} Standard ethers.TransactionResponse {% endtab %} {% endtabs %} ```typescript sdk.rollIn(ethersSigner: ethers.Signer, fromChainId: number, receiveAddress: string, amount: string): Promise; ``` ## **2.rollOut** {% tabs %} {% tab title="Usage" %} Roll your ETH from cycle to other chains {% endtab %} {% tab title="Parameters" %} ethersSigner: standard signer of ethers.js toChainId: the chain id where you want to bridge your token receiveAddress: the address you will receive token on cycle amount: its name explained itself {% endtab %} {% tab title="Return" %} Standard ethers.TransactionResponse {% endtab %} {% endtabs %} ```typescript sdk.rollOut(ethersSigner: ethers.Signer, toChainId: number, receiveAddress: string, amount: string): Promise; ``` ## **3.rollInMessage** {% tabs %} {% tab title="Usage" %} Roll your message to cycle {% endtab %} {% tab title="Parameters" %} ethersSigner: standard signer of ethers.js fromChainId: the chain id where you initiate rollin transaction receiveAddress: the address you will receive token on cycle amount: its name explained itself {% endtab %} {% tab title="Return" %} Standard ethers.TransactionResponse {% endtab %} {% endtabs %} ```typescript sdk.rollInMessage(ethersSigner: ethers.Signer, fromChainId: number, receiveAddress: string, message: string): Promise; ``` ## **4.rollOutMessage** {% tabs %} {% tab title="Usage" %} Roll your message from cycle to other chains {% endtab %} {% tab title="Parameters" %} ethersSigner: standard signer of ethers.js toChainId: the chain id where you want to bridge your token receiveAddress: the address you will receive token on cycle message: its name explained itself {% endtab %} {% tab title="Return" %} Standard ethers.TransactionResponse {% endtab %} {% endtabs %} ```typescript sdk.rollOutMessage(ethersSigner: ethers.Signer, toChainId: number, receiveAddress: string, message: string): Promise; ``` ## **5.claimAssets** {% tabs %} {% tab title="Usage" %} Claim your assets after being rolled out. The assets rolled in will be claimed automatically. {% endtab %} {% tab title="Parameters" %} ethersSigner: standard signer of ethers.js claimInfo: the proxy object including everthing needed to claim {% endtab %} {% tab title="Return" %} Standard ethers.TransactionResponse {% endtab %} {% endtabs %} ```typescript sdk.claimAsset(ethersSigner: ethers.Signer, claimInfo: IClaimInfo): Promise; ``` ## **6.claimMessage** {% tabs %} {% tab title="Usage" %} Claim your message after being rolled out. The assets rolled in will be claimed automatically. {% endtab %} {% tab title="Parameters" %} ethersSigner: standard signer of ethers.js claimInfo: the proxy object including everthing needed to claim {% endtab %} {% tab title="Return" %} Standard ethers.TransactionResponse {% endtab %} {% endtabs %} ```typescript sdk.claimMessage(ethersSigner: ethers.Signer, claimInfo: IClaimInfo): Promise; ``` # Query Service ## Bridge Service The `BridgeService` class provides methods to interact with the Cycle network's bridge functionality, allowing users to manage deposits, claims, and cross-chain transactions. ## **1.getBridge** {% tabs %} {% tab title="Usage" %} Gets a specific bridge deposit. {% endtab %} {% tab title="Parameters" %} netId: network\_id where the rollup initiated depositCnt: the nonce of deposit on a certain chain {% endtab %} {% tab title="Return" %} Standard AxiosResponse {% endtab %} {% endtabs %} ```typescript sdk.bridgeService.getBridge(netId: number, depositCnt: string): Promise; ``` ## **2.getMerkleProof** {% tabs %} {% tab title="Usage" %} Retrieves the Merkle proof for a specific deposit. {% endtab %} {% tab title="Parameters" %} netId: network\_id where the rollup initiated depositCnt: the nonce of deposit on a certain chain destNetwork: network\_id where corresponding to the rollup destination chain {% endtab %} {% tab title="Return" %} Standard AxiosResponse {% endtab %} {% endtabs %} ```typescript sdk.bridgeService.getMerkleProof(netId: number, depositCnt: string, destNetwork: number): Promise; ``` ## **3.getBridgeByTransaction** {% tabs %} {% tab title="Usage" %} Gets a bridge deposit by its transaction hash. {% endtab %} {% tab title="Parameters" %} netId: network\_id where the rollup initiated txHash: the rollup txHash {% endtab %} {% tab title="Return" %} Standard AxiosResponse {% endtab %} {% endtabs %} ```typescript sdk.bridgeService.getBridgeByTransaction(netId: number, txHash: string): Promise; ``` ## **4.getBridges** {% tabs %} {% tab title="Usage" %} Retrieves bridge deposits for a specific user address. {% endtab %} {% tab title="Parameters" %} userAddr: the direct caller address of the bridge contract offset: the start position of rollup list limit: the return count of rollup {% endtab %} {% tab title="Return" %} Standard AxiosResponse {% endtab %} {% endtabs %} ```typescript sdk.bridgeService.getBridges(userAddr: string, offset: number = 0, limit: number = 10): Promise; ``` ## **5.getSenderBridges** {% tabs %} {% tab title="Usage" %} Retrieves all bridge deposits for a specific sender address. {% endtab %} {% tab title="Parameters" %} senderAddr: the sender of the rollup tx offset: the start position of rollup list limit: the return count of rollup {% endtab %} {% tab title="Return" %} Standard AxiosResponse {% endtab %} {% endtabs %} ```typescript sdk.bridgeService.getSenderBridges(senderAddr: string, offset: number = 0, limit: number = 10): Promise; ``` ## **6.getSenderBridgesNotClaimed** {% tabs %} {% tab title="Usage" %} Retrieves all bridge deposits to be claimed for a specific sender address. {% endtab %} {% tab title="Parameters" %} senderAddr: the sender of the rollup tx offset: the start position of rollup list limit: the return count of rollup {% endtab %} {% tab title="Return" %} Standard AxiosResponse {% endtab %} {% endtabs %} ```typescript sdk.bridgeService.getSenderBridgesNotClaimed(senderAddr: string, offset: number = 0, limit: number = 10): Promise; ``` ## **7.getCrossChainBridges** {% tabs %} {% tab title="Usage" %} Gets cross-chain bridge transactions for a specific user address. {% endtab %} {% tab title="Parameters" %} rollinTx: the rollin tx on the initiate chain networkId: the initiate chain network\_id {% endtab %} {% tab title="Return" %} Standard AxiosResponse {% endtab %} {% endtabs %} ```typescript sdk.bridgeService.getCrossChainBridges(senderAddr: string, offset: number = 0, limit: number = 10): Promise; ``` ## **8.getCrossChainBridgeByRollIn** {% tabs %} {% tab title="Usage" %} Retrieves a cross-chain bridge transaction by its roll-in transaction hash. {% endtab %} {% tab title="Parameters" %} rollinTx: the rollin tx on the initiate chain networkId: the initiate chain network\_id {% endtab %} {% tab title="Return" %} Standard AxiosResponse {% endtab %} {% endtabs %} ```typescript sdk.bridgeService.getCrossChainBridgeByRollIn(rollinTx: string, networkId: number): Promise; ``` ## **9.batchGetCrossChainBridges** {% tabs %} {% tab title="Usage" %} Gets multiple cross-chain bridge transactions in a single batch request. {% endtab %} {% tab title="Parameters" %} rollinRequests: the array of the rollin request params you want to query {% endtab %} {% tab title="Return" %} Standard AxiosResponse {% endtab %} {% endtabs %} ```typescript sdk.bridgeService.batchGetCrossChainBridges(rollInRequests: Array<{ rollin_tx: string; network_id: number }>): Promise; ``` # AVS Operators # Cycle Unit Guide ## 1. Create APP 1. Go to Cycle Unit Manager to log in and create an APP [\[link\]](https://unit.cyclenetwork.io/) and connect your wallet to log in. Each EOA address can create or manage one APP. 2. On your first login, you'll see the page below. Enter your Organization Name and App Name to create your first app.
3. Fill in the relevant details for your newly created app.
4. Click + to add asset managers and select the supported tokens. Then click Submit to complete the setup.
Note: You can update your App Info and App Details anytime. If you need to make changes — such as updating, adding, or removing asset managers — you can do so at any time. ## 2. Deploy Vault Contract The Vault contract is used for users to deposit funds. It must implement the `deposit` method. For specific implementation, please refer to [the documentation](https://github.com/CycleNetwork-Labs/cycle-unit-example-vault-contract). ```solidity // @param user The staker's account // @param token The contract address, use address(0) for native token function deposit( address user, address token, uint256 amount ) external payable; event Deposit(address user, address token, uint256 amount); ``` ## 3. Interfaces The Cycle Unit SDK helps users implement the withdrawal UI. Withdrawals require the application server to provide a balance query interface and a withdrawal application interface. After configuring the interface addresses, users can initiate withdrawals directly through the client. The application needs to verify the validity of the data and implement the asynchronous withdrawal logic on the server side. ### 3.1 User Withdrawable Balance Query Interface Request Method: GET Request Parameters: | Parameter Name | Type | Required | Description | | -------------- | ------ | -------- | ---------------- | | userAddress | string | Yes | User eoa address | Request Example: ```go curl --location 'https://unit-api.cyclenetwork.io/v5/mock/balance?userAddress=0x10Ca44272987fa662cA8C4916361c378b7Da4D50' ``` Response Parameters: ```go { "code": 0, "data": [ { "tokenSymbol": "USDT", "tokenDecimals": 6, "tokenAmount": "5000000", "feeSymbol": "USDT", "feeDecimals": "6", "feeAmount": "1000000" }, { "tokenSymbol": "ETH", "tokenDecimals": 18, "tokenAmount": "2000000000000000000", "feeSymbol": "USDT", "feeDecimals": "6", "feeAmount": "1000000" } ], "message": "success" } ``` ### 3.2 Withdrawal Application Interface Request Method: POST Authentication Method: EIP712 Request Parameters:
Parameter NameParameter TypeRequiredDescription
userAddressstringYesUser address
messageobject[Withdraw]YesWithdrawal information
signaturestringYesSignature information
Request Parameter Example: ```json { "userAddress": "0x10Ca44272987fa662cA8C4916361c378b7Da4D50", "message": { "tokenSymbol": "USDT", "amount": "2000000", "destinationChainId": 421614, "chainId": 11155111, "timestamp": 1234567890 }, "signature": "xxxx" } ``` \ EIP712 Signature Parameters: ```go typedData := apitypes.TypedData{ Types: apitypes.Types{ "EIP712Domain": { {Name: "name", Type: "string"}, {Name: "version", Type: "string"}, {Name: "chainId", Type: "uint256"}, {Name: "verifyingContract", Type: "address"}, }, "Withdraw": { {Name: "tokenSymbol", Type: "string"}, {Name: "amount", Type: "uint256"}, {Name: "destinationChainId", Type: "uint256"}, {Name: "chainId", Type: "uint256"}, {Name: "timestamp", Type: "uint256"}, }, }, PrimaryType: "Withdraw", Domain: apitypes.TypedDataDomain{ Name: "Cycle Network", Version: "1", ChainId: math.NewHexOrDecimal256(params.Message.ChainID), VerifyingContract: "0x0000000000000000000000000000000000000000", }, Message: map[string]interface{}{ "tokenSymbol": params.Message.TokenSymbol, "amount": amount, "destinationChainId": big.NewInt(params.Message.DestinationChainId), "chainId": big.NewInt(params.Message.ChainID), "timestamp": big.NewInt(params.Message.Timestamp), }, } ``` \ Response Parameters: ```go { "code": 0, "message": "success", "data": "PENDING" } ``` ## 4. React Components SDK ### 4.1 Frontend Usage
Full documentation is available on 

import { Deposit, Withdraw } from "cycle-unit";

const apiBaseUrl = import.meta.env.VITE_ADMIN_API_BASE_URL;

if (!apiBaseUrl) {
  throw new Error("Missing VITE_ADMIN_API_BASE_URL");
}

const appId = "your-app-id";
const walletConnectProjectId = "your-walletconnect-project-id";
const vaultChainId = -1; // replace with the numeric chain id that holds your vault
const vaultContract = "your-vault-contract-address";
const shouldProvideProviders = true; // set to false when your app already wraps children in Wagmi/RainbowKit providers

<Deposit
  appId={appId}
  apiBaseUrl={apiBaseUrl}
  walletConnectProjectId={walletConnectProjectId}
  vaultChainId={vaultChainId}
  vaultContract={vaultContract}
  shouldProvideProviders={shouldProvideProviders}
  onDeposit={(action) => console.log("Deposit completed", action)}
/>;

<Withdraw
  appId={appId}
  apiBaseUrl={apiBaseUrl}
  walletConnectProjectId={walletConnectProjectId}
  vaultChainId={vaultChainId}
  vaultContract={vaultContract}
  shouldProvideProviders={shouldProvideProviders}
  onWithdraw={(action) => console.log("Withdraw completed", action)}
/>;

- `appId` – Identifier copied from the admin surface for the app you are embedding.
- `apiBaseUrl` – Base URL for the Cycle backend; must be defined as `VITE_ADMIN_API_BASE_URL`.
- `walletConnectProjectId` – WalletConnect project identifier used to launch the connect modal.
- `vaultChainId` – Numeric chain ID that backs the vault handling deposits and withdrawals.
- `vaultContract` – Contract address for the vault on the specified chain.
- `shouldProvideProviders` – Controls whether the SDK mounts its own Wagmi/RainbowKit providers. Leaving it undefined lets the SDK auto-detect existing context; keep it `true` when integrating standalone, and set `false` if your application already supplies these wrappers.
## 5. Withdrawal SDK When APP users initiate a withdrawal, they can use the following SDK to construct, sign, and submit the transaction. Alternatively, they can refer to the code to customize their own logic.**Usage:**Import: ```go go get -u github.com/CycleNetwork-Labs/cycle-unit-withdraw-sdk/withdraw-go ``` Usage Example: ```go package main import ( "context" "log" "math/big" "github.com/CycleNetwork-Labs/cycle-unit-withdraw-sdk/withdraw-go/transactions" "github.com/davecgh/go-spew/spew" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/ethclient" ) func main() { ctx := context.Background() sender := common.HexToAddress("") client, err := ethclient.Dial("") if err != nil { log.Fatal(err) } nonce, err := client.PendingNonceAt(ctx, sender) gasPrice, err := client.SuggestGasPrice(ctx) gasLimit := uint64(220000) sourceChainID := int64(11155111) destinationChainID := int64(421614) destinationAddress := common.HexToAddress("0x0") params := transactions.WithdrawParams{ Client: client, Nonce: nonce, GasPrice: gasPrice, GasLimit: gasLimit, TokenSymbol: "USDT", SourceChainID: sourceChainID, DestinationChainID: destinationChainID, DestinationAddress: destinationAddress, Amount: big.NewInt(1000000), } tx, err := transactions.Build(params) if err != nil { log.Fatal(err) } spew.Dump(tx) } ``` \ Withdrawal Parameters: * `TokenSymbol`: Token symbol defined by Cycle [\[link\]](/developers/connect-to-cycle/connect-to-cycle-mainnet/cycle-frigate#token-list) * `SourceChainID`: Chain ID initiating the transfer * `DestinationChainID`: Chain ID receiving the tokens * `DestinationAddress`: Destination address for the withdrawal * `Amount`: Token transfer amount (full precision) # Overview Cycle Network presents an omni state solution based on Verifiable State Aggregation (VSA). From the perspective of layered blockchain architecture, the framework of Cycle can be represented as the Security Layer, the Extended Layers, and Cycle Layer.

Cycle Network Framework in Aerial View

The figure above illustrates the three primary components within the Cycle Network framework: the Security Layer, the Extended Layers, and Cycle Layer. This section offers a comprehensive overview of these parties, and their roles in global state proof, respectively. The Security Layer is defined as a blockchain layer that provides the safety and liveness of transaction state. This layer can be either Bitcoin, Ethereum, or any other highly decentralized blockchain. The consensus mechanism of this layer guarantees state safety so that no two nodes that are functioning properly will produce conflicting results. Meanwhile, it provides some form of finality guarantees that the transactions will be finalized within a bounded time. The security Layer provides foundational security for Cycle Network as a high level decentralized blockchain through Rollup. The security Layer should be evaluated in a conservative assessment to ensure the safety and liveness of the transaction state, therefore protecting the stable operation and data integrity of the Cycle Network. Bitcoin and Ethereum, two blockchains reputed with their high degree of decentralization and secure consensus mechanisms, have been considered to serve as the Security Layer in the Cycle Network. The Bitcoin Network is temporarily excluded since it is difficult to achieve trustless two-way communication in the Bitcoin network, which is typically addressed through multi-signatures for off-chain verification. This contrasts with the trustless goal of Cycle Network. On the contrary, the Ethereum network is programmable and capable of supporting trustless off-chain verification, making it a more suitable choice for our Security Layer. Cycle Network deploys an Endpoint, and associates with Ethereum via the implementation of zero-knowledge proofs (ZKP). The Extended Layers refer to the source layers and destination layers where all transaction state and data state are located. This includes all Layer 1s, Layer 2s, and application blockchains. Cycle Network establishes an Endpoints on each Extended Layer for Extended Data Availability (EDA). The Omni Decentralised Indexer is deployed to achieve decentralized indexing of all Extended Layers to achieve the DA (Data Availability) for them. Essentially, Endpoints validate that received messages constitute a comprehensive set for each Extend Layer without any omissions. Synchronization takes place on Endpoints across all Extended Layers through Cycle Layer to ensure complete message retrieval. Cycle Layer serves as a Rollup for both the Security Layer and each Extended Layer. It is constructed with a range of essential components, with particular emphasis on Omni State Channel Indexer (OSCI), the decentralized Sequencer and ZK proof model. All transactions in the Cycle Network, including the cross chain transactions across Security Layer and Extended Layers, as well as internal transactions within Cycle Layer, collectively generate the aggregate Cycle state. The root state of Cycle is generated by a zk-EVM (Zero- Knowledge Ethereum Virtual Machine) Prover. Subsequently, this proof is submitted by the Prover for validation to multiple Layer 1 blockchains and Extended Layers. In the described process, Cycle Network functions similarly to a custodial system in a centralized exchange. However, users from different chains can trustlessly deposit their assets into Cycle Network and engage in seamless, self-custodied transactions and operations through Cycle Network. Users who employ Cycle Network for on-chain operations are unaware of the existence of multiple chains, making it easier for them to engage in more on-chain activities. \
# Technical Background In this section, we introduce several fundamental concepts that are crucial for understanding the architecture of Cycle Network. These concepts include Rollup, Zero-Knowledge Proofs (ZKP), Sequencer, and Fully Homomorphic Encryption (FHE). # ZK-Rollup Rollup is a widely adopted Layer 2 solution in blockchain scaling, known for batching multiple off-chain transactions into a single transaction which will be executed on the host chain. A key feature of Rollup is its ability to inherit the security guarantees of the host chain, maintaining equivalent security properties. There are two primary types of Rollups: Optimistic Rollups and Zero-Knowledge Rollups. They employ different transaction verification mechanisms, and therefore offer different trade-offs between latency, cost-effectiveness, and security. The Rollup technology is implemented by the Rollup Nodes and Endpoints. The Rollup Node plays a critical role in processing transactions, primarily responsible for sequencing and batching transactions. These transactions are then relayed to an Endpoint contract deployed on the Layer 1 blockchain. A key feature of this framework is the incorporation of Merkle proofs, which are essential during the withdrawal processes to ensure the integrity of transactions.

Rollup State Update

This figure illustrates a typical state transition in the Rollup verification procedure. When a transaction is sent to Layer 2, it updates the blockchain’s virtual machine (VM) state. Afterwards, the transaction details and the updated Layer 2 VM state are synchronized with Layer 1 via a smart contract call. Subsequently, Layer 2 generates a Zero-Knowledge (ZK) proof , enabling the Layer 1 contract to verify that the old VM state in Layer 2 correctly transitions to the new VM state after executing the transaction. This process demonstrates how transactions occurring on Layer 2 are validated on Layer 1, explaining why the security guarantees of Layer 2 are underpinned by the Layer 1. Another critical concept in ZK-Rollup is data availability, referring to the assurance that all necessary data for validating and verifying Layer 2 transactions is publicly accessible to all stakeholders. In the context of blockchain, data availability ensures that all nodes in the network can retrieve and validate the data required to maintain the integrity and security of the blockchain.
# Sequencer A sequencer is a specialized entity or component responsible for ordering and managing the sequence of transactions within a blockchain network. The primary role of a sequencer is to ensure that transactions are processed in a specific and consistent order, which is crucial to maintain the integrity and reliability of the underlying blockchain. Sequencers are particularly important in Layer 2 scaling solutions. In a Layer 2 network, the sequencer collects transactions, orders them, and then submits the ordered block to Layer 1 for the final settlement. This process helps alleviate the congestion on the main blockchain and allows for faster and cheaper transactions. The sequencer can be operated by a single entity or a decentralized group of participants, depending on the design of the blockchain protocol. In some implementations, the role of the sequencer may rotate among different nodes to enhance security and decentralization. By ensuring a consistent transaction order, sequencers play a critical role in preventing double-spending attacks and other forms of transaction manipulation. They also contribute to the overall efficiency and scalability of the blockchain network by enabling higher transaction throughput and reducing latency.
# Zero-knowledge hardware acceleration The hardware acceleration of Zero-knowledge Proofs (ZKPs) can enhance the efficiency of ZKPs by using specialized hardware to execute the cryptographic operations involved in ZKP. Dedicated hardware accelerators generate and verify ZKPs much faster than software methods, handling intensive computations and reducing time and resource usage. This makes zero-knowledge hardware acceleration valuable for blockchain and decentralized applications, where efficiency and scalability are critical. In the blockchain world, zero-knowledge hardware acceleration can act as a scaling technology, improving overall performance of rollups, and enabling efficient execution of complex smart contracts.
# Fully Homomorphic Encryption Fully Homomorphic Encryption (FHE) is an advanced encryption technique that enables computations to be performed on encrypted data without requiring decryption. This means that data can remain encrypted and secure while being processed, making FHE particularly valuable for data-centric applications. By allowing operations such as addition and multiplication to be executed on ciphertexts, FHE ensures that sensitive information is never exposed during computation. This unique capability protects privacy and enhances security, offering a robust solution for handling confidential data in untrusted environments. In the context of blockchain technology, FHE can significantly enhance the security and privacy of transactions and smart contracts. Blockchains are decentralized ledgers where all transactions are publicly recorded, which can lead to privacy concerns. By integrating FHE, blockchain platforms can perform computations on encrypted data, ensuring that the content of transactions remains confidential while still enabling validation and verification processes. This can help maintain the transparency and integrity of the blockchain while protecting user data. Additionally, FHE can be used to secure smart contracts, allowing them to execute complex logic on encrypted inputs without revealing sensitive information. This would enable more sophisticated and secure dApps to be developed, further expanding the potential uses of blockchain.
# Module Explanation In this section, we provide a comprehensive overview of the Cycle Network modules, highlighting key components such as the Omni State Channel Indexer and decentralized aggregate sequencer. We will also discuss our recent progress in ZK hardware acceleration and Fully Homomorphic Encryption (FHE). # Omni State Channel Indexer (OSCI) The Cycle Network is designed based on Verifiable State Aggregation (executed by Cycle Node) to connect various external chains in different states. However, different blockchains have their own definition of finality, presenting challenges in determining the validity of the state of each Cycle Node. An Omni State Channel Indexer (OSCI) is a decentralized multi-chain indexer that operates omni-chain indexing with decentralized governance to allow for a trustless validation and determination of the state of the Cycle ledger at any given moment. As illustrated in the Figure below, the Omni State Channel Indexer consists of three essential components: 1. OSCI serves as the indexer through which the recovery of the Cycle ledger can be determined and valid at any moment. 2. Cycle Node submits transactions by block packing, and OSCI. Similar to a Block structure, Cycle Nodes string together in a tandem order using Block ID, and therefore initiate the omni ledger. 3. Extended A, B, and C represent the networks that Cycle Node connects to.

Omni State Channel Indexer

The diagram depicts the operational mode of the blockchain and the state machine transition as the cycle network continuously increases its extended layers. The horizontal arrows from left to right indicate the ongoing block production by the cycle. Each block in the cycle is synchronized to the Ethereum mainnet and undergoes a verification process, ultimately being finalized on Ethereum. Multiple extended layers and the security layer (i.e., Ethereum, which is not fully represented due to the limitations of the flowchart) also have their rollup states synchronized to the cycle and uploaded to Ethereum for recording and verification along with the blocks. During the cycle's operation, new networks are continuously registered with the Ethereum chain indexer contract and added to the cycle extended layers. Cycle Network presents examples to demonstrate Cycle state flow in different Extended Layer scenarios, which is observed by Omni State Channel Indexer. At Block M state, Cycle connects with Extended A. The change of Cycle state flow is shown as follows:
At Block M+i state, Cycle connects with Extended A and Extended B. The change of Cycle state flow is shown as follows:
At Block M+i+j state, Cycle connects with Extended A, Extended B, and Extended C. The change of Cycle state flow is shown as follows:
The subsequent state in a Block state of Cycle is determined by all inputs. At any given time, as long as the transaction arrangement is determined, the final state is determined. The state of the entire Cycle is solely dependent on the unified inputs of all Indexers, and the state of the transaction is verified upon submission. To safeguard the integrity of the data, Project can oversee Cycle by maintaining their trusted full nodes. In practice, the finalized states of Cycle and all security/Extended layers can be acquired permissionless by any network service and the multi-chain state flow order can be accessed from OSCI under any circumstances. Since all necessary data to rebuild the entire Cycle is available, anyone can rebuild the comprehensive Cycle state flow. As long as the multi-chain states can be aggregated in blocks with a determined order which is guaranteed by the OSCI, any third-party service can verify every state finalized on Cycle, which is the prerequisite for achieving decentralized sequencer.
# Decentralized Aggregate Sequencer The Sequencer is a fundamental component of Cycle infrastructure which is responsible for managing transactions, generating blocks which are validated by mutual verification mechanism and aggregating transaction states. In Cycle, multiple decentralized sequencers operate simultaneously. By coordinating the cooperation of these sequencers via distributed consensus protocols, the decentralization of Cycle is ensured. Cycle implements decentralized sequencer intending to enhance Cycle’s security, fairness and network robustness. To this end, Cycle develops a mutual verification network for sequencers to ensure decentralization. OSCI ensures that the multi-chain aggregate state is verifiable, and any stakeholder can rebuild the comprehensive Cycle state flow. That means, every state in Cycle history can be rebuilt and verified by the sequencer hosted by anyone. Further in multiple sequencers, every sequencer can verify the state transition. Besides, every sequencer can verify the order of transactions in every block match their packing priority, which is critical to ensure any valid transaction can be included in Cycle based on its public priority, preventing a single sequencer from intentionally excluding certain transactions. While OSCI makes aggregate sequencer verification possible, a pre-Consensus network of sequencer can be developed and thus the decentralization of sequencer is feasible. ### Features of Decentralized Aggregate Sequencer: #### **Managing transactions:** A Sequencer can manage the entire lifecycle of transactions it received, which involves sequencing, executing and recording each transaction on the Cycle Network and the Security Layer. #### **Generating blocks:** Each Sequencer packs transactions according to their own order into a new block as it sees fit; By broadcasting the blocks that Sequencers packed up, a mutual verification will be made to determine the block’s legitimacy. #### **Aggregating transaction states:** Cycle transactions consist of two parts: transactions that occur within Cycle and the rollup transactions between Cycle and the related blockchains. All of these transactions are aggregated into ZK-proofs that are persistently stored on the Security Layer. #### **Sequencer decentralization:** The Sequencer of Cycle is completely decentralized so that any stakeholder can run a Sequencer to validate transactions relevant to Cycle. ### Technical architecture of Decentralized Aggregate Sequencer: A Decentralized Aggregated Sequencer consists of two key components: state manager and pre-consensus client. #### State manager: A state manager is the crucial part of the decentralized aggregate sequencer which features transactions management, block generation and state submission. 1. Transactions Management: Once a transaction is submitted to a sequencer, the state manager will store the transaction in the state database. Afterwards, the state manager executes suitable transactions, permanently changing the global states on Cycle. The state manager takes care of transactions until its state is verified on the Security Layer. 2. Block Generation: In Cycle, multiple transactions are aggregated into a block. After ordering all recorded pending transactions, the state manager decides which transactions are chosen to be packed in the block and then submits the block to the Security Layer. 3. State Submission: The state of a block has multiple status, the final status of a block is to be verified on the Security Layer. The state manager collaborates with the ZK prover, publishing the aggregate ZK proof of multiple transaction blocks to the Security Layer, and eventually finalizing the blocks included in the submitted proof. #### Pre-Consensus Client: The multiple sequencers forming Cycle’s decentralized network need to achieve pre-Consensus to decide which block will be submitted to the blockchain. In Cycle, a general-purpose consensus architecture such as Symbiotic or Eigenlayer can be used to implement the pre-Consensus mechanism. The decentralized sequencers and the consensus architecture are integrated via smart contracts deployed on the Security Layer. In conclusion, a Sequencer plays the role of a decentralized node in Cycle. It is responsible for transaction management, pre-consensus mechanism, and transaction states aggregation in a fully decentralized manner.

Decentralized Aggregate Sequencer

# Zero-knowledge hardware acceleration Cycle Network enhances the developer experience by using ZK Rollup to reduce the latency of Rollout. In this section, we discuss our recent effort on accelerating the ZK computation via hardware. If you want to know more details about zero-knowledge hardware acceleration, you can read our [whitepaper](https://www.cyclenetwork.io/whitepaper.pdf) to learn deeply. # Fully Homomorphic Encryption CycleNetwork employs Fully Homomorphic Encryption (FHE) to enable computations on encrypted data without needing decryption. This ensures that sensitive information remains secure throughout the cross-chain operations, offering complete privacy guarantees to users. If you want to know more details about fully homomrphic encryption, you can read our [whitepaper](https://www.cyclenetwork.io/whitepaper.pdf) to learn deeply. # Golden Goose

Golden Goose

## **What is Golden Goose?** \ Golden Goose is **The First Chain-Abstracted Gamified DEFAI**— incubated by Cycle Network. As a flagship use case of Cycle Network’s core innovation, Golden Goose brings the network’s verifiable state aggregation and bridgeless liquidity abstraction to life. It serves as the perfect application layer implementation of Cycle’s infrastructure, delivering real super hybrid yields to both Web2 and Web3 users through an intuitive and gamified experience. ## Cycle Network Empowering Golden Goose For users, complex multi-chain DeFi strategies are abstracted into simple, gamified interactions. Behind the scenes, Cycle Network handles cross-chain asset routing, liquidity aggregation, and strategy execution — delivering higher yields, lower risks, and a smooth one-click experience. ## Without Golden Goose: Complex and Fragmented Manual Operations Without Golden Goose’s one-click investment solution, users are required to manually perform a series of complex and fragmented on-chain operations across multiple networks in order to access yield opportunities: 1. Cross-Chain Asset Bridging: Users must bridge USDT or other assets from their source chain (e.g., BNB Smart Chain) to the target chain (e.g., Berachain) using third-party cross-chain bridges, exposing them to bridge risks and high fees. 2. Token Swapping: After bridging, users need to manually swap USDT into the target chain’s native token ($BERA) through DEX platforms. 3. Liquidity Provision: Users then provide liquidity into specific LP pools (e.g., BERA/USDT LP) to participate in DeFi protocols. 4. Staking LP Tokens: After providing liquidity, users must stake LP tokens into yield farming platforms (e.g., BEX) to start earning rewards. 5. Multiple Wallet Interactions: Each step requires interacting with multiple dApps, signing multiple transactions, and managing gas fees on different chains.
This fragmented experience creates high friction, increased user error risk, security concerns, and limits accessibility for non-technical or casual users. # Piggy Bank
## **What is Piggy Bank?** Piggy Bank is a pioneering all-chain asset management platform that leverages Cycle Network to deliver a revolutionary asset management experience. Designed to be a flagship product, Piggy Bank simplifies blockchain usage and serves as an accessible crypto asset management tool for everyone. It offers a bridgeless experience and harnesses Cycle's all-chain liquidity sharing solution to automate and optimize investment strategies across multiple chains. ## **Features of Piggy Bank** **For End Users** 1. **All-Chain Bridgeless UX** Piggy Bank eliminates the complexities of different chains for both Web3 and Web2 users. Managing, trading, investing, and minting assets is entirely bridgeless. Users can handle their crypto assets on Piggy Bank as effortlessly as they manage traditional financial products, without needing to understand the nuances of various chains, gas tokens, or third-party bridges. 2. **High-Yield Platform Aggregating All-Chain DeFi Protocols** Utilizing Cycle Network, Piggy Bank aggregates DeFi protocols from any network (L1, EVM, Non-EVM, BTC L2, etc.). AI-driven analysis evaluates security, yield, and stability, recommending personalized investment strategies. Users can select investment options with a single click, benefiting from superior returns due to aggregated and compounded yields across chains. 3. **Wide Range of Asset Classes** Piggy Bank supports a diverse array of assets by integrating with Cycle’s all-chain DeFi Hub. Users can manage physical assets like real estate and artwork, access various financial derivatives (options, futures, leveraged tokens), and engage in asset borrowing, lending, and liquidity mining across all chains. ## **For Developers** 1. **Shared Liquidity Pool** Piggy Bank's integration with Cycle Liquidity Aggregator consolidates fragmented liquidity resources into a shared pool. This approach enhances overall liquidity and capital efficiency, maximizing returns and simplifying liquidity management. 2. **Secure and Low-Cost** Cycle Network provides Piggy Bank with a unified interface and protocol, streamlining blockchain operations and integrations. The shared liquidity pool reduces the risk associated with single-chain funding and minimizes potential for fraud. **Example: Bridgeless Mint NFT** Piggy Bank’s highly anticipated Piggy Box event has seen over 246K accounts, with nearly 190K assets minted in a bridgeless manner. Users from any chain can mint assets with a single click without leaving their native chain. Transactions, gas fees, and signatures are handled seamlessly on the user’s preferred chain (such as IoTeX, BEVM (BTC L2), Arbitrum, BASE, BeraChain), while receiving assets on the project’s issuing chain.\ Quickly enter [Piggy Bank ](https://www.piggy-bank.finance/piggy-box)to experience the revolutionary Cycle Bridgeless Mint Asset and mint your first Genesis Piggy Box. # Bridgeless All Chain Trading For on-chain trading, Cycle Network enables native token issuance, both EVM and Non-EVM tokens, on any target chain. dApps can rapidly deploy on all chains, build- ing unified liquidity and enriching DeFi’s trading pairs, security, and depth. Additionally, Cycle Network offers all chain data integration that assists on-chain dashboard and trading bot data observation and strategy deployment, ultimately maximizing the profit on DeFi. Moreover, meme tokens, tokens, and NFTs, including new concepts, such as Ordinals on BTC, and Meme tokens on Solana, with community consensus, can quickly go viral through fast deployment and marketing across chains. # Bridgeless All Chain AI Application The idea of Web3 and AI combination is one of the inevitable trends in the industry. Cycle Network can help AI to perform machine learning and data analysis by providing all chain data and information. Cycle Network can also optimize predictive models in fields of DeFi, NFT, and GameFi. Meanwhile, with the help of Cycle Network, dApps can upgrade their creativity and innovation in multiple tracks such as Algorithmic Trading, Security Enhancements, Risk Modeling and Prediction, AI Chatbots and NPC Design, and Dynamic NFTs. # CYCLE-CORE-SDK ## # TapUp ## **What is TapUp?** TapUp is an all-chain Meme LaunchPad that combines the power of Telegram with the seamless integration of Cycle Network. Designed to facilitate the creation and launch of meme coins across all chains, TapUp allows users to mint meme coins without the need for traditional bridges. By bridging Web2 and Web3, TapUp extends its reach to Telegram's vast user base of 900 million active users, making Web3 accessible to a broader audience. Get damn rich💰,Tap for airdrop!🪂[https://t.me/TapUp\_Bot](https://t.co/Sm60x4S774)
### **TapUp's Core Advantages:** 1. **Integration with Telegram:** Extensive Web2 User Base: Telegram, a leading instant messaging app with over 900 million active users, provides a massive user base for TapUp. Leveraging Telegram's popularity, TapUp can attract a large number of users quickly and facilitate viral growth through its Tap to Earn feature. This opens up significant user traffic and value creation opportunities for projects and the blockchain ecosystem. 2. **Cycle Network Integration:** All-Chain Web3 User Source: Cycle Network's advanced chain abstraction technology enables seamless and bridgeless connections between users across any blockchain (L1, EVM, Non-EVM, BTC L2, etc.). TapUp's integration with Cycle Network ensures that users from any chain can participate in meme coin minting and other operations without incurring the complexities or costs associated with traditional cross-chain transactions. 3. **Ecosystem Cooperation:** Powerful Collaboration Platform: TapUp offers a robust platform for collaboration with other blockchain and Web2 game projects. By partnering with TapUp, project owners can enhance their user exposure, engage in joint marketing initiatives, and drive the development and adoption of blockchain technology. ## **Bridgeless User Experience** 1. **All-Chain Meme Coin Launch:** TapUp removes the limitations of traditional chain-to-chain interactions. Projects can launch meme coins from any blockchain (e.g., TON, Polygon, Solana, Base) and complete the entire process within TapUp without needing to leave their source chain. 2. **Universal Minting Experience:** Telegram users, Web3 users from any chain, and even new Web2 users can participate in meme coin minting without facing liquidity, asset, or chain split issues. Users simply pay for tokens on their native chain and mint meme coins directly within TapUp, bypassing the need for bridging or asset swapping. TapUp has rapidly gained popularity, becoming one of the most popular MiniApps on Telegram Apps Center. User growth has been rapid within just one month of its launch, with the user base reaching 430K, many of whom have been highly engaged, with some spending over 300 hours online. TapUp exemplifies how bridging Web2 and Web3 can create powerful, user-friendly applications that drive adoption and growth in the blockchain ecosystem. # Token $CYC Economic Cycle Network, as the **first all-chain settlement layer**, designs its economic model around **CYC token’s multi-functional applications, liquidity incentives, staking security mechanisms, and market expansion strategies** to ensure proper token circulation, long-term value growth, and sustainable ecosystem development. 1. ### **Token Economics** #### **1.1 Token Supply** * **Total supply: 1 Billion $CYC. No additional tokens will ever be minted.** #### **1.2 Token Distribution**
| Distribution | Allocation | Release mechanism | | --------------------------------------------------------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Team and Advisor** | 20% | 12-month cliff after TGE and vesting in 48 months linearly | |

Investors

| 15% | 12-month cliff after TGE and vesting in 24-36 months linearly | |

Treasury

| 10% | Cliff 6 months and Unlock after next 48 months, release determined by governance | |

Market Expansion & Platform Staking

| 10% | Used for project TGE and subsequent platform partnerships and liquidity expansion | | **Business & Ecosystem Incentive** | 20% | Used to incentivize applications on the Cycle Network, released based on contribution to network usage. After the voting system is established, distribution will be decided by community votes. | |

Community

| 15% | Incentives for community users who use Cycle and contribute revenue to the Cycle network are released every half year and fully unlocked after three years. | | **Staking & Share Security Rewards** | 10% | Incentives for network security after TGE will be released linearly over 60 months. | #### **1.3 Token Utility** 1. **SDK Usage Fees**: * Developers must pay **CYC** to call Rollin/Rollout SDK. 2. **Mainnet Gas Fees**: * Deploying dApps on Cycle requires paying **CYC** for gas fees. 3. **Staking Mechanism**: * Users can stake CYC via Symbiotic for staking, enhancing Cycle’s security. * New networks or appchains wishing to join **Cycle’s unified liquidity network** must also stake CYC tokens. 4. **Liquidity Mining**: * **ETH, USDT, and USDC mainstream assets require liquidity**, incentivized through **all-chain settlement** LP staking rewards. #### **1.4 Market Strategy** * **Growth Strategy**: Assisting RWA growth by helping more Web2 enterprises complete full cross-chain asset issuance, coordinating on-chain and real-world business revenue, and enabling more Web2/Web3 users to safely and seamlessly own and trade diverse assets across any chain, including but not limited to native on-chain assets, RWA assets, and various stablecoins. * **CEX/DEX Listing**: Cycle plans for TGE in 2025, targeting major CEX listings. Initial liquidity provisioning will be conducted through Uniswap, PancakeSwap. Currently cooperating to complete data audits and actively integrating assets into major mainstream ETFs. * **Liquidity Mining (LP Staking)**: Since ETH, USDT, and USDC mainstream tokens still require liquidity, Cycle incentivizes LP mining to maintain efficient capital flow across different ecosystems. * **Developer Growth**: Cycle provides a developer grant program, organizes developer education and advocacy, and fosters widespread knowledge of Cycle’s technology. The goal is to help developers directly build **application-centric** products, creating groundbreaking Web3 applications and popularizing Web3 technology adoption. * **B2B Ecosystem Expansion**: At this stage, Cycle is focused on building **Showcase Products** to demonstrate the capabilities of chain abstraction. Key products include **Golden Goose (Chain Abstraction DEFAI)** and Piggy Bank (chain abstraction NFT Launchpad), serving as client examples and educational tools. After TGE, the strategy will shift toward integrating with well-known applications, assisting them in implementing chain abstraction. 2. ### **Ecosystem Circulation** * **B2C Business Model**: Developers (B2B) must purchase CYC for SDK usage & gas fees, while end users (B2C) can pay via native gas fees without holding CYC, lowering Web2 adoption barriers. * **Tokenized Asset Liquidity**: Projects can issue fully full-chain tokens without requiring additional liquidity, but ETH, USDT, and USDC **mainstream assets** still require dedicated liquidity providers. 3. ### **Long-Term Token Sustainability** * **Staking APR Adjustments**: Initially, staking APR will be high to attract early stakers & LP providers. Over time, staking rewards will gradually decrease as the ecosystem matures to prevent inflation. * **Buyback & Burn Mechanism**: Currently, no buyback or burn mechanism is in place, but governance may introduce it in the future. * **Governance Mechanism**: The short-term governance structure relies on a governance committee & multi-signature decision-making, with long-term plans to transition to a DAO model. 4. ### **Keep Building and Roadmap (1-3 Years)** **Powering full-chain RWA settlement and bridgeless payments for the real world.** **Phase 1: Foundation and Ecosystem Expansion (2025)** * Token Generation Event (TGE) and CEX listings to attract early investors and liquidity providers * Expansion to additional L1 and L2 ecosystems, including Solana, Cosmos, and the broader Move ecosystem * Promotion of Cycle SDK to onboard dApp developers and grow B2B integration * Cycle mainnet staking support for $CYC to increase network participation and security * Early demonstration of Cycle’s **Settlement-first architecture**, decoupling messaging and settlement for better asset security and composability **Phase 2: Infrastructure Upgrade and RWA Enablement (Q2 2025 – Q2 2026)** * Mainnet Phase 2 and SDK 2.0 release, improving scalability, developer experience, and abstraction APIs * Onboarding multichain DEXs, stablecoins, payment systems, and RWA issuers * Enable Web2 enterprises to verify, issue, and distribute assets across chains, with on-chain revenue mechanisms * Launch of Multichain Stablecoin Settlement System, providing a **full-chain, settlement-native backend** for issuers across both EVM and non-EVM chains * Rollout of Cycle’s **Bridgeless Payment Layer**, enabling direct, wallet-to-wallet cross-chain payments without third-party bridges or wrapped assets * Targeted deployment in high-growth regions such as LATAM and Southeast Asia, using CYC as the universal gas and settlement medium **Phase 3: Decentralization and Chain Abstraction at Scale (2026 and beyond)** * Build global chain abstraction infrastructure integrating over 100 blockchains, with native routing and settlement * Explore native stablecoin issuance to serve on-chain financial activity * Introduce DAO-based governance for protocol upgrades and resource allocation * Continuous tokenomics optimization to sustain long-term growth and participation * Position Cycle as the go-to settlement backbone for RWA projects seeking secure, scalable, **bridgeless** full-chain distribution
# $CYC Tokenomics Cycle Network, as the **first all-chain settlement layer**, designs its economic model around **CYC token’s multi-functional applications, liquidity incentives, staking security mechanisms, and market expansion strategies** to ensure proper token circulation, long-term value growth, and sustainable ecosystem development. 1. ### **Token Economics** #### **1.1 Token Supply** * **Total supply: 1 Billion $CYC. No additional tokens will ever be minted.** #### **1.2 Token Distribution**
| Distribution | Allocation | Release mechanism | | --------------------------------------------------------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Team and Advisor** | 20% | 12-month cliff after TGE and vesting in 48 months linearly | |

Investors

| 15% | 12-month cliff after TGE and vesting in 24-36 months linearly | |

Treasury

| 10% | Cliff 6 months and Unlock after next 48 months, release determined by governance | |

Market Expansion & Platform Staking

| 10% | Used for project TGE and subsequent platform partnerships and liquidity expansion | | **Business & Ecosystem Incentive** | 20% | Used to incentivize applications on the Cycle Network, released based on contribution to network usage. After the voting system is established, distribution will be decided by community votes. | |

Community

| 15% | Incentives for community users who use Cycle and contribute revenue to the Cycle network are released every half year and fully unlocked after three years. | | **Staking & Share Security Rewards** | 10% | Incentives for network security after TGE will be released linearly over 60 months. | #### **1.3 Token Utility** 1. **SDK Usage Fees**: * Developers must pay **CYC** to call Rollin/Rollout SDK. 2. **Mainnet Gas Fees**: * Deploying dApps on Cycle requires paying **CYC** for gas fees. 3. **Staking Mechanism**: * Users can stake CYC via Symbiotic for staking, enhancing Cycle’s security. * New networks or appchains wishing to join **Cycle’s unified liquidity network** must also stake CYC tokens. 4. **Liquidity Mining**: * **ETH, USDT, and USDC mainstream assets require liquidity**, incentivized through **all-chain settlement** LP staking rewards. #### **1.4 Market Strategy** * **Growth Strategy**: Assisting RWA growth by helping more Web2 enterprises complete full cross-chain asset issuance, coordinating on-chain and real-world business revenue, and enabling more Web2/Web3 users to safely and seamlessly own and trade diverse assets across any chain, including but not limited to native on-chain assets, RWA assets, and various stablecoins. * **CEX/DEX Listing**: Cycle plans for TGE in 2025, targeting major CEX listings. Initial liquidity provisioning will be conducted through Uniswap, PancakeSwap. Currently cooperating to complete data audits and actively integrating assets into major mainstream ETFs. * **Liquidity Mining (LP Staking)**: Since ETH, USDT, and USDC mainstream tokens still require liquidity, Cycle incentivizes LP mining to maintain efficient capital flow across different ecosystems. * **Developer Growth**: Cycle provides a developer grant program, organizes developer education and advocacy, and fosters widespread knowledge of Cycle’s technology. The goal is to help developers directly build **application-centric** products, creating groundbreaking Web3 applications and popularizing Web3 technology adoption. * **B2B Ecosystem Expansion**: At this stage, Cycle is focused on building **Showcase Products** to demonstrate the capabilities of chain abstraction. Key products include **Golden Goose (Chain Abstraction DEFAI)** and Piggy Bank (chain abstraction NFT Launchpad), serving as client examples and educational tools. After TGE, the strategy will shift toward integrating with well-known applications, assisting them in implementing chain abstraction. 2. ### **Ecosystem Circulation** * **B2C Business Model**: Developers (B2B) must purchase CYC for SDK usage & gas fees, while end users (B2C) can pay via native gas fees without holding CYC, lowering Web2 adoption barriers. * **Tokenized Asset Liquidity**: Projects can issue fully full-chain tokens without requiring additional liquidity, but ETH, USDT, and USDC **mainstream assets** still require dedicated liquidity providers. 3. ### **Long-Term Token Sustainability** * **Staking APR Adjustments**: Initially, staking APR will be high to attract early stakers & LP providers. Over time, staking rewards will gradually decrease as the ecosystem matures to prevent inflation. * **Buyback & Burn Mechanism**: Currently, no buyback or burn mechanism is in place, but governance may introduce it in the future. * **Governance Mechanism**: The short-term governance structure relies on a governance committee & multi-signature decision-making, with long-term plans to transition to a DAO model. 4. ### **Keep Building and Roadmap (1-3 Years)** **Powering full-chain RWA settlement and bridgeless payments for the real world.** **Phase 1: Foundation and Ecosystem Expansion (2025)** * Token Generation Event (TGE) and CEX listings to attract early investors and liquidity providers * Expansion to additional L1 and L2 ecosystems, including Solana, Cosmos, and the broader Move ecosystem * Promotion of Cycle SDK to onboard dApp developers and grow B2B integration * Cycle mainnet staking support for $CYC to increase network participation and security * Early demonstration of Cycle’s **Settlement-first architecture**, decoupling messaging and settlement for better asset security and composability **Phase 2: Infrastructure Upgrade and RWA Enablement (Q2 2025 – Q2 2026)** * Mainnet Phase 2 and SDK 2.0 release, improving scalability, developer experience, and abstraction APIs * Onboarding multichain DEXs, stablecoins, payment systems, and RWA issuers * Enable Web2 enterprises to verify, issue, and distribute assets across chains, with on-chain revenue mechanisms * Launch of Multichain Stablecoin Settlement System, providing a **full-chain, settlement-native backend** for issuers across both EVM and non-EVM chains * Rollout of Cycle’s **Bridgeless Payment Layer**, enabling direct, wallet-to-wallet cross-chain payments without third-party bridges or wrapped assets * Targeted deployment in high-growth regions such as LATAM and Southeast Asia, using CYC as the universal gas and settlement medium **Phase 3: Decentralization and Chain Abstraction at Scale (2026 and beyond)** * Build global chain abstraction infrastructure integrating over 100 blockchains, with native routing and settlement * Explore native stablecoin issuance to serve on-chain financial activity * Introduce DAO-based governance for protocol upgrades and resource allocation * Continuous tokenomics optimization to sustain long-term growth and participation * Position Cycle as the go-to settlement backbone for RWA projects seeking secure, scalable, **bridgeless** full-chain distribution
# Tokenomics Cycle Network, as the **first all-chain settlement layer**, designs its economic model around $**CYC token’s multi-functional applications, liquidity incentives, staking security mechanisms, and market expansion strategies** to ensure proper token circulation, long-term value growth, and sustainable ecosystem development. ## **Token Supply** * **Total supply: 1 Billion $CYC. No additional tokens will ever be minted.** ## **Token Distribution**
| Distribution | Allocation | Release mechanism | | --------------------------------------------------------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Team and Advisor** | 20% | 12-month cliff after TGE and vesting in 48 months linearly | |

Investors

| 15% | 12-month cliff after TGE and vesting in 24-36 months linearly | |

Treasury

| 10% | Cliff 6 months and Unlock after next 48 months, release determined by governance | |

Market Expansion & Platform Staking

| 10% | Used for project TGE and subsequent platform partnerships and liquidity expansion | | **Business & Ecosystem Incentive** | 20% | Used to incentivize applications on the Cycle Network, released based on contribution to network usage. After the voting system is established, distribution will be decided by community votes. | |

Community

| 15% | Incentives for community users who use Cycle and contribute revenue to the Cycle network are released every half year and fully unlocked after three years. | | **Staking & Share Security Rewards** | 10% | Incentives for network security after TGE will be released linearly over 60 months. | ## **Token Utility** 1. **SDK Usage Fees**: * Developers must pay $**CYC** to call Rollin/Rollout SDK. 2. **Mainnet Gas Fees**: * Deploying dApps on Cycle requires paying $**CYC** for gas fees. 3. **Staking Mechanism**: * Users can stake $CYC via Symbiotic for staking, enhancing Cycle’s security. * New networks or appchains wishing to join **Cycle’s unified liquidity network** must also stake $CYC tokens. 4. **Liquidity Mining**: * **ETH, USDT, and USDC mainstream assets require liquidity**, incentivized through **all-chain settlement** LP staking rewards.
# Market Strategy * **Growth Strategy**: Assisting RWA growth by helping more Web2 enterprises complete full cross-chain asset issuance, coordinating on-chain and real-world business revenue, and enabling more Web2/Web3 users to safely and seamlessly own and trade diverse assets across any chain, including but not limited to native on-chain assets, RWA assets, and various stablecoins. * **CEX/DEX Listing**: Cycle plans for TGE in 2025, targeting major CEX listings. Initial liquidity provisioning will be conducted through Uniswap, PancakeSwap. Currently cooperating to complete data audits and actively integrating assets into major mainstream ETFs. * **Liquidity Mining (LP Staking)**: Since ETH, USDT, and USDC mainstream tokens still require liquidity, Cycle incentivizes LP mining to maintain efficient capital flow across different ecosystems. * **Developer Growth**: Cycle provides a developer grant program, organizes developer education and advocacy, and fosters widespread knowledge of Cycle’s technology. The goal is to help developers directly build **application-centric** products, creating groundbreaking Web3 applications and popularizing Web3 technology adoption. * **B2B Ecosystem Expansion**: At this stage, Cycle is focused on building **Showcase Products** to demonstrate the capabilities of chain abstraction. Key products include **Golden Goose (Chain Abstraction DEFAI)** and Piggy Bank (chain abstraction NFT Launchpad), serving as client examples and educational tools. After TGE, the strategy will shift toward integrating with well-known applications, assisting them in implementing chain abstraction. # Stability and Sustainability ## **Ecosystem Circulation** * **B2C Business Model**: Developers (B2B) must purchase CYC for SDK usage & gas fees, while end users (B2C) can pay via native gas fees without holding CYC, lowering Web2 adoption barriers. * **Tokenized Asset Liquidity**: Projects can issue fully full-chain tokens without requiring additional liquidity, but ETH, USDT, and USDC **mainstream assets** still require dedicated liquidity providers. ## **Long-Term Token Sustainability** * **Staking APR Adjustments**: Initially, staking APR will be high to attract early stakers & LP providers. Over time, staking rewards will gradually decrease as the ecosystem matures to prevent inflation. * **Buyback & Burn Mechanism**: Currently, no buyback or burn mechanism is in place, but governance may introduce it in the future. * **Governance Mechanism**: The short-term governance structure relies on a governance committee & multi-signature decision-making, with long-term plans to transition to a DAO model. # Keep Building and Roadmap (1-3 Years) **Powering full-chain RWA settlement and bridgeless payments for the real world.** ### **Phase 1: Foundation and Ecosystem Expansion (2025)** * Token Generation Event (TGE) and CEX listings to attract early investors and liquidity providers * Expansion to additional L1 and L2 ecosystems, including Solana, Cosmos, and the broader Move ecosystem * Promotion of Cycle SDK to onboard dApp developers and grow B2B integration * Cycle mainnet staking support for $CYC to increase network participation and security * Early demonstration of Cycle’s **Settlement-first architecture**, decoupling messaging and settlement for better asset security and composability ### **Phase 2: Infrastructure Upgrade and RWA Enablement (Q2 2025 – Q2 2026)** * Mainnet Phase 2 and SDK 2.0 release, improving scalability, developer experience, and abstraction APIs * Onboarding multichain DEXs, stablecoins, payment systems, and RWA issuers * Enable Web2 enterprises to verify, issue, and distribute assets across chains, with on-chain revenue mechanisms * Launch of Multichain Stablecoin Settlement System, providing a **full-chain, settlement-native backend** for issuers across both EVM and non-EVM chains * Rollout of Cycle’s **Bridgeless Payment Layer**, enabling direct, wallet-to-wallet cross-chain payments without third-party bridges or wrapped assets * Targeted deployment in high-growth regions such as LATAM and Southeast Asia, using CYC as the universal gas and settlement medium ### **Phase 3: Decentralization and Chain Abstraction at Scale (2026 and beyond)** * Build global chain abstraction infrastructure integrating over 100 blockchains, with native routing and settlement * Explore native stablecoin issuance to serve on-chain financial activity * Introduce DAO-based governance for protocol upgrades and resource allocation * Continuous tokenomics optimization to sustain long-term growth and participation * Position Cycle as the go-to settlement backbone for RWA projects seeking secure, scalable, **bridgeless** full-chain distribution # Token $CYC Economic Cycle Network, as the **first all-chain settlement layer**, designs its economic model around **CYC token’s multi-functional applications, liquidity incentives, staking security mechanisms, and market expansion strategies** to ensure proper token circulation, long-term value growth, and sustainable ecosystem development. 1. ### **Token Economics** #### **1.1 Token Supply** * **Total supply: 1 Billion $CYC. No additional tokens will ever be minted.** #### **1.2 Token Distribution**
| Distribution | Allocation | Release mechanism | | --------------------------------------------------------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Team and Advisor** | 20% | 12-month cliff after TGE and vesting in 48 months linearly | |

Investors

| 15% | 12-month cliff after TGE and vesting in 24-36 months linearly | |

Treasury

| 10% | Cliff 6 months and Unlock after next 48 months, release determined by governance | |

Market Expansion & Platform Staking

| 10% | Used for project TGE and subsequent platform partnerships and liquidity expansion | | **Business & Ecosystem Incentive** | 20% | Used to incentivize applications on the Cycle Network, released based on contribution to network usage. After the voting system is established, distribution will be decided by community votes. | |

Community

| 15% | Incentives for community users who use Cycle and contribute revenue to the Cycle network are released every half year and fully unlocked after three years. | | **Staking & Share Security Rewards** | 10% | Incentives for network security after TGE will be released linearly over 60 months. | #### **1.3 Token Utility** 1. **SDK Usage Fees**: * Developers must pay **CYC** to call Rollin/Rollout SDK. 2. **Mainnet Gas Fees**: * Deploying dApps on Cycle requires paying **CYC** for gas fees. 3. **Staking Mechanism**: * Users can stake CYC via Symbiotic for staking, enhancing Cycle’s security. * New networks or appchains wishing to join **Cycle’s unified liquidity network** must also stake CYC tokens. 4. **Liquidity Mining**: * **ETH, USDT, and USDC mainstream assets require liquidity**, incentivized through **all-chain settlement** LP staking rewards. #### **1.4 Market Strategy** * **Growth Strategy**: Assisting RWA growth by helping more Web2 enterprises complete full cross-chain asset issuance, coordinating on-chain and real-world business revenue, and enabling more Web2/Web3 users to safely and seamlessly own and trade diverse assets across any chain, including but not limited to native on-chain assets, RWA assets, and various stablecoins. * **CEX/DEX Listing**: Cycle plans for TGE in 2025, targeting major CEX listings. Initial liquidity provisioning will be conducted through Uniswap, PancakeSwap. Currently cooperating to complete data audits and actively integrating assets into major mainstream ETFs. * **Liquidity Mining (LP Staking)**: Since ETH, USDT, and USDC mainstream tokens still require liquidity, Cycle incentivizes LP mining to maintain efficient capital flow across different ecosystems. * **Developer Growth**: Cycle provides a developer grant program, organizes developer education and advocacy, and fosters widespread knowledge of Cycle’s technology. The goal is to help developers directly build **application-centric** products, creating groundbreaking Web3 applications and popularizing Web3 technology adoption. * **B2B Ecosystem Expansion**: At this stage, Cycle is focused on building **Showcase Products** to demonstrate the capabilities of chain abstraction. Key products include **Golden Goose (Chain Abstraction DEFAI)** and Piggy Bank (chain abstraction NFT Launchpad), serving as client examples and educational tools. After TGE, the strategy will shift toward integrating with well-known applications, assisting them in implementing chain abstraction. 2. ### **Ecosystem Circulation** * **B2C Business Model**: Developers (B2B) must purchase CYC for SDK usage & gas fees, while end users (B2C) can pay via native gas fees without holding CYC, lowering Web2 adoption barriers. * **Tokenized Asset Liquidity**: Projects can issue fully full-chain tokens without requiring additional liquidity, but ETH, USDT, and USDC **mainstream assets** still require dedicated liquidity providers. 3. ### **Long-Term Token Sustainability** * **Staking APR Adjustments**: Initially, staking APR will be high to attract early stakers & LP providers. Over time, staking rewards will gradually decrease as the ecosystem matures to prevent inflation. * **Buyback & Burn Mechanism**: Currently, no buyback or burn mechanism is in place, but governance may introduce it in the future. * **Governance Mechanism**: The short-term governance structure relies on a governance committee & multi-signature decision-making, with long-term plans to transition to a DAO model. 4. ### **Keep Building and Roadmap (1-3 Years)** **Powering full-chain RWA settlement and bridgeless payments for the real world.** **Phase 1: Foundation and Ecosystem Expansion (2025)** * Token Generation Event (TGE) and CEX listings to attract early investors and liquidity providers * Expansion to additional L1 and L2 ecosystems, including Solana, Cosmos, and the broader Move ecosystem * Promotion of Cycle SDK to onboard dApp developers and grow B2B integration * Cycle mainnet staking support for $CYC to increase network participation and security * Early demonstration of Cycle’s **Settlement-first architecture**, decoupling messaging and settlement for better asset security and composability **Phase 2: Infrastructure Upgrade and RWA Enablement (Q2 2025 – Q2 2026)** * Mainnet Phase 2 and SDK 2.0 release, improving scalability, developer experience, and abstraction APIs * Onboarding multichain DEXs, stablecoins, payment systems, and RWA issuers * Enable Web2 enterprises to verify, issue, and distribute assets across chains, with on-chain revenue mechanisms * Launch of Multichain Stablecoin Settlement System, providing a **full-chain, settlement-native backend** for issuers across both EVM and non-EVM chains * Rollout of Cycle’s **Bridgeless Payment Layer**, enabling direct, wallet-to-wallet cross-chain payments without third-party bridges or wrapped assets * Targeted deployment in high-growth regions such as LATAM and Southeast Asia, using CYC as the universal gas and settlement medium **Phase 3: Decentralization and Chain Abstraction at Scale (2026 and beyond)** * Build global chain abstraction infrastructure integrating over 100 blockchains, with native routing and settlement * Explore native stablecoin issuance to serve on-chain financial activity * Introduce DAO-based governance for protocol upgrades and resource allocation * Continuous tokenomics optimization to sustain long-term growth and participation * Position Cycle as the go-to settlement backbone for RWA projects seeking secure, scalable, **bridgeless** full-chain distribution