schema.graphql

schema {
  query: RootQueryType
}

type Account {
  account_udts(input: AccountChildAccountUdtsInput = {page: 1, page_size: 20, sort_type: DESC}): [AccountUdt]
  eth_address: String
  id: Int
  nonce: Int
  script: Json
  script_hash: String
  short_address: String
  smart_contract: SmartContract
  token_transfer_count: Int
  transaction_count: Int
  type: AccountType
}

input AccountChildAccountUdtsInput {
  """
  argument: the page of query result, the relations of postgres offset: offset = (page - 1) * page_size
  
  default: 1
  """
  page: Int = 1

  """
  argument: the page_size of query result, it's the same of postgres limit
  
  default: 20
  """
  page_size: Int = 20

  """
  argument: the sort of type by custom condition
  
  default: desc
  """
  sort_type: SortType = DESC
}

type AccountCkb {
  address_hash: String
  balance: Decimal
}

input AccountCkbsInput {
  address_hashes: [String] = []
}

input AccountInput {
  """
  argument: account address(eth_address or short_address)
  example-1: "0x15ca4f2165ff0e798d9c7434010eaacc4d768d85"
  example-2: "0xc5e133e6b01b2c335055576c51a53647b1b9b624"
  """
  address: String!
}

enum AccountType {
  META_CONTRACT
  POLYJUICE_CONTRACT
  POLYJUICE_ROOT
  UDT
  USER
}

type AccountUdt {
  account: Account
  address_hash: String
  balance: Decimal
  id: Int
  udt: Udt
}

input AccountUdtContractAddressInput {
  """
  argument: the page of query result, the relations of postgres offset: offset = (page - 1) * page_size
  
  default: 1
  """
  page: Int = 1

  """
  argument: the page_size of query result, it's the same of postgres limit
  
  default: 20
  """
  page_size: Int = 20

  """
  argument: the sort of type by custom condition
  
  default: desc
  """
  sort_type: SortType = DESC
  token_contract_address_hash: String!
}

input AccountUdtsInput {
  """
  argument: the list of account udt address
  example: ["0x15ca4f2165ff0e798d9c7434010eaacc4d768d85"]
  """
  address_hashes: [String] = []

  """
  argument: the page of query result, the relations of postgres offset: offset = (page - 1) * page_size
  
  default: 1
  """
  page: Int = 1

  """
  argument: the page_size of query result, it's the same of postgres limit
  
  default: 20
  """
  page_size: Int = 20

  """
  argument: the address of smart contract which supply udts
  example: "0xbf1f27daea43849b67f839fd101569daaa321e2c"
  """
  token_contract_address_hash: String
}

type Block {
  account: Account
  aggregator_id: Int
  difficulty: Decimal
  extra_data: String
  gas_limit: Decimal
  gas_used: Decimal
  hash: String
  layer1_block_number: Int
  layer1_tx_hash: String
  logs_bloom: String
  nonce: String
  number: Int
  parent_hash: String
  sha3_uncles: String
  size: Int
  state_root: String
  status: BlockStatus
  timestamp: DateTime
  total_difficulty: Decimal
  transaction_count: Int
  transactions(input: PageAndSizeInput = {page: 1, page_size: 5}): [Transaction]
}

input BlockInput {
  hash: String
  number: Int
}

input BlocksInput {
  """
  argument: the page of query result, the relations of postgres offset: offset = (page - 1) * page_size
  
  default: 1
  """
  page: Int = 1

  """
  argument: the page_size of query result, it's the same of postgres limit
  
  default: 20
  """
  page_size: Int = 20

  """
  argument: the sort of type by custom condition
  
  default: desc
  """
  sort_type: SortType = DESC
}

enum BlockStatus {
  COMMITTED
  FINALIZED
}

"""
The `DateTime` scalar type represents a date and time in the UTC
timezone. The DateTime appears in a JSON response as an ISO8601 formatted
string, including UTC timezone ("Z"). The parsed date and time string will
be converted to UTC if there is an offset.
"""
scalar DateTime

"""
The `Decimal` scalar type represents signed double-precision fractional
values parsed by the `Decimal` library.  The Decimal appears in a JSON
response as a string to preserve precision.

Formally:
sign           ::=  '+' | '-'
digit          ::=  '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' |
                    '8' | '9'
indicator      ::=  'e' | 'E'
digits         ::=  digit [digit]...
decimal-part   ::=  digits '.' [digits] | ['.'] digits
exponent-part  ::=  indicator [sign] digits
infinity       ::=  'Infinity' | 'Inf'
nan            ::=  'NaN' [digits] | 'sNaN' [digits]
numeric-value  ::=  decimal-part [exponent-part] | infinity
numeric-string ::=  [sign] numeric-value | [sign] nan

Examples:

Some numeric strings are:

    "0"          -- zero
    "12"         -- a whole number
    "-76"        -- a signed whole number
    "12.70"      -- some decimal places
    "+0.003"     -- a plus sign is allowed, too
    "017."       -- the same as 17
    ".5"         -- the same as 0.5
    "4E+9"       -- exponential notation
    "0.73e-7"    -- exponential notation, negative power
    "Inf"        -- the same as Infinity
    "-infinity"  -- the same as -Inf
    "NaN"        -- not-a-Number
    "NaN8275"    -- diagnostic NaN
"""
scalar Decimal

"""
The `Json` scalar type represents arbitrary json string data, represented as UTF-8
character sequences. The Json type is most often used to represent a free-form
human-readable json string.
"""
scalar Json

type Log {
  address_hash: String
  block_hash: String
  block_number: Int
  data: String
  first_topic: String
  fourth_topic: String
  index: Int
  second_topic: String
  third_topic: String
  transaction_hash: String
}

input LogInput {
  address_hash: String

  """argument: the end of block number(inclusive) for search query"""
  end_block_number: Int
  first_topic: String
  fourth_topic: String

  """
  argument: the page of query result, the relations of postgres offset: offset = (page - 1) * page_size
  
  default: 1
  """
  page: Int = 1

  """
  argument: the page_size of query result, it's the same of postgres limit
  
  default: 20
  """
  page_size: Int = 20
  second_topic: String

  """
  argument: the sort of type by custom condition
  
  default: desc
  """
  sort_type: SortType = DESC

  """argument: the start of block number(inclusive) for search query"""
  start_block_number: Int
  third_topic: String
  transaction_hash: String
}

input PageAndSizeInput {
  """
  argument: the page of query result, the relations of postgres offset: offset = (page - 1) * page_size
  
  default: 1
  """
  page: Int = 1

  """
  argument: the page_size of query result, it's the same of postgres limit
  
  default: 20
  """
  page_size: Int = 20
}

type Polyjuice {
  gas_limit: Int
  gas_price: Decimal
  gas_used: Int
  id: Int
  input: String
  input_size: Int
  is_create: Boolean
  status: PolyjuiceStatus
  tx_hash: String
  value: Decimal
}

type PolyjuiceCreator {
  code_hash: String
  fee_amount: Decimal
  fee_udt_id: Int
  hash_type: String
  id: Int
  script_args: String
  tx_hash: String
}

enum PolyjuiceStatus {
  FAILED
  SUCCEED
}

type RootQueryType {
  """
  function: get account by account addresses
  
  request-example-1:
  query {
    account(input: {address: "0xbfbe23681d99a158f632e64a31288946770c7a9e"}){
      id
      type
      account_udts{
      	id
        balance
        udt{
          name
          type
        }
      }
    }
  }
  
  result-example-1:
  {
    "data": {
      "account": {
        "account_udts": [
          {
            "balance": "1352700556596252988061",
            "id": 22651,
            "udt": {
              "name": "Yokai",
              "type": "NATIVE"
            }
          },
          {
            "balance": "950876407191",
            "id": 21837,
            "udt": {
              "name": "Nervos Token",
              "type": "BRIDGE"
            }
          }
        ],
        "id": 51118,
        "type": "USER"
      }
    }
  }
  
  request-example-2:
  query {
    account(input: {address: "0xc5e133e6b01b2c335055576c51a53647b1b9b624"}){
      id
      type
      smart_contract{
        id
        name
        deployment_tx_hash
      }
    }
  }
  
  result-example-2:
  {
    "data": {
      "account": {
        "id": 3014,
        "smart_contract": {
          "deployment_tx_hash": "0x0000000000",
          "id": 1,
          "name": "YOKAI"
        },
        "type": "POLYJUICE_CONTRACT"
      }
    }
  }
  """
  account(input: AccountInput!): Account

  """
  function: get list of account ckbs by account addresses
  
  request-example:
  query {
    account_ckbs(input: {address_hashes: ["0x15ca4f2165ff0e798d9c7434010eaacc4d768d85"]}){
      address_hash
      balance
    }
  }
  
  result-example:
  {
    "data": {
      "account_ckbs": [
        {
          "address_hash": "0x15ca4f2165ff0e798d9c7434010eaacc4d768d85",
          "balance": "993799999325"
        }
      ]
    }
  }
  """
  account_ckbs(input: AccountCkbsInput!): [AccountCkb]

  """
  function: get list of account udt by account addresses
  
  request-example:
  query {
    account_udts(input: {address_hashes:
  ["0x15ca4f2165ff0e798d9c7434010eaacc4d768d85",
  "0xc20538aa80bb3ced9e240dc8f8130b7f7d0b0c49"],
        token_contract_address_hash: "0xbf1f27daea43849b67f839fd101569daaa321e2c"}) {
      address_hash
      balance
      udt{
        type
        name
      }
    }
  }
  
  result-example:
  {
    "data": {
      "account_udts": [
        {
          "address_hash": "0x15ca4f2165ff0e798d9c7434010eaacc4d768d85",
          "balance": "993799999325",
          "udt": {
            "name": "Nervos Token",
            "type": "BRIDGE"
          }
        },
        {
          "address_hash": "0xc20538aa80bb3ced9e240dc8f8130b7f7d0b0c49",
          "balance": "950876407191",
          "udt": {
            "name": "Nervos Token",
            "type": "BRIDGE"
          }
        }
      ]
    }
  }
  """
  account_udts(input: AccountUdtsInput!): [AccountUdt]

  """
  function: get list account udts by smart contract address which sort of balance
  
  request-example:
  query {
    account_udts_by_contract_address(input: {token_contract_address_hash:
  "0xbf1f27daea43849b67f839fd101569daaa321e2c", page_size: 2}){
      address_hash
      balance
      udt {
        type
  	    name
      }
    }
  }
  
  result-example:
  {
    "data": {
      "account_udts_by_contract_address": [
        {
          "address_hash": "0x68f5cea51fa6fcfdcc10f6cddcafa13bf6717436",
          "balance": "3711221022882427",
          "udt": {
            "name": "Nervos Token",
            "type": "BRIDGE"
          }
        },
        {
          "address_hash": "0x7c12cbcbc3703bff1230434f792d84d70d47bb6f",
          "balance": "1075120930414037",
          "udt": {
            "name": "Nervos Token",
            "type": "BRIDGE"
          }
        }
      ]
    }
  }
  """
  account_udts_by_contract_address(input: AccountUdtContractAddressInput!): [AccountUdt]

  """
  function: get block by block number or block hash
  
  request-example:
  query {
    block(input: {number: 345600}){
      hash
      parent_hash
      number
      gas_used
      gas_limit
      account{
        id
        short_address
      }
      transactions (input: {page: 1, page_size: 2}) {
        type
        from_account_id
        to_account_id
      }
    }
  }
  
  result-example:
  {
    "data": {
      "block": {
        "account": {
          "id": 2,
          "short_address": "0x68f5cea51fa6fcfdcc10f6cddcafa13bf6717436"
        },
        "gas_limit": "981000000",
        "gas_used": "95240385",
        "hash": "0x67dad5ec7f3bc8b5b8f623f4df230cb50c9c39493080a6b32d94023994ba886b",
        "number": 345600,
        "parent_hash": "0x962906210825c339fa4f871239d967c60b62005a6b780ced4334dba56618dbf5",
        "transactions": [
          {
            "from_account_id": 52269,
            "to_account_id": 64241,
            "type": "POLYJUICE"
          },
          {
            "from_account_id": 52920,
            "to_account_id": 197067,
            "type": "POLYJUICE"
          }
        ]
      }
    }
  }
  """
  block(input: BlockInput): Block

  """
  function: get list of block sort by block number
  
  request-example:
  query {
    blocks(input: {page: 1, page_size: 1}){
      hash
      parent_hash
      number
      gas_used
      gas_limit
      account{
        id
        short_address
      }
      transactions (input: {page: 1, page_size: 2}) {
        type
        from_account_id
        to_account_id
      }
    }
  }
  
  result-example:
  {
    "data": {
      "blocks": [
        {
          "account": {
            "id": 2,
            "short_address": "0x68f5cea51fa6fcfdcc10f6cddcafa13bf6717436"
          },
          "gas_limit": "12500000",
          "gas_used": "0",
          "hash": "0xba8cf2630dfb02bebb208aa674d835073c9a0ff61c881689622e7e07490669e5",
          "number": 346124,
          "parent_hash": "0x4a35f2a925a51aeb3f780afbd485226ec9603fceb2a2c77a04c9b49657b5ead4",
          "transactions": []
        }
      ]
    }
  }
  """
  blocks(input: BlocksInput = {page: 1, page_size: 10, sort_type: DESC}): [Block]

  """
  function: get list of logs by filter or conditions
  
  request-example:
  query {
    logs(input: {first_topic: "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0",end_block_number:
  346283, page: 1, page_size: 1}) {
      transaction_hash
      block_number
      address_hash
      data
      first_topic
      second_topic
      third_topic
      fourth_topic
    }
  }
  
  result-example:
  {
    "data": {
      "logs": [
        {
          "address_hash": "0x2406a7233d72540291ff0627c397b26fd73dc3d9",
          "block_number": 346283,
          "data": "0x0000000000000000000000000000000000000000000000000000000000000000",
          "first_topic": "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0",
          "fourth_topic": null,
          "second_topic": "0x0000000000000000000000000000000000000000000000000000000000000000",
          "third_topic": "0x000000000000000000000000b3a91e71f67c29ae9ed5e164e8a1daa4c9e71361",
          "transaction_hash": "0x835eadb22bd55661717b0829b6bb29fb461facdbdc21f803752f9e7383577581"
        }
      ]
    }
  }
  """
  logs(input: LogInput!): [Log]

  """
  function: get smart contract by address
  
  request-example:
  query {
    smart_contract(input: {contract_address: "0x21c814bf216ec7b988d872c56bf948d9cc1638a2"}) {
      name
      account_id
      account {
        eth_address
      }
    }
  }
  
  result-example:
  {
    "data": {
      "smart_contract": {
        "account": {
          "eth_address": "0x21c814bf216ec7b988d872c56bf948d9cc1638a2"
        },
        "account_id": "3014",
        "name": "YOKAI"
      }
    }
  }
  """
  smart_contract(input: SmartContractInput!): SmartContract

  """
  function: get list of smart contracts
  
  request-example:
  query {
    smart_contracts {
      name
      account_id
      account {
        eth_address
      }
    }
  }
  
  result-example:
  {
    "data": {
      "smart_contracts": [
        {
          "account": {
            "eth_address": "0x21c814bf216ec7b988d872c56bf948d9cc1638a2"
          },
          "account_id": "3014",
          "name": "YOKAI"
        }
      ]
    }
  }
  """
  smart_contracts(input: PageAndSizeInput = {page: 1, page_size: 20}): [SmartContract]

  """
  function: get list of token transfers by filter
  
  request-example:
  query {
    token_transfers(input: {from_address_hash:
  "0x3770f660a5b6fde2dadd765c0f336543ff285097", start_block_number: 300000,
  end_block_number:344620, page: 1, page_size: 1, sort_type: DESC}) {
      transaction_hash
      block_number
      to_account{
        id
        short_address
      }
      to_address_hash
      from_account{
        id
        short_address
      }
    }
  }
  
  result-example:
  {
    "data": {
      "token_transfers": [
        {
          "block_number": 344620,
          "from_account": {
            "id": 53057,
            "short_address": "0x3770f660a5b6fde2dadd765c0f336543ff285097"
          },
          "to_account": {
            "id": 53057,
            "short_address": "0x3770f660a5b6fde2dadd765c0f336543ff285097"
          },
          "to_address_hash": "0x3770f660a5b6fde2dadd765c0f336543ff285097",
          "transaction_hash": "0xf6caf10b0a43adaabd08ef00fde03aa6d25310a1872dd08e7a7a4a4d3bd82301"
        }
      ]
    }
  }
  """
  token_transfers(input: TokenTransferInput!): [TokenTransfer]

  """
  function: get transaction by transaction_hash
  
  request-example:
  query {
    transaction (input: {transaction_hash: "0x21d6428f5325fc3632fb4762d40a1833a4e739329ca5bcb1de0a91fb519cf8a4"}) {
      hash
      block_hash
      block_number
      type
      from_account_id
      to_account_id
    }
  }
  
  result-example:
  {
    "data": {
      "transaction": {
        "block_hash": "0x47d74ac830a8da437da48d95844a9f60c71eaaeffa9e0547738dd49ffe5417cf",
        "block_number": 341275,
        "from_account_id": 27455,
        "hash": "0x21d6428f5325fc3632fb4762d40a1833a4e739329ca5bcb1de0a91fb519cf8a4",
        "to_account_id": 3014,
        "type": "POLYJUICE"
      }
    }
  }
  """
  transaction(input: TransactionHashInput!): Transaction

  """
  function: list transactions by account address
  
  request-example:
  query {
    transactions (input: {address: "0xc5e133e6b01b2c335055576c51a53647b1b9b624", 
  page: 1, page_size: 2, start_block_number: 335796, end_block_number: 341275}) {
      block_hash
      block_number
      type
      from_account_id
      to_account_id
    }
  }
  
  result-example:
  {
    "data": {
      "transactions": [
        {
          "block_hash": "0x47d74ac830a8da437da48d95844a9f60c71eaaeffa9e0547738dd49ffe5417cf",
          "block_number": 341275,
          "from_account_id": 27455,
          "to_account_id": 3014,
          "type": "POLYJUICE"
        },
        {
          "block_hash": "0xb68eee6a72bfd54a06101bedb264e1026af2228250b82dd7c3f06beb35f5d865",
          "block_number": 335796,
          "from_account_id": 172581,
          "to_account_id": 3014,
          "type": "POLYJUICE"
        }
      ]
    }
  }
  """
  transactions(input: TransactionInput!): [Transaction]

  """
  function: get udt by contract address
  
  request-example:
  query {
    udt(input: {contract_address: "0xbf1f27daea43849b67f839fd101569daaa321e2c"}){
      id
      name
      type
      supply
      account{
        short_address
      }
    }
  }
  
  result-example:
  {
    "data": {
      "udt": {
        "account": {
          "short_address": "0xbf1f27daea43849b67f839fd101569daaa321e2c"
        },
        "id": "1",
        "name": "Nervos Token",
        "supply": "693247799.35570027",
        "type": "BRIDGE"
      }
    }
  }
  """
  udt(input: SmartContractInput!): Udt

  """
  function: get list of udts
  
  request-example:
  query {
    udts(input: {page: 1, page_size: 2, sort_type: ASC}){
      id
      name
      type
      supply
      account{
        eth_address
        short_address
      }
    }
  }
  
  result-example:
  {
    "data": {
      "udts": [
        {
          "account": {
            "eth_address": null,
            "short_address": "0xbf1f27daea43849b67f839fd101569daaa321e2c"
          },
          "id": "1",
          "name": "Nervos Token",
          "supply": "693247799.35570027",
          "type": "BRIDGE"
        },
        {
          "account": {
            "eth_address": null,
            "short_address": "0x21ad25fab1d759da1a419a589c0f36dee5e7fe3d"
          },
          "id": "17",
          "name": null,
          "supply": "400000002840",
          "type": "BRIDGE"
        }
      ]
    }
  }
  """
  udts(input: UdtsInput = {page: 1, page_size: 10, sort_type: ASC, type: BRIDGE}): [Udt]
}

type SmartContract {
  abi: [Json]
  account: Account
  account_id: String
  compiler_file_format: String
  compiler_version: String
  constructor_arguments: String
  contract_source_code: String
  deployment_tx_hash: String
  id: Int
  name: String
  other_info: String
}

input SmartContractInput {
  contract_address: String!
}

enum SortType {
  ASC
  DESC
}

type TokenTransfer {
  amount: Decimal
  block: Block
  block_hash: String
  block_number: Int
  from_account: Account
  from_address_hash: String
  log_index: Int
  polyjuice: Polyjuice
  to_account: Account
  to_address_hash: String
  token_contract_address_hash: String
  token_id: Decimal
  transaction: Transaction
  transaction_hash: String
  udt: Udt
}

input TokenTransferInput {
  """argument: the end of block number(inclusive) for search query"""
  end_block_number: Int
  from_address_hash: String

  """
  argument: the page of query result, the relations of postgres offset: offset = (page - 1) * page_size
  
  default: 1
  """
  page: Int = 1

  """
  argument: the page_size of query result, it's the same of postgres limit
  
  default: 20
  """
  page_size: Int = 20

  """
  argument: the sort of type by custom condition
  
  default: desc
  """
  sort_type: SortType = DESC

  """argument: the start of block number(inclusive) for search query"""
  start_block_number: Int
  to_address_hash: String
  token_contract_address_hash: String
  transaction_hash: String
}

type Transaction {
  args: String
  block: Block
  block_hash: String
  block_number: Int
  from_account: Account
  from_account_id: Int
  hash: String
  nonce: Int
  polyjuice: Polyjuice
  polyjuice_creator: PolyjuiceCreator
  to_account: Account
  to_account_id: Int
  type: TransactionType
}

input TransactionHashInput {
  transaction_hash: String!
}

input TransactionInput {
  address: String!

  """argument: the end of block number(inclusive) for search query"""
  end_block_number: Int

  """
  argument: the page of query result, the relations of postgres offset: offset = (page - 1) * page_size
  
  default: 1
  """
  page: Int = 1

  """
  argument: the page_size of query result, it's the same of postgres limit
  
  default: 20
  """
  page_size: Int = 20
  sort: SortType

  """
  argument: the sort of type by custom condition
  
  default: desc
  """
  sort_type: SortType = DESC

  """argument: the start of block number(inclusive) for search query"""
  start_block_number: Int
}

enum TransactionType {
  POLYJUICE
  POLYJUICE_CREATOR
}

type Udt {
  account: Account
  bridge_account_id: Int
  decimal: Int
  description: String
  icon: String
  id: String
  name: String
  official_site: String
  price: Decimal
  script_hash: String
  supply: Decimal
  symbol: String
  type: UdtType
  type_script: Json
  value: Decimal
}

input UdtsInput {
  """
  argument: the page of query result, the relations of postgres offset: offset = (page - 1) * page_size
  
  default: 1
  """
  page: Int = 1

  """
  argument: the page_size of query result, it's the same of postgres limit
  
  default: 20
  """
  page_size: Int = 20

  """
  argument: the sort of type by custom condition
  
  default: desc
  """
  sort_type: SortType = DESC
  type: UdtType
}

enum UdtType {
  BRIDGE
  NATIVE
}