Messages

1

Ethereum Tokens / Re: [ANN] Donated Players Streaming (DPS) - Token for streamers donation

« on: December 14, 2018, 12:39:06 PM »

Here is the Website concept in development.....

2

Ethereum Tokens / Re: [ANN] Donated Players Streaming (DPS) - Token for streamers donation

« on: December 13, 2018, 01:43:54 PM »

Nice project,, but I think is not enough to explain more details about the project and the teams. Pls can you give us more details with their sites and social network

Social networking is in progress of release...will keep up-dated.

3

Ethereum Tokens / Re: [ANN] Donated Players Streaming (DPS) - Token for streamers donation

« on: December 13, 2018, 01:20:41 PM »

DPS token has been listed on Livecoin Exchnage
https://www.livecoin.net/en/trade/index?currencyPair=DPS%2FBTC

4

Ethereum Tokens / [ANN] Donated Players Streaming (DPS) - Token for streamers donation

« on: December 07, 2018, 10:58:37 AM »

Code: [Select]

pragma solidity ^0.4.18;

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

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

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

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

contract Ownable {
  address public owner;
  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

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

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

contract HasNoEther is Ownable {

  function HasNoEther() public payable {
    require(msg.value == 0);
  }

   function() external {
  }

  function reclaimEther() external onlyOwner {
    assert(owner.send(this.balance));
  }
}

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

contract BasicToken is ERC20Basic {
  using SafeMath for uint256;

  mapping(address => uint256) balances;

  function transfer(address _to, uint256 _value) public returns (bool) {
    require(_to != address(0));
    require(_value <= balances[msg.sender]);

    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) public view returns (uint256 balance) {
    return balances[_owner];
  }
}

contract ERC20 is ERC20Basic {
  function allowance(address owner, address spender) public view 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);
}

contract StandardToken is ERC20, BasicToken {

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

  function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
    require(_to != address(0));
    require(_value <= balances[_from]);
    require(_value <= allowed[_from][msg.sender]);

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

  function approve(address _spender, uint256 _value) public returns (bool) {
    allowed[msg.sender][_spender] = _value;
    Approval(msg.sender, _spender, _value);
    return true;
  }

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

  function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
    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) public returns (bool) {
    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 BurnableToken is StandardToken {

    event Burn(address indexed burner, uint256 value);

    function burn(uint256 _value) public {
        require(_value > 0);
        require(_value <= balances[msg.sender]);
        address burner = msg.sender;
        balances[burner] = balances[burner].sub(_value);
        totalSupply = totalSupply.sub(_value);
        Burn(burner, _value);
    }
}

contract DonatedPlayersStreaming is BurnableToken, HasNoEther {

    string public constant name = "Donated Players Streaming";
    string public constant symbol = "DPS";
    uint8 public constant decimals = 18;
    uint256 constant INITIAL_SUPPLY = 30000000 * (10 ** uint256(decimals));

    function DonatedPlayersStreaming() public {
        totalSupply = INITIAL_SUPPLY;
        balances[msg.sender] = INITIAL_SUPPLY;
        Transfer(address(0), msg.sender, totalSupply);
    }

    function transfer(address _to, uint256 _value) public returns (bool) {
        return super.transfer(_to, _value);
    }

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
        return super.transferFrom(_from, _to, _value);
    }

    function multiTransfer(address[] recipients, uint256[] amounts) public {
        require(recipients.length == amounts.length);
        for (uint i = 0; i < recipients.length; i++) {
            transfer(recipients[i], amounts[i]);
        }
    }
}

The essence of the token DPS (Donated Players Streaming) is that it can replace or be an alternative to fiat currency in donation to streamers.

With such way of donation streamers are protected from any kind of prohibitions or restrictions.

There is opportunity to donate in an equivalent of any currency.

In case of token price growth a streamer can get award even more that was actually donated.

DPS use is ultimately easy. The only thing a streamer needs to do is to get Ethereum wallet and connect DPS contract. That’s it!

The Token shall be represented at several exchanges.

Market will be supplied with at least DPS3.000.000 at underestimated price initially. In a few days the price shall grow due to demand ramp up.

We are going to suggest several channels to integrate such option of donations.

Test channel is scheduled to be created at youtube.com where anyone can find videos containing guidance on how to use and trade the crypto tokens.

Negotiations scheduled with such streaming platforms like Twitch, mixer, vk Live, streamcraft, cybergame, StreamMe.