Skip to main content

Query <TInstructions, TDescriptor>

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

  • new Query<TInstructions, TDescriptor>(instructions?: TInstructions): Query<TInstructions, TDescriptor>

  • Type parameters

    • TInstructions: QueryInstruction[] = QueryInstruction[]
    • TDescriptor: ChainDefinition = ChainDefinition

    Parameters

    • instructions: TInstructions = ...

    Returns Query<TInstructions, TDescriptor>

Properties

callApi

callApi: <TPallet, TApi, TDefer>(pallet: TPallet, api: TApi, ...__namedParameters: InferPapiRuntimeCall<TypedApi<TDescriptor>[apis][TPallet][TApi]>[args] extends [] ? [args?: any[any], options?: { at?: Finality; defer?: TDefer }] : [args: InferPapiRuntimeCall<TypedApi<TDescriptor>[apis][TPallet][TApi]>[args], options?: { at?: Finality; defer?: TDefer }]) => Query<[...TInstructions[], { api: TApi; args: unknown[]; at: Finality; directives: { defer: NoInfer<TDefer> }; instruction: call-api; pallet: TPallet }], TDescriptor> = ...
@deprecated

Use Query.runtimeApi instead.

Type declaration

    • <TPallet, TApi, TDefer>(pallet: TPallet, api: TApi, ...__namedParameters: InferPapiRuntimeCall<TypedApi<TDescriptor>[apis][TPallet][TApi]>[args] extends [] ? [args?: any[any], options?: { at?: Finality; defer?: TDefer }] : [args: InferPapiRuntimeCall<TypedApi<TDescriptor>[apis][TPallet][TApi]>[args], options?: { at?: Finality; defer?: TDefer }]): Query<[...TInstructions[], { api: TApi; args: unknown[]; at: Finality; directives: { defer: NoInfer<TDefer> }; instruction: call-api; pallet: TPallet }], TDescriptor>

    • Type parameters

      • TPallet: string
      • TApi: string
      • TDefer: boolean = false

      Parameters

      • pallet: TPallet
      • api: TApi
      • rest...__namedParameters: InferPapiRuntimeCall<TypedApi<TDescriptor>[apis][TPallet][TApi]>[args] extends [] ? [args?: any[any], options?: { at?: Finality; defer?: TDefer }] : [args: InferPapiRuntimeCall<TypedApi<TDescriptor>[apis][TPallet][TApi]>[args], options?: { at?: Finality; defer?: TDefer }]

      Returns Query<[...TInstructions[], { api: TApi; args: unknown[]; at: Finality; directives: { defer: NoInfer<TDefer> }; instruction: call-api; pallet: TPallet }], TDescriptor>

callApis

callApis: <TPallet, TApi, TDefer, TStream>(pallet: TPallet, api: TApi, args: InferPapiRuntimeCall<TypedApi<TDescriptor>[apis][TPallet][TApi]>[args][], options?: { at?: Finality; defer?: TDefer; stream?: TStream }) => Query<[...TInstructions[], { api: TApi; args: InferPapiRuntimeCall<TypedApi<...>[apis][TPallet][TApi]>[args][]; at: Finality; directives: { defer: NoInfer<TDefer>; stream: NoInfer<TStream> }; instruction: call-api; multi: true; pallet: TPallet }], TDescriptor> = ...
@deprecated

Use Query.runtimeApis instead.

Type declaration

    • <TPallet, TApi, TDefer, TStream>(pallet: TPallet, api: TApi, args: InferPapiRuntimeCall<TypedApi<TDescriptor>[apis][TPallet][TApi]>[args][], options?: { at?: Finality; defer?: TDefer; stream?: TStream }): Query<[...TInstructions[], { api: TApi; args: InferPapiRuntimeCall<TypedApi<...>[apis][TPallet][TApi]>[args][]; at: Finality; directives: { defer: NoInfer<TDefer>; stream: NoInfer<TStream> }; instruction: call-api; multi: true; pallet: TPallet }], TDescriptor>

    • Type parameters

      • TPallet: string
      • TApi: string
      • TDefer: boolean = false
      • TStream: boolean = false

      Parameters

      • pallet: TPallet
      • api: TApi
      • args: InferPapiRuntimeCall<TypedApi<TDescriptor>[apis][TPallet][TApi]>[args][]
      • optionaloptions: { at?: Finality; defer?: TDefer; stream?: TStream }
        • optionalat: Finality
        • optionaldefer: TDefer
        • optionalstream: TStream

      Returns Query<[...TInstructions[], { api: TApi; args: InferPapiRuntimeCall<TypedApi<...>[apis][TPallet][TApi]>[args][]; at: Finality; directives: { defer: NoInfer<TDefer>; stream: NoInfer<TStream> }; instruction: call-api; multi: true; pallet: TPallet }], TDescriptor>

getConstant

getConstant: <TPallet, TConstant, TDefer>(pallet: TPallet, constant: TConstant, options?: { defer?: TDefer }) => Query<[...TInstructions[], { constant: TConstant; directives: { defer: NoInfer<TDefer> }; instruction: get-constant; pallet: TPallet }], TDescriptor> = ...
@deprecated

Use Query.constant instead.

Type declaration

    • <TPallet, TConstant, TDefer>(pallet: TPallet, constant: TConstant, options?: { defer?: TDefer }): Query<[...TInstructions[], { constant: TConstant; directives: { defer: NoInfer<TDefer> }; instruction: get-constant; pallet: TPallet }], TDescriptor>

    • Type parameters

      • TPallet: string
      • TConstant: string
      • TDefer: boolean = false

      Parameters

      • pallet: TPallet
      • constant: TConstant
      • optionaloptions: { defer?: TDefer }
        • optionaldefer: TDefer

      Returns Query<[...TInstructions[], { constant: TConstant; directives: { defer: NoInfer<TDefer> }; instruction: get-constant; pallet: TPallet }], TDescriptor>

readStorage

readStorage: <TPallet, TStorage, TDefer>(pallet: TPallet, storage: TStorage, ...__namedParameters: InferPapiStorageEntry<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args] extends [] ? [args?: any[any], options?: { at?: At; defer?: TDefer }] : [args: InferPapiStorageEntry<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args], options?: { at?: At; defer?: TDefer }]) => Query<[...TInstructions[], { args: any[] | InferPapiStorageEntry<TypedApi<...>[query][TPallet][TStorage]>[args]; at: At; directives: { defer: NoInfer<TDefer> }; instruction: read-storage; pallet: TPallet; storage: TStorage }], TDescriptor> = ...
@deprecated

Use Query.storage instead.

Type declaration

    • <TPallet, TStorage, TDefer>(pallet: TPallet, storage: TStorage, ...__namedParameters: InferPapiStorageEntry<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args] extends [] ? [args?: any[any], options?: { at?: At; defer?: TDefer }] : [args: InferPapiStorageEntry<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args], options?: { at?: At; defer?: TDefer }]): Query<[...TInstructions[], { args: any[] | InferPapiStorageEntry<TypedApi<...>[query][TPallet][TStorage]>[args]; at: At; directives: { defer: NoInfer<TDefer> }; instruction: read-storage; pallet: TPallet; storage: TStorage }], TDescriptor>

    • Type parameters

      • TPallet: string
      • TStorage: string
      • TDefer: boolean = false

      Parameters

      • pallet: TPallet
      • storage: TStorage
      • rest...__namedParameters: InferPapiStorageEntry<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args] extends [] ? [args?: any[any], options?: { at?: At; defer?: TDefer }] : [args: InferPapiStorageEntry<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args], options?: { at?: At; defer?: TDefer }]

      Returns Query<[...TInstructions[], { args: any[] | InferPapiStorageEntry<TypedApi<...>[query][TPallet][TStorage]>[args]; at: At; directives: { defer: NoInfer<TDefer> }; instruction: read-storage; pallet: TPallet; storage: TStorage }], TDescriptor>

readStorageEntries

readStorageEntries: <TPallet, TStorage, TDefer>(pallet: TPallet, storage: TStorage, args?: InferPapiStorageEntries<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args], options?: { at?: At; defer?: TDefer }) => Query<[...TInstructions[], { args: unknown[]; at: At; directives: { defer: NoInfer<TDefer> }; instruction: read-storage-entries; pallet: TPallet; storage: TStorage }], TDescriptor> = ...
@deprecated

Use Query.storageEntries instead.

Type declaration

    • <TPallet, TStorage, TDefer>(pallet: TPallet, storage: TStorage, args?: InferPapiStorageEntries<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args], options?: { at?: At; defer?: TDefer }): Query<[...TInstructions[], { args: unknown[]; at: At; directives: { defer: NoInfer<TDefer> }; instruction: read-storage-entries; pallet: TPallet; storage: TStorage }], TDescriptor>

    • Type parameters

      • TPallet: string
      • TStorage: string
      • TDefer: boolean = false

      Parameters

      • pallet: TPallet
      • storage: TStorage
      • optionalargs: InferPapiStorageEntries<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args]
      • optionaloptions: { at?: At; defer?: TDefer }
        • optionalat: At
        • optionaldefer: TDefer

      Returns Query<[...TInstructions[], { args: unknown[]; at: At; directives: { defer: NoInfer<TDefer> }; instruction: read-storage-entries; pallet: TPallet; storage: TStorage }], TDescriptor>

readStorages

readStorages: <TPallet, TStorage, TDefer, TStream>(pallet: TPallet, storage: TStorage, args: InferPapiStorageEntry<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args][], options?: { at?: At; defer?: TDefer; stream?: TStream }) => Query<[...TInstructions[], { args: InferPapiStorageEntry<TypedApi<...>[query][TPallet][TStorage]>[args][]; at: At; directives: { defer: NoInfer<TDefer>; stream: NoInfer<TStream> }; instruction: read-storage; multi: true; pallet: TPallet; storage: TStorage }], TDescriptor> = ...
@deprecated

Use Query.storages instead.

Type declaration

    • <TPallet, TStorage, TDefer, TStream>(pallet: TPallet, storage: TStorage, args: InferPapiStorageEntry<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args][], options?: { at?: At; defer?: TDefer; stream?: TStream }): Query<[...TInstructions[], { args: InferPapiStorageEntry<TypedApi<...>[query][TPallet][TStorage]>[args][]; at: At; directives: { defer: NoInfer<TDefer>; stream: NoInfer<TStream> }; instruction: read-storage; multi: true; pallet: TPallet; storage: TStorage }], TDescriptor>

    • Type parameters

      • TPallet: string
      • TStorage: string
      • TDefer: boolean = false
      • TStream: boolean = false

      Parameters

      • pallet: TPallet
      • storage: TStorage
      • args: InferPapiStorageEntry<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args][]
      • optionaloptions: { at?: At; defer?: TDefer; stream?: TStream }
        • optionalat: At
        • optionaldefer: TDefer
        • optionalstream: TStream

      Returns Query<[...TInstructions[], { args: InferPapiStorageEntry<TypedApi<...>[query][TPallet][TStorage]>[args][]; at: At; directives: { defer: NoInfer<TDefer>; stream: NoInfer<TStream> }; instruction: read-storage; multi: true; pallet: TPallet; storage: TStorage }], TDescriptor>

Accessors

instructions

  • get instructions(): TInstructions

  • Returns TInstructions

Methods

concat

  • concat<TQueries>(...queries: TQueries): Query<[...TInstructions[], ...Flatten<{ [ P in string | number | symbol ]: TQueries[P<P>] extends Query<Instructions, _> ? Instructions : never }>[]], TDescriptor>

  • Type parameters

    • TQueries: Query<QueryInstruction[], ChainDefinition>[]

    Parameters

    • rest...queries: TQueries

    Returns Query<[...TInstructions[], ...Flatten<{ [ P in string | number | symbol ]: TQueries[P<P>] extends Query<Instructions, _> ? Instructions : never }>[]], TDescriptor>

constant

  • constant<TPallet, TConstant, TDefer>(pallet: TPallet, constant: TConstant, options?: { defer?: TDefer }): Query<[...TInstructions[], { constant: TConstant; directives: { defer: NoInfer<TDefer> }; instruction: get-constant; pallet: TPallet }], TDescriptor>

  • Type parameters

    • TPallet: string
    • TConstant: string
    • TDefer: boolean = false

    Parameters

    • pallet: TPallet
    • constant: TConstant
    • optionaloptions: { defer?: TDefer }
      • optionaldefer: TDefer

    Returns Query<[...TInstructions[], { constant: TConstant; directives: { defer: NoInfer<TDefer> }; instruction: get-constant; pallet: TPallet }], TDescriptor>

contract

  • contract<TContractDescriptor, TContractInstructions, TDefer>(contract: InkContract<TContractDescriptor>, address: string, builder: (query: InkQuery<TContractDescriptor, []>) => InkQuery<TContractDescriptor, TContractInstructions>, options?: { defer?: TDefer }): Query<[...TInstructions[], { address: string; contract: InkContract<TContractDescriptor>; directives: { defer: NoInfer<TDefer> }; instruction: read-contract; instructions: TContractInstructions }], TDescriptor>
  • contract<TAbi, TContractInstructions, TDefer>(contract: SolidityContract<TAbi>, address: string, builder: (query: SolidityQuery<TAbi, []>) => SolidityQuery<TAbi, TContractInstructions>, options?: { defer?: TDefer }): Query<[...TInstructions[], { address: string; contract: SolidityContract<TAbi>; directives: { defer: NoInfer<TDefer> }; instruction: read-contract; instructions: TContractInstructions }], TDescriptor>

  • Type parameters

    • TContractDescriptor: GenericInkDescriptors
    • TContractInstructions: InkQueryInstruction[]
    • TDefer: boolean = false

    Parameters

    • contract: InkContract<TContractDescriptor>
    • address: string
    • builder: (query: InkQuery<TContractDescriptor, []>) => InkQuery<TContractDescriptor, TContractInstructions>
      • optionaloptions: { defer?: TDefer }
        • optionaldefer: TDefer

      Returns Query<[...TInstructions[], { address: string; contract: InkContract<TContractDescriptor>; directives: { defer: NoInfer<TDefer> }; instruction: read-contract; instructions: TContractInstructions }], TDescriptor>

    contracts

    • contracts<TContractDescriptor, TContractInstructions, TDefer, TStream>(contract: InkContract<TContractDescriptor>, addresses: string[], builder: (query: InkQuery<TContractDescriptor, []>) => InkQuery<TContractDescriptor, TContractInstructions>, options?: { defer?: TDefer; stream?: TStream }): Query<[...TInstructions[], { addresses: string[]; contract: InkContract<TContractDescriptor>; directives: { defer: NoInfer<TDefer>; stream: NoInfer<TStream> }; instruction: read-contract; instructions: TContractInstructions; multi: true }], TDescriptor>
    • contracts<TAbi, TContractInstructions, TDefer, TStream>(contract: SolidityContract<TAbi>, addresses: string[], builder: (query: SolidityQuery<TAbi, []>) => SolidityQuery<TAbi, TContractInstructions>, options?: { defer?: TDefer; stream?: TStream }): Query<[...TInstructions[], { addresses: string[]; contract: SolidityContract<TAbi>; directives: { defer: NoInfer<TDefer>; stream: NoInfer<TStream> }; instruction: read-contract; instructions: TContractInstructions; multi: true }], TDescriptor>

    • Type parameters

      • TContractDescriptor: GenericInkDescriptors
      • TContractInstructions: InkQueryInstruction[]
      • TDefer: boolean = false
      • TStream: boolean = false

      Parameters

      • contract: InkContract<TContractDescriptor>
      • addresses: string[]
      • builder: (query: InkQuery<TContractDescriptor, []>) => InkQuery<TContractDescriptor, TContractInstructions>
        • optionaloptions: { defer?: TDefer; stream?: TStream }
          • optionaldefer: TDefer
          • optionalstream: TStream

        Returns Query<[...TInstructions[], { addresses: string[]; contract: InkContract<TContractDescriptor>; directives: { defer: NoInfer<TDefer>; stream: NoInfer<TStream> }; instruction: read-contract; instructions: TContractInstructions; multi: true }], TDescriptor>

      runtimeApi

      • runtimeApi<TPallet, TApi, TDefer>(pallet: TPallet, api: TApi, ...__namedParameters: InferPapiRuntimeCall<TypedApi<TDescriptor>[apis][TPallet][TApi]>[args] extends [] ? [args?: any[any], options?: { at?: Finality; defer?: TDefer }] : [args: InferPapiRuntimeCall<TypedApi<TDescriptor>[apis][TPallet][TApi]>[args], options?: { at?: Finality; defer?: TDefer }]): Query<[...TInstructions[], { api: TApi; args: unknown[]; at: Finality; directives: { defer: NoInfer<TDefer> }; instruction: call-api; pallet: TPallet }], TDescriptor>

      • Type parameters

        • TPallet: string
        • TApi: string
        • TDefer: boolean = false

        Parameters

        • pallet: TPallet
        • api: TApi
        • rest...__namedParameters: InferPapiRuntimeCall<TypedApi<TDescriptor>[apis][TPallet][TApi]>[args] extends [] ? [args?: any[any], options?: { at?: Finality; defer?: TDefer }] : [args: InferPapiRuntimeCall<TypedApi<TDescriptor>[apis][TPallet][TApi]>[args], options?: { at?: Finality; defer?: TDefer }]

        Returns Query<[...TInstructions[], { api: TApi; args: unknown[]; at: Finality; directives: { defer: NoInfer<TDefer> }; instruction: call-api; pallet: TPallet }], TDescriptor>

      runtimeApis

      • runtimeApis<TPallet, TApi, TDefer, TStream>(pallet: TPallet, api: TApi, args: InferPapiRuntimeCall<TypedApi<TDescriptor>[apis][TPallet][TApi]>[args][], options?: { at?: Finality; defer?: TDefer; stream?: TStream }): Query<[...TInstructions[], { api: TApi; args: InferPapiRuntimeCall<TypedApi<TDescriptor>[apis][TPallet][TApi]>[args][]; at: Finality; directives: { defer: NoInfer<TDefer>; stream: NoInfer<TStream> }; instruction: call-api; multi: true; pallet: TPallet }], TDescriptor>

      • Type parameters

        • TPallet: string
        • TApi: string
        • TDefer: boolean = false
        • TStream: boolean = false

        Parameters

        • pallet: TPallet
        • api: TApi
        • args: InferPapiRuntimeCall<TypedApi<TDescriptor>[apis][TPallet][TApi]>[args][]
        • optionaloptions: { at?: Finality; defer?: TDefer; stream?: TStream }
          • optionalat: Finality
          • optionaldefer: TDefer
          • optionalstream: TStream

        Returns Query<[...TInstructions[], { api: TApi; args: InferPapiRuntimeCall<TypedApi<TDescriptor>[apis][TPallet][TApi]>[args][]; at: Finality; directives: { defer: NoInfer<TDefer>; stream: NoInfer<TStream> }; instruction: call-api; multi: true; pallet: TPallet }], TDescriptor>

      storage

      • storage<TPallet, TStorage, TDefer>(pallet: TPallet, storage: TStorage, ...__namedParameters: InferPapiStorageEntry<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args] extends [] ? [args?: any[any], options?: { at?: At; defer?: TDefer }] : [args: InferPapiStorageEntry<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args], options?: { at?: At; defer?: TDefer }]): Query<[...TInstructions[], { args: any[] | InferPapiStorageEntry<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args]; at: At; directives: { defer: NoInfer<TDefer> }; instruction: read-storage; pallet: TPallet; storage: TStorage }], TDescriptor>

      • Type parameters

        • TPallet: string
        • TStorage: string
        • TDefer: boolean = false

        Parameters

        • pallet: TPallet
        • storage: TStorage
        • rest...__namedParameters: InferPapiStorageEntry<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args] extends [] ? [args?: any[any], options?: { at?: At; defer?: TDefer }] : [args: InferPapiStorageEntry<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args], options?: { at?: At; defer?: TDefer }]

        Returns Query<[...TInstructions[], { args: any[] | InferPapiStorageEntry<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args]; at: At; directives: { defer: NoInfer<TDefer> }; instruction: read-storage; pallet: TPallet; storage: TStorage }], TDescriptor>

      storageEntries

      • storageEntries<TPallet, TStorage, TDefer>(pallet: TPallet, storage: TStorage, args?: InferPapiStorageEntries<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args], options?: { at?: At; defer?: TDefer }): Query<[...TInstructions[], { args: unknown[]; at: At; directives: { defer: NoInfer<TDefer> }; instruction: read-storage-entries; pallet: TPallet; storage: TStorage }], TDescriptor>

      • Type parameters

        • TPallet: string
        • TStorage: string
        • TDefer: boolean = false

        Parameters

        • pallet: TPallet
        • storage: TStorage
        • optionalargs: InferPapiStorageEntries<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args]
        • optionaloptions: { at?: At; defer?: TDefer }
          • optionalat: At
          • optionaldefer: TDefer

        Returns Query<[...TInstructions[], { args: unknown[]; at: At; directives: { defer: NoInfer<TDefer> }; instruction: read-storage-entries; pallet: TPallet; storage: TStorage }], TDescriptor>

      storages

      • storages<TPallet, TStorage, TDefer, TStream>(pallet: TPallet, storage: TStorage, args: InferPapiStorageEntry<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args][], options?: { at?: At; defer?: TDefer; stream?: TStream }): Query<[...TInstructions[], { args: InferPapiStorageEntry<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args][]; at: At; directives: { defer: NoInfer<TDefer>; stream: NoInfer<TStream> }; instruction: read-storage; multi: true; pallet: TPallet; storage: TStorage }], TDescriptor>

      • Type parameters

        • TPallet: string
        • TStorage: string
        • TDefer: boolean = false
        • TStream: boolean = false

        Parameters

        • pallet: TPallet
        • storage: TStorage
        • args: InferPapiStorageEntry<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args][]
        • optionaloptions: { at?: At; defer?: TDefer; stream?: TStream }
          • optionalat: At
          • optionaldefer: TDefer
          • optionalstream: TStream

        Returns Query<[...TInstructions[], { args: InferPapiStorageEntry<TypedApi<TDescriptor>[query][TPallet][TStorage]>[args][]; at: At; directives: { defer: NoInfer<TDefer>; stream: NoInfer<TStream> }; instruction: read-storage; multi: true; pallet: TPallet; storage: TStorage }], TDescriptor>

      Page Options