Introducing the First Fully Decentralized DataPlatform
Trading On 3 Exchanges December 2018
Shardix In The Press
- https://hardwareate.com/por-que-muchas-ico-fracasan-la-opinion-de-expertos
Our Core
The Future of Database as a Service for the Decentralize Web
Shardix is creating a DataPlatform, a decentralized, on-demand, scalable database service. It will store both structured and unstructured data geographically dispersed and replicated for speed and security, complementary to the other components to make the decentralized Internet complete.
Versatile
Performance
Shardix is developing a geodistributed decentralized sharded database. Shardix reduces latency by retrieving data from the nearest nodes and fastest nodes and as the nodes are symmetric, retrieval can happen in parallel.
Scalable
By Design
Scalability Horizonal scaling is the foundation of Shardix, no more trading off consistency of NOSQL for scalability. Shardix will scale across business and geographic partitions.
Network
Reliability
With Shardix the end user can dictate the level of replication and sharding of their data, allowing many nines of reliability. This makes Shardix immune to partitioning and failure of data-centers, businesses, even entire countries.
Array of
Service Tiers
Beyond choosing replication levels, Shardix Dataplatform users can choose to have their data tiered for faster throughput by choosing the allocation of RAM, SSD, and HD. It’s possible with Shardix to allocate multi-terabyte database fully in RAM.
Powered By

The New Paradigm For Miners
- Storage Miners are a key part of the Shardix DataPlatform. To join, they rent out unused capacity on their rig’s hard drive and RAM.
- This capacity is then sold on the Shardix network and assigned sharded storage. Miners earn passive income by serving database queries based on their shards.
- Together, Storage Miners make up the Shardix Network, which serves as the basis for its dynamically scalable DataPlatform
- Shardix Miners are paid in SDX which accrues based upon bandwidth, storage space, and geographical dispersion. These micro transactions allow for flexible need based service provision.
A New Kind of Database
- By utilizing the Shardix Network, users can access a fully scalable global SQL database service for a fraction of the price of existing solutions.
- Unlike conventional providers, users can optimize for a myriad of performance factors such as RAM, SSD, and Bandwidth, providing the flexibility to ensure a perfect fit for every use case.
Live Shardix Hosted Network Map
The Shardix Hosted Network (SHN) acts as a seed and test network for the Shardix Data Platform.
American Management - Global Team
Richard Nehrboss
CEO - Richard has over 30 years’ experience in business, f...
Richard NehrbossCEO - Richard has over 30 years’ experience in business, finance and software development. With a BS in Computer Systems Engineering from RPI, Richard h...
Olivier Meyer
CTO - Having been the Senior Program Manager of t...
Olivier MeyerCTO - Having been the Senior Program Manager of the SQL Server team at Microsoft, Olivier is uniquely qualified to disrupt the database/data platform i...
Mathew Cusack
Ecosystem Development - As the first advisor to Sia...
Mathew CusackEcosystem Development - As the first advisor to Sia tech, Mathew has extensive experience in the Blockchain Industry. He also co-founded Plug Power, a...
David Cleary
Infrastructure - David hold numerous patents in network...
David ClearyInfrastructure - David hold numerous patents in network computing and has over 25 years experience in the industry. He oversees the framework for the Shardix...
Anita Whitaker
Regulatory Affairs - As a technical writer and regulatory...
Anita WhitakerRegulatory Affairs - As a technical writer and regulatory affairs specialist for numerous NYSE companies including Boston Scientific and Medtronic, Anita...
Private Sale On Now
Start: | August 24, 2018, 12:00 AM (GMT) |
Soft cap: | $3m |
Hardcap: | $38m |
Token: | SDX |
Exchange rate: | 1 ETH = 1400 SDX |
Project protocol: | ERC20 |
Payment Methods
SDX Token Contract Address
TBD. The address is for the SDX token contract. It is NOT a deposit address. Do NOT send tokens to it. To buy click “Get Whitelisted”.
Roadmap
Token Inception
April 25, 2017
Development of the private chain token and test SDX.
Testnet
April 28, 2017
Shardix Network monitoring site. Basic deployment of storage level swarm.
Private Sale
January 28, 2018
Development of private blockchain token and test SDX.
Swarm – Monitor
February 28, 2018
Shardix Network monitoring site. Basic deployment of storage level swarm.
ICO Launch
April 28, 2018
Public token SDX offering. Hire remainder of the team.
Release: Locke
April 28, 2018
OLTP, Referential Integrity, data migration tool.
Release: Socrates
July 1, 2018
Encrypted, sharded storage tier, KV column stores. CRUD socket communication.
Release: Kant
July 28, 2018
ORM interfaces, visualizations.
Release: Plato
October 8, 2018
Client Data Platform Console. Use of SDX to purchase dataplatform services.
Release: Aristotle
January 2, 2019
Tiered storage levels based on latency. Cross boundary partition setup. Joins.
Our Smart Contract
pragma solidity ^0.4.18; | |
/** | |
* @title ERC20Basic | |
* @dev Simpler version of ERC20 interface | |
* @dev see https://github.com/ethereum/EIPs/issues/179 | |
*/ | |
contract ERC20Basic { | |
function totalSupply() public view returns (uint256); | |
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); | |
} | |
/** | |
* @title ERC20 interface | |
* @dev see https://github.com/ethereum/EIPs/issues/20 | |
*/ | |
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); | |
} | |
library SafeMath { | |
function mul(uint256 a, uint256 b) internal pure returns (uint256) { | |
uint256 c = a * b; | |
assert(a == 0 || 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; | |
} | |
} | |
contract Hive is ERC20 { | |
using SafeMath for uint; | |
string public constant name = "UHIVE"; | |
string public constant symbol = "HVE"; | |
uint256 public constant decimals = 18; | |
uint256 _totalSupply = 80000000000 * (10**decimals); | |
mapping (address => bool) public frozenAccount; | |
event FrozenFunds(address target, bool frozen); | |
// Balances for each account | |
mapping(address => uint256) balances; | |
// Owner of account approves the transfer of an amount to another account | |
mapping(address => mapping (address => uint256)) allowed; | |
// Owner of this contract | |
address public owner; | |
// Functions with this modifier can only be executed by the owner | |
modifier onlyOwner() { | |
require(msg.sender == owner); | |
_; | |
} | |
function changeOwner(address _newOwner) onlyOwner public { | |
require(_newOwner != address(0)); | |
owner = _newOwner; | |
} | |
function freezeAccount(address target, bool freeze) onlyOwner public { | |
frozenAccount[target] = freeze; | |
FrozenFunds(target, freeze); | |
} | |
function isFrozenAccount(address _addr) public constant returns (bool) { | |
return frozenAccount[_addr]; | |
} | |
function destroyCoins(address addressToDestroy, uint256 amount) onlyOwner public { | |
require(addressToDestroy != address(0)); | |
require(amount > 0); | |
require(amount <= balances[addressToDestroy]); | |
balances[addressToDestroy] -= amount; | |
_totalSupply -= amount; | |
} | |
// Constructor | |
function Hive() public { | |
owner = msg.sender; | |
balances[owner] = _totalSupply; | |
} | |
function totalSupply() public constant returns (uint256 supply) { | |
supply = _totalSupply; | |
} | |
// What is the balance of a particular account? | |
function balanceOf(address _owner) public constant returns (uint256 balance) { | |
return balances[_owner]; | |
} | |
// Transfer the balance from owner's account to another account | |
function transfer(address _to, uint256 _value) public returns (bool success) { | |
if (_to != address(0) && isFrozenAccount(msg.sender) == false && balances[msg.sender] >= _value && _value > 0 && balances[_to] + _value > balances[_to]) { | |
balances[msg.sender] = balances[msg.sender].sub(_value); | |
balances[_to] = balances[_to].add(_value); | |
Transfer(msg.sender, _to, _value); | |
return true; | |
} else { | |
return false; | |
} | |
} | |
// Send _value amount of tokens from address _from to address _to | |
// The transferFrom method is used for a withdraw workflow, allowing contracts to send | |
// tokens on your behalf, for example to "deposit" to a contract address and/or to charge | |
// fees in sub-currencies; the command should fail unless the _from account has | |
// deliberately authorized the sender of the message via some mechanism; we propose | |
// these standardized APIs for approval: | |
function transferFrom(address _from,address _to, uint256 _value) public returns (bool success) { | |
if (_to != address(0) && isFrozenAccount(_from) == false && balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0 && balances[_to] + _value > balances[_to]) { | |
balances[_from] = balances[_from].sub(_value); | |
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); | |
balances[_to] = balances[_to].add(_value); | |
Transfer(_from, _to, _value); | |
return true; | |
} else { | |
return false; | |
} | |
} | |
// Allow _spender to withdraw from your account, multiple times, up to the _value amount. | |
// If this function is called again it overwrites the current allowance with _value. | |
function approve(address _spender, uint256 _value) public returns (bool success) { | |
allowed[msg.sender][_spender] = _value; | |
Approval(msg.sender, _spender, _value); | |
return true; | |
} | |
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { | |
return allowed[_owner][_spender]; | |
} | |
} |