@solana-program/system 0.10.0 → 0.12.0

package/dist/src/index.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var kit = require('@solana/kit');
+var programClientCore = require('@solana/kit/program-client-core');
 
 // src/generated/accounts/nonce.ts
 var NonceState = /* @__PURE__ */ ((NonceState2) => {
@@ -55,10 +56,7 @@ function getNonceCodec() {
   return kit.combineCodec(getNonceEncoder(), getNonceDecoder());
 }
 function decodeNonce(encodedAccount) {
-  return kit.decodeAccount(
-    encodedAccount,
-    getNonceDecoder()
-  );
+  return kit.decodeAccount(encodedAccount, getNonceDecoder());
 }
 async function fetchNonce(rpc, address, config) {
   const maybeAccount = await fetchMaybeNonce(rpc, address, config);
@@ -81,183 +79,39 @@ async function fetchAllMaybeNonce(rpc, addresses, config) {
 function getNonceSize() {
   return 80;
 }
-var SYSTEM_PROGRAM_ADDRESS = "11111111111111111111111111111111";
-var SystemAccount = /* @__PURE__ */ ((SystemAccount2) => {
-  SystemAccount2[SystemAccount2["Nonce"] = 0] = "Nonce";
-  return SystemAccount2;
-})(SystemAccount || {});
-var SystemInstruction = /* @__PURE__ */ ((SystemInstruction2) => {
-  SystemInstruction2[SystemInstruction2["CreateAccount"] = 0] = "CreateAccount";
-  SystemInstruction2[SystemInstruction2["Assign"] = 1] = "Assign";
-  SystemInstruction2[SystemInstruction2["TransferSol"] = 2] = "TransferSol";
-  SystemInstruction2[SystemInstruction2["CreateAccountWithSeed"] = 3] = "CreateAccountWithSeed";
-  SystemInstruction2[SystemInstruction2["AdvanceNonceAccount"] = 4] = "AdvanceNonceAccount";
-  SystemInstruction2[SystemInstruction2["WithdrawNonceAccount"] = 5] = "WithdrawNonceAccount";
-  SystemInstruction2[SystemInstruction2["InitializeNonceAccount"] = 6] = "InitializeNonceAccount";
-  SystemInstruction2[SystemInstruction2["AuthorizeNonceAccount"] = 7] = "AuthorizeNonceAccount";
-  SystemInstruction2[SystemInstruction2["Allocate"] = 8] = "Allocate";
-  SystemInstruction2[SystemInstruction2["AllocateWithSeed"] = 9] = "AllocateWithSeed";
-  SystemInstruction2[SystemInstruction2["AssignWithSeed"] = 10] = "AssignWithSeed";
-  SystemInstruction2[SystemInstruction2["TransferSolWithSeed"] = 11] = "TransferSolWithSeed";
-  SystemInstruction2[SystemInstruction2["UpgradeNonceAccount"] = 12] = "UpgradeNonceAccount";
-  return SystemInstruction2;
-})(SystemInstruction || {});
-function identifySystemInstruction(instruction) {
-  const data = "data" in instruction ? instruction.data : instruction;
-  if (kit.containsBytes(data, kit.getU32Encoder().encode(0), 0)) {
-    return 0 /* CreateAccount */;
-  }
-  if (kit.containsBytes(data, kit.getU32Encoder().encode(1), 0)) {
-    return 1 /* Assign */;
-  }
-  if (kit.containsBytes(data, kit.getU32Encoder().encode(2), 0)) {
-    return 2 /* TransferSol */;
-  }
-  if (kit.containsBytes(data, kit.getU32Encoder().encode(3), 0)) {
-    return 3 /* CreateAccountWithSeed */;
-  }
-  if (kit.containsBytes(data, kit.getU32Encoder().encode(4), 0)) {
-    return 4 /* AdvanceNonceAccount */;
-  }
-  if (kit.containsBytes(data, kit.getU32Encoder().encode(5), 0)) {
-    return 5 /* WithdrawNonceAccount */;
-  }
-  if (kit.containsBytes(data, kit.getU32Encoder().encode(6), 0)) {
-    return 6 /* InitializeNonceAccount */;
-  }
-  if (kit.containsBytes(data, kit.getU32Encoder().encode(7), 0)) {
-    return 7 /* AuthorizeNonceAccount */;
-  }
-  if (kit.containsBytes(data, kit.getU32Encoder().encode(8), 0)) {
-    return 8 /* Allocate */;
-  }
-  if (kit.containsBytes(data, kit.getU32Encoder().encode(9), 0)) {
-    return 9 /* AllocateWithSeed */;
-  }
-  if (kit.containsBytes(data, kit.getU32Encoder().encode(10), 0)) {
-    return 10 /* AssignWithSeed */;
-  }
-  if (kit.containsBytes(data, kit.getU32Encoder().encode(11), 0)) {
-    return 11 /* TransferSolWithSeed */;
-  }
-  if (kit.containsBytes(data, kit.getU32Encoder().encode(12), 0)) {
-    return 12 /* UpgradeNonceAccount */;
-  }
-  throw new Error(
-    "The provided instruction could not be identified as a system instruction."
-  );
-}
-
-// src/generated/errors/system.ts
-var SYSTEM_ERROR__ACCOUNT_ALREADY_IN_USE = 0;
-var SYSTEM_ERROR__RESULT_WITH_NEGATIVE_LAMPORTS = 1;
-var SYSTEM_ERROR__INVALID_PROGRAM_ID = 2;
-var SYSTEM_ERROR__INVALID_ACCOUNT_DATA_LENGTH = 3;
-var SYSTEM_ERROR__MAX_SEED_LENGTH_EXCEEDED = 4;
-var SYSTEM_ERROR__ADDRESS_WITH_SEED_MISMATCH = 5;
-var SYSTEM_ERROR__NONCE_NO_RECENT_BLOCKHASHES = 6;
-var SYSTEM_ERROR__NONCE_BLOCKHASH_NOT_EXPIRED = 7;
-var SYSTEM_ERROR__NONCE_UNEXPECTED_BLOCKHASH_VALUE = 8;
-var systemErrorMessages;
-if (process.env.NODE_ENV !== "production") {
-  systemErrorMessages = {
-    [SYSTEM_ERROR__ACCOUNT_ALREADY_IN_USE]: `an account with the same address already exists`,
-    [SYSTEM_ERROR__ADDRESS_WITH_SEED_MISMATCH]: `provided address does not match addressed derived from seed`,
-    [SYSTEM_ERROR__INVALID_ACCOUNT_DATA_LENGTH]: `cannot allocate account data of this length`,
-    [SYSTEM_ERROR__INVALID_PROGRAM_ID]: `cannot assign account to this program id`,
-    [SYSTEM_ERROR__MAX_SEED_LENGTH_EXCEEDED]: `length of requested seed is too long`,
-    [SYSTEM_ERROR__NONCE_BLOCKHASH_NOT_EXPIRED]: `stored nonce is still in recent_blockhashes`,
-    [SYSTEM_ERROR__NONCE_NO_RECENT_BLOCKHASHES]: `advancing stored nonce requires a populated RecentBlockhashes sysvar`,
-    [SYSTEM_ERROR__NONCE_UNEXPECTED_BLOCKHASH_VALUE]: `specified nonce does not match stored nonce`,
-    [SYSTEM_ERROR__RESULT_WITH_NEGATIVE_LAMPORTS]: `account does not have enough SOL to perform the operation`
-  };
-}
-function getSystemErrorMessage(code) {
-  if (process.env.NODE_ENV !== "production") {
-    return systemErrorMessages[code];
-  }
-  return "Error message not available in production bundles.";
-}
-function isSystemError(error, transactionMessage, code) {
-  return kit.isProgramError(
-    error,
-    transactionMessage,
-    SYSTEM_PROGRAM_ADDRESS,
-    code
-  );
-}
-function expectAddress(value) {
-  if (!value) {
-    throw new Error("Expected a Address.");
-  }
-  if (typeof value === "object" && "address" in value) {
-    return value.address;
-  }
-  if (Array.isArray(value)) {
-    return value[0];
-  }
-  return value;
-}
-function getAccountMetaFactory(programAddress, optionalAccountStrategy) {
-  return (account) => {
-    if (!account.value) {
-      return;
-    }
-    const writableRole = account.isWritable ? kit.AccountRole.WRITABLE : kit.AccountRole.READONLY;
-    return Object.freeze({
-      address: expectAddress(account.value),
-      role: isTransactionSigner(account.value) ? kit.upgradeRoleToSigner(writableRole) : writableRole,
-      ...isTransactionSigner(account.value) ? { signer: account.value } : {}
-    });
-  };
-}
-function isTransactionSigner(value) {
-  return !!value && typeof value === "object" && "address" in value && kit.isTransactionSigner(value);
-}
-
-// src/generated/instructions/advanceNonceAccount.ts
 var ADVANCE_NONCE_ACCOUNT_DISCRIMINATOR = 4;
 function getAdvanceNonceAccountDiscriminatorBytes() {
   return kit.getU32Encoder().encode(ADVANCE_NONCE_ACCOUNT_DISCRIMINATOR);
 }
 function getAdvanceNonceAccountInstructionDataEncoder() {
-  return kit.transformEncoder(
-    kit.getStructEncoder([["discriminator", kit.getU32Encoder()]]),
-    (value) => ({
-      ...value,
-      discriminator: ADVANCE_NONCE_ACCOUNT_DISCRIMINATOR
-    })
-  );
+  return kit.transformEncoder(kit.getStructEncoder([["discriminator", kit.getU32Encoder()]]), (value) => ({
+    ...value,
+    discriminator: ADVANCE_NONCE_ACCOUNT_DISCRIMINATOR
+  }));
 }
 function getAdvanceNonceAccountInstructionDataDecoder() {
   return kit.getStructDecoder([["discriminator", kit.getU32Decoder()]]);
 }
 function getAdvanceNonceAccountInstructionDataCodec() {
-  return kit.combineCodec(
-    getAdvanceNonceAccountInstructionDataEncoder(),
-    getAdvanceNonceAccountInstructionDataDecoder()
-  );
+  return kit.combineCodec(getAdvanceNonceAccountInstructionDataEncoder(), getAdvanceNonceAccountInstructionDataDecoder());
 }
 function getAdvanceNonceAccountInstruction(input, config) {
   const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
   const originalAccounts = {
     nonceAccount: { value: input.nonceAccount ?? null, isWritable: true },
-    recentBlockhashesSysvar: {
-      value: input.recentBlockhashesSysvar ?? null,
-      isWritable: false
-    },
+    recentBlockhashesSysvar: { value: input.recentBlockhashesSysvar ?? null, isWritable: false },
     nonceAuthority: { value: input.nonceAuthority ?? null, isWritable: false }
   };
   const accounts = originalAccounts;
   if (!accounts.recentBlockhashesSysvar.value) {
     accounts.recentBlockhashesSysvar.value = "SysvarRecentB1ockHashes11111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
     accounts: [
-      getAccountMeta(accounts.nonceAccount),
-      getAccountMeta(accounts.recentBlockhashesSysvar),
-      getAccountMeta(accounts.nonceAuthority)
+      getAccountMeta("nonceAccount", accounts.nonceAccount),
+      getAccountMeta("recentBlockhashesSysvar", accounts.recentBlockhashesSysvar),
+      getAccountMeta("nonceAuthority", accounts.nonceAuthority)
     ],
     data: getAdvanceNonceAccountInstructionDataEncoder().encode({}),
     programAddress
@@ -265,7 +119,10 @@ function getAdvanceNonceAccountInstruction(input, config) {
 }
 function parseAdvanceNonceAccountInstruction(instruction) {
   if (instruction.accounts.length < 3) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 3
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -280,9 +137,7 @@ function parseAdvanceNonceAccountInstruction(instruction) {
       recentBlockhashesSysvar: getNextAccount(),
       nonceAuthority: getNextAccount()
     },
-    data: getAdvanceNonceAccountInstructionDataDecoder().decode(
-      instruction.data
-    )
+    data: getAdvanceNonceAccountInstructionDataDecoder().decode(instruction.data)
   };
 }
 var ALLOCATE_DISCRIMINATOR = 8;
@@ -305,30 +160,26 @@ function getAllocateInstructionDataDecoder() {
   ]);
 }
 function getAllocateInstructionDataCodec() {
-  return kit.combineCodec(
-    getAllocateInstructionDataEncoder(),
-    getAllocateInstructionDataDecoder()
-  );
+  return kit.combineCodec(getAllocateInstructionDataEncoder(), getAllocateInstructionDataDecoder());
 }
 function getAllocateInstruction(input, config) {
   const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    newAccount: { value: input.newAccount ?? null, isWritable: true }
-  };
+  const originalAccounts = { newAccount: { value: input.newAccount ?? null, isWritable: true } };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
-    accounts: [getAccountMeta(accounts.newAccount)],
-    data: getAllocateInstructionDataEncoder().encode(
-      args
-    ),
+    accounts: [getAccountMeta("newAccount", accounts.newAccount)],
+    data: getAllocateInstructionDataEncoder().encode(args),
     programAddress
   });
 }
 function parseAllocateInstruction(instruction) {
   if (instruction.accounts.length < 1) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 1
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -368,10 +219,7 @@ function getAllocateWithSeedInstructionDataDecoder() {
   ]);
 }
 function getAllocateWithSeedInstructionDataCodec() {
-  return kit.combineCodec(
-    getAllocateWithSeedInstructionDataEncoder(),
-    getAllocateWithSeedInstructionDataDecoder()
-  );
+  return kit.combineCodec(getAllocateWithSeedInstructionDataEncoder(), getAllocateWithSeedInstructionDataDecoder());
 }
 function getAllocateWithSeedInstruction(input, config) {
   const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
@@ -381,21 +229,22 @@ function getAllocateWithSeedInstruction(input, config) {
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
     accounts: [
-      getAccountMeta(accounts.newAccount),
-      getAccountMeta(accounts.baseAccount)
+      getAccountMeta("newAccount", accounts.newAccount),
+      getAccountMeta("baseAccount", accounts.baseAccount)
     ],
-    data: getAllocateWithSeedInstructionDataEncoder().encode(
-      args
-    ),
+    data: getAllocateWithSeedInstructionDataEncoder().encode(args),
     programAddress
   });
 }
 function parseAllocateWithSeedInstruction(instruction) {
   if (instruction.accounts.length < 2) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 2
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -429,30 +278,26 @@ function getAssignInstructionDataDecoder() {
   ]);
 }
 function getAssignInstructionDataCodec() {
-  return kit.combineCodec(
-    getAssignInstructionDataEncoder(),
-    getAssignInstructionDataDecoder()
-  );
+  return kit.combineCodec(getAssignInstructionDataEncoder(), getAssignInstructionDataDecoder());
 }
 function getAssignInstruction(input, config) {
   const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    account: { value: input.account ?? null, isWritable: true }
-  };
+  const originalAccounts = { account: { value: input.account ?? null, isWritable: true } };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
-    accounts: [getAccountMeta(accounts.account)],
-    data: getAssignInstructionDataEncoder().encode(
-      args
-    ),
+    accounts: [getAccountMeta("account", accounts.account)],
+    data: getAssignInstructionDataEncoder().encode(args),
     programAddress
   });
 }
 function parseAssignInstruction(instruction) {
   if (instruction.accounts.length < 1) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 1
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -490,10 +335,7 @@ function getAssignWithSeedInstructionDataDecoder() {
   ]);
 }
 function getAssignWithSeedInstructionDataCodec() {
-  return kit.combineCodec(
-    getAssignWithSeedInstructionDataEncoder(),
-    getAssignWithSeedInstructionDataDecoder()
-  );
+  return kit.combineCodec(getAssignWithSeedInstructionDataEncoder(), getAssignWithSeedInstructionDataDecoder());
 }
 function getAssignWithSeedInstruction(input, config) {
   const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
@@ -503,21 +345,19 @@ function getAssignWithSeedInstruction(input, config) {
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.account),
-      getAccountMeta(accounts.baseAccount)
-    ],
-    data: getAssignWithSeedInstructionDataEncoder().encode(
-      args
-    ),
+    accounts: [getAccountMeta("account", accounts.account), getAccountMeta("baseAccount", accounts.baseAccount)],
+    data: getAssignWithSeedInstructionDataEncoder().encode(args),
     programAddress
   });
 }
 function parseAssignWithSeedInstruction(instruction) {
   if (instruction.accounts.length < 2) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 2
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -541,10 +381,7 @@ function getAuthorizeNonceAccountInstructionDataEncoder() {
       ["discriminator", kit.getU32Encoder()],
       ["newNonceAuthority", kit.getAddressEncoder()]
     ]),
-    (value) => ({
-      ...value,
-      discriminator: AUTHORIZE_NONCE_ACCOUNT_DISCRIMINATOR
-    })
+    (value) => ({ ...value, discriminator: AUTHORIZE_NONCE_ACCOUNT_DISCRIMINATOR })
   );
 }
 function getAuthorizeNonceAccountInstructionDataDecoder() {
@@ -567,21 +404,22 @@ function getAuthorizeNonceAccountInstruction(input, config) {
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
     accounts: [
-      getAccountMeta(accounts.nonceAccount),
-      getAccountMeta(accounts.nonceAuthority)
+      getAccountMeta("nonceAccount", accounts.nonceAccount),
+      getAccountMeta("nonceAuthority", accounts.nonceAuthority)
     ],
-    data: getAuthorizeNonceAccountInstructionDataEncoder().encode(
-      args
-    ),
+    data: getAuthorizeNonceAccountInstructionDataEncoder().encode(args),
     programAddress
   });
 }
 function parseAuthorizeNonceAccountInstruction(instruction) {
   if (instruction.accounts.length < 2) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 2
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -591,13 +429,8 @@ function parseAuthorizeNonceAccountInstruction(instruction) {
   };
   return {
     programAddress: instruction.programAddress,
-    accounts: {
-      nonceAccount: getNextAccount(),
-      nonceAuthority: getNextAccount()
-    },
-    data: getAuthorizeNonceAccountInstructionDataDecoder().decode(
-      instruction.data
-    )
+    accounts: { nonceAccount: getNextAccount(), nonceAuthority: getNextAccount() },
+    data: getAuthorizeNonceAccountInstructionDataDecoder().decode(instruction.data)
   };
 }
 var CREATE_ACCOUNT_DISCRIMINATOR = 0;
@@ -624,10 +457,7 @@ function getCreateAccountInstructionDataDecoder() {
   ]);
 }
 function getCreateAccountInstructionDataCodec() {
-  return kit.combineCodec(
-    getCreateAccountInstructionDataEncoder(),
-    getCreateAccountInstructionDataDecoder()
-  );
+  return kit.combineCodec(getCreateAccountInstructionDataEncoder(), getCreateAccountInstructionDataDecoder());
 }
 function getCreateAccountInstruction(input, config) {
   const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
@@ -637,26 +467,21 @@ function getCreateAccountInstruction(input, config) {
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  const byteDelta = [Number(args.space) + kit.BASE_ACCOUNT_SIZE].reduce(
-    (a, b) => a + b,
-    0
-  );
-  const getAccountMeta = getAccountMetaFactory();
+  const byteDelta = [Number(args.space) + kit.BASE_ACCOUNT_SIZE].reduce((a, b) => a + b, 0);
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.payer),
-      getAccountMeta(accounts.newAccount)
-    ],
+    accounts: [getAccountMeta("payer", accounts.payer), getAccountMeta("newAccount", accounts.newAccount)],
     byteDelta,
-    data: getCreateAccountInstructionDataEncoder().encode(
-      args
-    ),
+    data: getCreateAccountInstructionDataEncoder().encode(args),
     programAddress
   });
 }
 function parseCreateAccountInstruction(instruction) {
   if (instruction.accounts.length < 2) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 2
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -684,10 +509,7 @@ function getCreateAccountWithSeedInstructionDataEncoder() {
       ["space", kit.getU64Encoder()],
       ["programAddress", kit.getAddressEncoder()]
     ]),
-    (value) => ({
-      ...value,
-      discriminator: CREATE_ACCOUNT_WITH_SEED_DISCRIMINATOR
-    })
+    (value) => ({ ...value, discriminator: CREATE_ACCOUNT_WITH_SEED_DISCRIMINATOR })
   );
 }
 function getCreateAccountWithSeedInstructionDataDecoder() {
@@ -715,22 +537,23 @@ function getCreateAccountWithSeedInstruction(input, config) {
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
     accounts: [
-      getAccountMeta(accounts.payer),
-      getAccountMeta(accounts.newAccount),
-      getAccountMeta(accounts.baseAccount)
+      getAccountMeta("payer", accounts.payer),
+      getAccountMeta("newAccount", accounts.newAccount),
+      getAccountMeta("baseAccount", accounts.baseAccount)
     ].filter((x) => x !== void 0),
-    data: getCreateAccountWithSeedInstructionDataEncoder().encode(
-      args
-    ),
+    data: getCreateAccountWithSeedInstructionDataEncoder().encode(args),
     programAddress
   });
 }
 function parseCreateAccountWithSeedInstruction(instruction) {
   if (instruction.accounts.length < 2) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 2
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -746,14 +569,8 @@ function parseCreateAccountWithSeedInstruction(instruction) {
   };
   return {
     programAddress: instruction.programAddress,
-    accounts: {
-      payer: getNextAccount(),
-      newAccount: getNextAccount(),
-      baseAccount: getNextOptionalAccount()
-    },
-    data: getCreateAccountWithSeedInstructionDataDecoder().decode(
-      instruction.data
-    )
+    accounts: { payer: getNextAccount(), newAccount: getNextAccount(), baseAccount: getNextOptionalAccount() },
+    data: getCreateAccountWithSeedInstructionDataDecoder().decode(instruction.data)
   };
 }
 var INITIALIZE_NONCE_ACCOUNT_DISCRIMINATOR = 6;
@@ -766,10 +583,7 @@ function getInitializeNonceAccountInstructionDataEncoder() {
       ["discriminator", kit.getU32Encoder()],
       ["nonceAuthority", kit.getAddressEncoder()]
     ]),
-    (value) => ({
-      ...value,
-      discriminator: INITIALIZE_NONCE_ACCOUNT_DISCRIMINATOR
-    })
+    (value) => ({ ...value, discriminator: INITIALIZE_NONCE_ACCOUNT_DISCRIMINATOR })
   );
 }
 function getInitializeNonceAccountInstructionDataDecoder() {
@@ -788,10 +602,7 @@ function getInitializeNonceAccountInstruction(input, config) {
   const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
   const originalAccounts = {
     nonceAccount: { value: input.nonceAccount ?? null, isWritable: true },
-    recentBlockhashesSysvar: {
-      value: input.recentBlockhashesSysvar ?? null,
-      isWritable: false
-    },
+    recentBlockhashesSysvar: { value: input.recentBlockhashesSysvar ?? null, isWritable: false },
     rentSysvar: { value: input.rentSysvar ?? null, isWritable: false }
   };
   const accounts = originalAccounts;
@@ -802,12 +613,12 @@ function getInitializeNonceAccountInstruction(input, config) {
   if (!accounts.rentSysvar.value) {
     accounts.rentSysvar.value = "SysvarRent111111111111111111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
     accounts: [
-      getAccountMeta(accounts.nonceAccount),
-      getAccountMeta(accounts.recentBlockhashesSysvar),
-      getAccountMeta(accounts.rentSysvar)
+      getAccountMeta("nonceAccount", accounts.nonceAccount),
+      getAccountMeta("recentBlockhashesSysvar", accounts.recentBlockhashesSysvar),
+      getAccountMeta("rentSysvar", accounts.rentSysvar)
     ],
     data: getInitializeNonceAccountInstructionDataEncoder().encode(
       args
@@ -817,7 +628,10 @@ function getInitializeNonceAccountInstruction(input, config) {
 }
 function parseInitializeNonceAccountInstruction(instruction) {
   if (instruction.accounts.length < 3) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 3
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -832,9 +646,7 @@ function parseInitializeNonceAccountInstruction(instruction) {
       recentBlockhashesSysvar: getNextAccount(),
       rentSysvar: getNextAccount()
     },
-    data: getInitializeNonceAccountInstructionDataDecoder().decode(
-      instruction.data
-    )
+    data: getInitializeNonceAccountInstructionDataDecoder().decode(instruction.data)
   };
 }
 var TRANSFER_SOL_DISCRIMINATOR = 2;
@@ -857,10 +669,7 @@ function getTransferSolInstructionDataDecoder() {
   ]);
 }
 function getTransferSolInstructionDataCodec() {
-  return kit.combineCodec(
-    getTransferSolInstructionDataEncoder(),
-    getTransferSolInstructionDataDecoder()
-  );
+  return kit.combineCodec(getTransferSolInstructionDataEncoder(), getTransferSolInstructionDataDecoder());
 }
 function getTransferSolInstruction(input, config) {
   const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
@@ -870,21 +679,19 @@ function getTransferSolInstruction(input, config) {
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.source),
-      getAccountMeta(accounts.destination)
-    ],
-    data: getTransferSolInstructionDataEncoder().encode(
-      args
-    ),
+    accounts: [getAccountMeta("source", accounts.source), getAccountMeta("destination", accounts.destination)],
+    data: getTransferSolInstructionDataEncoder().encode(args),
     programAddress
   });
 }
 function parseTransferSolInstruction(instruction) {
   if (instruction.accounts.length < 2) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 2
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -910,10 +717,7 @@ function getTransferSolWithSeedInstructionDataEncoder() {
       ["fromSeed", kit.addEncoderSizePrefix(kit.getUtf8Encoder(), kit.getU64Encoder())],
       ["fromOwner", kit.getAddressEncoder()]
     ]),
-    (value) => ({
-      ...value,
-      discriminator: TRANSFER_SOL_WITH_SEED_DISCRIMINATOR
-    })
+    (value) => ({ ...value, discriminator: TRANSFER_SOL_WITH_SEED_DISCRIMINATOR })
   );
 }
 function getTransferSolWithSeedInstructionDataDecoder() {
@@ -925,10 +729,7 @@ function getTransferSolWithSeedInstructionDataDecoder() {
   ]);
 }
 function getTransferSolWithSeedInstructionDataCodec() {
-  return kit.combineCodec(
-    getTransferSolWithSeedInstructionDataEncoder(),
-    getTransferSolWithSeedInstructionDataDecoder()
-  );
+  return kit.combineCodec(getTransferSolWithSeedInstructionDataEncoder(), getTransferSolWithSeedInstructionDataDecoder());
 }
 function getTransferSolWithSeedInstruction(input, config) {
   const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
@@ -939,22 +740,23 @@ function getTransferSolWithSeedInstruction(input, config) {
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
     accounts: [
-      getAccountMeta(accounts.source),
-      getAccountMeta(accounts.baseAccount),
-      getAccountMeta(accounts.destination)
+      getAccountMeta("source", accounts.source),
+      getAccountMeta("baseAccount", accounts.baseAccount),
+      getAccountMeta("destination", accounts.destination)
     ],
-    data: getTransferSolWithSeedInstructionDataEncoder().encode(
-      args
-    ),
+    data: getTransferSolWithSeedInstructionDataEncoder().encode(args),
     programAddress
   });
 }
 function parseTransferSolWithSeedInstruction(instruction) {
   if (instruction.accounts.length < 3) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 3
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -964,14 +766,8 @@ function parseTransferSolWithSeedInstruction(instruction) {
   };
   return {
     programAddress: instruction.programAddress,
-    accounts: {
-      source: getNextAccount(),
-      baseAccount: getNextAccount(),
-      destination: getNextAccount()
-    },
-    data: getTransferSolWithSeedInstructionDataDecoder().decode(
-      instruction.data
-    )
+    accounts: { source: getNextAccount(), baseAccount: getNextAccount(), destination: getNextAccount() },
+    data: getTransferSolWithSeedInstructionDataDecoder().decode(instruction.data)
   };
 }
 var UPGRADE_NONCE_ACCOUNT_DISCRIMINATOR = 12;
@@ -979,39 +775,34 @@ function getUpgradeNonceAccountDiscriminatorBytes() {
   return kit.getU32Encoder().encode(UPGRADE_NONCE_ACCOUNT_DISCRIMINATOR);
 }
 function getUpgradeNonceAccountInstructionDataEncoder() {
-  return kit.transformEncoder(
-    kit.getStructEncoder([["discriminator", kit.getU32Encoder()]]),
-    (value) => ({
-      ...value,
-      discriminator: UPGRADE_NONCE_ACCOUNT_DISCRIMINATOR
-    })
-  );
+  return kit.transformEncoder(kit.getStructEncoder([["discriminator", kit.getU32Encoder()]]), (value) => ({
+    ...value,
+    discriminator: UPGRADE_NONCE_ACCOUNT_DISCRIMINATOR
+  }));
 }
 function getUpgradeNonceAccountInstructionDataDecoder() {
   return kit.getStructDecoder([["discriminator", kit.getU32Decoder()]]);
 }
 function getUpgradeNonceAccountInstructionDataCodec() {
-  return kit.combineCodec(
-    getUpgradeNonceAccountInstructionDataEncoder(),
-    getUpgradeNonceAccountInstructionDataDecoder()
-  );
+  return kit.combineCodec(getUpgradeNonceAccountInstructionDataEncoder(), getUpgradeNonceAccountInstructionDataDecoder());
 }
 function getUpgradeNonceAccountInstruction(input, config) {
   const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    nonceAccount: { value: input.nonceAccount ?? null, isWritable: true }
-  };
+  const originalAccounts = { nonceAccount: { value: input.nonceAccount ?? null, isWritable: true } };
   const accounts = originalAccounts;
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
-    accounts: [getAccountMeta(accounts.nonceAccount)],
+    accounts: [getAccountMeta("nonceAccount", accounts.nonceAccount)],
     data: getUpgradeNonceAccountInstructionDataEncoder().encode({}),
     programAddress
   });
 }
 function parseUpgradeNonceAccountInstruction(instruction) {
   if (instruction.accounts.length < 1) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 1
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -1022,9 +813,7 @@ function parseUpgradeNonceAccountInstruction(instruction) {
   return {
     programAddress: instruction.programAddress,
     accounts: { nonceAccount: getNextAccount() },
-    data: getUpgradeNonceAccountInstructionDataDecoder().decode(
-      instruction.data
-    )
+    data: getUpgradeNonceAccountInstructionDataDecoder().decode(instruction.data)
   };
 }
 var WITHDRAW_NONCE_ACCOUNT_DISCRIMINATOR = 5;
@@ -1037,10 +826,7 @@ function getWithdrawNonceAccountInstructionDataEncoder() {
       ["discriminator", kit.getU32Encoder()],
       ["withdrawAmount", kit.getU64Encoder()]
     ]),
-    (value) => ({
-      ...value,
-      discriminator: WITHDRAW_NONCE_ACCOUNT_DISCRIMINATOR
-    })
+    (value) => ({ ...value, discriminator: WITHDRAW_NONCE_ACCOUNT_DISCRIMINATOR })
   );
 }
 function getWithdrawNonceAccountInstructionDataDecoder() {
@@ -1059,14 +845,8 @@ function getWithdrawNonceAccountInstruction(input, config) {
   const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
   const originalAccounts = {
     nonceAccount: { value: input.nonceAccount ?? null, isWritable: true },
-    recipientAccount: {
-      value: input.recipientAccount ?? null,
-      isWritable: true
-    },
-    recentBlockhashesSysvar: {
-      value: input.recentBlockhashesSysvar ?? null,
-      isWritable: false
-    },
+    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 }
   };
@@ -1078,24 +858,25 @@ function getWithdrawNonceAccountInstruction(input, config) {
   if (!accounts.rentSysvar.value) {
     accounts.rentSysvar.value = "SysvarRent111111111111111111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
     accounts: [
-      getAccountMeta(accounts.nonceAccount),
-      getAccountMeta(accounts.recipientAccount),
-      getAccountMeta(accounts.recentBlockhashesSysvar),
-      getAccountMeta(accounts.rentSysvar),
-      getAccountMeta(accounts.nonceAuthority)
+      getAccountMeta("nonceAccount", accounts.nonceAccount),
+      getAccountMeta("recipientAccount", accounts.recipientAccount),
+      getAccountMeta("recentBlockhashesSysvar", accounts.recentBlockhashesSysvar),
+      getAccountMeta("rentSysvar", accounts.rentSysvar),
+      getAccountMeta("nonceAuthority", accounts.nonceAuthority)
     ],
-    data: getWithdrawNonceAccountInstructionDataEncoder().encode(
-      args
-    ),
+    data: getWithdrawNonceAccountInstructionDataEncoder().encode(args),
     programAddress
   });
 }
 function parseWithdrawNonceAccountInstruction(instruction) {
   if (instruction.accounts.length < 5) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 5
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -1112,11 +893,232 @@ function parseWithdrawNonceAccountInstruction(instruction) {
       rentSysvar: getNextAccount(),
       nonceAuthority: getNextAccount()
     },
-    data: getWithdrawNonceAccountInstructionDataDecoder().decode(
-      instruction.data
-    )
+    data: getWithdrawNonceAccountInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/generated/programs/system.ts
+var SYSTEM_PROGRAM_ADDRESS = "11111111111111111111111111111111";
+var SystemAccount = /* @__PURE__ */ ((SystemAccount2) => {
+  SystemAccount2[SystemAccount2["Nonce"] = 0] = "Nonce";
+  return SystemAccount2;
+})(SystemAccount || {});
+var SystemInstruction = /* @__PURE__ */ ((SystemInstruction2) => {
+  SystemInstruction2[SystemInstruction2["CreateAccount"] = 0] = "CreateAccount";
+  SystemInstruction2[SystemInstruction2["Assign"] = 1] = "Assign";
+  SystemInstruction2[SystemInstruction2["TransferSol"] = 2] = "TransferSol";
+  SystemInstruction2[SystemInstruction2["CreateAccountWithSeed"] = 3] = "CreateAccountWithSeed";
+  SystemInstruction2[SystemInstruction2["AdvanceNonceAccount"] = 4] = "AdvanceNonceAccount";
+  SystemInstruction2[SystemInstruction2["WithdrawNonceAccount"] = 5] = "WithdrawNonceAccount";
+  SystemInstruction2[SystemInstruction2["InitializeNonceAccount"] = 6] = "InitializeNonceAccount";
+  SystemInstruction2[SystemInstruction2["AuthorizeNonceAccount"] = 7] = "AuthorizeNonceAccount";
+  SystemInstruction2[SystemInstruction2["Allocate"] = 8] = "Allocate";
+  SystemInstruction2[SystemInstruction2["AllocateWithSeed"] = 9] = "AllocateWithSeed";
+  SystemInstruction2[SystemInstruction2["AssignWithSeed"] = 10] = "AssignWithSeed";
+  SystemInstruction2[SystemInstruction2["TransferSolWithSeed"] = 11] = "TransferSolWithSeed";
+  SystemInstruction2[SystemInstruction2["UpgradeNonceAccount"] = 12] = "UpgradeNonceAccount";
+  return SystemInstruction2;
+})(SystemInstruction || {});
+function identifySystemInstruction(instruction) {
+  const data = "data" in instruction ? instruction.data : instruction;
+  if (kit.containsBytes(data, kit.getU32Encoder().encode(0), 0)) {
+    return 0 /* CreateAccount */;
+  }
+  if (kit.containsBytes(data, kit.getU32Encoder().encode(1), 0)) {
+    return 1 /* Assign */;
+  }
+  if (kit.containsBytes(data, kit.getU32Encoder().encode(2), 0)) {
+    return 2 /* TransferSol */;
+  }
+  if (kit.containsBytes(data, kit.getU32Encoder().encode(3), 0)) {
+    return 3 /* CreateAccountWithSeed */;
+  }
+  if (kit.containsBytes(data, kit.getU32Encoder().encode(4), 0)) {
+    return 4 /* AdvanceNonceAccount */;
+  }
+  if (kit.containsBytes(data, kit.getU32Encoder().encode(5), 0)) {
+    return 5 /* WithdrawNonceAccount */;
+  }
+  if (kit.containsBytes(data, kit.getU32Encoder().encode(6), 0)) {
+    return 6 /* InitializeNonceAccount */;
+  }
+  if (kit.containsBytes(data, kit.getU32Encoder().encode(7), 0)) {
+    return 7 /* AuthorizeNonceAccount */;
+  }
+  if (kit.containsBytes(data, kit.getU32Encoder().encode(8), 0)) {
+    return 8 /* Allocate */;
+  }
+  if (kit.containsBytes(data, kit.getU32Encoder().encode(9), 0)) {
+    return 9 /* AllocateWithSeed */;
+  }
+  if (kit.containsBytes(data, kit.getU32Encoder().encode(10), 0)) {
+    return 10 /* AssignWithSeed */;
+  }
+  if (kit.containsBytes(data, kit.getU32Encoder().encode(11), 0)) {
+    return 11 /* TransferSolWithSeed */;
+  }
+  if (kit.containsBytes(data, kit.getU32Encoder().encode(12), 0)) {
+    return 12 /* UpgradeNonceAccount */;
+  }
+  throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, {
+    instructionData: data,
+    programName: "system"
+  });
+}
+function parseSystemInstruction(instruction) {
+  const instructionType = identifySystemInstruction(instruction);
+  switch (instructionType) {
+    case 0 /* CreateAccount */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return { instructionType: 0 /* CreateAccount */, ...parseCreateAccountInstruction(instruction) };
+    }
+    case 1 /* Assign */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return { instructionType: 1 /* Assign */, ...parseAssignInstruction(instruction) };
+    }
+    case 2 /* TransferSol */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return { instructionType: 2 /* TransferSol */, ...parseTransferSolInstruction(instruction) };
+    }
+    case 3 /* CreateAccountWithSeed */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 3 /* CreateAccountWithSeed */,
+        ...parseCreateAccountWithSeedInstruction(instruction)
+      };
+    }
+    case 4 /* AdvanceNonceAccount */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 4 /* AdvanceNonceAccount */,
+        ...parseAdvanceNonceAccountInstruction(instruction)
+      };
+    }
+    case 5 /* WithdrawNonceAccount */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 5 /* WithdrawNonceAccount */,
+        ...parseWithdrawNonceAccountInstruction(instruction)
+      };
+    }
+    case 6 /* InitializeNonceAccount */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 6 /* InitializeNonceAccount */,
+        ...parseInitializeNonceAccountInstruction(instruction)
+      };
+    }
+    case 7 /* AuthorizeNonceAccount */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 7 /* AuthorizeNonceAccount */,
+        ...parseAuthorizeNonceAccountInstruction(instruction)
+      };
+    }
+    case 8 /* Allocate */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return { instructionType: 8 /* Allocate */, ...parseAllocateInstruction(instruction) };
+    }
+    case 9 /* AllocateWithSeed */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 9 /* AllocateWithSeed */,
+        ...parseAllocateWithSeedInstruction(instruction)
+      };
+    }
+    case 10 /* AssignWithSeed */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 10 /* AssignWithSeed */,
+        ...parseAssignWithSeedInstruction(instruction)
+      };
+    }
+    case 11 /* TransferSolWithSeed */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 11 /* TransferSolWithSeed */,
+        ...parseTransferSolWithSeedInstruction(instruction)
+      };
+    }
+    case 12 /* UpgradeNonceAccount */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 12 /* UpgradeNonceAccount */,
+        ...parseUpgradeNonceAccountInstruction(instruction)
+      };
+    }
+    default:
+      throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, {
+        instructionType,
+        programName: "system"
+      });
+  }
+}
+function systemProgram() {
+  return (client) => {
+    return {
+      ...client,
+      system: {
+        accounts: { nonce: programClientCore.addSelfFetchFunctions(client, getNonceCodec()) },
+        instructions: {
+          createAccount: (input) => programClientCore.addSelfPlanAndSendFunctions(
+            client,
+            getCreateAccountInstruction({ ...input, payer: input.payer ?? client.payer })
+          ),
+          assign: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getAssignInstruction(input)),
+          transferSol: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getTransferSolInstruction(input)),
+          createAccountWithSeed: (input) => programClientCore.addSelfPlanAndSendFunctions(
+            client,
+            getCreateAccountWithSeedInstruction({ ...input, payer: input.payer ?? client.payer })
+          ),
+          advanceNonceAccount: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getAdvanceNonceAccountInstruction(input)),
+          withdrawNonceAccount: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getWithdrawNonceAccountInstruction(input)),
+          initializeNonceAccount: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getInitializeNonceAccountInstruction(input)),
+          authorizeNonceAccount: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getAuthorizeNonceAccountInstruction(input)),
+          allocate: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getAllocateInstruction(input)),
+          allocateWithSeed: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getAllocateWithSeedInstruction(input)),
+          assignWithSeed: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getAssignWithSeedInstruction(input)),
+          transferSolWithSeed: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getTransferSolWithSeedInstruction(input)),
+          upgradeNonceAccount: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getUpgradeNonceAccountInstruction(input))
+        }
+      }
+    };
+  };
+}
+
+// src/generated/errors/system.ts
+var SYSTEM_ERROR__ACCOUNT_ALREADY_IN_USE = 0;
+var SYSTEM_ERROR__RESULT_WITH_NEGATIVE_LAMPORTS = 1;
+var SYSTEM_ERROR__INVALID_PROGRAM_ID = 2;
+var SYSTEM_ERROR__INVALID_ACCOUNT_DATA_LENGTH = 3;
+var SYSTEM_ERROR__MAX_SEED_LENGTH_EXCEEDED = 4;
+var SYSTEM_ERROR__ADDRESS_WITH_SEED_MISMATCH = 5;
+var SYSTEM_ERROR__NONCE_NO_RECENT_BLOCKHASHES = 6;
+var SYSTEM_ERROR__NONCE_BLOCKHASH_NOT_EXPIRED = 7;
+var SYSTEM_ERROR__NONCE_UNEXPECTED_BLOCKHASH_VALUE = 8;
+var systemErrorMessages;
+if (process.env.NODE_ENV !== "production") {
+  systemErrorMessages = {
+    [SYSTEM_ERROR__ACCOUNT_ALREADY_IN_USE]: `an account with the same address already exists`,
+    [SYSTEM_ERROR__ADDRESS_WITH_SEED_MISMATCH]: `provided address does not match addressed derived from seed`,
+    [SYSTEM_ERROR__INVALID_ACCOUNT_DATA_LENGTH]: `cannot allocate account data of this length`,
+    [SYSTEM_ERROR__INVALID_PROGRAM_ID]: `cannot assign account to this program id`,
+    [SYSTEM_ERROR__MAX_SEED_LENGTH_EXCEEDED]: `length of requested seed is too long`,
+    [SYSTEM_ERROR__NONCE_BLOCKHASH_NOT_EXPIRED]: `stored nonce is still in recent_blockhashes`,
+    [SYSTEM_ERROR__NONCE_NO_RECENT_BLOCKHASHES]: `advancing stored nonce requires a populated RecentBlockhashes sysvar`,
+    [SYSTEM_ERROR__NONCE_UNEXPECTED_BLOCKHASH_VALUE]: `specified nonce does not match stored nonce`,
+    [SYSTEM_ERROR__RESULT_WITH_NEGATIVE_LAMPORTS]: `account does not have enough SOL to perform the operation`
   };
 }
+function getSystemErrorMessage(code) {
+  if (process.env.NODE_ENV !== "production") {
+    return systemErrorMessages[code];
+  }
+  return "Error message not available in production bundles.";
+}
+function isSystemError(error, transactionMessage, code) {
+  return kit.isProgramError(error, transactionMessage, SYSTEM_PROGRAM_ADDRESS, code);
+}
 
 exports.ADVANCE_NONCE_ACCOUNT_DISCRIMINATOR = ADVANCE_NONCE_ACCOUNT_DISCRIMINATOR;
 exports.ALLOCATE_DISCRIMINATOR = ALLOCATE_DISCRIMINATOR;
@@ -1237,9 +1239,11 @@ exports.parseAuthorizeNonceAccountInstruction = parseAuthorizeNonceAccountInstru
 exports.parseCreateAccountInstruction = parseCreateAccountInstruction;
 exports.parseCreateAccountWithSeedInstruction = parseCreateAccountWithSeedInstruction;
 exports.parseInitializeNonceAccountInstruction = parseInitializeNonceAccountInstruction;
+exports.parseSystemInstruction = parseSystemInstruction;
 exports.parseTransferSolInstruction = parseTransferSolInstruction;
 exports.parseTransferSolWithSeedInstruction = parseTransferSolWithSeedInstruction;
 exports.parseUpgradeNonceAccountInstruction = parseUpgradeNonceAccountInstruction;
 exports.parseWithdrawNonceAccountInstruction = parseWithdrawNonceAccountInstruction;
+exports.systemProgram = systemProgram;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map