@solana-program/system 0.12.0 → 0.12.1

package/src/generated/instructions/withdrawNonceAccount.ts

@@ -0,0 +1,235 @@
+/**
+ * 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 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 WITHDRAW_NONCE_ACCOUNT_DISCRIMINATOR = 5;
+
+export function getWithdrawNonceAccountDiscriminatorBytes(): ReadonlyUint8Array {
+    return getU32Encoder().encode(WITHDRAW_NONCE_ACCOUNT_DISCRIMINATOR);
+}
+
+export type WithdrawNonceAccountInstruction<
+    TProgram extends string = typeof SYSTEM_PROGRAM_ADDRESS,
+    TAccountNonceAccount extends string | AccountMeta<string> = string,
+    TAccountRecipientAccount extends string | AccountMeta<string> = string,
+    TAccountRecentBlockhashesSysvar extends string | AccountMeta<string> =
+        'SysvarRecentB1ockHashes11111111111111111111',
+    TAccountRentSysvar extends string | AccountMeta<string> = 'SysvarRent111111111111111111111111111111111',
+    TAccountNonceAuthority extends string | AccountMeta<string> = string,
+    TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> &
+    InstructionWithData<ReadonlyUint8Array> &
+    InstructionWithAccounts<
+        [
+            TAccountNonceAccount extends string ? WritableAccount<TAccountNonceAccount> : TAccountNonceAccount,
+            TAccountRecipientAccount extends string
+                ? WritableAccount<TAccountRecipientAccount>
+                : TAccountRecipientAccount,
+            TAccountRecentBlockhashesSysvar extends string
+                ? ReadonlyAccount<TAccountRecentBlockhashesSysvar>
+                : TAccountRecentBlockhashesSysvar,
+            TAccountRentSysvar extends string ? ReadonlyAccount<TAccountRentSysvar> : TAccountRentSysvar,
+            TAccountNonceAuthority extends string
+                ? ReadonlySignerAccount<TAccountNonceAuthority> & AccountSignerMeta<TAccountNonceAuthority>
+                : TAccountNonceAuthority,
+            ...TRemainingAccounts,
+        ]
+    >;
+
+export type WithdrawNonceAccountInstructionData = { discriminator: number; withdrawAmount: bigint };
+
+export type WithdrawNonceAccountInstructionDataArgs = { withdrawAmount: number | bigint };
+
+export function getWithdrawNonceAccountInstructionDataEncoder(): FixedSizeEncoder<WithdrawNonceAccountInstructionDataArgs> {
+    return transformEncoder(
+        getStructEncoder([
+            ['discriminator', getU32Encoder()],
+            ['withdrawAmount', getU64Encoder()],
+        ]),
+        value => ({ ...value, discriminator: WITHDRAW_NONCE_ACCOUNT_DISCRIMINATOR }),
+    );
+}
+
+export function getWithdrawNonceAccountInstructionDataDecoder(): FixedSizeDecoder<WithdrawNonceAccountInstructionData> {
+    return getStructDecoder([
+        ['discriminator', getU32Decoder()],
+        ['withdrawAmount', getU64Decoder()],
+    ]);
+}
+
+export function getWithdrawNonceAccountInstructionDataCodec(): FixedSizeCodec<
+    WithdrawNonceAccountInstructionDataArgs,
+    WithdrawNonceAccountInstructionData
+> {
+    return combineCodec(
+        getWithdrawNonceAccountInstructionDataEncoder(),
+        getWithdrawNonceAccountInstructionDataDecoder(),
+    );
+}
+
+export type WithdrawNonceAccountInput<
+    TAccountNonceAccount extends string = string,
+    TAccountRecipientAccount extends string = string,
+    TAccountRecentBlockhashesSysvar extends string = string,
+    TAccountRentSysvar extends string = string,
+    TAccountNonceAuthority extends string = string,
+> = {
+    nonceAccount: Address<TAccountNonceAccount>;
+    recipientAccount: Address<TAccountRecipientAccount>;
+    recentBlockhashesSysvar?: Address<TAccountRecentBlockhashesSysvar>;
+    rentSysvar?: Address<TAccountRentSysvar>;
+    nonceAuthority: TransactionSigner<TAccountNonceAuthority>;
+    withdrawAmount: WithdrawNonceAccountInstructionDataArgs['withdrawAmount'];
+};
+
+export function getWithdrawNonceAccountInstruction<
+    TAccountNonceAccount extends string,
+    TAccountRecipientAccount extends string,
+    TAccountRecentBlockhashesSysvar extends string,
+    TAccountRentSysvar extends string,
+    TAccountNonceAuthority extends string,
+    TProgramAddress extends Address = typeof SYSTEM_PROGRAM_ADDRESS,
+>(
+    input: WithdrawNonceAccountInput<
+        TAccountNonceAccount,
+        TAccountRecipientAccount,
+        TAccountRecentBlockhashesSysvar,
+        TAccountRentSysvar,
+        TAccountNonceAuthority
+    >,
+    config?: { programAddress?: TProgramAddress },
+): WithdrawNonceAccountInstruction<
+    TProgramAddress,
+    TAccountNonceAccount,
+    TAccountRecipientAccount,
+    TAccountRecentBlockhashesSysvar,
+    TAccountRentSysvar,
+    TAccountNonceAuthority
+> {
+    // Program address.
+    const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
+
+    // Original accounts.
+    const originalAccounts = {
+        nonceAccount: { value: input.nonceAccount ?? null, isWritable: true },
+        recipientAccount: { value: input.recipientAccount ?? null, isWritable: true },
+        recentBlockhashesSysvar: { value: input.recentBlockhashesSysvar ?? null, isWritable: false },
+        rentSysvar: { value: input.rentSysvar ?? null, isWritable: false },
+        nonceAuthority: { value: input.nonceAuthority ?? null, isWritable: false },
+    };
+    const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+    // Original args.
+    const args = { ...input };
+
+    // Resolve default values.
+    if (!accounts.recentBlockhashesSysvar.value) {
+        accounts.recentBlockhashesSysvar.value =
+            'SysvarRecentB1ockHashes11111111111111111111' as Address<'SysvarRecentB1ockHashes11111111111111111111'>;
+    }
+    if (!accounts.rentSysvar.value) {
+        accounts.rentSysvar.value =
+            'SysvarRent111111111111111111111111111111111' as Address<'SysvarRent111111111111111111111111111111111'>;
+    }
+
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'omitted');
+    return Object.freeze({
+        accounts: [
+            getAccountMeta('nonceAccount', accounts.nonceAccount),
+            getAccountMeta('recipientAccount', accounts.recipientAccount),
+            getAccountMeta('recentBlockhashesSysvar', accounts.recentBlockhashesSysvar),
+            getAccountMeta('rentSysvar', accounts.rentSysvar),
+            getAccountMeta('nonceAuthority', accounts.nonceAuthority),
+        ],
+        data: getWithdrawNonceAccountInstructionDataEncoder().encode(args as WithdrawNonceAccountInstructionDataArgs),
+        programAddress,
+    } as WithdrawNonceAccountInstruction<
+        TProgramAddress,
+        TAccountNonceAccount,
+        TAccountRecipientAccount,
+        TAccountRecentBlockhashesSysvar,
+        TAccountRentSysvar,
+        TAccountNonceAuthority
+    >);
+}
+
+export type ParsedWithdrawNonceAccountInstruction<
+    TProgram extends string = typeof SYSTEM_PROGRAM_ADDRESS,
+    TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[],
+> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        nonceAccount: TAccountMetas[0];
+        recipientAccount: TAccountMetas[1];
+        recentBlockhashesSysvar: TAccountMetas[2];
+        rentSysvar: TAccountMetas[3];
+        nonceAuthority: TAccountMetas[4];
+    };
+    data: WithdrawNonceAccountInstructionData;
+};
+
+export function parseWithdrawNonceAccountInstruction<
+    TProgram extends string,
+    TAccountMetas extends readonly AccountMeta[],
+>(
+    instruction: Instruction<TProgram> &
+        InstructionWithAccounts<TAccountMetas> &
+        InstructionWithData<ReadonlyUint8Array>,
+): ParsedWithdrawNonceAccountInstruction<TProgram, TAccountMetas> {
+    if (instruction.accounts.length < 5) {
+        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+            actualAccountMetas: instruction.accounts.length,
+            expectedAccountMetas: 5,
+        });
+    }
+    let accountIndex = 0;
+    const getNextAccount = () => {
+        const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+        accountIndex += 1;
+        return accountMeta;
+    };
+    return {
+        programAddress: instruction.programAddress,
+        accounts: {
+            nonceAccount: getNextAccount(),
+            recipientAccount: getNextAccount(),
+            recentBlockhashesSysvar: getNextAccount(),
+            rentSysvar: getNextAccount(),
+            nonceAuthority: getNextAccount(),
+        },
+        data: getWithdrawNonceAccountInstructionDataDecoder().decode(instruction.data),
+    };
+}

package/src/generated/programs/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/programs/system.ts

@@ -0,0 +1,355 @@
+/**
+ * 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 {
+    assertIsInstructionWithAccounts,
+    containsBytes,
+    extendClient,
+    getU32Encoder,
+    SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
+    SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
+    SolanaError,
+    type Address,
+    type ClientWithPayer,
+    type ClientWithRpc,
+    type ClientWithTransactionPlanning,
+    type ClientWithTransactionSending,
+    type GetAccountInfoApi,
+    type GetMultipleAccountsApi,
+    type Instruction,
+    type InstructionWithData,
+    type ReadonlyUint8Array,
+} from '@solana/kit';
+import {
+    addSelfFetchFunctions,
+    addSelfPlanAndSendFunctions,
+    type SelfFetchFunctions,
+    type SelfPlanAndSendFunctions,
+} from '@solana/kit/program-client-core';
+import { getNonceCodec, type Nonce, type NonceArgs } from '../accounts';
+import {
+    getAdvanceNonceAccountInstruction,
+    getAllocateInstruction,
+    getAllocateWithSeedInstruction,
+    getAssignInstruction,
+    getAssignWithSeedInstruction,
+    getAuthorizeNonceAccountInstruction,
+    getCreateAccountInstruction,
+    getCreateAccountWithSeedInstruction,
+    getInitializeNonceAccountInstruction,
+    getTransferSolInstruction,
+    getTransferSolWithSeedInstruction,
+    getUpgradeNonceAccountInstruction,
+    getWithdrawNonceAccountInstruction,
+    parseAdvanceNonceAccountInstruction,
+    parseAllocateInstruction,
+    parseAllocateWithSeedInstruction,
+    parseAssignInstruction,
+    parseAssignWithSeedInstruction,
+    parseAuthorizeNonceAccountInstruction,
+    parseCreateAccountInstruction,
+    parseCreateAccountWithSeedInstruction,
+    parseInitializeNonceAccountInstruction,
+    parseTransferSolInstruction,
+    parseTransferSolWithSeedInstruction,
+    parseUpgradeNonceAccountInstruction,
+    parseWithdrawNonceAccountInstruction,
+    type AdvanceNonceAccountInput,
+    type AllocateInput,
+    type AllocateWithSeedInput,
+    type AssignInput,
+    type AssignWithSeedInput,
+    type AuthorizeNonceAccountInput,
+    type CreateAccountInput,
+    type CreateAccountWithSeedInput,
+    type InitializeNonceAccountInput,
+    type ParsedAdvanceNonceAccountInstruction,
+    type ParsedAllocateInstruction,
+    type ParsedAllocateWithSeedInstruction,
+    type ParsedAssignInstruction,
+    type ParsedAssignWithSeedInstruction,
+    type ParsedAuthorizeNonceAccountInstruction,
+    type ParsedCreateAccountInstruction,
+    type ParsedCreateAccountWithSeedInstruction,
+    type ParsedInitializeNonceAccountInstruction,
+    type ParsedTransferSolInstruction,
+    type ParsedTransferSolWithSeedInstruction,
+    type ParsedUpgradeNonceAccountInstruction,
+    type ParsedWithdrawNonceAccountInstruction,
+    type TransferSolInput,
+    type TransferSolWithSeedInput,
+    type UpgradeNonceAccountInput,
+    type WithdrawNonceAccountInput,
+} from '../instructions';
+
+export const SYSTEM_PROGRAM_ADDRESS = '11111111111111111111111111111111' as Address<'11111111111111111111111111111111'>;
+
+export enum SystemAccount {
+    Nonce,
+}
+
+export enum SystemInstruction {
+    CreateAccount,
+    Assign,
+    TransferSol,
+    CreateAccountWithSeed,
+    AdvanceNonceAccount,
+    WithdrawNonceAccount,
+    InitializeNonceAccount,
+    AuthorizeNonceAccount,
+    Allocate,
+    AllocateWithSeed,
+    AssignWithSeed,
+    TransferSolWithSeed,
+    UpgradeNonceAccount,
+}
+
+export function identifySystemInstruction(
+    instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array,
+): SystemInstruction {
+    const data = 'data' in instruction ? instruction.data : instruction;
+    if (containsBytes(data, getU32Encoder().encode(0), 0)) {
+        return SystemInstruction.CreateAccount;
+    }
+    if (containsBytes(data, getU32Encoder().encode(1), 0)) {
+        return SystemInstruction.Assign;
+    }
+    if (containsBytes(data, getU32Encoder().encode(2), 0)) {
+        return SystemInstruction.TransferSol;
+    }
+    if (containsBytes(data, getU32Encoder().encode(3), 0)) {
+        return SystemInstruction.CreateAccountWithSeed;
+    }
+    if (containsBytes(data, getU32Encoder().encode(4), 0)) {
+        return SystemInstruction.AdvanceNonceAccount;
+    }
+    if (containsBytes(data, getU32Encoder().encode(5), 0)) {
+        return SystemInstruction.WithdrawNonceAccount;
+    }
+    if (containsBytes(data, getU32Encoder().encode(6), 0)) {
+        return SystemInstruction.InitializeNonceAccount;
+    }
+    if (containsBytes(data, getU32Encoder().encode(7), 0)) {
+        return SystemInstruction.AuthorizeNonceAccount;
+    }
+    if (containsBytes(data, getU32Encoder().encode(8), 0)) {
+        return SystemInstruction.Allocate;
+    }
+    if (containsBytes(data, getU32Encoder().encode(9), 0)) {
+        return SystemInstruction.AllocateWithSeed;
+    }
+    if (containsBytes(data, getU32Encoder().encode(10), 0)) {
+        return SystemInstruction.AssignWithSeed;
+    }
+    if (containsBytes(data, getU32Encoder().encode(11), 0)) {
+        return SystemInstruction.TransferSolWithSeed;
+    }
+    if (containsBytes(data, getU32Encoder().encode(12), 0)) {
+        return SystemInstruction.UpgradeNonceAccount;
+    }
+    throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, {
+        instructionData: data,
+        programName: 'system',
+    });
+}
+
+export type ParsedSystemInstruction<TProgram extends string = '11111111111111111111111111111111'> =
+    | ({ instructionType: SystemInstruction.CreateAccount } & ParsedCreateAccountInstruction<TProgram>)
+    | ({ instructionType: SystemInstruction.Assign } & ParsedAssignInstruction<TProgram>)
+    | ({ instructionType: SystemInstruction.TransferSol } & ParsedTransferSolInstruction<TProgram>)
+    | ({ instructionType: SystemInstruction.CreateAccountWithSeed } & ParsedCreateAccountWithSeedInstruction<TProgram>)
+    | ({ instructionType: SystemInstruction.AdvanceNonceAccount } & ParsedAdvanceNonceAccountInstruction<TProgram>)
+    | ({ instructionType: SystemInstruction.WithdrawNonceAccount } & ParsedWithdrawNonceAccountInstruction<TProgram>)
+    | ({
+          instructionType: SystemInstruction.InitializeNonceAccount;
+      } & ParsedInitializeNonceAccountInstruction<TProgram>)
+    | ({ instructionType: SystemInstruction.AuthorizeNonceAccount } & ParsedAuthorizeNonceAccountInstruction<TProgram>)
+    | ({ instructionType: SystemInstruction.Allocate } & ParsedAllocateInstruction<TProgram>)
+    | ({ instructionType: SystemInstruction.AllocateWithSeed } & ParsedAllocateWithSeedInstruction<TProgram>)
+    | ({ instructionType: SystemInstruction.AssignWithSeed } & ParsedAssignWithSeedInstruction<TProgram>)
+    | ({ instructionType: SystemInstruction.TransferSolWithSeed } & ParsedTransferSolWithSeedInstruction<TProgram>)
+    | ({ instructionType: SystemInstruction.UpgradeNonceAccount } & ParsedUpgradeNonceAccountInstruction<TProgram>);
+
+export function parseSystemInstruction<TProgram extends string>(
+    instruction: Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array>,
+): ParsedSystemInstruction<TProgram> {
+    const instructionType = identifySystemInstruction(instruction);
+    switch (instructionType) {
+        case SystemInstruction.CreateAccount: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: SystemInstruction.CreateAccount, ...parseCreateAccountInstruction(instruction) };
+        }
+        case SystemInstruction.Assign: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: SystemInstruction.Assign, ...parseAssignInstruction(instruction) };
+        }
+        case SystemInstruction.TransferSol: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: SystemInstruction.TransferSol, ...parseTransferSolInstruction(instruction) };
+        }
+        case SystemInstruction.CreateAccountWithSeed: {
+            assertIsInstructionWithAccounts(instruction);
+            return {
+                instructionType: SystemInstruction.CreateAccountWithSeed,
+                ...parseCreateAccountWithSeedInstruction(instruction),
+            };
+        }
+        case SystemInstruction.AdvanceNonceAccount: {
+            assertIsInstructionWithAccounts(instruction);
+            return {
+                instructionType: SystemInstruction.AdvanceNonceAccount,
+                ...parseAdvanceNonceAccountInstruction(instruction),
+            };
+        }
+        case SystemInstruction.WithdrawNonceAccount: {
+            assertIsInstructionWithAccounts(instruction);
+            return {
+                instructionType: SystemInstruction.WithdrawNonceAccount,
+                ...parseWithdrawNonceAccountInstruction(instruction),
+            };
+        }
+        case SystemInstruction.InitializeNonceAccount: {
+            assertIsInstructionWithAccounts(instruction);
+            return {
+                instructionType: SystemInstruction.InitializeNonceAccount,
+                ...parseInitializeNonceAccountInstruction(instruction),
+            };
+        }
+        case SystemInstruction.AuthorizeNonceAccount: {
+            assertIsInstructionWithAccounts(instruction);
+            return {
+                instructionType: SystemInstruction.AuthorizeNonceAccount,
+                ...parseAuthorizeNonceAccountInstruction(instruction),
+            };
+        }
+        case SystemInstruction.Allocate: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: SystemInstruction.Allocate, ...parseAllocateInstruction(instruction) };
+        }
+        case SystemInstruction.AllocateWithSeed: {
+            assertIsInstructionWithAccounts(instruction);
+            return {
+                instructionType: SystemInstruction.AllocateWithSeed,
+                ...parseAllocateWithSeedInstruction(instruction),
+            };
+        }
+        case SystemInstruction.AssignWithSeed: {
+            assertIsInstructionWithAccounts(instruction);
+            return {
+                instructionType: SystemInstruction.AssignWithSeed,
+                ...parseAssignWithSeedInstruction(instruction),
+            };
+        }
+        case SystemInstruction.TransferSolWithSeed: {
+            assertIsInstructionWithAccounts(instruction);
+            return {
+                instructionType: SystemInstruction.TransferSolWithSeed,
+                ...parseTransferSolWithSeedInstruction(instruction),
+            };
+        }
+        case SystemInstruction.UpgradeNonceAccount: {
+            assertIsInstructionWithAccounts(instruction);
+            return {
+                instructionType: SystemInstruction.UpgradeNonceAccount,
+                ...parseUpgradeNonceAccountInstruction(instruction),
+            };
+        }
+        default:
+            throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, {
+                instructionType: instructionType as string,
+                programName: 'system',
+            });
+    }
+}
+
+export type SystemPlugin = { accounts: SystemPluginAccounts; instructions: SystemPluginInstructions };
+
+export type SystemPluginAccounts = { nonce: ReturnType<typeof getNonceCodec> & SelfFetchFunctions<NonceArgs, Nonce> };
+
+export type SystemPluginInstructions = {
+    createAccount: (
+        input: MakeOptional<CreateAccountInput, 'payer'>,
+    ) => ReturnType<typeof getCreateAccountInstruction> & SelfPlanAndSendFunctions;
+    assign: (input: AssignInput) => ReturnType<typeof getAssignInstruction> & SelfPlanAndSendFunctions;
+    transferSol: (input: TransferSolInput) => ReturnType<typeof getTransferSolInstruction> & SelfPlanAndSendFunctions;
+    createAccountWithSeed: (
+        input: MakeOptional<CreateAccountWithSeedInput, 'payer'>,
+    ) => ReturnType<typeof getCreateAccountWithSeedInstruction> & SelfPlanAndSendFunctions;
+    advanceNonceAccount: (
+        input: AdvanceNonceAccountInput,
+    ) => ReturnType<typeof getAdvanceNonceAccountInstruction> & SelfPlanAndSendFunctions;
+    withdrawNonceAccount: (
+        input: WithdrawNonceAccountInput,
+    ) => ReturnType<typeof getWithdrawNonceAccountInstruction> & SelfPlanAndSendFunctions;
+    initializeNonceAccount: (
+        input: InitializeNonceAccountInput,
+    ) => ReturnType<typeof getInitializeNonceAccountInstruction> & SelfPlanAndSendFunctions;
+    authorizeNonceAccount: (
+        input: AuthorizeNonceAccountInput,
+    ) => ReturnType<typeof getAuthorizeNonceAccountInstruction> & SelfPlanAndSendFunctions;
+    allocate: (input: AllocateInput) => ReturnType<typeof getAllocateInstruction> & SelfPlanAndSendFunctions;
+    allocateWithSeed: (
+        input: AllocateWithSeedInput,
+    ) => ReturnType<typeof getAllocateWithSeedInstruction> & SelfPlanAndSendFunctions;
+    assignWithSeed: (
+        input: AssignWithSeedInput,
+    ) => ReturnType<typeof getAssignWithSeedInstruction> & SelfPlanAndSendFunctions;
+    transferSolWithSeed: (
+        input: TransferSolWithSeedInput,
+    ) => ReturnType<typeof getTransferSolWithSeedInstruction> & SelfPlanAndSendFunctions;
+    upgradeNonceAccount: (
+        input: UpgradeNonceAccountInput,
+    ) => ReturnType<typeof getUpgradeNonceAccountInstruction> & SelfPlanAndSendFunctions;
+};
+
+export type SystemPluginRequirements = ClientWithRpc<GetAccountInfoApi & GetMultipleAccountsApi> &
+    ClientWithPayer &
+    ClientWithTransactionPlanning &
+    ClientWithTransactionSending;
+
+export function systemProgram() {
+    return <T extends SystemPluginRequirements>(client: T): Omit<T, 'system'> & { system: SystemPlugin } => {
+        return extendClient(client, {
+            system: <SystemPlugin>{
+                accounts: { nonce: addSelfFetchFunctions(client, getNonceCodec()) },
+                instructions: {
+                    createAccount: input =>
+                        addSelfPlanAndSendFunctions(
+                            client,
+                            getCreateAccountInstruction({ ...input, payer: input.payer ?? client.payer }),
+                        ),
+                    assign: input => addSelfPlanAndSendFunctions(client, getAssignInstruction(input)),
+                    transferSol: input => addSelfPlanAndSendFunctions(client, getTransferSolInstruction(input)),
+                    createAccountWithSeed: input =>
+                        addSelfPlanAndSendFunctions(
+                            client,
+                            getCreateAccountWithSeedInstruction({ ...input, payer: input.payer ?? client.payer }),
+                        ),
+                    advanceNonceAccount: input =>
+                        addSelfPlanAndSendFunctions(client, getAdvanceNonceAccountInstruction(input)),
+                    withdrawNonceAccount: input =>
+                        addSelfPlanAndSendFunctions(client, getWithdrawNonceAccountInstruction(input)),
+                    initializeNonceAccount: input =>
+                        addSelfPlanAndSendFunctions(client, getInitializeNonceAccountInstruction(input)),
+                    authorizeNonceAccount: input =>
+                        addSelfPlanAndSendFunctions(client, getAuthorizeNonceAccountInstruction(input)),
+                    allocate: input => addSelfPlanAndSendFunctions(client, getAllocateInstruction(input)),
+                    allocateWithSeed: input =>
+                        addSelfPlanAndSendFunctions(client, getAllocateWithSeedInstruction(input)),
+                    assignWithSeed: input => addSelfPlanAndSendFunctions(client, getAssignWithSeedInstruction(input)),
+                    transferSolWithSeed: input =>
+                        addSelfPlanAndSendFunctions(client, getTransferSolWithSeedInstruction(input)),
+                    upgradeNonceAccount: input =>
+                        addSelfPlanAndSendFunctions(client, getUpgradeNonceAccountInstruction(input)),
+                },
+            },
+        });
+    };
+}
+
+type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/src/generated/types/index.ts

@@ -0,0 +1,10 @@
+/**
+ * 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 './nonceState';
+export * from './nonceVersion';

package/src/generated/types/nonceState.ts

@@ -0,0 +1,37 @@
+/**
+ * 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,
+    getEnumDecoder,
+    getEnumEncoder,
+    getU32Decoder,
+    getU32Encoder,
+    type FixedSizeCodec,
+    type FixedSizeDecoder,
+    type FixedSizeEncoder,
+} from '@solana/kit';
+
+export enum NonceState {
+    Uninitialized,
+    Initialized,
+}
+
+export type NonceStateArgs = NonceState;
+
+export function getNonceStateEncoder(): FixedSizeEncoder<NonceStateArgs> {
+    return getEnumEncoder(NonceState, { size: getU32Encoder() });
+}
+
+export function getNonceStateDecoder(): FixedSizeDecoder<NonceState> {
+    return getEnumDecoder(NonceState, { size: getU32Decoder() });
+}
+
+export function getNonceStateCodec(): FixedSizeCodec<NonceStateArgs, NonceState> {
+    return combineCodec(getNonceStateEncoder(), getNonceStateDecoder());
+}

package/src/generated/types/nonceVersion.ts

@@ -0,0 +1,37 @@
+/**
+ * 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,
+    getEnumDecoder,
+    getEnumEncoder,
+    getU32Decoder,
+    getU32Encoder,
+    type FixedSizeCodec,
+    type FixedSizeDecoder,
+    type FixedSizeEncoder,
+} from '@solana/kit';
+
+export enum NonceVersion {
+    Legacy,
+    Current,
+}
+
+export type NonceVersionArgs = NonceVersion;
+
+export function getNonceVersionEncoder(): FixedSizeEncoder<NonceVersionArgs> {
+    return getEnumEncoder(NonceVersion, { size: getU32Encoder() });
+}
+
+export function getNonceVersionDecoder(): FixedSizeDecoder<NonceVersion> {
+    return getEnumDecoder(NonceVersion, { size: getU32Decoder() });
+}
+
+export function getNonceVersionCodec(): FixedSizeCodec<NonceVersionArgs, NonceVersion> {
+    return combineCodec(getNonceVersionEncoder(), getNonceVersionDecoder());
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './generated';