秒合約/永續合約/合約跟單/量化交易系統設計開發/詳情分析

作為加密貨幣市場中歡迎的交易方式之一，合約交易（Contract Trading）已經成為數字貨幣衍生品市場中的主流交易

方式。合約交易的主要優勢在於其高槓桿率和方便的交易方式，投資者可以在沒有實際購買或出售加密貨幣的情況下進行

交易，從而透過較小的資本參與更多的交易。

與此相關的是，合約交易有三個主要的型別：秒合約（Perpetual Contract）、永續合約（Futures Contract）和合約跟單交

易（Copy-trading）。下面將對這三種型別進行詳細介紹並提供程式碼實現示例。

一、秒合約（Perpetual Contract）

在秒合約中，交易者可以進行屬於自己的無息借貸和利率交換，從而進行期權式交易。當交易者買入時，他們將長期

持有這個合約，並且不需要在每日結算時還清暫時的盈利或損失。與此相關的是，合約為了維護市場穩定，可能會收取資

金費用，這是由多頭（買方）和空頭（賣方）之間的差異來決定的。

示例程式碼：

PerpetualContract.sol

pragma solidity ^0.6.0;

contract PerpetualContract {

    string public name;

    uint public decimals;

    uint public totalSupply;

    address public owner;

    uint public lockedCollateral;

    uint public lockedLong;

    uint public lockedShort;

    event Transfer(address indexed from, address indexed to, uint tokens);

    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);

    event Mint(address indexed investor, uint tokens, uint lockedCollateral);

    event Burn(address indexed investor, uint tokens, uint lockedCollateral);

    mapping(address => uint) balances;

    mapping(address => mapping(address => uint)) allowed;

    constructor(string memory _name, uint _decimals) public {

        name = _name;

        decimals = _decimals;

        owner = msg.sender;

        // TODO: Add more contract initialization here

    }

    function balanceOf(address tokenOwner) public view returns (uint) {

        return balances[tokenOwner];

    }

    function transfer(address receiver, uint tokens) public returns (bool) {

        balances[msg.sender] = safeSub(balances[msg.sender], tokens);

        balances[receiver] = safeAdd(balances[receiver], tokens);

        emit Transfer(msg.sender, receiver, tokens);

        return true;

    }

    function approve(address delegate, uint tokens) public returns (bool) {

        allowed[msg.sender][delegate] = tokens;

        emit Approval(msg.sender, delegate, tokens);

        return true;

    }

    function allowance(address owner, address delegate) public view returns (uint) {

        return allowed[owner][delegate];

    }

    function transferFrom(address owner, address buyer, uint tokens) public returns (bool) {

        balances[owner] = safeSub(balances[owner], tokens);

        allowed[owner][msg.sender] = safeSub(allowed[owner][msg.sender], tokens);

        balances[buyer] = safeAdd(balances[buyer], tokens);

        emit Transfer(owner, buyer, tokens);

        return true;

    }

    function safeAdd(uint a, uint b) private pure returns (uint) {

        require(a + b >= a);

        return a + b;

    }

    function safeSub(uint a, uint b) private pure returns (uint) {

        require(b <= a);

        return a - b;

    }

    function mint(address investor, uint tokens, uint collateral) public returns (bool) {

        require(msg.sender == owner, "Only contract owner can mint tokens.");

        require(tokens > 0, "Tokens must be greater than zero.");

        require(collateral > 0, "Collateral must be greater than zero.");

        balances[investor] = safeAdd(balances[investor], tokens);

        totalSupply = safeAdd(totalSupply, tokens);

        lockedCollateral = safeAdd(lockedCollateral, collateral);

        emit Mint(investor, tokens, collateral);

        return true;

    }

    function burn(address investor, uint tokens, uint collateral) public returns (bool) {

        require(msg.sender == owner, "Only contract owner can burn tokens.");

        require(tokens > 0, "Tokens must be greater than zero.");

        require(collateral > 0, "Collateral must be greater than zero.");

        require(balances[investor] >= tokens, "Insufficient balance.");

        balances[investor] = safeSub(balances[investor], tokens);

        totalSupply = safeSub(totalSupply, tokens);

        lockedCollateral = safeSub(lockedCollateral, collateral);

        emit Burn(investor, tokens, collateral);

        return true;

    }

}