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

package/dist/chunk-K2DZLHPZ.cjs

@@ -1,4573 +0,0 @@
-'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