New Stablecoin
Ethereum-based (ERC-20 standard)
1 USDZ is always equal to 1 US dollar
Global Promotional Video
Media about us
USDZ meets the international standards in the cryptocurrency industry
Stable Currency
1 USDZ is always equal to 1 US Dollar. This is guaranteed by 100% collateral in the insured UK custodian institutions.
Security Guarantee
USDZ is based on the Ethereum blockchain and uses the ERC-20 standard, which ensures 100% security of receiving, storing, and sending the tokens.
100% Backed
Each USDZ is backed by 1 USD. Official audits are conducted twice a month and are followed by publication of reports.
Available to Everyone
All popular Ethereum wallets support receiving, storing, and sending of USDZ tokens. Ease of use is one of the essential conditions for rapid product development.
Liquidity
Stablecoins secured by US dollars are highly valued and used by the largest blockchain companies, exchanges, private traders, and ordinary cryptocurrency users.
Professional Team
All members of the USDZ team have extensive experience in the blockchain industry. Global strategy and excellent business reputation enable the team to bring the product to the leading position in the market.
USDZ WhitePaper
Contract Source Code (Solidity)

pragma solidity ^0.4.23;

// This is the proxy contract for the USDZ Registry

// File: contracts/Proxy/Proxy.sol

/**

* @title Proxy

* @dev Gives the possibility to delegate any call to a foreign implementation.

*/

contract Proxy {

/**

* @dev Tells the address of the implementation where every call will be delegated.

* @return address of the implementation to which it will be delegated

*/

function implementation() public view returns (address);

/**

* @dev Fallback function allowing to perform a delegatecall to the given implementation.

* This function will return whatever the implementation call returns

*/

function() external payable {

address _impl = implementation();

require(_impl != address(0), "implementation contract not set");

assembly {

let ptr := mload(0x40)

calldatacopy(ptr, 0, calldatasize)

let result := delegatecall(gas, _impl, ptr, calldatasize, 0, 0)

let size := returndatasize

returndatacopy(ptr, 0, size)

switch result

case 0 { revert(ptr, size) }

default { return(ptr, size) }

}

}

}

// File: contracts/Proxy/UpgradeabilityProxy.sol

/**

* @title UpgradeabilityProxy

* @dev This contract represents a proxy where the implementation address to which it will delegate can be upgraded

*/

contract UpgradeabilityProxy is Proxy {

/**

* @dev This event will be emitted every time the implementation gets upgraded

* @param implementation representing the address of the upgraded implementation

*/

event Upgraded(address indexed implementation);

// Storage position of the address of the current implementation

bytes32 private constant implementationPosition = keccak256("USDZ.proxy.implementation");

/**

* @dev Tells the address of the current implementation

* @return address of the current implementation

*/

function implementation() public view returns (address impl) {

bytes32 position = implementationPosition;

assembly {

impl := sload(position)

}

}

/**

* @dev Sets the address of the current implementation

* @param newImplementation address representing the new implementation to be set

*/

function _setImplementation(address newImplementation) internal {

bytes32 position = implementationPosition;

assembly {

sstore(position, newImplementation)

}

}

/**

* @dev Upgrades the implementation address

* @param newImplementation representing the address of the new implementation to be set

*/

function _upgradeTo(address newImplementation) internal {

address currentImplementation = implementation();

require(currentImplementation != newImplementation);

_setImplementation(newImplementation);

emit Upgraded(newImplementation);

}

}

// File: contracts/Proxy/OwnedUpgradeabilityProxy.sol

/**

* @title OwnedUpgradeabilityProxy

* @dev This contract combines an upgradeability proxy with basic authorization control functionalities

*/

contract OwnedUpgradeabilityProxy is UpgradeabilityProxy {

/**

* @dev Event to show ownership has been transferred

* @param previousOwner representing the address of the previous owner

* @param newOwner representing the address of the new owner

*/

event ProxyOwnershipTransferred(address indexed previousOwner, address indexed newOwner);

/**

* @dev Event to show ownership transfer is pending

* @param currentOwner representing the address of the current owner

* @param pendingOwner representing the address of the pending owner

*/

event NewPendingOwner(address currentOwner, address pendingOwner);

// Storage position of the owner and pendingOwner of the contract

bytes32 private constant proxyOwnerPosition = keccak256("USDZ.proxy.owner");

bytes32 private constant pendingProxyOwnerPosition = keccak256("USDZ.pending.proxy.owner");

/**

* @dev the constructor sets the original owner of the contract to the sender account.

*/

constructor() public {

_setUpgradeabilityOwner(msg.sender);

}

/**

* @dev Throws if called by any account other than the owner.

*/

modifier onlyProxyOwner() {

require(msg.sender == proxyOwner(), "only Proxy Owner");

_;

}

/**

* @dev Throws if called by any account other than the pending owner.

*/

modifier onlyPendingProxyOwner() {

require(msg.sender == pendingProxyOwner(), "only pending Proxy Owner");

_;

}

/**

* @dev Tells the address of the owner

* @return the address of the owner

*/

function proxyOwner() public view returns (address owner) {

bytes32 position = proxyOwnerPosition;

assembly {

owner := sload(position)

}

}

/**

* @dev Tells the address of the owner

* @return the address of the owner

*/

function pendingProxyOwner() public view returns (address pendingOwner) {

bytes32 position = pendingProxyOwnerPosition;

assembly {

pendingOwner := sload(position)

}

}

/**

* @dev Sets the address of the owner

*/

function _setUpgradeabilityOwner(address newProxyOwner) internal {

bytes32 position = proxyOwnerPosition;

assembly {

sstore(position, newProxyOwner)

}

}

/**

* @dev Sets the address of the owner

*/

function _setPendingUpgradeabilityOwner(address newPendingProxyOwner) internal {

bytes32 position = pendingProxyOwnerPosition;

assembly {

sstore(position, newPendingProxyOwner)

}

}

/**

* @dev Allows the current owner to transfer control of the contract to a newOwner.

*changes the pending owner to newOwner. But doesn't actually transfer

* @param newOwner The address to transfer ownership to.

*/

function transferProxyOwnership(address newOwner) external onlyProxyOwner {

require(newOwner != address(0));

_setPendingUpgradeabilityOwner(newOwner);

emit NewPendingOwner(proxyOwner(), newOwner);

}

/**

* @dev Allows the pendingOwner to claim ownership of the proxy

*/

function claimProxyOwnership() external onlyPendingProxyOwner {

emit ProxyOwnershipTransferred(proxyOwner(), pendingProxyOwner());

_setUpgradeabilityOwner(pendingProxyOwner());

_setPendingUpgradeabilityOwner(address(0));

}

/**

* @dev Allows the proxy owner to upgrade the current version of the proxy.

* @param implementation representing the address of the new implementation to be set.

*/

function upgradeTo(address implementation) external onlyProxyOwner {

_upgradeTo(implementation);

}

}

Meet the Leadership Team
Community of the best minds in technologies, law, and finances from all over the world
Robert Evans
CEO
Richard Moore
CFO
Sebastian Schneider
CTO
Kirsten Larsen
CMO
James Turner
FAQ
How is a stable rate (1:1) guaranteed?

1 USDZ is always backed by 1 USD. Formal audits are conducted 2 times a month with reports published publicly. The company operates under the direct supervision and control of the Financial Services Authority and is subject to the banking laws of the UK and other applicable UK laws and regulations. USDZ Capital Group Ltd has all necessary licenses and approvals.

How is technical security guaranteed?

The highest security rating is ensured by open source code, multiple and thorough security audits. USDZ is based on the Ethereum blockchain and uses the ERC-20 standard, which guarantees secure receiving, storing, and transfer of tokens.

Why do many experts appreciate the level of your team?

All members of our team have extensive experience in the industry and a high level of business reputation. Regular participation in major international industry events and continuous professional training guarantee rapid product development and increase in the market share.

How do I get news about the company's activities?

Subscribe to our social networks and you will be the first to know all the news and will be able to view reports on activities and learn about upcoming events.

Contact Us
Global Customer Support

Contact us at
support@usdztoken.io or 24/7 online chat on our website

Press

For all inquiries, members of the press should contact
press@usdztoken.io

Business Development

For business development inquiries, please contact
dev@usdztoken.io

Careers

Interested in working at USDZ company? email us at
recruiting@usdztoken.io

Our accounts in social media:
Head office in London:

33 Cavendish Square, Marylebone, London, England, W1G 0DT