@solana/kit 8.1.0-canary-20260827164440 → 8.1.0

package/dist/index.development.js

@@ -211,6 +211,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
   var SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_LOADED_ACCOUNTS_DATA_SIZE_LIMIT = 5663036;
   var SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_RESOURCE_LIMITS = 5663037;
   var SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_INSTRUCTION_ACCOUNT_INDEX_OUT_OF_RANGE = 5663038;
+  var SOLANA_ERROR__TRANSACTION__COMPUTE_UNIT_LIMIT_OUT_OF_RANGE = 5663039;
+  var SOLANA_ERROR__TRANSACTION__INVALID_HEAP_SIZE = 5663040;
   var SOLANA_ERROR__TRANSACTION_INTROSPECTION__CANNOT_DECODE_JSON_PARSED_TRANSACTION = 5664e3;
   var SOLANA_ERROR__TRANSACTION_INTROSPECTION__UNRECOGNIZED_GET_TRANSACTION_RESPONSE = 5664001;
   var SOLANA_ERROR__TRANSACTION_ERROR__UNKNOWN = 705e4;
@@ -615,6 +617,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     [SOLANA_ERROR__TRANSACTION__ADDRESSES_CANNOT_SIGN_TRANSACTION]: "Attempted to sign a transaction with an address that is not a signer for it",
     [SOLANA_ERROR__TRANSACTION__ADDRESS_MISSING]: "Transaction is missing an address at index: $index.",
     [SOLANA_ERROR__TRANSACTION__CANNOT_ENCODE_WITH_EMPTY_SIGNATURES]: "Transaction has no expected signers therefore it cannot be encoded",
+    [SOLANA_ERROR__TRANSACTION__COMPUTE_UNIT_LIMIT_OUT_OF_RANGE]: "Transaction compute unit limit must be an integer in the range [0, $maxComputeUnitLimit]. `$computeUnitLimit` given",
     [SOLANA_ERROR__TRANSACTION__EXCEEDS_SIZE_LIMIT]: "Transaction size $transactionSize exceeds limit of $transactionSizeLimit bytes",
     [SOLANA_ERROR__TRANSACTION__EXPECTED_BLOCKHASH_LIFETIME]: "Transaction does not have a blockhash lifetime",
     [SOLANA_ERROR__TRANSACTION__EXPECTED_NONCE_LIFETIME]: "Transaction is not a durable nonce transaction",
@@ -643,6 +646,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     [SOLANA_ERROR__TRANSACTION__CANNOT_DECODE_EMPTY_TRANSACTION_BYTES]: "Transaction bytes are empty, so no transaction can be decoded",
     [SOLANA_ERROR__TRANSACTION__VERSION_ZERO_MUST_BE_ENCODED_WITH_SIGNATURES_FIRST]: "Transaction version 0 must be encoded with signatures first. This transaction was encoded with first byte $firstByte, which is expected to be a signature count for v0 transactions.",
     [SOLANA_ERROR__TRANSACTION__SIGNATURE_COUNT_TOO_HIGH_FOR_TRANSACTION_BYTES]: "The provided transaction bytes expect that there should be $numExpectedSignatures signatures, but the bytes are not long enough to contain a transaction message with this many signatures. The provided bytes are $transactionBytesLength bytes long.",
+    [SOLANA_ERROR__TRANSACTION__INVALID_HEAP_SIZE]: "Transaction heap size must be an integer multiple of $multipleOf bytes in the range [$minHeapSize, $maxHeapSize]. `$heapSize` given",
     [SOLANA_ERROR__TRANSACTION__INVALID_NONCE_ACCOUNT_INDEX]: "The transaction has a durable nonce lifetime, but the nonce account index is invalid. Expected a nonce account index less than $numberOfStaticAccounts, got $nonceAccountIndex.",
     [SOLANA_ERROR__TRANSACTION__INVALID_CONFIG_VALUE_KIND]: "The transaction config value for $configName has the incorrect kind. Expected $expectedKind, got $actualKind.",
     [SOLANA_ERROR__TRANSACTION__INSTRUCTION_HEADERS_PAYLOADS_MISMATCH]: "The transaction does not have the same number of instruction headers and instruction payloads. Got $numInstructionHeaders instruction headers, and $numInstructionPayloads instruction payloads.",
@@ -4822,6 +4826,102 @@ this.globalThis.solanaWeb3 = (function (exports) {
       }
     );
   }
+  var COMPUTE_BUDGET_PROGRAM_ADDRESS = "ComputeBudget111111111111111111111111111111";
+  var MAX_COMPUTE_UNIT_LIMIT = 14e5;
+  var REQUEST_HEAP_FRAME_DISCRIMINATOR = 1;
+  var SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR = 2;
+  var SET_COMPUTE_UNIT_PRICE_DISCRIMINATOR = 3;
+  var SET_LOADED_ACCOUNTS_DATA_SIZE_LIMIT_DISCRIMINATOR = 4;
+  function getComputeBudgetInstruction(discriminator, value) {
+    const data = getStructEncoder([
+      ["discriminator", getU8Encoder()],
+      ["value", getBytesEncoder()]
+    ]).encode({ discriminator, value });
+    return Object.freeze({
+      data,
+      programAddress: COMPUTE_BUDGET_PROGRAM_ADDRESS
+    });
+  }
+  function isComputeBudgetInstruction(instruction, discriminator, expectedDataLength) {
+    return instruction.programAddress === COMPUTE_BUDGET_PROGRAM_ADDRESS && "data" in instruction && instruction.data != null && instruction.data.byteLength === expectedDataLength && instruction.data[0] === discriminator;
+  }
+  function getSetComputeUnitLimitInstruction(units) {
+    return getComputeBudgetInstruction(SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR, getU32Encoder().encode(units));
+  }
+  function isSetComputeUnitLimitInstruction(instruction) {
+    return isComputeBudgetInstruction(instruction, SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR, 5);
+  }
+  function getComputeUnitLimitFromInstructionData(data) {
+    return getU32Decoder().decode(data, 1);
+  }
+  function getSetComputeUnitPriceInstruction(microLamports) {
+    return getComputeBudgetInstruction(SET_COMPUTE_UNIT_PRICE_DISCRIMINATOR, getU64Encoder().encode(microLamports));
+  }
+  function isSetComputeUnitPriceInstruction(instruction) {
+    return isComputeBudgetInstruction(instruction, SET_COMPUTE_UNIT_PRICE_DISCRIMINATOR, 9);
+  }
+  function getPriorityFeeFromInstructionData(data) {
+    return getU64Decoder().decode(data, 1);
+  }
+  function getRequestHeapFrameInstruction(bytes) {
+    return getComputeBudgetInstruction(REQUEST_HEAP_FRAME_DISCRIMINATOR, getU32Encoder().encode(bytes));
+  }
+  function isRequestHeapFrameInstruction(instruction) {
+    return isComputeBudgetInstruction(instruction, REQUEST_HEAP_FRAME_DISCRIMINATOR, 5);
+  }
+  function getHeapSizeFromInstructionData(data) {
+    return getU32Decoder().decode(data, 1);
+  }
+  function getSetLoadedAccountsDataSizeLimitInstruction(limit) {
+    return getComputeBudgetInstruction(
+      SET_LOADED_ACCOUNTS_DATA_SIZE_LIMIT_DISCRIMINATOR,
+      getU32Encoder().encode(limit)
+    );
+  }
+  function isSetLoadedAccountsDataSizeLimitInstruction(instruction) {
+    return isComputeBudgetInstruction(instruction, SET_LOADED_ACCOUNTS_DATA_SIZE_LIMIT_DISCRIMINATOR, 5);
+  }
+  function getLoadedAccountsDataSizeLimitFromInstructionData(data) {
+    return getU32Decoder().decode(data, 1);
+  }
+  function replaceTransactionMessageInstruction(index, newInstruction, transactionMessage) {
+    const nextInstructions = [...transactionMessage.instructions];
+    nextInstructions[index] = newInstruction;
+    return Object.freeze({
+      ...transactionMessage,
+      instructions: Object.freeze(nextInstructions)
+    });
+  }
+  function removeTransactionMessageInstruction(index, transactionMessage) {
+    return Object.freeze({
+      ...transactionMessage,
+      instructions: Object.freeze([
+        ...transactionMessage.instructions.slice(0, index),
+        ...transactionMessage.instructions.slice(index + 1)
+      ])
+    });
+  }
+  var MIN_HEAP_SIZE = 32 * 1024;
+  var MAX_HEAP_SIZE = 256 * 1024;
+  var HEAP_SIZE_MULTIPLE_OF = 1024;
+  function assertIsValidComputeUnitLimit(computeUnitLimit) {
+    if (!Number.isInteger(computeUnitLimit) || computeUnitLimit < 0 || computeUnitLimit > MAX_COMPUTE_UNIT_LIMIT) {
+      throw new SolanaError(SOLANA_ERROR__TRANSACTION__COMPUTE_UNIT_LIMIT_OUT_OF_RANGE, {
+        computeUnitLimit,
+        maxComputeUnitLimit: MAX_COMPUTE_UNIT_LIMIT
+      });
+    }
+  }
+  function assertIsValidHeapSize(heapSize) {
+    if (!Number.isInteger(heapSize) || heapSize < MIN_HEAP_SIZE || heapSize > MAX_HEAP_SIZE || heapSize % HEAP_SIZE_MULTIPLE_OF !== 0) {
+      throw new SolanaError(SOLANA_ERROR__TRANSACTION__INVALID_HEAP_SIZE, {
+        heapSize,
+        maxHeapSize: MAX_HEAP_SIZE,
+        minHeapSize: MIN_HEAP_SIZE,
+        multipleOf: HEAP_SIZE_MULTIPLE_OF
+      });
+    }
+  }
   function isV1ConfigEmpty(config) {
     return config.computeUnitLimit === void 0 && config.heapSize === void 0 && config.loadedAccountsDataSizeLimit === void 0 && config.priorityFeeLamports === void 0;
   }
@@ -4829,6 +4929,12 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return config1.computeUnitLimit === config2.computeUnitLimit && config1.heapSize === config2.heapSize && config1.loadedAccountsDataSizeLimit === config2.loadedAccountsDataSizeLimit && config1.priorityFeeLamports === config2.priorityFeeLamports;
   }
   function setTransactionMessageConfig(config, transactionMessage) {
+    if (config.computeUnitLimit !== void 0) {
+      assertIsValidComputeUnitLimit(config.computeUnitLimit);
+    }
+    if (config.heapSize !== void 0) {
+      assertIsValidHeapSize(config.heapSize);
+    }
     const mergedConfig = {
       ...transactionMessage.config,
       ...config
@@ -5674,80 +5780,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
       updatedAnyInstructions ? { ...transactionMessage, instructions: newInstructions } : transactionMessage
     );
   }
-  var COMPUTE_BUDGET_PROGRAM_ADDRESS = "ComputeBudget111111111111111111111111111111";
-  var REQUEST_HEAP_FRAME_DISCRIMINATOR = 1;
-  var SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR = 2;
-  var SET_COMPUTE_UNIT_PRICE_DISCRIMINATOR = 3;
-  var SET_LOADED_ACCOUNTS_DATA_SIZE_LIMIT_DISCRIMINATOR = 4;
-  function getComputeBudgetInstruction(discriminator, value) {
-    const data = getStructEncoder([
-      ["discriminator", getU8Encoder()],
-      ["value", getBytesEncoder()]
-    ]).encode({ discriminator, value });
-    return Object.freeze({
-      data,
-      programAddress: COMPUTE_BUDGET_PROGRAM_ADDRESS
-    });
-  }
-  function isComputeBudgetInstruction(instruction, discriminator, expectedDataLength) {
-    return instruction.programAddress === COMPUTE_BUDGET_PROGRAM_ADDRESS && "data" in instruction && instruction.data != null && instruction.data.byteLength === expectedDataLength && instruction.data[0] === discriminator;
-  }
-  function getSetComputeUnitLimitInstruction(units) {
-    return getComputeBudgetInstruction(SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR, getU32Encoder().encode(units));
-  }
-  function isSetComputeUnitLimitInstruction(instruction) {
-    return isComputeBudgetInstruction(instruction, SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR, 5);
-  }
-  function getComputeUnitLimitFromInstructionData(data) {
-    return getU32Decoder().decode(data, 1);
-  }
-  function getSetComputeUnitPriceInstruction(microLamports) {
-    return getComputeBudgetInstruction(SET_COMPUTE_UNIT_PRICE_DISCRIMINATOR, getU64Encoder().encode(microLamports));
-  }
-  function isSetComputeUnitPriceInstruction(instruction) {
-    return isComputeBudgetInstruction(instruction, SET_COMPUTE_UNIT_PRICE_DISCRIMINATOR, 9);
-  }
-  function getPriorityFeeFromInstructionData(data) {
-    return getU64Decoder().decode(data, 1);
-  }
-  function getRequestHeapFrameInstruction(bytes) {
-    return getComputeBudgetInstruction(REQUEST_HEAP_FRAME_DISCRIMINATOR, getU32Encoder().encode(bytes));
-  }
-  function isRequestHeapFrameInstruction(instruction) {
-    return isComputeBudgetInstruction(instruction, REQUEST_HEAP_FRAME_DISCRIMINATOR, 5);
-  }
-  function getHeapSizeFromInstructionData(data) {
-    return getU32Decoder().decode(data, 1);
-  }
-  function getSetLoadedAccountsDataSizeLimitInstruction(limit) {
-    return getComputeBudgetInstruction(
-      SET_LOADED_ACCOUNTS_DATA_SIZE_LIMIT_DISCRIMINATOR,
-      getU32Encoder().encode(limit)
-    );
-  }
-  function isSetLoadedAccountsDataSizeLimitInstruction(instruction) {
-    return isComputeBudgetInstruction(instruction, SET_LOADED_ACCOUNTS_DATA_SIZE_LIMIT_DISCRIMINATOR, 5);
-  }
-  function getLoadedAccountsDataSizeLimitFromInstructionData(data) {
-    return getU32Decoder().decode(data, 1);
-  }
-  function replaceTransactionMessageInstruction(index, newInstruction, transactionMessage) {
-    const nextInstructions = [...transactionMessage.instructions];
-    nextInstructions[index] = newInstruction;
-    return Object.freeze({
-      ...transactionMessage,
-      instructions: Object.freeze(nextInstructions)
-    });
-  }
-  function removeTransactionMessageInstruction(index, transactionMessage) {
-    return Object.freeze({
-      ...transactionMessage,
-      instructions: Object.freeze([
-        ...transactionMessage.instructions.slice(0, index),
-        ...transactionMessage.instructions.slice(index + 1)
-      ])
-    });
-  }
   function appendTransactionMessageInstruction(instruction, transactionMessage) {
     return appendTransactionMessageInstructions([instruction], transactionMessage);
   }
@@ -5787,6 +5819,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return existingInstruction ? getComputeUnitLimitFromInstructionData(existingInstruction.data) : void 0;
   }
   function setTransactionMessageComputeUnitLimit(computeUnitLimit, transactionMessage) {
+    if (computeUnitLimit !== void 0) {
+      assertIsValidComputeUnitLimit(computeUnitLimit);
+    }
     switch (transactionMessage.version) {
       case 1:
         return setTransactionMessageComputeUnitLimitUsingConfig(
@@ -6161,7 +6196,10 @@ this.globalThis.solanaWeb3 = (function (exports) {
     );
     return pipe(
       createTransactionMessage({ version: 1 }),
-      (m) => setTransactionMessageConfig(transactionConfig, m),
+      // Attach the decoded config directly instead of going through `setTransactionMessageConfig`,
+      // which validates resource limits. Decoding must not reject a transaction merely because it
+      // carries values the runtime would refuse; callers need to be able to inspect such messages.
+      (m) => isV1ConfigEmpty(transactionConfig) ? m : Object.freeze({ ...m, config: Object.freeze(transactionConfig) }),
       (m) => setTransactionMessageFeePayer(feePayer, m),
       (m) => appendTransactionMessageInstructions(instructions, m),
       (m) => "blockhash" in lifetimeConstraint ? setTransactionMessageLifetimeUsingBlockhash(lifetimeConstraint, m) : setTransactionMessageLifetimeUsingDurableNonce(lifetimeConstraint, m)
@@ -6196,6 +6234,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return existingInstruction ? getHeapSizeFromInstructionData(existingInstruction.data) : void 0;
   }
   function setTransactionMessageHeapSize(heapSize, transactionMessage) {
+    if (heapSize !== void 0) {
+      assertIsValidHeapSize(heapSize);
+    }
     switch (transactionMessage.version) {
       case 1:
         return setTransactionMessageHeapSizeUsingConfig(heapSize, transactionMessage);
@@ -10719,7 +10760,7 @@ ${lastLines.map((line) => `  > ${line}
           ...config.headers ? normalizeHeaders2(config.headers) : void 0,
           ...{
             // Keep these headers lowercase so they will override any user-supplied headers above.
-            "solana-client": `js/${"8.1.0-canary-20260827164440"}`
+            "solana-client": `js/${"8.1.0"}`
           }
         }
       }),
@@ -12855,7 +12896,7 @@ ${lastLines.map((line) => `  > ${line}
 
   // src/resource-limit-estimation.ts
   var PROVISORY_LIMIT = 0;
-  var MAX_COMPUTE_UNIT_LIMIT = 14e5;
+  var MAX_COMPUTE_UNIT_LIMIT2 = 14e5;
   var MAX_LOADED_ACCOUNTS_DATA_SIZE_LIMIT = 64 * 1024 * 1024;
   function estimateResourceLimitsFactory({
     rpc
@@ -12866,7 +12907,7 @@ ${lastLines.map((line) => `  > ${line}
       const isDataSizeRequired = transactionMessage.version === 1;
       const transaction = pipe(
         transactionMessage,
-        (m) => setTransactionMessageComputeUnitLimit(MAX_COMPUTE_UNIT_LIMIT, m),
+        (m) => setTransactionMessageComputeUnitLimit(MAX_COMPUTE_UNIT_LIMIT2, m),
         (m) => isDataSizeRequired ? setTransactionMessageLoadedAccountsDataSizeLimit(MAX_LOADED_ACCOUNTS_DATA_SIZE_LIMIT, m) : m,
         compileTransaction
       );
@@ -12912,7 +12953,7 @@ ${lastLines.map((line) => `  > ${line}
   function estimateAndSetResourceLimitsFactory(estimateResourceLimits) {
     return async function estimateAndSetResourceLimits(transactionMessage, config) {
       const existingComputeUnitLimit = getTransactionMessageComputeUnitLimit(transactionMessage);
-      const computeUnitLimitIsExplicit = existingComputeUnitLimit !== void 0 && existingComputeUnitLimit !== PROVISORY_LIMIT && existingComputeUnitLimit !== MAX_COMPUTE_UNIT_LIMIT;
+      const computeUnitLimitIsExplicit = existingComputeUnitLimit !== void 0 && existingComputeUnitLimit !== PROVISORY_LIMIT && existingComputeUnitLimit !== MAX_COMPUTE_UNIT_LIMIT2;
       const isV1 = transactionMessage.version === 1;
       let loadedAccountsDataSizeLimitIsExplicit = true;
       if (isV1) {
@@ -13421,6 +13462,7 @@ ${lastLines.map((line) => `  > ${line}
   exports.SOLANA_ERROR__TRANSACTION__CANNOT_DECODE_EMPTY_TRANSACTION_BYTES = SOLANA_ERROR__TRANSACTION__CANNOT_DECODE_EMPTY_TRANSACTION_BYTES;
   exports.SOLANA_ERROR__TRANSACTION__CANNOT_ENCODE_WITH_EMPTY_MESSAGE_BYTES = SOLANA_ERROR__TRANSACTION__CANNOT_ENCODE_WITH_EMPTY_MESSAGE_BYTES;
   exports.SOLANA_ERROR__TRANSACTION__CANNOT_ENCODE_WITH_EMPTY_SIGNATURES = SOLANA_ERROR__TRANSACTION__CANNOT_ENCODE_WITH_EMPTY_SIGNATURES;
+  exports.SOLANA_ERROR__TRANSACTION__COMPUTE_UNIT_LIMIT_OUT_OF_RANGE = SOLANA_ERROR__TRANSACTION__COMPUTE_UNIT_LIMIT_OUT_OF_RANGE;
   exports.SOLANA_ERROR__TRANSACTION__EXCEEDS_SIZE_LIMIT = SOLANA_ERROR__TRANSACTION__EXCEEDS_SIZE_LIMIT;
   exports.SOLANA_ERROR__TRANSACTION__EXPECTED_BLOCKHASH_LIFETIME = SOLANA_ERROR__TRANSACTION__EXPECTED_BLOCKHASH_LIFETIME;
   exports.SOLANA_ERROR__TRANSACTION__EXPECTED_NONCE_LIFETIME = SOLANA_ERROR__TRANSACTION__EXPECTED_NONCE_LIFETIME;
@@ -13438,6 +13480,7 @@ ${lastLines.map((line) => `  > ${line}
   exports.SOLANA_ERROR__TRANSACTION__INSTRUCTION_HEADERS_PAYLOADS_MISMATCH = SOLANA_ERROR__TRANSACTION__INSTRUCTION_HEADERS_PAYLOADS_MISMATCH;
   exports.SOLANA_ERROR__TRANSACTION__INVALID_CONFIG_MASK_PRIORITY_FEE_BITS = SOLANA_ERROR__TRANSACTION__INVALID_CONFIG_MASK_PRIORITY_FEE_BITS;
   exports.SOLANA_ERROR__TRANSACTION__INVALID_CONFIG_VALUE_KIND = SOLANA_ERROR__TRANSACTION__INVALID_CONFIG_VALUE_KIND;
+  exports.SOLANA_ERROR__TRANSACTION__INVALID_HEAP_SIZE = SOLANA_ERROR__TRANSACTION__INVALID_HEAP_SIZE;
   exports.SOLANA_ERROR__TRANSACTION__INVALID_NONCE_ACCOUNT_INDEX = SOLANA_ERROR__TRANSACTION__INVALID_NONCE_ACCOUNT_INDEX;
   exports.SOLANA_ERROR__TRANSACTION__INVALID_NONCE_TRANSACTION_FIRST_INSTRUCTION_MUST_BE_ADVANCE_NONCE = SOLANA_ERROR__TRANSACTION__INVALID_NONCE_TRANSACTION_FIRST_INSTRUCTION_MUST_BE_ADVANCE_NONCE;
   exports.SOLANA_ERROR__TRANSACTION__INVALID_NONCE_TRANSACTION_INSTRUCTIONS_MISSING = SOLANA_ERROR__TRANSACTION__INVALID_NONCE_TRANSACTION_INSTRUCTIONS_MISSING;