x402-proxy 0.10.7 → 0.10.10

package/dist/index.node-CxkL0OFh.js

@@ -0,0 +1,3592 @@
+#!/usr/bin/env node
+import { setMaxListeners } from "events";
+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__SIGNER__WALLET_ACCOUNT_CANNOT_SIGN_TRANSACTION = 5508012;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__MAXIMUM_LENGTH_EXCEEDED = 5607e3;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__RESTRICTED_ASCII_BODY_CHARACTER_OUT_OF_RANGE = 5607001;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__APPLICATION_DOMAIN_STRING_LENGTH_OUT_OF_RANGE = 5607002;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__INVALID_APPLICATION_DOMAIN_BYTE_LENGTH = 5607003;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_SIGNATURES_MISMATCH = 5607004;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_REQUIRED_SIGNERS_CANNOT_BE_ZERO = 5607005;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__VERSION_NUMBER_NOT_SUPPORTED = 5607006;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_FORMAT_MISMATCH = 5607007;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_LENGTH_MISMATCH = 5607008;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_MUST_BE_NON_EMPTY = 5607009;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_ENVELOPE_SIGNATURES_CANNOT_BE_ZERO = 5607010;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURES_MISSING = 5607011;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__ENVELOPE_SIGNERS_MISMATCH = 5607012;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__ADDRESSES_CANNOT_SIGN_OFFCHAIN_MESSAGE = 5607013;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__UNEXPECTED_VERSION = 5607014;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATORIES_MUST_BE_SORTED = 5607015;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATORIES_MUST_BE_UNIQUE = 5607016;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURE_VERIFICATION_FAILURE = 5607017;
+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__MALFORMED_MESSAGE_BYTES = 5663023;
+var SOLANA_ERROR__TRANSACTION__CANNOT_ENCODE_WITH_EMPTY_MESSAGE_BYTES = 5663024;
+var SOLANA_ERROR__TRANSACTION__CANNOT_DECODE_EMPTY_TRANSACTION_BYTES = 5663025;
+var SOLANA_ERROR__TRANSACTION__VERSION_ZERO_MUST_BE_ENCODED_WITH_SIGNATURES_FIRST = 5663026;
+var SOLANA_ERROR__TRANSACTION__SIGNATURE_COUNT_TOO_HIGH_FOR_TRANSACTION_BYTES = 5663027;
+var SOLANA_ERROR__TRANSACTION__INVALID_CONFIG_MASK_PRIORITY_FEE_BITS = 5663028;
+var SOLANA_ERROR__TRANSACTION__INVALID_NONCE_ACCOUNT_INDEX = 5663029;
+var SOLANA_ERROR__TRANSACTION__INVALID_CONFIG_VALUE_KIND = 5663030;
+var SOLANA_ERROR__TRANSACTION__INSTRUCTION_HEADERS_PAYLOADS_MISMATCH = 5663031;
+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__INSTRUCTION_PLANS__NON_DIVISIBLE_TRANSACTION_PLANS_NOT_SUPPORTED = 7618004;
+var SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_SINGLE_TRANSACTION_PLAN_RESULT_NOT_FOUND = 7618005;
+var SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_INSTRUCTION_PLAN = 7618006;
+var SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN = 7618007;
+var SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN_RESULT = 7618008;
+var SOLANA_ERROR__INSTRUCTION_PLANS__EXPECTED_SUCCESSFUL_TRANSACTION_PLAN_RESULT = 7618009;
+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__CODECS__INVALID_PATTERN_MATCH_VALUE = 8078024;
+var SOLANA_ERROR__CODECS__INVALID_PATTERN_MATCH_BYTES = 8078025;
+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__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS = 85e5;
+var SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE = 8500001;
+var SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION = 8500002;
+var SOLANA_ERROR__PROGRAM_CLIENTS__UNEXPECTED_RESOLVED_INSTRUCTION_INPUT_TYPE = 8500003;
+var SOLANA_ERROR__PROGRAM_CLIENTS__RESOLVED_INSTRUCTION_INPUT_MUST_BE_NON_NULL = 8500004;
+var SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_ACCOUNT_TYPE = 8500005;
+var SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT = 8500006;
+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;
+function encodeValue(value) {
+	if (Array.isArray(value)) return "%5B" + value.map(encodeValue).join("%2C%20") + "%5D";
+	else if (typeof value === "bigint") return `${value}n`;
+	else return encodeURIComponent(String(value != null && Object.getPrototypeOf(value) === null ? { ...value } : value));
+}
+function encodeObjectContextEntry([key, value]) {
+	return `${key}=${encodeValue(value)}`;
+}
+function encodeContextObject(context) {
+	const searchParamsString = Object.entries(context).map(encodeObjectContextEntry).join("&");
+	return Buffer.from(searchParamsString, "utf8").toString("base64");
+}
+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.",
+	[4]: "Expected base58-encoded blockash string of length in the range [32, 44]. Actual length: $actualLength.",
+	[1]: "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__CODECS__INVALID_PATTERN_MATCH_VALUE]: "Invalid pattern match value. The provided value does not match any of the specified patterns.",
+	[SOLANA_ERROR__CODECS__INVALID_PATTERN_MATCH_BYTES]: "Invalid pattern match bytes. The provided byte array does not match any of the specified patterns.",
+	[SOLANA_ERROR__CRYPTO__RANDOM_VALUES_FUNCTION_UNIMPLEMENTED]: "No random values implementation could be found.",
+	[11]: "Failed to send transaction$causeMessage",
+	[12]: "Failed to send transactions$causeMessages",
+	[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",
+	[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]: "The instruction failed with the error: $errorName",
+	[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_SINGLE_TRANSACTION_PLAN_RESULT_NOT_FOUND]: "No failed transaction plan result was found in the provided transaction plan result.",
+	[SOLANA_ERROR__INSTRUCTION_PLANS__NON_DIVISIBLE_TRANSACTION_PLANS_NOT_SUPPORTED]: "This transaction plan executor does not support non-divisible sequential plans. To support them, you may create your own executor such that multi-transaction atomicity is preserved — e.g. by targetting RPCs that support transaction bundles.",
+	[SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN]: "The provided transaction plan failed to execute. See the `transactionPlanResult` attribute for more details. Note that the `cause` property is deprecated, and a future version will not set it.",
+	[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_PLANS__UNEXPECTED_INSTRUCTION_PLAN]: "Unexpected instruction plan. Expected $expectedKind plan, got $actualKind plan.",
+	[SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN]: "Unexpected transaction plan. Expected $expectedKind plan, got $actualKind plan.",
+	[SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN_RESULT]: "Unexpected transaction plan result. Expected $expectedKind plan, got $actualKind plan.",
+	[SOLANA_ERROR__INSTRUCTION_PLANS__EXPECTED_SUCCESSFUL_TRANSACTION_PLAN_RESULT]: "Expected a successful transaction plan result. I.e. there is at least one failed or cancelled transaction in the 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.",
+	[5]: "Expected base58 encoded blockhash to decode to a byte array of length 32. Actual length: $actualLength.",
+	[2]: "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.",
+	[6]: "Lamports value must be in the range [0, 2e64-1]",
+	[7]: "`$value` cannot be parsed as a `BigInt`",
+	[10]: "$message",
+	[8]: "`$value` cannot be parsed as a `Number`",
+	[3]: "No nonce account could be found at address `$nonceAccountAddress`",
+	[SOLANA_ERROR__OFFCHAIN_MESSAGE__INVALID_APPLICATION_DOMAIN_BYTE_LENGTH]: "Expected base58 encoded application domain to decode to a byte array of length 32. Actual length: $actualLength.",
+	[SOLANA_ERROR__OFFCHAIN_MESSAGE__ADDRESSES_CANNOT_SIGN_OFFCHAIN_MESSAGE]: "Attempted to sign an offchain message with an address that is not a signer for it",
+	[SOLANA_ERROR__OFFCHAIN_MESSAGE__APPLICATION_DOMAIN_STRING_LENGTH_OUT_OF_RANGE]: "Expected base58-encoded application domain string of length in the range [32, 44]. Actual length: $actualLength.",
+	[SOLANA_ERROR__OFFCHAIN_MESSAGE__ENVELOPE_SIGNERS_MISMATCH]: "The signer addresses in this offchain message envelope do not match the list of required signers in the message preamble. These unexpected signers were present in the envelope: `[$unexpectedSigners]`. These required signers were missing from the envelope `[$missingSigners]`.",
+	[SOLANA_ERROR__OFFCHAIN_MESSAGE__MAXIMUM_LENGTH_EXCEEDED]: "The message body provided has a byte-length of $actualBytes. The maximum allowable byte-length is $maxBytes",
+	[SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_FORMAT_MISMATCH]: "Expected message format $expectedMessageFormat, got $actualMessageFormat",
+	[SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_LENGTH_MISMATCH]: "The message length specified in the message preamble is $specifiedLength bytes. The actual length of the message is $actualLength bytes.",
+	[SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_MUST_BE_NON_EMPTY]: "Offchain message content must be non-empty",
+	[SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_REQUIRED_SIGNERS_CANNOT_BE_ZERO]: "Offchain message must specify the address of at least one required signer",
+	[SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_ENVELOPE_SIGNATURES_CANNOT_BE_ZERO]: "Offchain message envelope must reserve space for at least one signature",
+	[SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_SIGNATURES_MISMATCH]: "The offchain message preamble specifies $numRequiredSignatures required signature(s), got $signaturesLength.",
+	[SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATORIES_MUST_BE_SORTED]: "The signatories of this offchain message must be listed in lexicographical order",
+	[SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATORIES_MUST_BE_UNIQUE]: "An address must be listed no more than once among the signatories of an offchain message",
+	[SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURES_MISSING]: "Offchain message is missing signatures for addresses: $addresses.",
+	[SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURE_VERIFICATION_FAILURE]: "Offchain message signature verification failed. Signature mismatch for required signatories [$signatoriesWithInvalidSignatures]. Missing signatures for signatories [$signatoriesWithMissingSignatures]",
+	[SOLANA_ERROR__OFFCHAIN_MESSAGE__RESTRICTED_ASCII_BODY_CHARACTER_OUT_OF_RANGE]: "The message body provided contains characters whose codes fall outside the allowed range. In order to ensure clear-signing compatiblity with hardware wallets, the message may only contain line feeds and characters in the range [\\x20-\\x7e].",
+	[SOLANA_ERROR__OFFCHAIN_MESSAGE__UNEXPECTED_VERSION]: "Expected offchain message version $expectedVersion. Got $actualVersion.",
+	[SOLANA_ERROR__OFFCHAIN_MESSAGE__VERSION_NUMBER_NOT_SUPPORTED]: "This version of Kit does not support decoding offchain messages with version $unsupportedVersion. The current max supported version is 0.",
+	[SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT]: "The provided account could not be identified as an account from the $programName program.",
+	[SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION]: "The provided instruction could not be identified as an instruction from the $programName program.",
+	[SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS]: "The provided instruction is missing some accounts. Expected at least $expectedAccountMetas account(s), got $actualAccountMetas.",
+	[SOLANA_ERROR__PROGRAM_CLIENTS__RESOLVED_INSTRUCTION_INPUT_MUST_BE_NON_NULL]: "Expected resolved instruction input '$inputName' to be non-null.",
+	[SOLANA_ERROR__PROGRAM_CLIENTS__UNEXPECTED_RESOLVED_INSTRUCTION_INPUT_TYPE]: "Expected resolved instruction input '$inputName' to be of type `$expectedType`.",
+	[SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_ACCOUNT_TYPE]: "Unrecognized account type '$accountType' for the $programName program.",
+	[SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE]: "Unrecognized instruction type '$instructionType' for the $programName program.",
+	[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_ACCOUNT_CANNOT_SIGN_TRANSACTION]: "The wallet account $address cannot be used to create a transaction signer because it does not implement either the `solana:signTransaction` or `solana:signAndSendTransaction` feature. At least one of these features is required. The account supports the following features: $supportedFeatures.",
+	[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.",
+	[9]: "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 1.",
+	[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.",
+	[SOLANA_ERROR__TRANSACTION__INVALID_CONFIG_MASK_PRIORITY_FEE_BITS]: "Invalid transaction config mask: $mask. Bits 0 and 1 must match (both set or both unset)",
+	[SOLANA_ERROR__TRANSACTION__MALFORMED_MESSAGE_BYTES]: "Transaction message bytes are malformed: $messageBytes",
+	[SOLANA_ERROR__TRANSACTION__CANNOT_ENCODE_WITH_EMPTY_MESSAGE_BYTES]: "Transaction message bytes are empty, so the transaction cannot be encoded",
+	[SOLANA_ERROR__TRANSACTION__CANNOT_DECODE_EMPTY_TRANSACTION_BYTES]: "Transaction bytes are empty, so no transaction can be decoded",
+	[SOLANA_ERROR__TRANSACTION__VERSION_ZERO_MUST_BE_ENCODED_WITH_SIGNATURES_FIRST]: "Transaction version 0 must be encoded with signatures first. This transaction was encoded with first byte $firstByte, which is expected to be a signature count for v0 transactions.",
+	[SOLANA_ERROR__TRANSACTION__SIGNATURE_COUNT_TOO_HIGH_FOR_TRANSACTION_BYTES]: "The provided transaction bytes expect that there should be $numExpectedSignatures signatures, but the bytes are not long enough to contain a transaction message with this many signatures. The provided bytes are $transactionBytesLength bytes long.",
+	[SOLANA_ERROR__TRANSACTION__INVALID_NONCE_ACCOUNT_INDEX]: "The transaction has a durable nonce lifetime, but the nonce account index is invalid. Expected a nonce account index less than $numberOfStaticAccounts, got $nonceAccountIndex.",
+	[SOLANA_ERROR__TRANSACTION__INVALID_CONFIG_VALUE_KIND]: "The transaction config value for $configName has the incorrect kind. Expected $expectedKind, got $actualKind.",
+	[SOLANA_ERROR__TRANSACTION__INSTRUCTION_HEADERS_PAYLOADS_MISMATCH]: "The transaction does not have the same number of instruction headers and instruction payloads. Got $numInstructionHeaders instruction headers, and $numInstructionPayloads instruction payloads."
+};
+var INSTRUCTION_ERROR_RANGE_SIZE = 1e3;
+var START_INDEX = "i";
+var TYPE$1 = "t";
+function getHumanReadableErrorMessage(code, context = {}) {
+	const messageFormatString = SolanaErrorMessages[code];
+	if (messageFormatString.length === 0) return "";
+	let state;
+	function commitStateUpTo(endIndex) {
+		if (state[TYPE$1] === 2) {
+			const variableName = messageFormatString.slice(state[START_INDEX] + 1, endIndex);
+			fragments.push(variableName in context ? `${context[variableName]}` : `$${variableName}`);
+		} else if (state[TYPE$1] === 1) fragments.push(messageFormatString.slice(state[START_INDEX], endIndex));
+	}
+	const fragments = [];
+	messageFormatString.split("").forEach((char, ii) => {
+		if (ii === 0) {
+			state = {
+				[START_INDEX]: 0,
+				[TYPE$1]: messageFormatString[0] === "\\" ? 0 : messageFormatString[0] === "$" ? 2 : 1
+			};
+			return;
+		}
+		let nextState;
+		switch (state[TYPE$1]) {
+			case 0:
+				nextState = {
+					[START_INDEX]: ii,
+					[TYPE$1]: 1
+				};
+				break;
+			case 1:
+				if (char === "\\") nextState = {
+					[START_INDEX]: ii,
+					[TYPE$1]: 0
+				};
+				else if (char === "$") nextState = {
+					[START_INDEX]: ii,
+					[TYPE$1]: 2
+				};
+				break;
+			case 2:
+				if (char === "\\") nextState = {
+					[START_INDEX]: ii,
+					[TYPE$1]: 0
+				};
+				else if (char === "$") nextState = {
+					[START_INDEX]: ii,
+					[TYPE$1]: 2
+				};
+				else if (!char.match(/\w/)) nextState = {
+					[START_INDEX]: ii,
+					[TYPE$1]: 1
+				};
+				break;
+		}
+		if (nextState) {
+			if (state !== nextState) commitStateUpTo(ii);
+			state = nextState;
+		}
+	});
+	commitStateUpTo();
+	let message = fragments.join("");
+	if (code >= 4615e3 && code < 4615e3 + INSTRUCTION_ERROR_RANGE_SIZE && "index" in context) message += ` (instruction #${context.index + 1})`;
+	return message;
+}
+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}\``;
+	}
+}
+function isSolanaError(e, code) {
+	if (e instanceof Error && e.name === "SolanaError") {
+		if (code !== void 0) return e.context.__code === code;
+		return true;
+	}
+	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 = { __code: code };
+				Object.defineProperty(context, name, descriptor);
+			}
+		});
+		const message = getErrorMessage(code, context);
+		super(message, errorOptions);
+		this.context = Object.freeze(context === void 0 ? { __code: code } : context);
+		this.name = "SolanaError";
+	}
+};
+function safeCaptureStackTrace(...args) {
+	if ("captureStackTrace" in Error && typeof Error.captureStackTrace === "function") Error.captureStackTrace(...args);
+}
+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 errorCode = errorCodeBaseOffset + orderedErrorNames.indexOf(rpcErrorName);
+	const err = new SolanaError(errorCode, getErrorContext(errorCode, rpcErrorName, rpcErrorContext));
+	safeCaptureStackTrace(err, constructorOpt);
+	return err;
+}
+var ORDERED_ERROR_NAMES = [
+	"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 === 4615e3) return {
+				errorName: rpcErrorName,
+				index: numberIndex,
+				...rpcErrorContext !== void 0 ? { instructionErrorContext: rpcErrorContext } : null
+			};
+			else if (errorCode === 4615026) return {
+				code: Number(rpcErrorContext),
+				index: numberIndex
+			};
+			return { index: numberIndex };
+		},
+		orderedErrorNames: ORDERED_ERROR_NAMES,
+		rpcEnumError: instructionError
+	}, getSolanaErrorFromInstructionError);
+}
+var ORDERED_ERROR_NAMES2 = [
+	"AccountInUse",
+	"AccountLoadedTwice",
+	"AccountNotFound",
+	"ProgramAccountNotFound",
+	"InsufficientFundsForFee",
+	"InvalidAccountForFee",
+	"AlreadyProcessed",
+	"BlockhashNotFound",
+	"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 === 705e4) return {
+				errorName: rpcErrorName,
+				...rpcErrorContext !== void 0 ? { transactionErrorContext: rpcErrorContext } : null
+			};
+			else if (errorCode === 7050030) return { index: Number(rpcErrorContext) };
+			else if (errorCode === 7050031 || errorCode === 7050035) return { accountIndex: Number(rpcErrorContext.account_index) };
+		},
+		orderedErrorNames: ORDERED_ERROR_NAMES2,
+		rpcEnumError: transactionError
+	}, getSolanaErrorFromTransactionError);
+}
+function getSolanaErrorFromJsonRpcError(putativeErrorResponse) {
+	let out;
+	if (isRpcErrorResponse(putativeErrorResponse)) {
+		const { code: rawCode, data, message } = putativeErrorResponse;
+		const code = Number(rawCode);
+		if (code === -32002) {
+			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 out = new SolanaError(10, {
+		error: putativeErrorResponse,
+		message: typeof putativeErrorResponse === "object" && putativeErrorResponse !== null && "message" in putativeErrorResponse && typeof putativeErrorResponse.message === "string" ? putativeErrorResponse.message : "Malformed JSON-RPC error with no message attribute"
+	});
+	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";
+}
+//#endregion
+//#region node_modules/.pnpm/@solana+codecs-core@6.5.0_typescript@5.9.3/node_modules/@solana/codecs-core/dist/index.node.mjs
+function padBytes(bytes, length) {
+	if (bytes.length >= length) return bytes;
+	const paddedBytes = new Uint8Array(length).fill(0);
+	paddedBytes.set(bytes);
+	return paddedBytes;
+}
+var fixBytes = (bytes, length) => padBytes(bytes.length <= length ? bytes : bytes.slice(0, length), length);
+function bytesEqual(bytes1, bytes2) {
+	return bytes1.length === bytes2.length && bytes1.every((value, index) => value === bytes2[index]);
+}
+function getEncodedSize(value, encoder) {
+	return "fixedSize" in encoder ? encoder.fixedSize : encoder.getSizeFromValue(value);
+}
+function createEncoder(encoder) {
+	return Object.freeze({
+		...encoder,
+		encode: (value) => {
+			const bytes = new Uint8Array(getEncodedSize(value, encoder));
+			encoder.write(value, bytes, 0);
+			return bytes;
+		}
+	});
+}
+function createDecoder(decoder) {
+	return Object.freeze({
+		...decoder,
+		decode: (bytes, offset = 0) => decoder.read(bytes, offset)[0]
+	});
+}
+function isFixedSize(codec) {
+	return "fixedSize" in codec && typeof codec.fixedSize === "number";
+}
+function assertIsFixedSize(codec) {
+	if (!isFixedSize(codec)) throw new SolanaError(SOLANA_ERROR__CODECS__EXPECTED_FIXED_LENGTH);
+}
+function isVariableSize(codec) {
+	return !isFixedSize(codec);
+}
+function combineCodec(encoder, decoder) {
+	if (isFixedSize(encoder) !== isFixedSize(decoder)) throw new SolanaError(SOLANA_ERROR__CODECS__ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH);
+	if (isFixedSize(encoder) && isFixedSize(decoder) && encoder.fixedSize !== decoder.fixedSize) throw new SolanaError(SOLANA_ERROR__CODECS__ENCODER_DECODER_FIXED_SIZE_MISMATCH, {
+		decoderFixedSize: decoder.fixedSize,
+		encoderFixedSize: encoder.fixedSize
+	});
+	if (!isFixedSize(encoder) && !isFixedSize(decoder) && encoder.maxSize !== decoder.maxSize) throw new SolanaError(SOLANA_ERROR__CODECS__ENCODER_DECODER_MAX_SIZE_MISMATCH, {
+		decoderMaxSize: decoder.maxSize,
+		encoderMaxSize: encoder.maxSize
+	});
+	return {
+		...decoder,
+		...encoder,
+		decode: decoder.decode,
+		encode: encoder.encode,
+		read: decoder.read,
+		write: encoder.write
+	};
+}
+function assertByteArrayIsNotEmptyForCodec(codecDescription, bytes, offset = 0) {
+	if (bytes.length - offset <= 0) throw new SolanaError(SOLANA_ERROR__CODECS__CANNOT_DECODE_EMPTY_BYTE_ARRAY, { codecDescription });
+}
+function assertByteArrayHasEnoughBytesForCodec(codecDescription, expected, bytes, offset = 0) {
+	const bytesLength = bytes.length - offset;
+	if (bytesLength < expected) throw new SolanaError(SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH, {
+		bytesLength,
+		codecDescription,
+		expected
+	});
+}
+function addEncoderSizePrefix(encoder, prefix) {
+	const write = ((value, bytes, offset) => {
+		const encoderBytes = encoder.encode(value);
+		offset = prefix.write(encoderBytes.length, bytes, offset);
+		bytes.set(encoderBytes, offset);
+		return offset + encoderBytes.length;
+	});
+	if (isFixedSize(prefix) && isFixedSize(encoder)) return createEncoder({
+		...encoder,
+		fixedSize: prefix.fixedSize + encoder.fixedSize,
+		write
+	});
+	const prefixMaxSize = isFixedSize(prefix) ? prefix.fixedSize : prefix.maxSize ?? null;
+	const encoderMaxSize = isFixedSize(encoder) ? encoder.fixedSize : encoder.maxSize ?? null;
+	const maxSize = prefixMaxSize !== null && encoderMaxSize !== null ? prefixMaxSize + encoderMaxSize : null;
+	return createEncoder({
+		...encoder,
+		...maxSize !== null ? { maxSize } : {},
+		getSizeFromValue: (value) => {
+			const encoderSize = getEncodedSize(value, encoder);
+			return getEncodedSize(encoderSize, prefix) + encoderSize;
+		},
+		write
+	});
+}
+function toArrayBuffer(bytes, offset, length) {
+	const bytesOffset = bytes.byteOffset + (offset ?? 0);
+	const bytesLength = length ?? bytes.byteLength;
+	let buffer;
+	if (typeof SharedArrayBuffer === "undefined") buffer = bytes.buffer;
+	else if (bytes.buffer instanceof SharedArrayBuffer) {
+		buffer = new ArrayBuffer(bytes.length);
+		new Uint8Array(buffer).set(new Uint8Array(bytes));
+	} else buffer = bytes.buffer;
+	return (bytesOffset === 0 || bytesOffset === -bytes.byteLength) && bytesLength === bytes.byteLength ? buffer : buffer.slice(bytesOffset, bytesOffset + bytesLength);
+}
+function fixEncoderSize(encoder, fixedBytes) {
+	return createEncoder({
+		fixedSize: fixedBytes,
+		write: (value, bytes, offset) => {
+			const variableByteArray = encoder.encode(value);
+			const fixedByteArray = variableByteArray.length > fixedBytes ? variableByteArray.slice(0, fixedBytes) : variableByteArray;
+			bytes.set(fixedByteArray, offset);
+			return offset + fixedBytes;
+		}
+	});
+}
+function fixDecoderSize(decoder, fixedBytes) {
+	return createDecoder({
+		fixedSize: fixedBytes,
+		read: (bytes, offset) => {
+			assertByteArrayHasEnoughBytesForCodec("fixCodecSize", fixedBytes, bytes, offset);
+			if (offset > 0 || bytes.length > fixedBytes) bytes = bytes.slice(offset, offset + fixedBytes);
+			if (isFixedSize(decoder)) bytes = fixBytes(bytes, decoder.fixedSize);
+			const [value] = decoder.read(bytes, 0);
+			return [value, offset + fixedBytes];
+		}
+	});
+}
+function transformEncoder(encoder, unmap) {
+	return createEncoder({
+		...isVariableSize(encoder) ? {
+			...encoder,
+			getSizeFromValue: (value) => encoder.getSizeFromValue(unmap(value))
+		} : encoder,
+		write: (value, bytes, offset) => encoder.write(unmap(value), bytes, offset)
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/@solana+codecs-strings@6.5.0_typescript@5.9.3/node_modules/@solana/codecs-strings/dist/index.node.mjs
+function assertValidBaseString$1(alphabet4, testValue, givenValue = testValue) {
+	if (!testValue.match(new RegExp(`^[${alphabet4}]*$`))) throw new SolanaError(SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE, {
+		alphabet: alphabet4,
+		base: alphabet4.length,
+		value: givenValue
+	});
+}
+var getBaseXEncoder$1 = (alphabet4) => {
+	return createEncoder({
+		getSizeFromValue: (value) => {
+			const [leadingZeroes, tailChars] = partitionLeadingZeroes$1(value, alphabet4[0]);
+			if (!tailChars) return value.length;
+			const base10Number = getBigIntFromBaseX$1(tailChars, alphabet4);
+			return leadingZeroes.length + Math.ceil(base10Number.toString(16).length / 2);
+		},
+		write(value, bytes, offset) {
+			assertValidBaseString$1(alphabet4, value);
+			if (value === "") return offset;
+			const [leadingZeroes, tailChars] = partitionLeadingZeroes$1(value, alphabet4[0]);
+			if (!tailChars) {
+				bytes.set(new Uint8Array(leadingZeroes.length).fill(0), offset);
+				return offset + leadingZeroes.length;
+			}
+			let base10Number = getBigIntFromBaseX$1(tailChars, alphabet4);
+			const tailBytes = [];
+			while (base10Number > 0n) {
+				tailBytes.unshift(Number(base10Number % 256n));
+				base10Number /= 256n;
+			}
+			const bytesToAdd = [...Array(leadingZeroes.length).fill(0), ...tailBytes];
+			bytes.set(bytesToAdd, offset);
+			return offset + bytesToAdd.length;
+		}
+	});
+};
+var getBaseXDecoder = (alphabet4) => {
+	return createDecoder({ read(rawBytes, offset) {
+		const bytes = offset === 0 || offset <= -rawBytes.byteLength ? rawBytes : rawBytes.slice(offset);
+		if (bytes.length === 0) return ["", 0];
+		let trailIndex = bytes.findIndex((n) => n !== 0);
+		trailIndex = trailIndex === -1 ? bytes.length : trailIndex;
+		const leadingZeroes = alphabet4[0].repeat(trailIndex);
+		if (trailIndex === bytes.length) return [leadingZeroes, rawBytes.length];
+		return [leadingZeroes + getBaseXFromBigInt(bytes.slice(trailIndex).reduce((sum, byte) => sum * 256n + BigInt(byte), 0n), alphabet4), rawBytes.length];
+	} });
+};
+function partitionLeadingZeroes$1(value, zeroCharacter) {
+	const [leadingZeros, tailChars] = value.split(new RegExp(`((?!${zeroCharacter}).*)`));
+	return [leadingZeros, tailChars];
+}
+function getBigIntFromBaseX$1(value, alphabet4) {
+	const base = BigInt(alphabet4.length);
+	let sum = 0n;
+	for (const char of value) {
+		sum *= base;
+		sum += BigInt(alphabet4.indexOf(char));
+	}
+	return sum;
+}
+function getBaseXFromBigInt(value, alphabet4) {
+	const base = BigInt(alphabet4.length);
+	const tailChars = [];
+	while (value > 0n) {
+		tailChars.unshift(alphabet4[Number(value % base)]);
+		value /= base;
+	}
+	return tailChars.join("");
+}
+var alphabet2$1 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var getBase58Encoder$1 = () => getBaseXEncoder$1(alphabet2$1);
+var getBase58Decoder = () => getBaseXDecoder(alphabet2$1);
+var getBase64Decoder = () => {
+	return createDecoder({ read: (bytes, offset = 0) => [Buffer.from(toArrayBuffer(bytes), offset).toString("base64"), bytes.length] });
+};
+globalThis.TextDecoder;
+globalThis.TextEncoder;
+//#endregion
+//#region node_modules/.pnpm/@solana+assertions@6.5.0_typescript@5.9.3/node_modules/@solana/assertions/dist/index.node.mjs
+function assertPRNGIsAvailable() {
+	if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.getRandomValues !== "function") throw new SolanaError(SOLANA_ERROR__CRYPTO__RANDOM_VALUES_FUNCTION_UNIMPLEMENTED);
+}
+function assertDigestCapabilityIsAvailable() {
+	if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.digest !== "function") throw new SolanaError(SOLANA_ERROR__SUBTLE_CRYPTO__DIGEST_UNIMPLEMENTED);
+}
+function assertKeyExporterIsAvailable() {
+	if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.exportKey !== "function") throw new SolanaError(SOLANA_ERROR__SUBTLE_CRYPTO__EXPORT_FUNCTION_UNIMPLEMENTED);
+}
+function assertSigningCapabilityIsAvailable() {
+	if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.sign !== "function") throw new SolanaError(SOLANA_ERROR__SUBTLE_CRYPTO__SIGN_FUNCTION_UNIMPLEMENTED);
+}
+function assertVerificationCapabilityIsAvailable() {
+	if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.verify !== "function") throw new SolanaError(SOLANA_ERROR__SUBTLE_CRYPTO__VERIFY_FUNCTION_UNIMPLEMENTED);
+}
+//#endregion
+//#region node_modules/.pnpm/@solana+addresses@6.5.0_typescript@5.9.3/node_modules/@solana/addresses/dist/index.node.mjs
+var memoizedBase58Encoder;
+var memoizedBase58Decoder;
+function getMemoizedBase58Encoder() {
+	if (!memoizedBase58Encoder) memoizedBase58Encoder = getBase58Encoder$1();
+	return memoizedBase58Encoder;
+}
+function getMemoizedBase58Decoder() {
+	if (!memoizedBase58Decoder) memoizedBase58Decoder = getBase58Decoder();
+	return memoizedBase58Decoder;
+}
+function isAddress(putativeAddress) {
+	if (putativeAddress.length < 32 || putativeAddress.length > 44) return false;
+	const base58Encoder = getMemoizedBase58Encoder();
+	try {
+		return base58Encoder.encode(putativeAddress).byteLength === 32;
+	} catch {
+		return false;
+	}
+}
+function assertIsAddress(putativeAddress) {
+	if (putativeAddress.length < 32 || putativeAddress.length > 44) throw new SolanaError(SOLANA_ERROR__ADDRESSES__STRING_LENGTH_OUT_OF_RANGE, { actualLength: putativeAddress.length });
+	const numBytes = getMemoizedBase58Encoder().encode(putativeAddress).byteLength;
+	if (numBytes !== 32) throw new SolanaError(SOLANA_ERROR__ADDRESSES__INVALID_BYTE_LENGTH, { actualLength: numBytes });
+}
+function address(putativeAddress) {
+	assertIsAddress(putativeAddress);
+	return putativeAddress;
+}
+function getAddressEncoder() {
+	return transformEncoder(fixEncoderSize(getMemoizedBase58Encoder(), 32), (putativeAddress) => address(putativeAddress));
+}
+function getAddressDecoder() {
+	return fixDecoderSize(getMemoizedBase58Decoder(), 32);
+}
+function getAddressCodec() {
+	return combineCodec(getAddressEncoder(), getAddressDecoder());
+}
+function getAddressComparator() {
+	return new Intl.Collator("en", {
+		caseFirst: "lower",
+		ignorePunctuation: false,
+		localeMatcher: "best fit",
+		numeric: false,
+		sensitivity: "variant",
+		usage: "sort"
+	}).compare;
+}
+var D = 37095705934669439343138083508754565189542113879843219016388785533085940283555n;
+var P = 57896044618658097711785492504343953926634992332820282019728792003956564819949n;
+var RM1 = 19681161376707505956807079304988542015446066515923890162744021073123829784752n;
+function mod(a) {
+	const r = a % P;
+	return r >= 0n ? r : P + r;
+}
+function pow2(x, power) {
+	let r = x;
+	while (power-- > 0n) {
+		r *= r;
+		r %= P;
+	}
+	return r;
+}
+function pow_2_252_3(x) {
+	const b2 = x * x % P * x % P;
+	const b5 = pow2(pow2(b2, 2n) * b2 % P, 1n) * x % P;
+	const b10 = pow2(b5, 5n) * b5 % P;
+	const b20 = pow2(b10, 10n) * b10 % P;
+	const b40 = pow2(b20, 20n) * b20 % P;
+	const b80 = pow2(b40, 40n) * b40 % P;
+	return pow2(pow2(pow2(pow2(b80, 80n) * b80 % P, 80n) * b80 % P, 10n) * b10 % P, 2n) * x % P;
+}
+function uvRatio(u, v) {
+	const v3 = mod(v * v * v);
+	const pow = pow_2_252_3(u * mod(v3 * v3 * v));
+	let x = mod(u * v3 * pow);
+	const vx2 = mod(v * x * x);
+	const root1 = x;
+	const root2 = mod(x * RM1);
+	const useRoot1 = vx2 === u;
+	const useRoot2 = vx2 === mod(-u);
+	const noRoot = vx2 === mod(-u * RM1);
+	if (useRoot1) x = root1;
+	if (useRoot2 || noRoot) x = root2;
+	if ((mod(x) & 1n) === 1n) x = mod(-x);
+	if (!useRoot1 && !useRoot2) return null;
+	return x;
+}
+function pointIsOnCurve(y, lastByte) {
+	const y2 = mod(y * y);
+	const x = uvRatio(mod(y2 - 1n), mod(D * y2 + 1n));
+	if (x === null) return false;
+	const isLastByteOdd = (lastByte & 128) !== 0;
+	if (x === 0n && isLastByteOdd) return false;
+	return true;
+}
+function byteToHex(byte) {
+	const hexString = byte.toString(16);
+	if (hexString.length === 1) return `0${hexString}`;
+	else return hexString;
+}
+function decompressPointBytes(bytes) {
+	const integerLiteralString = `0x${bytes.reduce((acc, byte, ii) => `${byteToHex(ii === 31 ? byte & -129 : byte)}${acc}`, "")}`;
+	return BigInt(integerLiteralString);
+}
+function compressedPointBytesAreOnCurve(bytes) {
+	if (bytes.byteLength !== 32) return false;
+	return pointIsOnCurve(decompressPointBytes(bytes), bytes[31]);
+}
+var MAX_SEED_LENGTH = 32;
+var MAX_SEEDS = 16;
+var PDA_MARKER_BYTES = [
+	80,
+	114,
+	111,
+	103,
+	114,
+	97,
+	109,
+	68,
+	101,
+	114,
+	105,
+	118,
+	101,
+	100,
+	65,
+	100,
+	100,
+	114,
+	101,
+	115,
+	115
+];
+async function createProgramDerivedAddress({ programAddress, seeds }) {
+	assertDigestCapabilityIsAvailable();
+	if (seeds.length > MAX_SEEDS) throw new SolanaError(SOLANA_ERROR__ADDRESSES__MAX_NUMBER_OF_PDA_SEEDS_EXCEEDED, {
+		actual: seeds.length,
+		maxSeeds: MAX_SEEDS
+	});
+	let textEncoder;
+	const seedBytes = seeds.reduce((acc, seed, ii) => {
+		const bytes = typeof seed === "string" ? (textEncoder ||= new TextEncoder()).encode(seed) : seed;
+		if (bytes.byteLength > MAX_SEED_LENGTH) throw new SolanaError(SOLANA_ERROR__ADDRESSES__MAX_PDA_SEED_LENGTH_EXCEEDED, {
+			actual: bytes.byteLength,
+			index: ii,
+			maxSeedLength: MAX_SEED_LENGTH
+		});
+		acc.push(...bytes);
+		return acc;
+	}, []);
+	const base58EncodedAddressCodec = getAddressCodec();
+	const programAddressBytes = base58EncodedAddressCodec.encode(programAddress);
+	const addressBytesBuffer = await crypto.subtle.digest("SHA-256", new Uint8Array([
+		...seedBytes,
+		...programAddressBytes,
+		...PDA_MARKER_BYTES
+	]));
+	const addressBytes = new Uint8Array(addressBytesBuffer);
+	if (compressedPointBytesAreOnCurve(addressBytes)) throw new SolanaError(SOLANA_ERROR__ADDRESSES__INVALID_SEEDS_POINT_ON_CURVE);
+	return base58EncodedAddressCodec.decode(addressBytes);
+}
+async function getProgramDerivedAddress({ programAddress, seeds }) {
+	let bumpSeed = 255;
+	while (bumpSeed > 0) try {
+		return [await createProgramDerivedAddress({
+			programAddress,
+			seeds: [...seeds, new Uint8Array([bumpSeed])]
+		}), bumpSeed];
+	} catch (e) {
+		if (isSolanaError(e, 2800008)) bumpSeed--;
+		else throw e;
+	}
+	throw new SolanaError(SOLANA_ERROR__ADDRESSES__FAILED_TO_FIND_VIABLE_PDA_BUMP_SEED);
+}
+async function getAddressFromPublicKey(publicKey) {
+	assertKeyExporterIsAvailable();
+	if (publicKey.type !== "public" || publicKey.algorithm.name !== "Ed25519") throw new SolanaError(SOLANA_ERROR__ADDRESSES__INVALID_ED25519_PUBLIC_KEY);
+	const publicKeyBytes = await crypto.subtle.exportKey("raw", publicKey);
+	return getAddressDecoder().decode(new Uint8Array(publicKeyBytes));
+}
+//#endregion
+//#region node_modules/.pnpm/@solana+codecs-numbers@6.5.0_typescript@5.9.3/node_modules/@solana/codecs-numbers/dist/index.node.mjs
+function assertNumberIsBetweenForCodec(codecDescription, min, max, value) {
+	if (value < min || value > max) throw new SolanaError(SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE, {
+		codecDescription,
+		max,
+		min,
+		value
+	});
+}
+function isLittleEndian(config) {
+	return config?.endian === 1 ? false : true;
+}
+function numberEncoderFactory(input) {
+	return createEncoder({
+		fixedSize: input.size,
+		write(value, bytes, offset) {
+			if (input.range) assertNumberIsBetweenForCodec(input.name, input.range[0], input.range[1], value);
+			const arrayBuffer = new ArrayBuffer(input.size);
+			input.set(new DataView(arrayBuffer), value, isLittleEndian(input.config));
+			bytes.set(new Uint8Array(arrayBuffer), offset);
+			return offset + input.size;
+		}
+	});
+}
+function numberDecoderFactory(input) {
+	return createDecoder({
+		fixedSize: input.size,
+		read(bytes, offset = 0) {
+			assertByteArrayIsNotEmptyForCodec(input.name, bytes, offset);
+			assertByteArrayHasEnoughBytesForCodec(input.name, input.size, bytes, offset);
+			const view = new DataView(toArrayBuffer(bytes, offset, input.size));
+			return [input.get(view, isLittleEndian(input.config)), offset + input.size];
+		}
+	});
+}
+var getShortU16Encoder = () => createEncoder({
+	getSizeFromValue: (value) => {
+		if (value <= 127) return 1;
+		if (value <= 16383) return 2;
+		return 3;
+	},
+	maxSize: 3,
+	write: (value, bytes, offset) => {
+		assertNumberIsBetweenForCodec("shortU16", 0, 65535, value);
+		const shortU16Bytes = [0];
+		for (let ii = 0;; ii += 1) {
+			const alignedValue = Number(value) >> ii * 7;
+			if (alignedValue === 0) break;
+			shortU16Bytes[ii] = 127 & alignedValue;
+			if (ii > 0) shortU16Bytes[ii - 1] |= 128;
+		}
+		bytes.set(shortU16Bytes, offset);
+		return offset + shortU16Bytes.length;
+	}
+});
+var getU16Encoder = (config = {}) => numberEncoderFactory({
+	config,
+	name: "u16",
+	range: [0, 65535],
+	set: (view, value, le) => view.setUint16(0, Number(value), le),
+	size: 2
+});
+var getU32Encoder = (config = {}) => numberEncoderFactory({
+	config,
+	name: "u32",
+	range: [0, 4294967295],
+	set: (view, value, le) => view.setUint32(0, Number(value), le),
+	size: 4
+});
+var getU32Decoder = (config = {}) => numberDecoderFactory({
+	config,
+	get: (view, le) => view.getUint32(0, le),
+	name: "u32",
+	size: 4
+});
+var getU64Encoder = (config = {}) => numberEncoderFactory({
+	config,
+	name: "u64",
+	range: [0n, BigInt("0xffffffffffffffff")],
+	set: (view, value, le) => view.setBigUint64(0, BigInt(value), le),
+	size: 8
+});
+var getU64Decoder = (config = {}) => numberDecoderFactory({
+	config,
+	get: (view, le) => view.getBigUint64(0, le),
+	name: "u64",
+	size: 8
+});
+var getU8Encoder = () => numberEncoderFactory({
+	name: "u8",
+	range: [0, 255],
+	set: (view, value) => view.setUint8(0, Number(value)),
+	size: 1
+});
+//#endregion
+//#region node_modules/.pnpm/@solana+codecs-data-structures@6.5.0_typescript@5.9.3/node_modules/@solana/codecs-data-structures/dist/index.node.mjs
+function assertValidNumberOfItemsForCodec(codecDescription, expected, actual) {
+	if (expected !== actual) throw new SolanaError(SOLANA_ERROR__CODECS__INVALID_NUMBER_OF_ITEMS, {
+		actual,
+		codecDescription,
+		expected
+	});
+}
+function maxCodecSizes(sizes) {
+	return sizes.reduce((all, size) => all === null || size === null ? null : Math.max(all, size), 0);
+}
+function sumCodecSizes(sizes) {
+	return sizes.reduce((all, size) => all === null || size === null ? null : all + size, 0);
+}
+function getFixedSize(codec) {
+	return isFixedSize(codec) ? codec.fixedSize : null;
+}
+function getMaxSize(codec) {
+	return isFixedSize(codec) ? codec.fixedSize : codec.maxSize ?? null;
+}
+function getArrayEncoder(item, config = {}) {
+	const size = config.size ?? getU32Encoder();
+	const fixedSize = computeArrayLikeCodecSize(size, getFixedSize(item));
+	const maxSize = computeArrayLikeCodecSize(size, getMaxSize(item)) ?? void 0;
+	return createEncoder({
+		...fixedSize !== null ? { fixedSize } : {
+			getSizeFromValue: (array) => {
+				return (typeof size === "object" ? getEncodedSize(array.length, size) : 0) + [...array].reduce((all, value) => all + getEncodedSize(value, item), 0);
+			},
+			maxSize
+		},
+		write: (array, bytes, offset) => {
+			if (typeof size === "number") assertValidNumberOfItemsForCodec(config.description ?? "array", size, array.length);
+			if (typeof size === "object") offset = size.write(array.length, bytes, offset);
+			array.forEach((value) => {
+				offset = item.write(value, bytes, offset);
+			});
+			return offset;
+		}
+	});
+}
+function computeArrayLikeCodecSize(size, itemSize) {
+	if (typeof size !== "number") return null;
+	if (size === 0) return 0;
+	return itemSize === null ? null : itemSize * size;
+}
+function getBooleanEncoder(config = {}) {
+	return transformEncoder(config.size ?? getU8Encoder(), (value) => value ? 1 : 0);
+}
+function getBytesEncoder() {
+	return createEncoder({
+		getSizeFromValue: (value) => value.length,
+		write: (value, bytes, offset) => {
+			bytes.set(value, offset);
+			return offset + value.length;
+		}
+	});
+}
+function getConstantEncoder(constant) {
+	return createEncoder({
+		fixedSize: constant.length,
+		write: (_, bytes, offset) => {
+			bytes.set(constant, offset);
+			return offset + constant.length;
+		}
+	});
+}
+function getTupleEncoder(items, config) {
+	const fixedSize = sumCodecSizes(items.map(getFixedSize));
+	const maxSize = sumCodecSizes(items.map(getMaxSize)) ?? void 0;
+	return createEncoder({
+		...fixedSize === null ? {
+			getSizeFromValue: (value) => items.map((item, index) => getEncodedSize(value[index], item)).reduce((all, one) => all + one, 0),
+			maxSize
+		} : { fixedSize },
+		write: (value, bytes, offset) => {
+			assertValidNumberOfItemsForCodec(config?.description ?? "tuple", items.length, value.length);
+			items.forEach((item, index) => {
+				offset = item.write(value[index], bytes, offset);
+			});
+			return offset;
+		}
+	});
+}
+function getUnionEncoder(variants, getIndexFromValue) {
+	const fixedSize = getUnionFixedSize(variants);
+	const write = (variant, bytes, offset) => {
+		const index = getIndexFromValue(variant);
+		assertValidVariantIndex(variants, index);
+		return variants[index].write(variant, bytes, offset);
+	};
+	if (fixedSize !== null) return createEncoder({
+		fixedSize,
+		write
+	});
+	const maxSize = getUnionMaxSize(variants);
+	return createEncoder({
+		...maxSize !== null ? { maxSize } : {},
+		getSizeFromValue: (variant) => {
+			const index = getIndexFromValue(variant);
+			assertValidVariantIndex(variants, index);
+			return getEncodedSize(variant, variants[index]);
+		},
+		write
+	});
+}
+function assertValidVariantIndex(variants, index) {
+	if (typeof variants[index] === "undefined") throw new SolanaError(SOLANA_ERROR__CODECS__UNION_VARIANT_OUT_OF_RANGE, {
+		maxRange: variants.length - 1,
+		minRange: 0,
+		variant: index
+	});
+}
+function getUnionFixedSize(variants) {
+	if (variants.length === 0) return 0;
+	if (!isFixedSize(variants[0])) return null;
+	const variantSize = variants[0].fixedSize;
+	return variants.every((variant) => isFixedSize(variant) && variant.fixedSize === variantSize) ? variantSize : null;
+}
+function getUnionMaxSize(variants) {
+	return maxCodecSizes(variants.map((variant) => getMaxSize(variant)));
+}
+function getUnitEncoder() {
+	return createEncoder({
+		fixedSize: 0,
+		write: (_value, _bytes, offset) => offset
+	});
+}
+function getNullableEncoder(item, config = {}) {
+	const prefix = (() => {
+		if (config.prefix === null) return transformEncoder(getUnitEncoder(), (_boolean) => void 0);
+		return getBooleanEncoder({ size: config.prefix ?? getU8Encoder() });
+	})();
+	return getUnionEncoder([transformEncoder(getTupleEncoder([prefix, (() => {
+		if (config.noneValue === "zeroes") {
+			assertIsFixedSize(item);
+			return fixEncoderSize(getUnitEncoder(), item.fixedSize);
+		}
+		if (!config.noneValue) return getUnitEncoder();
+		return getConstantEncoder(config.noneValue);
+	})()]), (_value) => [false, void 0]), transformEncoder(getTupleEncoder([prefix, item]), (value) => [true, value])], (variant) => Number(variant !== null));
+}
+function getPatternMatchEncoder(patterns) {
+	return getUnionEncoder(patterns.map(([, encoder]) => encoder), (value) => {
+		const index = patterns.findIndex(([predicate]) => predicate(value));
+		if (index === -1) throw new SolanaError(SOLANA_ERROR__CODECS__INVALID_PATTERN_MATCH_VALUE);
+		return index;
+	});
+}
+function getPredicateEncoder(predicate, ifTrue, ifFalse) {
+	return getUnionEncoder([ifTrue, ifFalse], (value) => predicate(value) ? 0 : 1);
+}
+function getStructEncoder(fields) {
+	const fieldCodecs = fields.map(([, codec]) => codec);
+	const fixedSize = sumCodecSizes(fieldCodecs.map(getFixedSize));
+	const maxSize = sumCodecSizes(fieldCodecs.map(getMaxSize)) ?? void 0;
+	return createEncoder({
+		...fixedSize === null ? {
+			getSizeFromValue: (value) => fields.map(([key, codec]) => getEncodedSize(value[key], codec)).reduce((all, one) => all + one, 0),
+			maxSize
+		} : { fixedSize },
+		write: (struct, bytes, offset) => {
+			fields.forEach(([key, codec]) => {
+				offset = codec.write(struct[key], bytes, offset);
+			});
+			return offset;
+		}
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/@solana+functional@6.5.0_typescript@5.9.3/node_modules/@solana/functional/dist/index.node.mjs
+function pipe(init, ...fns) {
+	return fns.reduce((acc, fn) => fn(acc), init);
+}
+//#endregion
+//#region node_modules/.pnpm/@solana+instructions@6.5.0_typescript@5.9.3/node_modules/@solana/instructions/dist/index.node.mjs
+var AccountRole = /* @__PURE__ */ ((AccountRole2) => {
+	AccountRole2[AccountRole2["WRITABLE_SIGNER"] = 3] = "WRITABLE_SIGNER";
+	AccountRole2[AccountRole2["READONLY_SIGNER"] = 2] = "READONLY_SIGNER";
+	AccountRole2[AccountRole2["WRITABLE"] = 1] = "WRITABLE";
+	AccountRole2[AccountRole2["READONLY"] = 0] = "READONLY";
+	return AccountRole2;
+})(AccountRole || {});
+var IS_SIGNER_BITMASK = 2;
+var IS_WRITABLE_BITMASK = 1;
+function isSignerRole(role) {
+	return role >= 2;
+}
+function isWritableRole(role) {
+	return (role & IS_WRITABLE_BITMASK) !== 0;
+}
+function mergeRoles(roleA, roleB) {
+	return roleA | roleB;
+}
+function upgradeRoleToSigner(role) {
+	return role | IS_SIGNER_BITMASK;
+}
+//#endregion
+//#region node_modules/.pnpm/@solana+rpc-types@6.5.0_typescript@5.9.3/node_modules/@solana/rpc-types/dist/index.node.mjs
+function isBlockhash(putativeBlockhash) {
+	return isAddress(putativeBlockhash);
+}
+function mainnet(putativeString) {
+	return putativeString;
+}
+//#endregion
+//#region node_modules/.pnpm/@solana+transaction-messages@6.5.0_typescript@5.9.3/node_modules/@solana/transaction-messages/dist/index.node.mjs
+function isTransactionMessageWithBlockhashLifetime(transactionMessage) {
+	return "lifetimeConstraint" in transactionMessage && typeof transactionMessage.lifetimeConstraint.blockhash === "string" && typeof transactionMessage.lifetimeConstraint.lastValidBlockHeight === "bigint" && isBlockhash(transactionMessage.lifetimeConstraint.blockhash);
+}
+function setTransactionMessageLifetimeUsingBlockhash(blockhashLifetimeConstraint, transactionMessage) {
+	if ("lifetimeConstraint" in transactionMessage && transactionMessage.lifetimeConstraint && "blockhash" in transactionMessage.lifetimeConstraint && transactionMessage.lifetimeConstraint.blockhash === blockhashLifetimeConstraint.blockhash && transactionMessage.lifetimeConstraint.lastValidBlockHeight === blockhashLifetimeConstraint.lastValidBlockHeight) return transactionMessage;
+	return Object.freeze({
+		...transactionMessage,
+		lifetimeConstraint: Object.freeze(blockhashLifetimeConstraint)
+	});
+}
+var memoizedU8Encoder;
+function getMemoizedU8Encoder() {
+	if (!memoizedU8Encoder) memoizedU8Encoder = getU8Encoder();
+	return memoizedU8Encoder;
+}
+function getMessageHeaderEncoder() {
+	return getStructEncoder([
+		["numSignerAccounts", getMemoizedU8Encoder()],
+		["numReadonlySignerAccounts", getMemoizedU8Encoder()],
+		["numReadonlyNonSignerAccounts", getMemoizedU8Encoder()]
+	]);
+}
+var memoizedGetInstructionEncoder;
+function getInstructionEncoder() {
+	if (!memoizedGetInstructionEncoder) memoizedGetInstructionEncoder = transformEncoder(getStructEncoder([
+		["programAddressIndex", getU8Encoder()],
+		["accountIndices", getArrayEncoder(getU8Encoder(), { size: getShortU16Encoder() })],
+		["data", addEncoderSizePrefix(getBytesEncoder(), getShortU16Encoder())]
+	]), (instruction) => {
+		if (instruction.accountIndices !== void 0 && instruction.data !== void 0) return instruction;
+		return {
+			...instruction,
+			accountIndices: instruction.accountIndices ?? [],
+			data: instruction.data ?? new Uint8Array(0)
+		};
+	});
+	return memoizedGetInstructionEncoder;
+}
+function assertValidBaseString(alphabet4, testValue, givenValue = testValue) {
+	if (!testValue.match(new RegExp(`^[${alphabet4}]*$`))) throw new SolanaError(SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE, {
+		alphabet: alphabet4,
+		base: alphabet4.length,
+		value: givenValue
+	});
+}
+var getBaseXEncoder = (alphabet4) => {
+	return createEncoder({
+		getSizeFromValue: (value) => {
+			const [leadingZeroes, tailChars] = partitionLeadingZeroes(value, alphabet4[0]);
+			if (!tailChars) return value.length;
+			const base10Number = getBigIntFromBaseX(tailChars, alphabet4);
+			return leadingZeroes.length + Math.ceil(base10Number.toString(16).length / 2);
+		},
+		write(value, bytes, offset) {
+			assertValidBaseString(alphabet4, value);
+			if (value === "") return offset;
+			const [leadingZeroes, tailChars] = partitionLeadingZeroes(value, alphabet4[0]);
+			if (!tailChars) {
+				bytes.set(new Uint8Array(leadingZeroes.length).fill(0), offset);
+				return offset + leadingZeroes.length;
+			}
+			let base10Number = getBigIntFromBaseX(tailChars, alphabet4);
+			const tailBytes = [];
+			while (base10Number > 0n) {
+				tailBytes.unshift(Number(base10Number % 256n));
+				base10Number /= 256n;
+			}
+			const bytesToAdd = [...Array(leadingZeroes.length).fill(0), ...tailBytes];
+			bytes.set(bytesToAdd, offset);
+			return offset + bytesToAdd.length;
+		}
+	});
+};
+function partitionLeadingZeroes(value, zeroCharacter) {
+	const [leadingZeros, tailChars] = value.split(new RegExp(`((?!${zeroCharacter}).*)`));
+	return [leadingZeros, tailChars];
+}
+function getBigIntFromBaseX(value, alphabet4) {
+	const base = BigInt(alphabet4.length);
+	let sum = 0n;
+	for (const char of value) {
+		sum *= base;
+		sum += BigInt(alphabet4.indexOf(char));
+	}
+	return sum;
+}
+var alphabet2 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var getBase58Encoder = () => getBaseXEncoder(alphabet2);
+function getLifetimeTokenEncoder() {
+	return transformEncoder(getNullableEncoder(fixEncoderSize(getBase58Encoder(), 32), {
+		noneValue: "zeroes",
+		prefix: null
+	}), (token) => token ?? null);
+}
+function getMessageEncoder() {
+	return transformEncoder(getStructEncoder([
+		["header", getMessageHeaderEncoder()],
+		["staticAccounts", getArrayEncoder(getAddressEncoder(), { size: getShortU16Encoder() })],
+		["lifetimeToken", getLifetimeTokenEncoder()],
+		["instructions", getArrayEncoder(getInstructionEncoder(), { size: getShortU16Encoder() })]
+	]), (value) => ({
+		...value,
+		lifetimeToken: "lifetimeToken" in value ? value.lifetimeToken : void 0
+	}));
+}
+var VERSION_FLAG_MASK = 128;
+function getTransactionVersionEncoder() {
+	return createEncoder({
+		getSizeFromValue: (value) => value === "legacy" ? 0 : 1,
+		maxSize: 1,
+		write: (value, bytes, offset) => {
+			if (value === "legacy") return offset;
+			if (value < 0 || value > 127) throw new SolanaError(SOLANA_ERROR__TRANSACTION__VERSION_NUMBER_OUT_OF_RANGE, { actualVersion: value });
+			if (value > 1) throw new SolanaError(SOLANA_ERROR__TRANSACTION__VERSION_NUMBER_NOT_SUPPORTED, { unsupportedVersion: value });
+			bytes.set([value | VERSION_FLAG_MASK], offset);
+			return offset + 1;
+		}
+	});
+}
+function getTransactionVersionDecoder() {
+	return createDecoder({
+		maxSize: 1,
+		read: (bytes, offset) => {
+			const firstByte = bytes[offset];
+			if ((firstByte & VERSION_FLAG_MASK) === 0) return ["legacy", offset];
+			else {
+				const version = firstByte ^ VERSION_FLAG_MASK;
+				if (version > 1) throw new SolanaError(SOLANA_ERROR__TRANSACTION__VERSION_NUMBER_NOT_SUPPORTED, { unsupportedVersion: version });
+				return [version, offset + 1];
+			}
+		}
+	});
+}
+var memoizedAddressTableLookupEncoder;
+function getAddressTableLookupEncoder() {
+	if (!memoizedAddressTableLookupEncoder) {
+		const indexEncoder = getArrayEncoder(getU8Encoder(), { size: getShortU16Encoder() });
+		memoizedAddressTableLookupEncoder = getStructEncoder([
+			["lookupTableAddress", getAddressEncoder()],
+			["writableIndexes", indexEncoder],
+			["readonlyIndexes", indexEncoder]
+		]);
+	}
+	return memoizedAddressTableLookupEncoder;
+}
+function getMessageEncoder2() {
+	return transformEncoder(getStructEncoder([
+		["version", getTransactionVersionEncoder()],
+		["header", getMessageHeaderEncoder()],
+		["staticAccounts", getArrayEncoder(getAddressEncoder(), { size: getShortU16Encoder() })],
+		["lifetimeToken", getLifetimeTokenEncoder()],
+		["instructions", getArrayEncoder(getInstructionEncoder(), { size: getShortU16Encoder() })],
+		["addressTableLookups", getArrayEncoder(getAddressTableLookupEncoder(), { size: getShortU16Encoder() })]
+	]), (value) => ({
+		...value,
+		addressTableLookups: value.addressTableLookups ?? [],
+		lifetimeToken: "lifetimeToken" in value ? value.lifetimeToken : void 0
+	}));
+}
+function isV1ConfigEmpty(config) {
+	return config.computeUnitLimit === void 0 && config.heapSize === void 0 && config.loadedAccountsDataSizeLimit === void 0 && config.priorityFeeLamports === void 0;
+}
+function areV1ConfigsEqual(config1, config2) {
+	return config1.computeUnitLimit === config2.computeUnitLimit && config1.heapSize === config2.heapSize && config1.loadedAccountsDataSizeLimit === config2.loadedAccountsDataSizeLimit && config1.priorityFeeLamports === config2.priorityFeeLamports;
+}
+var TRANSACTION_CONFIG_PRIORITY_FEE_LAMPORTS_BIT_MASK = 3;
+var TRANSACTION_CONFIG_COMPUTE_UNIT_LIMIT_BIT_MASK = 4;
+var TRANSACTION_CONFIG_LOADED_ACCOUNTS_DATA_SIZE_LIMIT_BIT_MASK = 8;
+var TRANSACTION_CONFIG_HEAP_SIZE_BIT_MASK = 16;
+function getCompiledTransactionConfigValueEncoder() {
+	return getPatternMatchEncoder([[(value) => value.kind === "u32", getStructEncoder([["value", getU32Encoder()]])], [(value) => value.kind === "u64", getStructEncoder([["value", getU64Encoder()]])]]);
+}
+function getCompiledTransactionConfigValuesEncoder() {
+	return getArrayEncoder(getCompiledTransactionConfigValueEncoder(), { size: "remainder" });
+}
+function getInstructionHeaderEncoder() {
+	return getStructEncoder([
+		["programAccountIndex", getU8Encoder()],
+		["numInstructionAccounts", getU8Encoder()],
+		["numInstructionDataBytes", getU16Encoder()]
+	]);
+}
+function getInstructionPayloadEncoder() {
+	return getStructEncoder([["instructionAccountIndices", getArrayEncoder(getU8Encoder(), { size: "remainder" })], ["instructionData", getBytesEncoder()]]);
+}
+function getMessageEncoder3() {
+	return transformEncoder(getStructEncoder([
+		["version", getTransactionVersionEncoder()],
+		["header", getMessageHeaderEncoder()],
+		["configMask", getU32Encoder()],
+		["lifetimeToken", getLifetimeTokenEncoder()],
+		["numInstructions", getU8Encoder()],
+		["numStaticAccounts", getU8Encoder()],
+		["staticAccounts", getArrayEncoder(getAddressEncoder(), { size: "remainder" })],
+		["configValues", getCompiledTransactionConfigValuesEncoder()],
+		["instructionHeaders", getArrayEncoder(getInstructionHeaderEncoder(), { size: "remainder" })],
+		["instructionPayloads", getArrayEncoder(getInstructionPayloadEncoder(), { size: "remainder" })]
+	]), (value) => ({
+		...value,
+		lifetimeToken: "lifetimeToken" in value ? value.lifetimeToken : void 0
+	}));
+}
+function getCompiledTransactionMessageEncoder() {
+	return transformEncoder(getPatternMatchEncoder([
+		[(m) => m.version === "legacy", getMessageEncoder()],
+		[(m) => m.version === 0, getMessageEncoder2()],
+		[(m) => m.version === 1, getMessageEncoder3()]
+	]), (value) => {
+		if (value.version !== "legacy" && value.version > 1) throw new SolanaError(SOLANA_ERROR__TRANSACTION__VERSION_NUMBER_NOT_SUPPORTED, { unsupportedVersion: value.version });
+		return value;
+	});
+}
+function upsert(addressMap, address, update) {
+	addressMap[address] = update(addressMap[address] ?? { role: AccountRole.READONLY });
+}
+var TYPE = Symbol("AddressMapTypeProperty");
+function getAddressMapFromInstructions(feePayer, instructions) {
+	const addressMap = { [feePayer]: {
+		[TYPE]: 0,
+		role: AccountRole.WRITABLE_SIGNER
+	} };
+	const addressesOfInvokedPrograms = /* @__PURE__ */ new Set();
+	for (const instruction of instructions) {
+		upsert(addressMap, instruction.programAddress, (entry) => {
+			addressesOfInvokedPrograms.add(instruction.programAddress);
+			if (TYPE in entry) {
+				if (isWritableRole(entry.role)) switch (entry[TYPE]) {
+					case 0: throw new SolanaError(SOLANA_ERROR__TRANSACTION__INVOKED_PROGRAMS_CANNOT_PAY_FEES, { programAddress: instruction.programAddress });
+					default: throw new SolanaError(SOLANA_ERROR__TRANSACTION__INVOKED_PROGRAMS_MUST_NOT_BE_WRITABLE, { programAddress: instruction.programAddress });
+				}
+				if (entry[TYPE] === 1) return entry;
+			}
+			return {
+				[TYPE]: 1,
+				role: AccountRole.READONLY
+			};
+		});
+		if (!instruction.accounts) continue;
+		for (const account of instruction.accounts) upsert(addressMap, account.address, (entry) => {
+			const { address: _, ...accountMeta } = account;
+			if (TYPE in entry) switch (entry[TYPE]) {
+				case 0: return entry;
+				case 1: {
+					const nextRole = mergeRoles(entry.role, accountMeta.role);
+					if (addressesOfInvokedPrograms.has(account.address)) {
+						if (isWritableRole(accountMeta.role)) throw new SolanaError(SOLANA_ERROR__TRANSACTION__INVOKED_PROGRAMS_MUST_NOT_BE_WRITABLE, { programAddress: account.address });
+						if (entry.role !== nextRole) return {
+							...entry,
+							role: nextRole
+						};
+						else return entry;
+					} else if (entry.role !== nextRole) return {
+						...entry,
+						role: nextRole
+					};
+					else return entry;
+				}
+			}
+			return {
+				...accountMeta,
+				[TYPE]: 1
+			};
+		});
+	}
+	return addressMap;
+}
+function getOrderedAccountsFromAddressMap(addressMap) {
+	let addressComparator;
+	return Object.entries(addressMap).sort(([leftAddress, leftEntry], [rightAddress, rightEntry]) => {
+		if (leftEntry[TYPE] !== rightEntry[TYPE]) {
+			if (leftEntry[TYPE] === 0) return -1;
+			else if (rightEntry[TYPE] === 0) return 1;
+			else if (leftEntry[TYPE] === 1) return -1;
+			else if (rightEntry[TYPE] === 1) return 1;
+		}
+		const leftIsSigner = isSignerRole(leftEntry.role);
+		if (leftIsSigner !== isSignerRole(rightEntry.role)) return leftIsSigner ? -1 : 1;
+		const leftIsWritable = isWritableRole(leftEntry.role);
+		if (leftIsWritable !== isWritableRole(rightEntry.role)) return leftIsWritable ? -1 : 1;
+		addressComparator ||= getAddressComparator();
+		return addressComparator(leftAddress, rightAddress);
+	}).map(([address, addressMeta]) => ({
+		address,
+		...addressMeta
+	}));
+}
+function getCompiledMessageHeader(orderedAccounts) {
+	let numReadonlyNonSignerAccounts = 0;
+	let numReadonlySignerAccounts = 0;
+	let numSignerAccounts = 0;
+	for (const account of orderedAccounts) {
+		if ("lookupTableAddress" in account) break;
+		const accountIsWritable = isWritableRole(account.role);
+		if (isSignerRole(account.role)) {
+			numSignerAccounts++;
+			if (!accountIsWritable) numReadonlySignerAccounts++;
+		} else if (!accountIsWritable) numReadonlyNonSignerAccounts++;
+	}
+	return {
+		numReadonlyNonSignerAccounts,
+		numReadonlySignerAccounts,
+		numSignerAccounts
+	};
+}
+function getAccountIndex(orderedAccounts) {
+	const out = {};
+	for (const [index, account] of orderedAccounts.entries()) out[account.address] = index;
+	return out;
+}
+function getCompiledInstructions(instructions, orderedAccounts) {
+	const accountIndex = getAccountIndex(orderedAccounts);
+	return instructions.map(({ accounts, data, programAddress }) => {
+		return {
+			programAddressIndex: accountIndex[programAddress],
+			...accounts ? { accountIndices: accounts.map(({ address }) => accountIndex[address]) } : null,
+			...data ? { data } : null
+		};
+	});
+}
+function getCompiledLifetimeToken(lifetimeConstraint) {
+	if ("nonce" in lifetimeConstraint) return lifetimeConstraint.nonce;
+	return lifetimeConstraint.blockhash;
+}
+function compileTransactionMessage(transactionMessage) {
+	const orderedAccounts = getOrderedAccountsFromAddressMap(getAddressMapFromInstructions(transactionMessage.feePayer.address, transactionMessage.instructions));
+	const lifetimeConstraint = transactionMessage.lifetimeConstraint;
+	return {
+		...lifetimeConstraint ? { lifetimeToken: getCompiledLifetimeToken(lifetimeConstraint) } : null,
+		header: getCompiledMessageHeader(orderedAccounts),
+		instructions: getCompiledInstructions(transactionMessage.instructions, orderedAccounts),
+		staticAccounts: orderedAccounts.map((account) => account.address),
+		version: transactionMessage.version
+	};
+}
+function upsert2(addressMap, address, update) {
+	addressMap[address] = update(addressMap[address] ?? { role: AccountRole.READONLY });
+}
+var TYPE2 = Symbol("AddressMapTypeProperty");
+function getAddressMapFromInstructions2(feePayer, instructions) {
+	const addressMap = { [feePayer]: {
+		[TYPE2]: 0,
+		role: AccountRole.WRITABLE_SIGNER
+	} };
+	const addressesOfInvokedPrograms = /* @__PURE__ */ new Set();
+	for (const instruction of instructions) {
+		upsert2(addressMap, instruction.programAddress, (entry) => {
+			addressesOfInvokedPrograms.add(instruction.programAddress);
+			if (TYPE2 in entry) {
+				if (isWritableRole(entry.role)) switch (entry[TYPE2]) {
+					case 0: throw new SolanaError(SOLANA_ERROR__TRANSACTION__INVOKED_PROGRAMS_CANNOT_PAY_FEES, { programAddress: instruction.programAddress });
+					default: throw new SolanaError(SOLANA_ERROR__TRANSACTION__INVOKED_PROGRAMS_MUST_NOT_BE_WRITABLE, { programAddress: instruction.programAddress });
+				}
+				if (entry[TYPE2] === 2) return entry;
+			}
+			return {
+				[TYPE2]: 2,
+				role: AccountRole.READONLY
+			};
+		});
+		let addressComparator;
+		if (!instruction.accounts) continue;
+		for (const account of instruction.accounts) upsert2(addressMap, account.address, (entry) => {
+			const { address: _, ...accountMeta } = account;
+			if (TYPE2 in entry) switch (entry[TYPE2]) {
+				case 0: return entry;
+				case 1: {
+					const nextRole = mergeRoles(entry.role, accountMeta.role);
+					if ("lookupTableAddress" in accountMeta) {
+						if (entry.lookupTableAddress !== accountMeta.lookupTableAddress && (addressComparator ||= getAddressComparator())(accountMeta.lookupTableAddress, entry.lookupTableAddress) < 0) return {
+							[TYPE2]: 1,
+							...accountMeta,
+							role: nextRole
+						};
+					} else if (isSignerRole(accountMeta.role)) return {
+						[TYPE2]: 2,
+						role: nextRole
+					};
+					if (entry.role !== nextRole) return {
+						...entry,
+						role: nextRole
+					};
+					else return entry;
+				}
+				case 2: {
+					const nextRole = mergeRoles(entry.role, accountMeta.role);
+					if (addressesOfInvokedPrograms.has(account.address)) {
+						if (isWritableRole(accountMeta.role)) throw new SolanaError(SOLANA_ERROR__TRANSACTION__INVOKED_PROGRAMS_MUST_NOT_BE_WRITABLE, { programAddress: account.address });
+						if (entry.role !== nextRole) return {
+							...entry,
+							role: nextRole
+						};
+						else return entry;
+					} else if ("lookupTableAddress" in accountMeta && !isSignerRole(entry.role)) return {
+						...accountMeta,
+						[TYPE2]: 1,
+						role: nextRole
+					};
+					else if (entry.role !== nextRole) return {
+						...entry,
+						role: nextRole
+					};
+					else return entry;
+				}
+			}
+			if ("lookupTableAddress" in accountMeta) return {
+				...accountMeta,
+				[TYPE2]: 1
+			};
+			else return {
+				...accountMeta,
+				[TYPE2]: 2
+			};
+		});
+	}
+	return addressMap;
+}
+function getOrderedAccountsFromAddressMap2(addressMap) {
+	let addressComparator;
+	return Object.entries(addressMap).sort(([leftAddress, leftEntry], [rightAddress, rightEntry]) => {
+		if (leftEntry[TYPE2] !== rightEntry[TYPE2]) {
+			if (leftEntry[TYPE2] === 0) return -1;
+			else if (rightEntry[TYPE2] === 0) return 1;
+			else if (leftEntry[TYPE2] === 2) return -1;
+			else if (rightEntry[TYPE2] === 2) return 1;
+		}
+		const leftIsSigner = isSignerRole(leftEntry.role);
+		if (leftIsSigner !== isSignerRole(rightEntry.role)) return leftIsSigner ? -1 : 1;
+		const leftIsWritable = isWritableRole(leftEntry.role);
+		if (leftIsWritable !== isWritableRole(rightEntry.role)) return leftIsWritable ? -1 : 1;
+		addressComparator ||= getAddressComparator();
+		if (leftEntry[TYPE2] === 1 && rightEntry[TYPE2] === 1 && leftEntry.lookupTableAddress !== rightEntry.lookupTableAddress) return addressComparator(leftEntry.lookupTableAddress, rightEntry.lookupTableAddress);
+		else return addressComparator(leftAddress, rightAddress);
+	}).map(([address, addressMeta]) => ({
+		address,
+		...addressMeta
+	}));
+}
+function getCompiledAddressTableLookups(orderedAccounts) {
+	const index = {};
+	for (const account of orderedAccounts) {
+		if (!("lookupTableAddress" in account)) continue;
+		const entry = index[account.lookupTableAddress] ||= {
+			readonlyIndexes: [],
+			writableIndexes: []
+		};
+		if (account.role === AccountRole.WRITABLE) entry.writableIndexes.push(account.addressIndex);
+		else entry.readonlyIndexes.push(account.addressIndex);
+	}
+	return Object.keys(index).sort(getAddressComparator()).map((lookupTableAddress) => ({
+		lookupTableAddress,
+		...index[lookupTableAddress]
+	}));
+}
+function getAccountIndex2(orderedAccounts) {
+	const out = {};
+	for (const [index, account] of orderedAccounts.entries()) out[account.address] = index;
+	return out;
+}
+function getCompiledInstructions2(instructions, orderedAccounts) {
+	const accountIndex = getAccountIndex2(orderedAccounts);
+	return instructions.map(({ accounts, data, programAddress }) => {
+		return {
+			programAddressIndex: accountIndex[programAddress],
+			...accounts ? { accountIndices: accounts.map(({ address }) => accountIndex[address]) } : null,
+			...data ? { data } : null
+		};
+	});
+}
+function getCompiledStaticAccounts(orderedAccounts) {
+	const firstLookupTableAccountIndex = orderedAccounts.findIndex((account) => "lookupTableAddress" in account);
+	return (firstLookupTableAccountIndex === -1 ? orderedAccounts : orderedAccounts.slice(0, firstLookupTableAccountIndex)).map(({ address }) => address);
+}
+function compileTransactionMessage2(transactionMessage) {
+	const orderedAccounts = getOrderedAccountsFromAddressMap2(getAddressMapFromInstructions2(transactionMessage.feePayer.address, transactionMessage.instructions));
+	const lifetimeConstraint = transactionMessage.lifetimeConstraint;
+	return {
+		addressTableLookups: getCompiledAddressTableLookups(orderedAccounts),
+		...lifetimeConstraint ? { lifetimeToken: getCompiledLifetimeToken(lifetimeConstraint) } : null,
+		header: getCompiledMessageHeader(orderedAccounts),
+		instructions: getCompiledInstructions2(transactionMessage.instructions, orderedAccounts),
+		staticAccounts: getCompiledStaticAccounts(orderedAccounts),
+		version: transactionMessage.version
+	};
+}
+function getTransactionConfigMask(config) {
+	let mask = 0;
+	if (config.priorityFeeLamports !== void 0) mask |= TRANSACTION_CONFIG_PRIORITY_FEE_LAMPORTS_BIT_MASK;
+	if (config.computeUnitLimit !== void 0) mask |= TRANSACTION_CONFIG_COMPUTE_UNIT_LIMIT_BIT_MASK;
+	if (config.loadedAccountsDataSizeLimit !== void 0) mask |= TRANSACTION_CONFIG_LOADED_ACCOUNTS_DATA_SIZE_LIMIT_BIT_MASK;
+	if (config.heapSize !== void 0) mask |= TRANSACTION_CONFIG_HEAP_SIZE_BIT_MASK;
+	return mask;
+}
+function getTransactionConfigValues(config) {
+	const values = [];
+	if (config.priorityFeeLamports !== void 0) values.push({
+		kind: "u64",
+		value: config.priorityFeeLamports
+	});
+	if (config.computeUnitLimit !== void 0) values.push({
+		kind: "u32",
+		value: config.computeUnitLimit
+	});
+	if (config.loadedAccountsDataSizeLimit !== void 0) values.push({
+		kind: "u32",
+		value: config.loadedAccountsDataSizeLimit
+	});
+	if (config.heapSize !== void 0) values.push({
+		kind: "u32",
+		value: config.heapSize
+	});
+	return values;
+}
+function getInstructionHeader(instruction, accountIndex) {
+	return {
+		numInstructionAccounts: instruction.accounts?.length ?? 0,
+		numInstructionDataBytes: instruction.data?.byteLength ?? 0,
+		programAccountIndex: accountIndex[instruction.programAddress]
+	};
+}
+function getInstructionPayload(instruction, accountIndex) {
+	return {
+		instructionAccountIndices: instruction.accounts?.map(({ address }) => accountIndex[address]) ?? [],
+		instructionData: instruction.data ?? new Uint8Array()
+	};
+}
+function compileTransactionMessage3(transactionMessage) {
+	const orderedAccounts = getOrderedAccountsFromAddressMap(getAddressMapFromInstructions(transactionMessage.feePayer.address, transactionMessage.instructions));
+	const accountIndex = getAccountIndex(orderedAccounts);
+	const lifetimeConstraint = transactionMessage.lifetimeConstraint;
+	return {
+		version: 1,
+		...lifetimeConstraint ? { lifetimeToken: getCompiledLifetimeToken(lifetimeConstraint) } : null,
+		configMask: getTransactionConfigMask(transactionMessage.config ?? {}),
+		configValues: getTransactionConfigValues(transactionMessage.config ?? {}),
+		header: getCompiledMessageHeader(orderedAccounts),
+		instructionHeaders: transactionMessage.instructions.map((instruction) => getInstructionHeader(instruction, accountIndex)),
+		instructionPayloads: transactionMessage.instructions.map((instruction) => getInstructionPayload(instruction, accountIndex)),
+		numInstructions: transactionMessage.instructions.length,
+		numStaticAccounts: orderedAccounts.length,
+		staticAccounts: orderedAccounts.map((account) => account.address)
+	};
+}
+function compileTransactionMessage4(transactionMessage) {
+	const version = transactionMessage.version;
+	if (version === "legacy") return compileTransactionMessage(transactionMessage);
+	else if (version === 0) return compileTransactionMessage2(transactionMessage);
+	else if (version === 1) return compileTransactionMessage3(transactionMessage);
+	else throw new SolanaError(SOLANA_ERROR__TRANSACTION__VERSION_NUMBER_NOT_SUPPORTED, { version });
+}
+var COMPUTE_BUDGET_PROGRAM_ADDRESS = "ComputeBudget111111111111111111111111111111";
+var SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR = 2;
+var SET_COMPUTE_UNIT_PRICE_DISCRIMINATOR = 3;
+function getComputeBudgetInstruction(discriminator, value) {
+	const data = getStructEncoder([["discriminator", getU8Encoder()], ["value", getBytesEncoder()]]).encode({
+		discriminator,
+		value
+	});
+	return Object.freeze({
+		data,
+		programAddress: COMPUTE_BUDGET_PROGRAM_ADDRESS
+	});
+}
+function isComputeBudgetInstruction(instruction, discriminator, expectedDataLength) {
+	return instruction.programAddress === COMPUTE_BUDGET_PROGRAM_ADDRESS && "data" in instruction && instruction.data != null && instruction.data.byteLength === expectedDataLength && instruction.data[0] === discriminator;
+}
+function getSetComputeUnitLimitInstruction(units) {
+	return getComputeBudgetInstruction(SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR, getU32Encoder().encode(units));
+}
+function isSetComputeUnitLimitInstruction(instruction) {
+	return isComputeBudgetInstruction(instruction, SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR, 5);
+}
+function getComputeUnitLimitFromInstructionData(data) {
+	return getU32Decoder().decode(data, 1);
+}
+function getSetComputeUnitPriceInstruction(microLamports) {
+	return getComputeBudgetInstruction(SET_COMPUTE_UNIT_PRICE_DISCRIMINATOR, getU64Encoder().encode(microLamports));
+}
+function isSetComputeUnitPriceInstruction(instruction) {
+	return isComputeBudgetInstruction(instruction, SET_COMPUTE_UNIT_PRICE_DISCRIMINATOR, 9);
+}
+function getPriorityFeeFromInstructionData(data) {
+	return getU64Decoder().decode(data, 1);
+}
+function replaceTransactionMessageInstruction(index, newInstruction, transactionMessage) {
+	const nextInstructions = [...transactionMessage.instructions];
+	nextInstructions[index] = newInstruction;
+	return Object.freeze({
+		...transactionMessage,
+		instructions: Object.freeze(nextInstructions)
+	});
+}
+function removeTransactionMessageInstruction(index, transactionMessage) {
+	return Object.freeze({
+		...transactionMessage,
+		instructions: Object.freeze([...transactionMessage.instructions.slice(0, index), ...transactionMessage.instructions.slice(index + 1)])
+	});
+}
+function appendTransactionMessageInstruction(instruction, transactionMessage) {
+	return appendTransactionMessageInstructions([instruction], transactionMessage);
+}
+function appendTransactionMessageInstructions(instructions, transactionMessage) {
+	return Object.freeze({
+		...transactionMessage,
+		instructions: Object.freeze([...transactionMessage.instructions, ...instructions])
+	});
+}
+function getTransactionMessageComputeUnitLimit(transactionMessage) {
+	switch (transactionMessage.version) {
+		case 1: return transactionMessage.config?.computeUnitLimit;
+		default: return getTransactionMessageComputeUnitLimitUsingInstruction(transactionMessage);
+	}
+}
+function getTransactionMessageComputeUnitLimitUsingInstruction(transactionMessage) {
+	const existingInstruction = transactionMessage.instructions.find(isSetComputeUnitLimitInstruction);
+	return existingInstruction ? getComputeUnitLimitFromInstructionData(existingInstruction.data) : void 0;
+}
+function setTransactionMessageComputeUnitLimit(computeUnitLimit, transactionMessage) {
+	switch (transactionMessage.version) {
+		case 1: return setTransactionMessageComputeUnitLimitUsingConfig(computeUnitLimit, transactionMessage);
+		default: return setTransactionMessageComputeUnitLimitUsingInstruction(computeUnitLimit, transactionMessage);
+	}
+}
+function setTransactionMessageComputeUnitLimitUsingConfig(computeUnitLimit, transactionMessage) {
+	const mergedConfig = {
+		...transactionMessage.config ?? {},
+		computeUnitLimit
+	};
+	const nextConfig = isV1ConfigEmpty(mergedConfig) ? void 0 : Object.freeze(mergedConfig);
+	if (nextConfig === void 0) {
+		const { config, ...rest } = transactionMessage;
+		return Object.freeze(rest);
+	}
+	if (transactionMessage.config && areV1ConfigsEqual(transactionMessage.config, nextConfig)) return transactionMessage;
+	return Object.freeze({
+		...transactionMessage,
+		config: nextConfig
+	});
+}
+function setTransactionMessageComputeUnitLimitUsingInstruction(computeUnitLimit, transactionMessage) {
+	const existingIndex = transactionMessage.instructions.findIndex(isSetComputeUnitLimitInstruction);
+	if (computeUnitLimit === void 0) return existingIndex === -1 ? transactionMessage : removeTransactionMessageInstruction(existingIndex, transactionMessage);
+	if (getTransactionMessageComputeUnitLimit(transactionMessage) === computeUnitLimit) return transactionMessage;
+	const newInstruction = getSetComputeUnitLimitInstruction(computeUnitLimit);
+	return existingIndex === -1 ? appendTransactionMessageInstruction(newInstruction, transactionMessage) : replaceTransactionMessageInstruction(existingIndex, newInstruction, transactionMessage);
+}
+function getTransactionMessageComputeUnitPrice(transactionMessage) {
+	const existingInstruction = transactionMessage.instructions.find(isSetComputeUnitPriceInstruction);
+	return existingInstruction ? getPriorityFeeFromInstructionData(existingInstruction.data) : void 0;
+}
+function setTransactionMessageComputeUnitPrice(computeUnitPrice, transactionMessage) {
+	const existingIndex = transactionMessage.instructions.findIndex(isSetComputeUnitPriceInstruction);
+	if (computeUnitPrice === void 0) return existingIndex === -1 ? transactionMessage : removeTransactionMessageInstruction(existingIndex, transactionMessage);
+	if (getTransactionMessageComputeUnitPrice(transactionMessage) === computeUnitPrice) return transactionMessage;
+	const newInstruction = getSetComputeUnitPriceInstruction(computeUnitPrice);
+	return existingIndex === -1 ? appendTransactionMessageInstruction(newInstruction, transactionMessage) : replaceTransactionMessageInstruction(existingIndex, newInstruction, transactionMessage);
+}
+function createTransactionMessage(config) {
+	return Object.freeze({
+		instructions: Object.freeze([]),
+		version: config.version
+	});
+}
+function setTransactionMessageFeePayer(feePayer, transactionMessage) {
+	if ("feePayer" in transactionMessage && feePayer === transactionMessage.feePayer?.address && isAddressOnlyFeePayer(transactionMessage.feePayer)) return transactionMessage;
+	const out = {
+		...transactionMessage,
+		feePayer: Object.freeze({ address: feePayer })
+	};
+	Object.freeze(out);
+	return out;
+}
+function isAddressOnlyFeePayer(feePayer) {
+	return !!feePayer && "address" in feePayer && typeof feePayer.address === "string" && Object.keys(feePayer).length === 1;
+}
+var RECENT_BLOCKHASHES_SYSVAR_ADDRESS = "SysvarRecentB1ockHashes11111111111111111111";
+var SYSTEM_PROGRAM_ADDRESS = "11111111111111111111111111111111";
+function isAdvanceNonceAccountInstruction(instruction) {
+	return instruction.programAddress === SYSTEM_PROGRAM_ADDRESS && instruction.data != null && isAdvanceNonceAccountInstructionData(instruction.data) && instruction.accounts?.length === 3 && instruction.accounts[0].address != null && instruction.accounts[0].role === AccountRole.WRITABLE && instruction.accounts[1].address === RECENT_BLOCKHASHES_SYSVAR_ADDRESS && instruction.accounts[1].role === AccountRole.READONLY && instruction.accounts[2].address != null && isSignerRole(instruction.accounts[2].role);
+}
+function isAdvanceNonceAccountInstructionData(data) {
+	return data.byteLength === 4 && data[0] === 4 && data[1] === 0 && data[2] === 0 && data[3] === 0;
+}
+function isTransactionMessageWithDurableNonceLifetime(transactionMessage) {
+	return "lifetimeConstraint" in transactionMessage && typeof transactionMessage.lifetimeConstraint.nonce === "string" && transactionMessage.instructions[0] != null && isAdvanceNonceAccountInstruction(transactionMessage.instructions[0]);
+}
+//#endregion
+//#region node_modules/.pnpm/@solana+keys@6.5.0_typescript@5.9.3/node_modules/@solana/keys/dist/index.node.mjs
+var ED25519_ALGORITHM_IDENTIFIER = Object.freeze({ name: "Ed25519" });
+function addPkcs8Header(bytes) {
+	return new Uint8Array([
+		48,
+		46,
+		2,
+		1,
+		0,
+		48,
+		5,
+		6,
+		3,
+		43,
+		101,
+		112,
+		4,
+		34,
+		4,
+		32,
+		...bytes
+	]);
+}
+async function createPrivateKeyFromBytes(bytes, extractable = false) {
+	const actualLength = bytes.byteLength;
+	if (actualLength !== 32) throw new SolanaError(SOLANA_ERROR__KEYS__INVALID_PRIVATE_KEY_BYTE_LENGTH, { actualLength });
+	const privateKeyBytesPkcs8 = addPkcs8Header(bytes);
+	return await crypto.subtle.importKey("pkcs8", privateKeyBytesPkcs8, ED25519_ALGORITHM_IDENTIFIER, extractable, ["sign"]);
+}
+async function signBytes(key, data) {
+	assertSigningCapabilityIsAvailable();
+	const signedData = await crypto.subtle.sign(ED25519_ALGORITHM_IDENTIFIER, key, toArrayBuffer(data));
+	return new Uint8Array(signedData);
+}
+async function verifySignature(key, signature2, data) {
+	assertVerificationCapabilityIsAvailable();
+	return await crypto.subtle.verify(ED25519_ALGORITHM_IDENTIFIER, key, toArrayBuffer(signature2), toArrayBuffer(data));
+}
+async function createKeyPairFromBytes(bytes, extractable = false) {
+	assertPRNGIsAvailable();
+	if (bytes.byteLength !== 64) throw new SolanaError(SOLANA_ERROR__KEYS__INVALID_KEY_PAIR_BYTE_LENGTH, { byteLength: bytes.byteLength });
+	const [publicKey, privateKey] = await Promise.all([crypto.subtle.importKey("raw", bytes.slice(32), ED25519_ALGORITHM_IDENTIFIER, true, ["verify"]), createPrivateKeyFromBytes(bytes.slice(0, 32), extractable)]);
+	const randomBytes = new Uint8Array(32);
+	crypto.getRandomValues(randomBytes);
+	if (!await verifySignature(publicKey, await signBytes(privateKey, randomBytes), randomBytes)) throw new SolanaError(SOLANA_ERROR__KEYS__PUBLIC_KEY_MUST_MATCH_PRIVATE_KEY);
+	return {
+		privateKey,
+		publicKey
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/@solana+transactions@6.5.0_typescript@5.9.3/node_modules/@solana/transactions/dist/index.node.mjs
+function getSignaturesToEncode(signaturesMap) {
+	const signatures = Object.values(signaturesMap);
+	if (signatures.length === 0) throw new SolanaError(SOLANA_ERROR__TRANSACTION__CANNOT_ENCODE_WITH_EMPTY_SIGNATURES);
+	return signatures.map((signature) => {
+		if (!signature) return new Uint8Array(64).fill(0);
+		return signature;
+	});
+}
+function getSignaturesEncoderWithSizePrefix() {
+	return transformEncoder(getArrayEncoder(fixEncoderSize(getBytesEncoder(), 64), { size: getShortU16Encoder() }), getSignaturesToEncode);
+}
+function getSignaturesEncoderWithLength(size) {
+	return transformEncoder(getArrayEncoder(fixEncoderSize(getBytesEncoder(), 64), {
+		description: "signatures",
+		size
+	}), getSignaturesToEncode);
+}
+function getEnvelopeShapeFromMessageBytes(messageBytes) {
+	if (messageBytes.length === 0) throw new SolanaError(SOLANA_ERROR__TRANSACTION__CANNOT_ENCODE_WITH_EMPTY_MESSAGE_BYTES);
+	return getTransactionVersionDecoder().decode(messageBytes) === 1 ? "messageFirst" : "signaturesFirst";
+}
+function getTransactionEncoder() {
+	return getPredicateEncoder((transaction) => getEnvelopeShapeFromMessageBytes(transaction.messageBytes) === "signaturesFirst", getTransactionEncoderWithSignaturesFirst(), getTransactionEncoderWithMessageFirst());
+}
+function getTransactionEncoderWithSignaturesFirst() {
+	return getStructEncoder([["signatures", getSignaturesEncoderWithSizePrefix()], ["messageBytes", getBytesEncoder()]]);
+}
+function getSignatureCountForVersionedOrThrow(messageBytes, offset) {
+	if (messageBytes.length < offset + 2) throw new SolanaError(SOLANA_ERROR__TRANSACTION__MALFORMED_MESSAGE_BYTES, { messageBytes });
+	return messageBytes[offset + 1];
+}
+function getTransactionEncoderWithMessageFirst() {
+	const bytesEncoder = getBytesEncoder();
+	return createEncoder({
+		getSizeFromValue: (transaction) => {
+			const signatureCount = getSignatureCountForVersionedOrThrow(transaction.messageBytes, 0);
+			return transaction.messageBytes.length + signatureCount * 64;
+		},
+		write: (transaction, bytes, offset) => {
+			offset = bytesEncoder.write(transaction.messageBytes, bytes, offset);
+			offset = getSignaturesEncoderWithLength(getSignatureCountForVersionedOrThrow(transaction.messageBytes, 0)).write(transaction.signatures, bytes, offset);
+			return offset;
+		}
+	});
+}
+function compileTransaction(transactionMessage) {
+	const compiledMessage = compileTransactionMessage4(transactionMessage);
+	const messageBytes = getCompiledTransactionMessageEncoder().encode(compiledMessage);
+	const transactionSigners = compiledMessage.staticAccounts.slice(0, compiledMessage.header.numSignerAccounts);
+	const signatures = {};
+	for (const signerAddress of transactionSigners) signatures[signerAddress] = null;
+	let lifetimeConstraint;
+	if (isTransactionMessageWithBlockhashLifetime(transactionMessage)) lifetimeConstraint = {
+		blockhash: transactionMessage.lifetimeConstraint.blockhash,
+		lastValidBlockHeight: transactionMessage.lifetimeConstraint.lastValidBlockHeight
+	};
+	else if (isTransactionMessageWithDurableNonceLifetime(transactionMessage)) lifetimeConstraint = {
+		nonce: transactionMessage.lifetimeConstraint.nonce,
+		nonceAccountAddress: transactionMessage.instructions[0].accounts[0].address
+	};
+	return Object.freeze({
+		...lifetimeConstraint ? { lifetimeConstraint } : void 0,
+		messageBytes,
+		signatures: Object.freeze(signatures)
+	});
+}
+async function partiallySignTransaction(keyPairs, transaction) {
+	let newSignatures;
+	let unexpectedSigners;
+	await Promise.all(keyPairs.map(async (keyPair) => {
+		const address = await getAddressFromPublicKey(keyPair.publicKey);
+		const existingSignature = transaction.signatures[address];
+		if (existingSignature === void 0) {
+			unexpectedSigners ||= /* @__PURE__ */ new Set();
+			unexpectedSigners.add(address);
+			return;
+		}
+		if (unexpectedSigners) return;
+		const newSignature = await signBytes(keyPair.privateKey, transaction.messageBytes);
+		if (existingSignature !== null && bytesEqual(newSignature, existingSignature)) return;
+		newSignatures ||= {};
+		newSignatures[address] = newSignature;
+	}));
+	if (unexpectedSigners && unexpectedSigners.size > 0) throw new SolanaError(SOLANA_ERROR__TRANSACTION__ADDRESSES_CANNOT_SIGN_TRANSACTION, {
+		expectedAddresses: Object.keys(transaction.signatures),
+		unexpectedAddresses: [...unexpectedSigners]
+	});
+	if (!newSignatures) return transaction;
+	return Object.freeze({
+		...transaction,
+		signatures: Object.freeze({
+			...transaction.signatures,
+			...newSignatures
+		})
+	});
+}
+function getBase64EncodedWireTransaction(transaction) {
+	const wireTransactionBytes = getTransactionEncoder().encode(transaction);
+	return getBase64Decoder().decode(wireTransactionBytes);
+}
+var TRANSACTION_PACKET_SIZE = 1280;
+TRANSACTION_PACKET_SIZE - 48;
+//#endregion
+//#region node_modules/.pnpm/@solana+rpc-spec-types@6.5.0_typescript@5.9.3/node_modules/@solana/rpc-spec-types/dist/index.node.mjs
+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";
+}
+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
+	};
+}
+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");
+}
+//#endregion
+//#region node_modules/.pnpm/@solana+rpc-spec@6.5.0_typescript@5.9.3/node_modules/@solana/rpc-spec/dist/index.node.mjs
+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;
+			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
+				});
+				return createPendingRpcRequest(rpcConfig, getApiPlan(...rawParams));
+			};
+		}
+	});
+}
+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 response = await transport({
+						payload: createRpcMessage(request),
+						signal
+					});
+					if (!config?.responseTransformer) return response;
+					return config.responseTransformer(response, request);
+				} });
+			};
+		}
+	});
+}
+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;
+}
+//#endregion
+//#region node_modules/.pnpm/@solana+rpc-transformers@6.5.0_typescript@5.9.3/node_modules/@solana/rpc-transformers/dist/index.node.mjs
+function downcastNodeToNumberIfBigint(value) {
+	return typeof value === "bigint" ? Number(value) : value;
+}
+var KEYPATH_WILDCARD = {};
+function getTreeWalker(visitors) {
+	return function traverse(node, state) {
+		if (Array.isArray(node)) return node.map((element, ii) => {
+			return traverse(element, {
+				...state,
+				keyPath: [...state.keyPath, ii]
+			});
+		});
+		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);
+}
+function getBigIntDowncastRequestTransformer() {
+	return getTreeWalkerRequestTransformer([downcastNodeToNumberIfBigint], { keyPath: [] });
+}
+function applyDefaultCommitment({ commitmentPropertyName, params, optionsObjectPositionInParams, overrideCommitment }) {
+	const paramInTargetPosition = params[optionsObjectPositionInParams];
+	if (paramInTargetPosition === void 0 || paramInTargetPosition && typeof paramInTargetPosition === "object" && !Array.isArray(paramInTargetPosition)) {
+		if (paramInTargetPosition && commitmentPropertyName in paramInTargetPosition) {
+			if (!paramInTargetPosition[commitmentPropertyName] || paramInTargetPosition[commitmentPropertyName] === "finalized") {
+				const nextParams = [...params];
+				const { [commitmentPropertyName]: _, ...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;
+}
+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
+			})
+		});
+	};
+}
+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;
+	};
+}
+function getIntegerOverflowRequestTransformer(onIntegerOverflow) {
+	return (request) => {
+		return getTreeWalkerRequestTransformer([getIntegerOverflowNodeVisitor((...args) => onIntegerOverflow(request, ...args))], { keyPath: [] })(request);
+	};
+}
+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
+};
+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
+		}));
+	};
+}
+function getBigIntUpcastVisitor(allowedNumericKeyPaths) {
+	return function upcastNodeToBigIntIfNumber(value, { keyPath }) {
+		if (!(typeof value === "number" && Number.isInteger(value) || typeof value === "bigint")) 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;
+	});
+}
+function getBigIntUpcastResponseTransformer(allowedNumericKeyPaths) {
+	return getTreeWalkerResponseTransformer([getBigIntUpcastVisitor(allowedNumericKeyPaths)], { keyPath: [] });
+}
+function getResultResponseTransformer() {
+	return (json) => json.result;
+}
+var jsonParsedTokenAccountsConfigs = [
+	[
+		"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,
+	[
+		"data",
+		"parsed",
+		"info",
+		"lastExtendedSlotStartIndex"
+	],
+	[
+		"data",
+		"parsed",
+		"info",
+		"slashPenalty"
+	],
+	[
+		"data",
+		"parsed",
+		"info",
+		"warmupCooldownRate"
+	],
+	[
+		"data",
+		"parsed",
+		"info",
+		"decimals"
+	],
+	[
+		"data",
+		"parsed",
+		"info",
+		"numRequiredSigners"
+	],
+	[
+		"data",
+		"parsed",
+		"info",
+		"numValidSigners"
+	],
+	[
+		"data",
+		"parsed",
+		"info",
+		"stake",
+		"delegation",
+		"warmupCooldownRate"
+	],
+	[
+		"data",
+		"parsed",
+		"info",
+		"exemptionThreshold"
+	],
+	[
+		"data",
+		"parsed",
+		"info",
+		"burnPercent"
+	],
+	[
+		"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"
+	]
+];
+function getSimulateTransactionAllowedNumericKeypaths() {
+	return [
+		["loadedAccountsDataSize"],
+		...jsonParsedAccountsConfigs.map((c) => [
+			"accounts",
+			KEYPATH_WILDCARD,
+			...c
+		]),
+		...innerInstructionsConfigs.map((c) => [
+			"innerInstructions",
+			KEYPATH_WILDCARD,
+			...c
+		])
+	];
+}
+function getThrowSolanaErrorResponseTransformer() {
+	return (json, request) => {
+		const jsonRpcResponse = json;
+		if ("error" in jsonRpcResponse) {
+			const { error } = jsonRpcResponse;
+			if (error && typeof error === "object" && "code" in error && (error.code === -32002 || error.code === -32002n) && "data" in error && error.data) {
+				const transformedData = getTreeWalkerResponseTransformer([getBigIntUpcastVisitor(getSimulateTransactionAllowedNumericKeypaths())], { keyPath: [] })(error.data, request);
+				throw getSolanaErrorFromJsonRpcError({
+					...error,
+					data: transformedData
+				});
+			}
+			throw getSolanaErrorFromJsonRpcError(jsonRpcResponse.error);
+		}
+		return jsonRpcResponse;
+	};
+}
+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));
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/@solana+rpc-api@6.5.0_typescript@5.9.3/node_modules/@solana/rpc-api/dist/index.node.mjs
+function createSolanaRpcApi(config) {
+	return createJsonRpcApi({
+		requestTransformer: getDefaultRequestTransformerForSolanaRpc(config),
+		responseTransformer: getDefaultResponseTransformerForSolanaRpc({ allowedNumericKeyPaths: getAllowedNumericKeypaths() })
+	});
+}
+var memoizedKeypaths;
+function getAllowedNumericKeypaths() {
+	if (!memoizedKeypaths) memoizedKeypaths = {
+		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;
+}
+//#endregion
+//#region node_modules/.pnpm/@solana+rpc-transport-http@6.5.0_typescript@5.9.3/node_modules/@solana/rpc-transport-http/dist/index.node.mjs
+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,
+	referer: true,
+	te: true,
+	trailer: true,
+	"transfer-encoding": true,
+	upgrade: true,
+	via: true
+}, void 0, void 0);
+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;
+}
+function createHttpTransport(config) {
+	if (process.env.NODE_ENV !== "production" && false);
+	const { fromJson, headers, toJson, url } = config;
+	if (process.env.NODE_ENV !== "production" && headers) assertIsAllowedHttpRequestHeaders(headers);
+	let dispatcherConfig;
+	if ("dispatcher_NODE_ONLY" in config) dispatcherConfig = { dispatcher: config.dispatcher_NODE_ONLY };
+	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,
+				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);
+}
+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)
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/@solana+fast-stable-stringify@6.5.0_typescript@5.9.3/node_modules/@solana/fast-stable-stringify/dist/index.node.mjs
+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;
+}
+//#endregion
+//#region node_modules/.pnpm/@solana+rpc@6.5.0_typescript@5.9.3/node_modules/@solana/rpc/dist/index.node.mjs
+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;
+}
+var DEFAULT_RPC_CONFIG = {
+	defaultCommitment: "confirmed",
+	onIntegerOverflow(request, keyPath, value) {
+		throw createSolanaJsonRpcIntegerOverflowError(request.methodName, keyPath, value);
+	}
+};
+var e = class extends globalThis.AbortController {
+	constructor(...t) {
+		super(...t), setMaxListeners(Number.MAX_SAFE_INTEGER, this.signal);
+	}
+};
+var EXPLICIT_ABORT_TOKEN;
+function createExplicitAbortToken() {
+	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 e();
+			const responsePromise = (async () => {
+				try {
+					return await transport({
+						...request,
+						signal: abortController.signal
+					});
+				} catch (e2) {
+					if (e2 === (EXPLICIT_ABORT_TOKEN ||= createExplicitAbortToken())) return;
+					throw e2;
+				}
+			})();
+			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 = (e2) => {
+					signal.removeEventListener("abort", handleAbort);
+					coalescedRequest.numConsumers -= 1;
+					queueMicrotask(() => {
+						if (coalescedRequest.numConsumers === 0) coalescedRequest.abortController.abort(EXPLICIT_ABORT_TOKEN ||= createExplicitAbortToken());
+					});
+					reject(e2.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;
+}
+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: {
+			"accept-encoding": "br,gzip,deflate",
+			...config.headers ? normalizeHeaders(config.headers) : void 0,
+			"solana-client": `js/6.5.0`
+		}
+	}), (transport) => getRpcTransportWithRequestCoalescing(transport, getSolanaRpcPayloadDeduplicationKey));
+}
+function createSolanaRpcFromTransport(transport) {
+	return createRpc({
+		api: createSolanaRpcApi(DEFAULT_RPC_CONFIG),
+		transport
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/@solana+signers@6.5.0_typescript@5.9.3/node_modules/@solana/signers/dist/index.node.mjs
+function deduplicateSigners(signers) {
+	const deduplicated = {};
+	signers.forEach((signer) => {
+		if (!deduplicated[signer.address]) deduplicated[signer.address] = signer;
+		else if (deduplicated[signer.address] !== signer) throw new SolanaError(SOLANA_ERROR__SIGNER__ADDRESS_CANNOT_HAVE_MULTIPLE_SIGNERS, { address: signer.address });
+	});
+	return Object.values(deduplicated);
+}
+function isTransactionModifyingSigner(value) {
+	return "modifyAndSignTransactions" in value && typeof value.modifyAndSignTransactions === "function";
+}
+function isTransactionPartialSigner(value) {
+	return "signTransactions" in value && typeof value.signTransactions === "function";
+}
+function isTransactionSendingSigner(value) {
+	return "signAndSendTransactions" in value && typeof value.signAndSendTransactions === "function";
+}
+function isTransactionSigner(value) {
+	return isTransactionPartialSigner(value) || isTransactionModifyingSigner(value) || isTransactionSendingSigner(value);
+}
+function getSignersFromInstruction(instruction) {
+	return deduplicateSigners((instruction.accounts ?? []).flatMap((account) => "signer" in account ? account.signer : []));
+}
+function getSignersFromTransactionMessage(transaction) {
+	return deduplicateSigners([...transaction.feePayer && isTransactionSigner(transaction.feePayer) ? [transaction.feePayer] : [], ...transaction.instructions.flatMap(getSignersFromInstruction)]);
+}
+async function createSignerFromKeyPair(keyPair) {
+	const address = await getAddressFromPublicKey(keyPair.publicKey);
+	return Object.freeze({
+		address,
+		keyPair,
+		signMessages: (messages) => Promise.all(messages.map(async (message) => Object.freeze({ [address]: await signBytes(keyPair.privateKey, message.content) }))),
+		signTransactions: (transactions) => Promise.all(transactions.map(async (transaction) => {
+			const signedTransaction = await partiallySignTransaction([keyPair], transaction);
+			return Object.freeze({ [address]: signedTransaction.signatures[address] });
+		}))
+	});
+}
+async function createKeyPairSignerFromBytes(bytes, extractable) {
+	return await createSignerFromKeyPair(await createKeyPairFromBytes(bytes, extractable));
+}
+async function partiallySignTransactionMessageWithSigners(transactionMessage, config) {
+	return await partiallySignTransactionWithSigners(getSignersFromTransactionMessage(transactionMessage).filter((signer) => isTransactionModifyingSigner(signer) || isTransactionPartialSigner(signer)), compileTransaction(transactionMessage), config);
+}
+async function partiallySignTransactionWithSigners(signers, transaction, config) {
+	const { partialSigners, modifyingSigners } = categorizeTransactionSigners(deduplicateSigners(signers), { identifySendingSigner: false });
+	return await signModifyingAndPartialTransactionSigners(transaction, modifyingSigners, partialSigners, config);
+}
+function categorizeTransactionSigners(signers, config = {}) {
+	const sendingSigner = config.identifySendingSigner ?? true ? identifyTransactionSendingSigner(signers) : null;
+	const otherSigners = signers.filter((signer) => signer !== sendingSigner && (isTransactionModifyingSigner(signer) || isTransactionPartialSigner(signer)));
+	const modifyingSigners = identifyTransactionModifyingSigners(otherSigners);
+	const partialSigners = otherSigners.filter(isTransactionPartialSigner).filter((signer) => !modifyingSigners.includes(signer));
+	return Object.freeze({
+		modifyingSigners,
+		partialSigners,
+		sendingSigner
+	});
+}
+function identifyTransactionSendingSigner(signers) {
+	const sendingSigners = signers.filter(isTransactionSendingSigner);
+	if (sendingSigners.length === 0) return null;
+	const sendingOnlySigners = sendingSigners.filter((signer) => !isTransactionModifyingSigner(signer) && !isTransactionPartialSigner(signer));
+	if (sendingOnlySigners.length > 0) return sendingOnlySigners[0];
+	return sendingSigners[0];
+}
+function identifyTransactionModifyingSigners(signers) {
+	const modifyingSigners = signers.filter(isTransactionModifyingSigner);
+	if (modifyingSigners.length === 0) return [];
+	const nonPartialSigners = modifyingSigners.filter((signer) => !isTransactionPartialSigner(signer));
+	if (nonPartialSigners.length > 0) return nonPartialSigners;
+	return [modifyingSigners[0]];
+}
+async function signModifyingAndPartialTransactionSigners(transaction, modifyingSigners = [], partialSigners = [], config) {
+	const modifiedTransaction = await modifyingSigners.reduce(async (transaction2, modifyingSigner) => {
+		config?.abortSignal?.throwIfAborted();
+		const [tx] = await modifyingSigner.modifyAndSignTransactions([await transaction2], config);
+		return Object.freeze(tx);
+	}, Promise.resolve(transaction));
+	config?.abortSignal?.throwIfAborted();
+	const signatureDictionaries = await Promise.all(partialSigners.map(async (partialSigner) => {
+		const [signatures] = await partialSigner.signTransactions([modifiedTransaction], config);
+		return signatures;
+	}));
+	return Object.freeze({
+		...modifiedTransaction,
+		signatures: Object.freeze(signatureDictionaries.reduce((signatures, signatureDictionary) => {
+			return {
+				...signatures,
+				...signatureDictionary
+			};
+		}, modifiedTransaction.signatures ?? {}))
+	});
+}
+globalThis.TextEncoder;
+//#endregion
+export { getArrayEncoder as $, SOLANA_ERROR__TRANSACTION_ERROR__INVALID_ADDRESS_LOOKUP_TABLE_OWNER as $a, SOLANA_ERROR__OFFCHAIN_MESSAGE__VERSION_NUMBER_NOT_SUPPORTED as $i, SOLANA_ERROR__INSTRUCTION_ERROR__DUPLICATE_ACCOUNT_INDEX as $n, getSolanaErrorFromInstructionError as $o, SOLANA_ERROR__INSTRUCTION__PROGRAM_ID_MISMATCH as $r, SOLANA_ERROR__ACCOUNTS__FAILED_TO_DECODE_ACCOUNT as $t, compileTransactionMessage4 as A, SOLANA_ERROR__SUBTLE_CRYPTO__DIGEST_UNIMPLEMENTED as Aa, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_UNSUPPORTED_TRANSACTION_VERSION as Ai, SOLANA_ERROR__CODECS__INVALID_NUMBER_OF_ITEMS as An, SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_FEE_PAYER_MISSING as Ao, SOLANA_ERROR__INSTRUCTION_ERROR__PROGRAM_FAILED_TO_COMPILE as Ar, getBase64Decoder as At, setTransactionMessageComputeUnitLimit as B, SOLANA_ERROR__TRANSACTION_ERROR__ACCOUNT_NOT_FOUND as Ba, SOLANA_ERROR__OFFCHAIN_MESSAGE__MAXIMUM_LENGTH_EXCEEDED as Bi, SOLANA_ERROR__INSTRUCTION_ERROR__ACCOUNT_ALREADY_INITIALIZED as Bn, SOLANA_ERROR__TRANSACTION__INVALID_NONCE_TRANSACTION_FIRST_INSTRUCTION_MUST_BE_ADVANCE_NONCE as Bo, SOLANA_ERROR__INSTRUCTION_ERROR__UNSUPPORTED_SYSVAR as Br, createEncoder as Bt, partiallySignTransaction as C, SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SENDING_SIGNER as Ca, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE as Ci, SOLANA_ERROR__CODECS__EXPECTED_VARIABLE_LENGTH as Cn, SOLANA_ERROR__TRANSACTION__CANNOT_ENCODE_WITH_EMPTY_MESSAGE_BYTES as Co, SOLANA_ERROR__INSTRUCTION_ERROR__MAX_SEED_LENGTH_EXCEEDED as Cr, getAddressEncoder as Ct, verifySignature as D, SOLANA_ERROR__SIGNER__WALLET_ACCOUNT_CANNOT_SIGN_TRANSACTION as Da, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_TRANSACTION_PRECOMPILE_VERIFICATION_FAILURE as Di, SOLANA_ERROR__CODECS__INVALID_DISCRIMINATED_UNION_VARIANT as Dn, SOLANA_ERROR__TRANSACTION__EXPECTED_NONCE_LIFETIME as Do, SOLANA_ERROR__INSTRUCTION_ERROR__NOT_ENOUGH_ACCOUNT_KEYS as Dr, assertValidBaseString$1 as Dt, signBytes as E, SOLANA_ERROR__SIGNER__TRANSACTION_SENDING_SIGNER_MISSING as Ea, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_TRANSACTION_HISTORY_NOT_AVAILABLE as Ei, SOLANA_ERROR__CODECS__INVALID_CONSTANT as En, SOLANA_ERROR__TRANSACTION__EXPECTED_BLOCKHASH_LIFETIME as Eo, SOLANA_ERROR__INSTRUCTION_ERROR__MODIFIED_PROGRAM_ID as Er, isAddress as Et, getTransactionVersionDecoder as F, SOLANA_ERROR__SUBTLE_CRYPTO__SIGN_FUNCTION_UNIMPLEMENTED as Fa, SOLANA_ERROR__KEYS__SIGNATURE_STRING_LENGTH_OUT_OF_RANGE as Fi, SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE as Fn, SOLANA_ERROR__TRANSACTION__FEE_PAYER_SIGNATURE_MISSING as Fo, SOLANA_ERROR__INSTRUCTION_ERROR__RENT_EPOCH_MODIFIED as Fr, assertByteArrayIsNotEmptyForCodec as Ft, mainnet as G, SOLANA_ERROR__TRANSACTION_ERROR__CLUSTER_MAINTENANCE as Ga, SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_REQUIRED_SIGNERS_CANNOT_BE_ZERO as Gi, SOLANA_ERROR__INSTRUCTION_ERROR__ACCOUNT_NOT_EXECUTABLE as Gn, SOLANA_ERROR__TRANSACTION__MESSAGE_SIGNATURES_MISMATCH as Go, SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN as Gr, isFixedSize as Gt, setTransactionMessageFeePayer as H, SOLANA_ERROR__TRANSACTION_ERROR__ALREADY_PROCESSED as Ha, SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_LENGTH_MISMATCH as Hi, SOLANA_ERROR__INSTRUCTION_ERROR__ACCOUNT_BORROW_OUTSTANDING as Hn, SOLANA_ERROR__TRANSACTION__INVOKED_PROGRAMS_CANNOT_PAY_FEES as Ho, SOLANA_ERROR__INSTRUCTION_PLANS__EXPECTED_SUCCESSFUL_TRANSACTION_PLAN_RESULT as Hr, fixDecoderSize as Ht, getTransactionVersionEncoder as I, SOLANA_ERROR__SUBTLE_CRYPTO__VERIFY_FUNCTION_UNIMPLEMENTED as Ia, SOLANA_ERROR__OFFCHAIN_MESSAGE__ADDRESSES_CANNOT_SIGN_OFFCHAIN_MESSAGE as Ii, SOLANA_ERROR__CODECS__OFFSET_OUT_OF_RANGE as In, SOLANA_ERROR__TRANSACTION__INSTRUCTION_HEADERS_PAYLOADS_MISMATCH as Io, SOLANA_ERROR__INSTRUCTION_ERROR__UNBALANCED_INSTRUCTION as Ir, assertIsFixedSize as It, isWritableRole as J, SOLANA_ERROR__TRANSACTION_ERROR__INSUFFICIENT_FUNDS_FOR_RENT as Ja, SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATORIES_MUST_BE_SORTED as Ji, SOLANA_ERROR__INSTRUCTION_ERROR__BORSH_IO_ERROR as Jn, SOLANA_ERROR__TRANSACTION__SIGNATURE_COUNT_TOO_HIGH_FOR_TRANSACTION_BYTES as Jo, SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_INSTRUCTION_PLAN as Jr, toArrayBuffer as Jt, AccountRole as K, SOLANA_ERROR__TRANSACTION_ERROR__DUPLICATE_INSTRUCTION as Ka, SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_SIGNATURES_MISMATCH as Ki, SOLANA_ERROR__INSTRUCTION_ERROR__ACCOUNT_NOT_RENT_EXEMPT as Kn, SOLANA_ERROR__TRANSACTION__NONCE_ACCOUNT_CANNOT_BE_IN_LOOKUP_TABLE as Ko, SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_PACKER_ALREADY_COMPLETE as Kr, isVariableSize as Kt, isAdvanceNonceAccountInstruction as L, SOLANA_ERROR__TRANSACTION_ERROR__ACCOUNT_BORROW_OUTSTANDING as La, SOLANA_ERROR__OFFCHAIN_MESSAGE__APPLICATION_DOMAIN_STRING_LENGTH_OUT_OF_RANGE as Li, SOLANA_ERROR__CODECS__SENTINEL_MISSING_IN_DECODED_BYTES as Ln, SOLANA_ERROR__TRANSACTION__INVALID_CONFIG_MASK_PRIORITY_FEE_BITS as Lo, SOLANA_ERROR__INSTRUCTION_ERROR__UNINITIALIZED_ACCOUNT as Lr, bytesEqual as Lt, getCompiledTransactionMessageEncoder as M, SOLANA_ERROR__SUBTLE_CRYPTO__ED25519_ALGORITHM_UNIMPLEMENTED as Ma, SOLANA_ERROR__KEYS__INVALID_PRIVATE_KEY_BYTE_LENGTH as Mi, SOLANA_ERROR__CODECS__INVALID_PATTERN_MATCH_VALUE as Mn, SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT as Mo, SOLANA_ERROR__INSTRUCTION_ERROR__READONLY_DATA_MODIFIED as Mr, getBaseXEncoder$1 as Mt, getTransactionMessageComputeUnitLimit as N, SOLANA_ERROR__SUBTLE_CRYPTO__EXPORT_FUNCTION_UNIMPLEMENTED as Na, SOLANA_ERROR__KEYS__INVALID_SIGNATURE_BYTE_LENGTH as Ni, SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE as Nn, SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT as No, SOLANA_ERROR__INSTRUCTION_ERROR__READONLY_LAMPORT_CHANGE as Nr, addEncoderSizePrefix as Nt, appendTransactionMessageInstruction as O, SOLANA_ERROR__SIGNER__WALLET_MULTISIGN_UNIMPLEMENTED as Oa, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_TRANSACTION_SIGNATURE_LEN_MISMATCH as Oi, SOLANA_ERROR__CODECS__INVALID_ENUM_VARIANT as On, SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_ADDRESS_LOOKUP_TABLE_CONTENTS_MISSING as Oo, SOLANA_ERROR__INSTRUCTION_ERROR__PRIVILEGE_ESCALATION as Or, getBase58Decoder as Ot, getTransactionMessageComputeUnitPrice as P, SOLANA_ERROR__SUBTLE_CRYPTO__GENERATE_FUNCTION_UNIMPLEMENTED as Pa, SOLANA_ERROR__KEYS__PUBLIC_KEY_MUST_MATCH_PRIVATE_KEY as Pi, SOLANA_ERROR__CODECS__LITERAL_UNION_DISCRIMINATOR_OUT_OF_RANGE as Pn, SOLANA_ERROR__TRANSACTION__FEE_PAYER_MISSING as Po, SOLANA_ERROR__INSTRUCTION_ERROR__REENTRANCY_NOT_ALLOWED as Pr, assertByteArrayHasEnoughBytesForCodec as Pt, assertValidNumberOfItemsForCodec as Q, SOLANA_ERROR__TRANSACTION_ERROR__INVALID_ADDRESS_LOOKUP_TABLE_INDEX as Qa, SOLANA_ERROR__OFFCHAIN_MESSAGE__UNEXPECTED_VERSION as Qi, SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM as Qn, SolanaError as Qo, SOLANA_ERROR__INSTRUCTION__EXPECTED_TO_HAVE_DATA as Qr, SOLANA_ERROR__ACCOUNTS__EXPECTED_DECODED_ACCOUNT as Qt, isTransactionMessageWithBlockhashLifetime as R, SOLANA_ERROR__TRANSACTION_ERROR__ACCOUNT_IN_USE as Ra, SOLANA_ERROR__OFFCHAIN_MESSAGE__ENVELOPE_SIGNERS_MISMATCH as Ri, SOLANA_ERROR__CODECS__UNION_VARIANT_OUT_OF_RANGE as Rn, SOLANA_ERROR__TRANSACTION__INVALID_CONFIG_VALUE_KIND as Ro, SOLANA_ERROR__INSTRUCTION_ERROR__UNKNOWN as Rr, combineCodec as Rt, getTransactionEncoder as S, SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_PARTIAL_SIGNER as Sa, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_NO_SNAPSHOT as Si, SOLANA_ERROR__CODECS__EXPECTED_POSITIVE_BYTE_LENGTH as Sn, SOLANA_ERROR__TRANSACTION__CANNOT_DECODE_EMPTY_TRANSACTION_BYTES as So, SOLANA_ERROR__INSTRUCTION_ERROR__MAX_INSTRUCTION_TRACE_LENGTH_EXCEEDED as Sr, getAddressDecoder as St, createPrivateKeyFromBytes as T, SOLANA_ERROR__SIGNER__TRANSACTION_CANNOT_HAVE_MULTIPLE_SENDING_SIGNERS as Ta, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SLOT_SKIPPED as Ti, SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH as Tn, SOLANA_ERROR__TRANSACTION__EXCEEDS_SIZE_LIMIT as To, SOLANA_ERROR__INSTRUCTION_ERROR__MISSING_REQUIRED_SIGNATURE as Tr, getProgramDerivedAddress as Tt, setTransactionMessageLifetimeUsingBlockhash as U, SOLANA_ERROR__TRANSACTION_ERROR__BLOCKHASH_NOT_FOUND as Ua, SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_MUST_BE_NON_EMPTY as Ui, SOLANA_ERROR__INSTRUCTION_ERROR__ACCOUNT_DATA_SIZE_CHANGED as Un, SOLANA_ERROR__TRANSACTION__INVOKED_PROGRAMS_MUST_NOT_BE_WRITABLE as Uo, SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_SINGLE_TRANSACTION_PLAN_RESULT_NOT_FOUND as Ur, fixEncoderSize as Ut, setTransactionMessageComputeUnitPrice as V, SOLANA_ERROR__TRANSACTION_ERROR__ADDRESS_LOOKUP_TABLE_NOT_FOUND as Va, SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_FORMAT_MISMATCH as Vi, SOLANA_ERROR__INSTRUCTION_ERROR__ACCOUNT_BORROW_FAILED as Vn, SOLANA_ERROR__TRANSACTION__INVALID_NONCE_TRANSACTION_INSTRUCTIONS_MISSING as Vo, SOLANA_ERROR__INSTRUCTION_PLANS__EMPTY_INSTRUCTION_PLAN as Vr, fixBytes as Vt, isBlockhash as W, SOLANA_ERROR__TRANSACTION_ERROR__CALL_CHAIN_TOO_DEEP as Wa, SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_ENVELOPE_SIGNATURES_CANNOT_BE_ZERO as Wi, SOLANA_ERROR__INSTRUCTION_ERROR__ACCOUNT_DATA_TOO_SMALL as Wn, SOLANA_ERROR__TRANSACTION__MALFORMED_MESSAGE_BYTES as Wo, SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN as Wr, getEncodedSize as Wt, upgradeRoleToSigner as X, SOLANA_ERROR__TRANSACTION_ERROR__INVALID_ACCOUNT_INDEX as Xa, SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURES_MISSING as Xi, SOLANA_ERROR__INSTRUCTION_ERROR__CALL_DEPTH as Xn, SOLANA_ERROR__TRANSACTION__VERSION_NUMBER_OUT_OF_RANGE as Xo, SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN_RESULT as Xr, SOLANA_ERROR__ACCOUNTS__ACCOUNT_NOT_FOUND as Xt, mergeRoles as Y, SOLANA_ERROR__TRANSACTION_ERROR__INVALID_ACCOUNT_FOR_FEE as Ya, SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATORIES_MUST_BE_UNIQUE as Yi, SOLANA_ERROR__INSTRUCTION_ERROR__BUILTIN_PROGRAMS_MUST_CONSUME_COMPUTE_UNITS as Yn, SOLANA_ERROR__TRANSACTION__VERSION_NUMBER_NOT_SUPPORTED as Yo, SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN as Yr, transformEncoder as Yt, pipe as Z, SOLANA_ERROR__TRANSACTION_ERROR__INVALID_ADDRESS_LOOKUP_TABLE_DATA as Za, SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURE_VERIFICATION_FAILURE as Zi, SOLANA_ERROR__INSTRUCTION_ERROR__COMPUTATIONAL_BUDGET_EXCEEDED as Zn, SOLANA_ERROR__TRANSACTION__VERSION_ZERO_MUST_BE_ENCODED_WITH_SIGNATURES_FIRST as Zo, SOLANA_ERROR__INSTRUCTION__EXPECTED_TO_HAVE_ACCOUNTS as Zr, SOLANA_ERROR__ACCOUNTS__EXPECTED_ALL_ACCOUNTS_TO_BE_DECODED as Zt, isJsonRpcPayload as _, SOLANA_ERROR__SIGNER__EXPECTED_KEY_PAIR_SIGNER as _a, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_KEY_EXCLUDED_FROM_SECONDARY_INDEX as _i, SOLANA_ERROR__CODECS__ENCODER_DECODER_MAX_SIZE_MISMATCH as _n, SOLANA_ERROR__TRANSACTION_ERROR__WOULD_EXCEED_MAX_ACCOUNT_COST_LIMIT as _o, SOLANA_ERROR__INSTRUCTION_ERROR__INVALID_INSTRUCTION_DATA as _r, getU8Encoder as _t, isTransactionModifyingSigner as a, SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_ACCOUNT_TYPE as aa, SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_STATE_MISSING as ai, SOLANA_ERROR__ADDRESSES__INVALID_OFF_CURVE_ADDRESS as an, SOLANA_ERROR__TRANSACTION_ERROR__MISSING_SIGNATURE_FOR_FEE as ao, SOLANA_ERROR__INSTRUCTION_ERROR__EXTERNAL_ACCOUNT_DATA_MODIFIED as ar, getPredicateEncoder as at, compileTransaction as b, SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_SIGNER as ba, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_MIN_CONTEXT_SLOT_NOT_REACHED as bi, SOLANA_ERROR__CODECS__EXPECTED_DECODER_TO_CONSUME_ENTIRE_BYTE_ARRAY as bn, SOLANA_ERROR__TRANSACTION__ADDRESSES_CANNOT_SIGN_TRANSACTION as bo, SOLANA_ERROR__INSTRUCTION_ERROR__MAX_ACCOUNTS_DATA_ALLOCATIONS_EXCEEDED as br, getAddressCodec as bt, isTransactionSigner as c, SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CLOSED_BEFORE_MESSAGE_BUFFERED as ca, SOLANA_ERROR__JSON_RPC__INVALID_PARAMS as ci, SOLANA_ERROR__ADDRESSES__MAX_NUMBER_OF_PDA_SEEDS_EXCEEDED as cn, SOLANA_ERROR__TRANSACTION_ERROR__RESANITIZATION_NEEDED as co, SOLANA_ERROR__INSTRUCTION_ERROR__ILLEGAL_OWNER as cr, getUnionEncoder as ct, DEFAULT_RPC_CONFIG as d, SOLANA_ERROR__RPC_SUBSCRIPTIONS__EXPECTED_SERVER_SUBSCRIPTION_ID as da, SOLANA_ERROR__JSON_RPC__PARSE_ERROR as di, SOLANA_ERROR__ADDRESSES__PDA_ENDS_WITH_PDA_MARKER as dn, SOLANA_ERROR__TRANSACTION_ERROR__TOO_MANY_ACCOUNT_LOCKS as do, SOLANA_ERROR__INSTRUCTION_ERROR__INCORRECT_PROGRAM_ID as dr, getShortU16Encoder as dt, SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT as ea, SOLANA_ERROR__INVARIANT_VIOLATION__CACHED_ABORTABLE_ITERABLE_CACHE_ENTRY_MISSING as ei, SOLANA_ERROR__ACCOUNTS__ONE_OR_MORE_ACCOUNTS_NOT_FOUND as en, SOLANA_ERROR__TRANSACTION_ERROR__INVALID_LOADED_ACCOUNTS_DATA_SIZE_LIMIT as eo, SOLANA_ERROR__INSTRUCTION_ERROR__DUPLICATE_ACCOUNT_OUT_OF_SYNC as er, getSolanaErrorFromJsonRpcError as es, getBooleanEncoder as et, createDefaultRpcTransport as f, SOLANA_ERROR__RPC__API_PLAN_MISSING_FOR_RPC_METHOD as fa, SOLANA_ERROR__JSON_RPC__SCAN_ERROR as fi, SOLANA_ERROR__ADDRESSES__STRING_LENGTH_OUT_OF_RANGE as fn, SOLANA_ERROR__TRANSACTION_ERROR__UNBALANCED_TRANSACTION as fo, SOLANA_ERROR__INSTRUCTION_ERROR__INSUFFICIENT_FUNDS as fr, getU16Encoder as ft, createRpc as g, SOLANA_ERROR__SIGNER__ADDRESS_CANNOT_HAVE_MULTIPLE_SIGNERS as ga, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_EPOCH_REWARDS_PERIOD_ACTIVE as gi, SOLANA_ERROR__CODECS__ENCODER_DECODER_FIXED_SIZE_MISMATCH as gn, SOLANA_ERROR__TRANSACTION_ERROR__WOULD_EXCEED_ACCOUNT_DATA_TOTAL_LIMIT as go, SOLANA_ERROR__INSTRUCTION_ERROR__INVALID_ERROR as gr, getU64Encoder as gt, createJsonRpcApi as h, SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN as ha, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_BLOCK_STATUS_NOT_AVAILABLE_YET as hi, SOLANA_ERROR__CODECS__ENCODED_BYTES_MUST_NOT_INCLUDE_SENTINEL as hn, SOLANA_ERROR__TRANSACTION_ERROR__WOULD_EXCEED_ACCOUNT_DATA_BLOCK_LIMIT as ho, SOLANA_ERROR__INSTRUCTION_ERROR__INVALID_ARGUMENT as hr, getU64Decoder as ht, getSignersFromTransactionMessage as i, SOLANA_ERROR__PROGRAM_CLIENTS__UNEXPECTED_RESOLVED_INSTRUCTION_INPUT_TYPE as ia, SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_MUST_NOT_POLL_BEFORE_RESOLVING_EXISTING_MESSAGE_PROMISE as ii, SOLANA_ERROR__ADDRESSES__INVALID_ED25519_PUBLIC_KEY as in, SOLANA_ERROR__TRANSACTION_ERROR__MAX_LOADED_ACCOUNTS_DATA_SIZE_EXCEEDED as io, SOLANA_ERROR__INSTRUCTION_ERROR__EXECUTABLE_MODIFIED as ir, getPatternMatchEncoder as it, createTransactionMessage as j, SOLANA_ERROR__SUBTLE_CRYPTO__DISALLOWED_IN_INSECURE_CONTEXT as ja, SOLANA_ERROR__KEYS__INVALID_KEY_PAIR_BYTE_LENGTH as ji, SOLANA_ERROR__CODECS__INVALID_PATTERN_MATCH_BYTES as jn, SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_INSTRUCTION_PROGRAM_ADDRESS_NOT_FOUND as jo, SOLANA_ERROR__INSTRUCTION_ERROR__PROGRAM_FAILED_TO_COMPLETE as jr, getBaseXDecoder as jt, appendTransactionMessageInstructions as k, SOLANA_ERROR__SUBTLE_CRYPTO__CANNOT_EXPORT_NON_EXTRACTABLE_KEY as ka, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_TRANSACTION_SIGNATURE_VERIFICATION_FAILURE as ki, SOLANA_ERROR__CODECS__INVALID_LITERAL_UNION_VARIANT as kn, SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_ADDRESS_LOOKUP_TABLE_INDEX_OUT_OF_RANGE as ko, SOLANA_ERROR__INSTRUCTION_ERROR__PROGRAM_ENVIRONMENT_SETUP_FAILURE as kr, getBase58Encoder$1 as kt, partiallySignTransactionMessageWithSigners as l, SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CONNECTION_CLOSED as la, SOLANA_ERROR__JSON_RPC__INVALID_REQUEST as li, SOLANA_ERROR__ADDRESSES__MAX_PDA_SEED_LENGTH_EXCEEDED as ln, SOLANA_ERROR__TRANSACTION_ERROR__SANITIZE_FAILURE as lo, SOLANA_ERROR__INSTRUCTION_ERROR__IMMUTABLE as lr, getUnitEncoder as lt, createSolanaRpcApi as m, SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR as ma, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_BLOCK_NOT_AVAILABLE as mi, SOLANA_ERROR__CODECS__CANNOT_USE_LEXICAL_VALUES_AS_ENUM_DISCRIMINATORS as mn, SOLANA_ERROR__TRANSACTION_ERROR__UNSUPPORTED_VERSION as mo, SOLANA_ERROR__INSTRUCTION_ERROR__INVALID_ACCOUNT_OWNER as mr, getU32Encoder as mt, createSignerFromKeyPair as n, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as na, SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_INSTRUCTION_PLAN_KIND as ni, SOLANA_ERROR__ADDRESSES__INVALID_BASE58_ENCODED_ADDRESS as nn, SOLANA_ERROR__TRANSACTION_ERROR__INVALID_RENT_PAYING_ACCOUNT as no, SOLANA_ERROR__INSTRUCTION_ERROR__EXECUTABLE_DATA_MODIFIED as nr, isSolanaError as ns, getConstantEncoder as nt, isTransactionPartialSigner as o, SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE as oa, SOLANA_ERROR__INVARIANT_VIOLATION__SWITCH_MUST_BE_EXHAUSTIVE as oi, SOLANA_ERROR__ADDRESSES__INVALID_SEEDS_POINT_ON_CURVE as on, SOLANA_ERROR__TRANSACTION_ERROR__PROGRAM_ACCOUNT_NOT_FOUND as oo, SOLANA_ERROR__INSTRUCTION_ERROR__EXTERNAL_ACCOUNT_LAMPORT_SPEND as or, getStructEncoder as ot, createSolanaRpcFromTransport as p, SOLANA_ERROR__RPC__INTEGER_OVERFLOW as pa, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_BLOCK_CLEANED_UP as pi, SOLANA_ERROR__CODECS__CANNOT_DECODE_EMPTY_BYTE_ARRAY as pn, SOLANA_ERROR__TRANSACTION_ERROR__UNKNOWN as po, SOLANA_ERROR__INSTRUCTION_ERROR__INVALID_ACCOUNT_DATA as pr, getU32Decoder as pt, isSignerRole as q, SOLANA_ERROR__TRANSACTION_ERROR__INSUFFICIENT_FUNDS_FOR_FEE as qa, SOLANA_ERROR__OFFCHAIN_MESSAGE__RESTRICTED_ASCII_BODY_CHARACTER_OUT_OF_RANGE as qi, SOLANA_ERROR__INSTRUCTION_ERROR__ARITHMETIC_OVERFLOW as qn, SOLANA_ERROR__TRANSACTION__SIGNATURES_MISSING as qo, SOLANA_ERROR__INSTRUCTION_PLANS__NON_DIVISIBLE_TRANSACTION_PLANS_NOT_SUPPORTED as qr, padBytes as qt, getSignersFromInstruction as r, SOLANA_ERROR__PROGRAM_CLIENTS__RESOLVED_INSTRUCTION_INPUT_MUST_BE_NON_NULL as ra, SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_TRANSACTION_PLAN_KIND as ri, SOLANA_ERROR__ADDRESSES__INVALID_BYTE_LENGTH as rn, SOLANA_ERROR__TRANSACTION_ERROR__INVALID_WRITABLE_ACCOUNT as ro, SOLANA_ERROR__INSTRUCTION_ERROR__EXECUTABLE_LAMPORT_CHANGE as rr, safeCaptureStackTrace as rs, getNullableEncoder as rt, isTransactionSendingSigner as s, SOLANA_ERROR__RPC_SUBSCRIPTIONS__CANNOT_CREATE_SUBSCRIPTION_PLAN as sa, SOLANA_ERROR__JSON_RPC__INTERNAL_ERROR as si, SOLANA_ERROR__ADDRESSES__MALFORMED_PDA as sn, SOLANA_ERROR__TRANSACTION_ERROR__PROGRAM_EXECUTION_TEMPORARILY_RESTRICTED as so, SOLANA_ERROR__INSTRUCTION_ERROR__GENERIC_ERROR as sr, getTupleEncoder as st, createKeyPairSignerFromBytes as t, SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION as ta, SOLANA_ERROR__INVARIANT_VIOLATION__DATA_PUBLISHER_CHANNEL_UNIMPLEMENTED as ti, SOLANA_ERROR__ADDRESSES__FAILED_TO_FIND_VIABLE_PDA_BUMP_SEED as tn, SOLANA_ERROR__TRANSACTION_ERROR__INVALID_PROGRAM_FOR_EXECUTION as to, SOLANA_ERROR__INSTRUCTION_ERROR__EXECUTABLE_ACCOUNT_NOT_RENT_EXEMPT as tr, getSolanaErrorFromTransactionError as ts, getBytesEncoder as tt, partiallySignTransactionWithSigners as u, SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_FAILED_TO_CONNECT as ua, SOLANA_ERROR__JSON_RPC__METHOD_NOT_FOUND as ui, SOLANA_ERROR__ADDRESSES__PDA_BUMP_SEED_OUT_OF_RANGE as un, SOLANA_ERROR__TRANSACTION_ERROR__SIGNATURE_FAILURE as uo, SOLANA_ERROR__INSTRUCTION_ERROR__INCORRECT_AUTHORITY as ur, assertNumberIsBetweenForCodec as ut, createRpcMessage as v, SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_MODIFYING_SIGNER as va, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_LONG_TERM_STORAGE_SLOT_SKIPPED as vi, SOLANA_ERROR__CODECS__ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH as vn, SOLANA_ERROR__TRANSACTION_ERROR__WOULD_EXCEED_MAX_BLOCK_COST_LIMIT as vo, SOLANA_ERROR__INSTRUCTION_ERROR__INVALID_REALLOC as vr, address as vt, createKeyPairFromBytes as w, SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SIGNER as wa, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SLOT_NOT_EPOCH_BOUNDARY as wi, SOLANA_ERROR__CODECS__EXPECTED_ZERO_VALUE_TO_MATCH_ITEM_FIXED_SIZE as wn, SOLANA_ERROR__TRANSACTION__CANNOT_ENCODE_WITH_EMPTY_SIGNATURES as wo, SOLANA_ERROR__INSTRUCTION_ERROR__MISSING_ACCOUNT as wr, getAddressFromPublicKey as wt, getBase64EncodedWireTransaction as x, SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_MODIFYING_SIGNER as xa, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_NODE_UNHEALTHY as xi, SOLANA_ERROR__CODECS__EXPECTED_FIXED_LENGTH as xn, SOLANA_ERROR__TRANSACTION__ADDRESS_MISSING as xo, SOLANA_ERROR__INSTRUCTION_ERROR__MAX_ACCOUNTS_EXCEEDED as xr, getAddressComparator as xt, TRANSACTION_PACKET_SIZE as y, SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_PARTIAL_SIGNER as ya, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_LONG_TERM_STORAGE_UNREACHABLE as yi, SOLANA_ERROR__CODECS__ENUM_DISCRIMINATOR_OUT_OF_RANGE as yn, SOLANA_ERROR__TRANSACTION_ERROR__WOULD_EXCEED_MAX_VOTE_COST_LIMIT as yo, SOLANA_ERROR__INSTRUCTION_ERROR__INVALID_SEEDS as yr, assertIsAddress as yt, isTransactionMessageWithDurableNonceLifetime as z, SOLANA_ERROR__TRANSACTION_ERROR__ACCOUNT_LOADED_TWICE as za, SOLANA_ERROR__OFFCHAIN_MESSAGE__INVALID_APPLICATION_DOMAIN_BYTE_LENGTH as zi, SOLANA_ERROR__CRYPTO__RANDOM_VALUES_FUNCTION_UNIMPLEMENTED as zn, SOLANA_ERROR__TRANSACTION__INVALID_NONCE_ACCOUNT_INDEX as zo, SOLANA_ERROR__INSTRUCTION_ERROR__UNSUPPORTED_PROGRAM_ID as zr, createDecoder as zt };