@solana/sysvars 6.3.1 → 6.3.2-canary-20260313112147

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solana/sysvars",
-  "version": "6.3.1",
+  "version": "6.3.2-canary-20260313112147",
   "description": "An abstraction layer over signing messages and transactions in Solana",
   "homepage": "https://www.solanakit.com/api#solanasysvars",
   "exports": {
@@ -33,7 +33,8 @@
   "types": "./dist/types/index.d.ts",
   "type": "commonjs",
   "files": [
-    "./dist/"
+    "./dist/",
+    "./src/"
   ],
   "sideEffects": false,
   "keywords": [
@@ -55,12 +56,12 @@
     "maintained node versions"
   ],
   "dependencies": {
-    "@solana/accounts": "6.3.1",
-    "@solana/codecs-data-structures": "6.3.1",
-    "@solana/codecs-core": "6.3.1",
-    "@solana/codecs-numbers": "6.3.1",
-    "@solana/errors": "6.3.1",
-    "@solana/rpc-types": "6.3.1"
+    "@solana/accounts": "6.3.2-canary-20260313112147",
+    "@solana/codecs-core": "6.3.2-canary-20260313112147",
+    "@solana/codecs-data-structures": "6.3.2-canary-20260313112147",
+    "@solana/codecs-numbers": "6.3.2-canary-20260313112147",
+    "@solana/errors": "6.3.2-canary-20260313112147",
+    "@solana/rpc-types": "6.3.2-canary-20260313112147"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"

package/src/clock.ts

@@ -0,0 +1,80 @@
+import { assertAccountExists, decodeAccount, type FetchAccountConfig } from '@solana/accounts';
+import { combineCodec, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder } from '@solana/codecs-core';
+import { getStructDecoder, getStructEncoder } from '@solana/codecs-data-structures';
+import { getI64Decoder, getI64Encoder, getU64Decoder, getU64Encoder } from '@solana/codecs-numbers';
+import type { GetAccountInfoApi } from '@solana/rpc-api';
+import type { Rpc } from '@solana/rpc-spec';
+import type { Epoch, Slot, UnixTimestamp } from '@solana/rpc-types';
+
+import { fetchEncodedSysvarAccount, SYSVAR_CLOCK_ADDRESS } from './sysvar';
+
+type SysvarClockSize = 40;
+
+/**
+ * Contains data on cluster time, including the current slot, epoch, and estimated wall-clock Unix
+ * timestamp. It is updated every slot.
+ */
+export type SysvarClock = Readonly<{
+    /** The current epoch */
+    epoch: Epoch;
+    /**
+     * The Unix timestamp of the first slot in this epoch.
+     *
+     * In the first slot of an epoch, this timestamp is identical to the `unixTimestamp`.
+     */
+    epochStartTimestamp: UnixTimestamp;
+    /** The most recent epoch for which the leader schedule has already been generated */
+    leaderScheduleEpoch: Epoch;
+    /** The current slot */
+    slot: Slot;
+    /** The Unix timestamp of this slot */
+    unixTimestamp: UnixTimestamp;
+}>;
+
+/**
+ * Returns an encoder that you can use to encode a {@link SysvarClock} to a byte array representing
+ * the `Clock` sysvar's account data.
+ */
+export function getSysvarClockEncoder(): FixedSizeEncoder<SysvarClock, SysvarClockSize> {
+    return getStructEncoder([
+        ['slot', getU64Encoder()],
+        ['epochStartTimestamp', getI64Encoder()],
+        ['epoch', getU64Encoder()],
+        ['leaderScheduleEpoch', getU64Encoder()],
+        ['unixTimestamp', getI64Encoder()],
+    ]) as FixedSizeEncoder<SysvarClock, SysvarClockSize>;
+}
+
+/**
+ * Returns a decoder that you can use to decode a byte array representing the `Clock` sysvar's
+ * account data to a {@link SysvarClock}.
+ */
+export function getSysvarClockDecoder(): FixedSizeDecoder<SysvarClock, SysvarClockSize> {
+    return getStructDecoder([
+        ['slot', getU64Decoder()],
+        ['epochStartTimestamp', getI64Decoder()],
+        ['epoch', getU64Decoder()],
+        ['leaderScheduleEpoch', getU64Decoder()],
+        ['unixTimestamp', getI64Decoder()],
+    ]) as FixedSizeDecoder<SysvarClock, SysvarClockSize>;
+}
+
+/**
+ * Returns a codec that you can use to encode from or decode to {@link SysvarClock}
+ *
+ * @see {@link getSysvarClockDecoder}
+ * @see {@link getSysvarClockEncoder}
+ */
+export function getSysvarClockCodec(): FixedSizeCodec<SysvarClock, SysvarClock, SysvarClockSize> {
+    return combineCodec(getSysvarClockEncoder(), getSysvarClockDecoder());
+}
+
+/**
+ * Fetches the `Clock` sysvar account using any RPC that supports the {@link GetAccountInfoApi}.
+ */
+export async function fetchSysvarClock(rpc: Rpc<GetAccountInfoApi>, config?: FetchAccountConfig): Promise<SysvarClock> {
+    const account = await fetchEncodedSysvarAccount(rpc, SYSVAR_CLOCK_ADDRESS, config);
+    assertAccountExists(account);
+    const decoded = decodeAccount(account, getSysvarClockDecoder());
+    return decoded.data;
+}

package/src/epoch-rewards.ts

@@ -0,0 +1,117 @@
+import { assertAccountExists, decodeAccount, type FetchAccountConfig } from '@solana/accounts';
+import { combineCodec, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder } from '@solana/codecs-core';
+import {
+    getBooleanDecoder,
+    getBooleanEncoder,
+    getStructDecoder,
+    getStructEncoder,
+} from '@solana/codecs-data-structures';
+import { getU64Decoder, getU64Encoder, getU128Decoder, getU128Encoder } from '@solana/codecs-numbers';
+import type { GetAccountInfoApi } from '@solana/rpc-api';
+import type { Rpc } from '@solana/rpc-spec';
+import {
+    Blockhash,
+    getBlockhashDecoder,
+    getBlockhashEncoder,
+    getDefaultLamportsDecoder,
+    getDefaultLamportsEncoder,
+    Lamports,
+} from '@solana/rpc-types';
+
+import { fetchEncodedSysvarAccount, SYSVAR_EPOCH_REWARDS_ADDRESS } from './sysvar';
+
+type SysvarEpochRewardsSize = 81;
+
+/**
+ * Tracks whether the rewards period (including calculation and distribution) is in progress, as
+ * well as the details needed to resume distribution when starting from a snapshot during the
+ * rewards period.
+ *
+ * The sysvar is repopulated at the start of the first block of each epoch. Therefore, the sysvar
+ * contains data about the current epoch until a new epoch begins.
+ */
+export type SysvarEpochRewards = Readonly<{
+    /** Whether the rewards period (including calculation and distribution) is active */
+    active: boolean;
+    /** The rewards currently distributed for the current epoch, in {@link Lamports} */
+    distributedRewards: Lamports;
+    /** The starting block height of the rewards distribution in the current epoch */
+    distributionStartingBlockHeight: bigint;
+    /**
+     * Number of partitions in the rewards distribution in the current epoch, used to generate an
+     * `EpochRewardsHasher`
+     */
+    numPartitions: bigint;
+    /**
+     * The {@link Blockhash} of the parent block of the first block in the epoch, used to seed an
+     * `EpochRewardsHasher`
+     */
+    parentBlockhash: Blockhash;
+    /**
+     * The total rewards points calculated for the current epoch, where points equals the sum of
+     * (delegated stake * credits observed) for all  delegations
+     */
+    totalPoints: bigint;
+    /** The total rewards for the current epoch, in {@link Lamports} */
+    totalRewards: Lamports;
+}>;
+
+/**
+ * Returns an encoder that you can use to encode a {@link SysvarEpochRewards} to a byte array
+ * representing the `EpochRewards` sysvar's account data.
+ */
+export function getSysvarEpochRewardsEncoder(): FixedSizeEncoder<SysvarEpochRewards, SysvarEpochRewardsSize> {
+    return getStructEncoder([
+        ['distributionStartingBlockHeight', getU64Encoder()],
+        ['numPartitions', getU64Encoder()],
+        ['parentBlockhash', getBlockhashEncoder()],
+        ['totalPoints', getU128Encoder()],
+        ['totalRewards', getDefaultLamportsEncoder()],
+        ['distributedRewards', getDefaultLamportsEncoder()],
+        ['active', getBooleanEncoder()],
+    ]) as FixedSizeEncoder<SysvarEpochRewards, SysvarEpochRewardsSize>;
+}
+
+/**
+ * Returns a decoder that you can use to decode a byte array representing the `EpochRewards`
+ * sysvar's account data to a {@link SysvarEpochRewards}.
+ */
+export function getSysvarEpochRewardsDecoder(): FixedSizeDecoder<SysvarEpochRewards, SysvarEpochRewardsSize> {
+    return getStructDecoder([
+        ['distributionStartingBlockHeight', getU64Decoder()],
+        ['numPartitions', getU64Decoder()],
+        ['parentBlockhash', getBlockhashDecoder()],
+        ['totalPoints', getU128Decoder()],
+        ['totalRewards', getDefaultLamportsDecoder()],
+        ['distributedRewards', getDefaultLamportsDecoder()],
+        ['active', getBooleanDecoder()],
+    ]) as FixedSizeDecoder<SysvarEpochRewards, SysvarEpochRewardsSize>;
+}
+
+/**
+ * Returns a codec that you can use to encode from or decode to {@link SysvarEpochRewards}
+ *
+ * @see {@link getSysvarEpochRewardsDecoder}
+ * @see {@link getSysvarEpochRewardsEncoder}
+ */
+export function getSysvarEpochRewardsCodec(): FixedSizeCodec<
+    SysvarEpochRewards,
+    SysvarEpochRewards,
+    SysvarEpochRewardsSize
+> {
+    return combineCodec(getSysvarEpochRewardsEncoder(), getSysvarEpochRewardsDecoder());
+}
+
+/**
+ * Fetch the `EpochRewards` sysvar account using any RPC that supports the
+ * {@link GetAccountInfoApi}.
+ */
+export async function fetchSysvarEpochRewards(
+    rpc: Rpc<GetAccountInfoApi>,
+    config?: FetchAccountConfig,
+): Promise<SysvarEpochRewards> {
+    const account = await fetchEncodedSysvarAccount(rpc, SYSVAR_EPOCH_REWARDS_ADDRESS, config);
+    assertAccountExists(account);
+    const decoded = decodeAccount(account, getSysvarEpochRewardsDecoder());
+    return decoded.data;
+}

package/src/epoch-schedule.ts

@@ -0,0 +1,97 @@
+import { assertAccountExists, decodeAccount, type FetchAccountConfig } from '@solana/accounts';
+import { combineCodec, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder } from '@solana/codecs-core';
+import {
+    getBooleanDecoder,
+    getBooleanEncoder,
+    getStructDecoder,
+    getStructEncoder,
+} from '@solana/codecs-data-structures';
+import { getU64Decoder, getU64Encoder } from '@solana/codecs-numbers';
+import type { GetAccountInfoApi } from '@solana/rpc-api';
+import type { Rpc } from '@solana/rpc-spec';
+import type { Epoch, Slot } from '@solana/rpc-types';
+
+import { fetchEncodedSysvarAccount, SYSVAR_EPOCH_SCHEDULE_ADDRESS } from './sysvar';
+
+type SysvarEpochScheduleSize = 33;
+
+/**
+ * Includes the number of slots per epoch, timing of leader schedule selection, and information
+ * about epoch warm-up time.
+ */
+export type SysvarEpochSchedule = Readonly<{
+    /**
+     * First normal-length epoch after the warmup period,
+     * log2(slotsPerEpoch) - log2(MINIMUM_SLOTS_PER_EPOCH)
+     */
+    firstNormalEpoch: Epoch;
+    /**
+     * The first slot after the warmup period, MINIMUM_SLOTS_PER_EPOCH * (2^(firstNormalEpoch) - 1)
+     */
+    firstNormalSlot: Slot;
+    /**
+     * A number of slots before beginning of an epoch to calculate a leader schedule for that
+     * epoch.
+     */
+    leaderScheduleSlotOffset: bigint;
+    /** The maximum number of slots in each epoch */
+    slotsPerEpoch: bigint;
+    /** Whether epochs start short and grow */
+    warmup: boolean;
+}>;
+
+/**
+ * Returns an encoder that you can use to encode a {@link SysvarEpochSchedule} to a byte array
+ * representing the `EpochSchedule` sysvar's account data.
+ */
+export function getSysvarEpochScheduleEncoder(): FixedSizeEncoder<SysvarEpochSchedule, SysvarEpochScheduleSize> {
+    return getStructEncoder([
+        ['slotsPerEpoch', getU64Encoder()],
+        ['leaderScheduleSlotOffset', getU64Encoder()],
+        ['warmup', getBooleanEncoder()],
+        ['firstNormalEpoch', getU64Encoder()],
+        ['firstNormalSlot', getU64Encoder()],
+    ]) as FixedSizeEncoder<SysvarEpochSchedule, SysvarEpochScheduleSize>;
+}
+
+/**
+ * Returns a decoder that you can use to decode a byte array representing the `EpochSchedule`
+ * sysvar's account data to a {@link SysvarEpochSchedule}.
+ */
+export function getSysvarEpochScheduleDecoder(): FixedSizeDecoder<SysvarEpochSchedule, SysvarEpochScheduleSize> {
+    return getStructDecoder([
+        ['slotsPerEpoch', getU64Decoder()],
+        ['leaderScheduleSlotOffset', getU64Decoder()],
+        ['warmup', getBooleanDecoder()],
+        ['firstNormalEpoch', getU64Decoder()],
+        ['firstNormalSlot', getU64Decoder()],
+    ]) as FixedSizeDecoder<SysvarEpochSchedule, SysvarEpochScheduleSize>;
+}
+
+/**
+ * Returns a codec that you can use to encode from or decode to {@link SysvarEpochSchedule}
+ *
+ * @see {@link getSysvarEpochScheduleDecoder}
+ * @see {@link getSysvarEpochScheduleEncoder}
+ */
+export function getSysvarEpochScheduleCodec(): FixedSizeCodec<
+    SysvarEpochSchedule,
+    SysvarEpochSchedule,
+    SysvarEpochScheduleSize
+> {
+    return combineCodec(getSysvarEpochScheduleEncoder(), getSysvarEpochScheduleDecoder());
+}
+
+/**
+ * Fetches the `EpochSchedule` sysvar account using any RPC that supports the
+ * {@link GetAccountInfoApi}.
+ */
+export async function fetchSysvarEpochSchedule(
+    rpc: Rpc<GetAccountInfoApi>,
+    config?: FetchAccountConfig,
+): Promise<SysvarEpochSchedule> {
+    const account = await fetchEncodedSysvarAccount(rpc, SYSVAR_EPOCH_SCHEDULE_ADDRESS, config);
+    assertAccountExists(account);
+    const decoded = decodeAccount(account, getSysvarEpochScheduleDecoder());
+    return decoded.data;
+}

package/src/index.ts

@@ -0,0 +1,64 @@
+/**
+ * This package contains types and helpers for fetching and decoding Solana sysvars.
+ * It can be used standalone, but it is also exported as part of Kit
+ * [`@solana/kit`](https://github.com/anza-xyz/kit/tree/main/packages/kit).
+ *
+ * More information about the available sysvars on Solana can be found in the docs at
+ * https://docs.solanalabs.com/runtime/sysvars.
+ *
+ * All currently available sysvars can be retrieved and/or decoded using this library.
+ *
+ * - `Clock`
+ * - `EpochRewards`
+ * - `EpochSchedule`
+ * - `Fees`
+ * - `LastRestartSlot`
+ * - `RecentBlockhashes`
+ * - `Rent`
+ * - `SlotHashes`
+ * - `SlotHistory`
+ * - `StakeHistory`
+ *
+ * The `Instructions` sysvar is also supported but does not exist on-chain, therefore has no
+ * corresponding module or codec.
+ *
+ * @example Fetch and decode a sysvar account.
+ * ```ts
+ * const clock: SysvarClock = await fetchSysvarClock(rpc);
+ * ```
+ *
+ * @example Fetch and decode a sysvar account manually.
+ * ```ts
+ * // Fetch.
+ * const clock = await fetchEncodedSysvarAccount(rpc, SYSVAR_CLOCK_ADDRESS);
+ * clock satisfies MaybeEncodedAccount<'SysvarC1ock11111111111111111111111111111111'>;
+ *
+ * // Assert.
+ * assertAccountExists(clock);
+ * clock satisfies EncodedAccount<'SysvarC1ock11111111111111111111111111111111'>;
+ *
+ * // Decode.
+ * const decodedClock = decodeAccount(clock, getSysvarClockDecoder());
+ * decodedClock satisfies Account<SysvarClock, 'SysvarC1ock11111111111111111111111111111111'>;
+ * ```
+ *
+ * @example Fetch a JSON-parsed sysvar account.
+ * ```ts
+ * const maybeJsonParsedClock = await fetchJsonParsedSysvarAccount(rpc, SYSVAR_CLOCK_ADDRESS);
+ * maybeJsonParsedClock satisfies
+ *     | MaybeAccount<JsonParsedSysvarAccount, 'SysvarC1ock11111111111111111111111111111111'>
+ *     | MaybeEncodedAccount<'SysvarC1ock11111111111111111111111111111111'>;
+ * ```
+ *
+ * @packageDocumentation
+ */
+export * from './clock';
+export * from './epoch-rewards';
+export * from './epoch-schedule';
+export * from './last-restart-slot';
+export * from './recent-blockhashes';
+export * from './rent';
+export * from './slot-hashes';
+export * from './slot-history';
+export * from './stake-history';
+export * from './sysvar';

package/src/last-restart-slot.ts

@@ -0,0 +1,73 @@
+import { assertAccountExists, decodeAccount, type FetchAccountConfig } from '@solana/accounts';
+import { combineCodec, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder } from '@solana/codecs-core';
+import { getStructDecoder, getStructEncoder } from '@solana/codecs-data-structures';
+import { getU64Decoder, getU64Encoder } from '@solana/codecs-numbers';
+import type { GetAccountInfoApi } from '@solana/rpc-api';
+import type { Rpc } from '@solana/rpc-spec';
+import type { Slot } from '@solana/rpc-types';
+
+import { fetchEncodedSysvarAccount, SYSVAR_LAST_RESTART_SLOT_ADDRESS } from './sysvar';
+
+type SysvarLastRestartSlotSize = 8;
+
+/**
+ * Information about the last restart slot (hard fork).
+ *
+ * The `LastRestartSlot` sysvar provides access to the last restart slot kept in the bank fork for
+ * the slot on the fork that executes the current transaction. In case there was no fork it returns
+ * `0`.
+ */
+export type SysvarLastRestartSlot = Readonly<{
+    /** The last restart {@link Slot} */
+    lastRestartSlot: Slot;
+}>;
+
+/**
+ * Returns an encoder that you can use to encode a {@link SysvarLastRestartSlot} to a byte array
+ * representing the `LastRestartSlot` sysvar's account data.
+ */
+export function getSysvarLastRestartSlotEncoder(): FixedSizeEncoder<SysvarLastRestartSlot, SysvarLastRestartSlotSize> {
+    return getStructEncoder([['lastRestartSlot', getU64Encoder()]]) as FixedSizeEncoder<
+        SysvarLastRestartSlot,
+        SysvarLastRestartSlotSize
+    >;
+}
+
+/**
+ * Returns a decoder that you can use to decode a byte array representing the `LastRestartSlot`
+ * sysvar's account data to a {@link SysvarLastRestartSlot}.
+ */
+export function getSysvarLastRestartSlotDecoder(): FixedSizeDecoder<SysvarLastRestartSlot, SysvarLastRestartSlotSize> {
+    return getStructDecoder([['lastRestartSlot', getU64Decoder()]]) as FixedSizeDecoder<
+        SysvarLastRestartSlot,
+        SysvarLastRestartSlotSize
+    >;
+}
+
+/**
+ * Returns a codec that you can use to encode from or decode to {@link SysvarLastRestartSlot}
+ *
+ * @see {@link getSysvarLastRestartSlotDecoder}
+ * @see {@link getSysvarLastRestartSlotEncoder}
+ */
+export function getSysvarLastRestartSlotCodec(): FixedSizeCodec<
+    SysvarLastRestartSlot,
+    SysvarLastRestartSlot,
+    SysvarLastRestartSlotSize
+> {
+    return combineCodec(getSysvarLastRestartSlotEncoder(), getSysvarLastRestartSlotDecoder());
+}
+
+/**
+ * Fetches the `LastRestartSlot` sysvar account using any RPC that supports the
+ * {@link GetAccountInfoApi}.
+ */
+export async function fetchSysvarLastRestartSlot(
+    rpc: Rpc<GetAccountInfoApi>,
+    config?: FetchAccountConfig,
+): Promise<SysvarLastRestartSlot> {
+    const account = await fetchEncodedSysvarAccount(rpc, SYSVAR_LAST_RESTART_SLOT_ADDRESS, config);
+    assertAccountExists(account);
+    const decoded = decodeAccount(account, getSysvarLastRestartSlotDecoder());
+    return decoded.data;
+}

package/src/recent-blockhashes.ts

@@ -0,0 +1,108 @@
+import { assertAccountExists, decodeAccount, type FetchAccountConfig } from '@solana/accounts';
+import {
+    combineCodec,
+    type VariableSizeCodec,
+    type VariableSizeDecoder,
+    type VariableSizeEncoder,
+} from '@solana/codecs-core';
+import { getArrayDecoder, getArrayEncoder, getStructDecoder, getStructEncoder } from '@solana/codecs-data-structures';
+import type { GetAccountInfoApi } from '@solana/rpc-api';
+import type { Rpc } from '@solana/rpc-spec';
+import {
+    type Blockhash,
+    getBlockhashDecoder,
+    getBlockhashEncoder,
+    getDefaultLamportsDecoder,
+    getDefaultLamportsEncoder,
+    type Lamports,
+} from '@solana/rpc-types';
+
+import { fetchEncodedSysvarAccount, SYSVAR_RECENT_BLOCKHASHES_ADDRESS } from './sysvar';
+
+type FeeCalculator = Readonly<{
+    /**
+     * The current cost of a signature.
+     *
+     * This amount may increase/decrease over time based on cluster processing load
+     */
+    lamportsPerSignature: Lamports;
+}>;
+type Entry = Readonly<{
+    blockhash: Blockhash;
+    feeCalculator: FeeCalculator;
+}>;
+
+/**
+ * Information about recent blocks and their fee calculators.
+ *
+ * @deprecated Transaction fees should be determined with the
+ * {@link GetFeeForMessageApi.getFeeForMessage} RPC method. For additional context see the
+ * [Comprehensive Compute Fees proposal](https://docs.anza.xyz/proposals/comprehensive-compute-fees/).
+ */
+export type SysvarRecentBlockhashes = Entry[];
+
+/**
+ * Returns an encoder that you can use to encode a {@link SysvarRecentBlockhashes} to a byte array
+ * representing the `RecentBlockhashes` sysvar's account data.
+ *
+ * @deprecated Transaction fees should be determined with the
+ * {@link GetFeeForMessageApi.getFeeForMessage} RPC method. For additional context see the
+ * [Comprehensive Compute Fees proposal](https://docs.anza.xyz/proposals/comprehensive-compute-fees/).
+ */
+export function getSysvarRecentBlockhashesEncoder(): VariableSizeEncoder<SysvarRecentBlockhashes> {
+    return getArrayEncoder(
+        getStructEncoder([
+            ['blockhash', getBlockhashEncoder()],
+            ['feeCalculator', getStructEncoder([['lamportsPerSignature', getDefaultLamportsEncoder()]])],
+        ]),
+    );
+}
+
+/**
+ * Returns a decoder that you can use to decode a byte array representing the `RecentBlockhashes`
+ * sysvar's account data to a {@link SysvarRecentBlockhashes}.
+ *
+ * @deprecated Transaction fees should be determined with the
+ * {@link GetFeeForMessageApi.getFeeForMessage} RPC method. For additional context see the
+ * [Comprehensive Compute Fees proposal](https://docs.anza.xyz/proposals/comprehensive-compute-fees/).
+ */
+export function getSysvarRecentBlockhashesDecoder(): VariableSizeDecoder<SysvarRecentBlockhashes> {
+    return getArrayDecoder(
+        getStructDecoder([
+            ['blockhash', getBlockhashDecoder()],
+            ['feeCalculator', getStructDecoder([['lamportsPerSignature', getDefaultLamportsDecoder()]])],
+        ]),
+    );
+}
+
+/**
+ * Returns a codec that you can use to encode from or decode to {@link SysvarRecentBlockhashes}
+ *
+ * @deprecated Transaction fees should be determined with the
+ * {@link GetFeeForMessageApi.getFeeForMessage} RPC method. For additional context see the
+ * [Comprehensive Compute Fees proposal](https://docs.anza.xyz/proposals/comprehensive-compute-fees/).
+ *
+ * @see {@link getSysvarRecentBlockhashesDecoder}
+ * @see {@link getSysvarRecentBlockhashesEncoder}
+ */
+export function getSysvarRecentBlockhashesCodec(): VariableSizeCodec<SysvarRecentBlockhashes> {
+    return combineCodec(getSysvarRecentBlockhashesEncoder(), getSysvarRecentBlockhashesDecoder());
+}
+
+/**
+ * Fetches the `RecentBlockhashes` sysvar account using any RPC that supports the
+ * {@link GetAccountInfoApi}.
+ *
+ * @deprecated Transaction fees should be determined with the
+ * {@link GetFeeForMessageApi.getFeeForMessage} RPC method. For additional context see the
+ * [Comprehensive Compute Fees proposal](https://docs.anza.xyz/proposals/comprehensive-compute-fees/).
+ */
+export async function fetchSysvarRecentBlockhashes(
+    rpc: Rpc<GetAccountInfoApi>,
+    config?: FetchAccountConfig,
+): Promise<SysvarRecentBlockhashes> {
+    const account = await fetchEncodedSysvarAccount(rpc, SYSVAR_RECENT_BLOCKHASHES_ADDRESS, config);
+    assertAccountExists(account);
+    const decoded = decodeAccount(account, getSysvarRecentBlockhashesDecoder());
+    return decoded.data;
+}

package/src/rent.ts

@@ -0,0 +1,77 @@
+import { assertAccountExists, decodeAccount, type FetchAccountConfig } from '@solana/accounts';
+import { combineCodec, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder } from '@solana/codecs-core';
+import { getStructDecoder, getStructEncoder } from '@solana/codecs-data-structures';
+import { getF64Decoder, getF64Encoder, getU8Decoder, getU8Encoder } from '@solana/codecs-numbers';
+import type { GetAccountInfoApi } from '@solana/rpc-api';
+import type { Rpc } from '@solana/rpc-spec';
+import {
+    F64UnsafeSeeDocumentation,
+    getDefaultLamportsDecoder,
+    getDefaultLamportsEncoder,
+    type Lamports,
+} from '@solana/rpc-types';
+
+import { fetchEncodedSysvarAccount, SYSVAR_RENT_ADDRESS } from './sysvar';
+
+type SysvarRentSize = 17;
+
+/**
+ * Configuration for network rent.
+ */
+export type SysvarRent = Readonly<{
+    /**
+     * The percentage of collected rent that is burned.
+     *
+     * Valid values are in the range [0, 100]. The remaining percentage is distributed to
+     * validators.
+     */
+    burnPercent: number;
+    /** Amount of time (in years) a balance must include rent for the account to be rent exempt */
+    exemptionThreshold: F64UnsafeSeeDocumentation;
+    /** Rental rate in {@link Lamports}/byte-year. */
+    lamportsPerByteYear: Lamports;
+}>;
+
+/**
+ * Returns an encoder that you can use to encode a {@link SysvarRent} to a byte array representing
+ * the `Rent` sysvar's account data.
+ */
+export function getSysvarRentEncoder(): FixedSizeEncoder<SysvarRent, SysvarRentSize> {
+    return getStructEncoder([
+        ['lamportsPerByteYear', getDefaultLamportsEncoder()],
+        ['exemptionThreshold', getF64Encoder()],
+        ['burnPercent', getU8Encoder()],
+    ]) as FixedSizeEncoder<SysvarRent, SysvarRentSize>;
+}
+
+/**
+ * Returns a decoder that you can use to decode a byte array representing the `Rent` sysvar's
+ * account data to a {@link SysvarRent}.
+ */
+export function getSysvarRentDecoder(): FixedSizeDecoder<SysvarRent, SysvarRentSize> {
+    return getStructDecoder([
+        ['lamportsPerByteYear', getDefaultLamportsDecoder()],
+        ['exemptionThreshold', getF64Decoder()],
+        ['burnPercent', getU8Decoder()],
+    ]) as FixedSizeDecoder<SysvarRent, SysvarRentSize>;
+}
+
+/**
+ * Returns a codec that you can use to encode from or decode to {@link SysvarRent}
+ *
+ * @see {@link getSysvarRentDecoder}
+ * @see {@link getSysvarRentEncoder}
+ */
+export function getSysvarRentCodec(): FixedSizeCodec<SysvarRent, SysvarRent, SysvarRentSize> {
+    return combineCodec(getSysvarRentEncoder(), getSysvarRentDecoder());
+}
+
+/**
+ * Fetches the `Rent` sysvar account using any RPC that supports the {@link GetAccountInfoApi}.
+ */
+export async function fetchSysvarRent(rpc: Rpc<GetAccountInfoApi>, config?: FetchAccountConfig): Promise<SysvarRent> {
+    const account = await fetchEncodedSysvarAccount(rpc, SYSVAR_RENT_ADDRESS, config);
+    assertAccountExists(account);
+    const decoded = decodeAccount(account, getSysvarRentDecoder());
+    return decoded.data;
+}

package/src/slot-hashes.ts

@@ -0,0 +1,71 @@
+import { assertAccountExists, decodeAccount, type FetchAccountConfig } from '@solana/accounts';
+import {
+    combineCodec,
+    type VariableSizeCodec,
+    type VariableSizeDecoder,
+    type VariableSizeEncoder,
+} from '@solana/codecs-core';
+import { getArrayDecoder, getArrayEncoder, getStructDecoder, getStructEncoder } from '@solana/codecs-data-structures';
+import { getU64Decoder, getU64Encoder } from '@solana/codecs-numbers';
+import type { GetAccountInfoApi } from '@solana/rpc-api';
+import type { Rpc } from '@solana/rpc-spec';
+import { type Blockhash, getBlockhashDecoder, getBlockhashEncoder, type Slot } from '@solana/rpc-types';
+
+import { fetchEncodedSysvarAccount, SYSVAR_SLOT_HASHES_ADDRESS } from './sysvar';
+
+type Entry = Readonly<{
+    hash: Blockhash;
+    slot: Slot;
+}>;
+
+/** The most recent hashes of a slot's parent banks. */
+export type SysvarSlotHashes = Entry[];
+
+/**
+ * Returns an encoder that you can use to encode a {@link SysvarSlotHashes} to a byte array
+ * representing the `SlotHashes` sysvar's account data.
+ */
+export function getSysvarSlotHashesEncoder(): VariableSizeEncoder<SysvarSlotHashes> {
+    return getArrayEncoder(
+        getStructEncoder([
+            ['slot', getU64Encoder()],
+            ['hash', getBlockhashEncoder()],
+        ]),
+    );
+}
+
+/**
+ * Returns a decoder that you can use to decode a byte array representing the `SlotHashes` sysvar's
+ * account data to a {@link SysvarSlotHashes}.
+ */
+export function getSysvarSlotHashesDecoder(): VariableSizeDecoder<SysvarSlotHashes> {
+    return getArrayDecoder(
+        getStructDecoder([
+            ['slot', getU64Decoder()],
+            ['hash', getBlockhashDecoder()],
+        ]),
+    );
+}
+
+/**
+ * Returns a codec that you can use to encode from or decode to {@link SysvarSlotHashes}
+ *
+ * @see {@link getSysvarSlotHashesDecoder}
+ * @see {@link getSysvarSlotHashesEncoder}
+ */
+export function getSysvarSlotHashesCodec(): VariableSizeCodec<SysvarSlotHashes> {
+    return combineCodec(getSysvarSlotHashesEncoder(), getSysvarSlotHashesDecoder());
+}
+
+/**
+ * Fetches the `SlotHashes` sysvar account using any RPC that supports the {@link GetAccountInfoApi}.
+ */
+export async function fetchSysvarSlotHashes(
+    rpc: Rpc<GetAccountInfoApi>,
+    config?: FetchAccountConfig,
+): Promise<SysvarSlotHashes> {
+    const account = await fetchEncodedSysvarAccount(rpc, SYSVAR_SLOT_HASHES_ADDRESS, config);
+    assertAccountExists(account);
+    const decoded = decodeAccount(account, getSysvarSlotHashesDecoder());
+    return decoded.data;
+}

package/src/slot-history.ts

@@ -0,0 +1,198 @@
+import { assertAccountExists, decodeAccount, type FetchAccountConfig } from '@solana/accounts';
+import {
+    combineCodec,
+    createDecoder,
+    createEncoder,
+    type FixedSizeCodec,
+    type FixedSizeDecoder,
+    type FixedSizeEncoder,
+    ReadonlyUint8Array,
+} from '@solana/codecs-core';
+import { getArrayCodec } from '@solana/codecs-data-structures';
+import { getU64Codec, getU64Decoder, getU64Encoder } from '@solana/codecs-numbers';
+import {
+    SOLANA_ERROR__CODECS__ENUM_DISCRIMINATOR_OUT_OF_RANGE,
+    SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH,
+    SOLANA_ERROR__CODECS__INVALID_NUMBER_OF_ITEMS,
+    SolanaError,
+} from '@solana/errors';
+import type { GetAccountInfoApi } from '@solana/rpc-api';
+import type { Rpc } from '@solana/rpc-spec';
+import type { Slot } from '@solana/rpc-types';
+
+import { fetchEncodedSysvarAccount, SYSVAR_SLOT_HISTORY_ADDRESS } from './sysvar';
+
+const BITVEC_DISCRIMINATOR = 1;
+// Max number of bits in the bitvector.
+// The Solana SDK defines a constant `MAX_ENTRIES` representing the maximum
+// number of bits that can be represented by the bitvector in the `SlotHistory`
+// sysvar. This value is 1024 * 1024 = 1_048_576.
+// See https://github.com/anza-xyz/agave/blob/e0203f22dc83cb792fa97f91dbe6e924cbd08af1/sdk/program/src/slot_history.rs#L43
+const BITVEC_NUM_BITS = 1024 * 1024;
+// The length of the bitvector in blocks.
+// At 64 bits per block, this is 1024 * 1024 / 64 = 16_384.
+const BITVEC_LENGTH = BITVEC_NUM_BITS / 64;
+
+const SLOT_HISTORY_ACCOUNT_DATA_STATIC_SIZE =
+    1 + // Discriminator
+    8 + // bitvector length (u64)
+    BITVEC_LENGTH * 8 +
+    8 + // Number of bits (u64)
+    8; // Next slot (u64)
+
+let memoizedU64Encoder: FixedSizeEncoder<bigint, 8> | undefined;
+let memoizedU64Decoder: FixedSizeDecoder<bigint, 8> | undefined;
+let memoizedU64ArrayEncoder: FixedSizeEncoder<bigint[]> | undefined;
+let memoizedU64ArrayDecoder: FixedSizeDecoder<bigint[]> | undefined;
+
+function getMemoizedU64Encoder(): FixedSizeEncoder<bigint, 8> {
+    if (!memoizedU64Encoder) memoizedU64Encoder = getU64Encoder();
+    return memoizedU64Encoder;
+}
+function getMemoizedU64Decoder(): FixedSizeDecoder<bigint, 8> {
+    if (!memoizedU64Decoder) memoizedU64Decoder = getU64Decoder();
+    return memoizedU64Decoder;
+}
+function getMemoizedU64ArrayEncoder(): FixedSizeEncoder<bigint[], typeof BITVEC_LENGTH> {
+    if (!memoizedU64ArrayEncoder) memoizedU64ArrayEncoder = getArrayCodec(getU64Codec(), { size: BITVEC_LENGTH });
+    return memoizedU64ArrayEncoder;
+}
+function getMemoizedU64ArrayDecoder(): FixedSizeDecoder<bigint[], typeof BITVEC_LENGTH> {
+    if (!memoizedU64ArrayDecoder) memoizedU64ArrayDecoder = getArrayCodec(getU64Codec(), { size: BITVEC_LENGTH });
+    return memoizedU64ArrayDecoder;
+}
+
+type SysvarSlotHistorySize = typeof SLOT_HISTORY_ACCOUNT_DATA_STATIC_SIZE;
+
+/** A bitvector of slots present over the last epoch. */
+export type SysvarSlotHistory = {
+    /**
+     * A vector of 64-bit numbers which, when their bits are strung together, represent a record of
+     * non-skipped slots.
+     *
+     * The bit in position (slot % MAX_ENTRIES) is 0 if the slot was skipped and 1 otherwise, valid
+     * only when the candidate slot is less than `nextSlot` and greater than or equal to
+     * `MAX_ENTRIES - nextSlot`.
+     */
+    bits: bigint[];
+    /** The number of the slot one newer than tracked by the bitvector */
+    nextSlot: Slot;
+};
+
+/**
+ * Returns an encoder that you can use to encode a {@link SysvarSlotHistory} to a byte array
+ * representing the `SlotHistory` sysvar's account data.
+ */
+export function getSysvarSlotHistoryEncoder(): FixedSizeEncoder<SysvarSlotHistory, SysvarSlotHistorySize> {
+    return createEncoder({
+        fixedSize: SLOT_HISTORY_ACCOUNT_DATA_STATIC_SIZE,
+        write: (value: SysvarSlotHistory, bytes, offset) => {
+            // First byte is the bitvector discriminator.
+            bytes.set([BITVEC_DISCRIMINATOR], offset);
+            offset += 1;
+            // Next 8 bytes are the bitvector length.
+            getMemoizedU64Encoder().write(BigInt(BITVEC_LENGTH), bytes, offset);
+            offset += 8;
+            // Next `BITVEC_LENGTH` bytes are the bitvector.
+            // Any missing bits are assumed to be 0.
+            getMemoizedU64ArrayEncoder().write(value.bits, bytes, offset);
+            offset += BITVEC_LENGTH * 8;
+            // Next 8 bytes are the number of bits.
+            getMemoizedU64Encoder().write(BigInt(BITVEC_NUM_BITS), bytes, offset);
+            offset += 8;
+            // Next 8 bytes are the next slot.
+            getMemoizedU64Encoder().write(value.nextSlot, bytes, offset);
+            offset += 8;
+            return offset;
+        },
+    });
+}
+
+/**
+ * Returns a decoder that you can use to decode a byte array representing the `SlotHistory` sysvar's
+ * account data to a {@link SysvarSlotHistory}.
+ */
+export function getSysvarSlotHistoryDecoder(): FixedSizeDecoder<SysvarSlotHistory, SysvarSlotHistorySize> {
+    return createDecoder({
+        fixedSize: SLOT_HISTORY_ACCOUNT_DATA_STATIC_SIZE,
+        read: (bytes: ReadonlyUint8Array | Uint8Array, offset) => {
+            // Byte length should be exact.
+            if (bytes.length != SLOT_HISTORY_ACCOUNT_DATA_STATIC_SIZE) {
+                throw new SolanaError(SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH, {
+                    actual: bytes.length,
+                    expected: SLOT_HISTORY_ACCOUNT_DATA_STATIC_SIZE,
+                });
+            }
+            // First byte is the bitvector discriminator.
+            const discriminator = bytes[offset];
+            offset += 1;
+            if (discriminator !== BITVEC_DISCRIMINATOR) {
+                throw new SolanaError(SOLANA_ERROR__CODECS__ENUM_DISCRIMINATOR_OUT_OF_RANGE, {
+                    actual: discriminator,
+                    expected: BITVEC_DISCRIMINATOR,
+                });
+            }
+            // Next 8 bytes are the bitvector length.
+            const bitVecLength = getMemoizedU64Decoder().read(bytes, offset)[0];
+            offset += 8;
+            if (bitVecLength !== BigInt(BITVEC_LENGTH)) {
+                throw new SolanaError(SOLANA_ERROR__CODECS__INVALID_NUMBER_OF_ITEMS, {
+                    actual: bitVecLength,
+                    codecDescription: 'SysvarSlotHistoryCodec',
+                    expected: BITVEC_LENGTH,
+                });
+            }
+            // Next `BITVEC_LENGTH` bytes are the bitvector.
+            const bits = getMemoizedU64ArrayDecoder().read(bytes, offset)[0];
+            offset += BITVEC_LENGTH * 8;
+            // Next 8 bytes are the number of bits.
+            const numBits = getMemoizedU64Decoder().read(bytes, offset)[0];
+            offset += 8;
+            if (numBits !== BigInt(BITVEC_NUM_BITS)) {
+                throw new SolanaError(SOLANA_ERROR__CODECS__INVALID_NUMBER_OF_ITEMS, {
+                    actual: numBits,
+                    codecDescription: 'SysvarSlotHistoryCodec',
+                    expected: BITVEC_NUM_BITS,
+                });
+            }
+            // Next 8 bytes are the next slot.
+            const nextSlot = getMemoizedU64Decoder().read(bytes, offset)[0];
+            offset += 8;
+            return [
+                {
+                    bits,
+                    nextSlot,
+                },
+                offset,
+            ];
+        },
+    });
+}
+
+/**
+ * Returns a codec that you can use to encode from or decode to {@link SysvarSlotHistory}
+ *
+ * @see {@link getSysvarSlotHistoryDecoder}
+ * @see {@link getSysvarSlotHistoryEncoder}
+ */
+export function getSysvarSlotHistoryCodec(): FixedSizeCodec<
+    SysvarSlotHistory,
+    SysvarSlotHistory,
+    SysvarSlotHistorySize
+> {
+    return combineCodec(getSysvarSlotHistoryEncoder(), getSysvarSlotHistoryDecoder());
+}
+
+/**
+ * Fetches the `SlotHistory` sysvar account using any RPC that supports the
+ * {@link GetAccountInfoApi}.
+ */
+export async function fetchSysvarSlotHistory(
+    rpc: Rpc<GetAccountInfoApi>,
+    config?: FetchAccountConfig,
+): Promise<SysvarSlotHistory> {
+    const account = await fetchEncodedSysvarAccount(rpc, SYSVAR_SLOT_HISTORY_ADDRESS, config);
+    assertAccountExists(account);
+    const decoded = decodeAccount(account, getSysvarSlotHistoryDecoder());
+    return decoded.data;
+}

package/src/stake-history.ts

@@ -0,0 +1,102 @@
+import { assertAccountExists, decodeAccount, type FetchAccountConfig } from '@solana/accounts';
+import {
+    combineCodec,
+    type VariableSizeCodec,
+    type VariableSizeDecoder,
+    type VariableSizeEncoder,
+} from '@solana/codecs-core';
+import { getArrayDecoder, getArrayEncoder, getStructDecoder, getStructEncoder } from '@solana/codecs-data-structures';
+import { getU64Decoder, getU64Encoder } from '@solana/codecs-numbers';
+import type { GetAccountInfoApi } from '@solana/rpc-api';
+import type { Rpc } from '@solana/rpc-spec';
+import { Epoch, getDefaultLamportsDecoder, getDefaultLamportsEncoder, type Lamports } from '@solana/rpc-types';
+
+import { fetchEncodedSysvarAccount, SYSVAR_STAKE_HISTORY_ADDRESS } from './sysvar';
+
+type Entry = Readonly<{
+    /** The epoch to which this stake history entry pertains */
+    epoch: Epoch;
+    stakeHistory: Readonly<{
+        /**
+         * Sum of portion of stakes requested to be warmed up, but not fully activated yet, in
+         * {@link Lamports}
+         */
+        activating: Lamports;
+        /**
+         * Sum of portion of stakes requested to be cooled down, but not fully deactivated yet, in
+         * {@link Lamports}
+         */
+        deactivating: Lamports;
+        /** Effective stake at this epoch, in {@link Lamports} */
+        effective: Lamports;
+    }>;
+}>;
+
+/** History of stake activations and de-activations. */
+export type SysvarStakeHistory = Entry[];
+
+/**
+ * Returns an encoder that you can use to encode a {@link SysvarStakeHistory} to a byte array
+ * representing the `StakeHistory` sysvar's account data.
+ */
+export function getSysvarStakeHistoryEncoder(): VariableSizeEncoder<SysvarStakeHistory> {
+    return getArrayEncoder(
+        getStructEncoder([
+            ['epoch', getU64Encoder()],
+            [
+                'stakeHistory',
+                getStructEncoder([
+                    ['effective', getDefaultLamportsEncoder()],
+                    ['activating', getDefaultLamportsEncoder()],
+                    ['deactivating', getDefaultLamportsEncoder()],
+                ]),
+            ],
+        ]),
+        { size: getU64Encoder() },
+    );
+}
+
+/**
+ * Returns a decoder that you can use to decode a byte array representing the `StakeHistory`
+ * sysvar's account data to a {@link SysvarStakeHistory}.
+ */
+export function getSysvarStakeHistoryDecoder(): VariableSizeDecoder<SysvarStakeHistory> {
+    return getArrayDecoder(
+        getStructDecoder([
+            ['epoch', getU64Decoder()],
+            [
+                'stakeHistory',
+                getStructDecoder([
+                    ['effective', getDefaultLamportsDecoder()],
+                    ['activating', getDefaultLamportsDecoder()],
+                    ['deactivating', getDefaultLamportsDecoder()],
+                ]),
+            ],
+        ]),
+        { size: getU64Decoder() },
+    );
+}
+
+/**
+ * Returns a codec that you can use to encode from or decode to {@link SysvarStakeHistory}
+ *
+ * @see {@link getSysvarStakeHistoryDecoder}
+ * @see {@link getSysvarStakeHistoryEncoder}
+ */
+export function getSysvarStakeHistoryCodec(): VariableSizeCodec<SysvarStakeHistory> {
+    return combineCodec(getSysvarStakeHistoryEncoder(), getSysvarStakeHistoryDecoder());
+}
+
+/**
+ * Fetches the `StakeHistory` sysvar account using any RPC that supports the
+ * {@link GetAccountInfoApi}.
+ */
+export async function fetchSysvarStakeHistory(
+    rpc: Rpc<GetAccountInfoApi>,
+    config?: FetchAccountConfig,
+): Promise<SysvarStakeHistory> {
+    const account = await fetchEncodedSysvarAccount(rpc, SYSVAR_STAKE_HISTORY_ADDRESS, config);
+    assertAccountExists(account);
+    const decoded = decodeAccount(account, getSysvarStakeHistoryDecoder());
+    return decoded.data;
+}

package/src/sysvar.ts

@@ -0,0 +1,72 @@
+import {
+    type FetchAccountConfig,
+    fetchEncodedAccount,
+    fetchJsonParsedAccount,
+    type MaybeAccount,
+    type MaybeEncodedAccount,
+} from '@solana/accounts';
+import type { Address } from '@solana/addresses';
+import type { GetAccountInfoApi } from '@solana/rpc-api';
+import type { JsonParsedSysvarAccount } from '@solana/rpc-parsed-types';
+import type { Rpc } from '@solana/rpc-spec';
+
+export const SYSVAR_CLOCK_ADDRESS =
+    'SysvarC1ock11111111111111111111111111111111' as Address<'SysvarC1ock11111111111111111111111111111111'>;
+export const SYSVAR_EPOCH_REWARDS_ADDRESS =
+    'SysvarEpochRewards1111111111111111111111111' as Address<'SysvarEpochRewards1111111111111111111111111'>;
+export const SYSVAR_EPOCH_SCHEDULE_ADDRESS =
+    'SysvarEpochSchedu1e111111111111111111111111' as Address<'SysvarEpochSchedu1e111111111111111111111111'>;
+export const SYSVAR_INSTRUCTIONS_ADDRESS =
+    'Sysvar1nstructions1111111111111111111111111' as Address<'Sysvar1nstructions1111111111111111111111111'>;
+export const SYSVAR_LAST_RESTART_SLOT_ADDRESS =
+    'SysvarLastRestartS1ot1111111111111111111111' as Address<'SysvarLastRestartS1ot1111111111111111111111'>;
+export const SYSVAR_RECENT_BLOCKHASHES_ADDRESS =
+    'SysvarRecentB1ockHashes11111111111111111111' as Address<'SysvarRecentB1ockHashes11111111111111111111'>;
+export const SYSVAR_RENT_ADDRESS =
+    'SysvarRent111111111111111111111111111111111' as Address<'SysvarRent111111111111111111111111111111111'>;
+export const SYSVAR_SLOT_HASHES_ADDRESS =
+    'SysvarS1otHashes111111111111111111111111111' as Address<'SysvarS1otHashes111111111111111111111111111'>;
+export const SYSVAR_SLOT_HISTORY_ADDRESS =
+    'SysvarS1otHistory11111111111111111111111111' as Address<'SysvarS1otHistory11111111111111111111111111'>;
+export const SYSVAR_STAKE_HISTORY_ADDRESS =
+    'SysvarStakeHistory1111111111111111111111111' as Address<'SysvarStakeHistory1111111111111111111111111'>;
+
+type SysvarAddress =
+    | typeof SYSVAR_CLOCK_ADDRESS
+    | typeof SYSVAR_EPOCH_REWARDS_ADDRESS
+    | typeof SYSVAR_EPOCH_SCHEDULE_ADDRESS
+    | typeof SYSVAR_INSTRUCTIONS_ADDRESS
+    | typeof SYSVAR_LAST_RESTART_SLOT_ADDRESS
+    | typeof SYSVAR_RECENT_BLOCKHASHES_ADDRESS
+    | typeof SYSVAR_RENT_ADDRESS
+    | typeof SYSVAR_SLOT_HASHES_ADDRESS
+    | typeof SYSVAR_SLOT_HISTORY_ADDRESS
+    | typeof SYSVAR_STAKE_HISTORY_ADDRESS;
+
+/**
+ * Fetch an encoded sysvar account.
+ *
+ * Sysvars are special accounts that contain dynamically-updated data about the network cluster, the
+ * blockchain history, and the executing transaction.
+ */
+export async function fetchEncodedSysvarAccount<TAddress extends SysvarAddress>(
+    rpc: Rpc<GetAccountInfoApi>,
+    address: TAddress,
+    config?: FetchAccountConfig,
+): Promise<MaybeEncodedAccount<TAddress>> {
+    return await fetchEncodedAccount<TAddress>(rpc, address, config);
+}
+
+/**
+ * Fetch a JSON-parsed sysvar account.
+ *
+ * Sysvars are special accounts that contain dynamically-updated data about the network cluster, the
+ * blockchain history, and the executing transaction.
+ */
+export async function fetchJsonParsedSysvarAccount<TAddress extends SysvarAddress>(
+    rpc: Rpc<GetAccountInfoApi>,
+    address: TAddress,
+    config?: FetchAccountConfig,
+): Promise<MaybeAccount<JsonParsedSysvarAccount, TAddress> | MaybeEncodedAccount<TAddress>> {
+    return await fetchJsonParsedAccount<JsonParsedSysvarAccount, TAddress>(rpc, address, config);
+}