Class PullFeed

constructor

• new PullFeed(program: Program, pubkey: string | PublicKey): PullFeed

  Constructs a PullFeed instance.

  Parameters

  • program: Program

    The Anchor program instance.
  • pubkey: string | PublicKey

    The public key of the pull feed account.

  Returns PullFeed

configs

gatewayUrl

jobs

lut

Readonlyprogram

pubkey

closeIx

• closeIx(params: { payer?: PublicKey }): Promise<TransactionInstruction>

  Parameters

  • params: { payer?: PublicKey }

  Returns Promise<TransactionInstruction>

fetchUpdateIx

• fetchUpdateIx(
      params: {
          chain?: string;
          crossbarClient?: CrossbarClient;
          gateway?: string;
          jobs?: IOracleJob[];
          network?: "mainnet" | "mainnet-beta" | "testnet" | "devnet";
          numSignatures?: number;
          recentSlothashes?: [BN, string][];
          retries?: number;
          solanaRpcUrl?: string;
      },
      debug?: boolean,
      payer?: PublicKey,
  ): Promise<
      [
          TransactionInstruction[],
          OracleResponse[],
          number,
          AddressLookupTableAccount[],
          string[],
      ],
  >

  Fetch updates for the feed.

  Parameters

  • params: {
        chain?: string;
        crossbarClient?: CrossbarClient;
        gateway?: string;
        jobs?: IOracleJob[];
        network?: "mainnet" | "mainnet-beta" | "testnet" | "devnet";
        numSignatures?: number;
        recentSlothashes?: [BN, string][];
        retries?: number;
        solanaRpcUrl?: string;
    }
  • Optionaldebug: boolean

    A boolean flag to enable or disable debug mode. Defaults to false.
  • Optionalpayer: PublicKey

  Returns Promise<
      [
          TransactionInstruction[],
          OracleResponse[],
          number,
          AddressLookupTableAccount[],
          string[],
      ],
  >

  A promise that resolves to a tuple containing:

  • The transaction instruction to fetch updates, or undefined if not applicable.
  • An array of OracleResponse objects.
  • A number representing the successful responses.
  • An array containing usable lookup tables.

getSolanaSubmitSignaturesIx

• getSolanaSubmitSignaturesIx(
      params: {
          chain?: string;
          offsets: number[];
          payer?: PublicKey;
          resps: FeedEvalResponse[];
          slot: BN;
      },
  ): TransactionInstruction

  Compiles a transaction instruction to submit oracle signatures for a given feed.

  Parameters

  • params: {
        chain?: string;
        offsets: number[];
        payer?: PublicKey;
        resps: FeedEvalResponse[];
        slot: BN;
    }

  Returns TransactionInstruction

  A promise that resolves to the transaction instruction.

initIx

• initIx(
      params: {
          maxStaleness: number;
          maxVariance: number;
          minResponses: number;
          minSampleSize: number;
          name: string;
          payer?: PublicKey;
          permitWriteByAuthority?: boolean;
          queue: PublicKey;
      } & ({ feedHash: Buffer } | { jobs: IOracleJob[] }),
  ): Promise<TransactionInstruction>

  Initializes a pull feed account.

  Parameters

  • params: {
        maxStaleness: number;
        maxVariance: number;
        minResponses: number;
        minSampleSize: number;
        name: string;
        payer?: PublicKey;
        permitWriteByAuthority?: boolean;
        queue: PublicKey;
    } & ({ feedHash: Buffer } | { jobs: IOracleJob[] })

  Returns Promise<TransactionInstruction>

  A promise that resolves to the transaction instruction.

isInitializedAsync

• isInitializedAsync(): Promise<boolean>

  Checks if the pull feed account has been initialized.

  Returns Promise<boolean>

  A promise that resolves to a boolean indicating if the account has been initialized.

loadConfigs

• loadConfigs(
      force?: boolean,
  ): Promise<
      {
          feedHash: Buffer;
          maxVariance: number;
          minResponses: number;
          minSampleSize: number;
          queue: PublicKey;
      },
  >

  Loads the feed configurations (if not already cached) for this PullFeed account from on chain.

  Parameters

  • Optionalforce: boolean

  Returns Promise<
      {
          feedHash: Buffer;
          maxVariance: number;
          minResponses: number;
          minSampleSize: number;
          queue: PublicKey;
      },
  >

  A promise that resolves to the feed configurations.

  Throws

  if the feed account does not exist.

loadData

• loadData(): Promise<PullFeedAccountData>

  Loads the feed data for this PullFeed account from on chain.

  Returns Promise<PullFeedAccountData>

  A promise that resolves to the feed data.

  Throws

  if the feed account does not exist.

loadHistoricalValuesCompact

• loadHistoricalValuesCompact(
      data_?: PullFeedAccountData,
  ): Promise<CompactResult[]>

  Parameters

  • Optionaldata_: PullFeedAccountData

  Returns Promise<CompactResult[]>

loadLookupTable

• loadLookupTable(): Promise<AddressLookupTableAccount>

  Returns Promise<AddressLookupTableAccount>

loadObservedValue

• loadObservedValue(
      onlyAfter: BN,
  ): Promise<{ oracle: PublicKey; slot: BN; value: Big }>

  Loads the feed data for this PullFeed account from on chain.

  Parameters

  • onlyAfter: BN

    Call will ignore data signed before this slot.

  Returns Promise<{ oracle: PublicKey; slot: BN; value: Big }>

  A promise that resolves to the observed value as it would be seen on-chain.

loadValues

• loadValues(): Promise<{ oracle: PublicKey; slot: BN; value: Big }[]>

  Loads the feed data for this PullFeed account from on chain.

  Returns Promise<{ oracle: PublicKey; slot: BN; value: Big }[]>

  A promise that resolves to the values currently stored in the feed.

  Throws

  if the feed account does not exist.

lookupTableKey

• lookupTableKey(data: any): PublicKey

  Parameters

  • data: any

  Returns PublicKey

setConfigsIx

• setConfigsIx(
      params: {
          authority?: PublicKey;
          feedHash?: Buffer;
          jobs?: IOracleJob[];
          maxStaleness?: number;
          maxVariance?: number;
          minResponses?: number;
          minSampleSize?: number;
          name?: string;
          permitWriteByAuthority?: boolean;
      },
  ): Promise<TransactionInstruction>

  Set configurations for the feed.

  Parameters

  • params: {
        authority?: PublicKey;
        feedHash?: Buffer;
        jobs?: IOracleJob[];
        maxStaleness?: number;
        maxVariance?: number;
        minResponses?: number;
        minSampleSize?: number;
        name?: string;
        permitWriteByAuthority?: boolean;
    }

    • Optionalauthority?: PublicKey

      The authority of the feed.

    • OptionalfeedHash?: Buffer

      The hash of the feed as a Uint8Array or hexadecimal string. Only results signed with this hash will be accepted.

    • Optionaljobs?: IOracleJob[]

    • OptionalmaxStaleness?: number

      The maximum number of slots that can pass before a feed value is considered stale.

    • OptionalmaxVariance?: number

      The maximum variance allowed for the feed.

    • OptionalminResponses?: number

      The minimum number of responses required.

    • OptionalminSampleSize?: number

      The minimum number of samples required for setting feed value.

    • Optionalname?: string

    • OptionalpermitWriteByAuthority?: boolean

  Returns Promise<TransactionInstruction>

  A promise that resolves to the transaction instruction to set feed configs.

subscribeToValueChanges

• subscribeToValueChanges(callback: any): Promise<number>

  Watches for any on-chain updates to the feed data.

  Parameters

  • callback: any

    The callback to call when the feed data is updated.

  Returns Promise<number>

  A promise that resolves to a subscription ID.

StaticfetchUpdateIx

• fetchUpdateIx(
      params: {
          chain?: string;
          crossbarClient?: CrossbarClient;
          gateway?: string;
          network?: "mainnet" | "mainnet-beta" | "testnet" | "devnet";
          numSignatures: number;
          pullFeed: PullFeed;
          recentSlothashes?: [BN, string][];
      },
      debug?: boolean,
      payer?: PublicKey,
  ): Promise<
      [
          TransactionInstruction[],
          OracleResponse[],
          number,
          AddressLookupTableAccount[],
          string[],
      ],
  >

  Fetches updates for a feed, returning instructions that must be executed in order at the front of the transaction.

  Parameters

  • params: {
        chain?: string;
        crossbarClient?: CrossbarClient;
        gateway?: string;
        network?: "mainnet" | "mainnet-beta" | "testnet" | "devnet";
        numSignatures: number;
        pullFeed: PullFeed;
        recentSlothashes?: [BN, string][];
    }

    The parameters object

    • Optionalchain?: string

      Optional chain identifier (defaults to "solana")

    • OptionalcrossbarClient?: CrossbarClient

      Optional CrossbarClient instance to use

    • Optionalgateway?: string

      Optional gateway URL to use for fetching updates

    • Optionalnetwork?: "mainnet" | "mainnet-beta" | "testnet" | "devnet"

      Optional network identifier ("mainnet", "mainnet-beta", "testnet", "devnet")

    • numSignatures: number

      Number of signatures to fetch

    • pullFeed: PullFeed

    • OptionalrecentSlothashes?: [BN, string][]

  • Optionaldebug: boolean

    Enable debug logging (default: false)
  • Optionalpayer: PublicKey

    Optional transaction payer public key

  Returns Promise<
      [
          TransactionInstruction[],
          OracleResponse[],
          number,
          AddressLookupTableAccount[],
          string[],
      ],
  >

  Promise resolving to:

  • instructions: Array of instructions that must be executed in order: [0] = secp256k1 program verification instruction [1] = feed update instruction
  • oracleResponses: Array of responses from oracles
  • numSuccesses: Number of successful responses
  • luts: Array of AddressLookupTableAccount to include
  • failures: Array of errors that occurred during the fetch

StaticfetchUpdateIxSvm

• fetchUpdateIxSvm(
      params: {
          chain?: string;
          crossbarClient?: CrossbarClient;
          gateway?: string;
          network?: "mainnet" | "mainnet-beta" | "testnet" | "devnet";
          numSignatures: number;
          pullFeed: PullFeed;
          recentSlothashes?: [BN, string][];
      },
      debug?: boolean,
      payer?: PublicKey,
  ): Promise<
      [
          TransactionInstruction[],
          OracleResponse[],
          number,
          AddressLookupTableAccount[],
          string[],
      ],
  >

  Parameters

  • params: {
        chain?: string;
        crossbarClient?: CrossbarClient;
        gateway?: string;
        network?: "mainnet" | "mainnet-beta" | "testnet" | "devnet";
        numSignatures: number;
        pullFeed: PullFeed;
        recentSlothashes?: [BN, string][];
    }
  • Optionaldebug: boolean
  • Optionalpayer: PublicKey

  Returns Promise<
      [
          TransactionInstruction[],
          OracleResponse[],
          number,
          AddressLookupTableAccount[],
          string[],
      ],
  >

StaticfetchUpdateManyIx

• fetchUpdateManyIx(
      program: Program,
      params: {
          chain?: string;
          crossbarClient?: CrossbarClient;
          feeds: PublicKey[];
          gateway?: string;
          network?: "mainnet" | "mainnet-beta" | "testnet" | "devnet";
          numSignatures: number;
          payer?: PublicKey;
          recentSlothashes?: [BN, string][];
      },
      debug?: boolean,
  ): Promise<
      [
          TransactionInstruction[],
          AddressLookupTableAccount[],
          FetchSignaturesConsensusResponse,
      ],
  >

  Fetches updates for multiple feeds at once into a SINGLE tightly packed instruction. Returns instructions that must be executed in order, with the secp256k1 verification instruction placed at the front of the transaction.

  Parameters

  • program: Program

    The Anchor program instance.
  • params: {
        chain?: string;
        crossbarClient?: CrossbarClient;
        feeds: PublicKey[];
        gateway?: string;
        network?: "mainnet" | "mainnet-beta" | "testnet" | "devnet";
        numSignatures: number;
        payer?: PublicKey;
        recentSlothashes?: [BN, string][];
    }
  • Optionaldebug: boolean

    A boolean flag to enable or disable debug mode. Defaults to false.

  Returns Promise<
      [
          TransactionInstruction[],
          AddressLookupTableAccount[],
          FetchSignaturesConsensusResponse,
      ],
  >

  A promise that resolves to a tuple containing:

  • An array of transaction instructions that must be executed in order: [0] = secp256k1 program verification instruction [1] = feed update instruction
  • An array of AddressLookupTableAccount to use.
  • The raw response data.

Staticgenerate

• generate(program: Program): [PullFeed, Keypair]

  Parameters

  • program: Program

  Returns [PullFeed, Keypair]

StaticinitTx

• initTx(
      program: Program,
      params: {
          maxStaleness: number;
          maxVariance: number;
          minResponses: number;
          minSampleSize: number;
          name: string;
          payer?: PublicKey;
          permitWriteByAuthority?: boolean;
          queue: PublicKey;
      } & ({ feedHash: Buffer } | { jobs: IOracleJob[] }),
  ): Promise<[PullFeed, VersionedTransaction]>

  Parameters

  • program: Program
  • params: {
        maxStaleness: number;
        maxVariance: number;
        minResponses: number;
        minSampleSize: number;
        name: string;
        payer?: PublicKey;
        permitWriteByAuthority?: boolean;
        queue: PublicKey;
    } & ({ feedHash: Buffer } | { jobs: IOracleJob[] })

  Returns Promise<[PullFeed, VersionedTransaction]>

StaticloadMany

• loadMany(program: Program, pubkeys: PublicKey[]): Promise<PullFeedAccountData[]>

  Loads the feed data for multiple feeds at once.

  Parameters

  • program: Program

    The program instance.
  • pubkeys: PublicKey[]

    The public keys of the feeds to load.

  Returns Promise<PullFeedAccountData[]>

  A promise that resolves to an array of feed data (or null if the feed account does not exist)

StaticsubscribeToAllUpdates

• subscribeToAllUpdates(
      program: Program,
      callback: (
          event: [number, { pubkey: PublicKey; submissions: FeedSubmission[] }],
      ) => Promise<void>,
  ): Promise<number>

  Watches for any on-chain updates to any data feed.

  Parameters

  • program: Program

    The Anchor program instance.
  • callback: (
        event: [number, { pubkey: PublicKey; submissions: FeedSubmission[] }],
    ) => Promise<void>

    The callback to call when the feed data is updated.

  Returns Promise<number>

  A promise that resolves to a subscription ID.