@solana-program/system 0.12.0 → 0.12.2

package/package.json

@@ -1,12 +1,26 @@
 {
   "name": "@solana-program/system",
-  "version": "0.12.0",
+  "version": "0.12.2",
   "description": "JavaScript client for the System program",
+  "homepage": "https://github.com/solana-program/system#readme",
+  "bugs": {
+    "url": "https://github.com/solana-program/system/issues"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/solana-program/system.git"
+  },
+  "files": [
+    "./dist/src",
+    "./dist/types",
+    "./src/"
+  ],
+  "type": "commonjs",
   "sideEffects": false,
-  "module": "./dist/src/index.mjs",
   "main": "./dist/src/index.js",
+  "module": "./dist/src/index.mjs",
   "types": "./dist/types/index.d.ts",
-  "type": "commonjs",
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",
@@ -14,47 +28,36 @@
       "require": "./dist/src/index.js"
     }
   },
-  "files": [
-    "./dist/src",
-    "./dist/types"
-  ],
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
-  "license": "Apache-2.0",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/solana-program/system.git"
-  },
-  "bugs": {
-    "url": "https://github.com/solana-program/system/issues"
-  },
-  "homepage": "https://github.com/solana-program/system#readme",
-  "peerDependencies": {
-    "@solana/kit": "^6.1.0"
-  },
   "devDependencies": {
-    "@solana/eslint-config-solana": "^6.0.0",
-    "@solana/kit-plugins": "^0.5.0",
-    "@solana/kit": "^6.1.0",
+    "@solana-config/oxc": "^0.1.1",
+    "@solana/kit": "^6.4.0",
+    "@solana/kit-plugin-litesvm": "^0.10.0",
+    "@solana/kit-plugin-signer": "^0.10.0",
     "@types/node": "^24",
-    "eslint": "^9.39.2",
-    "prettier": "^3.7.4",
+    "oxfmt": "^0.48.0",
+    "oxlint": "^1.63.0",
+    "oxlint-tsgolint": "^0.23.0",
     "rimraf": "^6.1.2",
     "tsup": "^8.1.2",
     "typedoc": "^0.28.15",
     "typescript": "^5.9.3",
     "vitest": "^4.0.15"
   },
+  "peerDependencies": {
+    "@solana/kit": "^6.4.0"
+  },
   "scripts": {
     "build": "rimraf dist && tsup && tsc -p ./tsconfig.declarations.json",
     "build:docs": "typedoc",
     "dev": "vitest",
     "test": "vitest run",
-    "lint": "eslint src",
-    "lint:fix": "eslint --fix src",
-    "format": "prettier --check src test",
-    "format:fix": "prettier --write src test"
+    "lint": "oxlint",
+    "lint:fix": "oxlint --fix",
+    "format": "oxfmt --check",
+    "format:fix": "oxfmt"
   }
 }

package/src/generated/accounts/index.ts

@@ -0,0 +1,9 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+export * from './nonce';

package/src/generated/accounts/nonce.ts

@@ -0,0 +1,139 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+    assertAccountExists,
+    assertAccountsExist,
+    combineCodec,
+    decodeAccount,
+    fetchEncodedAccount,
+    fetchEncodedAccounts,
+    getAddressDecoder,
+    getAddressEncoder,
+    getStructDecoder,
+    getStructEncoder,
+    getU64Decoder,
+    getU64Encoder,
+    type Account,
+    type Address,
+    type EncodedAccount,
+    type FetchAccountConfig,
+    type FetchAccountsConfig,
+    type FixedSizeCodec,
+    type FixedSizeDecoder,
+    type FixedSizeEncoder,
+    type MaybeAccount,
+    type MaybeEncodedAccount,
+} from '@solana/kit';
+import {
+    getNonceStateDecoder,
+    getNonceStateEncoder,
+    getNonceVersionDecoder,
+    getNonceVersionEncoder,
+    type NonceState,
+    type NonceStateArgs,
+    type NonceVersion,
+    type NonceVersionArgs,
+} from '../types';
+
+export type Nonce = {
+    version: NonceVersion;
+    state: NonceState;
+    authority: Address;
+    blockhash: Address;
+    lamportsPerSignature: bigint;
+};
+
+export type NonceArgs = {
+    version: NonceVersionArgs;
+    state: NonceStateArgs;
+    authority: Address;
+    blockhash: Address;
+    lamportsPerSignature: number | bigint;
+};
+
+/** Gets the encoder for {@link NonceArgs} account data. */
+export function getNonceEncoder(): FixedSizeEncoder<NonceArgs> {
+    return getStructEncoder([
+        ['version', getNonceVersionEncoder()],
+        ['state', getNonceStateEncoder()],
+        ['authority', getAddressEncoder()],
+        ['blockhash', getAddressEncoder()],
+        ['lamportsPerSignature', getU64Encoder()],
+    ]);
+}
+
+/** Gets the decoder for {@link Nonce} account data. */
+export function getNonceDecoder(): FixedSizeDecoder<Nonce> {
+    return getStructDecoder([
+        ['version', getNonceVersionDecoder()],
+        ['state', getNonceStateDecoder()],
+        ['authority', getAddressDecoder()],
+        ['blockhash', getAddressDecoder()],
+        ['lamportsPerSignature', getU64Decoder()],
+    ]);
+}
+
+/** Gets the codec for {@link Nonce} account data. */
+export function getNonceCodec(): FixedSizeCodec<NonceArgs, Nonce> {
+    return combineCodec(getNonceEncoder(), getNonceDecoder());
+}
+
+export function decodeNonce<TAddress extends string = string>(
+    encodedAccount: EncodedAccount<TAddress>,
+): Account<Nonce, TAddress>;
+export function decodeNonce<TAddress extends string = string>(
+    encodedAccount: MaybeEncodedAccount<TAddress>,
+): MaybeAccount<Nonce, TAddress>;
+export function decodeNonce<TAddress extends string = string>(
+    encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
+): Account<Nonce, TAddress> | MaybeAccount<Nonce, TAddress> {
+    return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getNonceDecoder());
+}
+
+export async function fetchNonce<TAddress extends string = string>(
+    rpc: Parameters<typeof fetchEncodedAccount>[0],
+    address: Address<TAddress>,
+    config?: FetchAccountConfig,
+): Promise<Account<Nonce, TAddress>> {
+    const maybeAccount = await fetchMaybeNonce(rpc, address, config);
+    assertAccountExists(maybeAccount);
+    return maybeAccount;
+}
+
+export async function fetchMaybeNonce<TAddress extends string = string>(
+    rpc: Parameters<typeof fetchEncodedAccount>[0],
+    address: Address<TAddress>,
+    config?: FetchAccountConfig,
+): Promise<MaybeAccount<Nonce, TAddress>> {
+    const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+    return decodeNonce(maybeAccount);
+}
+
+export async function fetchAllNonce(
+    rpc: Parameters<typeof fetchEncodedAccounts>[0],
+    addresses: Array<Address>,
+    config?: FetchAccountsConfig,
+): Promise<Account<Nonce>[]> {
+    const maybeAccounts = await fetchAllMaybeNonce(rpc, addresses, config);
+    assertAccountsExist(maybeAccounts);
+    return maybeAccounts;
+}
+
+export async function fetchAllMaybeNonce(
+    rpc: Parameters<typeof fetchEncodedAccounts>[0],
+    addresses: Array<Address>,
+    config?: FetchAccountsConfig,
+): Promise<MaybeAccount<Nonce>[]> {
+    const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+    return maybeAccounts.map(maybeAccount => decodeNonce(maybeAccount));
+}
+
+export function getNonceSize(): number {
+    return 80;
+}

package/src/generated/errors/index.ts

@@ -0,0 +1,9 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+export * from './system';

package/src/generated/errors/system.ts

@@ -0,0 +1,77 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+    isProgramError,
+    type Address,
+    type SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM,
+    type SolanaError,
+} from '@solana/kit';
+import { SYSTEM_PROGRAM_ADDRESS } from '../programs';
+
+/** AccountAlreadyInUse: an account with the same address already exists */
+export const SYSTEM_ERROR__ACCOUNT_ALREADY_IN_USE = 0x0; // 0
+/** ResultWithNegativeLamports: account does not have enough SOL to perform the operation */
+export const SYSTEM_ERROR__RESULT_WITH_NEGATIVE_LAMPORTS = 0x1; // 1
+/** InvalidProgramId: cannot assign account to this program id */
+export const SYSTEM_ERROR__INVALID_PROGRAM_ID = 0x2; // 2
+/** InvalidAccountDataLength: cannot allocate account data of this length */
+export const SYSTEM_ERROR__INVALID_ACCOUNT_DATA_LENGTH = 0x3; // 3
+/** MaxSeedLengthExceeded: length of requested seed is too long */
+export const SYSTEM_ERROR__MAX_SEED_LENGTH_EXCEEDED = 0x4; // 4
+/** AddressWithSeedMismatch: provided address does not match addressed derived from seed */
+export const SYSTEM_ERROR__ADDRESS_WITH_SEED_MISMATCH = 0x5; // 5
+/** NonceNoRecentBlockhashes: advancing stored nonce requires a populated RecentBlockhashes sysvar */
+export const SYSTEM_ERROR__NONCE_NO_RECENT_BLOCKHASHES = 0x6; // 6
+/** NonceBlockhashNotExpired: stored nonce is still in recent_blockhashes */
+export const SYSTEM_ERROR__NONCE_BLOCKHASH_NOT_EXPIRED = 0x7; // 7
+/** NonceUnexpectedBlockhashValue: specified nonce does not match stored nonce */
+export const SYSTEM_ERROR__NONCE_UNEXPECTED_BLOCKHASH_VALUE = 0x8; // 8
+
+export type SystemError =
+    | typeof SYSTEM_ERROR__ACCOUNT_ALREADY_IN_USE
+    | typeof SYSTEM_ERROR__ADDRESS_WITH_SEED_MISMATCH
+    | typeof SYSTEM_ERROR__INVALID_ACCOUNT_DATA_LENGTH
+    | typeof SYSTEM_ERROR__INVALID_PROGRAM_ID
+    | typeof SYSTEM_ERROR__MAX_SEED_LENGTH_EXCEEDED
+    | typeof SYSTEM_ERROR__NONCE_BLOCKHASH_NOT_EXPIRED
+    | typeof SYSTEM_ERROR__NONCE_NO_RECENT_BLOCKHASHES
+    | typeof SYSTEM_ERROR__NONCE_UNEXPECTED_BLOCKHASH_VALUE
+    | typeof SYSTEM_ERROR__RESULT_WITH_NEGATIVE_LAMPORTS;
+
+let systemErrorMessages: Record<SystemError, string> | undefined;
+if (process.env['NODE_ENV'] !== 'production') {
+    systemErrorMessages = {
+        [SYSTEM_ERROR__ACCOUNT_ALREADY_IN_USE]: `an account with the same address already exists`,
+        [SYSTEM_ERROR__ADDRESS_WITH_SEED_MISMATCH]: `provided address does not match addressed derived from seed`,
+        [SYSTEM_ERROR__INVALID_ACCOUNT_DATA_LENGTH]: `cannot allocate account data of this length`,
+        [SYSTEM_ERROR__INVALID_PROGRAM_ID]: `cannot assign account to this program id`,
+        [SYSTEM_ERROR__MAX_SEED_LENGTH_EXCEEDED]: `length of requested seed is too long`,
+        [SYSTEM_ERROR__NONCE_BLOCKHASH_NOT_EXPIRED]: `stored nonce is still in recent_blockhashes`,
+        [SYSTEM_ERROR__NONCE_NO_RECENT_BLOCKHASHES]: `advancing stored nonce requires a populated RecentBlockhashes sysvar`,
+        [SYSTEM_ERROR__NONCE_UNEXPECTED_BLOCKHASH_VALUE]: `specified nonce does not match stored nonce`,
+        [SYSTEM_ERROR__RESULT_WITH_NEGATIVE_LAMPORTS]: `account does not have enough SOL to perform the operation`,
+    };
+}
+
+export function getSystemErrorMessage(code: SystemError): string {
+    if (process.env['NODE_ENV'] !== 'production') {
+        return (systemErrorMessages as Record<SystemError, string>)[code];
+    }
+
+    return 'Error message not available in production bundles.';
+}
+
+export function isSystemError<TProgramErrorCode extends SystemError>(
+    error: unknown,
+    transactionMessage: { instructions: Record<number, { programAddress: Address }> },
+    code?: TProgramErrorCode,
+): error is SolanaError<typeof SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM> &
+    Readonly<{ context: Readonly<{ code: TProgramErrorCode }> }> {
+    return isProgramError<TProgramErrorCode>(error, transactionMessage, SYSTEM_PROGRAM_ADDRESS, code);
+}

package/src/generated/index.ts

@@ -0,0 +1,13 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+export * from './accounts';
+export * from './errors';
+export * from './instructions';
+export * from './programs';
+export * from './types';

package/src/generated/instructions/advanceNonceAccount.ts

@@ -0,0 +1,186 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+    combineCodec,
+    getStructDecoder,
+    getStructEncoder,
+    getU32Decoder,
+    getU32Encoder,
+    SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+    SolanaError,
+    transformEncoder,
+    type AccountMeta,
+    type AccountSignerMeta,
+    type Address,
+    type FixedSizeCodec,
+    type FixedSizeDecoder,
+    type FixedSizeEncoder,
+    type Instruction,
+    type InstructionWithAccounts,
+    type InstructionWithData,
+    type ReadonlyAccount,
+    type ReadonlySignerAccount,
+    type ReadonlyUint8Array,
+    type TransactionSigner,
+    type WritableAccount,
+} from '@solana/kit';
+import { getAccountMetaFactory, type ResolvedInstructionAccount } from '@solana/kit/program-client-core';
+import { SYSTEM_PROGRAM_ADDRESS } from '../programs';
+
+export const ADVANCE_NONCE_ACCOUNT_DISCRIMINATOR = 4;
+
+export function getAdvanceNonceAccountDiscriminatorBytes(): ReadonlyUint8Array {
+    return getU32Encoder().encode(ADVANCE_NONCE_ACCOUNT_DISCRIMINATOR);
+}
+
+export type AdvanceNonceAccountInstruction<
+    TProgram extends string = typeof SYSTEM_PROGRAM_ADDRESS,
+    TAccountNonceAccount extends string | AccountMeta<string> = string,
+    TAccountRecentBlockhashesSysvar extends string | AccountMeta<string> =
+        'SysvarRecentB1ockHashes11111111111111111111',
+    TAccountNonceAuthority extends string | AccountMeta<string> = string,
+    TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> &
+    InstructionWithData<ReadonlyUint8Array> &
+    InstructionWithAccounts<
+        [
+            TAccountNonceAccount extends string ? WritableAccount<TAccountNonceAccount> : TAccountNonceAccount,
+            TAccountRecentBlockhashesSysvar extends string
+                ? ReadonlyAccount<TAccountRecentBlockhashesSysvar>
+                : TAccountRecentBlockhashesSysvar,
+            TAccountNonceAuthority extends string
+                ? ReadonlySignerAccount<TAccountNonceAuthority> & AccountSignerMeta<TAccountNonceAuthority>
+                : TAccountNonceAuthority,
+            ...TRemainingAccounts,
+        ]
+    >;
+
+export type AdvanceNonceAccountInstructionData = { discriminator: number };
+
+export type AdvanceNonceAccountInstructionDataArgs = {};
+
+export function getAdvanceNonceAccountInstructionDataEncoder(): FixedSizeEncoder<AdvanceNonceAccountInstructionDataArgs> {
+    return transformEncoder(getStructEncoder([['discriminator', getU32Encoder()]]), value => ({
+        ...value,
+        discriminator: ADVANCE_NONCE_ACCOUNT_DISCRIMINATOR,
+    }));
+}
+
+export function getAdvanceNonceAccountInstructionDataDecoder(): FixedSizeDecoder<AdvanceNonceAccountInstructionData> {
+    return getStructDecoder([['discriminator', getU32Decoder()]]);
+}
+
+export function getAdvanceNonceAccountInstructionDataCodec(): FixedSizeCodec<
+    AdvanceNonceAccountInstructionDataArgs,
+    AdvanceNonceAccountInstructionData
+> {
+    return combineCodec(getAdvanceNonceAccountInstructionDataEncoder(), getAdvanceNonceAccountInstructionDataDecoder());
+}
+
+export type AdvanceNonceAccountInput<
+    TAccountNonceAccount extends string = string,
+    TAccountRecentBlockhashesSysvar extends string = string,
+    TAccountNonceAuthority extends string = string,
+> = {
+    nonceAccount: Address<TAccountNonceAccount>;
+    recentBlockhashesSysvar?: Address<TAccountRecentBlockhashesSysvar>;
+    nonceAuthority: TransactionSigner<TAccountNonceAuthority>;
+};
+
+export function getAdvanceNonceAccountInstruction<
+    TAccountNonceAccount extends string,
+    TAccountRecentBlockhashesSysvar extends string,
+    TAccountNonceAuthority extends string,
+    TProgramAddress extends Address = typeof SYSTEM_PROGRAM_ADDRESS,
+>(
+    input: AdvanceNonceAccountInput<TAccountNonceAccount, TAccountRecentBlockhashesSysvar, TAccountNonceAuthority>,
+    config?: { programAddress?: TProgramAddress },
+): AdvanceNonceAccountInstruction<
+    TProgramAddress,
+    TAccountNonceAccount,
+    TAccountRecentBlockhashesSysvar,
+    TAccountNonceAuthority
+> {
+    // Program address.
+    const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
+
+    // Original accounts.
+    const originalAccounts = {
+        nonceAccount: { value: input.nonceAccount ?? null, isWritable: true },
+        recentBlockhashesSysvar: { value: input.recentBlockhashesSysvar ?? null, isWritable: false },
+        nonceAuthority: { value: input.nonceAuthority ?? null, isWritable: false },
+    };
+    const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+    // Resolve default values.
+    if (!accounts.recentBlockhashesSysvar.value) {
+        accounts.recentBlockhashesSysvar.value =
+            'SysvarRecentB1ockHashes11111111111111111111' as Address<'SysvarRecentB1ockHashes11111111111111111111'>;
+    }
+
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'omitted');
+    return Object.freeze({
+        accounts: [
+            getAccountMeta('nonceAccount', accounts.nonceAccount),
+            getAccountMeta('recentBlockhashesSysvar', accounts.recentBlockhashesSysvar),
+            getAccountMeta('nonceAuthority', accounts.nonceAuthority),
+        ],
+        data: getAdvanceNonceAccountInstructionDataEncoder().encode({}),
+        programAddress,
+    } as AdvanceNonceAccountInstruction<
+        TProgramAddress,
+        TAccountNonceAccount,
+        TAccountRecentBlockhashesSysvar,
+        TAccountNonceAuthority
+    >);
+}
+
+export type ParsedAdvanceNonceAccountInstruction<
+    TProgram extends string = typeof SYSTEM_PROGRAM_ADDRESS,
+    TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[],
+> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        nonceAccount: TAccountMetas[0];
+        recentBlockhashesSysvar: TAccountMetas[1];
+        nonceAuthority: TAccountMetas[2];
+    };
+    data: AdvanceNonceAccountInstructionData;
+};
+
+export function parseAdvanceNonceAccountInstruction<
+    TProgram extends string,
+    TAccountMetas extends readonly AccountMeta[],
+>(
+    instruction: Instruction<TProgram> &
+        InstructionWithAccounts<TAccountMetas> &
+        InstructionWithData<ReadonlyUint8Array>,
+): ParsedAdvanceNonceAccountInstruction<TProgram, TAccountMetas> {
+    if (instruction.accounts.length < 3) {
+        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+            actualAccountMetas: instruction.accounts.length,
+            expectedAccountMetas: 3,
+        });
+    }
+    let accountIndex = 0;
+    const getNextAccount = () => {
+        const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+        accountIndex += 1;
+        return accountMeta;
+    };
+    return {
+        programAddress: instruction.programAddress,
+        accounts: {
+            nonceAccount: getNextAccount(),
+            recentBlockhashesSysvar: getNextAccount(),
+            nonceAuthority: getNextAccount(),
+        },
+        data: getAdvanceNonceAccountInstructionDataDecoder().decode(instruction.data),
+    };
+}

package/src/generated/instructions/allocate.ts

@@ -0,0 +1,148 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+    combineCodec,
+    getStructDecoder,
+    getStructEncoder,
+    getU32Decoder,
+    getU32Encoder,
+    getU64Decoder,
+    getU64Encoder,
+    SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+    SolanaError,
+    transformEncoder,
+    type AccountMeta,
+    type AccountSignerMeta,
+    type Address,
+    type FixedSizeCodec,
+    type FixedSizeDecoder,
+    type FixedSizeEncoder,
+    type Instruction,
+    type InstructionWithAccounts,
+    type InstructionWithData,
+    type ReadonlyUint8Array,
+    type TransactionSigner,
+    type WritableSignerAccount,
+} from '@solana/kit';
+import { getAccountMetaFactory, type ResolvedInstructionAccount } from '@solana/kit/program-client-core';
+import { SYSTEM_PROGRAM_ADDRESS } from '../programs';
+
+export const ALLOCATE_DISCRIMINATOR = 8;
+
+export function getAllocateDiscriminatorBytes(): ReadonlyUint8Array {
+    return getU32Encoder().encode(ALLOCATE_DISCRIMINATOR);
+}
+
+export type AllocateInstruction<
+    TProgram extends string = typeof SYSTEM_PROGRAM_ADDRESS,
+    TAccountNewAccount extends string | AccountMeta<string> = string,
+    TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> &
+    InstructionWithData<ReadonlyUint8Array> &
+    InstructionWithAccounts<
+        [
+            TAccountNewAccount extends string
+                ? WritableSignerAccount<TAccountNewAccount> & AccountSignerMeta<TAccountNewAccount>
+                : TAccountNewAccount,
+            ...TRemainingAccounts,
+        ]
+    >;
+
+export type AllocateInstructionData = { discriminator: number; space: bigint };
+
+export type AllocateInstructionDataArgs = { space: number | bigint };
+
+export function getAllocateInstructionDataEncoder(): FixedSizeEncoder<AllocateInstructionDataArgs> {
+    return transformEncoder(
+        getStructEncoder([
+            ['discriminator', getU32Encoder()],
+            ['space', getU64Encoder()],
+        ]),
+        value => ({ ...value, discriminator: ALLOCATE_DISCRIMINATOR }),
+    );
+}
+
+export function getAllocateInstructionDataDecoder(): FixedSizeDecoder<AllocateInstructionData> {
+    return getStructDecoder([
+        ['discriminator', getU32Decoder()],
+        ['space', getU64Decoder()],
+    ]);
+}
+
+export function getAllocateInstructionDataCodec(): FixedSizeCodec<
+    AllocateInstructionDataArgs,
+    AllocateInstructionData
+> {
+    return combineCodec(getAllocateInstructionDataEncoder(), getAllocateInstructionDataDecoder());
+}
+
+export type AllocateInput<TAccountNewAccount extends string = string> = {
+    newAccount: TransactionSigner<TAccountNewAccount>;
+    space: AllocateInstructionDataArgs['space'];
+};
+
+export function getAllocateInstruction<
+    TAccountNewAccount extends string,
+    TProgramAddress extends Address = typeof SYSTEM_PROGRAM_ADDRESS,
+>(
+    input: AllocateInput<TAccountNewAccount>,
+    config?: { programAddress?: TProgramAddress },
+): AllocateInstruction<TProgramAddress, TAccountNewAccount> {
+    // Program address.
+    const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
+
+    // Original accounts.
+    const originalAccounts = { newAccount: { value: input.newAccount ?? null, isWritable: true } };
+    const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+    // Original args.
+    const args = { ...input };
+
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'omitted');
+    return Object.freeze({
+        accounts: [getAccountMeta('newAccount', accounts.newAccount)],
+        data: getAllocateInstructionDataEncoder().encode(args as AllocateInstructionDataArgs),
+        programAddress,
+    } as AllocateInstruction<TProgramAddress, TAccountNewAccount>);
+}
+
+export type ParsedAllocateInstruction<
+    TProgram extends string = typeof SYSTEM_PROGRAM_ADDRESS,
+    TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[],
+> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        newAccount: TAccountMetas[0];
+    };
+    data: AllocateInstructionData;
+};
+
+export function parseAllocateInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(
+    instruction: Instruction<TProgram> &
+        InstructionWithAccounts<TAccountMetas> &
+        InstructionWithData<ReadonlyUint8Array>,
+): ParsedAllocateInstruction<TProgram, TAccountMetas> {
+    if (instruction.accounts.length < 1) {
+        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+            actualAccountMetas: instruction.accounts.length,
+            expectedAccountMetas: 1,
+        });
+    }
+    let accountIndex = 0;
+    const getNextAccount = () => {
+        const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+        accountIndex += 1;
+        return accountMeta;
+    };
+    return {
+        programAddress: instruction.programAddress,
+        accounts: { newAccount: getNextAccount() },
+        data: getAllocateInstructionDataDecoder().decode(instruction.data),
+    };
+}