@solana-program/system 0.1.3 → 0.3.0

package/dist/src/index.cjs

@@ -1,10 +1,6 @@
 'use strict';
 
-var accounts = require('@solana/accounts');
-var addresses = require('@solana/addresses');
-var codecs = require('@solana/codecs');
-var instructions = require('@solana/instructions');
-var signers = require('@solana/signers');
+var web3_js = require('@solana/web3.js');
 
 // env-shim.ts
 var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
@@ -14,13 +10,13 @@ var NonceState = /* @__PURE__ */ ((NonceState3) => {
   return NonceState3;
 })(NonceState || {});
 function getNonceStateEncoder() {
-  return codecs.getScalarEnumEncoder(NonceState, { size: codecs.getU32Encoder() });
+  return web3_js.getEnumEncoder(NonceState, { size: web3_js.getU32Encoder() });
 }
 function getNonceStateDecoder() {
-  return codecs.getScalarEnumDecoder(NonceState, { size: codecs.getU32Decoder() });
+  return web3_js.getEnumDecoder(NonceState, { size: web3_js.getU32Decoder() });
 }
 function getNonceStateCodec() {
-  return codecs.combineCodec(getNonceStateEncoder(), getNonceStateDecoder());
+  return web3_js.combineCodec(getNonceStateEncoder(), getNonceStateDecoder());
 }
 var NonceVersion = /* @__PURE__ */ ((NonceVersion3) => {
   NonceVersion3[NonceVersion3["Legacy"] = 0] = "Legacy";
@@ -28,62 +24,59 @@ var NonceVersion = /* @__PURE__ */ ((NonceVersion3) => {
   return NonceVersion3;
 })(NonceVersion || {});
 function getNonceVersionEncoder() {
-  return codecs.getScalarEnumEncoder(NonceVersion, { size: codecs.getU32Encoder() });
+  return web3_js.getEnumEncoder(NonceVersion, { size: web3_js.getU32Encoder() });
 }
 function getNonceVersionDecoder() {
-  return codecs.getScalarEnumDecoder(NonceVersion, { size: codecs.getU32Decoder() });
+  return web3_js.getEnumDecoder(NonceVersion, { size: web3_js.getU32Decoder() });
 }
 function getNonceVersionCodec() {
-  return codecs.combineCodec(getNonceVersionEncoder(), getNonceVersionDecoder());
+  return web3_js.combineCodec(getNonceVersionEncoder(), getNonceVersionDecoder());
 }
 
 // src/generated/accounts/nonce.ts
-function getNonceAccountDataEncoder() {
-  return codecs.getStructEncoder([
+function getNonceEncoder() {
+  return web3_js.getStructEncoder([
     ["version", getNonceVersionEncoder()],
     ["state", getNonceStateEncoder()],
-    ["authority", addresses.getAddressEncoder()],
-    ["blockhash", addresses.getAddressEncoder()],
-    ["lamportsPerSignature", codecs.getU64Encoder()]
+    ["authority", web3_js.getAddressEncoder()],
+    ["blockhash", web3_js.getAddressEncoder()],
+    ["lamportsPerSignature", web3_js.getU64Encoder()]
   ]);
 }
-function getNonceAccountDataDecoder() {
-  return codecs.getStructDecoder([
+function getNonceDecoder() {
+  return web3_js.getStructDecoder([
     ["version", getNonceVersionDecoder()],
     ["state", getNonceStateDecoder()],
-    ["authority", addresses.getAddressDecoder()],
-    ["blockhash", addresses.getAddressDecoder()],
-    ["lamportsPerSignature", codecs.getU64Decoder()]
+    ["authority", web3_js.getAddressDecoder()],
+    ["blockhash", web3_js.getAddressDecoder()],
+    ["lamportsPerSignature", web3_js.getU64Decoder()]
   ]);
 }
-function getNonceAccountDataCodec() {
-  return codecs.combineCodec(
-    getNonceAccountDataEncoder(),
-    getNonceAccountDataDecoder()
-  );
+function getNonceCodec() {
+  return web3_js.combineCodec(getNonceEncoder(), getNonceDecoder());
 }
 function decodeNonce(encodedAccount) {
-  return accounts.decodeAccount(
+  return web3_js.decodeAccount(
     encodedAccount,
-    getNonceAccountDataDecoder()
+    getNonceDecoder()
   );
 }
 async function fetchNonce(rpc, address, config) {
   const maybeAccount = await fetchMaybeNonce(rpc, address, config);
-  accounts.assertAccountExists(maybeAccount);
+  web3_js.assertAccountExists(maybeAccount);
   return maybeAccount;
 }
 async function fetchMaybeNonce(rpc, address, config) {
-  const maybeAccount = await accounts.fetchEncodedAccount(rpc, address, config);
+  const maybeAccount = await web3_js.fetchEncodedAccount(rpc, address, config);
   return decodeNonce(maybeAccount);
 }
 async function fetchAllNonce(rpc, addresses, config) {
   const maybeAccounts = await fetchAllMaybeNonce(rpc, addresses, config);
-  accounts.assertAccountsExist(maybeAccounts);
+  web3_js.assertAccountsExist(maybeAccounts);
   return maybeAccounts;
 }
 async function fetchAllMaybeNonce(rpc, addresses, config) {
-  const maybeAccounts = await accounts.fetchEncodedAccounts(rpc, addresses, config);
+  const maybeAccounts = await web3_js.fetchEncodedAccounts(rpc, addresses, config);
   return maybeAccounts.map((maybeAccount) => decodeNonce(maybeAccount));
 }
 function getNonceSize() {
@@ -91,89 +84,100 @@ function getNonceSize() {
 }
 
 // src/generated/errors/system.ts
-var SystemProgramErrorCode = /* @__PURE__ */ ((SystemProgramErrorCode3) => {
-  SystemProgramErrorCode3[SystemProgramErrorCode3["ACCOUNT_ALREADY_IN_USE"] = 0] = "ACCOUNT_ALREADY_IN_USE";
-  SystemProgramErrorCode3[SystemProgramErrorCode3["RESULT_WITH_NEGATIVE_LAMPORTS"] = 1] = "RESULT_WITH_NEGATIVE_LAMPORTS";
-  SystemProgramErrorCode3[SystemProgramErrorCode3["INVALID_PROGRAM_ID"] = 2] = "INVALID_PROGRAM_ID";
-  SystemProgramErrorCode3[SystemProgramErrorCode3["INVALID_ACCOUNT_DATA_LENGTH"] = 3] = "INVALID_ACCOUNT_DATA_LENGTH";
-  SystemProgramErrorCode3[SystemProgramErrorCode3["MAX_SEED_LENGTH_EXCEEDED"] = 4] = "MAX_SEED_LENGTH_EXCEEDED";
-  SystemProgramErrorCode3[SystemProgramErrorCode3["ADDRESS_WITH_SEED_MISMATCH"] = 5] = "ADDRESS_WITH_SEED_MISMATCH";
-  SystemProgramErrorCode3[SystemProgramErrorCode3["NONCE_NO_RECENT_BLOCKHASHES"] = 6] = "NONCE_NO_RECENT_BLOCKHASHES";
-  SystemProgramErrorCode3[SystemProgramErrorCode3["NONCE_BLOCKHASH_NOT_EXPIRED"] = 7] = "NONCE_BLOCKHASH_NOT_EXPIRED";
-  SystemProgramErrorCode3[SystemProgramErrorCode3["NONCE_UNEXPECTED_BLOCKHASH_VALUE"] = 8] = "NONCE_UNEXPECTED_BLOCKHASH_VALUE";
-  return SystemProgramErrorCode3;
-})(SystemProgramErrorCode || {});
-var SystemProgramError = class extends Error {
-  name = "SystemProgramError";
-  code;
-  cause;
-  constructor(code, name, message, cause) {
-    super(`${name} (${code}): ${message}`);
-    this.code = code;
-    this.cause = cause;
-  }
-};
-var systemProgramErrorCodeMap;
+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 (__DEV__) {
-  systemProgramErrorCodeMap = {
-    [0 /* ACCOUNT_ALREADY_IN_USE */]: [
-      "AccountAlreadyInUse",
-      `an account with the same address already exists`
-    ],
-    [1 /* RESULT_WITH_NEGATIVE_LAMPORTS */]: [
-      "ResultWithNegativeLamports",
-      `account does not have enough SOL to perform the operation`
-    ],
-    [2 /* INVALID_PROGRAM_ID */]: [
-      "InvalidProgramId",
-      `cannot assign account to this program id`
-    ],
-    [3 /* INVALID_ACCOUNT_DATA_LENGTH */]: [
-      "InvalidAccountDataLength",
-      `cannot allocate account data of this length`
-    ],
-    [4 /* MAX_SEED_LENGTH_EXCEEDED */]: [
-      "MaxSeedLengthExceeded",
-      `length of requested seed is too long`
-    ],
-    [5 /* ADDRESS_WITH_SEED_MISMATCH */]: [
-      "AddressWithSeedMismatch",
-      `provided address does not match addressed derived from seed`
-    ],
-    [6 /* NONCE_NO_RECENT_BLOCKHASHES */]: [
-      "NonceNoRecentBlockhashes",
-      `advancing stored nonce requires a populated RecentBlockhashes sysvar`
-    ],
-    [7 /* NONCE_BLOCKHASH_NOT_EXPIRED */]: [
-      "NonceBlockhashNotExpired",
-      `stored nonce is still in recent_blockhashes`
-    ],
-    [8 /* NONCE_UNEXPECTED_BLOCKHASH_VALUE */]: [
-      "NonceUnexpectedBlockhashValue",
-      `specified nonce does not match stored nonce`
-    ]
+  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 getSystemProgramErrorFromCode(code, cause) {
+function getSystemErrorMessage(code) {
   if (__DEV__) {
-    return new SystemProgramError(
-      code,
-      ...systemProgramErrorCodeMap[code],
-      cause
-    );
+    return systemErrorMessages[code];
   }
-  return new SystemProgramError(
-    code,
-    "Unknown",
-    "Error message not available in production bundles. Compile with __DEV__ set to true to see more information.",
-    cause
-  );
+  return "Error message not available in production bundles. Compile with `__DEV__` set to true to see more information.";
 }
-function expectSome(value) {
-  if (value == null) {
-    throw new Error("Expected a value but received null or undefined.");
+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 = instruction instanceof Uint8Array ? instruction : instruction.data;
+  if (web3_js.containsBytes(data, web3_js.getU32Encoder().encode(0), 0)) {
+    return 0 /* CreateAccount */;
   }
-  return value;
+  if (web3_js.containsBytes(data, web3_js.getU32Encoder().encode(1), 0)) {
+    return 1 /* Assign */;
+  }
+  if (web3_js.containsBytes(data, web3_js.getU32Encoder().encode(2), 0)) {
+    return 2 /* TransferSol */;
+  }
+  if (web3_js.containsBytes(data, web3_js.getU32Encoder().encode(3), 0)) {
+    return 3 /* CreateAccountWithSeed */;
+  }
+  if (web3_js.containsBytes(data, web3_js.getU32Encoder().encode(4), 0)) {
+    return 4 /* AdvanceNonceAccount */;
+  }
+  if (web3_js.containsBytes(data, web3_js.getU32Encoder().encode(5), 0)) {
+    return 5 /* WithdrawNonceAccount */;
+  }
+  if (web3_js.containsBytes(data, web3_js.getU32Encoder().encode(6), 0)) {
+    return 6 /* InitializeNonceAccount */;
+  }
+  if (web3_js.containsBytes(data, web3_js.getU32Encoder().encode(7), 0)) {
+    return 7 /* AuthorizeNonceAccount */;
+  }
+  if (web3_js.containsBytes(data, web3_js.getU32Encoder().encode(8), 0)) {
+    return 8 /* Allocate */;
+  }
+  if (web3_js.containsBytes(data, web3_js.getU32Encoder().encode(9), 0)) {
+    return 9 /* AllocateWithSeed */;
+  }
+  if (web3_js.containsBytes(data, web3_js.getU32Encoder().encode(10), 0)) {
+    return 10 /* AssignWithSeed */;
+  }
+  if (web3_js.containsBytes(data, web3_js.getU32Encoder().encode(11), 0)) {
+    return 11 /* TransferSolWithSeed */;
+  }
+  if (web3_js.containsBytes(data, web3_js.getU32Encoder().encode(12), 0)) {
+    return 12 /* UpgradeNonceAccount */;
+  }
+  throw new Error(
+    "The provided instruction could not be identified as a system instruction."
+  );
 }
 function expectAddress(value) {
   if (!value) {
@@ -187,74 +191,45 @@ function expectAddress(value) {
   }
   return value;
 }
-function expectProgramDerivedAddress(value) {
-  if (!value || !Array.isArray(value) || !addresses.isProgramDerivedAddress(value)) {
-    throw new Error("Expected a ProgramDerivedAddress.");
-  }
-  return value;
-}
-function expectTransactionSigner(value) {
-  if (!value || !isTransactionSigner(value)) {
-    throw new Error("Expected a TransactionSigner.");
-  }
-  return value;
-}
-function accountMetaWithDefault(account, role) {
-  if (account === void 0)
-    return void 0;
-  return typeof account === "string" ? { address: account, role } : account;
-}
-function getAccountMetasWithSigners(accounts, optionalAccountStrategy, programAddress) {
-  const accountMetas = {};
-  Object.keys(accounts).forEach((key) => {
-    const account = accounts[key];
+function getAccountMetaFactory(programAddress, optionalAccountStrategy) {
+  return (account) => {
     if (!account.value) {
-      if (optionalAccountStrategy === "omitted")
-        return;
-      accountMetas[key] = {
+      return Object.freeze({
         address: programAddress,
-        role: instructions.AccountRole.READONLY
-      };
-      return;
+        role: web3_js.AccountRole.READONLY
+      });
     }
-    const writableRole = account.isWritable ? instructions.AccountRole.WRITABLE : instructions.AccountRole.READONLY;
-    accountMetas[key] = Object.freeze({
+    const writableRole = account.isWritable ? web3_js.AccountRole.WRITABLE : web3_js.AccountRole.READONLY;
+    return Object.freeze({
       address: expectAddress(account.value),
-      role: isTransactionSigner(account.value) ? instructions.upgradeRoleToSigner(writableRole) : writableRole,
+      role: isTransactionSigner(account.value) ? web3_js.upgradeRoleToSigner(writableRole) : writableRole,
       ...isTransactionSigner(account.value) ? { signer: account.value } : {}
     });
-  });
-  return accountMetas;
+  };
 }
 function isTransactionSigner(value) {
-  return !!value && typeof value === "object" && "address" in value && signers.isTransactionSigner(value);
-}
-function memcmp(data, bytes, offset) {
-  const slice = data.slice(offset, offset + bytes.length);
-  if (slice.length !== bytes.length)
-    return false;
-  return bytes.every((b, i) => b === slice[i]);
+  return !!value && typeof value === "object" && "address" in value && web3_js.isTransactionSigner(value);
 }
 
 // src/generated/instructions/advanceNonceAccount.ts
 function getAdvanceNonceAccountInstructionDataEncoder() {
-  return codecs.mapEncoder(
-    codecs.getStructEncoder([["discriminator", codecs.getU32Encoder()]]),
+  return web3_js.transformEncoder(
+    web3_js.getStructEncoder([["discriminator", web3_js.getU32Encoder()]]),
     (value) => ({ ...value, discriminator: 4 })
   );
 }
 function getAdvanceNonceAccountInstructionDataDecoder() {
-  return codecs.getStructDecoder([["discriminator", codecs.getU32Decoder()]]);
+  return web3_js.getStructDecoder([["discriminator", web3_js.getU32Decoder()]]);
 }
 function getAdvanceNonceAccountInstructionDataCodec() {
-  return codecs.combineCodec(
+  return web3_js.combineCodec(
     getAdvanceNonceAccountInstructionDataEncoder(),
     getAdvanceNonceAccountInstructionDataDecoder()
   );
 }
 function getAdvanceNonceAccountInstruction(input) {
-  const programAddress = "11111111111111111111111111111111";
-  const accounts = {
+  const programAddress = SYSTEM_PROGRAM_ADDRESS;
+  const originalAccounts = {
     nonceAccount: { value: input.nonceAccount ?? null, isWritable: true },
     recentBlockhashesSysvar: {
       value: input.recentBlockhashesSysvar ?? null,
@@ -262,37 +237,21 @@ function getAdvanceNonceAccountInstruction(input) {
     },
     nonceAuthority: { value: input.nonceAuthority ?? null, isWritable: false }
   };
+  const accounts = originalAccounts;
   if (!accounts.recentBlockhashesSysvar.value) {
     accounts.recentBlockhashesSysvar.value = "SysvarRecentB1ockHashes11111111111111111111";
   }
-  const accountMetas = getAccountMetasWithSigners(
-    accounts,
-    "programId",
-    programAddress
-  );
-  const instruction = getAdvanceNonceAccountInstructionRaw(
-    accountMetas,
-    programAddress
-  );
-  return instruction;
-}
-function getAdvanceNonceAccountInstructionRaw(accounts, programAddress = "11111111111111111111111111111111", remainingAccounts) {
-  return {
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  const instruction = {
     accounts: [
-      accountMetaWithDefault(accounts.nonceAccount, instructions.AccountRole.WRITABLE),
-      accountMetaWithDefault(
-        accounts.recentBlockhashesSysvar ?? "SysvarRecentB1ockHashes11111111111111111111",
-        instructions.AccountRole.READONLY
-      ),
-      accountMetaWithDefault(
-        accounts.nonceAuthority,
-        instructions.AccountRole.READONLY_SIGNER
-      ),
-      ...remainingAccounts ?? []
+      getAccountMeta(accounts.nonceAccount),
+      getAccountMeta(accounts.recentBlockhashesSysvar),
+      getAccountMeta(accounts.nonceAuthority)
     ],
-    data: getAdvanceNonceAccountInstructionDataEncoder().encode({}),
-    programAddress
+    programAddress,
+    data: getAdvanceNonceAccountInstructionDataEncoder().encode({})
   };
+  return instruction;
 }
 function parseAdvanceNonceAccountInstruction(instruction) {
   if (instruction.accounts.length < 3) {
@@ -317,53 +276,42 @@ function parseAdvanceNonceAccountInstruction(instruction) {
   };
 }
 function getAllocateInstructionDataEncoder() {
-  return codecs.mapEncoder(
-    codecs.getStructEncoder([
-      ["discriminator", codecs.getU32Encoder()],
-      ["space", codecs.getU64Encoder()]
+  return web3_js.transformEncoder(
+    web3_js.getStructEncoder([
+      ["discriminator", web3_js.getU32Encoder()],
+      ["space", web3_js.getU64Encoder()]
     ]),
     (value) => ({ ...value, discriminator: 8 })
   );
 }
 function getAllocateInstructionDataDecoder() {
-  return codecs.getStructDecoder([
-    ["discriminator", codecs.getU32Decoder()],
-    ["space", codecs.getU64Decoder()]
+  return web3_js.getStructDecoder([
+    ["discriminator", web3_js.getU32Decoder()],
+    ["space", web3_js.getU64Decoder()]
   ]);
 }
 function getAllocateInstructionDataCodec() {
-  return codecs.combineCodec(
+  return web3_js.combineCodec(
     getAllocateInstructionDataEncoder(),
     getAllocateInstructionDataDecoder()
   );
 }
 function getAllocateInstruction(input) {
-  const programAddress = "11111111111111111111111111111111";
-  const accounts = {
+  const programAddress = SYSTEM_PROGRAM_ADDRESS;
+  const originalAccounts = {
     newAccount: { value: input.newAccount ?? null, isWritable: true }
   };
+  const accounts = originalAccounts;
   const args = { ...input };
-  const accountMetas = getAccountMetasWithSigners(
-    accounts,
-    "programId",
-    programAddress
-  );
-  const instruction = getAllocateInstructionRaw(
-    accountMetas,
-    args,
-    programAddress
-  );
-  return instruction;
-}
-function getAllocateInstructionRaw(accounts, args, programAddress = "11111111111111111111111111111111", remainingAccounts) {
-  return {
-    accounts: [
-      accountMetaWithDefault(accounts.newAccount, instructions.AccountRole.WRITABLE_SIGNER),
-      ...remainingAccounts ?? []
-    ],
-    data: getAllocateInstructionDataEncoder().encode(args),
-    programAddress
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  const instruction = {
+    accounts: [getAccountMeta(accounts.newAccount)],
+    programAddress,
+    data: getAllocateInstructionDataEncoder().encode(
+      args
+    )
   };
+  return instruction;
 }
 function parseAllocateInstruction(instruction) {
   if (instruction.accounts.length < 1) {
@@ -384,61 +332,52 @@ function parseAllocateInstruction(instruction) {
   };
 }
 function getAllocateWithSeedInstructionDataEncoder() {
-  return codecs.mapEncoder(
-    codecs.getStructEncoder([
-      ["discriminator", codecs.getU32Encoder()],
-      ["base", addresses.getAddressEncoder()],
-      ["seed", codecs.getStringEncoder()],
-      ["space", codecs.getU64Encoder()],
-      ["programAddress", addresses.getAddressEncoder()]
+  return web3_js.transformEncoder(
+    web3_js.getStructEncoder([
+      ["discriminator", web3_js.getU32Encoder()],
+      ["base", web3_js.getAddressEncoder()],
+      ["seed", web3_js.addEncoderSizePrefix(web3_js.getUtf8Encoder(), web3_js.getU32Encoder())],
+      ["space", web3_js.getU64Encoder()],
+      ["programAddress", web3_js.getAddressEncoder()]
     ]),
     (value) => ({ ...value, discriminator: 9 })
   );
 }
 function getAllocateWithSeedInstructionDataDecoder() {
-  return codecs.getStructDecoder([
-    ["discriminator", codecs.getU32Decoder()],
-    ["base", addresses.getAddressDecoder()],
-    ["seed", codecs.getStringDecoder()],
-    ["space", codecs.getU64Decoder()],
-    ["programAddress", addresses.getAddressDecoder()]
+  return web3_js.getStructDecoder([
+    ["discriminator", web3_js.getU32Decoder()],
+    ["base", web3_js.getAddressDecoder()],
+    ["seed", web3_js.addDecoderSizePrefix(web3_js.getUtf8Decoder(), web3_js.getU32Decoder())],
+    ["space", web3_js.getU64Decoder()],
+    ["programAddress", web3_js.getAddressDecoder()]
   ]);
 }
 function getAllocateWithSeedInstructionDataCodec() {
-  return codecs.combineCodec(
+  return web3_js.combineCodec(
     getAllocateWithSeedInstructionDataEncoder(),
     getAllocateWithSeedInstructionDataDecoder()
   );
 }
 function getAllocateWithSeedInstruction(input) {
-  const programAddress = "11111111111111111111111111111111";
-  const accounts = {
+  const programAddress = SYSTEM_PROGRAM_ADDRESS;
+  const originalAccounts = {
     newAccount: { value: input.newAccount ?? null, isWritable: true },
     baseAccount: { value: input.baseAccount ?? null, isWritable: false }
   };
+  const accounts = originalAccounts;
   const args = { ...input };
-  const accountMetas = getAccountMetasWithSigners(
-    accounts,
-    "programId",
-    programAddress
-  );
-  const instruction = getAllocateWithSeedInstructionRaw(
-    accountMetas,
-    args,
-    programAddress
-  );
-  return instruction;
-}
-function getAllocateWithSeedInstructionRaw(accounts, args, programAddress = "11111111111111111111111111111111", remainingAccounts) {
-  return {
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  const instruction = {
     accounts: [
-      accountMetaWithDefault(accounts.newAccount, instructions.AccountRole.WRITABLE),
-      accountMetaWithDefault(accounts.baseAccount, instructions.AccountRole.READONLY_SIGNER),
-      ...remainingAccounts ?? []
+      getAccountMeta(accounts.newAccount),
+      getAccountMeta(accounts.baseAccount)
     ],
-    data: getAllocateWithSeedInstructionDataEncoder().encode(args),
-    programAddress
+    programAddress,
+    data: getAllocateWithSeedInstructionDataEncoder().encode(
+      args
+    )
   };
+  return instruction;
 }
 function parseAllocateWithSeedInstruction(instruction) {
   if (instruction.accounts.length < 2) {
@@ -460,53 +399,42 @@ function parseAllocateWithSeedInstruction(instruction) {
   };
 }
 function getAssignInstructionDataEncoder() {
-  return codecs.mapEncoder(
-    codecs.getStructEncoder([
-      ["discriminator", codecs.getU32Encoder()],
-      ["programAddress", addresses.getAddressEncoder()]
+  return web3_js.transformEncoder(
+    web3_js.getStructEncoder([
+      ["discriminator", web3_js.getU32Encoder()],
+      ["programAddress", web3_js.getAddressEncoder()]
     ]),
     (value) => ({ ...value, discriminator: 1 })
   );
 }
 function getAssignInstructionDataDecoder() {
-  return codecs.getStructDecoder([
-    ["discriminator", codecs.getU32Decoder()],
-    ["programAddress", addresses.getAddressDecoder()]
+  return web3_js.getStructDecoder([
+    ["discriminator", web3_js.getU32Decoder()],
+    ["programAddress", web3_js.getAddressDecoder()]
   ]);
 }
 function getAssignInstructionDataCodec() {
-  return codecs.combineCodec(
+  return web3_js.combineCodec(
     getAssignInstructionDataEncoder(),
     getAssignInstructionDataDecoder()
   );
 }
 function getAssignInstruction(input) {
-  const programAddress = "11111111111111111111111111111111";
-  const accounts = {
+  const programAddress = SYSTEM_PROGRAM_ADDRESS;
+  const originalAccounts = {
     account: { value: input.account ?? null, isWritable: true }
   };
+  const accounts = originalAccounts;
   const args = { ...input };
-  const accountMetas = getAccountMetasWithSigners(
-    accounts,
-    "programId",
-    programAddress
-  );
-  const instruction = getAssignInstructionRaw(
-    accountMetas,
-    args,
-    programAddress
-  );
-  return instruction;
-}
-function getAssignInstructionRaw(accounts, args, programAddress = "11111111111111111111111111111111", remainingAccounts) {
-  return {
-    accounts: [
-      accountMetaWithDefault(accounts.account, instructions.AccountRole.WRITABLE_SIGNER),
-      ...remainingAccounts ?? []
-    ],
-    data: getAssignInstructionDataEncoder().encode(args),
-    programAddress
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  const instruction = {
+    accounts: [getAccountMeta(accounts.account)],
+    programAddress,
+    data: getAssignInstructionDataEncoder().encode(
+      args
+    )
   };
+  return instruction;
 }
 function parseAssignInstruction(instruction) {
   if (instruction.accounts.length < 1) {
@@ -527,59 +455,50 @@ function parseAssignInstruction(instruction) {
   };
 }
 function getAssignWithSeedInstructionDataEncoder() {
-  return codecs.mapEncoder(
-    codecs.getStructEncoder([
-      ["discriminator", codecs.getU32Encoder()],
-      ["base", addresses.getAddressEncoder()],
-      ["seed", codecs.getStringEncoder()],
-      ["programAddress", addresses.getAddressEncoder()]
+  return web3_js.transformEncoder(
+    web3_js.getStructEncoder([
+      ["discriminator", web3_js.getU32Encoder()],
+      ["base", web3_js.getAddressEncoder()],
+      ["seed", web3_js.addEncoderSizePrefix(web3_js.getUtf8Encoder(), web3_js.getU32Encoder())],
+      ["programAddress", web3_js.getAddressEncoder()]
     ]),
     (value) => ({ ...value, discriminator: 10 })
   );
 }
 function getAssignWithSeedInstructionDataDecoder() {
-  return codecs.getStructDecoder([
-    ["discriminator", codecs.getU32Decoder()],
-    ["base", addresses.getAddressDecoder()],
-    ["seed", codecs.getStringDecoder()],
-    ["programAddress", addresses.getAddressDecoder()]
+  return web3_js.getStructDecoder([
+    ["discriminator", web3_js.getU32Decoder()],
+    ["base", web3_js.getAddressDecoder()],
+    ["seed", web3_js.addDecoderSizePrefix(web3_js.getUtf8Decoder(), web3_js.getU32Decoder())],
+    ["programAddress", web3_js.getAddressDecoder()]
   ]);
 }
 function getAssignWithSeedInstructionDataCodec() {
-  return codecs.combineCodec(
+  return web3_js.combineCodec(
     getAssignWithSeedInstructionDataEncoder(),
     getAssignWithSeedInstructionDataDecoder()
   );
 }
 function getAssignWithSeedInstruction(input) {
-  const programAddress = "11111111111111111111111111111111";
-  const accounts = {
+  const programAddress = SYSTEM_PROGRAM_ADDRESS;
+  const originalAccounts = {
     account: { value: input.account ?? null, isWritable: true },
     baseAccount: { value: input.baseAccount ?? null, isWritable: false }
   };
+  const accounts = originalAccounts;
   const args = { ...input };
-  const accountMetas = getAccountMetasWithSigners(
-    accounts,
-    "programId",
-    programAddress
-  );
-  const instruction = getAssignWithSeedInstructionRaw(
-    accountMetas,
-    args,
-    programAddress
-  );
-  return instruction;
-}
-function getAssignWithSeedInstructionRaw(accounts, args, programAddress = "11111111111111111111111111111111", remainingAccounts) {
-  return {
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  const instruction = {
     accounts: [
-      accountMetaWithDefault(accounts.account, instructions.AccountRole.WRITABLE),
-      accountMetaWithDefault(accounts.baseAccount, instructions.AccountRole.READONLY_SIGNER),
-      ...remainingAccounts ?? []
+      getAccountMeta(accounts.account),
+      getAccountMeta(accounts.baseAccount)
     ],
-    data: getAssignWithSeedInstructionDataEncoder().encode(args),
-    programAddress
+    programAddress,
+    data: getAssignWithSeedInstructionDataEncoder().encode(
+      args
+    )
   };
+  return instruction;
 }
 function parseAssignWithSeedInstruction(instruction) {
   if (instruction.accounts.length < 2) {
@@ -601,58 +520,46 @@ function parseAssignWithSeedInstruction(instruction) {
   };
 }
 function getAuthorizeNonceAccountInstructionDataEncoder() {
-  return codecs.mapEncoder(
-    codecs.getStructEncoder([
-      ["discriminator", codecs.getU32Encoder()],
-      ["newNonceAuthority", addresses.getAddressEncoder()]
+  return web3_js.transformEncoder(
+    web3_js.getStructEncoder([
+      ["discriminator", web3_js.getU32Encoder()],
+      ["newNonceAuthority", web3_js.getAddressEncoder()]
     ]),
     (value) => ({ ...value, discriminator: 7 })
   );
 }
 function getAuthorizeNonceAccountInstructionDataDecoder() {
-  return codecs.getStructDecoder([
-    ["discriminator", codecs.getU32Decoder()],
-    ["newNonceAuthority", addresses.getAddressDecoder()]
+  return web3_js.getStructDecoder([
+    ["discriminator", web3_js.getU32Decoder()],
+    ["newNonceAuthority", web3_js.getAddressDecoder()]
   ]);
 }
 function getAuthorizeNonceAccountInstructionDataCodec() {
-  return codecs.combineCodec(
+  return web3_js.combineCodec(
     getAuthorizeNonceAccountInstructionDataEncoder(),
     getAuthorizeNonceAccountInstructionDataDecoder()
   );
 }
 function getAuthorizeNonceAccountInstruction(input) {
-  const programAddress = "11111111111111111111111111111111";
-  const accounts = {
+  const programAddress = SYSTEM_PROGRAM_ADDRESS;
+  const originalAccounts = {
     nonceAccount: { value: input.nonceAccount ?? null, isWritable: true },
     nonceAuthority: { value: input.nonceAuthority ?? null, isWritable: false }
   };
+  const accounts = originalAccounts;
   const args = { ...input };
-  const accountMetas = getAccountMetasWithSigners(
-    accounts,
-    "programId",
-    programAddress
-  );
-  const instruction = getAuthorizeNonceAccountInstructionRaw(
-    accountMetas,
-    args,
-    programAddress
-  );
-  return instruction;
-}
-function getAuthorizeNonceAccountInstructionRaw(accounts, args, programAddress = "11111111111111111111111111111111", remainingAccounts) {
-  return {
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  const instruction = {
     accounts: [
-      accountMetaWithDefault(accounts.nonceAccount, instructions.AccountRole.WRITABLE),
-      accountMetaWithDefault(
-        accounts.nonceAuthority,
-        instructions.AccountRole.READONLY_SIGNER
-      ),
-      ...remainingAccounts ?? []
+      getAccountMeta(accounts.nonceAccount),
+      getAccountMeta(accounts.nonceAuthority)
     ],
-    data: getAuthorizeNonceAccountInstructionDataEncoder().encode(args),
-    programAddress
+    programAddress,
+    data: getAuthorizeNonceAccountInstructionDataEncoder().encode(
+      args
+    )
   };
+  return instruction;
 }
 function parseAuthorizeNonceAccountInstruction(instruction) {
   if (instruction.accounts.length < 2) {
@@ -676,63 +583,54 @@ function parseAuthorizeNonceAccountInstruction(instruction) {
   };
 }
 function getCreateAccountInstructionDataEncoder() {
-  return codecs.mapEncoder(
-    codecs.getStructEncoder([
-      ["discriminator", codecs.getU32Encoder()],
-      ["lamports", codecs.getU64Encoder()],
-      ["space", codecs.getU64Encoder()],
-      ["programAddress", addresses.getAddressEncoder()]
+  return web3_js.transformEncoder(
+    web3_js.getStructEncoder([
+      ["discriminator", web3_js.getU32Encoder()],
+      ["lamports", web3_js.getU64Encoder()],
+      ["space", web3_js.getU64Encoder()],
+      ["programAddress", web3_js.getAddressEncoder()]
     ]),
     (value) => ({ ...value, discriminator: 0 })
   );
 }
 function getCreateAccountInstructionDataDecoder() {
-  return codecs.getStructDecoder([
-    ["discriminator", codecs.getU32Decoder()],
-    ["lamports", codecs.getU64Decoder()],
-    ["space", codecs.getU64Decoder()],
-    ["programAddress", addresses.getAddressDecoder()]
+  return web3_js.getStructDecoder([
+    ["discriminator", web3_js.getU32Decoder()],
+    ["lamports", web3_js.getU64Decoder()],
+    ["space", web3_js.getU64Decoder()],
+    ["programAddress", web3_js.getAddressDecoder()]
   ]);
 }
 function getCreateAccountInstructionDataCodec() {
-  return codecs.combineCodec(
+  return web3_js.combineCodec(
     getCreateAccountInstructionDataEncoder(),
     getCreateAccountInstructionDataDecoder()
   );
 }
 function getCreateAccountInstruction(input) {
-  const programAddress = "11111111111111111111111111111111";
-  const accounts$1 = {
+  const programAddress = SYSTEM_PROGRAM_ADDRESS;
+  const originalAccounts = {
     payer: { value: input.payer ?? null, isWritable: true },
     newAccount: { value: input.newAccount ?? null, isWritable: true }
   };
+  const accounts = originalAccounts;
   const args = { ...input };
-  const byteDelta = [Number(args.space) + accounts.BASE_ACCOUNT_SIZE].reduce(
+  const byteDelta = [Number(args.space) + web3_js.BASE_ACCOUNT_SIZE].reduce(
     (a, b) => a + b,
     0
   );
-  const accountMetas = getAccountMetasWithSigners(
-    accounts$1,
-    "programId",
-    programAddress
-  );
-  const instruction = getCreateAccountInstructionRaw(
-    accountMetas,
-    args,
-    programAddress
-  );
-  return Object.freeze({ ...instruction, byteDelta });
-}
-function getCreateAccountInstructionRaw(accounts, args, programAddress = "11111111111111111111111111111111", remainingAccounts) {
-  return {
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  const instruction = {
     accounts: [
-      accountMetaWithDefault(accounts.payer, instructions.AccountRole.WRITABLE_SIGNER),
-      accountMetaWithDefault(accounts.newAccount, instructions.AccountRole.WRITABLE_SIGNER),
-      ...remainingAccounts ?? []
+      getAccountMeta(accounts.payer),
+      getAccountMeta(accounts.newAccount)
     ],
-    data: getCreateAccountInstructionDataEncoder().encode(args),
-    programAddress
+    programAddress,
+    data: getCreateAccountInstructionDataEncoder().encode(
+      args
+    )
   };
+  return Object.freeze({ ...instruction, byteDelta });
 }
 function parseCreateAccountInstruction(instruction) {
   if (instruction.accounts.length < 2) {
@@ -754,65 +652,56 @@ function parseCreateAccountInstruction(instruction) {
   };
 }
 function getCreateAccountWithSeedInstructionDataEncoder() {
-  return codecs.mapEncoder(
-    codecs.getStructEncoder([
-      ["discriminator", codecs.getU32Encoder()],
-      ["base", addresses.getAddressEncoder()],
-      ["seed", codecs.getStringEncoder()],
-      ["amount", codecs.getU64Encoder()],
-      ["space", codecs.getU64Encoder()],
-      ["programAddress", addresses.getAddressEncoder()]
+  return web3_js.transformEncoder(
+    web3_js.getStructEncoder([
+      ["discriminator", web3_js.getU32Encoder()],
+      ["base", web3_js.getAddressEncoder()],
+      ["seed", web3_js.addEncoderSizePrefix(web3_js.getUtf8Encoder(), web3_js.getU32Encoder())],
+      ["amount", web3_js.getU64Encoder()],
+      ["space", web3_js.getU64Encoder()],
+      ["programAddress", web3_js.getAddressEncoder()]
     ]),
     (value) => ({ ...value, discriminator: 3 })
   );
 }
 function getCreateAccountWithSeedInstructionDataDecoder() {
-  return codecs.getStructDecoder([
-    ["discriminator", codecs.getU32Decoder()],
-    ["base", addresses.getAddressDecoder()],
-    ["seed", codecs.getStringDecoder()],
-    ["amount", codecs.getU64Decoder()],
-    ["space", codecs.getU64Decoder()],
-    ["programAddress", addresses.getAddressDecoder()]
+  return web3_js.getStructDecoder([
+    ["discriminator", web3_js.getU32Decoder()],
+    ["base", web3_js.getAddressDecoder()],
+    ["seed", web3_js.addDecoderSizePrefix(web3_js.getUtf8Decoder(), web3_js.getU32Decoder())],
+    ["amount", web3_js.getU64Decoder()],
+    ["space", web3_js.getU64Decoder()],
+    ["programAddress", web3_js.getAddressDecoder()]
   ]);
 }
 function getCreateAccountWithSeedInstructionDataCodec() {
-  return codecs.combineCodec(
+  return web3_js.combineCodec(
     getCreateAccountWithSeedInstructionDataEncoder(),
     getCreateAccountWithSeedInstructionDataDecoder()
   );
 }
 function getCreateAccountWithSeedInstruction(input) {
-  const programAddress = "11111111111111111111111111111111";
-  const accounts = {
+  const programAddress = SYSTEM_PROGRAM_ADDRESS;
+  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;
   const args = { ...input };
-  const accountMetas = getAccountMetasWithSigners(
-    accounts,
-    "programId",
-    programAddress
-  );
-  const instruction = getCreateAccountWithSeedInstructionRaw(
-    accountMetas,
-    args,
-    programAddress
-  );
-  return instruction;
-}
-function getCreateAccountWithSeedInstructionRaw(accounts, args, programAddress = "11111111111111111111111111111111", remainingAccounts) {
-  return {
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  const instruction = {
     accounts: [
-      accountMetaWithDefault(accounts.payer, instructions.AccountRole.WRITABLE_SIGNER),
-      accountMetaWithDefault(accounts.newAccount, instructions.AccountRole.WRITABLE),
-      accountMetaWithDefault(accounts.baseAccount, instructions.AccountRole.READONLY_SIGNER),
-      ...remainingAccounts ?? []
+      getAccountMeta(accounts.payer),
+      getAccountMeta(accounts.newAccount),
+      getAccountMeta(accounts.baseAccount)
     ],
-    data: getCreateAccountWithSeedInstructionDataEncoder().encode(args),
-    programAddress
+    programAddress,
+    data: getCreateAccountWithSeedInstructionDataEncoder().encode(
+      args
+    )
   };
+  return instruction;
 }
 function parseCreateAccountWithSeedInstruction(instruction) {
   if (instruction.accounts.length < 3) {
@@ -837,29 +726,29 @@ function parseCreateAccountWithSeedInstruction(instruction) {
   };
 }
 function getInitializeNonceAccountInstructionDataEncoder() {
-  return codecs.mapEncoder(
-    codecs.getStructEncoder([
-      ["discriminator", codecs.getU32Encoder()],
-      ["nonceAuthority", addresses.getAddressEncoder()]
+  return web3_js.transformEncoder(
+    web3_js.getStructEncoder([
+      ["discriminator", web3_js.getU32Encoder()],
+      ["nonceAuthority", web3_js.getAddressEncoder()]
     ]),
     (value) => ({ ...value, discriminator: 6 })
   );
 }
 function getInitializeNonceAccountInstructionDataDecoder() {
-  return codecs.getStructDecoder([
-    ["discriminator", codecs.getU32Decoder()],
-    ["nonceAuthority", addresses.getAddressDecoder()]
+  return web3_js.getStructDecoder([
+    ["discriminator", web3_js.getU32Decoder()],
+    ["nonceAuthority", web3_js.getAddressDecoder()]
   ]);
 }
 function getInitializeNonceAccountInstructionDataCodec() {
-  return codecs.combineCodec(
+  return web3_js.combineCodec(
     getInitializeNonceAccountInstructionDataEncoder(),
     getInitializeNonceAccountInstructionDataDecoder()
   );
 }
 function getInitializeNonceAccountInstruction(input) {
-  const programAddress = "11111111111111111111111111111111";
-  const accounts = {
+  const programAddress = SYSTEM_PROGRAM_ADDRESS;
+  const originalAccounts = {
     nonceAccount: { value: input.nonceAccount ?? null, isWritable: true },
     recentBlockhashesSysvar: {
       value: input.recentBlockhashesSysvar ?? null,
@@ -867,6 +756,7 @@ function getInitializeNonceAccountInstruction(input) {
     },
     rentSysvar: { value: input.rentSysvar ?? null, isWritable: false }
   };
+  const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.recentBlockhashesSysvar.value) {
     accounts.recentBlockhashesSysvar.value = "SysvarRecentB1ockHashes11111111111111111111";
@@ -874,35 +764,19 @@ function getInitializeNonceAccountInstruction(input) {
   if (!accounts.rentSysvar.value) {
     accounts.rentSysvar.value = "SysvarRent111111111111111111111111111111111";
   }
-  const accountMetas = getAccountMetasWithSigners(
-    accounts,
-    "programId",
-    programAddress
-  );
-  const instruction = getInitializeNonceAccountInstructionRaw(
-    accountMetas,
-    args,
-    programAddress
-  );
-  return instruction;
-}
-function getInitializeNonceAccountInstructionRaw(accounts, args, programAddress = "11111111111111111111111111111111", remainingAccounts) {
-  return {
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  const instruction = {
     accounts: [
-      accountMetaWithDefault(accounts.nonceAccount, instructions.AccountRole.WRITABLE),
-      accountMetaWithDefault(
-        accounts.recentBlockhashesSysvar ?? "SysvarRecentB1ockHashes11111111111111111111",
-        instructions.AccountRole.READONLY
-      ),
-      accountMetaWithDefault(
-        accounts.rentSysvar ?? "SysvarRent111111111111111111111111111111111",
-        instructions.AccountRole.READONLY
-      ),
-      ...remainingAccounts ?? []
+      getAccountMeta(accounts.nonceAccount),
+      getAccountMeta(accounts.recentBlockhashesSysvar),
+      getAccountMeta(accounts.rentSysvar)
     ],
-    data: getInitializeNonceAccountInstructionDataEncoder().encode(args),
-    programAddress
+    programAddress,
+    data: getInitializeNonceAccountInstructionDataEncoder().encode(
+      args
+    )
   };
+  return instruction;
 }
 function parseInitializeNonceAccountInstruction(instruction) {
   if (instruction.accounts.length < 3) {
@@ -927,55 +801,46 @@ function parseInitializeNonceAccountInstruction(instruction) {
   };
 }
 function getTransferSolInstructionDataEncoder() {
-  return codecs.mapEncoder(
-    codecs.getStructEncoder([
-      ["discriminator", codecs.getU32Encoder()],
-      ["amount", codecs.getU64Encoder()]
+  return web3_js.transformEncoder(
+    web3_js.getStructEncoder([
+      ["discriminator", web3_js.getU32Encoder()],
+      ["amount", web3_js.getU64Encoder()]
     ]),
     (value) => ({ ...value, discriminator: 2 })
   );
 }
 function getTransferSolInstructionDataDecoder() {
-  return codecs.getStructDecoder([
-    ["discriminator", codecs.getU32Decoder()],
-    ["amount", codecs.getU64Decoder()]
+  return web3_js.getStructDecoder([
+    ["discriminator", web3_js.getU32Decoder()],
+    ["amount", web3_js.getU64Decoder()]
   ]);
 }
 function getTransferSolInstructionDataCodec() {
-  return codecs.combineCodec(
+  return web3_js.combineCodec(
     getTransferSolInstructionDataEncoder(),
     getTransferSolInstructionDataDecoder()
   );
 }
 function getTransferSolInstruction(input) {
-  const programAddress = "11111111111111111111111111111111";
-  const accounts = {
+  const programAddress = SYSTEM_PROGRAM_ADDRESS;
+  const originalAccounts = {
     source: { value: input.source ?? null, isWritable: true },
     destination: { value: input.destination ?? null, isWritable: true }
   };
+  const accounts = originalAccounts;
   const args = { ...input };
-  const accountMetas = getAccountMetasWithSigners(
-    accounts,
-    "programId",
-    programAddress
-  );
-  const instruction = getTransferSolInstructionRaw(
-    accountMetas,
-    args,
-    programAddress
-  );
-  return instruction;
-}
-function getTransferSolInstructionRaw(accounts, args, programAddress = "11111111111111111111111111111111", remainingAccounts) {
-  return {
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  const instruction = {
     accounts: [
-      accountMetaWithDefault(accounts.source, instructions.AccountRole.WRITABLE_SIGNER),
-      accountMetaWithDefault(accounts.destination, instructions.AccountRole.WRITABLE),
-      ...remainingAccounts ?? []
+      getAccountMeta(accounts.source),
+      getAccountMeta(accounts.destination)
     ],
-    data: getTransferSolInstructionDataEncoder().encode(args),
-    programAddress
+    programAddress,
+    data: getTransferSolInstructionDataEncoder().encode(
+      args
+    )
   };
+  return instruction;
 }
 function parseTransferSolInstruction(instruction) {
   if (instruction.accounts.length < 2) {
@@ -997,61 +862,52 @@ function parseTransferSolInstruction(instruction) {
   };
 }
 function getTransferSolWithSeedInstructionDataEncoder() {
-  return codecs.mapEncoder(
-    codecs.getStructEncoder([
-      ["discriminator", codecs.getU32Encoder()],
-      ["amount", codecs.getU64Encoder()],
-      ["fromSeed", codecs.getStringEncoder()],
-      ["fromOwner", addresses.getAddressEncoder()]
+  return web3_js.transformEncoder(
+    web3_js.getStructEncoder([
+      ["discriminator", web3_js.getU32Encoder()],
+      ["amount", web3_js.getU64Encoder()],
+      ["fromSeed", web3_js.addEncoderSizePrefix(web3_js.getUtf8Encoder(), web3_js.getU32Encoder())],
+      ["fromOwner", web3_js.getAddressEncoder()]
     ]),
     (value) => ({ ...value, discriminator: 11 })
   );
 }
 function getTransferSolWithSeedInstructionDataDecoder() {
-  return codecs.getStructDecoder([
-    ["discriminator", codecs.getU32Decoder()],
-    ["amount", codecs.getU64Decoder()],
-    ["fromSeed", codecs.getStringDecoder()],
-    ["fromOwner", addresses.getAddressDecoder()]
+  return web3_js.getStructDecoder([
+    ["discriminator", web3_js.getU32Decoder()],
+    ["amount", web3_js.getU64Decoder()],
+    ["fromSeed", web3_js.addDecoderSizePrefix(web3_js.getUtf8Decoder(), web3_js.getU32Decoder())],
+    ["fromOwner", web3_js.getAddressDecoder()]
   ]);
 }
 function getTransferSolWithSeedInstructionDataCodec() {
-  return codecs.combineCodec(
+  return web3_js.combineCodec(
     getTransferSolWithSeedInstructionDataEncoder(),
     getTransferSolWithSeedInstructionDataDecoder()
   );
 }
 function getTransferSolWithSeedInstruction(input) {
-  const programAddress = "11111111111111111111111111111111";
-  const accounts = {
+  const programAddress = SYSTEM_PROGRAM_ADDRESS;
+  const originalAccounts = {
     source: { value: input.source ?? null, isWritable: true },
     baseAccount: { value: input.baseAccount ?? null, isWritable: false },
     destination: { value: input.destination ?? null, isWritable: true }
   };
+  const accounts = originalAccounts;
   const args = { ...input };
-  const accountMetas = getAccountMetasWithSigners(
-    accounts,
-    "programId",
-    programAddress
-  );
-  const instruction = getTransferSolWithSeedInstructionRaw(
-    accountMetas,
-    args,
-    programAddress
-  );
-  return instruction;
-}
-function getTransferSolWithSeedInstructionRaw(accounts, args, programAddress = "11111111111111111111111111111111", remainingAccounts) {
-  return {
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  const instruction = {
     accounts: [
-      accountMetaWithDefault(accounts.source, instructions.AccountRole.WRITABLE),
-      accountMetaWithDefault(accounts.baseAccount, instructions.AccountRole.READONLY_SIGNER),
-      accountMetaWithDefault(accounts.destination, instructions.AccountRole.WRITABLE),
-      ...remainingAccounts ?? []
+      getAccountMeta(accounts.source),
+      getAccountMeta(accounts.baseAccount),
+      getAccountMeta(accounts.destination)
     ],
-    data: getTransferSolWithSeedInstructionDataEncoder().encode(args),
-    programAddress
+    programAddress,
+    data: getTransferSolWithSeedInstructionDataEncoder().encode(
+      args
+    )
   };
+  return instruction;
 }
 function parseTransferSolWithSeedInstruction(instruction) {
   if (instruction.accounts.length < 3) {
@@ -1076,45 +932,33 @@ function parseTransferSolWithSeedInstruction(instruction) {
   };
 }
 function getUpgradeNonceAccountInstructionDataEncoder() {
-  return codecs.mapEncoder(
-    codecs.getStructEncoder([["discriminator", codecs.getU32Encoder()]]),
+  return web3_js.transformEncoder(
+    web3_js.getStructEncoder([["discriminator", web3_js.getU32Encoder()]]),
     (value) => ({ ...value, discriminator: 12 })
   );
 }
 function getUpgradeNonceAccountInstructionDataDecoder() {
-  return codecs.getStructDecoder([["discriminator", codecs.getU32Decoder()]]);
+  return web3_js.getStructDecoder([["discriminator", web3_js.getU32Decoder()]]);
 }
 function getUpgradeNonceAccountInstructionDataCodec() {
-  return codecs.combineCodec(
+  return web3_js.combineCodec(
     getUpgradeNonceAccountInstructionDataEncoder(),
     getUpgradeNonceAccountInstructionDataDecoder()
   );
 }
 function getUpgradeNonceAccountInstruction(input) {
-  const programAddress = "11111111111111111111111111111111";
-  const accounts = {
+  const programAddress = SYSTEM_PROGRAM_ADDRESS;
+  const originalAccounts = {
     nonceAccount: { value: input.nonceAccount ?? null, isWritable: true }
   };
-  const accountMetas = getAccountMetasWithSigners(
-    accounts,
-    "programId",
-    programAddress
-  );
-  const instruction = getUpgradeNonceAccountInstructionRaw(
-    accountMetas,
-    programAddress
-  );
-  return instruction;
-}
-function getUpgradeNonceAccountInstructionRaw(accounts, programAddress = "11111111111111111111111111111111", remainingAccounts) {
-  return {
-    accounts: [
-      accountMetaWithDefault(accounts.nonceAccount, instructions.AccountRole.WRITABLE),
-      ...remainingAccounts ?? []
-    ],
-    data: getUpgradeNonceAccountInstructionDataEncoder().encode({}),
-    programAddress
+  const accounts = originalAccounts;
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  const instruction = {
+    accounts: [getAccountMeta(accounts.nonceAccount)],
+    programAddress,
+    data: getUpgradeNonceAccountInstructionDataEncoder().encode({})
   };
+  return instruction;
 }
 function parseUpgradeNonceAccountInstruction(instruction) {
   if (instruction.accounts.length < 1) {
@@ -1137,29 +981,29 @@ function parseUpgradeNonceAccountInstruction(instruction) {
   };
 }
 function getWithdrawNonceAccountInstructionDataEncoder() {
-  return codecs.mapEncoder(
-    codecs.getStructEncoder([
-      ["discriminator", codecs.getU32Encoder()],
-      ["withdrawAmount", codecs.getU64Encoder()]
+  return web3_js.transformEncoder(
+    web3_js.getStructEncoder([
+      ["discriminator", web3_js.getU32Encoder()],
+      ["withdrawAmount", web3_js.getU64Encoder()]
     ]),
     (value) => ({ ...value, discriminator: 5 })
   );
 }
 function getWithdrawNonceAccountInstructionDataDecoder() {
-  return codecs.getStructDecoder([
-    ["discriminator", codecs.getU32Decoder()],
-    ["withdrawAmount", codecs.getU64Decoder()]
+  return web3_js.getStructDecoder([
+    ["discriminator", web3_js.getU32Decoder()],
+    ["withdrawAmount", web3_js.getU64Decoder()]
   ]);
 }
 function getWithdrawNonceAccountInstructionDataCodec() {
-  return codecs.combineCodec(
+  return web3_js.combineCodec(
     getWithdrawNonceAccountInstructionDataEncoder(),
     getWithdrawNonceAccountInstructionDataDecoder()
   );
 }
 function getWithdrawNonceAccountInstruction(input) {
-  const programAddress = "11111111111111111111111111111111";
-  const accounts = {
+  const programAddress = SYSTEM_PROGRAM_ADDRESS;
+  const originalAccounts = {
     nonceAccount: { value: input.nonceAccount ?? null, isWritable: true },
     recipientAccount: {
       value: input.recipientAccount ?? null,
@@ -1172,6 +1016,7 @@ function getWithdrawNonceAccountInstruction(input) {
     rentSysvar: { value: input.rentSysvar ?? null, isWritable: false },
     nonceAuthority: { value: input.nonceAuthority ?? null, isWritable: false }
   };
+  const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.recentBlockhashesSysvar.value) {
     accounts.recentBlockhashesSysvar.value = "SysvarRecentB1ockHashes11111111111111111111";
@@ -1179,40 +1024,21 @@ function getWithdrawNonceAccountInstruction(input) {
   if (!accounts.rentSysvar.value) {
     accounts.rentSysvar.value = "SysvarRent111111111111111111111111111111111";
   }
-  const accountMetas = getAccountMetasWithSigners(
-    accounts,
-    "programId",
-    programAddress
-  );
-  const instruction = getWithdrawNonceAccountInstructionRaw(
-    accountMetas,
-    args,
-    programAddress
-  );
-  return instruction;
-}
-function getWithdrawNonceAccountInstructionRaw(accounts, args, programAddress = "11111111111111111111111111111111", remainingAccounts) {
-  return {
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  const instruction = {
     accounts: [
-      accountMetaWithDefault(accounts.nonceAccount, instructions.AccountRole.WRITABLE),
-      accountMetaWithDefault(accounts.recipientAccount, instructions.AccountRole.WRITABLE),
-      accountMetaWithDefault(
-        accounts.recentBlockhashesSysvar ?? "SysvarRecentB1ockHashes11111111111111111111",
-        instructions.AccountRole.READONLY
-      ),
-      accountMetaWithDefault(
-        accounts.rentSysvar ?? "SysvarRent111111111111111111111111111111111",
-        instructions.AccountRole.READONLY
-      ),
-      accountMetaWithDefault(
-        accounts.nonceAuthority,
-        instructions.AccountRole.READONLY_SIGNER
-      ),
-      ...remainingAccounts ?? []
+      getAccountMeta(accounts.nonceAccount),
+      getAccountMeta(accounts.recipientAccount),
+      getAccountMeta(accounts.recentBlockhashesSysvar),
+      getAccountMeta(accounts.rentSysvar),
+      getAccountMeta(accounts.nonceAuthority)
     ],
-    data: getWithdrawNonceAccountInstructionDataEncoder().encode(args),
-    programAddress
+    programAddress,
+    data: getWithdrawNonceAccountInstructionDataEncoder().encode(
+      args
+    )
   };
+  return instruction;
 }
 function parseWithdrawNonceAccountInstruction(instruction) {
   if (instruction.accounts.length < 5) {
@@ -1238,148 +1064,65 @@ function parseWithdrawNonceAccountInstruction(instruction) {
     )
   };
 }
-var SYSTEM_PROGRAM_ADDRESS = "11111111111111111111111111111111";
-function getSystemProgram() {
-  return {
-    name: "system",
-    address: SYSTEM_PROGRAM_ADDRESS,
-    getErrorFromCode(code, cause) {
-      return getSystemProgramErrorFromCode(code, cause);
-    }
-  };
-}
-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 = instruction instanceof Uint8Array ? instruction : instruction.data;
-  if (memcmp(data, codecs.getU32Encoder().encode(0), 0)) {
-    return 0 /* CreateAccount */;
-  }
-  if (memcmp(data, codecs.getU32Encoder().encode(1), 0)) {
-    return 1 /* Assign */;
-  }
-  if (memcmp(data, codecs.getU32Encoder().encode(2), 0)) {
-    return 2 /* TransferSol */;
-  }
-  if (memcmp(data, codecs.getU32Encoder().encode(3), 0)) {
-    return 3 /* CreateAccountWithSeed */;
-  }
-  if (memcmp(data, codecs.getU32Encoder().encode(4), 0)) {
-    return 4 /* AdvanceNonceAccount */;
-  }
-  if (memcmp(data, codecs.getU32Encoder().encode(5), 0)) {
-    return 5 /* WithdrawNonceAccount */;
-  }
-  if (memcmp(data, codecs.getU32Encoder().encode(6), 0)) {
-    return 6 /* InitializeNonceAccount */;
-  }
-  if (memcmp(data, codecs.getU32Encoder().encode(7), 0)) {
-    return 7 /* AuthorizeNonceAccount */;
-  }
-  if (memcmp(data, codecs.getU32Encoder().encode(8), 0)) {
-    return 8 /* Allocate */;
-  }
-  if (memcmp(data, codecs.getU32Encoder().encode(9), 0)) {
-    return 9 /* AllocateWithSeed */;
-  }
-  if (memcmp(data, codecs.getU32Encoder().encode(10), 0)) {
-    return 10 /* AssignWithSeed */;
-  }
-  if (memcmp(data, codecs.getU32Encoder().encode(11), 0)) {
-    return 11 /* TransferSolWithSeed */;
-  }
-  if (memcmp(data, codecs.getU32Encoder().encode(12), 0)) {
-    return 12 /* UpgradeNonceAccount */;
-  }
-  throw new Error(
-    "The provided instruction could not be identified as a system instruction."
-  );
-}
 
 exports.NonceState = NonceState;
 exports.NonceVersion = NonceVersion;
+exports.SYSTEM_ERROR__ACCOUNT_ALREADY_IN_USE = SYSTEM_ERROR__ACCOUNT_ALREADY_IN_USE;
+exports.SYSTEM_ERROR__ADDRESS_WITH_SEED_MISMATCH = SYSTEM_ERROR__ADDRESS_WITH_SEED_MISMATCH;
+exports.SYSTEM_ERROR__INVALID_ACCOUNT_DATA_LENGTH = SYSTEM_ERROR__INVALID_ACCOUNT_DATA_LENGTH;
+exports.SYSTEM_ERROR__INVALID_PROGRAM_ID = SYSTEM_ERROR__INVALID_PROGRAM_ID;
+exports.SYSTEM_ERROR__MAX_SEED_LENGTH_EXCEEDED = SYSTEM_ERROR__MAX_SEED_LENGTH_EXCEEDED;
+exports.SYSTEM_ERROR__NONCE_BLOCKHASH_NOT_EXPIRED = SYSTEM_ERROR__NONCE_BLOCKHASH_NOT_EXPIRED;
+exports.SYSTEM_ERROR__NONCE_NO_RECENT_BLOCKHASHES = SYSTEM_ERROR__NONCE_NO_RECENT_BLOCKHASHES;
+exports.SYSTEM_ERROR__NONCE_UNEXPECTED_BLOCKHASH_VALUE = SYSTEM_ERROR__NONCE_UNEXPECTED_BLOCKHASH_VALUE;
+exports.SYSTEM_ERROR__RESULT_WITH_NEGATIVE_LAMPORTS = SYSTEM_ERROR__RESULT_WITH_NEGATIVE_LAMPORTS;
 exports.SYSTEM_PROGRAM_ADDRESS = SYSTEM_PROGRAM_ADDRESS;
 exports.SystemAccount = SystemAccount;
 exports.SystemInstruction = SystemInstruction;
-exports.SystemProgramError = SystemProgramError;
-exports.SystemProgramErrorCode = SystemProgramErrorCode;
-exports.accountMetaWithDefault = accountMetaWithDefault;
 exports.decodeNonce = decodeNonce;
-exports.expectAddress = expectAddress;
-exports.expectProgramDerivedAddress = expectProgramDerivedAddress;
-exports.expectSome = expectSome;
-exports.expectTransactionSigner = expectTransactionSigner;
 exports.fetchAllMaybeNonce = fetchAllMaybeNonce;
 exports.fetchAllNonce = fetchAllNonce;
 exports.fetchMaybeNonce = fetchMaybeNonce;
 exports.fetchNonce = fetchNonce;
-exports.getAccountMetasWithSigners = getAccountMetasWithSigners;
 exports.getAdvanceNonceAccountInstruction = getAdvanceNonceAccountInstruction;
 exports.getAdvanceNonceAccountInstructionDataCodec = getAdvanceNonceAccountInstructionDataCodec;
 exports.getAdvanceNonceAccountInstructionDataDecoder = getAdvanceNonceAccountInstructionDataDecoder;
 exports.getAdvanceNonceAccountInstructionDataEncoder = getAdvanceNonceAccountInstructionDataEncoder;
-exports.getAdvanceNonceAccountInstructionRaw = getAdvanceNonceAccountInstructionRaw;
 exports.getAllocateInstruction = getAllocateInstruction;
 exports.getAllocateInstructionDataCodec = getAllocateInstructionDataCodec;
 exports.getAllocateInstructionDataDecoder = getAllocateInstructionDataDecoder;
 exports.getAllocateInstructionDataEncoder = getAllocateInstructionDataEncoder;
-exports.getAllocateInstructionRaw = getAllocateInstructionRaw;
 exports.getAllocateWithSeedInstruction = getAllocateWithSeedInstruction;
 exports.getAllocateWithSeedInstructionDataCodec = getAllocateWithSeedInstructionDataCodec;
 exports.getAllocateWithSeedInstructionDataDecoder = getAllocateWithSeedInstructionDataDecoder;
 exports.getAllocateWithSeedInstructionDataEncoder = getAllocateWithSeedInstructionDataEncoder;
-exports.getAllocateWithSeedInstructionRaw = getAllocateWithSeedInstructionRaw;
 exports.getAssignInstruction = getAssignInstruction;
 exports.getAssignInstructionDataCodec = getAssignInstructionDataCodec;
 exports.getAssignInstructionDataDecoder = getAssignInstructionDataDecoder;
 exports.getAssignInstructionDataEncoder = getAssignInstructionDataEncoder;
-exports.getAssignInstructionRaw = getAssignInstructionRaw;
 exports.getAssignWithSeedInstruction = getAssignWithSeedInstruction;
 exports.getAssignWithSeedInstructionDataCodec = getAssignWithSeedInstructionDataCodec;
 exports.getAssignWithSeedInstructionDataDecoder = getAssignWithSeedInstructionDataDecoder;
 exports.getAssignWithSeedInstructionDataEncoder = getAssignWithSeedInstructionDataEncoder;
-exports.getAssignWithSeedInstructionRaw = getAssignWithSeedInstructionRaw;
 exports.getAuthorizeNonceAccountInstruction = getAuthorizeNonceAccountInstruction;
 exports.getAuthorizeNonceAccountInstructionDataCodec = getAuthorizeNonceAccountInstructionDataCodec;
 exports.getAuthorizeNonceAccountInstructionDataDecoder = getAuthorizeNonceAccountInstructionDataDecoder;
 exports.getAuthorizeNonceAccountInstructionDataEncoder = getAuthorizeNonceAccountInstructionDataEncoder;
-exports.getAuthorizeNonceAccountInstructionRaw = getAuthorizeNonceAccountInstructionRaw;
 exports.getCreateAccountInstruction = getCreateAccountInstruction;
 exports.getCreateAccountInstructionDataCodec = getCreateAccountInstructionDataCodec;
 exports.getCreateAccountInstructionDataDecoder = getCreateAccountInstructionDataDecoder;
 exports.getCreateAccountInstructionDataEncoder = getCreateAccountInstructionDataEncoder;
-exports.getCreateAccountInstructionRaw = getCreateAccountInstructionRaw;
 exports.getCreateAccountWithSeedInstruction = getCreateAccountWithSeedInstruction;
 exports.getCreateAccountWithSeedInstructionDataCodec = getCreateAccountWithSeedInstructionDataCodec;
 exports.getCreateAccountWithSeedInstructionDataDecoder = getCreateAccountWithSeedInstructionDataDecoder;
 exports.getCreateAccountWithSeedInstructionDataEncoder = getCreateAccountWithSeedInstructionDataEncoder;
-exports.getCreateAccountWithSeedInstructionRaw = getCreateAccountWithSeedInstructionRaw;
 exports.getInitializeNonceAccountInstruction = getInitializeNonceAccountInstruction;
 exports.getInitializeNonceAccountInstructionDataCodec = getInitializeNonceAccountInstructionDataCodec;
 exports.getInitializeNonceAccountInstructionDataDecoder = getInitializeNonceAccountInstructionDataDecoder;
 exports.getInitializeNonceAccountInstructionDataEncoder = getInitializeNonceAccountInstructionDataEncoder;
-exports.getInitializeNonceAccountInstructionRaw = getInitializeNonceAccountInstructionRaw;
-exports.getNonceAccountDataCodec = getNonceAccountDataCodec;
-exports.getNonceAccountDataDecoder = getNonceAccountDataDecoder;
-exports.getNonceAccountDataEncoder = getNonceAccountDataEncoder;
+exports.getNonceCodec = getNonceCodec;
+exports.getNonceDecoder = getNonceDecoder;
+exports.getNonceEncoder = getNonceEncoder;
 exports.getNonceSize = getNonceSize;
 exports.getNonceStateCodec = getNonceStateCodec;
 exports.getNonceStateDecoder = getNonceStateDecoder;
@@ -1387,31 +1130,24 @@ exports.getNonceStateEncoder = getNonceStateEncoder;
 exports.getNonceVersionCodec = getNonceVersionCodec;
 exports.getNonceVersionDecoder = getNonceVersionDecoder;
 exports.getNonceVersionEncoder = getNonceVersionEncoder;
-exports.getSystemProgram = getSystemProgram;
-exports.getSystemProgramErrorFromCode = getSystemProgramErrorFromCode;
+exports.getSystemErrorMessage = getSystemErrorMessage;
 exports.getTransferSolInstruction = getTransferSolInstruction;
 exports.getTransferSolInstructionDataCodec = getTransferSolInstructionDataCodec;
 exports.getTransferSolInstructionDataDecoder = getTransferSolInstructionDataDecoder;
 exports.getTransferSolInstructionDataEncoder = getTransferSolInstructionDataEncoder;
-exports.getTransferSolInstructionRaw = getTransferSolInstructionRaw;
 exports.getTransferSolWithSeedInstruction = getTransferSolWithSeedInstruction;
 exports.getTransferSolWithSeedInstructionDataCodec = getTransferSolWithSeedInstructionDataCodec;
 exports.getTransferSolWithSeedInstructionDataDecoder = getTransferSolWithSeedInstructionDataDecoder;
 exports.getTransferSolWithSeedInstructionDataEncoder = getTransferSolWithSeedInstructionDataEncoder;
-exports.getTransferSolWithSeedInstructionRaw = getTransferSolWithSeedInstructionRaw;
 exports.getUpgradeNonceAccountInstruction = getUpgradeNonceAccountInstruction;
 exports.getUpgradeNonceAccountInstructionDataCodec = getUpgradeNonceAccountInstructionDataCodec;
 exports.getUpgradeNonceAccountInstructionDataDecoder = getUpgradeNonceAccountInstructionDataDecoder;
 exports.getUpgradeNonceAccountInstructionDataEncoder = getUpgradeNonceAccountInstructionDataEncoder;
-exports.getUpgradeNonceAccountInstructionRaw = getUpgradeNonceAccountInstructionRaw;
 exports.getWithdrawNonceAccountInstruction = getWithdrawNonceAccountInstruction;
 exports.getWithdrawNonceAccountInstructionDataCodec = getWithdrawNonceAccountInstructionDataCodec;
 exports.getWithdrawNonceAccountInstructionDataDecoder = getWithdrawNonceAccountInstructionDataDecoder;
 exports.getWithdrawNonceAccountInstructionDataEncoder = getWithdrawNonceAccountInstructionDataEncoder;
-exports.getWithdrawNonceAccountInstructionRaw = getWithdrawNonceAccountInstructionRaw;
 exports.identifySystemInstruction = identifySystemInstruction;
-exports.isTransactionSigner = isTransactionSigner;
-exports.memcmp = memcmp;
 exports.parseAdvanceNonceAccountInstruction = parseAdvanceNonceAccountInstruction;
 exports.parseAllocateInstruction = parseAllocateInstruction;
 exports.parseAllocateWithSeedInstruction = parseAllocateWithSeedInstruction;