blockworks-foundation
/
sbv2-solana
mirror of https://github.com/blockworks-foundation/sbv2-solana.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
sbv2-solana/javascript/solana.js/src/accounts/aggregatorAccount.ts

2778 lines
82 KiB
TypeScript
Raw Blame History

import * as errors from "../errors.js";
import {
AggregatorAccountData,
AggregatorAccountDataFields,
AggregatorAccountDataJSON,
} from "../generated/oracle-program/accounts/AggregatorAccountData.js";
import {
JobAccountData,
JobAccountDataJSON,
} from "../generated/oracle-program/accounts/JobAccountData.js";
import {
LeaseAccountData,
LeaseAccountDataJSON,
} from "../generated/oracle-program/accounts/LeaseAccountData.js";
import { OracleAccountData } from "../generated/oracle-program/accounts/OracleAccountData.js";
import {
OracleQueueAccountData,
OracleQueueAccountDataJSON,
} from "../generated/oracle-program/accounts/OracleQueueAccountData.js";
import {
PermissionAccountData,
PermissionAccountDataJSON,
} from "../generated/oracle-program/accounts/PermissionAccountData.js";
import * as ix from "../generated/oracle-program/instructions/index.js";
import {
AggregatorHistoryRow,
AggregatorResolutionMode,
AggregatorResolutionModeKind,
BorshDecimal,
} from "../generated/oracle-program/types/index.js";
import { SwitchboardDecimal } from "../generated/oracle-program/types/SwitchboardDecimal.js";
import { PermitOracleQueueUsage } from "../generated/oracle-program/types/SwitchboardPermission.js";
import { SwitchboardProgram } from "../SwitchboardProgram.js";
import {
SendTransactionObjectOptions,
TransactionObject,
TransactionObjectOptions,
TransactionPackOptions,
} from "../TransactionObject.js";
import { Account, OnAccountChangeCallback } from "./account.js";
import { AggregatorHistoryBuffer } from "./aggregatorHistoryBuffer.js";
import { CrankAccount } from "./crankAccount.js";
import { JobAccount } from "./jobAccount.js";
import { LeaseAccount, LeaseExtendParams } from "./leaseAccount.js";
import { OracleAccount } from "./oracleAccount.js";
import { PermissionAccount } from "./permissionAccount.js";
import { QueueAccount } from "./queueAccount.js";
import * as anchor from "@coral-xyz/anchor";
import * as spl from "@solana/spl-token";
import { TOKEN_PROGRAM_ID } from "@solana/spl-token";
import {
AccountInfo,
AccountMeta,
Commitment,
Keypair,
LAMPORTS_PER_SOL,
PublicKey,
SystemProgram,
TransactionInstruction,
TransactionSignature,
} from "@solana/web3.js";
import {
Big,
BN,
OracleJob,
promiseWithTimeout,
toUtf8,
} from "@switchboard-xyz/common";
import assert from "assert";
import crypto, { createHash } from "crypto";
/**
* Account type holding a data feed's update configuration, job accounts, and its current result.
*
* Data: {@linkcode AggregatorAccountData}
*
* Result: {@linkcode SwitchboardDecimal}
*
* HistoryBuffer?: Array<{@linkcode AggregatorHistoryRow}>
*
* An aggregator account belongs to a single {@linkcode QueueAccount} but can later be transferred by the aggregator's authority. In order for an {@linkcode OracleAccount} to respond to an aggregator's update request, the aggregator must initialize a {@linkcode PermissionAccount} and {@linkcode LeaseAccount}. These will need to be recreated when transferring queues.
*
* Optionally, An aggregator can be pushed onto a {@linkcode CrankAccount} in order to be updated
*
* Optionally, an aggregator can add a history buffer to store the last N historical samples along with their update timestamp.
*/
export class AggregatorAccount extends Account<AggregatorAccountData> {
static accountName = "AggregatorAccountData";
public history?: AggregatorHistoryBuffer;
/**
* Returns the aggregator's name buffer in a stringified format.
*/
public static getName = (aggregator: AggregatorAccountData) =>
toUtf8(aggregator.name);
/**
* Returns the aggregator's metadata buffer in a stringified format.
*/
public static getMetadata = (aggregator: AggregatorAccountData) =>
toUtf8(aggregator.metadata);
public static size = 3851;
/**
* Get the size of an {@linkcode AggregatorAccount} on-chain.
*/
public size = this.program.account.aggregatorAccountData.size;
public decode(data: Buffer): AggregatorAccountData {
try {
return AggregatorAccountData.decode(data);
} catch {
return this.program.coder.decode<AggregatorAccountData>(
AggregatorAccount.accountName,
data
);
}
}
/**
* Return an aggregator account state initialized to the default values.
*/
public static default(): AggregatorAccountData {
const buffer = Buffer.alloc(AggregatorAccount.size, 0);
AggregatorAccountData.discriminator.copy(buffer, 0);
return AggregatorAccountData.decode(buffer);
}
/**
* Create a mock account info for a given aggregator config. Useful for test integrations.
*/
public static createMock(
programId: PublicKey,
data: Partial<AggregatorAccountData>,
options?: {
lamports?: number;
rentEpoch?: number;
}
): AccountInfo<Buffer> {
const fields: AggregatorAccountDataFields = {
...AggregatorAccount.default(),
...data,
// any cleanup actions here
};
const state = new AggregatorAccountData(fields);
const buffer = Buffer.alloc(AggregatorAccount.size, 0);
AggregatorAccountData.discriminator.copy(buffer, 0);
AggregatorAccountData.layout.encode(state, buffer, 8);
return {
executable: false,
owner: programId,
lamports: options?.lamports ?? 1 * LAMPORTS_PER_SOL,
data: buffer,
rentEpoch: options?.rentEpoch ?? 0,
};
}
/**
* Invoke a callback each time an AggregatorAccount's data has changed on-chain.
* @param callback - the callback invoked when the aggregator state changes
* @param commitment - optional, the desired transaction finality. defaults to 'confirmed'
* @returns the websocket subscription id
*/
public onChange(
callback: OnAccountChangeCallback<AggregatorAccountData>,
commitment: Commitment = "confirmed"
): number {
return this.program.connection.onAccountChange(
this.publicKey,
(accountInfo) => {
callback(this.decode(accountInfo.data));
},
commitment
);
}
/**
* Retrieve and decode the {@linkcode AggregatorAccountData} stored in this account.
*/
public async loadData(): Promise<AggregatorAccountData> {
const data = await AggregatorAccountData.fetch(
this.program,
this.publicKey
);
if (data === null)
throw new errors.AccountNotFoundError("Aggregator", this.publicKey);
this.history = AggregatorHistoryBuffer.fromAggregator(this.program, data);
return data;
}
public get slidingWindowKey(): PublicKey {
return PublicKey.findProgramAddressSync(
[Buffer.from("SlidingResultAccountData"), this.publicKey.toBytes()],
this.program.programId
)[0];
}
/** Load an existing AggregatorAccount with its current on-chain state */
public static async load(
program: SwitchboardProgram,
publicKey: PublicKey | string
): Promise<[AggregatorAccount, AggregatorAccountData]> {
const account = new AggregatorAccount(
program,
typeof publicKey === "string" ? new PublicKey(publicKey) : publicKey
);
const state = await account.loadData();
return [account, state];
}
/**
* Creates a transaction object with aggregatorInit instructions.
* @param program The SwitchboardProgram.
* @param payer The account that will pay for the new accounts.
* @param params aggregator configuration parameters.
* @return {@linkcode TransactionObject} that will create the aggregatorAccount.
*
* Basic usage example:
*
* ```ts
* import {AggregatorAccount} from '@switchboard-xyz/solana.js';
* const [aggregatorAccount, aggregatorInit ] = await AggregatorAccount.createInstruction(program, payer, {
* queueAccount,
* queueAuthority,
* batchSize: 5,
* minRequiredOracleResults: 3,
* minRequiredJobResults: 1,
* minUpdateDelaySeconds: 30,
* });
* const txnSignature = await program.signAndSend(aggregatorInit);
* ```
*/
public static async createInstruction(
program: SwitchboardProgram,
payer: PublicKey,
params: AggregatorInitParams,
options?: TransactionObjectOptions
): Promise<[AggregatorAccount, TransactionObject]> {
if (params.batchSize > 8) {
throw new errors.AggregatorConfigError(
"oracleRequestBatchSize",
"must be less than or equal to 8"
);
}
if (params.minUpdateDelaySeconds < 5) {
throw new errors.AggregatorConfigError(
"minUpdateDelaySeconds",
"must be greater than 5 seconds"
);
}
const keypair = params.keypair ?? Keypair.generate();
program.verifyNewKeypair(keypair);
const ixns: TransactionInstruction[] = [];
const signers: Keypair[] = [keypair];
ixns.push(
SystemProgram.createAccount({
fromPubkey: payer,
newAccountPubkey: keypair.publicKey,
space: program.account.aggregatorAccountData.size,
lamports: await program.connection.getMinimumBalanceForRentExemption(
program.account.aggregatorAccountData.size
),
programId: program.programId,
})
);
ixns.push(
ix.aggregatorInit(
program,
{
params: {
name: [...Buffer.from(params.name ?? "", "utf8").slice(0, 32)],
metadata: [
...Buffer.from(params.metadata ?? "", "utf8").slice(0, 128),
],
batchSize: params.batchSize,
minOracleResults: params.minRequiredOracleResults,
minJobResults: params.minRequiredJobResults,
minUpdateDelaySeconds: params.minUpdateDelaySeconds,
startAfter: new BN(params.startAfter ?? 0),
varianceThreshold: SwitchboardDecimal.fromBig(
new Big(params.varianceThreshold ?? 0)
).borsh,
forceReportPeriod: new BN(params.forceReportPeriod ?? 0),
expiration: new BN(params.expiration ?? 0),
stateBump: program.programState.bump,
disableCrank: params.disableCrank ?? false,
},
},
{
aggregator: keypair.publicKey,
authority: params.authority ?? payer,
queue: params.queueAccount.publicKey,
programState: program.programState.publicKey,
}
)
);
const aggregatorInitTxn = new TransactionObject(
payer,
ixns,
signers,
options
);
const aggregatorAccount = new AggregatorAccount(program, keypair.publicKey);
return [aggregatorAccount, aggregatorInitTxn];
}
/**
* Creates an aggregator on-chain and return the transaction signature and created account resource.
* @param program The SwitchboardProgram.
* @param params aggregator configuration parameters.
* @return Transaction signature and the newly created aggregatorAccount.
*
* Basic usage example:
*
* ```ts
* import {AggregatorAccount} from '@switchboard-xyz/solana.js';
* const [aggregatorAccount, txnSignature] = await AggregatorAccount.create(program, {
* queueAccount,
* queueAuthority,
* batchSize: 5,
* minRequiredOracleResults: 3,
* minRequiredJobResults: 1,
* minUpdateDelaySeconds: 30,
* });
* const aggregator = await aggregatorAccount.loadData();
* ```
*/
public static async create(
program: SwitchboardProgram,
params: AggregatorInitParams,
options?: SendTransactionObjectOptions
): Promise<[AggregatorAccount, TransactionSignature]> {
const [account, transaction] = await AggregatorAccount.createInstruction(
program,
program.walletPubkey,
params,
options
);
const txnSignature = await program.signAndSend(transaction, options);
return [account, txnSignature];
}
/**
* Create the {@linkcode PermissionAccount} and {@linkcode LeaseAccount} for a new oracle queue without affecting the feed's rhythm. This does not evict a feed from the current queue.
*/
async transferQueuePart1Instructions(
payer: PublicKey,
params: {
newQueue: QueueAccount;
} & LeaseExtendParams
): Promise<[TransactionObject, PermissionAccount, LeaseAccount]> {
const txns: Array<TransactionObject> = [];
const aggregator = await this.loadData();
const newQueue = await params.newQueue.loadData();
const jobs = await this.loadJobs(aggregator);
const jobAuthorities = jobs.map((job) => job.state.authority);
const [newPermissionAccount] = this.getPermissionAccount(
params.newQueue.publicKey,
newQueue.authority
);
const newPermissionAccountInfo =
await this.program.connection.getAccountInfo(
newPermissionAccount.publicKey
);
if (newPermissionAccountInfo === null) {
const [_newPermissionAccount, permissionInitTxn] =
PermissionAccount.createInstruction(this.program, payer, {
authority: newQueue.authority,
granter: params.newQueue.publicKey,
grantee: this.publicKey,
});
assert(
newPermissionAccount.publicKey.equals(_newPermissionAccount.publicKey)
);
txns.push(permissionInitTxn);
}
const [newLeaseAccount] = this.getLeaseAccount(params.newQueue.publicKey);
const newLeaseAccountInfo = await this.program.connection.getAccountInfo(
newLeaseAccount.publicKey
);
if (newLeaseAccountInfo === null) {
const [userTokenWallet, userWrap] =
params.fundAmount && params.fundAmount > 0 && !params.funderTokenWallet
? await this.program.mint.getOrCreateWrappedUserInstructions(payer, {
fundUpTo: params.fundAmount ?? 0,
})
: [undefined, undefined];
if (userWrap) {
txns.push(userWrap);
}
// create lease for the new queue but dont transfer any balance
const [_newLeaseAccount, leaseInit] =
await LeaseAccount.createInstructions(this.program, payer, {
aggregatorAccount: this,
queueAccount: params.newQueue,
funderTokenWallet:
params.funderTokenWallet ?? userTokenWallet ?? undefined,
funderAuthority: params.funderAuthority ?? undefined,
jobAuthorities,
fundAmount: params.fundAmount ?? 0,
withdrawAuthority: aggregator.authority, // set to current authority
jobPubkeys: aggregator.jobPubkeysData.slice(
0,
aggregator.jobPubkeysSize
),
});
assert(newLeaseAccount.publicKey.equals(_newLeaseAccount.publicKey));
txns.push(leaseInit);
}
const packed = TransactionObject.pack(txns);
if (packed.length !== 1) {
throw new Error(
`QueueTransfer-Part1: Expected a single TransactionObject`
);
}
return [packed[0], newPermissionAccount, newLeaseAccount];
}
/**
* Create the {@linkcode PermissionAccount} and {@linkcode LeaseAccount} for a new oracle queue without affecting the feed's rhythm. This does not evict a feed from the current queue.
*/
async transferQueuePart1(
params: {
newQueue: QueueAccount;
} & LeaseExtendParams
): Promise<[PermissionAccount, LeaseAccount, TransactionSignature]> {
const [txn, permissionAccount, leaseAccount] =
await this.transferQueuePart1Instructions(
this.program.walletPubkey,
params
);
const signature = await this.program.signAndSend(txn);
return [permissionAccount, leaseAccount, signature];
}
/**
* Approve the feed to use the new queue. Must be signed by the {@linkcode QueueAccount} authority.
*
* This does not affect the feed's rhythm nor evict it from the current queue. The Aggregator authority is still required to sign a transaction to move the feed.
*/
async transferQueuePart2Instructions(
payer: PublicKey,
params: {
newQueue: QueueAccount;
enable: boolean;
queueAuthority?: Keypair;
// dont check if new accounts have been created yet
force?: boolean;
}
): Promise<[TransactionObject | undefined, PermissionAccount]> {
const newQueue = await params.newQueue.loadData();
const [permissionAccount] = this.getPermissionAccount(
params.newQueue.publicKey,
newQueue.authority
);
if (!params.enable) {
return [undefined, permissionAccount];
}
if (
params.queueAuthority &&
!params.queueAuthority.publicKey.equals(newQueue.authority)
) {
throw new errors.IncorrectAuthority(
newQueue.authority,
params.queueAuthority.publicKey
);
}
if (!params.force) {
await permissionAccount.loadData().catch(() => {
throw new Error(`Expected permissionAccount to be created already`);
});
}
const permissionSet = permissionAccount.setInstruction(payer, {
enable: params.enable,
queueAuthority: params.queueAuthority,
permission: new PermitOracleQueueUsage(),
});
return [permissionSet, permissionAccount];
}
/**
* Approve the feed to use the new queue. Must be signed by the {@linkcode QueueAccount} authority.
*
* This does not affect the feed's rhythm nor evict it from the current queue. The Aggregator authority is still required to sign a transaction to move the feed.
*/
async transferQueuePart2(params: {
newQueue: QueueAccount;
enable: boolean;
queueAuthority?: Keypair;
// dont check if new accounts have been created yet
force?: boolean;
}): Promise<[PermissionAccount, TransactionSignature | undefined]> {
const [txn, permissionAccount] = await this.transferQueuePart2Instructions(
this.program.walletPubkey,
params
);
if (!txn) {
return [permissionAccount, undefined];
}
const signature = await this.program.signAndSend(txn);
return [permissionAccount, signature];
}
/**
* Transfer the feed to the new {@linkcode QueueAccount} and optionally push it on a crank. Must be signed by the Aggregator authority to approve the transfer.
*
* This will evict a feed from the previous queue and crank.
*/
async transferQueuePart3Instructions(
payer: PublicKey,
params: {
newQueue: QueueAccount;
authority?: Keypair;
newCrank?: CrankAccount;
// dont check if new accounts have been created yet
force?: boolean;
}
): Promise<Array<TransactionObject>> {
const txns: Array<TransactionObject> = [];
const newQueue = await params.newQueue.loadData();
const aggregator = await this.loadData();
// new permission account needs to be created and approved
const [permissionAccount] = this.getPermissionAccount(
params.newQueue.publicKey,
newQueue.authority
);
if (!params.force) {
await permissionAccount
.loadData()
.catch(() => {
throw new Error(`Expected permissionAccount to be created already`);
})
.then((permission) => {
if (
!newQueue.unpermissionedFeedsEnabled &&
permission.permissions !== 2
) {
throw new Error(
`PermissionAccount missing required permissions to enable this queue`
);
}
});
}
// check the new lease has been created
const [newLeaseAccount] = this.getLeaseAccount(params.newQueue.publicKey);
if (!params.force) {
await newLeaseAccount.loadData().catch(() => {
throw new Error(`Expected leaseAccount to be created already`);
});
}
// set the feeds queue
const setQueueTxn = new TransactionObject(
payer,
[
ix.aggregatorSetQueue(
this.program,
{ params: {} },
{
aggregator: this.publicKey,
authority: aggregator.authority,
queue: params.newQueue.publicKey,
}
),
],
params.authority ? [params.authority] : []
);
txns.push(setQueueTxn);
// push to crank
if (params.newCrank) {
const newCrank = await params.newCrank.loadData();
if (!newCrank.queuePubkey.equals(params.newQueue.publicKey)) {
throw new Error(`Crank is owned by the wrong queue`);
}
const crankPush = params.newCrank.pushInstructionSync(payer, {
aggregatorAccount: this,
queue: newQueue,
crank: newCrank,
});
txns.push(crankPush);
}
// remove any funds from the old lease account
const [oldLeaseAccount] = this.getLeaseAccount(aggregator.queuePubkey);
const oldLease = await oldLeaseAccount.loadData();
const oldLeaseBalance = await oldLeaseAccount.fetchBalance(oldLease.escrow);
if (oldLease.withdrawAuthority.equals(payer) && oldLeaseBalance > 0) {
const withdrawTxn = await oldLeaseAccount.withdrawInstruction(payer, {
amount: oldLeaseBalance,
unwrap: false,
// withdraw old lease funds into the new lease
withdrawWallet: this.program.mint.getAssociatedAddress(
newLeaseAccount.publicKey
),
});
txns.push(withdrawTxn);
}
return TransactionObject.pack(txns);
}
/**
* Transfer the feed to the new {@linkcode QueueAccount} and optionally push it on a crank. Must be signed by the Aggregator authority to approve the transfer.
*
* This will evict a feed from the previous queue and crank.
*/
async transferQueuePart3(params: {
newQueue: QueueAccount;
authority?: Keypair;
newCrank?: CrankAccount;
// dont check if new accounts have been created yet
force?: boolean;
}): Promise<Array<TransactionSignature>> {
const txns = await this.transferQueuePart3Instructions(
this.program.walletPubkey,
params
);
const signatures = await this.program.signAndSendAll(txns, {
skipPreflight: true,
});
return signatures;
}
async transferQueueInstructions(
payer: PublicKey,
params: {
authority?: Keypair;
newQueue: QueueAccount;
newCrank?: CrankAccount;
enable: boolean;
queueAuthority?: Keypair;
} & LeaseExtendParams,
opts?: TransactionObjectOptions
): Promise<[Array<TransactionObject>, PermissionAccount, LeaseAccount]> {
const txns: Array<TransactionObject> = [];
const [part1, permissionAccount, leaseAccount] =
await this.transferQueuePart1Instructions(payer, {
newQueue: params.newQueue,
fundAmount: params.fundAmount,
funderTokenWallet: params.funderTokenWallet,
funderAuthority: params.funderAuthority,
});
txns.push(part1);
const [part2] = await this.transferQueuePart2Instructions(payer, {
newQueue: params.newQueue,
enable: params.enable,
queueAuthority: params.queueAuthority,
force: true,
});
if (part2) {
txns.push(part2);
}
const part3 = await this.transferQueuePart3Instructions(payer, {
newQueue: params.newQueue,
authority: params.authority,
newCrank: params.newCrank,
force: true,
});
txns.push(...part3);
return [
TransactionObject.pack(txns, opts),
permissionAccount,
leaseAccount,
];
}
async transferQueue(
params: {
authority?: Keypair;
newQueue: QueueAccount;
newCrank?: CrankAccount;
enable: boolean;
queueAuthority?: Keypair;
} & LeaseExtendParams
): Promise<[PermissionAccount, LeaseAccount, Array<TransactionSignature>]> {
const [txns, permissionAccount, leaseAccount] =
await this.transferQueueInstructions(this.program.walletPubkey, params);
const signatures = await this.program.signAndSendAll(txns, {
skipPreflight: true,
});
return [permissionAccount, leaseAccount, signatures];
}
public getPermissionAccount(
queuePubkey: PublicKey,
queueAuthority: PublicKey
): [PermissionAccount, number] {
return PermissionAccount.fromSeed(
this.program,
queueAuthority,
queuePubkey,
this.publicKey
);
}
public getLeaseAccount(
queuePubkey: PublicKey
): [LeaseAccount, PublicKey, number] {
const [leaseAccount, leaseBump] = LeaseAccount.fromSeed(
this.program,
queuePubkey,
this.publicKey
);
const leaseEscrow = this.program.mint.getAssociatedAddress(
leaseAccount.publicKey
);
return [leaseAccount, leaseEscrow, leaseBump];
}
/**
* Derives the Program Derived Accounts (PDAs) for the Aggregator, based on its currently assigned oracle queue.
*
* @param queueAccount The QueueAccount associated with the Aggregator.
* @param queueAuthority The PublicKey of the oracle queue authority.
*
* @return An object containing the Aggregator PDA accounts, including:
* - permissionAccount: The permission account.
* - permissionBump: The nonce value used to generate the permission account.
* - leaseAccount: The lease account.
* - leaseBump: The nonce value used to generate the lease account.
* - leaseEscrow: The lease escrow account.
*
* Basic usage example:
*
* ```ts
* const aggregatorPdaAccounts = aggregator.getAccounts(queueAccount, queueAuthority);
* console.log("Aggregator PDA accounts:", aggregatorPdaAccounts);
* ```
*/
public getAccounts(
queueAccount: QueueAccount,
queueAuthority: PublicKey
): AggregatorPdaAccounts {
const [permissionAccount, permissionBump] = this.getPermissionAccount(
queueAccount.publicKey,
queueAuthority
);
const [leaseAccount, leaseEscrow, leaseBump] = this.getLeaseAccount(
queueAccount.publicKey
);
return {
permissionAccount,
permissionBump,
leaseAccount,
leaseBump,
leaseEscrow,
};
}
/**
* Retrieves the latest confirmed value stored in the aggregator account from a pre-fetched account state.
*
* @param aggregator The pre-fetched aggregator account data.
*
* @return The latest feed value as a Big instance, or null if no successful rounds have been confirmed yet.
*
* Basic usage example:
*
* ```ts
* const latestValue = AggregatorAccount.decodeLatestValue(aggregatorAccountData);
* console.log("Latest confirmed value:", latestValue?.toString() ?? "No successful rounds yet");
* ```
*/
public static decodeLatestValue(
aggregator: AggregatorAccountData
): Big | null {
if ((aggregator.latestConfirmedRound?.numSuccess ?? 0) === 0) {
return null;
}
const result = aggregator.latestConfirmedRound.result.toBig();
return result;
}
/**
* Retrieves the latest confirmed value stored in the aggregator account.
*
* @return A Promise that resolves to the latest feed value as a Big instance, or null if the value is not populated or no successful rounds have been confirmed yet.
*
* Basic usage example:
*
* ```ts
* const latestValue = await aggregatorAccount.fetchLatestValue();
* console.log("Latest confirmed value:", latestValue?.toString() ?? "No successful rounds yet");
* ```
*/
public async fetchLatestValue(): Promise<Big | null> {
const aggregator = await this.loadData();
return AggregatorAccount.decodeLatestValue(aggregator);
}
/**
* Retrieves the timestamp of the latest confirmed round stored in the aggregator account from a pre-fetched account state.
*
* @param aggregator The pre-fetched aggregator account data.
*
* @return The latest feed timestamp as an BN instance.
*
* @throws Error if the aggregator currently holds no value or no successful rounds have been confirmed yet.
*
* Basic usage example:
*
* ```ts
* const latestTimestamp = AggregatorAccount.decodeLatestTimestamp(aggregatorAccountData);
* console.log("Latest confirmed round timestamp:", latestTimestamp.toString());
* ```
*/
public static decodeLatestTimestamp(aggregator: AggregatorAccountData): BN {
if ((aggregator.latestConfirmedRound?.numSuccess ?? 0) === 0) {
throw new Error("Aggregator currently holds no value.");
}
return aggregator.latestConfirmedRound.roundOpenTimestamp;
}
/**
* Decodes the confirmed round results of the aggregator account from a pre-fetched account state.
*
* @param aggregator The pre-fetched aggregator account data.
*
* @return An array of objects containing the oracle public keys and their respective reported values as Big instances.
*
* @throws Error if the aggregator currently holds no value or no successful rounds have been confirmed yet.
*
* Basic usage example:
*
* ```ts
* const confirmedRoundResults = AggregatorAccount.decodeConfirmedRoundResults(aggregatorAccountData);
* console.log("Confirmed round results:", confirmedRoundResults);
* ```
*/
public static decodeConfirmedRoundResults(
aggregator: AggregatorAccountData
): Array<{ oraclePubkeys: PublicKey; value: Big }> {
if ((aggregator.latestConfirmedRound?.numSuccess ?? 0) === 0) {
throw new Error("Aggregator currently holds no value.");
}
const results: Array<{ oraclePubkeys: PublicKey; value: Big }> = [];
for (let i = 0; i < aggregator.oracleRequestBatchSize; ++i) {
if (aggregator.latestConfirmedRound.mediansFulfilled[i] === true) {
results.push({
oraclePubkeys: aggregator.latestConfirmedRound.oraclePubkeysData[i],
value: aggregator.latestConfirmedRound.mediansData[i].toBig(),
});
}
}
return results;
}
/**
* Retrieves the individual oracle results of the latest confirmed round from a pre-fetched account state.
*
* @param aggregator The pre-fetched aggregator account data.
*
* @return An array of objects containing the oracle account instances and their respective reported values as Big instances.
*
* Basic usage example:
*
* ```ts
* const aggregatorAccountData = await aggregatorAccount.loadData();
* const confirmedRoundResults = aggregatorAccount.getConfirmedRoundResults(aggregatorAccountData);
* console.log("Confirmed round results by oracle account:", confirmedRoundResults);
* ```
*/
public getConfirmedRoundResults(
aggregator: AggregatorAccountData
): Array<{ oracleAccount: OracleAccount; value: Big }> {
return AggregatorAccount.decodeConfirmedRoundResults(aggregator).map(
(o) => {
return {
oracleAccount: new OracleAccount(this.program, o.oraclePubkeys),
value: o.value,
};
}
);
}
/**
* Generates a SHA-256 hash of all the oracle jobs currently in the aggregator.
*
* @param jobs An array of OracleJob instances representing the jobs in the aggregator.
*
* @return A crypto.Hash object representing the hash of all the feed jobs.
*
* Basic usage example:
*
* ```ts
* const jobs = [job1, job2, job3];
* const jobsHash = aggregatorAccount.produceJobsHash(jobs);
* console.log("Hash of all the feed jobs:", jobsHash);
* ```
*/
public produceJobsHash(jobs: Array<OracleJob>): crypto.Hash {
const hash = crypto.createHash("sha256");
for (const job of jobs) {
const jobHasher = crypto.createHash("sha256");
jobHasher.update(OracleJob.encodeDelimited(job).finish());
hash.update(jobHasher.digest());
}
return hash;
}
public static decodeCurrentRoundOracles(
aggregator: AggregatorAccountData
): Array<PublicKey> {
return aggregator.currentRound.oraclePubkeysData.slice(
0,
aggregator.oracleRequestBatchSize
);
}
public async loadCurrentRoundOracles(
aggregator: AggregatorAccountData
): Promise<Array<{ account: OracleAccount; state: OracleAccountData }>> {
return await Promise.all(
AggregatorAccount.decodeCurrentRoundOracles(aggregator).map(async (o) => {
const oracleAccount = new OracleAccount(this.program, o);
return {
account: oracleAccount,
state: await oracleAccount.loadData(),
};
})
);
}
public static decodeJobPubkeys(
aggregator: AggregatorAccountData
): Array<PublicKey> {
return aggregator.jobPubkeysData.slice(0, aggregator.jobPubkeysSize);
}
public async loadJobs(aggregator: AggregatorAccountData): Promise<
Array<{
account: JobAccount;
state: JobAccountData;
job: OracleJob;
weight: number;
}>
> {
const jobAccountDatas = await anchor.utils.rpc.getMultipleAccounts(
this.program.connection,
AggregatorAccount.decodeJobPubkeys(aggregator)
);
return await Promise.all(
jobAccountDatas.map(async (j) => {
if (!j?.account) {
throw new Error(
`Failed to fetch account data for job ${j?.publicKey}`
);
}
if (!j.account.owner.equals(this.program.programId)) {
throw new errors.IncorrectOwner(
this.program.programId,
j.account.owner
);
}
const jobAccount = new JobAccount(this.program, j.publicKey);
const jobState: JobAccountData = this.program.coder.decode(
"JobAccountData",
j.account.data
);
return {
account: jobAccount,
state: jobState,
job: OracleJob.decodeDelimited(jobState.data),
weight: Math.max(
aggregator.jobWeights[
aggregator.jobPubkeysData.findIndex((x: PublicKey) =>
x.equals(j.publicKey)
)
] ?? 1,
1
),
};
})
);
}
public getJobHashes(
jobs: Array<{
account: JobAccount;
state: JobAccountData;
}>
): Array<Buffer> {
return jobs.map((j) => Buffer.from(new Uint8Array(j.state.hash)));
}
/**
* Validates an aggregator's configuration.
*
* @param aggregator An object containing the aggregator's account data or a partial configuration.
* @param queue An object containing the OracleQueueAccountData.
* @param target An object containing the target configuration values to be verified.
*
* @throws {AggregatorConfigError} If any of the following conditions are met:
* - minUpdateDelaySeconds is less than 5 seconds
* - batchSize is greater than 8
* - batchSize is greater than the queue size
* - minOracleResults is greater than batchSize
* - minJobResults is equal to 0
*
* Basic usage example:
*
* ```ts
* AggregatorAccount.verifyConfig(
* aggregatorData,
* queueData,
* {
* batchSize: 8,
* minOracleResults: 5,
* minJobResults: 4,
* minUpdateDelaySeconds: 10,
* }
* );
* ```
*/
public static verifyConfig(
aggregator:
| AggregatorAccountData
| {
oracleRequestBatchSize: number;
minOracleResults: number;
minJobResults: number;
minUpdateDelaySeconds: number;
jobPubkeysSize: number;
},
queue: OracleQueueAccountData,
target: {
batchSize?: number;
minOracleResults?: number;
minJobResults?: number;
minUpdateDelaySeconds?: number;
}
): void {
const numberOfOracles = queue.size;
const endState = {
batchSize: target.batchSize ?? aggregator.oracleRequestBatchSize,
minOracleResults: target.minOracleResults ?? aggregator.minOracleResults,
minJobResults: target.minJobResults ?? aggregator.minJobResults,
minUpdateDelaySeconds:
target.minUpdateDelaySeconds ?? aggregator.minUpdateDelaySeconds,
};
if (endState.batchSize > 8) {
throw new errors.AggregatorConfigError(
"oracleRequestBatchSize",
"must be less than or equal to 8"
);
}
if (endState.minUpdateDelaySeconds < 5) {
throw new errors.AggregatorConfigError(
"minUpdateDelaySeconds",
"must be greater than 5 seconds"
);
}
if (endState.minJobResults === 0 || endState.minJobResults > 16) {
throw new errors.AggregatorConfigError(
"minJobResults",
"must be a value between 1 and 16"
);
}
if (endState.minJobResults > aggregator.jobPubkeysSize) {
console.warn(
`The aggregator's minJobResults (${endState.minJobResults}) is less than the current number of jobs (${aggregator.jobPubkeysSize})`
);
}
if (endState.batchSize > numberOfOracles) {
throw new errors.AggregatorConfigError(
"oracleRequestBatchSize",
`must be less than the number of oracles actively heartbeating on the queue (${numberOfOracles})`
);
}
if (endState.minOracleResults > endState.batchSize) {
throw new errors.AggregatorConfigError(
"minOracleResults",
`must be less than the oracleRequestBatchSize (${endState.batchSize})`
);
}
}
/**
* Validates an aggregator's configuration.
*
* @param aggregator An object containing the aggregator's account data or a partial configuration.
* @param queue An object containing the OracleQueueAccountData.
* @param target An object containing the target configuration values to be verified.
*
* @throws {AggregatorConfigError} If any of the following conditions are met:
* - minUpdateDelaySeconds is less than 5 seconds
* - batchSize is greater than 8
* - batchSize is greater than the queue size
* - minOracleResults is greater than batchSize
* - minJobResults is greater than the aggregator's jobPubkeysSize
*
* Basic usage example:
*
* ```ts
* aggregatorAccount.verifyConfig(
* aggregatorData,
* queueData,
* {
* batchSize: 8,
* minOracleResults: 5,
* minJobResults: 4,
* minUpdateDelaySeconds: 10,
* }
* );
* ```
*/
public verifyConfig(
aggregator:
| AggregatorAccountData
| {
oracleRequestBatchSize: number;
minOracleResults: number;
minJobResults: number;
minUpdateDelaySeconds: number;
jobPubkeysSize: number;
},
queue: OracleQueueAccountData,
target: {
batchSize?: number;
minOracleResults?: number;
minJobResults?: number;
minUpdateDelaySeconds?: number;
}
): void {
AggregatorAccount.verifyConfig(aggregator, queue, target);
}
/**
* Creates a transaction object to set aggregator configuration parameters.
*
* @param payer The public key of the payer account.
* @param params An object containing partial configuration parameters to be set.
* @param options Optional transaction object options.
*
* @return A promise that resolves to a transaction object containing the setConfig instruction.
*
* Basic usage example:
*
* ```ts
* const transactionObject = await aggregatorAccount.setConfigInstruction(
* payerPublicKey,
* {
* name: 'New Aggregator Name',
* metadata: 'New Aggregator Metadata',
* batchSize: 8,
* minOracleResults: 5,
* minJobResults: 4,
* minUpdateDelaySeconds: 10,
* forceReportPeriod: 20,
* varianceThreshold: 0.01,
* basePriorityFee: 1,
* priorityFeeBump: 0.1,
* priorityFeeBumpPeriod: 60,
* maxPriorityFeeMultiplier: 5,
* force: false,
* }
* );
* ```
*/
public async setConfigInstruction(
payer: PublicKey,
params: Partial<{
name: string;
metadata: string;
batchSize: number;
minOracleResults: number;
minJobResults: number;
minUpdateDelaySeconds: number;
forceReportPeriod: number;
varianceThreshold: number;
authority: Keypair;
basePriorityFee: number;
priorityFeeBump: number;
priorityFeeBumpPeriod: number;
maxPriorityFeeMultiplier: number;
force: boolean;
disableCrank: boolean;
}>,
options?: TransactionObjectOptions
): Promise<TransactionObject> {
if (!(params.force ?? false)) {
const aggregator = await this.loadData();
const queueAccount = new QueueAccount(
this.program,
aggregator.queuePubkey
);
const queue = await queueAccount.loadData();
this.verifyConfig(aggregator, queue, {
batchSize: params.batchSize,
minOracleResults: params.minOracleResults,
minJobResults: params.minJobResults,
minUpdateDelaySeconds: params.minUpdateDelaySeconds,
});
}
const varianceThreshold = params.varianceThreshold ?? 0;
const setConfigIxn = ix.aggregatorSetConfig(
this.program,
{
params: {
name: params.name
? ([
...Buffer.from(params.name, "utf-8").slice(0, 32),
] as Array<number>)
: null,
metadata: params.metadata
? ([
...Buffer.from(params.metadata, "utf-8").slice(0, 128),
] as Array<number>)
: null,
batchSize: params.batchSize ?? null,
minOracleResults: params.minOracleResults ?? null,
minUpdateDelaySeconds: params.minUpdateDelaySeconds ?? null,
minJobResults: params.minJobResults ?? null,
forceReportPeriod: params.forceReportPeriod ?? null,
varianceThreshold:
varianceThreshold >= 0
? new BorshDecimal(
SwitchboardDecimal.fromBig(new Big(varianceThreshold))
)
: null,
basePriorityFee: params.basePriorityFee ?? null,
priorityFeeBump: params.priorityFeeBump ?? null,
priorityFeeBumpPeriod: params.priorityFeeBumpPeriod ?? null,
maxPriorityFeeMultiplier: params.maxPriorityFeeMultiplier ?? null,
disableCrank: params.disableCrank ?? null,
},
},
{
aggregator: this.publicKey,
authority: params.authority ? params.authority.publicKey : payer,
}
);
return new TransactionObject(
payer,
[setConfigIxn],
params.authority ? [params.authority] : [],
options
);
}
/**
* Sets an aggregator configuration parameters.
*
* @param params An object containing partial configuration parameters to be set.
* @param options Optional transaction object options.
*
* @return A promise that resolves to a transaction object containing the setConfig instruction.
*
* Basic usage example:
*
* ```ts
* const transactionObject = await aggregatorAccount.setConfig(
* {
* name: 'New Aggregator Name',
* metadata: 'New Aggregator Metadata',
* batchSize: 8,
* minOracleResults: 5,
* minJobResults: 4,
* minUpdateDelaySeconds: 10,
* forceReportPeriod: 20,
* varianceThreshold: 0.01,
* basePriorityFee: 1,
* priorityFeeBump: 0.1,
* priorityFeeBumpPeriod: 60,
* maxPriorityFeeMultiplier: 5,
* force: false,
* }
* );
* ```
*/
public async setConfig(
params: Partial<{
name: string;
metadata: string;
batchSize: number;
minOracleResults: number;
minJobResults: number;
minUpdateDelaySeconds: number;
forceReportPeriod: number;
varianceThreshold: number;
authority?: Keypair;
basePriorityFee?: number;
priorityFeeBump?: number;
priorityFeeBumpPeriod?: number;
maxPriorityFeeMultiplier?: number;
force: boolean;
disableCrank: boolean;
}>,
options?: SendTransactionObjectOptions
): Promise<TransactionSignature> {
const setConfigTxn = await this.setConfigInstruction(
this.program.walletPubkey,
params,
options
);
const txnSignature = await this.program.signAndSend(setConfigTxn);
return txnSignature;
}
public setQueueInstruction(
payer: PublicKey,
params: {
queueAccount: QueueAccount;
authority?: Keypair;
},
options?: TransactionObjectOptions
): TransactionObject {
const setQueueIxn = ix.aggregatorSetQueue(
this.program,
{
params: {},
},
{
aggregator: this.publicKey,
authority: params.authority ? params.authority.publicKey : payer,
queue: params.queueAccount.publicKey,
}
);
return new TransactionObject(
payer,
[setQueueIxn],
params.authority ? [params.authority] : [],
options
);
}
public async setQueue(
params: {
queueAccount: QueueAccount;
authority?: Keypair;
},
options?: SendTransactionObjectOptions
): Promise<TransactionSignature> {
const setQueueTxn = this.setQueueInstruction(
this.program.walletPubkey,
params,
options
);
const txnSignature = await this.program.signAndSend(setQueueTxn, options);
return txnSignature;
}
public addJobInstruction(
payer: PublicKey,
params: {
job: JobAccount;
weight?: number;
authority?: Keypair;
},
options?: TransactionObjectOptions
): TransactionObject {
const authority = params.authority ? params.authority.publicKey : payer;
const addJobIxn = ix.aggregatorAddJob(
this.program,
{ params: { weight: params.weight ?? 1 } },
{
aggregator: this.publicKey,
authority: authority,
job: params.job.publicKey,
}
);
return new TransactionObject(
payer,
[addJobIxn],
params.authority ? [params.authority] : [],
options
);
}
public async addJob(
params: {
job: JobAccount;
weight?: number;
authority?: Keypair;
},
options?: SendTransactionObjectOptions
): Promise<TransactionSignature> {
const txn = this.addJobInstruction(
this.program.walletPubkey,
params,
options
);
const txnSignature = await this.program.signAndSend(txn, options);
return txnSignature;
}
public lockInstruction(
payer: PublicKey,
params: {
authority?: Keypair;
},
options?: TransactionObjectOptions
): TransactionObject {
return new TransactionObject(
payer,
[
ix.aggregatorLock(
this.program,
{ params: {} },
{
aggregator: this.publicKey,
authority: params.authority ? params.authority.publicKey : payer,
}
),
],
params.authority ? [params.authority] : [],
options
);
}
public async lock(
params: {
authority?: Keypair;
},
options?: SendTransactionObjectOptions
): Promise<TransactionSignature> {
const lockTxn = this.lockInstruction(
this.program.walletPubkey,
params,
options
);
const txnSignature = await this.program.signAndSend(lockTxn, options);
return txnSignature;
}
public setAuthorityInstruction(
payer: PublicKey,
params: {
newAuthority: PublicKey;
authority?: Keypair;
},
options?: TransactionObjectOptions
): TransactionObject {
return new TransactionObject(
payer,
[
ix.aggregatorSetAuthority(
this.program,
{ params: {} },
{
aggregator: this.publicKey,
authority: params.authority ? params.authority.publicKey : payer,
newAuthority: params.newAuthority,
}
),
],
params.authority ? [params.authority] : [],
options
);
}
public async setAuthority(
params: {
newAuthority: PublicKey;
authority?: Keypair;
},
options?: SendTransactionObjectOptions
): Promise<TransactionSignature> {
const setAuthorityTxn = this.setAuthorityInstruction(
this.program.walletPubkey,
params,
options
);
const txnSignature = await this.program.signAndSend(
setAuthorityTxn,
options
);
return txnSignature;
}
public updateJobWeightInstruction(
payer: PublicKey,
params: {
job: JobAccount;
jobIdx: number;
weight: number;
authority?: Keypair;
},
options?: TransactionObjectOptions
): TransactionObject {
const removeJob = this.removeJobInstruction(
payer,
{
job: params.job,
jobIdx: params.jobIdx,
authority: params.authority,
},
options
);
const addJob = this.addJobInstruction(payer, {
job: params.job,
weight: params.weight,
authority: params.authority,
});
return removeJob.combine(addJob);
}
public async updateJobWeight(
params: {
job: JobAccount;
jobIdx: number;
weight: number;
authority?: Keypair;
},
options?: SendTransactionObjectOptions
): Promise<TransactionSignature> {
const transaction = this.updateJobWeightInstruction(
this.program.walletPubkey,
params,
options
);
const signature = await this.program.signAndSend(transaction, options);
return signature;
}
public removeJobInstruction(
payer: PublicKey,
params: {
job: JobAccount;
jobIdx: number;
authority?: Keypair;
},
options?: TransactionObjectOptions
): TransactionObject {
const authority = params.authority ? params.authority.publicKey : payer;
const removeJobIxn = ix.aggregatorRemoveJob(
this.program,
{ params: { jobIdx: params.jobIdx } },
{
aggregator: this.publicKey,
authority: authority,
job: params.job.publicKey,
}
);
return new TransactionObject(
payer,
[removeJobIxn],
params.authority ? [params.authority] : [],
options
);
}
public async removeJob(
params: {
job: JobAccount;
jobIdx: number;
authority?: Keypair;
},
options?: SendTransactionObjectOptions
): Promise<TransactionSignature> {
const removeJobTxn = this.removeJobInstruction(
this.program.walletPubkey,
params,
options
);
const txnSignature = await this.program.signAndSend(removeJobTxn, options);
return txnSignature;
}
public async openRoundInstruction(
payer: PublicKey,
params?: { payoutWallet?: PublicKey },
options?: TransactionObjectOptions
): Promise<TransactionObject> {
const aggregatorData = await this.loadData();
const queueAccount = new QueueAccount(
this.program,
aggregatorData.queuePubkey
);
const queue = await queueAccount.loadData();
const {
permissionAccount,
permissionBump,
leaseAccount,
leaseBump,
leaseEscrow,
} = this.getAccounts(queueAccount, queue.authority);
const ixns: Array<TransactionInstruction> = [];
const payoutWallet =
params?.payoutWallet ?? this.program.mint.getAssociatedAddress(payer);
const payoutWalletAccountInfo =
await this.program.connection.getAccountInfo(payoutWallet);
if (payoutWalletAccountInfo === null) {
const [createTokenAccountTxn] =
this.program.mint.createAssocatedUserInstruction(payer);
ixns.push(...createTokenAccountTxn.ixns);
}
ixns.push(
ix.aggregatorOpenRound(
this.program,
{
params: {
stateBump: this.program.programState.bump,
leaseBump,
permissionBump,
jitter: 0,
},
},
{
aggregator: this.publicKey,
lease: leaseAccount.publicKey,
oracleQueue: queueAccount.publicKey,
queueAuthority: queue.authority,
permission: permissionAccount.publicKey,
escrow: leaseEscrow,
programState: this.program.programState.publicKey,
payoutWallet: payoutWallet,
tokenProgram: TOKEN_PROGRAM_ID,
dataBuffer: queue.dataBuffer,
mint: this.program.mint.address,
}
)
);
return new TransactionObject(payer, ixns, [], options);
}
public async openRound(
params?: {
payoutWallet?: PublicKey;
},
options?: SendTransactionObjectOptions
): Promise<TransactionSignature> {
const openRoundTxn = await this.openRoundInstruction(
this.program.walletPubkey,
params,
options
);
const txnSignature = await this.program.signAndSend(openRoundTxn, options);
return txnSignature;
}
public quoteKeypairFromSeed(seed: PublicKey): Keypair {
const hash = createHash("sha256");
hash.update(Buffer.from("QuoteAccountData"));
hash.update(seed.toBuffer());
const kp = Keypair.fromSeed(hash.digest());
return kp;
}
public teeSaveResultInstructionSync(
payer: PublicKey,
params: AggregatorSaveResultSyncParams & {
quotePubkey?: PublicKey;
authority: Keypair;
},
options?: TransactionObjectOptions
): TransactionObject {
const [oraclePermissionAccount, oraclePermissionBump] =
params.oraclePermission;
const quote =
params.quotePubkey ??
this.quoteKeypairFromSeed(
params.oracles[params.oracleIdx].state.oracleAuthority
).publicKey;
const saveResultIxn = ix.aggregatorTeeSaveResult(
this.program,
{
params: {
// oracleIdx: params.oracleIdx,
// error: params.error ?? false,
value: SwitchboardDecimal.fromBig(params.value).borsh,
jobsChecksum: [...this.produceJobsHash(params.jobs).digest()],
minResponse: SwitchboardDecimal.fromBig(params.minResponse).borsh,
maxResponse: SwitchboardDecimal.fromBig(params.maxResponse).borsh,
feedPermissionBump: params.permissionBump,
oraclePermissionBump: oraclePermissionBump,
leaseBump: params.leaseBump,
stateBump: this.program.programState.bump,
},
},
{
aggregator: this.publicKey,
oracle: params.oracles[params.oracleIdx].account.publicKey,
oracleAuthority: params.oracles[params.oracleIdx].state.oracleAuthority,
oracleQueue: params.queueAccount.publicKey,
queueAuthority: params.queueAuthority,
feedPermission: params.permissionAccount.publicKey,
oraclePermission: oraclePermissionAccount.publicKey,
lease: params.leaseAccount.publicKey,
escrow: params.leaseEscrow,
tokenProgram: spl.TOKEN_PROGRAM_ID,
programState: this.program.programState.publicKey,
historyBuffer: params.historyBuffer ?? this.publicKey,
mint: this.program.mint.address,
slider: this.slidingWindowKey,
quote: quote,
rewardWallet: this.program.mint.getAssociatedAddress(payer),
payer: payer,
systemProgram: SystemProgram.programId,
}
);
const remainingAccounts: Array<PublicKey> = [];
params.oracles.forEach((oracle) =>
remainingAccounts.push(oracle.account.publicKey)
);
params.oracles.forEach((oracle) =>
remainingAccounts.push(oracle.state.tokenAccount)
);
remainingAccounts.push(this.slidingWindowKey);
saveResultIxn.keys.push(
...remainingAccounts.map((pubkey): AccountMeta => {
return { isSigner: false, isWritable: true, pubkey };
})
);
return new TransactionObject(
payer,
[saveResultIxn],
[params.authority],
options
);
}
public saveResultInstructionSync(
payer: PublicKey,
params: AggregatorSaveResultSyncParams,
options?: TransactionObjectOptions
): TransactionObject {
const [oraclePermissionAccount, oraclePermissionBump] =
params.oraclePermission;
if (params.oracleIdx < 0 || params.oracleIdx > params.oracles.length - 1) {
throw new Error("Failed to find oracle in current round");
}
const saveResultIxn = ix.aggregatorSaveResult(
this.program,
{
params: {
oracleIdx: params.oracleIdx,
error: params.error ?? false,
value: SwitchboardDecimal.fromBig(params.value).borsh,
jobsChecksum: [...this.produceJobsHash(params.jobs).digest()],
minResponse: SwitchboardDecimal.fromBig(params.minResponse).borsh,
maxResponse: SwitchboardDecimal.fromBig(params.maxResponse).borsh,
feedPermissionBump: params.permissionBump,
oraclePermissionBump: oraclePermissionBump,
leaseBump: params.leaseBump,
stateBump: this.program.programState.bump,
},
},
{
aggregator: this.publicKey,
oracle: params.oracles[params.oracleIdx].account.publicKey,
oracleAuthority: params.oracles[params.oracleIdx].state.oracleAuthority,
oracleQueue: params.queueAccount.publicKey,
queueAuthority: params.queueAuthority,
feedPermission: params.permissionAccount.publicKey,
oraclePermission: oraclePermissionAccount.publicKey,
lease: params.leaseAccount.publicKey,
escrow: params.leaseEscrow,
tokenProgram: spl.TOKEN_PROGRAM_ID,
programState: this.program.programState.publicKey,
historyBuffer: params.historyBuffer ?? this.publicKey,
mint: this.program.mint.address,
}
);
const remainingAccounts: Array<PublicKey> = [];
params.oracles.forEach((oracle) =>
remainingAccounts.push(oracle.account.publicKey)
);
params.oracles.forEach((oracle) =>
remainingAccounts.push(oracle.state.tokenAccount)
);
remainingAccounts.push(this.slidingWindowKey);
saveResultIxn.keys.push(
...remainingAccounts.map((pubkey): AccountMeta => {
return { isSigner: false, isWritable: true, pubkey };
})
);
return new TransactionObject(payer, [saveResultIxn], [], options);
}
public async saveResultInstruction(
payer: PublicKey,
params: AggregatorSaveResultAsyncParams,
options?: TransactionObjectOptions
): Promise<TransactionObject> {
const aggregator = params.aggregator ?? (await this.loadData());
const oracles =
params.oracles ?? (await this.loadCurrentRoundOracles(aggregator));
const oracleIdx =
params.oracleIdx ??
oracles.findIndex((o) =>
o.account.publicKey.equals(params.oracleAccount.publicKey)
);
if (oracleIdx < 0 || oracleIdx > oracles.length - 1) {
throw new Error("Failed to find oracle in current round");
}
const queueAccount =
params.queueAccount ??
new QueueAccount(this.program, aggregator.queuePubkey);
const queueAuthority =
params.queueAuthority ?? (await queueAccount.loadData()).authority;
const [oraclePermissionAccount, oraclePermissionBump] =
params.oraclePermission ??
params.oracleAccount.getPermissionAccount(
queueAccount.publicKey,
queueAuthority
);
const accounts: AggregatorPdaAccounts =
params.permissionAccount === undefined ||
params.leaseAccount === undefined ||
params.leaseEscrow === undefined ||
params.permissionBump === undefined ||
params.leaseBump === undefined
? this.getAccounts(queueAccount, queueAuthority)
: {
permissionAccount: params.permissionAccount,
permissionBump: params.permissionBump,
leaseAccount: params.leaseAccount,
leaseBump: params.leaseBump,
leaseEscrow: params.leaseEscrow,
};
const saveResultTxn = this.saveResultInstructionSync(
payer,
{
...accounts,
queueAccount,
queueAuthority,
jobs: params.jobs,
historyBuffer: aggregator.historyBuffer.equals(PublicKey.default)
? undefined
: aggregator.historyBuffer,
oracleIdx,
oraclePermission: [oraclePermissionAccount, oraclePermissionBump],
value: params.value,
minResponse: params.minResponse,
maxResponse: params.maxResponse,
error: params.error ?? false,
aggregator: aggregator,
oracles: oracles,
},
options
);
return saveResultTxn;
}
public async saveResult(
params: AggregatorSaveResultAsyncParams,
options?: SendTransactionObjectOptions
): Promise<TransactionSignature> {
const saveResultTxn = await this.saveResultInstruction(
this.program.walletPubkey,
params,
options
);
const txnSignature = await this.program.signAndSend(saveResultTxn, options);
return txnSignature;
}
public async fetchAccounts(
_aggregator?: AggregatorAccountData,
_queueAccount?: QueueAccount,
_queue?: OracleQueueAccountData,
commitment: Commitment = "confirmed"
): Promise<AggregatorAccounts> {
const aggregator = _aggregator ?? (await this.loadData());
const queueAccount =
_queueAccount ?? new QueueAccount(this.program, aggregator.queuePubkey);
const queue = _queue ?? (await queueAccount.loadData());
const {
permissionAccount,
permissionBump,
leaseAccount,
leaseEscrow,
leaseBump,
} = this.getAccounts(queueAccount, queue.authority);
const jobPubkeys = aggregator.jobPubkeysData.slice(
0,
aggregator.jobPubkeysSize
);
const accountInfos = await anchor.utils.rpc.getMultipleAccounts(
this.program.connection,
[
permissionAccount.publicKey,
leaseAccount.publicKey,
leaseEscrow,
...jobPubkeys,
],
commitment
);
const permissionAccountInfo = accountInfos.shift();
if (!permissionAccountInfo || !permissionAccountInfo.account) {
throw new Error(
`PermissionAccount has not been created yet for this aggregator`
);
}
const permission = PermissionAccountData.decode(
permissionAccountInfo.account.data
);
const leaseAccountInfo = accountInfos.shift();
if (!leaseAccountInfo || !leaseAccountInfo.account) {
throw new Error(
`LeaseAccount has not been created yet for this aggregator`
);
}
const lease = LeaseAccountData.decode(leaseAccountInfo.account.data);
const leaseEscrowAccountInfo = accountInfos.shift();
if (!leaseEscrowAccountInfo || !leaseEscrowAccountInfo.account) {
throw new Error(
`LeaseAccount escrow has not been created yet for this aggregator`
);
}
const leaseEscrowAccount = spl.unpackAccount(
leaseEscrow,
leaseEscrowAccountInfo.account
);
const jobs: Array<{
publicKey: PublicKey;
data: JobAccountData;
tasks: Array<OracleJob.ITask>;
}> = [];
accountInfos.map((accountInfo) => {
if (!accountInfo || !accountInfo.account) {
throw new Error(`Failed to fetch JobAccount`);
}
const job = JobAccountData.decode(accountInfo.account.data);
const oracleJob = OracleJob.decodeDelimited(job.data);
jobs.push({
publicKey: accountInfo.publicKey,
data: job,
tasks: oracleJob.tasks,
});
});
return {
aggregator: {
publicKey: this.publicKey,
data: aggregator,
},
queue: {
publicKey: queueAccount.publicKey,
data: queue,
},
permission: {
publicKey: permissionAccount.publicKey,
bump: permissionBump,
data: permission,
},
lease: {
publicKey: leaseAccount.publicKey,
bump: leaseBump,
data: lease,
balance: this.program.mint.fromTokenAmount(leaseEscrowAccount.amount),
},
jobs: jobs,
};
}
public async toAccountsJSON(
_aggregator?: AggregatorAccountData,
_queueAccount?: QueueAccount,
_queue?: OracleQueueAccountData
): Promise<AggregatorAccountsJSON> {
const accounts = await this.fetchAccounts(
_aggregator,
_queueAccount,
_queue
);
return {
publicKey: this.publicKey,
...accounts.aggregator.data.toJSON(),
queue: {
publicKey: accounts.queue.publicKey,
...accounts.queue.data.toJSON(),
},
permission: {
publicKey: accounts.permission.publicKey,
...accounts.permission.data.toJSON(),
bump: accounts.permission.bump,
},
lease: {
publicKey: accounts.lease.publicKey,
...accounts.lease.data.toJSON(),
bump: accounts.lease.bump,
balance: accounts.lease.balance,
},
jobs: accounts.jobs.map((j) => {
return {
publicKey: j.publicKey,
...j.data.toJSON(),
tasks: j.tasks,
};
}),
};
}
setSlidingWindowInstruction(
payer: PublicKey,
params: {
authority?: Keypair;
mode: AggregatorResolutionModeKind;
},
options?: TransactionObjectOptions
): TransactionObject {
return new TransactionObject(
payer,
[
ix.aggregatorSetResolutionMode(
this.program,
{
params: { mode: params.mode.discriminator },
},
{
aggregator: this.publicKey,
authority: params.authority ? params.authority.publicKey : payer,
slidingWindow: this.slidingWindowKey,
payer: payer,
systemProgram: SystemProgram.programId,
}
),
],
params.authority ? [params.authority] : [],
options
);
}
async setSlidingWindow(
params: {
authority?: Keypair;
mode: AggregatorResolutionModeKind;
},
options?: TransactionObjectOptions
): Promise<TransactionSignature> {
const setSlidingWindowTxn = this.setSlidingWindowInstruction(
this.program.walletPubkey,
params,
options
);
const txnSignature = await this.program.signAndSend(setSlidingWindowTxn);
return txnSignature;
}
async openRoundAndAwaitResult(
params?: { payoutWallet?: PublicKey } & {
aggregator?: AggregatorAccountData;
},
timeout = 30000,
options?: TransactionObjectOptions
): Promise<[AggregatorAccountData, TransactionSignature | undefined]> {
const aggregator = params?.aggregator ?? (await this.loadData());
const currentRoundOpenSlot = aggregator.latestConfirmedRound.roundOpenSlot;
let ws: number | undefined = undefined;
const closeWebsocket = async () => {
if (ws !== undefined) {
await this.program.connection.removeAccountChangeListener(ws);
ws = undefined;
}
};
const statePromise: Promise<AggregatorAccountData> = promiseWithTimeout(
timeout,
new Promise((resolve: (result: AggregatorAccountData) => void) => {
ws = this.onChange((aggregator) => {
// if confirmed round slot larger than last open slot
// AND sliding window mode or sufficient oracle results
if (
aggregator.latestConfirmedRound.roundOpenSlot.gt(
currentRoundOpenSlot
) &&
(aggregator.resolutionMode.kind ===
AggregatorResolutionMode.ModeSlidingResolution.kind ||
(aggregator.latestConfirmedRound.numSuccess ?? 0) >=
aggregator.minOracleResults)
) {
resolve(aggregator);
}
});
})
).finally(async () => {
await closeWebsocket();
});
const openRoundSignature = await this.openRound(params, options).catch(
async (error) => {
await closeWebsocket();
throw new Error(`Failed to call openRound, ${error}`);
}
);
const state = await statePromise;
await closeWebsocket();
return [state, openRoundSignature];
}
/**
* Await for the next round to close and return the aggregator round result
*
* @param roundOpenSlot - optional, the slot when the current round was opened. if not provided then it will be loaded.
* @param timeout - the number of milliseconds to wait for the round to close
*
* @throws {string} when the timeout interval is exceeded or when the latestConfirmedRound.roundOpenSlot exceeds the target roundOpenSlot
*/
async nextRound(
roundOpenSlot?: BN,
timeout = 30000
): Promise<AggregatorAccountData> {
const slot =
roundOpenSlot ?? (await this.loadData()).currentRound.roundOpenSlot;
let ws: number | undefined;
let result: AggregatorAccountData;
try {
result = await promiseWithTimeout(
timeout,
new Promise((resolve: (result: AggregatorAccountData) => void) => {
ws = this.onChange((aggregator) => {
if (aggregator.latestConfirmedRound.roundOpenSlot.eq(slot)) {
resolve(aggregator);
}
});
})
);
} finally {
if (ws) {
await this.program.connection.removeAccountChangeListener(ws);
}
}
return result;
}
/**
* Load an aggregators {@linkcode AggregatorHistoryBuffer}.
* @return the list of historical samples attached to the aggregator.
*/
async loadHistory(
startTimestamp?: number,
endTimestamp?: number
): Promise<Array<AggregatorHistoryRow>> {
if (!this.history) {
this.history = new AggregatorHistoryBuffer(
this.program,
(await this.loadData()).historyBuffer
);
}
const history = await this.history.loadData(startTimestamp, endTimestamp);
return history;
}
static async fetchMultiple(
program: SwitchboardProgram,
publicKeys: Array<PublicKey>,
commitment: Commitment = "confirmed"
): Promise<
Array<{
account: AggregatorAccount;
data: AggregatorAccountData;
}>
> {
const aggregators: Array<{
account: AggregatorAccount;
data: AggregatorAccountData;
}> = [];
const accountInfos = await anchor.utils.rpc.getMultipleAccounts(
program.connection,
publicKeys,
commitment
);
for (const accountInfo of accountInfos) {
if (!accountInfo?.publicKey) {
continue;
}
try {
const account = new AggregatorAccount(program, accountInfo.publicKey);
const data = AggregatorAccountData.decode(accountInfo.account.data);
aggregators.push({ account, data });
// eslint-disable-next-line no-empty
} catch {}
}
return aggregators;
}
/**
* Calculates the required priority fee for a given aggregator
*
* Multiplier = the minimum of maxPriorityFeeMultiplier and (timestamp - lastUpdatedTimestamp) / priorityFeeBumpPeriod
* Fee = baseFee + basePriorityFee + priorityFeeBump * multiplier
*
* @param aggregator - the current aggregator state including its last updated timestamp and priority fee config
* @param timestamp - optional, the current unix timestamp. can provide the SolanaClock timestamp for better accuracy
* @param baseFee - optional, the Solana compute unit base fee
*
* @returns the solana priority fee to include in the save_result action
*/
public static calculatePriorityFee(
aggregator: AggregatorAccountData,
timestamp = Math.round(Date.now() / 1000),
baseFee = 0 // base compute unit price
): number {
// parse defaults
const lastUpdateTimestamp =
aggregator.latestConfirmedRound.roundOpenTimestamp.gt(new BN(0))
? aggregator.latestConfirmedRound.roundOpenTimestamp.toNumber()
: timestamp; // on first update this would cause max multiplier
const priorityFeeBumpPeriod = Math.max(1, aggregator.priorityFeeBumpPeriod); // cant divide by 0
const maxPriorityFeeMultiplier = Math.max(
1,
aggregator.maxPriorityFeeMultiplier
);
// calculate staleness multiplier
const multiplier = Math.min(
(timestamp - lastUpdateTimestamp) / priorityFeeBumpPeriod,
maxPriorityFeeMultiplier
);
const feeBump = aggregator.priorityFeeBump * multiplier;
const fee = baseFee + aggregator.basePriorityFee + feeBump;
if (Number.isNaN(fee)) {
return 0;
}
// Should we enforce some upper limit? Like 1 SOL?
// Probably not, gives MEV bots a floor
return Math.round(fee);
}
/** Fetch the balance of an aggregator's lease */
public async fetchBalance(
leaseEscrow?: PublicKey,
queuePubkey?: PublicKey
): Promise<number> {
const escrowPubkey =
leaseEscrow ??
this.getLeaseAccount(
queuePubkey ?? (await this.loadData()).queuePubkey
)[1];
const escrowBalance = await this.program.mint.fetchBalance(escrowPubkey);
if (escrowBalance === null) {
throw new errors.AccountNotFoundError("Lease Escrow", escrowPubkey);
}
return escrowBalance;
}
/** Create a transaction object that will fund an aggregator's lease up to a given balance */
public async fundUpToInstruction(
payer: PublicKey,
fundUpTo: number,
disableWrap = false
): Promise<[TransactionObject | undefined, number | undefined]> {
const [leaseAccount, leaseEscrow] = this.getLeaseAccount(
(await this.loadData()).queuePubkey
);
const balance = await this.fetchBalance(leaseEscrow);
if (balance >= fundUpTo) {
return [undefined, undefined];
}
const fundAmount = fundUpTo - balance;
const leaseExtend = await leaseAccount.extendInstruction(payer, {
fundAmount,
disableWrap,
});
return [leaseExtend, fundAmount];
}
/** Fund an aggregator's lease up to a given balance */
public async fundUpTo(
payer: PublicKey,
fundUpTo: number,
disableWrap = false
): Promise<[TransactionSignature | undefined, number | undefined]> {
const [fundUpToTxn, fundAmount] = await this.fundUpToInstruction(
payer,
fundUpTo,
disableWrap
);
if (!fundUpToTxn) {
return [undefined, undefined];
}
const txnSignature = await this.program.signAndSend(fundUpToTxn);
return [txnSignature, fundAmount!];
}
/** Create a set of transactions that will fund an aggregator's lease up to a given balance */
public static async fundMultipleUpToInstructions(
payer: PublicKey,
fundUpTo: number,
aggregators: Array<AggregatorAccount>,
options?: TransactionPackOptions | undefined
): Promise<Array<TransactionObject>> {
if (aggregators.length === 0) {
throw new Error(`No aggregator accounts provided`);
}
const program = aggregators[0].program;
const txns: Array<TransactionObject> = [];
let wrapAmount = 0;
for (const aggregator of aggregators) {
const [depositTxn, depositAmount] = await aggregator.fundUpToInstruction(
payer,
fundUpTo,
true
);
if (depositTxn && depositAmount) {
txns.push(depositTxn);
wrapAmount = wrapAmount + depositAmount;
}
}
const [_, wrapTxn] = await program.mint.getOrCreateWrappedUserInstructions(
payer,
{
fundUpTo: wrapAmount,
}
);
if (wrapTxn) {
txns.unshift(wrapTxn);
}
return TransactionObject.pack(txns, options);
}
/** Fund multiple aggregator account lease's up to a given balance */
public static async fundMultipleUpTo(
fundUpTo: number,
aggregators: Array<AggregatorAccount>,
options?: TransactionPackOptions | undefined
): Promise<Array<TransactionSignature>> {
if (aggregators.length === 0) {
throw new Error(`No aggregator accounts provided`);
}
const program = aggregators[0].program;
const txns = await AggregatorAccount.fundMultipleUpToInstructions(
program.walletPubkey,
fundUpTo,
aggregators,
options
);
const txnSignatures = await program.signAndSendAll(txns);
return txnSignatures;
}
public async closeInstructions(
payer: PublicKey,
params?: {
authority?: Keypair;
tokenWallet?: PublicKey;
},
opts?: TransactionObjectOptions
): Promise<TransactionObject> {
if (this.program.cluster === "mainnet-beta") {
throw new Error(
`Aggregators can only be closed with the devnet version of Switchboard`
);
}
const [tokenWallet, tokenWalletInit] = params?.tokenWallet
? [params.tokenWallet, undefined]
: await this.program.mint.getOrCreateWrappedUserInstructions(payer, {
fundUpTo: 0,
});
const aggregator = await this.loadData();
const [queueAccount, queue] = await QueueAccount.load(
this.program,
aggregator.queuePubkey
);
const slidingWindowKey = this.slidingWindowKey;
const slidingWindowAccountInfo =
await this.program.connection.getAccountInfo(slidingWindowKey);
const {
permissionAccount,
permissionBump,
leaseAccount,
leaseBump,
leaseEscrow,
} = this.getAccounts(queueAccount, queue.authority);
const crankPubkey: PublicKey | null = aggregator.crankPubkey.equals(
PublicKey.default
)
? null
: aggregator.crankPubkey;
let dataBuffer: PublicKey | null = null;
if (crankPubkey !== null) {
const [crankAccount, crank] = await CrankAccount.load(
this.program,
crankPubkey
);
dataBuffer = crank.dataBuffer;
}
const accounts = {
authority: aggregator.authority,
aggregator: this.publicKey,
permission: permissionAccount.publicKey,
lease: leaseAccount.publicKey,
escrow: leaseEscrow,
oracleQueue: queueAccount.publicKey,
queueAuthority: queue.authority,
programState: queueAccount.program.programState.publicKey,
solDest: payer,
escrowDest: tokenWallet,
tokenProgram: TOKEN_PROGRAM_ID,
};
if (crankPubkey !== null && dataBuffer !== null) {
accounts["crank"] = crankPubkey;
accounts["dataBuffer"] = dataBuffer;
} else {
accounts["crank"] = null;
accounts["dataBuffer"] = null;
}
if (slidingWindowAccountInfo !== null) {
accounts["slidingWindow"] = slidingWindowKey;
} else {
accounts["slidingWindow"] = null;
}
const closeIxn = await (
(this.program as any)._program as anchor.Program
).methods
.aggregatorClose({
stateBump: this.program.programState.bump,
permissionBump: permissionBump,
leaseBump: leaseBump,
})
.accounts(
accounts as any // compiler expects all types to be pubkeys
)
.instruction();
const closeTxn = tokenWalletInit
? tokenWalletInit.add(
closeIxn,
params?.authority ? [params.authority] : undefined
)
: new TransactionObject(
payer,
[closeIxn],
params?.authority ? [params.authority] : []
);
// add txn options
return new TransactionObject(
closeTxn.payer,
closeTxn.ixns,
closeTxn.signers,
opts
);
}
public async close(
params?: {
authority?: Keypair;
tokenWallet?: PublicKey;
},
opts?: TransactionObjectOptions
): Promise<TransactionSignature> {
const closeTxn = await this.closeInstructions(
this.program.walletPubkey,
params,
opts
);
const txnSignature = await this.program.signAndSend(closeTxn);
return txnSignature;
}
}
/**
* Parameters to initialize an aggregator account.
*/
export interface AggregatorInitParams {
/**
* Name of the aggregator to store on-chain.
*/
name?: string;
/**
* Metadata of the aggregator to store on-chain.
*/
metadata?: string;
/**
* Number of oracles to request on aggregator update.
*/
batchSize: number;
/**
* Minimum number of oracle responses required before a round is validated.
*/
minRequiredOracleResults: number;
/**
* Minimum number of feed jobs suggested to be successful before an oracle
* sends a response.
*/
minRequiredJobResults: number;
/**
* Minimum number of seconds required between aggregator rounds.
*/
minUpdateDelaySeconds: number;
/**
* unix_timestamp for which no feed update will occur before.
*/
startAfter?: number;
/**
* Change percentage required between a previous round and the current round.
* If variance percentage is not met, reject new oracle responses.
*/
varianceThreshold?: number;
/**
* Number of seconds for which, even if the variance threshold is not passed,
* accept new responses from oracles.
*/
forceReportPeriod?: number;
/**
* unix_timestamp after which funds may be withdrawn from the aggregator.
* null/undefined/0 means the feed has no expiration.
*/
expiration?: number;
/**
* If true, this aggregator is disallowed from being updated by a crank on the queue.
*/
disableCrank?: boolean;
/**
* Optional pre-existing keypair to use for aggregator initialization.
*/
keypair?: Keypair;
/**
* If included, this keypair will be the aggregator authority rather than
* the aggregator keypair.
*/
authority?: PublicKey;
/**
* The queue to which this aggregator will be linked
*/
queueAccount: QueueAccount;
/**
* The authority of the queue.
*/
queueAuthority: PublicKey;
}
export interface AggregatorSetQueueParams {
queueAccount: QueueAccount;
authority?: Keypair;
}
/**
* Parameters required to open an aggregator round
*/
export interface AggregatorOpenRoundParams {
/**
* The oracle queue from which oracles are assigned this update.
*/
oracleQueueAccount: QueueAccount;
/**
* The token wallet which will receive rewards for calling update on this feed.
*/
payoutWallet: PublicKey;
}
/**
* Parameters for creating and setting a history buffer for an aggregator
*/
export interface AggregatorSetHistoryBufferParams {
/**
* Authority keypair for the aggregator.
*/
authority?: Keypair;
/**
* Number of elements for the history buffer to fit.
*/
size: number;
}
/**
* Parameters for which oracles must submit for responding to update requests.
*/
export interface AggregatorSaveResultParams {
/**
* Index in the list of oracles in the aggregator assigned to this round update.
*/
oracleIdx: number;
/**
* Reports that an error occured and the oracle could not send a value.
*/
error: boolean;
/**
* Value the oracle is responding with for this update.
*/
value: Big;
/**
* The minimum value this oracle has seen this round for the jobs listed in the
* aggregator.
*/
minResponse: Big;
/**
* The maximum value this oracle has seen this round for the jobs listed in the
* aggregator.
*/
maxResponse: Big;
/**
* List of OracleJobs that were performed to produce this result.
*/
jobs: Array<OracleJob>;
/**
* Authority of the queue the aggregator is attached to.
*/
queueAuthority: PublicKey;
/**
* Program token mint.
*/
tokenMint: PublicKey;
/**
* List of parsed oracles.
*/
oracles: Array<OracleAccountData>;
}
export type AggregatorAccountsJSON = AggregatorAccountDataJSON & {
publicKey: PublicKey;
queue: OracleQueueAccountDataJSON & { publicKey: PublicKey };
permission: PermissionAccountDataJSON & {
bump: number;
publicKey: PublicKey;
};
lease: LeaseAccountDataJSON & { bump: number; publicKey: PublicKey } & {
balance: number;
};
jobs: Array<
JobAccountDataJSON & {
publicKey: PublicKey;
tasks: Array<OracleJob.ITask>;
}
>;
};
export type AggregatorAccounts = {
aggregator: {
publicKey: PublicKey;
data: AggregatorAccountData;
};
queue: {
publicKey: PublicKey;
data: OracleQueueAccountData;
};
permission: {
publicKey: PublicKey;
bump: number;
data: PermissionAccountData;
};
lease: {
publicKey: PublicKey;
bump: number;
balance: number;
data: LeaseAccountData;
};
jobs: Array<{
publicKey: PublicKey;
data: JobAccountData;
tasks: Array<OracleJob.ITask>;
}>;
};
export type AggregatorPdaAccounts = {
permissionAccount: PermissionAccount;
permissionBump: number;
leaseAccount: LeaseAccount;
leaseBump: number;
leaseEscrow: PublicKey;
};
export type SaveResultResponse = {
jobs: Array<OracleJob>;
// oracleAccount: OracleAccount;
value: Big;
minResponse: Big;
maxResponse: Big;
error?: boolean;
};
export type SaveResultAccounts = AggregatorPdaAccounts & {
aggregator: AggregatorAccountData;
// queue
queueAccount: QueueAccount;
queueAuthority: PublicKey;
// oracle
oraclePermission: [PermissionAccount, number];
oracles: Array<{ account: OracleAccount; state: OracleAccountData }>;
oracleIdx: number;
// history
historyBuffer?: PublicKey;
};
export type AggregatorSaveResultSyncParams = SaveResultResponse &
SaveResultAccounts;
export type AggregatorSaveResultAsyncParams = SaveResultResponse &
(Partial<SaveResultAccounts> & { oracleAccount: OracleAccount });
Reference in New Issue View Git Blame Copy Permalink