@solana/web3.js 2.0.0-experimental.ad9c23c → 2.0.0-experimental.adbd218

package/dist/index.development.js

@@ -125,6 +125,572 @@ this.globalThis.solanaWeb3 = (function (exports) {
   // ../accounts/dist/index.browser.js
   init_env_shim();
 
+  // ../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;
+  var SOLANA_ERROR__NONCE_ACCOUNT_NOT_FOUND = 7;
+  var SOLANA_ERROR__ACCOUNT_NOT_FOUND = 8;
+  var SOLANA_ERROR__MULTIPLE_ACCOUNTS_NOT_FOUND = 9;
+  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__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;
+  var SOLANA_ERROR__PROGRAM_DERIVED_ADDRESS_BUMP_SEED_OUT_OF_RANGE = 18;
+  var SOLANA_ERROR__MAX_NUMBER_OF_PDA_SEEDS_EXCEEDED = 19;
+  var SOLANA_ERROR__MAX_PDA_SEED_LENGTH_EXCEEDED = 20;
+  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__SUBTLE_CRYPTO_MISSING = 24;
+  var SOLANA_ERROR__SUBTLE_CRYPTO_DIGEST_MISSING = 25;
+  var SOLANA_ERROR__SUBTLE_CRYPTO_ED25519_ALGORITHM_MISSING = 26;
+  var SOLANA_ERROR__SUBTLE_CRYPTO_EXPORT_FUNCTION_MISSING = 27;
+  var SOLANA_ERROR__SUBTLE_CRYPTO_GENERATE_FUNCTION_MISSING = 28;
+  var SOLANA_ERROR__SUBTLE_CRYPTO_SIGN_FUNCTION_MISSING = 29;
+  var SOLANA_ERROR__SUBTLE_CRYPTO_VERIFY_FUNCTION_MISSING = 30;
+  var SOLANA_ERROR__CODECS_CANNOT_DECODE_EMPTY_BYTE_ARRAY = 31;
+  var SOLANA_ERROR__CODECS_WRONG_NUMBER_OF_BYTES = 32;
+  var SOLANA_ERROR__CODECS_EXPECTED_FIXED_LENGTH_GOT_VARIABLE_LENGTH = 33;
+  var SOLANA_ERROR__CODECS_EXPECTED_VARIABLE_LENGTH_GOT_FIXED_LENGTH = 34;
+  var SOLANA_ERROR__CODECS_ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH = 35;
+  var SOLANA_ERROR__CODECS_FIXED_SIZE_ENCODER_DECODER_SIZE_MISMATCH = 36;
+  var SOLANA_ERROR__CODECS_VARIABLE_SIZE_ENCODER_DECODER_MAX_SIZE_MISMATCH = 37;
+  var SOLANA_ERROR__CODECS_CANNOT_REVERSE_CODEC_OF_VARIABLE_SIZE = 38;
+  var SOLANA_ERROR__CODECS_WRONG_NUMBER_OF_ITEMS = 39;
+  var SOLANA_ERROR__CODECS_ENUM_DISCRIMINATOR_OUT_OF_RANGE = 40;
+  var SOLANA_ERROR__CODECS_INVALID_DATA_ENUM_VARIANT = 41;
+  var SOLANA_ERROR__CODECS_INVALID_SCALAR_ENUM_VARIANT = 42;
+  var SOLANA_ERROR__CODECS_FIXED_NULLABLE_WITH_VARIABLE_SIZE_CODEC = 43;
+  var SOLANA_ERROR__CODECS_FIXED_NULLABLE_WITH_VARIABLE_SIZE_PREFIX = 44;
+  var SOLANA_ERROR__CODECS_CODEC_REQUIRES_FIXED_SIZE = 45;
+  var SOLANA_ERROR__CODECS_NUMBER_OUT_OF_RANGE = 46;
+  var SOLANA_ERROR__CODECS_INVALID_STRING_FOR_BASE = 47;
+  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__RPC_TRANSPORT_HEADER_FORBIDDEN = 54;
+  var SOLANA_ERROR__RPC_TRANSPORT_HTTP_ERROR = 55;
+  var SOLANA_ERROR__EXPECTED_INSTRUCTION_TO_HAVE_ACCOUNTS = 70;
+  var SOLANA_ERROR__EXPECTED_INSTRUCTION_TO_HAVE_DATA = 71;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_UNKNOWN = 4615e3;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_GENERIC_ERROR = 4615001;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_INVALID_ARGUMENT = 4615002;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_INVALID_INSTRUCTION_DATA = 4615003;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_INVALID_ACCOUNT_DATA = 4615004;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_ACCOUNT_DATA_TOO_SMALL = 4615005;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_INSUFFICIENT_FUNDS = 4615006;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_INCORRECT_PROGRAM_ID = 4615007;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_MISSING_REQUIRED_SIGNATURE = 4615008;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_ACCOUNT_ALREADY_INITIALIZED = 4615009;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_UNINITIALIZED_ACCOUNT = 4615010;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_UNBALANCED_INSTRUCTION = 4615011;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_MODIFIED_PROGRAM_ID = 4615012;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_EXTERNAL_ACCOUNT_LAMPORT_SPEND = 4615013;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_EXTERNAL_ACCOUNT_DATA_MODIFIED = 4615014;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_READONLY_LAMPORT_CHANGE = 4615015;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_READONLY_DATA_MODIFIED = 4615016;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_DUPLICATE_ACCOUNT_INDEX = 4615017;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_EXECUTABLE_MODIFIED = 4615018;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_RENT_EPOCH_MODIFIED = 4615019;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_NOT_ENOUGH_ACCOUNT_KEYS = 4615020;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_ACCOUNT_DATA_SIZE_CHANGED = 4615021;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_ACCOUNT_NOT_EXECUTABLE = 4615022;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_ACCOUNT_BORROW_FAILED = 4615023;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_ACCOUNT_BORROW_OUTSTANDING = 4615024;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_DUPLICATE_ACCOUNT_OUT_OF_SYNC = 4615025;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_CUSTOM = 4615026;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_INVALID_ERROR = 4615027;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_EXECUTABLE_DATA_MODIFIED = 4615028;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_EXECUTABLE_LAMPORT_CHANGE = 4615029;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_EXECUTABLE_ACCOUNT_NOT_RENT_EXEMPT = 4615030;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_UNSUPPORTED_PROGRAM_ID = 4615031;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_CALL_DEPTH = 4615032;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_MISSING_ACCOUNT = 4615033;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_REENTRANCY_NOT_ALLOWED = 4615034;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_MAX_SEED_LENGTH_EXCEEDED = 4615035;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_INVALID_SEEDS = 4615036;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_INVALID_REALLOC = 4615037;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_COMPUTATIONAL_BUDGET_EXCEEDED = 4615038;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_PRIVILEGE_ESCALATION = 4615039;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_PROGRAM_ENVIRONMENT_SETUP_FAILURE = 4615040;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_PROGRAM_FAILED_TO_COMPLETE = 4615041;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_PROGRAM_FAILED_TO_COMPILE = 4615042;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_IMMUTABLE = 4615043;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_INCORRECT_AUTHORITY = 4615044;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_BORSH_IO_ERROR = 4615045;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_ACCOUNT_NOT_RENT_EXEMPT = 4615046;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_INVALID_ACCOUNT_OWNER = 4615047;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_ARITHMETIC_OVERFLOW = 4615048;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_UNSUPPORTED_SYSVAR = 4615049;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_ILLEGAL_OWNER = 4615050;
+  var SOLANA_ERROR__INSTRUCTION_ERROR_MAX_ACCOUNTS_DATA_ALLOCATIONS_EXCEEDED = 4615051;
+  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;
+  var SOLANA_ERROR__TRANSACTION_EXPECTED_NONCE_LIFETIME = 5663004;
+  var SOLANA_ERROR__TRANSACTION_VERSION_NUMBER_OUT_OF_RANGE = 5663005;
+  var SOLANA_ERROR__TRANSACTION_FAILED_TO_DECOMPILE_ADDRESS_LOOKUP_TABLE_CONTENTS_MISSING = 5663006;
+  var SOLANA_ERROR__TRANSACTION_FAILED_TO_DECOMPILE_ADDRESS_LOOKUP_TABLE_INDEX_OUT_OF_RANGE = 5663007;
+  var SOLANA_ERROR__TRANSACTION_FAILED_TO_DECOMPILE_INSTRUCTION_PROGRAM_ADDRESS_NOT_FOUND = 5663008;
+  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;
+  var SOLANA_ERROR__TRANSACTION_ERROR_ACCOUNT_NOT_FOUND = 7050003;
+  var SOLANA_ERROR__TRANSACTION_ERROR_PROGRAM_ACCOUNT_NOT_FOUND = 7050004;
+  var SOLANA_ERROR__TRANSACTION_ERROR_INSUFFICIENT_FUNDS_FOR_FEE = 7050005;
+  var SOLANA_ERROR__TRANSACTION_ERROR_INVALID_ACCOUNT_FOR_FEE = 7050006;
+  var SOLANA_ERROR__TRANSACTION_ERROR_ALREADY_PROCESSED = 7050007;
+  var SOLANA_ERROR__TRANSACTION_ERROR_BLOCKHASH_NOT_FOUND = 7050008;
+  var SOLANA_ERROR__TRANSACTION_ERROR_CALL_CHAIN_TOO_DEEP = 7050009;
+  var SOLANA_ERROR__TRANSACTION_ERROR_MISSING_SIGNATURE_FOR_FEE = 7050010;
+  var SOLANA_ERROR__TRANSACTION_ERROR_INVALID_ACCOUNT_INDEX = 7050011;
+  var SOLANA_ERROR__TRANSACTION_ERROR_SIGNATURE_FAILURE = 7050012;
+  var SOLANA_ERROR__TRANSACTION_ERROR_INVALID_PROGRAM_FOR_EXECUTION = 7050013;
+  var SOLANA_ERROR__TRANSACTION_ERROR_SANITIZE_FAILURE = 7050014;
+  var SOLANA_ERROR__TRANSACTION_ERROR_CLUSTER_MAINTENANCE = 7050015;
+  var SOLANA_ERROR__TRANSACTION_ERROR_ACCOUNT_BORROW_OUTSTANDING = 7050016;
+  var SOLANA_ERROR__TRANSACTION_ERROR_WOULD_EXCEED_MAX_BLOCK_COST_LIMIT = 7050017;
+  var SOLANA_ERROR__TRANSACTION_ERROR_UNSUPPORTED_VERSION = 7050018;
+  var SOLANA_ERROR__TRANSACTION_ERROR_INVALID_WRITABLE_ACCOUNT = 7050019;
+  var SOLANA_ERROR__TRANSACTION_ERROR_WOULD_EXCEED_MAX_ACCOUNT_COST_LIMIT = 7050020;
+  var SOLANA_ERROR__TRANSACTION_ERROR_WOULD_EXCEED_ACCOUNT_DATA_BLOCK_LIMIT = 7050021;
+  var SOLANA_ERROR__TRANSACTION_ERROR_TOO_MANY_ACCOUNT_LOCKS = 7050022;
+  var SOLANA_ERROR__TRANSACTION_ERROR_ADDRESS_LOOKUP_TABLE_NOT_FOUND = 7050023;
+  var SOLANA_ERROR__TRANSACTION_ERROR_INVALID_ADDRESS_LOOKUP_TABLE_OWNER = 7050024;
+  var SOLANA_ERROR__TRANSACTION_ERROR_INVALID_ADDRESS_LOOKUP_TABLE_DATA = 7050025;
+  var SOLANA_ERROR__TRANSACTION_ERROR_INVALID_ADDRESS_LOOKUP_TABLE_INDEX = 7050026;
+  var SOLANA_ERROR__TRANSACTION_ERROR_INVALID_RENT_PAYING_ACCOUNT = 7050027;
+  var SOLANA_ERROR__TRANSACTION_ERROR_WOULD_EXCEED_MAX_VOTE_COST_LIMIT = 7050028;
+  var SOLANA_ERROR__TRANSACTION_ERROR_WOULD_EXCEED_ACCOUNT_DATA_TOTAL_LIMIT = 7050029;
+  var SOLANA_ERROR__TRANSACTION_ERROR_DUPLICATE_INSTRUCTION = 7050030;
+  var SOLANA_ERROR__TRANSACTION_ERROR_INSUFFICIENT_FUNDS_FOR_RENT = 7050031;
+  var SOLANA_ERROR__TRANSACTION_ERROR_MAX_LOADED_ACCOUNTS_DATA_SIZE_EXCEEDED = 7050032;
+  var SOLANA_ERROR__TRANSACTION_ERROR_INVALID_LOADED_ACCOUNTS_DATA_SIZE_LIMIT = 7050033;
+  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 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_CANNOT_REVERSE_CODEC_OF_VARIABLE_SIZE]: "Cannot reverse a codec of variable size.",
+    [SOLANA_ERROR__CODECS_CODEC_REQUIRES_FIXED_SIZE]: "Codec [$codecDescription] requires a fixed size.",
+    [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_NULLABLE_WITH_VARIABLE_SIZE_CODEC]: "Fixed nullables can only be used with fixed-size codecs.",
+    [SOLANA_ERROR__CODECS_FIXED_NULLABLE_WITH_VARIABLE_SIZE_PREFIX]: "Fixed nullables can only be used with fixed-size prefix.",
+    [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__EXPECTED_INSTRUCTION_TO_HAVE_ACCOUNTS]: "The instruction does not have any accounts.",
+    [SOLANA_ERROR__EXPECTED_INSTRUCTION_TO_HAVE_DATA]: "The instruction does not have any data.",
+    [SOLANA_ERROR__FAILED_TO_DECODE_ACCOUNT]: "Failed to decode account data at address: $address",
+    [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",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_ACCOUNT_DATA_SIZE_CHANGED]: "program other than the account's owner changed the size of the account data",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_ACCOUNT_DATA_TOO_SMALL]: "account data too small for instruction",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_ACCOUNT_NOT_EXECUTABLE]: "instruction expected an executable account",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_ACCOUNT_NOT_RENT_EXEMPT]: "An account does not have enough lamports to be rent-exempt",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_ARITHMETIC_OVERFLOW]: "Program arithmetic overflowed",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_BORSH_IO_ERROR]: "Failed to serialize or deserialize account data: $encodedData",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_BUILTIN_PROGRAMS_MUST_CONSUME_COMPUTE_UNITS]: "Builtin programs must consume compute units",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_CALL_DEPTH]: "Cross-program invocation call depth too deep",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_COMPUTATIONAL_BUDGET_EXCEEDED]: "Computational budget exceeded",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_CUSTOM]: "custom program error: #$code",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_DUPLICATE_ACCOUNT_INDEX]: "instruction contains duplicate accounts",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_DUPLICATE_ACCOUNT_OUT_OF_SYNC]: "instruction modifications of multiply-passed account differ",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_EXECUTABLE_ACCOUNT_NOT_RENT_EXEMPT]: "executable accounts must be rent exempt",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_EXECUTABLE_DATA_MODIFIED]: "instruction changed executable accounts data",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_EXECUTABLE_LAMPORT_CHANGE]: "instruction changed the balance of an executable account",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_EXECUTABLE_MODIFIED]: "instruction changed executable bit of an account",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_EXTERNAL_ACCOUNT_DATA_MODIFIED]: "instruction modified data of an account it does not own",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_EXTERNAL_ACCOUNT_LAMPORT_SPEND]: "instruction spent from the balance of an account it does not own",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_GENERIC_ERROR]: "generic instruction error",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_ILLEGAL_OWNER]: "Provided owner is not allowed",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_IMMUTABLE]: "Account is immutable",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_INCORRECT_AUTHORITY]: "Incorrect authority provided",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_INCORRECT_PROGRAM_ID]: "incorrect program id for instruction",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_INSUFFICIENT_FUNDS]: "insufficient funds for instruction",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_INVALID_ACCOUNT_DATA]: "invalid account data for instruction",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_INVALID_ACCOUNT_OWNER]: "Invalid account owner",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_INVALID_ARGUMENT]: "invalid program argument",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_INVALID_ERROR]: "program returned invalid error code",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_INVALID_INSTRUCTION_DATA]: "invalid instruction data",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_INVALID_REALLOC]: "Failed to reallocate account data",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_INVALID_SEEDS]: "Provided seeds do not result in a valid address",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_MAX_ACCOUNTS_DATA_ALLOCATIONS_EXCEEDED]: "Accounts data allocations exceeded the maximum allowed per transaction",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_MAX_ACCOUNTS_EXCEEDED]: "Max accounts exceeded",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_MAX_INSTRUCTION_TRACE_LENGTH_EXCEEDED]: "Max instruction trace length exceeded",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_MAX_SEED_LENGTH_EXCEEDED]: "Length of the seed is too long for address generation",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_MISSING_ACCOUNT]: "An account required by the instruction is missing",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_MISSING_REQUIRED_SIGNATURE]: "missing required signature for instruction",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_MODIFIED_PROGRAM_ID]: "instruction illegally modified the program id of an account",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_NOT_ENOUGH_ACCOUNT_KEYS]: "insufficient account keys for instruction",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_PRIVILEGE_ESCALATION]: "Cross-program invocation with unauthorized signer or writable account",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_PROGRAM_ENVIRONMENT_SETUP_FAILURE]: "Failed to create program execution environment",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_PROGRAM_FAILED_TO_COMPILE]: "Program failed to compile",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_PROGRAM_FAILED_TO_COMPLETE]: "Program failed to complete",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_READONLY_DATA_MODIFIED]: "instruction modified data of a read-only account",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_READONLY_LAMPORT_CHANGE]: "instruction changed the balance of a read-only account",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_REENTRANCY_NOT_ALLOWED]: "Cross-program invocation reentrancy not allowed for this instruction",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_RENT_EPOCH_MODIFIED]: "instruction modified rent epoch of an account",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_UNBALANCED_INSTRUCTION]: "sum of account balances before and after instruction do not match",
+    [SOLANA_ERROR__INSTRUCTION_ERROR_UNINITIALIZED_ACCOUNT]: "instruction requires an initialized account",
+    [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__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__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.",
+    [SOLANA_ERROR__MULTIPLE_ACCOUNTS_NOT_FOUND]: "Accounts not found at addresses: $addresses",
+    [SOLANA_ERROR__NONCE_ACCOUNT_NOT_FOUND]: "No nonce account could be found at address `$nonceAccountAddress`",
+    [SOLANA_ERROR__NONCE_INVALID]: "The nonce `$expectedNonceValue` is no longer valid. It has advanced to `$actualNonceValue`",
+    [SOLANA_ERROR__NOT_ALL_ACCOUNTS_DECODED]: "Not all accounts were decoded. Encoded accounts found at addresses: $addresses.",
+    [SOLANA_ERROR__NOT_AN_ED25519_PUBLIC_KEY]: "The `CryptoKey` must be an `Ed25519` public key.",
+    [SOLANA_ERROR__NOT_A_BASE58_ENCODED_ADDRESS]: "$putativeAddress is not a base58-encoded address.",
+    [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_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",
+    [SOLANA_ERROR__TRANSACTION_ERROR_ACCOUNT_NOT_FOUND]: "Attempt to debit an account but found no record of a prior credit.",
+    [SOLANA_ERROR__TRANSACTION_ERROR_ADDRESS_LOOKUP_TABLE_NOT_FOUND]: "Transaction loads an address table account that doesn't exist",
+    [SOLANA_ERROR__TRANSACTION_ERROR_ALREADY_PROCESSED]: "This transaction has already been processed",
+    [SOLANA_ERROR__TRANSACTION_ERROR_BLOCKHASH_NOT_FOUND]: "Blockhash not found",
+    [SOLANA_ERROR__TRANSACTION_ERROR_CALL_CHAIN_TOO_DEEP]: "Loader call chain is too deep",
+    [SOLANA_ERROR__TRANSACTION_ERROR_CLUSTER_MAINTENANCE]: "Transactions are currently disabled due to cluster maintenance",
+    [SOLANA_ERROR__TRANSACTION_ERROR_DUPLICATE_INSTRUCTION]: "Transaction contains a duplicate instruction ($index) that is not allowed",
+    [SOLANA_ERROR__TRANSACTION_ERROR_INSUFFICIENT_FUNDS_FOR_FEE]: "Insufficient funds for fee",
+    [SOLANA_ERROR__TRANSACTION_ERROR_INSUFFICIENT_FUNDS_FOR_RENT]: "Transaction results in an account ($accountIndex) with insufficient funds for rent",
+    [SOLANA_ERROR__TRANSACTION_ERROR_INVALID_ACCOUNT_FOR_FEE]: "This account may not be used to pay transaction fees",
+    [SOLANA_ERROR__TRANSACTION_ERROR_INVALID_ACCOUNT_INDEX]: "Transaction contains an invalid account reference",
+    [SOLANA_ERROR__TRANSACTION_ERROR_INVALID_ADDRESS_LOOKUP_TABLE_DATA]: "Transaction loads an address table account with invalid data",
+    [SOLANA_ERROR__TRANSACTION_ERROR_INVALID_ADDRESS_LOOKUP_TABLE_INDEX]: "Transaction address table lookup uses an invalid index",
+    [SOLANA_ERROR__TRANSACTION_ERROR_INVALID_ADDRESS_LOOKUP_TABLE_OWNER]: "Transaction loads an address table account with an invalid owner",
+    [SOLANA_ERROR__TRANSACTION_ERROR_INVALID_LOADED_ACCOUNTS_DATA_SIZE_LIMIT]: "LoadedAccountsDataSizeLimit set for transaction must be greater than 0.",
+    [SOLANA_ERROR__TRANSACTION_ERROR_INVALID_PROGRAM_FOR_EXECUTION]: "This program may not be used for executing instructions",
+    [SOLANA_ERROR__TRANSACTION_ERROR_INVALID_RENT_PAYING_ACCOUNT]: "Transaction leaves an account with a lower balance than rent-exempt minimum",
+    [SOLANA_ERROR__TRANSACTION_ERROR_INVALID_WRITABLE_ACCOUNT]: "Transaction loads a writable account that cannot be written",
+    [SOLANA_ERROR__TRANSACTION_ERROR_MAX_LOADED_ACCOUNTS_DATA_SIZE_EXCEEDED]: "Transaction exceeded max loaded accounts data size cap",
+    [SOLANA_ERROR__TRANSACTION_ERROR_MISSING_SIGNATURE_FOR_FEE]: "Transaction requires a fee but has no signature present",
+    [SOLANA_ERROR__TRANSACTION_ERROR_PROGRAM_ACCOUNT_NOT_FOUND]: "Attempt to load a program that does not exist",
+    [SOLANA_ERROR__TRANSACTION_ERROR_PROGRAM_EXECUTION_TEMPORARILY_RESTRICTED]: "Execution of the program referenced by account at index $accountIndex is temporarily restricted.",
+    [SOLANA_ERROR__TRANSACTION_ERROR_RESANITIZATION_NEEDED]: "ResanitizationNeeded",
+    [SOLANA_ERROR__TRANSACTION_ERROR_SANITIZE_FAILURE]: "Transaction failed to sanitize accounts offsets correctly",
+    [SOLANA_ERROR__TRANSACTION_ERROR_SIGNATURE_FAILURE]: "Transaction did not pass signature verification",
+    [SOLANA_ERROR__TRANSACTION_ERROR_TOO_MANY_ACCOUNT_LOCKS]: "Transaction locked too many accounts",
+    [SOLANA_ERROR__TRANSACTION_ERROR_UNBALANCED_TRANSACTION]: "Sum of account balances before and after transaction do not match",
+    [SOLANA_ERROR__TRANSACTION_ERROR_UNKNOWN]: "The transaction failed with the error `$errorName`",
+    [SOLANA_ERROR__TRANSACTION_ERROR_UNSUPPORTED_VERSION]: "Transaction version is unsupported",
+    [SOLANA_ERROR__TRANSACTION_ERROR_WOULD_EXCEED_ACCOUNT_DATA_BLOCK_LIMIT]: "Transaction would exceed account data limit within the block",
+    [SOLANA_ERROR__TRANSACTION_ERROR_WOULD_EXCEED_ACCOUNT_DATA_TOTAL_LIMIT]: "Transaction would exceed total account data limit",
+    [SOLANA_ERROR__TRANSACTION_ERROR_WOULD_EXCEED_MAX_ACCOUNT_COST_LIMIT]: "Transaction would exceed max account limit within the block",
+    [SOLANA_ERROR__TRANSACTION_ERROR_WOULD_EXCEED_MAX_BLOCK_COST_LIMIT]: "Transaction would exceed max Block Cost Limit",
+    [SOLANA_ERROR__TRANSACTION_ERROR_WOULD_EXCEED_MAX_VOTE_COST_LIMIT]: "Transaction would exceed max Vote Cost Limit",
+    [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",
+    [SOLANA_ERROR__TRANSACTION_FAILED_TO_DECOMPILE_ADDRESS_LOOKUP_TABLE_CONTENTS_MISSING]: "Contents of these address lookup tables unknown: $lookupTableAddresses",
+    [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"
+  };
+  function getHumanReadableErrorMessage(code, context = {}) {
+    const messageFormatString = SolanaErrorMessages[code];
+    const message = messageFormatString.replace(
+      new RegExp("(?<!\\\\)\\$(\\w+)", "g"),
+      (substring, variableName) => variableName in context ? `${context[variableName]}` : substring
+    );
+    return message;
+  }
+  function getErrorMessage(code, context = {}) {
+    {
+      return getHumanReadableErrorMessage(code, context);
+    }
+  }
+  function isSolanaError(e4, code) {
+    const isSolanaError2 = e4 instanceof Error && e4.name === "SolanaError";
+    if (isSolanaError2) {
+      if (code !== void 0) {
+        return e4.context.__code === code;
+      }
+      return true;
+    }
+    return false;
+  }
+  var SolanaError = class extends Error {
+    constructor(...[code, context]) {
+      const message = getErrorMessage(code, context);
+      super(message);
+      __publicField(this, "context");
+      this.context = {
+        __code: code,
+        ...context
+      };
+      this.name = "SolanaError";
+    }
+  };
+  function getSolanaErrorFromRpcError({ errorCodeBaseOffset, getErrorContext, orderedErrorNames, rpcEnumError }, constructorOpt) {
+    let rpcErrorName;
+    let rpcErrorContext;
+    if (typeof rpcEnumError === "string") {
+      rpcErrorName = rpcEnumError;
+    } else {
+      rpcErrorName = Object.keys(rpcEnumError)[0];
+      rpcErrorContext = rpcEnumError[rpcErrorName];
+    }
+    const codeOffset = orderedErrorNames.indexOf(rpcErrorName);
+    const errorCode = errorCodeBaseOffset + codeOffset;
+    const errorContext = getErrorContext(errorCode, rpcErrorName, rpcErrorContext);
+    const err = new SolanaError(errorCode, errorContext);
+    if ("captureStackTrace" in Error && typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(err, constructorOpt);
+    }
+    return err;
+  }
+  var ORDERED_ERROR_NAMES = [
+    // Keep synced with RPC source: https://github.com/anza-xyz/agave/blob/master/sdk/program/src/instruction.rs
+    // If this list ever gets too large, consider implementing a compression strategy like this:
+    // https://gist.github.com/steveluscher/aaa7cbbb5433b1197983908a40860c47
+    "GenericError",
+    "InvalidArgument",
+    "InvalidInstructionData",
+    "InvalidAccountData",
+    "AccountDataTooSmall",
+    "InsufficientFunds",
+    "IncorrectProgramId",
+    "MissingRequiredSignature",
+    "AccountAlreadyInitialized",
+    "UninitializedAccount",
+    "UnbalancedInstruction",
+    "ModifiedProgramId",
+    "ExternalAccountLamportSpend",
+    "ExternalAccountDataModified",
+    "ReadonlyLamportChange",
+    "ReadonlyDataModified",
+    "DuplicateAccountIndex",
+    "ExecutableModified",
+    "RentEpochModified",
+    "NotEnoughAccountKeys",
+    "AccountDataSizeChanged",
+    "AccountNotExecutable",
+    "AccountBorrowFailed",
+    "AccountBorrowOutstanding",
+    "DuplicateAccountOutOfSync",
+    "Custom",
+    "InvalidError",
+    "ExecutableDataModified",
+    "ExecutableLamportChange",
+    "ExecutableAccountNotRentExempt",
+    "UnsupportedProgramId",
+    "CallDepth",
+    "MissingAccount",
+    "ReentrancyNotAllowed",
+    "MaxSeedLengthExceeded",
+    "InvalidSeeds",
+    "InvalidRealloc",
+    "ComputationalBudgetExceeded",
+    "PrivilegeEscalation",
+    "ProgramEnvironmentSetupFailure",
+    "ProgramFailedToComplete",
+    "ProgramFailedToCompile",
+    "Immutable",
+    "IncorrectAuthority",
+    "BorshIoError",
+    "AccountNotRentExempt",
+    "InvalidAccountOwner",
+    "ArithmeticOverflow",
+    "UnsupportedSysvar",
+    "IllegalOwner",
+    "MaxAccountsDataAllocationsExceeded",
+    "MaxAccountsExceeded",
+    "MaxInstructionTraceLengthExceeded",
+    "BuiltinProgramsMustConsumeComputeUnits"
+  ];
+  function getSolanaErrorFromInstructionError(index, instructionError) {
+    return getSolanaErrorFromRpcError(
+      {
+        errorCodeBaseOffset: 4615001,
+        getErrorContext(errorCode, rpcErrorName, rpcErrorContext) {
+          if (errorCode === SOLANA_ERROR__INSTRUCTION_ERROR_UNKNOWN) {
+            return {
+              errorName: rpcErrorName,
+              index,
+              ...rpcErrorContext !== void 0 ? { instructionErrorContext: rpcErrorContext } : null
+            };
+          } else if (errorCode === SOLANA_ERROR__INSTRUCTION_ERROR_CUSTOM) {
+            return {
+              code: rpcErrorContext,
+              index
+            };
+          } else if (errorCode === SOLANA_ERROR__INSTRUCTION_ERROR_BORSH_IO_ERROR) {
+            return {
+              encodedData: rpcErrorContext,
+              index
+            };
+          }
+          return { index };
+        },
+        orderedErrorNames: ORDERED_ERROR_NAMES,
+        rpcEnumError: instructionError
+      },
+      getSolanaErrorFromInstructionError
+    );
+  }
+  var ORDERED_ERROR_NAMES2 = [
+    // Keep synced with RPC source: https://github.com/anza-xyz/agave/blob/master/sdk/src/transaction/error.rs
+    // If this list ever gets too large, consider implementing a compression strategy like this:
+    // https://gist.github.com/steveluscher/aaa7cbbb5433b1197983908a40860c47
+    "AccountInUse",
+    "AccountLoadedTwice",
+    "AccountNotFound",
+    "ProgramAccountNotFound",
+    "InsufficientFundsForFee",
+    "InvalidAccountForFee",
+    "AlreadyProcessed",
+    "BlockhashNotFound",
+    // `InstructionError` intentionally omitted; delegated to `getSolanaErrorFromInstructionError`
+    "CallChainTooDeep",
+    "MissingSignatureForFee",
+    "InvalidAccountIndex",
+    "SignatureFailure",
+    "InvalidProgramForExecution",
+    "SanitizeFailure",
+    "ClusterMaintenance",
+    "AccountBorrowOutstanding",
+    "WouldExceedMaxBlockCostLimit",
+    "UnsupportedVersion",
+    "InvalidWritableAccount",
+    "WouldExceedMaxAccountCostLimit",
+    "WouldExceedAccountDataBlockLimit",
+    "TooManyAccountLocks",
+    "AddressLookupTableNotFound",
+    "InvalidAddressLookupTableOwner",
+    "InvalidAddressLookupTableData",
+    "InvalidAddressLookupTableIndex",
+    "InvalidRentPayingAccount",
+    "WouldExceedMaxVoteCostLimit",
+    "WouldExceedAccountDataTotalLimit",
+    "DuplicateInstruction",
+    "InsufficientFundsForRent",
+    "MaxLoadedAccountsDataSizeExceeded",
+    "InvalidLoadedAccountsDataSizeLimit",
+    "ResanitizationNeeded",
+    "ProgramExecutionTemporarilyRestricted",
+    "UnbalancedTransaction"
+  ];
+  function getSolanaErrorFromTransactionError(transactionError) {
+    if (typeof transactionError === "object" && "InstructionError" in transactionError) {
+      return getSolanaErrorFromInstructionError(
+        ...transactionError.InstructionError
+      );
+    }
+    return getSolanaErrorFromRpcError(
+      {
+        errorCodeBaseOffset: 7050001,
+        getErrorContext(errorCode, rpcErrorName, rpcErrorContext) {
+          if (errorCode === SOLANA_ERROR__TRANSACTION_ERROR_UNKNOWN) {
+            return {
+              errorName: rpcErrorName,
+              ...rpcErrorContext !== void 0 ? { transactionErrorContext: rpcErrorContext } : null
+            };
+          } else if (errorCode === SOLANA_ERROR__TRANSACTION_ERROR_DUPLICATE_INSTRUCTION) {
+            return {
+              index: rpcErrorContext
+            };
+          } else if (errorCode === SOLANA_ERROR__TRANSACTION_ERROR_INSUFFICIENT_FUNDS_FOR_RENT || errorCode === SOLANA_ERROR__TRANSACTION_ERROR_PROGRAM_EXECUTION_TEMPORARILY_RESTRICTED) {
+            return {
+              accountIndex: rpcErrorContext.account_index
+            };
+          }
+        },
+        orderedErrorNames: ORDERED_ERROR_NAMES2,
+        rpcEnumError: transactionError
+      },
+      getSolanaErrorFromTransactionError
+    );
+  }
+
   // ../codecs-strings/dist/index.browser.js
   init_env_shim();
 
@@ -132,13 +698,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) => {
@@ -199,32 +771,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,
@@ -287,7 +861,15 @@ this.globalThis.solanaWeb3 = (function (exports) {
     });
   }
   function reverseEncoder(encoder) {
-    assertIsFixedSize(encoder, "Cannot reverse a codec of variable size.");
+    try {
+      assertIsFixedSize(encoder);
+    } catch (e4) {
+      if (isSolanaError(e4, SOLANA_ERROR__CODECS_EXPECTED_FIXED_LENGTH_GOT_VARIABLE_LENGTH)) {
+        throw new SolanaError(SOLANA_ERROR__CODECS_CANNOT_REVERSE_CODEC_OF_VARIABLE_SIZE);
+      } else {
+        throw e4;
+      }
+    }
     return createEncoder({
       ...encoder,
       write: (value, bytes, offset) => {
@@ -299,7 +881,15 @@ this.globalThis.solanaWeb3 = (function (exports) {
     });
   }
   function reverseDecoder(decoder) {
-    assertIsFixedSize(decoder, "Cannot reverse a codec of variable size.");
+    try {
+      assertIsFixedSize(decoder);
+    } catch (e4) {
+      if (isSolanaError(e4, SOLANA_ERROR__CODECS_EXPECTED_FIXED_LENGTH_GOT_VARIABLE_LENGTH)) {
+        throw new SolanaError(SOLANA_ERROR__CODECS_CANNOT_REVERSE_CODEC_OF_VARIABLE_SIZE);
+      } else {
+        throw e4;
+      }
+    }
     return createDecoder({
       ...decoder,
       read: (bytes, offset) => {
@@ -321,9 +911,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) => {
@@ -518,7 +1111,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;
@@ -572,7 +1165,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
   });
@@ -599,7 +1192,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) => {
@@ -738,6 +1335,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
     return output;
   }
+  var alphabet3 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
   var getBase64Encoder = () => {
     {
       return createEncoder({
@@ -745,7 +1343,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) {
@@ -754,7 +1356,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
+            });
           }
         }
       });
@@ -858,10 +1464,10 @@ this.globalThis.solanaWeb3 = (function (exports) {
         return encodedAccount;
       }
       return Object.freeze({ ...encodedAccount, data: decoder.decode(encodedAccount.data) });
-    } catch (error) {
-      const newError = new Error(`Failed to decode account [${encodedAccount.address}].`);
-      newError.cause = error;
-      throw newError;
+    } catch (e4) {
+      throw new SolanaError(SOLANA_ERROR__FAILED_TO_DECODE_ACCOUNT, {
+        address: encodedAccount.address
+      });
     }
   }
   function accountExists(account) {
@@ -869,14 +1475,18 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   function assertAccountDecoded(account) {
     if (accountExists(account) && account.data instanceof Uint8Array) {
-      throw new Error(`Expected account [${account.address}] to be decoded.`);
+      throw new SolanaError(SOLANA_ERROR__EXPECTED_DECODED_ACCOUNT, {
+        address: account.address
+      });
     }
   }
   function assertAccountsDecoded(accounts) {
     const encoded = accounts.filter((a) => accountExists(a) && a.data instanceof Uint8Array);
     if (encoded.length > 0) {
-      const encodedAddresses = encoded.map((a) => a.address).join(", ");
-      throw new Error(`Expected accounts [${encodedAddresses}] to be decoded.`);
+      const encodedAddresses = encoded.map((a) => a.address);
+      throw new SolanaError(SOLANA_ERROR__NOT_ALL_ACCOUNTS_DECODED, {
+        addresses: encodedAddresses
+      });
     }
   }
   function parseBase64RpcAccount(address2, rpcAccount) {
@@ -928,14 +1538,14 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   function assertAccountExists(account) {
     if (!account.exists) {
-      throw new Error(`Expected account [${account.address}] to exist.`);
+      throw new SolanaError(SOLANA_ERROR__ACCOUNT_NOT_FOUND, { address: account.address });
     }
   }
   function assertAccountsExist(accounts) {
     const missingAccounts = accounts.filter((a) => !a.exists);
     if (missingAccounts.length > 0) {
       const missingAddresses = missingAccounts.map((a) => a.address);
-      throw new Error(`Expected accounts [${missingAddresses.join(", ")}] to exist.`);
+      throw new SolanaError(SOLANA_ERROR__MULTIPLE_ACCOUNTS_NOT_FOUND, { addresses: missingAddresses });
     }
   }
 
@@ -946,9 +1556,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;
@@ -977,40 +1585,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);
     }
   }
 
@@ -1044,23 +1650,21 @@ 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 Error("Expected input string to decode to a byte array of length 32.");
-      }
-      const base58Encoder4 = getMemoizedBase58Encoder();
-      const bytes = base58Encoder4.encode(putativeAddress);
-      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(`\`${putativeAddress}\` is not a base-58 encoded address`, {
-        cause: e4
+    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
       });
     }
   }
@@ -1182,12 +1786,12 @@ this.globalThis.solanaWeb3 = (function (exports) {
   function assertIsProgramDerivedAddress(value) {
     const validFormat = Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && typeof value[1] === "number";
     if (!validFormat) {
-      throw new Error(
-        `Expected given program derived address to have the following format: [Address, ProgramDerivedAddressBump].`
-      );
+      throw new SolanaError(SOLANA_ERROR__MALFORMED_PROGRAM_DERIVED_ADDRESS);
     }
     if (value[1] < 0 || value[1] > 255) {
-      throw new Error(`Expected program derived address bump to be in the range [0, 255], got: ${value[1]}.`);
+      throw new SolanaError(SOLANA_ERROR__PROGRAM_DERIVED_ADDRESS_BUMP_SEED_OUT_OF_RANGE, {
+        bump: value[1]
+      });
     }
     assertIsAddress(value[0]);
   }
@@ -1217,18 +1821,23 @@ this.globalThis.solanaWeb3 = (function (exports) {
     115,
     115
   ];
-  var PointOnCurveError = class extends Error {
-  };
   async function createProgramDerivedAddress({ programAddress, seeds }) {
     await assertDigestCapabilityIsAvailable();
     if (seeds.length > MAX_SEEDS) {
-      throw new Error(`A maximum of ${MAX_SEEDS} seeds may be supplied when creating an address`);
+      throw new SolanaError(SOLANA_ERROR__MAX_NUMBER_OF_PDA_SEEDS_EXCEEDED, {
+        actual: seeds.length,
+        maxSeeds: MAX_SEEDS
+      });
     }
     let textEncoder;
     const seedBytes = seeds.reduce((acc, seed, ii) => {
       const bytes = typeof seed === "string" ? (textEncoder || (textEncoder = new TextEncoder())).encode(seed) : seed;
       if (bytes.byteLength > MAX_SEED_LENGTH) {
-        throw new Error(`The seed at index ${ii} exceeds the maximum length of 32 bytes`);
+        throw new SolanaError(SOLANA_ERROR__MAX_PDA_SEED_LENGTH_EXCEEDED, {
+          actual: bytes.byteLength,
+          index: ii,
+          maxSeedLength: MAX_SEED_LENGTH
+        });
       }
       acc.push(...bytes);
       return acc;
@@ -1241,7 +1850,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     );
     const addressBytes = new Uint8Array(addressBytesBuffer);
     if (await compressedPointBytesAreOnCurve(addressBytes)) {
-      throw new PointOnCurveError("Invalid seeds; point must fall off the Ed25519 curve");
+      throw new SolanaError(SOLANA_ERROR__INVALID_SEEDS_POINT_ON_CURVE);
     }
     return base58EncodedAddressCodec.decode(addressBytes);
   }
@@ -1258,24 +1867,28 @@ this.globalThis.solanaWeb3 = (function (exports) {
         });
         return [address2, bumpSeed];
       } catch (e4) {
-        if (e4 instanceof PointOnCurveError) {
+        if (isSolanaError(e4, SOLANA_ERROR__INVALID_SEEDS_POINT_ON_CURVE)) {
           bumpSeed--;
         } else {
           throw e4;
         }
       }
     }
-    throw new Error("Unable to find a viable program address bump seed");
+    throw new SolanaError(SOLANA_ERROR__COULD_NOT_FIND_VIABLE_PDA_BUMP_SEED);
   }
   async function createAddressWithSeed({ baseAddress, programAddress, seed }) {
     const { encode, decode } = getAddressCodec();
     const seedBytes = typeof seed === "string" ? new TextEncoder().encode(seed) : seed;
     if (seedBytes.byteLength > MAX_SEED_LENGTH) {
-      throw new Error(`The seed exceeds the maximum length of 32 bytes`);
+      throw new SolanaError(SOLANA_ERROR__MAX_PDA_SEED_LENGTH_EXCEEDED, {
+        actual: seedBytes.byteLength,
+        index: 0,
+        maxSeedLength: MAX_SEED_LENGTH
+      });
     }
     const programAddressBytes = encode(programAddress);
     if (programAddressBytes.length >= PDA_MARKER_BYTES.length && programAddressBytes.slice(-PDA_MARKER_BYTES.length).every((byte, index) => byte === PDA_MARKER_BYTES[index])) {
-      throw new Error(`programAddress cannot end with the PDA marker`);
+      throw new SolanaError(SOLANA_ERROR__PROGRAM_ADDRESS_ENDS_WITH_PDA_MARKER);
     }
     const addressBytesBuffer = await crypto.subtle.digest(
       "SHA-256",
@@ -1287,7 +1900,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   async function getAddressFromPublicKey(publicKey) {
     await assertKeyExporterIsAvailable();
     if (publicKey.type !== "public" || publicKey.algorithm.name !== "Ed25519") {
-      throw new Error("The `CryptoKey` must be an `Ed25519` public key");
+      throw new SolanaError(SOLANA_ERROR__NOT_AN_ED25519_PUBLIC_KEY);
     }
     const publicKeyBytes = await crypto.subtle.exportKey("raw", publicKey);
     return getAddressDecoder().decode(new Uint8Array(publicKeyBytes));
@@ -1297,7 +1910,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) {
@@ -1443,13 +2060,33 @@ 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.");
+    try {
+      assertIsFixedSize(size);
+    } catch (e4) {
+      if (isSolanaError(e4, SOLANA_ERROR__CODECS_EXPECTED_FIXED_LENGTH_GOT_VARIABLE_LENGTH)) {
+        throw new SolanaError(SOLANA_ERROR__CODECS_CODEC_REQUIRES_FIXED_SIZE, {
+          codecDescription: "bool"
+        });
+      } else {
+        throw e4;
+      }
+    }
     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.");
+    try {
+      assertIsFixedSize(size);
+    } catch (e4) {
+      if (isSolanaError(e4, SOLANA_ERROR__CODECS_EXPECTED_FIXED_LENGTH_GOT_VARIABLE_LENGTH)) {
+        throw new SolanaError(SOLANA_ERROR__CODECS_CODEC_REQUIRES_FIXED_SIZE, {
+          codecDescription: "bool"
+        });
+      } else {
+        throw e4;
+      }
+    }
     return mapDecoder(size, (value) => Number(value) === 1);
   }
   function getBooleanCodec(config = {}) {
@@ -1545,9 +2182,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;
@@ -1556,7 +2195,10 @@ this.globalThis.solanaWeb3 = (function (exports) {
     });
   }
   function getDataEnumCodec(variants, config = {}) {
-    return combineCodec(getDataEnumEncoder(variants, config), getDataEnumDecoder(variants, config));
+    return combineCodec(
+      getDataEnumEncoder(variants, config),
+      getDataEnumDecoder(variants, config)
+    );
   }
   function getDataEnumFixedSize(variants, prefix) {
     if (variants.length === 0)
@@ -1579,9 +2221,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;
   }
@@ -1647,8 +2290,24 @@ 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.");
+      try {
+        assertIsFixedSize(item);
+      } catch (e4) {
+        if (isSolanaError(e4, SOLANA_ERROR__CODECS_EXPECTED_FIXED_LENGTH_GOT_VARIABLE_LENGTH)) {
+          throw new SolanaError(SOLANA_ERROR__CODECS_FIXED_NULLABLE_WITH_VARIABLE_SIZE_CODEC);
+        } else {
+          throw e4;
+        }
+      }
+      try {
+        assertIsFixedSize(prefix);
+      } catch (e4) {
+        if (isSolanaError(e4, SOLANA_ERROR__CODECS_EXPECTED_FIXED_LENGTH_GOT_VARIABLE_LENGTH)) {
+          throw new SolanaError(SOLANA_ERROR__CODECS_FIXED_NULLABLE_WITH_VARIABLE_SIZE_PREFIX);
+        } else {
+          throw e4;
+        }
+      }
       const fixedSize = prefix.fixedSize + item.fixedSize;
       return createEncoder({
         fixedSize,
@@ -1680,8 +2339,24 @@ 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.");
+      try {
+        assertIsFixedSize(item);
+      } catch (e4) {
+        if (isSolanaError(e4, SOLANA_ERROR__CODECS_EXPECTED_FIXED_LENGTH_GOT_VARIABLE_LENGTH)) {
+          throw new SolanaError(SOLANA_ERROR__CODECS_FIXED_NULLABLE_WITH_VARIABLE_SIZE_CODEC);
+        } else {
+          throw e4;
+        }
+      }
+      try {
+        assertIsFixedSize(prefix);
+      } catch (e4) {
+        if (isSolanaError(e4, SOLANA_ERROR__CODECS_EXPECTED_FIXED_LENGTH_GOT_VARIABLE_LENGTH)) {
+          throw new SolanaError(SOLANA_ERROR__CODECS_FIXED_NULLABLE_WITH_VARIABLE_SIZE_PREFIX);
+        } else {
+          throw e4;
+        }
+      }
       fixedSize = prefix.fixedSize + item.fixedSize;
     }
     return createDecoder({
@@ -1711,9 +2386,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;
@@ -1730,9 +2408,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]];
     });
@@ -1806,7 +2486,10 @@ this.globalThis.solanaWeb3 = (function (exports) {
     });
   }
   function getStructCodec(fields) {
-    return combineCodec(getStructEncoder(fields), getStructDecoder(fields));
+    return combineCodec(
+      getStructEncoder(fields),
+      getStructDecoder(fields)
+    );
   }
   function getUnitEncoder() {
     return createEncoder({
@@ -1843,8 +2526,16 @@ 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.");
+      try {
+        assertIsFixedSize(item);
+      } catch (e4) {
+        throw new Error("Fixed options can only be used with fixed-size codecs.");
+      }
+      try {
+        assertIsFixedSize(prefix);
+      } catch (e4) {
+        throw new Error("Fixed options can only be used with fixed-size prefix.");
+      }
       const fixedSize = prefix.fixedSize + item.fixedSize;
       return createEncoder({
         fixedSize,
@@ -1881,8 +2572,16 @@ 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.");
+      try {
+        assertIsFixedSize(item);
+      } catch (e4) {
+        throw new Error("Fixed options can only be used with fixed-size codecs.");
+      }
+      try {
+        assertIsFixedSize(prefix);
+      } catch (e4) {
+        throw new Error("Fixed options can only be used with fixed-size prefix.");
+      }
       fixedSize = prefix.fixedSize + item.fixedSize;
     }
     return createDecoder({
@@ -1937,6 +2636,29 @@ this.globalThis.solanaWeb3 = (function (exports) {
 
   // ../instructions/dist/index.browser.js
   init_env_shim();
+  function isInstructionWithAccounts(instruction) {
+    return instruction.accounts !== void 0;
+  }
+  function assertIsInstructionWithAccounts(instruction) {
+    if (instruction.accounts === void 0) {
+      throw new SolanaError(SOLANA_ERROR__EXPECTED_INSTRUCTION_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__EXPECTED_INSTRUCTION_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";
@@ -1974,52 +2696,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
 
   // ../keys/dist/index.browser.js
   init_env_shim();
-
-  // ../errors/dist/index.browser.js
-  init_env_shim();
-  var SOLANA_ERROR__TRANSACTION_MISSING_SIGNATURES = 1;
-  var SOLANA_ERROR__TRANSACTION_SIGNATURE_NOT_COMPUTABLE = 2;
-  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;
-  var SOLANA_ERROR__NONCE_ACCOUNT_NOT_FOUND = 7;
-  var SolanaErrorMessages = {
-    [SOLANA_ERROR__BLOCK_HEIGHT_EXCEEDED]: "The network has progressed past the last block for which this transaction could have been committed.",
-    [SOLANA_ERROR__INVALID_KEYPAIR_BYTES]: "Key pair bytes must be of length 64, got $byteLength.",
-    [SOLANA_ERROR__NONCE_ACCOUNT_NOT_FOUND]: "No nonce account could be found at address `$nonceAccountAddress`",
-    [SOLANA_ERROR__NONCE_INVALID]: "The nonce `$expectedNonceValue` is no longer valid. It has advanced to `$actualNonceValue`",
-    [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__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."
-  };
-  function getHumanReadableErrorMessage(code, context = {}) {
-    const messageFormatString = SolanaErrorMessages[code];
-    const message = messageFormatString.replace(
-      new RegExp("(?<!\\\\)\\$(\\w+)", "g"),
-      (substring, variableName) => variableName in context ? `${context[variableName]}` : substring
-    );
-    return message;
-  }
-  function getErrorMessage(code, context = {}) {
-    {
-      return getHumanReadableErrorMessage(code, context);
-    }
-  }
-  var SolanaError = class extends Error {
-    constructor(...[code, context]) {
-      const message = getErrorMessage(code, context);
-      super(message);
-      __publicField(this, "context");
-      this.context = {
-        __code: code,
-        ...context
-      };
-      this.name = "SolanaError";
-    }
-  };
-
-  // ../keys/dist/index.browser.js
   function addPkcs8Header(bytes) {
     return new Uint8Array([
       /**
@@ -2719,17 +3395,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,
@@ -2750,9 +3415,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
     "keep-alive": true,
     origin: true,
     "permissions-policy": true,
-    // No currently available Typescript technique allows you to match on a prefix.
-    // 'proxy-':true,
-    // 'sec-':true,
+    // Prefix matching is implemented in code, below.
+    // 'proxy-': true,
+    // 'sec-': true,
     referer: true,
     te: true,
     trailer: true,
@@ -2766,9 +3431,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) {
@@ -2778,10 +3443,25 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
     return out;
   }
-  function createHttpTransport({ headers, url }) {
+  var didWarnDispatcherWasSuppliedInNonNodeEnvironment = false;
+  function warnDispatcherWasSuppliedInNonNodeEnvironment() {
+    if (didWarnDispatcherWasSuppliedInNonNodeEnvironment) {
+      return;
+    }
+    didWarnDispatcherWasSuppliedInNonNodeEnvironment = true;
+    console.warn(
+      "You have supplied a `Dispatcher` to `createHttpTransport()`. It has been ignored because Undici dispatchers only work in Node environments. To eliminate this warning, omit the `dispatcher_NODE_ONLY` property from your config when running in a non-Node environment."
+    );
+  }
+  function createHttpTransport(config) {
+    if ("dispatcher_NODE_ONLY" in config) {
+      warnDispatcherWasSuppliedInNonNodeEnvironment();
+    }
+    const { headers, url } = config;
     if (headers) {
       assertIsAllowedHttpRequestHeaders(headers);
     }
+    let dispatcherConfig;
     const customHeaders = headers && normalizeHeaders(headers);
     return async function makeHttpRequest({
       payload,
@@ -2789,6 +3469,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }) {
       const body = JSON.stringify(payload);
       const requestInfo = {
+        ...dispatcherConfig,
         body,
         headers: {
           ...customHeaders,
@@ -2802,7 +3483,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
         });
@@ -2855,6 +3536,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
     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" 
+  );
   function getRpcTransportWithRequestCoalescing(transport, getDeduplicationKey) {
     let coalescedRequestsByDeduplicationKey;
     return async function makeCoalescedHttpRequest(config) {
@@ -2878,7 +3562,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
               signal: abortController.signal
             });
           } catch (e4) {
-            if (e4 && typeof e4 === "object" && "name" in e4 && e4.name === "AbortError") {
+            if (e4 === EXPLICIT_ABORT_TOKEN) {
               return;
             }
             throw e4;
@@ -2900,10 +3584,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
             coalescedRequest.numConsumers -= 1;
             if (coalescedRequest.numConsumers === 0) {
               const abortController = coalescedRequest.abortController;
-              abortController.abort();
+              abortController.abort(EXPLICIT_ABORT_TOKEN);
             }
-            const abortError = new DOMException(e4.target.reason, "AbortError");
-            reject(abortError);
+            reject(e4.target.reason);
           };
           signal.addEventListener("abort", handleAbort);
           responsePromise.then(resolve).finally(() => {
@@ -3275,7 +3958,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   // ../rpc-subscriptions-transport-websocket/dist/index.browser.js
   init_env_shim();
   var e3 = globalThis.WebSocket;
-  var EXPLICIT_ABORT_TOKEN = Symbol(
+  var EXPLICIT_ABORT_TOKEN2 = Symbol(
     "This symbol is thrown from a socket's iterator when the connection is explicitly aborted by the user" 
   );
   async function createWebSocketConnection({
@@ -3297,7 +3980,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
         });
       }
       function handleAbort() {
-        errorAndClearAllIteratorStates(EXPLICIT_ABORT_TOKEN);
+        errorAndClearAllIteratorStates(EXPLICIT_ABORT_TOKEN2);
         if (webSocket.readyState !== e3.CLOSED && webSocket.readyState !== e3.CLOSING) {
           webSocket.close(1e3);
         }
@@ -3385,7 +4068,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
                       });
                     });
                   } catch (e22) {
-                    if (e22 === EXPLICIT_ABORT_TOKEN) {
+                    if (e22 === EXPLICIT_ABORT_TOKEN2) {
                       return;
                     } else {
                       throw new Error("WebSocket connection closed", { cause: e22 });
@@ -3558,7 +4241,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
       }
     };
   }
-  var EXPLICIT_ABORT_TOKEN2 = Symbol(
+  var EXPLICIT_ABORT_TOKEN3 = Symbol(
     "This symbol is thrown from a subscription's iterator when the subscription is explicitly aborted by the user" 
   );
   function registerIterableCleanup22(iterable, cleanupFn) {
@@ -3629,9 +4312,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
               return {
                 ...iterable,
                 async *[Symbol.asyncIterator]() {
-                  abortPromise || (abortPromise = abortSignal.aborted ? Promise.reject(EXPLICIT_ABORT_TOKEN2) : new Promise((_, reject) => {
+                  abortPromise || (abortPromise = abortSignal.aborted ? Promise.reject(EXPLICIT_ABORT_TOKEN3) : new Promise((_, reject) => {
                     abortSignal.addEventListener("abort", () => {
-                      reject(EXPLICIT_ABORT_TOKEN2);
+                      reject(EXPLICIT_ABORT_TOKEN3);
                     });
                   }));
                   try {
@@ -3645,7 +4328,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
                       }
                     }
                   } catch (e4) {
-                    if (e4 === EXPLICIT_ABORT_TOKEN2) {
+                    if (e4 === EXPLICIT_ABORT_TOKEN3) {
                       return;
                     }
                     cache.delete(deduplicationKey);
@@ -3791,22 +4474,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
       });
     }
   }
@@ -3844,11 +4525,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) {
@@ -3885,9 +4563,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
       });
     }
   }
@@ -3900,7 +4578,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) {
@@ -3914,13 +4594,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
       });
     }
   }
@@ -3938,22 +4614,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
       });
     }
   }
@@ -3982,7 +4656,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   function assertIsTransactionWithBlockhashLifetime(transaction) {
     if (!isTransactionWithBlockhashLifetime(transaction)) {
-      throw new Error("Transaction does not have a blockhash lifetime");
+      throw new SolanaError(SOLANA_ERROR__TRANSACTION_EXPECTED_BLOCKHASH_LIFETIME);
     }
   }
   function setTransactionLifetimeUsingBlockhash(blockhashLifetimeConstraint, transaction) {
@@ -4031,7 +4705,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   var SYSTEM_PROGRAM_ADDRESS = "11111111111111111111111111111111";
   function assertIsDurableNonceTransaction(transaction) {
     if (!isDurableNonceTransaction(transaction)) {
-      throw new Error("Transaction is not a durable nonce transaction");
+      throw new SolanaError(SOLANA_ERROR__TRANSACTION_EXPECTED_NONCE_LIFETIME);
     }
   }
   function createAdvanceNonceAccountInstruction(nonceAccountAddress, nonceAuthorityAddress) {
@@ -4175,8 +4849,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
     const compiledAddressTableLookupAddresses = compiledAddressTableLookups.map((l) => l.lookupTableAddress);
     const missing = compiledAddressTableLookupAddresses.filter((a) => addressesByLookupTableAddress[a] === void 0);
     if (missing.length > 0) {
-      const missingAddresses = missing.join(", ");
-      throw new Error(`Addresses not provided for lookup tables: [${missingAddresses}]`);
+      throw new SolanaError(SOLANA_ERROR__TRANSACTION_FAILED_TO_DECOMPILE_ADDRESS_LOOKUP_TABLE_CONTENTS_MISSING, {
+        lookupTableAddresses: missing
+      });
     }
     const readOnlyMetas = [];
     const writableMetas = [];
@@ -4184,8 +4859,13 @@ this.globalThis.solanaWeb3 = (function (exports) {
       const addresses = addressesByLookupTableAddress[lookup.lookupTableAddress];
       const highestIndex = Math.max(...lookup.readableIndices, ...lookup.writableIndices);
       if (highestIndex >= addresses.length) {
-        throw new Error(
-          `Cannot look up index ${highestIndex} in lookup table [${lookup.lookupTableAddress}]. The lookup table may have been extended since the addresses provided were retrieved.`
+        throw new SolanaError(
+          SOLANA_ERROR__TRANSACTION_FAILED_TO_DECOMPILE_ADDRESS_LOOKUP_TABLE_INDEX_OUT_OF_RANGE,
+          {
+            highestKnownIndex: addresses.length - 1,
+            highestRequestedIndex: highestIndex,
+            lookupTableAddress: lookup.lookupTableAddress
+          }
         );
       }
       const readOnlyForLookup = lookup.readableIndices.map((r) => ({
@@ -4209,7 +4889,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
     var _a, _b;
     const programAddress = (_a = accountMetas[instruction.programAddressIndex]) == null ? void 0 : _a.address;
     if (!programAddress) {
-      throw new Error(`Could not find program address at index ${instruction.programAddressIndex}`);
+      throw new SolanaError(SOLANA_ERROR__TRANSACTION_FAILED_TO_DECOMPILE_INSTRUCTION_PROGRAM_ADDRESS_NOT_FOUND, {
+        index: instruction.programAddressIndex
+      });
     }
     const accounts = (_b = instruction.accountIndices) == null ? void 0 : _b.map((accountIndex) => accountMetas[accountIndex]);
     const { data } = instruction;
@@ -4255,8 +4937,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
     var _a;
     const { compiledMessage } = compiledTransaction;
     const feePayer = compiledMessage.staticAccounts[0];
-    if (!feePayer)
-      throw new Error("No fee payer set in CompiledTransaction");
+    if (!feePayer) {
+      throw new SolanaError(SOLANA_ERROR__TRANSACTION_FAILED_TO_DECOMPILE_FEE_PAYER_MISSING);
+    }
     const accountMetas = getAccountMetas(compiledMessage);
     const accountLookupMetas = "addressTableLookups" in compiledMessage && compiledMessage.addressTableLookups !== void 0 && compiledMessage.addressTableLookups.length > 0 ? getAddressLookupMetas(compiledMessage.addressTableLookups, (_a = config == null ? void 0 : config.addressesByLookupTableAddress) != null ? _a : {}) : [];
     const transactionMetas = [...accountMetas, ...accountLookupMetas];
@@ -4297,13 +4980,13 @@ this.globalThis.solanaWeb3 = (function (exports) {
           if (isWritableRole2(entry.role)) {
             switch (entry[TYPE]) {
               case 0:
-                throw new Error(
-                  `This transaction includes an address (\`${instruction.programAddress}\`) which is both invoked and set as the fee payer. Program addresses may not pay fees.`
-                );
+                throw new SolanaError(SOLANA_ERROR__TRANSACTION_INVOKED_PROGRAMS_CANNOT_PAY_FEES, {
+                  programAddress: instruction.programAddress
+                });
               default:
-                throw new Error(
-                  `This transaction includes an address (\`${instruction.programAddress}\`) which is both invoked and marked writable. Program addresses may not be writable.`
-                );
+                throw new SolanaError(SOLANA_ERROR__TRANSACTION_INVOKED_PROGRAMS_MUST_NOT_BE_WRITABLE, {
+                  programAddress: instruction.programAddress
+                });
             }
           }
           if (entry[TYPE] === 2) {
@@ -4368,8 +5051,11 @@ this.globalThis.solanaWeb3 = (function (exports) {
                   addressesOfInvokedPrograms.has(account.address)
                 ) {
                   if (isWritableRole2(accountMeta.role)) {
-                    throw new Error(
-                      `This transaction includes an address (\`${account.address}\`) which is both invoked and marked writable. Program addresses may not be writable.`
+                    throw new SolanaError(
+                      SOLANA_ERROR__TRANSACTION_INVOKED_PROGRAMS_MUST_NOT_BE_WRITABLE,
+                      {
+                        programAddress: account.address
+                      }
                     );
                   }
                   if (entry.role !== nextRole) {
@@ -4653,7 +5339,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
           return offset;
         }
         if (value < 0 || value > 127) {
-          throw new Error(`Transaction version must be in the range [0, 127]. \`${value}\` given.`);
+          throw new SolanaError(SOLANA_ERROR__TRANSACTION_VERSION_NUMBER_OUT_OF_RANGE, {
+            actualVersion: value
+          });
         }
         bytes.set([value | VERSION_FLAG_MASK], offset);
         return offset + 1;
@@ -4739,12 +5427,15 @@ this.globalThis.solanaWeb3 = (function (exports) {
     });
   }
   function getCompiledMessageDecoder() {
-    return mapDecoder(getStructDecoder(getPreludeStructDecoderTuple()), ({ addressTableLookups, ...restOfMessage }) => {
-      if (restOfMessage.version === "legacy" || !(addressTableLookups == null ? void 0 : addressTableLookups.length)) {
-        return restOfMessage;
+    return mapDecoder(
+      getStructDecoder(getPreludeStructDecoderTuple()),
+      ({ addressTableLookups, ...restOfMessage }) => {
+        if (restOfMessage.version === "legacy" || !(addressTableLookups == null ? void 0 : addressTableLookups.length)) {
+          return restOfMessage;
+        }
+        return { ...restOfMessage, addressTableLookups };
       }
-      return { ...restOfMessage, addressTableLookups };
-    });
+    );
   }
   function getCompiledMessageCodec() {
     return combineCodec(getCompiledMessageEncoder(), getCompiledMessageDecoder());
@@ -4861,9 +5552,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);
@@ -4926,7 +5617,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) {
@@ -4934,7 +5627,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) {
@@ -4942,7 +5637,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) {
@@ -4975,7 +5672,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) {
@@ -4983,7 +5682,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) {
@@ -4999,7 +5700,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) {
@@ -5007,7 +5710,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) {
@@ -5015,7 +5720,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 = {}) {
@@ -5043,9 +5750,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 });
@@ -5130,17 +5835,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);
     }
   }
 
@@ -5285,9 +5986,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
       const signatureDidCommitPromise = (async () => {
         for await (const signatureStatusNotification of signatureStatusNotifications) {
           if (signatureStatusNotification.value.err) {
-            throw new Error(`The transaction with signature \`${signature2}\` failed.`, {
-              cause: signatureStatusNotification.value.err
-            });
+            throw getSolanaErrorFromTransactionError(signatureStatusNotification.value.err);
           } else {
             return;
           }
@@ -5653,6 +6352,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.assertIsBlockhash = assertIsBlockhash;
   exports.assertIsDurableNonceTransaction = assertIsDurableNonceTransaction;
   exports.assertIsFixedSize = assertIsFixedSize;
+  exports.assertIsInstructionWithAccounts = assertIsInstructionWithAccounts;
+  exports.assertIsInstructionWithData = assertIsInstructionWithData;
   exports.assertIsKeyPairSigner = assertIsKeyPairSigner;
   exports.assertIsLamports = assertIsLamports;
   exports.assertIsMessageModifyingSigner = assertIsMessageModifyingSigner;
@@ -5840,6 +6541,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.isAddress = isAddress;
   exports.isAdvanceNonceAccountInstruction = isAdvanceNonceAccountInstruction;
   exports.isFixedSize = isFixedSize;
+  exports.isInstructionWithAccounts = isInstructionWithAccounts;
+  exports.isInstructionWithData = isInstructionWithData;
   exports.isKeyPairSigner = isKeyPairSigner;
   exports.isLamports = isLamports;
   exports.isMessageModifyingSigner = isMessageModifyingSigner;