ARAW Ratings

Challenges, Approach, and Objectives


Araw Pay

Accept online payments with a click of button

Araw Touch & Pay Card

Enabling instore micropayments


Transparent ecosystem to increase adoption rate


Increase the ARAW token adoption by merchants

Unified reward system

Unified Reward System enabled e-commerce ecosystem


Plug and Play WIDGET

Design and implement Araw Pay online widget which can be plug and play on any websites


Easily redeemable rewards and rapid cash in will encourage customers to use ARAW card for all their shopping needs.

ease of use

Intuitive user interfaces making it feel like second nature thus user do not notice the advance technology that power purchases and rewards system.


Targeted and specialist resource dedicated to merchant on-boarding and support to ensure every client campaign is a success.


Specific campaign management assistance to help clients maximise adoption rates.



Provide end-to-end solutions for E-Commerce Marketplace, Touch & Pay Cryptocurrency Card, Online Cryptocurrency Payment, and Unified Reward System powered by the Ethereum Blockchain regulated by the ARAW token

self managed

Create a Consumers driven floating ecosystem


Create a Transparent ecosystem that can be used by regular customers across the world;and hence, increase the adoption rate of the ARAW token, the Blockchain based cryptocurrency

The goal of the ARAW token is to be a part of everyone’s day-to-day online &
in-store shopping. See how it works

Strategic Partners

iFashion Group

Blockchain User Adoption & The Araw Platform

The Araw Platform is aiming to contribute to the global Blockchain User Adoption across regular people by intuitive and seamless integration of vastly used E-Commerce channel with the Decentralised Payment.

The ARAW Token Ecosystem

Araw Pay

Araw pay will be an open widget to accept payments in ARAW tokens with a click of a button. We aim to provide seamless Araw pay solutions in Araw mobile & web wallet, open API platform, and Araw e-commerce marketplace.

E-commerce Marketplace

The goal of the ARAW token is to be a part of everyone’s day-to-day shopping without them changing their shopping pattern.

Araw Card - Touch & Pay

Araw - Touch & Pay card aims to enable customers to make micropayments at coffee shops, supermarkets and day-to-day online shopping.

Open API Platform

Plug & Play Enterprise Blockchain based E-Commerce Platform with a click of button

Banking System Integration

Top-up or cashback ARAW tokens to the linked bank accounts.

Araw Mobile Wallet

The seamless integration of Araw Mobile Wallet with Banking and cryptocurrency Exchanges

Cryptocurrency Exchanges Integration

Exchange ARAW tokens with other cryptocurrencies (like ETH and BTC).

Ethereum Blockchain - Proof of Delivery & Service

The Araw e-commerce marketplace leverages Ethereum smart contracts for exchanging goods with ARAW tokens.

Peer-to-Peer Transfer

Direct exchange of goods and services between interested parties.

Unified Reward System

The ARAW token aims to transform the poorly utilised multi-branded loyalty industry

1 Consumer makes a purchase from Merchant-1 using Fiat currency.

2 Transactions registered into Araw Platform

3 Consumer rewarded an Araw tokens

4 Consumer redeems these Araw tokens to purchase items from Merchant-2

5 Transactions registered into Araw Platform

Token Sale: 10 SEP - 09 NOV

Ticker ARAW
Token type ERC20
ICO token price 1 ARAW = $0.01
Total tokens 5,000,000,000
Available for token sale 3,500,000,000 (70%)
Whitelist YES (15 MAY – 30 JUNE )
Know Your Customer (KYC) YES
Pre-sale start date 1 JULY
Public sale start date 10th September
Soft cap 2,000,000 USD
Hard cap 25,000,000 USD
Accepts ETH
Contact us for pre-sale

Fundraising Goals

Token Distribution

Use of Funds



April 25th,2018

The Araw Ecosystem was carefully designed from the beginning as a supportive sphere in which users can be confident in their trades on the Blockchain. [...]

April 25th,2018

Today’s e-commerce industry is growing at a rapid pace and global retail e-commerce sales are expected to reach $4.5 trillion by 2021. For most comm [...]

April 18th,2018

One of the most important and often used metrics for measuring today’s retail e-commerce success is the customer loyalty and reward program. Nowaday [...]

April 17th,2018

The ARAW Token is an innovative cyptocurrency solution that is set to revolutionize and transform E-commerce into banking and finance industry. Yes, i [...]

April 16th,2018

This is 2018; the year of cryptocurrency as widely speculated by many crypto experts and analysis, and the question asked by most people is “what is [...]

April 15th,2018

We are in digital generation and consequently, the era of digital currency. Similarly, a lot of crypto-coin exchange websites exist. Hence, the reason [...]


Krutesh Shah

Co-Founder & CEO

Krutesh is qualified and experienced Business Analyst worked with investment banks like BNP Paribas and Barclays where he was specialised in developing and aligning business models, managing people and projects and developing new products.

He worked on shaping the vision and direction of the business and focus on designing business systems and processes that enable the successful implementation of the business strategy.

Krutesh is overseeing all operations and business activities to ensure they produce the desired results and are consistent with the overall strategy and mission of the company.

Carlo Pascoli

Co-Founder & CTO

MSc in Computer Engineering, Carlo has been building software solutions and leading software engineering teams in world class companies like Shazam, IG and Thomson Reuters.

In the last 15 years, he’s become an expert in distributed systems and mobile apps development, with a primary focus on the financial sector.

Carlo always felt passionate about innovation and believes in the positive disruption represented by decentralised systems based on cryptocurrencies and blockchain technology.

He thinks we are living the beginning of a revolution that will first impact the payment and e-commerce sectors and he wants to contribute to that.

Dev Shah


Dev has a Finance Degree from Kingston Business School. He is an experienced ex-management consultant having worked at Deloitte, TSC, Compaq, and J.P.Morgan.

He combines core skills with ‘in-depth’ knowledge of systems, processes, businesses and to build successful businesses across these numerous industries.

Dev has a structured approach to management and a breadth of experience from business development to daily operations.

Dev’s involvement with ARAW will be to lead the business development efforts which he is well versed with, having secured partnering agreements in over 40 different countries in his previous enterprises.

Manan Jobanputra

Lead Blockchain Developer

Roman Golovay

Blockchain Developer

Dimpy Ladva

Senior Mobile Developer

Jainesh Mehta

Platform Developer

Sagar Jobanputra

Web Designer/Developer

Stephen AO

Lead Designer

Ami Shah

Senior QA Analyst

Kunjan Parmar

Legal advisor


Jeremy Khoo

E-Commerce & Retail Expert

Jeremy Khoo is an international business operator, founder and blockchain entrepreneur who has successfully exited 3 venture funded companies. He is currently Group CEO of iFashion - a leading regional retail enabler and conglomerate.

Under his leadership, iFashion and it’s subsidiaries have raised multiple investment rounds from venture capitalists up to Series B. iFashion has been acquired by MC Payment for $23 million and Jeremy will be co-leading the combined push for a public listing on the SGX in 2018.

Jeremy co-founded retail blockchain MegaX which conducted a token sale and deployed the cryptocurrency for use in the retail eco-system. Jeremy co-founded successful Crypto-E-Commerce store Megaxstore which is spearheading cryptocurrency mass adoption.

He is also a Partner and Principal Consultant in Novum Capital and Enblockr, which has helped many high profile companies sell more than USD 100M in tokens so far.

Jane Thomason

Advisory Board Member

Experienced CEO and thought leader in the applications of blockchain technology for social impact. She is a frequent commentator and blogger on blockchain and social impact and conference speaker globally.

She published peer reviewed articles in 2017, on blockchain and climate finance and the poor and on blockchain as an accelerator for women’s and children’s health.

Jane is an adviser to several blockchain startups with applications that solve global problems, and is currently working with collaborators to co-develop blockchain POCs in several emerging economies.

Dr Thomason is a Global Ambassador and Advisory Board member of the British Blockchain Association and a member of the Advisory Board of the Kerala Blockchain Academy.

John Wellman

Bleep Plc, Group CEO

John is the founder and group CEO of Bleep UK Plc established in 1981.

Bleep’s “Events Division” has become number one in the world for supplying Epos and Payment systems to the largest sporting events around the World. From FIFA World Cup in Brazil, 2015 Panam games in Toronto, Rugby World Cup, Wimbledon, The Open, 2016 Euro finals in France, Tour de France, Glastonbury, Isle of White festival, Commonwealth Games, 2016 Rio Olympics. This year Bleep has added Formula 1 in 15 countries around the world in their portfolio.

Today Bleep solutions found in a variety of businesses from small cafés, fast food, casual dining, fine dining, bars , pubs, retail, hotels to stadiums such the Principality Stadium in Wales, Chelsea FC, Middlesbrough FC.

Naviin Kapoor

Blockchain Advisor

Naviin Kapoor is a blockchain consultant and a business transformation leader with more than eleven and half years of experience in project management and business analysis

He has professional experience in ethereum, bitcoin, hyperledger, EOS, consensus protocol and distributed/shared ledger technology.

Naviin is working on digital transformation projects and providing Blockchain consultation

Paresh Masani

Platform Vision & Strategy

Paresh is a Gold Medalist in Masters Degree in Computer Science from one of the most prestigious university in India, National Institute of Technology, Trichy.

Having worked over 10 years as an Executive Director in Banking and Finance, Paresh will make a vital contribution to the Araw Platform’s future vision.

Paresh possesses solid understanding of FinTech business and technology; and has a proven track record of running successful businesses.

He is a technology geek and has worked as technical lead and full-stack developer for some of the critical Banking and Finance projects in the world!

Paresh is an expert in security, cryptography, blockchain technology, and end-to-end system development.

Srinivas Anala

Founder of Bloqwise

Before becoming a true believer in Decentralised technology, Srinivas has a combined 10 Years of experience working for Industry Leading FinTech companies.

He will bring his knowledge and experience to help Araw build decentralised payment for e-commerce ecosystem

Srinivas founded Bloqwise to support growth and sustainability of blockchain ecosystem. He built an active and growing global community of blockchain developers, crypto currency investors and decentralised technology enthusiasts.

Expert in providing technical guidance, blockchain technology, and community support.

Smart Contract

pragma solidity ^0.4.24;

// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
 * @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) {
    if (a == 0) {
      return 0;
    uint256 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 <= a);
    return a - b;

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

// ----------------------------------------------------------------------------
// Ownership functionality for authorization controls and user permissions
// ----------------------------------------------------------------------------
 * @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 transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
  function transferOwnership(address newOwner) public onlyOwner {
    require(newOwner != address(0));
    emit OwnershipTransferred(owner, newOwner);
    owner = newOwner;

   * @dev Allows the current owner to relinquish control of the contract.
  function renounceOwnership() public onlyOwner {
    emit OwnershipRenounced(owner);
    owner = address(0);

// ERC20 Standard Interface
// ----------------------------------------------------------------------------
 * @title ERC20Basic
 * @dev Simpler version of ERC20 interface
 * @dev see
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
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

// ----------------------------------------------------------------------------
// Basic version of StandardToken, with no allowances.
// ----------------------------------------------------------------------------

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

  mapping(address =<= balances[msg.sender]);

    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 Standard ERC20 token
 * @dev Implementation of the basic standard token.
 * @dev
 * @dev Based on code by FirstBlood:
contract StandardToken is ERC20, BasicToken {

  mapping (address => mapping (address =<= balances[_from]);
    require(_value <= allowed[_from][msg.sender]);

    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:
   * @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
    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,
    uint _addedValue
    returns (bool)
    allowed[msg.sender][_spender] = (
    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,
    uint _subtractedValue
    returns (bool)
    uint 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;

 * @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 Standard Burnable Token
 * @dev Adds burnFrom method to ERC20 implementations
contract StandardBurnableToken is BurnableToken, StandardToken {

   * @dev Burns a specific amount of tokens from the target address and decrements allowance
   * @param _from address The address which you want to send tokens from
   * @param _value uint256 The amount of token to be burned
  function burnFrom(address _from, uint256 _value) public {
    require(_value <= allowed[_from][msg.sender]);
    // Should be accepted,
    // this function needs to emit an event with the updated approval.
    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
    _burn(_from, _value);

contract ArawToken is StandardBurnableToken, Ownable {

  using SafeMath for uint256;

  string public symbol = "ARAW";
  string public name = "ARAW";
  uint256 public decimals = 18;

  /* Wallet address will be changed for production */ 
  address public arawWallet;

  /* Locked tokens addresses - will be changed for production */
  address public reservedTokensAddress;
  address public foundersTokensAddress;
  address public advisorsTokensAddress;

  /* Variables to manage Advisors tokens vesting periods time */
  uint256 public advisorsTokensFirstReleaseTime; 
  uint256 public advisorsTokensSecondReleaseTime; 
  uint256 public advisorsTokensThirdReleaseTime; 
  /* Flags to indicate Advisors tokens released */
  bool public isAdvisorsTokensFirstReleased; 
  bool public isAdvisorsTokensSecondReleased; 
  bool public isAdvisorsTokensThirdReleased; 

  /* Variables to hold reserved and founders tokens locking period */
  uint256 public reservedTokensLockedPeriod;
  uint256 public foundersTokensLockedPeriod;

  /* Total advisors tokens allocated */
  uint256 totalAdvisorsLockedTokens; 

  modifier checkAfterICOLock () {
    if (msg.sender == reservedTokensAddress){
        require (now >= reservedTokensLockedPeriod);
    if (msg.sender == foundersTokensAddress){
        require (now < advisorsTokensSecondReleaseTime) {   
      require (!isAdvisorsTokensFirstReleased);
      isAdvisorsTokensFirstReleased = true;

      return true;

    if (now < advisorsTokensThirdReleaseTime) {
      require (!isAdvisorsTokensSecondReleased);
      if (!isAdvisorsTokensFirstReleased) {
        isAdvisorsTokensFirstReleased = true;
      } else{
      isAdvisorsTokensSecondReleased = true;
      return true;

    require (!isAdvisorsTokensThirdReleased);

    if (!isAdvisorsTokensFirstReleased) {
    } else if (!isAdvisorsTokensSecondReleased) {
    } else{

    isAdvisorsTokensFirstReleased = true;
    isAdvisorsTokensSecondReleased = true;
    isAdvisorsTokensThirdReleased = true;

    return true;
   * @param percent tokens release for advisors from their pool
  function releaseAdvisorsTokensForPercentage(uint256 percent) internal {
    uint256 releasedTokens = (percent.mul(totalAdvisorsLockedTokens)).div(100);

    balances[advisorsTokensAddress] = balances[advisorsTokensAddress].add(releasedTokens);
    balances[this] = balances[this].sub(releasedTokens);
    emit Transfer(this, advisorsTokensAddress, releasedTokens);

   * @dev all ether transfer to another wallet automatic
  function () public payable {
    require(state == State.Active); // Reject the transactions after ICO ended
    require(msg.value >= 0.1 ether);

  * After ICO close it helps to lock tokens for pools
  function close() onlyOwner public {
    require(state == State.Active);
    state = State.Closed;
    foundersTokensLockedPeriod = now + 365 days;
    reservedTokensLockedPeriod = now + 1095 days; //3 years
    advisorsTokensFirstReleaseTime = now + 12 weeks; //3 months to unlock 30 %
    advisorsTokensSecondReleaseTime = now + 24 weeks; // 6 months to unlock 30%
    advisorsTokensThirdReleaseTime = now + 365 days; //1 year to unlock 40 %
    emit Closed();
View on Github


The ARAW token is a utility based token specifically designed for the global E-commerce marketplace. ARAW token works as unified rewards as well as mode of payments for both online and retail outlets.
ARAW UK Ltd is incorporated in London, United Kingdom
Token type is ERC20 and it will be based on Etheruem platform.
US citizens will not be able to participate in the ARAW Token ICO.
We also plan to comply with restrictions placed on citizens of other nations and will continue to monitor the legal environment closely.
We have Araw E-Commerce Platform demo ready for testing. Please check Araw MVP Demo
We will accept ETH, BTC, BCH, and LTC. Please subscribe for updates for additional information.
There are bonuses during the ICO presale phase and crowdsale. Please subscribe for updates for additional information.
5,000,000,000 ARAW – 5 Billion ARAW
Yes. We will be releasing whitelist registration and KYC information soon. Please subscribe for updates to don't miss anything.
ARAW aims to be as credible and compliant as possible in everything it does, including KYC verification. In order to participate in the ARAW token sale, you must complete KYC process. We will be releasing whitelist registration and KYC information soon. Please subscribe for updates to don't miss anything.
Minimum is 0.1 Ether during the crowdsale. For pre-sale, minimum Ether will be 10 ETH.
Coins that are allocated to the team and advisors will be in lock-up for 1 year.
We are working closely with our advisors to be fully compliant and well positioned for being listed on exchanges.
Furthermore, we have engaged early on in conversations with exchanges. For strategic reasons, we will only disclose names once 100% confirmed.
If you haven’t already, join our Telegram channel to chat directly with the team and community.