@solana-program/system 0.12.0 → 0.12.2

package/src/generated/instructions/createAccount.ts

@@ -0,0 +1,184 @@
+/**
+ * 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 {
+    BASE_ACCOUNT_SIZE,
+    combineCodec,
+    getAddressDecoder,
+    getAddressEncoder,
+    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 InstructionWithByteDelta,
+    type ResolvedInstructionAccount,
+} from '@solana/kit/program-client-core';
+import { SYSTEM_PROGRAM_ADDRESS } from '../programs';
+
+export const CREATE_ACCOUNT_DISCRIMINATOR = 0;
+
+export function getCreateAccountDiscriminatorBytes(): ReadonlyUint8Array {
+    return getU32Encoder().encode(CREATE_ACCOUNT_DISCRIMINATOR);
+}
+
+export type CreateAccountInstruction<
+    TProgram extends string = typeof SYSTEM_PROGRAM_ADDRESS,
+    TAccountPayer extends string | AccountMeta<string> = string,
+    TAccountNewAccount extends string | AccountMeta<string> = string,
+    TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> &
+    InstructionWithData<ReadonlyUint8Array> &
+    InstructionWithAccounts<
+        [
+            TAccountPayer extends string
+                ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer>
+                : TAccountPayer,
+            TAccountNewAccount extends string
+                ? WritableSignerAccount<TAccountNewAccount> & AccountSignerMeta<TAccountNewAccount>
+                : TAccountNewAccount,
+            ...TRemainingAccounts,
+        ]
+    >;
+
+export type CreateAccountInstructionData = {
+    discriminator: number;
+    lamports: bigint;
+    space: bigint;
+    programAddress: Address;
+};
+
+export type CreateAccountInstructionDataArgs = {
+    lamports: number | bigint;
+    space: number | bigint;
+    programAddress: Address;
+};
+
+export function getCreateAccountInstructionDataEncoder(): FixedSizeEncoder<CreateAccountInstructionDataArgs> {
+    return transformEncoder(
+        getStructEncoder([
+            ['discriminator', getU32Encoder()],
+            ['lamports', getU64Encoder()],
+            ['space', getU64Encoder()],
+            ['programAddress', getAddressEncoder()],
+        ]),
+        value => ({ ...value, discriminator: CREATE_ACCOUNT_DISCRIMINATOR }),
+    );
+}
+
+export function getCreateAccountInstructionDataDecoder(): FixedSizeDecoder<CreateAccountInstructionData> {
+    return getStructDecoder([
+        ['discriminator', getU32Decoder()],
+        ['lamports', getU64Decoder()],
+        ['space', getU64Decoder()],
+        ['programAddress', getAddressDecoder()],
+    ]);
+}
+
+export function getCreateAccountInstructionDataCodec(): FixedSizeCodec<
+    CreateAccountInstructionDataArgs,
+    CreateAccountInstructionData
+> {
+    return combineCodec(getCreateAccountInstructionDataEncoder(), getCreateAccountInstructionDataDecoder());
+}
+
+export type CreateAccountInput<TAccountPayer extends string = string, TAccountNewAccount extends string = string> = {
+    payer: TransactionSigner<TAccountPayer>;
+    newAccount: TransactionSigner<TAccountNewAccount>;
+    lamports: CreateAccountInstructionDataArgs['lamports'];
+    space: CreateAccountInstructionDataArgs['space'];
+    programAddress: CreateAccountInstructionDataArgs['programAddress'];
+};
+
+export function getCreateAccountInstruction<
+    TAccountPayer extends string,
+    TAccountNewAccount extends string,
+    TProgramAddress extends Address = typeof SYSTEM_PROGRAM_ADDRESS,
+>(
+    input: CreateAccountInput<TAccountPayer, TAccountNewAccount>,
+    config?: { programAddress?: TProgramAddress },
+): CreateAccountInstruction<TProgramAddress, TAccountPayer, TAccountNewAccount> & InstructionWithByteDelta {
+    // Program address.
+    const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
+
+    // Original accounts.
+    const originalAccounts = {
+        payer: { value: input.payer ?? null, isWritable: true },
+        newAccount: { value: input.newAccount ?? null, isWritable: true },
+    };
+    const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+    // Original args.
+    const args = { ...input };
+
+    // Bytes created or reallocated by the instruction.
+    const byteDelta: number = [Number(args.space) + BASE_ACCOUNT_SIZE].reduce((a, b) => a + b, 0);
+
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'omitted');
+    return Object.freeze({
+        accounts: [getAccountMeta('payer', accounts.payer), getAccountMeta('newAccount', accounts.newAccount)],
+        byteDelta,
+        data: getCreateAccountInstructionDataEncoder().encode(args as CreateAccountInstructionDataArgs),
+        programAddress,
+    } as CreateAccountInstruction<TProgramAddress, TAccountPayer, TAccountNewAccount> & InstructionWithByteDelta);
+}
+
+export type ParsedCreateAccountInstruction<
+    TProgram extends string = typeof SYSTEM_PROGRAM_ADDRESS,
+    TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[],
+> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        payer: TAccountMetas[0];
+        newAccount: TAccountMetas[1];
+    };
+    data: CreateAccountInstructionData;
+};
+
+export function parseCreateAccountInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(
+    instruction: Instruction<TProgram> &
+        InstructionWithAccounts<TAccountMetas> &
+        InstructionWithData<ReadonlyUint8Array>,
+): ParsedCreateAccountInstruction<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: { payer: getNextAccount(), newAccount: getNextAccount() },
+        data: getCreateAccountInstructionDataDecoder().decode(instruction.data),
+    };
+}

package/src/generated/instructions/createAccountAllowPrefund.ts

@@ -0,0 +1,212 @@
+/**
+ * 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 {
+    BASE_ACCOUNT_SIZE,
+    combineCodec,
+    getAddressDecoder,
+    getAddressEncoder,
+    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 InstructionWithByteDelta,
+    type ResolvedInstructionAccount,
+} from '@solana/kit/program-client-core';
+import { SYSTEM_PROGRAM_ADDRESS } from '../programs';
+
+export const CREATE_ACCOUNT_ALLOW_PREFUND_DISCRIMINATOR = 13;
+
+export function getCreateAccountAllowPrefundDiscriminatorBytes(): ReadonlyUint8Array {
+    return getU32Encoder().encode(CREATE_ACCOUNT_ALLOW_PREFUND_DISCRIMINATOR);
+}
+
+export type CreateAccountAllowPrefundInstruction<
+    TProgram extends string = typeof SYSTEM_PROGRAM_ADDRESS,
+    TAccountNewAccount extends string | AccountMeta<string> = string,
+    TAccountPayer extends string | AccountMeta<string> | undefined = undefined,
+    TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> &
+    InstructionWithData<ReadonlyUint8Array> &
+    InstructionWithAccounts<
+        [
+            TAccountNewAccount extends string
+                ? WritableSignerAccount<TAccountNewAccount> & AccountSignerMeta<TAccountNewAccount>
+                : TAccountNewAccount,
+            ...(TAccountPayer extends undefined
+                ? []
+                : [
+                      TAccountPayer extends string
+                          ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer>
+                          : TAccountPayer,
+                  ]),
+            ...TRemainingAccounts,
+        ]
+    >;
+
+export type CreateAccountAllowPrefundInstructionData = {
+    discriminator: number;
+    lamports: bigint;
+    space: bigint;
+    programAddress: Address;
+};
+
+export type CreateAccountAllowPrefundInstructionDataArgs = {
+    lamports?: number | bigint;
+    space: number | bigint;
+    programAddress: Address;
+};
+
+export function getCreateAccountAllowPrefundInstructionDataEncoder(): FixedSizeEncoder<CreateAccountAllowPrefundInstructionDataArgs> {
+    return transformEncoder(
+        getStructEncoder([
+            ['discriminator', getU32Encoder()],
+            ['lamports', getU64Encoder()],
+            ['space', getU64Encoder()],
+            ['programAddress', getAddressEncoder()],
+        ]),
+        value => ({
+            ...value,
+            discriminator: CREATE_ACCOUNT_ALLOW_PREFUND_DISCRIMINATOR,
+            lamports: value.lamports ?? 0,
+        }),
+    );
+}
+
+export function getCreateAccountAllowPrefundInstructionDataDecoder(): FixedSizeDecoder<CreateAccountAllowPrefundInstructionData> {
+    return getStructDecoder([
+        ['discriminator', getU32Decoder()],
+        ['lamports', getU64Decoder()],
+        ['space', getU64Decoder()],
+        ['programAddress', getAddressDecoder()],
+    ]);
+}
+
+export function getCreateAccountAllowPrefundInstructionDataCodec(): FixedSizeCodec<
+    CreateAccountAllowPrefundInstructionDataArgs,
+    CreateAccountAllowPrefundInstructionData
+> {
+    return combineCodec(
+        getCreateAccountAllowPrefundInstructionDataEncoder(),
+        getCreateAccountAllowPrefundInstructionDataDecoder(),
+    );
+}
+
+export type CreateAccountAllowPrefundInput<
+    TAccountNewAccount extends string = string,
+    TAccountPayer extends string = string,
+> = {
+    newAccount: TransactionSigner<TAccountNewAccount>;
+    payer?: TransactionSigner<TAccountPayer>;
+    lamports?: CreateAccountAllowPrefundInstructionDataArgs['lamports'];
+    space: CreateAccountAllowPrefundInstructionDataArgs['space'];
+    programAddress: CreateAccountAllowPrefundInstructionDataArgs['programAddress'];
+};
+
+export function getCreateAccountAllowPrefundInstruction<
+    TAccountNewAccount extends string,
+    TAccountPayer extends string,
+    TProgramAddress extends Address = typeof SYSTEM_PROGRAM_ADDRESS,
+>(
+    input: CreateAccountAllowPrefundInput<TAccountNewAccount, TAccountPayer>,
+    config?: { programAddress?: TProgramAddress },
+): CreateAccountAllowPrefundInstruction<TProgramAddress, TAccountNewAccount, TAccountPayer> & InstructionWithByteDelta {
+    // Program address.
+    const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
+
+    // Original accounts.
+    const originalAccounts = {
+        newAccount: { value: input.newAccount ?? null, isWritable: true },
+        payer: { value: input.payer ?? null, isWritable: true },
+    };
+    const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+    // Original args.
+    const args = { ...input };
+
+    // Bytes created or reallocated by the instruction.
+    const byteDelta: number = [Number(args.space) + BASE_ACCOUNT_SIZE].reduce((a, b) => a + b, 0);
+
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'omitted');
+    return Object.freeze({
+        accounts: [getAccountMeta('newAccount', accounts.newAccount), getAccountMeta('payer', accounts.payer)].filter(
+            <T>(x: T | undefined): x is T => x !== undefined,
+        ),
+        byteDelta,
+        data: getCreateAccountAllowPrefundInstructionDataEncoder().encode(
+            args as CreateAccountAllowPrefundInstructionDataArgs,
+        ),
+        programAddress,
+    } as CreateAccountAllowPrefundInstruction<TProgramAddress, TAccountNewAccount, TAccountPayer> &
+        InstructionWithByteDelta);
+}
+
+export type ParsedCreateAccountAllowPrefundInstruction<
+    TProgram extends string = typeof SYSTEM_PROGRAM_ADDRESS,
+    TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[],
+> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        newAccount: TAccountMetas[0];
+        payer?: TAccountMetas[1] | undefined;
+    };
+    data: CreateAccountAllowPrefundInstructionData;
+};
+
+export function parseCreateAccountAllowPrefundInstruction<
+    TProgram extends string,
+    TAccountMetas extends readonly AccountMeta[],
+>(
+    instruction: Instruction<TProgram> &
+        InstructionWithAccounts<TAccountMetas> &
+        InstructionWithData<ReadonlyUint8Array>,
+): ParsedCreateAccountAllowPrefundInstruction<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;
+    };
+    let optionalAccountsRemaining = instruction.accounts.length - 1;
+    const getNextOptionalAccount = () => {
+        if (optionalAccountsRemaining === 0) return undefined;
+        optionalAccountsRemaining -= 1;
+        return getNextAccount();
+    };
+    return {
+        programAddress: instruction.programAddress,
+        accounts: { newAccount: getNextAccount(), payer: getNextOptionalAccount() },
+        data: getCreateAccountAllowPrefundInstructionDataDecoder().decode(instruction.data),
+    };
+}

package/src/generated/instructions/createAccountWithSeed.ts

@@ -0,0 +1,221 @@
+/**
+ * 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,
+    type WritableSignerAccount,
+} from '@solana/kit';
+import { getAccountMetaFactory, type ResolvedInstructionAccount } from '@solana/kit/program-client-core';
+import { SYSTEM_PROGRAM_ADDRESS } from '../programs';
+
+export const CREATE_ACCOUNT_WITH_SEED_DISCRIMINATOR = 3;
+
+export function getCreateAccountWithSeedDiscriminatorBytes(): ReadonlyUint8Array {
+    return getU32Encoder().encode(CREATE_ACCOUNT_WITH_SEED_DISCRIMINATOR);
+}
+
+export type CreateAccountWithSeedInstruction<
+    TProgram extends string = typeof SYSTEM_PROGRAM_ADDRESS,
+    TAccountPayer extends string | AccountMeta<string> = string,
+    TAccountNewAccount extends string | AccountMeta<string> = string,
+    TAccountBaseAccount extends string | AccountMeta<string> | undefined = undefined,
+    TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> &
+    InstructionWithData<ReadonlyUint8Array> &
+    InstructionWithAccounts<
+        [
+            TAccountPayer extends string
+                ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer>
+                : TAccountPayer,
+            TAccountNewAccount extends string ? WritableAccount<TAccountNewAccount> : TAccountNewAccount,
+            ...(TAccountBaseAccount extends undefined
+                ? []
+                : [
+                      TAccountBaseAccount extends string
+                          ? ReadonlySignerAccount<TAccountBaseAccount> & AccountSignerMeta<TAccountBaseAccount>
+                          : TAccountBaseAccount,
+                  ]),
+            ...TRemainingAccounts,
+        ]
+    >;
+
+export type CreateAccountWithSeedInstructionData = {
+    discriminator: number;
+    base: Address;
+    seed: string;
+    amount: bigint;
+    space: bigint;
+    programAddress: Address;
+};
+
+export type CreateAccountWithSeedInstructionDataArgs = {
+    base: Address;
+    seed: string;
+    amount: number | bigint;
+    space: number | bigint;
+    programAddress: Address;
+};
+
+export function getCreateAccountWithSeedInstructionDataEncoder(): Encoder<CreateAccountWithSeedInstructionDataArgs> {
+    return transformEncoder(
+        getStructEncoder([
+            ['discriminator', getU32Encoder()],
+            ['base', getAddressEncoder()],
+            ['seed', addEncoderSizePrefix(getUtf8Encoder(), getU64Encoder())],
+            ['amount', getU64Encoder()],
+            ['space', getU64Encoder()],
+            ['programAddress', getAddressEncoder()],
+        ]),
+        value => ({ ...value, discriminator: CREATE_ACCOUNT_WITH_SEED_DISCRIMINATOR }),
+    );
+}
+
+export function getCreateAccountWithSeedInstructionDataDecoder(): Decoder<CreateAccountWithSeedInstructionData> {
+    return getStructDecoder([
+        ['discriminator', getU32Decoder()],
+        ['base', getAddressDecoder()],
+        ['seed', addDecoderSizePrefix(getUtf8Decoder(), getU64Decoder())],
+        ['amount', getU64Decoder()],
+        ['space', getU64Decoder()],
+        ['programAddress', getAddressDecoder()],
+    ]);
+}
+
+export function getCreateAccountWithSeedInstructionDataCodec(): Codec<
+    CreateAccountWithSeedInstructionDataArgs,
+    CreateAccountWithSeedInstructionData
+> {
+    return combineCodec(
+        getCreateAccountWithSeedInstructionDataEncoder(),
+        getCreateAccountWithSeedInstructionDataDecoder(),
+    );
+}
+
+export type CreateAccountWithSeedInput<
+    TAccountPayer extends string = string,
+    TAccountNewAccount extends string = string,
+    TAccountBaseAccount extends string = string,
+> = {
+    payer: TransactionSigner<TAccountPayer>;
+    newAccount: Address<TAccountNewAccount>;
+    baseAccount?: TransactionSigner<TAccountBaseAccount>;
+    base: CreateAccountWithSeedInstructionDataArgs['base'];
+    seed: CreateAccountWithSeedInstructionDataArgs['seed'];
+    amount: CreateAccountWithSeedInstructionDataArgs['amount'];
+    space: CreateAccountWithSeedInstructionDataArgs['space'];
+    programAddress: CreateAccountWithSeedInstructionDataArgs['programAddress'];
+};
+
+export function getCreateAccountWithSeedInstruction<
+    TAccountPayer extends string,
+    TAccountNewAccount extends string,
+    TAccountBaseAccount extends string,
+    TProgramAddress extends Address = typeof SYSTEM_PROGRAM_ADDRESS,
+>(
+    input: CreateAccountWithSeedInput<TAccountPayer, TAccountNewAccount, TAccountBaseAccount>,
+    config?: { programAddress?: TProgramAddress },
+): CreateAccountWithSeedInstruction<TProgramAddress, TAccountPayer, TAccountNewAccount, TAccountBaseAccount> {
+    // Program address.
+    const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
+
+    // Original accounts.
+    const originalAccounts = {
+        payer: { value: input.payer ?? null, isWritable: true },
+        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('payer', accounts.payer),
+            getAccountMeta('newAccount', accounts.newAccount),
+            getAccountMeta('baseAccount', accounts.baseAccount),
+        ].filter(<T>(x: T | undefined): x is T => x !== undefined),
+        data: getCreateAccountWithSeedInstructionDataEncoder().encode(args as CreateAccountWithSeedInstructionDataArgs),
+        programAddress,
+    } as CreateAccountWithSeedInstruction<TProgramAddress, TAccountPayer, TAccountNewAccount, TAccountBaseAccount>);
+}
+
+export type ParsedCreateAccountWithSeedInstruction<
+    TProgram extends string = typeof SYSTEM_PROGRAM_ADDRESS,
+    TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[],
+> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        payer: TAccountMetas[0];
+        newAccount: TAccountMetas[1];
+        baseAccount?: TAccountMetas[2] | undefined;
+    };
+    data: CreateAccountWithSeedInstructionData;
+};
+
+export function parseCreateAccountWithSeedInstruction<
+    TProgram extends string,
+    TAccountMetas extends readonly AccountMeta[],
+>(
+    instruction: Instruction<TProgram> &
+        InstructionWithAccounts<TAccountMetas> &
+        InstructionWithData<ReadonlyUint8Array>,
+): ParsedCreateAccountWithSeedInstruction<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;
+    };
+    let optionalAccountsRemaining = instruction.accounts.length - 2;
+    const getNextOptionalAccount = () => {
+        if (optionalAccountsRemaining === 0) return undefined;
+        optionalAccountsRemaining -= 1;
+        return getNextAccount();
+    };
+    return {
+        programAddress: instruction.programAddress,
+        accounts: { payer: getNextAccount(), newAccount: getNextAccount(), baseAccount: getNextOptionalAccount() },
+        data: getCreateAccountWithSeedInstructionDataDecoder().decode(instruction.data),
+    };
+}

package/src/generated/instructions/index.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 './advanceNonceAccount';
+export * from './allocate';
+export * from './allocateWithSeed';
+export * from './assign';
+export * from './assignWithSeed';
+export * from './authorizeNonceAccount';
+export * from './createAccount';
+export * from './createAccountAllowPrefund';
+export * from './createAccountWithSeed';
+export * from './initializeNonceAccount';
+export * from './transferSol';
+export * from './transferSolWithSeed';
+export * from './upgradeNonceAccount';
+export * from './withdrawNonceAccount';