JEWEL
JWL

JEWEL (JWL) is a non – government-controlled digital currency that allows you to send money anywhere in the world instantly, securely and virtually free of charge. Moreover, the JWL aims to empower people to achieve financial independence by making each JWL coin an interest-bearing asset with a high annual interest rate. This state-of-the-art financial instrument can serve as a great way to preserve the value that is supported by network protocols, infrastructure, and services.

Raised

$

ICO End In


Days
Days
Hours
Hours
Minutes
Minutes
Raised
Next target
NaN%
$
$
Whitepaper
Smart contract address

OUR NEW VOLATILITY SOFTWARE

Our new volatility software will allow our investors and future investors who choose to buy directly from the exchanges to have the opportunity to lend their Jewel (JWL) to earn a variable daily interest that will be disbursed every 24 hours, the percentage of interest will vary. Investors will have the option to choose to lend their JWL anywhere from 60-200 days and will also have the option to reinvest their daily earnings to compound their interest and watch their investments grow daily.
Licensed and Regulated Broker
100+ Employees in 6 Countries
500 000+ Registered Accounts
Best Trading Platform
TECHNOLOGY JEWEL
LANDING_ECOSYSTEM_SHADOW
JEWEL (JWL) is an coin designed with an open source peer-to-peer architecture that allows users to trade and invest in a non government controlled currency. Think of it as a heaven for your assets that not only protects them from unwanted government policy interference, but also political and economic turmoil that might adversely affect your investments and transactions. With JWL your finances are safe, secure and increase overtime thanks to our cutting-edge proof-of- stake algorithm. Expect to be able to use JWL online and offline to trade diamonds and gold.
A Powerful Crypto Exchange with Fiat Purchases
Wallet for Buying, Storing and Using Cryptos
Online Trading Platform with Token-Based Trading Accounts
Reliable up-to-date news source for fiat and crypto trading
1OUR VISION
We at JEWEL would like to change the financial system by creating a more futuristic way of investing. We want to be one of the first companies to give access to everyone to have not one, but multiple ways to earn and grow their investments. Together we will build a new decentralized financial system that would work great for everyone so that investors can have more financial freedom and see their money grow faster than the traditional methods of investing. As the future arrives, less jobs become available and more jobs are being given to Artificial Intelligence which in turn is impacting over half of the world’s economy.
Most Powerful Engine Among Crypto Exchanges
Fast KYC and Withdrawals
No Delays in Orders
Lower fees when paying with Jewel Coin
2JEWEL.FINANCE
Jewel.Finance will be an investor’s all inclusive wallet for all financial transactions. Exchanging fiat to crypto and vice versa can be made through an easy app revolutionizing our concept of crypto transactions and eliminating complicated processes. The wallet can be used to buy, store and exchange
3JEDEX.EXCHANGE
For the first time in history diamonds can be traded like any other financial asset class. The JEDEX exchange allows investors to easily and securely trade in diamonds, while diamond holders can effortlessly liquidate their assets. By using innovative tools and blockchain technology JEDEX has overcome the obstacles that have prevented diamonds from becoming a tradable asset class: transparency, liquidity and standardization.
4HOW DOES JEDEX WORK?
It’s simple. JEDEX connects diamond dealers or private diamond holders with investors who want to diversify their holdings. The platform offers easy-to-understand investment options, so you can buy/sell diamonds with confidence, without the need for specialized diamond expertise.
Timely Market News Updates To Keep Investors Informed
Financial Information on the Crypto and Financial Market
Accurate Technical Analysis Provided by Financial Experts
Free Access for Both Jewel and Non-Jewel Users
Crowdsale
Crowdsale
1 JWL = $0,20
Current price
0% BONUS
Token sale
$500
Minimum investment
Crowdsale70%
Company20%
Bounty5%
Teamlocked till 1 Jan5%
Total supply 300 000 000 coins. All unsold coins will be burnt.
NEWS
News

Blockchain and cryptocurrencies like Bitcoin are changing the world at an ever-increasing pace.

Blockchain and Cryptocurrency Conference

The Best Bitcoin Exchanges

The definition of a cryptocurrency is a digital currency built with cryptographic protocols that make transactions secure and difficult to fake.

Roadmap
Roadmap

2017

The JEWELPAY Group is established

January 2018

partnership with Rapaport

March 2018

Google and Facebook partnerships

19.09.2018 - 14.10.2018

Private Presale

15.10.2018 - 15.12.2018

Crowd Presale

16.12.2018 - 16.02.2019

Crowd Sale

15 December 2018

Obtaining License for crypto payments and exchange

8 March 2019

Listing on exchanges

20 March 2019

Jewel.Finance wallet launched

10 May 2019

Jedex exchange launched

August 2019

Jedex iOS and Android apps launch

September 2019

Airdrop

October 2019

Perfomance improvement JEDEX

November 2019

Marketing campaign

January 2020

Top 20 in Coinmarketcap
Smart Contract
Smart Contract
pragma solidity ^0.4.24;

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;


  event OwnershipRenounced(address indexed previousOwner);
  event OwnershipTransferred(
    address indexed previousOwner,
    address indexed newOwner
  );


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  constructor() public {
    owner = msg.sender;
  }

  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }

  /**
   * @dev Allows the current owner to relinquish control of the contract.
   * @notice Renouncing to ownership will leave the contract without an owner.
   * It will not be possible to call the functions with the `onlyOwner`
   * modifier anymore.
   */
  function renounceOwnership() public onlyOwner {
    emit OwnershipRenounced(owner);
    owner = address(0);
  }

  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param _newOwner The address to transfer ownership to.
   */
  function transferOwnership(address _newOwner) public onlyOwner {
    _transferOwnership(_newOwner);
  }

  /**
   * @dev Transfers control of the contract to a newOwner.
   * @param _newOwner The address to transfer ownership to.
   */
  function _transferOwnership(address _newOwner) internal {
    require(_newOwner != address(0));
    emit OwnershipTransferred(owner, _newOwner);
    owner = _newOwner;
  }
}

/**
 * @title ERC20Basic
 * @dev Simpler version of ERC20 interface
 * 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 SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {

  /**
  * @dev Multiplies two numbers, throws on overflow.
  */
  function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
    // Gas optimization: this is cheaper than asserting 'a' not being zero, but the
    // benefit is lost if 'b' is also tested.
    // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
    if (_a == 0) {
      return 0;
    }

    c = _a * _b;
    assert(c / _a == _b);
    return c;
  }

  /**
  * @dev Integer division of two numbers, truncating the quotient.
  */
  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 _a / _b;
  }

  /**
  * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
    assert(_b <= _a);
    return _a - _b;
  }

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
    c = _a + _b;
    assert(c >= _a);
    return c;
  }
}

/**
 * @title Basic token
 * @dev Basic version of StandardToken, with no allowances.
 */
contract BasicToken is ERC20Basic {
  using SafeMath for uint256;

  mapping(address => uint256) internal balances;

  uint256 internal totalSupply_;

  /**
  * @dev Total number of tokens in existence
  */
  function totalSupply() public view returns (uint256) {
    return totalSupply_;
  }

  /**
  * @dev Transfer token for a specified address
  * @param _to The address to transfer to.
  * @param _value The amount to be transferred.
  */
  function transfer(address _to, uint256 _value) public returns (bool) {
    require(_value <= balances[msg.sender]);
    require(_to != address(0));

    balances[msg.sender] = balances[msg.sender].sub(_value);
    balances[_to] = balances[_to].add(_value);
    emit Transfer(msg.sender, _to, _value);
    return true;
  }

  /**
  * @dev Gets the balance of the specified address.
  * @param _owner The address to query the the balance of.
  * @return An uint256 representing the amount owned by the passed address.
  */
  function balanceOf(address _owner) public view returns (uint256) {
    return balances[_owner];
  }

}

/**
 * @title Burnable Token
 * @dev Token that can be irreversibly burned (destroyed).
 */
contract BurnableToken is BasicToken {

  event Burn(address indexed burner, uint256 value);

  /**
   * @dev Burns a specific amount of tokens.
   * @param _value The amount of token to be burned.
   */
  function burn(uint256 _value) public {
    _burn(msg.sender, _value);
  }

  function _burn(address _who, uint256 _value) internal {
    require(_value <= balances[_who]);
    // no need to require value <= totalSupply, since that would imply the
    // sender's balance is greater than the totalSupply, which *should* be an assertion failure

    balances[_who] = balances[_who].sub(_value);
    totalSupply_ = totalSupply_.sub(_value);
    emit Burn(_who, _value);
    emit Transfer(_who, address(0), _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
  );
}

/**
 * @title Standard ERC20 token
 *
 * @dev Implementation of the basic standard token.
 * https://github.com/ethereum/EIPs/issues/20
 * Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
 */
contract StandardToken is ERC20, BasicToken {

  mapping (address => mapping (address => uint256)) internal allowed;


  /**
   * @dev Transfer tokens from one address to another
   * @param _from address The address which you want to send tokens from
   * @param _to address The address which you want to transfer to
   * @param _value uint256 the amount of tokens to be transferred
   */
  function transferFrom(
    address _from,
    address _to,
    uint256 _value
  )
    public
    returns (bool)
  {
    require(_value <= balances[_from]);
    require(_value <= allowed[_from][msg.sender]);
    require(_to != address(0));

    balances[_from] = balances[_from].sub(_value);
    balances[_to] = balances[_to].add(_value);
    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
    emit Transfer(_from, _to, _value);
    return true;
  }

  /**
   * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
   * Beware that changing an allowance with this method brings the risk that someone may use both the old
   * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
   * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
   * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
   * @param _spender The address which will spend the funds.
   * @param _value The amount of tokens to be spent.
   */
  function approve(address _spender, uint256 _value) public returns (bool) {
    allowed[msg.sender][_spender] = _value;
    emit Approval(msg.sender, _spender, _value);
    return true;
  }

  /**
   * @dev Function to check the amount of tokens that an owner allowed to a spender.
   * @param _owner address The address which owns the funds.
   * @param _spender address The address which will spend the funds.
   * @return A uint256 specifying the amount of tokens still available for the spender.
   */
  function allowance(
    address _owner,
    address _spender
   )
    public
    view
    returns (uint256)
  {
    return allowed[_owner][_spender];
  }

  /**
   * @dev Increase the amount of tokens that an owner allowed to a spender.
   * approve should be called when allowed[_spender] == 0. To increment
   * allowed value is better to use this function to avoid 2 calls (and wait until
   * the first transaction is mined)
   * From MonolithDAO Token.sol
   * @param _spender The address which will spend the funds.
   * @param _addedValue The amount of tokens to increase the allowance by.
   */
  function increaseApproval(
    address _spender,
    uint256 _addedValue
  )
    public
    returns (bool)
  {
    allowed[msg.sender][_spender] = (
      allowed[msg.sender][_spender].add(_addedValue));
    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
  }

  /**
   * @dev Decrease the amount of tokens that an owner allowed to a spender.
   * approve should be called when allowed[_spender] == 0. To decrement
   * allowed value is better to use this function to avoid 2 calls (and wait until
   * the first transaction is mined)
   * From MonolithDAO Token.sol
   * @param _spender The address which will spend the funds.
   * @param _subtractedValue The amount of tokens to decrease the allowance by.
   */
  function decreaseApproval(
    address _spender,
    uint256 _subtractedValue
  )
    public
    returns (bool)
  {
    uint256 oldValue = allowed[msg.sender][_spender];
    if (_subtractedValue >= oldValue) {
      allowed[msg.sender][_spender] = 0;
    } else {
      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
    }
    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
  }

}

contract JewelToken is Ownable, StandardToken, BurnableToken {
  string public name = 'Jewel';
  string public symbol = 'JWL';
  uint8 public decimals = 18;
  uint256 public totalSupply = 300000000 * 10 ** uint256(decimals);

  constructor() public {
    balances[msg.sender] = totalSupply;
  }
}
Jewelpay Group Management
Team
Our team of 100+ professionals in six countries single-handedly developed and lead Jewelpay to success. Our years of experience in the industry but also with each other will only lead to great results.
  • Hiranya Tyagi

    Hiranya Tyagi

    HEAD OF CUSTOMER CARE

    Hiranya Tyagi leads the Jewelpay Group customer care team and overlooks support quality and customer satisfaction at all stages of the process. He has a history in the investment banking industry and excels in many sectors. His vast knowledge enables him to combine knowledge from all the departments to handle all customer queries. Hiranya Tyagi lead the Jewelpay Group team to handle more than 15000 traders and will do the same for Jedex.

  • Maya Şensoy

    Maya Şensoy

    CHIEF MARKETING OFFICER

    Maya Şensoy is the marketing leader at Jewelpay Group. She is one of the brightest minds in marketing who helped turn Jewelpay group into one of the biggest fintech platforms on the market. Her savvy technical knowledge combined with his natural creative instinct has lead to measurable results which prove her abilities.

  • Balagun Akeem

    Balagun Akeem

    CHIEF TECHNICAL OFFICER

    Balagun Akeem is the technical leader at the Jewelpay platforms. He has more than 5 years experience of building and leading effective development teams (up to 50 developers). He developed successful proven high load projects with multi-million daily active audience. He is also a crypto expert with more than 5 years of experience in blockchain.

  • 50+Employees
  • 3Offices
  • 22Languages
  • 2017Founded