# ERC-20 S.C.s

The **ZCN Token Smart Contract** is an **ERC-20 token** built for the **Züs blockchain ecosystem**. It follows the ERC-20 standard while incorporating key features such as **custom decimals, controlled minting, and allowance management**.

The contract is built using **OpenZeppelin’s** secure and tested libraries, ensuring interoperability with wallets, exchanges, and decentralized applications (dApps).

### **Contract Overview**

* **Token Name:** Configurable (set during deployment)
* **Symbol:** Configurable (set during deployment)
* **Decimals:** **10** (instead of the default 18)
* **Initial Supply:** **500,000,000 ZCN**
* **Total Supply:** Can be increased via minting by the contract **owner**
* **Minting:** Restricted to the **owner**
* **Allowance Management:** Includes `increaseApproval()` for backward compatibility
* **Standard Functions:** Implements all ERC-20 functions such as `transfer`, `approve`, `allowance`, etc.

### **Smart Contract Code**

```solidity
// SPDX-License-Identifier: MIT
pragma solidity 0.8.18;

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

/**
 * @title Token
 *
 * @notice Represents ERC20 implementation for ZCN tokens
 */
contract Token is ERC20, Ownable {
    constructor(string memory name_, string memory symbol_)
        ERC20(name_, symbol_)
    {
        _mint(msg.sender, 500000000 * 10**decimals());
    }

    /**
     * @notice Overrides ERC20 decimals function to modify amount of token decimals
     * @return uint8 The amount of token decimals
     */
    function decimals() public pure override returns (uint8){
        return 10;
    }

    /**
     * @notice Public mint function
     * @param account_ The address to mint tokens to
     * @param amount_ The amount of tokens to mint
     */
    function mint(address account_, uint256 amount_) external onlyOwner {
        _mint(account_, amount_);
    }

    /**
     * @notice Alias for an older version of ERC20 smart contract to use increaseAllowance method
     * @param spender_ The address to increase allowance for
     * @param amount_ The amount to increase
     */
    function increaseApproval(address spender_, uint256 amount_) external onlyOwner {
        increaseAllowance(spender_, amount_);
    }
}
```

### **Key Features**

#### **1. ERC-20 Compliance**

This contract follows the **ERC-20 standard**, meaning it supports:

* `transfer()`: Allows token transfers between users.
* `approve()`: Grants spending permission to another address.
* `allowance()`: Checks the approved spending limit.
* `transferFrom()`: Executes transfers on behalf of a user.

#### **2. Custom Decimals**

Unlike the default **18 decimals** in ERC-20, this token has **10 decimals**:

```solidity
function decimals() public pure override returns (uint8){
    return 10;
}
```

* This allows for finer precision in transactions.

#### **3. Minting New Tokens**

* Only the **contract owner** can mint new tokens:

```solidity
function mint(address account_, uint256 amount_) external onlyOwner {
    _mint(account_, amount_);
}
```

* Use case:
  * This function can be used for **staking rewards, governance incentives, or controlled token supply expansion**.

#### **4. Increased Allowance Function (`increaseApproval`)**

* Provides backward compatibility for older ERC-20 implementations:

```solidity
function increaseApproval(address spender_, uint256 amount_) external onlyOwner {
    increaseAllowance(spender_, amount_);
}
```

* This function allows **adjusting allowances without resetting them**, which is useful in **older DeFi applications**.

### **Deployment & Usage**

#### **1. Deploying the Contract**

To deploy the contract, provide the **token name** and **symbol**:

```solidity
Token zcnToken = new Token("Zus Coin", "ZCN");
```

#### **2. Interacting with the Contract**

**Minting New Tokens**

```solidity
zcnToken.mint(0xRecipientAddress, 1000 * 10**10);
```

✅ Mints **1,000 ZCN** tokens.

**Transferring Tokens**

```solidity
zcnToken.transfer(0xRecipientAddress, 500 * 10**10);
```

✅ Transfers **500 ZCN** to the recipient.

**Approving a Spender**

```solidity
zcnToken.approve(0xSpenderAddress, 200 * 10**10);
```

✅ Allows **spender** to transfer up to **200 ZCN** on behalf of the owner.

**Checking Balance**

```solidity
zcnToken.balanceOf(0xUserAddress);
```

✅ Returns the **token balance** of a user.

**Using `increaseApproval`**

```solidity
zcnToken.increaseApproval(0xSpenderAddress, 50 * 10**10);
```

✅ Increases allowance by **50 ZCN**.

### **Use Cases**

* **Utility Token:** Used for transactions, fees, and governance within the **Züs ecosystem**.
* **DeFi & Staking:** Can be used in **staking, farming, and liquidity pools**.
* **Token Bridging:** Supports **cross-chain transfers between Ethereum and Züs**.

The **ZCN ERC-20 Smart Contract** is designed for efficiency, security, and seamless integration within the **Züs ecosystem**. It offers **controlled minting, customized decimals, and standard ERC-20 functions**, ensuring compatibility with **DeFi applications, wallets, and exchanges**.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.zus.network/zus-docs/system-overview/smart-contracts/erc-20-s.c.s.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.