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

package/dist/chunk-K2DZLHPZ.cjs

@@ -0,0 +1,4573 @@
+'use strict';
+
+var chunkGXZYS537_cjs = require('./chunk-GXZYS537.cjs');
+var chunkO7I5CWRX_cjs = require('./chunk-O7I5CWRX.cjs');
+var kit = require('@solana/kit');
+var Decimal4 = require('decimal.js');
+var BN10 = require('bn.js');
+var scopeSdk = require('@kamino-finance/scope-sdk');
+var OraclePrices = require('@kamino-finance/scope-sdk/dist/@codegen/scope/accounts/OraclePrices');
+var kliquiditySdk = require('@kamino-finance/kliquidity-sdk');
+var borsh28 = require('@coral-xyz/borsh');
+var buffer = require('buffer');
+var axios = require('axios');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var Decimal4__default = /*#__PURE__*/_interopDefault(Decimal4);
+var BN10__default = /*#__PURE__*/_interopDefault(BN10);
+var borsh28__namespace = /*#__PURE__*/_interopNamespace(borsh28);
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+
+var PROGRAM_ID_CLI = kit.address(
+  "KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD"
+);
+var PROGRAM_ID = PROGRAM_ID_CLI;
+var DEFAULT_PUBLIC_KEY = kit.address("11111111111111111111111111111111");
+var WRAPPED_SOL_MINT = kit.address("So11111111111111111111111111111111111111112");
+var NULL_PUBKEY = kit.address("nu11111111111111111111111111111111111111111");
+var COMPUTE_BUDGET_PROGRAM_ID = kit.address("ComputeBudget111111111111111111111111111111");
+function isNotNullPubkey(pubkey) {
+  return pubkey && pubkey !== NULL_PUBKEY && pubkey !== DEFAULT_PUBLIC_KEY;
+}
+var STAGING_PROGRAM_ID = kit.address("SLendK7ySfcEzyaFqy93gDnD3RtrpXJcnRwb6zFHJSh");
+var DEFAULT_KLEND_PROGRAM_ID = PROGRAM_ID.toString();
+var U64_MAX = "18446744073709551615";
+var INITIAL_COLLATERAL_RATIO = 1;
+var INITIAL_COLLATERAL_RATE = new Decimal4__default.default(INITIAL_COLLATERAL_RATIO);
+var SECONDS_PER_YEAR = 365.242199 * 24 * 60 * 60;
+var TOTAL_NUMBER_OF_IDS_TO_CHECK = 25;
+function isENV(value) {
+  return value === "mainnet-beta" || value === "devnet" || value === "localnet";
+}
+function getApiEndpoint(programId, apiBaseUrl = "https://api.kamino.finance") {
+  if (programId === PROGRAM_ID) {
+    return `${apiBaseUrl}/v2/kamino-market`;
+  } else {
+    return `${apiBaseUrl}/v2/kamino-market/?programId=${programId.toString()}`;
+  }
+}
+var CDN_ENDPOINT = "https://cdn.kamino.finance";
+var ONE_HUNDRED_PCT_IN_BPS = 1e4;
+function getProgramId(env = "mainnet-beta") {
+  if (env === "mainnet-beta") {
+    return PROGRAM_ID;
+  } else {
+    return STAGING_PROGRAM_ID;
+  }
+}
+var SLOTS_PER_SECOND = 2;
+var SLOTS_PER_MINUTE = SLOTS_PER_SECOND * 60;
+var SLOTS_PER_HOUR = SLOTS_PER_MINUTE * 60;
+var SLOTS_PER_DAY = SLOTS_PER_HOUR * 24;
+var SLOTS_PER_YEAR = SLOTS_PER_DAY * 365;
+var MIN_AUTODELEVERAGE_BONUS_BPS = 50;
+var SOL_DECIMALS = 9;
+var BORROWS_LIMIT = 5;
+var DEPOSITS_LIMIT = 8;
+var DEFAULT_MAX_COMPUTE_UNITS = 14e5;
+var SOL_PADDING_FOR_INTEREST = new BN10__default.default("1000000");
+var MIN_INITIAL_DEPOSIT = 1e5;
+var MIN_VAULT_INITIAL_DEPOSIT = 1e9;
+var VAULT_INITIAL_DEPOSIT = 1e3;
+
+// src/utils/slots.ts
+function toSeconds(slots) {
+  return Math.trunc(slots / SLOTS_PER_SECOND);
+}
+function toHours(slots) {
+  return Math.trunc(slots / SLOTS_PER_HOUR);
+}
+function toDays(slots) {
+  return Math.trunc(slots / SLOTS_PER_DAY);
+}
+
+// src/@codegen/pyth_rec/utils/borshAddress.ts
+var import_buffer_layout = chunkO7I5CWRX_cjs.__toESM(chunkGXZYS537_cjs.require_Layout(), 1);
+var addressCodec = kit.getAddressCodec();
+function borshAddress(property) {
+  return new WrappedLayout(
+    (0, import_buffer_layout.blob)(32),
+    (b) => addressCodec.decode(b),
+    (addr) => Buffer.from(addressCodec.encode(addr)),
+    property
+  );
+}
+var WrappedLayout = class extends import_buffer_layout.Layout {
+  layout;
+  decoder;
+  encoder;
+  constructor(layout4, decoder, encoder, property) {
+    super(layout4.span, property);
+    this.layout = layout4;
+    this.decoder = decoder;
+    this.encoder = encoder;
+  }
+  decode(b, offset) {
+    return this.decoder(this.layout.decode(b, offset));
+  }
+  encode(src, b, offset) {
+    return this.layout.encode(this.encoder(src), b, offset);
+  }
+  getSpan(b, offset) {
+    return this.layout.getSpan(b, offset);
+  }
+};
+
+// src/@codegen/pyth_rec/types/VerificationLevel.ts
+var VerificationLevel_exports = {};
+chunkO7I5CWRX_cjs.__export(VerificationLevel_exports, {
+  Full: () => Full,
+  Partial: () => Partial,
+  fromDecoded: () => fromDecoded,
+  fromJSON: () => fromJSON,
+  layout: () => layout
+});
+var Partial = class {
+  static discriminator = 0;
+  static kind = "Partial";
+  discriminator = 0;
+  kind = "Partial";
+  value;
+  constructor(value) {
+    this.value = {
+      numSignatures: value.numSignatures
+    };
+  }
+  toJSON() {
+    return {
+      kind: "Partial",
+      value: {
+        numSignatures: this.value.numSignatures
+      }
+    };
+  }
+  toEncodable() {
+    return {
+      Partial: {
+        numSignatures: this.value.numSignatures
+      }
+    };
+  }
+};
+var Full = class {
+  static discriminator = 1;
+  static kind = "Full";
+  discriminator = 1;
+  kind = "Full";
+  toJSON() {
+    return {
+      kind: "Full"
+    };
+  }
+  toEncodable() {
+    return {
+      Full: {}
+    };
+  }
+};
+function fromDecoded(obj) {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object");
+  }
+  if ("Partial" in obj) {
+    const val = obj["Partial"];
+    return new Partial({
+      numSignatures: val["numSignatures"]
+    });
+  }
+  if ("Full" in obj) {
+    return new Full();
+  }
+  throw new Error("Invalid enum object");
+}
+function fromJSON(obj) {
+  switch (obj.kind) {
+    case "Partial": {
+      return new Partial({
+        numSignatures: obj.value.numSignatures
+      });
+    }
+    case "Full": {
+      return new Full();
+    }
+  }
+}
+function layout(property) {
+  const ret = borsh28__namespace.rustEnum([
+    borsh28__namespace.struct([borsh28__namespace.u8("numSignatures")], "Partial"),
+    borsh28__namespace.struct([], "Full")
+  ]);
+  if (property !== void 0) {
+    return ret.replicate(property);
+  }
+  return ret;
+}
+var PriceFeedMessage = class _PriceFeedMessage {
+  feedId;
+  price;
+  conf;
+  exponent;
+  publishTime;
+  prevPublishTime;
+  emaPrice;
+  emaConf;
+  constructor(fields) {
+    this.feedId = fields.feedId;
+    this.price = fields.price;
+    this.conf = fields.conf;
+    this.exponent = fields.exponent;
+    this.publishTime = fields.publishTime;
+    this.prevPublishTime = fields.prevPublishTime;
+    this.emaPrice = fields.emaPrice;
+    this.emaConf = fields.emaConf;
+  }
+  static layout(property) {
+    return borsh28__namespace.struct(
+      [
+        borsh28__namespace.array(borsh28__namespace.u8(), 32, "feedId"),
+        borsh28__namespace.i64("price"),
+        borsh28__namespace.u64("conf"),
+        borsh28__namespace.i32("exponent"),
+        borsh28__namespace.i64("publishTime"),
+        borsh28__namespace.i64("prevPublishTime"),
+        borsh28__namespace.i64("emaPrice"),
+        borsh28__namespace.u64("emaConf")
+      ],
+      property
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj) {
+    return new _PriceFeedMessage({
+      feedId: obj.feedId,
+      price: obj.price,
+      conf: obj.conf,
+      exponent: obj.exponent,
+      publishTime: obj.publishTime,
+      prevPublishTime: obj.prevPublishTime,
+      emaPrice: obj.emaPrice,
+      emaConf: obj.emaConf
+    });
+  }
+  static toEncodable(fields) {
+    return {
+      feedId: fields.feedId,
+      price: fields.price,
+      conf: fields.conf,
+      exponent: fields.exponent,
+      publishTime: fields.publishTime,
+      prevPublishTime: fields.prevPublishTime,
+      emaPrice: fields.emaPrice,
+      emaConf: fields.emaConf
+    };
+  }
+  toJSON() {
+    return {
+      feedId: this.feedId,
+      price: this.price.toString(),
+      conf: this.conf.toString(),
+      exponent: this.exponent,
+      publishTime: this.publishTime.toString(),
+      prevPublishTime: this.prevPublishTime.toString(),
+      emaPrice: this.emaPrice.toString(),
+      emaConf: this.emaConf.toString()
+    };
+  }
+  static fromJSON(obj) {
+    return new _PriceFeedMessage({
+      feedId: obj.feedId,
+      price: new BN10__default.default(obj.price),
+      conf: new BN10__default.default(obj.conf),
+      exponent: obj.exponent,
+      publishTime: new BN10__default.default(obj.publishTime),
+      prevPublishTime: new BN10__default.default(obj.prevPublishTime),
+      emaPrice: new BN10__default.default(obj.emaPrice),
+      emaConf: new BN10__default.default(obj.emaConf)
+    });
+  }
+  toEncodable() {
+    return _PriceFeedMessage.toEncodable(this);
+  }
+};
+var TwapPrice = class _TwapPrice {
+  feedId;
+  startTime;
+  endTime;
+  price;
+  conf;
+  exponent;
+  /**
+   * 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;
+  constructor(fields) {
+    this.feedId = fields.feedId;
+    this.startTime = fields.startTime;
+    this.endTime = fields.endTime;
+    this.price = fields.price;
+    this.conf = fields.conf;
+    this.exponent = fields.exponent;
+    this.downSlotsRatio = fields.downSlotsRatio;
+  }
+  static layout(property) {
+    return borsh28__namespace.struct(
+      [
+        borsh28__namespace.array(borsh28__namespace.u8(), 32, "feedId"),
+        borsh28__namespace.i64("startTime"),
+        borsh28__namespace.i64("endTime"),
+        borsh28__namespace.i64("price"),
+        borsh28__namespace.u64("conf"),
+        borsh28__namespace.i32("exponent"),
+        borsh28__namespace.u32("downSlotsRatio")
+      ],
+      property
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj) {
+    return new _TwapPrice({
+      feedId: obj.feedId,
+      startTime: obj.startTime,
+      endTime: obj.endTime,
+      price: obj.price,
+      conf: obj.conf,
+      exponent: obj.exponent,
+      downSlotsRatio: obj.downSlotsRatio
+    });
+  }
+  static toEncodable(fields) {
+    return {
+      feedId: fields.feedId,
+      startTime: fields.startTime,
+      endTime: fields.endTime,
+      price: fields.price,
+      conf: fields.conf,
+      exponent: fields.exponent,
+      downSlotsRatio: fields.downSlotsRatio
+    };
+  }
+  toJSON() {
+    return {
+      feedId: this.feedId,
+      startTime: this.startTime.toString(),
+      endTime: this.endTime.toString(),
+      price: this.price.toString(),
+      conf: this.conf.toString(),
+      exponent: this.exponent,
+      downSlotsRatio: this.downSlotsRatio
+    };
+  }
+  static fromJSON(obj) {
+    return new _TwapPrice({
+      feedId: obj.feedId,
+      startTime: new BN10__default.default(obj.startTime),
+      endTime: new BN10__default.default(obj.endTime),
+      price: new BN10__default.default(obj.price),
+      conf: new BN10__default.default(obj.conf),
+      exponent: obj.exponent,
+      downSlotsRatio: obj.downSlotsRatio
+    });
+  }
+  toEncodable() {
+    return _TwapPrice.toEncodable(this);
+  }
+};
+var DataSource = class _DataSource {
+  chain;
+  emitter;
+  constructor(fields) {
+    this.chain = fields.chain;
+    this.emitter = fields.emitter;
+  }
+  static layout(property) {
+    return borsh28__namespace.struct([borsh28__namespace.u16("chain"), borshAddress("emitter")], property);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj) {
+    return new _DataSource({
+      chain: obj.chain,
+      emitter: obj.emitter
+    });
+  }
+  static toEncodable(fields) {
+    return {
+      chain: fields.chain,
+      emitter: fields.emitter
+    };
+  }
+  toJSON() {
+    return {
+      chain: this.chain,
+      emitter: this.emitter
+    };
+  }
+  static fromJSON(obj) {
+    return new _DataSource({
+      chain: obj.chain,
+      emitter: kit.address(obj.emitter)
+    });
+  }
+  toEncodable() {
+    return _DataSource.toEncodable(this);
+  }
+};
+var PROGRAM_ID_CLI2 = kit.address(
+  "rec5EKMGg6MxZYaMdyBfgwp4d5rB9T1VQH5pJv5LtFJ"
+);
+var PROGRAM_ID2 = PROGRAM_ID_CLI2;
+
+// src/@codegen/pyth_rec/accounts/Config.ts
+var Config = class _Config {
+  governanceAuthority;
+  targetGovernanceAuthority;
+  wormhole;
+  validDataSources;
+  singleUpdateFeeInLamports;
+  minimumSignatures;
+  static discriminator = Buffer.from([
+    155,
+    12,
+    170,
+    224,
+    30,
+    250,
+    204,
+    130
+  ]);
+  static layout = borsh28__namespace.struct([
+    borshAddress("governanceAuthority"),
+    borsh28__namespace.option(borshAddress(), "targetGovernanceAuthority"),
+    borshAddress("wormhole"),
+    borsh28__namespace.vec(DataSource.layout(), "validDataSources"),
+    borsh28__namespace.u64("singleUpdateFeeInLamports"),
+    borsh28__namespace.u8("minimumSignatures")
+  ]);
+  constructor(fields) {
+    this.governanceAuthority = fields.governanceAuthority;
+    this.targetGovernanceAuthority = fields.targetGovernanceAuthority;
+    this.wormhole = fields.wormhole;
+    this.validDataSources = fields.validDataSources.map(
+      (item) => new DataSource({ ...item })
+    );
+    this.singleUpdateFeeInLamports = fields.singleUpdateFeeInLamports;
+    this.minimumSignatures = fields.minimumSignatures;
+  }
+  static async fetch(rpc, address32, programId = PROGRAM_ID2) {
+    const info = await kit.fetchEncodedAccount(rpc, address32);
+    if (!info.exists) {
+      return null;
+    }
+    if (info.programAddress !== programId) {
+      throw new Error(
+        `ConfigFields account ${address32} belongs to wrong program ${info.programAddress}, expected ${programId}`
+      );
+    }
+    return this.decode(Buffer.from(info.data));
+  }
+  static async fetchMultiple(rpc, addresses, programId = PROGRAM_ID2) {
+    const infos = await kit.fetchEncodedAccounts(rpc, addresses);
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null;
+      }
+      if (info.programAddress !== programId) {
+        throw new Error(
+          `ConfigFields account ${info.address} belongs to wrong program ${info.programAddress}, expected ${programId}`
+        );
+      }
+      return this.decode(Buffer.from(info.data));
+    });
+  }
+  static decode(data) {
+    if (!data.slice(0, 8).equals(_Config.discriminator)) {
+      throw new Error("invalid account discriminator");
+    }
+    const dec = _Config.layout.decode(data.slice(8));
+    return new _Config({
+      governanceAuthority: dec.governanceAuthority,
+      targetGovernanceAuthority: dec.targetGovernanceAuthority,
+      wormhole: dec.wormhole,
+      validDataSources: dec.validDataSources.map(
+        (item) => DataSource.fromDecoded(item)
+      ),
+      singleUpdateFeeInLamports: dec.singleUpdateFeeInLamports,
+      minimumSignatures: dec.minimumSignatures
+    });
+  }
+  toJSON() {
+    return {
+      governanceAuthority: this.governanceAuthority,
+      targetGovernanceAuthority: this.targetGovernanceAuthority,
+      wormhole: this.wormhole,
+      validDataSources: this.validDataSources.map((item) => item.toJSON()),
+      singleUpdateFeeInLamports: this.singleUpdateFeeInLamports.toString(),
+      minimumSignatures: this.minimumSignatures
+    };
+  }
+  static fromJSON(obj) {
+    return new _Config({
+      governanceAuthority: kit.address(obj.governanceAuthority),
+      targetGovernanceAuthority: obj.targetGovernanceAuthority && kit.address(obj.targetGovernanceAuthority) || null,
+      wormhole: kit.address(obj.wormhole),
+      validDataSources: obj.validDataSources.map(
+        (item) => DataSource.fromJSON(item)
+      ),
+      singleUpdateFeeInLamports: new BN10__default.default(obj.singleUpdateFeeInLamports),
+      minimumSignatures: obj.minimumSignatures
+    });
+  }
+};
+var priceUpdateV2 = class _priceUpdateV2 {
+  writeAuthority;
+  verificationLevel;
+  priceMessage;
+  postedSlot;
+  static discriminator = Buffer.from([
+    34,
+    241,
+    35,
+    99,
+    157,
+    126,
+    244,
+    205
+  ]);
+  static layout = borsh28__namespace.struct([
+    borshAddress("writeAuthority"),
+    VerificationLevel_exports.layout("verificationLevel"),
+    PriceFeedMessage.layout("priceMessage"),
+    borsh28__namespace.u64("postedSlot")
+  ]);
+  constructor(fields) {
+    this.writeAuthority = fields.writeAuthority;
+    this.verificationLevel = fields.verificationLevel;
+    this.priceMessage = new PriceFeedMessage({ ...fields.priceMessage });
+    this.postedSlot = fields.postedSlot;
+  }
+  static async fetch(rpc, address32, programId = PROGRAM_ID2) {
+    const info = await kit.fetchEncodedAccount(rpc, address32);
+    if (!info.exists) {
+      return null;
+    }
+    if (info.programAddress !== programId) {
+      throw new Error(
+        `priceUpdateV2Fields account ${address32} belongs to wrong program ${info.programAddress}, expected ${programId}`
+      );
+    }
+    return this.decode(Buffer.from(info.data));
+  }
+  static async fetchMultiple(rpc, addresses, programId = PROGRAM_ID2) {
+    const infos = await kit.fetchEncodedAccounts(rpc, addresses);
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null;
+      }
+      if (info.programAddress !== programId) {
+        throw new Error(
+          `priceUpdateV2Fields account ${info.address} belongs to wrong program ${info.programAddress}, expected ${programId}`
+        );
+      }
+      return this.decode(Buffer.from(info.data));
+    });
+  }
+  static decode(data) {
+    if (!data.slice(0, 8).equals(_priceUpdateV2.discriminator)) {
+      throw new Error("invalid account discriminator");
+    }
+    const dec = _priceUpdateV2.layout.decode(data.slice(8));
+    return new _priceUpdateV2({
+      writeAuthority: dec.writeAuthority,
+      verificationLevel: VerificationLevel_exports.fromDecoded(
+        dec.verificationLevel
+      ),
+      priceMessage: PriceFeedMessage.fromDecoded(dec.priceMessage),
+      postedSlot: dec.postedSlot
+    });
+  }
+  toJSON() {
+    return {
+      writeAuthority: this.writeAuthority,
+      verificationLevel: this.verificationLevel.toJSON(),
+      priceMessage: this.priceMessage.toJSON(),
+      postedSlot: this.postedSlot.toString()
+    };
+  }
+  static fromJSON(obj) {
+    return new _priceUpdateV2({
+      writeAuthority: kit.address(obj.writeAuthority),
+      verificationLevel: VerificationLevel_exports.fromJSON(
+        obj.verificationLevel
+      ),
+      priceMessage: PriceFeedMessage.fromJSON(obj.priceMessage),
+      postedSlot: new BN10__default.default(obj.postedSlot)
+    });
+  }
+};
+var twapUpdate = class _twapUpdate {
+  writeAuthority;
+  twap;
+  static discriminator = Buffer.from([
+    104,
+    192,
+    188,
+    72,
+    246,
+    166,
+    12,
+    81
+  ]);
+  static layout = borsh28__namespace.struct([
+    borshAddress("writeAuthority"),
+    TwapPrice.layout("twap")
+  ]);
+  constructor(fields) {
+    this.writeAuthority = fields.writeAuthority;
+    this.twap = new TwapPrice({ ...fields.twap });
+  }
+  static async fetch(rpc, address32, programId = PROGRAM_ID2) {
+    const info = await kit.fetchEncodedAccount(rpc, address32);
+    if (!info.exists) {
+      return null;
+    }
+    if (info.programAddress !== programId) {
+      throw new Error(
+        `twapUpdateFields account ${address32} belongs to wrong program ${info.programAddress}, expected ${programId}`
+      );
+    }
+    return this.decode(Buffer.from(info.data));
+  }
+  static async fetchMultiple(rpc, addresses, programId = PROGRAM_ID2) {
+    const infos = await kit.fetchEncodedAccounts(rpc, addresses);
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null;
+      }
+      if (info.programAddress !== programId) {
+        throw new Error(
+          `twapUpdateFields account ${info.address} belongs to wrong program ${info.programAddress}, expected ${programId}`
+        );
+      }
+      return this.decode(Buffer.from(info.data));
+    });
+  }
+  static decode(data) {
+    if (!data.slice(0, 8).equals(_twapUpdate.discriminator)) {
+      throw new Error("invalid account discriminator");
+    }
+    const dec = _twapUpdate.layout.decode(data.slice(8));
+    return new _twapUpdate({
+      writeAuthority: dec.writeAuthority,
+      twap: TwapPrice.fromDecoded(dec.twap)
+    });
+  }
+  toJSON() {
+    return {
+      writeAuthority: this.writeAuthority,
+      twap: this.twap.toJSON()
+    };
+  }
+  static fromJSON(obj) {
+    return new _twapUpdate({
+      writeAuthority: kit.address(obj.writeAuthority),
+      twap: TwapPrice.fromJSON(obj.twap)
+    });
+  }
+};
+
+// src/@codegen/switchboard_v2/utils/borshAddress.ts
+var import_buffer_layout2 = chunkO7I5CWRX_cjs.__toESM(chunkGXZYS537_cjs.require_Layout(), 1);
+var addressCodec2 = kit.getAddressCodec();
+function borshAddress2(property) {
+  return new WrappedLayout2(
+    (0, import_buffer_layout2.blob)(32),
+    (b) => addressCodec2.decode(b),
+    (addr) => Buffer.from(addressCodec2.encode(addr)),
+    property
+  );
+}
+var WrappedLayout2 = class extends import_buffer_layout2.Layout {
+  layout;
+  decoder;
+  encoder;
+  constructor(layout4, decoder, encoder, property) {
+    super(layout4.span, property);
+    this.layout = layout4;
+    this.decoder = decoder;
+    this.encoder = encoder;
+  }
+  decode(b, offset) {
+    return this.decoder(this.layout.decode(b, offset));
+  }
+  encode(src, b, offset) {
+    return this.layout.encode(this.encoder(src), b, offset);
+  }
+  getSpan(b, offset) {
+    return this.layout.getSpan(b, offset);
+  }
+};
+var PROGRAM_ID_CLI3 = kit.address(
+  "SW1TCH7qEPTdLsDHRgPuMQjbQxKdH2aBStViMFnt64f"
+);
+var PROGRAM_ID3 = PROGRAM_ID_CLI3;
+
+// src/@codegen/switchboard_v2/accounts/SbState.ts
+var SbState = class _SbState {
+  authority;
+  tokenMint;
+  tokenVault;
+  daoMint;
+  ebuf;
+  static discriminator = Buffer.from([
+    159,
+    42,
+    192,
+    191,
+    139,
+    62,
+    168,
+    28
+  ]);
+  static layout = borsh28__namespace.struct([
+    borshAddress2("authority"),
+    borshAddress2("tokenMint"),
+    borshAddress2("tokenVault"),
+    borshAddress2("daoMint"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 992, "ebuf")
+  ]);
+  constructor(fields) {
+    this.authority = fields.authority;
+    this.tokenMint = fields.tokenMint;
+    this.tokenVault = fields.tokenVault;
+    this.daoMint = fields.daoMint;
+    this.ebuf = fields.ebuf;
+  }
+  static async fetch(rpc, address32, programId = PROGRAM_ID3) {
+    const info = await kit.fetchEncodedAccount(rpc, address32);
+    if (!info.exists) {
+      return null;
+    }
+    if (info.programAddress !== programId) {
+      throw new Error("account doesn't belong to this program");
+    }
+    return this.decode(Buffer.from(info.data));
+  }
+  static async fetchMultiple(rpc, addresses, programId = PROGRAM_ID3) {
+    const infos = await kit.fetchEncodedAccounts(rpc, addresses);
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null;
+      }
+      if (info.programAddress !== programId) {
+        throw new Error("account doesn't belong to this program");
+      }
+      return this.decode(Buffer.from(info.data));
+    });
+  }
+  static decode(data) {
+    if (!data.slice(0, 8).equals(_SbState.discriminator)) {
+      throw new Error("invalid account discriminator");
+    }
+    const dec = _SbState.layout.decode(data.slice(8));
+    return new _SbState({
+      authority: dec.authority,
+      tokenMint: dec.tokenMint,
+      tokenVault: dec.tokenVault,
+      daoMint: dec.daoMint,
+      ebuf: dec.ebuf
+    });
+  }
+  toJSON() {
+    return {
+      authority: this.authority,
+      tokenMint: this.tokenMint,
+      tokenVault: this.tokenVault,
+      daoMint: this.daoMint,
+      ebuf: this.ebuf
+    };
+  }
+  static fromJSON(obj) {
+    return new _SbState({
+      authority: kit.address(obj.authority),
+      tokenMint: kit.address(obj.tokenMint),
+      tokenVault: kit.address(obj.tokenVault),
+      daoMint: kit.address(obj.daoMint),
+      ebuf: obj.ebuf
+    });
+  }
+};
+
+// src/@codegen/switchboard_v2/types/AggregatorResolutionMode.ts
+var AggregatorResolutionMode_exports = {};
+chunkO7I5CWRX_cjs.__export(AggregatorResolutionMode_exports, {
+  ModeRoundResolution: () => ModeRoundResolution,
+  ModeSlidingResolution: () => ModeSlidingResolution,
+  fromDecoded: () => fromDecoded2,
+  fromJSON: () => fromJSON2,
+  layout: () => layout2
+});
+var ModeRoundResolution = class {
+  static discriminator = 0;
+  static kind = "ModeRoundResolution";
+  discriminator = 0;
+  kind = "ModeRoundResolution";
+  toJSON() {
+    return {
+      kind: "ModeRoundResolution"
+    };
+  }
+  toEncodable() {
+    return {
+      ModeRoundResolution: {}
+    };
+  }
+};
+var ModeSlidingResolution = class {
+  static discriminator = 1;
+  static kind = "ModeSlidingResolution";
+  discriminator = 1;
+  kind = "ModeSlidingResolution";
+  toJSON() {
+    return {
+      kind: "ModeSlidingResolution"
+    };
+  }
+  toEncodable() {
+    return {
+      ModeSlidingResolution: {}
+    };
+  }
+};
+function fromDecoded2(obj) {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object");
+  }
+  if ("ModeRoundResolution" in obj) {
+    return new ModeRoundResolution();
+  }
+  if ("ModeSlidingResolution" in obj) {
+    return new ModeSlidingResolution();
+  }
+  throw new Error("Invalid enum object");
+}
+function fromJSON2(obj) {
+  switch (obj.kind) {
+    case "ModeRoundResolution": {
+      return new ModeRoundResolution();
+    }
+    case "ModeSlidingResolution": {
+      return new ModeSlidingResolution();
+    }
+  }
+}
+function layout2(property) {
+  const ret = borsh28__namespace.rustEnum([
+    borsh28__namespace.struct([], "ModeRoundResolution"),
+    borsh28__namespace.struct([], "ModeSlidingResolution")
+  ]);
+  if (property !== void 0) {
+    return ret.replicate(property);
+  }
+  return ret;
+}
+
+// src/@codegen/switchboard_v2/types/VrfStatus.ts
+var VrfStatus_exports = {};
+chunkO7I5CWRX_cjs.__export(VrfStatus_exports, {
+  StatusCallbackSuccess: () => StatusCallbackSuccess,
+  StatusNone: () => StatusNone,
+  StatusRequesting: () => StatusRequesting,
+  StatusVerified: () => StatusVerified,
+  StatusVerifyFailure: () => StatusVerifyFailure,
+  StatusVerifying: () => StatusVerifying,
+  fromDecoded: () => fromDecoded3,
+  fromJSON: () => fromJSON3,
+  layout: () => layout3
+});
+var StatusNone = class {
+  static discriminator = 0;
+  static kind = "StatusNone";
+  discriminator = 0;
+  kind = "StatusNone";
+  toJSON() {
+    return {
+      kind: "StatusNone"
+    };
+  }
+  toEncodable() {
+    return {
+      StatusNone: {}
+    };
+  }
+};
+var StatusRequesting = class {
+  static discriminator = 1;
+  static kind = "StatusRequesting";
+  discriminator = 1;
+  kind = "StatusRequesting";
+  toJSON() {
+    return {
+      kind: "StatusRequesting"
+    };
+  }
+  toEncodable() {
+    return {
+      StatusRequesting: {}
+    };
+  }
+};
+var StatusVerifying = class {
+  static discriminator = 2;
+  static kind = "StatusVerifying";
+  discriminator = 2;
+  kind = "StatusVerifying";
+  toJSON() {
+    return {
+      kind: "StatusVerifying"
+    };
+  }
+  toEncodable() {
+    return {
+      StatusVerifying: {}
+    };
+  }
+};
+var StatusVerified = class {
+  static discriminator = 3;
+  static kind = "StatusVerified";
+  discriminator = 3;
+  kind = "StatusVerified";
+  toJSON() {
+    return {
+      kind: "StatusVerified"
+    };
+  }
+  toEncodable() {
+    return {
+      StatusVerified: {}
+    };
+  }
+};
+var StatusCallbackSuccess = class {
+  static discriminator = 4;
+  static kind = "StatusCallbackSuccess";
+  discriminator = 4;
+  kind = "StatusCallbackSuccess";
+  toJSON() {
+    return {
+      kind: "StatusCallbackSuccess"
+    };
+  }
+  toEncodable() {
+    return {
+      StatusCallbackSuccess: {}
+    };
+  }
+};
+var StatusVerifyFailure = class {
+  static discriminator = 5;
+  static kind = "StatusVerifyFailure";
+  discriminator = 5;
+  kind = "StatusVerifyFailure";
+  toJSON() {
+    return {
+      kind: "StatusVerifyFailure"
+    };
+  }
+  toEncodable() {
+    return {
+      StatusVerifyFailure: {}
+    };
+  }
+};
+function fromDecoded3(obj) {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object");
+  }
+  if ("StatusNone" in obj) {
+    return new StatusNone();
+  }
+  if ("StatusRequesting" in obj) {
+    return new StatusRequesting();
+  }
+  if ("StatusVerifying" in obj) {
+    return new StatusVerifying();
+  }
+  if ("StatusVerified" in obj) {
+    return new StatusVerified();
+  }
+  if ("StatusCallbackSuccess" in obj) {
+    return new StatusCallbackSuccess();
+  }
+  if ("StatusVerifyFailure" in obj) {
+    return new StatusVerifyFailure();
+  }
+  throw new Error("Invalid enum object");
+}
+function fromJSON3(obj) {
+  switch (obj.kind) {
+    case "StatusNone": {
+      return new StatusNone();
+    }
+    case "StatusRequesting": {
+      return new StatusRequesting();
+    }
+    case "StatusVerifying": {
+      return new StatusVerifying();
+    }
+    case "StatusVerified": {
+      return new StatusVerified();
+    }
+    case "StatusCallbackSuccess": {
+      return new StatusCallbackSuccess();
+    }
+    case "StatusVerifyFailure": {
+      return new StatusVerifyFailure();
+    }
+  }
+}
+function layout3(property) {
+  const ret = borsh28__namespace.rustEnum([
+    borsh28__namespace.struct([], "StatusNone"),
+    borsh28__namespace.struct([], "StatusRequesting"),
+    borsh28__namespace.struct([], "StatusVerifying"),
+    borsh28__namespace.struct([], "StatusVerified"),
+    borsh28__namespace.struct([], "StatusCallbackSuccess"),
+    borsh28__namespace.struct([], "StatusVerifyFailure")
+  ]);
+  if (property !== void 0) {
+    return ret.replicate(property);
+  }
+  return ret;
+}
+var EcvrfProofZC = class _EcvrfProofZC {
+  gamma;
+  c;
+  s;
+  constructor(fields) {
+    this.gamma = new EdwardsPointZC({ ...fields.gamma });
+    this.c = new Scalar({ ...fields.c });
+    this.s = new Scalar({ ...fields.s });
+  }
+  static layout(property) {
+    return borsh28__namespace.struct(
+      [
+        EdwardsPointZC.layout("gamma"),
+        Scalar.layout("c"),
+        Scalar.layout("s")
+      ],
+      property
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj) {
+    return new _EcvrfProofZC({
+      gamma: EdwardsPointZC.fromDecoded(obj.gamma),
+      c: Scalar.fromDecoded(obj.c),
+      s: Scalar.fromDecoded(obj.s)
+    });
+  }
+  static toEncodable(fields) {
+    return {
+      gamma: EdwardsPointZC.toEncodable(fields.gamma),
+      c: Scalar.toEncodable(fields.c),
+      s: Scalar.toEncodable(fields.s)
+    };
+  }
+  toJSON() {
+    return {
+      gamma: this.gamma.toJSON(),
+      c: this.c.toJSON(),
+      s: this.s.toJSON()
+    };
+  }
+  static fromJSON(obj) {
+    return new _EcvrfProofZC({
+      gamma: EdwardsPointZC.fromJSON(obj.gamma),
+      c: Scalar.fromJSON(obj.c),
+      s: Scalar.fromJSON(obj.s)
+    });
+  }
+  toEncodable() {
+    return _EcvrfProofZC.toEncodable(this);
+  }
+};
+var Scalar = class _Scalar {
+  bytes;
+  constructor(fields) {
+    this.bytes = fields.bytes;
+  }
+  static layout(property) {
+    return borsh28__namespace.struct([borsh28__namespace.array(borsh28__namespace.u8(), 32, "bytes")], property);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj) {
+    return new _Scalar({
+      bytes: obj.bytes
+    });
+  }
+  static toEncodable(fields) {
+    return {
+      bytes: fields.bytes
+    };
+  }
+  toJSON() {
+    return {
+      bytes: this.bytes
+    };
+  }
+  static fromJSON(obj) {
+    return new _Scalar({
+      bytes: obj.bytes
+    });
+  }
+  toEncodable() {
+    return _Scalar.toEncodable(this);
+  }
+};
+var FieldElementZC = class _FieldElementZC {
+  bytes;
+  constructor(fields) {
+    this.bytes = fields.bytes;
+  }
+  static layout(property) {
+    return borsh28__namespace.struct([borsh28__namespace.array(borsh28__namespace.u64(), 5, "bytes")], property);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj) {
+    return new _FieldElementZC({
+      bytes: obj.bytes
+    });
+  }
+  static toEncodable(fields) {
+    return {
+      bytes: fields.bytes
+    };
+  }
+  toJSON() {
+    return {
+      bytes: this.bytes.map((item) => item.toString())
+    };
+  }
+  static fromJSON(obj) {
+    return new _FieldElementZC({
+      bytes: obj.bytes.map((item) => new BN10__default.default(item))
+    });
+  }
+  toEncodable() {
+    return _FieldElementZC.toEncodable(this);
+  }
+};
+var CompletedPointZC = class _CompletedPointZC {
+  x;
+  y;
+  z;
+  t;
+  constructor(fields) {
+    this.x = new FieldElementZC({ ...fields.x });
+    this.y = new FieldElementZC({ ...fields.y });
+    this.z = new FieldElementZC({ ...fields.z });
+    this.t = new FieldElementZC({ ...fields.t });
+  }
+  static layout(property) {
+    return borsh28__namespace.struct(
+      [
+        FieldElementZC.layout("x"),
+        FieldElementZC.layout("y"),
+        FieldElementZC.layout("z"),
+        FieldElementZC.layout("t")
+      ],
+      property
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj) {
+    return new _CompletedPointZC({
+      x: FieldElementZC.fromDecoded(obj.x),
+      y: FieldElementZC.fromDecoded(obj.y),
+      z: FieldElementZC.fromDecoded(obj.z),
+      t: FieldElementZC.fromDecoded(obj.t)
+    });
+  }
+  static toEncodable(fields) {
+    return {
+      x: FieldElementZC.toEncodable(fields.x),
+      y: FieldElementZC.toEncodable(fields.y),
+      z: FieldElementZC.toEncodable(fields.z),
+      t: FieldElementZC.toEncodable(fields.t)
+    };
+  }
+  toJSON() {
+    return {
+      x: this.x.toJSON(),
+      y: this.y.toJSON(),
+      z: this.z.toJSON(),
+      t: this.t.toJSON()
+    };
+  }
+  static fromJSON(obj) {
+    return new _CompletedPointZC({
+      x: FieldElementZC.fromJSON(obj.x),
+      y: FieldElementZC.fromJSON(obj.y),
+      z: FieldElementZC.fromJSON(obj.z),
+      t: FieldElementZC.fromJSON(obj.t)
+    });
+  }
+  toEncodable() {
+    return _CompletedPointZC.toEncodable(this);
+  }
+};
+var EdwardsPointZC = class _EdwardsPointZC {
+  x;
+  y;
+  z;
+  t;
+  constructor(fields) {
+    this.x = new FieldElementZC({ ...fields.x });
+    this.y = new FieldElementZC({ ...fields.y });
+    this.z = new FieldElementZC({ ...fields.z });
+    this.t = new FieldElementZC({ ...fields.t });
+  }
+  static layout(property) {
+    return borsh28__namespace.struct(
+      [
+        FieldElementZC.layout("x"),
+        FieldElementZC.layout("y"),
+        FieldElementZC.layout("z"),
+        FieldElementZC.layout("t")
+      ],
+      property
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj) {
+    return new _EdwardsPointZC({
+      x: FieldElementZC.fromDecoded(obj.x),
+      y: FieldElementZC.fromDecoded(obj.y),
+      z: FieldElementZC.fromDecoded(obj.z),
+      t: FieldElementZC.fromDecoded(obj.t)
+    });
+  }
+  static toEncodable(fields) {
+    return {
+      x: FieldElementZC.toEncodable(fields.x),
+      y: FieldElementZC.toEncodable(fields.y),
+      z: FieldElementZC.toEncodable(fields.z),
+      t: FieldElementZC.toEncodable(fields.t)
+    };
+  }
+  toJSON() {
+    return {
+      x: this.x.toJSON(),
+      y: this.y.toJSON(),
+      z: this.z.toJSON(),
+      t: this.t.toJSON()
+    };
+  }
+  static fromJSON(obj) {
+    return new _EdwardsPointZC({
+      x: FieldElementZC.fromJSON(obj.x),
+      y: FieldElementZC.fromJSON(obj.y),
+      z: FieldElementZC.fromJSON(obj.z),
+      t: FieldElementZC.fromJSON(obj.t)
+    });
+  }
+  toEncodable() {
+    return _EdwardsPointZC.toEncodable(this);
+  }
+};
+var EcvrfIntermediate = class _EcvrfIntermediate {
+  r;
+  nS;
+  d;
+  t13;
+  t15;
+  constructor(fields) {
+    this.r = new FieldElementZC({ ...fields.r });
+    this.nS = new FieldElementZC({ ...fields.nS });
+    this.d = new FieldElementZC({ ...fields.d });
+    this.t13 = new FieldElementZC({ ...fields.t13 });
+    this.t15 = new FieldElementZC({ ...fields.t15 });
+  }
+  static layout(property) {
+    return borsh28__namespace.struct(
+      [
+        FieldElementZC.layout("r"),
+        FieldElementZC.layout("nS"),
+        FieldElementZC.layout("d"),
+        FieldElementZC.layout("t13"),
+        FieldElementZC.layout("t15")
+      ],
+      property
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj) {
+    return new _EcvrfIntermediate({
+      r: FieldElementZC.fromDecoded(obj.r),
+      nS: FieldElementZC.fromDecoded(obj.nS),
+      d: FieldElementZC.fromDecoded(obj.d),
+      t13: FieldElementZC.fromDecoded(obj.t13),
+      t15: FieldElementZC.fromDecoded(obj.t15)
+    });
+  }
+  static toEncodable(fields) {
+    return {
+      r: FieldElementZC.toEncodable(fields.r),
+      nS: FieldElementZC.toEncodable(fields.nS),
+      d: FieldElementZC.toEncodable(fields.d),
+      t13: FieldElementZC.toEncodable(fields.t13),
+      t15: FieldElementZC.toEncodable(fields.t15)
+    };
+  }
+  toJSON() {
+    return {
+      r: this.r.toJSON(),
+      nS: this.nS.toJSON(),
+      d: this.d.toJSON(),
+      t13: this.t13.toJSON(),
+      t15: this.t15.toJSON()
+    };
+  }
+  static fromJSON(obj) {
+    return new _EcvrfIntermediate({
+      r: FieldElementZC.fromJSON(obj.r),
+      nS: FieldElementZC.fromJSON(obj.nS),
+      d: FieldElementZC.fromJSON(obj.d),
+      t13: FieldElementZC.fromJSON(obj.t13),
+      t15: FieldElementZC.fromJSON(obj.t15)
+    });
+  }
+  toEncodable() {
+    return _EcvrfIntermediate.toEncodable(this);
+  }
+};
+var Hash = class _Hash {
+  data;
+  constructor(fields) {
+    this.data = fields.data;
+  }
+  static layout(property) {
+    return borsh28__namespace.struct([borsh28__namespace.array(borsh28__namespace.u8(), 32, "data")], property);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj) {
+    return new _Hash({
+      data: obj.data
+    });
+  }
+  static toEncodable(fields) {
+    return {
+      data: fields.data
+    };
+  }
+  toJSON() {
+    return {
+      data: this.data
+    };
+  }
+  static fromJSON(obj) {
+    return new _Hash({
+      data: obj.data
+    });
+  }
+  toEncodable() {
+    return _Hash.toEncodable(this);
+  }
+};
+var SlidingWindowElement = class _SlidingWindowElement {
+  oracleKey;
+  value;
+  slot;
+  timestamp;
+  constructor(fields) {
+    this.oracleKey = fields.oracleKey;
+    this.value = new SwitchboardDecimal({ ...fields.value });
+    this.slot = fields.slot;
+    this.timestamp = fields.timestamp;
+  }
+  static layout(property) {
+    return borsh28__namespace.struct(
+      [
+        borshAddress2("oracleKey"),
+        SwitchboardDecimal.layout("value"),
+        borsh28__namespace.u64("slot"),
+        borsh28__namespace.i64("timestamp")
+      ],
+      property
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj) {
+    return new _SlidingWindowElement({
+      oracleKey: obj.oracleKey,
+      value: SwitchboardDecimal.fromDecoded(obj.value),
+      slot: obj.slot,
+      timestamp: obj.timestamp
+    });
+  }
+  static toEncodable(fields) {
+    return {
+      oracleKey: fields.oracleKey,
+      value: SwitchboardDecimal.toEncodable(fields.value),
+      slot: fields.slot,
+      timestamp: fields.timestamp
+    };
+  }
+  toJSON() {
+    return {
+      oracleKey: this.oracleKey,
+      value: this.value.toJSON(),
+      slot: this.slot.toString(),
+      timestamp: this.timestamp.toString()
+    };
+  }
+  static fromJSON(obj) {
+    return new _SlidingWindowElement({
+      oracleKey: kit.address(obj.oracleKey),
+      value: SwitchboardDecimal.fromJSON(obj.value),
+      slot: new BN10__default.default(obj.slot),
+      timestamp: new BN10__default.default(obj.timestamp)
+    });
+  }
+  toEncodable() {
+    return _SlidingWindowElement.toEncodable(this);
+  }
+};
+var AggregatorRound = class _AggregatorRound {
+  numSuccess;
+  numError;
+  isClosed;
+  roundOpenSlot;
+  roundOpenTimestamp;
+  result;
+  stdDeviation;
+  minResponse;
+  maxResponse;
+  oraclePubkeysData;
+  mediansData;
+  currentPayout;
+  mediansFulfilled;
+  errorsFulfilled;
+  constructor(fields) {
+    this.numSuccess = fields.numSuccess;
+    this.numError = fields.numError;
+    this.isClosed = fields.isClosed;
+    this.roundOpenSlot = fields.roundOpenSlot;
+    this.roundOpenTimestamp = fields.roundOpenTimestamp;
+    this.result = new SwitchboardDecimal({ ...fields.result });
+    this.stdDeviation = new SwitchboardDecimal({ ...fields.stdDeviation });
+    this.minResponse = new SwitchboardDecimal({ ...fields.minResponse });
+    this.maxResponse = new SwitchboardDecimal({ ...fields.maxResponse });
+    this.oraclePubkeysData = fields.oraclePubkeysData;
+    this.mediansData = fields.mediansData.map(
+      (item) => new SwitchboardDecimal({ ...item })
+    );
+    this.currentPayout = fields.currentPayout;
+    this.mediansFulfilled = fields.mediansFulfilled;
+    this.errorsFulfilled = fields.errorsFulfilled;
+  }
+  static layout(property) {
+    return borsh28__namespace.struct(
+      [
+        borsh28__namespace.u32("numSuccess"),
+        borsh28__namespace.u32("numError"),
+        borsh28__namespace.bool("isClosed"),
+        borsh28__namespace.u64("roundOpenSlot"),
+        borsh28__namespace.i64("roundOpenTimestamp"),
+        SwitchboardDecimal.layout("result"),
+        SwitchboardDecimal.layout("stdDeviation"),
+        SwitchboardDecimal.layout("minResponse"),
+        SwitchboardDecimal.layout("maxResponse"),
+        borsh28__namespace.array(borshAddress2(), 16, "oraclePubkeysData"),
+        borsh28__namespace.array(SwitchboardDecimal.layout(), 16, "mediansData"),
+        borsh28__namespace.array(borsh28__namespace.i64(), 16, "currentPayout"),
+        borsh28__namespace.array(borsh28__namespace.bool(), 16, "mediansFulfilled"),
+        borsh28__namespace.array(borsh28__namespace.bool(), 16, "errorsFulfilled")
+      ],
+      property
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj) {
+    return new _AggregatorRound({
+      numSuccess: obj.numSuccess,
+      numError: obj.numError,
+      isClosed: obj.isClosed,
+      roundOpenSlot: obj.roundOpenSlot,
+      roundOpenTimestamp: obj.roundOpenTimestamp,
+      result: SwitchboardDecimal.fromDecoded(obj.result),
+      stdDeviation: SwitchboardDecimal.fromDecoded(obj.stdDeviation),
+      minResponse: SwitchboardDecimal.fromDecoded(obj.minResponse),
+      maxResponse: SwitchboardDecimal.fromDecoded(obj.maxResponse),
+      oraclePubkeysData: obj.oraclePubkeysData,
+      mediansData: obj.mediansData.map(
+        (item) => SwitchboardDecimal.fromDecoded(item)
+      ),
+      currentPayout: obj.currentPayout,
+      mediansFulfilled: obj.mediansFulfilled,
+      errorsFulfilled: obj.errorsFulfilled
+    });
+  }
+  static toEncodable(fields) {
+    return {
+      numSuccess: fields.numSuccess,
+      numError: fields.numError,
+      isClosed: fields.isClosed,
+      roundOpenSlot: fields.roundOpenSlot,
+      roundOpenTimestamp: fields.roundOpenTimestamp,
+      result: SwitchboardDecimal.toEncodable(fields.result),
+      stdDeviation: SwitchboardDecimal.toEncodable(fields.stdDeviation),
+      minResponse: SwitchboardDecimal.toEncodable(fields.minResponse),
+      maxResponse: SwitchboardDecimal.toEncodable(fields.maxResponse),
+      oraclePubkeysData: fields.oraclePubkeysData,
+      mediansData: fields.mediansData.map(
+        (item) => SwitchboardDecimal.toEncodable(item)
+      ),
+      currentPayout: fields.currentPayout,
+      mediansFulfilled: fields.mediansFulfilled,
+      errorsFulfilled: fields.errorsFulfilled
+    };
+  }
+  toJSON() {
+    return {
+      numSuccess: this.numSuccess,
+      numError: this.numError,
+      isClosed: this.isClosed,
+      roundOpenSlot: this.roundOpenSlot.toString(),
+      roundOpenTimestamp: this.roundOpenTimestamp.toString(),
+      result: this.result.toJSON(),
+      stdDeviation: this.stdDeviation.toJSON(),
+      minResponse: this.minResponse.toJSON(),
+      maxResponse: this.maxResponse.toJSON(),
+      oraclePubkeysData: this.oraclePubkeysData,
+      mediansData: this.mediansData.map((item) => item.toJSON()),
+      currentPayout: this.currentPayout.map((item) => item.toString()),
+      mediansFulfilled: this.mediansFulfilled,
+      errorsFulfilled: this.errorsFulfilled
+    };
+  }
+  static fromJSON(obj) {
+    return new _AggregatorRound({
+      numSuccess: obj.numSuccess,
+      numError: obj.numError,
+      isClosed: obj.isClosed,
+      roundOpenSlot: new BN10__default.default(obj.roundOpenSlot),
+      roundOpenTimestamp: new BN10__default.default(obj.roundOpenTimestamp),
+      result: SwitchboardDecimal.fromJSON(obj.result),
+      stdDeviation: SwitchboardDecimal.fromJSON(obj.stdDeviation),
+      minResponse: SwitchboardDecimal.fromJSON(obj.minResponse),
+      maxResponse: SwitchboardDecimal.fromJSON(obj.maxResponse),
+      oraclePubkeysData: obj.oraclePubkeysData.map((item) => kit.address(item)),
+      mediansData: obj.mediansData.map(
+        (item) => SwitchboardDecimal.fromJSON(item)
+      ),
+      currentPayout: obj.currentPayout.map((item) => new BN10__default.default(item)),
+      mediansFulfilled: obj.mediansFulfilled,
+      errorsFulfilled: obj.errorsFulfilled
+    });
+  }
+  toEncodable() {
+    return _AggregatorRound.toEncodable(this);
+  }
+};
+var SwitchboardDecimal = class _SwitchboardDecimal {
+  mantissa;
+  scale;
+  constructor(fields) {
+    this.mantissa = fields.mantissa;
+    this.scale = fields.scale;
+  }
+  static layout(property) {
+    return borsh28__namespace.struct([borsh28__namespace.i128("mantissa"), borsh28__namespace.u32("scale")], property);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj) {
+    return new _SwitchboardDecimal({
+      mantissa: obj.mantissa,
+      scale: obj.scale
+    });
+  }
+  static toEncodable(fields) {
+    return {
+      mantissa: fields.mantissa,
+      scale: fields.scale
+    };
+  }
+  toJSON() {
+    return {
+      mantissa: this.mantissa.toString(),
+      scale: this.scale
+    };
+  }
+  static fromJSON(obj) {
+    return new _SwitchboardDecimal({
+      mantissa: new BN10__default.default(obj.mantissa),
+      scale: obj.scale
+    });
+  }
+  toEncodable() {
+    return _SwitchboardDecimal.toEncodable(this);
+  }
+};
+var OracleMetrics = class _OracleMetrics {
+  consecutiveSuccess;
+  consecutiveError;
+  consecutiveDisagreement;
+  consecutiveLateResponse;
+  consecutiveFailure;
+  totalSuccess;
+  totalError;
+  totalDisagreement;
+  totalLateResponse;
+  constructor(fields) {
+    this.consecutiveSuccess = fields.consecutiveSuccess;
+    this.consecutiveError = fields.consecutiveError;
+    this.consecutiveDisagreement = fields.consecutiveDisagreement;
+    this.consecutiveLateResponse = fields.consecutiveLateResponse;
+    this.consecutiveFailure = fields.consecutiveFailure;
+    this.totalSuccess = fields.totalSuccess;
+    this.totalError = fields.totalError;
+    this.totalDisagreement = fields.totalDisagreement;
+    this.totalLateResponse = fields.totalLateResponse;
+  }
+  static layout(property) {
+    return borsh28__namespace.struct(
+      [
+        borsh28__namespace.u64("consecutiveSuccess"),
+        borsh28__namespace.u64("consecutiveError"),
+        borsh28__namespace.u64("consecutiveDisagreement"),
+        borsh28__namespace.u64("consecutiveLateResponse"),
+        borsh28__namespace.u64("consecutiveFailure"),
+        borsh28__namespace.u128("totalSuccess"),
+        borsh28__namespace.u128("totalError"),
+        borsh28__namespace.u128("totalDisagreement"),
+        borsh28__namespace.u128("totalLateResponse")
+      ],
+      property
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj) {
+    return new _OracleMetrics({
+      consecutiveSuccess: obj.consecutiveSuccess,
+      consecutiveError: obj.consecutiveError,
+      consecutiveDisagreement: obj.consecutiveDisagreement,
+      consecutiveLateResponse: obj.consecutiveLateResponse,
+      consecutiveFailure: obj.consecutiveFailure,
+      totalSuccess: obj.totalSuccess,
+      totalError: obj.totalError,
+      totalDisagreement: obj.totalDisagreement,
+      totalLateResponse: obj.totalLateResponse
+    });
+  }
+  static toEncodable(fields) {
+    return {
+      consecutiveSuccess: fields.consecutiveSuccess,
+      consecutiveError: fields.consecutiveError,
+      consecutiveDisagreement: fields.consecutiveDisagreement,
+      consecutiveLateResponse: fields.consecutiveLateResponse,
+      consecutiveFailure: fields.consecutiveFailure,
+      totalSuccess: fields.totalSuccess,
+      totalError: fields.totalError,
+      totalDisagreement: fields.totalDisagreement,
+      totalLateResponse: fields.totalLateResponse
+    };
+  }
+  toJSON() {
+    return {
+      consecutiveSuccess: this.consecutiveSuccess.toString(),
+      consecutiveError: this.consecutiveError.toString(),
+      consecutiveDisagreement: this.consecutiveDisagreement.toString(),
+      consecutiveLateResponse: this.consecutiveLateResponse.toString(),
+      consecutiveFailure: this.consecutiveFailure.toString(),
+      totalSuccess: this.totalSuccess.toString(),
+      totalError: this.totalError.toString(),
+      totalDisagreement: this.totalDisagreement.toString(),
+      totalLateResponse: this.totalLateResponse.toString()
+    };
+  }
+  static fromJSON(obj) {
+    return new _OracleMetrics({
+      consecutiveSuccess: new BN10__default.default(obj.consecutiveSuccess),
+      consecutiveError: new BN10__default.default(obj.consecutiveError),
+      consecutiveDisagreement: new BN10__default.default(obj.consecutiveDisagreement),
+      consecutiveLateResponse: new BN10__default.default(obj.consecutiveLateResponse),
+      consecutiveFailure: new BN10__default.default(obj.consecutiveFailure),
+      totalSuccess: new BN10__default.default(obj.totalSuccess),
+      totalError: new BN10__default.default(obj.totalError),
+      totalDisagreement: new BN10__default.default(obj.totalDisagreement),
+      totalLateResponse: new BN10__default.default(obj.totalLateResponse)
+    });
+  }
+  toEncodable() {
+    return _OracleMetrics.toEncodable(this);
+  }
+};
+var VrfBuilder = class _VrfBuilder {
+  producer;
+  status;
+  reprProof;
+  proof;
+  yPoint;
+  stage;
+  stage1Out;
+  r1;
+  r2;
+  stage3Out;
+  hPoint;
+  sReduced;
+  yPointBuilder;
+  yRistrettoPoint;
+  mulRound;
+  hashPointsRound;
+  mulTmp1;
+  uPoint1;
+  uPoint2;
+  vPoint1;
+  vPoint2;
+  uPoint;
+  vPoint;
+  u1;
+  u2;
+  invertee;
+  y;
+  z;
+  p1Bytes;
+  p2Bytes;
+  p3Bytes;
+  p4Bytes;
+  cPrimeHashbuf;
+  m1;
+  m2;
+  txRemaining;
+  verified;
+  result;
+  constructor(fields) {
+    this.producer = fields.producer;
+    this.status = fields.status;
+    this.reprProof = fields.reprProof;
+    this.proof = new EcvrfProofZC({ ...fields.proof });
+    this.yPoint = fields.yPoint;
+    this.stage = fields.stage;
+    this.stage1Out = new EcvrfIntermediate({ ...fields.stage1Out });
+    this.r1 = new EdwardsPointZC({ ...fields.r1 });
+    this.r2 = new EdwardsPointZC({ ...fields.r2 });
+    this.stage3Out = new EcvrfIntermediate({ ...fields.stage3Out });
+    this.hPoint = new EdwardsPointZC({ ...fields.hPoint });
+    this.sReduced = new Scalar({ ...fields.sReduced });
+    this.yPointBuilder = fields.yPointBuilder.map(
+      (item) => new FieldElementZC({ ...item })
+    );
+    this.yRistrettoPoint = new EdwardsPointZC({
+      ...fields.yRistrettoPoint
+    });
+    this.mulRound = fields.mulRound;
+    this.hashPointsRound = fields.hashPointsRound;
+    this.mulTmp1 = new CompletedPointZC({ ...fields.mulTmp1 });
+    this.uPoint1 = new EdwardsPointZC({ ...fields.uPoint1 });
+    this.uPoint2 = new EdwardsPointZC({ ...fields.uPoint2 });
+    this.vPoint1 = new EdwardsPointZC({ ...fields.vPoint1 });
+    this.vPoint2 = new EdwardsPointZC({ ...fields.vPoint2 });
+    this.uPoint = new EdwardsPointZC({ ...fields.uPoint });
+    this.vPoint = new EdwardsPointZC({ ...fields.vPoint });
+    this.u1 = new FieldElementZC({ ...fields.u1 });
+    this.u2 = new FieldElementZC({ ...fields.u2 });
+    this.invertee = new FieldElementZC({ ...fields.invertee });
+    this.y = new FieldElementZC({ ...fields.y });
+    this.z = new FieldElementZC({ ...fields.z });
+    this.p1Bytes = fields.p1Bytes;
+    this.p2Bytes = fields.p2Bytes;
+    this.p3Bytes = fields.p3Bytes;
+    this.p4Bytes = fields.p4Bytes;
+    this.cPrimeHashbuf = fields.cPrimeHashbuf;
+    this.m1 = new FieldElementZC({ ...fields.m1 });
+    this.m2 = new FieldElementZC({ ...fields.m2 });
+    this.txRemaining = fields.txRemaining;
+    this.verified = fields.verified;
+    this.result = fields.result;
+  }
+  static layout(property) {
+    return borsh28__namespace.struct(
+      [
+        borshAddress2("producer"),
+        VrfStatus_exports.layout("status"),
+        borsh28__namespace.array(borsh28__namespace.u8(), 80, "reprProof"),
+        EcvrfProofZC.layout("proof"),
+        borshAddress2("yPoint"),
+        borsh28__namespace.u32("stage"),
+        EcvrfIntermediate.layout("stage1Out"),
+        EdwardsPointZC.layout("r1"),
+        EdwardsPointZC.layout("r2"),
+        EcvrfIntermediate.layout("stage3Out"),
+        EdwardsPointZC.layout("hPoint"),
+        Scalar.layout("sReduced"),
+        borsh28__namespace.array(FieldElementZC.layout(), 3, "yPointBuilder"),
+        EdwardsPointZC.layout("yRistrettoPoint"),
+        borsh28__namespace.u8("mulRound"),
+        borsh28__namespace.u8("hashPointsRound"),
+        CompletedPointZC.layout("mulTmp1"),
+        EdwardsPointZC.layout("uPoint1"),
+        EdwardsPointZC.layout("uPoint2"),
+        EdwardsPointZC.layout("vPoint1"),
+        EdwardsPointZC.layout("vPoint2"),
+        EdwardsPointZC.layout("uPoint"),
+        EdwardsPointZC.layout("vPoint"),
+        FieldElementZC.layout("u1"),
+        FieldElementZC.layout("u2"),
+        FieldElementZC.layout("invertee"),
+        FieldElementZC.layout("y"),
+        FieldElementZC.layout("z"),
+        borsh28__namespace.array(borsh28__namespace.u8(), 32, "p1Bytes"),
+        borsh28__namespace.array(borsh28__namespace.u8(), 32, "p2Bytes"),
+        borsh28__namespace.array(borsh28__namespace.u8(), 32, "p3Bytes"),
+        borsh28__namespace.array(borsh28__namespace.u8(), 32, "p4Bytes"),
+        borsh28__namespace.array(borsh28__namespace.u8(), 16, "cPrimeHashbuf"),
+        FieldElementZC.layout("m1"),
+        FieldElementZC.layout("m2"),
+        borsh28__namespace.u32("txRemaining"),
+        borsh28__namespace.bool("verified"),
+        borsh28__namespace.array(borsh28__namespace.u8(), 32, "result")
+      ],
+      property
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj) {
+    return new _VrfBuilder({
+      producer: obj.producer,
+      status: VrfStatus_exports.fromDecoded(obj.status),
+      reprProof: obj.reprProof,
+      proof: EcvrfProofZC.fromDecoded(obj.proof),
+      yPoint: obj.yPoint,
+      stage: obj.stage,
+      stage1Out: EcvrfIntermediate.fromDecoded(obj.stage1Out),
+      r1: EdwardsPointZC.fromDecoded(obj.r1),
+      r2: EdwardsPointZC.fromDecoded(obj.r2),
+      stage3Out: EcvrfIntermediate.fromDecoded(obj.stage3Out),
+      hPoint: EdwardsPointZC.fromDecoded(obj.hPoint),
+      sReduced: Scalar.fromDecoded(obj.sReduced),
+      yPointBuilder: obj.yPointBuilder.map(
+        (item) => FieldElementZC.fromDecoded(item)
+      ),
+      yRistrettoPoint: EdwardsPointZC.fromDecoded(obj.yRistrettoPoint),
+      mulRound: obj.mulRound,
+      hashPointsRound: obj.hashPointsRound,
+      mulTmp1: CompletedPointZC.fromDecoded(obj.mulTmp1),
+      uPoint1: EdwardsPointZC.fromDecoded(obj.uPoint1),
+      uPoint2: EdwardsPointZC.fromDecoded(obj.uPoint2),
+      vPoint1: EdwardsPointZC.fromDecoded(obj.vPoint1),
+      vPoint2: EdwardsPointZC.fromDecoded(obj.vPoint2),
+      uPoint: EdwardsPointZC.fromDecoded(obj.uPoint),
+      vPoint: EdwardsPointZC.fromDecoded(obj.vPoint),
+      u1: FieldElementZC.fromDecoded(obj.u1),
+      u2: FieldElementZC.fromDecoded(obj.u2),
+      invertee: FieldElementZC.fromDecoded(obj.invertee),
+      y: FieldElementZC.fromDecoded(obj.y),
+      z: FieldElementZC.fromDecoded(obj.z),
+      p1Bytes: obj.p1Bytes,
+      p2Bytes: obj.p2Bytes,
+      p3Bytes: obj.p3Bytes,
+      p4Bytes: obj.p4Bytes,
+      cPrimeHashbuf: obj.cPrimeHashbuf,
+      m1: FieldElementZC.fromDecoded(obj.m1),
+      m2: FieldElementZC.fromDecoded(obj.m2),
+      txRemaining: obj.txRemaining,
+      verified: obj.verified,
+      result: obj.result
+    });
+  }
+  static toEncodable(fields) {
+    return {
+      producer: fields.producer,
+      status: fields.status.toEncodable(),
+      reprProof: fields.reprProof,
+      proof: EcvrfProofZC.toEncodable(fields.proof),
+      yPoint: fields.yPoint,
+      stage: fields.stage,
+      stage1Out: EcvrfIntermediate.toEncodable(fields.stage1Out),
+      r1: EdwardsPointZC.toEncodable(fields.r1),
+      r2: EdwardsPointZC.toEncodable(fields.r2),
+      stage3Out: EcvrfIntermediate.toEncodable(fields.stage3Out),
+      hPoint: EdwardsPointZC.toEncodable(fields.hPoint),
+      sReduced: Scalar.toEncodable(fields.sReduced),
+      yPointBuilder: fields.yPointBuilder.map(
+        (item) => FieldElementZC.toEncodable(item)
+      ),
+      yRistrettoPoint: EdwardsPointZC.toEncodable(fields.yRistrettoPoint),
+      mulRound: fields.mulRound,
+      hashPointsRound: fields.hashPointsRound,
+      mulTmp1: CompletedPointZC.toEncodable(fields.mulTmp1),
+      uPoint1: EdwardsPointZC.toEncodable(fields.uPoint1),
+      uPoint2: EdwardsPointZC.toEncodable(fields.uPoint2),
+      vPoint1: EdwardsPointZC.toEncodable(fields.vPoint1),
+      vPoint2: EdwardsPointZC.toEncodable(fields.vPoint2),
+      uPoint: EdwardsPointZC.toEncodable(fields.uPoint),
+      vPoint: EdwardsPointZC.toEncodable(fields.vPoint),
+      u1: FieldElementZC.toEncodable(fields.u1),
+      u2: FieldElementZC.toEncodable(fields.u2),
+      invertee: FieldElementZC.toEncodable(fields.invertee),
+      y: FieldElementZC.toEncodable(fields.y),
+      z: FieldElementZC.toEncodable(fields.z),
+      p1Bytes: fields.p1Bytes,
+      p2Bytes: fields.p2Bytes,
+      p3Bytes: fields.p3Bytes,
+      p4Bytes: fields.p4Bytes,
+      cPrimeHashbuf: fields.cPrimeHashbuf,
+      m1: FieldElementZC.toEncodable(fields.m1),
+      m2: FieldElementZC.toEncodable(fields.m2),
+      txRemaining: fields.txRemaining,
+      verified: fields.verified,
+      result: fields.result
+    };
+  }
+  toJSON() {
+    return {
+      producer: this.producer,
+      status: this.status.toJSON(),
+      reprProof: this.reprProof,
+      proof: this.proof.toJSON(),
+      yPoint: this.yPoint,
+      stage: this.stage,
+      stage1Out: this.stage1Out.toJSON(),
+      r1: this.r1.toJSON(),
+      r2: this.r2.toJSON(),
+      stage3Out: this.stage3Out.toJSON(),
+      hPoint: this.hPoint.toJSON(),
+      sReduced: this.sReduced.toJSON(),
+      yPointBuilder: this.yPointBuilder.map((item) => item.toJSON()),
+      yRistrettoPoint: this.yRistrettoPoint.toJSON(),
+      mulRound: this.mulRound,
+      hashPointsRound: this.hashPointsRound,
+      mulTmp1: this.mulTmp1.toJSON(),
+      uPoint1: this.uPoint1.toJSON(),
+      uPoint2: this.uPoint2.toJSON(),
+      vPoint1: this.vPoint1.toJSON(),
+      vPoint2: this.vPoint2.toJSON(),
+      uPoint: this.uPoint.toJSON(),
+      vPoint: this.vPoint.toJSON(),
+      u1: this.u1.toJSON(),
+      u2: this.u2.toJSON(),
+      invertee: this.invertee.toJSON(),
+      y: this.y.toJSON(),
+      z: this.z.toJSON(),
+      p1Bytes: this.p1Bytes,
+      p2Bytes: this.p2Bytes,
+      p3Bytes: this.p3Bytes,
+      p4Bytes: this.p4Bytes,
+      cPrimeHashbuf: this.cPrimeHashbuf,
+      m1: this.m1.toJSON(),
+      m2: this.m2.toJSON(),
+      txRemaining: this.txRemaining,
+      verified: this.verified,
+      result: this.result
+    };
+  }
+  static fromJSON(obj) {
+    return new _VrfBuilder({
+      producer: kit.address(obj.producer),
+      status: VrfStatus_exports.fromJSON(obj.status),
+      reprProof: obj.reprProof,
+      proof: EcvrfProofZC.fromJSON(obj.proof),
+      yPoint: kit.address(obj.yPoint),
+      stage: obj.stage,
+      stage1Out: EcvrfIntermediate.fromJSON(obj.stage1Out),
+      r1: EdwardsPointZC.fromJSON(obj.r1),
+      r2: EdwardsPointZC.fromJSON(obj.r2),
+      stage3Out: EcvrfIntermediate.fromJSON(obj.stage3Out),
+      hPoint: EdwardsPointZC.fromJSON(obj.hPoint),
+      sReduced: Scalar.fromJSON(obj.sReduced),
+      yPointBuilder: obj.yPointBuilder.map(
+        (item) => FieldElementZC.fromJSON(item)
+      ),
+      yRistrettoPoint: EdwardsPointZC.fromJSON(obj.yRistrettoPoint),
+      mulRound: obj.mulRound,
+      hashPointsRound: obj.hashPointsRound,
+      mulTmp1: CompletedPointZC.fromJSON(obj.mulTmp1),
+      uPoint1: EdwardsPointZC.fromJSON(obj.uPoint1),
+      uPoint2: EdwardsPointZC.fromJSON(obj.uPoint2),
+      vPoint1: EdwardsPointZC.fromJSON(obj.vPoint1),
+      vPoint2: EdwardsPointZC.fromJSON(obj.vPoint2),
+      uPoint: EdwardsPointZC.fromJSON(obj.uPoint),
+      vPoint: EdwardsPointZC.fromJSON(obj.vPoint),
+      u1: FieldElementZC.fromJSON(obj.u1),
+      u2: FieldElementZC.fromJSON(obj.u2),
+      invertee: FieldElementZC.fromJSON(obj.invertee),
+      y: FieldElementZC.fromJSON(obj.y),
+      z: FieldElementZC.fromJSON(obj.z),
+      p1Bytes: obj.p1Bytes,
+      p2Bytes: obj.p2Bytes,
+      p3Bytes: obj.p3Bytes,
+      p4Bytes: obj.p4Bytes,
+      cPrimeHashbuf: obj.cPrimeHashbuf,
+      m1: FieldElementZC.fromJSON(obj.m1),
+      m2: FieldElementZC.fromJSON(obj.m2),
+      txRemaining: obj.txRemaining,
+      verified: obj.verified,
+      result: obj.result
+    });
+  }
+  toEncodable() {
+    return _VrfBuilder.toEncodable(this);
+  }
+};
+var AccountMetaZC = class _AccountMetaZC {
+  pubkey;
+  isSigner;
+  isWritable;
+  constructor(fields) {
+    this.pubkey = fields.pubkey;
+    this.isSigner = fields.isSigner;
+    this.isWritable = fields.isWritable;
+  }
+  static layout(property) {
+    return borsh28__namespace.struct(
+      [
+        borshAddress2("pubkey"),
+        borsh28__namespace.bool("isSigner"),
+        borsh28__namespace.bool("isWritable")
+      ],
+      property
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj) {
+    return new _AccountMetaZC({
+      pubkey: obj.pubkey,
+      isSigner: obj.isSigner,
+      isWritable: obj.isWritable
+    });
+  }
+  static toEncodable(fields) {
+    return {
+      pubkey: fields.pubkey,
+      isSigner: fields.isSigner,
+      isWritable: fields.isWritable
+    };
+  }
+  toJSON() {
+    return {
+      pubkey: this.pubkey,
+      isSigner: this.isSigner,
+      isWritable: this.isWritable
+    };
+  }
+  static fromJSON(obj) {
+    return new _AccountMetaZC({
+      pubkey: kit.address(obj.pubkey),
+      isSigner: obj.isSigner,
+      isWritable: obj.isWritable
+    });
+  }
+  toEncodable() {
+    return _AccountMetaZC.toEncodable(this);
+  }
+};
+var CallbackZC = class _CallbackZC {
+  programId;
+  accounts;
+  accountsLen;
+  ixData;
+  ixDataLen;
+  constructor(fields) {
+    this.programId = fields.programId;
+    this.accounts = fields.accounts.map(
+      (item) => new AccountMetaZC({ ...item })
+    );
+    this.accountsLen = fields.accountsLen;
+    this.ixData = fields.ixData;
+    this.ixDataLen = fields.ixDataLen;
+  }
+  static layout(property) {
+    return borsh28__namespace.struct(
+      [
+        borshAddress2("programId"),
+        borsh28__namespace.array(AccountMetaZC.layout(), 32, "accounts"),
+        borsh28__namespace.u32("accountsLen"),
+        borsh28__namespace.array(borsh28__namespace.u8(), 1024, "ixData"),
+        borsh28__namespace.u32("ixDataLen")
+      ],
+      property
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj) {
+    return new _CallbackZC({
+      programId: obj.programId,
+      accounts: obj.accounts.map(
+        (item) => AccountMetaZC.fromDecoded(item)
+      ),
+      accountsLen: obj.accountsLen,
+      ixData: obj.ixData,
+      ixDataLen: obj.ixDataLen
+    });
+  }
+  static toEncodable(fields) {
+    return {
+      programId: fields.programId,
+      accounts: fields.accounts.map(
+        (item) => AccountMetaZC.toEncodable(item)
+      ),
+      accountsLen: fields.accountsLen,
+      ixData: fields.ixData,
+      ixDataLen: fields.ixDataLen
+    };
+  }
+  toJSON() {
+    return {
+      programId: this.programId,
+      accounts: this.accounts.map((item) => item.toJSON()),
+      accountsLen: this.accountsLen,
+      ixData: this.ixData,
+      ixDataLen: this.ixDataLen
+    };
+  }
+  static fromJSON(obj) {
+    return new _CallbackZC({
+      programId: kit.address(obj.programId),
+      accounts: obj.accounts.map((item) => AccountMetaZC.fromJSON(item)),
+      accountsLen: obj.accountsLen,
+      ixData: obj.ixData,
+      ixDataLen: obj.ixDataLen
+    });
+  }
+  toEncodable() {
+    return _CallbackZC.toEncodable(this);
+  }
+};
+var VrfRound = class _VrfRound {
+  alpha;
+  alphaLen;
+  requestSlot;
+  requestTimestamp;
+  result;
+  numVerified;
+  ebuf;
+  constructor(fields) {
+    this.alpha = fields.alpha;
+    this.alphaLen = fields.alphaLen;
+    this.requestSlot = fields.requestSlot;
+    this.requestTimestamp = fields.requestTimestamp;
+    this.result = fields.result;
+    this.numVerified = fields.numVerified;
+    this.ebuf = fields.ebuf;
+  }
+  static layout(property) {
+    return borsh28__namespace.struct(
+      [
+        borsh28__namespace.array(borsh28__namespace.u8(), 256, "alpha"),
+        borsh28__namespace.u32("alphaLen"),
+        borsh28__namespace.u64("requestSlot"),
+        borsh28__namespace.i64("requestTimestamp"),
+        borsh28__namespace.array(borsh28__namespace.u8(), 32, "result"),
+        borsh28__namespace.u32("numVerified"),
+        borsh28__namespace.array(borsh28__namespace.u8(), 256, "ebuf")
+      ],
+      property
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj) {
+    return new _VrfRound({
+      alpha: obj.alpha,
+      alphaLen: obj.alphaLen,
+      requestSlot: obj.requestSlot,
+      requestTimestamp: obj.requestTimestamp,
+      result: obj.result,
+      numVerified: obj.numVerified,
+      ebuf: obj.ebuf
+    });
+  }
+  static toEncodable(fields) {
+    return {
+      alpha: fields.alpha,
+      alphaLen: fields.alphaLen,
+      requestSlot: fields.requestSlot,
+      requestTimestamp: fields.requestTimestamp,
+      result: fields.result,
+      numVerified: fields.numVerified,
+      ebuf: fields.ebuf
+    };
+  }
+  toJSON() {
+    return {
+      alpha: this.alpha,
+      alphaLen: this.alphaLen,
+      requestSlot: this.requestSlot.toString(),
+      requestTimestamp: this.requestTimestamp.toString(),
+      result: this.result,
+      numVerified: this.numVerified,
+      ebuf: this.ebuf
+    };
+  }
+  static fromJSON(obj) {
+    return new _VrfRound({
+      alpha: obj.alpha,
+      alphaLen: obj.alphaLen,
+      requestSlot: new BN10__default.default(obj.requestSlot),
+      requestTimestamp: new BN10__default.default(obj.requestTimestamp),
+      result: obj.result,
+      numVerified: obj.numVerified,
+      ebuf: obj.ebuf
+    });
+  }
+  toEncodable() {
+    return _VrfRound.toEncodable(this);
+  }
+};
+var BufferRelayerRound = class _BufferRelayerRound {
+  numSuccess;
+  numError;
+  roundOpenSlot;
+  roundOpenTimestamp;
+  oraclePubkey;
+  constructor(fields) {
+    this.numSuccess = fields.numSuccess;
+    this.numError = fields.numError;
+    this.roundOpenSlot = fields.roundOpenSlot;
+    this.roundOpenTimestamp = fields.roundOpenTimestamp;
+    this.oraclePubkey = fields.oraclePubkey;
+  }
+  static layout(property) {
+    return borsh28__namespace.struct(
+      [
+        borsh28__namespace.u32("numSuccess"),
+        borsh28__namespace.u32("numError"),
+        borsh28__namespace.u64("roundOpenSlot"),
+        borsh28__namespace.i64("roundOpenTimestamp"),
+        borshAddress2("oraclePubkey")
+      ],
+      property
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj) {
+    return new _BufferRelayerRound({
+      numSuccess: obj.numSuccess,
+      numError: obj.numError,
+      roundOpenSlot: obj.roundOpenSlot,
+      roundOpenTimestamp: obj.roundOpenTimestamp,
+      oraclePubkey: obj.oraclePubkey
+    });
+  }
+  static toEncodable(fields) {
+    return {
+      numSuccess: fields.numSuccess,
+      numError: fields.numError,
+      roundOpenSlot: fields.roundOpenSlot,
+      roundOpenTimestamp: fields.roundOpenTimestamp,
+      oraclePubkey: fields.oraclePubkey
+    };
+  }
+  toJSON() {
+    return {
+      numSuccess: this.numSuccess,
+      numError: this.numError,
+      roundOpenSlot: this.roundOpenSlot.toString(),
+      roundOpenTimestamp: this.roundOpenTimestamp.toString(),
+      oraclePubkey: this.oraclePubkey
+    };
+  }
+  static fromJSON(obj) {
+    return new _BufferRelayerRound({
+      numSuccess: obj.numSuccess,
+      numError: obj.numError,
+      roundOpenSlot: new BN10__default.default(obj.roundOpenSlot),
+      roundOpenTimestamp: new BN10__default.default(obj.roundOpenTimestamp),
+      oraclePubkey: kit.address(obj.oraclePubkey)
+    });
+  }
+  toEncodable() {
+    return _BufferRelayerRound.toEncodable(this);
+  }
+};
+
+// src/@codegen/switchboard_v2/accounts/TaskSpecRecord.ts
+var TaskSpecRecord = class _TaskSpecRecord {
+  hash;
+  static discriminator = Buffer.from([
+    202,
+    10,
+    194,
+    236,
+    111,
+    47,
+    234,
+    48
+  ]);
+  static layout = borsh28__namespace.struct([
+    Hash.layout("hash")
+  ]);
+  constructor(fields) {
+    this.hash = new Hash({ ...fields.hash });
+  }
+  static async fetch(rpc, address32, programId = PROGRAM_ID3) {
+    const info = await kit.fetchEncodedAccount(rpc, address32);
+    if (!info.exists) {
+      return null;
+    }
+    if (info.programAddress !== programId) {
+      throw new Error("account doesn't belong to this program");
+    }
+    return this.decode(Buffer.from(info.data));
+  }
+  static async fetchMultiple(rpc, addresses, programId = PROGRAM_ID3) {
+    const infos = await kit.fetchEncodedAccounts(rpc, addresses);
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null;
+      }
+      if (info.programAddress !== programId) {
+        throw new Error("account doesn't belong to this program");
+      }
+      return this.decode(Buffer.from(info.data));
+    });
+  }
+  static decode(data) {
+    if (!data.slice(0, 8).equals(_TaskSpecRecord.discriminator)) {
+      throw new Error("invalid account discriminator");
+    }
+    const dec = _TaskSpecRecord.layout.decode(data.slice(8));
+    return new _TaskSpecRecord({
+      hash: Hash.fromDecoded(dec.hash)
+    });
+  }
+  toJSON() {
+    return {
+      hash: this.hash.toJSON()
+    };
+  }
+  static fromJSON(obj) {
+    return new _TaskSpecRecord({
+      hash: Hash.fromJSON(obj.hash)
+    });
+  }
+};
+var AggregatorAccountData = class _AggregatorAccountData {
+  name;
+  metadata;
+  reserved1;
+  queuePubkey;
+  oracleRequestBatchSize;
+  minOracleResults;
+  minJobResults;
+  minUpdateDelaySeconds;
+  startAfter;
+  varianceThreshold;
+  forceReportPeriod;
+  expiration;
+  consecutiveFailureCount;
+  nextAllowedUpdateTime;
+  isLocked;
+  crankPubkey;
+  latestConfirmedRound;
+  currentRound;
+  jobPubkeysData;
+  jobHashes;
+  jobPubkeysSize;
+  jobsChecksum;
+  authority;
+  historyBuffer;
+  previousConfirmedRoundResult;
+  previousConfirmedRoundSlot;
+  disableCrank;
+  jobWeights;
+  creationTimestamp;
+  resolutionMode;
+  basePriorityFee;
+  priorityFeeBump;
+  priorityFeeBumpPeriod;
+  maxPriorityFeeMultiplier;
+  ebuf;
+  static discriminator = Buffer.from([
+    217,
+    230,
+    65,
+    101,
+    201,
+    162,
+    27,
+    125
+  ]);
+  static layout = borsh28__namespace.struct([
+    borsh28__namespace.array(borsh28__namespace.u8(), 32, "name"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 128, "metadata"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 32, "reserved1"),
+    borshAddress2("queuePubkey"),
+    borsh28__namespace.u32("oracleRequestBatchSize"),
+    borsh28__namespace.u32("minOracleResults"),
+    borsh28__namespace.u32("minJobResults"),
+    borsh28__namespace.u32("minUpdateDelaySeconds"),
+    borsh28__namespace.i64("startAfter"),
+    SwitchboardDecimal.layout("varianceThreshold"),
+    borsh28__namespace.i64("forceReportPeriod"),
+    borsh28__namespace.i64("expiration"),
+    borsh28__namespace.u64("consecutiveFailureCount"),
+    borsh28__namespace.i64("nextAllowedUpdateTime"),
+    borsh28__namespace.bool("isLocked"),
+    borshAddress2("crankPubkey"),
+    AggregatorRound.layout("latestConfirmedRound"),
+    AggregatorRound.layout("currentRound"),
+    borsh28__namespace.array(borshAddress2(), 16, "jobPubkeysData"),
+    borsh28__namespace.array(Hash.layout(), 16, "jobHashes"),
+    borsh28__namespace.u32("jobPubkeysSize"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 32, "jobsChecksum"),
+    borshAddress2("authority"),
+    borshAddress2("historyBuffer"),
+    SwitchboardDecimal.layout("previousConfirmedRoundResult"),
+    borsh28__namespace.u64("previousConfirmedRoundSlot"),
+    borsh28__namespace.bool("disableCrank"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 16, "jobWeights"),
+    borsh28__namespace.i64("creationTimestamp"),
+    AggregatorResolutionMode_exports.layout("resolutionMode"),
+    borsh28__namespace.u32("basePriorityFee"),
+    borsh28__namespace.u32("priorityFeeBump"),
+    borsh28__namespace.u32("priorityFeeBumpPeriod"),
+    borsh28__namespace.u32("maxPriorityFeeMultiplier"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 122, "ebuf")
+  ]);
+  constructor(fields) {
+    this.name = fields.name;
+    this.metadata = fields.metadata;
+    this.reserved1 = fields.reserved1;
+    this.queuePubkey = fields.queuePubkey;
+    this.oracleRequestBatchSize = fields.oracleRequestBatchSize;
+    this.minOracleResults = fields.minOracleResults;
+    this.minJobResults = fields.minJobResults;
+    this.minUpdateDelaySeconds = fields.minUpdateDelaySeconds;
+    this.startAfter = fields.startAfter;
+    this.varianceThreshold = new SwitchboardDecimal({
+      ...fields.varianceThreshold
+    });
+    this.forceReportPeriod = fields.forceReportPeriod;
+    this.expiration = fields.expiration;
+    this.consecutiveFailureCount = fields.consecutiveFailureCount;
+    this.nextAllowedUpdateTime = fields.nextAllowedUpdateTime;
+    this.isLocked = fields.isLocked;
+    this.crankPubkey = fields.crankPubkey;
+    this.latestConfirmedRound = new AggregatorRound({
+      ...fields.latestConfirmedRound
+    });
+    this.currentRound = new AggregatorRound({ ...fields.currentRound });
+    this.jobPubkeysData = fields.jobPubkeysData;
+    this.jobHashes = fields.jobHashes.map((item) => new Hash({ ...item }));
+    this.jobPubkeysSize = fields.jobPubkeysSize;
+    this.jobsChecksum = fields.jobsChecksum;
+    this.authority = fields.authority;
+    this.historyBuffer = fields.historyBuffer;
+    this.previousConfirmedRoundResult = new SwitchboardDecimal({
+      ...fields.previousConfirmedRoundResult
+    });
+    this.previousConfirmedRoundSlot = fields.previousConfirmedRoundSlot;
+    this.disableCrank = fields.disableCrank;
+    this.jobWeights = fields.jobWeights;
+    this.creationTimestamp = fields.creationTimestamp;
+    this.resolutionMode = fields.resolutionMode;
+    this.basePriorityFee = fields.basePriorityFee;
+    this.priorityFeeBump = fields.priorityFeeBump;
+    this.priorityFeeBumpPeriod = fields.priorityFeeBumpPeriod;
+    this.maxPriorityFeeMultiplier = fields.maxPriorityFeeMultiplier;
+    this.ebuf = fields.ebuf;
+  }
+  static async fetch(rpc, address32, programId = PROGRAM_ID3) {
+    const info = await kit.fetchEncodedAccount(rpc, address32);
+    if (!info.exists) {
+      return null;
+    }
+    if (info.programAddress !== programId) {
+      throw new Error("account doesn't belong to this program");
+    }
+    return this.decode(Buffer.from(info.data));
+  }
+  static async fetchMultiple(rpc, addresses, programId = PROGRAM_ID3) {
+    const infos = await kit.fetchEncodedAccounts(rpc, addresses);
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null;
+      }
+      if (info.programAddress !== programId) {
+        throw new Error("account doesn't belong to this program");
+      }
+      return this.decode(Buffer.from(info.data));
+    });
+  }
+  static decode(data) {
+    if (!data.slice(0, 8).equals(_AggregatorAccountData.discriminator)) {
+      throw new Error("invalid account discriminator");
+    }
+    const dec = _AggregatorAccountData.layout.decode(data.slice(8));
+    return new _AggregatorAccountData({
+      name: dec.name,
+      metadata: dec.metadata,
+      reserved1: dec.reserved1,
+      queuePubkey: dec.queuePubkey,
+      oracleRequestBatchSize: dec.oracleRequestBatchSize,
+      minOracleResults: dec.minOracleResults,
+      minJobResults: dec.minJobResults,
+      minUpdateDelaySeconds: dec.minUpdateDelaySeconds,
+      startAfter: dec.startAfter,
+      varianceThreshold: SwitchboardDecimal.fromDecoded(
+        dec.varianceThreshold
+      ),
+      forceReportPeriod: dec.forceReportPeriod,
+      expiration: dec.expiration,
+      consecutiveFailureCount: dec.consecutiveFailureCount,
+      nextAllowedUpdateTime: dec.nextAllowedUpdateTime,
+      isLocked: dec.isLocked,
+      crankPubkey: dec.crankPubkey,
+      latestConfirmedRound: AggregatorRound.fromDecoded(
+        dec.latestConfirmedRound
+      ),
+      currentRound: AggregatorRound.fromDecoded(dec.currentRound),
+      jobPubkeysData: dec.jobPubkeysData,
+      jobHashes: dec.jobHashes.map(
+        (item) => Hash.fromDecoded(item)
+      ),
+      jobPubkeysSize: dec.jobPubkeysSize,
+      jobsChecksum: dec.jobsChecksum,
+      authority: dec.authority,
+      historyBuffer: dec.historyBuffer,
+      previousConfirmedRoundResult: SwitchboardDecimal.fromDecoded(
+        dec.previousConfirmedRoundResult
+      ),
+      previousConfirmedRoundSlot: dec.previousConfirmedRoundSlot,
+      disableCrank: dec.disableCrank,
+      jobWeights: dec.jobWeights,
+      creationTimestamp: dec.creationTimestamp,
+      resolutionMode: AggregatorResolutionMode_exports.fromDecoded(
+        dec.resolutionMode
+      ),
+      basePriorityFee: dec.basePriorityFee,
+      priorityFeeBump: dec.priorityFeeBump,
+      priorityFeeBumpPeriod: dec.priorityFeeBumpPeriod,
+      maxPriorityFeeMultiplier: dec.maxPriorityFeeMultiplier,
+      ebuf: dec.ebuf
+    });
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      metadata: this.metadata,
+      reserved1: this.reserved1,
+      queuePubkey: this.queuePubkey,
+      oracleRequestBatchSize: this.oracleRequestBatchSize,
+      minOracleResults: this.minOracleResults,
+      minJobResults: this.minJobResults,
+      minUpdateDelaySeconds: this.minUpdateDelaySeconds,
+      startAfter: this.startAfter.toString(),
+      varianceThreshold: this.varianceThreshold.toJSON(),
+      forceReportPeriod: this.forceReportPeriod.toString(),
+      expiration: this.expiration.toString(),
+      consecutiveFailureCount: this.consecutiveFailureCount.toString(),
+      nextAllowedUpdateTime: this.nextAllowedUpdateTime.toString(),
+      isLocked: this.isLocked,
+      crankPubkey: this.crankPubkey,
+      latestConfirmedRound: this.latestConfirmedRound.toJSON(),
+      currentRound: this.currentRound.toJSON(),
+      jobPubkeysData: this.jobPubkeysData,
+      jobHashes: this.jobHashes.map((item) => item.toJSON()),
+      jobPubkeysSize: this.jobPubkeysSize,
+      jobsChecksum: this.jobsChecksum,
+      authority: this.authority,
+      historyBuffer: this.historyBuffer,
+      previousConfirmedRoundResult: this.previousConfirmedRoundResult.toJSON(),
+      previousConfirmedRoundSlot: this.previousConfirmedRoundSlot.toString(),
+      disableCrank: this.disableCrank,
+      jobWeights: this.jobWeights,
+      creationTimestamp: this.creationTimestamp.toString(),
+      resolutionMode: this.resolutionMode.toJSON(),
+      basePriorityFee: this.basePriorityFee,
+      priorityFeeBump: this.priorityFeeBump,
+      priorityFeeBumpPeriod: this.priorityFeeBumpPeriod,
+      maxPriorityFeeMultiplier: this.maxPriorityFeeMultiplier,
+      ebuf: this.ebuf
+    };
+  }
+  static fromJSON(obj) {
+    return new _AggregatorAccountData({
+      name: obj.name,
+      metadata: obj.metadata,
+      reserved1: obj.reserved1,
+      queuePubkey: kit.address(obj.queuePubkey),
+      oracleRequestBatchSize: obj.oracleRequestBatchSize,
+      minOracleResults: obj.minOracleResults,
+      minJobResults: obj.minJobResults,
+      minUpdateDelaySeconds: obj.minUpdateDelaySeconds,
+      startAfter: new BN10__default.default(obj.startAfter),
+      varianceThreshold: SwitchboardDecimal.fromJSON(
+        obj.varianceThreshold
+      ),
+      forceReportPeriod: new BN10__default.default(obj.forceReportPeriod),
+      expiration: new BN10__default.default(obj.expiration),
+      consecutiveFailureCount: new BN10__default.default(obj.consecutiveFailureCount),
+      nextAllowedUpdateTime: new BN10__default.default(obj.nextAllowedUpdateTime),
+      isLocked: obj.isLocked,
+      crankPubkey: kit.address(obj.crankPubkey),
+      latestConfirmedRound: AggregatorRound.fromJSON(
+        obj.latestConfirmedRound
+      ),
+      currentRound: AggregatorRound.fromJSON(obj.currentRound),
+      jobPubkeysData: obj.jobPubkeysData.map((item) => kit.address(item)),
+      jobHashes: obj.jobHashes.map((item) => Hash.fromJSON(item)),
+      jobPubkeysSize: obj.jobPubkeysSize,
+      jobsChecksum: obj.jobsChecksum,
+      authority: kit.address(obj.authority),
+      historyBuffer: kit.address(obj.historyBuffer),
+      previousConfirmedRoundResult: SwitchboardDecimal.fromJSON(
+        obj.previousConfirmedRoundResult
+      ),
+      previousConfirmedRoundSlot: new BN10__default.default(obj.previousConfirmedRoundSlot),
+      disableCrank: obj.disableCrank,
+      jobWeights: obj.jobWeights,
+      creationTimestamp: new BN10__default.default(obj.creationTimestamp),
+      resolutionMode: AggregatorResolutionMode_exports.fromJSON(
+        obj.resolutionMode
+      ),
+      basePriorityFee: obj.basePriorityFee,
+      priorityFeeBump: obj.priorityFeeBump,
+      priorityFeeBumpPeriod: obj.priorityFeeBumpPeriod,
+      maxPriorityFeeMultiplier: obj.maxPriorityFeeMultiplier,
+      ebuf: obj.ebuf
+    });
+  }
+};
+var SlidingResultAccountData = class _SlidingResultAccountData {
+  data;
+  bump;
+  ebuf;
+  static discriminator = Buffer.from([
+    91,
+    4,
+    83,
+    187,
+    102,
+    216,
+    153,
+    254
+  ]);
+  static layout = borsh28__namespace.struct([
+    borsh28__namespace.array(SlidingWindowElement.layout(), 16, "data"),
+    borsh28__namespace.u8("bump"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 512, "ebuf")
+  ]);
+  constructor(fields) {
+    this.data = fields.data.map(
+      (item) => new SlidingWindowElement({ ...item })
+    );
+    this.bump = fields.bump;
+    this.ebuf = fields.ebuf;
+  }
+  static async fetch(rpc, address32, programId = PROGRAM_ID3) {
+    const info = await kit.fetchEncodedAccount(rpc, address32);
+    if (!info.exists) {
+      return null;
+    }
+    if (info.programAddress !== programId) {
+      throw new Error("account doesn't belong to this program");
+    }
+    return this.decode(Buffer.from(info.data));
+  }
+  static async fetchMultiple(rpc, addresses, programId = PROGRAM_ID3) {
+    const infos = await kit.fetchEncodedAccounts(rpc, addresses);
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null;
+      }
+      if (info.programAddress !== programId) {
+        throw new Error("account doesn't belong to this program");
+      }
+      return this.decode(Buffer.from(info.data));
+    });
+  }
+  static decode(data) {
+    if (!data.slice(0, 8).equals(_SlidingResultAccountData.discriminator)) {
+      throw new Error("invalid account discriminator");
+    }
+    const dec = _SlidingResultAccountData.layout.decode(data.slice(8));
+    return new _SlidingResultAccountData({
+      data: dec.data.map(
+        (item) => SlidingWindowElement.fromDecoded(item)
+      ),
+      bump: dec.bump,
+      ebuf: dec.ebuf
+    });
+  }
+  toJSON() {
+    return {
+      data: this.data.map((item) => item.toJSON()),
+      bump: this.bump,
+      ebuf: this.ebuf
+    };
+  }
+  static fromJSON(obj) {
+    return new _SlidingResultAccountData({
+      data: obj.data.map((item) => SlidingWindowElement.fromJSON(item)),
+      bump: obj.bump,
+      ebuf: obj.ebuf
+    });
+  }
+};
+var PermissionAccountData = class _PermissionAccountData {
+  authority;
+  permissions;
+  granter;
+  grantee;
+  expiration;
+  ebuf;
+  static discriminator = Buffer.from([
+    77,
+    37,
+    177,
+    164,
+    38,
+    39,
+    34,
+    109
+  ]);
+  static layout = borsh28__namespace.struct([
+    borshAddress2("authority"),
+    borsh28__namespace.u32("permissions"),
+    borshAddress2("granter"),
+    borshAddress2("grantee"),
+    borsh28__namespace.i64("expiration"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 256, "ebuf")
+  ]);
+  constructor(fields) {
+    this.authority = fields.authority;
+    this.permissions = fields.permissions;
+    this.granter = fields.granter;
+    this.grantee = fields.grantee;
+    this.expiration = fields.expiration;
+    this.ebuf = fields.ebuf;
+  }
+  static async fetch(rpc, address32, programId = PROGRAM_ID3) {
+    const info = await kit.fetchEncodedAccount(rpc, address32);
+    if (!info.exists) {
+      return null;
+    }
+    if (info.programAddress !== programId) {
+      throw new Error("account doesn't belong to this program");
+    }
+    return this.decode(Buffer.from(info.data));
+  }
+  static async fetchMultiple(rpc, addresses, programId = PROGRAM_ID3) {
+    const infos = await kit.fetchEncodedAccounts(rpc, addresses);
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null;
+      }
+      if (info.programAddress !== programId) {
+        throw new Error("account doesn't belong to this program");
+      }
+      return this.decode(Buffer.from(info.data));
+    });
+  }
+  static decode(data) {
+    if (!data.slice(0, 8).equals(_PermissionAccountData.discriminator)) {
+      throw new Error("invalid account discriminator");
+    }
+    const dec = _PermissionAccountData.layout.decode(data.slice(8));
+    return new _PermissionAccountData({
+      authority: dec.authority,
+      permissions: dec.permissions,
+      granter: dec.granter,
+      grantee: dec.grantee,
+      expiration: dec.expiration,
+      ebuf: dec.ebuf
+    });
+  }
+  toJSON() {
+    return {
+      authority: this.authority,
+      permissions: this.permissions,
+      granter: this.granter,
+      grantee: this.grantee,
+      expiration: this.expiration.toString(),
+      ebuf: this.ebuf
+    };
+  }
+  static fromJSON(obj) {
+    return new _PermissionAccountData({
+      authority: kit.address(obj.authority),
+      permissions: obj.permissions,
+      granter: kit.address(obj.granter),
+      grantee: kit.address(obj.grantee),
+      expiration: new BN10__default.default(obj.expiration),
+      ebuf: obj.ebuf
+    });
+  }
+};
+var RealmSpawnRecordAccountData = class _RealmSpawnRecordAccountData {
+  ebuf;
+  static discriminator = Buffer.from([229, 116, 99, 2, 145, 96, 5, 95]);
+  static layout = borsh28__namespace.struct([
+    borsh28__namespace.array(borsh28__namespace.u8(), 256, "ebuf")
+  ]);
+  constructor(fields) {
+    this.ebuf = fields.ebuf;
+  }
+  static async fetch(rpc, address32, programId = PROGRAM_ID3) {
+    const info = await kit.fetchEncodedAccount(rpc, address32);
+    if (!info.exists) {
+      return null;
+    }
+    if (info.programAddress !== programId) {
+      throw new Error("account doesn't belong to this program");
+    }
+    return this.decode(Buffer.from(info.data));
+  }
+  static async fetchMultiple(rpc, addresses, programId = PROGRAM_ID3) {
+    const infos = await kit.fetchEncodedAccounts(rpc, addresses);
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null;
+      }
+      if (info.programAddress !== programId) {
+        throw new Error("account doesn't belong to this program");
+      }
+      return this.decode(Buffer.from(info.data));
+    });
+  }
+  static decode(data) {
+    if (!data.slice(0, 8).equals(_RealmSpawnRecordAccountData.discriminator)) {
+      throw new Error("invalid account discriminator");
+    }
+    const dec = _RealmSpawnRecordAccountData.layout.decode(data.slice(8));
+    return new _RealmSpawnRecordAccountData({
+      ebuf: dec.ebuf
+    });
+  }
+  toJSON() {
+    return {
+      ebuf: this.ebuf
+    };
+  }
+  static fromJSON(obj) {
+    return new _RealmSpawnRecordAccountData({
+      ebuf: obj.ebuf
+    });
+  }
+};
+var LeaseAccountData = class _LeaseAccountData {
+  escrow;
+  queue;
+  aggregator;
+  tokenProgram;
+  isActive;
+  crankRowCount;
+  createdAt;
+  updateCount;
+  withdrawAuthority;
+  ebuf;
+  static discriminator = Buffer.from([
+    55,
+    254,
+    208,
+    251,
+    164,
+    44,
+    150,
+    50
+  ]);
+  static layout = borsh28__namespace.struct([
+    borshAddress2("escrow"),
+    borshAddress2("queue"),
+    borshAddress2("aggregator"),
+    borshAddress2("tokenProgram"),
+    borsh28__namespace.bool("isActive"),
+    borsh28__namespace.u32("crankRowCount"),
+    borsh28__namespace.i64("createdAt"),
+    borsh28__namespace.u128("updateCount"),
+    borshAddress2("withdrawAuthority"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 256, "ebuf")
+  ]);
+  constructor(fields) {
+    this.escrow = fields.escrow;
+    this.queue = fields.queue;
+    this.aggregator = fields.aggregator;
+    this.tokenProgram = fields.tokenProgram;
+    this.isActive = fields.isActive;
+    this.crankRowCount = fields.crankRowCount;
+    this.createdAt = fields.createdAt;
+    this.updateCount = fields.updateCount;
+    this.withdrawAuthority = fields.withdrawAuthority;
+    this.ebuf = fields.ebuf;
+  }
+  static async fetch(rpc, address32, programId = PROGRAM_ID3) {
+    const info = await kit.fetchEncodedAccount(rpc, address32);
+    if (!info.exists) {
+      return null;
+    }
+    if (info.programAddress !== programId) {
+      throw new Error("account doesn't belong to this program");
+    }
+    return this.decode(Buffer.from(info.data));
+  }
+  static async fetchMultiple(rpc, addresses, programId = PROGRAM_ID3) {
+    const infos = await kit.fetchEncodedAccounts(rpc, addresses);
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null;
+      }
+      if (info.programAddress !== programId) {
+        throw new Error("account doesn't belong to this program");
+      }
+      return this.decode(Buffer.from(info.data));
+    });
+  }
+  static decode(data) {
+    if (!data.slice(0, 8).equals(_LeaseAccountData.discriminator)) {
+      throw new Error("invalid account discriminator");
+    }
+    const dec = _LeaseAccountData.layout.decode(data.slice(8));
+    return new _LeaseAccountData({
+      escrow: dec.escrow,
+      queue: dec.queue,
+      aggregator: dec.aggregator,
+      tokenProgram: dec.tokenProgram,
+      isActive: dec.isActive,
+      crankRowCount: dec.crankRowCount,
+      createdAt: dec.createdAt,
+      updateCount: dec.updateCount,
+      withdrawAuthority: dec.withdrawAuthority,
+      ebuf: dec.ebuf
+    });
+  }
+  toJSON() {
+    return {
+      escrow: this.escrow,
+      queue: this.queue,
+      aggregator: this.aggregator,
+      tokenProgram: this.tokenProgram,
+      isActive: this.isActive,
+      crankRowCount: this.crankRowCount,
+      createdAt: this.createdAt.toString(),
+      updateCount: this.updateCount.toString(),
+      withdrawAuthority: this.withdrawAuthority,
+      ebuf: this.ebuf
+    };
+  }
+  static fromJSON(obj) {
+    return new _LeaseAccountData({
+      escrow: kit.address(obj.escrow),
+      queue: kit.address(obj.queue),
+      aggregator: kit.address(obj.aggregator),
+      tokenProgram: kit.address(obj.tokenProgram),
+      isActive: obj.isActive,
+      crankRowCount: obj.crankRowCount,
+      createdAt: new BN10__default.default(obj.createdAt),
+      updateCount: new BN10__default.default(obj.updateCount),
+      withdrawAuthority: kit.address(obj.withdrawAuthority),
+      ebuf: obj.ebuf
+    });
+  }
+};
+var OracleQueueAccountData = class _OracleQueueAccountData {
+  name;
+  metadata;
+  authority;
+  oracleTimeout;
+  reward;
+  minStake;
+  slashingEnabled;
+  varianceToleranceMultiplier;
+  feedProbationPeriod;
+  currIdx;
+  size;
+  gcIdx;
+  consecutiveFeedFailureLimit;
+  consecutiveOracleFailureLimit;
+  unpermissionedFeedsEnabled;
+  unpermissionedVrfEnabled;
+  curatorRewardCut;
+  lockLeaseFunding;
+  mint;
+  enableBufferRelayers;
+  ebuf;
+  maxSize;
+  dataBuffer;
+  static discriminator = Buffer.from([
+    164,
+    207,
+    200,
+    51,
+    199,
+    113,
+    35,
+    109
+  ]);
+  static layout = borsh28__namespace.struct([
+    borsh28__namespace.array(borsh28__namespace.u8(), 32, "name"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 64, "metadata"),
+    borshAddress2("authority"),
+    borsh28__namespace.u32("oracleTimeout"),
+    borsh28__namespace.u64("reward"),
+    borsh28__namespace.u64("minStake"),
+    borsh28__namespace.bool("slashingEnabled"),
+    SwitchboardDecimal.layout("varianceToleranceMultiplier"),
+    borsh28__namespace.u32("feedProbationPeriod"),
+    borsh28__namespace.u32("currIdx"),
+    borsh28__namespace.u32("size"),
+    borsh28__namespace.u32("gcIdx"),
+    borsh28__namespace.u64("consecutiveFeedFailureLimit"),
+    borsh28__namespace.u64("consecutiveOracleFailureLimit"),
+    borsh28__namespace.bool("unpermissionedFeedsEnabled"),
+    borsh28__namespace.bool("unpermissionedVrfEnabled"),
+    SwitchboardDecimal.layout("curatorRewardCut"),
+    borsh28__namespace.bool("lockLeaseFunding"),
+    borshAddress2("mint"),
+    borsh28__namespace.bool("enableBufferRelayers"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 968, "ebuf"),
+    borsh28__namespace.u32("maxSize"),
+    borshAddress2("dataBuffer")
+  ]);
+  constructor(fields) {
+    this.name = fields.name;
+    this.metadata = fields.metadata;
+    this.authority = fields.authority;
+    this.oracleTimeout = fields.oracleTimeout;
+    this.reward = fields.reward;
+    this.minStake = fields.minStake;
+    this.slashingEnabled = fields.slashingEnabled;
+    this.varianceToleranceMultiplier = new SwitchboardDecimal({
+      ...fields.varianceToleranceMultiplier
+    });
+    this.feedProbationPeriod = fields.feedProbationPeriod;
+    this.currIdx = fields.currIdx;
+    this.size = fields.size;
+    this.gcIdx = fields.gcIdx;
+    this.consecutiveFeedFailureLimit = fields.consecutiveFeedFailureLimit;
+    this.consecutiveOracleFailureLimit = fields.consecutiveOracleFailureLimit;
+    this.unpermissionedFeedsEnabled = fields.unpermissionedFeedsEnabled;
+    this.unpermissionedVrfEnabled = fields.unpermissionedVrfEnabled;
+    this.curatorRewardCut = new SwitchboardDecimal({
+      ...fields.curatorRewardCut
+    });
+    this.lockLeaseFunding = fields.lockLeaseFunding;
+    this.mint = fields.mint;
+    this.enableBufferRelayers = fields.enableBufferRelayers;
+    this.ebuf = fields.ebuf;
+    this.maxSize = fields.maxSize;
+    this.dataBuffer = fields.dataBuffer;
+  }
+  static async fetch(rpc, address32, programId = PROGRAM_ID3) {
+    const info = await kit.fetchEncodedAccount(rpc, address32);
+    if (!info.exists) {
+      return null;
+    }
+    if (info.programAddress !== programId) {
+      throw new Error("account doesn't belong to this program");
+    }
+    return this.decode(Buffer.from(info.data));
+  }
+  static async fetchMultiple(rpc, addresses, programId = PROGRAM_ID3) {
+    const infos = await kit.fetchEncodedAccounts(rpc, addresses);
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null;
+      }
+      if (info.programAddress !== programId) {
+        throw new Error("account doesn't belong to this program");
+      }
+      return this.decode(Buffer.from(info.data));
+    });
+  }
+  static decode(data) {
+    if (!data.slice(0, 8).equals(_OracleQueueAccountData.discriminator)) {
+      throw new Error("invalid account discriminator");
+    }
+    const dec = _OracleQueueAccountData.layout.decode(data.slice(8));
+    return new _OracleQueueAccountData({
+      name: dec.name,
+      metadata: dec.metadata,
+      authority: dec.authority,
+      oracleTimeout: dec.oracleTimeout,
+      reward: dec.reward,
+      minStake: dec.minStake,
+      slashingEnabled: dec.slashingEnabled,
+      varianceToleranceMultiplier: SwitchboardDecimal.fromDecoded(
+        dec.varianceToleranceMultiplier
+      ),
+      feedProbationPeriod: dec.feedProbationPeriod,
+      currIdx: dec.currIdx,
+      size: dec.size,
+      gcIdx: dec.gcIdx,
+      consecutiveFeedFailureLimit: dec.consecutiveFeedFailureLimit,
+      consecutiveOracleFailureLimit: dec.consecutiveOracleFailureLimit,
+      unpermissionedFeedsEnabled: dec.unpermissionedFeedsEnabled,
+      unpermissionedVrfEnabled: dec.unpermissionedVrfEnabled,
+      curatorRewardCut: SwitchboardDecimal.fromDecoded(
+        dec.curatorRewardCut
+      ),
+      lockLeaseFunding: dec.lockLeaseFunding,
+      mint: dec.mint,
+      enableBufferRelayers: dec.enableBufferRelayers,
+      ebuf: dec.ebuf,
+      maxSize: dec.maxSize,
+      dataBuffer: dec.dataBuffer
+    });
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      metadata: this.metadata,
+      authority: this.authority,
+      oracleTimeout: this.oracleTimeout,
+      reward: this.reward.toString(),
+      minStake: this.minStake.toString(),
+      slashingEnabled: this.slashingEnabled,
+      varianceToleranceMultiplier: this.varianceToleranceMultiplier.toJSON(),
+      feedProbationPeriod: this.feedProbationPeriod,
+      currIdx: this.currIdx,
+      size: this.size,
+      gcIdx: this.gcIdx,
+      consecutiveFeedFailureLimit: this.consecutiveFeedFailureLimit.toString(),
+      consecutiveOracleFailureLimit: this.consecutiveOracleFailureLimit.toString(),
+      unpermissionedFeedsEnabled: this.unpermissionedFeedsEnabled,
+      unpermissionedVrfEnabled: this.unpermissionedVrfEnabled,
+      curatorRewardCut: this.curatorRewardCut.toJSON(),
+      lockLeaseFunding: this.lockLeaseFunding,
+      mint: this.mint,
+      enableBufferRelayers: this.enableBufferRelayers,
+      ebuf: this.ebuf,
+      maxSize: this.maxSize,
+      dataBuffer: this.dataBuffer
+    };
+  }
+  static fromJSON(obj) {
+    return new _OracleQueueAccountData({
+      name: obj.name,
+      metadata: obj.metadata,
+      authority: kit.address(obj.authority),
+      oracleTimeout: obj.oracleTimeout,
+      reward: new BN10__default.default(obj.reward),
+      minStake: new BN10__default.default(obj.minStake),
+      slashingEnabled: obj.slashingEnabled,
+      varianceToleranceMultiplier: SwitchboardDecimal.fromJSON(
+        obj.varianceToleranceMultiplier
+      ),
+      feedProbationPeriod: obj.feedProbationPeriod,
+      currIdx: obj.currIdx,
+      size: obj.size,
+      gcIdx: obj.gcIdx,
+      consecutiveFeedFailureLimit: new BN10__default.default(obj.consecutiveFeedFailureLimit),
+      consecutiveOracleFailureLimit: new BN10__default.default(obj.consecutiveOracleFailureLimit),
+      unpermissionedFeedsEnabled: obj.unpermissionedFeedsEnabled,
+      unpermissionedVrfEnabled: obj.unpermissionedVrfEnabled,
+      curatorRewardCut: SwitchboardDecimal.fromJSON(obj.curatorRewardCut),
+      lockLeaseFunding: obj.lockLeaseFunding,
+      mint: kit.address(obj.mint),
+      enableBufferRelayers: obj.enableBufferRelayers,
+      ebuf: obj.ebuf,
+      maxSize: obj.maxSize,
+      dataBuffer: kit.address(obj.dataBuffer)
+    });
+  }
+};
+var CrankAccountData = class _CrankAccountData {
+  name;
+  metadata;
+  queuePubkey;
+  pqSize;
+  maxRows;
+  jitterModifier;
+  ebuf;
+  dataBuffer;
+  static discriminator = Buffer.from([
+    111,
+    81,
+    146,
+    73,
+    172,
+    180,
+    134,
+    209
+  ]);
+  static layout = borsh28__namespace.struct([
+    borsh28__namespace.array(borsh28__namespace.u8(), 32, "name"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 64, "metadata"),
+    borshAddress2("queuePubkey"),
+    borsh28__namespace.u32("pqSize"),
+    borsh28__namespace.u32("maxRows"),
+    borsh28__namespace.u8("jitterModifier"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 255, "ebuf"),
+    borshAddress2("dataBuffer")
+  ]);
+  constructor(fields) {
+    this.name = fields.name;
+    this.metadata = fields.metadata;
+    this.queuePubkey = fields.queuePubkey;
+    this.pqSize = fields.pqSize;
+    this.maxRows = fields.maxRows;
+    this.jitterModifier = fields.jitterModifier;
+    this.ebuf = fields.ebuf;
+    this.dataBuffer = fields.dataBuffer;
+  }
+  static async fetch(rpc, address32, programId = PROGRAM_ID3) {
+    const info = await kit.fetchEncodedAccount(rpc, address32);
+    if (!info.exists) {
+      return null;
+    }
+    if (info.programAddress !== programId) {
+      throw new Error("account doesn't belong to this program");
+    }
+    return this.decode(Buffer.from(info.data));
+  }
+  static async fetchMultiple(rpc, addresses, programId = PROGRAM_ID3) {
+    const infos = await kit.fetchEncodedAccounts(rpc, addresses);
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null;
+      }
+      if (info.programAddress !== programId) {
+        throw new Error("account doesn't belong to this program");
+      }
+      return this.decode(Buffer.from(info.data));
+    });
+  }
+  static decode(data) {
+    if (!data.slice(0, 8).equals(_CrankAccountData.discriminator)) {
+      throw new Error("invalid account discriminator");
+    }
+    const dec = _CrankAccountData.layout.decode(data.slice(8));
+    return new _CrankAccountData({
+      name: dec.name,
+      metadata: dec.metadata,
+      queuePubkey: dec.queuePubkey,
+      pqSize: dec.pqSize,
+      maxRows: dec.maxRows,
+      jitterModifier: dec.jitterModifier,
+      ebuf: dec.ebuf,
+      dataBuffer: dec.dataBuffer
+    });
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      metadata: this.metadata,
+      queuePubkey: this.queuePubkey,
+      pqSize: this.pqSize,
+      maxRows: this.maxRows,
+      jitterModifier: this.jitterModifier,
+      ebuf: this.ebuf,
+      dataBuffer: this.dataBuffer
+    };
+  }
+  static fromJSON(obj) {
+    return new _CrankAccountData({
+      name: obj.name,
+      metadata: obj.metadata,
+      queuePubkey: kit.address(obj.queuePubkey),
+      pqSize: obj.pqSize,
+      maxRows: obj.maxRows,
+      jitterModifier: obj.jitterModifier,
+      ebuf: obj.ebuf,
+      dataBuffer: kit.address(obj.dataBuffer)
+    });
+  }
+};
+var OracleAccountData = class _OracleAccountData {
+  name;
+  metadata;
+  oracleAuthority;
+  lastHeartbeat;
+  numInUse;
+  tokenAccount;
+  queuePubkey;
+  metrics;
+  ebuf;
+  static discriminator = Buffer.from([
+    128,
+    30,
+    16,
+    241,
+    170,
+    73,
+    55,
+    54
+  ]);
+  static layout = borsh28__namespace.struct([
+    borsh28__namespace.array(borsh28__namespace.u8(), 32, "name"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 128, "metadata"),
+    borshAddress2("oracleAuthority"),
+    borsh28__namespace.i64("lastHeartbeat"),
+    borsh28__namespace.u32("numInUse"),
+    borshAddress2("tokenAccount"),
+    borshAddress2("queuePubkey"),
+    OracleMetrics.layout("metrics"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 256, "ebuf")
+  ]);
+  constructor(fields) {
+    this.name = fields.name;
+    this.metadata = fields.metadata;
+    this.oracleAuthority = fields.oracleAuthority;
+    this.lastHeartbeat = fields.lastHeartbeat;
+    this.numInUse = fields.numInUse;
+    this.tokenAccount = fields.tokenAccount;
+    this.queuePubkey = fields.queuePubkey;
+    this.metrics = new OracleMetrics({ ...fields.metrics });
+    this.ebuf = fields.ebuf;
+  }
+  static async fetch(rpc, address32, programId = PROGRAM_ID3) {
+    const info = await kit.fetchEncodedAccount(rpc, address32);
+    if (!info.exists) {
+      return null;
+    }
+    if (info.programAddress !== programId) {
+      throw new Error("account doesn't belong to this program");
+    }
+    return this.decode(Buffer.from(info.data));
+  }
+  static async fetchMultiple(rpc, addresses, programId = PROGRAM_ID3) {
+    const infos = await kit.fetchEncodedAccounts(rpc, addresses);
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null;
+      }
+      if (info.programAddress !== programId) {
+        throw new Error("account doesn't belong to this program");
+      }
+      return this.decode(Buffer.from(info.data));
+    });
+  }
+  static decode(data) {
+    if (!data.slice(0, 8).equals(_OracleAccountData.discriminator)) {
+      throw new Error("invalid account discriminator");
+    }
+    const dec = _OracleAccountData.layout.decode(data.slice(8));
+    return new _OracleAccountData({
+      name: dec.name,
+      metadata: dec.metadata,
+      oracleAuthority: dec.oracleAuthority,
+      lastHeartbeat: dec.lastHeartbeat,
+      numInUse: dec.numInUse,
+      tokenAccount: dec.tokenAccount,
+      queuePubkey: dec.queuePubkey,
+      metrics: OracleMetrics.fromDecoded(dec.metrics),
+      ebuf: dec.ebuf
+    });
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      metadata: this.metadata,
+      oracleAuthority: this.oracleAuthority,
+      lastHeartbeat: this.lastHeartbeat.toString(),
+      numInUse: this.numInUse,
+      tokenAccount: this.tokenAccount,
+      queuePubkey: this.queuePubkey,
+      metrics: this.metrics.toJSON(),
+      ebuf: this.ebuf
+    };
+  }
+  static fromJSON(obj) {
+    return new _OracleAccountData({
+      name: obj.name,
+      metadata: obj.metadata,
+      oracleAuthority: kit.address(obj.oracleAuthority),
+      lastHeartbeat: new BN10__default.default(obj.lastHeartbeat),
+      numInUse: obj.numInUse,
+      tokenAccount: kit.address(obj.tokenAccount),
+      queuePubkey: kit.address(obj.queuePubkey),
+      metrics: OracleMetrics.fromJSON(obj.metrics),
+      ebuf: obj.ebuf
+    });
+  }
+};
+var JobAccountData = class _JobAccountData {
+  name;
+  metadata;
+  authority;
+  expiration;
+  hash;
+  data;
+  referenceCount;
+  totalSpent;
+  createdAt;
+  isInitializing;
+  static discriminator = Buffer.from([
+    124,
+    69,
+    101,
+    195,
+    229,
+    218,
+    144,
+    63
+  ]);
+  static layout = borsh28__namespace.struct([
+    borsh28__namespace.array(borsh28__namespace.u8(), 32, "name"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 64, "metadata"),
+    borshAddress2("authority"),
+    borsh28__namespace.i64("expiration"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 32, "hash"),
+    borsh28__namespace.vecU8("data"),
+    borsh28__namespace.u32("referenceCount"),
+    borsh28__namespace.u64("totalSpent"),
+    borsh28__namespace.i64("createdAt"),
+    borsh28__namespace.u8("isInitializing")
+  ]);
+  constructor(fields) {
+    this.name = fields.name;
+    this.metadata = fields.metadata;
+    this.authority = fields.authority;
+    this.expiration = fields.expiration;
+    this.hash = fields.hash;
+    this.data = fields.data;
+    this.referenceCount = fields.referenceCount;
+    this.totalSpent = fields.totalSpent;
+    this.createdAt = fields.createdAt;
+    this.isInitializing = fields.isInitializing;
+  }
+  static async fetch(rpc, address32, programId = PROGRAM_ID3) {
+    const info = await kit.fetchEncodedAccount(rpc, address32);
+    if (!info.exists) {
+      return null;
+    }
+    if (info.programAddress !== programId) {
+      throw new Error("account doesn't belong to this program");
+    }
+    return this.decode(Buffer.from(info.data));
+  }
+  static async fetchMultiple(rpc, addresses, programId = PROGRAM_ID3) {
+    const infos = await kit.fetchEncodedAccounts(rpc, addresses);
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null;
+      }
+      if (info.programAddress !== programId) {
+        throw new Error("account doesn't belong to this program");
+      }
+      return this.decode(Buffer.from(info.data));
+    });
+  }
+  static decode(data) {
+    if (!data.slice(0, 8).equals(_JobAccountData.discriminator)) {
+      throw new Error("invalid account discriminator");
+    }
+    const dec = _JobAccountData.layout.decode(data.slice(8));
+    return new _JobAccountData({
+      name: dec.name,
+      metadata: dec.metadata,
+      authority: dec.authority,
+      expiration: dec.expiration,
+      hash: dec.hash,
+      data: new Uint8Array(
+        dec.data.buffer,
+        dec.data.byteOffset,
+        dec.data.length
+      ),
+      referenceCount: dec.referenceCount,
+      totalSpent: dec.totalSpent,
+      createdAt: dec.createdAt,
+      isInitializing: dec.isInitializing
+    });
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      metadata: this.metadata,
+      authority: this.authority,
+      expiration: this.expiration.toString(),
+      hash: this.hash,
+      data: Array.from(this.data.values()),
+      referenceCount: this.referenceCount,
+      totalSpent: this.totalSpent.toString(),
+      createdAt: this.createdAt.toString(),
+      isInitializing: this.isInitializing
+    };
+  }
+  static fromJSON(obj) {
+    return new _JobAccountData({
+      name: obj.name,
+      metadata: obj.metadata,
+      authority: kit.address(obj.authority),
+      expiration: new BN10__default.default(obj.expiration),
+      hash: obj.hash,
+      data: Uint8Array.from(obj.data),
+      referenceCount: obj.referenceCount,
+      totalSpent: new BN10__default.default(obj.totalSpent),
+      createdAt: new BN10__default.default(obj.createdAt),
+      isInitializing: obj.isInitializing
+    });
+  }
+};
+var VrfAccountData = class _VrfAccountData {
+  status;
+  counter;
+  authority;
+  oracleQueue;
+  escrow;
+  callback;
+  batchSize;
+  builders;
+  buildersLen;
+  testMode;
+  currentRound;
+  ebuf;
+  static discriminator = Buffer.from([
+    101,
+    35,
+    62,
+    239,
+    103,
+    151,
+    6,
+    18
+  ]);
+  static layout = borsh28__namespace.struct([
+    VrfStatus_exports.layout("status"),
+    borsh28__namespace.u128("counter"),
+    borshAddress2("authority"),
+    borshAddress2("oracleQueue"),
+    borshAddress2("escrow"),
+    CallbackZC.layout("callback"),
+    borsh28__namespace.u32("batchSize"),
+    borsh28__namespace.array(VrfBuilder.layout(), 8, "builders"),
+    borsh28__namespace.u32("buildersLen"),
+    borsh28__namespace.bool("testMode"),
+    VrfRound.layout("currentRound"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 1024, "ebuf")
+  ]);
+  constructor(fields) {
+    this.status = fields.status;
+    this.counter = fields.counter;
+    this.authority = fields.authority;
+    this.oracleQueue = fields.oracleQueue;
+    this.escrow = fields.escrow;
+    this.callback = new CallbackZC({ ...fields.callback });
+    this.batchSize = fields.batchSize;
+    this.builders = fields.builders.map(
+      (item) => new VrfBuilder({ ...item })
+    );
+    this.buildersLen = fields.buildersLen;
+    this.testMode = fields.testMode;
+    this.currentRound = new VrfRound({ ...fields.currentRound });
+    this.ebuf = fields.ebuf;
+  }
+  static async fetch(rpc, address32, programId = PROGRAM_ID3) {
+    const info = await kit.fetchEncodedAccount(rpc, address32);
+    if (!info.exists) {
+      return null;
+    }
+    if (info.programAddress !== programId) {
+      throw new Error("account doesn't belong to this program");
+    }
+    return this.decode(Buffer.from(info.data));
+  }
+  static async fetchMultiple(rpc, addresses, programId = PROGRAM_ID3) {
+    const infos = await kit.fetchEncodedAccounts(rpc, addresses);
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null;
+      }
+      if (info.programAddress !== programId) {
+        throw new Error("account doesn't belong to this program");
+      }
+      return this.decode(Buffer.from(info.data));
+    });
+  }
+  static decode(data) {
+    if (!data.slice(0, 8).equals(_VrfAccountData.discriminator)) {
+      throw new Error("invalid account discriminator");
+    }
+    const dec = _VrfAccountData.layout.decode(data.slice(8));
+    return new _VrfAccountData({
+      status: VrfStatus_exports.fromDecoded(dec.status),
+      counter: dec.counter,
+      authority: dec.authority,
+      oracleQueue: dec.oracleQueue,
+      escrow: dec.escrow,
+      callback: CallbackZC.fromDecoded(dec.callback),
+      batchSize: dec.batchSize,
+      builders: dec.builders.map(
+        (item) => VrfBuilder.fromDecoded(item)
+      ),
+      buildersLen: dec.buildersLen,
+      testMode: dec.testMode,
+      currentRound: VrfRound.fromDecoded(dec.currentRound),
+      ebuf: dec.ebuf
+    });
+  }
+  toJSON() {
+    return {
+      status: this.status.toJSON(),
+      counter: this.counter.toString(),
+      authority: this.authority,
+      oracleQueue: this.oracleQueue,
+      escrow: this.escrow,
+      callback: this.callback.toJSON(),
+      batchSize: this.batchSize,
+      builders: this.builders.map((item) => item.toJSON()),
+      buildersLen: this.buildersLen,
+      testMode: this.testMode,
+      currentRound: this.currentRound.toJSON(),
+      ebuf: this.ebuf
+    };
+  }
+  static fromJSON(obj) {
+    return new _VrfAccountData({
+      status: VrfStatus_exports.fromJSON(obj.status),
+      counter: new BN10__default.default(obj.counter),
+      authority: kit.address(obj.authority),
+      oracleQueue: kit.address(obj.oracleQueue),
+      escrow: kit.address(obj.escrow),
+      callback: CallbackZC.fromJSON(obj.callback),
+      batchSize: obj.batchSize,
+      builders: obj.builders.map((item) => VrfBuilder.fromJSON(item)),
+      buildersLen: obj.buildersLen,
+      testMode: obj.testMode,
+      currentRound: VrfRound.fromJSON(obj.currentRound),
+      ebuf: obj.ebuf
+    });
+  }
+};
+var VrfLiteAccountData = class _VrfLiteAccountData {
+  stateBump;
+  permissionBump;
+  vrfPool;
+  status;
+  result;
+  counter;
+  alpha;
+  alphaLen;
+  requestSlot;
+  requestTimestamp;
+  authority;
+  queue;
+  escrow;
+  callback;
+  builder;
+  expiration;
+  ebuf;
+  static discriminator = Buffer.from([
+    98,
+    127,
+    126,
+    124,
+    166,
+    81,
+    97,
+    100
+  ]);
+  static layout = borsh28__namespace.struct([
+    borsh28__namespace.u8("stateBump"),
+    borsh28__namespace.u8("permissionBump"),
+    borshAddress2("vrfPool"),
+    VrfStatus_exports.layout("status"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 32, "result"),
+    borsh28__namespace.u128("counter"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 256, "alpha"),
+    borsh28__namespace.u32("alphaLen"),
+    borsh28__namespace.u64("requestSlot"),
+    borsh28__namespace.i64("requestTimestamp"),
+    borshAddress2("authority"),
+    borshAddress2("queue"),
+    borshAddress2("escrow"),
+    CallbackZC.layout("callback"),
+    VrfBuilder.layout("builder"),
+    borsh28__namespace.i64("expiration"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 1024, "ebuf")
+  ]);
+  constructor(fields) {
+    this.stateBump = fields.stateBump;
+    this.permissionBump = fields.permissionBump;
+    this.vrfPool = fields.vrfPool;
+    this.status = fields.status;
+    this.result = fields.result;
+    this.counter = fields.counter;
+    this.alpha = fields.alpha;
+    this.alphaLen = fields.alphaLen;
+    this.requestSlot = fields.requestSlot;
+    this.requestTimestamp = fields.requestTimestamp;
+    this.authority = fields.authority;
+    this.queue = fields.queue;
+    this.escrow = fields.escrow;
+    this.callback = new CallbackZC({ ...fields.callback });
+    this.builder = new VrfBuilder({ ...fields.builder });
+    this.expiration = fields.expiration;
+    this.ebuf = fields.ebuf;
+  }
+  static async fetch(rpc, address32, programId = PROGRAM_ID3) {
+    const info = await kit.fetchEncodedAccount(rpc, address32);
+    if (!info.exists) {
+      return null;
+    }
+    if (info.programAddress !== programId) {
+      throw new Error("account doesn't belong to this program");
+    }
+    return this.decode(Buffer.from(info.data));
+  }
+  static async fetchMultiple(rpc, addresses, programId = PROGRAM_ID3) {
+    const infos = await kit.fetchEncodedAccounts(rpc, addresses);
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null;
+      }
+      if (info.programAddress !== programId) {
+        throw new Error("account doesn't belong to this program");
+      }
+      return this.decode(Buffer.from(info.data));
+    });
+  }
+  static decode(data) {
+    if (!data.slice(0, 8).equals(_VrfLiteAccountData.discriminator)) {
+      throw new Error("invalid account discriminator");
+    }
+    const dec = _VrfLiteAccountData.layout.decode(data.slice(8));
+    return new _VrfLiteAccountData({
+      stateBump: dec.stateBump,
+      permissionBump: dec.permissionBump,
+      vrfPool: dec.vrfPool,
+      status: VrfStatus_exports.fromDecoded(dec.status),
+      result: dec.result,
+      counter: dec.counter,
+      alpha: dec.alpha,
+      alphaLen: dec.alphaLen,
+      requestSlot: dec.requestSlot,
+      requestTimestamp: dec.requestTimestamp,
+      authority: dec.authority,
+      queue: dec.queue,
+      escrow: dec.escrow,
+      callback: CallbackZC.fromDecoded(dec.callback),
+      builder: VrfBuilder.fromDecoded(dec.builder),
+      expiration: dec.expiration,
+      ebuf: dec.ebuf
+    });
+  }
+  toJSON() {
+    return {
+      stateBump: this.stateBump,
+      permissionBump: this.permissionBump,
+      vrfPool: this.vrfPool,
+      status: this.status.toJSON(),
+      result: this.result,
+      counter: this.counter.toString(),
+      alpha: this.alpha,
+      alphaLen: this.alphaLen,
+      requestSlot: this.requestSlot.toString(),
+      requestTimestamp: this.requestTimestamp.toString(),
+      authority: this.authority,
+      queue: this.queue,
+      escrow: this.escrow,
+      callback: this.callback.toJSON(),
+      builder: this.builder.toJSON(),
+      expiration: this.expiration.toString(),
+      ebuf: this.ebuf
+    };
+  }
+  static fromJSON(obj) {
+    return new _VrfLiteAccountData({
+      stateBump: obj.stateBump,
+      permissionBump: obj.permissionBump,
+      vrfPool: kit.address(obj.vrfPool),
+      status: VrfStatus_exports.fromJSON(obj.status),
+      result: obj.result,
+      counter: new BN10__default.default(obj.counter),
+      alpha: obj.alpha,
+      alphaLen: obj.alphaLen,
+      requestSlot: new BN10__default.default(obj.requestSlot),
+      requestTimestamp: new BN10__default.default(obj.requestTimestamp),
+      authority: kit.address(obj.authority),
+      queue: kit.address(obj.queue),
+      escrow: kit.address(obj.escrow),
+      callback: CallbackZC.fromJSON(obj.callback),
+      builder: VrfBuilder.fromJSON(obj.builder),
+      expiration: new BN10__default.default(obj.expiration),
+      ebuf: obj.ebuf
+    });
+  }
+};
+var VrfPoolAccountData = class _VrfPoolAccountData {
+  authority;
+  queue;
+  escrow;
+  minInterval;
+  maxRows;
+  size;
+  idx;
+  stateBump;
+  ebuf;
+  static discriminator = Buffer.from([86, 67, 58, 9, 46, 21, 101, 248]);
+  static layout = borsh28__namespace.struct([
+    borshAddress2("authority"),
+    borshAddress2("queue"),
+    borshAddress2("escrow"),
+    borsh28__namespace.u32("minInterval"),
+    borsh28__namespace.u32("maxRows"),
+    borsh28__namespace.u32("size"),
+    borsh28__namespace.u32("idx"),
+    borsh28__namespace.u8("stateBump"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 135, "ebuf")
+  ]);
+  constructor(fields) {
+    this.authority = fields.authority;
+    this.queue = fields.queue;
+    this.escrow = fields.escrow;
+    this.minInterval = fields.minInterval;
+    this.maxRows = fields.maxRows;
+    this.size = fields.size;
+    this.idx = fields.idx;
+    this.stateBump = fields.stateBump;
+    this.ebuf = fields.ebuf;
+  }
+  static async fetch(rpc, address32, programId = PROGRAM_ID3) {
+    const info = await kit.fetchEncodedAccount(rpc, address32);
+    if (!info.exists) {
+      return null;
+    }
+    if (info.programAddress !== programId) {
+      throw new Error("account doesn't belong to this program");
+    }
+    return this.decode(Buffer.from(info.data));
+  }
+  static async fetchMultiple(rpc, addresses, programId = PROGRAM_ID3) {
+    const infos = await kit.fetchEncodedAccounts(rpc, addresses);
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null;
+      }
+      if (info.programAddress !== programId) {
+        throw new Error("account doesn't belong to this program");
+      }
+      return this.decode(Buffer.from(info.data));
+    });
+  }
+  static decode(data) {
+    if (!data.slice(0, 8).equals(_VrfPoolAccountData.discriminator)) {
+      throw new Error("invalid account discriminator");
+    }
+    const dec = _VrfPoolAccountData.layout.decode(data.slice(8));
+    return new _VrfPoolAccountData({
+      authority: dec.authority,
+      queue: dec.queue,
+      escrow: dec.escrow,
+      minInterval: dec.minInterval,
+      maxRows: dec.maxRows,
+      size: dec.size,
+      idx: dec.idx,
+      stateBump: dec.stateBump,
+      ebuf: dec.ebuf
+    });
+  }
+  toJSON() {
+    return {
+      authority: this.authority,
+      queue: this.queue,
+      escrow: this.escrow,
+      minInterval: this.minInterval,
+      maxRows: this.maxRows,
+      size: this.size,
+      idx: this.idx,
+      stateBump: this.stateBump,
+      ebuf: this.ebuf
+    };
+  }
+  static fromJSON(obj) {
+    return new _VrfPoolAccountData({
+      authority: kit.address(obj.authority),
+      queue: kit.address(obj.queue),
+      escrow: kit.address(obj.escrow),
+      minInterval: obj.minInterval,
+      maxRows: obj.maxRows,
+      size: obj.size,
+      idx: obj.idx,
+      stateBump: obj.stateBump,
+      ebuf: obj.ebuf
+    });
+  }
+};
+var BufferRelayerAccountData = class _BufferRelayerAccountData {
+  name;
+  queuePubkey;
+  escrow;
+  authority;
+  jobPubkey;
+  jobHash;
+  minUpdateDelaySeconds;
+  isLocked;
+  currentRound;
+  latestConfirmedRound;
+  result;
+  static discriminator = Buffer.from([
+    50,
+    35,
+    51,
+    115,
+    169,
+    219,
+    158,
+    52
+  ]);
+  static layout = borsh28__namespace.struct([
+    borsh28__namespace.array(borsh28__namespace.u8(), 32, "name"),
+    borshAddress2("queuePubkey"),
+    borshAddress2("escrow"),
+    borshAddress2("authority"),
+    borshAddress2("jobPubkey"),
+    borsh28__namespace.array(borsh28__namespace.u8(), 32, "jobHash"),
+    borsh28__namespace.u32("minUpdateDelaySeconds"),
+    borsh28__namespace.bool("isLocked"),
+    BufferRelayerRound.layout("currentRound"),
+    BufferRelayerRound.layout("latestConfirmedRound"),
+    borsh28__namespace.vecU8("result")
+  ]);
+  constructor(fields) {
+    this.name = fields.name;
+    this.queuePubkey = fields.queuePubkey;
+    this.escrow = fields.escrow;
+    this.authority = fields.authority;
+    this.jobPubkey = fields.jobPubkey;
+    this.jobHash = fields.jobHash;
+    this.minUpdateDelaySeconds = fields.minUpdateDelaySeconds;
+    this.isLocked = fields.isLocked;
+    this.currentRound = new BufferRelayerRound({ ...fields.currentRound });
+    this.latestConfirmedRound = new BufferRelayerRound({
+      ...fields.latestConfirmedRound
+    });
+    this.result = fields.result;
+  }
+  static async fetch(rpc, address32, programId = PROGRAM_ID3) {
+    const info = await kit.fetchEncodedAccount(rpc, address32);
+    if (!info.exists) {
+      return null;
+    }
+    if (info.programAddress !== programId) {
+      throw new Error("account doesn't belong to this program");
+    }
+    return this.decode(Buffer.from(info.data));
+  }
+  static async fetchMultiple(rpc, addresses, programId = PROGRAM_ID3) {
+    const infos = await kit.fetchEncodedAccounts(rpc, addresses);
+    return infos.map((info) => {
+      if (!info.exists) {
+        return null;
+      }
+      if (info.programAddress !== programId) {
+        throw new Error("account doesn't belong to this program");
+      }
+      return this.decode(Buffer.from(info.data));
+    });
+  }
+  static decode(data) {
+    if (!data.slice(0, 8).equals(_BufferRelayerAccountData.discriminator)) {
+      throw new Error("invalid account discriminator");
+    }
+    const dec = _BufferRelayerAccountData.layout.decode(data.slice(8));
+    return new _BufferRelayerAccountData({
+      name: dec.name,
+      queuePubkey: dec.queuePubkey,
+      escrow: dec.escrow,
+      authority: dec.authority,
+      jobPubkey: dec.jobPubkey,
+      jobHash: dec.jobHash,
+      minUpdateDelaySeconds: dec.minUpdateDelaySeconds,
+      isLocked: dec.isLocked,
+      currentRound: BufferRelayerRound.fromDecoded(dec.currentRound),
+      latestConfirmedRound: BufferRelayerRound.fromDecoded(
+        dec.latestConfirmedRound
+      ),
+      result: new Uint8Array(
+        dec.result.buffer,
+        dec.result.byteOffset,
+        dec.result.length
+      )
+    });
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      queuePubkey: this.queuePubkey,
+      escrow: this.escrow,
+      authority: this.authority,
+      jobPubkey: this.jobPubkey,
+      jobHash: this.jobHash,
+      minUpdateDelaySeconds: this.minUpdateDelaySeconds,
+      isLocked: this.isLocked,
+      currentRound: this.currentRound.toJSON(),
+      latestConfirmedRound: this.latestConfirmedRound.toJSON(),
+      result: Array.from(this.result.values())
+    };
+  }
+  static fromJSON(obj) {
+    return new _BufferRelayerAccountData({
+      name: obj.name,
+      queuePubkey: kit.address(obj.queuePubkey),
+      escrow: kit.address(obj.escrow),
+      authority: kit.address(obj.authority),
+      jobPubkey: kit.address(obj.jobPubkey),
+      jobHash: obj.jobHash,
+      minUpdateDelaySeconds: obj.minUpdateDelaySeconds,
+      isLocked: obj.isLocked,
+      currentRound: BufferRelayerRound.fromJSON(obj.currentRound),
+      latestConfirmedRound: BufferRelayerRound.fromJSON(
+        obj.latestConfirmedRound
+      ),
+      result: Uint8Array.from(obj.result)
+    });
+  }
+};
+function getLatestAggregatorValue(aggregator, maxStaleness = 0) {
+  if ((aggregator.latestConfirmedRound?.numSuccess ?? 0) === 0) {
+    return null;
+  }
+  if (maxStaleness !== 0) {
+    const now = new BN10__default.default(Date.now() / 1e3);
+    const latestRoundTimestamp = aggregator.latestConfirmedRound.roundOpenTimestamp;
+    const staleness = now.sub(latestRoundTimestamp);
+    if (staleness.gt(new BN10__default.default(maxStaleness))) {
+      return null;
+    }
+  }
+  const mantissa = new Decimal4__default.default(aggregator.latestConfirmedRound.result.mantissa.toString());
+  const scale = aggregator.latestConfirmedRound.result.scale;
+  const result = mantissa.div(new Decimal4__default.default(10).pow(scale));
+  return new Decimal4__default.default(result.toPrecision(20));
+}
+
+// src/utils/oracle.ts
+var MAX_CONFIDENCE_PERCENTAGE = new Decimal4__default.default("2");
+var CONFIDENCE_FACTOR = new Decimal4__default.default("100").div(MAX_CONFIDENCE_PERCENTAGE);
+var getScopeAddress = () => {
+  return kit.address("HFn8GnPADiny6XqUoWE8uRPPxb29ikn4yTuPa9MF2fWJ");
+};
+function getTokenOracleDataSync(allOracleAccounts, reserves) {
+  const tokenOracleDataForReserves = [];
+  const pythCache = /* @__PURE__ */ new Map();
+  const switchboardCache = /* @__PURE__ */ new Map();
+  const scopeCache = /* @__PURE__ */ new Map();
+  for (const { address: address32, state: reserve } of reserves) {
+    let currentBest = void 0;
+    const oracle = {
+      pythAddress: reserve.config.tokenInfo.pythConfiguration.price,
+      switchboardFeedAddress: reserve.config.tokenInfo.switchboardConfiguration.priceAggregator,
+      switchboardTwapAddress: reserve.config.tokenInfo.switchboardConfiguration.twapAggregator,
+      scopeOracleAddress: reserve.config.tokenInfo.scopeConfiguration.priceFeed
+    };
+    if (isNotNullPubkey(oracle.pythAddress)) {
+      const pythPrices = cacheOrGetPythPrices(oracle.pythAddress, pythCache, allOracleAccounts);
+      if (pythPrices && pythPrices.spot) {
+        currentBest = getBestPrice(currentBest, pythPrices.spot);
+      }
+    }
+    if (isNotNullPubkey(oracle.switchboardFeedAddress)) {
+      const switchboardPrice = cacheOrGetSwitchboardPrice(
+        oracle.switchboardFeedAddress,
+        switchboardCache,
+        allOracleAccounts
+      );
+      if (switchboardPrice) {
+        currentBest = getBestPrice(currentBest, switchboardPrice);
+      }
+    }
+    if (isNotNullPubkey(oracle.scopeOracleAddress)) {
+      const scopePrice = cacheOrGetScopePrice(
+        oracle.scopeOracleAddress,
+        scopeCache,
+        allOracleAccounts,
+        reserve.config.tokenInfo.scopeConfiguration.priceChain
+      );
+      if (scopePrice) {
+        currentBest = getBestPrice(currentBest, scopePrice);
+      }
+    }
+    if (!currentBest) {
+      const reserveSymbol = parseTokenSymbol(reserve.config.tokenInfo.name);
+      console.error(
+        `No price found for reserve: ${reserveSymbol ?? "unknown"} (${address32}) in market: ${reserve.lendingMarket}`
+      );
+      tokenOracleDataForReserves.push([reserve, void 0]);
+      continue;
+    }
+    const tokenOracleData = {
+      mintAddress: reserve.liquidity.mintPubkey,
+      decimals: Decimal4__default.default.pow(10, reserve.liquidity.mintDecimals.toString()),
+      price: new Decimal4__default.default(currentBest.price),
+      timestamp: currentBest.timestamp,
+      valid: currentBest.valid
+    };
+    tokenOracleDataForReserves.push([reserve, tokenOracleData]);
+  }
+  return tokenOracleDataForReserves;
+}
+async function getTokenOracleData(rpc, reserves, oracleAccounts) {
+  const allOracleAccounts = oracleAccounts ?? await getAllOracleAccounts(
+    rpc,
+    reserves.map((r) => r.state)
+  );
+  return getTokenOracleDataSync(allOracleAccounts, reserves);
+}
+async function getAllOracleAccounts(rpc, reserves) {
+  const allAccounts = [];
+  reserves.forEach((reserve) => {
+    if (isNotNullPubkey(reserve.config.tokenInfo.pythConfiguration.price)) {
+      allAccounts.push(reserve.config.tokenInfo.pythConfiguration.price);
+    }
+    if (isNotNullPubkey(reserve.config.tokenInfo.switchboardConfiguration.priceAggregator)) {
+      allAccounts.push(reserve.config.tokenInfo.switchboardConfiguration.priceAggregator);
+    }
+    if (isNotNullPubkey(reserve.config.tokenInfo.switchboardConfiguration.twapAggregator)) {
+      allAccounts.push(reserve.config.tokenInfo.switchboardConfiguration.twapAggregator);
+    }
+    if (isNotNullPubkey(reserve.config.tokenInfo.scopeConfiguration.priceFeed)) {
+      allAccounts.push(reserve.config.tokenInfo.scopeConfiguration.priceFeed);
+    }
+  });
+  const allAccountsDeduped = dedupKeys(allAccounts);
+  const allAccs = await kliquiditySdk.batchFetch(
+    allAccountsDeduped,
+    async (chunk) => (await rpc.getMultipleAccounts(chunk).send()).value
+  );
+  const allAccsMap = /* @__PURE__ */ new Map();
+  allAccs.forEach((acc, i) => {
+    if (acc !== null) {
+      allAccsMap.set(allAccountsDeduped[i], { ...acc, programAddress: acc.owner, address: allAccountsDeduped[i] });
+    }
+  });
+  return allAccsMap;
+}
+function dedupKeys(keys) {
+  return [...new Set(keys)];
+}
+function cacheOrGetPythPrices(oracle, cache, oracleAccounts) {
+  const prices = {};
+  const cached = cache.get(oracle);
+  if (cached) {
+    return cached;
+  } else {
+    const result = oracleAccounts.get(oracle);
+    if (result) {
+      try {
+        const { priceMessage } = priceUpdateV2.decode(buffer.Buffer.from(result.data[0], "base64"));
+        const { price, exponent, conf: confidence, publishTime: timestamp, emaPrice } = priceMessage;
+        if (price) {
+          const px = new Decimal4__default.default(price.toString()).div(10 ** Math.abs(exponent));
+          const conf = new Decimal4__default.default(confidence.toString());
+          prices.spot = {
+            price: px,
+            timestamp: BigInt(timestamp.toString()),
+            valid: validatePythPx(px, conf)
+          };
+        }
+        if (emaPrice !== void 0 && emaPrice !== null) {
+          const emaPx = new Decimal4__default.default(emaPrice.toString()).div(10 ** Math.abs(exponent));
+          prices.twap = {
+            price: emaPx,
+            timestamp: BigInt(timestamp.toString()),
+            valid: true
+          };
+        }
+        if (prices.spot || prices.twap) {
+          cache.set(oracle, prices);
+        }
+      } catch (error) {
+        console.error(`Error parsing pyth price account ${oracle.toString()} data`, error);
+        return null;
+      }
+    } else {
+      return null;
+    }
+  }
+  return prices;
+}
+function cacheOrGetSwitchboardPrice(oracle, switchboardCache, oracleAccounts) {
+  const cached = switchboardCache.get(oracle);
+  if (cached) {
+    return cached;
+  } else {
+    const info = oracleAccounts.get(oracle);
+    if (info) {
+      if (info.programAddress === PROGRAM_ID3) {
+        const agg = AggregatorAccountData.decode(buffer.Buffer.from(info.data[0], "base64"));
+        const result = getLatestAggregatorValue(agg);
+        if (result !== void 0 && result !== null) {
+          const switchboardPx = new Decimal4__default.default(result.toString());
+          const latestRoundTimestamp = agg.latestConfirmedRound.roundOpenTimestamp;
+          const ts = BigInt(latestRoundTimestamp.toString());
+          const valid = validateSwitchboardV2Px(agg);
+          return {
+            price: switchboardPx,
+            timestamp: ts,
+            valid
+          };
+        }
+      } else {
+        console.error("Unrecognized switchboard owner address: ", info.programAddress);
+        return null;
+      }
+    }
+  }
+  return null;
+}
+function cacheOrGetScopePrice(oracle, scopeCache, allOracleAccounts, chain) {
+  if (!isNotNullPubkey(oracle) || !chain || !scopeSdk.Scope.isScopeChainValid(chain)) {
+    return null;
+  }
+  const scopePrices = scopeCache.get(oracle);
+  if (scopePrices) {
+    return scopeChainToCandidatePrice(chain, scopePrices);
+  }
+  const info = allOracleAccounts.get(oracle);
+  if (info) {
+    const owner = info.programAddress;
+    if (owner === getScopeAddress()) {
+      const prices = OraclePrices.OraclePrices.decode(buffer.Buffer.from(info.data[0], "base64"));
+      scopeCache.set(oracle, prices);
+      return scopeChainToCandidatePrice(chain, prices);
+    } else {
+      console.error("Unrecognized scope owner address: ", owner);
+    }
+  }
+  return null;
+}
+function getBestPrice(current, next) {
+  if (isBetterPrice(current, next)) {
+    return next;
+  }
+  return current;
+}
+function isBetterPrice(current, next) {
+  if (!current) {
+    return true;
+  }
+  if (current.valid && !next.valid) {
+    return false;
+  }
+  if (!current.valid && next.valid) {
+    return true;
+  }
+  return next.timestamp > current.timestamp;
+}
+function validatePythPx(price, confidence) {
+  const conf50x = confidence.mul(CONFIDENCE_FACTOR);
+  return !price.isZero() && price.gt(conf50x);
+}
+function validateSwitchboardV2Px(agg) {
+  const pxMantissa = new Decimal4__default.default(agg.latestConfirmedRound.result.mantissa.toString());
+  const pxScale = new Decimal4__default.default(agg.latestConfirmedRound.result.scale.toString());
+  const stDevMantissa = new Decimal4__default.default(agg.latestConfirmedRound.stdDeviation.mantissa.toString());
+  const stDevScale = new Decimal4__default.default(agg.latestConfirmedRound.stdDeviation.scale.toString());
+  let conf50xScaled;
+  if (pxScale.gte(stDevScale)) {
+    const scalingFactor = pxScale.sub(stDevScale);
+    const conf50x = stDevMantissa.mul(CONFIDENCE_FACTOR);
+    conf50xScaled = conf50x.mul(scalingFactor);
+  } else {
+    const scalingFactor = stDevScale.sub(pxScale);
+    const conf50x = stDevMantissa.mul(CONFIDENCE_FACTOR);
+    conf50xScaled = conf50x.div(scalingFactor);
+  }
+  return conf50xScaled.gte(pxMantissa);
+}
+function scopeChainToCandidatePrice(chain, prices) {
+  const scopePx = scopeSdk.Scope.getPriceFromScopeChain(chain, prices);
+  const valid = scopePx.timestamp.gt("0");
+  return {
+    price: scopePx.price,
+    timestamp: BigInt(scopePx.timestamp.toString()),
+    valid
+  };
+}
+function getLatestRewardRate(rewardRates, slot) {
+  return rewardRates.filter((rr) => slot >= rr.beginningSlot).reduce((v1, v2) => v1.beginningSlot > v2.beginningSlot ? v1 : v2, {
+    beginningSlot: 0,
+    rewardRate: "0"
+  });
+}
+var calculateNewScore = (rewardStat, pool, rewardRate, endSlot, startSlot) => {
+  const { balance, debt, score } = pool;
+  const { rewardsPerShare, totalBalance } = rewardStat;
+  const oldDebt = new Decimal4__default.default(debt);
+  const oldScore = new Decimal4__default.default(score);
+  const oldRewardsPerShare = new Decimal4__default.default(rewardsPerShare);
+  const oldBalance = new Decimal4__default.default(balance);
+  const totalBalanceVal = new Decimal4__default.default(totalBalance);
+  const newRewardsPerShare = !totalBalanceVal.isZero() ? oldRewardsPerShare.plus(
+    new Decimal4__default.default(endSlot).minus(new Decimal4__default.default(startSlot.toString())).times(new Decimal4__default.default(rewardRate)).div(totalBalanceVal).div(new Decimal4__default.default(SLOTS_PER_YEAR))
+  ) : new Decimal4__default.default(0);
+  return oldScore.plus(newRewardsPerShare.times(oldBalance).minus(oldDebt));
+};
+var estimateCurrentScore = (rewardStat, rewardScore, mostRecentSlot, mostRecentSlotTime) => {
+  const { lastSlot, rewardRates } = rewardStat;
+  const estimatedCurrentSlot = mostRecentSlot + SLOTS_PER_SECOND * (Date.now() / 1e3 - mostRecentSlotTime);
+  const { rewardRate } = getLatestRewardRate(rewardRates, estimatedCurrentSlot);
+  const currentScore = calculateNewScore(rewardStat, rewardScore, rewardRate, estimatedCurrentSlot, lastSlot);
+  return currentScore;
+};
+var interpolate = (x, x0, x1, y0, y1) => {
+  if (x > x1) {
+    throw "Cannot do extrapolation";
+  }
+  return y0 + (x - x0) * (y1 - y0) / (x1 - x0);
+};
+var getBorrowRate = (currentUtilization, curve) => {
+  let [x0, y0, x1, y1] = [0, 0, 0, 0];
+  if (curve.length < 2) {
+    throw "Invalid borrow rate curve, only one point";
+  }
+  if (currentUtilization > 1) {
+    currentUtilization = 1;
+  }
+  for (let i = 1; i < curve.length; i++) {
+    const [pointUtilization, pointRate] = curve[i];
+    if (pointUtilization === currentUtilization) {
+      return pointRate;
+    }
+    if (currentUtilization <= pointUtilization) {
+      x0 = curve[i - 1][0];
+      y0 = curve[i - 1][1];
+      x1 = curve[i][0];
+      y1 = curve[i][1];
+      break;
+    }
+  }
+  if (x0 === 0 && y0 === 0 && x1 === 0 && y1 === 0) {
+    console.log("All are 0");
+    throw "Invalid borrow rate curve, could not identify the interpolation points.";
+  }
+  if (x0 >= x1 || y0 > y1) {
+    console.log("(x0, y0), (x1, y1)", x0, y0, x1, y1);
+    throw "Invalid borrow rate curve, curve is not uniformly increasing";
+  }
+  return interpolate(currentUtilization, x0, x1, y0, y1);
+};
+var parseTokenSymbol = (tokenSymbol) => {
+  return String.fromCharCode(...tokenSymbol.filter((x) => x > 0));
+};
+function parseZeroPaddedUtf8(utf8Array) {
+  for (let last = utf8Array.length - 1; last >= 0; last--) {
+    const trailing_zero = utf8Array[last];
+    if (trailing_zero != 0) {
+      const encoding = new Uint8Array(last + 1);
+      for (let i = 0; i <= last; i++) {
+        encoding[i] = utf8Array[i];
+      }
+      return new TextDecoder().decode(encoding);
+    }
+  }
+  return "";
+}
+function renderZeroPaddedUtf8(str, utf8ArrayLength) {
+  const encoding = new TextEncoder().encode(str);
+  const result = new Array(utf8ArrayLength);
+  for (let i = 0; i < result.length; i++) {
+    result[i] = i < encoding.length ? encoding[i] : 0;
+  }
+  return result;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function numberToLamportsDecimal(amount, decimals) {
+  const factor = 10 ** decimals;
+  return new Decimal4__default.default(amount).mul(factor);
+}
+function lamportsToNumberDecimal(amount, decimals) {
+  const factor = 10 ** decimals;
+  return new Decimal4__default.default(amount).div(factor);
+}
+function lamportsToDecimal(amount, decimals) {
+  const factor = new Decimal4__default.default(10).pow(decimals);
+  return new Decimal4__default.default(amount).div(factor);
+}
+var isSolMint = (mint) => {
+  return WRAPPED_SOL_MINT === mint;
+};
+var valueOrZero = (value) => {
+  const zero = new Decimal4__default.default(0);
+  if (value.isNaN() || !value.isFinite()) {
+    return zero;
+  } else {
+    return value;
+  }
+};
+var isEmptyObject = (obj) => {
+  return Object.keys(obj).length === 0 && obj.constructor === Object;
+};
+var positiveOrZero = (value) => {
+  const zero = new Decimal4__default.default(0);
+  return Decimal4__default.default.max(value, zero);
+};
+function calculateAPYFromAPR(apr) {
+  const apy = new Decimal4__default.default(1).plus(new Decimal4__default.default(apr).dividedBy(SLOTS_PER_YEAR)).toNumber() ** SLOTS_PER_YEAR - 1;
+  return apy;
+}
+function calculateAPRFromAPY(apy) {
+  return new Decimal4__default.default(apy).plus(1).pow(1 / SLOTS_PER_YEAR).minus(1).times(SLOTS_PER_YEAR);
+}
+function sameLengthArrayEquals(left, right) {
+  if (left.length != right.length) {
+    throw new Error(`Not same length: ${left.length} != ${right.length}`);
+  }
+  return left.every((value, index) => {
+    const other = right[index];
+    if (value != null && typeof value.eq === "function") {
+      return value.eq(other);
+    }
+    return value === other;
+  });
+}
+function getTokenBalanceFromAccountInfoLamports(token) {
+  return new Decimal4__default.default(token.data.amount.toString());
+}
+function bpsToPct(bps) {
+  return bps.div(100);
+}
+function truncateDecimals(num, maxDecimals) {
+  const factor = new Decimal4__default.default(10).pow(maxDecimals);
+  return new Decimal4__default.default(num).times(factor).floor().dividedBy(factor);
+}
+function decodeVaultName(token) {
+  const maxArray = new Uint8Array(token);
+  let s = new TextDecoder().decode(maxArray);
+  s = s.replace(/[\0 ]+$/, "");
+  return s;
+}
+function pubkeyHashMapToJson(map) {
+  const obj = {};
+  map.forEach((value, key) => {
+    obj[key] = value.toString();
+  });
+  return obj;
+}
+function toJson(object, inline = false) {
+  const replacer = (key, value) => typeof value === "bigint" ? value.toString() : value;
+  return inline ? JSON.stringify(object, replacer) : JSON.stringify(object, replacer, 2);
+}
+function assertNever(x) {
+  throw new Error("Unexpected object: " + x);
+}
+function orThrow(message) {
+  throw new Error(message);
+}
+function blobEquals(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  for (let i = 0; i < left.length; ++i) {
+    if (left[i] !== right[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function roundNearest(decimal) {
+  return decimal.toDecimalPlaces(0, Decimal4__default.default.ROUND_HALF_CEIL);
+}
+async function getMedianSlotDurationInMsFromLastEpochs() {
+  const response = await axios__default.default.get("https://api.kamino.finance/slots/duration");
+  return response.data.recentSlotDurationInMs;
+}
+
+exports.AggregatorAccountData = AggregatorAccountData;
+exports.BORROWS_LIMIT = BORROWS_LIMIT;
+exports.BufferRelayerAccountData = BufferRelayerAccountData;
+exports.CDN_ENDPOINT = CDN_ENDPOINT;
+exports.COMPUTE_BUDGET_PROGRAM_ID = COMPUTE_BUDGET_PROGRAM_ID;
+exports.CONFIDENCE_FACTOR = CONFIDENCE_FACTOR;
+exports.Config = Config;
+exports.CrankAccountData = CrankAccountData;
+exports.DEFAULT_KLEND_PROGRAM_ID = DEFAULT_KLEND_PROGRAM_ID;
+exports.DEFAULT_MAX_COMPUTE_UNITS = DEFAULT_MAX_COMPUTE_UNITS;
+exports.DEFAULT_PUBLIC_KEY = DEFAULT_PUBLIC_KEY;
+exports.DEPOSITS_LIMIT = DEPOSITS_LIMIT;
+exports.INITIAL_COLLATERAL_RATE = INITIAL_COLLATERAL_RATE;
+exports.JobAccountData = JobAccountData;
+exports.LeaseAccountData = LeaseAccountData;
+exports.MAX_CONFIDENCE_PERCENTAGE = MAX_CONFIDENCE_PERCENTAGE;
+exports.MIN_AUTODELEVERAGE_BONUS_BPS = MIN_AUTODELEVERAGE_BONUS_BPS;
+exports.MIN_INITIAL_DEPOSIT = MIN_INITIAL_DEPOSIT;
+exports.MIN_VAULT_INITIAL_DEPOSIT = MIN_VAULT_INITIAL_DEPOSIT;
+exports.NULL_PUBKEY = NULL_PUBKEY;
+exports.ONE_HUNDRED_PCT_IN_BPS = ONE_HUNDRED_PCT_IN_BPS;
+exports.OracleAccountData = OracleAccountData;
+exports.OracleQueueAccountData = OracleQueueAccountData;
+exports.PROGRAM_ID = PROGRAM_ID;
+exports.PROGRAM_ID_CLI = PROGRAM_ID_CLI;
+exports.PermissionAccountData = PermissionAccountData;
+exports.RealmSpawnRecordAccountData = RealmSpawnRecordAccountData;
+exports.SECONDS_PER_YEAR = SECONDS_PER_YEAR;
+exports.SLOTS_PER_DAY = SLOTS_PER_DAY;
+exports.SLOTS_PER_HOUR = SLOTS_PER_HOUR;
+exports.SLOTS_PER_MINUTE = SLOTS_PER_MINUTE;
+exports.SLOTS_PER_SECOND = SLOTS_PER_SECOND;
+exports.SLOTS_PER_YEAR = SLOTS_PER_YEAR;
+exports.SOL_DECIMALS = SOL_DECIMALS;
+exports.SOL_PADDING_FOR_INTEREST = SOL_PADDING_FOR_INTEREST;
+exports.STAGING_PROGRAM_ID = STAGING_PROGRAM_ID;
+exports.SbState = SbState;
+exports.SlidingResultAccountData = SlidingResultAccountData;
+exports.TOTAL_NUMBER_OF_IDS_TO_CHECK = TOTAL_NUMBER_OF_IDS_TO_CHECK;
+exports.TaskSpecRecord = TaskSpecRecord;
+exports.U64_MAX = U64_MAX;
+exports.VAULT_INITIAL_DEPOSIT = VAULT_INITIAL_DEPOSIT;
+exports.VrfAccountData = VrfAccountData;
+exports.VrfLiteAccountData = VrfLiteAccountData;
+exports.VrfPoolAccountData = VrfPoolAccountData;
+exports.WRAPPED_SOL_MINT = WRAPPED_SOL_MINT;
+exports.assertNever = assertNever;
+exports.blobEquals = blobEquals;
+exports.bpsToPct = bpsToPct;
+exports.cacheOrGetPythPrices = cacheOrGetPythPrices;
+exports.cacheOrGetScopePrice = cacheOrGetScopePrice;
+exports.cacheOrGetSwitchboardPrice = cacheOrGetSwitchboardPrice;
+exports.calculateAPRFromAPY = calculateAPRFromAPY;
+exports.calculateAPYFromAPR = calculateAPYFromAPR;
+exports.calculateNewScore = calculateNewScore;
+exports.decodeVaultName = decodeVaultName;
+exports.estimateCurrentScore = estimateCurrentScore;
+exports.getAllOracleAccounts = getAllOracleAccounts;
+exports.getApiEndpoint = getApiEndpoint;
+exports.getBorrowRate = getBorrowRate;
+exports.getLatestAggregatorValue = getLatestAggregatorValue;
+exports.getMedianSlotDurationInMsFromLastEpochs = getMedianSlotDurationInMsFromLastEpochs;
+exports.getProgramId = getProgramId;
+exports.getTokenBalanceFromAccountInfoLamports = getTokenBalanceFromAccountInfoLamports;
+exports.getTokenOracleData = getTokenOracleData;
+exports.getTokenOracleDataSync = getTokenOracleDataSync;
+exports.interpolate = interpolate;
+exports.isENV = isENV;
+exports.isEmptyObject = isEmptyObject;
+exports.isNotNullPubkey = isNotNullPubkey;
+exports.isSolMint = isSolMint;
+exports.lamportsToDecimal = lamportsToDecimal;
+exports.lamportsToNumberDecimal = lamportsToNumberDecimal;
+exports.numberToLamportsDecimal = numberToLamportsDecimal;
+exports.orThrow = orThrow;
+exports.parseTokenSymbol = parseTokenSymbol;
+exports.parseZeroPaddedUtf8 = parseZeroPaddedUtf8;
+exports.positiveOrZero = positiveOrZero;
+exports.priceUpdateV2 = priceUpdateV2;
+exports.pubkeyHashMapToJson = pubkeyHashMapToJson;
+exports.renderZeroPaddedUtf8 = renderZeroPaddedUtf8;
+exports.roundNearest = roundNearest;
+exports.sameLengthArrayEquals = sameLengthArrayEquals;
+exports.sleep = sleep;
+exports.toDays = toDays;
+exports.toHours = toHours;
+exports.toJson = toJson;
+exports.toSeconds = toSeconds;
+exports.truncateDecimals = truncateDecimals;
+exports.twapUpdate = twapUpdate;
+exports.valueOrZero = valueOrZero;
+//# sourceMappingURL=chunk-K2DZLHPZ.cjs.map
+//# sourceMappingURL=chunk-K2DZLHPZ.cjs.map