Company strategy video VIDEO

IN THE PRESS:

USSDex=USD

How USDDex Works

USDDex is a reliable source of stability in the face of volatility. Every USDDex is always backed in excess by collateral, so you never have to worry about its value moving up or down. Our collateral portfolio is diversified, therefore it allows multiple assets to guarantee the value of each USDDex. Anyone can view the information about the locked collateral backing each USDDex including its safety profile.

Technical Documentation (PDF file)
More than 800 traiding pairs

USDDex advantages:

  • Fixed rate (1 USDDex = 1 USD)*
  • Absolute decentralization
  • Open source code
  • Maximum security
  • Adaptable to centralized exchanges
  • Adaptable to decentralized exchanges
  • Supported by all largest Binance Smart Chain wallets
* Volatility: no greater than 0.1%

Contract Source Code USDDex

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
contract Token {
 
    /// @return total amount of tokens
    function totalSupply() constant returns (uint256 supply) {}
 
    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) constant returns (uint256 balance) {}
 
    /// @notice send `_value` token to `_to` from `msg.sender`
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transfer(address _to, uint256 _value) returns (bool success) {}
 
    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
    /// @param _from The address of the sender
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
 
    /// @notice `msg.sender` approves `_addr` to spend `_value` tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @param _value The amount of wei to be approved for transfer
    /// @return Whether the approval was successful or not
    function approve(address _spender, uint256 _value) returns (bool success) {}
 
    /// @param _owner The address of the account owning tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @return Amount of remaining tokens allowed to spent
    function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
 
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
 
/*
This implements ONLY the standard functions and NOTHING else.
For a token like you would want to deploy in something like Mist, see HumanStandardToken.sol.
 
If you deploy this, you won't have anything useful.
 
Implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20
.*/
 
contract StandardToken is Token {
 
    function transfer(address _to, uint256 _value) returns (bool success) {
        //Default assumes totalSupply can't be over max (2^256 - 1).
        //If your token leaves out totalSupply and can issue more tokens as time goes on, you need to check if it doesn't wrap.
        //Replace the if with this one instead.
        //if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
        if (balances[msg.sender] >= _value && _value > 0) {
            balances[msg.sender] -= _value;
            balances[_to] += _value;
            Transfer(msg.sender, _to, _value);
            return true;
        } else { return false; }
    }
 
    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
        //same as above. Replace this line with the following if you want to protect against wrapping uints.
        //if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
        if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
            balances[_to] += _value;
            balances[_from] -= _value;
            allowed[_from][msg.sender] -= _value;
            Transfer(_from, _to, _value);
            return true;
        } else { return false; }
    }
 
    function balanceOf(address _owner) constant returns (uint256 balance) {
        return balances[_owner];
    }
 
    function approve(address _spender, uint256 _value) returns (bool success) {
        allowed[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);
        return true;
    }
 
    function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
      return allowed[_owner][_spender];
    }
 
    mapping (address => uint256) balances;
    mapping (address => mapping (address => uint256)) allowed;
    uint256 public totalSupply;
}
 
/*
This Token Contract implements the standard token functionality (https://github.com/ethereum/EIPs/issues/20) as well as the following OPTIONAL extras intended for use by humans.
 
In other words. This is intended for deployment in something like a Token Factory or Mist wallet, and then used by humans.
Imagine coins, currencies, shares, voting weight, etc.
Machine-based, rapid creation of many tokens would not necessarily need these extra features or will be minted in other manners.
 
1) Initial Finite Supply (upon creation one specifies how much is minted).
2) In the absence of a token registry: Optional Decimal, Symbol & Name.
3) Optional approveAndCall() functionality to notify a contract if an approval() has occurred.
 
.*/
 
contract HumanStandardToken is StandardToken {
 
    function () {
        //if ether is sent to this address, send it back.
        throw;
    }
 
    /* Public variables of the token */
 
    /*
    NOTE:
    The following variables are OPTIONAL vanities. One does not have to include them.
    They allow one to customise the token contract & in no way influences the core functionality.
    Some wallets/interfaces might not even bother to look at this information.
    */
    string public name;                   //fancy name: eg USDDex
    uint8 public decimals;                //How many decimals to show. ie. There could 1000 base units with 3 decimals. Meaning 0.980 USDDex = 980 base units. It's like comparing 1 wei to 1 ether.
    string public symbol;                 //An identifier: eg USDDex
    string public version = 'H0.1';       //human 0.1 standard. Just an arbitrary versioning scheme.
 
    function HumanStandardToken(
        uint256 _initialAmount,
        string _tokenName,
        uint8 _decimalUnits,
        string _tokenSymbol
        ) {
        balances[msg.sender] = _initialAmount;               // Give the creator all initial tokens
        totalSupply = _initialAmount;                        // Update total supply
        name = _tokenName;                                   // Set the name for display purposes
        decimals = _decimalUnits;                            // Amount of decimals for display purposes
        symbol = _tokenSymbol;                               // Set the symbol for display purposes
    }
 
    /* Approves and then calls the receiving contract */
    function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
        allowed[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);
 
        //call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually so one doesn't have to include a contract in here just for this.
        //receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
        //it is assumed that when does this that the call *should* succeed, otherwise one would use vanilla approve instead.
        if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
        return true;
    }
}

Who is USDDex for? USDDex

Exchanges

Offer customers a stablecoin they can trust. Use USDDex as an alternative to traditional currency purchase methods.

Crypto Traders

Hedge against volatility on the crypto market. Move money into crypto without immediate exposure to BTC or ETH.

Commerce

Online purchases, salaries, escrow, and loans are enabled through price stability, enabling the mainstream adoption of digital currencies.

Financial Services

Enter crypto markets without immediate exposure to BTC or ETH. Receipts and proof of ownership for your USDDex Stablecoins.

USDDex will be traded at exchanges before August 30, 2021 USDDex

HitbtcBTC
ethfinexDEX
DDEX
IDEXDEX
kyber network
Bitinka
OpenLedgerDEX
radarrelayDEX
ForkDeltaDex
BancorDEX
EtherDeltaDex
ShapeShiftDEX
AIrSwapDex
Bibox
Changelly
change NOW
Bit-Z
Bitmart
Paradex
*Total trade turnover per day: over 1,5 billion dollars

USDDex is supported by all popular Binance Smart Chain wallets USDDex

MyEtherWallet
ledger
Metamask
imToken
jaxx
eidoo
Exodus
Etherum
bread
parity
trezor
Trust Wallet
Kee[Key
Coin.Space
Garda Wallet
Coinomi
CoolWallets
Infinito Wallet
BitBox
MyCrypto
*Over 20 million daily active users

Executive Team TEAM

Hitoshi Shibata
Founder, CEO
Naoki Sakamoto
COO
Masaki Hatano
CTO
Jiho Hong
CIO
Ayako Nakamura
CMO

Advisors

Tatsuo Okuda
Advisor
Naoki Tamura
Advisor
Satoko Kudo
Advisor

Contact USDDex CONTACT

Any questions? Reach us now and we will get back to you shortly.

  • emailsupport@usddex.net

New coin based on Binance Smart Chain ERC-20 standard

BLOCKSHOWASIA