# GUNZScan (GUNZ chain block explorer) GraphQL schema
# generated: 2026-08-04
# method: probed
# source: https://gunzscan.io/api/v1/graphql (anonymous introspection, HTTP 200)
# note: Reconstructed as SDL from a per-type __type introspection walk. The endpoint
#       enforces a query-complexity limit of 100, so the standard single-shot
#       IntrospectionQuery is rejected; each type was introspected individually.
#       Console: https://gunzscan.io/graphiql

schema {
  query: RootQueryType
  subscription: RootSubscriptionType
}

"""A stored representation of a Web3 address."""
type Address {
  contractCode: Data
  fetchedCoinBalance: Wei
  fetchedCoinBalanceBlockNumber: Int
  gasUsed: Int
  hash: AddressHash
  nonce: Int
  smartContract: SmartContract
  tokenTransfers(after: String, before: String, count: Int, first: Int, last: Int): TokenTransferConnection
  tokenTransfersCount: Int
  transactions(after: String, before: String, count: Int, first: Int, last: Int, order: SortOrder = DESC): TransactionConnection
  transactionsCount: Int
}

"""The address (40 (hex) characters / 160 bits / 20 bytes) is derived from the public key (128 (hex) characters /
512 bits / 64 bytes) which is derived from the private key (64 (hex) characters / 256 bits / 32 bytes).

The address is actually the last 40 characters of the keccak-256 hash of the public key with `0x` appended."""
scalar AddressHash

"""A package of data that contains zero or more transactions, the hash of the previous block ("parent"), and optionally
other data. Because each block (except for the initial "genesis block") points to the previous block, the data
structure that they form is called a "blockchain"."""
type Block {
  baseFeePerGas: Wei
  consensus: Boolean
  difficulty: Decimal
  gasLimit: Decimal
  gasUsed: Decimal
  hash: FullHash
  isEmpty: Boolean
  minerHash: AddressHash
  nonce: NonceHash
  number: Int
  parentHash: FullHash
  size: Int
  timestamp: DateTime
  totalDifficulty: Decimal
}

"""The `Boolean` scalar type represents `true` or `false`."""
scalar Boolean

enum CallType {
  CALL
  CALLCODE
  DELEGATECALL
  STATICCALL
}

"""Represents a CELO or usd token transfer between addresses."""
type CeloTransfer implements Node {
  blockNumber: Int
  comment: String
  fromAccountHash: AddressHash
  fromAddressHash: AddressHash
  gasPrice: Wei
  gasUsed: Decimal
  """The ID of an object"""
  id: ID!
  input: String
  logIndex: Int
  timestamp: DateTime
  toAccountHash: AddressHash
  toAddressHash: AddressHash
  token: String
  tokenAddress: String
  tokenId: Decimal
  tokenType: String
  transactionHash: FullHash
  value: Decimal
}

type CeloTransferConnection {
  edges: [CeloTransferEdge]
  pageInfo: PageInfo!
}

type CeloTransferEdge {
  cursor: String
  node: CeloTransfer
}

"""An unpadded hexadecimal number with 0 or more digits. Each pair of digits
maps directly to a byte in the underlying binary representation. When
interpreted as a number, it should be treated as big-endian."""
scalar Data

"""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."""
scalar Decimal

"""A 32-byte [KECCAK-256](https://en.wikipedia.org/wiki/SHA-3) hash."""
scalar FullHash

"""The `ID` scalar type represents a unique identifier, often used to
refetch an object or as key for a cache. The ID type appears in a JSON
response as a String; however, it is not intended to be human-readable.
When expected as an input type, any string (such as `"4"`) or integer
(such as `4`) input value will be accepted as an ID."""
scalar ID

"""The `Int` scalar type represents non-fractional signed whole numeric
values. It is NOT compliant with the GraphQl spec, it can represent
values between `-(2^53 - 1)` and `2^53 - 1` as specified by
[IEEE 754](https://en.wikipedia.org/wiki/IEEE_754).
It is kept here for backwards compatibility, prefer using
the SpecCompliantInt."""
scalar Int

"""Models internal transactions."""
type InternalTransaction implements Node {
  blockHash: FullHash
  blockIndex: Int
  blockNumber: Int
  callType: CallType
  createdContractAddressHash: AddressHash
  createdContractCode: Data
  error: String
  fromAddressHash: AddressHash
  gas: Decimal
  gasUsed: Decimal
  """The ID of an object"""
  id: ID!
  index: Int
  init: Data
  input: Data
  output: Data
  toAddressHash: AddressHash
  traceAddress: Json
  transactionHash: FullHash
  transactionIndex: Int
  type: Type
  value: Wei
}

type InternalTransactionConnection {
  edges: [InternalTransactionEdge]
  pageInfo: PageInfo!
}

type InternalTransactionEdge {
  cursor: String
  node: InternalTransaction
}

"""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

enum Language {
  SOLIDITY
  VYPER
  YUL
}

interface Node {
  """The ID of the object."""
  id: ID!
}

"""The nonce (16 (hex) characters / 128 bits / 8 bytes) is derived from the Proof-of-Work."""
scalar NonceHash

type PageInfo {
  """When paginating forwards, the cursor to continue."""
  endCursor: String
  """When paginating forwards, are there more items?"""
  hasNextPage: Boolean!
  """When paginating backwards, are there more items?"""
  hasPreviousPage: Boolean!
  """When paginating backwards, the cursor to continue."""
  startCursor: String
}

type RootQueryType {
  """Gets an address by hash."""
  address(hash: AddressHash!): Address
  """Gets addresses by address hash."""
  addresses(hashes: [AddressHash!]!): [Address]
  """Gets a block by number."""
  block(number: Int!): Block
  node(id: ID!): Node
  tokenTransferTxs(addressHash: AddressHash, after: String, before: String, count: Int, first: Int, last: Int): TransferTransactionConnection
  """Gets token transfers by token contract address hash."""
  tokenTransfers(after: String, before: String, count: Int, first: Int, last: Int, tokenContractAddressHash: AddressHash!): TokenTransferConnection
  """Gets a transaction by hash."""
  transaction(hash: FullHash!): Transaction
}

"""The representation of a verified Smart Contract.

"A contract in the sense of Solidity is a collection of code (its functions)
and data (its state) that resides at a specific address on the Ethereum
blockchain."
http://solidity.readthedocs.io/en/v0.4.24/introduction-to-smart-contracts.html"""
type SmartContract {
  abi: Json
  addressHash: AddressHash
  compilerSettings: Json
  compilerVersion: String
  constructorArguments: String
  contractSourceCode: String
  evmVersion: String
  externalLibraries: Json
  filePath: String
  isChangedBytecode: Boolean
  language: Language
  name: String
  optimization: Boolean
  optimizationRuns: Int
  partiallyVerified: Boolean
  verifiedViaEthBytecodeDb: Boolean
  verifiedViaSourcify: Boolean
}

enum SortOrder {
  ASC
  DESC
}

enum Status {
  ERROR
  OK
}

"""The `String` scalar type represents textual data, represented as UTF-8
character sequences. The String type is most often used by GraphQL to
represent free-form human-readable text."""
scalar String

type RootSubscriptionType {
  tokenTransfers(tokenContractAddressHash: AddressHash!): [TokenTransfer]
}

"""Represents a token."""
type Token {
  circulatingMarketCap: Decimal
  contractAddressHash: AddressHash
  decimals: Decimal
  holderCount: Int
  iconUrl: String
  name: String
  symbol: String
  totalSupply: Decimal
  type: String
  volume24h: Decimal
}

"""Represents a token transfer between addresses."""
type TokenTransfer implements Node {
  amount: Decimal
  amounts: [Decimal]
  blockNumber: Int
  fromAddressHash: AddressHash
  """The ID of an object"""
  id: ID!
  logIndex: Int
  toAddressHash: AddressHash
  token: Token
  tokenContractAddressHash: AddressHash
  tokenIds: [Decimal]
  transaction: Transaction
  transactionHash: FullHash
}

type TokenTransferConnection {
  edges: [TokenTransferEdge]
  pageInfo: PageInfo!
}

type TokenTransferEdge {
  cursor: String
  node: TokenTransfer
}

"""Models a Web3 transaction."""
type Transaction implements Node {
  block: Block
  blockHash: FullHash
  blockNumber: Int
  createdContractAddressHash: AddressHash
  cumulativeGasUsed: Decimal
  earliestProcessingStart: DateTime
  error: String
  fromAddressHash: AddressHash
  gas: Decimal
  gasPrice: Wei
  gasUsed: Decimal
  hasErrorInInternalTransactions: Boolean
  hash: FullHash
  """The ID of an object"""
  id: ID!
  index: Int
  input: String
  internalTransactions(after: String, before: String, count: Int, first: Int, last: Int): InternalTransactionConnection
  maxFeePerGas: Wei
  maxPriorityFeePerGas: Wei
  nonce: NonceHash
  r: Decimal
  revertReason: String
  s: Decimal
  status: Status
  toAddressHash: AddressHash
  type: Int
  v: Decimal
  value: Wei
}

type TransactionConnection {
  edges: [TransactionEdge]
  pageInfo: PageInfo!
}

type TransactionEdge {
  cursor: String
  node: Transaction
}

"""Represents a CELO token transfer between addresses."""
type TransferTransaction implements Node {
  addressHash: AddressHash
  blockNumber: Int
  feeCurrency: AddressHash
  feeToken: String
  gasPrice: Wei
  gasUsed: Decimal
  gatewayFee: AddressHash
  gatewayFeeRecipient: AddressHash
  """The ID of an object"""
  id: ID!
  input: String
  timestamp: DateTime
  tokenTransfer(after: String, before: String, count: Int, first: Int, last: Int): CeloTransferConnection
  transactionHash: FullHash
}

type TransferTransactionConnection {
  edges: [TransferTransactionEdge]
  pageInfo: PageInfo!
}

type TransferTransactionEdge {
  cursor: String
  node: TransferTransaction
}

enum Type {
  CALL
  CREATE
  REWARD
  SELFDESTRUCT
}

"""The smallest fractional unit of Ether. Using wei instead of ether allows code to do integer match instead of using
floats.

See [Ethereum Homestead Documentation](http://ethdocs.org/en/latest/ether.html) for examples of various denominations of wei.

Etymology of "wei" comes from [Wei Dai (戴維)](https://en.wikipedia.org/wiki/Wei_Dai), a
[cypherpunk](https://en.wikipedia.org/wiki/Cypherpunk) who came up with b-money, which outlined modern
cryptocurrencies."""
scalar Wei