Quaiscan provides a comprehensive, easy-to-use interface for users to view, confirm, inspect and interact with Quai Network.

While there are several explorers available to blockchain projects, most are closed systems (ie Etherscan, Routescan) which are not independently verifiable and do not support the Quai Network ecosystem.

As the multi-chain paradigm continues to take hold in both private and public settings, transparent tools are needed to analyze and validate transactions and provide an explorer interface for all shards within Quai Network.

Information on the latest release and version history is available in the Github repo.

Quaiscan is a full-featured explorer with many uses. A block explorer provides views and insights into various data stored on chain. Depending on the page, section and instance, different types of data is displayed. See below for different views and learn how to navigate blockchain data.

Quaiscan offeres different informational displays depending on the page and section you are viewing. Learn more about different views and data displays in Quaiscan:

• Top Menu

• Blocks

Quaiscan Glossary

• Address: A unique identifier for a wallet or smart contract on the blockchain.

• Block: A group of transactions that have been verified and added to the blockchain.

• Block Height: The number of blocks in the chain between any given block and the first block in the same given shard.

• Contract: Also known as a smart contract, it's a self-executing program stored on the blockchain.

• Gas: The unit of measure for the computational work required to execute transactions or smart contracts on Quai Network.

• Gas Price: The amount of Quai or Qi tokens you're willing to pay per unit of gas for a transaction.

• Hash: A unique fixed-length string of characters that represents data. In blockchain, it's used to identify blocks, transactions, addresses, and more.

• Miner: Entities that verify and add new transactions to the blockchain.

• Nonce: A number used once, typically to verify the uniqueness of transactions.

• Pending Transaction: A transaction that has been broadcast to the network but not yet included in a block.

• Token: A type of cryptocurrency that represents a tradable asset or utility and is often built on top of an existing blockchain.

• Transaction: The transfer of cryptocurrency or data between addresses on the blockchain.

• Transaction Fee: The cost to process a transaction on the blockchain, typically paid to miners.

• Wallet: A tool that allows users to store, send, and receive cryptocurrency.

Blockchain Menu

Access transactions, blocks, top accounts, and smart contracts.

Blocks

• Blocks: Access high-level data for blocks, beginning with the most recent.

• Forked Blocks (Reorgs): Blocks which are not included in the primary chain due to chain reorganizations.

Transactions

• Mined: Transactions which have been mined and confirmed on the chain.

• Pending: Transactions still in the mempool which are waiting to be mined. These transactions may be mined or excluded depending on gas fees or network congestion.

Tokens

• Single Chain Tokens: A list of ERC-20, ERC-721, and ERC1155 tokens deployed to the chain.

• Bridged: If a chain includes bridged tokens (i.e. bridged USDC) these can be catalogued here.

Charts & Stats

A collection of relevant statistics for the network.

• Accounts: Active accounts, account growth, and new accounts.

• Transactions: Fees, confirmation rates, and transaction growth.

• Blocks: Block rewards, size, and rates.

• Tokens: Token transfers, creations, and conversions.

• Gas: Gas limit, price, and growth over time.

• Contracts: Information about the growth of deployed and verified contracts.

API Menu

Access API information including:

• Rest API: API supporting a wider number of requests for indexed data.

• GraphQL: Explore API calls using GraphQL and the in-browser IDE. Learn more about the GraphQL Quaiscan integration here.

• RPC: API supporting GET and POST requests for many different API calls.

• Quai RPC: Supports the most popular JSON RPC methods.

Other

Contract Verification

Verify deployed contracts on the network to gain access to labeled function logging, source code display, and detailed trace descriptions.

Gas Tracker

Detailed statistics on network fee rates, congestion, and load over time.

Blocks update on the homepage as they are created with basic information including block number (block height), number of transactions in the block, and time since the block was created.

Click on a specific block number for information about that block, or View All Blocks for a more detailed overview of recent blocks.

The all blocks page can also be accessed from the top menu.

View All Blocks

The view all blocks page shows updated details from the most recent blocks. Use the page arrows to navigate

Details by line

1. Block Number and time since inclusion

2. Size of the block in bytes

3. Address of the miner who mined this block

4. Number of transactions included in the block

5. Percentage of the total gas used within this block

6. The block reward paid to the miner of this block

7. The total transaction fees burnt within this block

Individual Block Page

Click on a block number (this number, also referred to as block height, indicates how many blocks have been added to the chain) to view additional details about the block. Scroll down to view individual transactions contained in a block.

Click on the tooltip (i) next to each item to view relevant info.

• Main Details

  • Block Height: Also known as block number, shows the position of the block on this shard.

  • Location: The 8 byte chain identifier, indicating which shard the block was mined in.

  • Size: Size of the data contained in the block in bytes.

  • Timestamp: Time & date the block was produced.

  • Transactions: Number of transactions included in the block.

  • Mined By: Address of the miner that received priority fees and the block reward. Copy the address with the gray icon and paste into search to find more details about this miner.

  • Gas Used: Total amount of gas used in the block & % of filled space.

  • Gas Limit: Total gas limit for the block. 30M is Quai Network limit, which represents 2x the 15M target.

  • Base Fee per Gas: Minimum multiplier required for a transaction to be included in a block.

• Extra Block Details

  • Difficulty: Total difficulty to mine the chain up until this block.

  • Location: The 8 byte chain identifier, indicating which shard the block was mined in.

  • MixHash:

  • Nonce: Demonstrates work in PoW.

  • Block Number: The number of the block within the shard it was mined in.

  • Parent Hash: Hash of the preceding block.

  • Time: Time & date the block was produced.

  • Hash: Cryptographic hash of the block header.

  • Total Entropy:

  • more...

Scroll below the block details to view transactions contained within the block.

Different types of transactions are categorized in the Quaiscan UI to allow for quick identification. Types include:

• Coin transfer: value transfer, value >= 0, no transaction input

• Contract call: transaction input is present (any value including 0)

• Contract creation: creation of a smart-contract

• Token burning: recognized token transfer of any of ERC-20, 721, 1155 token instance (single or bulk) to 0x0000... address

• Token creation: creation of token instance in ERC-1155

• Token minting: token transfer of any of ERC-20, 721, 1155 token instance (single or bulk) from 0x0000... address

• Token transfer: token transfer of any of ERC-20, 721, 1155 token instance (single or bulk)

• Transaction: A contract call where the contract has not yet been identified by Quaiscan.

• Coinbase: payout of mining rewards to the miner of a block or workshare.

Quaiscan supports the following token types:

• ERC-20: Fungible tokens

  • Standard for interchangeable tokens

  • Used for cryptocurrencies, stablecoins, utility tokens

• ERC-721: Non-fungible tokens (NFTs)

  • Unique, indivisible tokens

  • Often used for digital art, collectibles, game items

• ERC-1155: Multi-token standard

  • Combines fungible and non-fungible tokens

  • Efficient for gaming and complex ecosystems

• ERC-777: Advanced fungible tokens (basic indexing but no additional views, provides similar info to ERC-20)

  • Adds features like operator support and hooks

  • Backward compatible with ERC-20.

• ERC-4626: Tokenized Vaults (basic indexing but no additional views, provides similar info to ERC-20)

  • Standard for yield-bearing tokens

  • Used in DeFi for lending and yield farming

ERC-1155 contracts are designed to support multiple token types within a single contract. This standard is being adopted rapidly for efficiency and optimization, and is being used to bundle multi-token transactions and approvals while supporting both fungible and non-fungible tokens.

Recognition and labelling for ERC-1155 contracts, indexing instance balances for both FTs and NFTs, parsing single and batched transactions, and monitoring and displaying minting events are included.

Quaiscan Internal Documentation

To view Modules and API Reference documentation:

1. Generate documentation.

   mix docs

2. View the generated docs.

   open doc/index.html

Requests and Limits

The default rate limit for requests is 50 requests/sec set via the default_api_rate_limit variable. This applies to global requests which do not originate from a whitelisted address or do not use an API key.

Quaiscan API Usage

API calls can be accessed from the Quaiscan main menu, footer or header depending on the instance.

Quaiscan supports several methods:

1. REST API: API that serves the Quaiscan UI. -> More info

2. RPC API: provided for developers transitioning their applications from other networks to Quaiscan. Supports GET and POST requests. -> More info

3. Quai RPC API: Supports the most popular JSON RPC methods. -> More info

4. Graphiql: An IDE for exploring GraphQL.

GraphQL

Send Queries to quickly get information. Use the Docs button to quickly find arguments accepted by the schema. More information is available in our Quaiscan GraphQL tutorial.

Quai RPC

Quaiscan supports the following methods. Requests and return data are identical to the Quai documentation.

• quai_blockNumber

• quai_getBalance

• quai_getLogs

• quai_gasPrice

• quai_getTransactionByHash

• quai_getTransactionReceipt

• quai_chainId

• quai_maxPriorityFeePerGas

• quai_getTransactionCount

• quai_getCode

• quai_getStorageAt

• quai_estimateGas

• quai_getBlockByNumber

• quai_getBlockByHash

• quai_sendRawTransaction

• quai_call

More details on Quai RPC for Quaiscan are available here.

REST API methods are used to render the UI for new versions of Blockscout. These can be accessed and used to get many types of information. Methods parameters and schemas are available at https://quaiscan.io/api-docs.

Pagination

Quaiscan uses the keyset pagination method to quickly return results. By default an API response returns the first 50 results. To access additional results (in groups of 50), add the next_page_params to your query.

For example, open https://quaiscan.io/api/v2/transactions and scroll to the bottom of the response.

You will see the next_page_params object. Add the parameters from this object to your next query to receive the next 50 results.

https://quaiscan.io/api/v2/transactions?block_number=4023&index=12&items_count=50

Repeat this process to continue receiving results in groups of 50 (remove params and substitute the new next_page_params found in the body of the query).

In this example, the query to receive the next 50 results would be:

https://quaiscan.io/api/v2/transactions?block_number=4023&index=69&items_count=100

What is GraphQL

GraphQL is an open-source data query and manipulation language for APIs, and a runtime for fulfilling queries with existing data. It provides an efficient, powerful and flexible approach to developing web APIs. It allows clients to define the structure of the data required, and exactly the same structure of the data is returned from the server, therefore preventing excessively large amounts of data from being returned.

Key concepts of the GraphQL query language are:

• Hierarchical

• Strongly typed

• Client-specified queries

Advantages of GraphQL:

• Declarative integration on client (what data/operations do I need)

• A standard way to expose data and operations

• Support for real-time data (with subscriptions)

Query types

There are three main query types in GraphQL schema:

1) Query: fetch data

query {
  allPosts {
    description
    text
  }
}

2) Mutation: change data.

   mutation {
     updatePost(id: 1, text: "text") {
       text
     }
   }

1. Subscription: subscribe to real-time data.

subscription {
  newPost(category: [1]) {
    description
    text
  }
}

Access GraphQL API

To access Quaiscan GraphQL interface you can use GraphiQL - in-browser IDE for exploring GraphQL. It's built in to Blockscout. From the APIs dropdown menu choose GraphQL.

You can also use your favorite http client:

curl 'https://quaiscan.io/graphiql'
  -H 'Authorization: Bearer YOUR_AUTH_TOKEN'
  -d '{"query":""{transaction(hash:\"0x4f3a80620613d18a5073108f56558c7cbf0020c8ccb1acbad2c1f1fe3714e5ce\"){blockNumbertoAddressHashfromAddressHashcreatedContractAddressHashvaluestatusnoncehasherrorgasgasPricegasUsedcumulativeGasUsedidindexinputrsv}}""}'

Queries

Blockscout's GraphQL API provides queries and a subscription. You can view them in the GraphQL interface in the Docs menu. Example Queries:

Example Query to retrieve transactions for a specific address

{
  address(hash: "0x...") {
    transactions(first:5) {
      edges {
        node {
          blockNumber
          createdContractAddressHash
          fromAddressHash
          gas
          hash
        }
      }
    }
  }
}

Note that transactions can accept the following arguments:

• first

• after

• before

This API is provided for developers transitioning applications from other networks to Quai and applications requiring general API and data support. It supports GET and POST requests.

The following modules are supported. Click through to see specific endpoints and parameters.

https://quaiscan.io/api?module=account

Return balance from a provided block

quai_get_balance

Mimics Quai Network JSON RPC's quai_getBalance

Example:

https://quaiscan.io/api
   ?module=account
   &action=quai_get_balance
   &address={addressHash}

{
  "id": 1,
  "jsonrpc": "2.0",
  "result": "0x0234c8a3397aab58"
}

Get the Quai or Qi balance for an address

balance

Many chains use their own native tokens. On Quai Network, this will return the result in "Quai" or "Qi". Results are returned in its (quai) or qits (qi).

Example:

https://quaiscan.io/api
   ?module=account
   &action=balance
   &address={addressHash}

{
	"message": "OK",
	"result": "663046792267785498951364",
	"status": "1"
}

Get balance for multiple addresses

balancemulti

Example:

https://quaiscan.io/api
   ?module=account
   &action=balancemulti
   &address={addressHash1,addressHash2,addressHash3}

{
  "message": "OK",
  "result": [
    {
      "account": "0x00a3e45aa16163f2663015b6695894d918866d19",
      "balance": "40807168566070000000000",
      "stale": true
    },
    {
      "account": "0x00a3e45aa16163f2663015b6695894d918866d19",
      "balance": "332567136222827062478",
      "stale": false
    },
  ],
  "status": "1"
}

Get pending transactions by address

pendingtxlist

Example:

https://quaiscan.io/api
   ?module=account
   &action=pendingtxlist
   &address={addressHash}
   &page=1
   &offset=5

  "message": "OK",
  "result": [
    {
      "contractAddress": "",
      "cumulativeGasUsed": "122207",
      "from": "0x00a3e45aa16163f2663015b6695894d918866d19",
      "gas": "122261",
      "gasPrice": "50000000000",
      "gasUsed": "122207",
      "hash": "0x009c00e4f7345d600b0cfe0dd2b3a0101d5d6f9d0f644d4435057b39141a3bea",
      "input": "0x",
      "nonce": "0",
      "to": "0xde0b295669a9fd93d5f28d9ec85e40f4cb697bae",
      "value": "0x1"
    }
  ],
  "status": "1"
}

Get transactions by address

txlist

Maximum of 10,000 transactions. Also available through a GraphQL 'address' query. For faster results, specify a smaller block range to search using the startblock and endblock parameters

Example:

https://quaiscan.io/api
   ?module=account
   &action=txlist
   &address={addressHash}
   &startblock=555555
   &endblock=666666
   &page=1
   &offset=5
   &sort=asc

{
  "message": "OK",
  "result": [
    {
      "blockHash": "0x0000063bc2cbf2eefcb5af1b8db967de70c15401f191f4d53ff6057bc48a20c2",
      "blockNumber": "0x8b62",
      "contractAddress": null,
      "cumulativeGasUsed": "0x0",
      "effectiveGasPrice": "0x0",
      "etxs": null,
      "from": "0x00a3e45aa16163f2663015b6695894d918866d19",
      "gasUsed": "0x0",
      "logs": [],
      "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
      "status": "0x0",
      "to": "0x00a3e45aa16163f2663015b6695894d918866d19",
      "transactionHash": "0x009c00e4f7345d600b0cfe0dd2b3a0101d5d6f9d0f644d4435057b39141a3bea",
      "transactionIndex": "0x12",
      "type": "0x1"
    }
  ],
  "status": "1"
}

Get internal transactions by transaction or address hash

txlistinternal

Up to a maximum of 10,000 internal transactions. Also available through a GraphQL 'transaction' query. For faster results, specify a smaller block range to search using the start_block and end_block parameters.

Example:

https://quaiscan.io/api
   ?module=account
   &action=txlistinternal
   &txhash={transactionHash}
   &startblock=555555
   &endblock=666666
   &page=1
   &offset=5
   &sort=asc

{
  "message": "OK",
  "result": [
    {
      "blockNumber": "6153702",
      "callType": "delegatecall",
      "contractAddress": "0x883103875d905c11f9ac7dacbfc16deb39655361",
      "errCode": "",
      "from": "0x2ca1e3f250f56f1761b9a52bc42db53986085eff",
      "gas": "814937",
      "gasUsed": "536262",
      "index": "0",
      "input": "",
      "isError": "0",
      "timeStamp": "1534362606",
      "to": "",
      "transactionHash": "0xd65b788c610949704a5f9aac2228c7c777434dfe11c863a12306f57fcbd8cdbb",
      "type": "call",
      "value": "5488334153118633"
    }
  ],
  "status": "1"
}

Get token transfer events by address

tokentx

Up to a maximum of 10,000 token transfer events. Also available through the GraphQL token_transfers query.

Example:

https://quaiscan.io/api
   ?module=account
   &action=tokentx
   &address={addressHash}
   &page=1
   &offset=10
   &sort=asc

{
  "message": "OK",
  "result": [
    {
      "blockHash": "0x6169c5dc05d0051564ba3eae8ebfbdefda640c5f5ffc095846b8aed0b44f64ea",
      "blockNumber": "5997843",
      "confirmations": "199384",
      "contractAddress": "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2",
      "cumulativeGasUsed": "1043649",
      "from": "0x4e83362442b8d1bec281594cea3050c8eb01311c",
      "gas": "44758",
      "gasPrice": "7000000000",
      "gasUsed": "37298",
      "hash": "0xd65b788c610949704a5f9aac2228c7c777434dfe11c863a12306f57fcbd8cdbb",
      "input": "0xa9059cbb00000000000000000000000021e21ba085289f81a86921de890eed30f1ad23750000000000000000000000000000000000000000000000008ac7230489e80000",
      "logIndex": "0",
      "nonce": "765",
      "timeStamp": "1532086946",
      "to": "0x21e21ba085289f81a86921de890eed30f1ad2375",
      "tokenDecimal": "18",
      "tokenName": "Maker",
      "tokenSymbol": "MKR",
      "transactionIndex": "27",
      "value": "10000000000000000000"
    }
  ],
  "status": "1"
}

Get ERC-721 token transfer events by address

tokennfttx

Example:

https://quaiscan.io/api
   ?module=account
   &action=tokennfttx
   &address={addressHash}
   &page=1
   &offset=10
   &sort=asc

{
  "message": "OK",
  "result": [
    {
      "blockHash": "0x3b8e5e9ecb0ad53e58cd99182de99a1166946dc758b85a5529710bd47e35a49d",
      "blockNumber": "8879951",
      "confirmations": "1295191",
      "contractAddress": "0xe0617cd5b8271070b68bfc275220ef5dd32b8f58",
      "cumulativeGasUsed": "15289706",
      "from": "0x0000000000000000000000000000000000000000",
      "gas": "59636",
      "gasPrice": "1503183880",
      "gasUsed": "59636",
      "hash": "0x844ddc178dbeed48c9caef9a71a86b2d017529c1074a0390d2a61d29baa94c94",
      "input": "deprecated",
      "logIndex": "83",
      "nonce": "301",
      "timeStamp": "1682283420",
      "to": "0x34aa3f359a9d614239015126635ce7732c18fdf3",
      "tokenDecimal": "0",
      "tokenID": "2",
      "tokenName": "YourMintableSoulboundCollectible",
      "tokenSymbol": "YMSC",
      "transactionIndex": "42"
    }
  ],
  "status": "1"
}

Usage:

• To fetch ERC-721 token transfers by address, specify address parameter

• To fetch ERC-721 token transfers by token, specify contractaddress parameter

• To fetch ERC-721 token transfers by address filtered by token, specify both address and contractaddress parameters

Get token account balance for token contract address

tokenbalance

Example:

https://quaiscan.io/api
   ?module=account
   &action=tokenbalance
   &contractaddress={contractAddressHash}
   &address={addressHash}

{
  "message": "OK",
  "result": "135499",
  "status": "1"
}

Get list of tokens owned by address

tokenlist

Example:

https://quaiscan.io/api
   ?module=account
   &action=tokenlist
   &address={addressHash}

{
  "message": "OK",
  "result": [
    {
      "balance": "135499",
      "contractAddress": "0x0000000000000000000000000000000000000000",
      "decimals": "18",
      "name": "Example Token",
      "symbol": "ET",
      "type": "ERC-20"
    },
    {
      "balance": "1",
      "contractAddress": "0x0000000000000000000000000000000000000001",
      "decimals": "18",
      "name": "Example ERC-721 Token",
      "symbol": "ET7",
      "type": "ERC-721"
    }
  ],
  "status": "1"
}

Get list of blocks mined by address

getminedblocks

Example:

https://quaiscan.io/api
   ?module=account
   &action=getminedblocks
   &address={addressHash}

{
  "message": "OK",
  "result": [
    {
      "blockNumber": "3462296",
      "blockReward": "5194770940000000000",
      "timeStamp": "1491118514"
    }
  ],
  "status": "1"
}

Get a list of accounts and their balances

listaccounts

Lists accounts and native balances, sorted ascending by the time they were first seen by the explorer.

Example:

https://quaiscan.io/api
   ?module=account
   &action=listaccounts
   &address={addressHash}
   &page=1
   &offset=3

{
  "message": "OK",
  "result": [
    {
      "address": "0x00a3e45aa16163f2663015b6695894d918866d19",
      "balance": "3790064387342000000",
      "stale": false
    },
    {
      "address": "0x00a3e45aa16163f2663015b6695894d918866d19",
      "balance": "2047176464264000000",
      "stale": false
    },
  ],
  "status": "1"
}

https://quaiscan.io/api?module=block

Get block reward by block number

getblockreward

Returns the block reward and 'uncle' block rewards when applicable.

Example:

https://quaiscan.io/api
   ?module=block
   &action=getblockreward
   &blockno={blockNumber}

{
	"message": "OK",
	"result": {
		"blockMiner": "0x00a3e45aa16163f2663015b6695894d918866d19",
		"blockNumber": "2165403",
		"blockReward": "5314181600000000000",
		"timeStamp": "1472533979",
		"uncleInclusionReward": null,
		"uncles": null
	},
	"status": "1"
}

Get estimated block countdown time by block number

getblockcountdown

Returns the estimated time remaining, in seconds, until a certain block is included in blockchain.

Example:

https://quaiscan.io/api
   ?module=block
   &action=getblockcountdown
   &blockno={blockNumber}

{
	"message": "OK",
	"result": {
		"CurrentBlock": "115334213",
		"CountdownBlock": "116015880",
		"RemainingBlock": "681667",
		"EstimateTimeInSec": "1363349.0"
	},
	"status": "1"
}

Get block number by time stamp

getblocknobytime

Returns the block number created closest to a provided timestamp.

Example:

https://quaiscan.io/api
   ?module=block
   &action=getblocknobytime
   &timestamp={blockTimestamp}
   &closest={before/after}

{
  "message": "OK",
  "result": {
    "blockNumber": "2165403"
  },
  "status": "1"
}

Get the latest block number

quai_block_number

Mimics Quai Network JSON RPC's quai_blockNumber.

Example:

https://quaiscan.io/api
   ?module=block
   &action=quai_block_number

{
  "jsonrpc": "2.0",
  "result": "0x103538a",
  "id": 1
}

https://quaiscan.io/api?module=contract

Get a list of contracts

listcontracts

List sorted in ascending order based on the time a contact was first indexed by the explorer. With filters `not_decompiled`(`4`) or `not_verified(4)` the results will not be sorted for performance reasons.

Example:

https://quaiscan.io/api
   ?module=contract
   &action=listcontracts

{
  "message": "OK",
  "result": [
    {
      "ABI": "[{\n\"type\":\"event\",\n\"inputs\": [{\"name\":\"a\",\"type\":\"uint256\",\"indexed\":true},{\"name\":\"b\",\"type\":\"bytes32\",\"indexed\":false}],\n\"name\":\"Event\"\n}, {\n\"type\":\"event\",\n\"inputs\": [{\"name\":\"a\",\"type\":\"uint256\",\"indexed\":true},{\"name\":\"b\",\"type\":\"bytes32\",\"indexed\":false}],\n\"name\":\"Event2\"\n}, {\n\"type\":\"function\",\n\"inputs\": [{\"name\":\"a\",\"type\":\"uint256\"}],\n\"name\":\"foo\",\n\"outputs\": []\n}]\n",
      "CompilerVersion": "v0.2.1-2016-01-30-91a6b35",
      "ContractName": "Test",
      "OptimizationUsed": "1",
      "SourceCode": "pragma solidity >0.4.24;\n\ncontract Test {\nconstructor() public { b = hex\"12345678901234567890123456789012\"; }\nevent Event(uint indexed a, bytes32 b);\nevent Event2(uint indexed a, bytes32 b);\nfunction foo(uint a) public { emit Event(a, b); }\nbytes32 b;\n}\n"
    }
  ],
  "status": "1"
}

Get ABI for a verified contract

getabi

Also available through a GraphQL addresses query.

Example:

https://quaiscan.io/api
   ?module=contract
   &action=getabi
   &address={addressHash}

{
  "message": "OK",
  "result": "[{\"constant\":false,\"inputs\":[{\"name\":\"voucher_token\",\"type\":\"bytes32\"}],\"name\":\"burn\",\"outputs\":[{\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"voucher_token\",\"type\":\"bytes32\"}],\"name\":\"is_expired\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"voucher_token\",\"type\":\"bytes32\"}],\"name\":\"is_burnt\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"name\":\"voucher_token\",\"type\":\"bytes32\"},{\"name\":\"_lifetime\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}]",
  "status": "1"
}

Get contract source code for a verified contract

getsourcecode

Also available through a GraphQL addresses query.

Example:

https://quaiscan.io/api
   ?module=contract
   &action=getsourcecode
   &address={addressHash}

{
  "message": "OK",
  "result": {
    "ABI": "[{\n\"type\":\"event\",\n\"inputs\": [{\"name\":\"a\",\"type\":\"uint256\",\"indexed\":true},{\"name\":\"b\",\"type\":\"bytes32\",\"indexed\":false}],\n\"name\":\"Event\"\n}, {\n\"type\":\"event\",\n\"inputs\": [{\"name\":\"a\",\"type\":\"uint256\",\"indexed\":true},{\"name\":\"b\",\"type\":\"bytes32\",\"indexed\":false}],\n\"name\":\"Event2\"\n}, {\n\"type\":\"function\",\n\"inputs\": [{\"name\":\"a\",\"type\":\"uint256\"}],\n\"name\":\"foo\",\n\"outputs\": []\n}]\n",
    "CompilerVersion": "v0.2.1-2016-01-30-91a6b35",
    "ContractName": "Test",
    "FileName": "{sourcify path or empty}",
    "ImplementationAddress": "0x000000000000000000000000000000000000000e",
    "IsProxy": "true",
    "OptimizationUsed": "1",
    "SourceCode": "pragma solidity >0.4.24;\n\ncontract Test {\nconstructor() public { b = hex\"12345678901234567890123456789012\"; }\nevent Event(uint indexed a, bytes32 b);\nevent Event2(uint indexed a, bytes32 b);\nfunction foo(uint a) public { emit Event(a, b); }\nbytes32 b;\n}\n"
  },
  "status": "1"
}

Get contract creator address hash and creation transaction hash

getcontractcreation

Returns contract creator and transaction hash. Up to 10 contracts at the one request

Example:

https://quaiscan.io/api
   ?module=contract
   &action=getcontractcreation
   &contractaddresses={addressHash},{addressHash}

{
  "message": "OK",
  "result": [
    {
      "contractAddress": "0x005f644097F8f0E9f996Dca4F4F23aBB6C1Cc8b3",
      "contractCreator": "0x00a3e45aa16163f2663015b6695894d918866d19",
      "txHash": "0x04fd008c28afb2c889d7d10a6f20f889289d333826be77e0945500c612ea6c2b"
    },
  ],
  "status": "1"
}

Verify a contract with its source code and contract creation information

verify

Example:

https://quaiscan.io/api
   ?module=contract
   &action=verify
   &addressHash={addressHash}
   &name={name}
   &compilerVersion={compilerVersion}
   &optimization={false}
   &contractSourceCode={contractSourceCode}

Curl Post Example

curl -d '{"addressHash":"0x005f644097F8f0E9f996Dca4F4F23aBB6C1Cc8b3","compilerVersion":"v0.5.4+commit.9549d8ff", "contractSourceCode":"pragma solidity ^0.5.4; contract Test { }","name":"Test","optimization":false}' -H "Content-Type: application/json" -X POST "https://quaiscan.io/api?module=contract&action=verify"

{
  "message": "OK",
  "result": {
    "ABI": "[{\n\"type\":\"event\",\n\"inputs\": [{\"name\":\"a\",\"type\":\"uint256\",\"indexed\":true},{\"name\":\"b\",\"type\":\"bytes32\",\"indexed\":false}],\n\"name\":\"Event\"\n}, {\n\"type\":\"event\",\n\"inputs\": [{\"name\":\"a\",\"type\":\"uint256\",\"indexed\":true},{\"name\":\"b\",\"type\":\"bytes32\",\"indexed\":false}],\n\"name\":\"Event2\"\n}, {\n\"type\":\"function\",\n\"inputs\": [{\"name\":\"a\",\"type\":\"uint256\"}],\n\"name\":\"foo\",\n\"outputs\": []\n}]\n",
    "CompilerVersion": "v0.2.1-2016-01-30-91a6b35",
    "ContractName": "Test",
    "ImplementationAddress": "0x000000000000000000000000000000000000000e",
    "IsProxy": "true",
    "OptimizationUsed": "1",
    "SourceCode": "pragma solidity >0.4.24;\n\ncontract Test {\nconstructor() public { b = hex\"12345678901234567890123456789012\"; }\nevent Event(uint indexed a, bytes32 b);\nevent Event2(uint indexed a, bytes32 b);\nfunction foo(uint a) public { emit Event(a, b); }\nbytes32 b;\n}\n"
  },
  "status": "1"
}

Verify a contract through Sourcify

verify_via_sourcify

1. if a smart contract is already verified on Sourcify, it will automatically fetch the data from the repo

2. otherwise you need to upload source files and JSON metadata file(s).

Example:

https://instance_base_url/api
 ?module=contract
 &action=verify_via_sourcify
 &addressHash={addressHash}

POST body example

--6e1e4c11657c62dc1e4349d024de9e28
Content-Disposition: form-data; name="addressHash"

0xb77b7443e0F32F1FEBf0BE0fBd7124D135d0a525

--6e1e4c11657c62dc1e4349d024de9e28
Content-Disposition: form-data; name="files[0]"; filename="contract.sol"
Content-Type: application/json

...Source code...

--6e1e4c11657c62dc1e4349d024de9e28
Content-Disposition: form-data; name="files[1]"; filename="metadata.json"
Content-Type: application/json

...JSON metadata...

--6e1e4c11657c62dc1e4349d024de9e28--

{
  "message": "OK",
  "result": {
    "ABI": "[{\n\"type\":\"event\",\n\"inputs\": [{\"name\":\"a\",\"type\":\"uint256\",\"indexed\":true},{\"name\":\"b\",\"type\":\"bytes32\",\"indexed\":false}],\n\"name\":\"Event\"\n}, {\n\"type\":\"event\",\n\"inputs\": [{\"name\":\"a\",\"type\":\"uint256\",\"indexed\":true},{\"name\":\"b\",\"type\":\"bytes32\",\"indexed\":false}],\n\"name\":\"Event2\"\n}, {\n\"type\":\"function\",\n\"inputs\": [{\"name\":\"a\",\"type\":\"uint256\"}],\n\"name\":\"foo\",\n\"outputs\": []\n}]\n",
    "CompilerVersion": "v0.2.1-2016-01-30-91a6b35",
    "ContractName": "Test",
    "ImplementationAddress": "0x000000000000000000000000000000000000000e",
    "IsProxy": "true",
    "OptimizationUsed": "1",
    "SourceCode": "pragma solidity >0.4.24;\n\ncontract Test {\nconstructor() public { b = hex\"12345678901234567890123456789012\"; }\nevent Event(uint indexed a, bytes32 b);\nevent Event2(uint indexed a, bytes32 b);\nfunction foo(uint a) public { emit Event(a, b); }\nbytes32 b;\n}\n"
  },
  "status": "1"
}

Verify a vyper contract with its source code and contract creation information

verify_vyper_contract

Example

https://instance_base_url/api
 ?module=contract
 &action=verify_vyper_contract
 &addressHash={addressHash}
 &name={name}
 &compilerVersion={compilerVersion}
 &contractSourceCode={contractSourceCode}

curl POST example

curl --location --request POST 'http://localhost:4000/api?module=contract&action=verify_vyper_contract' --form 'contractSourceCode="SOURCE_CODE"' --form 'name="Vyper_contract"' --form 'addressHash="0xE60B1B8bD493569a3E945be50A6c89d29a560Fa1"' --form 'compilerVersion="v0.2.12"'

{
  "message": "OK",
  "result": {
    "ABI": "[{\n\"type\":\"event\",\n\"inputs\": [{\"name\":\"a\",\"type\":\"uint256\",\"indexed\":true},{\"name\":\"b\",\"type\":\"bytes32\",\"indexed\":false}],\n\"name\":\"Event\"\n}, {\n\"type\":\"event\",\n\"inputs\": [{\"name\":\"a\",\"type\":\"uint256\",\"indexed\":true},{\"name\":\"b\",\"type\":\"bytes32\",\"indexed\":false}],\n\"name\":\"Event2\"\n}, {\n\"type\":\"function\",\n\"inputs\": [{\"name\":\"a\",\"type\":\"uint256\"}],\n\"name\":\"foo\",\n\"outputs\": []\n}]\n",
    "CompilerVersion": "v0.2.1-2016-01-30-91a6b35",
    "ContractName": "Test",
    "ImplementationAddress": "0x000000000000000000000000000000000000000e",
    "IsProxy": "true",
    "OptimizationUsed": "1",
    "SourceCode": "pragma solidity >0.4.24;\n\ncontract Test {\nconstructor() public { b = hex\"12345678901234567890123456789012\"; }\nevent Event(uint indexed a, bytes32 b);\nevent Event2(uint indexed a, bytes32 b);\nfunction foo(uint a) public { emit Event(a, b); }\nbytes32 b;\n}\n"
  },
  "status": "1"
}

Verify a contract with Standard input JSON file

verifysourcecode

Example

https://instance_base_url/api
 ?module=contract
 &action=verifysourcecode
 &codeformat={solidity-standard-json-input}
 &contractaddress={contractaddress}
 &contractname={contractname}
 &compilerversion={compilerversion}
 &sourceCode={sourceCode}

solidity-single-file:

curl --location 'localhost:4000/api?module=contract&action=verifysourcecode' \
--form 'contractaddress="0xDc2082945d55596bf39F362d9EC0F7F65eDBB9DD"' \
--form 'sourceCode="// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract Storage {
    uint256 number;

    function store(uint256 num) public {
        number = num;
    }

    function retrieve() public view returns (uint256){
        return number;
    }
}"' \
--form 'contractname="Storage"' \
--form 'codeformat="solidity-single-file"' \
--form 'compilerversion="v0.8.17+commit.8df45f5f"' \
--form 'optimizationUsed="1"' \
--form 'runs="199"' \
--form 'constructorArguements=""' \
--form 'evmversion="london"' \
--form 'libraryname1="qwe"' \
--form 'libraryaddress1="0xDc2082945d55596bf39F362d9EC0F7F65eDBB9DD"'
--form 'licenseType=0'

{
  "message": "OK",
  "result": "b080b96bd06ad1c9341c2afb7e3730311388544961acde94",
  "status": "1"
}

Return status of a verification attempt

checkverifystatus

Example

https://instance_base_url/api
 ?module=contract
 &action=checkverifystatus
 &guid={identifierString}

{
  "message": "OK",
  "result": "Pending in queue",
  "status": "1"
}

Verify proxy contract

verifyproxycontract

Example

https://instance_base_url/api
 ?module=contract
 &action=verifyproxycontract
 &address={addressHash}

{
    "message": "OK",
    "result": "c32d204404f33ff38fee42394f7e671fd96314b3658d466a",
    "status": "1"
}

Return status of a proxy contract verification attempt

checkproxyverification

Example

https://instance_base_url/api
 ?module=contract
 &action=checkproxyverification
 &guid={identifierString}

{
  "message": "OK",
  "result": "Implementation (0x5a3f40fd57731bbf62a38fd290add074e9cdb844) was verified and saved for proxy (0xc32d204404f33ff38fee42394f7e671fd96314b3)",
  "status": "1"
}

https://quaiscan.io/api?module=logs

Get Event Logs by Address and/or Topic(s)

getLogs

Event logs for an address and topic. Use and/or with the topic operator to specify topic retrieval options when adding multiple topics. Up to a maximum of 1,000 event logs.

Example:

https://quaiscan.io/api
   ?module=logs
   &action=getLogs
   &fromBlock=1379224
   &toBlock=13792288
   &address=0x005f644097F8f0E9f996Dca4F4F23aBB6C1Cc8b3
   &topic0=0xf63780e752c6a54a94fc52715dbc5518a3b4c3c2833d301a204226548a2a8545
   &topic1=0x72657075746174696f6e00000000000000000000000000000000000000000000
   &topic0_1_opr=or

*=required field

{
  "message": "OK",
  "result": [
    {
      "address": "0x33990122638b9132ca29c723bdf037f1a891a70c",
      "blockNumber": "0x5c958",
      "data": "0x",
      "gasPrice": "0xba43b7400",
      "gasUsed": "0x10682",
      "logIndex": "0x",
      "timeStamp": "0x561d688c",
      "topics": [
        "0xf63780e752c6a54a94fc52715dbc5518a3b4c3c2833d301a204226548a2a8545",
        "0x72657075746174696f6e00000000000000000000000000000000000000000000",
        "0x000000000000000000000000d9b2f59f3b5c7b3c67047d2f03c3e8052470be92"
      ],
      "transactionHash": "0x0b03498648ae2da924f961dda00dc6bb0a8df15519262b7e012b7d67f4bb7e83",
      "transactionIndex": "0x"
    }
  ],
  "status": "1"
}

https://quaiscan.io/api?module=stats

Get ERC-20 or ERC-721 token total supply by contract address

tokensupply

Example

https://quaiscan.io/api
   ?module=stats
   &action=tokensupply
   &contractaddress={contractAddressHash}

{
  "message": "OK",
  "result": "21265524714464",
  "status": "1"
}

Get total coin supply from DB minus burnt number

coinsupply

Example:

// Some code

// Some code

Get latest price of native coin in USD and BTC in more general format

coinprice

Example:

// Some code

// Some code

https://quaiscan.io/api?module=token

Get ERC-20 or ERC-721 token by contract address

getToken

Info on name, symbol, supply and type for a token contract address.

Example

https://quaiscan.io/api
   ?module=token
   &action=getToken
   &contractaddress={contractaddressHash}

{
  "message": "OK",
  "result": {
    "cataloged": true,
    "contractAddress": "0x0000000000000000000000000000000000000000",
    "decimals": "18",
    "name": "Example Token",
    "symbol": "ET",
    "totalSupply": "1000000000",
    "type": "ERC-20"
  },
  "status": "1"
}

Get token holders by contract address

getTokenHolders

Returns an array of token holder's accounts and amounts held for a specified token contract address.

Example

https://quaiscan.io/api
   ?module=token
   &action=getTokenHolders
   &contractaddress={contractaddressHash}
   &page={integer}
   &offset={integer}

{
  "message": "OK",
  "result": [
    {
      "address": "0x005f644097F8f0E9f996Dca4F4F23aBB6C1Cc8b3",
      "value": "153737849289497644937838"
    },
  ],
  "status": "1"
}

https://quaiscan.io/api?module=transaction

Get transaction info

gettxinfo

Information related to a specified transaction. Includes:

• blockNumber

• confirmations

• from

• gasLimit (in its)

• gasPrice (in its)

• gasUsed

• hash

• input

• logs (array)

• revert reason

• success

• timeStamp

• to

• value (in its)

Example

https://quaiscan.io/api
   ?module=transaction
   &action=gettxinfo
   &txhash={transactionHash}

{
  "result": {
    "revertReason": "No credit of that type",
    "blockNumber": "3",
    "confirmations": "0",
    "from": "0x000000000000000000000000000000000000000c",
    "gasLimit": "91966",
    "gasPrice": "100000",
    "gasUsed": "95123",
    "hash": "0x0000000000000000000000000000000000000000000000000000000000000004",
    "input": "0x04",
    "logs": [
      {
        "address": "0x000000000000000000000000000000000000000e",
        "data": "0x00",
        "topics": [
          "First Topic",
          "Second Topic",
          "Third Topic",
          "Fourth Topic"
        ]
      }
    ],
    "success": true,
    "timeStamp": "1541018182",
    "to": "0x000000000000000000000000000000000000000d",
    "value": "67612"
  },
  "status": "1"
}

Get transaction receipt status

gettxreceiptstatus

Also available through a GraphQL 'transaction' query. Status field return:

• 0 = failed transaction

• 1 = successful transaction

Example

https://quaiscan.io/api
   ?module=transaction
   &action=gettxreceiptstatus
   &txhash={transactionHash}

{
  "message": "OK",
  "result": {
    "status": "1"
  },
  "status": "1"
}

Get error status and message

getstatus

Also available through a GraphQL 'transaction' query. Includes the following:

• errDescription: string with error message

• isError

  • 0 = pass, no error

  • 1 = error

Example

https://instance_base_url/api
   ?module=transaction
   &action=getstatus
   &txhash={transactionHash}

{
  "message": "OK",
  "result": {
    "errDescription": "Out of gas",
    "isError": "1"
  },
  "status": "1"
}

\

In addition to the custom RPC endpoints documented here, the Quaiscan Quai RPC API supports most used methods in the exact format specified for Quai Network nodes, see the Quai Network JSON-RPC Specification for more details.

These methods are provided for your convenience and are most suitable as a fallback option in your JSON RPC API providers. For other use cases, REST or custom RPC methods are recommended.

The following methods are supported:

• quai_blockNumber

• quai_getBalance

• quai_getLogs

• quai_gasPrice

• quai_getTransactionByHash

• quai_getTransactionReceipt

• quai_chainId

• quai_maxPriorityFeePerGas

• quai_getTransactionCount

• quai_getCode

• quai_getStorageAt

• quai_estimateGas

• quai_getBlockByNumber

• quai_getBlockByHash

• quai_sendRawTransaction

• quai_call

In the following examples we use the Quai Network mainnet with the base instance url https://quaiscan.io. When sending a request add /api/eth-rpc to the end of the base url.

quai_blockNumber

Returns the latest block number in the chain in hexidecimal format. No params are needed. Type: POST

Example

// Request
curl -H "content-type: application/json" -X POST --data '{"id":0,"jsonrpc":"2.0","method":"quai_blockNumber","params":[]}' https://quaiscan.io/api/eth-rpc
// Response
{
  "jsonrpc": "2.0",
  "result": "0xfa0b0e",
  "id": 0
}

quai_getBalance

Returns the balance of a given address in its. Note the earliest parameter does not work as expected because genesis block balances are not currently imported. Parameters are required.

Required Parameters

Example

// Request
curl -H "content-type: application/json" -X POST --data '{"id":0,"jsonrpc":"2.0","method":"quai_getBalance","params":["0x005f644097F8f0E9f996Dca4F4F23aBB6C1Cc8b3","latest"]}' https://quaiscan.io/api/eth-rpc
// Response
{
  "jsonrpc": "2.0",
  "result": "0x1d863bf76508104fb", //34039260923474019579
  "id": 0
}

More examples

Refer to the Quai Network JSON-RPC Specification for more examples and info on the remaining methods.

Once verified, a smart contract or token contract's source code becomes publicly available and verifiable, creating transparency and trust.

Verification is available for both Solidity and SolidityX contracts. Currently, there are 3 different type of inputs you can use for verification using the Quaiscan UI.

Smart Contract Verification with Quaiscan

1) Go to the Verify contract page (Other -> Verify contract)

2) Enter in the contract address you received during deployment. The dropdown will show you several available verification options. Select the one you would like to use and continue.

• Solidity & SolidityX (Flattened source code)

• Solidity & SolidityX (Standard JSON input)

• Solidity & SolidityX (Multi-part files)

Solidity (Flattened source code)

This verification method is recommended only for single-file smart contract without any imports. For verifaction of contracts containing more that 1 file, it's recommended to use different verification method.

1. Contract Address: The 0x address supplied on contract creation (added above)

2. Is Yul contract: Select if the contract is coded in Yul for efficiency.

3. Include Nightly Builds: Select if you want to show nightly builds.

4. Compiler: derived from the first line in the contract pragma solidity X.X.X. Use the corresponding compiler version rather than the nightly build.

5. EVM Version: Select the correct EVM version if known, otherwise use default.

6. Optimization Enabled: If you enabled optimization during compilation, select and enter the run value. 200 is the Solidity Compiler default value. Only change if you changed this value while compiling.

7. Enter the Solidity Contract Code: Copy-paste the source code of your smart contract as is.

8. Add Contract Libraries: Enter the name and 0x address for any required libraries called in the .sol file. You can add multiple contracts with the "+" button.

9. Click the Verify and Publish button.

10. If all goes well, you will see a checkmark ✅ next to Code in the code tab, and an additional tab called Read Contract. The contract name will now appear in Quaiscan with any transactions related to your contract.

Solidity (Standard JSON input)

1. Include nightly builds. You can choose Yes or No depending on your compiler.

2. Compiler. Choose the compiler version used to compile your smart contract. If you selected yes for nightly builds, use the compiler version rather than the build.

3. Standard Input JSON. Upload your Standard Input JSON file. File should follows solidity format and all the sources must be in Literal Content format, not a URL.

Click the Verify & publish button and wait for the response.

Solidity (Multi-part files)

See the above settings. You will upload all of the .sol or .yul files you used for your contract. This method requires at least 2 files - if you have a single file use the flattened source code method.

Troubleshooting

If you receive the dreaded There was an error compiling your contract message this means the bytecode doesn't match the supplied source code. Unfortunately, there are many reasons this may be the case. Here are a few things to try:

1) Double check the compiler version is correct

2) Check that an extra space has not been added to the end of the contract. When pasting in, an extra space may be added. Delete this and attempt to recompile.

3) Copy, paste, and verify your source code in Remix. You may find some exceptions here.

Verification in a dev environment

The Hardhat verification plugin supports Quaiscan.

This is the preferred option for contract verification via API. However, you can also use RPC endpoints, more info is available here.

License type

You can specify license type of the smart contract as string or number. For example for GNU General Public License v2.0 (GNU GPLv2) you could pass either 4 or "gnu_gpl_v2"

We are supporting such types of license as:

1. No License (None)
2. The Unlicense (Unlicense)
3. MIT License (MIT)
4. GNU General Public License v2.0 (GNU GPLv2)
5. GNU General Public License v3.0 (GNU GPLv3)
6. GNU Lesser General Public License v2.1 (GNU LGPLv2.1)
7. GNU Lesser General Public License v3.0 (GNU LGPLv3)
8. BSD 2-clause "Simplified" license (BSD-2-Clause)
9. BSD 3-clause "New" Or "Revised" license* (BSD-3-Clause)
10. Mozilla Public License 2.0 (MPL-2.0)
11. Open Software License 3.0 (OSL-3.0)
12. Apache 2.0 (Apache-2.0)
13. GNU Affero General Public License (GNU AGPLv3)
14. Business Source License (BSL 1.1)

API license types:

none
unlicense
mit
gnu_gpl_v2
gnu_gpl_v3
gnu_lgpl_v2_1
gnu_lgpl_v3
bsd_2_clause
bsd_3_clause
mpl_2_0
osl_3_0
apache_2_0
gnu_agpl_v3
bsl_1_1

Verify smart contract

Use the appropriate Quaiscan instance endpoint to verify if the smart contract microservice is enabled.

In the following examples we use https://quaiscan.io to query the network.

Flattened contract

For more information on parameters to pass, see the flattened source code information on the Verifying a smart contract page.

Via Standard JSON input

For more information on parameters to pass, see the flattened source code information on the Verifying a smart contract page. 0x contract in POST example should be replaced with your contract hash.

Multi-part Solidity files

Hardhat is a full-featured development environment for contract compilation, deployment and verification. The hardhat-verify plugin supports contract verification on Quaiscan.

Get Started

1) Install Hardhat

If you are starting from scratch, create an npm project by going to an empty folder, running npm init, and following the instructions. Recommend npm 7 or higher.

Once your project is ready:

npm instructions

npm install --save-dev hardhat

yarn instructions

yarn add --dev hardhat

2) Create a project

Run npx hardhat in your project folder and follow the instructions to create (more info here).

3) Install plugin

Install the hardhat-verify plugin

npm

npm install --save-dev @nomicfoundation/hardhat-verify

yarn

yarn add --dev @nomicfoundation/hardhat-verify

4) Add plugin reference to config file

Add the following statement to your hardhat.config.js.

require("@nomicfoundation/hardhat-verify");

If using TypeScript, add this to your hardhat.config.ts. More info on using typescript with hardhat available here.

import "@nomicfoundation/hardhat-verify";

Config File

Your basic Hardhat config file (hardhat.config.js or hardhat.config.ts) will be setup to support the network you are working on. In this example we use the Optimism Sepolia test network and a .js file.

Here we add an RPC url without an API key, however some value is still required. You can use any arbitrary string. More info.

If you prefer, you can migrate to hardhat-toolbox to use a plugin bundle.

In order to use Quaiscan explorer for the verification, you have to specify the explorer details under a customChains object. It includes:

• chainID - Quai Network ChainID

• apiURL - Quaiscan API URL

• browserURL - Quaiscan Web URL

For example, here we added Quaiscan api endpoints for Quai Network to the config file. Note the network name in customChains must match the network name in the apiKey object.

import { HardhatUserConfig } from 'hardhat/config'
import '@nomicfoundation/hardhat-toolbox'
import '@nomicfoundation/hardhat-verify'

const PRIVATE_KEY = vars.get('PRIVATE_KEY')

const config: HardhatUserConfig = {
	solidity: '0.8.24',
	networks: {
		'quai': {
			url: 'https://rpc.dev.quai.network',
			accounts: [PRIVATE_KEY],
		},
	},
	etherscan: {
		apiKey: {
			// Is not required by quaiscan. Can be any non-empty string
			'quai': 'abc',
		},
		customChains: [
			{
				network: 'quai',
				chainId: 9000,
				urls: {
					apiURL: 'https://quaiscan.io/api/v2',
					browserURL: 'https://quaiscan.io/',
				},
			},
		],
	},
	sourcify: {
		enabled: false,
	},
}

export default config

Deploy and Verify

For deployment we will use Hardhat Ignition - built-in Hardhat deployment system.

Deploy

> npx hardhat ignition deploy ./ignition/modules/Lock.ts --network quai
✔ Confirm deploy to network quai (9000)? … yes
Compiled 1 Solidity file successfully (evm target: istanbul).
Hardhat Ignition 🚀

Deploying [ LockModule ]

Batch #1
  Executed LockModule#Lock

[ LockModule ] successfully deployed 🚀

Deployed Addresses

LockModule#Lock - 0x00126b33e425f99ce962ACB91752DB41F302EFEA

Verify

The plugin requires you to include constructor arguments with the verify task and ensures that they correspond to expected ABI signature. However, Quaiscan ignores those arguments, so you may specify any values that correspond to the ABI.

npx hardhat verify --network <network> DEPLOYED_CONTRACT_ADDRESS "Constructor argument 1"

Optimism Sepolia example.

> npx hardhat verify --network quai 0x00126b33e425f99ce962ACB91752DB41F302EFEA 1234
Successfully submitted source code for contract
contracts/Lock.sol:Lock at 0x00126b33e425f99ce962ACB91752DB41F302EFEA
for verification on the block explorer. Waiting for verification result...

Successfully verified contract Lock on the block explorer.
https://quaiscan.io/address/0x00126b33e425f99ce962ACB91752DB41F302EFEA#code

Confirm Verification on Quaiscan

Go to your Quaiscan instance and paste the contract address into the search bar.

Scroll down to see verified status. A green checkmark ✅ means the contract is verified.

Scroll down to see and interact with the contract code.

Resources

Docker deployment is currently the easiest way to deploy Quaiscan locally. See the Docker-compose Deployment section for instructions.

If you have a question that isn't answered here, please contact us in our Discord and the team and community can help troubleshoot your issue.

User FAQs

Developer FAQs

curl -X GET "
https://quaiscan.io/api?module=contract&action=listcontracts&page=1&offset=50&filter=verified
" -H "accept: application/json"

Frontend, Backend, and Indexer Release notes:

https://github.com/dominant-strategies/quaiscan-blockscout

Highlights

• #pull-request-number - description

New Features List

• #pull-request-number - description