Bridging CZKC among blockchains

This section explains how CZKC interacts with different blockchains and how you can transfer tokens between them.

Supported Networks

The CZKC project is designed to work across a range of blockchains. However, the issuer supports only a specific set of these blockchains to ensure security and stability. You can find the most up-to-date list of supported blockchains on the official CZKC project website.

See supported chains - technical details.

Expanding to New Blockchains

The decision to incorporate support for new blockchains is entirely up to the issuer of CZKC. This decision follows a specific internal process that prioritizes the security of the CZKC token and ensures it aligns with all relevant regulations in the EU and the Czech Republic. While users can't demand support for a particular blockchain, they are welcome to suggest new blockchain integrations to the issuer.

Transferring CZKC Between Blockchains

You can transfer your CZKC tokens between different blockchains using independent, third-party services known as "Bridges." It's important to note that the CZKC project issuer is not involved in the creation or management of these Bridges.

Bridge Integration

To ensure smooth interaction with Bridges, the CZKC contract utilizes the xERC-20 standard on EVM-compatible blockchains. The CZKC project only supports a selected number of Bridges.

Integrating New Bridges

The decision to integrate with new Bridges is entirely at the issuer's discretion, similar to the process for adding support for new blockchains. This decision follows an internal process that prioritizes security and regulatory compliance. Users can suggest new Bridge integrations to the issuer through the contact information provided on the website.

"Burn and Mint" Mechanism

When transferring CZKC tokens between blockchains, a "burn and mint" mechanism is used. This method enhances security by reducing the risk of attacks targeting accumulated tokens, a potential vulnerability with other methods like "lock and mint." Furthermore, it reduces the risk of transfer failures that might occur due to low liquidity between the blockchains involved.

Bridging Capacity Limits

To minimize the risks associated with potential malicious activity by Bridge providers or weaknesses in their systems, the issuer sets limits on the capacity of each integrated Bridge. These limits control how many CZKC tokens can be moved between blockchains through a specific Bridge. You can find the current capacity limits for each Bridge in the publicly available CZKC contract configuration as depicted below.

These limits are not static; they are actively adjusted based on the time elapsed (t) since the last CZKC transfer. This dynamic adjustment mechanism ensures that the bridges can handle varying levels of transfer activity while maintaining overall system stability.

\( \text{CapacityIndicator}_\text{Bridge i} = \min( \Delta t \times \text{tRecoveryRate}_\text{Bridge i} , \text{TotalCapacity}_\text{Bridge i} ) \)

Bridge capacity limits functions

    /**
     * @notice Returns the max limit of a bridge
     *
     * @param _bridge The bridge we are viewing the limits of
     * @return _limit The limit the bridge has
     */
    function mintingMaxLimitOf(address _bridge) external view returns (uint256 _limit);

    /**
     * @notice Returns the max limit of a bridge
     *
     * @param _bridge the bridge we are viewing the limits of
     * @return _limit The limit the bridge has
     */
    function burningMaxLimitOf(address _bridge) external view returns (uint256 _limit);

    /**
     * @notice Returns the current limit of a bridge
     *
     * @param _bridge The bridge we are viewing the limits of
     * @return _limit The limit the bridge has
     */
    function mintingCurrentLimitOf(address _bridge) external view returns (uint256 _limit);

    /**
     * @notice Returns the current limit of a bridge
     *
     * @param _bridge the bridge we are viewing the limits of
     * @return _limit The limit the bridge has
     */
    function burningCurrentLimitOf(address _bridge) external view returns (uint256 _limit);