Introducing the First Fully Decentralized DataPlatform

Trading On 3 Exchanges December 2018

Shardix In The Press

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

iphone2

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.

Product-Focused Team

American Management - Global Team

Advisory Team

  • Mathew Cusack

    Ecosystem Development - As the first advisor to...

    Mathew Cusack

    Ecosystem Development - As the first advisor to Sia tech, Mathew has extensive experience in the Blockchain...

  • David Cleary

    Infrastructure - David hold numerous patents in...

    David Cleary

    Infrastructure - David hold numerous patents in network computing and has over 25 years experience in...

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];
}
}
view raw Test.rdn hosted with ❤ by GitHub

Pin It on Pinterest

Share This