@solana-program/system 0.12.0 → 0.12.1

package/src/generated/instructions/allocateWithSeed.ts

@@ -0,0 +1,189 @@
+/**
+ * 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 {
+    addDecoderSizePrefix,
+    addEncoderSizePrefix,
+    combineCodec,
+    getAddressDecoder,
+    getAddressEncoder,
+    getStructDecoder,
+    getStructEncoder,
+    getU32Decoder,
+    getU32Encoder,
+    getU64Decoder,
+    getU64Encoder,
+    getUtf8Decoder,
+    getUtf8Encoder,
+    SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+    SolanaError,
+    transformEncoder,
+    type AccountMeta,
+    type AccountSignerMeta,
+    type Address,
+    type Codec,
+    type Decoder,
+    type Encoder,
+    type Instruction,
+    type InstructionWithAccounts,
+    type InstructionWithData,
+    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 ALLOCATE_WITH_SEED_DISCRIMINATOR = 9;
+
+export function getAllocateWithSeedDiscriminatorBytes(): ReadonlyUint8Array {
+    return getU32Encoder().encode(ALLOCATE_WITH_SEED_DISCRIMINATOR);
+}
+
+export type AllocateWithSeedInstruction<
+    TProgram extends string = typeof SYSTEM_PROGRAM_ADDRESS,
+    TAccountNewAccount extends string | AccountMeta<string> = string,
+    TAccountBaseAccount extends string | AccountMeta<string> = string,
+    TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> &
+    InstructionWithData<ReadonlyUint8Array> &
+    InstructionWithAccounts<
+        [
+            TAccountNewAccount extends string ? WritableAccount<TAccountNewAccount> : TAccountNewAccount,
+            TAccountBaseAccount extends string
+                ? ReadonlySignerAccount<TAccountBaseAccount> & AccountSignerMeta<TAccountBaseAccount>
+                : TAccountBaseAccount,
+            ...TRemainingAccounts,
+        ]
+    >;
+
+export type AllocateWithSeedInstructionData = {
+    discriminator: number;
+    base: Address;
+    seed: string;
+    space: bigint;
+    programAddress: Address;
+};
+
+export type AllocateWithSeedInstructionDataArgs = {
+    base: Address;
+    seed: string;
+    space: number | bigint;
+    programAddress: Address;
+};
+
+export function getAllocateWithSeedInstructionDataEncoder(): Encoder<AllocateWithSeedInstructionDataArgs> {
+    return transformEncoder(
+        getStructEncoder([
+            ['discriminator', getU32Encoder()],
+            ['base', getAddressEncoder()],
+            ['seed', addEncoderSizePrefix(getUtf8Encoder(), getU64Encoder())],
+            ['space', getU64Encoder()],
+            ['programAddress', getAddressEncoder()],
+        ]),
+        value => ({ ...value, discriminator: ALLOCATE_WITH_SEED_DISCRIMINATOR }),
+    );
+}
+
+export function getAllocateWithSeedInstructionDataDecoder(): Decoder<AllocateWithSeedInstructionData> {
+    return getStructDecoder([
+        ['discriminator', getU32Decoder()],
+        ['base', getAddressDecoder()],
+        ['seed', addDecoderSizePrefix(getUtf8Decoder(), getU64Decoder())],
+        ['space', getU64Decoder()],
+        ['programAddress', getAddressDecoder()],
+    ]);
+}
+
+export function getAllocateWithSeedInstructionDataCodec(): Codec<
+    AllocateWithSeedInstructionDataArgs,
+    AllocateWithSeedInstructionData
+> {
+    return combineCodec(getAllocateWithSeedInstructionDataEncoder(), getAllocateWithSeedInstructionDataDecoder());
+}
+
+export type AllocateWithSeedInput<
+    TAccountNewAccount extends string = string,
+    TAccountBaseAccount extends string = string,
+> = {
+    newAccount: Address<TAccountNewAccount>;
+    baseAccount: TransactionSigner<TAccountBaseAccount>;
+    base: AllocateWithSeedInstructionDataArgs['base'];
+    seed: AllocateWithSeedInstructionDataArgs['seed'];
+    space: AllocateWithSeedInstructionDataArgs['space'];
+    programAddress: AllocateWithSeedInstructionDataArgs['programAddress'];
+};
+
+export function getAllocateWithSeedInstruction<
+    TAccountNewAccount extends string,
+    TAccountBaseAccount extends string,
+    TProgramAddress extends Address = typeof SYSTEM_PROGRAM_ADDRESS,
+>(
+    input: AllocateWithSeedInput<TAccountNewAccount, TAccountBaseAccount>,
+    config?: { programAddress?: TProgramAddress },
+): AllocateWithSeedInstruction<TProgramAddress, TAccountNewAccount, TAccountBaseAccount> {
+    // Program address.
+    const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
+
+    // Original accounts.
+    const originalAccounts = {
+        newAccount: { value: input.newAccount ?? null, isWritable: true },
+        baseAccount: { value: input.baseAccount ?? null, isWritable: false },
+    };
+    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),
+            getAccountMeta('baseAccount', accounts.baseAccount),
+        ],
+        data: getAllocateWithSeedInstructionDataEncoder().encode(args as AllocateWithSeedInstructionDataArgs),
+        programAddress,
+    } as AllocateWithSeedInstruction<TProgramAddress, TAccountNewAccount, TAccountBaseAccount>);
+}
+
+export type ParsedAllocateWithSeedInstruction<
+    TProgram extends string = typeof SYSTEM_PROGRAM_ADDRESS,
+    TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[],
+> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        newAccount: TAccountMetas[0];
+        baseAccount: TAccountMetas[1];
+    };
+    data: AllocateWithSeedInstructionData;
+};
+
+export function parseAllocateWithSeedInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(
+    instruction: Instruction<TProgram> &
+        InstructionWithAccounts<TAccountMetas> &
+        InstructionWithData<ReadonlyUint8Array>,
+): ParsedAllocateWithSeedInstruction<TProgram, TAccountMetas> {
+    if (instruction.accounts.length < 2) {
+        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+            actualAccountMetas: instruction.accounts.length,
+            expectedAccountMetas: 2,
+        });
+    }
+    let accountIndex = 0;
+    const getNextAccount = () => {
+        const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+        accountIndex += 1;
+        return accountMeta;
+    };
+    return {
+        programAddress: instruction.programAddress,
+        accounts: { newAccount: getNextAccount(), baseAccount: getNextAccount() },
+        data: getAllocateWithSeedInstructionDataDecoder().decode(instruction.data),
+    };
+}

package/src/generated/instructions/assign.ts

@@ -0,0 +1,145 @@
+/**
+ * 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,
+    getAddressDecoder,
+    getAddressEncoder,
+    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 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 ASSIGN_DISCRIMINATOR = 1;
+
+export function getAssignDiscriminatorBytes(): ReadonlyUint8Array {
+    return getU32Encoder().encode(ASSIGN_DISCRIMINATOR);
+}
+
+export type AssignInstruction<
+    TProgram extends string = typeof SYSTEM_PROGRAM_ADDRESS,
+    TAccountAccount extends string | AccountMeta<string> = string,
+    TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> &
+    InstructionWithData<ReadonlyUint8Array> &
+    InstructionWithAccounts<
+        [
+            TAccountAccount extends string
+                ? WritableSignerAccount<TAccountAccount> & AccountSignerMeta<TAccountAccount>
+                : TAccountAccount,
+            ...TRemainingAccounts,
+        ]
+    >;
+
+export type AssignInstructionData = { discriminator: number; programAddress: Address };
+
+export type AssignInstructionDataArgs = { programAddress: Address };
+
+export function getAssignInstructionDataEncoder(): FixedSizeEncoder<AssignInstructionDataArgs> {
+    return transformEncoder(
+        getStructEncoder([
+            ['discriminator', getU32Encoder()],
+            ['programAddress', getAddressEncoder()],
+        ]),
+        value => ({ ...value, discriminator: ASSIGN_DISCRIMINATOR }),
+    );
+}
+
+export function getAssignInstructionDataDecoder(): FixedSizeDecoder<AssignInstructionData> {
+    return getStructDecoder([
+        ['discriminator', getU32Decoder()],
+        ['programAddress', getAddressDecoder()],
+    ]);
+}
+
+export function getAssignInstructionDataCodec(): FixedSizeCodec<AssignInstructionDataArgs, AssignInstructionData> {
+    return combineCodec(getAssignInstructionDataEncoder(), getAssignInstructionDataDecoder());
+}
+
+export type AssignInput<TAccountAccount extends string = string> = {
+    account: TransactionSigner<TAccountAccount>;
+    programAddress: AssignInstructionDataArgs['programAddress'];
+};
+
+export function getAssignInstruction<
+    TAccountAccount extends string,
+    TProgramAddress extends Address = typeof SYSTEM_PROGRAM_ADDRESS,
+>(
+    input: AssignInput<TAccountAccount>,
+    config?: { programAddress?: TProgramAddress },
+): AssignInstruction<TProgramAddress, TAccountAccount> {
+    // Program address.
+    const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
+
+    // Original accounts.
+    const originalAccounts = { account: { value: input.account ?? 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('account', accounts.account)],
+        data: getAssignInstructionDataEncoder().encode(args as AssignInstructionDataArgs),
+        programAddress,
+    } as AssignInstruction<TProgramAddress, TAccountAccount>);
+}
+
+export type ParsedAssignInstruction<
+    TProgram extends string = typeof SYSTEM_PROGRAM_ADDRESS,
+    TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[],
+> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        account: TAccountMetas[0];
+    };
+    data: AssignInstructionData;
+};
+
+export function parseAssignInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(
+    instruction: Instruction<TProgram> &
+        InstructionWithAccounts<TAccountMetas> &
+        InstructionWithData<ReadonlyUint8Array>,
+): ParsedAssignInstruction<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: { account: getNextAccount() },
+        data: getAssignInstructionDataDecoder().decode(instruction.data),
+    };
+}

package/src/generated/instructions/assignWithSeed.ts

@@ -0,0 +1,177 @@
+/**
+ * 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 {
+    addDecoderSizePrefix,
+    addEncoderSizePrefix,
+    combineCodec,
+    getAddressDecoder,
+    getAddressEncoder,
+    getStructDecoder,
+    getStructEncoder,
+    getU32Decoder,
+    getU32Encoder,
+    getU64Decoder,
+    getU64Encoder,
+    getUtf8Decoder,
+    getUtf8Encoder,
+    SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+    SolanaError,
+    transformEncoder,
+    type AccountMeta,
+    type AccountSignerMeta,
+    type Address,
+    type Codec,
+    type Decoder,
+    type Encoder,
+    type Instruction,
+    type InstructionWithAccounts,
+    type InstructionWithData,
+    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 ASSIGN_WITH_SEED_DISCRIMINATOR = 10;
+
+export function getAssignWithSeedDiscriminatorBytes(): ReadonlyUint8Array {
+    return getU32Encoder().encode(ASSIGN_WITH_SEED_DISCRIMINATOR);
+}
+
+export type AssignWithSeedInstruction<
+    TProgram extends string = typeof SYSTEM_PROGRAM_ADDRESS,
+    TAccountAccount extends string | AccountMeta<string> = string,
+    TAccountBaseAccount extends string | AccountMeta<string> = string,
+    TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> &
+    InstructionWithData<ReadonlyUint8Array> &
+    InstructionWithAccounts<
+        [
+            TAccountAccount extends string ? WritableAccount<TAccountAccount> : TAccountAccount,
+            TAccountBaseAccount extends string
+                ? ReadonlySignerAccount<TAccountBaseAccount> & AccountSignerMeta<TAccountBaseAccount>
+                : TAccountBaseAccount,
+            ...TRemainingAccounts,
+        ]
+    >;
+
+export type AssignWithSeedInstructionData = {
+    discriminator: number;
+    base: Address;
+    seed: string;
+    programAddress: Address;
+};
+
+export type AssignWithSeedInstructionDataArgs = { base: Address; seed: string; programAddress: Address };
+
+export function getAssignWithSeedInstructionDataEncoder(): Encoder<AssignWithSeedInstructionDataArgs> {
+    return transformEncoder(
+        getStructEncoder([
+            ['discriminator', getU32Encoder()],
+            ['base', getAddressEncoder()],
+            ['seed', addEncoderSizePrefix(getUtf8Encoder(), getU64Encoder())],
+            ['programAddress', getAddressEncoder()],
+        ]),
+        value => ({ ...value, discriminator: ASSIGN_WITH_SEED_DISCRIMINATOR }),
+    );
+}
+
+export function getAssignWithSeedInstructionDataDecoder(): Decoder<AssignWithSeedInstructionData> {
+    return getStructDecoder([
+        ['discriminator', getU32Decoder()],
+        ['base', getAddressDecoder()],
+        ['seed', addDecoderSizePrefix(getUtf8Decoder(), getU64Decoder())],
+        ['programAddress', getAddressDecoder()],
+    ]);
+}
+
+export function getAssignWithSeedInstructionDataCodec(): Codec<
+    AssignWithSeedInstructionDataArgs,
+    AssignWithSeedInstructionData
+> {
+    return combineCodec(getAssignWithSeedInstructionDataEncoder(), getAssignWithSeedInstructionDataDecoder());
+}
+
+export type AssignWithSeedInput<
+    TAccountAccount extends string = string,
+    TAccountBaseAccount extends string = string,
+> = {
+    account: Address<TAccountAccount>;
+    baseAccount: TransactionSigner<TAccountBaseAccount>;
+    base: AssignWithSeedInstructionDataArgs['base'];
+    seed: AssignWithSeedInstructionDataArgs['seed'];
+    programAddress: AssignWithSeedInstructionDataArgs['programAddress'];
+};
+
+export function getAssignWithSeedInstruction<
+    TAccountAccount extends string,
+    TAccountBaseAccount extends string,
+    TProgramAddress extends Address = typeof SYSTEM_PROGRAM_ADDRESS,
+>(
+    input: AssignWithSeedInput<TAccountAccount, TAccountBaseAccount>,
+    config?: { programAddress?: TProgramAddress },
+): AssignWithSeedInstruction<TProgramAddress, TAccountAccount, TAccountBaseAccount> {
+    // Program address.
+    const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
+
+    // Original accounts.
+    const originalAccounts = {
+        account: { value: input.account ?? null, isWritable: true },
+        baseAccount: { value: input.baseAccount ?? null, isWritable: false },
+    };
+    const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+    // Original args.
+    const args = { ...input };
+
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'omitted');
+    return Object.freeze({
+        accounts: [getAccountMeta('account', accounts.account), getAccountMeta('baseAccount', accounts.baseAccount)],
+        data: getAssignWithSeedInstructionDataEncoder().encode(args as AssignWithSeedInstructionDataArgs),
+        programAddress,
+    } as AssignWithSeedInstruction<TProgramAddress, TAccountAccount, TAccountBaseAccount>);
+}
+
+export type ParsedAssignWithSeedInstruction<
+    TProgram extends string = typeof SYSTEM_PROGRAM_ADDRESS,
+    TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[],
+> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        account: TAccountMetas[0];
+        baseAccount: TAccountMetas[1];
+    };
+    data: AssignWithSeedInstructionData;
+};
+
+export function parseAssignWithSeedInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(
+    instruction: Instruction<TProgram> &
+        InstructionWithAccounts<TAccountMetas> &
+        InstructionWithData<ReadonlyUint8Array>,
+): ParsedAssignWithSeedInstruction<TProgram, TAccountMetas> {
+    if (instruction.accounts.length < 2) {
+        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+            actualAccountMetas: instruction.accounts.length,
+            expectedAccountMetas: 2,
+        });
+    }
+    let accountIndex = 0;
+    const getNextAccount = () => {
+        const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+        accountIndex += 1;
+        return accountMeta;
+    };
+    return {
+        programAddress: instruction.programAddress,
+        accounts: { account: getNextAccount(), baseAccount: getNextAccount() },
+        data: getAssignWithSeedInstructionDataDecoder().decode(instruction.data),
+    };
+}

package/src/generated/instructions/authorizeNonceAccount.ts

@@ -0,0 +1,169 @@
+/**
+ * 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,
+    getAddressDecoder,
+    getAddressEncoder,
+    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 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 AUTHORIZE_NONCE_ACCOUNT_DISCRIMINATOR = 7;
+
+export function getAuthorizeNonceAccountDiscriminatorBytes(): ReadonlyUint8Array {
+    return getU32Encoder().encode(AUTHORIZE_NONCE_ACCOUNT_DISCRIMINATOR);
+}
+
+export type AuthorizeNonceAccountInstruction<
+    TProgram extends string = typeof SYSTEM_PROGRAM_ADDRESS,
+    TAccountNonceAccount extends string | AccountMeta<string> = string,
+    TAccountNonceAuthority extends string | AccountMeta<string> = string,
+    TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> &
+    InstructionWithData<ReadonlyUint8Array> &
+    InstructionWithAccounts<
+        [
+            TAccountNonceAccount extends string ? WritableAccount<TAccountNonceAccount> : TAccountNonceAccount,
+            TAccountNonceAuthority extends string
+                ? ReadonlySignerAccount<TAccountNonceAuthority> & AccountSignerMeta<TAccountNonceAuthority>
+                : TAccountNonceAuthority,
+            ...TRemainingAccounts,
+        ]
+    >;
+
+export type AuthorizeNonceAccountInstructionData = { discriminator: number; newNonceAuthority: Address };
+
+export type AuthorizeNonceAccountInstructionDataArgs = { newNonceAuthority: Address };
+
+export function getAuthorizeNonceAccountInstructionDataEncoder(): FixedSizeEncoder<AuthorizeNonceAccountInstructionDataArgs> {
+    return transformEncoder(
+        getStructEncoder([
+            ['discriminator', getU32Encoder()],
+            ['newNonceAuthority', getAddressEncoder()],
+        ]),
+        value => ({ ...value, discriminator: AUTHORIZE_NONCE_ACCOUNT_DISCRIMINATOR }),
+    );
+}
+
+export function getAuthorizeNonceAccountInstructionDataDecoder(): FixedSizeDecoder<AuthorizeNonceAccountInstructionData> {
+    return getStructDecoder([
+        ['discriminator', getU32Decoder()],
+        ['newNonceAuthority', getAddressDecoder()],
+    ]);
+}
+
+export function getAuthorizeNonceAccountInstructionDataCodec(): FixedSizeCodec<
+    AuthorizeNonceAccountInstructionDataArgs,
+    AuthorizeNonceAccountInstructionData
+> {
+    return combineCodec(
+        getAuthorizeNonceAccountInstructionDataEncoder(),
+        getAuthorizeNonceAccountInstructionDataDecoder(),
+    );
+}
+
+export type AuthorizeNonceAccountInput<
+    TAccountNonceAccount extends string = string,
+    TAccountNonceAuthority extends string = string,
+> = {
+    nonceAccount: Address<TAccountNonceAccount>;
+    nonceAuthority: TransactionSigner<TAccountNonceAuthority>;
+    newNonceAuthority: AuthorizeNonceAccountInstructionDataArgs['newNonceAuthority'];
+};
+
+export function getAuthorizeNonceAccountInstruction<
+    TAccountNonceAccount extends string,
+    TAccountNonceAuthority extends string,
+    TProgramAddress extends Address = typeof SYSTEM_PROGRAM_ADDRESS,
+>(
+    input: AuthorizeNonceAccountInput<TAccountNonceAccount, TAccountNonceAuthority>,
+    config?: { programAddress?: TProgramAddress },
+): AuthorizeNonceAccountInstruction<TProgramAddress, TAccountNonceAccount, TAccountNonceAuthority> {
+    // Program address.
+    const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
+
+    // Original accounts.
+    const originalAccounts = {
+        nonceAccount: { value: input.nonceAccount ?? null, isWritable: true },
+        nonceAuthority: { value: input.nonceAuthority ?? null, isWritable: false },
+    };
+    const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+    // Original args.
+    const args = { ...input };
+
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'omitted');
+    return Object.freeze({
+        accounts: [
+            getAccountMeta('nonceAccount', accounts.nonceAccount),
+            getAccountMeta('nonceAuthority', accounts.nonceAuthority),
+        ],
+        data: getAuthorizeNonceAccountInstructionDataEncoder().encode(args as AuthorizeNonceAccountInstructionDataArgs),
+        programAddress,
+    } as AuthorizeNonceAccountInstruction<TProgramAddress, TAccountNonceAccount, TAccountNonceAuthority>);
+}
+
+export type ParsedAuthorizeNonceAccountInstruction<
+    TProgram extends string = typeof SYSTEM_PROGRAM_ADDRESS,
+    TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[],
+> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        nonceAccount: TAccountMetas[0];
+        nonceAuthority: TAccountMetas[1];
+    };
+    data: AuthorizeNonceAccountInstructionData;
+};
+
+export function parseAuthorizeNonceAccountInstruction<
+    TProgram extends string,
+    TAccountMetas extends readonly AccountMeta[],
+>(
+    instruction: Instruction<TProgram> &
+        InstructionWithAccounts<TAccountMetas> &
+        InstructionWithData<ReadonlyUint8Array>,
+): ParsedAuthorizeNonceAccountInstruction<TProgram, TAccountMetas> {
+    if (instruction.accounts.length < 2) {
+        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+            actualAccountMetas: instruction.accounts.length,
+            expectedAccountMetas: 2,
+        });
+    }
+    let accountIndex = 0;
+    const getNextAccount = () => {
+        const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+        accountIndex += 1;
+        return accountMeta;
+    };
+    return {
+        programAddress: instruction.programAddress,
+        accounts: { nonceAccount: getNextAccount(), nonceAuthority: getNextAccount() },
+        data: getAuthorizeNonceAccountInstructionDataDecoder().decode(instruction.data),
+    };
+}