Roadmap
Pryvate App Launches (2013 - February 2018)
- Decentralization initiative starts
- ICO underway
- Pryvatecoin.io website launch
- Pryvate App/PVC development
Integration begins
- Smart Contract released with 32.5 million coins available
- PryvateCoin Exchange and Swap services enabled




Phase 2 (February 2018 - April 2018)
- App decentralization continues with Web service technical documentation
- Marketing
- Coin promotion
- Coin/App development of integrated services documentation


Phase 3 (April 2018 - June 2018)
- Pryvate Web services development
- PryvateCoin and Pryvate App Tokenization (Subscription Services)
- Exchange Integration




Phase 4 (June 2018 - September 2018)
- PVC Deployment
- Partner program initiative
- PryvateCoin Industry API deployment
Token Distribution & Allocation

Token Price
1 ETH = 1205 PVC Participation via ETHPryvateCoin
Decimals : 18 Symbol : PVC Type : Utility Blockchain : Ethereum ERC-20Use of Proceeds




Features

Upcoming Features
Smart Contract
pragma solidity ^0.4.21;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
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) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
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;
}
}
/**
* @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() public {
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) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface TokenInterface {
function totalSupply() external constant returns (uint);
function balanceOf(address tokenOwner) external constant returns (uint balance);
function allowance(address tokenOwner, address spender) external constant returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed burner, uint256 value);
}
contract PVCCrowdsale is Ownable{
using SafeMath for uint256;
// The token being sold
TokenInterface public token;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
uint256 public endTime;
// how many token units a buyer gets per wei
uint256 public ratePerWei = 1000;
// amount of raised money in wei
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 maxTokensToSale;
uint256 TokensForTeamVesting;
uint256 TokensForAdvisorVesting;
uint256 bonusInPreSalePhase1;
uint256 bonusInPreSalePhase2;
uint256 bonusInPublicSalePhase1;
uint256 bonusInPublicSalePhase2;
uint256 bonusInPublicSalePhase3;
uint256 bonusInPublicSalePhase4;
uint256 bonusInPublicSalePhase5;
uint256 bonusInPublicSalePhase6;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 145 days;
mapping(address=>bool) isAddressWhiteListed;
/**
* event for token purchase logging
* @param purchaser who paid for the tokens
* @param beneficiary who got the tokens
* @param value weis paid for purchase
* @param amount amount of tokens purchased
*/
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function PVCCrowdsale(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_wallet != 0x0);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = 32500000 * 10 ** 18;
TOKENS_SOLD = 346018452900000000000; // the tokens that have been sold through the previous contract
weiRaised = 285373570000000000; // the weis that have been raised through the previous contract
bonusInPreSalePhase1 = 30;
bonusInPreSalePhase2 = 25;
bonusInPublicSalePhase1 = 20;
bonusInPublicSalePhase2 = 25;
bonusInPublicSalePhase3 = 20;
bonusInPublicSalePhase4 = 15;
bonusInPublicSalePhase5 = 10;
bonusInPublicSalePhase6 = 5;
TokensForTeamVesting = 7000000 * 10 ** 18;
TokensForAdvisorVesting = 3000000 * 10 ** 18;
token = TokenInterface(_tokenAddress);
}
// fallback function can be used to buy tokens
function () public payable {
buyTokens(msg.sender);
}
function determineBonus(uint tokens) internal view returns (uint256 bonus)
{
uint256 timeElapsed = now - startTime;
uint256 timeElapsedInDays = timeElapsed.div(1 days);
//Closed pre-sale phase 1 (8 days starting apr 9)
if (timeElapsedInDays <8)
{
bonus = tokens.mul(bonusInPreSalePhase1);
bonus = bonus.div(100);
require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSale);
}
//Closed pre-sale phase 2 (8 days starting apr 17)
else if (timeElapsedInDays >=8 && timeElapsedInDays <16)
{
bonus = tokens.mul(bonusInPreSalePhase2);
bonus = bonus.div(100);
require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSale);
}
//Public sale phase 1 original (30 days starting on apr 25)
//Public sale phase 1 new (10 days ending may 4)
else if (timeElapsedInDays >=16 && timeElapsedInDays <26)
{
bonus = tokens.mul(bonusInPublicSalePhase1);
bonus = bonus.div(100);
require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSale);
}
//Public sale phase 2 (27 days)
else if (timeElapsedInDays >=26 && timeElapsedInDays <53)
{
bonus = tokens.mul(bonusInPublicSalePhase2);
bonus = bonus.div(100);
require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSale);
}
//Public sale phase 3 (30 days)
else if (timeElapsedInDays >=53 && timeElapsedInDays <83)
{
bonus = tokens.mul(bonusInPublicSalePhase3);
bonus = bonus.div(100);
require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSale);
}
//Public sale phase 4 (15 days)
else if (timeElapsedInDays >=83 && timeElapsedInDays <98)
{
bonus = tokens.mul(bonusInPublicSalePhase4);
bonus = bonus.div(100);
require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSale);
}
//Public sale phase 5 (16 days)
else if (timeElapsedInDays >=98 && timeElapsedInDays <114)
{
bonus = tokens.mul(bonusInPublicSalePhase5);
bonus = bonus.div(100);
require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSale);
}
//Public sale phase 6 (31 days)
else if (timeElapsedInDays >=114 && timeElapsedInDays <145)
{
bonus = tokens.mul(bonusInPublicSalePhase6);
bonus = bonus.div(100);
require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSale);
}
//
else
{
bonus = 0;
}
}
// low level token purchase function
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(isCrowdsalePaused == false);
require(validPurchase());
require(TOKENS_SOLD= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
// @return true if crowdsale event has ended
function hasEnded() public constant returns (bool) {
return now > endTime;
}
/**
* function to change the end timestamp of the ico
* can only be called by owner wallet
**/
function changeEndDate(uint256 endTimeUnixTimestamp) public onlyOwner{
endTime = endTimeUnixTimestamp;
}
/**
* function to change the start timestamp of the ico
* can only be called by owner wallet
**/
function changeStartDate(uint256 startTimeUnixTimestamp) public onlyOwner{
startTime = startTimeUnixTimestamp;
}
/**
* function to change the rate of tokens
* can only be called by owner wallet
**/
function setPriceRate(uint256 newPrice) public onlyOwner {
ratePerWei = newPrice;
}
/**
* function to pause the crowdsale
* can only be called from owner wallet
**/
function pauseCrowdsale() public onlyOwner {
isCrowdsalePaused = true;
}
/**
* function to resume the crowdsale if it is paused
* can only be called from owner wallet
**/
function resumeCrowdsale() public onlyOwner {
isCrowdsalePaused = false;
}
/**
* function through which owner can take back the tokens from the contract
**/
function takeTokensBack() public onlyOwner
{
uint remainingTokensInTheContract = token.balanceOf(address(this));
token.transfer(owner,remainingTokensInTheContract);
}
/**
* once the ICO has ended, owner can send all the unsold tokens to treasury address
**/
function sendUnsoldTokensToTreasury(address treasury) public onlyOwner
{
require(hasEnded());
uint remainingTokensInTheContract = token.balanceOf(address(this));
token.transfer(treasury,remainingTokensInTheContract);
}
}
GitHub
Pryvate Technology
END TO END ENCRYPTION YOU CAN TRUST
Subscribe
Sign up to receive news and updates
Frequently Asked Questions
Have more questions? Ask us anything in our Twitter channel or directly by email at [email protected]
For further information please visit our corporate site:
PryvateNow
- Military-grade encryption combined with RSA 4096-bit and AES 256-bit encryption
- No risk of data being intercepted by hackers, criminals or government surveillance agencies
- Diffie-Hellman (D-H) key exchange, MD5 and SHA512 hash for voice integrity
- Proprietary 'Protection Agent' software that detects, alerts and defends against 'man-in-the-middle' attacks
- Encryption keys that are automatically created on your smartphone for each call
The PryvateCoin (PVC) token is a critical component of the application. It will enable a number of key functions within the Pryvate Ecosystem, with functionality supplemented as the project is further developed. It will allow many of the platform's features to be decentralized, incentivise active and positive participation, block bad and abusive behaviour and create an equitable and transparent system of rewards in which all users will have a say. This right of governance and other equally impactful features will be introduced as the network develops, with PVC playing a critical role for the users' experience and the ongoing success of the platform.
For more details on the implementation, please review our Roadmap and White Paper.
Please click here to register, learn more and get the latest news.
Some of them are MyEtherWallet, Metamask, Mist, ImToken for Android and iOS.
The fuel that allows the distributed application platform to run is Ether (ETH), a form of payment made by the users of the platform to the machines executing the requested operations. Ether functions as the incentive ensuring that developers write quality applications, since wasteful code is more costly, and that the network remains healthy and people are compensated for their contributions to it.
Private Sale:
- Hard Cap Target - $1,000,000 (USD)
- Sale Dates
- April 9th, 2018 - April 17th, 2018 (Bonus 30%)
- April 17th, 2018 - May 5th, 2018 (Bonus 25%)
- Hard Cap Target - $20,000,000 (USD)
- Sale Dates
- May 5th, 2018 - June 1st, 2018 (Bonus 25%)
- June 1st, 2018 - July 1st, 2018 (Bonus 20%)
- July 1st, 2018 - July 15th, 2018 (Bonus 15%)
- July 15th, 2018 - August 1st, 2018 (Bonus 10%)
- August 1st, 2018 - September 1st, 2018 (Bonus 5%)
I.e: Lost phone or other emergency - log into the dashboard and flip the “switch” - cutting off any potential access. This also allows you to set parameters in the event of any type of personal incapacitation. Only you can set those parameters.
I.e: Freeze account, grant/delete access privilege levels (useful for our escrow services)
You are always in control.
