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/engine/install/ubuntu/#install-using-the-repository

https://docs.docker.com/compose/install//

1. 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:

https://github.com/CycleNetwork-Labs/cycle-data-availability/tree/main/deploy

1. 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.

1. 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

1. Running a DAC Node

Execute the following command to start the DAC Node.

docker-compose -f docker-compose.yml up cdk-data-availability -d

1. 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 https://github.com/CycleNetwork-Labs/cycle-data-availability.git

1. 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

1. 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.

1. 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.

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: https://github.com/CycleNetwork-Labs/cycle-data-availability