# query

Returns the latest revisions of on-chain objects.

# Type

;<T extends new (...args: any) => any>(
  query:
    | {
        ids: string[]
      }
    | {
        publicKey?: string
        mod?: string
        limit?: number
        offset?: number
        order?: 'ASC' | 'DEC'
      },
) => Promise<string[]>

# Parameters

# `args`

An object with the query parameters.

Key	Description
publicKey	Return latest revisions of on-chain objects owned by a public key
ids	Return latest revision of on-chain objects with ids in order
mod	Return the latest revision of on-chain objects created with this module specifier
limit	Limit the number of revisions returned
offset	Return results starting from offset
order	Order results in ascending or descending order

# Return Value

Given the query parameters, returns an array of strings encoding the latest revisions of on-chain objects that matches the specified conditions.

# Description

The args object specifies the on-chain objects of which to return the latest revisions. One can either query by public key to obtain the latests revisions of objects currently owned by that public key

Conditions can be passed in to determine the on-chain objects. When multiple conditions are passed in, the latest revisions of the on-chain objects that satisfy all conditions are returned.

# Example

import { Computer } from '@bitcoin-computer/lib'
import { chain, expect, network, url } from '../../utils'

// Create wallet
const computer = new Computer({ chain, network, url })

// A smart contract
class Counter extends Contract {
  n: number

  constructor() {
    super({ n: 0 })
  }
  inc() {
    this.n += 1
  }
}

describe('query', () => {
  const publicKey = computer.getPublicKey()
  let counter
  let mod

  before('Before tests for query', async () => {
    // Fund wallet
    await computer.faucet(1e8)

    // Deploy module
    mod = await computer.deploy(`export ${Counter}`)

    // Encode on-chain object and create it by broadcasting the transaction
    const { effect, tx } = await computer.encode({ exp: 'new Counter()', mod })
    await computer.broadcast(tx)

    // Increment on-chain object
    counter = effect.res
    await counter.inc()
  })

  // Query by public key
  it('Should return the latest revisions for a public key', async () => {
    const revs = await computer.query({ publicKey })
    expect(revs.includes(counter._rev)).to.be.true
  })

  // Query by id
  it('Should return the latest revision for an id', async () => {
    const [rev] = await computer.query({ ids: [counter._id] })
    expect(rev).eq(counter._rev)
  })

  // Query by module specifier
  it('Should return the latest revisions for a module specifier', async () => {
    const [rev] = await computer.query({ mod })
    expect(rev).eq(counter._rev)
  })

  // Query by multiple parameters
  it('Should return the latest revisions for multiple parameters', async () => {
    const revs = await computer.query({ publicKey, limit: 1 })
    expect(revs.length).eq(1)
  })
})

Sources