Linkoln

The Interchain Agent (Formerly Chain Dimension)

Original Dapp Features, to be integrated into Telegram with Natural Language

Linkoln is our on-chain AI agent, powered on Telegram, designed to empower the Web3 industry through effortless interchain functionality. With an intuitive natural language interface, Linkoln simplifies multichain asset management, token creation, and cross-network interactions, ensuring a seamless and engaging user experience, all through a simple chat.

Key Features

1. Creation of Brand-New Interchain Game Tokens

   • Mint tokens that operate across various blockchain networks, enabling multi-chain utilization.

2. Conversion of Existing Tokens

   • Convert existing tokens into interchain-compatible tokens, expanding asset functionality.

3. Interchain Bridging

   • Facilitate the transfer and interaction of assets across platforms, ensuring interoperability.

4. Turnkey Self-Service

   • Ready to use out of the box with minimal setup, making interchain easy to deploy and manage.

5. User-Friendly Interface

   • Powered by natural language, making interchain accessible, removing all technical complexities.

---

Benefits

1. For developers:

   • Expand market with interoperability

   • Increase asset engagement

   • Maximize utility and reach global user base

2. For general users:

   • Access a wide range of applications and assets through a simple chat interface

   • Enjoy richer experiences with interchain assets

   • Unlock new possibilities to connect with decentralized ecosystems

Linkoln is an intelligent AI agent shaping the future of interconnectivity. By making network interactions intuitive and accessible, Linkoln empowers users to innovate, connect, and thrive in a dynamic environment that transcend the limitations of single blockchain ecosystems.

Renamed to Linkoln

---

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:

• Mainchain: Base Chain: Base Explorer

• Interchains:

  • Arbitrum: Arbitrum Explorer

  • Blast: Blast Explorer

  • Optimism: Optimism Explorer

  • Avalanche: Avalanche Explorer

  • Scroll: Scroll Explorer

  • Polygon: Polygon Explorer

  • BNBChain: BNBChain Explorer

  • Linea: Linea Explorer

  • Mantle: Mantle Explorer

  • Fantom: Fantom Explorer

  • Ethereum: Ethereum Explorer

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

---

Technical Details

Linkoln 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