ICO:奖金+20%的代币

RU:COIN 忠誠

俄羅斯貨幣RUCOIN
加密貨幣由RUCOIN LOYALTY的義務保證

Soft Cap $1.000.000: 成功地到达

1 ETH = 750 Rucoin | 1 BTC = 7500 Rucoin | +20% Bonus

$ 1.155.215

$ 4.500.000

Token Sale收集

$1155215

25

比特币收到

200

Ethereum收到

玫瑰色的认与奖金20%后

! 根据比特币网络流量,数字可能会延迟

关于项目

RUCOIN令牌和統一全球忠誠度網絡共同努力,成為虛擬貨幣數字世界與世界各地知名品牌的現實獎勵/折扣之間的橋樑。

 

RUCOIN的特點。

 

    • 穩定的加密貨幣,每季度增加負債。
    • 消費者現在不需要將不同的獎勵積分,獎勵積分結合起來,只需在全球忠誠網絡中使用RUCOIN,即可獲得對他們有實際價值的商品和服務。
  • 截止到14/01/2018 10:02有87家商店提供1 082 632報價。
  • 忠誠度網絡提供:
  • 1.對消費者來說,這是一個包含RUCOIN的錢包,顯示了RUCOIN的等價物。 根據忠誠計劃為RUCOIN購買的商品清單。 在RUCOIN令牌的現金返還。
  • 安全的交易使用加密貨幣Rucoin,比特幣,以太坊。 在一項安全交易中,RUCOIN LOYALTY作為交易雙方執行交易的擔保人。
  • 2.品牌:指數擴大合作夥伴忠誠度網絡的機會。 這將通過消費者的使用/還款來減少他們的資產負債表負債。
  • 希望獲得新客戶的製造商和品牌也可能成為RUCOIN LOYALTY的成員。
  • 3.對於所有者(應用程序/網站):一種方便而有形的方式來獎勵用戶的參與,而沒有創建和管理獎勵系統的麻煩。
  • Rucoin是集成到ThePowe網絡中的ERC20令牌,它將成為一種交換手段
    並在系統中使用。 作為加密貨幣,RUCOIN令牌將在世界各地的合作夥伴品牌之
    間提供無限,安全和安全的交易。 此外,RUCOIN也將成為尋求吸引用戶的網站
    所有者的退出點。
    這種模式將導致生態系統中的消費者基礎的增加,這將導致交易的增加。
  • 提出的解決方案的關鍵組成部分將是RUCOIN,即與客戶和RUCOIN LOYALTY
    網絡的交互的複合體。

 

  • 警告! 官方Rucoin不在交易所進行交易!
  • advantages
    RuCoin-带有开源代码的加密货币
  • advantages
    付款会在公开块链中发布,它将提供交易的保密性或选择性的透明度。
  • advantages
    RuCoin有共计5亿个数,并会从使用Rucoin的服务获得利润。
  • advantages
    BFT 委派的验证程序节点 + DPoS 委派的共享证明
  • advantages
    交易确认速度小于1秒。
  • advantages
    與Rucoin,比特幣,以太坊進行安全交易
  • advantages
    每秒超过100000的操作的吞吐量。Macbook 每秒10 000……
  • advantages
    使用 Rucoin 作为结算单位来结算、奖励、股份和折扣的单位、发奖金等
  • advantages
    0.01%最大交易佣金
  • advantages
    自动化会帮助减少系统运行成本。
  • advantages
    快速、安全的实名认证。
  • advantages
    穩定和可預測的令牌。
使用RUCOIN
忠誠規則 - RUCOIN中的產品或服務價格至少降低5%
  • title

    購買商品和服務

  • title

    在RUCOIN收到獎金並返現至5%

  • title

    在RUCOIN購買商品和服務的折扣高達

一個交易平台,獎金RUCOIN已經從79家商店超過1 105 428個報價
rl
任何類型的忠誠計劃
  • 不變的最低折扣5%
  • 最小現金返還
  • 忠誠計劃
  • 假日促銷
  • 新一代的返現
android ios
我們正在合作
title
title
title
title
title
发展蓝图
  • 2014年2月12日
    建立RuCoin Community。塑造平台的愿景和意识形态。
  • 2014年12月
    市场分析及其需求。第一个Rucoin平台原型的研制。
  • 2016年10月
    开发和测试平台的Alpha版本以及开发BRC平台
  • 2017年11月
    开始RUCOIN的售前工作。开始生产BIOTEK产品。
  • 2018年3月
    内部货币兑换。在国际交易所中列入RUCOIN加密货币。
  • 2018年2月
    启动RUCOIN平台工作
  • 2018年1月
    RUCOIN的Token Sale
  • 2017年12月
    RUCOIN CHECK平台的法律结构和其原型。BRCICO網站
  • 2018年4月
    启动Rucoin Loyalty、See Life、Smart Reputation、Movie Worker、Rucoin Check。
  • 2018年5月
    iOS版应用程序。改善WEB-版本。
  • 2018年7月
    安卓版应用程序。平台的SEO和SMM优化。
  • 2018年8月
    开发其他功能。与第三方服务合作。
  • 2018年9月
    将平台语言化,加入其他语言。
令牌销售
  • PRE-ICO RUCOIN

    开始: 22.11.2017 (12:00 AM MSK Time, UTC+3)

    结束: 27.12.2017 (1:59 PM MSK Time, UTC+3)

    支持的货币: Bitcoin (ВТС), Ethereum (ETH)

    Bitcoin的最低交易: 0.0025

    Ethereum的最低交易: 0.04

    1 RUCOIN = $1.2的价钱。奖励:

    最少 : 10 個代幣; 最大 : 50 000 萬令牌;

    30% – 22.11.2017

    25% – 29.11.2017

    有限数量— 4.500.000 令牌

  • ICO RUCOIN

    开始: 15.01.2018 (12:00 AM MSK Time, UTC+)

    结束: 15.04.2018 (12:00PM MSK Time, UTC+3)

    支持的货币: Bitcoin (ВТС), Ethereum (ETH)

    Bitcoin的最低交易: 0.0025

    Ethereum的最低交易: 0.04

    1 RUCOIN = $2的价钱。奖励:

    最少 : 10 個代幣; 最大 : 50 000 萬令牌;

    20% – 15.01.2018 – 40.500.000 令牌

     

    有限数量— 40.500.000 令牌

Smart contract rucoin
// Created using ICO Wizard https://github.com/oraclesorg/ico-wizard by Oracles Network 
pragma solidity ^0.4.11;


/**
 * @title ERC20Basic
 * @dev Simpler version of ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/179
 */
contract ERC20Basic {
  uint256 public totalSupply;
  function balanceOf(address who) public constant returns (uint256);
  function transfer(address to, uint256 value) public returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
}



/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;


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


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  function Ownable() {
    owner = msg.sender;
  }


  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }


  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) onlyOwner public {
    require(newOwner != address(0));
    OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }

}
// Temporarily have SafeMath here until all contracts have been migrated to SafeMathLib version from OpenZeppelin




/**
 * Math operations with safety checks
 */
contract SafeMath {
  function safeMul(uint a, uint b) internal returns (uint) {
    uint c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

  function safeDiv(uint a, uint b) internal returns (uint) {
    assert(b > 0);
    uint c = a / b;
    assert(a == b * c + a % b);
    return c;
  }

  function safeSub(uint a, uint b) internal returns (uint) {
    assert(b <= a);
    return a - b;
  }

  function safeAdd(uint a, uint b) internal returns (uint) {
    uint c = a + b;
    assert(c>=a && c>=b);
    return c;
  }

  function max64(uint64 a, uint64 b) internal constant returns (uint64) {
    return a >= b ? a : b;
  }

  function min64(uint64 a, uint64 b) internal constant returns (uint64) {
    return a < b ? a : b;
  }

  function max256(uint256 a, uint256 b) internal constant returns (uint256) {
    return a >= b ? a : b;
  }

  function min256(uint256 a, uint256 b) internal constant returns (uint256) {
    return a < b ? a : b;
  }

}
/**
 * This smart contract code is Copyright 2017 TokenMarket Ltd. For more information see https://tokenmarket.net
 *
 * Licensed under the Apache License, version 2.0: https://github.com/TokenMarketNet/ico/blob/master/LICENSE.txt
 */



/**
 * This smart contract code is Copyright 2017 TokenMarket Ltd. For more information see https://tokenmarket.net
 *
 * Licensed under the Apache License, version 2.0: https://github.com/TokenMarketNet/ico/blob/master/LICENSE.txt
 */










/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
contract ERC20 is ERC20Basic {
  function allowance(address owner, address spender) public constant returns (uint256);
  function transferFrom(address from, address to, uint256 value) public returns (bool);
  function approve(address spender, uint256 value) public returns (bool);
  event Approval(address indexed owner, address indexed spender, uint256 value);
}




/**
 * Standard ERC20 token with Short Hand Attack and approve() race condition mitigation.
 *
 * Based on code by FirstBlood:
 * https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
 */
contract StandardToken is ERC20, SafeMath {

  /* Token supply got increased and a new owner received these tokens */
  event Minted(address receiver, uint amount);

  /* Actual balances of token holders */
  mapping(address => uint) balances;

  /* approve() allowances */
  mapping (address => mapping (address => uint)) allowed;

  /* Interface declaration */
  function isToken() public constant returns (bool weAre) {
    return true;
  }

  function transfer(address _to, uint _value) returns (bool success) {
    balances[msg.sender] = safeSub(balances[msg.sender], _value);
    balances[_to] = safeAdd(balances[_to], _value);
    Transfer(msg.sender, _to, _value);
    return true;
  }

  function transferFrom(address _from, address _to, uint _value) returns (bool success) {
    uint _allowance = allowed[_from][msg.sender];

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

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

  function approve(address _spender, uint _value) returns (bool success) {

    // To change the approve amount you first have to reduce the addresses`
    //  allowance to zero by calling `approve(_spender, 0)` if it is not
    //  already 0 to mitigate the race condition described here:
    //  https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
    if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;

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

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

}

/**
 * This smart contract code is Copyright 2017 TokenMarket Ltd. For more information see https://tokenmarket.net
 *
 * Licensed under the Apache License, version 2.0: https://github.com/TokenMarketNet/ico/blob/master/LICENSE.txt
 */





/**
 * This smart contract code is Copyright 2017 TokenMarket Ltd. For more information see https://tokenmarket.net
 *
 * Licensed under the Apache License, version 2.0: https://github.com/TokenMarketNet/ico/blob/master/LICENSE.txt
 */



/**
 * Upgrade agent interface inspired by Lunyr.
 *
 * Upgrade agent transfers tokens to a new contract.
 * Upgrade agent itself can be the token contract, or just a middle man contract doing the heavy lifting.
 */
contract UpgradeAgent {

  uint public originalSupply;

  /** Interface marker */
  function isUpgradeAgent() public constant returns (bool) {
    return true;
  }

  function upgradeFrom(address _from, uint256 _value) public;

}


/**
 * A token upgrade mechanism where users can opt-in amount of tokens to the next smart contract revision.
 *
 * First envisioned by Golem and Lunyr projects.
 */
contract UpgradeableToken is StandardToken {

  /** Contract / person who can set the upgrade path. This can be the same as team multisig wallet, as what it is with its default value. */
  address public upgradeMaster;

  /** The next contract where the tokens will be migrated. */
  UpgradeAgent public upgradeAgent;

  /** How many tokens we have upgraded by now. */
  uint256 public totalUpgraded;

  /**
   * Upgrade states.
   *
   * - NotAllowed: The child contract has not reached a condition where the upgrade can bgun
   * - WaitingForAgent: Token allows upgrade, but we don't have a new agent yet
   * - ReadyToUpgrade: The agent is set, but not a single token has been upgraded yet
   * - Upgrading: Upgrade agent is set and the balance holders can upgrade their tokens
   *
   */
  enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}

  /**
   * Somebody has upgraded some of his tokens.
   */
  event Upgrade(address indexed _from, address indexed _to, uint256 _value);

  /**
   * New upgrade agent available.
   */
  event UpgradeAgentSet(address agent);

  /**
   * Do not allow construction without upgrade master set.
   */
  function UpgradeableToken(address _upgradeMaster) {
    upgradeMaster = _upgradeMaster;
  }

  /**
   * Allow the token holder to upgrade some of their tokens to a new contract.
   */
  function upgrade(uint256 value) public {

      UpgradeState state = getUpgradeState();
      if(!(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading)) {
        // Called in a bad state
        throw;
      }

      // Validate input value.
      if (value == 0) throw;

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

      // Take tokens out from circulation
      totalSupply = safeSub(totalSupply, value);
      totalUpgraded = safeAdd(totalUpgraded, value);

      // Upgrade agent reissues the tokens
      upgradeAgent.upgradeFrom(msg.sender, value);
      Upgrade(msg.sender, upgradeAgent, value);
  }

  /**
   * Set an upgrade agent that handles
   */
  function setUpgradeAgent(address agent) external {

      if(!canUpgrade()) {
        // The token is not yet in a state that we could think upgrading
        throw;
      }

      if (agent == 0x0) throw;
      // Only a master can designate the next agent
      if (msg.sender != upgradeMaster) throw;
      // Upgrade has already begun for an agent
      if (getUpgradeState() == UpgradeState.Upgrading) throw;

      upgradeAgent = UpgradeAgent(agent);

      // Bad interface
      if(!upgradeAgent.isUpgradeAgent()) throw;
      // Make sure that token supplies match in source and target
      if (upgradeAgent.originalSupply() != totalSupply) throw;

      UpgradeAgentSet(upgradeAgent);
  }

  /**
   * Get the state of the token upgrade.
   */
  function getUpgradeState() public constant returns(UpgradeState) {
    if(!canUpgrade()) return UpgradeState.NotAllowed;
    else if(address(upgradeAgent) == 0x00) return UpgradeState.WaitingForAgent;
    else if(totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
    else return UpgradeState.Upgrading;
  }

  /**
   * Change the upgrade master.
   *
   * This allows us to set a new owner for the upgrade mechanism.
   */
  function setUpgradeMaster(address master) public {
      if (master == 0x0) throw;
      if (msg.sender != upgradeMaster) throw;
      upgradeMaster = master;
  }

  /**
   * Child contract can enable to provide the condition when the upgrade can begun.
   */
  function canUpgrade() public constant returns(bool) {
     return true;
  }

}

/**
 * This smart contract code is Copyright 2017 TokenMarket Ltd. For more information see https://tokenmarket.net
 *
 * Licensed under the Apache License, version 2.0: https://github.com/TokenMarketNet/ico/blob/master/LICENSE.txt
 */







/**
 * Define interface for releasing the token transfer after a successful crowdsale.
 */
contract ReleasableToken is ERC20, Ownable {

  /* The finalizer contract that allows unlift the transfer limits on this token */
  address public releaseAgent;

  /** A crowdsale contract can release us to the wild if ICO success. If false we are are in transfer lock up period.*/
  bool public released = false;

  /** Map of agents that are allowed to transfer tokens regardless of the lock down period. These are crowdsale contracts and possible the team multisig itself. */
  mapping (address => bool) public transferAgents;

  /**
   * Limit token transfer until the crowdsale is over.
   *
   */
  modifier canTransfer(address _sender) {

    if(!released) {
        if(!transferAgents[_sender]) {
            throw;
        }
    }

    _;
  }

  /**
   * Set the contract that can call release and make the token transferable.
   *
   * Design choice. Allow reset the release agent to fix fat finger mistakes.
   */
  function setReleaseAgent(address addr) onlyOwner inReleaseState(false) public {

    // We don't do interface check here as we might want to a normal wallet address to act as a release agent
    releaseAgent = addr;
  }

  /**
   * Owner can allow a particular address (a crowdsale contract) to transfer tokens despite the lock up period.
   */
  function setTransferAgent(address addr, bool state) onlyOwner inReleaseState(false) public {
    transferAgents[addr] = state;
  }

  /**
   * One way function to release the tokens to the wild.
   *
   * Can be called only from the release agent that is the final ICO contract. It is only called if the crowdsale has been success (first milestone reached).
   */
  function releaseTokenTransfer() public onlyReleaseAgent {
    released = true;
  }

  /** The function can be called only before or after the tokens have been releasesd */
  modifier inReleaseState(bool releaseState) {
    if(releaseState != released) {
        throw;
    }
    _;
  }

  /** The function can be called only by a whitelisted release agent. */
  modifier onlyReleaseAgent() {
    if(msg.sender != releaseAgent) {
        throw;
    }
    _;
  }

  function transfer(address _to, uint _value) canTransfer(msg.sender) returns (bool success) {
    // Call StandardToken.transfer()
   return super.transfer(_to, _value);
  }

  function transferFrom(address _from, address _to, uint _value) canTransfer(_from) returns (bool success) {
    // Call StandardToken.transferForm()
    return super.transferFrom(_from, _to, _value);
  }

}

/**
 * This smart contract code is Copyright 2017 TokenMarket Ltd. For more information see https://tokenmarket.net
 *
 * Licensed under the Apache License, version 2.0: https://github.com/TokenMarketNet/ico/blob/master/LICENSE.txt
 */




/**
 * This smart contract code is Copyright 2017 TokenMarket Ltd. For more information see https://tokenmarket.net
 *
 * Licensed under the Apache License, version 2.0: https://github.com/TokenMarketNet/ico/blob/master/LICENSE.txt
 */



/**
 * Safe unsigned safe math.
 *
 * https://blog.aragon.one/library-driven-development-in-solidity-2bebcaf88736#.750gwtwli
 *
 * Originally from https://raw.githubusercontent.com/AragonOne/zeppelin-solidity/master/contracts/SafeMathLib.sol
 *
 * Maintained here until merged to mainline zeppelin-solidity.
 *
 */
library SafeMathLibExt {

  function times(uint a, uint b) returns (uint) {
    uint c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

  function divides(uint a, uint b) returns (uint) {
    assert(b > 0);
    uint c = a / b;
    assert(a == b * c + a % b);
    return c;
  }

  function minus(uint a, uint b) returns (uint) {
    assert(b <= a);
    return a - b;
  }

  function plus(uint a, uint b) returns (uint) {
    uint c = a + b;
    assert(c>=a);
    return c;
  }

}




/**
 * A token that can increase its supply by another contract.
 *
 * This allows uncapped crowdsale by dynamically increasing the supply when money pours in.
 * Only mint agents, contracts whitelisted by owner, can mint new tokens.
 *
 */
contract MintableTokenExt is StandardToken, Ownable {

  using SafeMathLibExt for uint;

  bool public mintingFinished = false;

  /** List of agents that are allowed to create new tokens */
  mapping (address => bool) public mintAgents;

  event MintingAgentChanged(address addr, bool state  );

  /** inPercentageUnit is percents of tokens multiplied to 10 up to percents decimals.
  * For example, for reserved tokens in percents 2.54%
  * inPercentageUnit = 254
  * inPercentageDecimals = 2
  */
  struct ReservedTokensData {
    uint inTokens;
    uint inPercentageUnit;
    uint inPercentageDecimals;
  }

  mapping (address => ReservedTokensData) public reservedTokensList;
  address[] public reservedTokensDestinations;
  uint public reservedTokensDestinationsLen = 0;

  function setReservedTokensList(address addr, uint inTokens, uint inPercentageUnit, uint inPercentageDecimals) onlyOwner {
    reservedTokensDestinations.push(addr);
    reservedTokensDestinationsLen++;
    reservedTokensList[addr] = ReservedTokensData({inTokens:inTokens, inPercentageUnit:inPercentageUnit, inPercentageDecimals: inPercentageDecimals});
  }

  function getReservedTokensListValInTokens(address addr) constant returns (uint inTokens) {
    return reservedTokensList[addr].inTokens;
  }

  function getReservedTokensListValInPercentageUnit(address addr) constant returns (uint inPercentageUnit) {
    return reservedTokensList[addr].inPercentageUnit;
  }

  function getReservedTokensListValInPercentageDecimals(address addr) constant returns (uint inPercentageDecimals) {
    return reservedTokensList[addr].inPercentageDecimals;
  }

  function setReservedTokensListMultiple(address[] addrs, uint[] inTokens, uint[] inPercentageUnit, uint[] inPercentageDecimals) onlyOwner {
    for (uint iterator = 0; iterator < addrs.length; iterator++) {
      setReservedTokensList(addrs[iterator], inTokens[iterator], inPercentageUnit[iterator], inPercentageDecimals[iterator]);
    }
  }

  /**
   * Create new tokens and allocate them to an address..
   *
   * Only callably by a crowdsale contract (mint agent).
   */
  function mint(address receiver, uint amount) onlyMintAgent canMint public {
    totalSupply = totalSupply.plus(amount);
    balances[receiver] = balances[receiver].plus(amount);

    // This will make the mint transaction apper in EtherScan.io
    // We can remove this after there is a standardized minting event
    Transfer(0, receiver, amount);
  }

  /**
   * Owner can allow a crowdsale contract to mint new tokens.
   */
  function setMintAgent(address addr, bool state) onlyOwner canMint public {
    mintAgents[addr] = state;
    MintingAgentChanged(addr, state);
  }

  modifier onlyMintAgent() {
    // Only crowdsale contracts are allowed to mint new tokens
    if(!mintAgents[msg.sender]) {
        throw;
    }
    _;
  }

  /** Make sure we are not done yet. */
  modifier canMint() {
    if(mintingFinished) throw;
    _;
  }
}



/**
 * A crowdsaled token.
 *
 * An ERC-20 token designed specifically for crowdsales with investor protection and further development path.
 *
 * - The token transfer() is disabled until the crowdsale is over
 * - The token contract gives an opt-in upgrade path to a new contract
 * - The same token can be part of several crowdsales through approve() mechanism
 * - The token can be capped (supply set in the constructor) or uncapped (crowdsale contract can mint new tokens)
 *
 */
contract CrowdsaleTokenExt is ReleasableToken, MintableTokenExt, UpgradeableToken {

  /** Name and symbol were updated. */
  event UpdatedTokenInformation(string newName, string newSymbol);

  string public name;

  string public symbol;

  uint public decimals;

  /* Minimum ammount of tokens every buyer can buy. */
  uint public minCap;

  /**
   * Construct the token.
   *
   * This token must be created through a team multisig wallet, so that it is owned by that wallet.
   *
   * @param _name Token name
   * @param _symbol Token symbol - should be all caps
   * @param _initialSupply How many tokens we start with
   * @param _decimals Number of decimal places
   * @param _mintable Are new tokens created over the crowdsale or do we distribute only the initial supply? Note that when the token becomes transferable the minting always ends.
   */
  function CrowdsaleTokenExt(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable, uint _globalMinCap)
    UpgradeableToken(msg.sender) {

    // Create any address, can be transferred
    // to team multisig via changeOwner(),
    // also remember to call setUpgradeMaster()
    owner = msg.sender;

    name = _name;
    symbol = _symbol;

    totalSupply = _initialSupply;

    decimals = _decimals;

    minCap = _globalMinCap;

    // Create initially all balance on the team multisig
    balances[owner] = totalSupply;

    if(totalSupply > 0) {
      Minted(owner, totalSupply);
    }

    // No more new supply allowed after the token creation
    if(!_mintable) {
      mintingFinished = true;
      if(totalSupply == 0) {
        throw; // Cannot create a token without supply and no minting
      }
    }
  }

  /**
   * When token is released to be transferable, enforce no new tokens can be created.
   */
  function releaseTokenTransfer() public onlyReleaseAgent {
    mintingFinished = true;
    super.releaseTokenTransfer();
  }

  /**
   * Allow upgrade agent functionality kick in only if the crowdsale was success.
   */
  function canUpgrade() public constant returns(bool) {
    return released && super.canUpgrade();
  }

  /**
   * Owner can update token information here.
   *
   * It is often useful to conceal the actual token association, until
   * the token operations, like central issuance or reissuance have been completed.
   *
   * This function allows the token owner to rename the token after the operations
   * have been completed and then point the audience to use the token contract.
   */
  function setTokenInformation(string _name, string _symbol) onlyOwner {
    name = _name;
    symbol = _symbol;

    UpdatedTokenInformation(name, symbol);
  }

}
grah
graf
文件
  • 白皮书

    选择你的语言:

    EN RU
  • 发展蓝图

    选择你的语言:

    EN RU
  • 令牌销售政策

    选择你的语言:

    EN RU
媒体刊物
  • RUCOIN Aims to be the First Decentralized E-commerce Platform
    RUCOIN Aims to be the First Decentralized E-commerce Platform
    Shortly speaking, RUCOIN is a smart marketplace platform with smart contracts, a unique rating system of vendors based on blockchain technology, and transactions...
    06/11/2017
  • RUCOIN Aims to be the First Decentralized E-commerce Platform
    RUCOIN Aims to be the First Decentralized E-commerce Platform
    Shortly speaking, RUCOIN is a smart marketplace platform with smart contracts, a unique rating system of vendors based on blockchain technology, and transactions...
    01/11/2017
  • RUCOIN Aims to be the First Decentralized E-commerce Platform
    RUCOIN Aims to be the First Decentralized E-commerce Platform
    Shortly speaking, RUCOIN is a smart marketplace platform with smart contracts, a unique rating system of vendors based on blockchain technology, and transactions...
    03/11/2017
  • RUCOIN Aims to be the First Decentralized E-commerce Platform
    RUCOIN Aims to be the First Decentralized E-commerce Platform
    Shortly speaking, RUCOIN is a smart marketplace platform with smart contracts, a unique rating system of vendors based on blockchain technology, and transactions...
    09/11/2017
  • RUCOIN Aims to be the First Decentralized E-commerce Platform
    RUCOIN Aims to be the First Decentralized E-commerce Platform
    Shortly speaking, RUCOIN is a smart marketplace platform with smart contracts, a unique rating system of vendors based on blockchain technology, and transactions...
    02/11/2017
  • 只允许在俄罗斯流动国产加密货币。
    只允许在俄罗斯流动国产加密货币。
    面对地缘政治舞台上的全球竞争对手和国外加密货币的发行与流通..。
    16/10/2017
  • 俄罗斯商人要求国产的加密货币的合法化
    俄罗斯商人要求国产的加密货币的合法化
    面对地缘政治舞台上的全球竞争对手和国外加密货币的发行与流通……
    16/10/2017
  • 一分钱一分钱地接近“加密卢布“
    一分钱一分钱地接近“加密卢布“
    在2017年7月,会有一个不太可能公开事件发生,但这应该是最重要的回答问题:是什么真正发生了在俄罗斯与加密货币之间?为什么俄罗斯的银行对他们有这样的态度?
    27/06/2017
  • 加密卢布和加密税:怎么把熊赶在洞穴里?
    加密卢布和加密税:怎么把熊赶在洞穴里?
    关于加密卢布的早期版本的发行已在政治顶端讲了话。然后他们赶紧为这些虚拟卢布加上了税。收入税。我有个加密卢布。
    17/10/2017
  • “翱文狄”协会呼吁俄罗斯联邦只接受国产的加密货币。
    “翱文狄”协会呼吁俄罗斯联邦只接受国产的加密货币。
    “翱文狄”商业协会的代表致函联邦理事会和杜马议长发送了邮件……
    16/10/2017
  • 创建一个国产的加密货币很难,但也可以实现!
    创建一个国产的加密货币很难,但也可以实现!
    今天,在莫斯科开幕了“开放创新”论坛。这次会议的主题之一是数字经济和加密货币。论坛在两天内完成了。
    17/10/2017
  • 在俄罗斯,为其加密货币RuCoin收集基金的工作开始了。
    在俄罗斯,为其加密货币RuCoin收集基金的工作开始了。
    在俄罗斯的一个复式的平台上—boomstarter.ru开始收集资金为实施俄罗斯的加密货币Rucoin项目。发展和支持由研究所“创新技术”进行。
    18/08/2017
  • 只允许在俄罗斯流动国产加密货币。
    只允许在俄罗斯流动国产加密货币。
    面对地缘政治舞台上的全球竞争对手和国外加密货币的发行与流通..。
    16/10/2017
  • 业务要求在国内只流动俄罗斯国产的加密货币
    业务要求在国内只流动俄罗斯国产的加密货币
    商界要求联邦委员会和国家杜马立法只允许在俄罗斯流动国产的加密货币,并指出涉及外币的匿名交易可能是晦涩目的服务,这也可能是一个融资来源
    16/10/2017
  • 商业团体要求联邦委员会和国家杜马立法允许国内 只流动国产加密货币。
    商业团体要求联邦委员会和国家杜马立法允许国内 只流动国产加密货币。
    商界要求联邦委员会和国家杜马立法只允许俄罗斯流动国产加密货币,并指出涉及外币的匿名交易可能有不明目的……
    16/10/2017
  • 在俄罗斯只流动国产加密货币
    在俄罗斯只流动国产加密货币
    发展商务的爱国思想的“翱文狄”商业协会的代表致函联邦委员会和杜马的发言人,瓦伦丁•马特维亚和维亚切斯拉夫•沃罗丁。他们在其中要求立法允许在俄罗斯的通行国产加密货币。
    16/10/2017
  • 俄罗斯联邦政府在新闻报道中介绍并使俄罗斯加密货币的营业额合法化,该报告是由企业家协会在国
    俄罗斯联邦政府在新闻报道中介绍并使俄罗斯加密货币的营业额合法化,该报告是由企业家协会在国
    该报告是由企业家协会在国家杜马和联邦理事会提出的,其目的是发展商业爱国主义,并指出加密货币的存在是一个现代的必需品
    16/10/2017
  • 俄罗斯的加密货币:有什么风险,俄罗斯企业家用RuCoin来干嘛?
    俄罗斯的加密货币:有什么风险,俄罗斯企业家用RuCoin来干嘛?
    俄罗斯的加密货币:它造成的风险以及俄罗斯企业家创建RuCoin干什么用?。加密货币在俄罗斯和世界正在获得势头,并获得更多的粉。今天,人们不必付钱了。
    16/10/2017
  • Ru:硬幣忠誠 - 俄羅斯貨幣Rucoin-Crypto-currency由Rucoin Loyalty的義務保證
    Ru:硬幣忠誠 - 俄羅斯貨幣Rucoin-Crypto-currency由Rucoin Loyalty的義務保證
    RUCOIN Cryptocurrency和一個全球忠誠度網絡是世界上最受歡迎的品牌“獎金/現實世界的折扣。
    05/01/2018
  • 區塊鏈連接虛擬資產和現實世界
    區塊鏈連接虛擬資產和現實世界
    從這篇文章中,您將了解到Rucoin如何在數字世界的虛擬貨幣與現實世界的獎金和折扣之間架起一座橋樑
    15/01/2018
  • 俄羅斯領先的銀行在Cryptocurrency Fever中啟動區塊鏈實驗室
    俄羅斯領先的銀行在Cryptocurrency Fever中啟動區塊鏈實驗室
    區塊鏈技術是一種分佈式和透明的計算系統,它使用密碼技術將信息存儲在越來越多的稱為塊的記錄中。
    11/01/2018
团队
  • 莉利娅•陆戳
    莉利娅•陆戳创始人和总书记

    科学创新部的领导和创始人,Rucoin的创始之一人。

  • 阿列克谢•陆戳
    阿列克谢•陆戳项目经理

    Rucoin创始人之一。分析实现业务顾问。

  • 叶夫格尼•维瑞丁
    叶夫格尼•维瑞丁媒体经理

    战略营销、负责品牌的内容和与社会的关系。

  • 阿列那•谢若千阔
    阿列那•谢若千阔财务主任

    营销和公关企业家。金融技术方面和合法性审查的专家

  • 谢廖沙•郭若伙吴
    谢廖沙•郭若伙吴前端开发人员

    样式和代码的英雄。他创建了用户界面。

  • Purysheva I. U.
    Purysheva I. U.賞金活動經理

    創建並管理賞金活動。 為RuCoin加密貨幣項目提供諮詢和推廣。

告訴我們關於我們的ICO。 獲得2%

現在獲得購買令牌的2%!
2018年2月15日前的薪酬計劃

留在通信support@ru-coin.com

订阅我们的电子邮件通讯是第一个知道所有的新闻

社交网络
  • fb
  • tw
  • tl
  • in
  • yt
  • vk
  • btc
  • ruc
  • wechat
x
x
谢谢你,用于订阅

我们联系您

x
注册表格
x
登录
x
个人信息
x
买以太坊

为保持KYC的程序这个钱包的地址不得公布。别把它交给第三人。最小的交易是0,04 ETH(比特币)。

ethereum
0x8d7B3a122b8379faD019eD35E3899951148d9027
买比特币

为保持KYC的程序这个钱包的地址不得公布。别把它交给第三人。最小的交易是0,0025 BTC(比特币)。

bitcoin
1Jg4imJH5pioWkDbfTq2Z3c7jENmmVoJ7x