Graph Node Requests

Prerequisites

For this section, you will need:

• A user's Theta Network wallet address, see the previous page on how to obtain this

• A HTTP request library installed, such as axios

• The smart contract address(es) of your event

Querying the GraphQL backend

We have a GraphQL playground for you to send requests directly before integrating this into your platform.

To start, try sending the following request using the playground:

query {
  ticketTokens (where: {
      owner: "0x059377c014cfc12dd2612ebfe9cfd1a6fc1a8883", 
      ticket_in: [
        "0x0478578c5e906afeb1bdbbf358929affbf1575c8",
        "0xaa7fc9c591eab1f80e7e29a1f88ee144c6a3694f"
       ]
     }) 
  {
    owner { id },
    tokenID
  
}

The above request searches all of our ticket tokens where the owner address is 0x059377c014cfc12dd2612ebfe9cfd1a6fc1a8883 and the ticket smart contract address is either 0x0478578c5e906afeb1bdbbf358929affbf1575c8 or 0xaa7fc9c591eab1f80e7e29a1f88ee144c6a3694f.

Searching for past transactions

Let's try something more advanced now, and try to find all of the past transactions of a ticket. Try sending the following request to the playground:

query {
  transfers (where: {ticketToken: "0x0478578c5e906afeb1bdbbf358929affbf1575c8#65"}) {
    from,
    to,
    ticketToken {
      tokenID,
      ticket {
        id
      },
      owner {
        id
      }
    }
  }
}

This searches the database for all transfers that had taken place for the ticket with smart contract address 0x0478578c5e906afeb1bdbbf358929affbf1575c8 and token ID 65. It returns the address from which it was transferred, the address it was transferred to, as well as the current owner and token ID of the ticket.

Querying Metapass platform data

Next, let's try the following query:

query {
  tketsdayDatas (where: {date_gt: 1635752657}, orderBy: date, orderDirection: desc, first: 10) {
    date,
    dailyTxns,
    dailyVolumeTFUEL,
    totalVolumeTFUEL,
    eventCount
  }
}

This query checks the daily data collated about the platform, and finds the first 10 entries corresponding to a date greater than a timestamp of 1635752657, ordered by descending date. It returns the date of the entry, the number of daily transactions, the total and daily volume of TFUEL transacted, as well as the event count.

By now, you should have a basic understanding of how the query system works, and can construct your own queries to suit the information you need. You can refer to the Graph Node API guide for a full schema of the data indexed by the Graph node, or also read more in the GraphQL API docs for more information about the query system.

Querying by HTTP request

Now, with your query crafted, you can query the database programmatically using a HTTP POST request rather than doing it manually in the playground. This also allows you to set any variables within your query.

Query the GraphQL database

POST https://graphql.tkets.io/subgraphs/name/tkets-core/graphql/

Submits a query to the GraphQL database with the specified variables, and returns a JSON response with the result objects

Request Body

Name	Type	Description
query*	String	Your query (as above), in a plaintext string
variables	JSON	(Optional) Variables within the query that can be defined

200: OK JSON response with objects specifieid by the query

{
    // Response
}

Make sure to use a POST method to submit the request. Mutations are not allowed because of restrictions on the graph node, and therefore the database is read only.

Securing your backend endpoints

For protected endpoints that require only users who are authenticated (for example, an endpoint that allows users who hold NFTs to change their name on your platform or make a vote), you will need to check on both your frontend and backend if they are indeed holders of your NFT.

This can be done with the GraphQL queries on this page, as well as a signature verification on your backend. See signature verification for more details

For example, you may use the following code to submit a request:

React TSX

import axios from 'axios'

const GRAPHQL_ADDRESS = 'https://graphql.tkets.io'
const GRAPHQL_LIMIT = 100

// This query finds the smart contract addresses of tickets
// that an account owns
const QUERY_OWNED_TICKETS_OF_ACCOUNT = `
  query ($ownerAddress: ID!, $skipNumber: Int!) {
    ticketTokens (where: {owner: $ownerAddress}, skip: $skipNumber) {
      ticket {
        id
      }
    }
  }
`

// Main function to call
export function getOwnedTicketsOfAccount(account: string) {
  return tryGetOwnedTicketsOfAccountWithSkip(account, 0, [])
}

// Helper function, can be called recursively with an accumulator
export async function tryGetOwnedTicketsOfAccountWithSkip(address: string, skip: number, accumulator: any[]) : Promise<string[]> {
  return axios.post(`${GRAPHQL_ADDRESS}/subgraphs/name/tkets-core`, 
    { 
      query: QUERY_OWNED_TICKETS_OF_ACCOUNT, 
      variables: {
        ownerAddress: address.toLowerCase(),
        skipNumber: skip
      }
    }
  ).then((r) => {
    if (r.status === 200) {
      // convert JSON result into a list of ticket smart contract address strings
      const ticketsParsed = r.data.data.ticketTokens.map((ticketToken: any) => {
        return ticketToken.ticket.id as string
      })

      // add result to the accumulator
      accumulator = accumulator.concat(ticketsParsed)

      // check if we have reached the GraphQL query limit of 100
      // if so, we need to submit another request with the skip variable
      // to get the next 100 ticket smart contract addresses
      if (r.data.data.ticketTokens.length === GRAPHQL_LIMIT) {
        return tryGetOwnedTicketsOfAccountWithSkip(address, skip + GRAPHQL_LIMIT, accumulator)
      }

      // Convert to set in order to remove any duplicates
      const ticketParsedSet = Array.from(new Set(accumulator))
      
      return ticketParsedSet as string[]
    }

    return [] as string[]
  }).catch((e: Error) => {
    return [] as string[]
  })
}

Python

import requests

GRAPHQL_ADDRESS = 'https://graphql.tkets.io'
GRAPHQL_LIMIT = 100

QUERY_TICKET_HOLDER = '''
  query ($ownerAddress: ID!, $skipNumber: Int!) {
    ticketTokens (where: {owner: $ownerAddress}, skip: $skipNumber) {
      ticket {
        id
      }
    }
  }
'''

def get_owned_tickets_of_account(address, skip=0, accumulator=None):
    accumulator = accumulator or []
    ticket_set = []
    
    try:
        holder_response = requests.post(f"{GRAPHQL_ADDRESS}/subgraphs/name/tkets-core", json={
            "query": QUERY_TICKET_HOLDER,
            "variables": {
                "ownerAddress": address.lower(),
                "skipNumber": skip
            }
        })
        
        for ticket_json in holder_response["data"]["ticketTokens"]:
          accumulator.append(ticket_json["ticket"]["id"])
        
        if (len(holder_response["data"]["ticketTokens"]) === GRAPHQL_LIMIT) {
          return get_owned_tickets_of_account(address, skip + GRAPHQL_LIMIT, accumulator)
        }
        
        ticket_set = list(set(accumulator))
    except:
        # error retrieving GraphQL, try again later
        raise
        
    return ticket_set