@solana-program/system 0.1.0

package/dist/src/index.mjs

@@ -0,0 +1,1320 @@
+import { decodeAccount, assertAccountExists, fetchEncodedAccount, assertAccountsExist, fetchEncodedAccounts, BASE_ACCOUNT_SIZE } from '@solana/accounts';
+import { getAddressEncoder, getAddressDecoder, isProgramDerivedAddress } from '@solana/addresses';
+import { combineCodec, mapEncoder } from '@solana/codecs-core';
+import { getScalarEnumEncoder, getScalarEnumDecoder, getStructEncoder, getStructDecoder } from '@solana/codecs-data-structures';
+import { getU32Encoder, getU32Decoder, getU64Encoder, getU64Decoder } from '@solana/codecs-numbers';
+import { AccountRole, upgradeRoleToSigner } from '@solana/instructions';
+import { isTransactionSigner as isTransactionSigner$1 } from '@solana/signers';
+import { getStringEncoder, getStringDecoder } from '@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 getScalarEnumEncoder(NonceState, { size: getU32Encoder() });
+}
+function getNonceStateDecoder() {
+  return getScalarEnumDecoder(NonceState, { size: getU32Decoder() });
+}
+function getNonceStateCodec() {
+  return combineCodec(getNonceStateEncoder(), getNonceStateDecoder());
+}
+var NonceVersion = /* @__PURE__ */ ((NonceVersion3) => {
+  NonceVersion3[NonceVersion3["Legacy"] = 0] = "Legacy";
+  NonceVersion3[NonceVersion3["Current"] = 1] = "Current";
+  return NonceVersion3;
+})(NonceVersion || {});
+function getNonceVersionEncoder() {
+  return getScalarEnumEncoder(NonceVersion, { size: getU32Encoder() });
+}
+function getNonceVersionDecoder() {
+  return getScalarEnumDecoder(NonceVersion, { size: getU32Decoder() });
+}
+function getNonceVersionCodec() {
+  return combineCodec(getNonceVersionEncoder(), getNonceVersionDecoder());
+}
+
+// src/generated/accounts/nonce.ts
+function getNonceAccountDataEncoder() {
+  return getStructEncoder([
+    ["version", getNonceVersionEncoder()],
+    ["state", getNonceStateEncoder()],
+    ["authority", getAddressEncoder()],
+    ["blockhash", getAddressEncoder()],
+    ["lamportsPerSignature", getU64Encoder()]
+  ]);
+}
+function getNonceAccountDataDecoder() {
+  return getStructDecoder([
+    ["version", getNonceVersionDecoder()],
+    ["state", getNonceStateDecoder()],
+    ["authority", getAddressDecoder()],
+    ["blockhash", getAddressDecoder()],
+    ["lamportsPerSignature", getU64Decoder()]
+  ]);
+}
+function getNonceAccountDataCodec() {
+  return combineCodec(
+    getNonceAccountDataEncoder(),
+    getNonceAccountDataDecoder()
+  );
+}
+function decodeNonce(encodedAccount) {
+  return decodeAccount(
+    encodedAccount,
+    getNonceAccountDataDecoder()
+  );
+}
+async function fetchNonce(rpc, address, config) {
+  const maybeAccount = await fetchMaybeNonce(rpc, address, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeNonce(rpc, address, config) {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return decodeNonce(maybeAccount);
+}
+async function fetchAllNonce(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeNonce(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeNonce(rpc, addresses, config) {
+  const maybeAccounts = await 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) || !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: AccountRole.READONLY
+      };
+      return;
+    }
+    const writableRole = account.isWritable ? AccountRole.WRITABLE : AccountRole.READONLY;
+    accountMetas[key] = Object.freeze({
+      address: expectAddress(account.value),
+      role: isTransactionSigner(account.value) ? upgradeRoleToSigner(writableRole) : writableRole,
+      ...isTransactionSigner(account.value) ? { signer: account.value } : {}
+    });
+  });
+  return accountMetas;
+}
+function isTransactionSigner(value) {
+  return !!value && typeof value === "object" && "address" in value && isTransactionSigner$1(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 mapEncoder(
+    getStructEncoder([["discriminator", getU32Encoder()]]),
+    (value) => ({ ...value, discriminator: 4 })
+  );
+}
+function getAdvanceNonceAccountInstructionDataDecoder() {
+  return getStructDecoder([["discriminator", getU32Decoder()]]);
+}
+function getAdvanceNonceAccountInstructionDataCodec() {
+  return 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, AccountRole.WRITABLE),
+      accountMetaWithDefault(
+        accounts.recentBlockhashesSysvar ?? "SysvarRecentB1ockHashes11111111111111111111",
+        AccountRole.READONLY
+      ),
+      accountMetaWithDefault(
+        accounts.nonceAuthority,
+        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 mapEncoder(
+    getStructEncoder([
+      ["discriminator", getU32Encoder()],
+      ["space", getU64Encoder()]
+    ]),
+    (value) => ({ ...value, discriminator: 8 })
+  );
+}
+function getAllocateInstructionDataDecoder() {
+  return getStructDecoder([
+    ["discriminator", getU32Decoder()],
+    ["space", getU64Decoder()]
+  ]);
+}
+function getAllocateInstructionDataCodec() {
+  return 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, 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 mapEncoder(
+    getStructEncoder([
+      ["discriminator", getU32Encoder()],
+      ["base", getAddressEncoder()],
+      ["seed", getStringEncoder()],
+      ["space", getU64Encoder()],
+      ["programAddress", getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: 9 })
+  );
+}
+function getAllocateWithSeedInstructionDataDecoder() {
+  return getStructDecoder([
+    ["discriminator", getU32Decoder()],
+    ["base", getAddressDecoder()],
+    ["seed", getStringDecoder()],
+    ["space", getU64Decoder()],
+    ["programAddress", getAddressDecoder()]
+  ]);
+}
+function getAllocateWithSeedInstructionDataCodec() {
+  return 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, AccountRole.WRITABLE),
+      accountMetaWithDefault(accounts.baseAccount, 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 mapEncoder(
+    getStructEncoder([
+      ["discriminator", getU32Encoder()],
+      ["programAddress", getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: 1 })
+  );
+}
+function getAssignInstructionDataDecoder() {
+  return getStructDecoder([
+    ["discriminator", getU32Decoder()],
+    ["programAddress", getAddressDecoder()]
+  ]);
+}
+function getAssignInstructionDataCodec() {
+  return 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, 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 mapEncoder(
+    getStructEncoder([
+      ["discriminator", getU32Encoder()],
+      ["base", getAddressEncoder()],
+      ["seed", getStringEncoder()],
+      ["programAddress", getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: 10 })
+  );
+}
+function getAssignWithSeedInstructionDataDecoder() {
+  return getStructDecoder([
+    ["discriminator", getU32Decoder()],
+    ["base", getAddressDecoder()],
+    ["seed", getStringDecoder()],
+    ["programAddress", getAddressDecoder()]
+  ]);
+}
+function getAssignWithSeedInstructionDataCodec() {
+  return 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, AccountRole.WRITABLE),
+      accountMetaWithDefault(accounts.baseAccount, 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 mapEncoder(
+    getStructEncoder([
+      ["discriminator", getU32Encoder()],
+      ["newNonceAuthority", getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: 7 })
+  );
+}
+function getAuthorizeNonceAccountInstructionDataDecoder() {
+  return getStructDecoder([
+    ["discriminator", getU32Decoder()],
+    ["newNonceAuthority", getAddressDecoder()]
+  ]);
+}
+function getAuthorizeNonceAccountInstructionDataCodec() {
+  return 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, AccountRole.WRITABLE),
+      accountMetaWithDefault(
+        accounts.nonceAuthority,
+        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 mapEncoder(
+    getStructEncoder([
+      ["discriminator", getU32Encoder()],
+      ["lamports", getU64Encoder()],
+      ["space", getU64Encoder()],
+      ["programAddress", getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: 0 })
+  );
+}
+function getCreateAccountInstructionDataDecoder() {
+  return getStructDecoder([
+    ["discriminator", getU32Decoder()],
+    ["lamports", getU64Decoder()],
+    ["space", getU64Decoder()],
+    ["programAddress", getAddressDecoder()]
+  ]);
+}
+function getCreateAccountInstructionDataCodec() {
+  return combineCodec(
+    getCreateAccountInstructionDataEncoder(),
+    getCreateAccountInstructionDataDecoder()
+  );
+}
+function getCreateAccountInstruction(input) {
+  const programAddress = "11111111111111111111111111111111";
+  const accounts = {
+    payer: { value: input.payer ?? null, isWritable: true },
+    newAccount: { value: input.newAccount ?? null, isWritable: true }
+  };
+  const args = { ...input };
+  const byteDelta = [Number(args.space) + BASE_ACCOUNT_SIZE].reduce(
+    (a, b) => a + b,
+    0
+  );
+  const accountMetas = getAccountMetasWithSigners(
+    accounts,
+    "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, AccountRole.WRITABLE_SIGNER),
+      accountMetaWithDefault(accounts.newAccount, 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 mapEncoder(
+    getStructEncoder([
+      ["discriminator", getU32Encoder()],
+      ["base", getAddressEncoder()],
+      ["seed", getStringEncoder()],
+      ["amount", getU64Encoder()],
+      ["space", getU64Encoder()],
+      ["programAddress", getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: 3 })
+  );
+}
+function getCreateAccountWithSeedInstructionDataDecoder() {
+  return getStructDecoder([
+    ["discriminator", getU32Decoder()],
+    ["base", getAddressDecoder()],
+    ["seed", getStringDecoder()],
+    ["amount", getU64Decoder()],
+    ["space", getU64Decoder()],
+    ["programAddress", getAddressDecoder()]
+  ]);
+}
+function getCreateAccountWithSeedInstructionDataCodec() {
+  return 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, AccountRole.WRITABLE_SIGNER),
+      accountMetaWithDefault(accounts.newAccount, AccountRole.WRITABLE),
+      accountMetaWithDefault(accounts.baseAccount, 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 mapEncoder(
+    getStructEncoder([
+      ["discriminator", getU32Encoder()],
+      ["nonceAuthority", getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: 6 })
+  );
+}
+function getInitializeNonceAccountInstructionDataDecoder() {
+  return getStructDecoder([
+    ["discriminator", getU32Decoder()],
+    ["nonceAuthority", getAddressDecoder()]
+  ]);
+}
+function getInitializeNonceAccountInstructionDataCodec() {
+  return 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, AccountRole.WRITABLE),
+      accountMetaWithDefault(
+        accounts.recentBlockhashesSysvar ?? "SysvarRecentB1ockHashes11111111111111111111",
+        AccountRole.READONLY
+      ),
+      accountMetaWithDefault(
+        accounts.rentSysvar ?? "SysvarRent111111111111111111111111111111111",
+        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 mapEncoder(
+    getStructEncoder([
+      ["discriminator", getU32Encoder()],
+      ["amount", getU64Encoder()]
+    ]),
+    (value) => ({ ...value, discriminator: 2 })
+  );
+}
+function getTransferSolInstructionDataDecoder() {
+  return getStructDecoder([
+    ["discriminator", getU32Decoder()],
+    ["amount", getU64Decoder()]
+  ]);
+}
+function getTransferSolInstructionDataCodec() {
+  return 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, AccountRole.WRITABLE_SIGNER),
+      accountMetaWithDefault(accounts.destination, 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 mapEncoder(
+    getStructEncoder([
+      ["discriminator", getU32Encoder()],
+      ["amount", getU64Encoder()],
+      ["fromSeed", getStringEncoder()],
+      ["fromOwner", getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: 11 })
+  );
+}
+function getTransferSolWithSeedInstructionDataDecoder() {
+  return getStructDecoder([
+    ["discriminator", getU32Decoder()],
+    ["amount", getU64Decoder()],
+    ["fromSeed", getStringDecoder()],
+    ["fromOwner", getAddressDecoder()]
+  ]);
+}
+function getTransferSolWithSeedInstructionDataCodec() {
+  return 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, AccountRole.WRITABLE),
+      accountMetaWithDefault(accounts.baseAccount, AccountRole.READONLY_SIGNER),
+      accountMetaWithDefault(accounts.destination, 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 mapEncoder(
+    getStructEncoder([["discriminator", getU32Encoder()]]),
+    (value) => ({ ...value, discriminator: 12 })
+  );
+}
+function getUpgradeNonceAccountInstructionDataDecoder() {
+  return getStructDecoder([["discriminator", getU32Decoder()]]);
+}
+function getUpgradeNonceAccountInstructionDataCodec() {
+  return 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, 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 mapEncoder(
+    getStructEncoder([
+      ["discriminator", getU32Encoder()],
+      ["withdrawAmount", getU64Encoder()]
+    ]),
+    (value) => ({ ...value, discriminator: 5 })
+  );
+}
+function getWithdrawNonceAccountInstructionDataDecoder() {
+  return getStructDecoder([
+    ["discriminator", getU32Decoder()],
+    ["withdrawAmount", getU64Decoder()]
+  ]);
+}
+function getWithdrawNonceAccountInstructionDataCodec() {
+  return 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, AccountRole.WRITABLE),
+      accountMetaWithDefault(accounts.recipientAccount, AccountRole.WRITABLE),
+      accountMetaWithDefault(
+        accounts.recentBlockhashesSysvar ?? "SysvarRecentB1ockHashes11111111111111111111",
+        AccountRole.READONLY
+      ),
+      accountMetaWithDefault(
+        accounts.rentSysvar ?? "SysvarRent111111111111111111111111111111111",
+        AccountRole.READONLY
+      ),
+      accountMetaWithDefault(
+        accounts.nonceAuthority,
+        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, getU32Encoder().encode(0), 0)) {
+    return 0 /* CreateAccount */;
+  }
+  if (memcmp(data, getU32Encoder().encode(1), 0)) {
+    return 1 /* Assign */;
+  }
+  if (memcmp(data, getU32Encoder().encode(2), 0)) {
+    return 2 /* TransferSol */;
+  }
+  if (memcmp(data, getU32Encoder().encode(3), 0)) {
+    return 3 /* CreateAccountWithSeed */;
+  }
+  if (memcmp(data, getU32Encoder().encode(4), 0)) {
+    return 4 /* AdvanceNonceAccount */;
+  }
+  if (memcmp(data, getU32Encoder().encode(5), 0)) {
+    return 5 /* WithdrawNonceAccount */;
+  }
+  if (memcmp(data, getU32Encoder().encode(6), 0)) {
+    return 6 /* InitializeNonceAccount */;
+  }
+  if (memcmp(data, getU32Encoder().encode(7), 0)) {
+    return 7 /* AuthorizeNonceAccount */;
+  }
+  if (memcmp(data, getU32Encoder().encode(8), 0)) {
+    return 8 /* Allocate */;
+  }
+  if (memcmp(data, getU32Encoder().encode(9), 0)) {
+    return 9 /* AllocateWithSeed */;
+  }
+  if (memcmp(data, getU32Encoder().encode(10), 0)) {
+    return 10 /* AssignWithSeed */;
+  }
+  if (memcmp(data, getU32Encoder().encode(11), 0)) {
+    return 11 /* TransferSolWithSeed */;
+  }
+  if (memcmp(data, getU32Encoder().encode(12), 0)) {
+    return 12 /* UpgradeNonceAccount */;
+  }
+  throw new Error(
+    "The provided instruction could not be identified as a system instruction."
+  );
+}
+
+export { NonceState, NonceVersion, SYSTEM_PROGRAM_ADDRESS, SystemAccount, SystemInstruction, SystemProgramError, SystemProgramErrorCode, accountMetaWithDefault, decodeNonce, expectAddress, expectProgramDerivedAddress, expectSome, expectTransactionSigner, fetchAllMaybeNonce, fetchAllNonce, fetchMaybeNonce, fetchNonce, getAccountMetasWithSigners, getAdvanceNonceAccountInstruction, getAdvanceNonceAccountInstructionDataCodec, getAdvanceNonceAccountInstructionDataDecoder, getAdvanceNonceAccountInstructionDataEncoder, getAdvanceNonceAccountInstructionRaw, getAllocateInstruction, getAllocateInstructionDataCodec, getAllocateInstructionDataDecoder, getAllocateInstructionDataEncoder, getAllocateInstructionRaw, getAllocateWithSeedInstruction, getAllocateWithSeedInstructionDataCodec, getAllocateWithSeedInstructionDataDecoder, getAllocateWithSeedInstructionDataEncoder, getAllocateWithSeedInstructionRaw, getAssignInstruction, getAssignInstructionDataCodec, getAssignInstructionDataDecoder, getAssignInstructionDataEncoder, getAssignInstructionRaw, getAssignWithSeedInstruction, getAssignWithSeedInstructionDataCodec, getAssignWithSeedInstructionDataDecoder, getAssignWithSeedInstructionDataEncoder, getAssignWithSeedInstructionRaw, getAuthorizeNonceAccountInstruction, getAuthorizeNonceAccountInstructionDataCodec, getAuthorizeNonceAccountInstructionDataDecoder, getAuthorizeNonceAccountInstructionDataEncoder, getAuthorizeNonceAccountInstructionRaw, getCreateAccountInstruction, getCreateAccountInstructionDataCodec, getCreateAccountInstructionDataDecoder, getCreateAccountInstructionDataEncoder, getCreateAccountInstructionRaw, getCreateAccountWithSeedInstruction, getCreateAccountWithSeedInstructionDataCodec, getCreateAccountWithSeedInstructionDataDecoder, getCreateAccountWithSeedInstructionDataEncoder, getCreateAccountWithSeedInstructionRaw, getInitializeNonceAccountInstruction, getInitializeNonceAccountInstructionDataCodec, getInitializeNonceAccountInstructionDataDecoder, getInitializeNonceAccountInstructionDataEncoder, getInitializeNonceAccountInstructionRaw, getNonceAccountDataCodec, getNonceAccountDataDecoder, getNonceAccountDataEncoder, getNonceSize, getNonceStateCodec, getNonceStateDecoder, getNonceStateEncoder, getNonceVersionCodec, getNonceVersionDecoder, getNonceVersionEncoder, getSystemProgram, getSystemProgramErrorFromCode, getTransferSolInstruction, getTransferSolInstructionDataCodec, getTransferSolInstructionDataDecoder, getTransferSolInstructionDataEncoder, getTransferSolInstructionRaw, getTransferSolWithSeedInstruction, getTransferSolWithSeedInstructionDataCodec, getTransferSolWithSeedInstructionDataDecoder, getTransferSolWithSeedInstructionDataEncoder, getTransferSolWithSeedInstructionRaw, getUpgradeNonceAccountInstruction, getUpgradeNonceAccountInstructionDataCodec, getUpgradeNonceAccountInstructionDataDecoder, getUpgradeNonceAccountInstructionDataEncoder, getUpgradeNonceAccountInstructionRaw, getWithdrawNonceAccountInstruction, getWithdrawNonceAccountInstructionDataCodec, getWithdrawNonceAccountInstructionDataDecoder, getWithdrawNonceAccountInstructionDataEncoder, getWithdrawNonceAccountInstructionRaw, identifySystemInstruction, isTransactionSigner, memcmp, parseAdvanceNonceAccountInstruction, parseAllocateInstruction, parseAllocateWithSeedInstruction, parseAssignInstruction, parseAssignWithSeedInstruction, parseAuthorizeNonceAccountInstruction, parseCreateAccountInstruction, parseCreateAccountWithSeedInstruction, parseInitializeNonceAccountInstruction, parseTransferSolInstruction, parseTransferSolWithSeedInstruction, parseUpgradeNonceAccountInstruction, parseWithdrawNonceAccountInstruction };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.mjs.map