Chain Dimension

The Gaming Interchain Hub

Chain Dimension is our browser platform designed to empower the web3 gaming industry with seamless interchain functionality. It provides game developers with tools for creating and managing interchain tokens, ensuring smooth interoperability across blockchain ecosystems. Gamers enjoy a unified experience, effortlessly transferring and utilizing assets across different games and networks.

Key Features

  1. Creation of Brand-New Interchain Game Tokens

    • Game developers can mint new tokens that operate across various blockchain networks, enhancing the gaming experience by enabling multi-chain asset utilization.

  2. Conversion of Existing Game Tokens

    • Convert existing tokens into interchain tokens, allowing them to interact and function within different blockchain ecosystems.

  3. Interchain Bridging

    • Facilitate the transfer and interaction of gaming assets across different blockchain platforms, ensuring seamless integration and interoperability.

  4. Turnkey Self-Service Platform

    • Our platform is designed to be ready to use out-of-the-box, requiring minimal setup and configuration, thereby reducing time-to-market.

  5. User-Friendly Interface

    • Intuitive and accessible interface designed for ease of use, allowing developers to focus on creating innovative gaming experiences without being bogged down by technical complexities.

Benefits

  1. For Game Developers:

    • Increase Interoperability

    • Enhance Engagement

    • Expand Market

    • Maximize Utility

    • Partner up with blockchains

    • Tap into worldwide market & user base

  2. For Gamers:

    • Ability to interact with a wide range of applications and assets from a single platform.

    • Enhanced gaming experiences through the seamless use of interchain assets.

    • Boosted Utilities

    • Participate in Diverse Ecosystems

Chain Dimension aims to be the backbone of interchain functionality in the gaming industry. By providing a robust, user-friendly, and secure platform, we empower game developers to innovate and create dynamic, interconnected gaming experiences that transcend the limitations of single blockchain ecosystems.

Bridging Process Backend

  • Mainchain: Where the initial token supply resides or is created.

This is the primary chain where tokens are initially issued, already your existing one.

  • Mainchain to Interchain: Tokens are locked on Mainchain and minted on Interchain.

Allows utilization on different blockchain networks while maintaining their original supply.

  • Interchain to Mainchain: Tokens on Interchain are burned and subsequently unlocked on Mainchain.

Ensures that the total supply remains consistent and accounted for across chains.

  • Interchain A to Interchain B: Tokens are burned on one Interchain (Interchain A) and minted on another (Interchain B).

Facilitates the transfer and utilization of tokens across different Interchains.

Example with our $VOLS Token:

This approach ensures that the $VOLS token is managed efficiently across multiple chains while maintaining its integrity and total supply.

Technical Details

Chain Dimension leverages advanced blockchain protocols to ensure high security, scalability, and efficiency in interchain transactions. Below are the core components and technical functionalities:

  1. Cross-Chain Gateway Protocol (CGP)

    • Analogous to the Border Gateway Protocol (BGP) of the internet, CGP connects multiple blockchain networks, facilitating routing and communication without requiring custom modifications to the blockchains.

  2. Cross-Chain Transfer Protocol (CTP)

    • Similar to application-level protocols like HTTP, CTP allows for asset transfers and interactions between applications on different blockchains through simple API calls. This includes locking, unlocking, and transferring assets, as well as executing cross-chain application triggers.

  3. Decentralized Validator Network

    • A network of validators maintains the security and integrity of interchain transactions, utilizing a Delegated Proof-of-Stake (DPoS) consensus mechanism to ensure high safety and liveness.

  4. Threshold Signature Schemes

    • To manage cross-chain transactions, validators use threshold signature schemes, where a consensus among a certain percentage of validators is required to approve transactions. This enhances security by distributing trust across multiple parties.

  5. Light-Client Protocols

    • Validators run light-client software to verify the state of other blockchains, ensuring accurate and reliable cross-chain data synchronization.

  6. Governance Model

    • An open governance model allows developers and users to propose and vote on new integrations and protocol updates, ensuring that the platform evolves in line with the community's needs.

Creating Brand-New Interchain Tokens

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract InterchainToken {
    string public name = "InterchainToken";
    string public symbol = "ICT";
    uint8 public decimals = 18;
    uint256 public totalSupply;

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    constructor(uint256 _initialSupply) {
        totalSupply = _initialSupply * 10 ** uint256(decimals);
        balanceOf[msg.sender] = totalSupply;
    }

    function transfer(address _to, uint256 _value) public returns (bool success) {
        require(balanceOf[msg.sender] >= _value);
        balanceOf[msg.sender] -= _value;
        balanceOf[_to] += _value;
        emit Transfer(msg.sender, _to, _value);
        return true;
    }

    function approve(address _spender, uint256 _value) public returns (bool success) {
        allowance[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value);
        return true;
    }

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
        require(_value <= balanceOf[_from]);
        require(_value <= allowance[_from][msg.sender]);
        balanceOf[_from] -= _value;
        balanceOf[_to] += _value;
        allowance[_from][msg.sender] -= _value;
        emit Transfer(_from, _to, _value);
        return true;
    }
}

Converting Existing Tokens to Interchain Tokens

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

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

contract TokenConverter is Ownable {
    address public interchainToken;

    event TokenConverted(address indexed user, uint256 amount);

    constructor(address _interchainToken) {
        interchainToken = _interchainToken;
    }

    function convertToken(address existingToken, uint256 amount) public {
        IERC20(existingToken).transferFrom(msg.sender, address(this), amount);
        IERC20(interchainToken).transfer(msg.sender, amount);
        emit TokenConverted(msg.sender, amount);
    }

    function setInterchainToken(address _interchainToken) public onlyOwner {
        interchainToken = _interchainToken;
    }
}

Handling Cross-Chain Transactions

// Cross-Chain Transaction Handler (JavaScript Example for Node.js)
const Web3 = require('web3');
const { toWei, fromWei } = Web3.utils;
const axios = require('axios');

class CrossChainHandler {
    constructor(sourceNetwork, targetNetwork) {
        this.sourceWeb3 = new Web3(new Web3.providers.HttpProvider(sourceNetwork));
        this.targetWeb3 = new Web3(new Web3.providers.HttpProvider(targetNetwork));
    }

    async transferAssets(sourcePrivateKey, targetAddress, amount, sourceTokenAddress, targetTokenAddress) {
        const sourceAccount = this.sourceWeb3.eth.accounts.privateKeyToAccount(sourcePrivateKey);
        const sourceToken = new this.sourceWeb3.eth.Contract(tokenAbi, sourceTokenAddress);
        const targetToken = new this.targetWeb3.eth.Contract(tokenAbi, targetTokenAddress);

        const amountInWei = toWei(amount, 'ether');

        // Lock assets on the source chain
        await sourceToken.methods.transfer(sourceToken.options.address, amountInWei)
            .send({ from: sourceAccount.address, gas: 200000 });

        // Generate a proof of transfer
        const proof = await this.generateProof(sourceAccount.address, targetAddress, amountInWei);

        // Unlock assets on the target chain
        await targetToken.methods.transfer(targetAddress, amountInWei)
            .send({ from: targetToken.options.address, gas: 200000, data: proof });

        console.log(`Successfully transferred ${amount} tokens from ${sourceAccount.address} to ${targetAddress}`);
    }

    async generateProof(sourceAddress, targetAddress, amount) {
        // Call an external service to generate a proof (simplified for illustration)
        const response = await axios.post('https://proof-service.example.com/generate', {
            sourceAddress,
            targetAddress,
            amount
        });
        return response.data.proof;
    }
}

const tokenAbi = [/* ABI of the token contract */];
const sourceNetwork = 'https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID';
const targetNetwork = 'https://bsc-dataseed.binance.org/';

const handler = new CrossChainHandler(sourceNetwork, targetNetwork);
const sourcePrivateKey = 'YOUR_PRIVATE_KEY';
const targetAddress = 'TARGET_WALLET_ADDRESS';
const amount = '10'; // 10 tokens
const sourceTokenAddress = 'SOURCE_TOKEN_CONTRACT_ADDRESS';
const targetTokenAddress = 'TARGET_TOKEN_CONTRACT_ADDRESS';

handler.transferAssets(sourcePrivateKey, targetAddress, amount, sourceTokenAddress, targetTokenAddress);

Consensus Layer

Leverages Byzantine Fault Tolerance (BFT) mechanisms to maintain the integrity and security of interchain transactions

def bft_consensus(nodes, transactions):
    """
    Byzantine Fault Tolerance consensus algorithm
    Args:
    nodes (list): List of participating nodes
    transactions (list): List of transactions to be validated

    Returns:
    bool: Consensus result
    """
    # Step 1: Transaction proposal
    proposals = propose_transactions(transactions)
    
    # Step 2: Validation
    valid_proposals = validate_proposals(nodes, proposals)
    
    # Step 3: Consensus voting
    consensus_result = vote_on_proposals(nodes, valid_proposals)
    
    return consensus_result

Threshold Cryptography

To enhance security during the key management process

def threshold_key_generation(participants, threshold):
    """
    Generate a threshold key for secure interchain operations
    Args:
    participants (int): Number of participants
    threshold (int): Minimum number of participants required to reconstruct the key

    Returns:
    tuple: Public and private keys
    """
    # Generate private keys
    private_keys = generate_private_keys(participants)
    
    # Distribute shares
    shares = distribute_shares(private_keys, threshold)
    
    # Reconstruct public key
    public_key = reconstruct_public_key(shares)
    
    return public_key, private_keys
PreviousProductsNextAdoption

Last updated