Quantstamp – the Protocol for Securing Smart Contracts.

Telegram
Join our community on Telegram

We believe in the future of smart contracts and are building a foundational technology to protect users and investors – with scalable proofs-of-audit.

SECURITY AUDITING

Quantstamp is the first scalable security-audit protocol designed to find vulnerabilities in Ethereum smart contracts. Our team is stellar: PhDs with industry experience, backed by a powerful blockchain industry advisory board.

Cost Effective

For smart contracts to truly play an important role in the future of many industries, cost-effective code auditing is integral.


Scalable

Quantstamp’s protocol is designed to scale to verify all Ethereum projects, and become a fundamental part of mainstream adoption for Ethereum.


Secure

Centralized audits are vulnerable to insider attacks. The proof-of-audit protocol is designed so that malicious actors cannot manipulate audit results.

Our vision for auditing is simple: More Automation, Higher Security and Lower Cost.

Richard Ma, Quantstamp Co-founder

Supported By

Team

Richard Ma

Co-founder & CEO


Strategy and Business Operations. Former Algorithmic Trader at Tower Research. Handled Millions of Dollars of Trading using Extreme Software Testing Methods. ECE at Cornell University.



Steven Stewart

Co-founder & CTO


Smart Contract Development. Previously founded Many Trees Inc that built GPU in-memory databases for ML. He worked for 5 years in the Canadian Department of National Defense. PhD dropout.



Edward Zulkoski

Senior Security Engineer


Smart Contract Development. Ex-Microsoft. Extensive research work in SAT and SMT solvers. Ed was awarded a Ph.D. Fellowship from IBM Canada’s Centers for Advanced Studies Research.


Vajih Montaghami

Senior Security Engineer


Software Verification. ECE PhD from the University of Waterloo for his work on verifying formal models. Ex-Google, Ex-Amazon. Expert in security infrastructure and scalable systems.



Prit Sheth

Lead Backend Engineer


Full-stack engineer. Expert in distributed systems. Ex-Barclays Senior Engineer. Ex-Samsung. Winner of Global Think Tank Innovation program at BarclaycardUS.




Leonardo Passos

Senior Developer


ECE Ph.D. from University of Waterloo for his work on mining patterns from the Linux kernel source code and other systems. Microsoft research medalist, with industry experience in backend development and scalable data pipelines.



Krishna Sriram

Community Manager/PR


Multidisciplinary background in film and interaction design. Worked on projects for Microsoft and TELUS. Organizer of Vancouver’s Ethereum meet up. Graduate of the University of British Columbia.


Meg VanDeventer

Head of Communications


Crypto community & media communications. Cambridge Blockchain. Duke MBA and Returned Peace Corps Volunteer. Expert in government relations, regulatory finance, and journalism.


Anna Kao

Graphics and UX Designer


Graphics and UI designer with over 14 years of experience working with leading firms in Asia, the US and Canada. B.A. in Fine Arts/Visual Communication Design from Dayeh University.



Jared Harrill

Community Manager


Longtime EthTrader Telegram manager, background in communications, design, tech and community management. Crypto event organizer in Vancouver, co-admin at DCTRL and expert in DAO governance.



We’re hiring

Senior Engineer


We will soon be announcing two highly experienced PhD security engineers who will be joining our team! We are hiring for blockchain engineers. Apply at [email protected]


Advisors

Evan Cheng

Engineering Advisor


Director of Engineering at Facebook, previously at Apple. Programming language system expert. Winner of ACM Software System Award for designing and implementing LLVM.


David Park

Blockchain Advisor


Product Manager at Facebook. Led product team for multi-billion dollar ad business at Facebook. Member of Facebook's Growth Team for 2 years. Previously VP of Growth at Nextdoor. CS at MIT. Harvard Law School. Crypto investor since 2013.


Dr. Vijay Ganesh

Security Advisor


Computer Engineering Professor at the University of Waterloo. Vijay has won numerous awards, including the ACM Test of Time Award at CCS 2016. Previously CS at Stanford/MIT.


Dr. Derek Rayside

Security Advisor


ECE Professor at the University of Waterloo. His primary research areas are lightweight formal methods, software verification and program analysis. Previously CS at MIT.


Chris Miess

Blockchain Advisor


Chris is the former CFO at TenX, where they conducted the largest ICO in Asia with $80M raised. Previously, he worked in M&A at Goldman Sachs in London. Chris is also the founder and CEO of Iconic Partners, the leading ICO consulting and investment company in Asia.


Tom Graham

Marketing Advisor


Co-founder at Codec.ai, an AI and machine learning marketing company. Prior to codec, Tom founded MapD with a friend at MIT. Harvard Law School ’10. Cryptocurrency Regulatory Expert.


Min Kim

Blockchain Advisor


Min heads SF Office for Cryptonomos. Founder of Blocultural Studios. Min previously worked with Tim Draper on PR & marketing for blockchain related initiatives. Dartmouth College.


Parr Business Law

Legal Counsel


Steve Parr operates a business law practice in Vancouver, supporting start-ups and blockchain ventures. Formerly drafted market regulation legislation for the Ontario Securities Commission.


The Auditing Network

Quantstamp is a specialized network that connects developers, investors and users around a transparent and scalable proof-of-audit.
The network acts as a critical piece of transparency by enabling automated checks on smart contract vulnerabilities and automatically rewarding verifiers who identify bugs.
Quantstamp tokens allow the platform to operate in a scalable and fully decentralized fashion, delivering computation fees to verifier nodes, and bounties for locating vulnerabilities.
Architecture

Token Allocation


Contribution cap: $30 million

Total supply: 1 billion QSP

Token type: Ethereum ERC20
Accepted purchase method: ETH

FAQ
The Quantstamp protocol is a scalable system to audit all projects on Ethereum.
100% of contributions go towards developing the Quantstamp protocol
There are no individual caps for the presale, early adopters allow the hiring of engineers
For the main sale, there are individual caps and partnering with a leading KYC provider
Unsold tokens are burned
Tokens for the founding team are on a 3 year vesting schedule.

Smart Contract on Github


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
// Quantstamp Technologies Inc. ([email protected])

pragma solidity ^0.4.15;

import './token/StandardToken.sol';
import './token/BurnableToken.sol';
import './ownership/Ownable.sol';
import './math/SafeMath.sol';

/**
 * The Quantstamp token (QSP) has a fixed supply and restricts the ability
 * to transfer tokens until the owner has called the enableTransfer()
 * function.
 *
 * The owner can associate the token with a token sale contract. In that
 * case, the token balance is moved to the token sale contract, which
 * in turn can transfer its tokens to contributors to the sale.
 */

contract QuantstampToken is StandardToken, BurnableToken, Ownable {

    // Constants
    string  public constant name = "Quantstamp Token";
    string  public constant symbol = "QSP";
    uint8   public constant decimals = 18;
    uint256 public constant INITIAL_SUPPLY      = 1000000000 * (10 ** uint256(decimals));
    uint256 public constant CROWDSALE_ALLOWANCE =  650000000 * (10 ** uint256(decimals));
    uint256 public constant ADMIN_ALLOWANCE     =  350000000 * (10 ** uint256(decimals));

    // Properties
    uint256 public crowdSaleAllowance;      // the number of tokens available for crowdsales
    uint256 public adminAllowance;          // the number of tokens available for the administrator
    address public crowdSaleAddr;           // the address of a crowdsale currently selling this token
    address public adminAddr;               // the address of a crowdsale currently selling this token
    bool    public transferEnabled = false; // indicates if transferring tokens is enabled or not

    // Modifiers
    modifier onlyWhenTransferEnabled() {
        if (!transferEnabled) {
            require(msg.sender == adminAddr || msg.sender == crowdSaleAddr);
        }
        _;
    }

    modifier validDestination(address _to) {
        require(_to != address(0x0));
        require(_to != address(this) );
        _;
    }

    /**
     * Constructor - instantiates token supply and allocates balanace of
     * to the owner (msg.sender).
     */

    function QuantstampToken(address _admin) {
        totalSupply = INITIAL_SUPPLY;
        crowdSaleAllowance = CROWDSALE_ALLOWANCE;
        adminAllowance = ADMIN_ALLOWANCE;

        // mint all tokens
        balances[msg.sender] = totalSupply;
        Transfer(address(0x0), msg.sender, totalSupply);

        adminAddr = _admin;
        approve(adminAddr, adminAllowance);
    }

    /**
     * Associates this token with a current crowdsale, giving the crowdsale
     * an allowance of tokens from the crowdsale supply. This gives the
     * crowdsale the ability to call transferFrom to transfer tokens to
     * whomever has purchased them.
     *
     * Note that if _amountForSale is 0, then it is assumed that the full
     * remaining crowdsale supply is made available to the crowdsale.
     *
     * @param _crowdSaleAddr The address of a crowdsale contract that will sell this token
     * @param _amountForSale The supply of tokens provided to the crowdsale
     */

    function setCrowdsale(address _crowdSaleAddr, uint256 _amountForSale) external onlyOwner {
        require(!transferEnabled);
        require(_amountForSale <= crowdSaleAllowance);

        // if 0, then full available crowdsale supply is assumed
        uint amount = (_amountForSale == 0) ? crowdSaleAllowance : _amountForSale;

        // Clear allowance of old, and set allowance of new
        approve(crowdSaleAddr, 0);
        approve(_crowdSaleAddr, amount);

        crowdSaleAddr = _crowdSaleAddr;
    }

    /**
     * Enables the ability of anyone to transfer their tokens. This can
     * only be called by the token owner. Once enabled, it is not
     * possible to disable transfers.
     */

    function enableTransfer() external onlyOwner {
        transferEnabled = true;
        crowdSaleAllowance = 0;
        adminAllowance = 0;
    }

    /**
     * Overrides ERC20 transfer function with modifier that prevents the
     * ability to transfer tokens until after transfers have been enabled.
     */

    function transfer(address _to, uint256 _value) public onlyWhenTransferEnabled validDestination(_to) returns (bool) {
        return super.transfer(_to, _value);
    }

    /**
     * Overrides ERC20 transferFrom function with modifier that prevents the
     * ability to transfer tokens until after transfers have been enabled.
     */

    function transferFrom(address _from, address _to, uint256 _value) public onlyWhenTransferEnabled validDestination(_to) returns (bool) {
        bool result = super.transferFrom(_from, _to, _value);
        if (result) {
            if (msg.sender == crowdSaleAddr)
                crowdSaleAllowance = crowdSaleAllowance.sub(_value);
            if (msg.sender == adminAddr)
                adminAllowance = adminAllowance.sub(_value);
        }
        return result;
    }

    /**
     * Overrides the transferOwnership function so that the balance of
     * tokens of the old owner can be transferred to the new owner.
     *
     * @param newOwner  The new owner of the token balance
     */

    function transferOwnership(address newOwner) onlyOwner public {
        super.transferOwnership(newOwner);
    }

    /**
     * Overrides the burn function so that it cannot be called until after
     * transfers have been enabled.
     *
     * @param _value    The amount of tokens to burn in mini-QSP
     */

    function burn(uint256 _value) public onlyWhenTransferEnabled {
        super.burn(_value);
        Transfer(msg.sender, address(0x0), _value);
    }
}

View code on Github

Documents


White Paper

Token Sale Policy

SEC Howey Test

Conferences

Conferences

Get in Touch


We always love to hear from our community.
Feel free to contact us using this form:

Contact Us