@solana/web3.js 2.0.0-experimental.bea19d2 → 2.0.0-experimental.c067018

package/dist/index.development.js

@@ -127,7 +127,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
 
   // ../errors/dist/index.browser.js
   init_env_shim();
-  var SOLANA_ERROR__RPC_INTEGER_OVERFLOW = 3;
   var SOLANA_ERROR__INVALID_KEYPAIR_BYTES = 4;
   var SOLANA_ERROR__BLOCK_HEIGHT_EXCEEDED = 5;
   var SOLANA_ERROR__NONCE_INVALID = 6;
@@ -137,8 +136,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
   var SOLANA_ERROR__FAILED_TO_DECODE_ACCOUNT = 10;
   var SOLANA_ERROR__EXPECTED_DECODED_ACCOUNT = 11;
   var SOLANA_ERROR__NOT_ALL_ACCOUNTS_DECODED = 12;
-  var SOLANA_ERROR__INCORRECT_BASE58_ADDRESS_LENGTH = 13;
-  var SOLANA_ERROR__INCORRECT_BASE58_ADDRESS_BYTE_LENGTH = 14;
+  var SOLANA_ERROR__ADDRESS_BYTE_LENGTH_OUT_OF_RANGE = 13;
+  var SOLANA_ERROR__ADDRESS_STRING_LENGTH_OUT_OF_RANGE = 14;
   var SOLANA_ERROR__NOT_A_BASE58_ENCODED_ADDRESS = 15;
   var SOLANA_ERROR__NOT_AN_ED25519_PUBLIC_KEY = 16;
   var SOLANA_ERROR__MALFORMED_PROGRAM_DERIVED_ADDRESS = 17;
@@ -148,6 +147,29 @@ this.globalThis.solanaWeb3 = (function (exports) {
   var SOLANA_ERROR__INVALID_SEEDS_POINT_ON_CURVE = 21;
   var SOLANA_ERROR__COULD_NOT_FIND_VIABLE_PDA_BUMP_SEED = 22;
   var SOLANA_ERROR__PROGRAM_ADDRESS_ENDS_WITH_PDA_MARKER = 23;
+  var SOLANA_ERROR__BLOCKHASH_STRING_LENGTH_OUT_OF_RANGE = 48;
+  var SOLANA_ERROR__BLOCKHASH_BYTE_LENGTH_OUT_OF_RANGE = 49;
+  var SOLANA_ERROR__LAMPORTS_OUT_OF_RANGE = 50;
+  var SOLANA_ERROR__MALFORMED_BIGINT_STRING = 51;
+  var SOLANA_ERROR__MALFORMED_NUMBER_STRING = 52;
+  var SOLANA_ERROR__TIMESTAMP_OUT_OF_RANGE = 53;
+  var SOLANA_ERROR__INVARIANT_VIOLATION_WEBSOCKET_MESSAGE_ITERATOR_STATE_MISSING = 3507e3;
+  var SOLANA_ERROR__INVARIANT_VIOLATION_WEBSOCKET_MESSAGE_ITERATOR_MUST_NOT_POLL_BEFORE_RESOLVING_EXISTING_MESSAGE_PROMISE = 3507001;
+  var SOLANA_ERROR__INVARIANT_VIOLATION_CACHED_ABORTABLE_ITERABLE_CACHE_ENTRY_MISSING = 3507002;
+  var SOLANA_ERROR__INVARIANT_VIOLATION_SWITCH_MUST_BE_EXHAUSTIVE = 3507003;
+  var SOLANA_ERROR__SUBTLE_CRYPTO_MISSING = 361e4;
+  var SOLANA_ERROR__SUBTLE_CRYPTO_DIGEST_MISSING = 3610001;
+  var SOLANA_ERROR__SUBTLE_CRYPTO_ED25519_ALGORITHM_MISSING = 3610002;
+  var SOLANA_ERROR__SUBTLE_CRYPTO_EXPORT_FUNCTION_MISSING = 3610003;
+  var SOLANA_ERROR__SUBTLE_CRYPTO_GENERATE_FUNCTION_MISSING = 3610004;
+  var SOLANA_ERROR__SUBTLE_CRYPTO_SIGN_FUNCTION_MISSING = 3610005;
+  var SOLANA_ERROR__SUBTLE_CRYPTO_VERIFY_FUNCTION_MISSING = 3610006;
+  var SOLANA_ERROR__KEYS_INVALID_PRIVATE_KEY_BYTE_LENGTH = 3704e3;
+  var SOLANA_ERROR__KEYS_INVALID_SIGNATURE_BYTE_LENGTH = 3704001;
+  var SOLANA_ERROR__KEYS_SIGNATURE_STRING_LENGTH_OUT_OF_RANGE = 3704002;
+  var SOLANA_ERROR__INSTRUCTION_EXPECTED_TO_HAVE_ACCOUNTS = 4128e3;
+  var SOLANA_ERROR__INSTRUCTION_EXPECTED_TO_HAVE_DATA = 4128001;
+  var SOLANA_ERROR__INSTRUCTION_PROGRAM_ID_MISMATCH = 4128002;
   var SOLANA_ERROR__INSTRUCTION_ERROR_UNKNOWN = 4615e3;
   var SOLANA_ERROR__INSTRUCTION_ERROR_GENERIC_ERROR = 4615001;
   var SOLANA_ERROR__INSTRUCTION_ERROR_INVALID_ARGUMENT = 4615002;
@@ -203,6 +225,17 @@ this.globalThis.solanaWeb3 = (function (exports) {
   var SOLANA_ERROR__INSTRUCTION_ERROR_MAX_ACCOUNTS_EXCEEDED = 4615052;
   var SOLANA_ERROR__INSTRUCTION_ERROR_MAX_INSTRUCTION_TRACE_LENGTH_EXCEEDED = 4615053;
   var SOLANA_ERROR__INSTRUCTION_ERROR_BUILTIN_PROGRAMS_MUST_CONSUME_COMPUTE_UNITS = 4615054;
+  var SOLANA_ERROR__SIGNER_ADDRESS_CANNOT_HAVE_MULTIPLE_SIGNERS = 5508e3;
+  var SOLANA_ERROR__SIGNER_EXPECTED_KEY_PAIR_SIGNER = 5508001;
+  var SOLANA_ERROR__SIGNER_EXPECTED_MESSAGE_SIGNER = 5508002;
+  var SOLANA_ERROR__SIGNER_EXPECTED_MESSAGE_MODIFYING_SIGNER = 5508003;
+  var SOLANA_ERROR__SIGNER_EXPECTED_MESSAGE_PARTIAL_SIGNER = 5508004;
+  var SOLANA_ERROR__SIGNER_EXPECTED_TRANSACTION_SIGNER = 5508005;
+  var SOLANA_ERROR__SIGNER_EXPECTED_TRANSACTION_MODIFYING_SIGNER = 5508006;
+  var SOLANA_ERROR__SIGNER_EXPECTED_TRANSACTION_PARTIAL_SIGNER = 5508007;
+  var SOLANA_ERROR__SIGNER_EXPECTED_TRANSACTION_SENDING_SIGNER = 5508008;
+  var SOLANA_ERROR__SIGNER_TRANSACTION_CANNOT_HAVE_MULTIPLE_SENDING_SIGNERS = 5508009;
+  var SOLANA_ERROR__SIGNER_TRANSACTION_SENDING_SIGNER_MISSING = 5508010;
   var SOLANA_ERROR__TRANSACTION_INVOKED_PROGRAMS_CANNOT_PAY_FEES = 5663001;
   var SOLANA_ERROR__TRANSACTION_INVOKED_PROGRAMS_MUST_NOT_BE_WRITABLE = 5663002;
   var SOLANA_ERROR__TRANSACTION_EXPECTED_BLOCKHASH_LIFETIME = 5663003;
@@ -214,6 +247,10 @@ this.globalThis.solanaWeb3 = (function (exports) {
   var SOLANA_ERROR__TRANSACTION_FAILED_TO_DECOMPILE_FEE_PAYER_MISSING = 5663009;
   var SOLANA_ERROR__TRANSACTION_MISSING_SIGNATURES = 5663010;
   var SOLANA_ERROR__TRANSACTION_SIGNATURE_NOT_COMPUTABLE = 5663011;
+  var SOLANA_ERROR__TRANSACTION_MISSING_ADDRESS = 5663012;
+  var SOLANA_ERROR__TRANSACTION_MISSING_FEE_PAYER = 5663013;
+  var SOLANA_ERROR__TRANSACTION_INVALID_NONCE_TRANSACTION_NO_INSTRUCTIONS = 5663014;
+  var SOLANA_ERROR__TRANSACTION_INVALID_NONCE_TRANSACTION_FIRST_INSTRUCTION_NOT_ADVANCE_NONCE = 5663015;
   var SOLANA_ERROR__TRANSACTION_ERROR_UNKNOWN = 705e4;
   var SOLANA_ERROR__TRANSACTION_ERROR_ACCOUNT_IN_USE = 7050001;
   var SOLANA_ERROR__TRANSACTION_ERROR_ACCOUNT_LOADED_TWICE = 7050002;
@@ -251,14 +288,50 @@ this.globalThis.solanaWeb3 = (function (exports) {
   var SOLANA_ERROR__TRANSACTION_ERROR_RESANITIZATION_NEEDED = 7050034;
   var SOLANA_ERROR__TRANSACTION_ERROR_PROGRAM_EXECUTION_TEMPORARILY_RESTRICTED = 7050035;
   var SOLANA_ERROR__TRANSACTION_ERROR_UNBALANCED_TRANSACTION = 7050036;
+  var SOLANA_ERROR__CODECS_CANNOT_DECODE_EMPTY_BYTE_ARRAY = 8078e3;
+  var SOLANA_ERROR__CODECS_WRONG_NUMBER_OF_BYTES = 8078001;
+  var SOLANA_ERROR__CODECS_EXPECTED_FIXED_LENGTH_GOT_VARIABLE_LENGTH = 8078002;
+  var SOLANA_ERROR__CODECS_EXPECTED_VARIABLE_LENGTH_GOT_FIXED_LENGTH = 8078003;
+  var SOLANA_ERROR__CODECS_ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH = 8078004;
+  var SOLANA_ERROR__CODECS_FIXED_SIZE_ENCODER_DECODER_SIZE_MISMATCH = 8078005;
+  var SOLANA_ERROR__CODECS_VARIABLE_SIZE_ENCODER_DECODER_MAX_SIZE_MISMATCH = 8078006;
+  var SOLANA_ERROR__CODECS_WRONG_NUMBER_OF_ITEMS = 8078007;
+  var SOLANA_ERROR__CODECS_ENUM_DISCRIMINATOR_OUT_OF_RANGE = 8078008;
+  var SOLANA_ERROR__CODECS_INVALID_DATA_ENUM_VARIANT = 8078009;
+  var SOLANA_ERROR__CODECS_INVALID_SCALAR_ENUM_VARIANT = 8078010;
+  var SOLANA_ERROR__CODECS_NUMBER_OUT_OF_RANGE = 8078011;
+  var SOLANA_ERROR__CODECS_INVALID_STRING_FOR_BASE = 8078012;
+  var SOLANA_ERROR__RPC_INTEGER_OVERFLOW = 81e5;
+  var SOLANA_ERROR__RPC_TRANSPORT_HEADER_FORBIDDEN = 8100001;
+  var SOLANA_ERROR__RPC_TRANSPORT_HTTP_ERROR = 8100002;
+  var SOLANA_ERROR__RPC_SUBSCRIPTIONS_CANNOT_CREATE_SUBSCRIPTION_REQUEST = 819e4;
+  var SOLANA_ERROR__RPC_SUBSCRIPTIONS_EXPECTED_SERVER_SUBSCRIPTION_ID = 8190001;
+  var SOLANA_ERROR__RPC_SUBSCRIPTIONS_TRANSPORT_CLOSED_BEFORE_MESSAGE_BUFFERED = 8190002;
+  var SOLANA_ERROR__RPC_SUBSCRIPTIONS_TRANSPORT_CONNECTION_CLOSED = 8190003;
+  var SOLANA_ERROR__RPC_SUBSCRIPTIONS_TRANSPORT_FAILED_TO_CONNECT = 8190004;
   var SolanaErrorMessages = {
     [SOLANA_ERROR__ACCOUNT_NOT_FOUND]: "Account not found at address: $address",
+    [SOLANA_ERROR__ADDRESS_BYTE_LENGTH_OUT_OF_RANGE]: "Expected base58 encoded address to decode to a byte array of length 32. Actual length: $actualLength.",
+    [SOLANA_ERROR__ADDRESS_STRING_LENGTH_OUT_OF_RANGE]: "Expected base58-encoded address string of length in the range [32, 44]. Actual length: $actualLength.",
+    [SOLANA_ERROR__BLOCKHASH_BYTE_LENGTH_OUT_OF_RANGE]: "Expected base58 encoded blockhash to decode to a byte array of length 32. Actual length: $actualLength.",
+    [SOLANA_ERROR__BLOCKHASH_STRING_LENGTH_OUT_OF_RANGE]: "Expected base58-encoded blockash string of length in the range [32, 44]. Actual length: $actualLength.",
     [SOLANA_ERROR__BLOCK_HEIGHT_EXCEEDED]: "The network has progressed past the last block for which this transaction could have been committed.",
+    [SOLANA_ERROR__CODECS_CANNOT_DECODE_EMPTY_BYTE_ARRAY]: "Codec [$codecDescription] cannot decode empty byte arrays.",
+    [SOLANA_ERROR__CODECS_ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH]: "Encoder and decoder must either both be fixed-size or variable-size.",
+    [SOLANA_ERROR__CODECS_ENUM_DISCRIMINATOR_OUT_OF_RANGE]: "Enum discriminator out of range. Expected a number between $minRange and $maxRange, got $discriminator.",
+    [SOLANA_ERROR__CODECS_EXPECTED_FIXED_LENGTH_GOT_VARIABLE_LENGTH]: "Expected a fixed-size codec, got a variable-size one.",
+    [SOLANA_ERROR__CODECS_EXPECTED_VARIABLE_LENGTH_GOT_FIXED_LENGTH]: "Expected a variable-size codec, got a fixed-size one.",
+    [SOLANA_ERROR__CODECS_FIXED_SIZE_ENCODER_DECODER_SIZE_MISMATCH]: "Encoder and decoder must have the same fixed size, got [$encoderFixedSize] and [$decoderFixedSize].",
+    [SOLANA_ERROR__CODECS_INVALID_DATA_ENUM_VARIANT]: "Invalid data enum variant. Expected one of [$variants], got $value.",
+    [SOLANA_ERROR__CODECS_INVALID_SCALAR_ENUM_VARIANT]: "Invalid scalar enum variant. Expected one of [$variants] or a number between $minRange and $maxRange, got $value.",
+    [SOLANA_ERROR__CODECS_INVALID_STRING_FOR_BASE]: "Invalid value $value for base $base with alphabet $alphabet.",
+    [SOLANA_ERROR__CODECS_NUMBER_OUT_OF_RANGE]: "Codec [$codecDescription] expected number to be in the range [$min, $max], got $value.",
+    [SOLANA_ERROR__CODECS_VARIABLE_SIZE_ENCODER_DECODER_MAX_SIZE_MISMATCH]: "Encoder and decoder must have the same max size, got [$encoderMaxSize] and [$decoderMaxSize].",
+    [SOLANA_ERROR__CODECS_WRONG_NUMBER_OF_BYTES]: "Codec [$codecDescription] expected $expected bytes, got $bytesLength.",
+    [SOLANA_ERROR__CODECS_WRONG_NUMBER_OF_ITEMS]: "Expected [$codecDescription] to have $expected items, got $actual.",
     [SOLANA_ERROR__COULD_NOT_FIND_VIABLE_PDA_BUMP_SEED]: "Unable to find a viable program address bump seed.",
     [SOLANA_ERROR__EXPECTED_DECODED_ACCOUNT]: "Expected decoded account at address: $address",
     [SOLANA_ERROR__FAILED_TO_DECODE_ACCOUNT]: "Failed to decode account data at address: $address",
-    [SOLANA_ERROR__INCORRECT_BASE58_ADDRESS_BYTE_LENGTH]: "Expected base58 encoded address to decode to a byte array of length 32. Actual length: $actualLength.",
-    [SOLANA_ERROR__INCORRECT_BASE58_ADDRESS_LENGTH]: "Expected base58-encoded string of length between 32 and 44, got $actualLength.",
     [SOLANA_ERROR__INSTRUCTION_ERROR_ACCOUNT_ALREADY_INITIALIZED]: "instruction requires an uninitialized account",
     [SOLANA_ERROR__INSTRUCTION_ERROR_ACCOUNT_BORROW_FAILED]: "instruction tries to borrow reference for an account which is already borrowed",
     [SOLANA_ERROR__INSTRUCTION_ERROR_ACCOUNT_BORROW_OUTSTANDING]: "instruction left account with an outstanding borrowed reference",
@@ -314,8 +387,21 @@ this.globalThis.solanaWeb3 = (function (exports) {
     [SOLANA_ERROR__INSTRUCTION_ERROR_UNKNOWN]: "",
     [SOLANA_ERROR__INSTRUCTION_ERROR_UNSUPPORTED_PROGRAM_ID]: "Unsupported program id",
     [SOLANA_ERROR__INSTRUCTION_ERROR_UNSUPPORTED_SYSVAR]: "Unsupported sysvar",
+    [SOLANA_ERROR__INSTRUCTION_EXPECTED_TO_HAVE_ACCOUNTS]: "The instruction does not have any accounts.",
+    [SOLANA_ERROR__INSTRUCTION_EXPECTED_TO_HAVE_DATA]: "The instruction does not have any data.",
+    [SOLANA_ERROR__INSTRUCTION_PROGRAM_ID_MISMATCH]: "Expected instruction to have progress address $expectedProgramAddress, got $actualProgramAddress.",
     [SOLANA_ERROR__INVALID_KEYPAIR_BYTES]: "Key pair bytes must be of length 64, got $byteLength.",
     [SOLANA_ERROR__INVALID_SEEDS_POINT_ON_CURVE]: "Invalid seeds; point must fall off the Ed25519 curve.",
+    [SOLANA_ERROR__INVARIANT_VIOLATION_CACHED_ABORTABLE_ITERABLE_CACHE_ENTRY_MISSING]: "Invariant violation: Found no abortable iterable cache entry for key `$cacheKey`. It should be impossible to hit this error; please file an issue at https://sola.na/web3invariant",
+    [SOLANA_ERROR__INVARIANT_VIOLATION_SWITCH_MUST_BE_EXHAUSTIVE]: "Invariant violation: Switch statement non-exhaustive. Received unexpected value `$unexpectedValue`. It should be impossible to hit this error; please file an issue at https://sola.na/web3invariant",
+    [SOLANA_ERROR__INVARIANT_VIOLATION_WEBSOCKET_MESSAGE_ITERATOR_MUST_NOT_POLL_BEFORE_RESOLVING_EXISTING_MESSAGE_PROMISE]: "Invariant violation: WebSocket message iterator state is corrupt; iterated without first resolving existing message promise. It should be impossible to hit this error; please file an issue at https://sola.na/web3invariant",
+    [SOLANA_ERROR__INVARIANT_VIOLATION_WEBSOCKET_MESSAGE_ITERATOR_STATE_MISSING]: "Invariant violation: WebSocket message iterator is missing state storage. It should be impossible to hit this error; please file an issue at https://sola.na/web3invariant",
+    [SOLANA_ERROR__KEYS_INVALID_PRIVATE_KEY_BYTE_LENGTH]: "Expected private key bytes with length 32. Actual length: $actualLength.",
+    [SOLANA_ERROR__KEYS_INVALID_SIGNATURE_BYTE_LENGTH]: "Expected base58-encoded signature to decode to a byte array of length 64. Actual length: $actualLength.",
+    [SOLANA_ERROR__KEYS_SIGNATURE_STRING_LENGTH_OUT_OF_RANGE]: "Expected base58-encoded signature string of length in the range [64, 88]. Actual length: $actualLength.",
+    [SOLANA_ERROR__LAMPORTS_OUT_OF_RANGE]: "Lamports value must be in the range [0, 2e64-1]",
+    [SOLANA_ERROR__MALFORMED_BIGINT_STRING]: "`$value` cannot be parsed as a `BigInt`",
+    [SOLANA_ERROR__MALFORMED_NUMBER_STRING]: "`$value` cannot be parsed as a `Number`",
     [SOLANA_ERROR__MALFORMED_PROGRAM_DERIVED_ADDRESS]: "Expected given program derived address to have the following format: [Address, ProgramDerivedAddressBump].",
     [SOLANA_ERROR__MAX_NUMBER_OF_PDA_SEEDS_EXCEEDED]: "A maximum of $maxSeeds seeds, including the bump seed, may be supplied when creating an address. Received: $actual.",
     [SOLANA_ERROR__MAX_PDA_SEED_LENGTH_EXCEEDED]: "The seed at index $index with length $actual exceeds the maximum length of $maxSeedLength bytes.",
@@ -328,6 +414,32 @@ this.globalThis.solanaWeb3 = (function (exports) {
     [SOLANA_ERROR__PROGRAM_ADDRESS_ENDS_WITH_PDA_MARKER]: "Program address cannot end with PDA marker.",
     [SOLANA_ERROR__PROGRAM_DERIVED_ADDRESS_BUMP_SEED_OUT_OF_RANGE]: "Expected program derived address bump to be in the range [0, 255], got: $bump.",
     [SOLANA_ERROR__RPC_INTEGER_OVERFLOW]: "The $argumentLabel argument to the `$methodName` RPC method$optionalPathLabel was `$value`. This number is unsafe for use with the Solana JSON-RPC because it exceeds `Number.MAX_SAFE_INTEGER`.",
+    [SOLANA_ERROR__RPC_SUBSCRIPTIONS_CANNOT_CREATE_SUBSCRIPTION_REQUEST]: "Either the notification name must end in 'Notifications' or the API must supply a subscription creator function for the notification '$notificationName' to map between the notification name and the subscribe/unsubscribe method names.",
+    [SOLANA_ERROR__RPC_SUBSCRIPTIONS_EXPECTED_SERVER_SUBSCRIPTION_ID]: "Failed to obtain a subscription id from the server",
+    [SOLANA_ERROR__RPC_SUBSCRIPTIONS_TRANSPORT_CLOSED_BEFORE_MESSAGE_BUFFERED]: "WebSocket was closed before payload could be added to the send buffer",
+    [SOLANA_ERROR__RPC_SUBSCRIPTIONS_TRANSPORT_CONNECTION_CLOSED]: "WebSocket connection closed",
+    [SOLANA_ERROR__RPC_SUBSCRIPTIONS_TRANSPORT_FAILED_TO_CONNECT]: "WebSocket failed to connect",
+    [SOLANA_ERROR__RPC_TRANSPORT_HEADER_FORBIDDEN]: "HTTP header(s) forbidden: $headers. Learn more at https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_header_name.",
+    [SOLANA_ERROR__RPC_TRANSPORT_HTTP_ERROR]: "HTTP error ($statusCode): $message",
+    [SOLANA_ERROR__SIGNER_ADDRESS_CANNOT_HAVE_MULTIPLE_SIGNERS]: "Multiple distinct signers were identified for address `$address`. Please ensure that you are using the same signer instance for each address.",
+    [SOLANA_ERROR__SIGNER_EXPECTED_KEY_PAIR_SIGNER]: "The provided value does not implement the `KeyPairSigner` interface",
+    [SOLANA_ERROR__SIGNER_EXPECTED_MESSAGE_MODIFYING_SIGNER]: "The provided value does not implement the `MessageModifyingSigner` interface",
+    [SOLANA_ERROR__SIGNER_EXPECTED_MESSAGE_PARTIAL_SIGNER]: "The provided value does not implement the `MessagePartialSigner` interface",
+    [SOLANA_ERROR__SIGNER_EXPECTED_MESSAGE_SIGNER]: "The provided value does not implement any of the `MessageSigner` interfaces",
+    [SOLANA_ERROR__SIGNER_EXPECTED_TRANSACTION_MODIFYING_SIGNER]: "The provided value does not implement the `TransactionModifyingSigner` interface",
+    [SOLANA_ERROR__SIGNER_EXPECTED_TRANSACTION_PARTIAL_SIGNER]: "The provided value does not implement the `TransactionPartialSigner` interface",
+    [SOLANA_ERROR__SIGNER_EXPECTED_TRANSACTION_SENDING_SIGNER]: "The provided value does not implement the `TransactionSendingSigner` interface",
+    [SOLANA_ERROR__SIGNER_EXPECTED_TRANSACTION_SIGNER]: "The provided value does not implement any of the `TransactionSigner` interfaces",
+    [SOLANA_ERROR__SIGNER_TRANSACTION_CANNOT_HAVE_MULTIPLE_SENDING_SIGNERS]: "More than one `TransactionSendingSigner` was identified.",
+    [SOLANA_ERROR__SIGNER_TRANSACTION_SENDING_SIGNER_MISSING]: "No `TransactionSendingSigner` was identified. Please provide a valid `ITransactionWithSingleSendingSigner` transaction.",
+    [SOLANA_ERROR__SUBTLE_CRYPTO_DIGEST_MISSING]: "No digest implementation could be found.",
+    [SOLANA_ERROR__SUBTLE_CRYPTO_ED25519_ALGORITHM_MISSING]: "This runtime does not support the generation of Ed25519 key pairs.\n\nInstall and import `@solana/webcrypto-ed25519-polyfill` before generating keys in environments that do not support Ed25519.\n\nFor a list of runtimes that currently support Ed25519 operations, visit https://github.com/WICG/webcrypto-secure-curves/issues/20.",
+    [SOLANA_ERROR__SUBTLE_CRYPTO_EXPORT_FUNCTION_MISSING]: "No signature verification implementation could be found.",
+    [SOLANA_ERROR__SUBTLE_CRYPTO_GENERATE_FUNCTION_MISSING]: "No key generation implementation could be found.",
+    [SOLANA_ERROR__SUBTLE_CRYPTO_MISSING]: "Cryptographic operations are only allowed in secure browser contexts. Read more here: https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts.",
+    [SOLANA_ERROR__SUBTLE_CRYPTO_SIGN_FUNCTION_MISSING]: "No signing implementation could be found.",
+    [SOLANA_ERROR__SUBTLE_CRYPTO_VERIFY_FUNCTION_MISSING]: "No key export implementation could be found.",
+    [SOLANA_ERROR__TIMESTAMP_OUT_OF_RANGE]: "Timestamp value must be in the range [-8.64e15, 8.64e15]. `$value` given",
     [SOLANA_ERROR__TRANSACTION_ERROR_ACCOUNT_BORROW_OUTSTANDING]: "Transaction processing left an account with an outstanding borrowed reference",
     [SOLANA_ERROR__TRANSACTION_ERROR_ACCOUNT_IN_USE]: "Account in use",
     [SOLANA_ERROR__TRANSACTION_ERROR_ACCOUNT_LOADED_TWICE]: "Account loaded twice",
@@ -371,8 +483,12 @@ this.globalThis.solanaWeb3 = (function (exports) {
     [SOLANA_ERROR__TRANSACTION_FAILED_TO_DECOMPILE_ADDRESS_LOOKUP_TABLE_INDEX_OUT_OF_RANGE]: "Lookup of address at index $highestRequestedIndex failed for lookup table `$lookupTableAddress`. Highest known index is $highestKnownIndex. The lookup table may have been extended since its contents were retrieved",
     [SOLANA_ERROR__TRANSACTION_FAILED_TO_DECOMPILE_FEE_PAYER_MISSING]: "No fee payer set in CompiledTransaction",
     [SOLANA_ERROR__TRANSACTION_FAILED_TO_DECOMPILE_INSTRUCTION_PROGRAM_ADDRESS_NOT_FOUND]: "Could not find program address at index $index",
+    [SOLANA_ERROR__TRANSACTION_INVALID_NONCE_TRANSACTION_FIRST_INSTRUCTION_NOT_ADVANCE_NONCE]: "Transaction first instruction is not advance nonce account instruction.",
+    [SOLANA_ERROR__TRANSACTION_INVALID_NONCE_TRANSACTION_NO_INSTRUCTIONS]: "Transaction with no instructions cannot be durable nonce transaction.",
     [SOLANA_ERROR__TRANSACTION_INVOKED_PROGRAMS_CANNOT_PAY_FEES]: "This transaction includes an address (`$programAddress`) which is both invoked and set as the fee payer. Program addresses may not pay fees",
     [SOLANA_ERROR__TRANSACTION_INVOKED_PROGRAMS_MUST_NOT_BE_WRITABLE]: "This transaction includes an address (`$programAddress`) which is both invoked and marked writable. Program addresses may not be writable",
+    [SOLANA_ERROR__TRANSACTION_MISSING_ADDRESS]: "Transaction is missing an address at index: $index.",
+    [SOLANA_ERROR__TRANSACTION_MISSING_FEE_PAYER]: "Transaction is missing a fee payer.",
     [SOLANA_ERROR__TRANSACTION_MISSING_SIGNATURES]: "Transaction is missing signatures for addresses: $addresses.",
     [SOLANA_ERROR__TRANSACTION_SIGNATURE_NOT_COMPUTABLE]: "Could not determine this transaction's signature. Make sure that the transaction has been signed by its fee payer.",
     [SOLANA_ERROR__TRANSACTION_VERSION_NUMBER_OUT_OF_RANGE]: "Transaction version must be in the range [0, 127]. `$actualVersion` given"
@@ -401,9 +517,20 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return false;
   }
   var SolanaError = class extends Error {
-    constructor(...[code, context]) {
+    constructor(...[code, contextAndErrorOptions]) {
+      let context;
+      let errorOptions;
+      if (contextAndErrorOptions) {
+        const { cause, ...contextRest } = contextAndErrorOptions;
+        if (cause) {
+          errorOptions = { cause };
+        }
+        if (Object.keys(contextRest).length > 0) {
+          context = contextRest;
+        }
+      }
       const message = getErrorMessage(code, context);
-      super(message);
+      super(message, errorOptions);
       __publicField(this, "context");
       this.context = {
         __code: code,
@@ -600,13 +727,19 @@ this.globalThis.solanaWeb3 = (function (exports) {
   init_env_shim();
   function assertByteArrayIsNotEmptyForCodec(codecDescription, bytes, offset = 0) {
     if (bytes.length - offset <= 0) {
-      throw new Error(`Codec [${codecDescription}] cannot decode empty byte arrays.`);
+      throw new SolanaError(SOLANA_ERROR__CODECS_CANNOT_DECODE_EMPTY_BYTE_ARRAY, {
+        codecDescription
+      });
     }
   }
   function assertByteArrayHasEnoughBytesForCodec(codecDescription, expected, bytes, offset = 0) {
     const bytesLength = bytes.length - offset;
     if (bytesLength < expected) {
-      throw new Error(`Codec [${codecDescription}] expected ${expected} bytes, got ${bytesLength}.`);
+      throw new SolanaError(SOLANA_ERROR__CODECS_WRONG_NUMBER_OF_BYTES, {
+        bytesLength,
+        codecDescription,
+        expected
+      });
     }
   }
   var mergeBytes = (byteArrays) => {
@@ -667,32 +800,34 @@ this.globalThis.solanaWeb3 = (function (exports) {
   function isFixedSize(codec) {
     return "fixedSize" in codec && typeof codec.fixedSize === "number";
   }
-  function assertIsFixedSize(codec, message) {
+  function assertIsFixedSize(codec) {
     if (!isFixedSize(codec)) {
-      throw new Error(message != null ? message : "Expected a fixed-size codec, got a variable-size one.");
+      throw new SolanaError(SOLANA_ERROR__CODECS_EXPECTED_FIXED_LENGTH_GOT_VARIABLE_LENGTH);
     }
   }
   function isVariableSize(codec) {
     return !isFixedSize(codec);
   }
-  function assertIsVariableSize(codec, message) {
+  function assertIsVariableSize(codec) {
     if (!isVariableSize(codec)) {
-      throw new Error(message != null ? message : "Expected a variable-size codec, got a fixed-size one.");
+      throw new SolanaError(SOLANA_ERROR__CODECS_EXPECTED_VARIABLE_LENGTH_GOT_FIXED_LENGTH);
     }
   }
   function combineCodec(encoder, decoder) {
     if (isFixedSize(encoder) !== isFixedSize(decoder)) {
-      throw new Error(`Encoder and decoder must either both be fixed-size or variable-size.`);
+      throw new SolanaError(SOLANA_ERROR__CODECS_ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH);
     }
     if (isFixedSize(encoder) && isFixedSize(decoder) && encoder.fixedSize !== decoder.fixedSize) {
-      throw new Error(
-        `Encoder and decoder must have the same fixed size, got [${encoder.fixedSize}] and [${decoder.fixedSize}].`
-      );
+      throw new SolanaError(SOLANA_ERROR__CODECS_FIXED_SIZE_ENCODER_DECODER_SIZE_MISMATCH, {
+        decoderFixedSize: decoder.fixedSize,
+        encoderFixedSize: encoder.fixedSize
+      });
     }
     if (!isFixedSize(encoder) && !isFixedSize(decoder) && encoder.maxSize !== decoder.maxSize) {
-      throw new Error(
-        `Encoder and decoder must have the same max size, got [${encoder.maxSize}] and [${decoder.maxSize}].`
-      );
+      throw new SolanaError(SOLANA_ERROR__CODECS_VARIABLE_SIZE_ENCODER_DECODER_MAX_SIZE_MISMATCH, {
+        decoderMaxSize: decoder.maxSize,
+        encoderMaxSize: encoder.maxSize
+      });
     }
     return {
       ...decoder,
@@ -755,7 +890,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     });
   }
   function reverseEncoder(encoder) {
-    assertIsFixedSize(encoder, "Cannot reverse a codec of variable size.");
+    assertIsFixedSize(encoder);
     return createEncoder({
       ...encoder,
       write: (value, bytes, offset) => {
@@ -767,7 +902,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     });
   }
   function reverseDecoder(decoder) {
-    assertIsFixedSize(decoder, "Cannot reverse a codec of variable size.");
+    assertIsFixedSize(decoder);
     return createDecoder({
       ...decoder,
       read: (bytes, offset) => {
@@ -789,9 +924,12 @@ this.globalThis.solanaWeb3 = (function (exports) {
   init_env_shim();
   function assertNumberIsBetweenForCodec(codecDescription, min, max, value) {
     if (value < min || value > max) {
-      throw new Error(
-        `Codec [${codecDescription}] expected number to be in the range [${min}, ${max}], got ${value}.`
-      );
+      throw new SolanaError(SOLANA_ERROR__CODECS_NUMBER_OUT_OF_RANGE, {
+        codecDescription,
+        max,
+        min,
+        value
+      });
     }
   }
   var Endian = /* @__PURE__ */ ((Endian2) => {
@@ -986,7 +1124,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   var getU128Encoder = (config = {}) => numberEncoderFactory({
     config,
     name: "u128",
-    range: [0, BigInt("0xffffffffffffffffffffffffffffffff")],
+    range: [0n, BigInt("0xffffffffffffffffffffffffffffffff")],
     set: (view, value, le) => {
       const leftOffset = le ? 8 : 0;
       const rightOffset = le ? 0 : 8;
@@ -1040,7 +1178,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   var getU64Encoder = (config = {}) => numberEncoderFactory({
     config,
     name: "u64",
-    range: [0, BigInt("0xffffffffffffffff")],
+    range: [0n, BigInt("0xffffffffffffffff")],
     set: (view, value, le) => view.setBigUint64(0, BigInt(value), le),
     size: 8
   });
@@ -1067,7 +1205,11 @@ this.globalThis.solanaWeb3 = (function (exports) {
   // ../codecs-strings/dist/index.browser.js
   function assertValidBaseString(alphabet4, testValue, givenValue = testValue) {
     if (!testValue.match(new RegExp(`^[${alphabet4}]*$`))) {
-      throw new Error(`Expected a string of base ${alphabet4.length}, got [${givenValue}].`);
+      throw new SolanaError(SOLANA_ERROR__CODECS_INVALID_STRING_FOR_BASE, {
+        alphabet: alphabet4,
+        base: alphabet4.length,
+        value: givenValue
+      });
     }
   }
   var getBaseXEncoder = (alphabet4) => {
@@ -1206,6 +1348,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
     return output;
   }
+  var alphabet3 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
   var getBase64Encoder = () => {
     {
       return createEncoder({
@@ -1213,7 +1356,11 @@ this.globalThis.solanaWeb3 = (function (exports) {
           try {
             return atob(value).length;
           } catch (e22) {
-            throw new Error(`Expected a string of base 64, got [${value}].`);
+            throw new SolanaError(SOLANA_ERROR__CODECS_INVALID_STRING_FOR_BASE, {
+              alphabet: alphabet3,
+              base: 64,
+              value
+            });
           }
         },
         write(value, bytes, offset) {
@@ -1222,7 +1369,11 @@ this.globalThis.solanaWeb3 = (function (exports) {
             bytes.set(bytesToAdd, offset);
             return bytesToAdd.length + offset;
           } catch (e22) {
-            throw new Error(`Expected a string of base 64, got [${value}].`);
+            throw new SolanaError(SOLANA_ERROR__CODECS_INVALID_STRING_FOR_BASE, {
+              alphabet: alphabet3,
+              base: 64,
+              value
+            });
           }
         }
       });
@@ -1418,9 +1569,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   init_env_shim();
   function assertIsSecureContext() {
     if (!globalThis.isSecureContext) {
-      throw new Error(
-        "Cryptographic operations are only allowed in secure browser contexts. Read more here: https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts"
-      );
+      throw new SolanaError(SOLANA_ERROR__SUBTLE_CRYPTO_MISSING);
     }
   }
   var cachedEd25519Decision;
@@ -1449,40 +1598,38 @@ this.globalThis.solanaWeb3 = (function (exports) {
     var _a;
     assertIsSecureContext();
     if (typeof globalThis.crypto === "undefined" || typeof ((_a = globalThis.crypto.subtle) == null ? void 0 : _a.digest) !== "function") {
-      throw new Error("No digest implementation could be found");
+      throw new SolanaError(SOLANA_ERROR__SUBTLE_CRYPTO_DIGEST_MISSING);
     }
   }
   async function assertKeyGenerationIsAvailable() {
     var _a;
     assertIsSecureContext();
     if (typeof globalThis.crypto === "undefined" || typeof ((_a = globalThis.crypto.subtle) == null ? void 0 : _a.generateKey) !== "function") {
-      throw new Error("No key generation implementation could be found");
+      throw new SolanaError(SOLANA_ERROR__SUBTLE_CRYPTO_GENERATE_FUNCTION_MISSING);
     }
     if (!await isEd25519CurveSupported(globalThis.crypto.subtle)) {
-      throw new Error(
-        "This runtime does not support the generation of Ed25519 key pairs.\n\nInstall and import `@solana/webcrypto-ed25519-polyfill` before generating keys in environments that do not support Ed25519.\n\nFor a list of runtimes that currently support Ed25519 operations, visit https://github.com/WICG/webcrypto-secure-curves/issues/20"
-      );
+      throw new SolanaError(SOLANA_ERROR__SUBTLE_CRYPTO_ED25519_ALGORITHM_MISSING);
     }
   }
   async function assertKeyExporterIsAvailable() {
     var _a;
     assertIsSecureContext();
     if (typeof globalThis.crypto === "undefined" || typeof ((_a = globalThis.crypto.subtle) == null ? void 0 : _a.exportKey) !== "function") {
-      throw new Error("No key export implementation could be found");
+      throw new SolanaError(SOLANA_ERROR__SUBTLE_CRYPTO_EXPORT_FUNCTION_MISSING);
     }
   }
   async function assertSigningCapabilityIsAvailable() {
     var _a;
     assertIsSecureContext();
     if (typeof globalThis.crypto === "undefined" || typeof ((_a = globalThis.crypto.subtle) == null ? void 0 : _a.sign) !== "function") {
-      throw new Error("No signing implementation could be found");
+      throw new SolanaError(SOLANA_ERROR__SUBTLE_CRYPTO_SIGN_FUNCTION_MISSING);
     }
   }
   async function assertVerificationCapabilityIsAvailable() {
     var _a;
     assertIsSecureContext();
     if (typeof globalThis.crypto === "undefined" || typeof ((_a = globalThis.crypto.subtle) == null ? void 0 : _a.verify) !== "function") {
-      throw new Error("No signature verification implementation could be found");
+      throw new SolanaError(SOLANA_ERROR__SUBTLE_CRYPTO_VERIFY_FUNCTION_MISSING);
     }
   }
 
@@ -1516,26 +1663,22 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return true;
   }
   function assertIsAddress(putativeAddress) {
-    try {
-      if (
-        // Lowest address (32 bytes of zeroes)
-        putativeAddress.length < 32 || // Highest address (32 bytes of 255)
-        putativeAddress.length > 44
-      ) {
-        throw new SolanaError(SOLANA_ERROR__INCORRECT_BASE58_ADDRESS_LENGTH, {
-          actualLength: putativeAddress.length
-        });
-      }
-      const base58Encoder4 = getMemoizedBase58Encoder();
-      const bytes = base58Encoder4.encode(putativeAddress);
-      const numBytes = bytes.byteLength;
-      if (numBytes !== 32) {
-        throw new SolanaError(SOLANA_ERROR__INCORRECT_BASE58_ADDRESS_BYTE_LENGTH, {
-          actualLength: numBytes
-        });
-      }
-    } catch (e4) {
-      throw new SolanaError(SOLANA_ERROR__NOT_A_BASE58_ENCODED_ADDRESS, { putativeAddress });
+    if (
+      // Lowest address (32 bytes of zeroes)
+      putativeAddress.length < 32 || // Highest address (32 bytes of 255)
+      putativeAddress.length > 44
+    ) {
+      throw new SolanaError(SOLANA_ERROR__ADDRESS_STRING_LENGTH_OUT_OF_RANGE, {
+        actualLength: putativeAddress.length
+      });
+    }
+    const base58Encoder4 = getMemoizedBase58Encoder();
+    const bytes = base58Encoder4.encode(putativeAddress);
+    const numBytes = bytes.byteLength;
+    if (numBytes !== 32) {
+      throw new SolanaError(SOLANA_ERROR__ADDRESS_BYTE_LENGTH_OUT_OF_RANGE, {
+        actualLength: numBytes
+      });
     }
   }
   function address(putativeAddress) {
@@ -1780,7 +1923,11 @@ this.globalThis.solanaWeb3 = (function (exports) {
   init_env_shim();
   function assertValidNumberOfItemsForCodec(codecDescription, expected, actual) {
     if (expected !== actual) {
-      throw new Error(`Expected [${codecDescription}] to have ${expected} items, got ${actual}.`);
+      throw new SolanaError(SOLANA_ERROR__CODECS_WRONG_NUMBER_OF_ITEMS, {
+        actual,
+        codecDescription,
+        expected
+      });
     }
   }
   function maxCodecSizes(sizes) {
@@ -1926,13 +2073,13 @@ this.globalThis.solanaWeb3 = (function (exports) {
   function getBooleanEncoder(config = {}) {
     var _a;
     const size = (_a = config.size) != null ? _a : getU8Encoder();
-    assertIsFixedSize(size, "Codec [bool] requires a fixed size.");
+    assertIsFixedSize(size);
     return mapEncoder(size, (value) => value ? 1 : 0);
   }
   function getBooleanDecoder(config = {}) {
     var _a;
     const size = (_a = config.size) != null ? _a : getU8Decoder();
-    assertIsFixedSize(size, "Codec [bool] requires a fixed size.");
+    assertIsFixedSize(size);
     return mapDecoder(size, (value) => Number(value) === 1);
   }
   function getBooleanCodec(config = {}) {
@@ -2028,9 +2175,11 @@ this.globalThis.solanaWeb3 = (function (exports) {
         offset = dOffset;
         const variantField = (_a2 = variants[Number(discriminator)]) != null ? _a2 : null;
         if (!variantField) {
-          throw new Error(
-            `Enum discriminator out of range. Expected a number between 0 and ${variants.length - 1}, got ${discriminator}.`
-          );
+          throw new SolanaError(SOLANA_ERROR__CODECS_ENUM_DISCRIMINATOR_OUT_OF_RANGE, {
+            discriminator,
+            maxRange: variants.length - 1,
+            minRange: 0
+          });
         }
         const [variant, vOffset] = variantField[1].read(bytes, offset);
         offset = vOffset;
@@ -2065,9 +2214,10 @@ this.globalThis.solanaWeb3 = (function (exports) {
   function getVariantDiscriminator(variants, variant) {
     const discriminator = variants.findIndex(([key]) => variant.__kind === key);
     if (discriminator < 0) {
-      throw new Error(
-        `Invalid data enum variant. Expected one of [${variants.map(([key]) => key).join(", ")}], got "${variant.__kind}".`
-      );
+      throw new SolanaError(SOLANA_ERROR__CODECS_INVALID_DATA_ENUM_VARIANT, {
+        value: variant.__kind,
+        variants: variants.map(([key]) => key)
+      });
     }
     return discriminator;
   }
@@ -2133,8 +2283,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
     const fixed = (_b = config.fixed) != null ? _b : false;
     const isZeroSizeItem = isFixedSize(item) && isFixedSize(prefix) && item.fixedSize === 0;
     if (fixed || isZeroSizeItem) {
-      assertIsFixedSize(item, "Fixed nullables can only be used with fixed-size codecs.");
-      assertIsFixedSize(prefix, "Fixed nullables can only be used with fixed-size prefix.");
+      assertIsFixedSize(item);
+      assertIsFixedSize(prefix);
       const fixedSize = prefix.fixedSize + item.fixedSize;
       return createEncoder({
         fixedSize,
@@ -2166,8 +2316,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
     let fixedSize = null;
     const isZeroSizeItem = isFixedSize(item) && isFixedSize(prefix) && item.fixedSize === 0;
     if (fixed || isZeroSizeItem) {
-      assertIsFixedSize(item, "Fixed nullables can only be used with fixed-size codecs.");
-      assertIsFixedSize(prefix, "Fixed nullables can only be used with fixed-size prefix.");
+      assertIsFixedSize(item);
+      assertIsFixedSize(prefix);
       fixedSize = prefix.fixedSize + item.fixedSize;
     }
     return createDecoder({
@@ -2197,9 +2347,12 @@ this.globalThis.solanaWeb3 = (function (exports) {
       const isInvalidNumber = typeof value === "number" && (value < minRange || value > maxRange);
       const isInvalidString = typeof value === "string" && !allStringInputs.includes(value);
       if (isInvalidNumber || isInvalidString) {
-        throw new Error(
-          `Invalid scalar enum variant. Expected one of [${allStringInputs.join(", ")}] or a number between ${minRange} and ${maxRange}, got "${value}".`
-        );
+        throw new SolanaError(SOLANA_ERROR__CODECS_INVALID_SCALAR_ENUM_VARIANT, {
+          maxRange,
+          minRange,
+          value,
+          variants: allStringInputs
+        });
       }
       if (typeof value === "number")
         return value;
@@ -2216,9 +2369,11 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return mapDecoder(prefix, (value) => {
       const valueAsNumber = Number(value);
       if (valueAsNumber < minRange || valueAsNumber > maxRange) {
-        throw new Error(
-          `Enum discriminator out of range. Expected a number between ${minRange} and ${maxRange}, got ${valueAsNumber}.`
-        );
+        throw new SolanaError(SOLANA_ERROR__CODECS_ENUM_DISCRIMINATOR_OUT_OF_RANGE, {
+          discriminator: valueAsNumber,
+          maxRange,
+          minRange
+        });
       }
       return constructor[enumKeys[valueAsNumber]];
     });
@@ -2332,8 +2487,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
     const fixed = (_b = config.fixed) != null ? _b : false;
     const isZeroSizeItem = isFixedSize(item) && isFixedSize(prefix) && item.fixedSize === 0;
     if (fixed || isZeroSizeItem) {
-      assertIsFixedSize(item, "Fixed options can only be used with fixed-size codecs.");
-      assertIsFixedSize(prefix, "Fixed options can only be used with fixed-size prefix.");
+      assertIsFixedSize(item);
+      assertIsFixedSize(prefix);
       const fixedSize = prefix.fixedSize + item.fixedSize;
       return createEncoder({
         fixedSize,
@@ -2370,8 +2525,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
     let fixedSize = null;
     const isZeroSizeItem = isFixedSize(item) && isFixedSize(prefix) && item.fixedSize === 0;
     if (fixed || isZeroSizeItem) {
-      assertIsFixedSize(item, "Fixed options can only be used with fixed-size codecs.");
-      assertIsFixedSize(prefix, "Fixed options can only be used with fixed-size prefix.");
+      assertIsFixedSize(item);
+      assertIsFixedSize(prefix);
       fixedSize = prefix.fixedSize + item.fixedSize;
     }
     return createDecoder({
@@ -2426,6 +2581,40 @@ this.globalThis.solanaWeb3 = (function (exports) {
 
   // ../instructions/dist/index.browser.js
   init_env_shim();
+  function isInstructionForProgram(instruction, programAddress) {
+    return instruction.programAddress === programAddress;
+  }
+  function assertIsInstructionForProgram(instruction, programAddress) {
+    if (instruction.programAddress !== programAddress) {
+      throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PROGRAM_ID_MISMATCH, {
+        actualProgramAddress: instruction.programAddress,
+        expectedProgramAddress: programAddress
+      });
+    }
+  }
+  function isInstructionWithAccounts(instruction) {
+    return instruction.accounts !== void 0;
+  }
+  function assertIsInstructionWithAccounts(instruction) {
+    if (instruction.accounts === void 0) {
+      throw new SolanaError(SOLANA_ERROR__INSTRUCTION_EXPECTED_TO_HAVE_ACCOUNTS, {
+        data: instruction.data,
+        programAddress: instruction.programAddress
+      });
+    }
+  }
+  function isInstructionWithData(instruction) {
+    return instruction.data !== void 0;
+  }
+  function assertIsInstructionWithData(instruction) {
+    var _a;
+    if (instruction.data === void 0) {
+      throw new SolanaError(SOLANA_ERROR__INSTRUCTION_EXPECTED_TO_HAVE_DATA, {
+        accountAddresses: (_a = instruction.accounts) == null ? void 0 : _a.map((a) => a.address),
+        programAddress: instruction.programAddress
+      });
+    }
+  }
   var AccountRole = /* @__PURE__ */ ((AccountRole22) => {
     AccountRole22[AccountRole22["WRITABLE_SIGNER"] = /* 3 */
     3] = "WRITABLE_SIGNER";
@@ -2510,8 +2699,11 @@ this.globalThis.solanaWeb3 = (function (exports) {
     ]);
   }
   async function createPrivateKeyFromBytes(bytes, extractable) {
-    if (bytes.byteLength !== 32) {
-      throw new Error("Private key bytes must be of length 32");
+    const actualLength = bytes.byteLength;
+    if (actualLength !== 32) {
+      throw new SolanaError(SOLANA_ERROR__KEYS_INVALID_PRIVATE_KEY_BYTE_LENGTH, {
+        actualLength
+      });
     }
     const privateKeyBytesPkcs8 = addPkcs8Header(bytes);
     return await crypto.subtle.importKey("pkcs8", privateKeyBytesPkcs8, "Ed25519", extractable != null ? extractable : false, ["sign"]);
@@ -2551,22 +2743,20 @@ this.globalThis.solanaWeb3 = (function (exports) {
   function assertIsSignature(putativeSignature) {
     if (!base58Encoder)
       base58Encoder = getBase58Encoder();
-    try {
-      if (
-        // Lowest value (64 bytes of zeroes)
-        putativeSignature.length < 64 || // Highest value (64 bytes of 255)
-        putativeSignature.length > 88
-      ) {
-        throw new Error("Expected input string to decode to a byte array of length 64.");
-      }
-      const bytes = base58Encoder.encode(putativeSignature);
-      const numBytes = bytes.byteLength;
-      if (numBytes !== 64) {
-        throw new Error(`Expected input string to decode to a byte array of length 64. Actual length: ${numBytes}`);
-      }
-    } catch (e4) {
-      throw new Error(`\`${putativeSignature}\` is not a signature`, {
-        cause: e4
+    if (
+      // Lowest value (64 bytes of zeroes)
+      putativeSignature.length < 64 || // Highest value (64 bytes of 255)
+      putativeSignature.length > 88
+    ) {
+      throw new SolanaError(SOLANA_ERROR__KEYS_SIGNATURE_STRING_LENGTH_OUT_OF_RANGE, {
+        actualLength: putativeSignature.length
+      });
+    }
+    const bytes = base58Encoder.encode(putativeSignature);
+    const numBytes = bytes.byteLength;
+    if (numBytes !== 64) {
+      throw new SolanaError(SOLANA_ERROR__KEYS_INVALID_SIGNATURE_BYTE_LENGTH, {
+        actualLength: numBytes
       });
     }
   }
@@ -3162,17 +3352,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
   // ../rpc-transport-http/dist/index.browser.js
   init_env_shim();
   var e2 = globalThis.fetch;
-  var SolanaHttpError = class extends Error {
-    constructor(details) {
-      super(`HTTP error (${details.statusCode}): ${details.message}`);
-      __publicField(this, "statusCode");
-      Error.captureStackTrace(this, this.constructor);
-      this.statusCode = details.statusCode;
-    }
-    get name() {
-      return "SolanaHttpError";
-    }
-  };
   var DISALLOWED_HEADERS = {
     accept: true,
     "content-length": true,
@@ -3209,9 +3388,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
       return DISALLOWED_HEADERS[headerName.toLowerCase()] === true || FORBIDDEN_HEADERS[headerName.toLowerCase()] === true || lowercaseHeaderName.startsWith("proxy-") || lowercaseHeaderName.startsWith("sec-");
     });
     if (badHeaders.length > 0) {
-      throw new Error(
-        `${badHeaders.length > 1 ? "These headers are" : "This header is"} forbidden: \`${badHeaders.join("`, `")}\`. Learn more at https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_header_name.`
-      );
+      throw new SolanaError(SOLANA_ERROR__RPC_TRANSPORT_HEADER_FORBIDDEN, {
+        headers: badHeaders
+      });
     }
   }
   function normalizeHeaders(headers) {
@@ -3261,7 +3440,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
       };
       const response = await e2(url, requestInfo);
       if (!response.ok) {
-        throw new SolanaHttpError({
+        throw new SolanaError(SOLANA_ERROR__RPC_TRANSPORT_HTTP_ERROR, {
           message: response.statusText,
           statusCode: response.status
         });
@@ -3310,10 +3489,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
       throw createSolanaJsonRpcIntegerOverflowError(methodName, keyPath, value);
     }
   };
-  function createSolanaRpc(config) {
-    const api = createSolanaRpcApi(DEFAULT_RPC_CONFIG);
-    return createRpc({ ...config, api });
-  }
   var EXPLICIT_ABORT_TOKEN = Symbol(
     "This symbol is thrown from the request that underlies a series of coalesced requests when the last request in that series aborts" 
   );
@@ -3408,6 +3583,15 @@ this.globalThis.solanaWeb3 = (function (exports) {
       (transport) => getRpcTransportWithRequestCoalescing(transport, getSolanaRpcPayloadDeduplicationKey)
     );
   }
+  function createSolanaRpc(clusterUrl, config) {
+    return createSolanaRpcFromTransport(createDefaultRpcTransport({ url: clusterUrl, ...config }));
+  }
+  function createSolanaRpcFromTransport(transport) {
+    return createRpc({
+      api: createSolanaRpcApi(DEFAULT_RPC_CONFIG),
+      transport
+    });
+  }
 
   // ../rpc-subscriptions/dist/index.browser.js
   init_env_shim();
@@ -3430,17 +3614,17 @@ this.globalThis.solanaWeb3 = (function (exports) {
       },
       get(target, p, receiver) {
         return function(...rawParams) {
-          const methodName = p.toString();
-          const createRpcSubscription = Reflect.get(target, methodName, receiver);
+          const notificationName = p.toString();
+          const createRpcSubscription = Reflect.get(target, notificationName, receiver);
           if (p.toString().endsWith("Notifications") === false && !createRpcSubscription) {
-            throw new Error(
-              "Either the notification name must end in 'Notifications' or the API must supply a subscription creator function to map between the notification name and the subscribe/unsubscribe method names."
-            );
+            throw new SolanaError(SOLANA_ERROR__RPC_SUBSCRIPTIONS_CANNOT_CREATE_SUBSCRIPTION_REQUEST, {
+              notificationName
+            });
           }
           const newRequest = createRpcSubscription ? createRpcSubscription(...rawParams) : {
             params: rawParams,
-            subscribeMethodName: methodName.replace(/Notifications$/, "Subscribe"),
-            unsubscribeMethodName: methodName.replace(/Notifications$/, "Unsubscribe")
+            subscribeMethodName: notificationName.replace(/Notifications$/, "Subscribe"),
+            unsubscribeMethodName: notificationName.replace(/Notifications$/, "Unsubscribe")
           };
           return createPendingRpcSubscription(rpcConfig, newRequest);
         };
@@ -3495,7 +3679,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
           }
         }
         if (subscriptionId == null) {
-          throw new Error("Failed to obtain a subscription id from the server");
+          throw new SolanaError(SOLANA_ERROR__RPC_SUBSCRIPTIONS_EXPECTED_SERVER_SUBSCRIPTION_ID);
         }
         return {
           async *[Symbol.asyncIterator]() {
@@ -3775,8 +3959,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
       function handleError(ev) {
         if (!hasConnected) {
           reject(
-            // TODO: Coded error
-            new Error("WebSocket failed to connect", { cause: ev })
+            new SolanaError(SOLANA_ERROR__RPC_SUBSCRIPTIONS_TRANSPORT_FAILED_TO_CONNECT, {
+              errorEvent: ev
+            })
           );
         }
       }
@@ -3801,8 +3986,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
                   bufferDrainWatcher = void 0;
                   clearInterval(intervalId);
                   reject2(
-                    // TODO: Coded error
-                    new Error("WebSocket was closed before payload could be sent")
+                    new SolanaError(
+                      SOLANA_ERROR__RPC_SUBSCRIPTIONS_TRANSPORT_CLOSED_BEFORE_MESSAGE_BUFFERED
+                    )
                   );
                 };
               });
@@ -3825,11 +4011,13 @@ this.globalThis.solanaWeb3 = (function (exports) {
               while (true) {
                 const state = iteratorState.get(iteratorKey);
                 if (!state) {
-                  throw new Error("Invariant: WebSocket message iterator is missing state storage");
+                  throw new SolanaError(
+                    SOLANA_ERROR__INVARIANT_VIOLATION_WEBSOCKET_MESSAGE_ITERATOR_STATE_MISSING
+                  );
                 }
                 if (state.__hasPolled) {
-                  throw new Error(
-                    "Invariant: WebSocket message iterator state is corrupt; iterated without first resolving existing message promise"
+                  throw new SolanaError(
+                    SOLANA_ERROR__INVARIANT_VIOLATION_WEBSOCKET_MESSAGE_ITERATOR_MUST_NOT_POLL_BEFORE_RESOLVING_EXISTING_MESSAGE_PROMISE
                   );
                 }
                 const queuedMessages = state.queuedMessages;
@@ -3849,7 +4037,12 @@ this.globalThis.solanaWeb3 = (function (exports) {
                     if (e22 === EXPLICIT_ABORT_TOKEN2) {
                       return;
                     } else {
-                      throw new Error("WebSocket connection closed", { cause: e22 });
+                      throw new SolanaError(
+                        SOLANA_ERROR__RPC_SUBSCRIPTIONS_TRANSPORT_CONNECTION_CLOSED,
+                        {
+                          cause: e22
+                        }
+                      );
                     }
                   }
                 }
@@ -3952,7 +4145,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   function getCachedAbortableIterableFactory({
     getAbortSignalFromInputArgs,
-    getCacheEntryMissingError,
     getCacheKeyFromInputArgs,
     onCacheHit,
     onCreateIterable
@@ -3961,7 +4153,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
     function getCacheEntryOrThrow(cacheKey) {
       const currentCacheEntry = cache.get(cacheKey);
       if (!currentCacheEntry) {
-        throw getCacheEntryMissingError(cacheKey);
+        throw new SolanaError(SOLANA_ERROR__INVARIANT_VIOLATION_CACHED_ABORTABLE_ITERABLE_CACHE_ENTRY_MISSING, {
+          cacheKey: cacheKey.toString()
+        });
       }
       return currentCacheEntry;
     }
@@ -4060,11 +4254,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
           }
           const iterableFactory = getCachedAbortableIterableFactory({
             getAbortSignalFromInputArgs: ({ abortSignal }) => abortSignal,
-            getCacheEntryMissingError(deduplicationKey2) {
-              return new Error(
-                `Found no cache entry for subscription with deduplication key \`${deduplicationKey2 == null ? void 0 : deduplicationKey2.toString()}\``
-              );
-            },
             getCacheKeyFromInputArgs: () => deduplicationKey,
             async onCacheHit(_iterable, _config) {
             },
@@ -4122,24 +4311,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
       }
     });
   }
-  function createSolanaRpcSubscriptions(config) {
-    return pipe(
-      createSubscriptionRpc({
-        ...config,
-        api: createSolanaRpcSubscriptionsApi(DEFAULT_RPC_CONFIG2)
-      }),
-      (rpcSubscriptions) => getRpcSubscriptionsWithSubscriptionCoalescing({
-        getDeduplicationKey: (...args) => (0, import_fast_stable_stringify2.default)(args),
-        rpcSubscriptions
-      })
-    );
-  }
-  function createSolanaRpcSubscriptions_UNSTABLE(config) {
-    return createSubscriptionRpc({
-      ...config,
-      api: createSolanaRpcSubscriptionsApi_UNSTABLE(DEFAULT_RPC_CONFIG2)
-    });
-  }
   var PING_PAYLOAD = {
     jsonrpc: "2.0",
     method: "ping"
@@ -4213,9 +4384,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }) {
     return getCachedAbortableIterableFactory({
       getAbortSignalFromInputArgs: ({ signal }) => signal,
-      getCacheEntryMissingError(shardKey) {
-        return new Error(`Found no cache entry for connection with shard key \`${shardKey == null ? void 0 : shardKey.toString()}\``);
-      },
       getCacheKeyFromInputArgs: ({ payload }) => getShard ? getShard(payload) : NULL_SHARD_CACHE_KEY,
       onCacheHit: (connection, { payload }) => connection.send_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(payload),
       onCreateIterable: (abortSignal, config) => transport({
@@ -4245,6 +4413,31 @@ this.globalThis.solanaWeb3 = (function (exports) {
       })
     );
   }
+  function createSolanaRpcSubscriptions(clusterUrl, config) {
+    const transport = createDefaultRpcSubscriptionsTransport({ url: clusterUrl, ...config });
+    return createSolanaRpcSubscriptionsFromTransport(transport);
+  }
+  function createSolanaRpcSubscriptions_UNSTABLE(clusterUrl, config) {
+    return createSolanaRpcSubscriptions(
+      clusterUrl,
+      config
+    );
+  }
+  function createSolanaRpcSubscriptionsFromTransport(transport) {
+    return pipe(
+      createSubscriptionRpc({
+        api: createSolanaRpcSubscriptionsApi(DEFAULT_RPC_CONFIG2),
+        transport
+      }),
+      (rpcSubscriptions) => getRpcSubscriptionsWithSubscriptionCoalescing({
+        getDeduplicationKey: (...args) => (0, import_fast_stable_stringify2.default)(args),
+        rpcSubscriptions
+      })
+    );
+  }
+  function createSolanaRpcSubscriptionsFromTransport_UNSTABLE(transport) {
+    return createSolanaRpcSubscriptionsFromTransport(transport);
+  }
 
   // ../rpc-types/dist/index.browser.js
   init_env_shim();
@@ -4252,22 +4445,20 @@ this.globalThis.solanaWeb3 = (function (exports) {
   function assertIsBlockhash(putativeBlockhash) {
     if (!base58Encoder2)
       base58Encoder2 = getBase58Encoder();
-    try {
-      if (
-        // Lowest value (32 bytes of zeroes)
-        putativeBlockhash.length < 32 || // Highest value (32 bytes of 255)
-        putativeBlockhash.length > 44
-      ) {
-        throw new Error("Expected input string to decode to a byte array of length 32.");
-      }
-      const bytes = base58Encoder2.encode(putativeBlockhash);
-      const numBytes = bytes.byteLength;
-      if (numBytes !== 32) {
-        throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
-      }
-    } catch (e4) {
-      throw new Error(`\`${putativeBlockhash}\` is not a blockhash`, {
-        cause: e4
+    if (
+      // Lowest value (32 bytes of zeroes)
+      putativeBlockhash.length < 32 || // Highest value (32 bytes of 255)
+      putativeBlockhash.length > 44
+    ) {
+      throw new SolanaError(SOLANA_ERROR__BLOCKHASH_STRING_LENGTH_OUT_OF_RANGE, {
+        actualLength: putativeBlockhash.length
+      });
+    }
+    const bytes = base58Encoder2.encode(putativeBlockhash);
+    const numBytes = bytes.byteLength;
+    if (numBytes !== 32) {
+      throw new SolanaError(SOLANA_ERROR__BLOCKHASH_BYTE_LENGTH_OUT_OF_RANGE, {
+        actualLength: numBytes
       });
     }
   }
@@ -4289,9 +4480,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
       case "processed":
         return 0;
       default:
-        return ((_) => {
-          throw new Error(`Unrecognized commitment \`${commitment}\`.`);
-        })();
+        throw new SolanaError(SOLANA_ERROR__INVARIANT_VIOLATION_SWITCH_MUST_BE_EXHAUSTIVE, {
+          unexpectedValue: commitment
+        });
     }
   }
   function commitmentComparator(a, b) {
@@ -4305,11 +4496,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return putativeLamports >= 0 && putativeLamports <= maxU64Value;
   }
   function assertIsLamports(putativeLamports) {
-    if (putativeLamports < 0) {
-      throw new Error("Input for 64-bit unsigned integer cannot be negative");
-    }
-    if (putativeLamports > maxU64Value) {
-      throw new Error("Input number is too large to be represented as a 64-bit unsigned integer");
+    if (putativeLamports < 0 || putativeLamports > maxU64Value) {
+      throw new SolanaError(SOLANA_ERROR__LAMPORTS_OUT_OF_RANGE);
     }
   }
   function lamports(putativeLamports) {
@@ -4346,9 +4534,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
   function assertIsStringifiedBigInt(putativeBigInt) {
     try {
       BigInt(putativeBigInt);
-    } catch (e4) {
-      throw new Error(`\`${putativeBigInt}\` cannot be parsed as a BigInt`, {
-        cause: e4
+    } catch {
+      throw new SolanaError(SOLANA_ERROR__MALFORMED_BIGINT_STRING, {
+        value: putativeBigInt
       });
     }
   }
@@ -4361,7 +4549,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   function assertIsStringifiedNumber(putativeNumber) {
     if (Number.isNaN(Number(putativeNumber))) {
-      throw new Error(`\`${putativeNumber}\` cannot be parsed as a Number`);
+      throw new SolanaError(SOLANA_ERROR__MALFORMED_NUMBER_STRING, {
+        value: putativeNumber
+      });
     }
   }
   function stringifiedNumber(putativeNumber) {
@@ -4375,13 +4565,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return true;
   }
   function assertIsUnixTimestamp(putativeTimestamp) {
-    try {
-      if (putativeTimestamp > 864e13 || putativeTimestamp < -864e13) {
-        throw new Error("Expected input number to be in the range [-8.64e15, 8.64e15]");
-      }
-    } catch (e4) {
-      throw new Error(`\`${putativeTimestamp}\` is not a timestamp`, {
-        cause: e4
+    if (putativeTimestamp > 864e13 || putativeTimestamp < -864e13) {
+      throw new SolanaError(SOLANA_ERROR__TIMESTAMP_OUT_OF_RANGE, {
+        value: putativeTimestamp
       });
     }
   }
@@ -4399,22 +4585,20 @@ this.globalThis.solanaWeb3 = (function (exports) {
   function assertIsBlockhash2(putativeBlockhash) {
     if (!base58Encoder3)
       base58Encoder3 = getBase58Encoder();
-    try {
-      if (
-        // Lowest value (32 bytes of zeroes)
-        putativeBlockhash.length < 32 || // Highest value (32 bytes of 255)
-        putativeBlockhash.length > 44
-      ) {
-        throw new Error("Expected input string to decode to a byte array of length 32.");
-      }
-      const bytes = base58Encoder3.encode(putativeBlockhash);
-      const numBytes = bytes.byteLength;
-      if (numBytes !== 32) {
-        throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
-      }
-    } catch (e4) {
-      throw new Error(`\`${putativeBlockhash}\` is not a blockhash`, {
-        cause: e4
+    if (
+      // Lowest value (32 bytes of zeroes)
+      putativeBlockhash.length < 32 || // Highest value (32 bytes of 255)
+      putativeBlockhash.length > 44
+    ) {
+      throw new SolanaError(SOLANA_ERROR__BLOCKHASH_STRING_LENGTH_OUT_OF_RANGE, {
+        actualLength: putativeBlockhash.length
+      });
+    }
+    const bytes = base58Encoder3.encode(putativeBlockhash);
+    const numBytes = bytes.byteLength;
+    if (numBytes !== 32) {
+      throw new SolanaError(SOLANA_ERROR__BLOCKHASH_BYTE_LENGTH_OUT_OF_RANGE, {
+        actualLength: numBytes
       });
     }
   }
@@ -5339,9 +5523,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
       if (!deduplicated[signer.address]) {
         deduplicated[signer.address] = signer;
       } else if (deduplicated[signer.address] !== signer) {
-        throw new Error(
-          `Multiple distinct signers were identified for address "${signer.address}". Please ensure that you are using the same signer instance for each address.`
-        );
+        throw new SolanaError(SOLANA_ERROR__SIGNER_ADDRESS_CANNOT_HAVE_MULTIPLE_SIGNERS, {
+          address: signer.address
+        });
       }
     });
     return Object.values(deduplicated);
@@ -5404,7 +5588,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   function assertIsMessagePartialSigner(value) {
     if (!isMessagePartialSigner(value)) {
-      throw new Error("The provided value does not implement the MessagePartialSigner interface");
+      throw new SolanaError(SOLANA_ERROR__SIGNER_EXPECTED_MESSAGE_PARTIAL_SIGNER, {
+        address: value.address
+      });
     }
   }
   function isTransactionPartialSigner(value) {
@@ -5412,7 +5598,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   function assertIsTransactionPartialSigner(value) {
     if (!isTransactionPartialSigner(value)) {
-      throw new Error("The provided value does not implement the TransactionPartialSigner interface");
+      throw new SolanaError(SOLANA_ERROR__SIGNER_EXPECTED_TRANSACTION_PARTIAL_SIGNER, {
+        address: value.address
+      });
     }
   }
   function isKeyPairSigner(value) {
@@ -5420,7 +5608,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   function assertIsKeyPairSigner(value) {
     if (!isKeyPairSigner(value)) {
-      throw new Error("The provided value does not implement the KeyPairSigner interface");
+      throw new SolanaError(SOLANA_ERROR__SIGNER_EXPECTED_KEY_PAIR_SIGNER, {
+        address: value.address
+      });
     }
   }
   async function createSignerFromKeyPair(keyPair) {
@@ -5453,7 +5643,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   function assertIsMessageModifyingSigner(value) {
     if (!isMessageModifyingSigner(value)) {
-      throw new Error("The provided value does not implement the MessageModifyingSigner interface");
+      throw new SolanaError(SOLANA_ERROR__SIGNER_EXPECTED_MESSAGE_MODIFYING_SIGNER, {
+        address: value.address
+      });
     }
   }
   function isMessageSigner(value) {
@@ -5461,7 +5653,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   function assertIsMessageSigner(value) {
     if (!isMessageSigner(value)) {
-      throw new Error("The provided value does not implement any of the MessageSigner interfaces");
+      throw new SolanaError(SOLANA_ERROR__SIGNER_EXPECTED_MESSAGE_SIGNER, {
+        address: value.address
+      });
     }
   }
   function createNoopSigner(address2) {
@@ -5477,7 +5671,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   function assertIsTransactionModifyingSigner(value) {
     if (!isTransactionModifyingSigner(value)) {
-      throw new Error("The provided value does not implement the TransactionModifyingSigner interface");
+      throw new SolanaError(SOLANA_ERROR__SIGNER_EXPECTED_TRANSACTION_MODIFYING_SIGNER, {
+        address: value.address
+      });
     }
   }
   function isTransactionSendingSigner(value) {
@@ -5485,7 +5681,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   function assertIsTransactionSendingSigner(value) {
     if (!isTransactionSendingSigner(value)) {
-      throw new Error("The provided value does not implement the TransactionSendingSigner interface");
+      throw new SolanaError(SOLANA_ERROR__SIGNER_EXPECTED_TRANSACTION_SENDING_SIGNER, {
+        address: value.address
+      });
     }
   }
   function isTransactionSigner(value) {
@@ -5493,7 +5691,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   function assertIsTransactionSigner(value) {
     if (!isTransactionSigner(value)) {
-      throw new Error("The provided value does not implement any of the TransactionSigner interfaces");
+      throw new SolanaError(SOLANA_ERROR__SIGNER_EXPECTED_TRANSACTION_SIGNER, {
+        address: value.address
+      });
     }
   }
   async function partiallySignTransactionWithSigners(transaction, config = {}) {
@@ -5521,9 +5721,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
       abortSignal
     );
     if (!sendingSigner) {
-      throw new Error(
-        "No `TransactionSendingSigner` was identified. Please provide a valid `ITransactionWithSingleSendingSigner` transaction."
-      );
+      throw new SolanaError(SOLANA_ERROR__SIGNER_TRANSACTION_SENDING_SIGNER_MISSING);
     }
     abortSignal == null ? void 0 : abortSignal.throwIfAborted();
     const [signature2] = await sendingSigner.signAndSendTransactions([signedTransaction], { abortSignal });
@@ -5608,17 +5806,13 @@ this.globalThis.solanaWeb3 = (function (exports) {
     const signers = getSignersFromTransaction(transaction);
     const sendingSigners = signers.filter(isTransactionSendingSigner);
     if (sendingSigners.length === 0) {
-      const error = new Error("No `TransactionSendingSigner` was identified.");
-      error.name = "MissingTransactionSendingSignerError";
-      throw error;
+      throw new SolanaError(SOLANA_ERROR__SIGNER_TRANSACTION_SENDING_SIGNER_MISSING);
     }
     const sendingOnlySigners = sendingSigners.filter(
       (signer) => !isTransactionPartialSigner(signer) && !isTransactionModifyingSigner(signer)
     );
     if (sendingOnlySigners.length > 1) {
-      const error = new Error("More than one `TransactionSendingSigner` was identified.");
-      error.name = "MultipleTransactionSendingSignersError";
-      throw error;
+      throw new SolanaError(SOLANA_ERROR__SIGNER_TRANSACTION_CANNOT_HAVE_MULTIPLE_SENDING_SIGNERS);
     }
   }
 
@@ -6129,6 +6323,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.assertIsBlockhash = assertIsBlockhash;
   exports.assertIsDurableNonceTransaction = assertIsDurableNonceTransaction;
   exports.assertIsFixedSize = assertIsFixedSize;
+  exports.assertIsInstructionForProgram = assertIsInstructionForProgram;
+  exports.assertIsInstructionWithAccounts = assertIsInstructionWithAccounts;
+  exports.assertIsInstructionWithData = assertIsInstructionWithData;
   exports.assertIsKeyPairSigner = assertIsKeyPairSigner;
   exports.assertIsLamports = assertIsLamports;
   exports.assertIsMessageModifyingSigner = assertIsMessageModifyingSigner;
@@ -6170,9 +6367,12 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.createSignerFromKeyPair = createSignerFromKeyPair;
   exports.createSolanaRpc = createSolanaRpc;
   exports.createSolanaRpcApi = createSolanaRpcApi;
+  exports.createSolanaRpcFromTransport = createSolanaRpcFromTransport;
   exports.createSolanaRpcSubscriptions = createSolanaRpcSubscriptions;
   exports.createSolanaRpcSubscriptionsApi = createSolanaRpcSubscriptionsApi;
   exports.createSolanaRpcSubscriptionsApi_UNSTABLE = createSolanaRpcSubscriptionsApi_UNSTABLE;
+  exports.createSolanaRpcSubscriptionsFromTransport = createSolanaRpcSubscriptionsFromTransport;
+  exports.createSolanaRpcSubscriptionsFromTransport_UNSTABLE = createSolanaRpcSubscriptionsFromTransport_UNSTABLE;
   exports.createSolanaRpcSubscriptions_UNSTABLE = createSolanaRpcSubscriptions_UNSTABLE;
   exports.createSubscriptionRpc = createSubscriptionRpc;
   exports.createTransaction = createTransaction;
@@ -6316,6 +6516,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.isAddress = isAddress;
   exports.isAdvanceNonceAccountInstruction = isAdvanceNonceAccountInstruction;
   exports.isFixedSize = isFixedSize;
+  exports.isInstructionForProgram = isInstructionForProgram;
+  exports.isInstructionWithAccounts = isInstructionWithAccounts;
+  exports.isInstructionWithData = isInstructionWithData;
   exports.isKeyPairSigner = isKeyPairSigner;
   exports.isLamports = isLamports;
   exports.isMessageModifyingSigner = isMessageModifyingSigner;