# Quickstart

<figure><img src="/files/AbltKyrzFDjK9CF1BwTR" alt=""><figcaption></figcaption></figure>

The purpose of this document is to give a general overview of KuCoin Community Chain and to serve as a starting point for new users to the KCC ecosystem.&#x20;

| For Developers                                                                                                      | For Individuals                                                                                                                                                        |
| ------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [How about the KCC consensus](/overview/consensus-engine) - Introduction to the KCC consensus model                 | [What is KCC](/overview/introduction) - An overview of KCC                                                                                                             |
| [How to deploy smart contract on KCC](/developers/deploy-smart-contract) - A guide on smart contract deployment     | [Wallet setup](/individuals/wallet/tutorial-on-how-to-set-up-wallet) - A guide on how to setup wallet for using KCC                                                    |
| [How to deploy tokens](/developers/issue-erc20-token) - A guide on token deployment                                 | [Connect wallet to KCC](/individuals/network-configuration/tutorial-on-how-to-config-kcc-network-in-metamask) - A guide on how to configure KCC network in your wallet |
| [How to deploy NFTs](/developers/deploy-nfts) - A guide on NFTs deployment                                          | [Transfer assets to KCC](/individuals/bridge-assets) - A brief intro on token transfer                                                                                 |
| [How to run a full node](/developers/run-a-node/run-a-full-node) - Steps to run a full node                         | [Get KCS token](/individuals/kcs-token/get-kcs) - A guide of the several ways to get KCS token                                                                         |
| <p><a href="/pages/qxclXIaQKNMamGLNFkMU">How to run a validator node</a> - Steps to r</p><p>un a validator node</p> | [Find a dApp on KCC](/individuals/find-a-dapp) - Explore KCC ecosystem                                                                                                 |
| [How to find out the development tools](/developers/dev-toolkit) - A collection of development tools                | [Submit your dApp on KCC](/individuals/find-a-dapp) - Learn how to submit your dApp                                                                                    |
| [What is KCC Oracle](/developers/oracles/kcc-oracle) - Learn more about KCC Oracle                                  | [Stake KCS to earn rewards](/individuals/kcs-token/stake-kcs) - Tutorial on participating in node staking                                                              |
| [What is KCC roadmap](/future-developments/milestone) - Discover the future of KCC                                  | [How to join KCC communities](/contact-us/contact-us) - Get updates on things we are currently working on                                                              |


# Introduction

<figure><img src="/files/w2pDMtNq3Xt7GX6eR8kn" alt=""><figcaption></figcaption></figure>

Launched in June 16, 2021, KCC is a decentralized public chain with high performance built by the developer fans of KuCoin and KCS.&#x20;

Our purpose is to solve problems such as low performance and high cost of the public chain and provide community users with a faster, more convenient, and less-costly experience.


# Features

<figure><img src="/files/8aLn970caDe6doV4Qtf7" alt=""><figcaption></figcaption></figure>

KCC 1.0 is built on the Ethereum source code and is compatible with EVM smart contracts. It seeks to solve the dual problem of low performance and high cost on Ethereum. Currently, millions of blocks have been produced while the number of active addresses on the chain has exceeded hundreds of thousands.&#x20;

**EVM Compatible**

KCC is EVM compatible. Deploy and run your dApps on KCC with your favorite tooling for Ethereum.

**Fast Finality**

The average block time of KCC is 3 seconds. A typical transaction can be included in a block in less than 6 seconds. And this block is finalized if more than half of all validators add their blocks after it.

**Low Cost**

Gas fee is paid with KCS. Transfer your tokens around the world with a fraction of a cent.

**Safe and Secure**

Each block is validated by trusted validators with their identities and KCS as stakes.


# Our Goal

<figure><img src="/files/3TK6HEKrmbgSj7J46Shx" alt=""><figcaption></figcaption></figure>

KCC will be developed in three phases: KCC 1.0, KCC 2.0, and KCC 3.0.

We are still in KCC 1.0, but as the developer community expands and the community becomes more vibrant, we will gradually begin to research and develop KCC 2.0.

**With KCC 2.0, we aim to improve the user experience, boost performance, and encourage more developers to build on KCC:**

* **Accounts Abstraction:** KCC2.0 will support the ERC4337 wallet, making it much easier for Web2 users to access their wallets. It is possible for them to make payments in the same manner as they do with PayPal or Google Pay. There is no need to memorize private keys or mnemonics. Additionally, they can recover and freeze their wallets just like in a Web2 application. If there are not enough KCS to cover transaction fees, stablecoins in the wallet can be used to cover gas fees.
* **Performance Improvement:** KCC2.0 will improve the execution of EVM codes, storage of states, and synchronization of states, transactions, and blocks.
* **Gas Incentives**: KCC2.0 will share the gas income with dApp developers, just like YouTubers share the advertisement income from Youtube.

**KCC 3.0 aims to become more resilient and to build an ecosystem of multiple rollups:**

* **Settlement Layer And DA Layer For Rollups**: KCC 3.0 will become the global settlement layer and DA layer for all rollups that run on KCC. Moreover, zk-rollups running on KCC 3.0 will be synchronously composable, which means a smart contract on one zk-rollup can synchronously call the smart contract on some other zk-rollup.
* **Client Diversity:** KCC 3.0 will implement more node clients. The diversity of node clients will make KCC more resilient.


# Consensus Engine

<figure><img src="/files/ZdhyjmoWha6yMAnJxAY2" alt=""><figcaption></figcaption></figure>

## Abstract

We are dedicated to build a decentralized network that is **high-performing**, **low-cost**, and **low-consumption**. We must find a solution that achieves the above goals while allowing minimal changes to the core data structure to maintain compatibility with existing Ethernet clients. Upon investigating some popular PoA consensus protocols, we found that the consensus designs of Bor and Heco are similar to ours. Hence, we adapted some parts of [Bor](https://polygon.technology/blog/heimdall-and-bor) and Heco's designs to design a **Proof of Staked Authority(PoSA)** consensus protocol to achieve our goal.

## Infrastructure Components <a href="#infrastructure-components" id="infrastructure-components"></a>

1. **Validators**. Validators are responsible for creating and propagating blocks, verifying blocks, and ensuring the distributed ledger and distributed governance. They are rewarded with gas for each transaction in return.
2. **System Contract**
   * **Proposal Contract**. It provides the framework for proposal creation, voting, and KCC governance.
   * **Validators Contract.** It will select the top 29 validators with the highest number of votes and set them up as validators for the next epoch, responsible for staking and unstaking from general users and calculating and issuing block rewards to voters and validators.
   * **Reserve Pool Contract.** Its primary function is to provide incentives, including gas fees from transactions and eco-incentives provided by the Foundations.
   * **Slash Contract.** It is introduced to avoid the uncertainty of the validator's missing blocks due to various factors, which will bring uncertainty and performance problems to the KCC network. The Slash contract will record the missed block metrics of each validator. Once the metrics of a preset threshold are reached, the unclaimed rewards that the validator himself has received will be slashed and put back into the reserve pool. The slashed prizes will be shared with other validators who propagate the block.

## System Reward Distribution

The rewards in the KCC network are highly configurable. To better incentivize the healthy development of the KCC ecosystem, the Foundations provides incentive support to participants in the KCC network through subsidies. The transaction fees and the Foundations' eco-incentive are equally distributed to each vote (one KCS equals one vote). The rewards in the KCC network are highly configurable.

## Consensus Protocol

KCC is dedicated to building a decentralized network that is high-performing, low-cost, and low-consumption by using the Proof of Staked Authority (PoSA) consensus protocol. Those 29 validators who have received the most votes in the network will become active validators responsible for mining and validating the blocks.&#x20;

Eco-participants (validators and voters) will be rewarded with transaction fees for each block and eco-incentives provided by the Foundations. To ensure network security, KCC also introduced a penalty mechanism to deal with dishonest and unstable verifiers and possible attacks.

### How to Create a Block

#### &#x20;**Step 1: Prepare**

An active validator node prepares the block header of the subsequent block.

* Create authorization snapshots
* Upon reaching an epoch block (`block number%epoch == 0`), it needs to retrieve the top active validator from the System Contract and store the selected validator set message in the `extraData` field of the block header to facilitate the implementation of the light client.

#### **Step 2: Finalize And Assemble**

* If the validator for the current block is not a duty validator, and the expected validator has not mined any blocks recently. In that case, the rewards of the validator will be reduced by the system contract.
* Distribute block rewards. Update active validators and recalculate missed block metrics if in an epoch block.

#### **Step 3: Seal**

* Sign the header of the block and append the signature hash to extraData.
* An appropriate random time must wait before the off-duty validator can sign the block.

### **How to Verify / Relay a Block**

#### **Step 1: Verify Header**

Checks whether a block's header confirms the consensus rules when receiving the block.

* To prevent selfish validators from rushing to seal a block, verify the block time of the receiving block to be rejected if the time is earlier than the current time.
* Check the `metaData` and the `difficulty`.

#### **Step 2: Finalize**

There's no difference between the **Finalize** stage and the [**Finalize And Assemble** ](#step-2-finalize-and-assemble)stage, except that the witness node must verify the `extraData` information during the epoch block to complete the finalization process.

### Security And Finality

In a PoA-based consensus network, if `1/2*N+1` validators are honest, and the whole network will run safely and correctly. But in some cases, some malicious validators may gain benefits through some attacks, so we recommend that high-value or critical transactions wait for `2/3*N+1` blocks before confirming.&#x20;

In the KCC network, with 29 validators, and 3 seconds for block intervals, a transaction should wait for `(2/3*29+1)*3 = 61` seconds to be finalized. Considering the double-signing attack and instability of validators in the network, KCC introduces a slash contract to make it difficult or unprofitable for malicious attackers. With this enhancement, `1/2*N+1`or even fewer blocks are enough to get most transactions to be finalized.

PoSA consensus protocol requires out-of-round validators to wait a random amount before sealing blocks. Each out-of-round validator is allowed a specific amount of time to seal blocks, which prevents validators from rushing to seal blocks. To avoid this delay and gain more profit, validators may be able to run modified full-node implementations driven by profit. Other witness nodes will discard any block generated by an out-of-round validator with an earlier blocking time.


# Marketing Guide

<figure><img src="/files/hFaAISw852GsU6MekYHO" alt=""><figcaption></figcaption></figure>

Welcome to the KuCoin Community Chain (KCC). Here is a guide to help you know what marketing resources KCC can give you and how to supply and use them.&#x20;

If you are new and want to deploy a contract on KCC or have already deployed but want to have more impressions, you must read this post.

### **We have**&#x20;

### **KCC Official Website Resource**

* [Discover dApps](https://www.kcc.io/apps)
* [Gas Revenue Program](https://www.kcc.io/gas-revenue)
* [News](https://news.kcc.io/)

{% content-ref url="/pages/dlmImjNnvAlQGjTKPtoq" %}
[KCC Official Website Resource](/overview/marketing-guide/kcc-official-website-resource)
{% endcontent-ref %}

### **KCC Social Media Promotion**

* [Twitter](https://twitter.com/KCCOfficialTW)
* [Telegram](https://t.me/KCCOfficialEnglishCommunity)
* [Discord](https://bit.ly/kccdiscord)
* [Youtube](https://www.youtube.com/channel/UCZhWm40SuAApnLqqq3F9o1w)

{% content-ref url="/pages/0k1KVMkIiCBkaVjPpGMi" %}
[KCC Social Media Promotion](/overview/marketing-guide/kcc-social-media-promotion)
{% endcontent-ref %}

### **PR Marketing Support**

* Crypto Media&#x20;
* Web3 Influencers

### **Third-Party Marketing Support**

* Get Listed on Third-Party Platforms
* Resource Connection of KuCoin&#x20;

{% content-ref url="/pages/WeqtVp9tXll6LtIqBwlp" %}
[PR & Third-Party Marketing Support](/overview/marketing-guide/pr-and-third-party-marketing-support)
{% endcontent-ref %}


# Requirements

Here are the qualification for discover listing and other co-marketing initiatives with the KCC official accounts:

## dApp Listing Requirements

### **DeFi**

* MUST have an audit report that doesn’t exceed the medium vulnerabilities;
* MUST be live on the KCC mainnet;
* MUST submit an email address or a social media account with at least one reputable reference/investor for reference checking;
* MUST have all contracts verified on the [KCC Explorer](https://explorer.kcc.io/) and [KCC Scan](https://scan.kcc.io/).

*\*NOTE that a submission doesn't guarantee a listing on this portal.*

### NFT

* MUST have proof of development (Demo or Code);
* MUST be an original art, not derivative works;
* MUST have an active community (daily engagement on Twitter or Discord);
* MUST submit an email address or a social media account with at least one reputable reference/investor for reference checking;
* MUST have all contracts verified on KCC.

*\*NOTE that a submission doesn't guarantee a listing on this portal.*

### Wallet

* MUST submit an email address or a social media account with at least one reputable reference/investor for reference checking.

### Infrastructure

* MUST submit an email address or a social media account with at least one reputable reference/investor for reference checking.

### Oracle

* MUST submit an email address or a social media account with at least one reputable reference/investor for reference checking.

### GameFi & Metaverse

* MUST have a public roadmap;
* MUST have proof of development (Demo or Code);
* MUST have a community (daily engagement on Twitter or Discord);
* MUST submit an email address or a social media account with at least one reputable reference/investor for reference checking;
* MUST have all contracts verified on the [KCC Explorer](https://explorer.kcc.io/) and [KCC Scan](https://scan.kcc.io/);
* For mobile games, MUST be on Apple/Google app store (not IPA/APK).\
  Web3 & DAO
* MUST have an active community (daily engagement on Twitter or Discord);
* MUST submit an email address or a social media account with at least one reputable reference/investor for reference checking.

### Data & Analytics

* MUST submit an email address or a social media account with at least one reputable reference/investor for reference checking.

*Please keep in mind:*

*- A submission doesn't guarantee a listing on this portal.*

<br>

## Co-marketing Requirements:

Please note there are qualifications for projects that have not yet to be launched on KCC but want to make an appointment for co-marketing.

### DeFi

* MUST submit an email address or a social media account with at least one reputable reference/investor for reference checking;
* MUST have a proof of development (Demo or Code).

### NFT

* MUST have a proof of development (Demo or Code);
* MUST be an original art, not derivative works;
* MUST have an active community (daily engagement on Twitter or Discord)
* MUST submit an email address or a social media account with at least one reputable reference/investor for reference checking.

### Wallet

* MUST submit an email address or a social media account with at least one reputable reference/investor for reference checking.

### Infrastructure

* MUST submit an email address or a social media account with at least one reputable reference/investor for reference checking.

### Oracle

* MUST submit an email address or a social media account with at least one reputable reference/investor for reference checking.

### GameFi & Metaverse

* MUST have a public roadmap;
* MUST have proof of development (Demo or Code);
* MUST have a community (daily engagement on Twitter or Discord);
* MUST submit an email address or a social media account with at least one reputable reference/investor for reference checking.

### Web3 & DAO

* MUST have an active community (daily engagement on Twitter or Discord);
* MUST submit an email address or a social media account with at least one reputable reference/investor for reference checking.

### Data & Analytics

* MUST submit an email address or a social media account with at least one reputable reference/investor for reference checking.


# KCC Official Website Resource

### Listing on the KCC Discover dApps

<figure><img src="https://lh3.googleusercontent.com/ZgEjE_0ZUNyr_wlIRKs9Y_ERowl558_ZP7Y9BqjkFJljAExTGb8w71Ow56EjdWJkC4bYRdWKwBufwrmlkDsluPsnDh_heTPRhIDRHNGHBMwzJuNbgP19Y9MzsI2eOSO3pqcWivobzJAid-yG3OHQ774" alt=""><figcaption></figcaption></figure>

Discover dApps is an overview of the dApps in the KCC ecosystem.

* Make sure you fulfill the qualifications of the section above;
* Fill in the project information on [submit page](https://www.kcc.io/apps/submit) to add their dApp on KCC;
* The KCC Team will review the submission in 5 working days.

*\*The KCC team has the right to regularly review the projects displayed on this page. If potential risks are found in the projects and cannot be resolved after communication, the KCC team has the right to temporarily remove the risky projects from the display.*

### Register for the KCC Gas Revenue Program

<figure><img src="https://lh3.googleusercontent.com/oz1e2pjjxYgZAYWkw_9BTtZiW-3Jqd64ufzpT_LZT7qFcOnMKCbG3ilKc5NmfIqCEwvX7TYR_H1TPPL7qyRdQyNjXcCf3QlHnS3L8BaAaadd23Od315zl-t1xiGzjM8PNCJ6CZKqeULU7ChukSVutDw" alt=""><figcaption></figcaption></figure>

Gas Revenue Program is the implementation of the KCC Ecosystem Incentive Program, which **supports gas refunds** to the KCC contract deployers (Gas here refers to the gas fee spent by the user when using the protocol).

* **All projects listed on the KCC Discover page** can register for the KCC Gas Revenue Program;
* [Register here](https://kcc.io/gas-revenue) and make sure to fill out all fields;
* The KCC team will contact you within 5 working days and complete the project review within 7 working days.

[View more details of the KCC Gas Revenue Program\ <br>](https://news.kcc.io/kcc-gas-revenue-program/)

### Announce on the KCC News

<figure><img src="https://lh3.googleusercontent.com/z51X1Yg5f2g-JbKTbsehLwAg-TyQfg7TZq58YDPGfDyx1jk-ac9LyvJNj63z7bLzM7450Ugf-EKCNOq3Yq1r6rDaPAH78sd2TOAnxV-EKeORpH2B_16GCLtK__UzSRTi-AaanEhYnlZex_ygCv_-Eps" alt=""><figcaption></figcaption></figure>

The KCC News is the official information integration platform of KCC.

* **All projects listed on the KCC Discover page** can apply to publish content on the KCC News;
* Released content includes project introductions, technical updates, product updates, brand news, large-scale events, etc.;
* If the project wants to publish content on the KCC News, it needs to **submit content materials to the KCC BD at least 3 working days** in advance (you can contact directly or send an email to <kcc-business@kcc.network>);&#x20;
* Materials include title, text content, pictures, project introduction, and contact information. [Click to see the project introduction demo](https://docs.google.com/document/d/1nZ3_i3oeYZxVh0UN7OY37b1-mermlJvNmLe2Hik4uHU/edit?usp=sharing)

*\*To protect users' rights, the content published on KCC News must be reviewed by the KCC team and published by GoDAO members.*

<br>


# KCC Social Media Promotion

### Twitter Announcement Content Requires:

1. MUST refrain from using words such as collaboration, partnership, joining hands, etc. Instead, we encourage use of words like **launching, coming on, live on, bringing, and integrating;**
2. MUST refrain from shilling or encouraging buying/staking a token of any sorts;
3. In the launch announcement, if one would like to include promotional campaigns such as **giveaway, airdrop, or other monetary incentives**, one MUST confirm the messaging with your BD contact at KCC.
4. If this is a multi-chain deployment, one MUST ensure that this is a KCC-specific announcement;
5. Include KCC elements in the announcement:
   * The only official KCC Twitter account is: @KCCOfficialTW
   * The related KCC accounts are: @0xleandre, @eth\_cedric
   * Use KCC logos from [here](https://docs.kcc.io/disclosure/media-kit).

### Requesting a Retweet/Quote Tweet from the KCC Official Twitter Account

<figure><img src="https://lh5.googleusercontent.com/_UrD3SPkx_GYserVQ4SjCe-1eQzNHhGNIwZPKyDTOjvA3z9ZcMiK7l6z_GiP5hxvNOIrrrd-P4Xa8HAj5jwHS2Zrn0sa-jIb45nWNOM8bd7NdlHtEC_C3LSJHRuDMsSjBuk8LYLLmm41cG7XLY_dzoY" alt=""><figcaption></figcaption></figure>

1. MUST use the following format for tweet requests to your point of contact at KCC. A retweet/quote tweet will typically be arranged within 3 business days.&#x20;
   * Link to the product on KCC dApp page:\_\_\_\_\_
   * Link to the launch tweet from your Twitter account:\_\_\_\_\_\_\_
2. As a company policy, the KCC official Twitter account will **only co-market with projects that have been listed on the KCC Discover.**

### Joint Campaigns

<figure><img src="https://lh3.googleusercontent.com/7AX6-k7H8awzCFRyTHmklWuhyPXb1FiSI5lM9qbAbOjeudHQukYoKBwnA3swZtFxx98s1mdkEvTkqElc-MthoLtyIBtLVJu4Cyul5zFS_6b_AOH5HKYSu6xX6fdkfxcv48-U0Teo8pHCQaFU-SIrQC0" alt=""><figcaption></figcaption></figure>

1. If you are requesting for retweet/quote tweet on top of the launch announcement (eg. marketing campaigns, product updates etc.), please submit your request in the following format with your point of contact at KCC:
   * Link to the product on KCC dApp page:\_\_\_\_\_
   * Link to the tweet from your Twitter account:\_\_\_\_\_\_\_
2. If you want to host a marketing campaign together with KCC officials, one MUST prepare their proposal in the following format and submit it to your point of contact at KCC:

   * Background (Why):\_\_\_\_\_\_\_\_\_
   * Purpose of the campaign:\_\_\_\_\_\_\_\_
   * Goals to reach:\_\_\_\_\_\_\_\_\_\_
   * Roles that KCC plays:\_\_\_\_\_\_\_\_
   * Rules:\_\_\_\_\_\_\_\_\_
   * Execution Plan:\_\_\_\_\_\_\_\_\_\_

### Twitter Space

<figure><img src="https://lh4.googleusercontent.com/n_QUQuRTKD-W0Uly2bj-wslhUOLGBOsgdJoVPVTm9_jpDA5Ukwh_8Uv9j8T999QH1AQTBWcBpOsDdTuHxowFM8PAybjh8MAbv76NQXF5XXh9PZMd__GaNsevgR6VVAFbGge4rfzqRDL5yXBqWRy6GEU" alt=""><figcaption></figcaption></figure>

KCC is offering Twitter Space/AMA for projects that have been listed on the KCC Discover. It is free of charge for the first time. If you want to book an AMA with KCC, please prepare the following materials:

* Speaker: Name, Position (title), Profile Pic;
* Project Logo: Landscape with the project name in PNG or SVG;
* Topic of the AMA;
* Prize Pool: Anything that you can provide as prizes such as NFTs, USDT, native token, and/or free accounts.&#x20;

### Announcement on Telegram & Discord

Post your launch announcement in our Telegram Community and Discord Server channels for everyone to see:

1. KCC official Telegram News Channel: <https://t.me/KCCOfficialChannel>
2. KCC official Telegram Group: <https://t.me/KCCOfficialEnglishCommunity>
3. KCC official Discord Server: #📣-kcc-announcement <br>

### YouTube Video

<figure><img src="https://lh3.googleusercontent.com/L7nzRw0B2IqE_SZbzBH1Ih3AhQY_xU3EsRmtKpULoWMdrIYqam-1ZJjKw5V9gtiFzFlSDPXl9MK7wtzGXrkoMI4U3stEwoVW7CMoEh_u6FB-_xF5DbGbvgPPl9UKJPOAqwKGghkb5m5QCgVV8oyhxBE" alt=""><figcaption></figcaption></figure>

For projects that are listed on the KCC Discover, you can post one product demonstration video on our [YouTube](https://www.youtube.com/channel/UCZhWm40SuAApnLqqq3F9o1w) channel sharing and guide users to use your product. If you want to post your video on KCC’s YouTube channel, please record your draft video in the following format and submit it to your point of contact at KCC.

* **Video Demo Content Guide:**

1. Intro to your project&#x20;
2. What are the key functions of your project
3. How to navigate through your app
4. Future use cases or plans you have for KuCoin/KCC communities
5. Other things you would like to mention
6. How to follow your project’s socials
7. Conclusion

* **File format:**&#x20;

1. At least 1080P in resolution
2. No need to show the speaker’s face in video
3. Landscape
4. No background music

* **The KCC team will review and edit the content within 5 business days after receiving it. The official post will be made within 10 business days.**
* **To protect the users, if the project has risk exposure, such as funds being hacked, KCC has the right to delist the video temporarily until risks have been relieved.**


# PR & Third-Party Marketing Support

## PR  Marketing Support

KCC can provide PR and KOL support to meet the project's major event announcement needs.

* The KCC team only provides resource docking, and the project party decides whether to adopt it at its own expense;
* Different projects have different needs, so this service requires the project to connect with the business 1V1.

## Third-Party Marketing Support

### Get Listed on Third-Party Platforms

Users get the latest KCC ecosystem update through platforms such as DefiLlama and CoinMarketCap. While these platforms are not managed by the KCC team, they are well-recognized among the KCC community.&#x20;

1. **DeFi Projects:**

* DefiLlama: <https://docs.llama.fi/list-your-project/submit-a-project>

2. **NFT Projects:**

* MojitoSwap Marketplace: <https://forms.gle/XptRLTSToLbPVvF4A>

3. **General Projects:**

* RootData: <https://www.rootdata.com/Projects/submit>
* CoinMarketCap: <https://support.coinmarketcap.com/hc/en-us/requests/new>
* CoinGecko: <https://docs.google.com/forms/d/e/1FAIpQLSfpIPMsCvVokn7l6OpjJmJoYRxvpArYpO4rvcps-0XQxLQ7DQ/viewform>

### Resource Connection of KuCoin <br>

## About KCC

KCC is a public chain project initiated and built by the developer community of KCS and KuCoin aiming to solve the network latency and high gas fee of Ethereum. KCC is an EVM-compatible blockchain and is striving to provide community users and developers with a higher-speed, more convenient, and lower-cost blockchain experience.

Visit KCC: <https://www.kcc.io/>

Contact us: <kcc-business@kcc.network>


# Network Endpoints

<figure><img src="/files/rcSSCo7nwKbZEqfxhrYP" alt=""><figcaption></figcaption></figure>

This index guide contains network details for the KCC Mainnet and KCC Testnet and lists their associated RPC and node endpoints.

## KCC Mainnet

The native token of the KCC Mainnet is KCS and is used for gas.

<table><thead><tr><th width="223" align="center">Properties</th><th width="554" align="center">Network Details</th></tr></thead><tbody><tr><td align="center">NetworkName</td><td align="center">KCC Mainnet</td></tr><tr><td align="center">ChainID</td><td align="center">321</td></tr><tr><td align="center">Gas Token</td><td align="center">KCS</td></tr><tr><td align="center">Faucet</td><td align="center"><a href="https://faucet.kcc.io/">https://faucet.kcc.io/</a></td></tr><tr><td align="center">RPC Endpoint</td><td align="center"><a href="https://rpc-mainnet.kcc.network">https://rpc-mainnet.kcc.network</a><br>or<br><a href="https://kcc-rpc.com">https://kcc-rpc.com</a></td></tr><tr><td align="center">Web Socket Endpoint</td><td align="center">wss://rpc-ws-mainnet.kcc.network<br>or<br>wss://ws.kcc-rpc.com</td></tr><tr><td align="center">Block Explorer</td><td align="center"><a href="https://explorer.kcc.io/en">https://explorer.kcc.io/en</a> or <a href="https://scan.kcc.io/">https://scan.kcc.io/</a></td></tr></tbody></table>

## KCC Testnet

<table><thead><tr><th width="213" align="center">Properties</th><th align="center">Network Details</th></tr></thead><tbody><tr><td align="center">NetworkName</td><td align="center">KCC Testnet</td></tr><tr><td align="center">ChainID</td><td align="center">322</td></tr><tr><td align="center">Gas Token</td><td align="center">KCS</td></tr><tr><td align="center">Faucet</td><td align="center"><a href="https://faucet-testnet.kcc.network/">https://faucet-testnet.kcc.network/</a></td></tr><tr><td align="center">RPC Endpoint</td><td align="center"><a href="https://rpc-testnet.kcc.network">https://rpc-testnet.kcc.network</a></td></tr><tr><td align="center">Web Socket Endpoint</td><td align="center">wss://rpc-ws-testnet.kcc.network</td></tr><tr><td align="center">Block Explorer</td><td align="center"><a href="https://scan-testnet.kcc.network">https://scan-testnet.kcc.network</a></td></tr></tbody></table>

## Infrastructure Providers <a href="#infrastructure-providers" id="infrastructure-providers"></a>

Public RPCs may have traffic or rate-limits depending on usage. You can sign up for a dedicated free RPC URL at the following:

* [Getblock](https://getblock.io/en/)
* [BlockPI](https://chains.blockpi.io/#/polygon)


# Deploy Smart Contract

{% content-ref url="/pages/J4JUWoraRmxe3WjUlySE" %}
[Using Remix](/developers/deploy-smart-contract/using-remix)
{% endcontent-ref %}

{% content-ref url="/pages/o9lREf7RiEiJzkm2Pa8r" %}
[Using Hardhat](/developers/deploy-smart-contract/using-hardhat)
{% endcontent-ref %}


# Using Hardhat

<figure><img src="/files/8RRADP0kaPPBWWEIuSmk" alt=""><figcaption></figcaption></figure>

## Overview

This tutorial will teach you how to create, compile and deploy a smart contract on the KCC Testnet using Hardhat.

[**Hardhat**](https://hardhat.org) is a development environment for Ethereum software. It consists of different components for editing, compiling, debugging, and deploying your smart contracts and dApps, all of which work together to create a complete development environment.

### What you will do[​](https://wiki.polygon.technology/docs/develop/hardhat#what-you-will-do) <a href="#what-you-will-do" id="what-you-will-do"></a>

* Set up Hardhat
* Create a simple smart contract
* Compile contract
* Test contract
* Deploy contract

## Setting up the development environment <a href="#setting-up-the-development-environment" id="setting-up-the-development-environment"></a>

There are a few technical requirements before we start.

### Pre-requisites[​](https://docs.bnbchain.org/docs/hardhat-new#pre-requisites) <a href="#pre-requisites" id="pre-requisites"></a>

There are a few technical requirements before we start, as listed below:

* [Node.js v10+ LTS and npm](https://nodejs.org/en/) (comes with Node)
* [Git](https://git-scm.com/)

Once we have those installed, you need to create an npm project by going to an empty folder, running `npm init --yes`, and following its instructions to install Hardhat. Once your project is ready, you should run the following:

```
npm install --save-dev hardhat
```

To create your Hardhat project, run `npx hardhat` in your project folder. Let’s create the sample project and follow these steps to try out a sample task and compile, test, and deploy the sample contract.

{% hint style="info" %}
**Note**

The sample project used here comes from the [Hardhat Quickstart guide](https://hardhat.org/getting-started/#quick-start), as well as its instructions.
{% endhint %}

## Creating a project <a href="#creating-a-project" id="creating-a-project"></a>

In your project folder, run `npx hardhat` to create a sample project. You should see the following prompt:

<figure><img src="/files/JEaLrSu3fhjGEhxlDVnA" alt=""><figcaption></figcaption></figure>

Choose the `TypeScript project` and The following prompt should appear:

<figure><img src="/files/rE0CgzAVoEQcwY1whkNg" alt=""><figcaption></figcaption></figure>

### Checking the Contract <a href="#create-smart-contract" id="create-smart-contract"></a>

A sample contract in the `contracts` folder is `Lock.sol`, which consists of a simple digital lock that allows users to withdraw funds only after a certain time has passed.

```solidity
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;

// Import this file to use console.log
import "hardhat/console.sol";

contract Lock {
    uint public unlockTime;
    address payable public owner;

    event Withdrawal(uint amount, uint when);

    constructor(uint _unlockTime) payable {
        require(
            block.timestamp < _unlockTime,
            "Unlock time should be in the future"
        );

        unlockTime = _unlockTime;
        owner = payable(msg.sender);
    }

    function withdraw() public {
        // Uncomment this line to print a log in your terminal
        // console.log("Unlock time is %o and block timestamp is %o", unlockTime, block.timestamp);

        require(block.timestamp >= unlockTime, "You can't withdraw yet");
        require(msg.sender == owner, "You aren't the owner");

        emit Withdrawal(address(this).balance, block.timestamp);

        owner.transfer(address(this).balance);
    }
}

```

### Configure Hardhat for KCC <a href="#configure-hardhat-for-bsc" id="configure-hardhat-for-bsc"></a>

* Go to `hardhat.config.ts`
* Create `.env` file in the root to store your private key
* Add **KCC Explorer** API key to `.env` file to verify the contract on KCC explorer. You can generate an API key by [creating an account](https://explorer.kcc.io/en/account/login?step=2)

{% hint style="info" %}
**Note**

Use the KCC Explorer API key to verify the contract is only for **KCC mainnet**
{% endhint %}

```typescript
// hardhat.config.ts
import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
import * as dotenv from "dotenv";

dotenv.config();

const config: HardhatUserConfig = {
    solidity: {
        compilers:[
            {
                version: "0.8.9",
                settings: {
                    optimizer: {
                        enabled: true,
                        runs: 200,
                    },
                },
            },
            {
                version: "0.4.18",
            }
        ]
    },

    networks: {
        ropsten: {
            url: process.env.ROPSTEN_URL || "",
            accounts:
                process.env.PRIVATE_KEY !== undefined ? [process.env.PRIVATE_KEY] : [],
        },
        testnet: {
            url: "https://rpc-testnet.kcc.network",
            chainId: 322,
            accounts: process.env.PRIVATE_KEY !== undefined ? [process.env.PRIVATE_KEY] : [],

        },
        mainnet: {
            url: "https://rpc-mainnet.kcc.network",
            chainId: 321,
            accounts: process.env.PRIVATE_KEY !== undefined ? [process.env.PRIVATE_KEY] : [],

        },

        hardhat: {
            allowUnlimitedContractSize: true,
        },
    },
    etherscan: {
        apiKey: process.env.ETHERSCAN_API_KEY,
    },
};

export default config;

```

{% hint style="info" %}
**NOTE**

Note that the file above requires DOTENV, for managing environment variables and also ethers and etherscan. Make sure to install all those packages.

Find more instructions on how to use DOTENV on [this page](https://www.npmjs.com/package/dotenv).
{% endhint %}

Your deployment contract account's private key is located in the `.env` file.

<figure><img src="/files/mJXgzpiRvXLH8o5e93h8" alt=""><figcaption></figcaption></figure>

### Compiling the contract <a href="#compiling-the-contract" id="compiling-the-contract"></a>

To compile a Hardhat project, change to the root of the directory where the project is located and you first need to install Hardhat Toolbox:

```
npm install --save-dev @nomicfoundation/hardhat-toolbox
```

&#x20;And then run to compile:

```
npx hardhat compile
```

### Testing the Contract <a href="#testing-the-contract" id="testing-the-contract"></a>

To run tests with Hardhat, you need to type the following:

```
npx hardhat test
```

And this is an expected output:

<figure><img src="/files/VrfhNfWP4yFjB39VfjXD" alt=""><figcaption></figcaption></figure>

### Deploying on KCC <a href="#deploying-on-polygon-network" id="deploying-on-polygon-network"></a>

Run this command in the root of the project directory:

```
npx hardhat run scripts/deploy.ts --network testnet
```

{% hint style="info" %}
**Note**

If you want to deploy your smart contract to **KCC Mainnet**, at the Deploying stage, you need to use mainnet instead of testnet after `--network`.
{% endhint %}

If you have enough amount of KCS you will see the sample output:

<figure><img src="/files/YLMLuXMPhSnSgRZ2ZpwZ" alt=""><figcaption></figcaption></figure>

The contract will be deployed on KCC Testnet, and you can check the deployment status here: <https://scan-testnet.kcc.network/>

**Congratulations! You have successfully deployed the `Lock` Smart Contract. The Smart Contract is now available for interaction.**

Besides, if you do not have the required amount of KCS, the output may look like this:

<figure><img src="/files/uUkirz5QnYbuKrpi6fU2" alt=""><figcaption></figcaption></figure>

You can go to [KCC Testnet Faucet ](https://faucet-testnet.kcc.network/)to get more KCS for testing.


# Using Remix

<figure><img src="/files/NU9W9y23Dn7K807si8Fl" alt=""><figcaption></figcaption></figure>

## Overview

This tutorial will show you how to compile and deploy an existing smart contract using Remix.

Remix IDE is a no-setup smart contract development tool with a GUI. Beginners and experts alike will benefit from Remix. Remix plays well with other tools, and allows for a simple deployment process to the chain of your choice. The Remix Project also can serve as a learning lab for teaching and experimenting with EVM-compatible chains.

## Pre-requisites <a href="#pre-requisites" id="pre-requisites"></a>

* Install Metamask
* Configure KuCoin Community Chain Testnet on Metamask
* Get Testnet token

## What you will do

* Create a file on Remix
* Upload or code the smart contract to the IDE
* Compile the smart contract
* Connect the application to KCC Testnet via Metamask
* Deploy the smart contract

## Getting started with [Remix IDE](https://remix.ethereum.org/)

To start building a smart contract, click on **New File** and name it as `HelloWorld.sol`.

<figure><img src="/files/spDX7EZitxMhN9e0q0GN" alt=""><figcaption></figcaption></figure>

## Writing smart contract

Copy the code given below to `HelloWorld.sol` file

```solidity
// SPDX-License-Identifier: MIT
// Specifies that the source code is for a version
// of Solidity greater than 0.8.15
pragma solidity ^0.8.15;

contract HelloWorld {

    // A publicly accessible function that takes a string as a parameter
    // and echoes the `message`
    function echo(string memory message) public pure returns (string memory) {
        return message;
    }
}
```

The first line, `pragma solidity ^0.8.15` specifies that the source code is for a Solidity version greater than 0.8.15. [Pragmas](https://solidity.readthedocs.io/en/latest/layout-of-source-files.html#pragma) are common instructions for compilers about how to treat the source code (e.g., pragma once).

## Compile smart contract

* Switch to the **Compiler** tab
* Select compiler version **0.8.15**
* Now, compile `HelloWorld.sol`
* After successful compilation, it will show a green tick mark on the **Compiler** tab button

<figure><img src="/files/nIS5IgZmeM7MfJS04AcW" alt=""><figcaption></figcaption></figure>

## Configure KCC Testnet on Metamask

{% content-ref url="/pages/qvwsNu1SF1zOMx8AOGPh" %}
[Network Configuration](/individuals/network-configuration)
{% endcontent-ref %}

## Deploy Smart Contract to KCC Testnet

In both Testnet and Mainnet, you do the below to deploy your smart contract using Remix.

* Navigate to the **Deployment tab**
* Select **Injected Provider** Metamask in the **Environment** dropdown, and your contract

![](/files/dtw0GNxnuNHuqArfmawY)

<figure><img src="/files/bA3irYQxanYngFSiKNNQ" alt=""><figcaption></figcaption></figure>

* Accept the Connect request received in MetaMask. You can also manually launch MetaMask if the popup doesn't open by default
* In MetaMask, once a transaction is deployed, you will receive another MetaMask pop-up that requires you to confirm the transaction. You just need to confirm the transaction

<figure><img src="/files/OLDO2Yu7vQupEMWUcYdf" alt=""><figcaption></figcaption></figure>

**Congratulations! You have successfully deployed the** [`HelloWorld`](https://scan-testnet.kcc.network/tx/0xfac405bc36a1e4230b5e6e7616877e48c81ee8d73b95a6d54d8aa7c9aa80b90f) **Smart Contract** to the **KuCoin Community Chain Testnet**. You can start interacting with your Smart Contract. Check the deployment status at <https://scan-testnet.kcc.network/>


# Verify Smart Contract

{% content-ref url="/pages/xKmfWQEw1JsHIxtBGvXm" %}
[Using Hardhat](/developers/verify-smart-contract/using-hardhat)
{% endcontent-ref %}

{% content-ref url="/pages/ZX93VQvaCuyVxoiS9Lqp" %}
[Using Foundry](/developers/verify-smart-contract/using-foundry)
{% endcontent-ref %}

{% content-ref url="/pages/xWkfsxdE6cqJff6r5RbL" %}
[Using Remix](/developers/verify-smart-contract/using-remix)
{% endcontent-ref %}


# Using Hardhat

[Hardhat ](https://hardhat.org/)is a full-featured development environment for contract compilation, deployment and verification. The [Hardhat Etherscan plugin](https://hardhat.org/plugins/nomiclabs-hardhat-etherscan.html) supports contract verification on kcc scan.

## Get Started

### **1) Install Hardhat**

If you are starting from scratch, create an npm project by going to an empty folder, running `npm init`, and following the instructions. Recommend npm 7 or higher.

Once your project is ready:

**npm instructions**

```
npm install --save-dev hardhat
```

**yarn instructions**

```
yarn add --dev hardhat
```

**pnpm instructions**

```
pnpm add -D hardhat
```

### **2) Create a project**

Run `npx hardhat` in your project folder and follow the instructions to create ([more info here](https://hardhat.org/getting-started/#quick-start)).

### 3) Install plugin

Install the [hardhat-etherscan plugin](https://hardhat.org/plugins/nomiclabs-hardhat-etherscan.html) (requires **v3.0.0+).**

**npm**

```
npm install --save-dev @nomiclabs/hardhat-etherscan
```

**yarn**

```
yarn add --dev @nomiclabs/hardhat-etherscan
```

**pnpm**

```
pnpm add -D @nomiclabs/hardhat-etherscan
```

### 4) Add plugin reference to config file

Add the following statement to your `hardhat.config.js`.

```
require("@nomiclabs/hardhat-etherscan");
```

If using TypeScript, add this to your `hardhat.config.ts.` [More info on using typescript with hardhat available here](https://hardhat.org/guides/typescript.html#typescript-support).

```
import "@nomiclabs/hardhat-etherscan";
```

## Config File

Your basic [Hardhat config file](https://hardhat.org/config/) (`hardhat.config.js` or `hardhat.config.ts`) will be setup to support the network you are working on. In this example we use the kcc test network and a `.js` file. &#x20;

You can add a `customChains` object to the config file. It includes:

* `chainID` - Network chain ID
* `apiURL` - Block explorer API URL
* `browserURL` - Block explorer URL

```
require("@nomiclabs/hardhat-waffle");
require("@nomiclabs/hardhat-etherscan");
require('hardhat-deploy');

let secret = require("./secret");

module.exports = {
  solidity: "0.8.17",
  networks: {
    kt: {
      url: 'https://rpc-testnet.kcc.network/',
      accounts: [secret.key],
    },
    km: {
      url: 'https://rpc-mainnet.kcc.network/',
      accounts: [secret.key],
    }
  },
  etherscan: {
    apiKey: {
      kt: "abc",
      km: "abc"
    },
    customChains: [
      {
        network: "km",
        chainId: 321,
        urls: {
          apiURL: "https://scan.kcc.io/api",
          browserURL: "https://scan.kcc.io/"
        }
      },
      {
        network: "kt",
        chainId: 322,
        urls: {
          apiURL: "https://scan-testnet.kcc.network/api",
          browserURL: "https://scan-testnet.kcc.network/"
        }
      }
    ]
  }
};
```

## Deploy and Verify

### Deploy

```
npx hardhat run scripts/deploy.js --network kt
Contract deployed to: 0x3F0A49981D3204A8E7bD7871aDEFBC6379A05410
```

### Verify

You can include constructor arguments with the verify task.

```
npx hardhat verify --network <network> DEPLOYED_CONTRACT_ADDRESS "Constructor argument"
```

KCC Testnet example (has constructors).

```sh
D:\hardhat>npx hardhat verify --network kt 0x3F0A49981D3204A8E7bD7871aDEFBC6379A05410 "0x0576a174D229E3cFA37253523E645A78A0C91B57,0xae3DB39196012a7bF6D38737192F260cdFE1E7Ec"
Nothing to compile
Compiling 1 file with 0.8.0
Successfully submitted source code for contract
contracts/KCCPaymaster.sol:KCCPaymaster at 0x3F0A49981D3204A8E7bD7871aDEFBC6379A05410
for verification on the block explorer. Waiting for verification result...

Successfully verified contract KCCPaymaster on Etherscan.
https://scan-testnet.kcc.network/address/0x3F0A49981D3204A8E7bD7871aDEFBC6379A05410#code
```

{% hint style="info" %}
Note the verify task will not be listed in the available tasks lists at `npx hardhat --config` but should work as expected.

If not, check you have the minimum required version of the nomiclabs-hardhat-etherscan plugin (v3.0.0+) installed
{% endhint %}

## Confirm Verification on KCC Scan

Go to KCC Scan instance and paste the contract address into the search bar. If verified, the code tab will display a green checkmark.

<figure><img src="/files/FBKKMhLULrvrLDEzOMqN" alt=""><figcaption></figcaption></figure>

**Selecting the Code tab will provide additional information about your contract.**

<figure><img src="/files/h2t1hs1WnuVl0SOfyfhx" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/A3Ogg74mCYMdAjwIyWOa" alt=""><figcaption></figcaption></figure>

## Resources

{% hint style="info" %}
Learn more about plugin configs, troubleshooting etc. at <https://hardhat.org/plugins/nomiclabs-hardhat-etherscan.html>
{% endhint %}


# Using Foundry

[Foundry](https://github.com/foundry-rs/foundry/) is a smart contract development toolchain. Foundry manages your dependencies, compiles your project, runs tests, deploys, and lets you interact with the chain from the command line and via Solidity scripts.

Forge is a command-line tool that ships with Foundry. Forge tests, builds, and deploys your smart contracts. Forge supports contract verification out of the box (<https://book.getfoundry.sh/reference/forge/forge-verify-contract>)

## Get Started

### **1)** Install Foundry

<https://book.getfoundry.sh/getting-started/installation>

### **2) Create a project**

To start a new project with Foundry, use [`forge init`](https://book.getfoundry.sh/reference/forge/forge-init.html):

```
forge init foundry_verify_demo
```

Let's check out what `forge` generated for us:

```
cd foundry_verify_demo
tree . -d -L 1
.
├── lib
├── script
├── src
└── test

4 directorie
```

## &#x20;Config File

foundry.toml

```
[profile.default]
src = 'src'
out = 'out'
libs = ['lib']
solc = "0.8.13"
eth-rpc-url = "https://rpc-testnet.kcc.network"
optimizer = true
optimizer-runs = 10_000_000

# See more config options https://github.com/foundry-rs/foundry/tree/master/config
```

### Deploying <a href="#deploying" id="deploying"></a>

Forge can deploy smart contracts to a given network with the [`forge create`](https://book.getfoundry.sh/reference/forge/forge-create.html) command.

Forge can deploy only one contract at a time.

To deploy a contract, you must provide a RPC URL (env: `ETH_RPC_URL`) and the private key of the account that will deploy the contract.

Deploy the `MyContract` to the network:

```
forge create --rpc-url <your_rpc_url> --private-key <your_private_key> src/MyContract.sol:MyContract
compiling...
success.
Deployer: 0xa735b3c25f...
Deployed to: 0x4054415432...
Transaction hash: 0x6b4e0ff93a...

```

Solidity files may contain multiple contracts. `:MyContract` above specifies which contract to deploy from the `src/MyContract.sol` file.

Use the `--constructor-args` flag to pass arguments to the constructor:

#### KCC Testnet Example

```solidity
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

contract TestVerify {
    string public name;
    uint256 public number;

    constructor(
        string memory _name,
        uint256  _number
    )  {
        name=_name;
        number = _number;
    }

    function setNumber(uint256 newNumber) public {
        number = newNumber;
    }

    function increment() public {
        number++;
    }
}
```

Ddeploy  the `TestVerify` to the KCC Testnet:

```
forge create \
    --rpc-url https://rpc-testnet.kcc.network/ \
    --constructor-args "counter-verify" 123 \
    --private-key <your_private_key> \
    src/TestVerify.sol:TestVerify \
    --constructor-args "" \
    --legacy

[⠢] Compiling...
No files changed, compilation skipped
Deployer: 0xC4E82486c745dF7Ff21498A32914558e255dfffa
Deployed to: 0x1E8e3E6d1a71a6267F199A5568f88A00aa4d10C4
Transaction hash: 0x66ca760f1532aacf383da0c747bddf3f81d1b6dec10846c9b45d3bded50446da
```

Additionally, we can tell Forge to verify our contract on Etherscan, Sourcify or Blockscout, if the network is supported, by passing `--verify`.

```
forge create \
    --rpc-url https://rpc-testnet.kcc.network/ \
    --constructor-args "counter-verify" 123 \
    --private-key <your_private_key> \
    src/TestVerify.sol:TestVerify \
    --verify \
    --verifier=blockscout \
    --verifier-url=https://scan-testnet.kcc.network/api \
    --legacy


[⠢] Compiling...
No files changed, compilation skipped
Deployer: 0xC4E82486c745dF7Ff21498A32914558e255dfffa
Deployed to: 0x713b499f4cD5E4f65CaD22B4245Cd38ece8285eD
Transaction hash: 0x3f07b8e249241254c051d19cd09f10561f36984a2509c5d1b576629490bb34fd
Starting contract verification...
Waiting for blockscout to detect contract deployment...
Start verifying contract `0x713b499f4cd5e4f65cad22b4245cd38ece8285ed` deployed on 322

Submitting verification for [src/TestVerify.sol:TestVerify] "0x713b499f4cD5E4f65CaD22B4245Cd38ece8285eD".
Submitted contract for verification:
        Response: `OK`
        GUID: `713b499f4cd5e4f65cad22b4245cd38ece8285ed642b8f33`
        URL:
        https://scan-testnet.kcc.network/apiaddress/0x713b499f4cd5e4f65cad22b4245cd38ece8285ed
Contract verification status:
Response: `OK`
Details: `Pending in queue`
Contract verification status:
Response: `OK`
Details: `Pass - Verified`
Contract successfully verified

```

### Verifying a pre-existing contract <a href="#verifying-a-pre-existing-contract" id="verifying-a-pre-existing-contract"></a>

If you are verifying an already deployed contract, read on.

You can verify a contract on Etherscan, Sourcify or Blockscout with the [`forge verify-contract`](https://book.getfoundry.sh/reference/forge/forge-verify-contract.html) command.

You must provide:

* the contract address
* the contract name or the path to the contract `<path>:<contractname>`

Moreover, you may need to provide:

* the constructor arguments in the ABI-encoded format, if there are any
* [compiler version](https://etherscan.io/solcversions) used for build, with 8 hex digits from the commit version prefix (the commit will usually not be a nightly build). It is auto-detected if not specified.
* the number of optimizations, if the Solidity optimizer was activated. It is auto-detected if not specified.
* the chain ID

Let's say you want to verify `TestVerify` (see above). You set the [number of optimizations](https://book.getfoundry.sh/reference/config/solidity-compiler.html#optimizer_runs) to 1 million, compiled it with v0.8.13, and deployed it, as shown above, to the KCC Testnet (chain ID: 322). Note that `--num-of-optimizations` will default to 0 if not set on verification, while it defaults to 200 if not set on deployment, so make sure you pass `--num-of-optimizations 200` if you left the default compilation settings.

Here's how to verify it:

```
forge verify-contract \
    --chain-id 322 \
    --num-of-optimizations 1000000 \
    --watch \
    --constructor-args $(cast abi-encode "constructor(string,uint256)" "counter-verify" 123) \
    --verifier=blockscout \
    --verifier-url=https://scan-testnet.kcc.network/api \
    --compiler-version v0.8.13+commit.abaa5c0e \
    0x1E8e3E6d1a71a6267F199A5568f88A00aa4d10C4 \
    src/TestVerify.sol:TestVerify

Submitting verification for [src/TestVerify.sol:TestVerify] "0x1E8e3E6d1a71a6267F199A5568f88A00aa4d10C4".
Submitted contract for verification:
        Response: `OK`
        GUID: `1e8e3e6d1a71a6267f199a5568f88a00aa4d10c4642b9477`
        URL:
        https://scan-testnet.kcc.network/apiaddress/0x1e8e3e6d1a71a6267f199a5568f88a00aa4d10c4
Contract verification status:
Response: `OK`
Details: `Pending in queue`
Contract verification status:
Response: `OK`
Details: `Pass - Verified`
Contract successfully verified
```

It is recommended to use the [`--watch`](https://book.getfoundry.sh/reference/forge/forge-verify-contract.html#verify-contract-options) flag along with `verify-contract` command in order to poll for the verification result.

If the `--watch` flag was not supplied, you can check the verification status with the [`forge verify-check`](https://book.getfoundry.sh/reference/forge/forge-verify-check.html) command:

{% hint style="info" %}

#### Tips:

1. Setting the `—verifier=blockscout` flag allows you to not specify any Api key.
2. While specifying `--verifier-url` flag omit the final slash (e.g., `--verifier-url=`[`https://scan-testnet.kcc.network/api`](https://scan-testnet.kcc.network/api)). Otherwise, you will encounter an “*Failed to deserialize response*” error.
3. You can specify most configuration options (e.g., evm version, disabling optimizations) via the usual Forge configuration (see <https://github.com/foundry-rs/foundry/blob/master/config/README.md>).
4. Use Cast's [`abi-encode`](https://book.getfoundry.sh/reference/cast/cast-abi-encode.html) to ABI-encode arguments.

   In this example, we ran `cast abi-encode "`constructor(string,uint256)`"` "counter-verify" 123 to ABI-encode the arguments.
5. KCC Mainnet Scan  `--verifier-url=`[`https://scan.kcc.io/api`](https://scan.kcc.io/api)
   {% endhint %}

## Troubleshooting <a href="#troubleshooting" id="troubleshooting"></a>

**EIP-1559 not activated**

EIP-1559 is not supported or not activated on the RPC server. Pass the `--legacy` flag to use legacy transactions instead of the EIP-1559 ones. If you do development in a local environment, you can use Hardhat instead of Ganache.

**Compiler version commit for verify**

If you want to check the exact commit you are running locally, try: `~/.svm/0.x.y/solc-0.x.y --version` where `x` and `y` are major and minor version numbers respectively. The output of this will be something like:

```ignore
solc, the solidity compiler commandline interface
Version: 0.8.12+commit.f00d7308.Darwin.appleclang
```

Note: You cannot just paste the entire string "0.8.12+commit.f00d7308.Darwin.appleclang" as the argument for the compiler-version. But you can use the 8 hex digits of the commit to look up exactly what you should copy and paste from [compiler version](https://etherscan.io/solcversions).


# Using Remix

## Deploy Smart Contract

You can refer to this tutorial on using Remix to deploy contracts.

{% content-ref url="/pages/J4JUWoraRmxe3WjUlySE" %}
[Using Remix](/developers/deploy-smart-contract/using-remix)
{% endcontent-ref %}

## Verify Smart Contract

### Via flattened source code

* &#x20;Our deployed `HelloWorld` contract address is `0x1267b1887f0a7333a47bb0a37e68c04a8ee80a44`
* Navigate to the HelloWorld smart contract address in the [KCC Testnet explorer](https://scan-testnet.kcc.network/)
* Find the **Code** sub-tab and click on **Verify & Publish**

<figure><img src="/files/P5tZKJDwwn3uGaJucBtK" alt=""><figcaption></figcaption></figure>

* Choose the `via flattened source code` and continue to the **Next**

<figure><img src="/files/ftaNkOnO6EZQJsqfkRb6" alt=""><figcaption></figcaption></figure>

* Naming the smart contract
* Select the appropriate compiler version
* Copy and paste the flattened source code
* Click **Verify & Publish**.

<figure><img src="/files/LtjYzMDao8xGsF4AuGRY" alt=""><figcaption></figcaption></figure>

* KCC Testnet will take a few seconds to compile your contract, verify, and publish it.

<figure><img src="/files/ezS5fIvmrFmEVBEJufO0" alt=""><figcaption></figcaption></figure>

### Via Standard Input JSON

Standard input json is basically the raw file fed into the Solidity compiler on verification. There are some minor updates made regarding info the output compiler should return, but the main contract-related fields remain the same. This way, standard json allows you to specify the most subtle compiler settings, as well as to specify all source files.

It is quite cumbersome and tedious work, so it is preferable to use any of the above methods, however, we describe the process in more detail for those who want to use it.

For this tutorial, we will create standard json for the following contract:

```solidity
// SPDX-License-Identifier: MIT
// Specifies that the source code is for a version
// of Solidity greater than 0.8.15
pragma solidity ^0.8.15;

contract HelloWorld {

    // A publicly accessible function that takes a string as a parameter
    // and echoes the `message`
    function echo(string memory message) public pure returns (string memory) {
        return message;
    }
}
```

1\) We will use a `COMPILERINPUT` file generated by the compiler. You can find it in the “Compilation Details” tab (ensure that correct contract is chosen).&#x20;

<figure><img src="/files/lUxj5eE68DWAFBYHBA8b" alt=""><figcaption></figcaption></figure>

Create a JSON file locally and paste the copied content into the JSON file.

```json
{
    "language":"Solidity",
    "sources":{
        "HelloWorld.sol":{
            "content":"// SPDX-License-Identifier: MIT\n// Specifies that the source code is for a version\n// of Solidity greater than 0.8.15\npragma solidity ^0.8.15;\n\ncontract HelloWorld {\n\n    // A publicly accessible function that takes a string as a parameter\n    // and echoes the `message`\n    function echo(string memory message) public pure returns (string memory) {\n        return message;\n    }\n}"
        }
    },
    "settings":{
        "optimizer":{
            "enabled":true,
            "runs":200
        },
        "outputSelection":{
            "*":{
                "":[
                    "ast"
                ],
                "*":[
                    "abi",
                    "metadata",
                    "devdoc",
                    "userdoc",
                    "storageLayout",
                    "evm.legacyAssembly",
                    "evm.bytecode",
                    "evm.deployedBytecode",
                    "evm.methodIdentifiers",
                    "evm.gasEstimates",
                    "evm.assembly"
                ]
            }
        }
    }
}
```

2\) Submit composed standard json for verification “`Via Standard Input JSON`” and check results.

<figure><img src="/files/890mq8mklyt6x8WpAw4x" alt=""><figcaption></figcaption></figure>

Import the local JSON file.

<figure><img src="/files/PE1rnexE6h5vVUpGk6y5" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/ZcxIGNXZIaMiZKNyni7w" alt=""><figcaption></figcaption></figure>


# Issue ERC20 Token

<figure><img src="/files/Rjca9uoAruGSfrMHA5jD" alt=""><figcaption></figcaption></figure>

## Overview

ERC-20 is the technical standard for fungible tokens created on the EVM-compatible blockchain. An ERC20 token contract keeps track of *fungible* tokens: any token is exactly equal to any other token; no tokens have special rights or behavior associated with them. This makes ERC20 tokens useful for things like a **medium of exchange currency**, **voting rights**, **staking**, and more.&#x20;

As we know, both OpenZeppelin and ConsenSys maintain the standard library of ERC contract classes. Simply put, ERC20 is nothing more than a class with methods and members that run the logic of what we usually call cryptocurrency. However, it has a broader meaning because it also has applications in other use cases.&#x20;

Having explained why we imported the OpenZeppelin library and what ERC20 means, let's move on to learning how to create and deploy an ERC20 token with the OpenZepplin library.&#x20;

{% hint style="info" %}
**Note**

Additionally, OpenZeppelin offers some [ERC20 extension contracts](https://docs.openzeppelin.com/contracts/4.x/api/token/erc20#extensions). Please review the details if you are interested.
{% endhint %}

## Pre-requisites <a href="#pre-requisites" id="pre-requisites"></a>

* Install Metamask
* Configure  KuCoin Community Chain Testnet on Metamask
* Get Testnet token

## Compile and Deploy ERC20 Token

### Open Remix IDE: <https://remix.ethereum.org/>

<figure><img src="/files/CjOzsoHiRPHDoFttyo3N" alt=""><figcaption></figcaption></figure>

### Create the contract

* Create a new `Token.sol` contract and copy the below contract code to `Token.sol`

```solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.9;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract KIP20Token is ERC20 {
    constructor(uint256 totalSupply) ERC20("DemoToken", "DET") {
        // create totalSupply of tokens for the deployer
        _mint(msg.sender, totalSupply);
    }
}
```

### &#x20;Compile the contract

* switch to the compile page
* Select proper compiler
* Select `KIP20Token(Token.sol)` contract
* And then click `Compile Token.sol`

<figure><img src="/files/UFMl8Bw2Hpnm9PPts69Q" alt=""><figcaption></figcaption></figure>

### Compile the contract

* Click the button to switch to compile button
* Select `Injected Provider-MetaMask`
* Select `KIP20Token-Token.sol`
* Fill in many tokens you want to mint and click **`Deploy`** button

<figure><img src="/files/yyhsnIbRufaLbh2FU9GX" alt=""><figcaption></figcaption></figure>

* Click **`Confirm`** button to sign and broadcast the transaction to KCC Testnet

<figure><img src="/files/Ln1p3Ftg1PZAg9bUcgnP" alt=""><figcaption></figcaption></figure>

### Add custom token to MetaMask

* Copy the deployed contract address

<figure><img src="/files/tKwpm69Yrsti4l9yjpK9" alt=""><figcaption></figcaption></figure>

* Click **`Import Tokens`**

![](/files/c29eLAbZvmVD4OpgDcpP)

* Paste the contract address to the `Token contract address`
* And the `Token symbol` and `Token decimal` will auto tilled by MetaMask
* Finally, Click the **`Add custom token`**

![](/files/67UfM9zi1J74FLWSg9Yf)

* Click the **`Import tokens`** button

![](/files/kXe2BeMTRaTBGXUDLMse)

* When you reopen the MetaMask next time, you will see the token and amount

![](/files/ZBOcaWENKVlzdsiXXqYG)

## Conclusion[​](https://docs.bnbchain.org/docs/hardhat-new#conclusion) <a href="#conclusion" id="conclusion"></a>

This tutorial guides you through the basics of creating and deploying an ERC20 token contract based on the OpenZepplin library using the Remix IDE on the KCC Testnet. It should be noted that the exact same instructions and sequence will also work on KCC Mainnet.


# Deploy NFTs

<figure><img src="/files/bIPIUAWfJXbfhJbrbG0i" alt=""><figcaption></figcaption></figure>

In this tutorial, we will walk through how to deploy an ERC721 contract with [foundry](https://github.com/foundry-rs/foundry). &#x20;

{% content-ref url="/pages/CbkEENOxj8kgfr67CQvG" %}
[Create A Foundry Project](/developers/deploy-nfts/create-a-foundry-project)
{% endcontent-ref %}

{% content-ref url="/pages/Mpb6iBO9rFQQO5IkeCOq" %}
[Create Your ERC721 Contract](/developers/deploy-nfts/create-your-erc721-contract)
{% endcontent-ref %}

{% content-ref url="/pages/N59xHGDWlUSbzXo4kB8z" %}
[Add Metadata](/developers/deploy-nfts/add-metadata)
{% endcontent-ref %}


# Create A Foundry Project

<figure><img src="/files/Ag2FYWGoYtJBAJOOtNd3" alt=""><figcaption></figcaption></figure>

Like hardhat and truffle, foundry is a development environment for Ethereum smart contracts. And it is becoming more and more popular. Likewise, you can use foundry for developing and deploying smart contracts for KCC.

### Prerequisites&#x20;

* [Install foundry ](https://github.com/foundry-rs/foundry#installation)

{% hint style="info" %}
Foundry provides three command-line tools: forge, cast, and anvil. If you have successfully installed foundry, you can invoke any of those in your shell.&#x20;
{% endhint %}

### Create A New Project With Forge&#x20;

Let's create a new project called "my-nft" with the `forge` command from foundry:&#x20;

```bash
forge init my-nft
```

After executing the commands above, forge will create a directory named "my-nft". And there are several subdirectories and a file named "foundry.toml" in that directory:&#x20;

```
my-nft/
├── foundry.toml
├── lib
│   └── forge-std
├── script
│   └── Counter.s.sol
├── src
│   └── Counter.sol
└── test
    └── Counter.t.sol
```

### Add Configurations For KCC&#x20;

You can add two profiles to your foundry project by appending the following lines to the end of your `foundry.toml` file:&#x20;

```toml
[profile.kcc_main]
src = 'src'
out = 'out'
libs = ['lib']
# KCC has not implemented the London fork yet 
evm_version = 'berlin'
eth_rpc_url = 'https://rpc-mainnet.kcc.network'

[profile.kcc_testnet]
src = 'src'
out = 'out'
libs = ['lib']
# KCC has not implemented the London fork yet 
evm_version = 'berlin'
eth_rpc_url = 'https://rpc-testnet.kcc.network'
```

To test the configurations above, let's deploy the generated contract in the "Counter.sol" file to the KCC testnet: &#x20;

```bash
FOUNDRY_PROFILE=kcc_testnet  \
        forge create --private-key=xxxxxxxxxxx \
        --legacy  Counter
```

{% hint style="info" %}

* Forge reads the profile's name from the environment variable "FOUNDRY\_PROFILE".
* You should replace \`xxxxxxxxxxx\` with your own private key.&#x20;
  * BTW,  foundry also supports several other wallets: Keystore, mnemonic, and even Ledger.  And it is not wise to use a private key except in a test.
* You must use the `--legacy` option because KCC has not implemented EIP1559 yet.&#x20;
  {% endhint %}

If everything goes well, forge will print out the address of the deployed contract and the transaction hash for the deployment.&#x20;


# Create Your ERC721 Contract

<figure><img src="/files/F1Z4rGNP2vjEp2XmWJIu" alt=""><figcaption></figcaption></figure>

### Install Dependencies&#x20;

We will build your ERC721 contract based on the Openzeppelin contracts. Let's install Openzeppelin contracts for our foundry project:&#x20;

```bash
forge install openzeppelin/openzeppelin-contracts 
```

Foundry installs all dependencies as git submodules under the directory of "lib". And to make it easier to import the dependencies, let's create a `remappings.txt` file with the following contents:&#x20;

```
openzeppelin-contracts=lib/openzeppelin-contracts
```

{% hint style="info" %}
The `remapping.txt` file should be put in the project root directory (i.e., the directory that contains the`foundry.toml` file. )
{% endhint %}

With the `remappings.txt` file above, we can import the ERC721 contract from Openzeppelin by the following `import statement` :&#x20;

```solidity
import "openzeppelin-contracts/contracts/token/ERC721/ERC721.sol";
```

### The ERC721 Contract&#x20;

Create a new file named "MyNFT.sol" under the directory of "src".  The content in the file is as follows:&#x20;

```solidity
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "openzeppelin-contracts/contracts/token/ERC721/ERC721.sol";
import "openzeppelin-contracts/contracts/access/Ownable.sol";

contract MyNFT is ERC721, Ownable{

    string private _URIBase;

    constructor(string memory name_, string memory symbol_) ERC721(name_, symbol_) {
        _transferOwnership(msg.sender);
    }

    function mint(address to, uint256 tokenId) public onlyOwner {
        _safeMint(to, tokenId);
    }

    function setBaseURI(string memory baseURI_) public onlyOwner {
        _URIBase = baseURI_;
    }

    function _baseURI() internal view override returns (string memory) {
        return _URIBase;
    }
}
```

{% hint style="info" %}
In this toy ERC721 contract, we have added some customized logics:

* The deployer of the contract will be the owner of the contract.&#x20;
* Only the owner can mint a new NFT token. However, he can mint the token to another address.&#x20;
* Only the owner can change the base URI of the Token URI.&#x20;
  {% endhint %}

### Deploy Your ERC721 Contract&#x20;

```bash
FOUNDRY_PROFILE=kcc_testnet \
    forge create \
    --constructor-args "my-nft" "M" 
    --private-key=XXXXXXXXXXXXXXXXX  \
    --legacy  src/MyNFT.sol:MyNFT
```

{% hint style="info" %}
We use `--constructor-args` to specify the arguments for our constructor.
{% endhint %}

If everything goes well, forge will print out the address of the deployed contract and the transaction hash for the deployment.&#x20;

### Mint An NFT&#x20;

We can use `cast` from `foundry`  to interact with our ERC721 contract. Let's mint an `NFT` with `cast`:&#x20;

```bash
FOUNDRY_PROFILE=kcc_testnet cast send  \
    --private-key=XXXXXXXXXXXX  --legacy \
    0xd382De234f8d3f1DB54C856498a9DbC84c \
    'mint(address,uint256)'  \
    0x6Dfc34a4a2FC03Ba5d5ff95566781bD2b39702fc 1337
```

{% hint style="info" %}

* You should replace `0xd382De234f8d3f1DB54C856498a9DbC84c` with the address of your ERC721 contract.&#x20;
* And `0x6Dfc34a4a2FC03Ba5d5ff95566781bD2b39702fc` is the address that receives the newly minted NFT.&#x20;
* Finally, `1337` is the id of the newly minted NFT.&#x20;
  {% endhint %}

We can also verify the owner of this newly minted NFT by using `cast` again:&#x20;

```
FOUNDRY_PROFILE=kcc_testnet \
        cast call  0xd382De234f8d3f1DB54C856498a9DbC84c \
        'ownerOf(uint256)(address)' 1337
```


# Add Metadata

<figure><img src="/files/q7M3R49Dah0PSsVK9lZ3" alt=""><figcaption></figcaption></figure>

Following the previous two tutorials, we created our contract and minted an NFT with ID = 1337. However, our minted NFT has no metadata associated with it. Without metadata, an NFT token is nothing but a token with an ID.&#x20;

Our smart contract implements the ERC721 meta extension, and it has the following method for getting the metadata URI of an NFT token:&#x20;

```solidity
    /// @notice A distinct Uniform Resource Identifier (URI) for a given asset.
    /// @dev Throws if `_tokenId` is not a valid NFT. URIs are defined in RFC
    ///  3986. The URI may point to a JSON file that conforms to the "ERC721
    ///  Metadata JSON Schema".
    function tokenURI(uint256 _tokenId) external view returns (string);
```

{% hint style="info" %}
The `tokenURI` method returns a string which is the URI to the metadata of an NFT token. And the metadata is presented in a JSON file.&#x20;
{% endhint %}

### Prepare Metadata&#x20;

The metadata of an NFT token is presented in a JSON file. Here is an example:&#x20;

```json
{
  "description": "My NFT", 
  "image": "https://example.com/1337.png", 
  "name": "Hacker's Token 1337",
  "attributes": [
    {
      "trait_type": "Mouth", 
      "value": "Surprised"
    }, 
    {
      "trait_type": "Level", 
      "value": 5
    }
  ]
}
```

{% hint style="info" %}

* `name` is the name of this item(i.e, this NFT token), because each NFT token may have a different name.&#x20;
* `image` is the link to the image of this NFT token.&#x20;
* `description` is a short description of this NFT token.&#x20;
* &#x20;and `attributes` is a list of attributes that this NFT token has.&#x20;

Apart from the commonly used fields in the above example,  some other fields are also supported in the metadata JSON file. You can find more [here](https://docs.opensea.io/docs/metadata-standards#metadata-structure).&#x20;
{% endhint %}

{% hint style="info" %}
Note the link to the image is also in the metadata JSON. In this example, we are using an ordinary (web2) link. However, to make it more decentralized, you can upload your images to IPFS and use the IPFS CIDs with a gateway.&#x20;
{% endhint %}

You should create one metadata JSON for each of your NFT tokens. Let's assume you are hosting  all the metadata JSON files on the host of `my-nft-metadata.com` , and the metadata JSON of each NFT token should have the following format:&#x20;

```
https://my-nft-metadata.com/1337
```

{% hint style="info" %}

* `https://my-nft-metadata.com` is called the base URI.
* &#x20;1337 is the ID of the NFT token&#x20;
  {% endhint %}

{% hint style="info" %}
If you upload all your metadata JSON files to IPFS, you should add the whole directory that includes all the JSON files.  Then, all the JSON files can be visited with the same base URI.  For example, [all the metadata JSON files of the BAYC collection share the same base URI](https://ipfs.io/ipfs/QmeSjSinHpPnmXmspMjwiXyN6zS4E9zccariGR3jxcaWtq).&#x20;
{% endhint %}

### Set The Base URI

After uploading all the metadata JSON files somewhere and hosting them with the same base URI, we can set the base URI of the contract. Again, we can use the `cast` command:&#x20;

```bash
FOUNDRY_PROFILE=kcc_testnet \
        cast send  --private-key=XXXXXXXXXX  \
        --legacy \
        0xd382De234f8d3B35823f1DB54C85cE6498a9DbC84c \
        'setBaseURI(string)' "https://my-nft-metadata.com/"
```

{% hint style="info" %}

* `XXXXXXXXX` is your private key as usual&#x20;
* `0xd382De234f8d3B353f1DB54C85cE6498a9DbC84c` is the address of our NFT contract.&#x20;
* And we use cast to call the `setBaseURI` method, and change the base URI to "<https://my-nft-metadata.com"&#x20>;
  {% endhint %}

Let's verify that our base URI  works as expected.  We use `cast` to get the `tokenURI` of the token of `1337`:&#x20;

```bash
FOUNDRY_PROFILE=kcc_testnet \
    cast call 0xd382De234f8d3B353f1DB54C85cE6498a9DbC84c \
    'tokenURI(uint256)(string)' 1337 
```

You should see the following URI printed out:&#x20;

```
https://my-nft-metadata.com/1337
```


# Run a Node

The following subpages include all the information you need to run a node:&#x20;

{% content-ref url="/pages/SqsXQmWthRwrmtfQ1Rpj" %}
[Hardware & System Requirements](/developers/run-a-node/hardware-and-system-requirements)
{% endcontent-ref %}

{% content-ref url="/pages/JedxBlcR12QbKf2Ub9cK" %}
[Install KCC](/developers/run-a-node/install-kcc)
{% endcontent-ref %}

{% content-ref url="/pages/N72RQ9KK2C6wq2LnB5Gg" %}
[Run A Full Node](/developers/run-a-node/run-a-full-node)
{% endcontent-ref %}

{% content-ref url="/pages/qxclXIaQKNMamGLNFkMU" %}
[Run A Validator Node](/developers/run-a-node/run-a-validator-node)
{% endcontent-ref %}

{% content-ref url="/pages/SJln4X8SKNJJBK0HVL2s" %}
[Troubleshooting](/developers/run-a-node/troubleshooting)
{% endcontent-ref %}


# Hardware & System Requirements

The hardware requirements for running a KCC node

<figure><img src="/files/79WxWIIJEmdls6XXz2Sh" alt=""><figcaption></figcaption></figure>

If you are running a full node, the recommended requirements are as follows :&#x20;

* CPU with 4+ cores&#x20;
* 8G+ RAM&#x20;
* SSD with at least 200GB of free space
* 100+Mbit/s network bandwidth&#x20;
* 30303/UDP and 30303/TCP should be accessible from other peers
* Linux Operating System (others may work, but Linux is preferred)

If you are running an archive node (full node with all historical states), you need a larger disk:&#x20;

* SSD with at least 1TB of free space&#x20;


# Install KCC

How to install KCC

<figure><img src="/files/60ADYu9nKvVjhSkdTGZI" alt=""><figcaption></figcaption></figure>

## Node Client&#x20;

The KCC node client is based on Go Ethereum (aka, Geth).  To run a KCC node, you only need to install a single binary.   You can either build the binary from the source or download it from our GitHub release page.  Besides, you can also use an automatically built docker image.

## Option 1: Build From The Source&#x20;

Prerequisites:

* [Install Golang](https://go.dev/doc/install) 1.13 or later&#x20;
* Install "make" and a C compiler
  * For Ubuntu users,  you can install "build-essential".&#x20;
  * For CentOS users, you can install the "Development Tools" group
* git&#x20;

First, clone the KCC node client repository:&#x20;

```shell
git clone --depth 1 -b kcc \
    --single-branch https://github.com/kcc-community/kcc.git
```

Then, "make":&#x20;

```shell
cd kcc/ && make 
```

If everything works well, you will find the resulting binary at:&#x20;

```shell
build/bin/geth
```

## Option 2:  Download The Binary From GitHub Release Page

Go to the [GitHub Release Page](https://github.com/kcc-community/kcc/releases) of  the KCC client node repository, and the latest binary can be found in the assets section under the latest release notes:&#x20;

<figure><img src="/files/oyyNH1c5PJsRREABN8V9" alt=""><figcaption></figcaption></figure>

## Option 3:  Use Docker&#x20;

> If you want to know more about docker, please go to [the docker official docs](https://docs.docker.com/get-started/).&#x20;

You can find the automatically built docker images from KCC[ official docker hub repository](https://hub.docker.com/r/kucoincommunitychain/kcc/tags).  Clone the latest docker image by running the following commands:&#x20;

```bash
docker pull kucoincommunitychain/kcc:latest 
```


# Run A Full Node

<figure><img src="/files/wQ2FW13rrAFYbwJqa5fb" alt=""><figcaption></figcaption></figure>

### Run Your Full Node From The Command Line&#x20;

Run the following command to connect to the KCC mainnet:&#x20;

```shell
# We assume you have put the client binary "geth" in one of the directories in $PATH
geth --datadir /data/.kcc 
```

{% hint style="info" %}
"geth"  is the client binary you have built or installed in [the previous section](/developers/run-a-node/install-kcc). If it is not in one of your $PATH, you should use an absolute path (i.e., `/path/to/geth` ) Instead.
{% endhint %}

{% hint style="info" %}
All the chain data is in the directory following the option `--datadir`. So you should ensure the disk mounted to this directory has enough free space.&#x20;
{% endhint %}

And if you want to connect to the KCC testnet, you can use the following command instead:&#x20;

```shell
# add "--testnet" to connect to the testnet
geth --testnet --datadir /data/.kcc 
```

{% hint style="warning" %}
In the following sections, we will only talk about the mainnet. However, all the following commands will work on testnet, except that you should add an extra `--testnet` option.
{% endhint %}

### Enable HTTP & Websocket RPC Server&#x20;

If you want to access your node through the [Ethereum JSON-RPC](https://ethereum.org/en/developers/docs/apis/json-rpc/), you can use the following command to enable the HTTP and WebSocket RPC servers:&#x20;

```shell
geth --datadir /data/.kcc  --http --ws
```

{% hint style="info" %}
`--http` enables an HTTP-RPC server that listens on`localhost:8545`
{% endhint %}

{% hint style="info" %}
`--ws` enables a Websocket-RPC server that listens on`localhost:8546`&#x20;
{% endhint %}

With the commands above, you can only access your RPC servers from the same machine that runs your node. If you want to make your RPC servers publicly accessible, you need to specify the listening addresses of your RPC servers:&#x20;

```shell
geth --datadir /data/.kcc  --http --ws --http.addr 0.0.0.0 --ws.addr 0.0.0.0
```

{% hint style="info" %}
Use `--http.addr` to specify the listening address of your HTTP-RPC server and use `--ws.addr` for the listening address of your Websocket-RPC server.&#x20;
{% endhint %}

{% hint style="danger" %}
Your node could be vulnerable if you make your RPC servers publicly accessible.
{% endhint %}

### Run An Archive Node&#x20;

The state is a snapshot of all accounts on KCC, which includes the balance and nonce of each account, the code of each contract, and the storage of each smart contract. If you want to query the historical state at some block, you can replay all the transactions starting from the genesis block to reconstruct the state at that block. However, if you want to save all states on your disk, that would take a lot of disk space. Therefore, although a full node saves all the historical blocks and receipts, it does not hold all the historical states. &#x20;

Nevertheless, in some scenarios, you want to save all the historical states on your disk. For example, you are building some analyzing system that frequently queries the historical states, and you don't want to waste time reconstructing the historical states. You can run an archive node as follows:&#x20;

```shell
geth --datadir /data/.kcc --syncmode full --gcmode archive  
```

{% hint style="info" %}
"`--syncmode full`" tells the node to replay transactions in each block by itself, and "`--gcmode archive`" asks the node to record all the intermediate states when replaying those transactions.
{% endhint %}

### Use A Process Manager&#x20;

We highly recommend managing your node with a process manager. A process manager watches your node client process, collects and rotates the logs, and restarts your node if needed. Here is a list of some popular process managers:&#x20;

* [PM2](https://pm2.keymetrics.io/)
* [Systemd](https://en.wikipedia.org/wiki/Systemd)
* [Supervisord](http://supervisord.org/)

### Run Your Full Node In A Docker Container

The entry point of our docker image is `geth`, so it is quite straightforward to run your node in a docker container:&#x20;

```shell
docker run --name kcc -d -v /host/path:/data/.kcc/ \
     kucoincommunitychain/kcc:latest --datadir /data/.kcc 
```

{% hint style="info" %}
Use `--name` to specify the name of your running container

Use `-d` to make your container run in the background&#x20;

Use `-v` to map a host path into the container&#x20;

The trailing "``--datadir /data/.kcc" are arguments passed to the `geth` process in the container.``&#x20;
{% endhint %}


# Run A Validator Node

<figure><img src="/files/CJbsqYUEgJYJnf5CxE8G" alt=""><figcaption></figcaption></figure>

A validator node is a special type of full node that validates and proposes new blocks. This section contains the following subpages:&#x20;

{% content-ref url="/pages/JDJhzuvxm1JqYDUqKqcm" %}
[Block Rewards](/developers/run-a-node/run-a-validator-node/block-rewards)
{% endcontent-ref %}

{% content-ref url="/pages/ay1fkMBtn298cAlYvAdW" %}
[Apply For Running A Validator](/developers/run-a-node/run-a-validator-node/apply-for-running-a-validator)
{% endcontent-ref %}

{% content-ref url="/pages/rYU1FxAfLpUW7M7VBDCT" %}
[Manager Account And Validator Account](/developers/run-a-node/run-a-validator-node/manager-account-and-validator-account)
{% endcontent-ref %}

{% content-ref url="/pages/BkavDKYqd95bdd7gdJ3i" %}
[Run A Validator](/developers/run-a-node/run-a-validator-node/run-a-validator)
{% endcontent-ref %}


# Block Rewards

<figure><img src="/files/vcBQBUt4CG7bFFQumCjQ" alt=""><figcaption></figcaption></figure>

### Reserve Pool

Unlike most other blockchains, a block producer of KCC does not directly take any transaction fees from a block, but all the transaction fees will go to the reserve pool first. However, for each block, a fixed amount of KCS will be taken out of the reserve pool as a block reward and distributed to all the validators and stakers. The specific amount taken from the reserve pool is a global parameter governed by the foundations.

Apart from the transaction fees, anyone could donate their KCS to the reserve pool. Currently, the foundations take advantage of this feature to maintain a reasonable APY for validators and stakers to encourage early participation.

<figure><img src="/files/NHXdE2r9Y0P6pio4BJ7q" alt=""><figcaption></figcaption></figure>

### Reward Distribution

For each validator, there is a pool of KCS. The KCS in the pool has two sources: either deposited by the validator himself as a margin or staked by the users( i.e., users' votes).

In each block, the reward taken out of the reserve pool is distributed as follows:

1. The amount of reward distributed to each pool is proportional to the total amount of votes in that pool, with 1 KCS for each vote. And both the validator's margin and users' stakes are counted as votes.
2. The reward distributed to each pool is then distributed to the validator and his stakers as follows:&#x20;
   1. The validator takes part of the reward as a commission.&#x20;
   2. Then, the remaining part of the reward will be distributed to the validator and stakers. The amount distributed to each party, either the validator or a user,  is proportional to their votes.


# Apply For Running A Validator

The consensus algorithm of KCC is Proof of Staked Authority (*PoSA*), which means the stakes of a validator are not only his KCS but also his reputation. Therefore, we need to verify each validator's identity carefully.&#x20;

If you want to apply for running a validator, please check [this](https://news.kcc.io/announcement-of-the-kcc-validator-election/) for more information.&#x20;


# Manager Account And Validator Account

To run a validator node, you need two different accounts. Each of the accounts has a different role:

* Your node uses an account(i.e., a private key) for signing new blocks. We call this account the `validator account`. You can only use a Keystore file for this account.
* You can manage all your funds (margin and pending rewards) with another account. We call this account the `manager account`. You can use either a hardware wallet or [a gnosis-safe wallet](/individuals/wallet/mutisig-wallet).&#x20;

With the above setup, your funds will be safe even if the server running your node is compromised and the hacker accesses the private key of your validator account.&#x20;

### How To Generate Your Validator Account&#x20;

You can only use a Keystore file for your validator account. You generate a new Keystore file by running the following command:&#x20;

```bash
geth account new --datadir /data/.kcc 
```

{% hint style="info" %}
In [the previous section,](/developers/run-a-node) we use `--datadir` to specify the directory where all chain data are stored.  The generated Keystore file for your validator account is also in this directory.&#x20;
{% endhint %}

After running the command above, it will ask you to provide the password for your Keystore file:&#x20;

```bash
Your new account is locked with a password. Please give a password. Do not forget this password.               
Password:
```

If everything goes well, it will print the address of your validator account on the screen:&#x20;

```
Your new key was generated                                                                                     
                                                                                                               
Public address of the key:   0xa693bE057aEBeD3fEd313b661ef3cBbFfB49E95d                                        
Path of the secret key file: /data/.kcc/keystore/UTC--2022-12-07T09-37-15.362634255Z--a693be057aebed3fed313b661ef3cbbffb49e95d                                                                                        
                                                                                                               
- You can share your public address with anyone. Others need it to interact with you.                          
- You must NEVER share the secret key with anyone! The key controls access to your funds!                      
- You must BACKUP your key file! Without the key, it's impossible to access account funds!                     
- You must REMEMBER your password! Without the password, it's impossible to decrypt the key!  
```

Note that it also prints the path of your Keystore file (i.e., the secret key file). Please backup this file! &#x20;


# Run A Validator

We assume you have already created the Keystore file for your validator account following the [previous section.](/developers/run-a-node/run-a-validator-node/manager-account-and-validator-account)  You can run your validator node with the following command:&#x20;

```shell
geth --datadir /data/.kcc \
    --unlock 0x0000000000000000000000000000000000000000 \
    --password /data/.kcc/pass --mine 
```

{% hint style="info" %}
The command is similar to what we have seen in "[Run A Full Node](/developers/run-a-node/run-a-full-node)", except with some extra options:

The address after `--unlock` should be the address of your validator account. So you should replace `0x0000000000000000000000000000000000000000`  with your validator account.&#x20;

The path `/data/.kcc/pass` after `--password refers to a plain text file that contains the password of your Keystore file.`

`The --mine option tells the node try to validate and propose new blocks.`&#x20;
{% endhint %}

{% hint style="danger" %}
If you want to enable the HTTP and Websocket RPC servers on your validator node, you should never make them publicly accessible! Because that would make your validator account accessible through the RPC requests. &#x20;
{% endhint %}


# Troubleshooting

### How do I know whether my node is synchronized?&#x20;

If your node is not synchronized, you may see logs similar to the following:&#x20;

```
INFO [12-07|10:04:51.115] Imported new chain segment       .... age=10d10h
```

The `age=10d10h` part shows that this node is still processing a block from 10 days ago.&#x20;

If your node is well synchronized, you will still see logs starting with "Imported new chain segment", but there will be nothing like `age=xxx` in those lines.  &#x20;

### Why is my node stuck after restarting from crash?&#x20;

Sometimes, if your node exits unexpectedly, you may see logs like the following:&#x20;

```
WARN [12-07|10:04:51.115] Head state missing, repairing  
```

In most cases, you must wait a little longer for it to recover. If you are not running an archive node, the state in the memory is occasionally flushed to the disk. If the state in the memory is not flushed to the disk yet, an unexpected exit will cause the missing state. Don't worry. The node will try to replay some blocks and recover the state automatically.&#x20;

### Why cannot my node connect to any peers?&#x20;

If you see logs like the following, your node is not connected to any other nodes (peers):

```
INFO [12-07|10:04:51.115] Looking for peers                        peercount=0 tried=20 static=0
```

The `peercount=0` signals that your node is not connected to any other nodes. The underlying wire protocol is TCP based. You should check your network and see if it can connect to another network peer that listens on port 30303/TCP.&#x20;


# Explorer

<figure><img src="/files/9bYVQ4JvJiTcwP7HrcU5" alt=""><figcaption></figcaption></figure>

### Mainnet Explorers&#x20;

Currently, there are two explorers for the KCC mainnet:&#x20;

* <https://explorer.kcc.io/>&#x20;
  * This explorer is powered by `Tokenview`
  * If you want to interact with this explorer with RPC calls, the API reference can be found [here](https://documenter.getpostman.com/view/20873420/UyxohiZs).&#x20;
* <https://scan.kcc.io/>
  * This explorer is adapted from the popular `blockscount`. &#x20;
  * The API of this explorer can be found [here](https://scan.kcc.io/api-docs). &#x20;

### Testnet Explorers&#x20;

Currently, there is only one explorer for the KCC testnet:&#x20;

* <https://scan-testnet.kcc.network/>&#x20;
  * This explorer is adapted from the popular `blockscount`. &#x20;


# Oracles

<figure><img src="/files/MBnzWbPYThPLZkuf7zaC" alt=""><figcaption></figcaption></figure>

Blockchains and smart contracts can’t access off-chain data (outside the network). However, for many contractual arrangements, it is vital to have relevant data from the outside world to execute the agreement.

Blockchain Oracles are entities that connect blockchains to external systems, thereby enabling smart contracts to execute based on inputs and outputs from the real world. Simply put, Oracles provide a mechanism for the decentralized Web3 ecosystem to access the outside world.

**KCC Oracle**: KCC Oracle, a decentralized Web3 Oracle, is a data feed network that connects real-world data to blockchain smart contracts.

**Pyth**: Pyth delivers real-time on-chain market data. Refer [here](https://pyth.network/developers) for API Reference.

**Witnet**: Witnet enables your smart contracts to react to real-world events with strong crypto-economic guarantees. Refer [here](https://docs.witnet.io/smart-contracts/witnet-data-feeds) for API Reference.

{% content-ref url="/pages/nJJEOeTO0pViYgHt3kbq" %}
[KCC Oracle](/developers/oracles/kcc-oracle)
{% endcontent-ref %}


# KCC Oracle

## Overview

A blockchain oracle is a bridge between the blockchain and the real world. These oracles allow real-world data to enter the blockchain. This data could be anything from price information to weather reports. Oracles can also be bi-directional and "send" data out to the real world. With the sharp rise of various DeFi applications, a stable and reliable decentralized oracle service is key to premium DeFi projects. Hence, the arrival of KCC Oracle addresses the need for KCC-based smart contracts to access external data. Please read through them carefully and understand the underlying risks before using Oracle.

## Reliability

### Data Sources

KCC Oracle sources price data from multiple centralized exchanges (CEXs) and from the decentralized finance (DeFi) applications and aggregates the data using a weighted formula.

### Data Signing

KCC Oracle has two roles: transmitter and signer. The signer signs data, and the transmitter is responsible for transmitting the signed data up the chain. It is intended to make data tamper-proof and to improve the security and reliability of different roles addresses.

### Data Publishing

Publishing data to the blockchain happens through multi-nodes. Multi-nodes also ensure that those smart contracts that already store some data are secure and audited. Multi-node architecture can also adjust the frequency of data publishing based on the situation. For example, it can help you get accurate data during high price volatility.

### Data Monitoring

The data on the KCC Oracle is kept up to date by an independent monitoring service that works 24 hours a day, seven days a week. It fetches prices from different data sources and compares them to published blockchain data. And the KCC Oracle support team will intervene if a significant deviation is detected.

## API Reference

Oracle Aggregator periodically publishes valuable data to the Oracle network. The aggregator stores the aggregated data on a chain so that consumers can retrieve and use it in the same transaction. We recommend retrieving data sources through [`AggregatorV3Interface`](https://github.com/kcc-community/kcc-oracle/blob/main/contracts/interfaces/AggregatorV3Interface.sol) and proxy addresses.

### Functions

<table><thead><tr><th width="178" align="center">Name</th><th align="center">Descripition</th></tr></thead><tbody><tr><td align="center">decimals</td><td align="center">The number of decimals</td></tr><tr><td align="center">description</td><td align="center">The description of trading pairs</td></tr><tr><td align="center">getRoundData</td><td align="center">Get data from a specific round</td></tr><tr><td align="center">latestRoundData</td><td align="center">Get data from the latest round</td></tr><tr><td align="center">version</td><td align="center">Get the version of the aggregator</td></tr></tbody></table>

#### decimals

Get the number of decimals of the response

```solidity
function decimals() external view returns (uint8);
```

**Return values**

* RETURN: The number of decimals

#### description

Get the description of the aggregator

```solidity
function description() external view returns (string memory);
```

**Return values**

* RETURN: The description of trading pairs

#### getRoundData

Get the round data details for a given round ID

```solidity
function getRoundData(uint80 _roundId)
  external
  view
  returns (
    uint80 roundId,
    int256 answer,
    uint256 startedAt,
    uint256 updatedAt,
    uint80 answeredInRound
  );
```

**Parameters**

* \_roundId: The round ID

**Return values**

* roundId: The round ID
* answer: The answer for this round
* startedAt: Timestamp of when the round started
* updatedAt: Timestamp of when the round was updated
* answeredInRound: The round ID in which the answer was computed

#### latestRoundData

Get the price from the latest round

```solidity
function latestRoundData() external view
    returns (
        uint80 roundId,
        int256 answer,
        uint256 startedAt,
        uint256 updatedAt,
        uint80 answeredInRound
    );
```

**Return values**

* roundId: The round ID
* answer: The price
* startedAt: Timestamp of when the round started
* updatedAt: Timestamp of when the round was updated
* answeredInRound: The round ID of the round in which the answer was computed

#### version

Get the version of the aggregator

```solidity
function version() external view returns (uint256);
```

**Return values**

* RETURN: The version of the aggregator

## Contract Address

**KCC Mainnet Feed addresses**

<table><thead><tr><th width="153" align="center">Pair (Base/Quote)</th><th width="107" align="center">Decimals	</th><th width="112" align="center">Deviation</th><th width="116" align="center">Heartbeat</th><th width="199" align="center">Data Feed Contract (Proxy Address)</th></tr></thead><tbody><tr><td align="center">BTC/USD</td><td align="center">8</td><td align="center">0.2%</td><td align="center">2m</td><td align="center"><mark style="color:green;">0xFAce3f85602A8dc013217b61a97a9AFE7B2F276F</mark></td></tr><tr><td align="center">ETH/USD</td><td align="center">8</td><td align="center">0.2%</td><td align="center">2m</td><td align="center"><mark style="color:green;">0x72E10386eBE0E3175f62BF3Edfc9A64aC3c5918a</mark></td></tr><tr><td align="center">KCS/USD</td><td align="center">8</td><td align="center">0.2%</td><td align="center">20m</td><td align="center"><mark style="color:green;">0xAFC9c849b1a784955908d91EE43A3203fBC1f950</mark></td></tr><tr><td align="center">SKCS/USD</td><td align="center">8</td><td align="center">0.2%</td><td align="center">20m</td><td align="center"><mark style="color:green;">0xdB4b34b3Fc38D828DFE5D9D34CcF0f5f15c09684</mark></td></tr><tr><td align="center">USDT/USD</td><td align="center">8</td><td align="center">0.1%</td><td align="center">30m</td><td align="center"><mark style="color:green;">0x001c1a168ba2a36D01a99542740C375c51615161</mark></td></tr><tr><td align="center">USDC/USD</td><td align="center">8</td><td align="center">0.1%</td><td align="center">30m</td><td align="center"><mark style="color:green;">0x1A165db46d431804B0082eb5BEbc307ffb97e31b</mark></td></tr></tbody></table>

**KCC Testnet Feed addresses**

<table><thead><tr><th width="142" align="center">Pair (Base/Quote)</th><th width="106" align="center">Decimals	</th><th width="114" align="center">Deviation</th><th width="122" align="center">Heartbeat</th><th align="center">Data Feed Contract (Proxy Address)</th></tr></thead><tbody><tr><td align="center">BTC/USD</td><td align="center">8</td><td align="center">0.2%</td><td align="center">2m</td><td align="center">0xBb3423a913a9a69aD7Dba09B62abdFDE4643BAe4</td></tr><tr><td align="center">ETH/USD</td><td align="center">8</td><td align="center">0.2%</td><td align="center">2m</td><td align="center">0x22337a9a305E081c0C801dd7B7b8eCF4966660bB</td></tr><tr><td align="center">KCS/USD</td><td align="center">8</td><td align="center">0.2%</td><td align="center">20m</td><td align="center">0xae3DB39196012a7bF6D38737192F260cdFE1E7Ec</td></tr><tr><td align="center">SKCS/USD</td><td align="center">8</td><td align="center">0.2%</td><td align="center">20m</td><td align="center">0xAAf1A426D4b5D57c55E67f6eCc2918c698D94359</td></tr><tr><td align="center">USDT/USD</td><td align="center">8</td><td align="center">0.1%</td><td align="center">30m</td><td align="center">0x2bE470B8BD3CF5655dcC666CDe37E3E4D6cf3168</td></tr><tr><td align="center">USDC/USD</td><td align="center">8</td><td align="center">0.1%</td><td align="center">30m</td><td align="center">0x91b66dAd926FaC824da9390D1aF6f68db391A5c0</td></tr></tbody></table>


# Bridge

<figure><img src="/files/gDLiKhaNocrEEIPiqNeP" alt=""><figcaption></figcaption></figure>

### The KCC Bridge&#x20;

The [KCC Bridge](https://www.kcc.io/bridge/transfer/) is a multi-chain bridge that helps you transfer assets between different chains. Currently, you can transfer your assets from Ethereum, Binance chain, Polygon, Fantom, or Avalanche to KCC.  Besides, you can also transfer your assets back from KCC to the original chains.&#x20;

Let's take an example to see how KCC Bridge works. We assume that you want to transfer your ETH from Ethereum to KCC. First, you deposit your ETH on the source chain (Ethereum). You deposit your ETH by interacting with the Bridge contract on Ethereum:&#x20;

<figure><img src="/files/gnrezO8ZdxD0zX5qqtD5" alt=""><figcaption></figcaption></figure>

A few Bridge operators will independently watch the deposit events emitted from the Bridge contract on Ethereum.

<figure><img src="/files/BDoM9IFrOyxClyoHSfDx" alt=""><figcaption></figcaption></figure>

Each operator will independently verify the validity of the deposit transaction. If the transaction passes all the checks, each operator will initiate a  "withdraw Token"  transaction on KCC:&#x20;

<figure><img src="/files/3Gu9ZCzQNcsULP4k26s8" alt=""><figcaption></figcaption></figure>

If more than the required (currently at least two) number of operators have initiated  "Withdraw Token" transactions, the last operator's transaction will trigger the minting process: The corresponding amount of Pegged-ETH will be minted to the user.&#x20;

If a user wants to transfer his ETH from KCC back to Ethereum. The reverse of the above would happen: The user will burn his Pegged-ETH through the Bridge contract on KCC, and then the operators will help to release his ETH locked in the Bridge contract on Ethereum.&#x20;

The KCC Bridge Smart Contracts are open-sourced. You can find them on GitHub:&#x20;

* [KCC-Peg-Token](https://github.com/kcc-community/kcc-peg-token)
* [KCC-Bridge-Contract](https://github.com/kcc-community/bridge-contract)

And you can also find a complete list of all the deployed contracts on each chain [here](https://github.com/kcc-community/bridge-contract#readme).  &#x20;


# Dev Toolkit

<figure><img src="/files/UhK921fpFtL4CG4u3P94" alt=""><figcaption></figcaption></figure>

### KCC Related Links

<table><thead><tr><th width="207">Name</th><th width="296.3333333333333">Link</th><th> Description</th></tr></thead><tbody><tr><td>Testnet Faucet</td><td><a href="https://faucet-testnet.kcc.network/">https://faucet-testnet.kcc.network/</a></td><td>Claim testnet token on KCC</td></tr><tr><td>Mainnet Faucet</td><td><a href="https://faucet.kcc.io/">https://faucet.kcc.io/</a></td><td>Claim mainnet KCS </td></tr><tr><td>KCC Bridge</td><td><a href="https://www.kcc.io/bridge/transfer">https://www.kcc.io/bridge/transfer</a></td><td>Bridge tokens from and to KCC</td></tr><tr><td>Gnosis Safe for KCC</td><td><a href="https://safe.kcc.io/">https://safe.kcc.io/</a></td><td>MultiSig Wallet on KCC</td></tr><tr><td>Node Client Repo</td><td><a href="https://github.com/kcc-community/kcc">https://github.com/kcc-community/kcc</a></td><td>The git repository for the KCC node client</td></tr><tr><td>Oracle Repo</td><td><a href="https://github.com/kcc-community/kcc-oracle">https://github.com/kcc-community/kcc-oracle</a></td><td>The git repository for the KCC Oracle</td></tr><tr><td>KCC Staking</td><td><a href="https://staking.kcc.io/">https://staking.kcc.io/</a></td><td>The KCC Staking App</td></tr></tbody></table>

### Other Links For Developers&#x20;

| Name                   | Link                                                                          | Description                                                                         |
| ---------------------- | ----------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
| Openzeppelin Contracts | <https://docs.openzeppelin.com/contracts/>                                    | The documentation of Openzepplin contracts                                          |
| Hardhat doc            | <https://hardhat.org/hardhat-runner/docs/getting-started#overview>            | The official documentation of hardhat                                               |
| Foundry Book           | <https://book.getfoundry.sh/>                                                 | A great book for learning foundry                                                   |
| evm.codes              | <https://www.evm.codes/?fork=berlin>                                          | An tool for learning EVM opcodes                                                    |
| Debank                 | <https://debank.com/>                                                         | A multi-chain portfolio tracker that supports the largest number of DeFi protocols. |
| Solidity Documentation | [https://docs.soliditylang.org/en](https://docs.soliditylang.org/en/v0.8.17/) | The official documentation of solidity                                              |


# Data


# Indexing and Querying


# The Graph

## Overview

The Graph, a decentralized protocol for indexing and querying chain data, supports the KCC network. Data defined by subgraphs is easy to query and explore. You may create subgraphs locally or use a free hosted explorer for indexing and displaying data.

## Steps

### Install the Graph CLI <a href="#id-1-install-the-graph-cli" id="id-1-install-the-graph-cli"></a>

The Graph CLI is written in JavaScript and you will need to have either `npm` or `yarn` installed to use it.

```
# NPM
$ npm install -g @graphprotocol/graph-cli

# Yarn
$ yarn global add @graphprotocol/graph-cli

```

### Initialize your Subgraph <a href="#id-2-initialize-your-subgraph" id="id-2-initialize-your-subgraph"></a>

The following command creates a subgraph that indexes all events of an existing contract. It attempts to fetch the contract ABI from BlockScout and returns to requesting a local file path. If any optional arguments are missing, it takes you through an interactive form.

```
graph init \
  --from-contract <CONTRACT_ADDRESS> \
  [--network ethereum ] \
  [--abi <FILE>] \
  <GITHUB_USER>/<SUBGRAPH_NAME> [<DIRECTORY>]

--network: choose “ethereum” both for KCC mainnet and KCC Testnet.
--from-contract <CONTRACT_ADDRESS> is the address of your existing contract which you have deployed on the KCC network: Testnet or Mainnet.
--abi <FILE> is a local path to a contract ABI file (optional, If verified in BlockScout, the graph will grab the ABI, otherwise you will need to manually add the ABI. You can save the abi from BlockScout or by running truffle compile or solc on a public project.)
The <GITHUB_USER> is your github user or organization name, <SUBGRAPH_NAME> is the name for your subgraph, and <DIRECTORY> is the optional name of the directory where graph init will put the example subgraph manifest.
```

Your subgraph slug is an identifier for your subgraph. The CLI tool will walk you through creating a subgraph, such as a contract address, network, etc., as shown in the screenshot below.

### Write your Subgraph <a href="#id-3-write-your-subgraph" id="id-3-write-your-subgraph"></a>

The previous commands create a scaffold subgraph that you can use as a starting point for building your subgraph. When making changes to the subgraph, you will mainly work with three files:

* Manifest (`subgraph.yaml`) - The manifest defines what data sources your subgraphs will index.
* Schema (`schema.graphql`) - The GraphQL schema defines what data you wish to retrieve from the subgraph.
* AssemblyScript Mappings (`mapping.ts`) - This code translates data from your data sources to the entities defined in the schema.

For more information on how to write your subgraph, see [Creating a Subgraph](https://thegraph.com/docs/en/developing/creating-a-subgraph/).

### Authenticate with the hosted service(if you have)

```
graph auth https://api.thegraph.com/deploy/ <your-access-token>
```

You can find the access token by going to your dashboard on the graph website.

* cd to the directory you created and started defining the subgraph. Information on creating a subgraph is available in the Graph Docs here. <https://thegraph.com/docs/define-a-subgraph>
* When you are ready, deploy your subgraph. You can always test and redeploy as needed.

> If your previously deployed subgraph is still in status Syncing, it will be immediately replaced with the newly deployed version. If the previously deployed subgraph is already fully synced, Graph Node will mark the newly deployed version as the Pending Version, sync it in the background, and only replace the currently deployed version with the new one once syncing the new version has finished. This ensures that you have a subgraph to work with while the new version is syncing.

```
yarn deploy
```

Your subgraph will be deployed and can be accessed from your dashboard.

You can learn about querying the subgraph here: <https://thegraph.com/docs/query-the-graph#using-the-graph-explorer>

If you want to make your subgraph public, you can do so by accessing your subgraph from your dashboard and then click on edit button. You will see the slider at the bottom of edit page.


# Using KCC's hosted subgraph

To make building applications easier for the KCC community developers, we have also provided some graph services to make development easier. We recommend, however, that you deploy the graph service separately from your application for better performance and service.

```
https://thegraph.kcc.network/deploy/
https://thegraph.kcc.network/ipfs/
https://thegraph.kcc.network/subgraphs/name/


// sample
"auth": "graph auth https://thegraph.kcc.network/deploy/ your-token"
"create": "graph create your-name --node https://thegraph.kcc.network/deploy/"
"deploy": "graph deploy your-name --ipfs https://thegraph.kcc.network/ipfs/ --node https://thegraph.kcc.network/deploy/"
"explorer": "https://thegraph.kcc.network/subgraphs/name/your-name"
```

To use the service, please fill out the online [**form**](https://forms.office.com/pages/responsepage.aspx?id=S3jy9rFT20yX1qylChjn8-DS3wXi_TFHkWLpe9Vi-NVUMzY4R0VEV0ZDV0pKVUNUMDI0MTdXU1hRNiQlQCN0PWcu) if you need it.


# Gas Revenue Program

<figure><img src="/files/OKaukbjofCgQ5xqYWNho" alt=""><figcaption></figcaption></figure>

## What is KCC Gas Revenue Program

[KCC Gas Revenue Program](https://kcc.io/gas-revenue) is the implementation of the KCC Ecosystem Incentive Program, which supports gas refunds to the KCC contract deployers (Gas here refers to the gas fee spent by the user when using the protocol ). Gas Revenue will lower the operation cost of KCC on-chain projects and encourage more developers to deploy contracts on KCC.

### The Influence of Gas Revenue Program on KCC Participant

<figure><img src="/files/kQjdp75WvVkMlUlWKddr" alt=""><figcaption></figcaption></figure>

*Note: The KCC Gas Revenue Program will not affect other participants on the chain, such as users and validators, and the fees returned to developers will be sponsored by the KCS Management Foundation.*

{% content-ref url="/pages/5aAYTAHgeMChd4Jo9Ti3" %}
[Rules for Calculation of Gas Revenue](/developers/gas-revenue-program/rules-for-calculation-of-gas-revenue)
{% endcontent-ref %}


# Rules for Calculation of Gas Revenue

1\. The KCC team will calculate the project gas revenue ratio according to the comprehensive dimensions of the registered projects.

**The gas revenue ratio = the rating of the project track + the rating of the project's development + the rating of length of the deployment+ the rating of the interaction data generated by the project.**

*\*Reference materials (the content attached below is for reference only, subject to the final publicized version of KCC, and the KCC team has the right to dynamically adjust the rating standards in the future according to the actual situation)*

**Track Rating:**

<figure><img src="https://lh4.googleusercontent.com/slPFwnEgG-KYKT46ad6UfeYrla_rg8q_EwJD1eHLg5eEOSktFU9cN9otDur09x2kPBKAmNIPGKmucxjCu9kEf9uE0EI2IuNBKNiLJUnMyBPzJwxc5v-4IMhTfA-k5F_8LKhT_7HQxk2i9DIuJsJ77So" alt=""><figcaption></figcaption></figure>

**Project Development:**

<figure><img src="https://lh3.googleusercontent.com/zkOU0YhvwOKPhOkeC1oS3XIPhRsqc96sOWmlh0cn0dujRbbZYEVwiQf3ws8bHvNFNdpSyu1pkqIL0sWr7j98Bcu6TrXZquPLzWB-EnK5pkPfhx4UJ85nS1VLSOrtM9Ep2Ve1OJ8DKBO-lRtwbPWUZRw" alt=""><figcaption></figcaption></figure>

**Developed Month:**

<figure><img src="https://lh6.googleusercontent.com/Iex5H1VUZ4N4ieAZa614vxCCAngsMi0VmoEEHOpu6X5m4349QII7YotdY4wCZFj-2WIzgaV5YOguijMABi5YX7jKXZShI5Q4jd4WKqwvnK5UYWV0OcbELPCLMPHk-rkGnolFGHIercx35HwF4vs_ELk" alt=""><figcaption></figcaption></figure>

**Contract Interaction Number Ranked:**

<figure><img src="https://lh6.googleusercontent.com/e4sfS4l-fV9fniSmAHB9fBuRIMKxk0W0gMdha4dC6824jtxDwQNf4yLn4QmSYcqy1GOokT8chEYE1UNdRtNPo4aAVtsl9YxXh-0r2Zk0u3NEERo3mU4DkdC2zwAEiGSfkh2UvVJNa8ZzGcq7dgae3zI" alt=""><figcaption></figcaption></figure>

**The Ratio of Different Ratings:**

<figure><img src="https://lh4.googleusercontent.com/SSh17TVMUbpnmnSfc_sWElFq9Lpt4jKPHaPpyBY7is2jFzWdPuQ41HtajlDzN5d2b09KUwLN56bvs4JlRZ_vglI4aDshJyVVD9JXHrsInEWbJFPnOfDANtRW9s06K5A6Kc_cgDr_vvPixkBN-pcfArE" alt=""><figcaption></figcaption></figure>

2\. The KCC team will divide the gas fee for the successfully registered projects on a monthly basis.&#x20;

Eg: If Project A signs up for the KCC Gas Revenue Program on April 10 and completes the review on April 12, and the refund rate is 100%. Then Project A will receive 100% of the gas generated from April 12 to April 30 in May.

3\. The KCC team will adjust the monthly rating of the registered projects according to the actual situation.

{% content-ref url="/pages/sTPEi67vRN8ughqqVZTn" %}
[How to Join the KCC Gas Revenue Program](/developers/gas-revenue-program/how-to-join-the-kcc-gas-revenue-program)
{% endcontent-ref %}


# How to Join the KCC Gas Revenue Program

All projects deployed on KCC can register to the KCC Gas Revenue Program. The required steps are as follows:

1. Visit the registration link of the [KCC Gas Revenue Program](https://kcc.io/gas-revenue)
2. Fill in the required project information on page
3. Finish the Google CAPTCHA
4. The KCC team will contact you within 5 working days and complete the project review within 7 working days.

[Register for the KCC Gas Revenue Program ](https://kcc.io/gas-revenue)


# Wallet

<figure><img src="/files/KCpwoARf3kyBfMEnUGia" alt=""><figcaption></figcaption></figure>

When investing in cryptocurrency, users need to use wallets as storage for saving their crypto assets. KCC supports mostly decentralized wallets and users can choose the right one for their required security and convenience.

Also, if you want to send, receive, buy, and exchange tokens on KCC, you need to create a wallet and configure the network first.&#x20;

{% content-ref url="/pages/Vc6f4r6eabxHNK4JGiST" %}
[Supported Wallet](/individuals/wallet/supported-wallet)
{% endcontent-ref %}

{% content-ref url="/pages/f6AXQW1yF1Nio3GCz3Qs" %}
[Tutorial on how to set up wallet](/individuals/wallet/tutorial-on-how-to-set-up-wallet)
{% endcontent-ref %}

{% content-ref url="/pages/MLEKum1lUpsnmTzfxgm5" %}
[Mutisig Wallet](/individuals/wallet/mutisig-wallet)
{% endcontent-ref %}


# Supported Wallet

Below we provide a list of the most popular wallets that support the KCC Network.

### Supported Wallet

<table><thead><tr><th>No</th><th>Wallet</th><th width="305.3333333333333">Official Website</th></tr></thead><tbody><tr><td>1</td><td>Metamask</td><td><a href="https://metamask.io/">https://metamask.io/</a></td></tr><tr><td>2</td><td>Halo Wallet</td><td><a href="https://halo.social/">https://halo.social/</a></td></tr><tr><td>3</td><td>Coinhub</td><td><a href="https://www.coinhub.org/">https://www.coinhub.org/</a></td></tr><tr><td>4</td><td>Trust Wallet</td><td><a href="https://trustwallet.com/">https://trustwallet.com/</a></td></tr><tr><td>5</td><td>SafePal</td><td><a href="https://safepal.io/">https://safepal.io/</a></td></tr><tr><td>6</td><td>TokenPocket</td><td><a href="htttps://www.tokenpocket.pro/">htttps://www.tokenpocket.pro/</a></td></tr><tr><td>7</td><td>Inifinity Wallet</td><td><a href="http://infinitywallet.io/">https://infinitywallet.io/</a></td></tr><tr><td>8</td><td>Ambire Wallet</td><td><a href="https://www.ambire.com/">https://www.ambire.com/</a></td></tr><tr><td>9</td><td>D’CENT Wallet</td><td><a href="https://dcentwallet.com/">https://dcentwallet.com/</a></td></tr><tr><td>10</td><td>Nabox</td><td><a href="https://nabox.io/">https://nabox.io/</a></td></tr><tr><td>11</td><td>FoxWallet</td><td><a href="https://foxwallet.com/">https://foxwallet.com/</a></td></tr><tr><td>12</td><td>Coin98</td><td><a href="https://coin98.com/">https://coin98.com/</a></td></tr><tr><td>13</td><td>Befi Wallet</td><td><a href="https://befiwallet.io/">https://befiwallet.io/</a></td></tr><tr><td>14</td><td>Math Wallet</td><td><a href="https://mathwallet.org/">https://mathwallet.org/</a></td></tr><tr><td>15</td><td>Rabby Wallet</td><td><a href="https://rabby.io/">https://rabby.io/</a></td></tr></tbody></table>

If you are new to wallet, don’t worry! We prepared some tutorials on how to set up KCC wallets in the next chapter.


# Tutorial on how to set up wallet

In order to make users easy to use wallet, we take Metamask as an example to show how to set up a wallet and connect with KCC.

### What is Metamask

[Metamask](https://metamask.io/) is one of the leading crypto wallets and it has a browser extension and a mobile app crypto wallet for accessing both KCC as well as other blockchains, such as Ethereum and Polygon. It is perfect for being used as a beginner wallet because it provides access to nearly all dapps and allows users to make transitions and interact with smart contracts with ease.

### Use Metamask for KCC

**If you are going to use the wallet on the web, you should install MetaMask for Chrome first.**

1\. Visit Metamask's[ official website](https://metamask.io/) and click the “Download for chrome” button

<figure><img src="/files/SLpVN27zb6aqfQJNWCfP" alt=""><figcaption></figcaption></figure>

2\. Click on “Add to Chrome" and you have successfully installed the MetaMask extension in Brave!

<figure><img src="/files/lhDYwHLlL9CTPkMJQ39T" alt=""><figcaption></figcaption></figure>

**Then, you can create an account in MetaMask**

1\. Click “Create a Wallet”.

<figure><img src="/files/3WRgzGPuySacpekYmmft" alt=""><figcaption></figcaption></figure>

2\. In this step, you need to create a minimum of 8 characters password for accessing your wallet.

![](/files/6ZPzGSNKJJQbpYve32s2)

3\. After creating your password, please watch this video to learn about your secret recovery phrase and how to keep your MetaMask wallet safe and secure.

![](/files/JwwKwgBMBHN48bx4hYkO)

4\. This page shows 12 recovery phrases for your wallet. You can memorize it or take a note and store it in a very safe place, and the most important thing is don’t share your secret recovery phrase with anyone.

Note: Without these recovery phrases, your wallet can’t be recovered if your device got damaged or lost.

![](/files/xUQRxNjHaObD9F1OT0Ch)

5\. Select each phrase in order to make sure it is correct then click “Confirm”.

![](/files/cnqrOGHu0IVgHUSOtF4V)

All done! Now you have your MetaMask Wallet!

<img src="/files/8tWTZMjrZ7z0dydX7TZF" alt="" data-size="original">

**How To Import Tokens?**

1\. Open your Metamask extension in your browser and click "Import tokens".

<img src="/files/gGgTiDQ7DTevZ5f0MTqZ" alt="" data-size="original">

2\. Copy the token contract address you want to import. And here are the main peg token' contracts on KCC mainnet.

| Name | Contract                                   |
| ---- | ------------------------------------------ |
| BTC  | 0xc654aff6cb2350eb0af234621f82beee648ea98b |
| ETH  | 0xf55af137a98607f7ed2efefa4cd2dfe70e4253b1 |
| USDT | 0x0039f574ee5cc39bdd162e9a88e3eb1f111baf48 |
| USDC | 0x980a5afef3d17ad98635f6c5aebcbaeded3c3430 |

You can check more token contracts here:&#x20;

{% embed url="<https://explorer.kcc.io/en/tokenlist?token=krc20>" %}

{% embed url="<https://github.com/kcc-community/kcc-peg-token#mainnet>" %}

3\. Take USDC as an example.&#x20;

Enter the contract address and the token symbol will auto-filled. When you confirm the content is right you can click the "Add custom token" button.

<img src="/files/zSJzGACpYBiagawEg4mI" alt="" data-size="original">

4\. In the last, you only need to tap the "Import tokens" button and you can see this token in your KCC wallet.

![](/files/BuMefq8zk8qxlGOUfbFJ)


# Mutisig Wallet

The most popular and trusted mutlisig wallet is Gnosis Safe. Gnosis Safe on KCC can be found here: <https://safe.kcc.io/welcome> .&#x20;

The following tutorials will give you a quick overview of how to use Gnosis Safe on KCC:&#x20;

{% content-ref url="/pages/pkcfict7GaUg3RUx10Ma" %}
[Create New Safe](/individuals/wallet/mutisig-wallet/create-new-safe)
{% endcontent-ref %}

{% content-ref url="/pages/pGSlNs7jBLD84of632T0" %}
[Send KCS From Your Safe](/individuals/wallet/mutisig-wallet/send-kcs-from-your-safe)
{% endcontent-ref %}

{% content-ref url="/pages/Oh6ykwNmlexu4L0re3vd" %}
[Use A DApp With Your Safe](/individuals/wallet/mutisig-wallet/use-a-dapp-with-your-safe)
{% endcontent-ref %}


# Create New Safe

A Safe is a smart contract wallet that multiple parties control. Creating a safe is quite straightforward.&#x20;

Go to <https://safe.kcc.io/welcome> in your browser, and you will see the following page:&#x20;

<figure><img src="/files/ljEvKKLP9u6HZersS0Yr" alt=""><figcaption></figcaption></figure>

Click the big green "Create new Safe" button, and you will be directed to the following page:&#x20;

<figure><img src="/files/hMiPDeWKbMDC0U0tfyfm" alt=""><figcaption></figcaption></figure>

Click the green "Connect" button, then select your wallet:&#x20;

<figure><img src="/files/1aEHP5QrlUVihXsGhjzW" alt=""><figcaption></figcaption></figure>

Let's take matamask as an example. After clicking the "MetaMask" logo, your metamask will pop up a window and ask you to confirm the connection to Gnosis Safe: &#x20;

![](/files/xpPcbiqvU5SoQcDS915G)

Select the wallet your want to use, then click "Next". You will see the following page:&#x20;

<figure><img src="/files/K8rCS2QrIycUQAvz3xwx" alt=""><figcaption></figcaption></figure>

Click the green "Continue" button, and the page will ask for the name of your safe. Let's name it "my-first-safe". Input your name in the blank and then click the green "Continue" button:&#x20;

<figure><img src="/files/xSYjF3JBpD0J7WrSy87O" alt=""><figcaption></figcaption></figure>

Now,  it comes to the most interesting part: set the owners of your Safe. You can add as many owners as you want by clicking the "+ Add another owner" button. In this example, I have added two more addresses (one starting with 0xDa05, another starting with 0x0508 ) as the owners of my safe.&#x20;

{% hint style="info" %}
The first owner of the safe is always your account.
{% endhint %}

{% hint style="info" %}
You can also give each owner a name by inputting a name in the blank before the owner's address.&#x20;
{% endhint %}

<figure><img src="/files/EwiPli3YwTXoxQDMJC8c" alt=""><figcaption></figcaption></figure>

Before clicking the green "Continue" button, we must choose the confirmation policy of the safe. In this example, I choose "2", which means any transaction from this safe must be confirmed by two of the owners (this safe has three owners in total). &#x20;

{% hint style="danger" %}
Our safe has three owners in total. If you choose "3" for the confirmation policy and even one of the owners cannot access his personal wallet (i.e., metamask/ledger, etc.), you can not access your safe anymore! Therefore, people usually use a number smaller than the total number of owners for the confirmation policy. For example, use "4" on a safe with 6 owners.
{% endhint %}

<figure><img src="/files/oiVF4CZsnta9rs8XKbWO" alt=""><figcaption></figcaption></figure>

After clicking the green "Continue" button, we come to the last part:&#x20;

<figure><img src="/files/GF55UGnsKOtry7Bkg3Dk" alt=""><figcaption></figcaption></figure>

You are asked to review all the setups. If everything is as expected, you can click the "Create" button to create your Safe on chain. Your metamask will pop up and ask you to confirm a transaction. This will cost you some KCS for paying the transaction fee.&#x20;

If everything works very well, you will see the following page:&#x20;

<figure><img src="/files/JvaJx9Yd45CSlmh6GjJi" alt=""><figcaption></figcaption></figure>

Let's click the green "Get Started" button. Bravo! That is your first Safe on KCC:&#x20;

<figure><img src="/files/kpxMNBIozE7vmiXk7t2G" alt=""><figcaption></figcaption></figure>

You can bookmark the link of the page above, or you can remember the address of your Safe:&#x20;

<figure><img src="/files/IV4qsjZCX76AQD4fg8us" alt=""><figcaption></figcaption></figure>


# Send KCS From Your Safe

In the [previous section](/individuals/wallet/mutisig-wallet/create-new-safe),  we created a new Safe. In this tutorial, we will deposit some KCS to your Safe and send KCS from the Safe.&#x20;

### Deposit KCS To Your Safe&#x20;

If you want to deposit KCS to your Safe, you can directly send KCS to your Safe's address, just as you send KCS to an ordinary user's address (i.e., EOA).  Besides, you can click the "Assets" entry on the left:&#x20;

<figure><img src="/files/9PxMKZ2gk1FlBIQPt6Zh" alt=""><figcaption></figcaption></figure>

The resulting page will show all the assets in your Safe. If you hover your mouse on the KCS line, you will see a "Send" and a "Receive" button. Let's click the "Receive" button:&#x20;

<figure><img src="/files/082GvO0GUP3Paa2AA53G" alt=""><figcaption></figcaption></figure>

You will see a QR code, which you can scan with the wallet on your phone. And the address of your Safe is also on the pop-up window. Let's click the copy button beside your Safe's address:&#x20;

<img src="/files/8ZiDTKaddyixEWRUxBlJ" alt="" data-size="original">

In this example, we will use metamask to send 0.2 KCS to our Safe.  First, Open your metamask and click the "Send" button:&#x20;

![](/files/kY5EmkGjrjAjI7Atcdg5)

Then, paste your Safe's address in the blank.&#x20;

![](/files/Ocm4xoDn1JZ10UOQC004)

{% hint style="danger" %}
Please make sure your metamask is connecting to the KCC network. Remember!!! You can only use your Safe on KCC. There is no way to recover your fund that is accidentally sent to the same address on another chain.&#x20;
{% endhint %}

{% hint style="info" %}
If you copy the address / scan the QR code from the pop-up window when you click the "Receive" button, the address will have a prefix of "KCC:". You need to manually remove it after ensuring that you are connecting to the KCC network.&#x20;
{% endhint %}

If you have a "KCC:" prefix in your address, you need to remove it manually. After that, you can input the amount of KCS you want to send. In this example, we will send 0.2 KCS to our Safe:&#x20;

![](/files/Qr4oo9R9ouO2A03uTHhy)

After confirming the transaction, let's go back to our Safe's page.  You will find 0.2 KCS in your Safe: &#x20;

<figure><img src="/files/7RiRbuPiZmo1lASd85cq" alt=""><figcaption></figcaption></figure>

### Send KCS From Your Safe&#x20;

Our Safe has three owners, and every transaction should be confirmed by two of all owners. Sending KCS from our Safe includes the following steps:&#x20;

1. One of the owners proposes the transaction for sending KCS. Because this owner proposed the transaction, the transaction has already been confirmed by him.  (Confirmation from the first owner)
2. We need another owner to confirm the same transaction.  (Confirmation from the second owner)
3. If we have two owners who have confirmed the transaction, the transaction can be executed.&#x20;

Let's first propose a transaction. We first go back to the page of our Safe and click the "New Transaction" button on the left:&#x20;

<figure><img src="/files/enpiggmEKq0TUjeB5xKv" alt=""><figcaption></figcaption></figure>

Then, click the "Send funds" button. You will see a new pop-up window. Input the address of your recipient, select the asset to send, and input the amount to send.&#x20;

![](/files/5g9n5MMj1xqSdQr5Kkb5)

If you have filled in all the required blanks, the "Review" button will become clickable:&#x20;

![](/files/LyOkZLGGS3AQCj3kHGhC)

After clicking the "Review" button, you will be asked to review the transaction:&#x20;

![](/files/zqCmztwN2fpRswCsspBv)

If you are happy with all the details, click the "Submit" button. Your metamask would pop up a window and ask you to sign a message:&#x20;

![](/files/biLdM0UJDTFuguj7ivXf)

Scroll down to the end of the message, the "Sign" button will become clickable. Click it and sign the transaction:&#x20;

![](/files/Ci2y9EjYaRgukkvERuLO)

If everything works well, you will see the following page:&#x20;

<figure><img src="/files/fxDR94kNt1dhRhauMr5e" alt=""><figcaption></figcaption></figure>

Note that the proposer already confirms the transaction. We need only one more confirmation from another owner. &#x20;

Now, you can send the link to the above page to another owner.&#x20;

{% hint style="info" %}
If the account of another owner is also in your metamask, you can switch to that account in your metamask.&#x20;
{% endhint %}

Open the above page and connect with the account of another owner, you will see that the "Confirm" button becomes clickable:&#x20;

<figure><img src="/files/5uagEZmjihtlQ3JkbapO" alt=""><figcaption></figcaption></figure>

Click the "Confirm" button, and you will see a pop-up window as follows:&#x20;

![](/files/ajgJ1cBry6PFQbj8czWJ)

If you check the "Execute transaction" option, you will not only confirm the transaction but also execute it. However, executing a transaction would cost you some KCS. If you don't have any KCS in this owner's account, you can uncheck this option:&#x20;

![](/files/cdo7gDsboGFRY9K6UI90)

Without checking the "Execute transaction" option,  we will only confirm the transaction but not execute it.  Let's click the "Submit" button.  Again, a metamask window will pop up, and you confirm the transaction by clicking the "Sign" button.  After that, the transaction is confirmed by two of the owners. So, we can execute it:&#x20;

<figure><img src="/files/8dVU0TfkbewRZeSTvKNM" alt=""><figcaption></figcaption></figure>

Now, any owner can connect their wallet and click the "Execute" button. And your metamask will pop up a window and ask you to send a transaction. In this transaction, 0.1 KCS will be transferred out from your Safe. &#x20;

If everything works well, the status of your transaction will become "Executed":&#x20;

<figure><img src="/files/n1AqjA9pJDH9C7SmzINn" alt=""><figcaption></figcaption></figure>


# Use A DApp With Your Safe

Let's first go to the page of your Safe. You will see some supported dApps at the bottom of the page.

<figure><img src="/files/zGEyCpeX2utbuo7KdXs1" alt=""><figcaption></figcaption></figure>

In this tutorial, we will swap KCS for MJT on Mojitoswap with our Safe.  Let's click the MojitoSwap logo. After that, you will see the Mojitoswap app embedded in your Safe's page:&#x20;

<figure><img src="/files/nUeVPMYvafgB4gvLwBFw" alt=""><figcaption></figcaption></figure>

Note the MojitoSwap shows that you are connecting with your Safe's account.&#x20;

When you confirm the swap in MojitoSwap, you will see a pop-up window as follows:&#x20;

<figure><img src="/files/nNKj2yIqltWTAG2HNDFf" alt=""><figcaption></figcaption></figure>

Let's click the "Submit" button. Then your metamask will pop up a window and ask you to sign a message.&#x20;

![](/files/tkKp4QQovkSPMpWGUrst)

After signing the transaction, click the "transactions" entry on the left of your Safe's page:&#x20;

<figure><img src="/files/oSKM0CWdkqeG3yvEbJOP" alt=""><figcaption></figcaption></figure>

There will be a transaction in the queue. This is the transaction you have just proposed.&#x20;

<figure><img src="/files/eECGAzlhjOy7CXaD9mXe" alt=""><figcaption></figcaption></figure>

After being confirmed by one more owner of the Safe, the transaction can be executed.&#x20;

{% hint style="info" %}
If you don't know to confirm and execute a proposed transaction, please check the previous section:  [Send KCS From Your Safe](/individuals/wallet/mutisig-wallet/send-kcs-from-your-safe)
{% endhint %}

If everything goes well, you will find the resulting MJT token in your Safe:&#x20;

<figure><img src="/files/FxIrZ8EKoYxPqJCYFA1Q" alt=""><figcaption></figcaption></figure>

{% hint style="warning" %}
Every transaction on MojitoSwap has a deadline. If you have to wait for a very long time until the other owner can confirm a transaction, your MojitoSwap transaction may be out of date. Besides, the price on MojitoSwap may also change when you wait for the other owner to confirm. Nevertheless, you can work around this by using a longer deadline and a greater slippage tolerance:&#x20;

<img src="/files/iIjDAhgGrf821Kh93oK9" alt="" data-size="original">
{% endhint %}


# Network Configuration


# Configure Value

<figure><img src="/files/Qisd0Yak2DFxXZF4jW7K" alt=""><figcaption></figcaption></figure>

**Here is the configure value of KCC, you can put them into the wallet network setting page to connect your KCC wallet.**

{% hint style="info" %}
[Click here to get the network infos.](/developers/network-endpoints#kcc-mainnet)
{% endhint %}


# Tutorial on how to config KCC network in Metamask

<figure><img src="/files/3TJVlOjo7ZNFriBPXP3w" alt=""><figcaption></figcaption></figure>

1\. Open your MetaMask wallet on your Chrome Extension and press the logo in the top right corner.

![](/files/LyqFCP3JVWLf9woKJgOv)

2\. Click “Setting” and scroll down to find “Networks”.

![](/files/z4Sob734MZbK7wREX6Vi)

3\. Click the “Add Network” button.

![](/files/dSzz6VAYAtnPf4q09Myd)

4\. This window below is going to pop up. Enter the following configuration value in the pop-up window, then click the “Save” button.

<figure><img src="/files/v82w8GY2njJeARYY2d7M" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/D99wCdbg7jA1hM07R3ko" alt=""><figcaption></figcaption></figure>

{% hint style="info" %}
[Click here to get the network infos.](/developers/network-endpoints#kcc-mainnet)
{% endhint %}

\
5\. You can switch from Ethereum Mainnet to KCC Mainnet simply by clicking the column next to the logo.


# Tutorial on how to config KCC network in Chainlist

1\. Visit Chainlist official website and connect your wallet.

<figure><img src="/files/iu2WTVWzuU36ktmvUKMs" alt=""><figcaption></figcaption></figure>

2\. Enter "KCC" into the search bar and you can see KCC below

<figure><img src="/files/umojBCj3Avw4fLsf4syz" alt=""><figcaption></figcaption></figure>

3\. Click " Add to Metamask".


# Bridge Assets

Assets

There are 2 ways to transfer your crypto assets to KCC:

{% content-ref url="/pages/UTGVzBnDVrj77OFnxkxO" %}
[KCC Bridge](/individuals/bridge-assets/kcc-bridge)
{% endcontent-ref %}

{% content-ref url="/pages/cAxHHpVLwYnnIEmcGoyg" %}
[Bridge assets form Exchange](/individuals/bridge-assets/bridge-assets-form-exchange)
{% endcontent-ref %}


# Bridge assets from others chains

### Supported cross-chain bridge

Users can using "cross-chain bridges" to transfer your assets into your KCC Chain wallet. Below we provide a list of cross-chain bridges that support the KCC Network.

| No | Cross-chain Bridge Name | Official Website                     |
| -- | ----------------------- | ------------------------------------ |
| 1  | KCC Bridge              | <https://www.kcc.io/bridge/transfer> |
| 2  | O3 swap                 | <https://o3swap.com/>                |

### The Addresses of  Pegged-Tokens On KCC

When you transfer foreign tokens (which are not issued on the KCC chain) from other chains to the KCC network, they become the corresponding pegged tokens.&#x20;

Here are pegged token addresses of some common tokens on the KCC mainnet:&#x20;

<table><thead><tr><th width="210">Name</th><th>Address</th></tr></thead><tbody><tr><td>USDT</td><td>0x0039f574eE5cC39bdD162E9A88e3EB1f111bAF48</td></tr><tr><td>USDC</td><td>0x980a5AfEf3D17aD98635F6C5aebCBAedEd3c3430</td></tr><tr><td>BTCK</td><td>0xfA93C12Cd345c658bc4644D1D4E1B9615952258C</td></tr><tr><td>ETH</td><td>0xf55aF137A98607F7ED2eFEfA4cd2DfE70E4253b1</td></tr></tbody></table>

You can find the full list of pegged tokens on [Github](https://github.com/kcc-community/kcc-peg-token#mainnet).&#x20;


# KCC Bridge

Using KCC Bridge, users can transfer tokens from different networks to the KuCoin Community Chain with the KCC Bridge.

The networks available currently are KuCoin Community Chain, Ethereum, Avalanche, Binance Smart Chain, Polygon, and Fantom Opera. Therefore, you can easily connect your Metamask wallet to this protocol and bridge between any of the blockchains mentioned.

To detail a specific bridge example, let’s assume that you are looking to transfer Tether (USDT) from Ethereum to KuCoin Community Chain via KCC Bridge.

1\. Visit the [KCC Bridge](https://www.kcc.io/bridge/transfer) website.

2\. Click “Connect your Wallet”.

<figure><img src="/files/dTdi8uJRKxIErUMzyygA" alt=""><figcaption></figcaption></figure>

3\. Select the asset for the desired token (in this case, USDT) from the “Asset” dropdown.

4\. Select “Ethereum Network” in the “From” section, then select “KCC Mainnet Network” in the “To” section.

<figure><img src="/files/dHmlrpJY9Rn4AAe4PJM9" alt=""><figcaption></figcaption></figure>

5\. Enter the amount that you want to send. You should see an image like the one below. Then click “Approve” to complete the transaction.

6\. A transfer confirmation window will open. Please recheck all the details and click “Transfer”.&#x20;

You can follow similar steps to transfer any tokens we supported to the different supporting networks.

View the[ video guide](https://www.youtube.com/watch?v=kZdX1V2Tgnc) of KCC Bridge


# Bridge assets form Exchange

<figure><img src="/files/nFq6U67JYjt6stybeOaG" alt=""><figcaption></figcaption></figure>

Take KuCoin as an example to show how to bridge assets from exchanges to KCC

1\. Visit [kucoin.com](https://www.kucoin.com/) on PC or open the KuCoin APP on mobile.

2\. Click the Assets icon in the upper right corner, and go to the asset page.

<figure><img src="/files/z190l0p7NTEV55fECz7H" alt=""><figcaption></figcaption></figure>

3\. After getting to the asset page, click the “Withdraw” button at the top right to jump to the withdrawal page.

<figure><img src="/files/lhpTxKfhvKlnkvG5YrF0" alt=""><figcaption></figcaption></figure>

4\. On the withdrawal page, you can select a token and enter the target KCC wallet address.

<figure><img src="/files/Qahm6ck3EctZbC9lBxHd" alt=""><figcaption></figcaption></figure>

5\. Please make sure you choose the KCC network.

<figure><img src="/files/wVNOQssn4LVM5mvqRgbh" alt=""><figcaption></figcaption></figure>

6\. You can check the process of your withdrawal by clicking the “ History” button.

<figure><img src="/files/aiT6vzmpQLRUgMGNBEun" alt=""><figcaption></figcaption></figure>


# Find a dApp

adApp

<figure><img src="/files/ZwOJGGZOFc73BOEnr60n" alt=""><figcaption></figcaption></figure>

You can easy to find the dAPP you like in KCC Ecosystem.

1.Just visit [kcc.io](https://docs.kcc.io/individuals/www.kcc.io)

2.Click "Ecosystem">"Explore dApp"

<figure><img src="/files/7msVo4vY3t5ZU0aY4nX3" alt=""><figcaption></figcaption></figure>

3\. Scroll down the page and you can see category column of dAPP on KCC

<figure><img src="/files/EngPQPkrhOsYOVyT8XRl" alt=""><figcaption></figcaption></figure>

4\. Click the category and find the dApp you like.


# Add Your dAPP

&#x20;1.Visit [kcc.io](https://docs.kcc.io/individuals/find-a-dapp/www.kcc.io)

2.Click "Ecosystem">"Explore dApp"

<figure><img src="/files/7msVo4vY3t5ZU0aY4nX3" alt=""><figcaption></figcaption></figure>

3\. Tap the "Add your dApp" button and submit your application.

<figure><img src="/files/AWDYJ07XaoJsdOe742eN" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/pD8noSdVv9ohWEBYsTK1" alt=""><figcaption></figcaption></figure>

4\. KCC team will review in the order of submission.


# KCS Token

<figure><img src="/files/i80WyO2KM9gg39wf1u8v" alt=""><figcaption></figcaption></figure>

KCS(KuCoin Token) is the native token and underlying fuel of KCC.&#x20;

Similar to gas on Ethereum, KCS is the transaction fuel on KCC. Also, KCS acts as a governance token, holding KCS gives you the right to make your voice heard and participate in KCC on-chain governance.&#x20;

Currently, KCS holders can stake their KCS to validators and share KCC gas. [Click here to learn more about KCC Node Staking](https://staking.kcc.io/).

[KCS Whitepaper](https://www.kcs.foundation/)


# Get KCS

There are many ways to get KCS, including buying KCS on CEX ([KuCoin](https://www.kucoin.com/)) or DEX ([MojitoSwap](https://www.mojitoswap.finance/)),  and borrowing KCS from lending protocols like [Torches](https://www.torches.finance/en).

Also, If you are new to the KCC network and have [set up your KCC Wallet ](/individuals/wallet/tutorial-on-how-to-set-up-wallet)successfully, you have the chance to claim free KCS as a gas fee.

### Here is the tutorial on how to use KCC Faucet to get  FREE KCS Gas

1\. Visit <https://faucet.kcc.io/>

2\. Login with Twitter first before claiming free KCS.

<figure><img src="/files/eJUmvrUuOPDhUTQKXcDK" alt=""><figcaption></figcaption></figure>

3\. Enter your KCC wallet address and finish the ‘reCAPTCHA’.

<figure><img src="/files/i9DewDvX5H12C0x4sybT" alt=""><figcaption></figcaption></figure>

4\. Click the ‘REQUEST 0.0005KCS’ button to claim your KCS token.

5\. You will see this pop-up when you successfully claim KCS.


# Stake KCS

KCC Validator Election were launched, everyone can stake their own KCS on the node and get rewards!

Staking KCS on nodes is an easy way to earn passive income. Compared to the KCS bonus on KuCoin, you have to hold at least 6 KCS tokens to earn around APR 2% revenue. If you stake your KCS to vote for the node, the APR will be more than 3%, and you only need at least 1 KCS token to earn this revenue.

{% content-ref url="/pages/N0w7mhN3LUawp1xWaOUz" %}
[How to participate in KCS Staking](/individuals/kcs-token/stake-kcs/how-to-participate-in-kcs-staking)
{% endcontent-ref %}


# How to participate in KCS Staking

1）Set up your KCC wallet;

If you haven’t set up your KCC wallet, you can see this tutorial to set up your KCC Wallet first.

2.）Have enough KCS in your crypto wallet;

KCS is the gas on KCC, you can buy KCS on [KuCoin](https://www.kucoin.com/) or [MojitoSwap](https://www.mojitoswap.finance/). You also can borrow KCS from [Torches](https://www.torches.finance/en/).

3\) Visit the [node staking page](https://staking.kcc.io/) and connect your crypto wallet

After having enough KCS, visit node staking pages on KCC and connect your crypto wallet.

<figure><img src="/files/TlZX1DSzkzeFcuuo6NyW" alt=""><figcaption></figcaption></figure>

4\) Stake KCS to vote

After that, click “Stake Now”, to start voting for validators.

<figure><img src="/files/1k4DhP7cTg9pYLlw1XoZ" alt=""><figcaption></figcaption></figure>

5\) Choose the validators&#x20;

Choose which validators you are going to vote for and click the “Vote” button.

<figure><img src="/files/Y29wgRb4kOv9pVWEqTUR" alt=""><figcaption></figcaption></figure>

6\) Stake your KCS&#x20;

Enter the amount of KCS that you want to stake. 1 KCS represents 1 vote, and It should be an integer amount. Then click “Vote” to complete the staking.

<figure><img src="/files/cENiqDBBU9Xzk9i8VjL8" alt=""><figcaption></figcaption></figure>


# How to redeem staked KCS

1\. Click “My Vote” in the top menu of the node staking page.

<figure><img src="/files/0z3kNe6HayoBgE9osLG0" alt=""><figcaption></figcaption></figure>

2\. Scroll down and click the “Redeem” button and enter the amount of the KCS you want to redeem.

<figure><img src="/files/7ftomREEECrTsxKqvvNY" alt=""><figcaption></figcaption></figure>

3\. KCS will be available to withdraw after a 3-day lockup period. During the lockup period, no more rewards will be generated.


# How to check or claim staking rewards

1\. Users can check their rewards details on “My Vote”  in the top menu of the node staking page.

<figure><img src="/files/0z3kNe6HayoBgE9osLG0" alt=""><figcaption></figcaption></figure>

2\. Users can claim their rewards by clicking “Claim”.

<figure><img src="/files/UzxV9T91rYBRE8KANNCD" alt=""><figcaption></figcaption></figure>

You can now stake your KCS to vote and get more rewards by visiting <https://staking.kcc.io/staking>.


# FAQs

{% content-ref url="/pages/uyOG38eZ8CGAeXp69btd" %}
[General FAQs](/faqs/faqs/general-faqs)
{% endcontent-ref %}

{% content-ref url="/pages/2dm3wBLh826xlZGBZodS" %}
[KCS and Staking FAQs](/faqs/faqs/kcs-and-staking-faqs)
{% endcontent-ref %}

{% content-ref url="/pages/uoidAtOfYEbgO7sgm9wI" %}
[Validator FAQs](/faqs/faqs/validator-faqs)
{% endcontent-ref %}


# General FAQs

<figure><img src="/files/eyUmNvBcEqgb91OqpxF2" alt=""><figcaption></figcaption></figure>

### What is KuCoin Community Chain(KCC)?[​](https://docs.bnbchain.org/docs/BSC-FAQs-general#what-is-bnb-smart-chain) <a href="#what-is-bnb-smart-chain" id="what-is-bnb-smart-chain"></a>

KCC brings a decentralized network that is **high-performing**, **low-cost**, and **low-consumption,** KCC is EVM-compatible using an innovative consensus of Proof of Staked Authority (PoSA).

### Where can I take a look at the KCC code? <a href="#where-can-i-take-a-look-at-the-bnb-smart-chain-code-is-there-a-github-repository" id="where-can-i-take-a-look-at-the-bnb-smart-chain-code-is-there-a-github-repository"></a>

Please refer to KCC GitHub: <https://github.com/kcc-community>

### What is the consensus model of KCC?

Please find details [here](/overview/consensus-engine).

### Where can I find some support?

Please access to social media channel for help:

[Telegram](https://github.com/kcc-community)

[Twitter](https://twitter.com/KCCOfficialTW)

[Discord](https://discord.com/invite/H5ucJydSyd)

### What are the incentives for developers to build on KCC?[​](https://docs.bnbchain.org/docs/BSC-FAQs-general#what-are-the-incentives-for-developers-to-build-on-bsc-chain) <a href="#what-are-the-incentives-for-developers-to-build-on-bsc-chain" id="what-are-the-incentives-for-developers-to-build-on-bsc-chain"></a>

Please check the technological grants [here](https://github.com/kcc-community/kcc-grants).

### How to transfer assets/tokens from other chain to KCC? <a href="#what-are-the-incentives-for-developers-to-build-on-bsc-chain" id="what-are-the-incentives-for-developers-to-build-on-bsc-chain"></a>

1, Official bridge: <https://bridge.kcc.io/>

2,  [Multichain](https://app.multichain.org/#/router) (formerly known as Anyswap)&#x20;

### Which dApps are deployed on KCC?[​](https://docs.bnbchain.org/docs/BSC-FAQs-general#which-dapps-are-deployed-on-bsc) <a href="#which-dapps-are-deployed-on-bsc" id="which-dapps-are-deployed-on-bsc"></a>

Refer to here to learn about the different projects deployed on KCC.

### What to do in case of wrong network issues?[​](https://docs.bnbchain.org/docs/BSC-FAQs-general#what-to-do-in-case-of-a-wrong-network-withdrawal-issue) <a href="#what-to-do-in-case-of-a-wrong-network-withdrawal-issue" id="what-to-do-in-case-of-a-wrong-network-withdrawal-issue"></a>

1, Please check the [list](/individuals/wallet/supported-wallet) of wallets that support the KCC network.

2, Follow the [guide](/individuals/network-configuration/tutorial-on-how-to-config-kcc-network-in-metamask) to configure the KCC network.


# KCS and Staking FAQs

<figure><img src="/files/l5ChymHr843X0JkN31DH" alt=""><figcaption></figcaption></figure>

### What role does KCS play in KCC ?[​](https://docs.bnbchain.org/docs/BSC-FAQs-tokens#what-role-does-bnb-play-in-securing-bnb-smart-chain-) <a href="#what-role-does-bnb-play-in-securing-bnb-smart-chain" id="what-role-does-bnb-play-in-securing-bnb-smart-chain"></a>

KCS is the native token for KCC.

### Where will the published whitepaper be found?[​](https://docs.bnbchain.org/docs/BSC-FAQs-general#where-will-the-published-whitepaper-be-found) <a href="#where-will-the-published-whitepaper-be-found" id="where-will-the-published-whitepaper-be-found"></a>

The whitepaper can be found at [here](https://www.kcs.foundation/) and download it.

### How can I stake my KCS?[​](https://docs.bnbchain.org/docs/BSC-FAQs-tokens#how-can-i-stake-my-bnb) <a href="#how-can-i-stake-my-bnb" id="how-can-i-stake-my-bnb"></a>

Please enter the node staking page(<https://staking.kcc.io/>) and follow the guide [here](/individuals/kcs-token/stake-kcs/how-to-participate-in-kcs-staking).

### How many tokens are required to stake KCS?[​](https://docs.bnbchain.org/docs/BSC-FAQs-tokens#how-many-tokens-are-required-to-stake-bnb) <a href="#how-many-tokens-are-required-to-stake-bnb" id="how-many-tokens-are-required-to-stake-bnb"></a>

The minimum amount is **1KCS**.

### How to check and claim KCS staking rewards？

Please follow the guide [here](/individuals/kcs-token/stake-kcs/how-to-check-or-claim-staking-rewards).

### How to redeem staked KCS

Please follow the guide [here](/individuals/kcs-token/stake-kcs/how-to-redeem-staked-kcs).

### Which wallets can be used to stake BNB?[​](https://docs.bnbchain.org/docs/BSC-FAQs-tokens/#which-wallets-can-be-used-to-stake-bnb) <a href="#which-wallets-can-be-used-to-stake-bnb" id="which-wallets-can-be-used-to-stake-bnb"></a>

You can use:

Metamask

KuCoin Wallet

Wallet Connect


# Validator FAQs

<figure><img src="/files/yj8A1zaidyLOjeKBEP3H" alt=""><figcaption></figcaption></figure>

### What is the role of KCC Validators?[​](https://docs.bnbchain.org/docs/BSC-FAQs-validator#what-is-the-role-of-bnb-smart-chain-validators) <a href="#what-is-the-role-of-bnb-smart-chain-validators" id="what-is-the-role-of-bnb-smart-chain-validators"></a>

It powers the blockchain network by processing transactions and signing blocks.

### What are the incentives to run a validator node?[​](https://docs.bnbchain.org/docs/BSC-FAQs-validator#what-are-the-incentives-to-run-a-validator-node)

Validators will earn rewards from transaction fees.

### What are hardware requirements of running a KCC validator node?

Please follow the guide [here](/developers/run-a-node/hardware-and-system-requirements).

## How to apply for running a validator node?

Please follow the guide [here](/developers/run-a-node/run-a-validator-node/apply-for-running-a-validator).

### How to run a validator node?

Please follow the guide [here](/developers/run-a-node/run-a-validator-node/run-a-validator).


# Milestone

Roadmap

<figure><img src="/files/b0hGnGk0zFxM9JuJUTDA" alt=""><figcaption></figcaption></figure>

### 2021

2021-04-28

KCC (testnet) Launched

2021-06-16

KCC Launched

2021-06-18

Grant Program Launched

2021-06-25

KCC Ambassdor Program

2021-07-16

KCC Bridge Launched

2021-09-24

KCC GoDAO Foundation Registered

2021-09-27

Discover Launched

2021-10-21

GoDAO Launched

2021-11-19

Safe.kcc.io Launched

### 2022

2022-02-25

Ecosystem Incentive Funds Announced

2022-03-15

First Hackathon Kicked Off

2022-03-29

Co-release KCS Whitepaper

2022-06-16

KCC Validator Election Launched

2022-06-24

KCC Mainnet Ishikari Hardfork Upgrade

2022-09-20

KCC Beowulf Launched

### 2023

2023-03-16

KCC VRF Lived

2023-05-19

The KCC Mainnet V1.3.1 Released


# Contact Us

You can view all commnunity here

<figure><img src="/files/soY2lkqBVbPfc52E5FKL" alt=""><figcaption></figcaption></figure>

<table data-view="cards"><thead><tr><th></th><th></th><th></th><th data-hidden data-card-cover data-type="files"></th><th data-hidden data-card-target data-type="content-ref"></th></tr></thead><tbody><tr><td></td><td><a href="https://twitter.com/KCCOfficialTW">KCC Official Twitter</a></td><td></td><td><a href="/files/gf1E6WsqwhLMWbJqYjJ1">/files/gf1E6WsqwhLMWbJqYjJ1</a></td><td><a href="https://twitter.com/KCCOfficialTW">https://twitter.com/KCCOfficialTW</a></td></tr><tr><td></td><td><a href="https://t.me/KCCOfficialEnglishCommunity">KCC Official Telegram</a></td><td></td><td><a href="/files/5zYKMvCLDisyq548Dx4E">/files/5zYKMvCLDisyq548Dx4E</a></td><td><a href="https://t.me/KCCOfficialEnglishCommunity">https://t.me/KCCOfficialEnglishCommunity</a></td></tr><tr><td></td><td><a href="https://discord.io/KCCOfficial">KCC Official Discord</a></td><td></td><td><a href="/files/5FF2mrWpWZvVwpaXdptu">/files/5FF2mrWpWZvVwpaXdptu</a></td><td><a href="https://discord.io/KCCOfficial">https://discord.io/KCCOfficial</a></td></tr><tr><td></td><td><a href="https://news.kcc.io/">KCC News</a></td><td></td><td><a href="/files/W81RxpzRuKXt2h6lC8Ho">/files/W81RxpzRuKXt2h6lC8Ho</a></td><td><a href="https://news.kcc.io/">https://news.kcc.io/</a></td></tr><tr><td></td><td><a href="https://medium.com/@kccofficial">KCC Medium</a></td><td></td><td><a href="/files/4wDKcklYEsuGE4dkD8BR">/files/4wDKcklYEsuGE4dkD8BR</a></td><td><a href="https://kccofficial.medium.com/">https://kccofficial.medium.com/</a></td></tr><tr><td>Email Us:</td><td>kcc-business@kcc.network</td><td></td><td><a href="/files/USPjBFKOFmSmd36Ni7XF">/files/USPjBFKOFmSmd36Ni7XF</a></td><td></td></tr></tbody></table>


# Disclaimers

KCC Disclamers

Please note that **all projects and dApp applications running on the KuCoin Community Chain (KCC) are independently developed by third-party developers.** They are not audited by KCC official team.&#x20;

**KuCoin Community Chain is an entirely open-source and open community**, which means everyone and all project parties can participate. All opportunities and risks also exist at the same time. You need to identify and prevent risks carefully. This is also the charm of the DeFi world.


# Risk Statement

<figure><img src="/files/cb3ou22VHqrDa6h38lI5" alt=""><figcaption></figcaption></figure>

**Dear Users (hereinafter referred to as "you"),**

KuCoin Community Chain (hereinafter referred to as "KCC" or "we") is a decentralized public chain. Developers around the world can deploy applications on KCC, all users can read, send and trade on KCC.&#x20;

Due to the characteristics of decentralization, we hereby remind you the risks of the third-party DAPP are as follows:

* Before you operate on any platform, wallet, or third-party DAPP, please do your own research first;
* Whether you participate in or use DAPP on KCC through any trading platform or wallet, it is your own behavior and we do not recommend it to you;
* We are not responsible for auditing any third-party DAPP, nor do we make any commitment and guarantee on the validity, accuracy, correctness, reliability, quality, stability, integrity, and timeliness of the technology and information involved in its services;
* You should bear all the responsibilities arising from your use of any third-party DAPP services on your own;
* Whether the third-party DAPP services meet the laws, regulations, or relevant policies of your jurisdiction, please make your own judgment and evaluation. We do not provide any evaluation, please make sure that you strictly abide by the laws of your jurisdiction;
* You and the third-party DAPP shall assume the responsibilities of any issues related to the usage of the third-party DAPP, including but not limited to legal issues, contractual liability issues, economic losses, etc., KCC will not be responsible for them;
* We do not recommend or ask you to use any third-party DAPP service.


# Media Kit

Downloadable assets like KCC logos

<figure><img src="/files/bcTZaia2YMIZpbhDsZPY" alt=""><figcaption></figcaption></figure>

You can download the KCC logo below.

<figure><img src="/files/46XlzvGmSvXgUyYBX39t" alt=""><figcaption></figcaption></figure>

{% file src="/files/3JP4XV6DPsr9oY0ESxrZ" %}