Class Queue

constructor

• new Queue(program: Program, pubkey: PublicKey): Queue

  Constructs a OnDemandQueue instance.

  Parameters

  • program: Program

    The Anchor program instance.
  • pubkey: PublicKey

    The public key of the queue account.

  Returns Queue

Readonlyprogram

Readonlypubkey

addMrEnclaveIx

• addMrEnclaveIx(
      params: { mrEnclave: Uint8Array },
  ): Promise<TransactionInstruction>

  Adds a new MR enclave to the queue. This will allow the queue to accept signatures from the given MR enclave.

  Parameters

  • params: { mrEnclave: Uint8Array }

  Returns Promise<TransactionInstruction>

  A promise that resolves to the transaction instruction.

  Throws

  if the request fails.

  Throws

  if the MR enclave is already added.

  Throws

  if the MR enclave is invalid.

  Throws

  if the MR enclave is not a valid length.

allowSubsidyIx

• allowSubsidyIx(params: { enable: boolean }): Promise<TransactionInstruction>

  Parameters

  • params: { enable: boolean }

  Returns Promise<TransactionInstruction>

fetchAllGateways

• fetchAllGateways(): Promise<Gateway[]>

  Loads the queue data from on chain and returns the listed gateways.

  Returns Promise<Gateway[]>

  A promise that resolves to an array of gateway URIs.

fetchFreshOracle

• fetchFreshOracle(): Promise<PublicKey>

  Fetches most recently added and verified Oracle Key.

  Returns Promise<PublicKey>

  A promise that resolves to an oracle public key.

  Throws

  if the request fails.

fetchGateway

• fetchGateway(gatewayUrl?: string): Promise<Gateway>

  Fetches a gateway interface for interacting with oracle nodes.

  Parameters

  • OptionalgatewayUrl: string

    Optional URL of a specific gateway to use. If not provided, a random gateway will be selected from the queue's available gateways.

  Returns Promise<Gateway>

  Gateway - A Gateway instance for making oracle requests

  Throws

  If no gateways are available on the queue when selecting randomly

fetchOracleKeys

• fetchOracleKeys(): Promise<PublicKey[]>

  Loads the queue data from on chain and returns the listed oracle keys.

  Returns Promise<PublicKey[]>

  A promise that resolves to an array of oracle public keys.

fetchSignatures

• fetchSignatures(
      params: {
          gateway?: string;
          jobs: IOracleJob[];
          maxVariance?: number;
          minResponses?: number;
          numSignatures?: number;
          recentHash?: string;
          useTimestamp?: boolean;
      },
  ): Promise<{ failures: string[]; responses: FeedEvalResponse[] }>

  Fetches signatures from a random gateway on the queue.

  REST API endpoint: /api/v1/fetch_signatures

  Parameters

  • params: {
        gateway?: string;
        jobs: IOracleJob[];
        maxVariance?: number;
        minResponses?: number;
        numSignatures?: number;
        recentHash?: string;
        useTimestamp?: boolean;
    }

  Returns Promise<{ failures: string[]; responses: FeedEvalResponse[] }>

  A promise that resolves to the feed evaluation responses.

  Throws

  if the request fails.

fetchSignaturesBatch

• fetchSignaturesBatch(
      params: {
          feedConfigs: FeedRequest[];
          gateway?: string;
          numSignatures?: number;
          recentHash?: string;
          useTimestamp?: boolean;
      },
  ): Promise<FetchSignaturesBatchResponse>

  Parameters

  • params: {
        feedConfigs: FeedRequest[];
        gateway?: string;
        numSignatures?: number;
        recentHash?: string;
        useTimestamp?: boolean;
    }

  Returns Promise<FetchSignaturesBatchResponse>

fetchSignaturesConsensus

• fetchSignaturesConsensus(
      params: {
          feedConfigs: FeedRequest[];
          gateway?: string;
          numSignatures?: number;
          recentHash?: string;
          useTimestamp?: boolean;
      },
  ): Promise<FetchSignaturesConsensusResponse>

  Parameters

  • params: {
        feedConfigs: FeedRequest[];
        gateway?: string;
        numSignatures?: number;
        recentHash?: string;
        useTimestamp?: boolean;
    }

  Returns Promise<FetchSignaturesConsensusResponse>

fetchSignaturesMulti

• fetchSignaturesMulti(
      params: {
          feedConfigs: FeedRequest[];
          gateway?: string;
          numSignatures?: number;
          recentHash?: string;
          useTimestamp?: boolean;
      },
  ): Promise<FetchSignaturesMultiResponse>

  Parameters

  • params: {
        feedConfigs: FeedRequest[];
        gateway?: string;
        numSignatures?: number;
        recentHash?: string;
        useTimestamp?: boolean;
    }

  Returns Promise<FetchSignaturesMultiResponse>

loadData

• loadData(): Promise<QueueAccountData>

  Loads the queue data for this Queue account from on chain.

  Returns Promise<QueueAccountData>

  A promise that resolves to the queue data.

  Throws

  if the queue account does not exist.

loadLookupTable

• loadLookupTable(): Promise<AddressLookupTableAccount>

  Returns Promise<AddressLookupTableAccount>

overrideSVM

• overrideSVM(
      params: {
          maxQuoteVerificationAge: number;
          mrEnclave: Buffer;
          oracle: PublicKey;
          secp256k1Signer: Buffer;
          slot: number;
      },
  ): Promise<TransactionInstruction>

  Add an Oracle to a queue and set permissions

  Parameters

  • params: {
        maxQuoteVerificationAge: number;
        mrEnclave: Buffer;
        oracle: PublicKey;
        secp256k1Signer: Buffer;
        slot: number;
    }

  Returns Promise<TransactionInstruction>

queuePDA

• queuePDA(): PublicKey

  Get the PDA for the queue (SVM chains that are not solana)

  Returns PublicKey

  Queue PDA Pubkey

rmAllMrEnclaveIxs

• rmAllMrEnclaveIxs(): Promise<TransactionInstruction[]>

  Removes all MR enclaves from the queue.

  Returns Promise<TransactionInstruction[]>

  A promise that resolves to an array of transaction instructions.

  Throws

  if the request fails.

rmMrEnclaveIx

• rmMrEnclaveIx(
      params: { mrEnclave: Uint8Array },
  ): Promise<TransactionInstruction>

  Removes an MR enclave from the queue. This will prevent the queue from accepting signatures from the given MR enclave.

  Parameters

  • params: { mrEnclave: Uint8Array }

  Returns Promise<TransactionInstruction>

  A promise that resolves to the transaction instruction.

  Throws

  if the request fails.

  Throws

  if the MR enclave is not present.

setConfigsIx

• setConfigsIx(
      params: { authority?: PublicKey; nodeTimeout?: number; reward?: number },
  ): Promise<TransactionInstruction>

  Sets the queue configurations.

  Parameters

  • params: { authority?: PublicKey; nodeTimeout?: number; reward?: number }

    • Optionalauthority?: PublicKey

      The new authority for the queue.

    • OptionalnodeTimeout?: number

      The new node timeout for the queue.

    • Optionalreward?: number

      The new reward for the queue.

  Returns Promise<TransactionInstruction>

  A promise that resolves to the transaction instruction.

setNcnIx

• setNcnIx(params: { ncn: PublicKey }): Promise<TransactionInstruction>

  Parameters

  • params: { ncn: PublicKey }

  Returns Promise<TransactionInstruction>

setOraclePermissionIx

• setOraclePermissionIx(
      params: {
          enable: boolean;
          oracle: PublicKey;
          permission: SwitchboardPermission;
      },
  ): Promise<TransactionInstruction>

  Sets the oracle permission on the queue.

  Parameters

  • params: { enable: boolean; oracle: PublicKey; permission: SwitchboardPermission }

    • enable: boolean

    • oracle: PublicKey

      The oracle to set the permission for.

    • permission: SwitchboardPermission

      The permission to set.

  Returns Promise<TransactionInstruction>

  A promise that resolves to the transaction instruction

setVaultIx

• setVaultIx(
      params: { enable: boolean; vault: PublicKey },
  ): Promise<TransactionInstruction>

  Parameters

  • params: { enable: boolean; vault: PublicKey }

  Returns Promise<TransactionInstruction>

StaticcreateIx

• createIx(
      program: Program,
      params: {
          allowAuthorityOverrideAfter?: number;
          lutSlot?: number;
          maxQuoteVerificationAge?: number;
          nodeTimeout?: number;
          requireAuthorityHeartbeatPermission?: boolean;
          requireUsagePermission?: boolean;
          reward?: number;
      },
  ): Promise<[Queue, Keypair, TransactionInstruction]>

  Parameters

  • program: Program
  • params: {
        allowAuthorityOverrideAfter?: number;
        lutSlot?: number;
        maxQuoteVerificationAge?: number;
        nodeTimeout?: number;
        requireAuthorityHeartbeatPermission?: boolean;
        requireUsagePermission?: boolean;
        reward?: number;
    }

  Returns Promise<[Queue, Keypair, TransactionInstruction]>

StaticcreateIxSVM

• createIxSVM(
      program: Program,
      params: {
          allowAuthorityOverrideAfter?: number;
          lutSlot?: number;
          maxQuoteVerificationAge?: number;
          nodeTimeout?: number;
          requireAuthorityHeartbeatPermission?: boolean;
          requireUsagePermission?: boolean;
          reward?: number;
          sourceQueueKey: PublicKey;
      },
  ): Promise<[Queue, TransactionInstruction]>

  Creates a new instance of the Queue account with a PDA for SVM (non-solana) chains.

  Parameters

  • program: Program

    The anchor program instance.
  • params: {
        allowAuthorityOverrideAfter?: number;
        lutSlot?: number;
        maxQuoteVerificationAge?: number;
        nodeTimeout?: number;
        requireAuthorityHeartbeatPermission?: boolean;
        requireUsagePermission?: boolean;
        reward?: number;
        sourceQueueKey: PublicKey;
    }

    The initialization parameters for the queue.

  Returns Promise<[Queue, TransactionInstruction]>

StaticfetchFeedHash

• fetchFeedHash(
      program: Program,
      params: {
          gateway?: string;
          jobs: IOracleJob[];
          maxVariance?: number;
          minResponses?: number;
          numSignatures?: number;
          queue: PublicKey;
          recentHash?: string;
      },
  ): Promise<Buffer<ArrayBufferLike>>

  Parameters

  • program: Program
  • params: {
        gateway?: string;
        jobs: IOracleJob[];
        maxVariance?: number;
        minResponses?: number;
        numSignatures?: number;
        queue: PublicKey;
        recentHash?: string;
    }

  Returns Promise<Buffer<ArrayBufferLike>>

  Deprecated

  Deprecated. Use @switchboard-xyz/common#FeedHash.compute instead.

StaticfetchSignatures

• fetchSignatures(
      program: Program,
      params: {
          gateway?: string;
          jobs: IOracleJob[];
          maxVariance?: number;
          minResponses?: number;
          numSignatures?: number;
          queue: PublicKey;
          recentHash?: string;
      },
  ): Promise<{ failures: string[]; responses: FeedEvalResponse[] }>

  Fetches signatures from a random gateway on the queue.

  REST API endpoint: /api/v1/fetch_signatures

  Parameters

  • program: Program
  • params: {
        gateway?: string;
        jobs: IOracleJob[];
        maxVariance?: number;
        minResponses?: number;
        numSignatures?: number;
        queue: PublicKey;
        recentHash?: string;
    }

  Returns Promise<{ failures: string[]; responses: FeedEvalResponse[] }>

  A promise that resolves to the feed evaluation responses.

  Throws

  if the request fails.

StaticfetchSignaturesBatch

• fetchSignaturesBatch(
      program: Program,
      params: {
          feedConfigs: FeedRequest[];
          gateway?: string;
          minResponses?: number;
          queue: PublicKey;
          recentHash?: string;
      },
  ): Promise<FetchSignaturesBatchResponse>

  Parameters

  • program: Program
  • params: {
        feedConfigs: FeedRequest[];
        gateway?: string;
        minResponses?: number;
        queue: PublicKey;
        recentHash?: string;
    }

  Returns Promise<FetchSignaturesBatchResponse>

StaticfetchSignaturesConsensus

• fetchSignaturesConsensus(
      program: Program,
      params: {
          feedConfigs: FeedRequest[];
          gateway?: string;
          numSignatures?: number;
          queue: PublicKey;
          recentHash?: string;
          useTimestamp?: boolean;
      },
  ): Promise<FetchSignaturesConsensusResponse>

  Parameters

  • program: Program
  • params: {
        feedConfigs: FeedRequest[];
        gateway?: string;
        numSignatures?: number;
        queue: PublicKey;
        recentHash?: string;
        useTimestamp?: boolean;
    }

  Returns Promise<FetchSignaturesConsensusResponse>

StaticfetchSignaturesMulti

• fetchSignaturesMulti(
      program: Program,
      params: {
          feedConfigs: FeedRequest[];
          gateway?: string;
          minResponses?: number;
          queue: PublicKey;
          recentHash?: string;
      },
  ): Promise<FetchSignaturesMultiResponse>

  Parameters

  • program: Program
  • params: {
        feedConfigs: FeedRequest[];
        gateway?: string;
        minResponses?: number;
        queue: PublicKey;
        recentHash?: string;
    }

  Returns Promise<FetchSignaturesMultiResponse>

StaticloadData

• loadData(program: Program, pubkey: PublicKey): Promise<QueueAccountData>

  Loads the queue data for this Queue account from on chain.

  Parameters

  • program: Program
  • pubkey: PublicKey

  Returns Promise<QueueAccountData>

  A promise that resolves to the queue data.

  Throws

  if the queue account does not exist.

StaticqueuePDA

• queuePDA(program: Program, pubkey: PublicKey): PublicKey

  Get the PDA for the queue (SVM chains that are not solana)

  Parameters

  • program: Program

    Anchor program
  • pubkey: PublicKey

    Queue pubkey

  Returns PublicKey

  Queue PDA Pubkey