@solana-program/system 0.1.0

package/dist/src/index.js

@@ -0,0 +1,1432 @@
+'use strict';
+
+var accounts = require('@solana/accounts');
+var addresses = require('@solana/addresses');
+var codecsCore = require('@solana/codecs-core');
+var codecsDataStructures = require('@solana/codecs-data-structures');
+var codecsNumbers = require('@solana/codecs-numbers');
+var instructions = require('@solana/instructions');
+var signers = require('@solana/signers');
+var codecsStrings = require('@solana/codecs-strings');
+
+// env-shim.ts
+var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
+var NonceState = /* @__PURE__ */ ((NonceState3) => {
+  NonceState3[NonceState3["Uninitialized"] = 0] = "Uninitialized";
+  NonceState3[NonceState3["Initialized"] = 1] = "Initialized";
+  return NonceState3;
+})(NonceState || {});
+function getNonceStateEncoder() {
+  return codecsDataStructures.getScalarEnumEncoder(NonceState, { size: codecsNumbers.getU32Encoder() });
+}
+function getNonceStateDecoder() {
+  return codecsDataStructures.getScalarEnumDecoder(NonceState, { size: codecsNumbers.getU32Decoder() });
+}
+function getNonceStateCodec() {
+  return codecsCore.combineCodec(getNonceStateEncoder(), getNonceStateDecoder());
+}
+var NonceVersion = /* @__PURE__ */ ((NonceVersion3) => {
+  NonceVersion3[NonceVersion3["Legacy"] = 0] = "Legacy";
+  NonceVersion3[NonceVersion3["Current"] = 1] = "Current";
+  return NonceVersion3;
+})(NonceVersion || {});
+function getNonceVersionEncoder() {
+  return codecsDataStructures.getScalarEnumEncoder(NonceVersion, { size: codecsNumbers.getU32Encoder() });
+}
+function getNonceVersionDecoder() {
+  return codecsDataStructures.getScalarEnumDecoder(NonceVersion, { size: codecsNumbers.getU32Decoder() });
+}
+function getNonceVersionCodec() {
+  return codecsCore.combineCodec(getNonceVersionEncoder(), getNonceVersionDecoder());
+}
+
+// src/generated/accounts/nonce.ts
+function getNonceAccountDataEncoder() {
+  return codecsDataStructures.getStructEncoder([
+    ["version", getNonceVersionEncoder()],
+    ["state", getNonceStateEncoder()],
+    ["authority", addresses.getAddressEncoder()],
+    ["blockhash", addresses.getAddressEncoder()],
+    ["lamportsPerSignature", codecsNumbers.getU64Encoder()]
+  ]);
+}
+function getNonceAccountDataDecoder() {
+  return codecsDataStructures.getStructDecoder([
+    ["version", getNonceVersionDecoder()],
+    ["state", getNonceStateDecoder()],
+    ["authority", addresses.getAddressDecoder()],
+    ["blockhash", addresses.getAddressDecoder()],
+    ["lamportsPerSignature", codecsNumbers.getU64Decoder()]
+  ]);
+}
+function getNonceAccountDataCodec() {
+  return codecsCore.combineCodec(
+    getNonceAccountDataEncoder(),
+    getNonceAccountDataDecoder()
+  );
+}
+function decodeNonce(encodedAccount) {
+  return accounts.decodeAccount(
+    encodedAccount,
+    getNonceAccountDataDecoder()
+  );
+}
+async function fetchNonce(rpc, address, config) {
+  const maybeAccount = await fetchMaybeNonce(rpc, address, config);
+  accounts.assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeNonce(rpc, address, config) {
+  const maybeAccount = await accounts.fetchEncodedAccount(rpc, address, config);
+  return decodeNonce(maybeAccount);
+}
+async function fetchAllNonce(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeNonce(rpc, addresses, config);
+  accounts.assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeNonce(rpc, addresses, config) {
+  const maybeAccounts = await accounts.fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeNonce(maybeAccount));
+}
+function getNonceSize() {
+  return 80;
+}
+
+// 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;
+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`
+    ]
+  };
+}
+function getSystemProgramErrorFromCode(code, cause) {
+  if (__DEV__) {
+    return new SystemProgramError(
+      code,
+      ...systemProgramErrorCodeMap[code],
+      cause
+    );
+  }
+  return new SystemProgramError(
+    code,
+    "Unknown",
+    "Error message not available in production bundles. Compile with __DEV__ set to true to see more information.",
+    cause
+  );
+}
+function expectSome(value) {
+  if (value == null) {
+    throw new Error("Expected a value but received null or undefined.");
+  }
+  return value;
+}
+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 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];
+    if (!account.value) {
+      if (optionalAccountStrategy === "omitted")
+        return;
+      accountMetas[key] = {
+        address: programAddress,
+        role: instructions.AccountRole.READONLY
+      };
+      return;
+    }
+    const writableRole = account.isWritable ? instructions.AccountRole.WRITABLE : instructions.AccountRole.READONLY;
+    accountMetas[key] = Object.freeze({
+      address: expectAddress(account.value),
+      role: isTransactionSigner(account.value) ? instructions.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]);
+}
+
+// src/generated/instructions/advanceNonceAccount.ts
+function getAdvanceNonceAccountInstructionDataEncoder() {
+  return codecsCore.mapEncoder(
+    codecsDataStructures.getStructEncoder([["discriminator", codecsNumbers.getU32Encoder()]]),
+    (value) => ({ ...value, discriminator: 4 })
+  );
+}
+function getAdvanceNonceAccountInstructionDataDecoder() {
+  return codecsDataStructures.getStructDecoder([["discriminator", codecsNumbers.getU32Decoder()]]);
+}
+function getAdvanceNonceAccountInstructionDataCodec() {
+  return codecsCore.combineCodec(
+    getAdvanceNonceAccountInstructionDataEncoder(),
+    getAdvanceNonceAccountInstructionDataDecoder()
+  );
+}
+function getAdvanceNonceAccountInstruction(input) {
+  const programAddress = "11111111111111111111111111111111";
+  const accounts = {
+    nonceAccount: { value: input.nonceAccount ?? null, isWritable: true },
+    recentBlockhashesSysvar: {
+      value: input.recentBlockhashesSysvar ?? null,
+      isWritable: false
+    },
+    nonceAuthority: { value: input.nonceAuthority ?? null, isWritable: false }
+  };
+  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 {
+    accounts: [
+      accountMetaWithDefault(accounts.nonceAccount, instructions.AccountRole.WRITABLE),
+      accountMetaWithDefault(
+        accounts.recentBlockhashesSysvar ?? "SysvarRecentB1ockHashes11111111111111111111",
+        instructions.AccountRole.READONLY
+      ),
+      accountMetaWithDefault(
+        accounts.nonceAuthority,
+        instructions.AccountRole.READONLY_SIGNER
+      ),
+      ...remainingAccounts ?? []
+    ],
+    data: getAdvanceNonceAccountInstructionDataEncoder().encode({}),
+    programAddress
+  };
+}
+function parseAdvanceNonceAccountInstruction(instruction) {
+  if (instruction.accounts.length < 3) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      nonceAccount: getNextAccount(),
+      recentBlockhashesSysvar: getNextAccount(),
+      nonceAuthority: getNextAccount()
+    },
+    data: getAdvanceNonceAccountInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+function getAllocateInstructionDataEncoder() {
+  return codecsCore.mapEncoder(
+    codecsDataStructures.getStructEncoder([
+      ["discriminator", codecsNumbers.getU32Encoder()],
+      ["space", codecsNumbers.getU64Encoder()]
+    ]),
+    (value) => ({ ...value, discriminator: 8 })
+  );
+}
+function getAllocateInstructionDataDecoder() {
+  return codecsDataStructures.getStructDecoder([
+    ["discriminator", codecsNumbers.getU32Decoder()],
+    ["space", codecsNumbers.getU64Decoder()]
+  ]);
+}
+function getAllocateInstructionDataCodec() {
+  return codecsCore.combineCodec(
+    getAllocateInstructionDataEncoder(),
+    getAllocateInstructionDataDecoder()
+  );
+}
+function getAllocateInstruction(input) {
+  const programAddress = "11111111111111111111111111111111";
+  const accounts = {
+    newAccount: { value: input.newAccount ?? null, isWritable: true }
+  };
+  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
+  };
+}
+function parseAllocateInstruction(instruction) {
+  if (instruction.accounts.length < 1) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      newAccount: getNextAccount()
+    },
+    data: getAllocateInstructionDataDecoder().decode(instruction.data)
+  };
+}
+function getAllocateWithSeedInstructionDataEncoder() {
+  return codecsCore.mapEncoder(
+    codecsDataStructures.getStructEncoder([
+      ["discriminator", codecsNumbers.getU32Encoder()],
+      ["base", addresses.getAddressEncoder()],
+      ["seed", codecsStrings.getStringEncoder()],
+      ["space", codecsNumbers.getU64Encoder()],
+      ["programAddress", addresses.getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: 9 })
+  );
+}
+function getAllocateWithSeedInstructionDataDecoder() {
+  return codecsDataStructures.getStructDecoder([
+    ["discriminator", codecsNumbers.getU32Decoder()],
+    ["base", addresses.getAddressDecoder()],
+    ["seed", codecsStrings.getStringDecoder()],
+    ["space", codecsNumbers.getU64Decoder()],
+    ["programAddress", addresses.getAddressDecoder()]
+  ]);
+}
+function getAllocateWithSeedInstructionDataCodec() {
+  return codecsCore.combineCodec(
+    getAllocateWithSeedInstructionDataEncoder(),
+    getAllocateWithSeedInstructionDataDecoder()
+  );
+}
+function getAllocateWithSeedInstruction(input) {
+  const programAddress = "11111111111111111111111111111111";
+  const accounts = {
+    newAccount: { value: input.newAccount ?? null, isWritable: true },
+    baseAccount: { value: input.baseAccount ?? null, isWritable: false }
+  };
+  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 {
+    accounts: [
+      accountMetaWithDefault(accounts.newAccount, instructions.AccountRole.WRITABLE),
+      accountMetaWithDefault(accounts.baseAccount, instructions.AccountRole.READONLY_SIGNER),
+      ...remainingAccounts ?? []
+    ],
+    data: getAllocateWithSeedInstructionDataEncoder().encode(args),
+    programAddress
+  };
+}
+function parseAllocateWithSeedInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      newAccount: getNextAccount(),
+      baseAccount: getNextAccount()
+    },
+    data: getAllocateWithSeedInstructionDataDecoder().decode(instruction.data)
+  };
+}
+function getAssignInstructionDataEncoder() {
+  return codecsCore.mapEncoder(
+    codecsDataStructures.getStructEncoder([
+      ["discriminator", codecsNumbers.getU32Encoder()],
+      ["programAddress", addresses.getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: 1 })
+  );
+}
+function getAssignInstructionDataDecoder() {
+  return codecsDataStructures.getStructDecoder([
+    ["discriminator", codecsNumbers.getU32Decoder()],
+    ["programAddress", addresses.getAddressDecoder()]
+  ]);
+}
+function getAssignInstructionDataCodec() {
+  return codecsCore.combineCodec(
+    getAssignInstructionDataEncoder(),
+    getAssignInstructionDataDecoder()
+  );
+}
+function getAssignInstruction(input) {
+  const programAddress = "11111111111111111111111111111111";
+  const accounts = {
+    account: { value: input.account ?? null, isWritable: true }
+  };
+  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
+  };
+}
+function parseAssignInstruction(instruction) {
+  if (instruction.accounts.length < 1) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      account: getNextAccount()
+    },
+    data: getAssignInstructionDataDecoder().decode(instruction.data)
+  };
+}
+function getAssignWithSeedInstructionDataEncoder() {
+  return codecsCore.mapEncoder(
+    codecsDataStructures.getStructEncoder([
+      ["discriminator", codecsNumbers.getU32Encoder()],
+      ["base", addresses.getAddressEncoder()],
+      ["seed", codecsStrings.getStringEncoder()],
+      ["programAddress", addresses.getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: 10 })
+  );
+}
+function getAssignWithSeedInstructionDataDecoder() {
+  return codecsDataStructures.getStructDecoder([
+    ["discriminator", codecsNumbers.getU32Decoder()],
+    ["base", addresses.getAddressDecoder()],
+    ["seed", codecsStrings.getStringDecoder()],
+    ["programAddress", addresses.getAddressDecoder()]
+  ]);
+}
+function getAssignWithSeedInstructionDataCodec() {
+  return codecsCore.combineCodec(
+    getAssignWithSeedInstructionDataEncoder(),
+    getAssignWithSeedInstructionDataDecoder()
+  );
+}
+function getAssignWithSeedInstruction(input) {
+  const programAddress = "11111111111111111111111111111111";
+  const accounts = {
+    account: { value: input.account ?? null, isWritable: true },
+    baseAccount: { value: input.baseAccount ?? null, isWritable: false }
+  };
+  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 {
+    accounts: [
+      accountMetaWithDefault(accounts.account, instructions.AccountRole.WRITABLE),
+      accountMetaWithDefault(accounts.baseAccount, instructions.AccountRole.READONLY_SIGNER),
+      ...remainingAccounts ?? []
+    ],
+    data: getAssignWithSeedInstructionDataEncoder().encode(args),
+    programAddress
+  };
+}
+function parseAssignWithSeedInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      account: getNextAccount(),
+      baseAccount: getNextAccount()
+    },
+    data: getAssignWithSeedInstructionDataDecoder().decode(instruction.data)
+  };
+}
+function getAuthorizeNonceAccountInstructionDataEncoder() {
+  return codecsCore.mapEncoder(
+    codecsDataStructures.getStructEncoder([
+      ["discriminator", codecsNumbers.getU32Encoder()],
+      ["newNonceAuthority", addresses.getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: 7 })
+  );
+}
+function getAuthorizeNonceAccountInstructionDataDecoder() {
+  return codecsDataStructures.getStructDecoder([
+    ["discriminator", codecsNumbers.getU32Decoder()],
+    ["newNonceAuthority", addresses.getAddressDecoder()]
+  ]);
+}
+function getAuthorizeNonceAccountInstructionDataCodec() {
+  return codecsCore.combineCodec(
+    getAuthorizeNonceAccountInstructionDataEncoder(),
+    getAuthorizeNonceAccountInstructionDataDecoder()
+  );
+}
+function getAuthorizeNonceAccountInstruction(input) {
+  const programAddress = "11111111111111111111111111111111";
+  const accounts = {
+    nonceAccount: { value: input.nonceAccount ?? null, isWritable: true },
+    nonceAuthority: { value: input.nonceAuthority ?? null, isWritable: false }
+  };
+  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 {
+    accounts: [
+      accountMetaWithDefault(accounts.nonceAccount, instructions.AccountRole.WRITABLE),
+      accountMetaWithDefault(
+        accounts.nonceAuthority,
+        instructions.AccountRole.READONLY_SIGNER
+      ),
+      ...remainingAccounts ?? []
+    ],
+    data: getAuthorizeNonceAccountInstructionDataEncoder().encode(args),
+    programAddress
+  };
+}
+function parseAuthorizeNonceAccountInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      nonceAccount: getNextAccount(),
+      nonceAuthority: getNextAccount()
+    },
+    data: getAuthorizeNonceAccountInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+function getCreateAccountInstructionDataEncoder() {
+  return codecsCore.mapEncoder(
+    codecsDataStructures.getStructEncoder([
+      ["discriminator", codecsNumbers.getU32Encoder()],
+      ["lamports", codecsNumbers.getU64Encoder()],
+      ["space", codecsNumbers.getU64Encoder()],
+      ["programAddress", addresses.getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: 0 })
+  );
+}
+function getCreateAccountInstructionDataDecoder() {
+  return codecsDataStructures.getStructDecoder([
+    ["discriminator", codecsNumbers.getU32Decoder()],
+    ["lamports", codecsNumbers.getU64Decoder()],
+    ["space", codecsNumbers.getU64Decoder()],
+    ["programAddress", addresses.getAddressDecoder()]
+  ]);
+}
+function getCreateAccountInstructionDataCodec() {
+  return codecsCore.combineCodec(
+    getCreateAccountInstructionDataEncoder(),
+    getCreateAccountInstructionDataDecoder()
+  );
+}
+function getCreateAccountInstruction(input) {
+  const programAddress = "11111111111111111111111111111111";
+  const accounts$1 = {
+    payer: { value: input.payer ?? null, isWritable: true },
+    newAccount: { value: input.newAccount ?? null, isWritable: true }
+  };
+  const args = { ...input };
+  const byteDelta = [Number(args.space) + accounts.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 {
+    accounts: [
+      accountMetaWithDefault(accounts.payer, instructions.AccountRole.WRITABLE_SIGNER),
+      accountMetaWithDefault(accounts.newAccount, instructions.AccountRole.WRITABLE_SIGNER),
+      ...remainingAccounts ?? []
+    ],
+    data: getCreateAccountInstructionDataEncoder().encode(args),
+    programAddress
+  };
+}
+function parseCreateAccountInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      payer: getNextAccount(),
+      newAccount: getNextAccount()
+    },
+    data: getCreateAccountInstructionDataDecoder().decode(instruction.data)
+  };
+}
+function getCreateAccountWithSeedInstructionDataEncoder() {
+  return codecsCore.mapEncoder(
+    codecsDataStructures.getStructEncoder([
+      ["discriminator", codecsNumbers.getU32Encoder()],
+      ["base", addresses.getAddressEncoder()],
+      ["seed", codecsStrings.getStringEncoder()],
+      ["amount", codecsNumbers.getU64Encoder()],
+      ["space", codecsNumbers.getU64Encoder()],
+      ["programAddress", addresses.getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: 3 })
+  );
+}
+function getCreateAccountWithSeedInstructionDataDecoder() {
+  return codecsDataStructures.getStructDecoder([
+    ["discriminator", codecsNumbers.getU32Decoder()],
+    ["base", addresses.getAddressDecoder()],
+    ["seed", codecsStrings.getStringDecoder()],
+    ["amount", codecsNumbers.getU64Decoder()],
+    ["space", codecsNumbers.getU64Decoder()],
+    ["programAddress", addresses.getAddressDecoder()]
+  ]);
+}
+function getCreateAccountWithSeedInstructionDataCodec() {
+  return codecsCore.combineCodec(
+    getCreateAccountWithSeedInstructionDataEncoder(),
+    getCreateAccountWithSeedInstructionDataDecoder()
+  );
+}
+function getCreateAccountWithSeedInstruction(input) {
+  const programAddress = "11111111111111111111111111111111";
+  const accounts = {
+    payer: { value: input.payer ?? null, isWritable: true },
+    newAccount: { value: input.newAccount ?? null, isWritable: true },
+    baseAccount: { value: input.baseAccount ?? null, isWritable: false }
+  };
+  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 {
+    accounts: [
+      accountMetaWithDefault(accounts.payer, instructions.AccountRole.WRITABLE_SIGNER),
+      accountMetaWithDefault(accounts.newAccount, instructions.AccountRole.WRITABLE),
+      accountMetaWithDefault(accounts.baseAccount, instructions.AccountRole.READONLY_SIGNER),
+      ...remainingAccounts ?? []
+    ],
+    data: getCreateAccountWithSeedInstructionDataEncoder().encode(args),
+    programAddress
+  };
+}
+function parseCreateAccountWithSeedInstruction(instruction) {
+  if (instruction.accounts.length < 3) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      payer: getNextAccount(),
+      newAccount: getNextAccount(),
+      baseAccount: getNextAccount()
+    },
+    data: getCreateAccountWithSeedInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+function getInitializeNonceAccountInstructionDataEncoder() {
+  return codecsCore.mapEncoder(
+    codecsDataStructures.getStructEncoder([
+      ["discriminator", codecsNumbers.getU32Encoder()],
+      ["nonceAuthority", addresses.getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: 6 })
+  );
+}
+function getInitializeNonceAccountInstructionDataDecoder() {
+  return codecsDataStructures.getStructDecoder([
+    ["discriminator", codecsNumbers.getU32Decoder()],
+    ["nonceAuthority", addresses.getAddressDecoder()]
+  ]);
+}
+function getInitializeNonceAccountInstructionDataCodec() {
+  return codecsCore.combineCodec(
+    getInitializeNonceAccountInstructionDataEncoder(),
+    getInitializeNonceAccountInstructionDataDecoder()
+  );
+}
+function getInitializeNonceAccountInstruction(input) {
+  const programAddress = "11111111111111111111111111111111";
+  const accounts = {
+    nonceAccount: { value: input.nonceAccount ?? null, isWritable: true },
+    recentBlockhashesSysvar: {
+      value: input.recentBlockhashesSysvar ?? null,
+      isWritable: false
+    },
+    rentSysvar: { value: input.rentSysvar ?? null, isWritable: false }
+  };
+  const args = { ...input };
+  if (!accounts.recentBlockhashesSysvar.value) {
+    accounts.recentBlockhashesSysvar.value = "SysvarRecentB1ockHashes11111111111111111111";
+  }
+  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 {
+    accounts: [
+      accountMetaWithDefault(accounts.nonceAccount, instructions.AccountRole.WRITABLE),
+      accountMetaWithDefault(
+        accounts.recentBlockhashesSysvar ?? "SysvarRecentB1ockHashes11111111111111111111",
+        instructions.AccountRole.READONLY
+      ),
+      accountMetaWithDefault(
+        accounts.rentSysvar ?? "SysvarRent111111111111111111111111111111111",
+        instructions.AccountRole.READONLY
+      ),
+      ...remainingAccounts ?? []
+    ],
+    data: getInitializeNonceAccountInstructionDataEncoder().encode(args),
+    programAddress
+  };
+}
+function parseInitializeNonceAccountInstruction(instruction) {
+  if (instruction.accounts.length < 3) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      nonceAccount: getNextAccount(),
+      recentBlockhashesSysvar: getNextAccount(),
+      rentSysvar: getNextAccount()
+    },
+    data: getInitializeNonceAccountInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+function getTransferSolInstructionDataEncoder() {
+  return codecsCore.mapEncoder(
+    codecsDataStructures.getStructEncoder([
+      ["discriminator", codecsNumbers.getU32Encoder()],
+      ["amount", codecsNumbers.getU64Encoder()]
+    ]),
+    (value) => ({ ...value, discriminator: 2 })
+  );
+}
+function getTransferSolInstructionDataDecoder() {
+  return codecsDataStructures.getStructDecoder([
+    ["discriminator", codecsNumbers.getU32Decoder()],
+    ["amount", codecsNumbers.getU64Decoder()]
+  ]);
+}
+function getTransferSolInstructionDataCodec() {
+  return codecsCore.combineCodec(
+    getTransferSolInstructionDataEncoder(),
+    getTransferSolInstructionDataDecoder()
+  );
+}
+function getTransferSolInstruction(input) {
+  const programAddress = "11111111111111111111111111111111";
+  const accounts = {
+    source: { value: input.source ?? null, isWritable: true },
+    destination: { value: input.destination ?? null, isWritable: true }
+  };
+  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 {
+    accounts: [
+      accountMetaWithDefault(accounts.source, instructions.AccountRole.WRITABLE_SIGNER),
+      accountMetaWithDefault(accounts.destination, instructions.AccountRole.WRITABLE),
+      ...remainingAccounts ?? []
+    ],
+    data: getTransferSolInstructionDataEncoder().encode(args),
+    programAddress
+  };
+}
+function parseTransferSolInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      source: getNextAccount(),
+      destination: getNextAccount()
+    },
+    data: getTransferSolInstructionDataDecoder().decode(instruction.data)
+  };
+}
+function getTransferSolWithSeedInstructionDataEncoder() {
+  return codecsCore.mapEncoder(
+    codecsDataStructures.getStructEncoder([
+      ["discriminator", codecsNumbers.getU32Encoder()],
+      ["amount", codecsNumbers.getU64Encoder()],
+      ["fromSeed", codecsStrings.getStringEncoder()],
+      ["fromOwner", addresses.getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: 11 })
+  );
+}
+function getTransferSolWithSeedInstructionDataDecoder() {
+  return codecsDataStructures.getStructDecoder([
+    ["discriminator", codecsNumbers.getU32Decoder()],
+    ["amount", codecsNumbers.getU64Decoder()],
+    ["fromSeed", codecsStrings.getStringDecoder()],
+    ["fromOwner", addresses.getAddressDecoder()]
+  ]);
+}
+function getTransferSolWithSeedInstructionDataCodec() {
+  return codecsCore.combineCodec(
+    getTransferSolWithSeedInstructionDataEncoder(),
+    getTransferSolWithSeedInstructionDataDecoder()
+  );
+}
+function getTransferSolWithSeedInstruction(input) {
+  const programAddress = "11111111111111111111111111111111";
+  const accounts = {
+    source: { value: input.source ?? null, isWritable: true },
+    baseAccount: { value: input.baseAccount ?? null, isWritable: false },
+    destination: { value: input.destination ?? null, isWritable: true }
+  };
+  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 {
+    accounts: [
+      accountMetaWithDefault(accounts.source, instructions.AccountRole.WRITABLE),
+      accountMetaWithDefault(accounts.baseAccount, instructions.AccountRole.READONLY_SIGNER),
+      accountMetaWithDefault(accounts.destination, instructions.AccountRole.WRITABLE),
+      ...remainingAccounts ?? []
+    ],
+    data: getTransferSolWithSeedInstructionDataEncoder().encode(args),
+    programAddress
+  };
+}
+function parseTransferSolWithSeedInstruction(instruction) {
+  if (instruction.accounts.length < 3) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      source: getNextAccount(),
+      baseAccount: getNextAccount(),
+      destination: getNextAccount()
+    },
+    data: getTransferSolWithSeedInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+function getUpgradeNonceAccountInstructionDataEncoder() {
+  return codecsCore.mapEncoder(
+    codecsDataStructures.getStructEncoder([["discriminator", codecsNumbers.getU32Encoder()]]),
+    (value) => ({ ...value, discriminator: 12 })
+  );
+}
+function getUpgradeNonceAccountInstructionDataDecoder() {
+  return codecsDataStructures.getStructDecoder([["discriminator", codecsNumbers.getU32Decoder()]]);
+}
+function getUpgradeNonceAccountInstructionDataCodec() {
+  return codecsCore.combineCodec(
+    getUpgradeNonceAccountInstructionDataEncoder(),
+    getUpgradeNonceAccountInstructionDataDecoder()
+  );
+}
+function getUpgradeNonceAccountInstruction(input) {
+  const programAddress = "11111111111111111111111111111111";
+  const accounts = {
+    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
+  };
+}
+function parseUpgradeNonceAccountInstruction(instruction) {
+  if (instruction.accounts.length < 1) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      nonceAccount: getNextAccount()
+    },
+    data: getUpgradeNonceAccountInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+function getWithdrawNonceAccountInstructionDataEncoder() {
+  return codecsCore.mapEncoder(
+    codecsDataStructures.getStructEncoder([
+      ["discriminator", codecsNumbers.getU32Encoder()],
+      ["withdrawAmount", codecsNumbers.getU64Encoder()]
+    ]),
+    (value) => ({ ...value, discriminator: 5 })
+  );
+}
+function getWithdrawNonceAccountInstructionDataDecoder() {
+  return codecsDataStructures.getStructDecoder([
+    ["discriminator", codecsNumbers.getU32Decoder()],
+    ["withdrawAmount", codecsNumbers.getU64Decoder()]
+  ]);
+}
+function getWithdrawNonceAccountInstructionDataCodec() {
+  return codecsCore.combineCodec(
+    getWithdrawNonceAccountInstructionDataEncoder(),
+    getWithdrawNonceAccountInstructionDataDecoder()
+  );
+}
+function getWithdrawNonceAccountInstruction(input) {
+  const programAddress = "11111111111111111111111111111111";
+  const accounts = {
+    nonceAccount: { value: input.nonceAccount ?? null, isWritable: true },
+    recipientAccount: {
+      value: input.recipientAccount ?? null,
+      isWritable: true
+    },
+    recentBlockhashesSysvar: {
+      value: input.recentBlockhashesSysvar ?? null,
+      isWritable: false
+    },
+    rentSysvar: { value: input.rentSysvar ?? null, isWritable: false },
+    nonceAuthority: { value: input.nonceAuthority ?? null, isWritable: false }
+  };
+  const args = { ...input };
+  if (!accounts.recentBlockhashesSysvar.value) {
+    accounts.recentBlockhashesSysvar.value = "SysvarRecentB1ockHashes11111111111111111111";
+  }
+  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 {
+    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 ?? []
+    ],
+    data: getWithdrawNonceAccountInstructionDataEncoder().encode(args),
+    programAddress
+  };
+}
+function parseWithdrawNonceAccountInstruction(instruction) {
+  if (instruction.accounts.length < 5) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      nonceAccount: getNextAccount(),
+      recipientAccount: getNextAccount(),
+      recentBlockhashesSysvar: getNextAccount(),
+      rentSysvar: getNextAccount(),
+      nonceAuthority: getNextAccount()
+    },
+    data: getWithdrawNonceAccountInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+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, codecsNumbers.getU32Encoder().encode(0), 0)) {
+    return 0 /* CreateAccount */;
+  }
+  if (memcmp(data, codecsNumbers.getU32Encoder().encode(1), 0)) {
+    return 1 /* Assign */;
+  }
+  if (memcmp(data, codecsNumbers.getU32Encoder().encode(2), 0)) {
+    return 2 /* TransferSol */;
+  }
+  if (memcmp(data, codecsNumbers.getU32Encoder().encode(3), 0)) {
+    return 3 /* CreateAccountWithSeed */;
+  }
+  if (memcmp(data, codecsNumbers.getU32Encoder().encode(4), 0)) {
+    return 4 /* AdvanceNonceAccount */;
+  }
+  if (memcmp(data, codecsNumbers.getU32Encoder().encode(5), 0)) {
+    return 5 /* WithdrawNonceAccount */;
+  }
+  if (memcmp(data, codecsNumbers.getU32Encoder().encode(6), 0)) {
+    return 6 /* InitializeNonceAccount */;
+  }
+  if (memcmp(data, codecsNumbers.getU32Encoder().encode(7), 0)) {
+    return 7 /* AuthorizeNonceAccount */;
+  }
+  if (memcmp(data, codecsNumbers.getU32Encoder().encode(8), 0)) {
+    return 8 /* Allocate */;
+  }
+  if (memcmp(data, codecsNumbers.getU32Encoder().encode(9), 0)) {
+    return 9 /* AllocateWithSeed */;
+  }
+  if (memcmp(data, codecsNumbers.getU32Encoder().encode(10), 0)) {
+    return 10 /* AssignWithSeed */;
+  }
+  if (memcmp(data, codecsNumbers.getU32Encoder().encode(11), 0)) {
+    return 11 /* TransferSolWithSeed */;
+  }
+  if (memcmp(data, codecsNumbers.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_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.getNonceSize = getNonceSize;
+exports.getNonceStateCodec = getNonceStateCodec;
+exports.getNonceStateDecoder = getNonceStateDecoder;
+exports.getNonceStateEncoder = getNonceStateEncoder;
+exports.getNonceVersionCodec = getNonceVersionCodec;
+exports.getNonceVersionDecoder = getNonceVersionDecoder;
+exports.getNonceVersionEncoder = getNonceVersionEncoder;
+exports.getSystemProgram = getSystemProgram;
+exports.getSystemProgramErrorFromCode = getSystemProgramErrorFromCode;
+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;
+exports.parseAssignInstruction = parseAssignInstruction;
+exports.parseAssignWithSeedInstruction = parseAssignWithSeedInstruction;
+exports.parseAuthorizeNonceAccountInstruction = parseAuthorizeNonceAccountInstruction;
+exports.parseCreateAccountInstruction = parseCreateAccountInstruction;
+exports.parseCreateAccountWithSeedInstruction = parseCreateAccountWithSeedInstruction;
+exports.parseInitializeNonceAccountInstruction = parseInitializeNonceAccountInstruction;
+exports.parseTransferSolInstruction = parseTransferSolInstruction;
+exports.parseTransferSolWithSeedInstruction = parseTransferSolWithSeedInstruction;
+exports.parseUpgradeNonceAccountInstruction = parseUpgradeNonceAccountInstruction;
+exports.parseWithdrawNonceAccountInstruction = parseWithdrawNonceAccountInstruction;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map