🚧2.2 Smart Contract Framework

In the Broken Bound project, smart contracts are crucial in enhancing the automation and security of cross-chain transactions. Smart contracts are self-executing contracts with the terms of the agreement directly written into code, stored, and executed on the blockchain. During the cross-chain circulation of assets, smart contracts ensure the transparency and immutability of all steps, providing users with security guarantees.

Application of Smart Contracts in Transaction Automation

Smart contracts automatically handle various steps in the cross-chain transaction process without human intervention, improving processing speed and efficiency. For example, when a user wishes to transfer Bitcoin to the Ethereum platform, a smart contract will lock the corresponding amount of Bitcoin on the Bitcoin chain and then mint an equivalent amount of Wrapped BTC on the Ethereum chain. The smart contract automatically executes the entire process, with the user only needing to initiate the transaction request.

Role of Smart Contracts in Enhancing Security

Smart contracts define transaction rules strictly through code, reducing the possibility of human error and fraud. Once deployed, the contract logic is immutable, ensuring transaction transparency and traceability. Additionally, smart contracts can incorporate mechanisms such as multi-signature and time-locks to add extra layers of security, further protecting assets.

Role of Smart Contracts in Cross-Chain Circulation:

Verification and Confirmation

Smart contracts verify the lock status of assets on the source chain and execute the minting operation on the target chain after confirming correctness.

Asset Synchronization

Smart contracts ensure that the locked assets on the source chain and the minted assets on the target chain are equivalent, preventing asset overflow or shortage.

Exception Handling

In case of errors during the cross-chain process, smart contracts can automatically trigger a rollback mechanism, reversing executed operations to protect user assets from loss.

Key Types of Smart Contracts in Broken Bound:

In Broken Bound, smart contracts are key components in achieving cross-chain functionality, primarily categorized into the following types:

Locking Contracts

Responsible for locking user assets on the source chain. When a user wishes to transfer assets from one chain to another, the locking contract ensures the assets are securely locked during transfer, preventing double usage or transfer.

Minting Contracts

Operate on the target chain, minting equivalent tokens based on the locked assets on the source chain. These tokens represent the locked assets, allowing users to use the corresponding assets on the new chain.

Verification Contracts

Handle and confirm the validity of cross-chain transactions. This includes verifying the lock status of assets on the source chain and ensuring all transaction details meet predefined security and execution standards.

Governance Contracts

Manage project governance operations such as voting and proposals. They allow token holders to vote on key project decisions, ensuring decentralized management and community-driven development.

Security Contracts

Include mechanisms such as multi-signature and time-locks to enhance transaction security. These contracts ensure fund security, prevent unauthorized access, and mitigate potential risks.

Modular Contract Approach

Adopting a modular approach in contract construction helps reduce complexity and improve readability, aiding in error and vulnerability identification during development and code review.

library Balances {
    function move(mapping(address => uint256) storage balances, address from, address to, uint amount) internal {
        require(balances[from] >= amount);
        require(balances[to] + amount >= balances[to]);
        balances[from] -= amount;
        balances[to] += amount;
    }
}


contract Token {
    mapping(address => uint256) balances;
    using Balances for *;
    mapping(address => mapping(address => uint256)) allowed;


    event Transfer(address from, address to, uint amount);
    event Approval(address owner, address spender, uint amount);


    function transfer(address to, uint amount) external returns (bool success) {
        balances.move(msg.sender, to, amount);
        emit Transfer(msg.sender, to, amount);
        return true;


    }


    function transferFrom(address from, address to, uint amount) external returns (bool success) {
        require(allowed[from][msg.sender] >= amount);
        allowed[from][msg.sender] -= amount;
        balances.move(from, to, amount);
        emit Transfer(from, to, amount);
        return true;
    }


    function approve(address spender, uint tokens) external returns (bool success) {
        require(allowed[msg.sender][spender] == 0, "");
        allowed[msg.sender][spender] = tokens;
        emit Approval(msg.sender, spender, tokens);
        return true;
    }


    function balanceOf(address tokenOwner) external view returns (uint balance) {
        return balances[tokenOwner];
    }
}