@pooflabs/web 0.0.73 → 0.0.75

package/dist/privy-wallet-provider-CFuoQYuv.esm.js

@@ -0,0 +1,3921 @@
+import { S as SOLANA_MAINNET_RPC_URL, a as SOLANA_DEVNET_RPC_URL, W as WebSessionManager, c as convertRemainingAccounts, b as buildSetDocumentsTransaction, d as bs58, e as confirmAndCheckTransaction, s as setCurrentUser, g as getPlatform, f as createSessionWithPrivy } from './index.native-BB7er4-z.esm.js';
+import { Connection, VersionedTransaction, PublicKey, Transaction } from '@solana/web3.js';
+import * as anchor from '@coral-xyz/anchor';
+import 'axios';
+import 'react';
+
+// src/codes.ts
+var SOLANA_ERROR__BLOCK_HEIGHT_EXCEEDED = 1;
+var SOLANA_ERROR__INVALID_NONCE = 2;
+var SOLANA_ERROR__NONCE_ACCOUNT_NOT_FOUND = 3;
+var SOLANA_ERROR__BLOCKHASH_STRING_LENGTH_OUT_OF_RANGE = 4;
+var SOLANA_ERROR__INVALID_BLOCKHASH_BYTE_LENGTH = 5;
+var SOLANA_ERROR__LAMPORTS_OUT_OF_RANGE = 6;
+var SOLANA_ERROR__MALFORMED_BIGINT_STRING = 7;
+var SOLANA_ERROR__MALFORMED_NUMBER_STRING = 8;
+var SOLANA_ERROR__TIMESTAMP_OUT_OF_RANGE = 9;
+var SOLANA_ERROR__MALFORMED_JSON_RPC_ERROR = 10;
+var SOLANA_ERROR__JSON_RPC__PARSE_ERROR = -32700;
+var SOLANA_ERROR__JSON_RPC__INTERNAL_ERROR = -32603;
+var SOLANA_ERROR__JSON_RPC__INVALID_PARAMS = -32602;
+var SOLANA_ERROR__JSON_RPC__METHOD_NOT_FOUND = -32601;
+var SOLANA_ERROR__JSON_RPC__INVALID_REQUEST = -32600;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_LONG_TERM_STORAGE_UNREACHABLE = -32019;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SLOT_NOT_EPOCH_BOUNDARY = -32018;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_EPOCH_REWARDS_PERIOD_ACTIVE = -32017;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_MIN_CONTEXT_SLOT_NOT_REACHED = -32016;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_UNSUPPORTED_TRANSACTION_VERSION = -32015;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_BLOCK_STATUS_NOT_AVAILABLE_YET = -32014;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_TRANSACTION_SIGNATURE_LEN_MISMATCH = -32013;
+var SOLANA_ERROR__JSON_RPC__SCAN_ERROR = -32012;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_TRANSACTION_HISTORY_NOT_AVAILABLE = -32011;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_KEY_EXCLUDED_FROM_SECONDARY_INDEX = -32010;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_LONG_TERM_STORAGE_SLOT_SKIPPED = -32009;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_NO_SNAPSHOT = -32008;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SLOT_SKIPPED = -32007;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_TRANSACTION_PRECOMPILE_VERIFICATION_FAILURE = -32006;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_NODE_UNHEALTHY = -32005;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_BLOCK_NOT_AVAILABLE = -32004;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_TRANSACTION_SIGNATURE_VERIFICATION_FAILURE = -32003;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE = -32002;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_BLOCK_CLEANED_UP = -32001;
+var SOLANA_ERROR__ADDRESSES__INVALID_BYTE_LENGTH = 28e5;
+var SOLANA_ERROR__ADDRESSES__STRING_LENGTH_OUT_OF_RANGE = 2800001;
+var SOLANA_ERROR__ADDRESSES__INVALID_BASE58_ENCODED_ADDRESS = 2800002;
+var SOLANA_ERROR__ADDRESSES__INVALID_ED25519_PUBLIC_KEY = 2800003;
+var SOLANA_ERROR__ADDRESSES__MALFORMED_PDA = 2800004;
+var SOLANA_ERROR__ADDRESSES__PDA_BUMP_SEED_OUT_OF_RANGE = 2800005;
+var SOLANA_ERROR__ADDRESSES__MAX_NUMBER_OF_PDA_SEEDS_EXCEEDED = 2800006;
+var SOLANA_ERROR__ADDRESSES__MAX_PDA_SEED_LENGTH_EXCEEDED = 2800007;
+var SOLANA_ERROR__ADDRESSES__INVALID_SEEDS_POINT_ON_CURVE = 2800008;
+var SOLANA_ERROR__ADDRESSES__FAILED_TO_FIND_VIABLE_PDA_BUMP_SEED = 2800009;
+var SOLANA_ERROR__ADDRESSES__PDA_ENDS_WITH_PDA_MARKER = 2800010;
+var SOLANA_ERROR__ADDRESSES__INVALID_OFF_CURVE_ADDRESS = 2800011;
+var SOLANA_ERROR__ACCOUNTS__ACCOUNT_NOT_FOUND = 323e4;
+var SOLANA_ERROR__ACCOUNTS__ONE_OR_MORE_ACCOUNTS_NOT_FOUND = 32300001;
+var SOLANA_ERROR__ACCOUNTS__FAILED_TO_DECODE_ACCOUNT = 3230002;
+var SOLANA_ERROR__ACCOUNTS__EXPECTED_DECODED_ACCOUNT = 3230003;
+var SOLANA_ERROR__ACCOUNTS__EXPECTED_ALL_ACCOUNTS_TO_BE_DECODED = 3230004;
+var SOLANA_ERROR__SUBTLE_CRYPTO__DISALLOWED_IN_INSECURE_CONTEXT = 361e4;
+var SOLANA_ERROR__SUBTLE_CRYPTO__DIGEST_UNIMPLEMENTED = 3610001;
+var SOLANA_ERROR__SUBTLE_CRYPTO__ED25519_ALGORITHM_UNIMPLEMENTED = 3610002;
+var SOLANA_ERROR__SUBTLE_CRYPTO__EXPORT_FUNCTION_UNIMPLEMENTED = 3610003;
+var SOLANA_ERROR__SUBTLE_CRYPTO__GENERATE_FUNCTION_UNIMPLEMENTED = 3610004;
+var SOLANA_ERROR__SUBTLE_CRYPTO__SIGN_FUNCTION_UNIMPLEMENTED = 3610005;
+var SOLANA_ERROR__SUBTLE_CRYPTO__VERIFY_FUNCTION_UNIMPLEMENTED = 3610006;
+var SOLANA_ERROR__SUBTLE_CRYPTO__CANNOT_EXPORT_NON_EXTRACTABLE_KEY = 3610007;
+var SOLANA_ERROR__CRYPTO__RANDOM_VALUES_FUNCTION_UNIMPLEMENTED = 3611e3;
+var SOLANA_ERROR__KEYS__INVALID_KEY_PAIR_BYTE_LENGTH = 3704e3;
+var SOLANA_ERROR__KEYS__INVALID_PRIVATE_KEY_BYTE_LENGTH = 3704001;
+var SOLANA_ERROR__KEYS__INVALID_SIGNATURE_BYTE_LENGTH = 3704002;
+var SOLANA_ERROR__KEYS__SIGNATURE_STRING_LENGTH_OUT_OF_RANGE = 3704003;
+var SOLANA_ERROR__KEYS__PUBLIC_KEY_MUST_MATCH_PRIVATE_KEY = 3704004;
+var SOLANA_ERROR__INSTRUCTION__EXPECTED_TO_HAVE_ACCOUNTS = 4128e3;
+var SOLANA_ERROR__INSTRUCTION__EXPECTED_TO_HAVE_DATA = 4128001;
+var SOLANA_ERROR__INSTRUCTION__PROGRAM_ID_MISMATCH = 4128002;
+var SOLANA_ERROR__INSTRUCTION_ERROR__UNKNOWN = 4615e3;
+var SOLANA_ERROR__INSTRUCTION_ERROR__GENERIC_ERROR = 4615001;
+var SOLANA_ERROR__INSTRUCTION_ERROR__INVALID_ARGUMENT = 4615002;
+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__SIGNER__WALLET_MULTISIGN_UNIMPLEMENTED = 5508011;
+var SOLANA_ERROR__TRANSACTION__INVOKED_PROGRAMS_CANNOT_PAY_FEES = 5663e3;
+var SOLANA_ERROR__TRANSACTION__INVOKED_PROGRAMS_MUST_NOT_BE_WRITABLE = 5663001;
+var SOLANA_ERROR__TRANSACTION__EXPECTED_BLOCKHASH_LIFETIME = 5663002;
+var SOLANA_ERROR__TRANSACTION__EXPECTED_NONCE_LIFETIME = 5663003;
+var SOLANA_ERROR__TRANSACTION__VERSION_NUMBER_OUT_OF_RANGE = 5663004;
+var SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_ADDRESS_LOOKUP_TABLE_CONTENTS_MISSING = 5663005;
+var SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_ADDRESS_LOOKUP_TABLE_INDEX_OUT_OF_RANGE = 5663006;
+var SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_INSTRUCTION_PROGRAM_ADDRESS_NOT_FOUND = 5663007;
+var SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_FEE_PAYER_MISSING = 5663008;
+var SOLANA_ERROR__TRANSACTION__SIGNATURES_MISSING = 5663009;
+var SOLANA_ERROR__TRANSACTION__ADDRESS_MISSING = 5663010;
+var SOLANA_ERROR__TRANSACTION__FEE_PAYER_MISSING = 5663011;
+var SOLANA_ERROR__TRANSACTION__FEE_PAYER_SIGNATURE_MISSING = 5663012;
+var SOLANA_ERROR__TRANSACTION__INVALID_NONCE_TRANSACTION_INSTRUCTIONS_MISSING = 5663013;
+var SOLANA_ERROR__TRANSACTION__INVALID_NONCE_TRANSACTION_FIRST_INSTRUCTION_MUST_BE_ADVANCE_NONCE = 5663014;
+var SOLANA_ERROR__TRANSACTION__ADDRESSES_CANNOT_SIGN_TRANSACTION = 5663015;
+var SOLANA_ERROR__TRANSACTION__CANNOT_ENCODE_WITH_EMPTY_SIGNATURES = 5663016;
+var SOLANA_ERROR__TRANSACTION__MESSAGE_SIGNATURES_MISMATCH = 5663017;
+var SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT = 5663018;
+var SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT = 5663019;
+var SOLANA_ERROR__TRANSACTION__EXCEEDS_SIZE_LIMIT = 5663020;
+var SOLANA_ERROR__TRANSACTION__VERSION_NUMBER_NOT_SUPPORTED = 5663021;
+var SOLANA_ERROR__TRANSACTION__NONCE_ACCOUNT_CANNOT_BE_IN_LOOKUP_TABLE = 5663022;
+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 SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN = 7618e3;
+var SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_PACKER_ALREADY_COMPLETE = 7618001;
+var SOLANA_ERROR__INSTRUCTION_PLANS__EMPTY_INSTRUCTION_PLAN = 7618002;
+var SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN = 7618003;
+var SOLANA_ERROR__CODECS__CANNOT_DECODE_EMPTY_BYTE_ARRAY = 8078e3;
+var SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH = 8078001;
+var SOLANA_ERROR__CODECS__EXPECTED_FIXED_LENGTH = 8078002;
+var SOLANA_ERROR__CODECS__EXPECTED_VARIABLE_LENGTH = 8078003;
+var SOLANA_ERROR__CODECS__ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH = 8078004;
+var SOLANA_ERROR__CODECS__ENCODER_DECODER_FIXED_SIZE_MISMATCH = 8078005;
+var SOLANA_ERROR__CODECS__ENCODER_DECODER_MAX_SIZE_MISMATCH = 8078006;
+var SOLANA_ERROR__CODECS__INVALID_NUMBER_OF_ITEMS = 8078007;
+var SOLANA_ERROR__CODECS__ENUM_DISCRIMINATOR_OUT_OF_RANGE = 8078008;
+var SOLANA_ERROR__CODECS__INVALID_DISCRIMINATED_UNION_VARIANT = 8078009;
+var SOLANA_ERROR__CODECS__INVALID_ENUM_VARIANT = 8078010;
+var SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE = 8078011;
+var SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE = 8078012;
+var SOLANA_ERROR__CODECS__EXPECTED_POSITIVE_BYTE_LENGTH = 8078013;
+var SOLANA_ERROR__CODECS__OFFSET_OUT_OF_RANGE = 8078014;
+var SOLANA_ERROR__CODECS__INVALID_LITERAL_UNION_VARIANT = 8078015;
+var SOLANA_ERROR__CODECS__LITERAL_UNION_DISCRIMINATOR_OUT_OF_RANGE = 8078016;
+var SOLANA_ERROR__CODECS__UNION_VARIANT_OUT_OF_RANGE = 8078017;
+var SOLANA_ERROR__CODECS__INVALID_CONSTANT = 8078018;
+var SOLANA_ERROR__CODECS__EXPECTED_ZERO_VALUE_TO_MATCH_ITEM_FIXED_SIZE = 8078019;
+var SOLANA_ERROR__CODECS__ENCODED_BYTES_MUST_NOT_INCLUDE_SENTINEL = 8078020;
+var SOLANA_ERROR__CODECS__SENTINEL_MISSING_IN_DECODED_BYTES = 8078021;
+var SOLANA_ERROR__CODECS__CANNOT_USE_LEXICAL_VALUES_AS_ENUM_DISCRIMINATORS = 8078022;
+var SOLANA_ERROR__CODECS__EXPECTED_DECODER_TO_CONSUME_ENTIRE_BYTE_ARRAY = 8078023;
+var SOLANA_ERROR__RPC__INTEGER_OVERFLOW = 81e5;
+var SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN = 8100001;
+var SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR = 8100002;
+var SOLANA_ERROR__RPC__API_PLAN_MISSING_FOR_RPC_METHOD = 8100003;
+var SOLANA_ERROR__RPC_SUBSCRIPTIONS__CANNOT_CREATE_SUBSCRIPTION_PLAN = 819e4;
+var SOLANA_ERROR__RPC_SUBSCRIPTIONS__EXPECTED_SERVER_SUBSCRIPTION_ID = 8190001;
+var SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CLOSED_BEFORE_MESSAGE_BUFFERED = 8190002;
+var SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CONNECTION_CLOSED = 8190003;
+var SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_FAILED_TO_CONNECT = 8190004;
+var SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_STATE_MISSING = 99e5;
+var SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_MUST_NOT_POLL_BEFORE_RESOLVING_EXISTING_MESSAGE_PROMISE = 9900001;
+var SOLANA_ERROR__INVARIANT_VIOLATION__CACHED_ABORTABLE_ITERABLE_CACHE_ENTRY_MISSING = 9900002;
+var SOLANA_ERROR__INVARIANT_VIOLATION__SWITCH_MUST_BE_EXHAUSTIVE = 9900003;
+var SOLANA_ERROR__INVARIANT_VIOLATION__DATA_PUBLISHER_CHANNEL_UNIMPLEMENTED = 9900004;
+var SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_INSTRUCTION_PLAN_KIND = 9900005;
+var SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_TRANSACTION_PLAN_KIND = 9900006;
+
+// src/context.ts
+function encodeValue(value) {
+  if (Array.isArray(value)) {
+    const commaSeparatedValues = value.map(encodeValue).join(
+      "%2C%20"
+      /* ", " */
+    );
+    return "%5B" + commaSeparatedValues + /* "]" */
+    "%5D";
+  } else if (typeof value === "bigint") {
+    return `${value}n`;
+  } else {
+    return encodeURIComponent(
+      String(
+        value != null && Object.getPrototypeOf(value) === null ? (
+          // Plain objects with no prototype don't have a `toString` method.
+          // Convert them before stringifying them.
+          { ...value }
+        ) : value
+      )
+    );
+  }
+}
+function encodeObjectContextEntry([key, value]) {
+  return `${key}=${encodeValue(value)}`;
+}
+function encodeContextObject(context) {
+  const searchParamsString = Object.entries(context).map(encodeObjectContextEntry).join("&");
+  return btoa(searchParamsString);
+}
+
+// src/messages.ts
+var SolanaErrorMessages = {
+  [SOLANA_ERROR__ACCOUNTS__ACCOUNT_NOT_FOUND]: "Account not found at address: $address",
+  [SOLANA_ERROR__ACCOUNTS__EXPECTED_ALL_ACCOUNTS_TO_BE_DECODED]: "Not all accounts were decoded. Encoded accounts found at addresses: $addresses.",
+  [SOLANA_ERROR__ACCOUNTS__EXPECTED_DECODED_ACCOUNT]: "Expected decoded account at address: $address",
+  [SOLANA_ERROR__ACCOUNTS__FAILED_TO_DECODE_ACCOUNT]: "Failed to decode account data at address: $address",
+  [SOLANA_ERROR__ACCOUNTS__ONE_OR_MORE_ACCOUNTS_NOT_FOUND]: "Accounts not found at addresses: $addresses",
+  [SOLANA_ERROR__ADDRESSES__FAILED_TO_FIND_VIABLE_PDA_BUMP_SEED]: "Unable to find a viable program address bump seed.",
+  [SOLANA_ERROR__ADDRESSES__INVALID_BASE58_ENCODED_ADDRESS]: "$putativeAddress is not a base58-encoded address.",
+  [SOLANA_ERROR__ADDRESSES__INVALID_BYTE_LENGTH]: "Expected base58 encoded address to decode to a byte array of length 32. Actual length: $actualLength.",
+  [SOLANA_ERROR__ADDRESSES__INVALID_ED25519_PUBLIC_KEY]: "The `CryptoKey` must be an `Ed25519` public key.",
+  [SOLANA_ERROR__ADDRESSES__INVALID_OFF_CURVE_ADDRESS]: "$putativeOffCurveAddress is not a base58-encoded off-curve address.",
+  [SOLANA_ERROR__ADDRESSES__INVALID_SEEDS_POINT_ON_CURVE]: "Invalid seeds; point must fall off the Ed25519 curve.",
+  [SOLANA_ERROR__ADDRESSES__MALFORMED_PDA]: "Expected given program derived address to have the following format: [Address, ProgramDerivedAddressBump].",
+  [SOLANA_ERROR__ADDRESSES__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__ADDRESSES__MAX_PDA_SEED_LENGTH_EXCEEDED]: "The seed at index $index with length $actual exceeds the maximum length of $maxSeedLength bytes.",
+  [SOLANA_ERROR__ADDRESSES__PDA_BUMP_SEED_OUT_OF_RANGE]: "Expected program derived address bump to be in the range [0, 255], got: $bump.",
+  [SOLANA_ERROR__ADDRESSES__PDA_ENDS_WITH_PDA_MARKER]: "Program address cannot end with PDA marker.",
+  [SOLANA_ERROR__ADDRESSES__STRING_LENGTH_OUT_OF_RANGE]: "Expected base58-encoded address string of length in the range [32, 44]. 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_USE_LEXICAL_VALUES_AS_ENUM_DISCRIMINATORS]: "Enum codec cannot use lexical values [$stringValues] as discriminators. Either remove all lexical values or set `useValuesAsDiscriminators` to `false`.",
+  [SOLANA_ERROR__CODECS__ENCODED_BYTES_MUST_NOT_INCLUDE_SENTINEL]: "Sentinel [$hexSentinel] must not be present in encoded bytes [$hexEncodedBytes].",
+  [SOLANA_ERROR__CODECS__ENCODER_DECODER_FIXED_SIZE_MISMATCH]: "Encoder and decoder must have the same fixed size, got [$encoderFixedSize] and [$decoderFixedSize].",
+  [SOLANA_ERROR__CODECS__ENCODER_DECODER_MAX_SIZE_MISMATCH]: "Encoder and decoder must have the same max size, got [$encoderMaxSize] and [$decoderMaxSize].",
+  [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 in [$formattedValidDiscriminators], got $discriminator.",
+  [SOLANA_ERROR__CODECS__EXPECTED_FIXED_LENGTH]: "Expected a fixed-size codec, got a variable-size one.",
+  [SOLANA_ERROR__CODECS__EXPECTED_POSITIVE_BYTE_LENGTH]: "Codec [$codecDescription] expected a positive byte length, got $bytesLength.",
+  [SOLANA_ERROR__CODECS__EXPECTED_VARIABLE_LENGTH]: "Expected a variable-size codec, got a fixed-size one.",
+  [SOLANA_ERROR__CODECS__EXPECTED_ZERO_VALUE_TO_MATCH_ITEM_FIXED_SIZE]: "Codec [$codecDescription] expected zero-value [$hexZeroValue] to have the same size as the provided fixed-size item [$expectedSize bytes].",
+  [SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH]: "Codec [$codecDescription] expected $expected bytes, got $bytesLength.",
+  [SOLANA_ERROR__CODECS__INVALID_CONSTANT]: "Expected byte array constant [$hexConstant] to be present in data [$hexData] at offset [$offset].",
+  [SOLANA_ERROR__CODECS__INVALID_DISCRIMINATED_UNION_VARIANT]: "Invalid discriminated union variant. Expected one of [$variants], got $value.",
+  [SOLANA_ERROR__CODECS__INVALID_ENUM_VARIANT]: "Invalid enum variant. Expected one of [$stringValues] or a number in [$formattedNumericalValues], got $variant.",
+  [SOLANA_ERROR__CODECS__INVALID_LITERAL_UNION_VARIANT]: "Invalid literal union variant. Expected one of [$variants], got $value.",
+  [SOLANA_ERROR__CODECS__INVALID_NUMBER_OF_ITEMS]: "Expected [$codecDescription] to have $expected items, got $actual.",
+  [SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE]: "Invalid value $value for base $base with alphabet $alphabet.",
+  [SOLANA_ERROR__CODECS__LITERAL_UNION_DISCRIMINATOR_OUT_OF_RANGE]: "Literal union discriminator out of range. Expected a number between $minRange and $maxRange, got $discriminator.",
+  [SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE]: "Codec [$codecDescription] expected number to be in the range [$min, $max], got $value.",
+  [SOLANA_ERROR__CODECS__OFFSET_OUT_OF_RANGE]: "Codec [$codecDescription] expected offset to be in the range [0, $bytesLength], got $offset.",
+  [SOLANA_ERROR__CODECS__SENTINEL_MISSING_IN_DECODED_BYTES]: "Expected sentinel [$hexSentinel] to be present in decoded bytes [$hexDecodedBytes].",
+  [SOLANA_ERROR__CODECS__UNION_VARIANT_OUT_OF_RANGE]: "Union variant out of range. Expected an index between $minRange and $maxRange, got $variant.",
+  [SOLANA_ERROR__CODECS__EXPECTED_DECODER_TO_CONSUME_ENTIRE_BYTE_ARRAY]: "This decoder expected a byte array of exactly $expectedLength bytes, but $numExcessBytes unexpected excess bytes remained after decoding. Are you sure that you have chosen the correct decoder for this data?",
+  [SOLANA_ERROR__CRYPTO__RANDOM_VALUES_FUNCTION_UNIMPLEMENTED]: "No random values implementation could be found.",
+  [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__INVARIANT_VIOLATION__INVALID_INSTRUCTION_PLAN_KIND]: "Invalid instruction plan kind: $kind.",
+  [SOLANA_ERROR__INSTRUCTION_PLANS__EMPTY_INSTRUCTION_PLAN]: "The provided instruction plan is empty.",
+  [SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN]: "The provided transaction plan failed to execute. See the `transactionPlanResult` attribute and the `cause` error for more details.",
+  [SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN]: "The provided message has insufficient capacity to accommodate the next instruction(s) in this plan. Expected at least $numBytesRequired free byte(s), got $numFreeBytes byte(s).",
+  [SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_TRANSACTION_PLAN_KIND]: "Invalid transaction plan kind: $kind.",
+  [SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_PACKER_ALREADY_COMPLETE]: "No more instructions to pack; the message packer has completed the instruction plan.",
+  [SOLANA_ERROR__INSTRUCTION__EXPECTED_TO_HAVE_ACCOUNTS]: "The instruction does not have any accounts.",
+  [SOLANA_ERROR__INSTRUCTION__EXPECTED_TO_HAVE_DATA]: "The instruction does not have any data.",
+  [SOLANA_ERROR__INSTRUCTION__PROGRAM_ID_MISMATCH]: "Expected instruction to have progress address $expectedProgramAddress, got $actualProgramAddress.",
+  [SOLANA_ERROR__INVALID_BLOCKHASH_BYTE_LENGTH]: "Expected base58 encoded blockhash to decode to a byte array of length 32. Actual length: $actualLength.",
+  [SOLANA_ERROR__INVALID_NONCE]: "The nonce `$expectedNonceValue` is no longer valid. It has advanced to `$actualNonceValue`",
+  [SOLANA_ERROR__INVARIANT_VIOLATION__CACHED_ABORTABLE_ITERABLE_CACHE_ENTRY_MISSING]: "Invariant violation: Found no abortable iterable cache entry for key `$cacheKey`. It should be impossible to hit this error; please file an issue at https://sola.na/web3invariant",
+  [SOLANA_ERROR__INVARIANT_VIOLATION__DATA_PUBLISHER_CHANNEL_UNIMPLEMENTED]: "Invariant violation: This data publisher does not publish to the channel named `$channelName`. Supported channels include $supportedChannelNames.",
+  [SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_MUST_NOT_POLL_BEFORE_RESOLVING_EXISTING_MESSAGE_PROMISE]: "Invariant violation: WebSocket message iterator state is corrupt; iterated without first resolving existing message promise. It should be impossible to hit this error; please file an issue at https://sola.na/web3invariant",
+  [SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_STATE_MISSING]: "Invariant violation: WebSocket message iterator is missing state storage. It should be impossible to hit this error; please file an issue at https://sola.na/web3invariant",
+  [SOLANA_ERROR__INVARIANT_VIOLATION__SWITCH_MUST_BE_EXHAUSTIVE]: "Invariant violation: Switch statement non-exhaustive. Received unexpected value `$unexpectedValue`. It should be impossible to hit this error; please file an issue at https://sola.na/web3invariant",
+  [SOLANA_ERROR__JSON_RPC__INTERNAL_ERROR]: "JSON-RPC error: Internal JSON-RPC error ($__serverMessage)",
+  [SOLANA_ERROR__JSON_RPC__INVALID_PARAMS]: "JSON-RPC error: Invalid method parameter(s) ($__serverMessage)",
+  [SOLANA_ERROR__JSON_RPC__INVALID_REQUEST]: "JSON-RPC error: The JSON sent is not a valid `Request` object ($__serverMessage)",
+  [SOLANA_ERROR__JSON_RPC__METHOD_NOT_FOUND]: "JSON-RPC error: The method does not exist / is not available ($__serverMessage)",
+  [SOLANA_ERROR__JSON_RPC__PARSE_ERROR]: "JSON-RPC error: An error occurred on the server while parsing the JSON text ($__serverMessage)",
+  [SOLANA_ERROR__JSON_RPC__SCAN_ERROR]: "$__serverMessage",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_BLOCK_CLEANED_UP]: "$__serverMessage",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_BLOCK_NOT_AVAILABLE]: "$__serverMessage",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_BLOCK_STATUS_NOT_AVAILABLE_YET]: "$__serverMessage",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_EPOCH_REWARDS_PERIOD_ACTIVE]: "Epoch rewards period still active at slot $slot",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_KEY_EXCLUDED_FROM_SECONDARY_INDEX]: "$__serverMessage",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_LONG_TERM_STORAGE_SLOT_SKIPPED]: "$__serverMessage",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_LONG_TERM_STORAGE_UNREACHABLE]: "Failed to query long-term storage; please try again",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_MIN_CONTEXT_SLOT_NOT_REACHED]: "Minimum context slot has not been reached",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_NODE_UNHEALTHY]: "Node is unhealthy; behind by $numSlotsBehind slots",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_NO_SNAPSHOT]: "No snapshot",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE]: "Transaction simulation failed",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SLOT_NOT_EPOCH_BOUNDARY]: "Rewards cannot be found because slot $slot is not the epoch boundary. This may be due to gap in the queried node's local ledger or long-term storage",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SLOT_SKIPPED]: "$__serverMessage",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_TRANSACTION_HISTORY_NOT_AVAILABLE]: "Transaction history is not available from this node",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_TRANSACTION_PRECOMPILE_VERIFICATION_FAILURE]: "$__serverMessage",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_TRANSACTION_SIGNATURE_LEN_MISMATCH]: "Transaction signature length mismatch",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_TRANSACTION_SIGNATURE_VERIFICATION_FAILURE]: "Transaction signature verification failure",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_UNSUPPORTED_TRANSACTION_VERSION]: "$__serverMessage",
+  [SOLANA_ERROR__KEYS__INVALID_KEY_PAIR_BYTE_LENGTH]: "Key pair bytes must be of length 64, got $byteLength.",
+  [SOLANA_ERROR__KEYS__INVALID_PRIVATE_KEY_BYTE_LENGTH]: "Expected private key bytes with length 32. Actual length: $actualLength.",
+  [SOLANA_ERROR__KEYS__INVALID_SIGNATURE_BYTE_LENGTH]: "Expected base58-encoded signature to decode to a byte array of length 64. Actual length: $actualLength.",
+  [SOLANA_ERROR__KEYS__PUBLIC_KEY_MUST_MATCH_PRIVATE_KEY]: "The provided private key does not match the provided public key.",
+  [SOLANA_ERROR__KEYS__SIGNATURE_STRING_LENGTH_OUT_OF_RANGE]: "Expected base58-encoded signature string of length in the range [64, 88]. Actual length: $actualLength.",
+  [SOLANA_ERROR__LAMPORTS_OUT_OF_RANGE]: "Lamports value must be in the range [0, 2e64-1]",
+  [SOLANA_ERROR__MALFORMED_BIGINT_STRING]: "`$value` cannot be parsed as a `BigInt`",
+  [SOLANA_ERROR__MALFORMED_JSON_RPC_ERROR]: "$message",
+  [SOLANA_ERROR__MALFORMED_NUMBER_STRING]: "`$value` cannot be parsed as a `Number`",
+  [SOLANA_ERROR__NONCE_ACCOUNT_NOT_FOUND]: "No nonce account could be found at address `$nonceAccountAddress`",
+  [SOLANA_ERROR__RPC_SUBSCRIPTIONS__CANNOT_CREATE_SUBSCRIPTION_PLAN]: "The notification name must end in 'Notifications' and the API must supply a subscription plan creator function for the notification '$notificationName'.",
+  [SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CLOSED_BEFORE_MESSAGE_BUFFERED]: "WebSocket was closed before payload could be added to the send buffer",
+  [SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CONNECTION_CLOSED]: "WebSocket connection closed",
+  [SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_FAILED_TO_CONNECT]: "WebSocket failed to connect",
+  [SOLANA_ERROR__RPC_SUBSCRIPTIONS__EXPECTED_SERVER_SUBSCRIPTION_ID]: "Failed to obtain a subscription id from the server",
+  [SOLANA_ERROR__RPC__API_PLAN_MISSING_FOR_RPC_METHOD]: "Could not find an API plan for RPC method: `$method`",
+  [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_HTTP_ERROR]: "HTTP error ($statusCode): $message",
+  [SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN]: "HTTP header(s) forbidden: $headers. Learn more at https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_header_name.",
+  [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 `TransactionWithSingleSendingSigner` transaction.",
+  [SOLANA_ERROR__SIGNER__WALLET_MULTISIGN_UNIMPLEMENTED]: "Wallet account signers do not support signing multiple messages/transactions in a single operation",
+  [SOLANA_ERROR__SUBTLE_CRYPTO__CANNOT_EXPORT_NON_EXTRACTABLE_KEY]: "Cannot export a non-extractable key.",
+  [SOLANA_ERROR__SUBTLE_CRYPTO__DIGEST_UNIMPLEMENTED]: "No digest implementation could be found.",
+  [SOLANA_ERROR__SUBTLE_CRYPTO__DISALLOWED_IN_INSECURE_CONTEXT]: "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__ED25519_ALGORITHM_UNIMPLEMENTED]: "This runtime does not support the generation of Ed25519 key pairs.\n\nInstall @solana/webcrypto-ed25519-polyfill and call its `install` function 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_UNIMPLEMENTED]: "No signature verification implementation could be found.",
+  [SOLANA_ERROR__SUBTLE_CRYPTO__GENERATE_FUNCTION_UNIMPLEMENTED]: "No key generation implementation could be found.",
+  [SOLANA_ERROR__SUBTLE_CRYPTO__SIGN_FUNCTION_UNIMPLEMENTED]: "No signing implementation could be found.",
+  [SOLANA_ERROR__SUBTLE_CRYPTO__VERIFY_FUNCTION_UNIMPLEMENTED]: "No key export implementation could be found.",
+  [SOLANA_ERROR__TIMESTAMP_OUT_OF_RANGE]: "Timestamp value must be in the range [-(2n ** 63n), (2n ** 63n) - 1]. `$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__ADDRESSES_CANNOT_SIGN_TRANSACTION]: "Attempted to sign a transaction with an address that is not a signer for it",
+  [SOLANA_ERROR__TRANSACTION__ADDRESS_MISSING]: "Transaction is missing an address at index: $index.",
+  [SOLANA_ERROR__TRANSACTION__CANNOT_ENCODE_WITH_EMPTY_SIGNATURES]: "Transaction has no expected signers therefore it cannot be encoded",
+  [SOLANA_ERROR__TRANSACTION__EXCEEDS_SIZE_LIMIT]: "Transaction size $transactionSize exceeds limit of $transactionSizeLimit bytes",
+  [SOLANA_ERROR__TRANSACTION__EXPECTED_BLOCKHASH_LIFETIME]: "Transaction does not have a blockhash lifetime",
+  [SOLANA_ERROR__TRANSACTION__EXPECTED_NONCE_LIFETIME]: "Transaction is not a durable nonce transaction",
+  [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__FAILED_TO_ESTIMATE_COMPUTE_LIMIT]: "Failed to estimate the compute unit consumption for this transaction message. This is likely because simulating the transaction failed. Inspect the `cause` property of this error to learn more",
+  [SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT]: "Transaction failed when it was simulated in order to estimate the compute unit consumption. The compute unit estimate provided is for a transaction that failed when simulated and may not be representative of the compute units this transaction would consume if successful. Inspect the `cause` property of this error to learn more",
+  [SOLANA_ERROR__TRANSACTION__FEE_PAYER_MISSING]: "Transaction is missing a fee payer.",
+  [SOLANA_ERROR__TRANSACTION__FEE_PAYER_SIGNATURE_MISSING]: "Could not determine this transaction's signature. Make sure that the transaction has been signed by its fee payer.",
+  [SOLANA_ERROR__TRANSACTION__INVALID_NONCE_TRANSACTION_FIRST_INSTRUCTION_MUST_BE_ADVANCE_NONCE]: "Transaction first instruction is not advance nonce account instruction.",
+  [SOLANA_ERROR__TRANSACTION__INVALID_NONCE_TRANSACTION_INSTRUCTIONS_MISSING]: "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__MESSAGE_SIGNATURES_MISMATCH]: "The transaction message expected the transaction to have $numRequiredSignatures signatures, got $signaturesLength.",
+  [SOLANA_ERROR__TRANSACTION__SIGNATURES_MISSING]: "Transaction is missing signatures for addresses: $addresses.",
+  [SOLANA_ERROR__TRANSACTION__VERSION_NUMBER_OUT_OF_RANGE]: "Transaction version must be in the range [0, 127]. `$actualVersion` given",
+  [SOLANA_ERROR__TRANSACTION__VERSION_NUMBER_NOT_SUPPORTED]: "This version of Kit does not support decoding transactions with version $unsupportedVersion. The current max supported version is 0.",
+  [SOLANA_ERROR__TRANSACTION__NONCE_ACCOUNT_CANNOT_BE_IN_LOOKUP_TABLE]: "The transaction has a durable nonce lifetime (with nonce `$nonce`), but the nonce account address is in a lookup table. The lifetime constraint cannot be constructed without fetching the lookup tables for the transaction."
+};
+
+// src/message-formatter.ts
+var START_INDEX = "i";
+var TYPE = "t";
+function getHumanReadableErrorMessage(code, context = {}) {
+  const messageFormatString = SolanaErrorMessages[code];
+  if (messageFormatString.length === 0) {
+    return "";
+  }
+  let state;
+  function commitStateUpTo(endIndex) {
+    if (state[TYPE] === 2 /* Variable */) {
+      const variableName = messageFormatString.slice(state[START_INDEX] + 1, endIndex);
+      fragments.push(
+        variableName in context ? (
+          // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+          `${context[variableName]}`
+        ) : `$${variableName}`
+      );
+    } else if (state[TYPE] === 1 /* Text */) {
+      fragments.push(messageFormatString.slice(state[START_INDEX], endIndex));
+    }
+  }
+  const fragments = [];
+  messageFormatString.split("").forEach((char, ii) => {
+    if (ii === 0) {
+      state = {
+        [START_INDEX]: 0,
+        [TYPE]: messageFormatString[0] === "\\" ? 0 /* EscapeSequence */ : messageFormatString[0] === "$" ? 2 /* Variable */ : 1 /* Text */
+      };
+      return;
+    }
+    let nextState;
+    switch (state[TYPE]) {
+      case 0 /* EscapeSequence */:
+        nextState = { [START_INDEX]: ii, [TYPE]: 1 /* Text */ };
+        break;
+      case 1 /* Text */:
+        if (char === "\\") {
+          nextState = { [START_INDEX]: ii, [TYPE]: 0 /* EscapeSequence */ };
+        } else if (char === "$") {
+          nextState = { [START_INDEX]: ii, [TYPE]: 2 /* Variable */ };
+        }
+        break;
+      case 2 /* Variable */:
+        if (char === "\\") {
+          nextState = { [START_INDEX]: ii, [TYPE]: 0 /* EscapeSequence */ };
+        } else if (char === "$") {
+          nextState = { [START_INDEX]: ii, [TYPE]: 2 /* Variable */ };
+        } else if (!char.match(/\w/)) {
+          nextState = { [START_INDEX]: ii, [TYPE]: 1 /* Text */ };
+        }
+        break;
+    }
+    if (nextState) {
+      if (state !== nextState) {
+        commitStateUpTo(ii);
+      }
+      state = nextState;
+    }
+  });
+  commitStateUpTo();
+  return fragments.join("");
+}
+function getErrorMessage(code, context = {}) {
+  if (process.env.NODE_ENV !== "production") {
+    return getHumanReadableErrorMessage(code, context);
+  } else {
+    let decodingAdviceMessage = `Solana error #${code}; Decode this error by running \`npx @solana/errors decode -- ${code}`;
+    if (Object.keys(context).length) {
+      decodingAdviceMessage += ` '${encodeContextObject(context)}'`;
+    }
+    return `${decodingAdviceMessage}\``;
+  }
+}
+
+// src/error.ts
+function isSolanaError(e, code) {
+  const isSolanaError2 = e instanceof Error && e.name === "SolanaError";
+  if (isSolanaError2) {
+    {
+      return e.context.__code === code;
+    }
+  }
+  return false;
+}
+var SolanaError = class extends Error {
+  /**
+   * Indicates the root cause of this {@link SolanaError}, if any.
+   *
+   * For example, a transaction error might have an instruction error as its root cause. In this
+   * case, you will be able to access the instruction error on the transaction error as `cause`.
+   */
+  cause = this.cause;
+  /**
+   * Contains context that can assist in understanding or recovering from a {@link SolanaError}.
+   */
+  context;
+  constructor(...[code, contextAndErrorOptions]) {
+    let context;
+    let errorOptions;
+    if (contextAndErrorOptions) {
+      Object.entries(Object.getOwnPropertyDescriptors(contextAndErrorOptions)).forEach(([name, descriptor]) => {
+        if (name === "cause") {
+          errorOptions = { cause: descriptor.value };
+        } else {
+          if (context === void 0) {
+            context = {};
+          }
+          Object.defineProperty(context, name, descriptor);
+        }
+      });
+    }
+    const message = getErrorMessage(code, context);
+    super(message, errorOptions);
+    this.context = context === void 0 ? {} : context;
+    this.context.__code = code;
+    this.name = "SolanaError";
+  }
+};
+
+// src/stack-trace.ts
+function safeCaptureStackTrace(...args) {
+  if ("captureStackTrace" in Error && typeof Error.captureStackTrace === "function") {
+    Error.captureStackTrace(...args);
+  }
+}
+
+// src/rpc-enum-errors.ts
+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);
+  safeCaptureStackTrace(err, constructorOpt);
+  return err;
+}
+
+// src/instruction-error.ts
+var ORDERED_ERROR_NAMES = [
+  // Keep synced with RPC source: https://github.com/anza-xyz/solana-sdk/blob/master/instruction-error/src/lib.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) {
+  const numberIndex = Number(index);
+  return getSolanaErrorFromRpcError(
+    {
+      errorCodeBaseOffset: 4615001,
+      getErrorContext(errorCode, rpcErrorName, rpcErrorContext) {
+        if (errorCode === SOLANA_ERROR__INSTRUCTION_ERROR__UNKNOWN) {
+          return {
+            errorName: rpcErrorName,
+            index: numberIndex,
+            ...rpcErrorContext !== void 0 ? { instructionErrorContext: rpcErrorContext } : null
+          };
+        } else if (errorCode === SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM) {
+          return {
+            code: Number(rpcErrorContext),
+            index: numberIndex
+          };
+        }
+        return { index: numberIndex };
+      },
+      orderedErrorNames: ORDERED_ERROR_NAMES,
+      rpcEnumError: instructionError
+    },
+    getSolanaErrorFromInstructionError
+  );
+}
+
+// src/transaction-error.ts
+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: Number(rpcErrorContext)
+          };
+        } else if (errorCode === SOLANA_ERROR__TRANSACTION_ERROR__INSUFFICIENT_FUNDS_FOR_RENT || errorCode === SOLANA_ERROR__TRANSACTION_ERROR__PROGRAM_EXECUTION_TEMPORARILY_RESTRICTED) {
+          return {
+            accountIndex: Number(rpcErrorContext.account_index)
+          };
+        }
+      },
+      orderedErrorNames: ORDERED_ERROR_NAMES2,
+      rpcEnumError: transactionError
+    },
+    getSolanaErrorFromTransactionError
+  );
+}
+
+// src/json-rpc-error.ts
+function getSolanaErrorFromJsonRpcError(putativeErrorResponse) {
+  let out;
+  if (isRpcErrorResponse(putativeErrorResponse)) {
+    const { code: rawCode, data, message } = putativeErrorResponse;
+    const code = Number(rawCode);
+    if (code === SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE) {
+      const { err, ...preflightErrorContext } = data;
+      const causeObject = err ? { cause: getSolanaErrorFromTransactionError(err) } : null;
+      out = new SolanaError(SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE, {
+        ...preflightErrorContext,
+        ...causeObject
+      });
+    } else {
+      let errorContext;
+      switch (code) {
+        case SOLANA_ERROR__JSON_RPC__INTERNAL_ERROR:
+        case SOLANA_ERROR__JSON_RPC__INVALID_PARAMS:
+        case SOLANA_ERROR__JSON_RPC__INVALID_REQUEST:
+        case SOLANA_ERROR__JSON_RPC__METHOD_NOT_FOUND:
+        case SOLANA_ERROR__JSON_RPC__PARSE_ERROR:
+        case SOLANA_ERROR__JSON_RPC__SCAN_ERROR:
+        case SOLANA_ERROR__JSON_RPC__SERVER_ERROR_BLOCK_CLEANED_UP:
+        case SOLANA_ERROR__JSON_RPC__SERVER_ERROR_BLOCK_NOT_AVAILABLE:
+        case SOLANA_ERROR__JSON_RPC__SERVER_ERROR_BLOCK_STATUS_NOT_AVAILABLE_YET:
+        case SOLANA_ERROR__JSON_RPC__SERVER_ERROR_KEY_EXCLUDED_FROM_SECONDARY_INDEX:
+        case SOLANA_ERROR__JSON_RPC__SERVER_ERROR_LONG_TERM_STORAGE_SLOT_SKIPPED:
+        case SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SLOT_SKIPPED:
+        case SOLANA_ERROR__JSON_RPC__SERVER_ERROR_TRANSACTION_PRECOMPILE_VERIFICATION_FAILURE:
+        case SOLANA_ERROR__JSON_RPC__SERVER_ERROR_UNSUPPORTED_TRANSACTION_VERSION:
+          errorContext = { __serverMessage: message };
+          break;
+        default:
+          if (typeof data === "object" && !Array.isArray(data)) {
+            errorContext = data;
+          }
+      }
+      out = new SolanaError(code, errorContext);
+    }
+  } else {
+    const message = typeof putativeErrorResponse === "object" && putativeErrorResponse !== null && "message" in putativeErrorResponse && typeof putativeErrorResponse.message === "string" ? putativeErrorResponse.message : "Malformed JSON-RPC error with no message attribute";
+    out = new SolanaError(SOLANA_ERROR__MALFORMED_JSON_RPC_ERROR, { error: putativeErrorResponse, message });
+  }
+  safeCaptureStackTrace(out, getSolanaErrorFromJsonRpcError);
+  return out;
+}
+function isRpcErrorResponse(value) {
+  return typeof value === "object" && value !== null && "code" in value && "message" in value && (typeof value.code === "number" || typeof value.code === "bigint") && typeof value.message === "string";
+}
+
+// src/pipe.ts
+function pipe(init, ...fns) {
+  return fns.reduce((acc, fn) => fn(acc), init);
+}
+
+// src/race.ts
+function isObject(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function");
+}
+function addRaceContender(contender) {
+  const deferreds = /* @__PURE__ */ new Set();
+  const record = { deferreds, settled: false };
+  Promise.resolve(contender).then(
+    (value) => {
+      for (const { resolve } of deferreds) {
+        resolve(value);
+      }
+      deferreds.clear();
+      record.settled = true;
+    },
+    (err) => {
+      for (const { reject } of deferreds) {
+        reject(err);
+      }
+      deferreds.clear();
+      record.settled = true;
+    }
+  );
+  return record;
+}
+var wm = /* @__PURE__ */ new WeakMap();
+async function safeRace(contenders) {
+  let deferred;
+  const result = new Promise((resolve, reject) => {
+    deferred = { reject, resolve };
+    for (const contender of contenders) {
+      if (!isObject(contender)) {
+        Promise.resolve(contender).then(resolve, reject);
+        continue;
+      }
+      let record = wm.get(contender);
+      if (record === void 0) {
+        record = addRaceContender(contender);
+        record.deferreds.add(deferred);
+        wm.set(contender, record);
+      } else if (record.settled) {
+        Promise.resolve(contender).then(resolve, reject);
+      } else {
+        record.deferreds.add(deferred);
+      }
+    }
+  });
+  return await result.finally(() => {
+    for (const contender of contenders) {
+      if (isObject(contender)) {
+        const record = wm.get(contender);
+        record.deferreds.delete(deferred);
+      }
+    }
+  });
+}
+
+// src/parse-json-with-bigints.ts
+function parseJsonWithBigInts(json) {
+  return JSON.parse(wrapIntegersInBigIntValueObject(json), (_, value) => {
+    return isBigIntValueObject(value) ? unwrapBigIntValueObject(value) : value;
+  });
+}
+function wrapIntegersInBigIntValueObject(json) {
+  const out = [];
+  let inQuote = false;
+  for (let ii = 0; ii < json.length; ii++) {
+    let isEscaped = false;
+    if (json[ii] === "\\") {
+      out.push(json[ii++]);
+      isEscaped = !isEscaped;
+    }
+    if (json[ii] === '"') {
+      out.push(json[ii]);
+      if (!isEscaped) {
+        inQuote = !inQuote;
+      }
+      continue;
+    }
+    if (!inQuote) {
+      const consumedNumber = consumeNumber(json, ii);
+      if (consumedNumber?.length) {
+        ii += consumedNumber.length - 1;
+        if (consumedNumber.match(/\.|[eE]-/)) {
+          out.push(consumedNumber);
+        } else {
+          out.push(wrapBigIntValueObject(consumedNumber));
+        }
+        continue;
+      }
+    }
+    out.push(json[ii]);
+  }
+  return out.join("");
+}
+function consumeNumber(json, ii) {
+  const JSON_NUMBER_REGEX = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/;
+  if (!json[ii]?.match(/[-\d]/)) {
+    return null;
+  }
+  const numberMatch = json.slice(ii).match(JSON_NUMBER_REGEX);
+  return numberMatch ? numberMatch[0] : null;
+}
+function wrapBigIntValueObject(value) {
+  return `{"$n":"${value}"}`;
+}
+function unwrapBigIntValueObject({ $n }) {
+  if ($n.match(/[eE]/)) {
+    const [units, exponent] = $n.split(/[eE]/);
+    return BigInt(units) * BigInt(10) ** BigInt(exponent);
+  }
+  return BigInt($n);
+}
+function isBigIntValueObject(value) {
+  return !!value && typeof value === "object" && "$n" in value && typeof value.$n === "string";
+}
+
+// src/rpc-message.ts
+var _nextMessageId = 0n;
+function getNextMessageId() {
+  const id = _nextMessageId;
+  _nextMessageId++;
+  return id.toString();
+}
+function createRpcMessage(request) {
+  return {
+    id: getNextMessageId(),
+    jsonrpc: "2.0",
+    method: request.methodName,
+    params: request.params
+  };
+}
+
+// src/stringify-json-with-bigints.ts
+function stringifyJsonWithBigInts(value, space) {
+  return unwrapBigIntValueObject2(
+    JSON.stringify(value, (_, v) => typeof v === "bigint" ? wrapBigIntValueObject2(v) : v, space)
+  );
+}
+function wrapBigIntValueObject2(value) {
+  return { $n: `${value}` };
+}
+function unwrapBigIntValueObject2(value) {
+  return value.replace(/\{\s*"\$n"\s*:\s*"(-?\d+)"\s*\}/g, "$1");
+}
+
+// src/rpc.ts
+function createRpc(rpcConfig) {
+  return makeProxy(rpcConfig);
+}
+function makeProxy(rpcConfig) {
+  return new Proxy(rpcConfig.api, {
+    defineProperty() {
+      return false;
+    },
+    deleteProperty() {
+      return false;
+    },
+    get(target, p, receiver) {
+      if (p === "then") {
+        return void 0;
+      }
+      return function(...rawParams) {
+        const methodName = p.toString();
+        const getApiPlan = Reflect.get(target, methodName, receiver);
+        if (!getApiPlan) {
+          throw new SolanaError(SOLANA_ERROR__RPC__API_PLAN_MISSING_FOR_RPC_METHOD, {
+            method: methodName,
+            params: rawParams
+          });
+        }
+        const apiPlan = getApiPlan(...rawParams);
+        return createPendingRpcRequest(rpcConfig, apiPlan);
+      };
+    }
+  });
+}
+function createPendingRpcRequest({ transport }, plan) {
+  return {
+    async send(options) {
+      return await plan.execute({ signal: options?.abortSignal, transport });
+    }
+  };
+}
+function createJsonRpcApi(config) {
+  return new Proxy({}, {
+    defineProperty() {
+      return false;
+    },
+    deleteProperty() {
+      return false;
+    },
+    get(...args) {
+      const [_, p] = args;
+      const methodName = p.toString();
+      return function(...rawParams) {
+        const rawRequest = Object.freeze({ methodName, params: rawParams });
+        const request = config?.requestTransformer ? config?.requestTransformer(rawRequest) : rawRequest;
+        return Object.freeze({
+          execute: async ({ signal, transport }) => {
+            const payload = createRpcMessage(request);
+            const response = await transport({ payload, signal });
+            if (!config?.responseTransformer) {
+              return response;
+            }
+            return config.responseTransformer(response, request);
+          }
+        });
+      };
+    }
+  });
+}
+
+// src/rpc-transport.ts
+function isJsonRpcPayload(payload) {
+  if (payload == null || typeof payload !== "object" || Array.isArray(payload)) {
+    return false;
+  }
+  return "jsonrpc" in payload && payload.jsonrpc === "2.0" && "method" in payload && typeof payload.method === "string" && "params" in payload;
+}
+
+// src/request-transformer.ts
+
+// src/request-transformer-bigint-downcast-internal.ts
+function downcastNodeToNumberIfBigint(value) {
+  return typeof value === "bigint" ? (
+    // FIXME(solana-labs/solana/issues/30341) Create a data type to represent u64 in the Solana
+    // JSON RPC implementation so that we can throw away this entire patcher instead of unsafely
+    // downcasting `bigints` to `numbers`.
+    Number(value)
+  ) : value;
+}
+
+// src/tree-traversal.ts
+var KEYPATH_WILDCARD = {};
+function getTreeWalker(visitors) {
+  return function traverse(node, state) {
+    if (Array.isArray(node)) {
+      return node.map((element, ii) => {
+        const nextState = {
+          ...state,
+          keyPath: [...state.keyPath, ii]
+        };
+        return traverse(element, nextState);
+      });
+    } else if (typeof node === "object" && node !== null) {
+      const out = {};
+      for (const propName in node) {
+        if (!Object.prototype.hasOwnProperty.call(node, propName)) {
+          continue;
+        }
+        const nextState = {
+          ...state,
+          keyPath: [...state.keyPath, propName]
+        };
+        out[propName] = traverse(node[propName], nextState);
+      }
+      return out;
+    } else {
+      return visitors.reduce((acc, visitNode) => visitNode(acc, state), node);
+    }
+  };
+}
+function getTreeWalkerRequestTransformer(visitors, initialState) {
+  return (request) => {
+    const traverse = getTreeWalker(visitors);
+    return Object.freeze({
+      ...request,
+      params: traverse(request.params, initialState)
+    });
+  };
+}
+function getTreeWalkerResponseTransformer(visitors, initialState) {
+  return (json) => getTreeWalker(visitors)(json, initialState);
+}
+
+// src/request-transformer-bigint-downcast.ts
+function getBigIntDowncastRequestTransformer() {
+  return getTreeWalkerRequestTransformer([downcastNodeToNumberIfBigint], { keyPath: [] });
+}
+
+// src/request-transformer-default-commitment-internal.ts
+function applyDefaultCommitment({
+  commitmentPropertyName,
+  params,
+  optionsObjectPositionInParams,
+  overrideCommitment
+}) {
+  const paramInTargetPosition = params[optionsObjectPositionInParams];
+  if (
+    // There's no config.
+    paramInTargetPosition === void 0 || // There is a config object.
+    paramInTargetPosition && typeof paramInTargetPosition === "object" && !Array.isArray(paramInTargetPosition)
+  ) {
+    if (
+      // The config object already has a commitment set.
+      paramInTargetPosition && commitmentPropertyName in paramInTargetPosition
+    ) {
+      if (!paramInTargetPosition[commitmentPropertyName] || paramInTargetPosition[commitmentPropertyName] === "finalized") {
+        const nextParams = [...params];
+        const {
+          [commitmentPropertyName]: _,
+          // eslint-disable-line @typescript-eslint/no-unused-vars
+          ...rest
+        } = paramInTargetPosition;
+        if (Object.keys(rest).length > 0) {
+          nextParams[optionsObjectPositionInParams] = rest;
+        } else {
+          if (optionsObjectPositionInParams === nextParams.length - 1) {
+            nextParams.length--;
+          } else {
+            nextParams[optionsObjectPositionInParams] = void 0;
+          }
+        }
+        return nextParams;
+      }
+    } else if (overrideCommitment !== "finalized") {
+      const nextParams = [...params];
+      nextParams[optionsObjectPositionInParams] = {
+        ...paramInTargetPosition,
+        [commitmentPropertyName]: overrideCommitment
+      };
+      return nextParams;
+    }
+  }
+  return params;
+}
+
+// src/request-transformer-default-commitment.ts
+function getDefaultCommitmentRequestTransformer({
+  defaultCommitment,
+  optionsObjectPositionByMethod
+}) {
+  return (request) => {
+    const { params, methodName } = request;
+    if (!Array.isArray(params)) {
+      return request;
+    }
+    const optionsObjectPositionInParams = optionsObjectPositionByMethod[methodName];
+    if (optionsObjectPositionInParams == null) {
+      return request;
+    }
+    return Object.freeze({
+      methodName,
+      params: applyDefaultCommitment({
+        commitmentPropertyName: methodName === "sendTransaction" ? "preflightCommitment" : "commitment",
+        optionsObjectPositionInParams,
+        overrideCommitment: defaultCommitment,
+        params
+      })
+    });
+  };
+}
+
+// src/request-transformer-integer-overflow-internal.ts
+function getIntegerOverflowNodeVisitor(onIntegerOverflow) {
+  return (value, { keyPath }) => {
+    if (typeof value === "bigint") {
+      if (onIntegerOverflow && (value > Number.MAX_SAFE_INTEGER || value < -Number.MAX_SAFE_INTEGER)) {
+        onIntegerOverflow(keyPath, value);
+      }
+    }
+    return value;
+  };
+}
+
+// src/request-transformer-integer-overflow.ts
+function getIntegerOverflowRequestTransformer(onIntegerOverflow) {
+  return (request) => {
+    const transformer = getTreeWalkerRequestTransformer(
+      [getIntegerOverflowNodeVisitor((...args) => onIntegerOverflow(request, ...args))],
+      { keyPath: [] }
+    );
+    return transformer(request);
+  };
+}
+
+// src/request-transformer-options-object-position-config.ts
+var OPTIONS_OBJECT_POSITION_BY_METHOD = {
+  accountNotifications: 1,
+  blockNotifications: 1,
+  getAccountInfo: 1,
+  getBalance: 1,
+  getBlock: 1,
+  getBlockHeight: 0,
+  getBlockProduction: 0,
+  getBlocks: 2,
+  getBlocksWithLimit: 2,
+  getEpochInfo: 0,
+  getFeeForMessage: 1,
+  getInflationGovernor: 0,
+  getInflationReward: 1,
+  getLargestAccounts: 0,
+  getLatestBlockhash: 0,
+  getLeaderSchedule: 1,
+  getMinimumBalanceForRentExemption: 1,
+  getMultipleAccounts: 1,
+  getProgramAccounts: 1,
+  getSignaturesForAddress: 1,
+  getSlot: 0,
+  getSlotLeader: 0,
+  getStakeMinimumDelegation: 0,
+  getSupply: 0,
+  getTokenAccountBalance: 1,
+  getTokenAccountsByDelegate: 2,
+  getTokenAccountsByOwner: 2,
+  getTokenLargestAccounts: 1,
+  getTokenSupply: 1,
+  getTransaction: 1,
+  getTransactionCount: 0,
+  getVoteAccounts: 0,
+  isBlockhashValid: 1,
+  logsNotifications: 1,
+  programNotifications: 1,
+  requestAirdrop: 2,
+  sendTransaction: 1,
+  signatureNotifications: 1,
+  simulateTransaction: 1
+};
+
+// src/request-transformer.ts
+function getDefaultRequestTransformerForSolanaRpc(config) {
+  const handleIntegerOverflow = config?.onIntegerOverflow;
+  return (request) => {
+    return pipe(
+      request,
+      handleIntegerOverflow ? getIntegerOverflowRequestTransformer(handleIntegerOverflow) : (r) => r,
+      getBigIntDowncastRequestTransformer(),
+      getDefaultCommitmentRequestTransformer({
+        defaultCommitment: config?.defaultCommitment,
+        optionsObjectPositionByMethod: OPTIONS_OBJECT_POSITION_BY_METHOD
+      })
+    );
+  };
+}
+
+// src/response-transformer-bigint-upcast-internal.ts
+function getBigIntUpcastVisitor(allowedNumericKeyPaths) {
+  return function upcastNodeToBigIntIfNumber(value, { keyPath }) {
+    const isInteger = typeof value === "number" && Number.isInteger(value) || typeof value === "bigint";
+    if (!isInteger) return value;
+    if (keyPathIsAllowedToBeNumeric(keyPath, allowedNumericKeyPaths)) {
+      return Number(value);
+    } else {
+      return BigInt(value);
+    }
+  };
+}
+function keyPathIsAllowedToBeNumeric(keyPath, allowedNumericKeyPaths) {
+  return allowedNumericKeyPaths.some((prohibitedKeyPath) => {
+    if (prohibitedKeyPath.length !== keyPath.length) {
+      return false;
+    }
+    for (let ii = keyPath.length - 1; ii >= 0; ii--) {
+      const keyPathPart = keyPath[ii];
+      const prohibitedKeyPathPart = prohibitedKeyPath[ii];
+      if (prohibitedKeyPathPart !== keyPathPart && (prohibitedKeyPathPart !== KEYPATH_WILDCARD || typeof keyPathPart !== "number")) {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+
+// src/response-transformer-bigint-upcast.ts
+function getBigIntUpcastResponseTransformer(allowedNumericKeyPaths) {
+  return getTreeWalkerResponseTransformer([getBigIntUpcastVisitor(allowedNumericKeyPaths)], { keyPath: [] });
+}
+
+// src/response-transformer-result.ts
+function getResultResponseTransformer() {
+  return (json) => json.result;
+}
+function getThrowSolanaErrorResponseTransformer() {
+  return (json) => {
+    const jsonRpcResponse = json;
+    if ("error" in jsonRpcResponse) {
+      throw getSolanaErrorFromJsonRpcError(jsonRpcResponse.error);
+    }
+    return jsonRpcResponse;
+  };
+}
+
+// src/response-transformer.ts
+function getDefaultResponseTransformerForSolanaRpc(config) {
+  return (response, request) => {
+    const methodName = request.methodName;
+    const keyPaths = config?.allowedNumericKeyPaths && methodName ? config.allowedNumericKeyPaths[methodName] : void 0;
+    return pipe(
+      response,
+      (r) => getThrowSolanaErrorResponseTransformer()(r, request),
+      (r) => getResultResponseTransformer()(r, request),
+      (r) => getBigIntUpcastResponseTransformer(keyPaths ?? [])(r, request)
+    );
+  };
+}
+function getDefaultResponseTransformerForSolanaRpcSubscriptions(config) {
+  return (response, request) => {
+    const methodName = request.methodName;
+    const keyPaths = config?.allowedNumericKeyPaths && methodName ? config.allowedNumericKeyPaths[methodName] : void 0;
+    return pipe(response, (r) => getBigIntUpcastResponseTransformer(keyPaths ?? [])(r, request));
+  };
+}
+
+// src/response-transformer-allowed-numeric-values.ts
+var jsonParsedTokenAccountsConfigs = [
+  // parsed Token/Token22 token account
+  ["data", "parsed", "info", "tokenAmount", "decimals"],
+  ["data", "parsed", "info", "tokenAmount", "uiAmount"],
+  ["data", "parsed", "info", "rentExemptReserve", "decimals"],
+  ["data", "parsed", "info", "rentExemptReserve", "uiAmount"],
+  ["data", "parsed", "info", "delegatedAmount", "decimals"],
+  ["data", "parsed", "info", "delegatedAmount", "uiAmount"],
+  ["data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "olderTransferFee", "transferFeeBasisPoints"],
+  ["data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "newerTransferFee", "transferFeeBasisPoints"],
+  ["data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "preUpdateAverageRate"],
+  ["data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "currentRate"]
+];
+var jsonParsedAccountsConfigs = [
+  ...jsonParsedTokenAccountsConfigs,
+  // parsed AddressTableLookup account
+  ["data", "parsed", "info", "lastExtendedSlotStartIndex"],
+  // parsed Config account
+  ["data", "parsed", "info", "slashPenalty"],
+  ["data", "parsed", "info", "warmupCooldownRate"],
+  // parsed Token/Token22 mint account
+  ["data", "parsed", "info", "decimals"],
+  // parsed Token/Token22 multisig account
+  ["data", "parsed", "info", "numRequiredSigners"],
+  ["data", "parsed", "info", "numValidSigners"],
+  // parsed Stake account
+  ["data", "parsed", "info", "stake", "delegation", "warmupCooldownRate"],
+  // parsed Sysvar rent account
+  ["data", "parsed", "info", "exemptionThreshold"],
+  ["data", "parsed", "info", "burnPercent"],
+  // parsed Vote account
+  ["data", "parsed", "info", "commission"],
+  ["data", "parsed", "info", "votes", KEYPATH_WILDCARD, "confirmationCount"]
+];
+var innerInstructionsConfigs = [
+  ["index"],
+  ["instructions", KEYPATH_WILDCARD, "accounts", KEYPATH_WILDCARD],
+  ["instructions", KEYPATH_WILDCARD, "programIdIndex"],
+  ["instructions", KEYPATH_WILDCARD, "stackHeight"]
+];
+var messageConfig = [
+  ["addressTableLookups", KEYPATH_WILDCARD, "writableIndexes", KEYPATH_WILDCARD],
+  ["addressTableLookups", KEYPATH_WILDCARD, "readonlyIndexes", KEYPATH_WILDCARD],
+  ["header", "numReadonlySignedAccounts"],
+  ["header", "numReadonlyUnsignedAccounts"],
+  ["header", "numRequiredSignatures"],
+  ["instructions", KEYPATH_WILDCARD, "accounts", KEYPATH_WILDCARD],
+  ["instructions", KEYPATH_WILDCARD, "programIdIndex"],
+  ["instructions", KEYPATH_WILDCARD, "stackHeight"]
+];
+
+// src/index.ts
+function createSolanaRpcApi(config) {
+  return createJsonRpcApi({
+    requestTransformer: getDefaultRequestTransformerForSolanaRpc(config),
+    responseTransformer: getDefaultResponseTransformerForSolanaRpc({
+      allowedNumericKeyPaths: getAllowedNumericKeypaths$1()
+    })
+  });
+}
+var memoizedKeypaths$1;
+function getAllowedNumericKeypaths$1() {
+  if (!memoizedKeypaths$1) {
+    memoizedKeypaths$1 = {
+      getAccountInfo: jsonParsedAccountsConfigs.map((c) => ["value", ...c]),
+      getBlock: [
+        ["transactions", KEYPATH_WILDCARD, "meta", "preTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "preTokenBalances",
+          KEYPATH_WILDCARD,
+          "uiTokenAmount",
+          "decimals"
+        ],
+        ["transactions", KEYPATH_WILDCARD, "meta", "postTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "postTokenBalances",
+          KEYPATH_WILDCARD,
+          "uiTokenAmount",
+          "decimals"
+        ],
+        ["transactions", KEYPATH_WILDCARD, "meta", "rewards", KEYPATH_WILDCARD, "commission"],
+        ...innerInstructionsConfigs.map((c) => [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "innerInstructions",
+          KEYPATH_WILDCARD,
+          ...c
+        ]),
+        ...messageConfig.map((c) => ["transactions", KEYPATH_WILDCARD, "transaction", "message", ...c]),
+        ["rewards", KEYPATH_WILDCARD, "commission"]
+      ],
+      getClusterNodes: [
+        [KEYPATH_WILDCARD, "featureSet"],
+        [KEYPATH_WILDCARD, "shredVersion"]
+      ],
+      getInflationGovernor: [["initial"], ["foundation"], ["foundationTerm"], ["taper"], ["terminal"]],
+      getInflationRate: [["foundation"], ["total"], ["validator"]],
+      getInflationReward: [[KEYPATH_WILDCARD, "commission"]],
+      getMultipleAccounts: jsonParsedAccountsConfigs.map((c) => ["value", KEYPATH_WILDCARD, ...c]),
+      getProgramAccounts: jsonParsedAccountsConfigs.flatMap((c) => [
+        ["value", KEYPATH_WILDCARD, "account", ...c],
+        [KEYPATH_WILDCARD, "account", ...c]
+      ]),
+      getRecentPerformanceSamples: [[KEYPATH_WILDCARD, "samplePeriodSecs"]],
+      getTokenAccountBalance: [
+        ["value", "decimals"],
+        ["value", "uiAmount"]
+      ],
+      getTokenAccountsByDelegate: jsonParsedTokenAccountsConfigs.map((c) => [
+        "value",
+        KEYPATH_WILDCARD,
+        "account",
+        ...c
+      ]),
+      getTokenAccountsByOwner: jsonParsedTokenAccountsConfigs.map((c) => [
+        "value",
+        KEYPATH_WILDCARD,
+        "account",
+        ...c
+      ]),
+      getTokenLargestAccounts: [
+        ["value", KEYPATH_WILDCARD, "decimals"],
+        ["value", KEYPATH_WILDCARD, "uiAmount"]
+      ],
+      getTokenSupply: [
+        ["value", "decimals"],
+        ["value", "uiAmount"]
+      ],
+      getTransaction: [
+        ["meta", "preTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
+        ["meta", "preTokenBalances", KEYPATH_WILDCARD, "uiTokenAmount", "decimals"],
+        ["meta", "postTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
+        ["meta", "postTokenBalances", KEYPATH_WILDCARD, "uiTokenAmount", "decimals"],
+        ["meta", "rewards", KEYPATH_WILDCARD, "commission"],
+        ...innerInstructionsConfigs.map((c) => ["meta", "innerInstructions", KEYPATH_WILDCARD, ...c]),
+        ...messageConfig.map((c) => ["transaction", "message", ...c])
+      ],
+      getVersion: [["feature-set"]],
+      getVoteAccounts: [
+        ["current", KEYPATH_WILDCARD, "commission"],
+        ["delinquent", KEYPATH_WILDCARD, "commission"]
+      ],
+      simulateTransaction: [
+        ["value", "loadedAccountsDataSize"],
+        ...jsonParsedAccountsConfigs.map((c) => ["value", "accounts", KEYPATH_WILDCARD, ...c]),
+        ...innerInstructionsConfigs.map((c) => ["value", "innerInstructions", KEYPATH_WILDCARD, ...c])
+      ]
+    };
+  }
+  return memoizedKeypaths$1;
+}
+
+// src/http-transport.ts
+var DISALLOWED_HEADERS = {
+  accept: true,
+  "content-length": true,
+  "content-type": true
+};
+var FORBIDDEN_HEADERS = /* @__PURE__ */ Object.assign(
+  {
+    "accept-charset": true,
+    "access-control-request-headers": true,
+    "access-control-request-method": true,
+    connection: true,
+    "content-length": true,
+    cookie: true,
+    date: true,
+    dnt: true,
+    expect: true,
+    host: true,
+    "keep-alive": true,
+    "permissions-policy": true,
+    // Prefix matching is implemented in code, below.
+    // 'proxy-': true,
+    // 'sec-': true,
+    referer: true,
+    te: true,
+    trailer: true,
+    "transfer-encoding": true,
+    upgrade: true,
+    via: true
+  },
+  { "accept-encoding": true },
+  { origin: true } 
+);
+function assertIsAllowedHttpRequestHeaders(headers) {
+  const badHeaders = Object.keys(headers).filter((headerName) => {
+    const lowercaseHeaderName = headerName.toLowerCase();
+    return DISALLOWED_HEADERS[headerName.toLowerCase()] === true || FORBIDDEN_HEADERS[headerName.toLowerCase()] === true || lowercaseHeaderName.startsWith("proxy-") || lowercaseHeaderName.startsWith("sec-");
+  });
+  if (badHeaders.length > 0) {
+    throw new SolanaError(SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN, {
+      headers: badHeaders
+    });
+  }
+}
+function normalizeHeaders$1(headers) {
+  const out = {};
+  for (const headerName in headers) {
+    out[headerName.toLowerCase()] = headers[headerName];
+  }
+  return out;
+}
+
+// src/http-transport.ts
+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 (process.env.NODE_ENV !== "production" && true && "dispatcher_NODE_ONLY" in config) {
+    warnDispatcherWasSuppliedInNonNodeEnvironment();
+  }
+  const { fromJson, headers, toJson, url } = config;
+  if (process.env.NODE_ENV !== "production" && headers) {
+    assertIsAllowedHttpRequestHeaders(headers);
+  }
+  let dispatcherConfig;
+  const customHeaders = headers && normalizeHeaders$1(headers);
+  return async function makeHttpRequest({
+    payload,
+    signal
+  }) {
+    const body = toJson ? toJson(payload) : JSON.stringify(payload);
+    const requestInfo = {
+      ...dispatcherConfig,
+      body,
+      headers: {
+        ...customHeaders,
+        // Keep these headers lowercase so they will override any user-supplied headers above.
+        accept: "application/json",
+        "content-length": body.length.toString(),
+        "content-type": "application/json; charset=utf-8"
+      },
+      method: "POST",
+      signal
+    };
+    const response = await fetch(url, requestInfo);
+    if (!response.ok) {
+      throw new SolanaError(SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR, {
+        headers: response.headers,
+        message: response.statusText,
+        statusCode: response.status
+      });
+    }
+    if (fromJson) {
+      return fromJson(await response.text(), payload);
+    }
+    return await response.json();
+  };
+}
+var SOLANA_RPC_METHODS = [
+  "getAccountInfo",
+  "getBalance",
+  "getBlock",
+  "getBlockCommitment",
+  "getBlockHeight",
+  "getBlockProduction",
+  "getBlocks",
+  "getBlocksWithLimit",
+  "getBlockTime",
+  "getClusterNodes",
+  "getEpochInfo",
+  "getEpochSchedule",
+  "getFeeForMessage",
+  "getFirstAvailableBlock",
+  "getGenesisHash",
+  "getHealth",
+  "getHighestSnapshotSlot",
+  "getIdentity",
+  "getInflationGovernor",
+  "getInflationRate",
+  "getInflationReward",
+  "getLargestAccounts",
+  "getLatestBlockhash",
+  "getLeaderSchedule",
+  "getMaxRetransmitSlot",
+  "getMaxShredInsertSlot",
+  "getMinimumBalanceForRentExemption",
+  "getMultipleAccounts",
+  "getProgramAccounts",
+  "getRecentPerformanceSamples",
+  "getRecentPrioritizationFees",
+  "getSignaturesForAddress",
+  "getSignatureStatuses",
+  "getSlot",
+  "getSlotLeader",
+  "getSlotLeaders",
+  "getStakeMinimumDelegation",
+  "getSupply",
+  "getTokenAccountBalance",
+  "getTokenAccountsByDelegate",
+  "getTokenAccountsByOwner",
+  "getTokenLargestAccounts",
+  "getTokenSupply",
+  "getTransaction",
+  "getTransactionCount",
+  "getVersion",
+  "getVoteAccounts",
+  "index",
+  "isBlockhashValid",
+  "minimumLedgerSlot",
+  "requestAirdrop",
+  "sendTransaction",
+  "simulateTransaction"
+];
+function isSolanaRequest(payload) {
+  return isJsonRpcPayload(payload) && SOLANA_RPC_METHODS.includes(payload.method);
+}
+
+// src/http-transport-for-solana-rpc.ts
+function createHttpTransportForSolanaRpc(config) {
+  return createHttpTransport({
+    ...config,
+    fromJson: (rawResponse, payload) => isSolanaRequest(payload) ? parseJsonWithBigInts(rawResponse) : JSON.parse(rawResponse),
+    toJson: (payload) => isSolanaRequest(payload) ? stringifyJsonWithBigInts(payload) : JSON.stringify(payload)
+  });
+}
+
+// src/index.ts
+var objToString = Object.prototype.toString;
+var objKeys = Object.keys || function(obj) {
+  const keys = [];
+  for (const name in obj) {
+    keys.push(name);
+  }
+  return keys;
+};
+function stringify(val, isArrayProp) {
+  let i, max, str, keys, key, propVal, toStr;
+  if (val === true) {
+    return "true";
+  }
+  if (val === false) {
+    return "false";
+  }
+  switch (typeof val) {
+    case "object":
+      if (val === null) {
+        return null;
+      } else if ("toJSON" in val && typeof val.toJSON === "function") {
+        return stringify(val.toJSON(), isArrayProp);
+      } else {
+        toStr = objToString.call(val);
+        if (toStr === "[object Array]") {
+          str = "[";
+          max = val.length - 1;
+          for (i = 0; i < max; i++) {
+            str += stringify(val[i], true) + ",";
+          }
+          if (max > -1) {
+            str += stringify(val[i], true);
+          }
+          return str + "]";
+        } else if (toStr === "[object Object]") {
+          keys = objKeys(val).sort();
+          max = keys.length;
+          str = "";
+          i = 0;
+          while (i < max) {
+            key = keys[i];
+            propVal = stringify(val[key], false);
+            if (propVal !== void 0) {
+              if (str) {
+                str += ",";
+              }
+              str += JSON.stringify(key) + ":" + propVal;
+            }
+            i++;
+          }
+          return "{" + str + "}";
+        } else {
+          return JSON.stringify(val);
+        }
+      }
+    case "function":
+    case "undefined":
+      return isArrayProp ? null : void 0;
+    case "bigint":
+      return `${val.toString()}n`;
+    case "string":
+      return JSON.stringify(val);
+    default:
+      return isFinite(val) ? val : null;
+  }
+}
+function index_default(val) {
+  const returnVal = stringify(val, false);
+  if (returnVal !== void 0) {
+    return "" + returnVal;
+  }
+}
+
+// src/index.ts
+function createSolanaJsonRpcIntegerOverflowError$1(methodName, keyPath, value) {
+  let argumentLabel = "";
+  if (typeof keyPath[0] === "number") {
+    const argPosition = keyPath[0] + 1;
+    const lastDigit = argPosition % 10;
+    const lastTwoDigits = argPosition % 100;
+    if (lastDigit == 1 && lastTwoDigits != 11) {
+      argumentLabel = argPosition + "st";
+    } else if (lastDigit == 2 && lastTwoDigits != 12) {
+      argumentLabel = argPosition + "nd";
+    } else if (lastDigit == 3 && lastTwoDigits != 13) {
+      argumentLabel = argPosition + "rd";
+    } else {
+      argumentLabel = argPosition + "th";
+    }
+  } else {
+    argumentLabel = `\`${keyPath[0].toString()}\``;
+  }
+  const path = keyPath.length > 1 ? keyPath.slice(1).map((pathPart) => typeof pathPart === "number" ? `[${pathPart}]` : pathPart).join(".") : void 0;
+  const error = new SolanaError(SOLANA_ERROR__RPC__INTEGER_OVERFLOW, {
+    argumentLabel,
+    keyPath,
+    methodName,
+    optionalPathLabel: path ? ` at path \`${path}\`` : "",
+    value,
+    ...path !== void 0 ? { path } : void 0
+  });
+  safeCaptureStackTrace(error, createSolanaJsonRpcIntegerOverflowError$1);
+  return error;
+}
+
+// src/rpc-default-config.ts
+var DEFAULT_RPC_CONFIG = {
+  defaultCommitment: "confirmed",
+  onIntegerOverflow(request, keyPath, value) {
+    throw createSolanaJsonRpcIntegerOverflowError$1(request.methodName, keyPath, value);
+  }
+};
+
+// ../event-target-impl/dist/index.browser.mjs
+var o$3 = globalThis.AbortController;
+
+// src/rpc-request-coalescer.ts
+var EXPLICIT_ABORT_TOKEN$1;
+function createExplicitAbortToken$1() {
+  return process.env.NODE_ENV !== "production" ? {
+    EXPLICIT_ABORT_TOKEN: "This object 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(request) {
+    const { payload, signal } = request;
+    const deduplicationKey = getDeduplicationKey(payload);
+    if (deduplicationKey === void 0) {
+      return await transport(request);
+    }
+    if (!coalescedRequestsByDeduplicationKey) {
+      queueMicrotask(() => {
+        coalescedRequestsByDeduplicationKey = void 0;
+      });
+      coalescedRequestsByDeduplicationKey = {};
+    }
+    if (coalescedRequestsByDeduplicationKey[deduplicationKey] == null) {
+      const abortController = new o$3();
+      const responsePromise = (async () => {
+        try {
+          return await transport({
+            ...request,
+            signal: abortController.signal
+          });
+        } catch (e) {
+          if (e === (EXPLICIT_ABORT_TOKEN$1 ||= createExplicitAbortToken$1())) {
+            return;
+          }
+          throw e;
+        }
+      })();
+      coalescedRequestsByDeduplicationKey[deduplicationKey] = {
+        abortController,
+        numConsumers: 0,
+        responsePromise
+      };
+    }
+    const coalescedRequest = coalescedRequestsByDeduplicationKey[deduplicationKey];
+    coalescedRequest.numConsumers++;
+    if (signal) {
+      const responsePromise = coalescedRequest.responsePromise;
+      return await new Promise((resolve, reject) => {
+        const handleAbort = (e) => {
+          signal.removeEventListener("abort", handleAbort);
+          coalescedRequest.numConsumers -= 1;
+          queueMicrotask(() => {
+            if (coalescedRequest.numConsumers === 0) {
+              const abortController = coalescedRequest.abortController;
+              abortController.abort(EXPLICIT_ABORT_TOKEN$1 ||= createExplicitAbortToken$1());
+            }
+          });
+          reject(e.target.reason);
+        };
+        signal.addEventListener("abort", handleAbort);
+        responsePromise.then(resolve).catch(reject).finally(() => {
+          signal.removeEventListener("abort", handleAbort);
+        });
+      });
+    } else {
+      return await coalescedRequest.responsePromise;
+    }
+  };
+}
+function getSolanaRpcPayloadDeduplicationKey(payload) {
+  return isJsonRpcPayload(payload) ? index_default([payload.method, payload.params]) : void 0;
+}
+
+// src/rpc-transport.ts
+function normalizeHeaders(headers) {
+  const out = {};
+  for (const headerName in headers) {
+    out[headerName.toLowerCase()] = headers[headerName];
+  }
+  return out;
+}
+function createDefaultRpcTransport(config) {
+  return pipe(
+    createHttpTransportForSolanaRpc({
+      ...config,
+      headers: {
+        ...false,
+        ...config.headers ? normalizeHeaders(config.headers) : void 0,
+        ...{
+          // Keep these headers lowercase so they will override any user-supplied headers above.
+          "solana-client": `js/${"5.0.0"}` 
+        }
+      }
+    }),
+    (transport) => getRpcTransportWithRequestCoalescing(transport, getSolanaRpcPayloadDeduplicationKey)
+  );
+}
+
+// src/rpc.ts
+function createSolanaRpc(clusterUrl, config) {
+  return createSolanaRpcFromTransport(createDefaultRpcTransport({ url: clusterUrl, ...config }));
+}
+function createSolanaRpcFromTransport(transport) {
+  return createRpc({
+    api: createSolanaRpcApi(DEFAULT_RPC_CONFIG),
+    transport
+  });
+}
+
+// src/async-iterable.ts
+
+// ../event-target-impl/dist/index.browser.mjs
+var o$2 = globalThis.AbortController;
+var t$1 = globalThis.EventTarget;
+
+// src/async-iterable.ts
+var EXPLICIT_ABORT_TOKEN;
+function createExplicitAbortToken() {
+  return Symbol(
+    process.env.NODE_ENV !== "production" ? "This symbol is thrown from a socket's iterator when the connection is explicitly aborted by the user" : void 0
+  );
+}
+var UNINITIALIZED = Symbol();
+function createAsyncIterableFromDataPublisher({
+  abortSignal,
+  dataChannelName,
+  dataPublisher,
+  errorChannelName
+}) {
+  const iteratorState = /* @__PURE__ */ new Map();
+  function publishErrorToAllIterators(reason) {
+    for (const [iteratorKey, state] of iteratorState.entries()) {
+      if (state.__hasPolled) {
+        iteratorState.delete(iteratorKey);
+        state.onError(reason);
+      } else {
+        state.publishQueue.push({
+          __type: 1 /* ERROR */,
+          err: reason
+        });
+      }
+    }
+  }
+  const abortController = new o$2();
+  abortSignal.addEventListener("abort", () => {
+    abortController.abort();
+    publishErrorToAllIterators(EXPLICIT_ABORT_TOKEN ||= createExplicitAbortToken());
+  });
+  const options = { signal: abortController.signal };
+  let firstError = UNINITIALIZED;
+  dataPublisher.on(
+    errorChannelName,
+    (err) => {
+      if (firstError === UNINITIALIZED) {
+        firstError = err;
+        abortController.abort();
+        publishErrorToAllIterators(err);
+      }
+    },
+    options
+  );
+  dataPublisher.on(
+    dataChannelName,
+    (data) => {
+      iteratorState.forEach((state, iteratorKey) => {
+        if (state.__hasPolled) {
+          const { onData } = state;
+          iteratorState.set(iteratorKey, { __hasPolled: false, publishQueue: [] });
+          onData(data);
+        } else {
+          state.publishQueue.push({
+            __type: 0 /* DATA */,
+            data
+          });
+        }
+      });
+    },
+    options
+  );
+  return {
+    async *[Symbol.asyncIterator]() {
+      if (abortSignal.aborted) {
+        return;
+      }
+      if (firstError !== UNINITIALIZED) {
+        throw firstError;
+      }
+      const iteratorKey = Symbol();
+      iteratorState.set(iteratorKey, { __hasPolled: false, publishQueue: [] });
+      try {
+        while (true) {
+          const state = iteratorState.get(iteratorKey);
+          if (!state) {
+            throw new SolanaError(SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_STATE_MISSING);
+          }
+          if (state.__hasPolled) {
+            throw new SolanaError(
+              SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_MUST_NOT_POLL_BEFORE_RESOLVING_EXISTING_MESSAGE_PROMISE
+            );
+          }
+          const publishQueue = state.publishQueue;
+          try {
+            if (publishQueue.length) {
+              state.publishQueue = [];
+              for (const item of publishQueue) {
+                if (item.__type === 0 /* DATA */) {
+                  yield item.data;
+                } else {
+                  throw item.err;
+                }
+              }
+            } else {
+              yield await new Promise((resolve, reject) => {
+                iteratorState.set(iteratorKey, {
+                  __hasPolled: true,
+                  onData: resolve,
+                  onError: reject
+                });
+              });
+            }
+          } catch (e) {
+            if (e === (EXPLICIT_ABORT_TOKEN ||= createExplicitAbortToken())) {
+              return;
+            } else {
+              throw e;
+            }
+          }
+        }
+      } finally {
+        iteratorState.delete(iteratorKey);
+      }
+    }
+  };
+}
+
+// src/data-publisher.ts
+function getDataPublisherFromEventEmitter(eventEmitter) {
+  return {
+    on(channelName, subscriber, options) {
+      function innerListener(ev) {
+        if (ev instanceof CustomEvent) {
+          const data = ev.detail;
+          subscriber(data);
+        } else {
+          subscriber();
+        }
+      }
+      eventEmitter.addEventListener(channelName, innerListener, options);
+      return () => {
+        eventEmitter.removeEventListener(channelName, innerListener);
+      };
+    }
+  };
+}
+
+// src/demultiplex.ts
+function demultiplexDataPublisher(publisher, sourceChannelName, messageTransformer) {
+  let innerPublisherState;
+  const eventTarget = new t$1();
+  const demultiplexedDataPublisher = getDataPublisherFromEventEmitter(eventTarget);
+  return {
+    ...demultiplexedDataPublisher,
+    on(channelName, subscriber, options) {
+      if (!innerPublisherState) {
+        const innerPublisherUnsubscribe = publisher.on(sourceChannelName, (sourceMessage) => {
+          const transformResult = messageTransformer(sourceMessage);
+          if (!transformResult) {
+            return;
+          }
+          const [destinationChannelName, message] = transformResult;
+          eventTarget.dispatchEvent(
+            new CustomEvent(destinationChannelName, {
+              detail: message
+            })
+          );
+        });
+        innerPublisherState = {
+          dispose: innerPublisherUnsubscribe,
+          numSubscribers: 0
+        };
+      }
+      innerPublisherState.numSubscribers++;
+      const unsubscribe = demultiplexedDataPublisher.on(channelName, subscriber, options);
+      let isActive = true;
+      function handleUnsubscribe() {
+        if (!isActive) {
+          return;
+        }
+        isActive = false;
+        options?.signal.removeEventListener("abort", handleUnsubscribe);
+        innerPublisherState.numSubscribers--;
+        if (innerPublisherState.numSubscribers === 0) {
+          innerPublisherState.dispose();
+          innerPublisherState = void 0;
+        }
+        unsubscribe();
+      }
+      options?.signal.addEventListener("abort", handleUnsubscribe);
+      return handleUnsubscribe;
+    }
+  };
+}
+
+// src/rpc-subscriptions.ts
+function createSubscriptionRpc(rpcConfig) {
+  return new Proxy(rpcConfig.api, {
+    defineProperty() {
+      return false;
+    },
+    deleteProperty() {
+      return false;
+    },
+    get(target, p, receiver) {
+      if (p === "then") {
+        return void 0;
+      }
+      return function(...rawParams) {
+        const notificationName = p.toString();
+        const createRpcSubscriptionPlan = Reflect.get(target, notificationName, receiver);
+        if (!createRpcSubscriptionPlan) {
+          throw new SolanaError(SOLANA_ERROR__RPC_SUBSCRIPTIONS__CANNOT_CREATE_SUBSCRIPTION_PLAN, {
+            notificationName
+          });
+        }
+        const subscriptionPlan = createRpcSubscriptionPlan(...rawParams);
+        return createPendingRpcSubscription(rpcConfig.transport, subscriptionPlan);
+      };
+    }
+  });
+}
+function createPendingRpcSubscription(transport, subscriptionsPlan) {
+  return {
+    async subscribe({ abortSignal }) {
+      const notificationsDataPublisher = await transport({
+        signal: abortSignal,
+        ...subscriptionsPlan
+      });
+      return createAsyncIterableFromDataPublisher({
+        abortSignal,
+        dataChannelName: "notification",
+        dataPublisher: notificationsDataPublisher,
+        errorChannelName: "error"
+      });
+    }
+  };
+}
+
+// src/rpc-subscriptions-api.ts
+function createRpcSubscriptionsApi(config) {
+  return new Proxy({}, {
+    defineProperty() {
+      return false;
+    },
+    deleteProperty() {
+      return false;
+    },
+    get(...args) {
+      const [_, p] = args;
+      const methodName = p.toString();
+      return function(...params) {
+        const rawRequest = { methodName, params };
+        const request = config.requestTransformer ? config.requestTransformer(rawRequest) : rawRequest;
+        return {
+          execute(planConfig) {
+            return config.planExecutor({ ...planConfig, request });
+          },
+          request
+        };
+      };
+    }
+  });
+}
+
+// src/rpc-subscriptions-channel.ts
+function transformChannelInboundMessages(channel, transform) {
+  return Object.freeze({
+    ...channel,
+    on(type, subscriber, options) {
+      if (type !== "message") {
+        return channel.on(
+          type,
+          subscriber,
+          options
+        );
+      }
+      return channel.on(
+        "message",
+        (message) => subscriber(transform(message)),
+        options
+      );
+    }
+  });
+}
+function transformChannelOutboundMessages(channel, transform) {
+  return Object.freeze({
+    ...channel,
+    send: (message) => channel.send(transform(message))
+  });
+}
+
+// ../event-target-impl/dist/index.browser.mjs
+var o$1 = globalThis.AbortController;
+var subscriberCountBySubscriptionIdByChannel = /* @__PURE__ */ new WeakMap();
+function decrementSubscriberCountAndReturnNewCount(channel, subscriptionId) {
+  return augmentSubscriberCountAndReturnNewCount(-1, channel, subscriptionId);
+}
+function incrementSubscriberCount(channel, subscriptionId) {
+  augmentSubscriberCountAndReturnNewCount(1, channel, subscriptionId);
+}
+function getSubscriberCountBySubscriptionIdForChannel(channel) {
+  let subscriberCountBySubscriptionId = subscriberCountBySubscriptionIdByChannel.get(channel);
+  if (!subscriberCountBySubscriptionId) {
+    subscriberCountBySubscriptionIdByChannel.set(channel, subscriberCountBySubscriptionId = {});
+  }
+  return subscriberCountBySubscriptionId;
+}
+function augmentSubscriberCountAndReturnNewCount(amount, channel, subscriptionId) {
+  if (subscriptionId === void 0) {
+    return;
+  }
+  const subscriberCountBySubscriptionId = getSubscriberCountBySubscriptionIdForChannel(channel);
+  if (!subscriberCountBySubscriptionId[subscriptionId] && amount > 0) {
+    subscriberCountBySubscriptionId[subscriptionId] = 0;
+  }
+  const newCount = amount + subscriberCountBySubscriptionId[subscriptionId];
+  if (newCount <= 0) {
+    delete subscriberCountBySubscriptionId[subscriptionId];
+  } else {
+    subscriberCountBySubscriptionId[subscriptionId] = newCount;
+  }
+  return newCount;
+}
+var cache = /* @__PURE__ */ new WeakMap();
+function getMemoizedDemultiplexedNotificationPublisherFromChannelAndResponseTransformer(channel, subscribeRequest, responseTransformer) {
+  let publisherByResponseTransformer = cache.get(channel);
+  if (!publisherByResponseTransformer) {
+    cache.set(channel, publisherByResponseTransformer = /* @__PURE__ */ new WeakMap());
+  }
+  const responseTransformerKey = responseTransformer ?? channel;
+  let publisher = publisherByResponseTransformer.get(responseTransformerKey);
+  if (!publisher) {
+    publisherByResponseTransformer.set(
+      responseTransformerKey,
+      publisher = demultiplexDataPublisher(channel, "message", (rawMessage) => {
+        const message = rawMessage;
+        if (!("method" in message)) {
+          return;
+        }
+        const transformedNotification = responseTransformer ? responseTransformer(message.params.result, subscribeRequest) : message.params.result;
+        return [`notification:${message.params.subscription}`, transformedNotification];
+      })
+    );
+  }
+  return publisher;
+}
+async function executeRpcPubSubSubscriptionPlan({
+  channel,
+  responseTransformer,
+  signal,
+  subscribeRequest,
+  unsubscribeMethodName
+}) {
+  let subscriptionId;
+  channel.on(
+    "error",
+    () => {
+      subscriptionId = void 0;
+      subscriberCountBySubscriptionIdByChannel.delete(channel);
+    },
+    { signal }
+  );
+  const abortPromise = new Promise((_, reject) => {
+    function handleAbort() {
+      if (decrementSubscriberCountAndReturnNewCount(channel, subscriptionId) === 0) {
+        const unsubscribePayload = createRpcMessage({
+          methodName: unsubscribeMethodName,
+          params: [subscriptionId]
+        });
+        subscriptionId = void 0;
+        channel.send(unsubscribePayload).catch(() => {
+        });
+      }
+      reject(this.reason);
+    }
+    if (signal.aborted) {
+      handleAbort.call(signal);
+    } else {
+      signal.addEventListener("abort", handleAbort);
+    }
+  });
+  const subscribePayload = createRpcMessage(subscribeRequest);
+  await channel.send(subscribePayload);
+  const subscriptionIdPromise = new Promise((resolve, reject) => {
+    const abortController = new o$1();
+    signal.addEventListener("abort", abortController.abort.bind(abortController));
+    const options = { signal: abortController.signal };
+    channel.on(
+      "error",
+      (err) => {
+        abortController.abort();
+        reject(err);
+      },
+      options
+    );
+    channel.on(
+      "message",
+      (message) => {
+        if (message && typeof message === "object" && "id" in message && message.id === subscribePayload.id) {
+          abortController.abort();
+          if ("error" in message) {
+            reject(getSolanaErrorFromJsonRpcError(message.error));
+          } else {
+            resolve(message.result);
+          }
+        }
+      },
+      options
+    );
+  });
+  subscriptionId = await safeRace([abortPromise, subscriptionIdPromise]);
+  if (subscriptionId == null) {
+    throw new SolanaError(SOLANA_ERROR__RPC_SUBSCRIPTIONS__EXPECTED_SERVER_SUBSCRIPTION_ID);
+  }
+  incrementSubscriberCount(channel, subscriptionId);
+  const notificationPublisher = getMemoizedDemultiplexedNotificationPublisherFromChannelAndResponseTransformer(
+    channel,
+    subscribeRequest,
+    responseTransformer
+  );
+  const notificationKey = `notification:${subscriptionId}`;
+  return {
+    on(type, listener, options) {
+      switch (type) {
+        case "notification":
+          return notificationPublisher.on(
+            notificationKey,
+            listener,
+            options
+          );
+        case "error":
+          return channel.on(
+            "error",
+            listener,
+            options
+          );
+        default:
+          throw new SolanaError(SOLANA_ERROR__INVARIANT_VIOLATION__DATA_PUBLISHER_CHANNEL_UNIMPLEMENTED, {
+            channelName: type,
+            supportedChannelNames: ["notification", "error"]
+          });
+      }
+    }
+  };
+}
+
+// src/index.ts
+function createSolanaRpcSubscriptionsApi_INTERNAL(config) {
+  const requestTransformer = getDefaultRequestTransformerForSolanaRpc(config);
+  const responseTransformer = getDefaultResponseTransformerForSolanaRpcSubscriptions({
+    allowedNumericKeyPaths: getAllowedNumericKeypaths()
+  });
+  return createRpcSubscriptionsApi({
+    planExecutor({ request, ...rest }) {
+      return executeRpcPubSubSubscriptionPlan({
+        ...rest,
+        responseTransformer,
+        subscribeRequest: { ...request, methodName: request.methodName.replace(/Notifications$/, "Subscribe") },
+        unsubscribeMethodName: request.methodName.replace(/Notifications$/, "Unsubscribe")
+      });
+    },
+    requestTransformer
+  });
+}
+function createSolanaRpcSubscriptionsApi(config) {
+  return createSolanaRpcSubscriptionsApi_INTERNAL(config);
+}
+var memoizedKeypaths;
+function getAllowedNumericKeypaths() {
+  if (!memoizedKeypaths) {
+    memoizedKeypaths = {
+      accountNotifications: jsonParsedAccountsConfigs.map((c) => ["value", ...c]),
+      blockNotifications: [
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "preTokenBalances",
+          KEYPATH_WILDCARD,
+          "accountIndex"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "preTokenBalances",
+          KEYPATH_WILDCARD,
+          "uiTokenAmount",
+          "decimals"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "postTokenBalances",
+          KEYPATH_WILDCARD,
+          "accountIndex"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "postTokenBalances",
+          KEYPATH_WILDCARD,
+          "uiTokenAmount",
+          "decimals"
+        ],
+        ["value", "block", "transactions", KEYPATH_WILDCARD, "meta", "rewards", KEYPATH_WILDCARD, "commission"],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "innerInstructions",
+          KEYPATH_WILDCARD,
+          "index"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "innerInstructions",
+          KEYPATH_WILDCARD,
+          "instructions",
+          KEYPATH_WILDCARD,
+          "programIdIndex"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "innerInstructions",
+          KEYPATH_WILDCARD,
+          "instructions",
+          KEYPATH_WILDCARD,
+          "accounts",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "addressTableLookups",
+          KEYPATH_WILDCARD,
+          "writableIndexes",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "addressTableLookups",
+          KEYPATH_WILDCARD,
+          "readonlyIndexes",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "instructions",
+          KEYPATH_WILDCARD,
+          "programIdIndex"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "instructions",
+          KEYPATH_WILDCARD,
+          "accounts",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "header",
+          "numReadonlySignedAccounts"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "header",
+          "numReadonlyUnsignedAccounts"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "header",
+          "numRequiredSignatures"
+        ],
+        ["value", "block", "rewards", KEYPATH_WILDCARD, "commission"]
+      ],
+      programNotifications: jsonParsedAccountsConfigs.flatMap((c) => [
+        ["value", KEYPATH_WILDCARD, "account", ...c],
+        [KEYPATH_WILDCARD, "account", ...c]
+      ])
+    };
+  }
+  return memoizedKeypaths;
+}
+
+// src/websocket-channel.ts
+var t = globalThis.EventTarget;
+
+// ../ws-impl/dist/index.browser.mjs
+var e = globalThis.WebSocket;
+
+// src/websocket-channel.ts
+var NORMAL_CLOSURE_CODE = 1e3;
+function createWebSocketChannel({
+  sendBufferHighWatermark,
+  signal,
+  url
+}) {
+  if (signal.aborted) {
+    return Promise.reject(signal.reason);
+  }
+  let bufferDrainWatcher;
+  let hasConnected = false;
+  const listenerRemovers = /* @__PURE__ */ new Set();
+  function cleanupListeners() {
+    listenerRemovers.forEach((r) => {
+      r();
+    });
+    listenerRemovers.clear();
+  }
+  function handleAbort() {
+    cleanupListeners();
+    if (!hasConnected) {
+      rejectOpen(signal.reason);
+    }
+    if (webSocket.readyState !== e.CLOSED && webSocket.readyState !== e.CLOSING) {
+      webSocket.close(NORMAL_CLOSURE_CODE);
+    }
+  }
+  function handleClose(ev) {
+    cleanupListeners();
+    bufferDrainWatcher?.onCancel();
+    signal.removeEventListener("abort", handleAbort);
+    webSocket.removeEventListener("close", handleClose);
+    webSocket.removeEventListener("error", handleError);
+    webSocket.removeEventListener("message", handleMessage);
+    webSocket.removeEventListener("open", handleOpen);
+    if (!signal.aborted && !(ev.wasClean && ev.code === NORMAL_CLOSURE_CODE)) {
+      eventTarget.dispatchEvent(
+        new CustomEvent("error", {
+          detail: new SolanaError(SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CONNECTION_CLOSED, {
+            cause: ev
+          })
+        })
+      );
+    }
+  }
+  function handleError(ev) {
+    if (signal.aborted) {
+      return;
+    }
+    if (!hasConnected) {
+      const failedToConnectError = new SolanaError(SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_FAILED_TO_CONNECT, {
+        errorEvent: ev
+      });
+      rejectOpen(failedToConnectError);
+      eventTarget.dispatchEvent(
+        new CustomEvent("error", {
+          detail: failedToConnectError
+        })
+      );
+    }
+  }
+  function handleMessage(ev) {
+    if (signal.aborted) {
+      return;
+    }
+    eventTarget.dispatchEvent(new CustomEvent("message", { detail: ev.data }));
+  }
+  const eventTarget = new t();
+  const dataPublisher = getDataPublisherFromEventEmitter(eventTarget);
+  function handleOpen() {
+    hasConnected = true;
+    resolveOpen({
+      ...dataPublisher,
+      async send(message) {
+        if (webSocket.readyState !== e.OPEN) {
+          throw new SolanaError(SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CONNECTION_CLOSED);
+        }
+        if (!bufferDrainWatcher && webSocket.bufferedAmount > sendBufferHighWatermark) {
+          let onCancel;
+          const promise = new Promise((resolve, reject) => {
+            const intervalId = setInterval(() => {
+              if (webSocket.readyState !== e.OPEN || !(webSocket.bufferedAmount > sendBufferHighWatermark)) {
+                clearInterval(intervalId);
+                bufferDrainWatcher = void 0;
+                resolve();
+              }
+            }, 16);
+            onCancel = () => {
+              bufferDrainWatcher = void 0;
+              clearInterval(intervalId);
+              reject(
+                new SolanaError(
+                  SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CLOSED_BEFORE_MESSAGE_BUFFERED
+                )
+              );
+            };
+          });
+          bufferDrainWatcher = {
+            onCancel,
+            promise
+          };
+        }
+        if (bufferDrainWatcher) {
+          if (ArrayBuffer.isView(message) && !(message instanceof DataView)) {
+            const TypedArrayConstructor = message.constructor;
+            message = new TypedArrayConstructor(message);
+          }
+          await bufferDrainWatcher.promise;
+        }
+        webSocket.send(message);
+      }
+    });
+  }
+  const webSocket = new e(url);
+  signal.addEventListener("abort", handleAbort);
+  webSocket.addEventListener("close", handleClose);
+  webSocket.addEventListener("error", handleError);
+  webSocket.addEventListener("message", handleMessage);
+  webSocket.addEventListener("open", handleOpen);
+  let rejectOpen;
+  let resolveOpen;
+  return new Promise((resolve, reject) => {
+    rejectOpen = reject;
+    resolveOpen = resolve;
+  });
+}
+
+// src/index.ts
+function createSolanaJsonRpcIntegerOverflowError(methodName, keyPath, value) {
+  let argumentLabel = "";
+  if (typeof keyPath[0] === "number") {
+    const argPosition = keyPath[0] + 1;
+    const lastDigit = argPosition % 10;
+    const lastTwoDigits = argPosition % 100;
+    if (lastDigit == 1 && lastTwoDigits != 11) {
+      argumentLabel = argPosition + "st";
+    } else if (lastDigit == 2 && lastTwoDigits != 12) {
+      argumentLabel = argPosition + "nd";
+    } else if (lastDigit == 3 && lastTwoDigits != 13) {
+      argumentLabel = argPosition + "rd";
+    } else {
+      argumentLabel = argPosition + "th";
+    }
+  } else {
+    argumentLabel = `\`${keyPath[0].toString()}\``;
+  }
+  const path = keyPath.length > 1 ? keyPath.slice(1).map((pathPart) => typeof pathPart === "number" ? `[${pathPart}]` : pathPart).join(".") : void 0;
+  const error = new SolanaError(SOLANA_ERROR__RPC__INTEGER_OVERFLOW, {
+    argumentLabel,
+    keyPath,
+    methodName,
+    optionalPathLabel: path ? ` at path \`${path}\`` : "",
+    value,
+    ...path !== void 0 ? { path } : void 0
+  });
+  safeCaptureStackTrace(error, createSolanaJsonRpcIntegerOverflowError);
+  return error;
+}
+
+// src/rpc-default-config.ts
+var DEFAULT_RPC_SUBSCRIPTIONS_CONFIG = {
+  defaultCommitment: "confirmed",
+  onIntegerOverflow(request, keyPath, value) {
+    throw createSolanaJsonRpcIntegerOverflowError(request.methodName, keyPath, value);
+  }
+};
+
+// ../event-target-impl/dist/index.browser.mjs
+var o = globalThis.AbortController;
+
+// src/rpc-subscriptions-autopinger.ts
+var PING_PAYLOAD = {
+  jsonrpc: "2.0",
+  method: "ping"
+};
+function getRpcSubscriptionsChannelWithAutoping({
+  abortSignal: callerAbortSignal,
+  channel,
+  intervalMs
+}) {
+  let intervalId;
+  function sendPing() {
+    channel.send(PING_PAYLOAD).catch((e) => {
+      if (isSolanaError(e, SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CONNECTION_CLOSED)) {
+        pingerAbortController.abort();
+      }
+    });
+  }
+  function restartPingTimer() {
+    clearInterval(intervalId);
+    intervalId = setInterval(sendPing, intervalMs);
+  }
+  const pingerAbortController = new o();
+  pingerAbortController.signal.addEventListener("abort", () => {
+    clearInterval(intervalId);
+  });
+  callerAbortSignal.addEventListener("abort", () => {
+    pingerAbortController.abort();
+  });
+  channel.on(
+    "error",
+    () => {
+      pingerAbortController.abort();
+    },
+    { signal: pingerAbortController.signal }
+  );
+  channel.on("message", restartPingTimer, { signal: pingerAbortController.signal });
+  if (globalThis.navigator.onLine) {
+    restartPingTimer();
+  }
+  {
+    globalThis.addEventListener(
+      "offline",
+      function handleOffline() {
+        clearInterval(intervalId);
+      },
+      { signal: pingerAbortController.signal }
+    );
+    globalThis.addEventListener(
+      "online",
+      function handleOnline() {
+        sendPing();
+        restartPingTimer();
+      },
+      { signal: pingerAbortController.signal }
+    );
+  }
+  return {
+    ...channel,
+    send(...args) {
+      if (!pingerAbortController.signal.aborted) {
+        restartPingTimer();
+      }
+      return channel.send(...args);
+    }
+  };
+}
+
+// src/rpc-subscriptions-channel-pool-internal.ts
+function createChannelPool() {
+  return {
+    entries: [],
+    freeChannelIndex: -1
+  };
+}
+
+// src/rpc-subscriptions-channel-pool.ts
+function getChannelPoolingChannelCreator(createChannel, { maxSubscriptionsPerChannel, minChannels }) {
+  const pool = createChannelPool();
+  function recomputeFreeChannelIndex() {
+    if (pool.entries.length < minChannels) {
+      pool.freeChannelIndex = -1;
+      return;
+    }
+    let mostFreeChannel;
+    for (let ii = 0; ii < pool.entries.length; ii++) {
+      const nextPoolIndex = (pool.freeChannelIndex + ii + 2) % pool.entries.length;
+      const nextPoolEntry = (
+        // Start from the item two positions after the current item. This way, the
+        // search will finish on the item after the current one. This ensures that, if
+        // any channels tie for having the most capacity, the one that will be chosen is
+        // the one immediately to the current one's right (wrapping around).
+        pool.entries[nextPoolIndex]
+      );
+      if (nextPoolEntry.subscriptionCount < maxSubscriptionsPerChannel && (!mostFreeChannel || mostFreeChannel.subscriptionCount >= nextPoolEntry.subscriptionCount)) {
+        mostFreeChannel = {
+          poolIndex: nextPoolIndex,
+          subscriptionCount: nextPoolEntry.subscriptionCount
+        };
+      }
+    }
+    pool.freeChannelIndex = mostFreeChannel?.poolIndex ?? -1;
+  }
+  return function getExistingChannelWithMostCapacityOrCreateChannel({ abortSignal }) {
+    let poolEntry;
+    function destroyPoolEntry() {
+      const index = pool.entries.findIndex((entry) => entry === poolEntry);
+      pool.entries.splice(index, 1);
+      poolEntry.dispose();
+      recomputeFreeChannelIndex();
+    }
+    if (pool.freeChannelIndex === -1) {
+      const abortController = new o();
+      const newChannelPromise = createChannel({ abortSignal: abortController.signal });
+      newChannelPromise.then((newChannel) => {
+        newChannel.on("error", destroyPoolEntry, { signal: abortController.signal });
+      }).catch(destroyPoolEntry);
+      poolEntry = {
+        channel: newChannelPromise,
+        dispose() {
+          abortController.abort();
+        },
+        subscriptionCount: 0
+      };
+      pool.entries.push(poolEntry);
+    } else {
+      poolEntry = pool.entries[pool.freeChannelIndex];
+    }
+    poolEntry.subscriptionCount++;
+    abortSignal.addEventListener("abort", function destroyConsumer() {
+      poolEntry.subscriptionCount--;
+      if (poolEntry.subscriptionCount === 0) {
+        destroyPoolEntry();
+      } else if (pool.freeChannelIndex !== -1) {
+        pool.freeChannelIndex--;
+        recomputeFreeChannelIndex();
+      }
+    });
+    recomputeFreeChannelIndex();
+    return poolEntry.channel;
+  };
+}
+function getRpcSubscriptionsChannelWithBigIntJSONSerialization(channel) {
+  return pipe(
+    channel,
+    (c) => transformChannelInboundMessages(c, parseJsonWithBigInts),
+    (c) => transformChannelOutboundMessages(c, stringifyJsonWithBigInts)
+  );
+}
+
+// src/rpc-subscriptions-channel.ts
+function createDefaultSolanaRpcSubscriptionsChannelCreator(config) {
+  return createDefaultRpcSubscriptionsChannelCreatorImpl({
+    ...config,
+    jsonSerializer: getRpcSubscriptionsChannelWithBigIntJSONSerialization
+  });
+}
+function createDefaultRpcSubscriptionsChannelCreatorImpl(config) {
+  if (/^wss?:/i.test(config.url) === false) {
+    const protocolMatch = config.url.match(/^([^:]+):/);
+    throw new DOMException(
+      protocolMatch ? `Failed to construct 'WebSocket': The URL's scheme must be either 'ws' or 'wss'. '${protocolMatch[1]}:' is not allowed.` : `Failed to construct 'WebSocket': The URL '${config.url}' is invalid.`
+    );
+  }
+  const { intervalMs, ...rest } = config;
+  const createDefaultRpcSubscriptionsChannel = ({ abortSignal }) => {
+    return createWebSocketChannel({
+      ...rest,
+      sendBufferHighWatermark: config.sendBufferHighWatermark ?? // Let 128KB of data into the WebSocket buffer before buffering it in the app.
+      131072,
+      signal: abortSignal
+    }).then(config.jsonSerializer).then(
+      (channel) => getRpcSubscriptionsChannelWithAutoping({
+        abortSignal,
+        channel,
+        intervalMs: intervalMs ?? 5e3
+      })
+    );
+  };
+  return getChannelPoolingChannelCreator(createDefaultRpcSubscriptionsChannel, {
+    maxSubscriptionsPerChannel: config.maxSubscriptionsPerChannel ?? /**
+     * A note about this default. The idea here is that, because some RPC providers impose
+     * an upper limit on the number of subscriptions you can make per channel, we must
+     * choose a number low enough to avoid hitting that limit. Without knowing what provider
+     * a given person is using, or what their limit is, we have to choose the lowest of all
+     * known limits. As of this writing (October 2024) that is the public mainnet RPC node
+     * (api.mainnet-beta.solana.com) at 100 subscriptions.
+     */
+    100,
+    minChannels: config.minChannels ?? 1
+  });
+}
+function getRpcSubscriptionsTransportWithSubscriptionCoalescing(transport) {
+  const cache = /* @__PURE__ */ new Map();
+  return function rpcSubscriptionsTransportWithSubscriptionCoalescing(config) {
+    const { request, signal } = config;
+    const subscriptionConfigurationHash = index_default([request.methodName, request.params]);
+    let cachedDataPublisherPromise = cache.get(subscriptionConfigurationHash);
+    if (!cachedDataPublisherPromise) {
+      const abortController = new o();
+      const dataPublisherPromise = transport({
+        ...config,
+        signal: abortController.signal
+      });
+      dataPublisherPromise.then((dataPublisher) => {
+        dataPublisher.on(
+          "error",
+          () => {
+            cache.delete(subscriptionConfigurationHash);
+            abortController.abort();
+          },
+          { signal: abortController.signal }
+        );
+      }).catch(() => {
+      });
+      cache.set(
+        subscriptionConfigurationHash,
+        cachedDataPublisherPromise = {
+          abortController,
+          dataPublisherPromise,
+          numSubscribers: 0
+        }
+      );
+    }
+    cachedDataPublisherPromise.numSubscribers++;
+    signal.addEventListener(
+      "abort",
+      () => {
+        cachedDataPublisherPromise.numSubscribers--;
+        if (cachedDataPublisherPromise.numSubscribers === 0) {
+          queueMicrotask(() => {
+            if (cachedDataPublisherPromise.numSubscribers === 0) {
+              cache.delete(subscriptionConfigurationHash);
+              cachedDataPublisherPromise.abortController.abort();
+            }
+          });
+        }
+      },
+      { signal: cachedDataPublisherPromise.abortController.signal }
+    );
+    return cachedDataPublisherPromise.dataPublisherPromise;
+  };
+}
+function createDefaultRpcSubscriptionsTransport({
+  createChannel
+}) {
+  return pipe(
+    createRpcSubscriptionsTransportFromChannelCreator(
+      createChannel
+    ),
+    (transport) => getRpcSubscriptionsTransportWithSubscriptionCoalescing(transport)
+  );
+}
+function createRpcSubscriptionsTransportFromChannelCreator(createChannel) {
+  return async ({ execute, signal }) => {
+    const channel = await createChannel({ abortSignal: signal });
+    return await execute({ channel, signal });
+  };
+}
+function createSolanaRpcSubscriptionsImpl(clusterUrl, config) {
+  const transport = createDefaultRpcSubscriptionsTransport({
+    createChannel: createDefaultSolanaRpcSubscriptionsChannelCreator({ ...config, url: clusterUrl })
+  });
+  return createSolanaRpcSubscriptionsFromTransport(transport);
+}
+function createSolanaRpcSubscriptions(clusterUrl, config) {
+  return createSolanaRpcSubscriptionsImpl(clusterUrl, config);
+}
+function createSolanaRpcSubscriptionsFromTransport(transport) {
+  return createSubscriptionRpc({
+    api: createSolanaRpcSubscriptionsApi(DEFAULT_RPC_SUBSCRIPTIONS_CONFIG),
+    transport
+  });
+}
+
+const SURFNET_RPC_URL = "https://surfpool.fly.dev";
+let React;
+let ReactDOM;
+let privyImports;
+let privySolana;
+// Only load React and Privy dependencies if we're in a browser
+if (typeof window !== 'undefined') {
+    React = require('react');
+    ReactDOM = require('react-dom/client');
+    privyImports = require('@privy-io/react-auth');
+    privySolana = require('@privy-io/react-auth/solana');
+}
+const defaultPrivyConfig = {
+    appId: "cm4ve714908o27dk2yurpnfhd",
+    config: {
+        embeddedWallets: {
+            solana: {
+                createOnLogin: "users-without-wallets"
+            }
+        },
+        appearance: {
+            walletChainType: 'solana-only'
+        },
+        externalWallets: { solana: { connectors: privySolana.toSolanaWalletConnectors() } }
+    }
+};
+class PrivyWalletProvider {
+    constructor(appName, appLogoUrl, privyConfig, networkUrl = null) {
+        this.containerElement = null;
+        this.chainId = 'solana:mainnet';
+        this.root = null;
+        this.privyMethods = null;
+        this.privyConfig = defaultPrivyConfig;
+        this.pendingLogin = null;
+        // This is used to store the pending transaction until the wallet is connected for workaround for the wallet not being connected after login completion
+        this.pendingTransaction = null;
+        // This is used to store pending signTransaction calls until the wallet is connected
+        this.pendingSignTransaction = null;
+        // This is used to store pending signMessage calls until the wallet is connected
+        this.pendingSignMessage = null;
+        // This is used to store pending signAndSubmitTransaction calls until the wallet is connected
+        this.pendingSignAndSubmitTransaction = null;
+        this.networkUrl = networkUrl;
+        if (typeof window === 'undefined') {
+            throw new Error('PrivyWalletProvider can only be instantiated in a browser environment');
+        }
+        if (PrivyWalletProvider.instance) {
+            return PrivyWalletProvider.instance;
+        }
+        this.containerElement = null;
+        this.root = null;
+        this.privyMethods = null;
+        this.privyConfig = privyConfig !== null && privyConfig !== void 0 ? privyConfig : defaultPrivyConfig;
+        // Only use the appName and appLogoUrl if no privyConfig is provided
+        if (privyConfig == null) {
+            if (appName != null && appName != '') {
+                this.privyConfig.config.appearance.landingHeader = appName;
+            }
+            if (appLogoUrl != null && appLogoUrl != '') {
+                this.privyConfig.config.appearance.logo = appLogoUrl;
+            }
+        }
+        // Ensure externalWallets connectors are always configured — required for
+        // useWallets().ready to resolve even when no browser extension is present
+        if (!this.privyConfig.config.externalWallets) {
+            this.privyConfig.config.externalWallets = {
+                solana: { connectors: privySolana.toSolanaWalletConnectors() }
+            };
+        }
+        // Add Solana RPC configuration for v3
+        let devnetUrl = SOLANA_DEVNET_RPC_URL;
+        let mainnetUrl = SOLANA_MAINNET_RPC_URL;
+        if (networkUrl != null) {
+            if (networkUrl.includes('mainnet')) {
+                mainnetUrl = networkUrl;
+                this.chainId = 'solana:mainnet';
+            }
+            else if (networkUrl.includes('devnet')) {
+                devnetUrl = networkUrl;
+                this.chainId = 'solana:devnet';
+            }
+        }
+        if (!this.privyConfig.config.solana) {
+            this.privyConfig.config.solana = {};
+        }
+        this.privyConfig.config.solana.rpcs = {
+            'solana:devnet': {
+                rpc: createSolanaRpc(devnetUrl),
+                rpcSubscriptions: createSolanaRpcSubscriptions(devnetUrl.replace('https://', 'wss://'))
+            },
+            'solana:mainnet': {
+                rpc: createSolanaRpc(mainnetUrl),
+                rpcSubscriptions: createSolanaRpcSubscriptions(mainnetUrl.replace('https://', 'wss://'))
+            }
+        };
+        const existingProviders = document.querySelectorAll('[data-privy-provider]');
+        existingProviders.forEach(el => el.remove());
+        this.initialize();
+        // Assign this instance to the static instance property
+        PrivyWalletProvider.instance = this;
+    }
+    // Optional: Provide a static method to get the instance
+    static getInstance(appName, appLogoUrl, privyConfig) {
+        if (!PrivyWalletProvider.instance) {
+            new PrivyWalletProvider(appName, appLogoUrl, privyConfig);
+        }
+        return PrivyWalletProvider.instance;
+    }
+    initialize() {
+        if (!this.containerElement) {
+            this.containerElement = document.createElement('div');
+            this.containerElement.setAttribute('data-privy-provider', 'true');
+            document.body.appendChild(this.containerElement);
+            const that = this;
+            const PrivyComponent = () => {
+                const privy = privyImports.usePrivy();
+                const useOAuthTokens = privyImports.useOAuthTokens();
+                const useFundWalletSolana = privySolana.useFundWallet();
+                const useSendTransactionSolana = privySolana.useSignAndSendTransaction();
+                const { signTransaction } = privySolana.useSignTransaction();
+                const { signMessage: signMessageHook } = privySolana.useSignMessage();
+                const { ready: walletReady, wallets } = privySolana.useWallets();
+                const { createWallet } = privySolana.useCreateWallet();
+                const { exportWallet } = privySolana.useExportWallet();
+                const useSolanaWallets = { createWallet, exportWallet, ready: walletReady, wallets };
+                const useIdentityToken = privyImports.useIdentityToken();
+                const { connectWallet } = privyImports.useConnectWallet({
+                    onSuccess: async ({ wallet }) => {
+                        await that.createSession(wallet.address, await privy.getAccessToken(), useIdentityToken.identityToken);
+                        // If there's a pending transaction, execute it now
+                        if (that.pendingTransaction) {
+                            const { evmTransactionData, solTransactionData, options, resolve, reject } = that.pendingTransaction;
+                            try {
+                                const result = await that.runTransaction(evmTransactionData, solTransactionData, options);
+                                resolve(result);
+                            }
+                            catch (error) {
+                                reject(error);
+                            }
+                            that.pendingTransaction = null;
+                        }
+                        // If there's a pending signTransaction, execute it now
+                        if (that.pendingSignTransaction) {
+                            const { transaction, resolve, reject } = that.pendingSignTransaction;
+                            try {
+                                const result = await that.signTransaction(transaction);
+                                resolve(result);
+                            }
+                            catch (error) {
+                                reject(error);
+                            }
+                            that.pendingSignTransaction = null;
+                        }
+                        // If there's a pending signMessage, execute it now
+                        if (that.pendingSignMessage) {
+                            const { message, resolve, reject } = that.pendingSignMessage;
+                            try {
+                                const result = await that.signMessage(message);
+                                resolve(result);
+                            }
+                            catch (error) {
+                                reject(error);
+                            }
+                            that.pendingSignMessage = null;
+                        }
+                        // If there's a pending signAndSubmitTransaction, execute it now
+                        if (that.pendingSignAndSubmitTransaction) {
+                            const { transaction, feePayer, resolve, reject } = that.pendingSignAndSubmitTransaction;
+                            try {
+                                const result = await that.signAndSubmitTransaction(transaction, feePayer);
+                                resolve(result);
+                            }
+                            catch (error) {
+                                reject(error);
+                            }
+                            that.pendingSignAndSubmitTransaction = null;
+                        }
+                    },
+                    onError: (error) => {
+                        // Only log errors that aren't user-initiated cancellations
+                        if (error !== 'exited_auth_flow' && (error === null || error === void 0 ? void 0 : error.message) !== 'exited_auth_flow') {
+                            console.error('Wallet connection error:', error);
+                        }
+                        if (that.pendingTransaction) {
+                            that.pendingTransaction.reject(error);
+                            that.pendingTransaction = null;
+                        }
+                        if (that.pendingSignTransaction) {
+                            that.pendingSignTransaction.reject(error);
+                            that.pendingSignTransaction = null;
+                        }
+                        if (that.pendingSignMessage) {
+                            that.pendingSignMessage.reject(error);
+                            that.pendingSignMessage = null;
+                        }
+                        if (that.pendingSignAndSubmitTransaction) {
+                            that.pendingSignAndSubmitTransaction.reject(error);
+                            that.pendingSignAndSubmitTransaction = null;
+                        }
+                    }
+                });
+                const { login } = privyImports.useLogin({
+                    onComplete: async ({ user }) => {
+                        var _a;
+                        // This is a hack to indicate to the app that privy login is not complete
+                        // @ts-ignore
+                        window.runningPrivyOnComplete = true;
+                        if (!user) {
+                            WebSessionManager.clearSession();
+                            return;
+                        }
+                        const solanaLinkedAccounts = user.linkedAccounts.filter((account) => account.chainType === 'solana');
+                        const sortedLinkedAccounts = solanaLinkedAccounts.sort((a, b) => new Date(b.latestVerifiedAt).getTime() - new Date(a.latestVerifiedAt).getTime());
+                        let finalAddress = (_a = sortedLinkedAccounts[0]) === null || _a === void 0 ? void 0 : _a.address;
+                        if (!finalAddress) {
+                            const solanaWallet = await createWallet();
+                            finalAddress = solanaWallet.address;
+                            WebSessionManager.clearSession();
+                            return;
+                        }
+                        const session = await WebSessionManager.getSession();
+                        if (!session || finalAddress !== session.address) {
+                            try {
+                                const accessToken = await privy.getAccessToken();
+                                const idToken = useIdentityToken.identityToken;
+                                await that.createSession(finalAddress, accessToken, idToken);
+                            }
+                            catch (error) {
+                                console.error('Error creating session:', error);
+                            }
+                        }
+                        // @ts-ignore
+                        window.runningPrivyOnComplete = false;
+                        setCurrentUser({ address: finalAddress, provider: that });
+                        if (that.pendingLogin) {
+                            that.pendingLogin.resolve({ address: finalAddress, provider: that });
+                            that.pendingLogin = null;
+                        }
+                    },
+                    onError: (error) => {
+                        // Only log errors that aren't user-initiated cancellations
+                        if (error !== 'exited_auth_flow' && (error === null || error === void 0 ? void 0 : error.message) !== 'exited_auth_flow') {
+                            console.error('Login error:', error);
+                        }
+                        if (that.pendingLogin) {
+                            that.pendingLogin.reject(error);
+                            that.pendingLogin = null;
+                        }
+                    }
+                });
+                const { logout } = privyImports.useLogout({
+                    onSuccess: () => {
+                        WebSessionManager.clearSession();
+                        setCurrentUser(null);
+                    }
+                });
+                React.useEffect(() => {
+                    if (privy.ready) {
+                        that.privyMethods = {
+                            ready: privy.ready,
+                            walletReady: walletReady,
+                            authenticated: privy.authenticated,
+                            wallets,
+                            login,
+                            logout,
+                            connectWallet,
+                            getAccessToken: privy.getAccessToken,
+                            identityToken: useIdentityToken.identityToken,
+                            usePrivy: privy,
+                            useOAuthTokens: useOAuthTokens,
+                            useFundWalletSolana: useFundWalletSolana,
+                            useSendTransactionSolana: useSendTransactionSolana,
+                            useSolanaWallets: useSolanaWallets,
+                            signTransaction: signTransaction,
+                            signMessage: signMessageHook,
+                        };
+                    }
+                }, [privy.ready, privy.authenticated, wallets, login, logout, walletReady]);
+                return null;
+            };
+            const FinalPrivyComponent = () => {
+                if (typeof window === 'undefined') {
+                    return null;
+                }
+                return React.createElement(privyImports.PrivyProvider, {
+                    appId: this.privyConfig.appId,
+                    config: this.privyConfig.config,
+                    children: React.createElement(PrivyComponent)
+                });
+            };
+            this.root = ReactDOM.createRoot(this.containerElement);
+            this.root.render(React.createElement(FinalPrivyComponent));
+        }
+    }
+    async login() {
+        var _a, _b;
+        await this.ensureReady();
+        // Check if we have a valid session that matches an authenticated wallet
+        const session = await WebSessionManager.getSession();
+        if (((_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.authenticated) && ((_b = this.privyMethods.wallets) === null || _b === void 0 ? void 0 : _b.length) > 0 && session) {
+            // Find the wallet matching the session
+            const matchingWallet = this.privyMethods.wallets.find((wallet) => wallet.address === session.address);
+            if (matchingWallet) {
+                // Valid session with matching wallet, return immediately
+                setCurrentUser({ address: matchingWallet.address, provider: this });
+                return {
+                    address: matchingWallet.address,
+                    provider: this
+                };
+            }
+            // Session exists but doesn't match any connected wallet
+            // This can happen after wallet switching - force fresh login
+            console.log('Session wallet mismatch detected, forcing fresh login flow');
+        }
+        // If no valid session or wallet mismatch, force a fresh login flow
+        // This ensures the user can select the correct wallet, especially after logout
+        if (this.pendingLogin) {
+            return new Promise((resolve, reject) => {
+                this.pendingLogin.resolve = resolve;
+                this.pendingLogin.reject = reject;
+            });
+        }
+        return new Promise((resolve, reject) => {
+            this.pendingLogin = { resolve, reject };
+            // open Privy modal to let user select/verify wallet
+            this.privyMethods.login();
+            // safety timeout
+            setTimeout(() => {
+                if (this.pendingLogin) {
+                    this.pendingLogin.reject(new Error("Login timed out"));
+                    this.pendingLogin = null;
+                }
+            }, 180000);
+        });
+    }
+    async getNativeMethods() {
+        var _a;
+        await this.ensureReady();
+        return (_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.usePrivy;
+    }
+    async logout() {
+        await this.ensureReady();
+        await this.privyMethods.logout();
+    }
+    async runTransaction(_evmTransactionData, solTransactionData, options) {
+        var _a, _b, _c;
+        await this.ensureReady({ waitForWallets: true });
+        let session = await WebSessionManager.getSession();
+        let sessionAddress = session === null || session === void 0 ? void 0 : session.address;
+        let privyWallets = (_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.wallets;
+        let privyWallet = privyWallets === null || privyWallets === void 0 ? void 0 : privyWallets.find((wallet) => wallet.address === sessionAddress);
+        // If wallet not found yet, it may be an embedded wallet (email login) that hasn't
+        // appeared in the wallets array due to React state timing. Wait for it before
+        // falling back to connectWallet() which shows an unwanted wallet selection modal.
+        if (!privyWallets || privyWallets.length === 0 || !privyWallet) {
+            if (((_b = this.privyMethods) === null || _b === void 0 ? void 0 : _b.authenticated) && sessionAddress) {
+                privyWallet = await this.waitForMatchingWallet(sessionAddress);
+            }
+        }
+        if (!privyWallet) {
+            // If there's already a pending transaction, throw an error to prevent overlapping calls
+            if (this.pendingTransaction) {
+                throw new Error("Oops... something went wrong. Please try again.");
+            }
+            // Create a promise to wait for the transaction result
+            return new Promise((resolve, reject) => {
+                this.pendingTransaction = {
+                    resolve,
+                    reject,
+                    evmTransactionData: _evmTransactionData,
+                    solTransactionData,
+                    options
+                };
+                this.privyMethods.connectWallet();
+                // Set a timeout to reject the promise if connection takes too long
+                setTimeout(() => {
+                    if (this.pendingTransaction) {
+                        this.pendingTransaction.reject(new Error("Wallet connection timed out"));
+                        this.pendingTransaction = null;
+                    }
+                }, 30000); // 30 seconds timeout
+            });
+        }
+        // Proceed with the transaction using privyWallet
+        const wallet = privyWallet;
+        if (solTransactionData == null) {
+            throw new Error("Solana transaction data is required");
+        }
+        const rpcUrl = this.getRpcUrl(solTransactionData.network);
+        const connection = new Connection(rpcUrl, "confirmed");
+        const remainingAccounts = convertRemainingAccounts(solTransactionData.txArgs[0].remainingAccounts);
+        let app_id = solTransactionData.appId;
+        if (typeof window !== 'undefined' && window.CUSTOM_TAROBASE_APP_ID_HEADER) {
+            const customAppId = window.CUSTOM_TAROBASE_APP_ID_HEADER;
+            if (customAppId) {
+                app_id = customAppId;
+            }
+        }
+        if (!app_id) {
+            throw new Error("App ID is required");
+        }
+        const anchorProvider = new anchor.AnchorProvider(connection, wallet.provider, anchor.AnchorProvider.defaultOptions());
+        const finalDeduped = [];
+        for (const acc of remainingAccounts) {
+            const existing = finalDeduped.find((d) => d.pubkey.equals(acc.pubkey));
+            if (existing) {
+                existing.isSigner = existing.isSigner || acc.isSigner;
+                existing.isWritable = existing.isWritable || acc.isWritable;
+            }
+            else {
+                finalDeduped.push(acc);
+            }
+        }
+        let tx;
+        let blockhash;
+        let lastValidBlockHeight;
+        if (solTransactionData.signedTransaction) {
+            // Server already set the blockhash and co-signed — do NOT overwrite
+            // the blockhash or it will invalidate the server's signature.
+            tx = VersionedTransaction.deserialize(Buffer.from(solTransactionData.signedTransaction, 'base64'));
+            // Extract the blockhash that was baked into the signed message
+            blockhash = tx.message.recentBlockhash;
+            const latestBlockhash = await connection.getLatestBlockhash('confirmed');
+            lastValidBlockHeight = latestBlockhash.lastValidBlockHeight;
+        }
+        else {
+            const result = await buildSetDocumentsTransaction(connection, solTransactionData.txArgs[0].idl, anchorProvider, new PublicKey(wallet.address), { app_id, documents: solTransactionData.txArgs[0].setDocumentData, delete_paths: solTransactionData.txArgs[0].deletePaths, txData: solTransactionData.txArgs[0].txData }, finalDeduped, solTransactionData.lutKey, solTransactionData.preInstructions, false, solTransactionData.additionalLutAddresses);
+            tx = result.tx;
+            blockhash = result.blockhash;
+            lastValidBlockHeight = result.lastValidBlockHeight;
+        }
+        // Use duck typing instead of instanceof to handle multiple @solana/web3.js versions
+        const isLegacyTx = 'recentBlockhash' in tx && !('message' in tx && 'staticAccountKeys' in tx.message);
+        if (isLegacyTx) {
+            tx.recentBlockhash = blockhash;
+            tx.lastValidBlockHeight = lastValidBlockHeight;
+        }
+        else {
+            tx.message.recentBlockhash = blockhash;
+        }
+        try {
+            if ((options === null || options === void 0 ? void 0 : options.shouldSubmitTx) === false) {
+                // Just sign, don't submit - return raw signed bytes (same as original runTransaction)
+                const signedTx = await this.signTransactionRaw(tx, privyWallet);
+                return {
+                    signedTransaction: signedTx, // Raw Uint8Array from Privy
+                    blockNumber: 0,
+                    gasUsed: "0",
+                    data: ""
+                };
+            }
+            // Sign and submit using shared helper
+            const { signature, txInfo } = await this.signAndSubmitInternal(tx, privyWallet, rpcUrl, connection);
+            return {
+                transactionSignature: signature,
+                blockNumber: (txInfo === null || txInfo === void 0 ? void 0 : txInfo.slot) || 0,
+                gasUsed: ((_c = txInfo === null || txInfo === void 0 ? void 0 : txInfo.meta) === null || _c === void 0 ? void 0 : _c.fee.toString()) || '0',
+                data: txInfo === null || txInfo === void 0 ? void 0 : txInfo.meta,
+            };
+        }
+        catch (err) {
+            console.error(err);
+            throw err;
+        }
+    }
+    /**
+     * Signs a Solana transaction without submitting it.
+     *
+     * This method handles blockhash automatically if not set - you do NOT need to
+     * set recentBlockhash on the transaction before calling this method.
+     * The network/RPC URL is derived from the provider's configuration (set during initialization).
+     *
+     * @param transaction - The transaction to sign (Transaction or VersionedTransaction)
+     * @returns The signed transaction
+     */
+    async signTransaction(transaction) {
+        var _a, _b;
+        await this.ensureReady({ waitForWallets: true });
+        let privyWallets = (_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.wallets;
+        let session = await WebSessionManager.getSession();
+        let sessionAddress = session === null || session === void 0 ? void 0 : session.address;
+        let privyWallet = privyWallets === null || privyWallets === void 0 ? void 0 : privyWallets.find((wallet) => wallet.address === sessionAddress);
+        // If there's already a pending sign transaction, throw an error to prevent overlapping calls
+        if (this.pendingSignTransaction) {
+            throw new Error("Oops... something went wrong. Please try again.");
+        }
+        // If wallet not found yet, it may be an embedded wallet (email login) that hasn't
+        // appeared in the wallets array due to React state timing. Wait for it before
+        // falling back to connectWallet() which shows an unwanted wallet selection modal.
+        if (!privyWallets || privyWallets.length === 0 || !privyWallet) {
+            if (((_b = this.privyMethods) === null || _b === void 0 ? void 0 : _b.authenticated) && sessionAddress) {
+                privyWallet = await this.waitForMatchingWallet(sessionAddress);
+            }
+        }
+        // If still no wallet after waiting, trigger connection and queue the signing
+        if (!privyWallet) {
+            return new Promise((resolve, reject) => {
+                this.pendingSignTransaction = {
+                    resolve,
+                    reject,
+                    transaction
+                };
+                this.privyMethods.connectWallet();
+                // Set a timeout to reject the promise if connection takes too long
+                setTimeout(() => {
+                    if (this.pendingSignTransaction) {
+                        this.pendingSignTransaction.reject(new Error("Wallet connection timed out"));
+                        this.pendingSignTransaction = null;
+                    }
+                }, 30000); // 30 seconds timeout
+            });
+        }
+        // Privy requires serialized transaction bytes, which requires a blockhash.
+        // If the transaction doesn't have one, get a fresh blockhash and set it.
+        // Use duck typing instead of instanceof to handle multiple @solana/web3.js versions
+        const isLegacyTransaction = 'recentBlockhash' in transaction && !('message' in transaction && 'staticAccountKeys' in transaction.message);
+        if (isLegacyTransaction) {
+            const legacyTx = transaction;
+            if (!legacyTx.recentBlockhash) {
+                const rpcUrl = this.getRpcUrl();
+                const connection = new Connection(rpcUrl, 'confirmed');
+                const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
+                legacyTx.recentBlockhash = blockhash;
+                legacyTx.lastValidBlockHeight = lastValidBlockHeight;
+            }
+            // Set feePayer if not already set
+            if (!legacyTx.feePayer) {
+                legacyTx.feePayer = new PublicKey(privyWallet.address);
+            }
+        }
+        else {
+            // VersionedTransaction
+            const versionedTx = transaction;
+            if (!versionedTx.message.recentBlockhash) {
+                const rpcUrl = this.getRpcUrl();
+                const connection = new Connection(rpcUrl, 'confirmed');
+                const { blockhash } = await connection.getLatestBlockhash('confirmed');
+                versionedTx.message.recentBlockhash = blockhash;
+            }
+        }
+        // Sign using raw method, then deserialize for the public API
+        const signedTxRaw = await this.signTransactionRaw(transaction, privyWallet);
+        return this.deserializeSignedTransaction(signedTxRaw);
+    }
+    /**
+     * Signs and submits a Solana transaction to the network.
+     *
+     * This method handles blockhash and transaction confirmation automatically - you do NOT need to
+     * set recentBlockhash or lastValidBlockHeight on the transaction before calling this method.
+     * The network/RPC URL is derived from the provider's configuration (set during initialization).
+     *
+     * @param transaction - The transaction to sign and submit (Transaction or VersionedTransaction)
+     * @param feePayer - Optional fee payer public key. If not provided and the transaction doesn't
+     *                   already have a feePayer set, the connected wallet address will be used.
+     *                   Useful for co-signing scenarios where a different account pays the fees.
+     * @returns The transaction signature
+     */
+    async signAndSubmitTransaction(transaction, feePayer) {
+        var _a, _b;
+        await this.ensureReady({ waitForWallets: true });
+        let privyWallets = (_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.wallets;
+        let session = await WebSessionManager.getSession();
+        let sessionAddress = session === null || session === void 0 ? void 0 : session.address;
+        let privyWallet = privyWallets === null || privyWallets === void 0 ? void 0 : privyWallets.find((wallet) => wallet.address === sessionAddress);
+        // If there's already a pending signAndSubmitTransaction, throw an error to prevent overlapping calls
+        if (this.pendingSignAndSubmitTransaction) {
+            throw new Error("Oops... something went wrong. Please try again.");
+        }
+        // If wallet not found yet, it may be an embedded wallet (email login) that hasn't
+        // appeared in the wallets array due to React state timing. Wait for it before
+        // falling back to connectWallet() which shows an unwanted wallet selection modal.
+        if (!privyWallets || privyWallets.length === 0 || !privyWallet) {
+            if (((_b = this.privyMethods) === null || _b === void 0 ? void 0 : _b.authenticated) && sessionAddress) {
+                privyWallet = await this.waitForMatchingWallet(sessionAddress);
+            }
+        }
+        // If still no wallet after waiting, trigger connection and queue the signing
+        if (!privyWallet) {
+            return new Promise((resolve, reject) => {
+                this.pendingSignAndSubmitTransaction = {
+                    resolve,
+                    reject,
+                    transaction,
+                    feePayer
+                };
+                this.privyMethods.connectWallet();
+                // Set a timeout to reject the promise if connection takes too long
+                setTimeout(() => {
+                    if (this.pendingSignAndSubmitTransaction) {
+                        this.pendingSignAndSubmitTransaction.reject(new Error("Wallet connection timed out"));
+                        this.pendingSignAndSubmitTransaction = null;
+                    }
+                }, 30000); // 30 seconds timeout
+            });
+        }
+        // Get RPC URL and create connection
+        const rpcUrl = this.getRpcUrl();
+        const connection = new Connection(rpcUrl, 'confirmed');
+        // Get fresh blockhash and set it on the transaction before signing
+        const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
+        // Use duck typing instead of instanceof to handle multiple @solana/web3.js versions
+        const isLegacyTransaction = 'recentBlockhash' in transaction && !('message' in transaction && 'staticAccountKeys' in transaction.message);
+        if (isLegacyTransaction) {
+            const legacyTx = transaction;
+            legacyTx.recentBlockhash = blockhash;
+            legacyTx.lastValidBlockHeight = lastValidBlockHeight;
+            // Set feePayer if not already set
+            if (!legacyTx.feePayer) {
+                legacyTx.feePayer = feePayer !== null && feePayer !== void 0 ? feePayer : new PublicKey(privyWallet.address);
+            }
+        }
+        else {
+            // VersionedTransaction
+            const versionedTx = transaction;
+            versionedTx.message.recentBlockhash = blockhash;
+            // Note: VersionedTransaction feePayer is set in the message at creation time
+            // and cannot be modified after creation
+        }
+        // Use shared sign and submit logic
+        const { signature } = await this.signAndSubmitInternal(transaction, privyWallet, rpcUrl, connection);
+        return signature;
+    }
+    // ============ Private Helpers ============
+    getRpcUrl(network) {
+        if (this.networkUrl) {
+            return this.networkUrl;
+        }
+        if (network === 'solana_devnet') {
+            return SOLANA_DEVNET_RPC_URL;
+        }
+        else if (network === 'solana_mainnet') {
+            return SOLANA_MAINNET_RPC_URL;
+        }
+        else if (network === 'surfnet') {
+            return SURFNET_RPC_URL;
+        }
+        return SOLANA_MAINNET_RPC_URL; // default to mainnet
+    }
+    /**
+     * Internal sign transaction - serializes and signs via Privy
+     * Returns the raw result from Privy (Uint8Array)
+     * This mirrors exactly what runTransaction was doing
+     */
+    async signTransactionRaw(transaction, privyWallet) {
+        var _a;
+        // Serialize the transaction
+        // Use duck typing instead of instanceof to handle multiple @solana/web3.js versions
+        const isLegacyTransaction = 'recentBlockhash' in transaction && !('message' in transaction && 'staticAccountKeys' in transaction.message);
+        let serializedForSign;
+        if (isLegacyTransaction) {
+            serializedForSign = transaction.serialize({ requireAllSignatures: false, verifySignatures: false });
+        }
+        else {
+            serializedForSign = transaction.serialize();
+        }
+        // Sign via Privy - returns { signedTransaction: Uint8Array }
+        const result = await ((_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.signTransaction({
+            transaction: serializedForSign,
+            wallet: privyWallet,
+            chain: this.chainId
+        }));
+        // Privy returns { signedTransaction: Uint8Array }, unwrap it
+        const signedTx = (result === null || result === void 0 ? void 0 : result.signedTransaction) || result;
+        return signedTx;
+    }
+    /**
+     * Deserialize a signed transaction from Uint8Array to Transaction object
+     */
+    deserializeSignedTransaction(signedTxRaw) {
+        // Handle different formats Privy might return
+        let signedTx;
+        if (signedTxRaw instanceof Uint8Array) {
+            signedTx = signedTxRaw;
+        }
+        else if (Array.isArray(signedTxRaw)) {
+            signedTx = new Uint8Array(signedTxRaw);
+        }
+        else if (signedTxRaw && typeof signedTxRaw === 'object' && 'signedTransaction' in signedTxRaw) {
+            // Privy might wrap the result
+            signedTx = signedTxRaw.signedTransaction instanceof Uint8Array
+                ? signedTxRaw.signedTransaction
+                : new Uint8Array(signedTxRaw.signedTransaction);
+        }
+        else if (Buffer.isBuffer(signedTxRaw)) {
+            signedTx = new Uint8Array(signedTxRaw);
+        }
+        else {
+            throw new Error(`Unexpected signed transaction format: ${typeof signedTxRaw}`);
+        }
+        // Try to deserialize as VersionedTransaction first, fall back to legacy Transaction
+        try {
+            return VersionedTransaction.deserialize(signedTx);
+        }
+        catch (_a) {
+            return Transaction.from(signedTx);
+        }
+    }
+    /**
+     * Internal sign and submit - handles Surfnet vs non-Surfnet logic
+     * This is the core submission logic used by both signAndSubmitTransaction and runTransaction
+     *
+     * For Surfnet: sign with signTransactionRaw, then sendRawTransaction
+     * For non-Surfnet: use Privy's signAndSendTransaction (combined operation)
+     */
+    async signAndSubmitInternal(transaction, privyWallet, rpcUrl, connection) {
+        var _a;
+        const isSurfnet = rpcUrl === SURFNET_RPC_URL;
+        let signature;
+        if (isSurfnet) {
+            // For Surfnet: sign with signTransactionRaw, then sendRawTransaction
+            const signedTx = await this.signTransactionRaw(transaction, privyWallet);
+            signature = await connection.sendRawTransaction(signedTx);
+        }
+        else {
+            // For non-Surfnet: use Privy's combined signAndSendTransaction
+            // Serialize the transaction for Privy API
+            // Use duck typing instead of instanceof to handle multiple @solana/web3.js versions
+            const isLegacyTransaction = 'recentBlockhash' in transaction && !('message' in transaction && 'staticAccountKeys' in transaction.message);
+            let serializedTx;
+            if (isLegacyTransaction) {
+                serializedTx = transaction.serialize({ requireAllSignatures: false, verifySignatures: false });
+            }
+            else {
+                serializedTx = transaction.serialize();
+            }
+            const result = await ((_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.useSendTransactionSolana.signAndSendTransaction({
+                transaction: serializedTx,
+                wallet: privyWallet,
+                chain: this.chainId
+            }));
+            // Handle case where signature might be bytes instead of string
+            const rawSig = result.signature;
+            if (rawSig instanceof Uint8Array || Array.isArray(rawSig)) {
+                signature = bs58.encode(rawSig instanceof Uint8Array ? rawSig : new Uint8Array(rawSig));
+            }
+            else {
+                signature = rawSig;
+            }
+        }
+        const txInfo = await confirmAndCheckTransaction(connection, signature);
+        return { signature, txInfo };
+    }
+    async signMessage(message) {
+        var _a, _b, _c;
+        await this.ensureReady({ waitForWallets: true });
+        const session = await WebSessionManager.getSession();
+        let sessionAddress = session === null || session === void 0 ? void 0 : session.address;
+        // If there's already a pending sign message, throw an error to prevent overlapping calls
+        if (this.pendingSignMessage) {
+            throw new Error("Oops... something went wrong. Please try again.");
+        }
+        // If no wallets connected yet, it may be an embedded wallet (email login) that hasn't
+        // appeared in the wallets array due to React state timing. Wait for it before
+        // falling back to connectWallet() which shows an unwanted wallet selection modal.
+        if (!((_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.wallets) || this.privyMethods.wallets.length === 0) {
+            if (((_b = this.privyMethods) === null || _b === void 0 ? void 0 : _b.authenticated) && sessionAddress) {
+                const matchedWallet = await this.waitForMatchingWallet(sessionAddress);
+                if (!matchedWallet) {
+                    return new Promise((resolve, reject) => {
+                        this.pendingSignMessage = {
+                            resolve,
+                            reject,
+                            message
+                        };
+                        this.privyMethods.connectWallet();
+                        // Set a timeout to reject the promise if connection takes too long
+                        setTimeout(() => {
+                            if (this.pendingSignMessage) {
+                                this.pendingSignMessage.reject(new Error("Wallet connection timed out"));
+                                this.pendingSignMessage = null;
+                            }
+                        }, 30000); // 30 seconds timeout
+                    });
+                }
+            }
+            else {
+                return new Promise((resolve, reject) => {
+                    this.pendingSignMessage = {
+                        resolve,
+                        reject,
+                        message
+                    };
+                    this.privyMethods.connectWallet();
+                    // Set a timeout to reject the promise if connection takes too long
+                    setTimeout(() => {
+                        if (this.pendingSignMessage) {
+                            this.pendingSignMessage.reject(new Error("Wallet connection timed out"));
+                            this.pendingSignMessage = null;
+                        }
+                    }, 30000); // 30 seconds timeout
+                });
+            }
+        }
+        let privyWallet = this.privyMethods.wallets.find((wallet) => wallet.address === sessionAddress);
+        if (!privyWallet) {
+            // Session address is not a privy wallet, just default to the first wallet
+            const accessToken = await this.privyMethods.getAccessToken();
+            await this.createSession(this.privyMethods.wallets[0].address, accessToken, this.privyMethods.identityToken);
+            setCurrentUser({ address: this.privyMethods.wallets[0].address, provider: this });
+            const session = await WebSessionManager.getSession();
+            sessionAddress = session === null || session === void 0 ? void 0 : session.address;
+            if (!sessionAddress) {
+                throw new Error('No wallet connected or logged in to sign message');
+            }
+            privyWallet = this.privyMethods.wallets[0];
+        }
+        // Use the Privy signMessage hook for Solana wallets
+        // The message needs to be passed as a Uint8Array
+        const messageBytes = getPlatform().textEncode(message);
+        const result = await ((_c = this.privyMethods) === null || _c === void 0 ? void 0 : _c.signMessage({
+            message: messageBytes,
+            wallet: privyWallet,
+        }));
+        // The signature is returned as a Uint8Array, encode it as base58 (standard Solana format)
+        const signatureBytes = (result === null || result === void 0 ? void 0 : result.signature) || result;
+        const bs58 = await import('./index.native-BB7er4-z.esm.js').then(function (n) { return n.a4; });
+        return bs58.default.encode(signatureBytes);
+    }
+    async restoreSession() {
+        const session = await WebSessionManager.getSession();
+        if (session) {
+            return { provider: this, address: session.address };
+        }
+        else {
+            return null;
+        }
+    }
+    async createSession(address, accessToken, idToken) {
+        if (accessToken == null || accessToken == '' || idToken == null || idToken == '') {
+            return;
+        }
+        const createSessionResult = await createSessionWithPrivy(accessToken, address, idToken);
+        await WebSessionManager.storeSession(address, createSessionResult.accessToken, createSessionResult.idToken, createSessionResult.refreshToken);
+    }
+    /**
+     * Waits for a wallet matching the session address to appear in the wallets array.
+     * This handles the timing gap where Privy's embedded wallet (created for email login users)
+     * may not yet be in the useWallets() array when signTransaction is called immediately after login.
+     */
+    async waitForMatchingWallet(sessionAddress, timeoutMs = 10000) {
+        var _a;
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeoutMs) {
+            const wallets = (_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.wallets;
+            if (wallets && wallets.length > 0) {
+                const wallet = wallets.find((w) => w.address === sessionAddress);
+                if (wallet)
+                    return wallet;
+            }
+            await new Promise(resolve => setTimeout(resolve, 200));
+        }
+        return null;
+    }
+    async ensureReady({ waitForWallets = false, timeoutMs = 15000 } = {}) {
+        const isReady = () => {
+            var _a, _b;
+            if (!((_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.ready))
+                return false;
+            if (waitForWallets && !((_b = this.privyMethods) === null || _b === void 0 ? void 0 : _b.walletReady))
+                return false;
+            return true;
+        };
+        if (isReady())
+            return;
+        return new Promise((resolve, reject) => {
+            const startTime = Date.now();
+            const check = () => {
+                if (isReady()) {
+                    resolve();
+                }
+                else if (Date.now() - startTime > timeoutMs) {
+                    reject(new Error('Login provider failed to initialize. This can happen in incognito mode or when third-party cookies are blocked. Try using a regular browser window.'));
+                }
+                else {
+                    setTimeout(check, 100);
+                }
+            };
+            check();
+        });
+    }
+}
+PrivyWalletProvider.instance = null;
+
+export { PrivyWalletProvider };
+//# sourceMappingURL=privy-wallet-provider-CFuoQYuv.esm.js.map