schema.graphql

# This file was generated based on ".graphqlconfig". Do not edit manually.

schema {
  query: Query
  mutation: Mutation
}

"Block is a single digital record created within a blockchain. Each block contains a record of the previous Block, and when linked together these become the “chain”.A block is always composed of header and body."
type Block {
  "Hash of the block"
  hash: Hash!
  "The header section of a block"
  header: BlockHeader!
  "The body section of a block"
  orderedTxHashes: [Hash!]!
}

"A block header is like the metadata of a block."
type BlockHeader {
  "Identifier of a chain in order to prevent replay attacks across channels "
  chainId: Hash!
  "The merkle roots of all the confirms"
  confirmRoot: [Hash!]!
  "The sum of all transactions costs"
  cyclesUsed: [Uint64!]!
  "The height to which the block has been executed"
  execHeight: Uint64!
  "block height"
  height: Uint64!
  "The merkle root of ordered transactions"
  orderRoot: Hash!
  "The hash of ordered signed transactions"
  orderSignedTransactionsHash: Hash!
  "The hash of the serialized previous block"
  prevHash: Hash!
  proof: Proof!
  "The address descirbed who packed the block"
  proposer: Address!
  "The merkle roots of receipts"
  receiptRoot: [Hash!]!
  "The merkle root of state root"
  stateRoot: Hash!
  "A timestamp that records when the block was created"
  timestamp: Uint64!
  "The version of validator is designed for cross chain"
  validatorVersion: Uint64!
  validators: [Validator!]!
}

type Event {
  data: String!
  name: String!
  service: String!
}

type Mutation {
  "send transaction"
  sendTransaction(inputEncryption: InputTransactionEncryption!, inputRaw: InputRawTransaction!): Hash!
  unsafeSendTransaction(inputPrivkey: Bytes!, inputRaw: InputRawTransaction!): Hash! @deprecated(reason : "DON'T use it in production! This is just for development.")
}

"The verifier of the block header proved"
type Proof {
  bitmap: Bytes!
  blockHash: Hash!
  height: Uint64!
  round: Uint64!
  signature: Bytes!
}

type Query {
  "Get the block"
  getBlock(height: Uint64): Block
  "Get the receipt by transaction hash"
  getReceipt(txHash: Hash!): Receipt
  "Get the transaction by hash"
  getTransaction(txHash: Hash!): SignedTransaction
  "query service"
  queryService(caller: Address!, cyclesLimit: Uint64, cyclesPrice: Uint64, height: Uint64, method: String!, payload: String!, serviceName: String!): ServiceResponse!
}

type Receipt {
  cyclesUsed: Uint64!
  events: [Event!]!
  height: Uint64!
  response: ReceiptResponse!
  stateRoot: Hash!
  txHash: Hash!
}

type ReceiptResponse {
  method: String!
  response: ServiceResponse!
  serviceName: String!
}

type ServiceResponse {
  code: Uint64!
  errorMessage: String!
  succeedData: String!
}

type SignedTransaction {
  chainId: Hash!
  cyclesLimit: Uint64!
  cyclesPrice: Uint64!
  method: String!
  nonce: Hash!
  payload: String!
  pubkey: Bytes!
  sender: Address!
  serviceName: String!
  signature: Bytes!
  timeout: Uint64!
  txHash: Hash!
}

"Validator address set"
type Validator {
  proposeWeight: Int!
  pubkey: Bytes!
  voteWeight: Int!
}

"There was many types of transaction in Muta, A transaction often require computing resources or write data to chain,these resources are valuable so we need to pay some token for them.InputRawTransaction describes information above"
input InputRawTransaction {
  "Identifier of the chain."
  chainId: Hash!
  "Mostly like the gas limit in Ethereum, describes the fee that you are willing to pay the highest price for the transaction"
  cyclesLimit: Uint64!
  cyclesPrice: Uint64!
  method: String!
  "Every transaction has its own id, unlike Ethereum's nonce,the nonce in Muta is an hash"
  nonce: Hash!
  payload: String!
  sender: Address!
  serviceName: String!
  "For security and performance reasons, Muta will only deal with trade request over a period of time,the `timeout` should be `timeout > current_block_height` and `timeout < current_block_height + timeout_gap`,the `timeout_gap` generally equal to 20."
  timeout: Uint64!
}

"Signature of the transaction"
input InputTransactionEncryption {
  "The public key of transfer"
  pubkey: Bytes!
  "The signature of the transaction"
  signature: Bytes!
  "The digest of the transaction"
  txHash: Hash!
}


"Bytes corresponding hex string."
scalar Bytes

"20 bytes of account address"
scalar Address

"Uint64"
scalar Uint64

"The output digest of Keccak hash function"
scalar Hash