@solana/sysvars 2.0.0-preview.1

package/dist/index.node.cjs

@@ -0,0 +1,813 @@
+'use strict';
+
+var accounts = require('@solana/accounts');
+var codecs = require('@solana/codecs');
+var errors = require('@solana/errors');
+
+// src/clock.ts
+var SYSVAR_CLOCK_ADDRESS = "SysvarC1ock11111111111111111111111111111111";
+var SYSVAR_EPOCH_REWARDS_ADDRESS = "SysvarEpochRewards1111111111111111111111111";
+var SYSVAR_EPOCH_SCHEDULE_ADDRESS = "SysvarEpochSchedu1e111111111111111111111111";
+var SYSVAR_FEES_ADDRESS = "SysvarFees111111111111111111111111111111111";
+var SYSVAR_INSTRUCTIONS_ADDRESS = "Sysvar1nstructions1111111111111111111111111";
+var SYSVAR_LAST_RESTART_SLOT_ADDRESS = "SysvarLastRestartS1ot1111111111111111111111";
+var SYSVAR_RECENT_BLOCKHASHES_ADDRESS = "SysvarRecentB1ockHashes11111111111111111111";
+var SYSVAR_RENT_ADDRESS = "SysvarRent111111111111111111111111111111111";
+var SYSVAR_SLOT_HASHES_ADDRESS = "SysvarS1otHashes111111111111111111111111111";
+var SYSVAR_SLOT_HISTORY_ADDRESS = "SysvarS1otHistory11111111111111111111111111";
+var SYSVAR_STAKE_HISTORY_ADDRESS = "SysvarStakeHistory1111111111111111111111111";
+async function fetchEncodedSysvarAccount(rpc, address, config) {
+  return accounts.fetchEncodedAccount(rpc, address, config);
+}
+async function fetchJsonParsedSysvarAccount(rpc, address, config) {
+  return accounts.fetchJsonParsedAccount(rpc, address, config);
+}
+
+// src/clock.ts
+function getSysvarClockEncoder() {
+  return codecs.getStructEncoder([
+    ["slot", codecs.getU64Encoder()],
+    ["epochStartTimestamp", codecs.getI64Encoder()],
+    ["epoch", codecs.getU64Encoder()],
+    ["leaderScheduleEpoch", codecs.getU64Encoder()],
+    ["unixTimestamp", codecs.getI64Encoder()]
+  ]);
+}
+function getSysvarClockDecoder() {
+  return codecs.getStructDecoder([
+    ["slot", codecs.getU64Decoder()],
+    ["epochStartTimestamp", codecs.getI64Decoder()],
+    ["epoch", codecs.getU64Decoder()],
+    ["leaderScheduleEpoch", codecs.getU64Decoder()],
+    ["unixTimestamp", codecs.getI64Decoder()]
+  ]);
+}
+function getSysvarClockCodec() {
+  return codecs.combineCodec(getSysvarClockEncoder(), getSysvarClockDecoder());
+}
+async function fetchSysvarClock(rpc, config) {
+  const account = await fetchEncodedSysvarAccount(rpc, SYSVAR_CLOCK_ADDRESS, config);
+  accounts.assertAccountExists(account);
+  const decoded = accounts.decodeAccount(account, getSysvarClockDecoder());
+  return decoded.data;
+}
+function getSysvarEpochRewardsEncoder() {
+  return codecs.getStructEncoder([
+    ["distributionCompleteBlockHeight", codecs.getU64Encoder()],
+    ["distributedRewards", codecs.getU64Encoder()],
+    ["totalRewards", codecs.getU64Encoder()]
+  ]);
+}
+function getSysvarEpochRewardsDecoder() {
+  return codecs.getStructDecoder([
+    ["distributionCompleteBlockHeight", codecs.getU64Decoder()],
+    ["distributedRewards", codecs.getU64Decoder()],
+    ["totalRewards", codecs.getU64Decoder()]
+  ]);
+}
+function getSysvarEpochRewardsCodec() {
+  return codecs.combineCodec(getSysvarEpochRewardsEncoder(), getSysvarEpochRewardsDecoder());
+}
+async function fetchSysvarEpochRewards(rpc, config) {
+  const account = await fetchEncodedSysvarAccount(rpc, SYSVAR_EPOCH_REWARDS_ADDRESS, config);
+  accounts.assertAccountExists(account);
+  const decoded = accounts.decodeAccount(account, getSysvarEpochRewardsDecoder());
+  return decoded.data;
+}
+function getSysvarEpochScheduleEncoder() {
+  return codecs.getStructEncoder([
+    ["slotsPerEpoch", codecs.getU64Encoder()],
+    ["leaderScheduleSlotOffset", codecs.getU64Encoder()],
+    ["warmup", codecs.getBooleanEncoder()],
+    ["firstNormalEpoch", codecs.getU64Encoder()],
+    ["firstNormalSlot", codecs.getU64Encoder()]
+  ]);
+}
+function getSysvarEpochScheduleDecoder() {
+  return codecs.getStructDecoder([
+    ["slotsPerEpoch", codecs.getU64Decoder()],
+    ["leaderScheduleSlotOffset", codecs.getU64Decoder()],
+    ["warmup", codecs.getBooleanDecoder()],
+    ["firstNormalEpoch", codecs.getU64Decoder()],
+    ["firstNormalSlot", codecs.getU64Decoder()]
+  ]);
+}
+function getSysvarEpochScheduleCodec() {
+  return codecs.combineCodec(getSysvarEpochScheduleEncoder(), getSysvarEpochScheduleDecoder());
+}
+async function fetchSysvarEpochSchedule(rpc, config) {
+  const account = await fetchEncodedSysvarAccount(rpc, SYSVAR_EPOCH_SCHEDULE_ADDRESS, config);
+  accounts.assertAccountExists(account);
+  const decoded = accounts.decodeAccount(account, getSysvarEpochScheduleDecoder());
+  return decoded.data;
+}
+function assertByteArrayIsNotEmptyForCodec(codecDescription, bytes, offset = 0) {
+  if (bytes.length - offset <= 0) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS__CANNOT_DECODE_EMPTY_BYTE_ARRAY, {
+      codecDescription
+    });
+  }
+}
+function assertByteArrayHasEnoughBytesForCodec(codecDescription, expected, bytes, offset = 0) {
+  const bytesLength = bytes.length - offset;
+  if (bytesLength < expected) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH, {
+      bytesLength,
+      codecDescription,
+      expected
+    });
+  }
+}
+var padBytes = (bytes, length) => {
+  if (bytes.length >= length)
+    return bytes;
+  const paddedBytes = new Uint8Array(length).fill(0);
+  paddedBytes.set(bytes);
+  return paddedBytes;
+};
+var fixBytes = (bytes, length) => padBytes(bytes.length <= length ? bytes : bytes.slice(0, length), length);
+function getEncodedSize(value, encoder) {
+  return "fixedSize" in encoder ? encoder.fixedSize : encoder.getSizeFromValue(value);
+}
+function createEncoder(encoder) {
+  return Object.freeze({
+    ...encoder,
+    encode: (value) => {
+      const bytes = new Uint8Array(getEncodedSize(value, encoder));
+      encoder.write(value, bytes, 0);
+      return bytes;
+    }
+  });
+}
+function createDecoder(decoder) {
+  return Object.freeze({
+    ...decoder,
+    decode: (bytes, offset = 0) => decoder.read(bytes, offset)[0]
+  });
+}
+function isFixedSize(codec) {
+  return "fixedSize" in codec && typeof codec.fixedSize === "number";
+}
+function fixEncoder(encoder, fixedBytes) {
+  return createEncoder({
+    fixedSize: fixedBytes,
+    write: (value, bytes, offset) => {
+      const variableByteArray = encoder.encode(value);
+      const fixedByteArray = variableByteArray.length > fixedBytes ? variableByteArray.slice(0, fixedBytes) : variableByteArray;
+      bytes.set(fixedByteArray, offset);
+      return offset + fixedBytes;
+    }
+  });
+}
+function fixDecoder(decoder, fixedBytes) {
+  return createDecoder({
+    fixedSize: fixedBytes,
+    read: (bytes, offset) => {
+      assertByteArrayHasEnoughBytesForCodec("fixCodec", fixedBytes, bytes, offset);
+      if (offset > 0 || bytes.length > fixedBytes) {
+        bytes = bytes.slice(offset, offset + fixedBytes);
+      }
+      if (isFixedSize(decoder)) {
+        bytes = fixBytes(bytes, decoder.fixedSize);
+      }
+      const [value] = decoder.read(bytes, 0);
+      return [value, offset + fixedBytes];
+    }
+  });
+}
+function assertNumberIsBetweenForCodec(codecDescription, min, max, value) {
+  if (value < min || value > max) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE, {
+      codecDescription,
+      max,
+      min,
+      value
+    });
+  }
+}
+function isLittleEndian(config) {
+  return config?.endian === 1 ? false : true;
+}
+function numberEncoderFactory(input) {
+  return createEncoder({
+    fixedSize: input.size,
+    write(value, bytes, offset) {
+      if (input.range) {
+        assertNumberIsBetweenForCodec(input.name, input.range[0], input.range[1], value);
+      }
+      const arrayBuffer = new ArrayBuffer(input.size);
+      input.set(new DataView(arrayBuffer), value, isLittleEndian(input.config));
+      bytes.set(new Uint8Array(arrayBuffer), offset);
+      return offset + input.size;
+    }
+  });
+}
+function numberDecoderFactory(input) {
+  return createDecoder({
+    fixedSize: input.size,
+    read(bytes, offset = 0) {
+      assertByteArrayIsNotEmptyForCodec(input.name, bytes, offset);
+      assertByteArrayHasEnoughBytesForCodec(input.name, input.size, bytes, offset);
+      const view = new DataView(toArrayBuffer(bytes, offset, input.size));
+      return [input.get(view, isLittleEndian(input.config)), offset + input.size];
+    }
+  });
+}
+function toArrayBuffer(bytes, offset, length) {
+  const bytesOffset = bytes.byteOffset + (offset ?? 0);
+  const bytesLength = length ?? bytes.byteLength;
+  return bytes.buffer.slice(bytesOffset, bytesOffset + bytesLength);
+}
+var getU32Encoder = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u32",
+  range: [0, Number("0xffffffff")],
+  set: (view, value, le) => view.setUint32(0, value, le),
+  size: 4
+});
+var getU32Decoder = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getUint32(0, le),
+  name: "u32",
+  size: 4
+});
+var getU64Encoder4 = (config = {}) => numberEncoderFactory({
+  config,
+  name: "u64",
+  range: [0n, BigInt("0xffffffffffffffff")],
+  set: (view, value, le) => view.setBigUint64(0, BigInt(value), le),
+  size: 8
+});
+var getU64Decoder4 = (config = {}) => numberDecoderFactory({
+  config,
+  get: (view, le) => view.getBigUint64(0, le),
+  name: "u64",
+  size: 8
+});
+
+// ../codecs-strings/dist/index.node.js
+function assertValidBaseString(alphabet4, testValue, givenValue = testValue) {
+  if (!testValue.match(new RegExp(`^[${alphabet4}]*$`))) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE, {
+      alphabet: alphabet4,
+      base: alphabet4.length,
+      value: givenValue
+    });
+  }
+}
+var getBaseXEncoder = (alphabet4) => {
+  return createEncoder({
+    getSizeFromValue: (value) => {
+      const [leadingZeroes, tailChars] = partitionLeadingZeroes(value, alphabet4[0]);
+      if (!tailChars)
+        return value.length;
+      const base10Number = getBigIntFromBaseX(tailChars, alphabet4);
+      return leadingZeroes.length + Math.ceil(base10Number.toString(16).length / 2);
+    },
+    write(value, bytes, offset) {
+      assertValidBaseString(alphabet4, value);
+      if (value === "")
+        return offset;
+      const [leadingZeroes, tailChars] = partitionLeadingZeroes(value, alphabet4[0]);
+      if (!tailChars) {
+        bytes.set(new Uint8Array(leadingZeroes.length).fill(0), offset);
+        return offset + leadingZeroes.length;
+      }
+      let base10Number = getBigIntFromBaseX(tailChars, alphabet4);
+      const tailBytes = [];
+      while (base10Number > 0n) {
+        tailBytes.unshift(Number(base10Number % 256n));
+        base10Number /= 256n;
+      }
+      const bytesToAdd = [...Array(leadingZeroes.length).fill(0), ...tailBytes];
+      bytes.set(bytesToAdd, offset);
+      return offset + bytesToAdd.length;
+    }
+  });
+};
+var getBaseXDecoder = (alphabet4) => {
+  return createDecoder({
+    read(rawBytes, offset) {
+      const bytes = offset === 0 ? rawBytes : rawBytes.slice(offset);
+      if (bytes.length === 0)
+        return ["", 0];
+      let trailIndex = bytes.findIndex((n) => n !== 0);
+      trailIndex = trailIndex === -1 ? bytes.length : trailIndex;
+      const leadingZeroes = alphabet4[0].repeat(trailIndex);
+      if (trailIndex === bytes.length)
+        return [leadingZeroes, rawBytes.length];
+      const base10Number = bytes.slice(trailIndex).reduce((sum, byte) => sum * 256n + BigInt(byte), 0n);
+      const tailChars = getBaseXFromBigInt(base10Number, alphabet4);
+      return [leadingZeroes + tailChars, rawBytes.length];
+    }
+  });
+};
+function partitionLeadingZeroes(value, zeroCharacter) {
+  const [leadingZeros, tailChars] = value.split(new RegExp(`((?!${zeroCharacter}).*)`));
+  return [leadingZeros, tailChars];
+}
+function getBigIntFromBaseX(value, alphabet4) {
+  const base = BigInt(alphabet4.length);
+  let sum = 0n;
+  for (const char of value) {
+    sum *= base;
+    sum += BigInt(alphabet4.indexOf(char));
+  }
+  return sum;
+}
+function getBaseXFromBigInt(value, alphabet4) {
+  const base = BigInt(alphabet4.length);
+  const tailChars = [];
+  while (value > 0n) {
+    tailChars.unshift(alphabet4[Number(value % base)]);
+    value /= base;
+  }
+  return tailChars.join("");
+}
+var alphabet2 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var getBase58Encoder = () => getBaseXEncoder(alphabet2);
+var getBase58Decoder = () => getBaseXDecoder(alphabet2);
+var removeNullCharacters = (value) => (
+  // eslint-disable-next-line no-control-regex
+  value.replace(/\u0000/g, "")
+);
+var e = globalThis.TextDecoder;
+var o = globalThis.TextEncoder;
+var getUtf8Encoder = () => {
+  let textEncoder;
+  return createEncoder({
+    getSizeFromValue: (value) => (textEncoder ||= new o()).encode(value).length,
+    write: (value, bytes, offset) => {
+      const bytesToAdd = (textEncoder ||= new o()).encode(value);
+      bytes.set(bytesToAdd, offset);
+      return offset + bytesToAdd.length;
+    }
+  });
+};
+var getUtf8Decoder = () => {
+  let textDecoder;
+  return createDecoder({
+    read(bytes, offset) {
+      const value = (textDecoder ||= new e()).decode(bytes.slice(offset));
+      return [removeNullCharacters(value), bytes.length];
+    }
+  });
+};
+function getStringEncoder(config = {}) {
+  const size = config.size ?? getU32Encoder();
+  const encoding = config.encoding ?? getUtf8Encoder();
+  if (size === "variable") {
+    return encoding;
+  }
+  if (typeof size === "number") {
+    return fixEncoder(encoding, size);
+  }
+  return createEncoder({
+    getSizeFromValue: (value) => {
+      const contentSize = getEncodedSize(value, encoding);
+      return getEncodedSize(contentSize, size) + contentSize;
+    },
+    write: (value, bytes, offset) => {
+      const contentSize = getEncodedSize(value, encoding);
+      offset = size.write(contentSize, bytes, offset);
+      return encoding.write(value, bytes, offset);
+    }
+  });
+}
+function getStringDecoder(config = {}) {
+  const size = config.size ?? getU32Decoder();
+  const encoding = config.encoding ?? getUtf8Decoder();
+  if (size === "variable") {
+    return encoding;
+  }
+  if (typeof size === "number") {
+    return fixDecoder(encoding, size);
+  }
+  return createDecoder({
+    read: (bytes, offset = 0) => {
+      assertByteArrayIsNotEmptyForCodec("string", bytes, offset);
+      const [lengthBigInt, lengthOffset] = size.read(bytes, offset);
+      const length = Number(lengthBigInt);
+      offset = lengthOffset;
+      const contentBytes = bytes.slice(offset, offset + length);
+      assertByteArrayHasEnoughBytesForCodec("string", length, contentBytes);
+      const [value, contentOffset] = encoding.read(contentBytes, 0);
+      offset += contentOffset;
+      return [value, offset];
+    }
+  });
+}
+
+// ../rpc-types/dist/index.node.js
+function getEncodedSize2(value, encoder) {
+  return "fixedSize" in encoder ? encoder.fixedSize : encoder.getSizeFromValue(value);
+}
+function createEncoder2(encoder) {
+  return Object.freeze({
+    ...encoder,
+    encode: (value) => {
+      const bytes = new Uint8Array(getEncodedSize2(value, encoder));
+      encoder.write(value, bytes, 0);
+      return bytes;
+    }
+  });
+}
+function createDecoder2(decoder) {
+  return Object.freeze({
+    ...decoder,
+    decode: (bytes, offset = 0) => decoder.read(bytes, offset)[0]
+  });
+}
+function isFixedSize2(codec) {
+  return "fixedSize" in codec && typeof codec.fixedSize === "number";
+}
+function isVariableSize(codec) {
+  return !isFixedSize2(codec);
+}
+function mapEncoder(encoder, unmap) {
+  return createEncoder2({
+    ...isVariableSize(encoder) ? { ...encoder, getSizeFromValue: (value) => encoder.getSizeFromValue(unmap(value)) } : encoder,
+    write: (value, bytes, offset) => encoder.write(unmap(value), bytes, offset)
+  });
+}
+function mapDecoder(decoder, map) {
+  return createDecoder2({
+    ...decoder,
+    read: (bytes, offset) => {
+      const [value, newOffset] = decoder.read(bytes, offset);
+      return [map(value, bytes, offset), newOffset];
+    }
+  });
+}
+var memoizedBase58Encoder;
+var memoizedBase58Decoder;
+function getMemoizedBase58Encoder() {
+  if (!memoizedBase58Encoder)
+    memoizedBase58Encoder = getBase58Encoder();
+  return memoizedBase58Encoder;
+}
+function getMemoizedBase58Decoder() {
+  if (!memoizedBase58Decoder)
+    memoizedBase58Decoder = getBase58Decoder();
+  return memoizedBase58Decoder;
+}
+function assertIsBlockhash(putativeBlockhash) {
+  if (
+    // Lowest value (32 bytes of zeroes)
+    putativeBlockhash.length < 32 || // Highest value (32 bytes of 255)
+    putativeBlockhash.length > 44
+  ) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__BLOCKHASH_STRING_LENGTH_OUT_OF_RANGE, {
+      actualLength: putativeBlockhash.length
+    });
+  }
+  const base58Encoder = getMemoizedBase58Encoder();
+  const bytes = base58Encoder.encode(putativeBlockhash);
+  const numBytes = bytes.byteLength;
+  if (numBytes !== 32) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__INVALID_BLOCKHASH_BYTE_LENGTH, {
+      actualLength: numBytes
+    });
+  }
+}
+function blockhash(putativeBlockhash) {
+  assertIsBlockhash(putativeBlockhash);
+  return putativeBlockhash;
+}
+function getBlockhashEncoder() {
+  return mapEncoder(
+    getStringEncoder({ encoding: getMemoizedBase58Encoder(), size: 32 }),
+    (putativeBlockhash) => blockhash(putativeBlockhash)
+  );
+}
+function getBlockhashDecoder() {
+  return getStringDecoder({ encoding: getMemoizedBase58Decoder(), size: 32 });
+}
+var maxU64Value = 18446744073709551615n;
+var memoizedU64Encoder;
+var memoizedU64Decoder;
+function getMemoizedU64Encoder() {
+  if (!memoizedU64Encoder)
+    memoizedU64Encoder = getU64Encoder4();
+  return memoizedU64Encoder;
+}
+function getMemoizedU64Decoder() {
+  if (!memoizedU64Decoder)
+    memoizedU64Decoder = getU64Decoder4();
+  return memoizedU64Decoder;
+}
+function assertIsLamports(putativeLamports) {
+  if (putativeLamports < 0 || putativeLamports > maxU64Value) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__LAMPORTS_OUT_OF_RANGE);
+  }
+}
+function lamports(putativeLamports) {
+  assertIsLamports(putativeLamports);
+  return putativeLamports;
+}
+function getLamportsEncoder() {
+  return getMemoizedU64Encoder();
+}
+function getLamportsDecoder() {
+  return mapDecoder(getMemoizedU64Decoder(), lamports);
+}
+
+// src/fees.ts
+function getSysvarFeesEncoder() {
+  return codecs.getStructEncoder([
+    ["feeCalculator", codecs.getStructEncoder([["lamportsPerSignature", getLamportsEncoder()]])]
+  ]);
+}
+function getSysvarFeesDecoder() {
+  return codecs.getStructDecoder([
+    ["feeCalculator", codecs.getStructDecoder([["lamportsPerSignature", getLamportsDecoder()]])]
+  ]);
+}
+function getSysvarFeesCodec() {
+  return codecs.combineCodec(getSysvarFeesEncoder(), getSysvarFeesDecoder());
+}
+async function fetchSysvarFees(rpc, config) {
+  const account = await fetchEncodedSysvarAccount(rpc, SYSVAR_FEES_ADDRESS, config);
+  accounts.assertAccountExists(account);
+  const decoded = accounts.decodeAccount(account, getSysvarFeesDecoder());
+  return decoded.data;
+}
+function getSysvarLastRestartSlotEncoder() {
+  return codecs.getStructEncoder([["lastRestartSlot", codecs.getU64Encoder()]]);
+}
+function getSysvarLastRestartSlotDecoder() {
+  return codecs.getStructDecoder([["lastRestartSlot", codecs.getU64Decoder()]]);
+}
+function getSysvarLastRestartSlotCodec() {
+  return codecs.combineCodec(getSysvarLastRestartSlotEncoder(), getSysvarLastRestartSlotDecoder());
+}
+async function fetchSysvarLastRestartSlot(rpc, config) {
+  const account = await fetchEncodedSysvarAccount(rpc, SYSVAR_LAST_RESTART_SLOT_ADDRESS, config);
+  accounts.assertAccountExists(account);
+  const decoded = accounts.decodeAccount(account, getSysvarLastRestartSlotDecoder());
+  return decoded.data;
+}
+function getSysvarRecentBlockhashesEncoder() {
+  return codecs.getArrayEncoder(
+    codecs.getStructEncoder([
+      ["blockhash", getBlockhashEncoder()],
+      ["feeCalculator", codecs.getStructEncoder([["lamportsPerSignature", getLamportsEncoder()]])]
+    ])
+  );
+}
+function getSysvarRecentBlockhashesDecoder() {
+  return codecs.getArrayDecoder(
+    codecs.getStructDecoder([
+      ["blockhash", getBlockhashDecoder()],
+      ["feeCalculator", codecs.getStructDecoder([["lamportsPerSignature", getLamportsDecoder()]])]
+    ])
+  );
+}
+function getSysvarRecentBlockhashesCodec() {
+  return codecs.combineCodec(getSysvarRecentBlockhashesEncoder(), getSysvarRecentBlockhashesDecoder());
+}
+async function fetchSysvarRecentBlockhashes(rpc, config) {
+  const account = await fetchEncodedSysvarAccount(rpc, SYSVAR_RECENT_BLOCKHASHES_ADDRESS, config);
+  accounts.assertAccountExists(account);
+  const decoded = accounts.decodeAccount(account, getSysvarRecentBlockhashesDecoder());
+  return decoded.data;
+}
+function getSysvarRentEncoder() {
+  return codecs.getStructEncoder([
+    ["lamportsPerByteYear", getLamportsEncoder()],
+    ["exemptionThreshold", codecs.getF64Encoder()],
+    ["burnPercent", codecs.getU8Encoder()]
+  ]);
+}
+function getSysvarRentDecoder() {
+  return codecs.getStructDecoder([
+    ["lamportsPerByteYear", getLamportsDecoder()],
+    ["exemptionThreshold", codecs.getF64Decoder()],
+    ["burnPercent", codecs.getU8Decoder()]
+  ]);
+}
+function getSysvarRentCodec() {
+  return codecs.combineCodec(getSysvarRentEncoder(), getSysvarRentDecoder());
+}
+async function fetchSysvarRent(rpc, config) {
+  const account = await fetchEncodedSysvarAccount(rpc, SYSVAR_RENT_ADDRESS, config);
+  accounts.assertAccountExists(account);
+  const decoded = accounts.decodeAccount(account, getSysvarRentDecoder());
+  return decoded.data;
+}
+function getSysvarSlotHashesEncoder() {
+  return codecs.getArrayEncoder(
+    codecs.getStructEncoder([
+      ["slot", codecs.getU64Encoder()],
+      ["hash", getBlockhashEncoder()]
+    ])
+  );
+}
+function getSysvarSlotHashesDecoder() {
+  return codecs.getArrayDecoder(
+    codecs.getStructDecoder([
+      ["slot", codecs.getU64Decoder()],
+      ["hash", getBlockhashDecoder()]
+    ])
+  );
+}
+function getSysvarSlotHashesCodec() {
+  return codecs.combineCodec(getSysvarSlotHashesEncoder(), getSysvarSlotHashesDecoder());
+}
+async function fetchSysvarSlotHashes(rpc, config) {
+  const account = await fetchEncodedSysvarAccount(rpc, SYSVAR_SLOT_HASHES_ADDRESS, config);
+  accounts.assertAccountExists(account);
+  const decoded = accounts.decodeAccount(account, getSysvarSlotHashesDecoder());
+  return decoded.data;
+}
+var BITVEC_DISCRIMINATOR = 1;
+var BITVEC_NUM_BITS = 1024 * 1024;
+var BITVEC_LENGTH = BITVEC_NUM_BITS / 64;
+var SLOT_HISTORY_ACCOUNT_DATA_STATIC_SIZE = 1 + // Discriminator
+8 + // bitvector length (u64)
+BITVEC_LENGTH * 8 + 8 + // Number of bits (u64)
+8;
+var memoizedU64Encoder2;
+var memoizedU64Decoder2;
+var memoizedU64ArrayEncoder;
+var memoizedU64ArrayDecoder;
+function getMemoizedU64Encoder2() {
+  if (!memoizedU64Encoder2)
+    memoizedU64Encoder2 = codecs.getU64Encoder();
+  return memoizedU64Encoder2;
+}
+function getMemoizedU64Decoder2() {
+  if (!memoizedU64Decoder2)
+    memoizedU64Decoder2 = codecs.getU64Decoder();
+  return memoizedU64Decoder2;
+}
+function getMemoizedU64ArrayEncoder() {
+  if (!memoizedU64ArrayEncoder)
+    memoizedU64ArrayEncoder = codecs.getArrayCodec(codecs.getU64Codec(), { size: BITVEC_LENGTH });
+  return memoizedU64ArrayEncoder;
+}
+function getMemoizedU64ArrayDecoder() {
+  if (!memoizedU64ArrayDecoder)
+    memoizedU64ArrayDecoder = codecs.getArrayCodec(codecs.getU64Codec(), { size: BITVEC_LENGTH });
+  return memoizedU64ArrayDecoder;
+}
+function getSysvarSlotHistoryEncoder() {
+  return codecs.createEncoder({
+    fixedSize: SLOT_HISTORY_ACCOUNT_DATA_STATIC_SIZE,
+    write: (value, bytes, offset) => {
+      bytes.set([BITVEC_DISCRIMINATOR], offset);
+      offset += 1;
+      getMemoizedU64Encoder2().write(BigInt(BITVEC_LENGTH), bytes, offset);
+      offset += 8;
+      getMemoizedU64ArrayEncoder().write(value.bits, bytes, offset);
+      offset += BITVEC_LENGTH * 8;
+      getMemoizedU64Encoder2().write(BigInt(BITVEC_NUM_BITS), bytes, offset);
+      offset += 8;
+      getMemoizedU64Encoder2().write(value.nextSlot, bytes, offset);
+      offset += 8;
+      return offset;
+    }
+  });
+}
+function getSysvarSlotHistoryDecoder() {
+  return codecs.createDecoder({
+    fixedSize: SLOT_HISTORY_ACCOUNT_DATA_STATIC_SIZE,
+    read: (bytes, offset) => {
+      if (bytes.length != SLOT_HISTORY_ACCOUNT_DATA_STATIC_SIZE) {
+        throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH, {
+          actual: bytes.length,
+          expected: SLOT_HISTORY_ACCOUNT_DATA_STATIC_SIZE
+        });
+      }
+      const discriminator = bytes[offset];
+      offset += 1;
+      if (discriminator !== BITVEC_DISCRIMINATOR) {
+        throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS__ENUM_DISCRIMINATOR_OUT_OF_RANGE, {
+          actual: discriminator,
+          expected: BITVEC_DISCRIMINATOR
+        });
+      }
+      const bitVecLength = getMemoizedU64Decoder2().read(bytes, offset)[0];
+      offset += 8;
+      if (bitVecLength !== BigInt(BITVEC_LENGTH)) {
+        throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS__INVALID_NUMBER_OF_ITEMS, {
+          actual: bitVecLength,
+          codecDescription: "SysvarSlotHistoryCodec",
+          expected: BITVEC_LENGTH
+        });
+      }
+      const bits = getMemoizedU64ArrayDecoder().read(bytes, offset)[0];
+      offset += BITVEC_LENGTH * 8;
+      const numBits = getMemoizedU64Decoder2().read(bytes, offset)[0];
+      offset += 8;
+      if (numBits !== BigInt(BITVEC_NUM_BITS)) {
+        throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS__INVALID_NUMBER_OF_ITEMS, {
+          actual: numBits,
+          codecDescription: "SysvarSlotHistoryCodec",
+          expected: BITVEC_NUM_BITS
+        });
+      }
+      const nextSlot = getMemoizedU64Decoder2().read(bytes, offset)[0];
+      offset += 8;
+      return [
+        {
+          bits,
+          nextSlot
+        },
+        offset
+      ];
+    }
+  });
+}
+function getSysvarSlotHistoryCodec() {
+  return codecs.combineCodec(getSysvarSlotHistoryEncoder(), getSysvarSlotHistoryDecoder());
+}
+async function fetchSysvarSlotHistory(rpc, config) {
+  const account = await fetchEncodedSysvarAccount(rpc, SYSVAR_SLOT_HISTORY_ADDRESS, config);
+  accounts.assertAccountExists(account);
+  const decoded = accounts.decodeAccount(account, getSysvarSlotHistoryDecoder());
+  return decoded.data;
+}
+function getSysvarStakeHistoryEncoder() {
+  return codecs.getArrayEncoder(
+    codecs.getStructEncoder([
+      ["effective", getLamportsEncoder()],
+      ["activating", getLamportsEncoder()],
+      ["deactivating", getLamportsEncoder()]
+    ])
+  );
+}
+function getSysvarStakeHistoryDecoder() {
+  return codecs.getArrayDecoder(
+    codecs.getStructDecoder([
+      ["effective", getLamportsDecoder()],
+      ["activating", getLamportsDecoder()],
+      ["deactivating", getLamportsDecoder()]
+    ])
+  );
+}
+function getSysvarStakeHistoryCodec() {
+  return codecs.combineCodec(getSysvarStakeHistoryEncoder(), getSysvarStakeHistoryDecoder());
+}
+async function fetchSysvarStakeHistory(rpc, config) {
+  const account = await fetchEncodedSysvarAccount(rpc, SYSVAR_STAKE_HISTORY_ADDRESS, config);
+  accounts.assertAccountExists(account);
+  const decoded = accounts.decodeAccount(account, getSysvarStakeHistoryDecoder());
+  return decoded.data;
+}
+
+exports.SYSVAR_CLOCK_ADDRESS = SYSVAR_CLOCK_ADDRESS;
+exports.SYSVAR_EPOCH_REWARDS_ADDRESS = SYSVAR_EPOCH_REWARDS_ADDRESS;
+exports.SYSVAR_EPOCH_SCHEDULE_ADDRESS = SYSVAR_EPOCH_SCHEDULE_ADDRESS;
+exports.SYSVAR_FEES_ADDRESS = SYSVAR_FEES_ADDRESS;
+exports.SYSVAR_INSTRUCTIONS_ADDRESS = SYSVAR_INSTRUCTIONS_ADDRESS;
+exports.SYSVAR_LAST_RESTART_SLOT_ADDRESS = SYSVAR_LAST_RESTART_SLOT_ADDRESS;
+exports.SYSVAR_RECENT_BLOCKHASHES_ADDRESS = SYSVAR_RECENT_BLOCKHASHES_ADDRESS;
+exports.SYSVAR_RENT_ADDRESS = SYSVAR_RENT_ADDRESS;
+exports.SYSVAR_SLOT_HASHES_ADDRESS = SYSVAR_SLOT_HASHES_ADDRESS;
+exports.SYSVAR_SLOT_HISTORY_ADDRESS = SYSVAR_SLOT_HISTORY_ADDRESS;
+exports.SYSVAR_STAKE_HISTORY_ADDRESS = SYSVAR_STAKE_HISTORY_ADDRESS;
+exports.fetchEncodedSysvarAccount = fetchEncodedSysvarAccount;
+exports.fetchJsonParsedSysvarAccount = fetchJsonParsedSysvarAccount;
+exports.fetchSysvarClock = fetchSysvarClock;
+exports.fetchSysvarEpochRewards = fetchSysvarEpochRewards;
+exports.fetchSysvarEpochSchedule = fetchSysvarEpochSchedule;
+exports.fetchSysvarFees = fetchSysvarFees;
+exports.fetchSysvarLastRestartSlot = fetchSysvarLastRestartSlot;
+exports.fetchSysvarRecentBlockhashes = fetchSysvarRecentBlockhashes;
+exports.fetchSysvarRent = fetchSysvarRent;
+exports.fetchSysvarSlotHashes = fetchSysvarSlotHashes;
+exports.fetchSysvarSlotHistory = fetchSysvarSlotHistory;
+exports.fetchSysvarStakeHistory = fetchSysvarStakeHistory;
+exports.getSysvarClockCodec = getSysvarClockCodec;
+exports.getSysvarClockDecoder = getSysvarClockDecoder;
+exports.getSysvarClockEncoder = getSysvarClockEncoder;
+exports.getSysvarEpochRewardsCodec = getSysvarEpochRewardsCodec;
+exports.getSysvarEpochRewardsDecoder = getSysvarEpochRewardsDecoder;
+exports.getSysvarEpochRewardsEncoder = getSysvarEpochRewardsEncoder;
+exports.getSysvarEpochScheduleCodec = getSysvarEpochScheduleCodec;
+exports.getSysvarEpochScheduleDecoder = getSysvarEpochScheduleDecoder;
+exports.getSysvarEpochScheduleEncoder = getSysvarEpochScheduleEncoder;
+exports.getSysvarFeesCodec = getSysvarFeesCodec;
+exports.getSysvarFeesDecoder = getSysvarFeesDecoder;
+exports.getSysvarFeesEncoder = getSysvarFeesEncoder;
+exports.getSysvarLastRestartSlotCodec = getSysvarLastRestartSlotCodec;
+exports.getSysvarLastRestartSlotDecoder = getSysvarLastRestartSlotDecoder;
+exports.getSysvarLastRestartSlotEncoder = getSysvarLastRestartSlotEncoder;
+exports.getSysvarRecentBlockhashesCodec = getSysvarRecentBlockhashesCodec;
+exports.getSysvarRecentBlockhashesDecoder = getSysvarRecentBlockhashesDecoder;
+exports.getSysvarRecentBlockhashesEncoder = getSysvarRecentBlockhashesEncoder;
+exports.getSysvarRentCodec = getSysvarRentCodec;
+exports.getSysvarRentDecoder = getSysvarRentDecoder;
+exports.getSysvarRentEncoder = getSysvarRentEncoder;
+exports.getSysvarSlotHashesCodec = getSysvarSlotHashesCodec;
+exports.getSysvarSlotHashesDecoder = getSysvarSlotHashesDecoder;
+exports.getSysvarSlotHashesEncoder = getSysvarSlotHashesEncoder;
+exports.getSysvarSlotHistoryCodec = getSysvarSlotHistoryCodec;
+exports.getSysvarSlotHistoryDecoder = getSysvarSlotHistoryDecoder;
+exports.getSysvarSlotHistoryEncoder = getSysvarSlotHistoryEncoder;
+exports.getSysvarStakeHistoryCodec = getSysvarStakeHistoryCodec;
+exports.getSysvarStakeHistoryDecoder = getSysvarStakeHistoryDecoder;
+exports.getSysvarStakeHistoryEncoder = getSysvarStakeHistoryEncoder;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.node.cjs.map