<Смарт Контракты/>

Создание, разработка и программирование умных контрактов любой сложности на платформах Ethereum и Hyperledger Fabric

Примеры работ

На данной странице мы опубликовали в открытый доступ некоторые из наших работ, на случай если вам интересно познакомиться с нашей деятельностью. Однако мы не можем на данной странице опубликовать все наши работы, принимая во внимания соглашения о конфиденциальности с нашими заказчиками. Тем не менее, некоторые примеры наших смарт-контрактов мы решили опубликовать на сайте, более того вы можете ими воспользоваться в своих личных целях.

Данные смарт-контракты написаны для платформы Ethereum на языке Solidity

Пример №1

Данный контракт предназначен для проведения pre-ICO и выпуска токенов. В смарт-контракте используются следующие параметры:

  • Время старта ICO
  • Время окончания ICO
  • Цена токена во время проведения ICO
  • Дробность токена
  • Резерв токенов за командой при окончании ICO


  • Язык программирования: Solidity

pragma solidity ^0.4.11;

library SafeMath {
  function mul(uint256 a, uint256 b) internal constant returns (uint256) {
    uint256 c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

  function div(uint256 a, uint256 b) internal constant returns (uint256) {
    uint256 c = a / b;
    return c;
  }

  function sub(uint256 a, uint256 b) internal constant returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  function add(uint256 a, uint256 b) internal constant returns (uint256) {
    uint256 c = a + b;
    assert(c >= a);
    return c;
  }
}

contract ERC20Basic {
  uint256 public totalSupply;
  function balanceOf(address who) constant returns (uint256);
  function transfer(address to, uint256 value) returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
}


contract Ownable {
  address public owner;


  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

  function Ownable() {
    owner = msg.sender;
  }

  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }

  function transferOwnership(address newOwner) onlyOwner {
    require(newOwner != address(0));
    OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }

}

contract ERC20 is ERC20Basic {
  function allowance(address owner, address spender) constant returns (uint256);
  function transferFrom(address from, address to, uint256 value) returns (bool);
  function approve(address spender, uint256 value) returns (bool);
  event Approval(address indexed owner, address indexed spender, uint256 value);
}

contract BasicToken is ERC20Basic {
  using SafeMath for uint256;

  mapping(address => uint256) balances;

  function transfer(address _to, uint256 _value) returns (bool) {
    require(_to != address(0));

    balances[msg.sender] = balances[msg.sender].sub(_value);
    balances[_to] = balances[_to].add(_value);
    Transfer(msg.sender, _to, _value);
    return true;
  }

  function balanceOf(address _owner) constant returns (uint256 balance) {
    return balances[_owner];
  }

}

contract StandardToken is ERC20, BasicToken {

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

  function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
    require(_to != address(0));

    var _allowance = allowed[_from][msg.sender];

    balances[_from] = balances[_from].sub(_value);
    balances[_to] = balances[_to].add(_value);
    allowed[_from][msg.sender] = _allowance.sub(_value);
    Transfer(_from, _to, _value);
    return true;
  }

  function approve(address _spender, uint256 _value) returns (bool) {

    require((_value == 0) || (allowed[msg.sender][_spender] == 0));

    allowed[msg.sender][_spender] = _value;
    Approval(msg.sender, _spender, _value);
    return true;
  }

  function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
    return allowed[_owner][_spender];
  }


  function increaseApproval (address _spender, uint _addedValue)
    returns (bool success) {
    allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
  }

  function decreaseApproval (address _spender, uint _subtractedValue)
    returns (bool success) {
    uint oldValue = allowed[msg.sender][_spender];
    if (_subtractedValue > oldValue) {
      allowed[msg.sender][_spender] = 0;
    } else {
      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
    }
    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
  }

}


contract MintableToken is StandardToken, Ownable {
  event Mint(address indexed to, uint256 amount);
  event MintFinished();

  bool public mintingFinished = false;


  modifier canMint() {
    require(!mintingFinished);
    _;
  }


  function mint(address _to, uint256 _amount) onlyOwner canMint returns (bool) {
    totalSupply = totalSupply.add(_amount);
    balances[_to] = balances[_to].add(_amount);
    Mint(_to, _amount);
    Transfer(0x0, _to, _amount);
    return true;
  }

  function finishMinting() onlyOwner returns (bool) {
    mintingFinished = true;
    MintFinished();
    return true;
  }
}

contract TestToken is MintableToken {
  string public constant name = "TestToken";
  string public constant symbol = "TT";
  uint8 public constant decimals = 18;
}

contract TESTCrowdsale is Ownable {

  using SafeMath for uint256;

  TestToken public token;

  uint256 public startTime;
  uint256 public endTime;

  address public wallet;

  uint256 public rate;

  uint256 public weiRaised;

  event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);

  function TESTCrowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
    // require(_startTime >= now);
    require(_endTime >= _startTime);
    require(_rate > 0);
    require(_wallet != 0x0);

    token = createTokenContract();
    startTime = _startTime;
    endTime = _endTime;
    rate = _rate;
    wallet = _wallet;
  }

  function createTokenContract() internal returns (TestToken) {
    return new TestToken();
  }

  function () payable {
    buyTokens(msg.sender);
  }

  function buyTokens(address beneficiary) payable {
    require(beneficiary != 0x0);
    require(validPurchase());

    uint256 weiAmount = msg.value;
    uint256 tokens = weiAmount.mul(rate);
    weiRaised = weiRaised.add(weiAmount);

    token.mint(beneficiary, tokens);
    TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);

    forwardFunds();
  }

  function forwardFunds() internal {
    wallet.transfer(msg.value);
  }

  function validPurchase() internal constant returns (bool) {
    bool withinPeriod = now >= startTime && now <= endTime;
    bool nonZeroPurchase = msg.value != 0;
    return withinPeriod && nonZeroPurchase;
  }

  function hasEnded() public constant returns (bool) {
    return now > endTime;
  }

  function closeAndTransferTokenOwnership() onlyOwner {
    require(now > endTime);
    // reserve for a team
    uint256 toMint = token.totalSupply().mul(15).div(100);
    token.mint(owner, toMint);
    // transfer of ownership
    token.transferOwnership(owner);
  }

}
                     

Пример №2

В текущем примере двумя способами решается задача обеспечения групповых арендных платежей. Первый одиночный смарт контракт представляет из себя микро-систему арендного расчета, хранит в себе данные по платежам. Участники расчета аккумулируют нужную сумму на контракте, после чего платеж фиксируется как выполненный и платеж исполняется, данные о расчете и его статус фиксируются в блокчейне и доступны для последующих выгрузок.

  • Язык программирования: Solidity

pragma solidity ^0.4.11;

contract Biller {
    
    struct Bill {
        uint id;
        uint status;
        address reciever;
        uint summ;
        string clientData;
        string payers;
        address[] wallets;
        int[] amounts;
        int[] payStatuses;
    }
    
    event Closed(
        uint billId
    );
    
    event Saved(
        uint billId
    );
    
    event Dead(
        uint billId
    );
    
    mapping(uint => Bill) public bills;

    function Biller() {
    }
    
    function saveOpenBill(uint id, address reciever, uint summ, string clientData, string payers, address[] wallets, int[] amounts, int[] payStatuses) {
        bills[id] = Bill(id, 1, reciever, summ, clientData, payers, wallets, amounts, payStatuses);
        Saved(id);
    }
    
    function setClosing(uint id, address[] wallets, int[] amounts) public {
        bills[id].status = 2;
        bills[id].wallets = wallets;
        bills[id].amounts = amounts;
        Closed(id);
    }
    
    function getAmounts(uint id) public constant returns (int[])  {
        return bills[id].amounts;
    }
    
    function getWallets(uint id) public constant returns (address[])  {
        return bills[id].wallets;
    }
    
    function getPayStatuses(uint id) public constant returns (int[])  {
        return bills[id].payStatuses;
    }
    
    function confirm(uint id, address wallet) public {
        var bill = bills[id];
        for (uint i = 0; i < bill.wallets.length; i++) {
            if (wallet == bill.wallets[i]) {
                bills[id].payStatuses[i] = 2;
            }
        }
        
        int notPayedCount = 0;
        for (uint j = 0; j < bills[id].amounts.length; j++) {
            if(bills[id].amounts[j] != 0) {
                if(bills[id].payStatuses[j] != 2) {
                    notPayedCount++;
                }
            }
        }
        
        if(notPayedCount == 0) {
            bills[id].status = 3;
            Dead(id);
        }
    }
    
    function getBillById(uint id) public constant returns (uint, address, uint, string, string) {
        var bill = bills[id];
        return (bill.status, bill.reciever, bill.summ, bill.clientData, bill.payers);
    }

}
                     

Пример №3

В данном смарт-контракте поступают новые требования - нужно разделять историю платежей и историю статусов плательщиков - вводятся понятия заморозки и разморозки счетов. Комбинация из трех смарт-контрактов покрывает новые кейсы в решении проблемы.

  • Язык программирования: Solidity

pragma solidity ^0.4.11;

contract Payer {
    
    bytes32[] id;
    string name;
    uint frozeStart;
    uint period = 3000;
    uint balance = 0;
    
    event Frozen(address frozened, uint amount);
    event Unfrozen(address winner, uint amount);
    event Priveleged(bytes32[] id);
    
    function Payer(bytes32[] id, string name, uint balance) {
        id = id;
        name = name;
        balance = balance;
    }
    
    function frozePayer() {
        frozeStart = now;
    }
    
    function unfrozePayer() {
        require(now >= (frozeStart + period)); 
        Unfrozen(this, balance);
    }
    
    function addPriveleges() {
        Priveleged(id);
    }

}

contract BillFactory {
    
    
    event Dead(
        uint billId
    );
    
    Bill[] bills;

    function createBill (bytes32 name, uint summ) {
        Bill newBill = new Bill(name, summ);
        bills.push(newBill);
    } 
    
    // function getBill (uint i) public constant returns (uint, address, uint, string, string) {
    //     Bill bill = Bill(bills[i]);
    //     return (bill.status, bill.reciever, bill.summ, bill.clientData, bill.payers);
    // }
    
    string[] names;
    
    event Closed(
        uint billId
    );
    
    event Saved(
        uint billId
    );
    
    function saveOpenBill(uint id, address reciever, uint summ, string clientData, string payers, address[] wallets, int[] amounts, int[] payStatuses) {
        bills[id] = Bill(id, 1, reciever, summ, clientData, payers, wallets, amounts, payStatuses);
        Saved(id);
    }
    
    function setClosing(uint id, address[] wallets, int[] amounts) public {
        bills[id].status = 2;
        bills[id].wallets = wallets;
        bills[id].amounts = amounts;
        Closed(id);
    }
    
    function getAmounts(uint id) public constant returns (int[])  {
        return bills[id].amounts;
    }
    
    function getWallets(uint id) public constant returns (address[])  {
        return bills[id].wallets;
    }
    
    function getPayStatuses(uint id) public constant returns (int[])  {
        return bills[id].payStatuses;
    }
    
    function confirm(uint id, address wallet) public {
        
        var bill = bills[id];
        for (uint i = 0; i < bill.length; i++) {
            if (wallet == bill.wallets[i]) {
                bills[id].payStatuses[i] = 2;
            }
        }
        
        int notPayedCount = 0;
        for (uint j = 0; j < bill.length; j++) {
            if(bills[id].amounts[j] != 0) {
                if(bills[id].payStatuses[j] != 2) {
                    notPayedCount++;
                }
            }
        }
        
        if(notPayedCount == 0) {
            bills[id].status = 3;
            Dead(id);
        }
    }
    
    
}

contract Bill {
    
    event Closed(
        uint billId
    );
    
    event Saved(
        uint billId
    );
    
    event Reserved(
        uint billId
    );
    
    uint id;
    uint status;
    address reciever;
    uint summ;
    string clientData;
    Payer[] payers;
    address[] wallets;
    int[] amounts;
    int[] payStatuses;

    function Bill (bytes32 name, uint summ) {
        name = name;
        summ = summ;
    }
    
    function closeBill() {
        Closed(id);
    }
    
    function reserveBill() {
        Reserved(id);
    }
    
}
                    

Лицензия

Вы можете свободно распространять и использовать данный код по своему усмотрению

Мы на связи