@kamino-finance/klend-sdk 7.3.4 → 7.3.5-beta.0

package/dist/oracle.d.cts

@@ -0,0 +1,2478 @@
+export { aA as AllOracleAccounts, au as CONFIDENCE_FACTOR, aw as CandidatePrice, at as MAX_CONFIDENCE_PERCENTAGE, aC as PythPrices, ax as ScopePriceRefreshConfig, av as TokenOracleData, aD as cacheOrGetPythPrices, aF as cacheOrGetScopePrice, aE as cacheOrGetSwitchboardPrice, aB as getAllOracleAccounts, az as getTokenOracleData, ay as getTokenOracleDataSync, as as toDays, ar as toHours, aq as toSeconds } from './fraction-BeFnhBaY.cjs';
+import Decimal from 'decimal.js';
+import * as buffer_layout from 'buffer-layout';
+import { Address, Rpc, GetAccountInfoApi, GetMultipleAccountsApi } from '@solana/kit';
+import BN from 'bn.js';
+import '@coral-xyz/borsh';
+import '@kamino-finance/scope-sdk';
+import '@kamino-finance/farms-sdk';
+import '@kamino-finance/scope-sdk/dist/@codegen/scope/accounts/OraclePrices';
+import '@kamino-finance/scope-sdk/dist/@codegen/scope/accounts/Configuration';
+import '@kamino-finance/kliquidity-sdk';
+
+interface ModeRoundResolutionJSON {
+    kind: "ModeRoundResolution";
+}
+declare class ModeRoundResolution {
+    static readonly discriminator = 0;
+    static readonly kind = "ModeRoundResolution";
+    readonly discriminator = 0;
+    readonly kind = "ModeRoundResolution";
+    toJSON(): ModeRoundResolutionJSON;
+    toEncodable(): {
+        ModeRoundResolution: {};
+    };
+}
+interface ModeSlidingResolutionJSON {
+    kind: "ModeSlidingResolution";
+}
+declare class ModeSlidingResolution {
+    static readonly discriminator = 1;
+    static readonly kind = "ModeSlidingResolution";
+    readonly discriminator = 1;
+    readonly kind = "ModeSlidingResolution";
+    toJSON(): ModeSlidingResolutionJSON;
+    toEncodable(): {
+        ModeSlidingResolution: {};
+    };
+}
+
+interface StatusNoneJSON {
+    kind: "StatusNone";
+}
+declare class StatusNone {
+    static readonly discriminator = 0;
+    static readonly kind = "StatusNone";
+    readonly discriminator = 0;
+    readonly kind = "StatusNone";
+    toJSON(): StatusNoneJSON;
+    toEncodable(): {
+        StatusNone: {};
+    };
+}
+interface StatusRequestingJSON {
+    kind: "StatusRequesting";
+}
+declare class StatusRequesting {
+    static readonly discriminator = 1;
+    static readonly kind = "StatusRequesting";
+    readonly discriminator = 1;
+    readonly kind = "StatusRequesting";
+    toJSON(): StatusRequestingJSON;
+    toEncodable(): {
+        StatusRequesting: {};
+    };
+}
+interface StatusVerifyingJSON {
+    kind: "StatusVerifying";
+}
+declare class StatusVerifying {
+    static readonly discriminator = 2;
+    static readonly kind = "StatusVerifying";
+    readonly discriminator = 2;
+    readonly kind = "StatusVerifying";
+    toJSON(): StatusVerifyingJSON;
+    toEncodable(): {
+        StatusVerifying: {};
+    };
+}
+interface StatusVerifiedJSON {
+    kind: "StatusVerified";
+}
+declare class StatusVerified {
+    static readonly discriminator = 3;
+    static readonly kind = "StatusVerified";
+    readonly discriminator = 3;
+    readonly kind = "StatusVerified";
+    toJSON(): StatusVerifiedJSON;
+    toEncodable(): {
+        StatusVerified: {};
+    };
+}
+interface StatusCallbackSuccessJSON {
+    kind: "StatusCallbackSuccess";
+}
+declare class StatusCallbackSuccess {
+    static readonly discriminator = 4;
+    static readonly kind = "StatusCallbackSuccess";
+    readonly discriminator = 4;
+    readonly kind = "StatusCallbackSuccess";
+    toJSON(): StatusCallbackSuccessJSON;
+    toEncodable(): {
+        StatusCallbackSuccess: {};
+    };
+}
+interface StatusVerifyFailureJSON {
+    kind: "StatusVerifyFailure";
+}
+declare class StatusVerifyFailure {
+    static readonly discriminator = 5;
+    static readonly kind = "StatusVerifyFailure";
+    readonly discriminator = 5;
+    readonly kind = "StatusVerifyFailure";
+    toJSON(): StatusVerifyFailureJSON;
+    toEncodable(): {
+        StatusVerifyFailure: {};
+    };
+}
+
+interface EcvrfProofZCFields {
+    gamma: EdwardsPointZCFields;
+    c: ScalarFields;
+    s: ScalarFields;
+}
+interface EcvrfProofZCJSON {
+    gamma: EdwardsPointZCJSON;
+    c: ScalarJSON;
+    s: ScalarJSON;
+}
+declare class EcvrfProofZC {
+    readonly gamma: EdwardsPointZC;
+    readonly c: Scalar;
+    readonly s: Scalar;
+    constructor(fields: EcvrfProofZCFields);
+    static layout(property?: string): buffer_layout.Layout<unknown>;
+    static fromDecoded(obj: any): EcvrfProofZC;
+    static toEncodable(fields: EcvrfProofZCFields): {
+        gamma: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        c: {
+            bytes: number[];
+        };
+        s: {
+            bytes: number[];
+        };
+    };
+    toJSON(): EcvrfProofZCJSON;
+    static fromJSON(obj: EcvrfProofZCJSON): EcvrfProofZC;
+    toEncodable(): {
+        gamma: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        c: {
+            bytes: number[];
+        };
+        s: {
+            bytes: number[];
+        };
+    };
+}
+
+interface ScalarFields {
+    bytes: Array<number>;
+}
+interface ScalarJSON {
+    bytes: Array<number>;
+}
+declare class Scalar {
+    readonly bytes: Array<number>;
+    constructor(fields: ScalarFields);
+    static layout(property?: string): buffer_layout.Layout<unknown>;
+    static fromDecoded(obj: any): Scalar;
+    static toEncodable(fields: ScalarFields): {
+        bytes: number[];
+    };
+    toJSON(): ScalarJSON;
+    static fromJSON(obj: ScalarJSON): Scalar;
+    toEncodable(): {
+        bytes: number[];
+    };
+}
+
+interface FieldElementZCFields {
+    bytes: Array<BN>;
+}
+interface FieldElementZCJSON {
+    bytes: Array<string>;
+}
+declare class FieldElementZC {
+    readonly bytes: Array<BN>;
+    constructor(fields: FieldElementZCFields);
+    static layout(property?: string): buffer_layout.Layout<unknown>;
+    static fromDecoded(obj: any): FieldElementZC;
+    static toEncodable(fields: FieldElementZCFields): {
+        bytes: BN[];
+    };
+    toJSON(): FieldElementZCJSON;
+    static fromJSON(obj: FieldElementZCJSON): FieldElementZC;
+    toEncodable(): {
+        bytes: BN[];
+    };
+}
+
+interface CompletedPointZCFields {
+    x: FieldElementZCFields;
+    y: FieldElementZCFields;
+    z: FieldElementZCFields;
+    t: FieldElementZCFields;
+}
+interface CompletedPointZCJSON {
+    x: FieldElementZCJSON;
+    y: FieldElementZCJSON;
+    z: FieldElementZCJSON;
+    t: FieldElementZCJSON;
+}
+declare class CompletedPointZC {
+    readonly x: FieldElementZC;
+    readonly y: FieldElementZC;
+    readonly z: FieldElementZC;
+    readonly t: FieldElementZC;
+    constructor(fields: CompletedPointZCFields);
+    static layout(property?: string): buffer_layout.Layout<unknown>;
+    static fromDecoded(obj: any): CompletedPointZC;
+    static toEncodable(fields: CompletedPointZCFields): {
+        x: {
+            bytes: BN[];
+        };
+        y: {
+            bytes: BN[];
+        };
+        z: {
+            bytes: BN[];
+        };
+        t: {
+            bytes: BN[];
+        };
+    };
+    toJSON(): CompletedPointZCJSON;
+    static fromJSON(obj: CompletedPointZCJSON): CompletedPointZC;
+    toEncodable(): {
+        x: {
+            bytes: BN[];
+        };
+        y: {
+            bytes: BN[];
+        };
+        z: {
+            bytes: BN[];
+        };
+        t: {
+            bytes: BN[];
+        };
+    };
+}
+
+interface EdwardsPointZCFields {
+    x: FieldElementZCFields;
+    y: FieldElementZCFields;
+    z: FieldElementZCFields;
+    t: FieldElementZCFields;
+}
+interface EdwardsPointZCJSON {
+    x: FieldElementZCJSON;
+    y: FieldElementZCJSON;
+    z: FieldElementZCJSON;
+    t: FieldElementZCJSON;
+}
+declare class EdwardsPointZC {
+    readonly x: FieldElementZC;
+    readonly y: FieldElementZC;
+    readonly z: FieldElementZC;
+    readonly t: FieldElementZC;
+    constructor(fields: EdwardsPointZCFields);
+    static layout(property?: string): buffer_layout.Layout<unknown>;
+    static fromDecoded(obj: any): EdwardsPointZC;
+    static toEncodable(fields: EdwardsPointZCFields): {
+        x: {
+            bytes: BN[];
+        };
+        y: {
+            bytes: BN[];
+        };
+        z: {
+            bytes: BN[];
+        };
+        t: {
+            bytes: BN[];
+        };
+    };
+    toJSON(): EdwardsPointZCJSON;
+    static fromJSON(obj: EdwardsPointZCJSON): EdwardsPointZC;
+    toEncodable(): {
+        x: {
+            bytes: BN[];
+        };
+        y: {
+            bytes: BN[];
+        };
+        z: {
+            bytes: BN[];
+        };
+        t: {
+            bytes: BN[];
+        };
+    };
+}
+
+interface EcvrfIntermediateFields {
+    r: FieldElementZCFields;
+    nS: FieldElementZCFields;
+    d: FieldElementZCFields;
+    t13: FieldElementZCFields;
+    t15: FieldElementZCFields;
+}
+interface EcvrfIntermediateJSON {
+    r: FieldElementZCJSON;
+    nS: FieldElementZCJSON;
+    d: FieldElementZCJSON;
+    t13: FieldElementZCJSON;
+    t15: FieldElementZCJSON;
+}
+declare class EcvrfIntermediate {
+    readonly r: FieldElementZC;
+    readonly nS: FieldElementZC;
+    readonly d: FieldElementZC;
+    readonly t13: FieldElementZC;
+    readonly t15: FieldElementZC;
+    constructor(fields: EcvrfIntermediateFields);
+    static layout(property?: string): buffer_layout.Layout<unknown>;
+    static fromDecoded(obj: any): EcvrfIntermediate;
+    static toEncodable(fields: EcvrfIntermediateFields): {
+        r: {
+            bytes: BN[];
+        };
+        nS: {
+            bytes: BN[];
+        };
+        d: {
+            bytes: BN[];
+        };
+        t13: {
+            bytes: BN[];
+        };
+        t15: {
+            bytes: BN[];
+        };
+    };
+    toJSON(): EcvrfIntermediateJSON;
+    static fromJSON(obj: EcvrfIntermediateJSON): EcvrfIntermediate;
+    toEncodable(): {
+        r: {
+            bytes: BN[];
+        };
+        nS: {
+            bytes: BN[];
+        };
+        d: {
+            bytes: BN[];
+        };
+        t13: {
+            bytes: BN[];
+        };
+        t15: {
+            bytes: BN[];
+        };
+    };
+}
+
+interface HashFields {
+    data: Array<number>;
+}
+interface HashJSON {
+    data: Array<number>;
+}
+declare class Hash {
+    readonly data: Array<number>;
+    constructor(fields: HashFields);
+    static layout(property?: string): buffer_layout.Layout<unknown>;
+    static fromDecoded(obj: any): Hash;
+    static toEncodable(fields: HashFields): {
+        data: number[];
+    };
+    toJSON(): HashJSON;
+    static fromJSON(obj: HashJSON): Hash;
+    toEncodable(): {
+        data: number[];
+    };
+}
+
+interface SlidingWindowElementFields {
+    oracleKey: Address;
+    value: SwitchboardDecimalFields;
+    slot: BN;
+    timestamp: BN;
+}
+interface SlidingWindowElementJSON {
+    oracleKey: string;
+    value: SwitchboardDecimalJSON;
+    slot: string;
+    timestamp: string;
+}
+declare class SlidingWindowElement {
+    readonly oracleKey: Address;
+    readonly value: SwitchboardDecimal;
+    readonly slot: BN;
+    readonly timestamp: BN;
+    constructor(fields: SlidingWindowElementFields);
+    static layout(property?: string): buffer_layout.Layout<unknown>;
+    static fromDecoded(obj: any): SlidingWindowElement;
+    static toEncodable(fields: SlidingWindowElementFields): {
+        oracleKey: Address;
+        value: {
+            mantissa: BN;
+            scale: number;
+        };
+        slot: BN;
+        timestamp: BN;
+    };
+    toJSON(): SlidingWindowElementJSON;
+    static fromJSON(obj: SlidingWindowElementJSON): SlidingWindowElement;
+    toEncodable(): {
+        oracleKey: Address;
+        value: {
+            mantissa: BN;
+            scale: number;
+        };
+        slot: BN;
+        timestamp: BN;
+    };
+}
+
+interface AggregatorRoundFields {
+    numSuccess: number;
+    numError: number;
+    isClosed: boolean;
+    roundOpenSlot: BN;
+    roundOpenTimestamp: BN;
+    result: SwitchboardDecimalFields;
+    stdDeviation: SwitchboardDecimalFields;
+    minResponse: SwitchboardDecimalFields;
+    maxResponse: SwitchboardDecimalFields;
+    oraclePubkeysData: Array<Address>;
+    mediansData: Array<SwitchboardDecimalFields>;
+    currentPayout: Array<BN>;
+    mediansFulfilled: Array<boolean>;
+    errorsFulfilled: Array<boolean>;
+}
+interface AggregatorRoundJSON {
+    numSuccess: number;
+    numError: number;
+    isClosed: boolean;
+    roundOpenSlot: string;
+    roundOpenTimestamp: string;
+    result: SwitchboardDecimalJSON;
+    stdDeviation: SwitchboardDecimalJSON;
+    minResponse: SwitchboardDecimalJSON;
+    maxResponse: SwitchboardDecimalJSON;
+    oraclePubkeysData: Array<string>;
+    mediansData: Array<SwitchboardDecimalJSON>;
+    currentPayout: Array<string>;
+    mediansFulfilled: Array<boolean>;
+    errorsFulfilled: Array<boolean>;
+}
+declare class AggregatorRound {
+    readonly numSuccess: number;
+    readonly numError: number;
+    readonly isClosed: boolean;
+    readonly roundOpenSlot: BN;
+    readonly roundOpenTimestamp: BN;
+    readonly result: SwitchboardDecimal;
+    readonly stdDeviation: SwitchboardDecimal;
+    readonly minResponse: SwitchboardDecimal;
+    readonly maxResponse: SwitchboardDecimal;
+    readonly oraclePubkeysData: Array<Address>;
+    readonly mediansData: Array<SwitchboardDecimal>;
+    readonly currentPayout: Array<BN>;
+    readonly mediansFulfilled: Array<boolean>;
+    readonly errorsFulfilled: Array<boolean>;
+    constructor(fields: AggregatorRoundFields);
+    static layout(property?: string): buffer_layout.Layout<unknown>;
+    static fromDecoded(obj: any): AggregatorRound;
+    static toEncodable(fields: AggregatorRoundFields): {
+        numSuccess: number;
+        numError: number;
+        isClosed: boolean;
+        roundOpenSlot: BN;
+        roundOpenTimestamp: BN;
+        result: {
+            mantissa: BN;
+            scale: number;
+        };
+        stdDeviation: {
+            mantissa: BN;
+            scale: number;
+        };
+        minResponse: {
+            mantissa: BN;
+            scale: number;
+        };
+        maxResponse: {
+            mantissa: BN;
+            scale: number;
+        };
+        oraclePubkeysData: Address[];
+        mediansData: {
+            mantissa: BN;
+            scale: number;
+        }[];
+        currentPayout: BN[];
+        mediansFulfilled: boolean[];
+        errorsFulfilled: boolean[];
+    };
+    toJSON(): AggregatorRoundJSON;
+    static fromJSON(obj: AggregatorRoundJSON): AggregatorRound;
+    toEncodable(): {
+        numSuccess: number;
+        numError: number;
+        isClosed: boolean;
+        roundOpenSlot: BN;
+        roundOpenTimestamp: BN;
+        result: {
+            mantissa: BN;
+            scale: number;
+        };
+        stdDeviation: {
+            mantissa: BN;
+            scale: number;
+        };
+        minResponse: {
+            mantissa: BN;
+            scale: number;
+        };
+        maxResponse: {
+            mantissa: BN;
+            scale: number;
+        };
+        oraclePubkeysData: Address[];
+        mediansData: {
+            mantissa: BN;
+            scale: number;
+        }[];
+        currentPayout: BN[];
+        mediansFulfilled: boolean[];
+        errorsFulfilled: boolean[];
+    };
+}
+
+interface SwitchboardDecimalFields {
+    mantissa: BN;
+    scale: number;
+}
+interface SwitchboardDecimalJSON {
+    mantissa: string;
+    scale: number;
+}
+declare class SwitchboardDecimal {
+    readonly mantissa: BN;
+    readonly scale: number;
+    constructor(fields: SwitchboardDecimalFields);
+    static layout(property?: string): buffer_layout.Layout<unknown>;
+    static fromDecoded(obj: any): SwitchboardDecimal;
+    static toEncodable(fields: SwitchboardDecimalFields): {
+        mantissa: BN;
+        scale: number;
+    };
+    toJSON(): SwitchboardDecimalJSON;
+    static fromJSON(obj: SwitchboardDecimalJSON): SwitchboardDecimal;
+    toEncodable(): {
+        mantissa: BN;
+        scale: number;
+    };
+}
+
+interface OracleMetricsFields {
+    consecutiveSuccess: BN;
+    consecutiveError: BN;
+    consecutiveDisagreement: BN;
+    consecutiveLateResponse: BN;
+    consecutiveFailure: BN;
+    totalSuccess: BN;
+    totalError: BN;
+    totalDisagreement: BN;
+    totalLateResponse: BN;
+}
+interface OracleMetricsJSON {
+    consecutiveSuccess: string;
+    consecutiveError: string;
+    consecutiveDisagreement: string;
+    consecutiveLateResponse: string;
+    consecutiveFailure: string;
+    totalSuccess: string;
+    totalError: string;
+    totalDisagreement: string;
+    totalLateResponse: string;
+}
+declare class OracleMetrics {
+    readonly consecutiveSuccess: BN;
+    readonly consecutiveError: BN;
+    readonly consecutiveDisagreement: BN;
+    readonly consecutiveLateResponse: BN;
+    readonly consecutiveFailure: BN;
+    readonly totalSuccess: BN;
+    readonly totalError: BN;
+    readonly totalDisagreement: BN;
+    readonly totalLateResponse: BN;
+    constructor(fields: OracleMetricsFields);
+    static layout(property?: string): buffer_layout.Layout<unknown>;
+    static fromDecoded(obj: any): OracleMetrics;
+    static toEncodable(fields: OracleMetricsFields): {
+        consecutiveSuccess: BN;
+        consecutiveError: BN;
+        consecutiveDisagreement: BN;
+        consecutiveLateResponse: BN;
+        consecutiveFailure: BN;
+        totalSuccess: BN;
+        totalError: BN;
+        totalDisagreement: BN;
+        totalLateResponse: BN;
+    };
+    toJSON(): OracleMetricsJSON;
+    static fromJSON(obj: OracleMetricsJSON): OracleMetrics;
+    toEncodable(): {
+        consecutiveSuccess: BN;
+        consecutiveError: BN;
+        consecutiveDisagreement: BN;
+        consecutiveLateResponse: BN;
+        consecutiveFailure: BN;
+        totalSuccess: BN;
+        totalError: BN;
+        totalDisagreement: BN;
+        totalLateResponse: BN;
+    };
+}
+
+interface VrfBuilderFields {
+    producer: Address;
+    status: VrfStatusKind;
+    reprProof: Array<number>;
+    proof: EcvrfProofZCFields;
+    yPoint: Address;
+    stage: number;
+    stage1Out: EcvrfIntermediateFields;
+    r1: EdwardsPointZCFields;
+    r2: EdwardsPointZCFields;
+    stage3Out: EcvrfIntermediateFields;
+    hPoint: EdwardsPointZCFields;
+    sReduced: ScalarFields;
+    yPointBuilder: Array<FieldElementZCFields>;
+    yRistrettoPoint: EdwardsPointZCFields;
+    mulRound: number;
+    hashPointsRound: number;
+    mulTmp1: CompletedPointZCFields;
+    uPoint1: EdwardsPointZCFields;
+    uPoint2: EdwardsPointZCFields;
+    vPoint1: EdwardsPointZCFields;
+    vPoint2: EdwardsPointZCFields;
+    uPoint: EdwardsPointZCFields;
+    vPoint: EdwardsPointZCFields;
+    u1: FieldElementZCFields;
+    u2: FieldElementZCFields;
+    invertee: FieldElementZCFields;
+    y: FieldElementZCFields;
+    z: FieldElementZCFields;
+    p1Bytes: Array<number>;
+    p2Bytes: Array<number>;
+    p3Bytes: Array<number>;
+    p4Bytes: Array<number>;
+    cPrimeHashbuf: Array<number>;
+    m1: FieldElementZCFields;
+    m2: FieldElementZCFields;
+    txRemaining: number;
+    verified: boolean;
+    result: Array<number>;
+}
+interface VrfBuilderJSON {
+    producer: string;
+    status: VrfStatusJSON;
+    reprProof: Array<number>;
+    proof: EcvrfProofZCJSON;
+    yPoint: string;
+    stage: number;
+    stage1Out: EcvrfIntermediateJSON;
+    r1: EdwardsPointZCJSON;
+    r2: EdwardsPointZCJSON;
+    stage3Out: EcvrfIntermediateJSON;
+    hPoint: EdwardsPointZCJSON;
+    sReduced: ScalarJSON;
+    yPointBuilder: Array<FieldElementZCJSON>;
+    yRistrettoPoint: EdwardsPointZCJSON;
+    mulRound: number;
+    hashPointsRound: number;
+    mulTmp1: CompletedPointZCJSON;
+    uPoint1: EdwardsPointZCJSON;
+    uPoint2: EdwardsPointZCJSON;
+    vPoint1: EdwardsPointZCJSON;
+    vPoint2: EdwardsPointZCJSON;
+    uPoint: EdwardsPointZCJSON;
+    vPoint: EdwardsPointZCJSON;
+    u1: FieldElementZCJSON;
+    u2: FieldElementZCJSON;
+    invertee: FieldElementZCJSON;
+    y: FieldElementZCJSON;
+    z: FieldElementZCJSON;
+    p1Bytes: Array<number>;
+    p2Bytes: Array<number>;
+    p3Bytes: Array<number>;
+    p4Bytes: Array<number>;
+    cPrimeHashbuf: Array<number>;
+    m1: FieldElementZCJSON;
+    m2: FieldElementZCJSON;
+    txRemaining: number;
+    verified: boolean;
+    result: Array<number>;
+}
+declare class VrfBuilder {
+    readonly producer: Address;
+    readonly status: VrfStatusKind;
+    readonly reprProof: Array<number>;
+    readonly proof: EcvrfProofZC;
+    readonly yPoint: Address;
+    readonly stage: number;
+    readonly stage1Out: EcvrfIntermediate;
+    readonly r1: EdwardsPointZC;
+    readonly r2: EdwardsPointZC;
+    readonly stage3Out: EcvrfIntermediate;
+    readonly hPoint: EdwardsPointZC;
+    readonly sReduced: Scalar;
+    readonly yPointBuilder: Array<FieldElementZC>;
+    readonly yRistrettoPoint: EdwardsPointZC;
+    readonly mulRound: number;
+    readonly hashPointsRound: number;
+    readonly mulTmp1: CompletedPointZC;
+    readonly uPoint1: EdwardsPointZC;
+    readonly uPoint2: EdwardsPointZC;
+    readonly vPoint1: EdwardsPointZC;
+    readonly vPoint2: EdwardsPointZC;
+    readonly uPoint: EdwardsPointZC;
+    readonly vPoint: EdwardsPointZC;
+    readonly u1: FieldElementZC;
+    readonly u2: FieldElementZC;
+    readonly invertee: FieldElementZC;
+    readonly y: FieldElementZC;
+    readonly z: FieldElementZC;
+    readonly p1Bytes: Array<number>;
+    readonly p2Bytes: Array<number>;
+    readonly p3Bytes: Array<number>;
+    readonly p4Bytes: Array<number>;
+    readonly cPrimeHashbuf: Array<number>;
+    readonly m1: FieldElementZC;
+    readonly m2: FieldElementZC;
+    readonly txRemaining: number;
+    readonly verified: boolean;
+    readonly result: Array<number>;
+    constructor(fields: VrfBuilderFields);
+    static layout(property?: string): buffer_layout.Layout<unknown>;
+    static fromDecoded(obj: any): VrfBuilder;
+    static toEncodable(fields: VrfBuilderFields): {
+        producer: Address;
+        status: {
+            StatusNone: {};
+        } | {
+            StatusRequesting: {};
+        } | {
+            StatusVerifying: {};
+        } | {
+            StatusVerified: {};
+        } | {
+            StatusCallbackSuccess: {};
+        } | {
+            StatusVerifyFailure: {};
+        };
+        reprProof: number[];
+        proof: {
+            gamma: {
+                x: {
+                    bytes: BN[];
+                };
+                y: {
+                    bytes: BN[];
+                };
+                z: {
+                    bytes: BN[];
+                };
+                t: {
+                    bytes: BN[];
+                };
+            };
+            c: {
+                bytes: number[];
+            };
+            s: {
+                bytes: number[];
+            };
+        };
+        yPoint: Address;
+        stage: number;
+        stage1Out: {
+            r: {
+                bytes: BN[];
+            };
+            nS: {
+                bytes: BN[];
+            };
+            d: {
+                bytes: BN[];
+            };
+            t13: {
+                bytes: BN[];
+            };
+            t15: {
+                bytes: BN[];
+            };
+        };
+        r1: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        r2: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        stage3Out: {
+            r: {
+                bytes: BN[];
+            };
+            nS: {
+                bytes: BN[];
+            };
+            d: {
+                bytes: BN[];
+            };
+            t13: {
+                bytes: BN[];
+            };
+            t15: {
+                bytes: BN[];
+            };
+        };
+        hPoint: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        sReduced: {
+            bytes: number[];
+        };
+        yPointBuilder: {
+            bytes: BN[];
+        }[];
+        yRistrettoPoint: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        mulRound: number;
+        hashPointsRound: number;
+        mulTmp1: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        uPoint1: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        uPoint2: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        vPoint1: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        vPoint2: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        uPoint: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        vPoint: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        u1: {
+            bytes: BN[];
+        };
+        u2: {
+            bytes: BN[];
+        };
+        invertee: {
+            bytes: BN[];
+        };
+        y: {
+            bytes: BN[];
+        };
+        z: {
+            bytes: BN[];
+        };
+        p1Bytes: number[];
+        p2Bytes: number[];
+        p3Bytes: number[];
+        p4Bytes: number[];
+        cPrimeHashbuf: number[];
+        m1: {
+            bytes: BN[];
+        };
+        m2: {
+            bytes: BN[];
+        };
+        txRemaining: number;
+        verified: boolean;
+        result: number[];
+    };
+    toJSON(): VrfBuilderJSON;
+    static fromJSON(obj: VrfBuilderJSON): VrfBuilder;
+    toEncodable(): {
+        producer: Address;
+        status: {
+            StatusNone: {};
+        } | {
+            StatusRequesting: {};
+        } | {
+            StatusVerifying: {};
+        } | {
+            StatusVerified: {};
+        } | {
+            StatusCallbackSuccess: {};
+        } | {
+            StatusVerifyFailure: {};
+        };
+        reprProof: number[];
+        proof: {
+            gamma: {
+                x: {
+                    bytes: BN[];
+                };
+                y: {
+                    bytes: BN[];
+                };
+                z: {
+                    bytes: BN[];
+                };
+                t: {
+                    bytes: BN[];
+                };
+            };
+            c: {
+                bytes: number[];
+            };
+            s: {
+                bytes: number[];
+            };
+        };
+        yPoint: Address;
+        stage: number;
+        stage1Out: {
+            r: {
+                bytes: BN[];
+            };
+            nS: {
+                bytes: BN[];
+            };
+            d: {
+                bytes: BN[];
+            };
+            t13: {
+                bytes: BN[];
+            };
+            t15: {
+                bytes: BN[];
+            };
+        };
+        r1: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        r2: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        stage3Out: {
+            r: {
+                bytes: BN[];
+            };
+            nS: {
+                bytes: BN[];
+            };
+            d: {
+                bytes: BN[];
+            };
+            t13: {
+                bytes: BN[];
+            };
+            t15: {
+                bytes: BN[];
+            };
+        };
+        hPoint: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        sReduced: {
+            bytes: number[];
+        };
+        yPointBuilder: {
+            bytes: BN[];
+        }[];
+        yRistrettoPoint: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        mulRound: number;
+        hashPointsRound: number;
+        mulTmp1: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        uPoint1: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        uPoint2: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        vPoint1: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        vPoint2: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        uPoint: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        vPoint: {
+            x: {
+                bytes: BN[];
+            };
+            y: {
+                bytes: BN[];
+            };
+            z: {
+                bytes: BN[];
+            };
+            t: {
+                bytes: BN[];
+            };
+        };
+        u1: {
+            bytes: BN[];
+        };
+        u2: {
+            bytes: BN[];
+        };
+        invertee: {
+            bytes: BN[];
+        };
+        y: {
+            bytes: BN[];
+        };
+        z: {
+            bytes: BN[];
+        };
+        p1Bytes: number[];
+        p2Bytes: number[];
+        p3Bytes: number[];
+        p4Bytes: number[];
+        cPrimeHashbuf: number[];
+        m1: {
+            bytes: BN[];
+        };
+        m2: {
+            bytes: BN[];
+        };
+        txRemaining: number;
+        verified: boolean;
+        result: number[];
+    };
+}
+
+interface AccountMetaZCFields {
+    pubkey: Address;
+    isSigner: boolean;
+    isWritable: boolean;
+}
+interface AccountMetaZCJSON {
+    pubkey: string;
+    isSigner: boolean;
+    isWritable: boolean;
+}
+declare class AccountMetaZC {
+    readonly pubkey: Address;
+    readonly isSigner: boolean;
+    readonly isWritable: boolean;
+    constructor(fields: AccountMetaZCFields);
+    static layout(property?: string): buffer_layout.Layout<unknown>;
+    static fromDecoded(obj: any): AccountMetaZC;
+    static toEncodable(fields: AccountMetaZCFields): {
+        pubkey: Address;
+        isSigner: boolean;
+        isWritable: boolean;
+    };
+    toJSON(): AccountMetaZCJSON;
+    static fromJSON(obj: AccountMetaZCJSON): AccountMetaZC;
+    toEncodable(): {
+        pubkey: Address;
+        isSigner: boolean;
+        isWritable: boolean;
+    };
+}
+
+interface CallbackZCFields {
+    programId: Address;
+    accounts: Array<AccountMetaZCFields>;
+    accountsLen: number;
+    ixData: Array<number>;
+    ixDataLen: number;
+}
+interface CallbackZCJSON {
+    programId: string;
+    accounts: Array<AccountMetaZCJSON>;
+    accountsLen: number;
+    ixData: Array<number>;
+    ixDataLen: number;
+}
+declare class CallbackZC {
+    readonly programId: Address;
+    readonly accounts: Array<AccountMetaZC>;
+    readonly accountsLen: number;
+    readonly ixData: Array<number>;
+    readonly ixDataLen: number;
+    constructor(fields: CallbackZCFields);
+    static layout(property?: string): buffer_layout.Layout<unknown>;
+    static fromDecoded(obj: any): CallbackZC;
+    static toEncodable(fields: CallbackZCFields): {
+        programId: Address;
+        accounts: {
+            pubkey: Address;
+            isSigner: boolean;
+            isWritable: boolean;
+        }[];
+        accountsLen: number;
+        ixData: number[];
+        ixDataLen: number;
+    };
+    toJSON(): CallbackZCJSON;
+    static fromJSON(obj: CallbackZCJSON): CallbackZC;
+    toEncodable(): {
+        programId: Address;
+        accounts: {
+            pubkey: Address;
+            isSigner: boolean;
+            isWritable: boolean;
+        }[];
+        accountsLen: number;
+        ixData: number[];
+        ixDataLen: number;
+    };
+}
+
+interface VrfRoundFields {
+    alpha: Array<number>;
+    alphaLen: number;
+    requestSlot: BN;
+    requestTimestamp: BN;
+    result: Array<number>;
+    numVerified: number;
+    ebuf: Array<number>;
+}
+interface VrfRoundJSON {
+    alpha: Array<number>;
+    alphaLen: number;
+    requestSlot: string;
+    requestTimestamp: string;
+    result: Array<number>;
+    numVerified: number;
+    ebuf: Array<number>;
+}
+declare class VrfRound {
+    readonly alpha: Array<number>;
+    readonly alphaLen: number;
+    readonly requestSlot: BN;
+    readonly requestTimestamp: BN;
+    readonly result: Array<number>;
+    readonly numVerified: number;
+    readonly ebuf: Array<number>;
+    constructor(fields: VrfRoundFields);
+    static layout(property?: string): buffer_layout.Layout<unknown>;
+    static fromDecoded(obj: any): VrfRound;
+    static toEncodable(fields: VrfRoundFields): {
+        alpha: number[];
+        alphaLen: number;
+        requestSlot: BN;
+        requestTimestamp: BN;
+        result: number[];
+        numVerified: number;
+        ebuf: number[];
+    };
+    toJSON(): VrfRoundJSON;
+    static fromJSON(obj: VrfRoundJSON): VrfRound;
+    toEncodable(): {
+        alpha: number[];
+        alphaLen: number;
+        requestSlot: BN;
+        requestTimestamp: BN;
+        result: number[];
+        numVerified: number;
+        ebuf: number[];
+    };
+}
+
+interface BufferRelayerRoundFields {
+    numSuccess: number;
+    numError: number;
+    roundOpenSlot: BN;
+    roundOpenTimestamp: BN;
+    oraclePubkey: Address;
+}
+interface BufferRelayerRoundJSON {
+    numSuccess: number;
+    numError: number;
+    roundOpenSlot: string;
+    roundOpenTimestamp: string;
+    oraclePubkey: string;
+}
+declare class BufferRelayerRound {
+    readonly numSuccess: number;
+    readonly numError: number;
+    readonly roundOpenSlot: BN;
+    readonly roundOpenTimestamp: BN;
+    readonly oraclePubkey: Address;
+    constructor(fields: BufferRelayerRoundFields);
+    static layout(property?: string): buffer_layout.Layout<unknown>;
+    static fromDecoded(obj: any): BufferRelayerRound;
+    static toEncodable(fields: BufferRelayerRoundFields): {
+        numSuccess: number;
+        numError: number;
+        roundOpenSlot: BN;
+        roundOpenTimestamp: BN;
+        oraclePubkey: Address;
+    };
+    toJSON(): BufferRelayerRoundJSON;
+    static fromJSON(obj: BufferRelayerRoundJSON): BufferRelayerRound;
+    toEncodable(): {
+        numSuccess: number;
+        numError: number;
+        roundOpenSlot: BN;
+        roundOpenTimestamp: BN;
+        oraclePubkey: Address;
+    };
+}
+
+type AggregatorResolutionModeKind = ModeRoundResolution | ModeSlidingResolution;
+type AggregatorResolutionModeJSON = ModeRoundResolutionJSON | ModeSlidingResolutionJSON;
+
+type VrfStatusKind = StatusNone | StatusRequesting | StatusVerifying | StatusVerified | StatusCallbackSuccess | StatusVerifyFailure;
+type VrfStatusJSON = StatusNoneJSON | StatusRequestingJSON | StatusVerifyingJSON | StatusVerifiedJSON | StatusCallbackSuccessJSON | StatusVerifyFailureJSON;
+
+interface AggregatorAccountDataFields {
+    name: Array<number>;
+    metadata: Array<number>;
+    reserved1: Array<number>;
+    queuePubkey: Address;
+    oracleRequestBatchSize: number;
+    minOracleResults: number;
+    minJobResults: number;
+    minUpdateDelaySeconds: number;
+    startAfter: BN;
+    varianceThreshold: SwitchboardDecimalFields;
+    forceReportPeriod: BN;
+    expiration: BN;
+    consecutiveFailureCount: BN;
+    nextAllowedUpdateTime: BN;
+    isLocked: boolean;
+    crankPubkey: Address;
+    latestConfirmedRound: AggregatorRoundFields;
+    currentRound: AggregatorRoundFields;
+    jobPubkeysData: Array<Address>;
+    jobHashes: Array<HashFields>;
+    jobPubkeysSize: number;
+    jobsChecksum: Array<number>;
+    authority: Address;
+    historyBuffer: Address;
+    previousConfirmedRoundResult: SwitchboardDecimalFields;
+    previousConfirmedRoundSlot: BN;
+    disableCrank: boolean;
+    jobWeights: Array<number>;
+    creationTimestamp: BN;
+    resolutionMode: AggregatorResolutionModeKind;
+    basePriorityFee: number;
+    priorityFeeBump: number;
+    priorityFeeBumpPeriod: number;
+    maxPriorityFeeMultiplier: number;
+    ebuf: Array<number>;
+}
+interface AggregatorAccountDataJSON {
+    name: Array<number>;
+    metadata: Array<number>;
+    reserved1: Array<number>;
+    queuePubkey: string;
+    oracleRequestBatchSize: number;
+    minOracleResults: number;
+    minJobResults: number;
+    minUpdateDelaySeconds: number;
+    startAfter: string;
+    varianceThreshold: SwitchboardDecimalJSON;
+    forceReportPeriod: string;
+    expiration: string;
+    consecutiveFailureCount: string;
+    nextAllowedUpdateTime: string;
+    isLocked: boolean;
+    crankPubkey: string;
+    latestConfirmedRound: AggregatorRoundJSON;
+    currentRound: AggregatorRoundJSON;
+    jobPubkeysData: Array<string>;
+    jobHashes: Array<HashJSON>;
+    jobPubkeysSize: number;
+    jobsChecksum: Array<number>;
+    authority: string;
+    historyBuffer: string;
+    previousConfirmedRoundResult: SwitchboardDecimalJSON;
+    previousConfirmedRoundSlot: string;
+    disableCrank: boolean;
+    jobWeights: Array<number>;
+    creationTimestamp: string;
+    resolutionMode: AggregatorResolutionModeJSON;
+    basePriorityFee: number;
+    priorityFeeBump: number;
+    priorityFeeBumpPeriod: number;
+    maxPriorityFeeMultiplier: number;
+    ebuf: Array<number>;
+}
+declare class AggregatorAccountData {
+    readonly name: Array<number>;
+    readonly metadata: Array<number>;
+    readonly reserved1: Array<number>;
+    readonly queuePubkey: Address;
+    readonly oracleRequestBatchSize: number;
+    readonly minOracleResults: number;
+    readonly minJobResults: number;
+    readonly minUpdateDelaySeconds: number;
+    readonly startAfter: BN;
+    readonly varianceThreshold: SwitchboardDecimal;
+    readonly forceReportPeriod: BN;
+    readonly expiration: BN;
+    readonly consecutiveFailureCount: BN;
+    readonly nextAllowedUpdateTime: BN;
+    readonly isLocked: boolean;
+    readonly crankPubkey: Address;
+    readonly latestConfirmedRound: AggregatorRound;
+    readonly currentRound: AggregatorRound;
+    readonly jobPubkeysData: Array<Address>;
+    readonly jobHashes: Array<Hash>;
+    readonly jobPubkeysSize: number;
+    readonly jobsChecksum: Array<number>;
+    readonly authority: Address;
+    readonly historyBuffer: Address;
+    readonly previousConfirmedRoundResult: SwitchboardDecimal;
+    readonly previousConfirmedRoundSlot: BN;
+    readonly disableCrank: boolean;
+    readonly jobWeights: Array<number>;
+    readonly creationTimestamp: BN;
+    readonly resolutionMode: AggregatorResolutionModeKind;
+    readonly basePriorityFee: number;
+    readonly priorityFeeBump: number;
+    readonly priorityFeeBumpPeriod: number;
+    readonly maxPriorityFeeMultiplier: number;
+    readonly ebuf: Array<number>;
+    static readonly discriminator: Buffer<ArrayBuffer>;
+    static readonly layout: buffer_layout.Layout<AggregatorAccountData>;
+    constructor(fields: AggregatorAccountDataFields);
+    static fetch(rpc: Rpc<GetAccountInfoApi>, address: Address, programId?: Address): Promise<AggregatorAccountData | null>;
+    static fetchMultiple(rpc: Rpc<GetMultipleAccountsApi>, addresses: Address[], programId?: Address): Promise<Array<AggregatorAccountData | null>>;
+    static decode(data: Buffer): AggregatorAccountData;
+    toJSON(): AggregatorAccountDataJSON;
+    static fromJSON(obj: AggregatorAccountDataJSON): AggregatorAccountData;
+}
+
+declare function getLatestAggregatorValue(aggregator: AggregatorAccountData, maxStaleness?: number): Decimal | null;
+
+interface SbStateFields {
+    authority: Address;
+    tokenMint: Address;
+    tokenVault: Address;
+    daoMint: Address;
+    ebuf: Array<number>;
+}
+interface SbStateJSON {
+    authority: string;
+    tokenMint: string;
+    tokenVault: string;
+    daoMint: string;
+    ebuf: Array<number>;
+}
+declare class SbState {
+    readonly authority: Address;
+    readonly tokenMint: Address;
+    readonly tokenVault: Address;
+    readonly daoMint: Address;
+    readonly ebuf: Array<number>;
+    static readonly discriminator: Buffer<ArrayBuffer>;
+    static readonly layout: buffer_layout.Layout<SbState>;
+    constructor(fields: SbStateFields);
+    static fetch(rpc: Rpc<GetAccountInfoApi>, address: Address, programId?: Address): Promise<SbState | null>;
+    static fetchMultiple(rpc: Rpc<GetMultipleAccountsApi>, addresses: Address[], programId?: Address): Promise<Array<SbState | null>>;
+    static decode(data: Buffer): SbState;
+    toJSON(): SbStateJSON;
+    static fromJSON(obj: SbStateJSON): SbState;
+}
+
+interface TaskSpecRecordFields {
+    hash: HashFields;
+}
+interface TaskSpecRecordJSON {
+    hash: HashJSON;
+}
+declare class TaskSpecRecord {
+    readonly hash: Hash;
+    static readonly discriminator: Buffer<ArrayBuffer>;
+    static readonly layout: buffer_layout.Layout<TaskSpecRecord>;
+    constructor(fields: TaskSpecRecordFields);
+    static fetch(rpc: Rpc<GetAccountInfoApi>, address: Address, programId?: Address): Promise<TaskSpecRecord | null>;
+    static fetchMultiple(rpc: Rpc<GetMultipleAccountsApi>, addresses: Address[], programId?: Address): Promise<Array<TaskSpecRecord | null>>;
+    static decode(data: Buffer): TaskSpecRecord;
+    toJSON(): TaskSpecRecordJSON;
+    static fromJSON(obj: TaskSpecRecordJSON): TaskSpecRecord;
+}
+
+interface SlidingResultAccountDataFields {
+    data: Array<SlidingWindowElementFields>;
+    bump: number;
+    ebuf: Array<number>;
+}
+interface SlidingResultAccountDataJSON {
+    data: Array<SlidingWindowElementJSON>;
+    bump: number;
+    ebuf: Array<number>;
+}
+declare class SlidingResultAccountData {
+    readonly data: Array<SlidingWindowElement>;
+    readonly bump: number;
+    readonly ebuf: Array<number>;
+    static readonly discriminator: Buffer<ArrayBuffer>;
+    static readonly layout: buffer_layout.Layout<SlidingResultAccountData>;
+    constructor(fields: SlidingResultAccountDataFields);
+    static fetch(rpc: Rpc<GetAccountInfoApi>, address: Address, programId?: Address): Promise<SlidingResultAccountData | null>;
+    static fetchMultiple(rpc: Rpc<GetMultipleAccountsApi>, addresses: Address[], programId?: Address): Promise<Array<SlidingResultAccountData | null>>;
+    static decode(data: Buffer): SlidingResultAccountData;
+    toJSON(): SlidingResultAccountDataJSON;
+    static fromJSON(obj: SlidingResultAccountDataJSON): SlidingResultAccountData;
+}
+
+interface PermissionAccountDataFields {
+    authority: Address;
+    permissions: number;
+    granter: Address;
+    grantee: Address;
+    expiration: BN;
+    ebuf: Array<number>;
+}
+interface PermissionAccountDataJSON {
+    authority: string;
+    permissions: number;
+    granter: string;
+    grantee: string;
+    expiration: string;
+    ebuf: Array<number>;
+}
+declare class PermissionAccountData {
+    readonly authority: Address;
+    readonly permissions: number;
+    readonly granter: Address;
+    readonly grantee: Address;
+    readonly expiration: BN;
+    readonly ebuf: Array<number>;
+    static readonly discriminator: Buffer<ArrayBuffer>;
+    static readonly layout: buffer_layout.Layout<PermissionAccountData>;
+    constructor(fields: PermissionAccountDataFields);
+    static fetch(rpc: Rpc<GetAccountInfoApi>, address: Address, programId?: Address): Promise<PermissionAccountData | null>;
+    static fetchMultiple(rpc: Rpc<GetMultipleAccountsApi>, addresses: Address[], programId?: Address): Promise<Array<PermissionAccountData | null>>;
+    static decode(data: Buffer): PermissionAccountData;
+    toJSON(): PermissionAccountDataJSON;
+    static fromJSON(obj: PermissionAccountDataJSON): PermissionAccountData;
+}
+
+interface RealmSpawnRecordAccountDataFields {
+    ebuf: Array<number>;
+}
+interface RealmSpawnRecordAccountDataJSON {
+    ebuf: Array<number>;
+}
+declare class RealmSpawnRecordAccountData {
+    readonly ebuf: Array<number>;
+    static readonly discriminator: Buffer<ArrayBuffer>;
+    static readonly layout: buffer_layout.Layout<RealmSpawnRecordAccountData>;
+    constructor(fields: RealmSpawnRecordAccountDataFields);
+    static fetch(rpc: Rpc<GetAccountInfoApi>, address: Address, programId?: Address): Promise<RealmSpawnRecordAccountData | null>;
+    static fetchMultiple(rpc: Rpc<GetMultipleAccountsApi>, addresses: Address[], programId?: Address): Promise<Array<RealmSpawnRecordAccountData | null>>;
+    static decode(data: Buffer): RealmSpawnRecordAccountData;
+    toJSON(): RealmSpawnRecordAccountDataJSON;
+    static fromJSON(obj: RealmSpawnRecordAccountDataJSON): RealmSpawnRecordAccountData;
+}
+
+interface LeaseAccountDataFields {
+    escrow: Address;
+    queue: Address;
+    aggregator: Address;
+    tokenProgram: Address;
+    isActive: boolean;
+    crankRowCount: number;
+    createdAt: BN;
+    updateCount: BN;
+    withdrawAuthority: Address;
+    ebuf: Array<number>;
+}
+interface LeaseAccountDataJSON {
+    escrow: string;
+    queue: string;
+    aggregator: string;
+    tokenProgram: string;
+    isActive: boolean;
+    crankRowCount: number;
+    createdAt: string;
+    updateCount: string;
+    withdrawAuthority: string;
+    ebuf: Array<number>;
+}
+declare class LeaseAccountData {
+    readonly escrow: Address;
+    readonly queue: Address;
+    readonly aggregator: Address;
+    readonly tokenProgram: Address;
+    readonly isActive: boolean;
+    readonly crankRowCount: number;
+    readonly createdAt: BN;
+    readonly updateCount: BN;
+    readonly withdrawAuthority: Address;
+    readonly ebuf: Array<number>;
+    static readonly discriminator: Buffer<ArrayBuffer>;
+    static readonly layout: buffer_layout.Layout<LeaseAccountData>;
+    constructor(fields: LeaseAccountDataFields);
+    static fetch(rpc: Rpc<GetAccountInfoApi>, address: Address, programId?: Address): Promise<LeaseAccountData | null>;
+    static fetchMultiple(rpc: Rpc<GetMultipleAccountsApi>, addresses: Address[], programId?: Address): Promise<Array<LeaseAccountData | null>>;
+    static decode(data: Buffer): LeaseAccountData;
+    toJSON(): LeaseAccountDataJSON;
+    static fromJSON(obj: LeaseAccountDataJSON): LeaseAccountData;
+}
+
+interface OracleQueueAccountDataFields {
+    name: Array<number>;
+    metadata: Array<number>;
+    authority: Address;
+    oracleTimeout: number;
+    reward: BN;
+    minStake: BN;
+    slashingEnabled: boolean;
+    varianceToleranceMultiplier: SwitchboardDecimalFields;
+    feedProbationPeriod: number;
+    currIdx: number;
+    size: number;
+    gcIdx: number;
+    consecutiveFeedFailureLimit: BN;
+    consecutiveOracleFailureLimit: BN;
+    unpermissionedFeedsEnabled: boolean;
+    unpermissionedVrfEnabled: boolean;
+    curatorRewardCut: SwitchboardDecimalFields;
+    lockLeaseFunding: boolean;
+    mint: Address;
+    enableBufferRelayers: boolean;
+    ebuf: Array<number>;
+    maxSize: number;
+    dataBuffer: Address;
+}
+interface OracleQueueAccountDataJSON {
+    name: Array<number>;
+    metadata: Array<number>;
+    authority: string;
+    oracleTimeout: number;
+    reward: string;
+    minStake: string;
+    slashingEnabled: boolean;
+    varianceToleranceMultiplier: SwitchboardDecimalJSON;
+    feedProbationPeriod: number;
+    currIdx: number;
+    size: number;
+    gcIdx: number;
+    consecutiveFeedFailureLimit: string;
+    consecutiveOracleFailureLimit: string;
+    unpermissionedFeedsEnabled: boolean;
+    unpermissionedVrfEnabled: boolean;
+    curatorRewardCut: SwitchboardDecimalJSON;
+    lockLeaseFunding: boolean;
+    mint: string;
+    enableBufferRelayers: boolean;
+    ebuf: Array<number>;
+    maxSize: number;
+    dataBuffer: string;
+}
+declare class OracleQueueAccountData {
+    readonly name: Array<number>;
+    readonly metadata: Array<number>;
+    readonly authority: Address;
+    readonly oracleTimeout: number;
+    readonly reward: BN;
+    readonly minStake: BN;
+    readonly slashingEnabled: boolean;
+    readonly varianceToleranceMultiplier: SwitchboardDecimal;
+    readonly feedProbationPeriod: number;
+    readonly currIdx: number;
+    readonly size: number;
+    readonly gcIdx: number;
+    readonly consecutiveFeedFailureLimit: BN;
+    readonly consecutiveOracleFailureLimit: BN;
+    readonly unpermissionedFeedsEnabled: boolean;
+    readonly unpermissionedVrfEnabled: boolean;
+    readonly curatorRewardCut: SwitchboardDecimal;
+    readonly lockLeaseFunding: boolean;
+    readonly mint: Address;
+    readonly enableBufferRelayers: boolean;
+    readonly ebuf: Array<number>;
+    readonly maxSize: number;
+    readonly dataBuffer: Address;
+    static readonly discriminator: Buffer<ArrayBuffer>;
+    static readonly layout: buffer_layout.Layout<OracleQueueAccountData>;
+    constructor(fields: OracleQueueAccountDataFields);
+    static fetch(rpc: Rpc<GetAccountInfoApi>, address: Address, programId?: Address): Promise<OracleQueueAccountData | null>;
+    static fetchMultiple(rpc: Rpc<GetMultipleAccountsApi>, addresses: Address[], programId?: Address): Promise<Array<OracleQueueAccountData | null>>;
+    static decode(data: Buffer): OracleQueueAccountData;
+    toJSON(): OracleQueueAccountDataJSON;
+    static fromJSON(obj: OracleQueueAccountDataJSON): OracleQueueAccountData;
+}
+
+interface CrankAccountDataFields {
+    name: Array<number>;
+    metadata: Array<number>;
+    queuePubkey: Address;
+    pqSize: number;
+    maxRows: number;
+    jitterModifier: number;
+    ebuf: Array<number>;
+    dataBuffer: Address;
+}
+interface CrankAccountDataJSON {
+    name: Array<number>;
+    metadata: Array<number>;
+    queuePubkey: string;
+    pqSize: number;
+    maxRows: number;
+    jitterModifier: number;
+    ebuf: Array<number>;
+    dataBuffer: string;
+}
+declare class CrankAccountData {
+    readonly name: Array<number>;
+    readonly metadata: Array<number>;
+    readonly queuePubkey: Address;
+    readonly pqSize: number;
+    readonly maxRows: number;
+    readonly jitterModifier: number;
+    readonly ebuf: Array<number>;
+    readonly dataBuffer: Address;
+    static readonly discriminator: Buffer<ArrayBuffer>;
+    static readonly layout: buffer_layout.Layout<CrankAccountData>;
+    constructor(fields: CrankAccountDataFields);
+    static fetch(rpc: Rpc<GetAccountInfoApi>, address: Address, programId?: Address): Promise<CrankAccountData | null>;
+    static fetchMultiple(rpc: Rpc<GetMultipleAccountsApi>, addresses: Address[], programId?: Address): Promise<Array<CrankAccountData | null>>;
+    static decode(data: Buffer): CrankAccountData;
+    toJSON(): CrankAccountDataJSON;
+    static fromJSON(obj: CrankAccountDataJSON): CrankAccountData;
+}
+
+interface OracleAccountDataFields {
+    name: Array<number>;
+    metadata: Array<number>;
+    oracleAuthority: Address;
+    lastHeartbeat: BN;
+    numInUse: number;
+    tokenAccount: Address;
+    queuePubkey: Address;
+    metrics: OracleMetricsFields;
+    ebuf: Array<number>;
+}
+interface OracleAccountDataJSON {
+    name: Array<number>;
+    metadata: Array<number>;
+    oracleAuthority: string;
+    lastHeartbeat: string;
+    numInUse: number;
+    tokenAccount: string;
+    queuePubkey: string;
+    metrics: OracleMetricsJSON;
+    ebuf: Array<number>;
+}
+declare class OracleAccountData {
+    readonly name: Array<number>;
+    readonly metadata: Array<number>;
+    readonly oracleAuthority: Address;
+    readonly lastHeartbeat: BN;
+    readonly numInUse: number;
+    readonly tokenAccount: Address;
+    readonly queuePubkey: Address;
+    readonly metrics: OracleMetrics;
+    readonly ebuf: Array<number>;
+    static readonly discriminator: Buffer<ArrayBuffer>;
+    static readonly layout: buffer_layout.Layout<OracleAccountData>;
+    constructor(fields: OracleAccountDataFields);
+    static fetch(rpc: Rpc<GetAccountInfoApi>, address: Address, programId?: Address): Promise<OracleAccountData | null>;
+    static fetchMultiple(rpc: Rpc<GetMultipleAccountsApi>, addresses: Address[], programId?: Address): Promise<Array<OracleAccountData | null>>;
+    static decode(data: Buffer): OracleAccountData;
+    toJSON(): OracleAccountDataJSON;
+    static fromJSON(obj: OracleAccountDataJSON): OracleAccountData;
+}
+
+interface JobAccountDataFields {
+    name: Array<number>;
+    metadata: Array<number>;
+    authority: Address;
+    expiration: BN;
+    hash: Array<number>;
+    data: Uint8Array;
+    referenceCount: number;
+    totalSpent: BN;
+    createdAt: BN;
+    isInitializing: number;
+}
+interface JobAccountDataJSON {
+    name: Array<number>;
+    metadata: Array<number>;
+    authority: string;
+    expiration: string;
+    hash: Array<number>;
+    data: Array<number>;
+    referenceCount: number;
+    totalSpent: string;
+    createdAt: string;
+    isInitializing: number;
+}
+declare class JobAccountData {
+    readonly name: Array<number>;
+    readonly metadata: Array<number>;
+    readonly authority: Address;
+    readonly expiration: BN;
+    readonly hash: Array<number>;
+    readonly data: Uint8Array;
+    readonly referenceCount: number;
+    readonly totalSpent: BN;
+    readonly createdAt: BN;
+    readonly isInitializing: number;
+    static readonly discriminator: Buffer<ArrayBuffer>;
+    static readonly layout: buffer_layout.Layout<JobAccountData>;
+    constructor(fields: JobAccountDataFields);
+    static fetch(rpc: Rpc<GetAccountInfoApi>, address: Address, programId?: Address): Promise<JobAccountData | null>;
+    static fetchMultiple(rpc: Rpc<GetMultipleAccountsApi>, addresses: Address[], programId?: Address): Promise<Array<JobAccountData | null>>;
+    static decode(data: Buffer): JobAccountData;
+    toJSON(): JobAccountDataJSON;
+    static fromJSON(obj: JobAccountDataJSON): JobAccountData;
+}
+
+interface VrfAccountDataFields {
+    status: VrfStatusKind;
+    counter: BN;
+    authority: Address;
+    oracleQueue: Address;
+    escrow: Address;
+    callback: CallbackZCFields;
+    batchSize: number;
+    builders: Array<VrfBuilderFields>;
+    buildersLen: number;
+    testMode: boolean;
+    currentRound: VrfRoundFields;
+    ebuf: Array<number>;
+}
+interface VrfAccountDataJSON {
+    status: VrfStatusJSON;
+    counter: string;
+    authority: string;
+    oracleQueue: string;
+    escrow: string;
+    callback: CallbackZCJSON;
+    batchSize: number;
+    builders: Array<VrfBuilderJSON>;
+    buildersLen: number;
+    testMode: boolean;
+    currentRound: VrfRoundJSON;
+    ebuf: Array<number>;
+}
+declare class VrfAccountData {
+    readonly status: VrfStatusKind;
+    readonly counter: BN;
+    readonly authority: Address;
+    readonly oracleQueue: Address;
+    readonly escrow: Address;
+    readonly callback: CallbackZC;
+    readonly batchSize: number;
+    readonly builders: Array<VrfBuilder>;
+    readonly buildersLen: number;
+    readonly testMode: boolean;
+    readonly currentRound: VrfRound;
+    readonly ebuf: Array<number>;
+    static readonly discriminator: Buffer<ArrayBuffer>;
+    static readonly layout: buffer_layout.Layout<VrfAccountData>;
+    constructor(fields: VrfAccountDataFields);
+    static fetch(rpc: Rpc<GetAccountInfoApi>, address: Address, programId?: Address): Promise<VrfAccountData | null>;
+    static fetchMultiple(rpc: Rpc<GetMultipleAccountsApi>, addresses: Address[], programId?: Address): Promise<Array<VrfAccountData | null>>;
+    static decode(data: Buffer): VrfAccountData;
+    toJSON(): VrfAccountDataJSON;
+    static fromJSON(obj: VrfAccountDataJSON): VrfAccountData;
+}
+
+interface VrfLiteAccountDataFields {
+    stateBump: number;
+    permissionBump: number;
+    vrfPool: Address;
+    status: VrfStatusKind;
+    result: Array<number>;
+    counter: BN;
+    alpha: Array<number>;
+    alphaLen: number;
+    requestSlot: BN;
+    requestTimestamp: BN;
+    authority: Address;
+    queue: Address;
+    escrow: Address;
+    callback: CallbackZCFields;
+    builder: VrfBuilderFields;
+    expiration: BN;
+    ebuf: Array<number>;
+}
+interface VrfLiteAccountDataJSON {
+    stateBump: number;
+    permissionBump: number;
+    vrfPool: string;
+    status: VrfStatusJSON;
+    result: Array<number>;
+    counter: string;
+    alpha: Array<number>;
+    alphaLen: number;
+    requestSlot: string;
+    requestTimestamp: string;
+    authority: string;
+    queue: string;
+    escrow: string;
+    callback: CallbackZCJSON;
+    builder: VrfBuilderJSON;
+    expiration: string;
+    ebuf: Array<number>;
+}
+declare class VrfLiteAccountData {
+    readonly stateBump: number;
+    readonly permissionBump: number;
+    readonly vrfPool: Address;
+    readonly status: VrfStatusKind;
+    readonly result: Array<number>;
+    readonly counter: BN;
+    readonly alpha: Array<number>;
+    readonly alphaLen: number;
+    readonly requestSlot: BN;
+    readonly requestTimestamp: BN;
+    readonly authority: Address;
+    readonly queue: Address;
+    readonly escrow: Address;
+    readonly callback: CallbackZC;
+    readonly builder: VrfBuilder;
+    readonly expiration: BN;
+    readonly ebuf: Array<number>;
+    static readonly discriminator: Buffer<ArrayBuffer>;
+    static readonly layout: buffer_layout.Layout<VrfLiteAccountData>;
+    constructor(fields: VrfLiteAccountDataFields);
+    static fetch(rpc: Rpc<GetAccountInfoApi>, address: Address, programId?: Address): Promise<VrfLiteAccountData | null>;
+    static fetchMultiple(rpc: Rpc<GetMultipleAccountsApi>, addresses: Address[], programId?: Address): Promise<Array<VrfLiteAccountData | null>>;
+    static decode(data: Buffer): VrfLiteAccountData;
+    toJSON(): VrfLiteAccountDataJSON;
+    static fromJSON(obj: VrfLiteAccountDataJSON): VrfLiteAccountData;
+}
+
+interface VrfPoolAccountDataFields {
+    authority: Address;
+    queue: Address;
+    escrow: Address;
+    minInterval: number;
+    maxRows: number;
+    size: number;
+    idx: number;
+    stateBump: number;
+    ebuf: Array<number>;
+}
+interface VrfPoolAccountDataJSON {
+    authority: string;
+    queue: string;
+    escrow: string;
+    minInterval: number;
+    maxRows: number;
+    size: number;
+    idx: number;
+    stateBump: number;
+    ebuf: Array<number>;
+}
+declare class VrfPoolAccountData {
+    readonly authority: Address;
+    readonly queue: Address;
+    readonly escrow: Address;
+    readonly minInterval: number;
+    readonly maxRows: number;
+    readonly size: number;
+    readonly idx: number;
+    readonly stateBump: number;
+    readonly ebuf: Array<number>;
+    static readonly discriminator: Buffer<ArrayBuffer>;
+    static readonly layout: buffer_layout.Layout<VrfPoolAccountData>;
+    constructor(fields: VrfPoolAccountDataFields);
+    static fetch(rpc: Rpc<GetAccountInfoApi>, address: Address, programId?: Address): Promise<VrfPoolAccountData | null>;
+    static fetchMultiple(rpc: Rpc<GetMultipleAccountsApi>, addresses: Address[], programId?: Address): Promise<Array<VrfPoolAccountData | null>>;
+    static decode(data: Buffer): VrfPoolAccountData;
+    toJSON(): VrfPoolAccountDataJSON;
+    static fromJSON(obj: VrfPoolAccountDataJSON): VrfPoolAccountData;
+}
+
+interface BufferRelayerAccountDataFields {
+    name: Array<number>;
+    queuePubkey: Address;
+    escrow: Address;
+    authority: Address;
+    jobPubkey: Address;
+    jobHash: Array<number>;
+    minUpdateDelaySeconds: number;
+    isLocked: boolean;
+    currentRound: BufferRelayerRoundFields;
+    latestConfirmedRound: BufferRelayerRoundFields;
+    result: Uint8Array;
+}
+interface BufferRelayerAccountDataJSON {
+    name: Array<number>;
+    queuePubkey: string;
+    escrow: string;
+    authority: string;
+    jobPubkey: string;
+    jobHash: Array<number>;
+    minUpdateDelaySeconds: number;
+    isLocked: boolean;
+    currentRound: BufferRelayerRoundJSON;
+    latestConfirmedRound: BufferRelayerRoundJSON;
+    result: Array<number>;
+}
+declare class BufferRelayerAccountData {
+    readonly name: Array<number>;
+    readonly queuePubkey: Address;
+    readonly escrow: Address;
+    readonly authority: Address;
+    readonly jobPubkey: Address;
+    readonly jobHash: Array<number>;
+    readonly minUpdateDelaySeconds: number;
+    readonly isLocked: boolean;
+    readonly currentRound: BufferRelayerRound;
+    readonly latestConfirmedRound: BufferRelayerRound;
+    readonly result: Uint8Array;
+    static readonly discriminator: Buffer<ArrayBuffer>;
+    static readonly layout: buffer_layout.Layout<BufferRelayerAccountData>;
+    constructor(fields: BufferRelayerAccountDataFields);
+    static fetch(rpc: Rpc<GetAccountInfoApi>, address: Address, programId?: Address): Promise<BufferRelayerAccountData | null>;
+    static fetchMultiple(rpc: Rpc<GetMultipleAccountsApi>, addresses: Address[], programId?: Address): Promise<Array<BufferRelayerAccountData | null>>;
+    static decode(data: Buffer): BufferRelayerAccountData;
+    toJSON(): BufferRelayerAccountDataJSON;
+    static fromJSON(obj: BufferRelayerAccountDataJSON): BufferRelayerAccountData;
+}
+
+type PartialFields = {
+    numSignatures: number;
+};
+type PartialValue = {
+    numSignatures: number;
+};
+interface PartialJSON {
+    kind: "Partial";
+    value: {
+        numSignatures: number;
+    };
+}
+declare class Partial {
+    static readonly discriminator = 0;
+    static readonly kind = "Partial";
+    readonly discriminator = 0;
+    readonly kind = "Partial";
+    readonly value: PartialValue;
+    constructor(value: PartialFields);
+    toJSON(): PartialJSON;
+    toEncodable(): {
+        Partial: {
+            numSignatures: number;
+        };
+    };
+}
+interface FullJSON {
+    kind: "Full";
+}
+declare class Full {
+    static readonly discriminator = 1;
+    static readonly kind = "Full";
+    readonly discriminator = 1;
+    readonly kind = "Full";
+    toJSON(): FullJSON;
+    toEncodable(): {
+        Full: {};
+    };
+}
+
+interface PriceFeedMessageFields {
+    feedId: Array<number>;
+    price: BN;
+    conf: BN;
+    exponent: number;
+    publishTime: BN;
+    prevPublishTime: BN;
+    emaPrice: BN;
+    emaConf: BN;
+}
+interface PriceFeedMessageJSON {
+    feedId: Array<number>;
+    price: string;
+    conf: string;
+    exponent: number;
+    publishTime: string;
+    prevPublishTime: string;
+    emaPrice: string;
+    emaConf: string;
+}
+declare class PriceFeedMessage {
+    readonly feedId: Array<number>;
+    readonly price: BN;
+    readonly conf: BN;
+    readonly exponent: number;
+    readonly publishTime: BN;
+    readonly prevPublishTime: BN;
+    readonly emaPrice: BN;
+    readonly emaConf: BN;
+    constructor(fields: PriceFeedMessageFields);
+    static layout(property?: string): buffer_layout.Layout<unknown>;
+    static fromDecoded(obj: any): PriceFeedMessage;
+    static toEncodable(fields: PriceFeedMessageFields): {
+        feedId: number[];
+        price: BN;
+        conf: BN;
+        exponent: number;
+        publishTime: BN;
+        prevPublishTime: BN;
+        emaPrice: BN;
+        emaConf: BN;
+    };
+    toJSON(): PriceFeedMessageJSON;
+    static fromJSON(obj: PriceFeedMessageJSON): PriceFeedMessage;
+    toEncodable(): {
+        feedId: number[];
+        price: BN;
+        conf: BN;
+        exponent: number;
+        publishTime: BN;
+        prevPublishTime: BN;
+        emaPrice: BN;
+        emaConf: BN;
+    };
+}
+
+interface TwapPriceFields {
+    feedId: Array<number>;
+    startTime: BN;
+    endTime: BN;
+    price: BN;
+    conf: BN;
+    exponent: number;
+    /**
+     * Ratio out of 1_000_000, where a value of 1_000_000 represents
+     * all slots were missed and 0 represents no slots were missed.
+     */
+    downSlotsRatio: number;
+}
+interface TwapPriceJSON {
+    feedId: Array<number>;
+    startTime: string;
+    endTime: string;
+    price: string;
+    conf: string;
+    exponent: number;
+    /**
+     * Ratio out of 1_000_000, where a value of 1_000_000 represents
+     * all slots were missed and 0 represents no slots were missed.
+     */
+    downSlotsRatio: number;
+}
+/**
+ * The time weighted average price & conf for a feed over the window [start_time, end_time].
+ * This type is used to persist the calculated TWAP in TwapUpdate accounts on Solana.
+ */
+declare class TwapPrice {
+    readonly feedId: Array<number>;
+    readonly startTime: BN;
+    readonly endTime: BN;
+    readonly price: BN;
+    readonly conf: BN;
+    readonly exponent: number;
+    /**
+     * Ratio out of 1_000_000, where a value of 1_000_000 represents
+     * all slots were missed and 0 represents no slots were missed.
+     */
+    readonly downSlotsRatio: number;
+    constructor(fields: TwapPriceFields);
+    static layout(property?: string): buffer_layout.Layout<unknown>;
+    static fromDecoded(obj: any): TwapPrice;
+    static toEncodable(fields: TwapPriceFields): {
+        feedId: number[];
+        startTime: BN;
+        endTime: BN;
+        price: BN;
+        conf: BN;
+        exponent: number;
+        downSlotsRatio: number;
+    };
+    toJSON(): TwapPriceJSON;
+    static fromJSON(obj: TwapPriceJSON): TwapPrice;
+    toEncodable(): {
+        feedId: number[];
+        startTime: BN;
+        endTime: BN;
+        price: BN;
+        conf: BN;
+        exponent: number;
+        downSlotsRatio: number;
+    };
+}
+
+interface DataSourceFields {
+    chain: number;
+    emitter: Address;
+}
+interface DataSourceJSON {
+    chain: number;
+    emitter: string;
+}
+declare class DataSource {
+    readonly chain: number;
+    readonly emitter: Address;
+    constructor(fields: DataSourceFields);
+    static layout(property?: string): buffer_layout.Layout<unknown>;
+    static fromDecoded(obj: any): DataSource;
+    static toEncodable(fields: DataSourceFields): {
+        chain: number;
+        emitter: Address;
+    };
+    toJSON(): DataSourceJSON;
+    static fromJSON(obj: DataSourceJSON): DataSource;
+    toEncodable(): {
+        chain: number;
+        emitter: Address;
+    };
+}
+
+/**
+ * * This enum represents how many guardian signatures were checked for a Pythnet price update
+ *  * If full, guardian quorum has been attained
+ *  * If partial, at least config.minimum signatures have been verified, but in the case config.minimum_signatures changes in the future we also include the number of signatures that were checked
+ */
+type VerificationLevelKind = Partial | Full;
+type VerificationLevelJSON = PartialJSON | FullJSON;
+
+interface ConfigFields {
+    governanceAuthority: Address;
+    targetGovernanceAuthority: Address | null;
+    wormhole: Address;
+    validDataSources: Array<DataSourceFields>;
+    singleUpdateFeeInLamports: BN;
+    minimumSignatures: number;
+}
+interface ConfigJSON {
+    governanceAuthority: string;
+    targetGovernanceAuthority: string | null;
+    wormhole: string;
+    validDataSources: Array<DataSourceJSON>;
+    singleUpdateFeeInLamports: string;
+    minimumSignatures: number;
+}
+declare class Config {
+    readonly governanceAuthority: Address;
+    readonly targetGovernanceAuthority: Address | null;
+    readonly wormhole: Address;
+    readonly validDataSources: Array<DataSource>;
+    readonly singleUpdateFeeInLamports: BN;
+    readonly minimumSignatures: number;
+    static readonly discriminator: Buffer<ArrayBuffer>;
+    static readonly layout: buffer_layout.Layout<Config>;
+    constructor(fields: ConfigFields);
+    static fetch(rpc: Rpc<GetAccountInfoApi>, address: Address, programId?: Address): Promise<Config | null>;
+    static fetchMultiple(rpc: Rpc<GetMultipleAccountsApi>, addresses: Address[], programId?: Address): Promise<Array<Config | null>>;
+    static decode(data: Buffer): Config;
+    toJSON(): ConfigJSON;
+    static fromJSON(obj: ConfigJSON): Config;
+}
+
+interface priceUpdateV2Fields {
+    writeAuthority: Address;
+    verificationLevel: VerificationLevelKind;
+    priceMessage: PriceFeedMessageFields;
+    postedSlot: BN;
+}
+interface priceUpdateV2JSON {
+    writeAuthority: string;
+    verificationLevel: VerificationLevelJSON;
+    priceMessage: PriceFeedMessageJSON;
+    postedSlot: string;
+}
+declare class priceUpdateV2 {
+    readonly writeAuthority: Address;
+    readonly verificationLevel: VerificationLevelKind;
+    readonly priceMessage: PriceFeedMessage;
+    readonly postedSlot: BN;
+    static readonly discriminator: Buffer<ArrayBuffer>;
+    static readonly layout: buffer_layout.Layout<priceUpdateV2>;
+    constructor(fields: priceUpdateV2Fields);
+    static fetch(rpc: Rpc<GetAccountInfoApi>, address: Address, programId?: Address): Promise<priceUpdateV2 | null>;
+    static fetchMultiple(rpc: Rpc<GetMultipleAccountsApi>, addresses: Address[], programId?: Address): Promise<Array<priceUpdateV2 | null>>;
+    static decode(data: Buffer): priceUpdateV2;
+    toJSON(): priceUpdateV2JSON;
+    static fromJSON(obj: priceUpdateV2JSON): priceUpdateV2;
+}
+
+interface twapUpdateFields {
+    writeAuthority: Address;
+    twap: TwapPriceFields;
+}
+interface twapUpdateJSON {
+    writeAuthority: string;
+    twap: TwapPriceJSON;
+}
+declare class twapUpdate {
+    readonly writeAuthority: Address;
+    readonly twap: TwapPrice;
+    static readonly discriminator: Buffer<ArrayBuffer>;
+    static readonly layout: buffer_layout.Layout<twapUpdate>;
+    constructor(fields: twapUpdateFields);
+    static fetch(rpc: Rpc<GetAccountInfoApi>, address: Address, programId?: Address): Promise<twapUpdate | null>;
+    static fetchMultiple(rpc: Rpc<GetMultipleAccountsApi>, addresses: Address[], programId?: Address): Promise<Array<twapUpdate | null>>;
+    static decode(data: Buffer): twapUpdate;
+    toJSON(): twapUpdateJSON;
+    static fromJSON(obj: twapUpdateJSON): twapUpdate;
+}
+
+export { AggregatorAccountData, type AggregatorAccountDataFields, type AggregatorAccountDataJSON, BufferRelayerAccountData, type BufferRelayerAccountDataFields, type BufferRelayerAccountDataJSON, Config, type ConfigFields, type ConfigJSON, CrankAccountData, type CrankAccountDataFields, type CrankAccountDataJSON, JobAccountData, type JobAccountDataFields, type JobAccountDataJSON, LeaseAccountData, type LeaseAccountDataFields, type LeaseAccountDataJSON, OracleAccountData, type OracleAccountDataFields, type OracleAccountDataJSON, OracleQueueAccountData, type OracleQueueAccountDataFields, type OracleQueueAccountDataJSON, PermissionAccountData, type PermissionAccountDataFields, type PermissionAccountDataJSON, RealmSpawnRecordAccountData, type RealmSpawnRecordAccountDataFields, type RealmSpawnRecordAccountDataJSON, SbState, type SbStateFields, type SbStateJSON, SlidingResultAccountData, type SlidingResultAccountDataFields, type SlidingResultAccountDataJSON, TaskSpecRecord, type TaskSpecRecordFields, type TaskSpecRecordJSON, VrfAccountData, type VrfAccountDataFields, type VrfAccountDataJSON, VrfLiteAccountData, type VrfLiteAccountDataFields, type VrfLiteAccountDataJSON, VrfPoolAccountData, type VrfPoolAccountDataFields, type VrfPoolAccountDataJSON, getLatestAggregatorValue, priceUpdateV2, type priceUpdateV2Fields, type priceUpdateV2JSON, twapUpdate, type twapUpdateFields, type twapUpdateJSON };