Global Finance Blockchain Infrastructure

Optherium’s Operating System and MultiDecentralized Private Blockchains Network™ fundamentally changes blockchain technology.

NEXT STAGE STARTS WHEN SOLD OUT OR IN:

00
DAYS
00
HOURS
00
MINUTES
00
SECONDS
$0.75

Current
price

20%

Bonus

25%

Current
discount

$3m

Invested in product
development

$10,000

Minimum
Investment

Media

OPEX token functionality
in Ecosystem

  • Facilitator for currency conversions in the Ecosystem
  • Reduce transaction fees
  • Utility token for Optherium Services
  • ERC-20 token
img img

OPEX as a
Facilitator Token

The primary role of OPEX™ Tokens is to act as a facilitator (Utility) token within the Optherium™ Ecosystem. As a facilitator token, OPEX™ Tokens will serve as an internal liquidity reserve token for the formation of digital-currency pairs with up to 150 digital currencies, permitting rapid internal conversion between currencies in response to user requests. The OPEX™ Tokens held in the liquidity pool will be maintained by the Company for their facilitator function and will not be sold.

img

The OPEX™ token is used as a facilitator for currency conversions in the Ecosystem using the Liquidity Reserve, and on the Optherium MultiDecentralized™ Digital Currency Exchange and Mobile Wallet application.

The OPEX™ token will be used to pay for Optherium Services including the KYC service, the KRS service, and the Digital Data Vault service by any user or client wishing to integrate these services into their own platform. For these services, OPEX™ tokens will be paid for each request.

Founding round conditions

Round A
Whitelist
Pre-Sale
Main Sale
Start Date
5 October 2018
5 December 2018
5 February 2019
End Date
5 December 2018
5 February 2019
5 March 2019
OPEX price, USD
$0.75
$0.85
$1
OPEX Bonus, %
20%
10%
0%
USD Cap
7,500,000
35,500,000
43,000,000
OPEX Cap
10,000,000
41,764,706
51,764,706
Bonus OPEX
2,000,000
4,176,471
6,176,471

Funding Round conditions

Start date
Whitelist
5 October 2018
Pre-Sale
5 December 2018
Main Sale
5 February 2019
End Date
Whitelist
5 December 2018
Pre-Sale
5 February 2019
Main Sale
5 March 2019
OPEX price, USD
Whitelist
$0.75
Pre-Sale
$0.85
Main Sale
$1
OPEX Bonus, %
Whitelist
20%
Pre-Sale
10%
Main Sale
0%
USD Cap
Whitelist
7,500,000
Pre-Sale
35,500,000
Main Sale
43,000,000
OPEX Cap
Whitelist
10,000,000
Pre-Sale
41,764,706
Main Sale
51,764,706
Bonus OPEX
Whitelist
2,000,000
Pre-Sale
4,176,471
Main Sale
6,176,471
Circulating Supply, OPEX
Whitelist
57,941,176
Pre-Sale
57,941,176
Main Sale
57,941,176
Soft Cap:
$5,000,000
Flex Cap:
$43,000,000

If the phase cap is not met, a next phase automatically begins.
If the next phases cap is still not met, any unsold tokens will be added to the OPEX reserve (restricted) and kept for future funding rounds.

Minimum Investment:
$10,000

Individual or Entity

Maximum Investment:
$20,000,000
Currencies Accepted:
currency
currency
currency
currency
currency
currency
currency
Token Generation:
100% premined
Vesting Period:
1 year

for team and for US based investors

Token Swap:
No token swap with other ICO tokens

for team and for US based investors

Escrow:
All collected funds will be held in an escrow account and released only after the soft cap is met based on smart contract logic. Unsold tokens will be returned to an OPEX escrow reserve account (access restricted by multisignature keys with third party law firms) for use only in future product funding rounds.

Token Distribution

  • Node Tokens
    Locked from sale for 1 year. Will not circulate or be sold on an exchange.
    1,504,000,000 OPEX
  • Liquidity Pool Tokens
    Will not be sold
    800,000,000 OPEX
  • Team Tokens
    Locked from sale for 1 year.
    480,000,000 OPEX
  • Investor Tokens
    416,000,000 OPEX
diagramm
47%
From Total Cap
1,504,000,000
OPEX Tokens
25%
From Total Cap
800,000,000
OPEX Tokens
15%
From Total Cap
480,000,000
OPEX Tokens
13%
From Total Cap
416,000,000
OPEX Tokens
3,200,000,000
Max Supply, OPEX
chapter
86%
14%

Unrestricted
Token Distribution

  • Tokens Circulating After
    Token Distribution (57,941,176 OPEX)
    Trading on Exchanges
    57,941,176 OPEX
  • Remaining Unrescticted Tokens After TGE
    (358,058,824 OPEX) Not for Sale

Round A Roadmap

Q1 2018

Registration,
Licenses, Patent
MultiDecentralized
Private Blockchains
Network™, Whitepaper

Q2 2018

Key Recovery Service
Know Your Customer Service
SEC Regulation D

Q3 2018

VivusPay™ eWallet Mobile App,
Whitelist

Q4 2018

Token Listing on exchanges
after Main Sale, B2B Platform,
Dynamic Biometrics™

Q1 2019

Bitcrox™
Exchange MVP

Q2 2019

Bitcrox™ Exchange,
Final MultiDecentralized Data Storage,
P2P, fully-functional Ecosystem

Q3 2019

eCommerce
Platform

Q4 2019

MultiDecentralized
Operating System

Smart Contracts

Node Tokens (1,504,000,000)
pragma solidity 0.4.23;

contract ERC20BasicInterface {
    event Transfer(address indexed from, address indexed to, uint256 value);

    function decimals() public view returns (uint8);
    function name() public view returns (string);
    function symbol() public view returns (string);
    function totalSupply() public view returns (uint256 supply);
    function balanceOf(address _owner) public view returns (uint256 balance);
    function transfer(address _to, uint256 _value) public returns (bool success);
}

contract ERC20Interface is ERC20BasicInterface {
    event Approval(address indexed owner, address indexed spender, uint256 value);

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
    function approve(address _spender, uint256 _value) public returns (bool success);
    function allowance(address _owner, address _spender) public view returns (uint256 remaining);
}

/**
 * @title ERC20Pocket
 *
 * This contract keeps particular token for the single owner.
 *
 * Original purpose is to be able to separate your tokens into different pockets for dedicated purposes.
 * Whenever a withdrawal happen, it will be transparent that tokens were taken from a particular pocket.
 *
 * Contract emits purely informational events when transfers happen, for better visualization on explorers.
 */
contract ERC20Pocket is ERC20BasicInterface {
    ERC20Interface public constant TOKEN = ERC20Interface(0x0b34a04b77Aa9bd2C07Ef365C05f7D0234C95630);
    address public constant OWNER = 0xCba6eE74b7Ca65Bd0506cf21d62bDd7c71F86AD8;
    string constant NAME = 'Optherium Node Tokens';
    string constant SYMBOL = 'OPEXnode';

    modifier onlyOwner() {
        require(msg.sender == OWNER, 'Access denied');
        _;
    }

    function deposit(uint _value) public onlyOwner() returns(bool) {
        require(TOKEN.transferFrom(OWNER, address(this), _value), 'Deposit failed');
        emit Transfer(0x0, OWNER, _value);
        return true;
    }

    function withdraw(address _to, uint _value) public onlyOwner() returns(bool) {
        require(TOKEN.transfer(_to, _value), 'Withdrawal failed');
        emit Transfer(OWNER, 0x0, _value);
        return true;
    }

    function totalSupply() public view returns(uint) {
        return TOKEN.balanceOf(address(this));
    }

    function balanceOf(address _holder) public view returns(uint) {
        if (_holder == OWNER) {
            return totalSupply();
        }
        return 0;
    }

    function decimals() public view returns(uint8) {
        return TOKEN.decimals();
    }

    function name() public view returns(string) {
        return NAME;
    }

    function symbol() public view returns(string) {
        return SYMBOL;
    }

    function transfer(address _to, uint _value) public returns(bool) {
        if (_to == address(this)) {
            deposit(_value);
        } else {
            withdraw(_to, _value);
        }
        return true;
    }

    function recoverTokens(ERC20BasicInterface _token, address _to, uint _value) public onlyOwner() returns(bool) {
        require(address(_token) != address(TOKEN), 'Can not recover this token');
        return _token.transfer(_to, _value);
    }
}

contract OPEXInterface {
    function transferWithLock(address _to, uint _value, uint _unlockDate) public returns(bool);
}

/**
 * @title OPEXnode
 *
 * This contract keeps OPEX tokens for Node.
 * When withdrawal happens, transferred tokens become locked for up to a year.
 */
contract OPEXnode is ERC20Pocket {
    function withdraw(address _to, uint _value) public onlyOwner() returns(bool) {
        OPEXInterface opex = OPEXInterface(address(TOKEN));
        require(opex.transferWithLock(_to, _value, inOneYear()), 'Withdrawal failed.');
        emit Transfer(OWNER, 0x0, _value);
        return true;
    }

    function currentDate() internal view returns(uint) {
        return now;
    }

    function inOneYear() internal view returns(uint) {
        return currentDate() + 1 years;
    }
}
        Team Tokens (480,000,000)
pragma solidity 0.4.23;

contract ERC20BasicInterface {
    event Transfer(address indexed from, address indexed to, uint256 value);

    function decimals() public view returns (uint8);
    function name() public view returns (string);
    function symbol() public view returns (string);
    function totalSupply() public view returns (uint256 supply);
    function balanceOf(address _owner) public view returns (uint256 balance);
    function transfer(address _to, uint256 _value) public returns (bool success);
}

contract ERC20Interface is ERC20BasicInterface {
    event Approval(address indexed owner, address indexed spender, uint256 value);

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
    function approve(address _spender, uint256 _value) public returns (bool success);
    function allowance(address _owner, address _spender) public view returns (uint256 remaining);
}

/**
 * @title ERC20Pocket
 *
 * This contract keeps particular token for the single owner.
 *
 * Original purpose is to be able to separate your tokens into different pockets for dedicated purposes.
 * Whenever a withdrawal happen, it will be transparent that tokens were taken from a particular pocket.
 *
 * Contract emits purely informational events when transfers happen, for better visualization on explorers.
 */
contract ERC20Pocket is ERC20BasicInterface {
    ERC20Interface public constant TOKEN = ERC20Interface(0x0b34a04b77Aa9bd2C07Ef365C05f7D0234C95630);
    address public constant OWNER = 0xCba6eE74b7Ca65Bd0506cf21d62bDd7c71F86AD8;
    string constant NAME = 'Optherium Team Tokens';
    string constant SYMBOL = 'OPEXteam';

    modifier onlyOwner() {
        require(msg.sender == OWNER, 'Access denied');
        _;
    }

    function deposit(uint _value) public onlyOwner() returns(bool) {
        require(TOKEN.transferFrom(OWNER, address(this), _value), 'Deposit failed');
        emit Transfer(0x0, OWNER, _value);
        return true;
    }

    function withdraw(address _to, uint _value) public onlyOwner() returns(bool) {
        require(TOKEN.transfer(_to, _value), 'Withdrawal failed');
        emit Transfer(OWNER, 0x0, _value);
        return true;
    }

    function totalSupply() public view returns(uint) {
        return TOKEN.balanceOf(address(this));
    }

    function balanceOf(address _holder) public view returns(uint) {
        if (_holder == OWNER) {
            return totalSupply();
        }
        return 0;
    }

    function decimals() public view returns(uint8) {
        return TOKEN.decimals();
    }

    function name() public view returns(string) {
        return NAME;
    }

    function symbol() public view returns(string) {
        return SYMBOL;
    }

    function transfer(address _to, uint _value) public returns(bool) {
        if (_to == address(this)) {
            deposit(_value);
        } else {
            withdraw(_to, _value);
        }
        return true;
    }

    function recoverTokens(ERC20BasicInterface _token, address _to, uint _value) public onlyOwner() returns(bool) {
        require(address(_token) != address(TOKEN), 'Can not recover this token');
        return _token.transfer(_to, _value);
    }
}

contract OPEXInterface {
    function transferWithLock(address _to, uint _value, uint _unlockDate) public returns(bool);
}

/**
 * @title OPEXteam
 *
 * This contract keeps OPEX tokens locked for the Optherium team.
 *
 * Unlock date can be extended by OPEX team, but not decreased.
 */
contract OPEXteam is ERC20Pocket {
    uint constant JANUARY_1ST_2020_00_00_00 = 1577836800;
    uint constant JANUARY_1ST_2030_00_00_00 = 1893456000;
    uint public unlockDate = JANUARY_1ST_2020_00_00_00;

    event UnlockDateExtended(uint newUnlockDate);

    function withdraw(address _to, uint _value) public returns(bool) {
        require(currentDate() > unlockDate, 'Tokens are still locked.');
        return super.withdraw(_to, _value);
    }

    function extendUnlockDate(uint _newUnlockDate) public onlyOwner() returns(bool) {
        require(_newUnlockDate > unlockDate, 'New unlock date must be further into the future.');
        require(_newUnlockDate <= JANUARY_1ST_2030_00_00_00, 'New unlock date must be before 1st January 2025.');
        unlockDate = _newUnlockDate;
        emit UnlockDateExtended(_newUnlockDate);
        return true;
    }

    function currentDate() internal view returns(uint) {
        return now;
    }
}
        Liquidity Pool Tokens (800,000,000)
pragma solidity 0.4.23;

contract ERC20BasicInterface {
    event Transfer(address indexed from, address indexed to, uint256 value);

    function decimals() public view returns (uint8);
    function name() public view returns (string);
    function symbol() public view returns (string);
    function totalSupply() public view returns (uint256 supply);
    function balanceOf(address _owner) public view returns (uint256 balance);
    function transfer(address _to, uint256 _value) public returns (bool success);
}

contract ERC20Interface is ERC20BasicInterface {
    event Approval(address indexed owner, address indexed spender, uint256 value);

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
    function approve(address _spender, uint256 _value) public returns (bool success);
    function allowance(address _owner, address _spender) public view returns (uint256 remaining);
}

/**
 * @title ERC20Pocket
 *
 * This contract keeps particular token for the single owner.
 *
 * Original purpose is to be able to separate your tokens into different pockets for dedicated purposes.
 * Whenewer a withdrawal happen, it will be transparent that tokens were taken from a particular pocket.
 *
 * Contract emits purely informational events when transfers happen, for better visualisation on explorers.
 */
contract OPEXliquidity is ERC20BasicInterface {
    ERC20Interface public constant TOKEN = ERC20Interface(0x0b34a04b77Aa9bd2C07Ef365C05f7D0234C95630);
    address public constant OWNER = 0xCba6eE74b7Ca65Bd0506cf21d62bDd7c71F86AD8;
    string constant NAME = 'Optherium Liquidity Pool Tokens';
    string constant SYMBOL = 'OPEXliquidity';

    modifier onlyOwner() {
        require(msg.sender == OWNER, 'Access denied');
        _;
    }

    function deposit(uint _value) public onlyOwner() returns(bool) {
        require(TOKEN.transferFrom(OWNER, address(this), _value), 'Deposit failed');
        emit Transfer(0x0, OWNER, _value);
        return true;
    }

    function withdraw(address _to, uint _value) public onlyOwner() returns(bool) {
        require(TOKEN.transfer(_to, _value), 'Withdrawal failed');
        emit Transfer(OWNER, 0x0, _value);
        return true;
    }

    function totalSupply() public view returns(uint) {
        return TOKEN.balanceOf(address(this));
    }

    function balanceOf(address _holder) public view returns(uint) {
        if (_holder == OWNER) {
            return totalSupply();
        }
        return 0;
    }

    function decimals() public view returns(uint8) {
        return TOKEN.decimals();
    }

    function name() public view returns(string) {
        return NAME;
    }

    function symbol() public view returns(string) {
        return SYMBOL;
    }

    function transfer(address _to, uint _value) public returns(bool) {
        if (_to == address(this)) {
            deposit(_value);
        } else {
            withdraw(_to, _value);
        }
        return true;
    }

    function recoverTokens(ERC20BasicInterface _token, address _to, uint _value) public onlyOwner() returns(bool) {
        require(address(_token) != address(TOKEN), 'Can not recover this token');
        return _token.transfer(_to, _value);
    }
}
        Airdrop Tokens (750,000)
pragma solidity 0.4.23;

contract ERC20BasicInterface {
    event Transfer(address indexed from, address indexed to, uint256 value);

    function decimals() public view returns (uint8);
    function name() public view returns (string);
    function symbol() public view returns (string);
    function totalSupply() public view returns (uint256 supply);
    function balanceOf(address _owner) public view returns (uint256 balance);
    function transfer(address _to, uint256 _value) public returns (bool success);
}

contract ERC20Interface is ERC20BasicInterface {
    event Approval(address indexed owner, address indexed spender, uint256 value);

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
    function approve(address _spender, uint256 _value) public returns (bool success);
    function allowance(address _owner, address _spender) public view returns (uint256 remaining);
}

/**
 * @title ERC20Pocket
 *
 * This contract keeps particular token for the single owner.
 *
 * Original purpose is to be able to separate your tokens into different pockets for dedicated purposes.
 * Whenewer a withdrawal happen, it will be transparent that tokens were taken from a particular pocket.
 *
 * Contract emits purely informational events when transfers happen, for better visualisation on explorers.
 */
contract OPEXairdrop is ERC20BasicInterface {
    ERC20Interface public constant TOKEN = ERC20Interface(0x0b34a04b77Aa9bd2C07Ef365C05f7D0234C95630);
    address public constant OWNER = 0xCba6eE74b7Ca65Bd0506cf21d62bDd7c71F86AD8;
    string constant NAME = 'Optherium Airdrop Tokens';
    string constant SYMBOL = 'OPEXairdrop';

    modifier onlyOwner() {
        require(msg.sender == OWNER, 'Access denied');
        _;
    }

    function deposit(uint _value) public onlyOwner() returns(bool) {
        require(TOKEN.transferFrom(OWNER, address(this), _value), 'Deposit failed');
        emit Transfer(0x0, OWNER, _value);
        return true;
    }

    function withdraw(address _to, uint _value) public onlyOwner() returns(bool) {
        require(TOKEN.transfer(_to, _value), 'Withdrawal failed');
        emit Transfer(OWNER, 0x0, _value);
        return true;
    }

    function totalSupply() public view returns(uint) {
        return TOKEN.balanceOf(address(this));
    }

    function balanceOf(address _holder) public view returns(uint) {
        if (_holder == OWNER) {
            return totalSupply();
        }
        return 0;
    }

    function decimals() public view returns(uint8) {
        return TOKEN.decimals();
    }

    function name() public view returns(string) {
        return NAME;
    }

    function symbol() public view returns(string) {
        return SYMBOL;
    }

    function transfer(address _to, uint _value) public returns(bool) {
        if (_to == address(this)) {
            deposit(_value);
        } else {
            withdraw(_to, _value);
        }
        return true;
    }

    function recoverTokens(ERC20BasicInterface _token, address _to, uint _value) public onlyOwner() returns(bool) {
        require(address(_token) != address(TOKEN), 'Can not recover this token');
        return _token.transfer(_to, _value);
    }
}
        Bounty Tokens (775,000)
pragma solidity 0.4.23;

contract ERC20BasicInterface {
    event Transfer(address indexed from, address indexed to, uint256 value);

    function decimals() public view returns (uint8);
    function name() public view returns (string);
    function symbol() public view returns (string);
    function totalSupply() public view returns (uint256 supply);
    function balanceOf(address _owner) public view returns (uint256 balance);
    function transfer(address _to, uint256 _value) public returns (bool success);
}

contract ERC20Interface is ERC20BasicInterface {
    event Approval(address indexed owner, address indexed spender, uint256 value);

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
    function approve(address _spender, uint256 _value) public returns (bool success);
    function allowance(address _owner, address _spender) public view returns (uint256 remaining);
}

/**
 * @title ERC20Pocket
 *
 * This contract keeps particular token for the single owner.
 *
 * Original purpose is to be able to separate your tokens into different pockets for dedicated purposes.
 * Whenever a withdrawal happen, it will be transparent that tokens were taken from a particular pocket.
 *
 * Contract emits purely informational events when transfers happen, for better visualization on explorers.
 */
contract OPEXbounty is ERC20BasicInterface {
    ERC20Interface public constant TOKEN = ERC20Interface(0x0b34a04b77Aa9bd2C07Ef365C05f7D0234C95630);
    address public constant OWNER = 0xCba6eE74b7Ca65Bd0506cf21d62bDd7c71F86AD8;
    string constant NAME = 'Optherium Bounty Tokens';
    string constant SYMBOL = 'OPEXbounty';

    modifier onlyOwner() {
        require(msg.sender == OWNER, 'Access denied');
        _;
    }

    function deposit(uint _value) public onlyOwner() returns(bool) {
        require(TOKEN.transferFrom(OWNER, address(this), _value), 'Deposit failed');
        emit Transfer(0x0, OWNER, _value);
        return true;
    }

    function withdraw(address _to, uint _value) public onlyOwner() returns(bool) {
        require(TOKEN.transfer(_to, _value), 'Withdrawal failed');
        emit Transfer(OWNER, 0x0, _value);
        return true;
    }

    function totalSupply() public view returns(uint) {
        return TOKEN.balanceOf(address(this));
    }

    function balanceOf(address _holder) public view returns(uint) {
        if (_holder == OWNER) {
            return totalSupply();
        }
        return 0;
    }

    function decimals() public view returns(uint8) {
        return TOKEN.decimals();
    }

    function name() public view returns(string) {
        return NAME;
    }

    function symbol() public view returns(string) {
        return SYMBOL;
    }

    function transfer(address _to, uint _value) public returns(bool) {
        if (_to == address(this)) {
            deposit(_value);
        } else {
            withdraw(_to, _value);
        }
        return true;
    }

    function recoverTokens(ERC20BasicInterface _token, address _to, uint _value) public onlyOwner() returns(bool) {
        require(address(_token) != address(TOKEN), 'Can not recover this token');
        return _token.transfer(_to, _value);
    }
}
        Investor Tokens (356,533,824)
pragma solidity 0.4.23;

contract ERC20BasicInterface {
    event Transfer(address indexed from, address indexed to, uint256 value);

    function decimals() public view returns (uint8);
    function name() public view returns (string);
    function symbol() public view returns (string);
    function totalSupply() public view returns (uint256 supply);
    function balanceOf(address _owner) public view returns (uint256 balance);
    function transfer(address _to, uint256 _value) public returns (bool success);
}

contract ERC20Interface is ERC20BasicInterface {
    event Approval(address indexed owner, address indexed spender, uint256 value);

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
    function approve(address _spender, uint256 _value) public returns (bool success);
    function allowance(address _owner, address _spender) public view returns (uint256 remaining);
}

/**
 * @title ERC20Pocket
 *
 * This contract keeps particular token for the single owner.
 *
 * Original purpose is to be able to separate your tokens into different pockets for dedicated purposes.
 * Whenever a withdrawal happen, it will be transparent that tokens were taken from a particular pocket.
 *
 * Contract emits purely informational events when transfers happen, for better visualization on explorers.
 */
contract OPEXinvest is ERC20BasicInterface {
    ERC20Interface public constant TOKEN = ERC20Interface(0x0b34a04b77Aa9bd2C07Ef365C05f7D0234C95630);
    address public constant OWNER = 0xCba6eE74b7Ca65Bd0506cf21d62bDd7c71F86AD8;
    string constant NAME = 'Optherium Investor Tokens';
    string constant SYMBOL = 'OPEXinvest';

    modifier onlyOwner() {
        require(msg.sender == OWNER, 'Access denied');
        _;
    }

    function deposit(uint _value) public onlyOwner() returns(bool) {
        require(TOKEN.transferFrom(OWNER, address(this), _value), 'Deposit failed');
        emit Transfer(0x0, OWNER, _value);
        return true;
    }

    function withdraw(address _to, uint _value) public onlyOwner() returns(bool) {
        require(TOKEN.transfer(_to, _value), 'Withdrawal failed');
        emit Transfer(OWNER, 0x0, _value);
        return true;
    }

    function totalSupply() public view returns(uint) {
        return TOKEN.balanceOf(address(this));
    }

    function balanceOf(address _holder) public view returns(uint) {
        if (_holder == OWNER) {
            return totalSupply();
        }
        return 0;
    }

    function decimals() public view returns(uint8) {
        return TOKEN.decimals();
    }

    function name() public view returns(string) {
        return NAME;
    }

    function symbol() public view returns(string) {
        return SYMBOL;
    }

    function transfer(address _to, uint _value) public returns(bool) {
        if (_to == address(this)) {
            deposit(_value);
        } else {
            withdraw(_to, _value);
        }
        return true;
    }

    function recoverTokens(ERC20BasicInterface _token, address _to, uint _value) public onlyOwner() returns(bool) {
        require(address(_token) != address(TOKEN), 'Can not recover this token');
        return _token.transfer(_to, _value);
    }
}
img img

Token Liquidity

As a result of the world roadshow, we have signed a contract with the CoinBene currency exchange and we are in active discussions with additional prominent exchanges in Asia and Europe to list the OPEX token after the Main Token Sale

What is Optherium?

Optherium Labs, a global fintech company and member of the Linux™, Hyperledger, and Crypto Valley Foundations, is fully licensed in the European Union for fiat-to-crypto and crypto-to-fiat currency exchange and eWallet services. Optherium’s mission is to create a Global Finance Blockchain Infrastructure that is accessible to all financial institutions, corporations and individual users.

Global Finance
Blockchain Infrastructure

The implementation and combination of products and solutions built upon Optherium’s MultiDecentralized Private Blockchains Network™ creates the infrastructure needed to upgrade the global digital economy and usher in the new era of global commerce. Optherium is the bridge between the traditional and digital economies.

MultiDecentralized Private
Blockchains Network™

Optherium is designed as a MultiDecentralized Private Blockchains Network™ ecosystem, which is unlike any other fintech solution in the world. It uses multiple blockchains within the Ecosystem, including its own private peer-to-peer nodes and blockchains forged by consensus, Hyperledger Fabric, the Ethereum Network, and the InterPlanetary File System (“IPFS”).

Optherium Operating System

The Ecosystem runs by an operating system for smart contracts, APIs, and assistive technologies. It supports a wide spectrum of functionality and capabilities through its MultiDecentralized, Multisecure, and modular structure.

  • MultiDecentralized — uses an array of blockchains and nodes to combine their functionality, execute operations, store and recover data.
  • Modular — flexible enough to add any new functionality to the Operating System and connect to MultiDecentralized private blockchains network.
  • Multisecure — all data is split, encrypted, archived and distributed across the MultiDecentralized Private Blockchains Network™.

Blockchain-as-a-Service Provider

Optherium Labs will create opportunities for enterprises to have a private-labeled product built for them within the Ecosystem. This will enable the enterprise to leverage the Optherium Ecosystem’s rapid transaction speeds, instant currency conversions and confirmations, Dynamic Biometrics™-based security verifications, and the Consistency of Multi-Decentralized™ Digital Currency Exchange for their own benefits.

API
API

Application Programming Interfaces make it possible for third parties to connect instantly with the Optherium Ecosystem and use a wide spectrum of functionality.

Decentralized Exchange
Decentralized Exchange

Optherium provides liquidity for any and all transactions inside the Ecosystem. It supports up to 150 digital currencies and includes an OTC desk.

Mobile eWallet
Mobile eWallet

Customizable mobile eWallets apps for enterprises with access to the Ecosystem’s features and functionality.

Debit Card
Debit Card
Debit Card

Connected with mobile eWallet and decentralized exchange, the debit card gives users the ability to withdraw money at any ATM worldwide.

Key Recovery
Key Recovery

Recover all your digital assets, whether it is your money or sensitive data stored in the Ecosystem.

Instant transactions and confirmations
Instant transactions and confirmations

Instant multisignature transaction confirmations on a Hyperledger Platform that supports more than 100,000 transactions per second worldwide.

Know Your Customer
Know Your Customer

Instant anonymous decentralized proof of identity services for all ecosystems’ users. Use biometrics as a passport or money in a real worlds.

Law Compliance
Law Compliance
Law Compliance

Global finance blockchain infrastructure principles are based on functionality, safety and usability for all members. The Ecosystem includes compliance with GDPR, AML, SEC and other regulations.

Dynamic Biometrics
Dynamic Biometrics

A technology for proof of identity needed for confirmations and payments in the global finance blockchain infrastructure.

Digital Data Vault
Digital Data Vault
Digital Data Vault

The MultiDecentralized Private Blockchains Network™ is the perfect place to store any kind of sensitive data or digital assets. It's also cost effective and maintains a data recovery service to restore lost assets.

Peer-to-Peer Transactions
Peer-to-Peer Transactions

Person-to-person transactions without intermediaries with use of QR, NFC or classic transaction to wallet address.

White Label Solutions
White Label Solutions

Optherium Labs creates and supports solutions for enterprises by combining all modules, functionalities, products and services of the MultiDecentralized Private Blockchains Network™.

Lowest fees
Lowest fees

The Ecosystem is designed as a safe, cost-effective, and user-friendly infrastructure with the lowest fees possible.

Blockchain standard
Blockchain standard
Blockchain standard

Optheirum is designed as a new standard for global financial institutions and enterprises.

Synergy of Blockchain Solutions

VivusPay
VivusPay
BitCrox
BitCrox
Otherium Card
Optherium Card
Dynamic Biometrics
Dynamic Biometrics

VivusPay Mobile App

VivusPay eWallet is an advanced tool for digital asset management. It allows individuals and small businesses to securely store their digital assets with Multisecure Technology™ and Key Recovery Service utilizing Dynamic Biometrics™ and other Know Your Customer data while managing their assets directly from their decentralized wallets.

VivusPay. Be your own bank.

MultiDecentralized Exchange

Bitcrox.io Digital Currency Exchange provides liquidity for any and all transactions within the Ecosystem that require instant conversion and confirmation, at speeds of over 100,000 transactions per second.

Support up to 150 digital currencies and include OTC desk for high volume transactions between enterprises and individual users in the most safe and user friendly ecosystem available.

Start

Debit Card

Withdraw money from any ATM in the world legally, safely, and anonymously. Enjoy the benefits of private blockchains for your advantage. Save your time with no effort and get the certainty of security and convenience anytime, anywhere.

Get card

Biometrics as a proof of identity

Optherium’s Dynamic Biometrics™ verification is a patented technology that uses biometric data (face, voice, fingerprint, retina, etc.) as a key, password or identity verification tool on the Ecosystem. Each of the private blockchain channels is responsible for decentralized encryption and decryption of a specific type of biometric data.

Biometrics-based verification depends on a group of private blockchain channels in the Optherium Ecosystem, each of which is responsible for a specific type of biometric data: dynamic facial movement, voice, fingerprint, etc. A user’s biometric template also known as a digital identity will be encrypted and stored using Biometric Encryption Untraceable and Cancelable Biometrics, which is an intentional and systematically repeatable distortion of biometric features in order to protect sensitive user-specific data.

Learn more

Team

Advisors

Partners

Thank you
for subscribe

live support on telegram