@solana-program/system 0.11.0 → 0.12.0

package/dist/src/index.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var kit = require('@solana/kit');
+var programClientCore = require('@solana/kit/program-client-core');
 
 // src/generated/accounts/nonce.ts
 var NonceState = /* @__PURE__ */ ((NonceState2) => {
@@ -78,36 +79,6 @@ async function fetchAllMaybeNonce(rpc, addresses, config) {
 function getNonceSize() {
   return 80;
 }
-function expectAddress(value) {
-  if (!value) {
-    throw new Error("Expected a Address.");
-  }
-  if (typeof value === "object" && "address" in value) {
-    return value.address;
-  }
-  if (Array.isArray(value)) {
-    return value[0];
-  }
-  return value;
-}
-function getAccountMetaFactory(programAddress, optionalAccountStrategy) {
-  return (account) => {
-    if (!account.value) {
-      return;
-    }
-    const writableRole = account.isWritable ? kit.AccountRole.WRITABLE : kit.AccountRole.READONLY;
-    return Object.freeze({
-      address: expectAddress(account.value),
-      role: isTransactionSigner(account.value) ? kit.upgradeRoleToSigner(writableRole) : writableRole,
-      ...isTransactionSigner(account.value) ? { signer: account.value } : {}
-    });
-  };
-}
-function isTransactionSigner(value) {
-  return !!value && typeof value === "object" && "address" in value && kit.isTransactionSigner(value);
-}
-
-// src/generated/instructions/advanceNonceAccount.ts
 var ADVANCE_NONCE_ACCOUNT_DISCRIMINATOR = 4;
 function getAdvanceNonceAccountDiscriminatorBytes() {
   return kit.getU32Encoder().encode(ADVANCE_NONCE_ACCOUNT_DISCRIMINATOR);
@@ -135,12 +106,12 @@ function getAdvanceNonceAccountInstruction(input, config) {
   if (!accounts.recentBlockhashesSysvar.value) {
     accounts.recentBlockhashesSysvar.value = "SysvarRecentB1ockHashes11111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
     accounts: [
-      getAccountMeta(accounts.nonceAccount),
-      getAccountMeta(accounts.recentBlockhashesSysvar),
-      getAccountMeta(accounts.nonceAuthority)
+      getAccountMeta("nonceAccount", accounts.nonceAccount),
+      getAccountMeta("recentBlockhashesSysvar", accounts.recentBlockhashesSysvar),
+      getAccountMeta("nonceAuthority", accounts.nonceAuthority)
     ],
     data: getAdvanceNonceAccountInstructionDataEncoder().encode({}),
     programAddress
@@ -148,7 +119,10 @@ function getAdvanceNonceAccountInstruction(input, config) {
 }
 function parseAdvanceNonceAccountInstruction(instruction) {
   if (instruction.accounts.length < 3) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 3
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -193,16 +167,19 @@ function getAllocateInstruction(input, config) {
   const originalAccounts = { newAccount: { value: input.newAccount ?? null, isWritable: true } };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
-    accounts: [getAccountMeta(accounts.newAccount)],
+    accounts: [getAccountMeta("newAccount", accounts.newAccount)],
     data: getAllocateInstructionDataEncoder().encode(args),
     programAddress
   });
 }
 function parseAllocateInstruction(instruction) {
   if (instruction.accounts.length < 1) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 1
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -252,16 +229,22 @@ function getAllocateWithSeedInstruction(input, config) {
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
-    accounts: [getAccountMeta(accounts.newAccount), getAccountMeta(accounts.baseAccount)],
+    accounts: [
+      getAccountMeta("newAccount", accounts.newAccount),
+      getAccountMeta("baseAccount", accounts.baseAccount)
+    ],
     data: getAllocateWithSeedInstructionDataEncoder().encode(args),
     programAddress
   });
 }
 function parseAllocateWithSeedInstruction(instruction) {
   if (instruction.accounts.length < 2) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 2
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -302,16 +285,19 @@ function getAssignInstruction(input, config) {
   const originalAccounts = { account: { value: input.account ?? null, isWritable: true } };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
-    accounts: [getAccountMeta(accounts.account)],
+    accounts: [getAccountMeta("account", accounts.account)],
     data: getAssignInstructionDataEncoder().encode(args),
     programAddress
   });
 }
 function parseAssignInstruction(instruction) {
   if (instruction.accounts.length < 1) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 1
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -359,16 +345,19 @@ function getAssignWithSeedInstruction(input, config) {
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
-    accounts: [getAccountMeta(accounts.account), getAccountMeta(accounts.baseAccount)],
+    accounts: [getAccountMeta("account", accounts.account), getAccountMeta("baseAccount", accounts.baseAccount)],
     data: getAssignWithSeedInstructionDataEncoder().encode(args),
     programAddress
   });
 }
 function parseAssignWithSeedInstruction(instruction) {
   if (instruction.accounts.length < 2) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 2
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -415,16 +404,22 @@ function getAuthorizeNonceAccountInstruction(input, config) {
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
-    accounts: [getAccountMeta(accounts.nonceAccount), getAccountMeta(accounts.nonceAuthority)],
+    accounts: [
+      getAccountMeta("nonceAccount", accounts.nonceAccount),
+      getAccountMeta("nonceAuthority", accounts.nonceAuthority)
+    ],
     data: getAuthorizeNonceAccountInstructionDataEncoder().encode(args),
     programAddress
   });
 }
 function parseAuthorizeNonceAccountInstruction(instruction) {
   if (instruction.accounts.length < 2) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 2
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -473,9 +468,9 @@ function getCreateAccountInstruction(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   const byteDelta = [Number(args.space) + kit.BASE_ACCOUNT_SIZE].reduce((a, b) => a + b, 0);
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
-    accounts: [getAccountMeta(accounts.payer), getAccountMeta(accounts.newAccount)],
+    accounts: [getAccountMeta("payer", accounts.payer), getAccountMeta("newAccount", accounts.newAccount)],
     byteDelta,
     data: getCreateAccountInstructionDataEncoder().encode(args),
     programAddress
@@ -483,7 +478,10 @@ function getCreateAccountInstruction(input, config) {
 }
 function parseCreateAccountInstruction(instruction) {
   if (instruction.accounts.length < 2) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 2
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -539,12 +537,12 @@ function getCreateAccountWithSeedInstruction(input, config) {
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
     accounts: [
-      getAccountMeta(accounts.payer),
-      getAccountMeta(accounts.newAccount),
-      getAccountMeta(accounts.baseAccount)
+      getAccountMeta("payer", accounts.payer),
+      getAccountMeta("newAccount", accounts.newAccount),
+      getAccountMeta("baseAccount", accounts.baseAccount)
     ].filter((x) => x !== void 0),
     data: getCreateAccountWithSeedInstructionDataEncoder().encode(args),
     programAddress
@@ -552,7 +550,10 @@ function getCreateAccountWithSeedInstruction(input, config) {
 }
 function parseCreateAccountWithSeedInstruction(instruction) {
   if (instruction.accounts.length < 2) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 2
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -612,12 +613,12 @@ function getInitializeNonceAccountInstruction(input, config) {
   if (!accounts.rentSysvar.value) {
     accounts.rentSysvar.value = "SysvarRent111111111111111111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
     accounts: [
-      getAccountMeta(accounts.nonceAccount),
-      getAccountMeta(accounts.recentBlockhashesSysvar),
-      getAccountMeta(accounts.rentSysvar)
+      getAccountMeta("nonceAccount", accounts.nonceAccount),
+      getAccountMeta("recentBlockhashesSysvar", accounts.recentBlockhashesSysvar),
+      getAccountMeta("rentSysvar", accounts.rentSysvar)
     ],
     data: getInitializeNonceAccountInstructionDataEncoder().encode(
       args
@@ -627,7 +628,10 @@ function getInitializeNonceAccountInstruction(input, config) {
 }
 function parseInitializeNonceAccountInstruction(instruction) {
   if (instruction.accounts.length < 3) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 3
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -675,16 +679,19 @@ function getTransferSolInstruction(input, config) {
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
-    accounts: [getAccountMeta(accounts.source), getAccountMeta(accounts.destination)],
+    accounts: [getAccountMeta("source", accounts.source), getAccountMeta("destination", accounts.destination)],
     data: getTransferSolInstructionDataEncoder().encode(args),
     programAddress
   });
 }
 function parseTransferSolInstruction(instruction) {
   if (instruction.accounts.length < 2) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 2
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -733,12 +740,12 @@ function getTransferSolWithSeedInstruction(input, config) {
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
     accounts: [
-      getAccountMeta(accounts.source),
-      getAccountMeta(accounts.baseAccount),
-      getAccountMeta(accounts.destination)
+      getAccountMeta("source", accounts.source),
+      getAccountMeta("baseAccount", accounts.baseAccount),
+      getAccountMeta("destination", accounts.destination)
     ],
     data: getTransferSolWithSeedInstructionDataEncoder().encode(args),
     programAddress
@@ -746,7 +753,10 @@ function getTransferSolWithSeedInstruction(input, config) {
 }
 function parseTransferSolWithSeedInstruction(instruction) {
   if (instruction.accounts.length < 3) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 3
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -780,16 +790,19 @@ function getUpgradeNonceAccountInstruction(input, config) {
   const programAddress = config?.programAddress ?? SYSTEM_PROGRAM_ADDRESS;
   const originalAccounts = { nonceAccount: { value: input.nonceAccount ?? null, isWritable: true } };
   const accounts = originalAccounts;
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
-    accounts: [getAccountMeta(accounts.nonceAccount)],
+    accounts: [getAccountMeta("nonceAccount", accounts.nonceAccount)],
     data: getUpgradeNonceAccountInstructionDataEncoder().encode({}),
     programAddress
   });
 }
 function parseUpgradeNonceAccountInstruction(instruction) {
   if (instruction.accounts.length < 1) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 1
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -845,14 +858,14 @@ function getWithdrawNonceAccountInstruction(input, config) {
   if (!accounts.rentSysvar.value) {
     accounts.rentSysvar.value = "SysvarRent111111111111111111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory();
+  const getAccountMeta = programClientCore.getAccountMetaFactory(programAddress, "omitted");
   return Object.freeze({
     accounts: [
-      getAccountMeta(accounts.nonceAccount),
-      getAccountMeta(accounts.recipientAccount),
-      getAccountMeta(accounts.recentBlockhashesSysvar),
-      getAccountMeta(accounts.rentSysvar),
-      getAccountMeta(accounts.nonceAuthority)
+      getAccountMeta("nonceAccount", accounts.nonceAccount),
+      getAccountMeta("recipientAccount", accounts.recipientAccount),
+      getAccountMeta("recentBlockhashesSysvar", accounts.recentBlockhashesSysvar),
+      getAccountMeta("rentSysvar", accounts.rentSysvar),
+      getAccountMeta("nonceAuthority", accounts.nonceAuthority)
     ],
     data: getWithdrawNonceAccountInstructionDataEncoder().encode(args),
     programAddress
@@ -860,7 +873,10 @@ function getWithdrawNonceAccountInstruction(input, config) {
 }
 function parseWithdrawNonceAccountInstruction(instruction) {
   if (instruction.accounts.length < 5) {
-    throw new Error("Not enough accounts");
+    throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+      actualAccountMetas: instruction.accounts.length,
+      expectedAccountMetas: 5
+    });
   }
   let accountIndex = 0;
   const getNextAccount = () => {
@@ -944,7 +960,10 @@ function identifySystemInstruction(instruction) {
   if (kit.containsBytes(data, kit.getU32Encoder().encode(12), 0)) {
     return 12 /* UpgradeNonceAccount */;
   }
-  throw new Error("The provided instruction could not be identified as a system instruction.");
+  throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, {
+    instructionData: data,
+    programName: "system"
+  });
 }
 function parseSystemInstruction(instruction) {
   const instructionType = identifySystemInstruction(instruction);
@@ -1029,9 +1048,43 @@ function parseSystemInstruction(instruction) {
       };
     }
     default:
-      throw new Error(`Unrecognized instruction type: ${instructionType}`);
+      throw new kit.SolanaError(kit.SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, {
+        instructionType,
+        programName: "system"
+      });
   }
 }
+function systemProgram() {
+  return (client) => {
+    return {
+      ...client,
+      system: {
+        accounts: { nonce: programClientCore.addSelfFetchFunctions(client, getNonceCodec()) },
+        instructions: {
+          createAccount: (input) => programClientCore.addSelfPlanAndSendFunctions(
+            client,
+            getCreateAccountInstruction({ ...input, payer: input.payer ?? client.payer })
+          ),
+          assign: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getAssignInstruction(input)),
+          transferSol: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getTransferSolInstruction(input)),
+          createAccountWithSeed: (input) => programClientCore.addSelfPlanAndSendFunctions(
+            client,
+            getCreateAccountWithSeedInstruction({ ...input, payer: input.payer ?? client.payer })
+          ),
+          advanceNonceAccount: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getAdvanceNonceAccountInstruction(input)),
+          withdrawNonceAccount: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getWithdrawNonceAccountInstruction(input)),
+          initializeNonceAccount: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getInitializeNonceAccountInstruction(input)),
+          authorizeNonceAccount: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getAuthorizeNonceAccountInstruction(input)),
+          allocate: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getAllocateInstruction(input)),
+          allocateWithSeed: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getAllocateWithSeedInstruction(input)),
+          assignWithSeed: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getAssignWithSeedInstruction(input)),
+          transferSolWithSeed: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getTransferSolWithSeedInstruction(input)),
+          upgradeNonceAccount: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getUpgradeNonceAccountInstruction(input))
+        }
+      }
+    };
+  };
+}
 
 // src/generated/errors/system.ts
 var SYSTEM_ERROR__ACCOUNT_ALREADY_IN_USE = 0;
@@ -1191,5 +1244,6 @@ exports.parseTransferSolInstruction = parseTransferSolInstruction;
 exports.parseTransferSolWithSeedInstruction = parseTransferSolWithSeedInstruction;
 exports.parseUpgradeNonceAccountInstruction = parseUpgradeNonceAccountInstruction;
 exports.parseWithdrawNonceAccountInstruction = parseWithdrawNonceAccountInstruction;
+exports.systemProgram = systemProgram;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map