@solana-program/system 0.14.1 → 0.16.0

package/src/generated/instructions/upgradeNonceAccount.ts

@@ -26,7 +26,13 @@ import {
     type ReadonlyUint8Array,
     type WritableAccount,
 } from '@solana/kit';
-import { getAccountMetaFactory, type ResolvedInstructionAccount } from '@solana/kit/program-client-core';
+import {
+    getAccountMetaFactory,
+    type InstructionAccountInput,
+    type InstructionAccountInputAddress,
+    type ResolvedInstructionAccount,
+    type ResolvedInstructionAccountMeta,
+} from '@solana/kit/program-client-core';
 import { SYSTEM_PROGRAM_ADDRESS } from '../programs';
 
 export const UPGRADE_NONCE_ACCOUNT_DISCRIMINATOR = 12;
@@ -70,30 +76,39 @@ export function getUpgradeNonceAccountInstructionDataCodec(): FixedSizeCodec<
     return combineCodec(getUpgradeNonceAccountInstructionDataEncoder(), getUpgradeNonceAccountInstructionDataDecoder());
 }
 
-export type UpgradeNonceAccountInput<TAccountNonceAccount extends string = string> = {
-    nonceAccount: Address<TAccountNonceAccount>;
+export type UpgradeNonceAccountInput<TAccountNonceAccount extends InstructionAccountInput = InstructionAccountInput> = {
+    nonceAccount: TAccountNonceAccount;
 };
 
 export function getUpgradeNonceAccountInstruction<
-    TAccountNonceAccount extends string,
+    TAccountNonceAccount extends InstructionAccountInput,
     TProgramAddress extends Address = typeof SYSTEM_PROGRAM_ADDRESS,
 >(
     input: UpgradeNonceAccountInput<TAccountNonceAccount>,
-    config?: { programAddress?: TProgramAddress },
-): UpgradeNonceAccountInstruction<TProgramAddress, TAccountNonceAccount> {
+    config?: { programAddress?: TProgramAddress | { readonly address: TProgramAddress } },
+): UpgradeNonceAccountInstruction<
+    TProgramAddress,
+    ResolvedInstructionAccountMeta<TAccountNonceAccount, InstructionAccountInputAddress<TAccountNonceAccount>>
+> {
     // Program address.
-    const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
+    const programAddressInput = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
+    const programAddress = typeof programAddressInput === 'string' ? programAddressInput : programAddressInput.address;
+
+    // Account meta helper.
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'omitted');
 
     // Original accounts.
-    const originalAccounts = { nonceAccount: { value: input.nonceAccount ?? null, isWritable: true } };
+    const originalAccounts = { nonceAccount: { value: input.nonceAccount ?? null, isSigner: false, isWritable: true } };
     const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
 
-    const getAccountMeta = getAccountMetaFactory(programAddress, 'omitted');
     return Object.freeze({
         accounts: [getAccountMeta('nonceAccount', accounts.nonceAccount)],
         data: getUpgradeNonceAccountInstructionDataEncoder().encode({}),
         programAddress,
-    } as UpgradeNonceAccountInstruction<TProgramAddress, TAccountNonceAccount>);
+    } as UpgradeNonceAccountInstruction<
+        TProgramAddress,
+        ResolvedInstructionAccountMeta<TAccountNonceAccount, InstructionAccountInputAddress<TAccountNonceAccount>>
+    >);
 }
 
 export type ParsedUpgradeNonceAccountInstruction<

package/src/generated/instructions/withdrawNonceAccount.ts

@@ -29,10 +29,16 @@ import {
     type ReadonlyAccount,
     type ReadonlySignerAccount,
     type ReadonlyUint8Array,
-    type TransactionSigner,
     type WritableAccount,
 } from '@solana/kit';
-import { getAccountMetaFactory, type ResolvedInstructionAccount } from '@solana/kit/program-client-core';
+import {
+    getAccountMetaFactory,
+    type InstructionAccountInput,
+    type InstructionAccountInputAddress,
+    type InstructionSignerInput,
+    type ResolvedInstructionAccount,
+    type ResolvedInstructionAccountMeta,
+} from '@solana/kit/program-client-core';
 import { SYSTEM_PROGRAM_ADDRESS } from '../programs';
 
 export const WITHDRAW_NONCE_ACCOUNT_DISCRIMINATOR = 5;
@@ -101,26 +107,26 @@ export function getWithdrawNonceAccountInstructionDataCodec(): FixedSizeCodec<
 }
 
 export type WithdrawNonceAccountInput<
-    TAccountNonceAccount extends string = string,
-    TAccountRecipientAccount extends string = string,
-    TAccountRecentBlockhashesSysvar extends string = string,
-    TAccountRentSysvar extends string = string,
-    TAccountNonceAuthority extends string = string,
+    TAccountNonceAccount extends InstructionAccountInput = InstructionAccountInput,
+    TAccountRecipientAccount extends InstructionAccountInput = InstructionAccountInput,
+    TAccountRecentBlockhashesSysvar extends InstructionAccountInput = InstructionAccountInput,
+    TAccountRentSysvar extends InstructionAccountInput = InstructionAccountInput,
+    TAccountNonceAuthority extends InstructionSignerInput = InstructionSignerInput,
 > = {
-    nonceAccount: Address<TAccountNonceAccount>;
-    recipientAccount: Address<TAccountRecipientAccount>;
-    recentBlockhashesSysvar?: Address<TAccountRecentBlockhashesSysvar>;
-    rentSysvar?: Address<TAccountRentSysvar>;
-    nonceAuthority: TransactionSigner<TAccountNonceAuthority>;
+    nonceAccount: TAccountNonceAccount;
+    recipientAccount: TAccountRecipientAccount;
+    recentBlockhashesSysvar?: TAccountRecentBlockhashesSysvar;
+    rentSysvar?: TAccountRentSysvar;
+    nonceAuthority: TAccountNonceAuthority;
     withdrawAmount: WithdrawNonceAccountInstructionDataArgs['withdrawAmount'];
 };
 
 export function getWithdrawNonceAccountInstruction<
-    TAccountNonceAccount extends string,
-    TAccountRecipientAccount extends string,
-    TAccountRecentBlockhashesSysvar extends string,
-    TAccountRentSysvar extends string,
-    TAccountNonceAuthority extends string,
+    TAccountNonceAccount extends InstructionAccountInput,
+    TAccountRecipientAccount extends InstructionAccountInput,
+    TAccountRecentBlockhashesSysvar extends InstructionAccountInput,
+    TAccountRentSysvar extends InstructionAccountInput,
+    TAccountNonceAuthority extends InstructionSignerInput,
     TProgramAddress extends Address = typeof SYSTEM_PROGRAM_ADDRESS,
 >(
     input: WithdrawNonceAccountInput<
@@ -130,25 +136,32 @@ export function getWithdrawNonceAccountInstruction<
         TAccountRentSysvar,
         TAccountNonceAuthority
     >,
-    config?: { programAddress?: TProgramAddress },
+    config?: { programAddress?: TProgramAddress | { readonly address: TProgramAddress } },
 ): WithdrawNonceAccountInstruction<
     TProgramAddress,
-    TAccountNonceAccount,
-    TAccountRecipientAccount,
-    TAccountRecentBlockhashesSysvar,
-    TAccountRentSysvar,
-    TAccountNonceAuthority
+    ResolvedInstructionAccountMeta<TAccountNonceAccount, InstructionAccountInputAddress<TAccountNonceAccount>>,
+    ResolvedInstructionAccountMeta<TAccountRecipientAccount, InstructionAccountInputAddress<TAccountRecipientAccount>>,
+    ResolvedInstructionAccountMeta<
+        TAccountRecentBlockhashesSysvar,
+        InstructionAccountInputAddress<TAccountRecentBlockhashesSysvar>
+    >,
+    ResolvedInstructionAccountMeta<TAccountRentSysvar, InstructionAccountInputAddress<TAccountRentSysvar>>,
+    ResolvedInstructionAccountMeta<TAccountNonceAuthority, InstructionAccountInputAddress<TAccountNonceAuthority>>
 > {
     // Program address.
-    const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
+    const programAddressInput = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
+    const programAddress = typeof programAddressInput === 'string' ? programAddressInput : programAddressInput.address;
+
+    // Account meta helper.
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'omitted');
 
     // 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 },
+        nonceAccount: { value: input.nonceAccount ?? null, isSigner: false, isWritable: true },
+        recipientAccount: { value: input.recipientAccount ?? null, isSigner: false, isWritable: true },
+        recentBlockhashesSysvar: { value: input.recentBlockhashesSysvar ?? null, isSigner: false, isWritable: false },
+        rentSysvar: { value: input.rentSysvar ?? null, isSigner: false, isWritable: false },
+        nonceAuthority: { value: input.nonceAuthority ?? null, isSigner: true, isWritable: false },
     };
     const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
 
@@ -165,7 +178,6 @@ export function getWithdrawNonceAccountInstruction<
             'SysvarRent111111111111111111111111111111111' as Address<'SysvarRent111111111111111111111111111111111'>;
     }
 
-    const getAccountMeta = getAccountMetaFactory(programAddress, 'omitted');
     return Object.freeze({
         accounts: [
             getAccountMeta('nonceAccount', accounts.nonceAccount),
@@ -178,11 +190,17 @@ export function getWithdrawNonceAccountInstruction<
         programAddress,
     } as WithdrawNonceAccountInstruction<
         TProgramAddress,
-        TAccountNonceAccount,
-        TAccountRecipientAccount,
-        TAccountRecentBlockhashesSysvar,
-        TAccountRentSysvar,
-        TAccountNonceAuthority
+        ResolvedInstructionAccountMeta<TAccountNonceAccount, InstructionAccountInputAddress<TAccountNonceAccount>>,
+        ResolvedInstructionAccountMeta<
+            TAccountRecipientAccount,
+            InstructionAccountInputAddress<TAccountRecipientAccount>
+        >,
+        ResolvedInstructionAccountMeta<
+            TAccountRecentBlockhashesSysvar,
+            InstructionAccountInputAddress<TAccountRecentBlockhashesSysvar>
+        >,
+        ResolvedInstructionAccountMeta<TAccountRentSysvar, InstructionAccountInputAddress<TAccountRentSysvar>>,
+        ResolvedInstructionAccountMeta<TAccountNonceAuthority, InstructionAccountInputAddress<TAccountNonceAuthority>>
     >);
 }
 

package/src/generated/programs/system.ts

@@ -22,6 +22,7 @@ import {
     type ExtendedClient,
     type GetAccountInfoApi,
     type GetMultipleAccountsApi,
+    type HasAddress,
     type Instruction,
     type InstructionWithData,
     type ReadonlyUint8Array,
@@ -298,39 +299,59 @@ export type SystemPluginAccounts = { nonce: ReturnType<typeof getNonceCodec> & S
 export type SystemPluginInstructions = {
     createAccount: (
         input: MakeOptional<CreateAccountInput, 'payer'>,
+        config?: { programAddress?: Address | HasAddress },
     ) => ReturnType<typeof getCreateAccountInstruction> & SelfPlanAndSendFunctions;
-    assign: (input: AssignInput) => ReturnType<typeof getAssignInstruction> & SelfPlanAndSendFunctions;
-    transferSol: (input: TransferSolInput) => ReturnType<typeof getTransferSolInstruction> & SelfPlanAndSendFunctions;
+    assign: (
+        input: AssignInput,
+        config?: { programAddress?: Address | HasAddress },
+    ) => ReturnType<typeof getAssignInstruction> & SelfPlanAndSendFunctions;
+    transferSol: (
+        input: TransferSolInput,
+        config?: { programAddress?: Address | HasAddress },
+    ) => ReturnType<typeof getTransferSolInstruction> & SelfPlanAndSendFunctions;
     createAccountWithSeed: (
         input: MakeOptional<CreateAccountWithSeedInput, 'payer'>,
+        config?: { programAddress?: Address | HasAddress },
     ) => ReturnType<typeof getCreateAccountWithSeedInstruction> & SelfPlanAndSendFunctions;
     advanceNonceAccount: (
         input: AdvanceNonceAccountInput,
+        config?: { programAddress?: Address | HasAddress },
     ) => ReturnType<typeof getAdvanceNonceAccountInstruction> & SelfPlanAndSendFunctions;
     withdrawNonceAccount: (
         input: WithdrawNonceAccountInput,
+        config?: { programAddress?: Address | HasAddress },
     ) => ReturnType<typeof getWithdrawNonceAccountInstruction> & SelfPlanAndSendFunctions;
     initializeNonceAccount: (
         input: InitializeNonceAccountInput,
+        config?: { programAddress?: Address | HasAddress },
     ) => ReturnType<typeof getInitializeNonceAccountInstruction> & SelfPlanAndSendFunctions;
     authorizeNonceAccount: (
         input: AuthorizeNonceAccountInput,
+        config?: { programAddress?: Address | HasAddress },
     ) => ReturnType<typeof getAuthorizeNonceAccountInstruction> & SelfPlanAndSendFunctions;
-    allocate: (input: AllocateInput) => ReturnType<typeof getAllocateInstruction> & SelfPlanAndSendFunctions;
+    allocate: (
+        input: AllocateInput,
+        config?: { programAddress?: Address | HasAddress },
+    ) => ReturnType<typeof getAllocateInstruction> & SelfPlanAndSendFunctions;
     allocateWithSeed: (
         input: AllocateWithSeedInput,
+        config?: { programAddress?: Address | HasAddress },
     ) => ReturnType<typeof getAllocateWithSeedInstruction> & SelfPlanAndSendFunctions;
     assignWithSeed: (
         input: AssignWithSeedInput,
+        config?: { programAddress?: Address | HasAddress },
     ) => ReturnType<typeof getAssignWithSeedInstruction> & SelfPlanAndSendFunctions;
     transferSolWithSeed: (
         input: TransferSolWithSeedInput,
+        config?: { programAddress?: Address | HasAddress },
     ) => ReturnType<typeof getTransferSolWithSeedInstruction> & SelfPlanAndSendFunctions;
     upgradeNonceAccount: (
         input: UpgradeNonceAccountInput,
+        config?: { programAddress?: Address | HasAddress },
     ) => ReturnType<typeof getUpgradeNonceAccountInstruction> & SelfPlanAndSendFunctions;
     createAccountAllowPrefund: (
         input: CreateAccountAllowPrefundInput,
+        config?: { programAddress?: Address | HasAddress },
     ) => ReturnType<typeof getCreateAccountAllowPrefundInstruction> & SelfPlanAndSendFunctions;
 };
 
@@ -339,42 +360,112 @@ export type SystemPluginRequirements = ClientWithRpc<GetAccountInfoApi & GetMult
     ClientWithTransactionPlanning &
     ClientWithTransactionSending;
 
-export function systemProgram() {
+export function systemProgram(config: { programAddress?: Address | HasAddress } = {}) {
     return <T extends SystemPluginRequirements>(client: T): ExtendedClient<T, { system: SystemPlugin }> => {
         return extendClient(client, {
             system: <SystemPlugin>{
                 accounts: { nonce: addSelfFetchFunctions(client, getNonceCodec()) },
                 instructions: {
-                    createAccount: input =>
+                    createAccount: (input, instructionConfig) =>
                         addSelfPlanAndSendFunctions(
                             client,
-                            getCreateAccountInstruction({ ...input, payer: input.payer ?? client.payer }),
+                            getCreateAccountInstruction(
+                                { ...input, payer: input.payer ?? client.payer },
+                                { programAddress: instructionConfig?.programAddress ?? config.programAddress },
+                            ),
                         ),
-                    assign: input => addSelfPlanAndSendFunctions(client, getAssignInstruction(input)),
-                    transferSol: input => addSelfPlanAndSendFunctions(client, getTransferSolInstruction(input)),
-                    createAccountWithSeed: input =>
+                    assign: (input, instructionConfig) =>
                         addSelfPlanAndSendFunctions(
                             client,
-                            getCreateAccountWithSeedInstruction({ ...input, payer: input.payer ?? client.payer }),
+                            getAssignInstruction(input, {
+                                programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                            }),
+                        ),
+                    transferSol: (input, instructionConfig) =>
+                        addSelfPlanAndSendFunctions(
+                            client,
+                            getTransferSolInstruction(input, {
+                                programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                            }),
+                        ),
+                    createAccountWithSeed: (input, instructionConfig) =>
+                        addSelfPlanAndSendFunctions(
+                            client,
+                            getCreateAccountWithSeedInstruction(
+                                { ...input, payer: input.payer ?? client.payer },
+                                { programAddress: instructionConfig?.programAddress ?? config.programAddress },
+                            ),
+                        ),
+                    advanceNonceAccount: (input, instructionConfig) =>
+                        addSelfPlanAndSendFunctions(
+                            client,
+                            getAdvanceNonceAccountInstruction(input, {
+                                programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                            }),
+                        ),
+                    withdrawNonceAccount: (input, instructionConfig) =>
+                        addSelfPlanAndSendFunctions(
+                            client,
+                            getWithdrawNonceAccountInstruction(input, {
+                                programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                            }),
+                        ),
+                    initializeNonceAccount: (input, instructionConfig) =>
+                        addSelfPlanAndSendFunctions(
+                            client,
+                            getInitializeNonceAccountInstruction(input, {
+                                programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                            }),
+                        ),
+                    authorizeNonceAccount: (input, instructionConfig) =>
+                        addSelfPlanAndSendFunctions(
+                            client,
+                            getAuthorizeNonceAccountInstruction(input, {
+                                programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                            }),
+                        ),
+                    allocate: (input, instructionConfig) =>
+                        addSelfPlanAndSendFunctions(
+                            client,
+                            getAllocateInstruction(input, {
+                                programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                            }),
+                        ),
+                    allocateWithSeed: (input, instructionConfig) =>
+                        addSelfPlanAndSendFunctions(
+                            client,
+                            getAllocateWithSeedInstruction(input, {
+                                programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                            }),
+                        ),
+                    assignWithSeed: (input, instructionConfig) =>
+                        addSelfPlanAndSendFunctions(
+                            client,
+                            getAssignWithSeedInstruction(input, {
+                                programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                            }),
+                        ),
+                    transferSolWithSeed: (input, instructionConfig) =>
+                        addSelfPlanAndSendFunctions(
+                            client,
+                            getTransferSolWithSeedInstruction(input, {
+                                programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                            }),
+                        ),
+                    upgradeNonceAccount: (input, instructionConfig) =>
+                        addSelfPlanAndSendFunctions(
+                            client,
+                            getUpgradeNonceAccountInstruction(input, {
+                                programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                            }),
+                        ),
+                    createAccountAllowPrefund: (input, instructionConfig) =>
+                        addSelfPlanAndSendFunctions(
+                            client,
+                            getCreateAccountAllowPrefundInstruction(input, {
+                                programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                            }),
                         ),
-                    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)),
-                    createAccountAllowPrefund: input =>
-                        addSelfPlanAndSendFunctions(client, getCreateAccountAllowPrefundInstruction(input)),
                 },
                 identifyInstruction: identifySystemInstruction,
                 parseInstruction: parseSystemInstruction,