@solana/client 1.1.2 → 1.1.4

package/dist/index.browser.cjs

@@ -1,3721 +0,0 @@
-'use strict';
-
-var kit = require('@solana/kit');
-var transactionConfirmation = require('@solana/transaction-confirmation');
-var addressLookupTable = require('@solana-program/address-lookup-table');
-var system = require('@solana-program/system');
-var codecsStrings = require('@solana/codecs-strings');
-var token = require('@solana-program/token');
-var stake = require('@solana-program/stake');
-var computeBudget = require('@solana-program/compute-budget');
-var vanilla = require('zustand/vanilla');
-var app = require('@wallet-standard/app');
-var features = require('@wallet-standard/features');
-var transactions = require('@solana/transactions');
-var walletStandardFeatures = require('@solana/wallet-standard-features');
-
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// src/actions.ts
-function connectWallet(client, params) {
-  return client.actions.connectWallet(params.connectorId, params.options);
-}
-__name(connectWallet, "connectWallet");
-function disconnectWallet(client, _params) {
-  return client.actions.disconnectWallet();
-}
-__name(disconnectWallet, "disconnectWallet");
-function fetchAccount(client, params) {
-  return client.actions.fetchAccount(params.address, params.commitment);
-}
-__name(fetchAccount, "fetchAccount");
-function fetchBalance(client, params) {
-  return client.actions.fetchBalance(params.address, params.commitment);
-}
-__name(fetchBalance, "fetchBalance");
-function fetchLookupTable(client, params) {
-  return client.actions.fetchLookupTable(params.address, params.commitment);
-}
-__name(fetchLookupTable, "fetchLookupTable");
-function fetchLookupTables(client, params) {
-  return client.actions.fetchLookupTables(params.addresses, params.commitment);
-}
-__name(fetchLookupTables, "fetchLookupTables");
-function fetchNonceAccount(client, params) {
-  return client.actions.fetchNonceAccount(params.address, params.commitment);
-}
-__name(fetchNonceAccount, "fetchNonceAccount");
-function requestAirdrop(client, params) {
-  return client.actions.requestAirdrop(params.address, params.lamports);
-}
-__name(requestAirdrop, "requestAirdrop");
-function sendTransaction(client, params) {
-  return client.actions.sendTransaction(params.transaction, params.commitment);
-}
-__name(sendTransaction, "sendTransaction");
-function setCluster(client, params) {
-  return client.actions.setCluster(params.endpoint, params.config);
-}
-__name(setCluster, "setCluster");
-
-// src/utils.ts
-function deepFreeze(value) {
-  if (typeof value !== "object" || value === null) {
-    return value;
-  }
-  const objectValue = value;
-  for (const key of Reflect.ownKeys(objectValue)) {
-    const property = objectValue[key];
-    deepFreeze(property);
-  }
-  return Object.freeze(value);
-}
-__name(deepFreeze, "deepFreeze");
-function now() {
-  return Date.now();
-}
-__name(now, "now");
-function toErrorMessage(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  try {
-    return JSON.stringify(error);
-  } catch {
-    return String(error);
-  }
-}
-__name(toErrorMessage, "toErrorMessage");
-
-// src/logging/logger.ts
-function createLogger(logger) {
-  if (logger) {
-    return logger;
-  }
-  return ({ data, level, message }) => {
-    const payload = data ? { ...data } : {};
-    switch (level) {
-      case "error":
-        console.error(`[react-core] ${message}`, payload);
-        break;
-      case "warn":
-        console.warn(`[react-core] ${message}`, payload);
-        break;
-      case "info":
-        console.info(`[react-core] ${message}`, payload);
-        break;
-      default:
-        console.debug(`[react-core] ${message}`, payload);
-    }
-  };
-}
-__name(createLogger, "createLogger");
-function formatError(error) {
-  return {
-    error,
-    message: toErrorMessage(error)
-  };
-}
-__name(formatError, "formatError");
-function createChainedAbortController(parent) {
-  const controller = new AbortController();
-  if (!parent) {
-    return controller;
-  }
-  if (parent.aborted) {
-    controller.abort(parent.reason);
-    return controller;
-  }
-  const onAbort = /* @__PURE__ */ __name(() => {
-    controller.abort(parent.reason);
-    parent.removeEventListener("abort", onAbort);
-  }, "onAbort");
-  parent.addEventListener("abort", onAbort, { once: true });
-  return controller;
-}
-__name(createChainedAbortController, "createChainedAbortController");
-function toBigint(value) {
-  if (value === void 0) {
-    return void 0;
-  }
-  return typeof value === "bigint" ? value : BigInt(Math.floor(value));
-}
-__name(toBigint, "toBigint");
-var DEFAULT_SIMULATION_CONFIG = Object.freeze({
-  encoding: "base64",
-  replaceRecentBlockhash: true,
-  sigVerify: false
-});
-function createSolanaRpcClient(config) {
-  const endpoint = config.endpoint;
-  const websocketEndpoint = config.websocketEndpoint ?? endpoint;
-  const commitment = config.commitment ?? "confirmed";
-  const rpc = kit.createSolanaRpc(endpoint, config.rpcConfig);
-  const rpcSubscriptions = kit.createSolanaRpcSubscriptions(websocketEndpoint, config.rpcSubscriptionsConfig);
-  async function sendAndConfirmTransaction(transaction, options = {}) {
-    const abortController = createChainedAbortController(options.abortSignal);
-    const targetCommitment = options.commitment ?? commitment;
-    const wireTransaction = kit.getBase64EncodedWireTransaction(transaction);
-    const response = await rpc.sendTransaction(wireTransaction, {
-      encoding: "base64",
-      maxRetries: toBigint(options.maxRetries),
-      minContextSlot: toBigint(options.minContextSlot),
-      preflightCommitment: targetCommitment,
-      skipPreflight: options.skipPreflight
-    }).send({ abortSignal: abortController.signal });
-    const getBlockHeightExceedencePromise = transactionConfirmation.createBlockHeightExceedencePromiseFactory({
-      rpc,
-      rpcSubscriptions
-    });
-    const getRecentSignatureConfirmationPromise = transactionConfirmation.createRecentSignatureConfirmationPromiseFactory({
-      rpc,
-      rpcSubscriptions
-    });
-    await transactionConfirmation.waitForRecentTransactionConfirmation({
-      abortSignal: abortController.signal,
-      commitment: targetCommitment,
-      getBlockHeightExceedencePromise,
-      getRecentSignatureConfirmationPromise,
-      transaction
-    });
-    return response;
-  }
-  __name(sendAndConfirmTransaction, "sendAndConfirmTransaction");
-  async function simulateTransaction(transaction, options = {}) {
-    const wireTransaction = kit.getBase64EncodedWireTransaction(transaction);
-    const baseConfig = options.config ?? {};
-    const mergedConfig = {
-      ...DEFAULT_SIMULATION_CONFIG,
-      ...baseConfig,
-      commitment: baseConfig.commitment ?? options.commitment ?? commitment
-    };
-    const normalizedConfig = mergedConfig.sigVerify === true && mergedConfig.replaceRecentBlockhash !== false ? { ...mergedConfig, replaceRecentBlockhash: false } : mergedConfig;
-    return rpc.simulateTransaction(wireTransaction, normalizedConfig).send({ abortSignal: options.abortSignal });
-  }
-  __name(simulateTransaction, "simulateTransaction");
-  return {
-    commitment,
-    endpoint,
-    rpc,
-    rpcSubscriptions,
-    sendAndConfirmTransaction,
-    simulateTransaction,
-    websocketEndpoint
-  };
-}
-__name(createSolanaRpcClient, "createSolanaRpcClient");
-
-// src/serialization/state.ts
-var SERIALIZABLE_STATE_VERSION = 1;
-function getInitialSerializableState(config) {
-  return {
-    autoconnect: false,
-    commitment: config.commitment,
-    endpoint: config.endpoint,
-    lastConnectorId: null,
-    lastPublicKey: null,
-    version: SERIALIZABLE_STATE_VERSION,
-    websocketEndpoint: config.websocketEndpoint
-  };
-}
-__name(getInitialSerializableState, "getInitialSerializableState");
-function applySerializableState(config, state) {
-  if (!state) {
-    return config;
-  }
-  return {
-    ...config,
-    commitment: state.commitment ?? config.commitment,
-    endpoint: state.endpoint ?? config.endpoint,
-    websocketEndpoint: state.websocketEndpoint ?? config.websocketEndpoint
-  };
-}
-__name(applySerializableState, "applySerializableState");
-function serializeSolanaState(state) {
-  return JSON.stringify(state);
-}
-__name(serializeSolanaState, "serializeSolanaState");
-function deserializeSolanaState(json) {
-  if (!json) return null;
-  try {
-    const parsed = JSON.parse(json);
-    if (typeof parsed !== "object" || parsed === null) return null;
-    const state = parsed;
-    return {
-      autoconnect: state.autoconnect ?? false,
-      commitment: state.commitment,
-      endpoint: state.endpoint,
-      lastConnectorId: state.lastConnectorId ?? null,
-      lastPublicKey: state.lastPublicKey ?? null,
-      version: state.version ?? SERIALIZABLE_STATE_VERSION,
-      websocketEndpoint: state.websocketEndpoint
-    };
-  } catch {
-    return null;
-  }
-}
-__name(deserializeSolanaState, "deserializeSolanaState");
-function getSerializableStateSnapshot(client) {
-  const state = client.store.getState();
-  const wallet = state.wallet;
-  const autoConnectPreference = wallet.autoConnect;
-  let lastConnectorId = null;
-  let lastPublicKey = null;
-  if ("connectorId" in wallet) {
-    lastConnectorId = wallet.connectorId ?? null;
-    if (wallet.status === "connected") {
-      lastPublicKey = wallet.session.account.address.toString();
-    }
-  }
-  return {
-    autoconnect: autoConnectPreference ?? Boolean(lastConnectorId),
-    commitment: state.cluster.commitment,
-    endpoint: state.cluster.endpoint,
-    lastConnectorId,
-    lastPublicKey,
-    version: SERIALIZABLE_STATE_VERSION,
-    websocketEndpoint: state.cluster.websocketEndpoint
-  };
-}
-__name(getSerializableStateSnapshot, "getSerializableStateSnapshot");
-function subscribeSolanaState(client, listener) {
-  let previous = serializeSolanaState(getSerializableStateSnapshot(client));
-  listener(JSON.parse(previous));
-  const unsubscribe = client.store.subscribe(() => {
-    const snapshot = getSerializableStateSnapshot(client);
-    const serialized = serializeSolanaState(snapshot);
-    if (serialized === previous) {
-      return;
-    }
-    previous = serialized;
-    listener(snapshot);
-  });
-  return unsubscribe;
-}
-__name(subscribeSolanaState, "subscribeSolanaState");
-
-// src/utils/cluster.ts
-function ensureHttpProtocol(endpoint) {
-  if (endpoint.startsWith("http://") || endpoint.startsWith("https://") || endpoint.startsWith("ws://") || endpoint.startsWith("wss://")) {
-    return endpoint;
-  }
-  return `https://${endpoint}`;
-}
-__name(ensureHttpProtocol, "ensureHttpProtocol");
-var MONIKER_ENDPOINTS = {
-  devnet: {
-    endpoint: "https://api.devnet.solana.com",
-    websocketEndpoint: "wss://api.devnet.solana.com"
-  },
-  localhost: {
-    endpoint: "http://127.0.0.1:8899",
-    websocketEndpoint: "ws://127.0.0.1:8900"
-  },
-  localnet: {
-    endpoint: "http://127.0.0.1:8899",
-    websocketEndpoint: "ws://127.0.0.1:8900"
-  },
-  "mainnet-beta": {
-    endpoint: "https://api.mainnet-beta.solana.com",
-    websocketEndpoint: "wss://api.mainnet-beta.solana.com"
-  },
-  mainnet: {
-    endpoint: "https://api.mainnet-beta.solana.com",
-    websocketEndpoint: "wss://api.mainnet-beta.solana.com"
-  },
-  testnet: {
-    endpoint: "https://api.testnet.solana.com",
-    websocketEndpoint: "wss://api.testnet.solana.com"
-  }
-};
-function inferWebsocketEndpoint(endpoint) {
-  if (endpoint.startsWith("https://")) {
-    return endpoint.replace("https://", "wss://");
-  }
-  if (endpoint.startsWith("http://")) {
-    return endpoint.replace("http://", "ws://");
-  }
-  if (endpoint.startsWith("ws://") || endpoint.startsWith("wss://")) {
-    return endpoint;
-  }
-  return endpoint;
-}
-__name(inferWebsocketEndpoint, "inferWebsocketEndpoint");
-function resolveCluster(config) {
-  const moniker = config.moniker ?? (config.endpoint ? "custom" : "devnet");
-  const mapped = moniker === "custom" ? void 0 : MONIKER_ENDPOINTS[moniker];
-  const endpoint = ensureHttpProtocol(config.endpoint ?? mapped?.endpoint);
-  const rawWebsocket = config.websocketEndpoint ? ensureHttpProtocol(config.websocketEndpoint) : void 0;
-  const websocketEndpoint = inferWebsocketEndpoint(
-    rawWebsocket ?? mapped?.websocketEndpoint ?? endpoint
-  );
-  return {
-    endpoint,
-    moniker,
-    websocketEndpoint
-  };
-}
-__name(resolveCluster, "resolveCluster");
-
-// src/wallet/registry.ts
-function createWalletRegistry(connectors) {
-  const byId = /* @__PURE__ */ new Map();
-  for (const connector of connectors) {
-    if (!byId.has(connector.id)) {
-      byId.set(connector.id, connector);
-    }
-  }
-  return {
-    all: [...byId.values()],
-    /**
-     * Looks up a connector by identifier.
-     *
-     * @param id - Unique connector identifier.
-     * @returns The registered connector, if present.
-     */
-    get(id) {
-      return byId.get(id);
-    }
-  };
-}
-__name(createWalletRegistry, "createWalletRegistry");
-function updateState(store, update) {
-  store.setState((state) => ({
-    ...state,
-    ...update,
-    lastUpdatedAt: now()
-  }));
-}
-__name(updateState, "updateState");
-function createActions({ connectors, logger: inputLogger, runtime, store }) {
-  const logger = inputLogger ?? createLogger();
-  let walletEventsCleanup;
-  function getCommitment(commitment) {
-    return commitment ?? store.getState().cluster.commitment;
-  }
-  __name(getCommitment, "getCommitment");
-  async function warmupCluster(endpoint, commitment) {
-    try {
-      const start = now();
-      await runtime.rpc.getLatestBlockhash({ commitment }).send({ abortSignal: AbortSignal.timeout(1e4) });
-      return now() - start;
-    } catch (error) {
-      logger({
-        data: { endpoint, ...formatError(error) },
-        level: "warn",
-        message: "cluster warmup failed"
-      });
-      return void 0;
-    }
-  }
-  __name(warmupCluster, "warmupCluster");
-  async function setCluster2(endpoint, config) {
-    const nextCommitment = config?.commitment ?? store.getState().cluster.commitment;
-    const websocketEndpoint = config?.websocketEndpoint ?? endpoint;
-    store.setState((state) => ({
-      ...state,
-      cluster: {
-        commitment: nextCommitment,
-        endpoint,
-        status: { status: "connecting" },
-        websocketEndpoint
-      },
-      lastUpdatedAt: now()
-    }));
-    try {
-      const newRpcClient = createSolanaRpcClient({
-        commitment: nextCommitment,
-        endpoint,
-        websocketEndpoint
-      });
-      runtime.rpc = newRpcClient.rpc;
-      runtime.rpcSubscriptions = newRpcClient.rpcSubscriptions;
-      const latencyMs = await warmupCluster(endpoint, nextCommitment);
-      store.setState((state) => ({
-        ...state,
-        cluster: {
-          commitment: nextCommitment,
-          endpoint,
-          status: { latencyMs, status: "ready" },
-          websocketEndpoint
-        },
-        lastUpdatedAt: now()
-      }));
-    } catch (error) {
-      store.setState((state) => ({
-        ...state,
-        cluster: {
-          commitment: nextCommitment,
-          endpoint,
-          status: { error, status: "error" },
-          websocketEndpoint
-        },
-        lastUpdatedAt: now()
-      }));
-      logger({
-        data: { endpoint, ...formatError(error) },
-        level: "error",
-        message: "cluster setup failed"
-      });
-      throw error;
-    }
-  }
-  __name(setCluster2, "setCluster");
-  async function connectWallet2(connectorId, options = {}) {
-    walletEventsCleanup?.();
-    walletEventsCleanup = void 0;
-    const connector = connectors.get(connectorId);
-    if (!connector) {
-      throw new Error(`No wallet connector registered for id "${connectorId}".`);
-    }
-    if (!connector.isSupported()) {
-      throw new Error(`Wallet connector "${connectorId}" is not supported in this environment.`);
-    }
-    const autoConnectPreference = options.autoConnect ?? false;
-    store.setState((state) => ({
-      ...state,
-      lastUpdatedAt: now(),
-      wallet: { autoConnect: autoConnectPreference, connectorId, status: "connecting" }
-    }));
-    try {
-      const session = await connector.connect(options);
-      store.setState((state) => ({
-        ...state,
-        lastUpdatedAt: now(),
-        wallet: { autoConnect: autoConnectPreference, connectorId, session, status: "connected" }
-      }));
-      if (session.onAccountsChanged) {
-        walletEventsCleanup = session.onAccountsChanged((accounts) => {
-          if (accounts.length === 0) {
-            walletEventsCleanup?.();
-            walletEventsCleanup = void 0;
-            void disconnectWallet3();
-          }
-        });
-      }
-      logger({
-        data: { address: session.account.address.toString(), connectorId },
-        level: "info",
-        message: "wallet connected"
-      });
-    } catch (error) {
-      store.setState((state) => ({
-        ...state,
-        lastUpdatedAt: now(),
-        wallet: { autoConnect: autoConnectPreference, connectorId, error, status: "error" }
-      }));
-      logger({
-        data: { connectorId, ...formatError(error) },
-        level: "error",
-        message: "wallet connection failed"
-      });
-      throw error;
-    }
-  }
-  __name(connectWallet2, "connectWallet");
-  async function disconnectWallet3() {
-    const wallet = store.getState().wallet;
-    if (wallet.status === "disconnected") {
-      return;
-    }
-    walletEventsCleanup?.();
-    walletEventsCleanup = void 0;
-    try {
-      if (wallet.status === "connected") {
-        await wallet.session.disconnect();
-        const connector = connectors.get(wallet.connectorId);
-        if (connector) {
-          await connector.disconnect();
-        }
-      } else if (wallet.status === "connecting") {
-        const connector = connectors.get(wallet.connectorId);
-        if (connector) {
-          await connector.disconnect();
-        }
-      }
-    } finally {
-      updateState(store, { wallet: { status: "disconnected" } });
-    }
-  }
-  __name(disconnectWallet3, "disconnectWallet");
-  async function fetchBalance2(address5, commitment) {
-    const key = address5.toString();
-    store.setState((state) => ({
-      ...state,
-      accounts: {
-        ...state.accounts,
-        [key]: {
-          address: address5,
-          data: state.accounts[key]?.data,
-          error: void 0,
-          fetching: true,
-          lamports: state.accounts[key]?.lamports ?? null,
-          lastFetchedAt: now(),
-          slot: state.accounts[key]?.slot ?? null
-        }
-      },
-      lastUpdatedAt: now()
-    }));
-    try {
-      const response = await runtime.rpc.getBalance(address5, { commitment: getCommitment(commitment) }).send({ abortSignal: AbortSignal.timeout(1e4) });
-      const lamports2 = response.value;
-      store.setState((state) => ({
-        ...state,
-        accounts: {
-          ...state.accounts,
-          [key]: {
-            address: address5,
-            data: state.accounts[key]?.data,
-            error: void 0,
-            fetching: false,
-            lamports: lamports2,
-            lastFetchedAt: now(),
-            slot: response.context.slot
-          }
-        },
-        lastUpdatedAt: now()
-      }));
-      return lamports2;
-    } catch (error) {
-      store.setState((state) => ({
-        ...state,
-        accounts: {
-          ...state.accounts,
-          [key]: {
-            address: address5,
-            data: state.accounts[key]?.data,
-            error,
-            fetching: false,
-            lamports: state.accounts[key]?.lamports ?? null,
-            lastFetchedAt: now(),
-            slot: state.accounts[key]?.slot ?? null
-          }
-        },
-        lastUpdatedAt: now()
-      }));
-      logger({
-        data: { address: key, ...formatError(error) },
-        level: "error",
-        message: "balance fetch failed"
-      });
-      throw error;
-    }
-  }
-  __name(fetchBalance2, "fetchBalance");
-  async function fetchAccount2(address5, commitment) {
-    const key = address5.toString();
-    store.setState((state) => ({
-      ...state,
-      accounts: {
-        ...state.accounts,
-        [key]: {
-          address: address5,
-          data: state.accounts[key]?.data,
-          error: void 0,
-          fetching: true,
-          lamports: state.accounts[key]?.lamports ?? null,
-          lastFetchedAt: now(),
-          slot: state.accounts[key]?.slot ?? null
-        }
-      },
-      lastUpdatedAt: now()
-    }));
-    try {
-      const response = await runtime.rpc.getAccountInfo(address5, { commitment: getCommitment(commitment), encoding: "base64" }).send({ abortSignal: AbortSignal.timeout(1e4) });
-      const value = response.value;
-      const lamports2 = value?.lamports ?? null;
-      store.setState((state) => ({
-        ...state,
-        accounts: {
-          ...state.accounts,
-          [key]: {
-            address: address5,
-            data: value,
-            error: void 0,
-            fetching: false,
-            lamports: lamports2,
-            lastFetchedAt: now(),
-            slot: response.context.slot
-          }
-        },
-        lastUpdatedAt: now()
-      }));
-      return store.getState().accounts[key];
-    } catch (error) {
-      store.setState((state) => ({
-        ...state,
-        accounts: {
-          ...state.accounts,
-          [key]: {
-            address: address5,
-            data: state.accounts[key]?.data,
-            error,
-            fetching: false,
-            lamports: state.accounts[key]?.lamports ?? null,
-            lastFetchedAt: now(),
-            slot: state.accounts[key]?.slot ?? null
-          }
-        },
-        lastUpdatedAt: now()
-      }));
-      logger({
-        data: { address: key, ...formatError(error) },
-        level: "error",
-        message: "account fetch failed"
-      });
-      throw error;
-    }
-  }
-  __name(fetchAccount2, "fetchAccount");
-  async function fetchLookupTable2(addr, commitment) {
-    const account = await addressLookupTable.fetchAddressLookupTable(runtime.rpc, addr, {
-      commitment: getCommitment(commitment)
-    });
-    const { addresses, authority, deactivationSlot, lastExtendedSlot, lastExtendedSlotStartIndex } = account.data;
-    return {
-      addresses,
-      authority: kit.isSome(authority) ? authority.value : void 0,
-      deactivationSlot,
-      lastExtendedSlot,
-      lastExtendedSlotStartIndex
-    };
-  }
-  __name(fetchLookupTable2, "fetchLookupTable");
-  async function fetchLookupTables2(addresses, commitment) {
-    if (addresses.length === 0) return [];
-    const accounts = await addressLookupTable.fetchAllAddressLookupTable(runtime.rpc, addresses, {
-      commitment: getCommitment(commitment)
-    });
-    return accounts.map(({ data }) => ({
-      addresses: data.addresses,
-      authority: kit.isSome(data.authority) ? data.authority.value : void 0,
-      deactivationSlot: data.deactivationSlot,
-      lastExtendedSlot: data.lastExtendedSlot,
-      lastExtendedSlotStartIndex: data.lastExtendedSlotStartIndex
-    }));
-  }
-  __name(fetchLookupTables2, "fetchLookupTables");
-  async function fetchNonceAccount2(addr, commitment) {
-    const account = await system.fetchNonce(runtime.rpc, addr, {
-      commitment: getCommitment(commitment)
-    });
-    return { authority: account.data.authority, blockhash: account.data.blockhash };
-  }
-  __name(fetchNonceAccount2, "fetchNonceAccount");
-  async function sendTransaction2(transaction, commitment) {
-    const targetCommitment = getCommitment(commitment);
-    const abortController = new AbortController();
-    const signature5 = await runtime.rpc.sendTransaction(kit.getBase64EncodedWireTransaction(transaction), {
-      encoding: "base64",
-      preflightCommitment: targetCommitment
-    }).send({ abortSignal: abortController.signal });
-    const key = signature5.toString();
-    store.setState((state) => ({
-      ...state,
-      lastUpdatedAt: now(),
-      transactions: {
-        ...state.transactions,
-        [key]: {
-          lastUpdatedAt: now(),
-          signature: signature5,
-          status: "sending"
-        }
-      }
-    }));
-    const getBlockHeightExceedencePromise = transactionConfirmation.createBlockHeightExceedencePromiseFactory({
-      rpc: runtime.rpc,
-      rpcSubscriptions: runtime.rpcSubscriptions
-    });
-    const getRecentSignatureConfirmationPromise = transactionConfirmation.createRecentSignatureConfirmationPromiseFactory({
-      rpc: runtime.rpc,
-      rpcSubscriptions: runtime.rpcSubscriptions
-    });
-    try {
-      await transactionConfirmation.waitForRecentTransactionConfirmation({
-        abortSignal: abortController.signal,
-        commitment: targetCommitment,
-        getBlockHeightExceedencePromise,
-        getRecentSignatureConfirmationPromise,
-        transaction
-      });
-      store.setState((state) => ({
-        ...state,
-        lastUpdatedAt: now(),
-        transactions: {
-          ...state.transactions,
-          [key]: {
-            lastUpdatedAt: now(),
-            signature: signature5,
-            status: "confirmed"
-          }
-        }
-      }));
-      return signature5;
-    } catch (error) {
-      store.setState((state) => ({
-        ...state,
-        lastUpdatedAt: now(),
-        transactions: {
-          ...state.transactions,
-          [key]: {
-            error,
-            lastUpdatedAt: now(),
-            signature: signature5,
-            status: "failed"
-          }
-        }
-      }));
-      logger({
-        data: { signature: key, ...formatError(error) },
-        level: "error",
-        message: "transaction failed to confirm"
-      });
-      throw error;
-    }
-  }
-  __name(sendTransaction2, "sendTransaction");
-  async function requestAirdrop2(address5, lamports2) {
-    try {
-      const factory = kit.airdropFactory({
-        rpc: runtime.rpc,
-        rpcSubscriptions: runtime.rpcSubscriptions
-      });
-      const signature5 = await factory({
-        commitment: getCommitment("confirmed"),
-        lamports: lamports2,
-        recipientAddress: address5
-      });
-      logger({
-        data: { address: address5.toString(), lamports: lamports2.toString(), signature: signature5 },
-        level: "info",
-        message: "airdrop requested"
-      });
-      return signature5;
-    } catch (error) {
-      logger({
-        data: { address: address5.toString(), lamports: lamports2.toString(), ...formatError(error) },
-        level: "error",
-        message: "airdrop request failed"
-      });
-      throw error;
-    }
-  }
-  __name(requestAirdrop2, "requestAirdrop");
-  return {
-    connectWallet: connectWallet2,
-    disconnectWallet: disconnectWallet3,
-    fetchAccount: fetchAccount2,
-    fetchBalance: fetchBalance2,
-    fetchLookupTable: fetchLookupTable2,
-    fetchLookupTables: fetchLookupTables2,
-    fetchNonceAccount: fetchNonceAccount2,
-    requestAirdrop: requestAirdrop2,
-    sendTransaction: sendTransaction2,
-    setCluster: setCluster2
-  };
-}
-__name(createActions, "createActions");
-
-// src/numeric/math.ts
-var TEN = 10n;
-function pow10(exponent) {
-  assertDecimals(exponent, "exponent");
-  return TEN ** BigInt(exponent);
-}
-__name(pow10, "pow10");
-function assertNonNegative(value, label = "value") {
-  if (value < 0n) {
-    throw new RangeError(`${label} must be non-negative`);
-  }
-}
-__name(assertNonNegative, "assertNonNegative");
-function assertDecimals(decimals, label = "decimals") {
-  if (!Number.isInteger(decimals) || decimals < 0 || decimals > 38) {
-    throw new RangeError(`${label} must be an integer between 0 and 38`);
-  }
-}
-__name(assertDecimals, "assertDecimals");
-function toBigint2(value, label = "value") {
-  if (typeof value === "bigint") {
-    return value;
-  }
-  if (typeof value === "number") {
-    if (!Number.isFinite(value) || !Number.isInteger(value)) {
-      throw new RangeError(`${label} must be a finite integer when provided as a number`);
-    }
-    if (!Number.isSafeInteger(value)) {
-      throw new RangeError(`${label} must be within the safe integer range when provided as a number`);
-    }
-    return BigInt(value);
-  }
-  const trimmed = value.trim();
-  const match = /^[-+]?\d+$/.exec(trimmed);
-  if (!match) {
-    throw new SyntaxError(`${label} must be an integer string`);
-  }
-  return BigInt(match[0]);
-}
-__name(toBigint2, "toBigint");
-function checkedAdd(lhs, rhs, label = "result") {
-  const result = lhs + rhs;
-  assertNonNegative(result, label);
-  return result;
-}
-__name(checkedAdd, "checkedAdd");
-function checkedSubtract(lhs, rhs, label = "result") {
-  const result = lhs - rhs;
-  assertNonNegative(result, label);
-  return result;
-}
-__name(checkedSubtract, "checkedSubtract");
-function checkedMultiply(lhs, rhs, label = "result") {
-  const result = lhs * rhs;
-  assertNonNegative(result, label);
-  return result;
-}
-__name(checkedMultiply, "checkedMultiply");
-function checkedDivide(dividend, divisor, label = "result") {
-  if (divisor === 0n) {
-    throw new RangeError("divisor must be non-zero");
-  }
-  const result = dividend / divisor;
-  assertNonNegative(result, label);
-  return result;
-}
-__name(checkedDivide, "checkedDivide");
-
-// src/numeric/rational.ts
-function divideWithRounding(dividend, divisor, rounding) {
-  if (divisor <= 0n) {
-    throw new RangeError("divisor must be positive");
-  }
-  const base = dividend / divisor;
-  const remainder = dividend % divisor;
-  if (remainder === 0n) {
-    return base;
-  }
-  switch (rounding) {
-    case "ceil":
-      return base + 1n;
-    case "round": {
-      const twice = remainder * 2n;
-      return twice >= divisor ? base + 1n : base;
-    }
-    default:
-      return base;
-  }
-}
-__name(divideWithRounding, "divideWithRounding");
-function createRatio(numeratorInput, denominatorInput) {
-  const numerator = toBigint2(numeratorInput, "numerator");
-  const denominator = toBigint2(denominatorInput, "denominator");
-  if (denominator <= 0n) {
-    throw new RangeError("denominator must be positive");
-  }
-  assertNonNegative(numerator, "numerator");
-  return Object.freeze({ denominator, numerator });
-}
-__name(createRatio, "createRatio");
-function applyRatio(amount, ratio, options = {}) {
-  assertNonNegative(amount, "amount");
-  const dividend = amount * ratio.numerator;
-  const rounding = options.rounding ?? "floor";
-  return divideWithRounding(dividend, ratio.denominator, rounding);
-}
-__name(applyRatio, "applyRatio");
-
-// src/numeric/amounts.ts
-var DECIMAL_PATTERN = /^\d+(?:\.\d+)?$/;
-function normalizeNumberInput(value, decimals, label) {
-  if (!Number.isFinite(value)) {
-    throw new RangeError(`${label} must be a finite number`);
-  }
-  if (Number.isInteger(value)) {
-    return value.toString(10);
-  }
-  const stringValue = value.toString(10);
-  if (stringValue.includes("e") || stringValue.includes("E")) {
-    throw new RangeError(`${label} cannot use exponential notation; provide a string instead`);
-  }
-  const parts = stringValue.split(".");
-  if (parts[1] && parts[1].length > decimals + 6) {
-    throw new RangeError(`${label} exceeds safe precision; provide a string instead`);
-  }
-  return stringValue;
-}
-__name(normalizeNumberInput, "normalizeNumberInput");
-function decimalToBaseUnits(value, decimals, scale, options) {
-  const label = options.label ?? "value";
-  const rounding = options.rounding ?? "floor";
-  const sanitized = value.replace(/_/g, "").trim();
-  if (sanitized === "") {
-    throw new SyntaxError(`${label} must not be empty`);
-  }
-  if (!DECIMAL_PATTERN.test(sanitized)) {
-    throw new SyntaxError(`${label} must be a non-negative decimal string`);
-  }
-  const [integerPartRaw, fractionalRaw] = sanitized.split(".");
-  const integerPart = integerPartRaw || "0";
-  assertNonNegative(BigInt(integerPart), label);
-  let result = BigInt(integerPart) * scale;
-  const fractionalDigits = fractionalRaw ?? "";
-  if (decimals === 0) {
-    if (fractionalDigits.length === 0) {
-      return result;
-    }
-    const hasFractional = /[1-9]/.test(fractionalDigits);
-    if (rounding === "ceil" && hasFractional) {
-      return result + 1n;
-    }
-    if (rounding === "round" && fractionalDigits[0] !== void 0 && fractionalDigits[0] >= "5") {
-      return result + 1n;
-    }
-    return result;
-  }
-  const truncatedFractional = fractionalDigits.slice(0, decimals).padEnd(decimals, "0");
-  const fractionalComponent = truncatedFractional === "" ? 0n : BigInt(truncatedFractional);
-  result += fractionalComponent;
-  if (fractionalDigits.length > decimals) {
-    const remainderDigits = fractionalDigits.slice(decimals);
-    const hasRemainder = /[1-9]/.test(remainderDigits);
-    if (rounding === "ceil" && hasRemainder) {
-      result += 1n;
-    } else if (rounding === "round") {
-      const firstRemainderDigit = remainderDigits[0];
-      if (firstRemainderDigit !== void 0 && firstRemainderDigit >= "5") {
-        result += 1n;
-      }
-    }
-  }
-  return result;
-}
-__name(decimalToBaseUnits, "decimalToBaseUnits");
-function formatBaseUnits(amount, decimals, scale, options) {
-  assertNonNegative(amount, "amount");
-  const minimumFractionDigits = options.minimumFractionDigits ?? 0;
-  if (minimumFractionDigits < 0 || minimumFractionDigits > decimals) {
-    throw new RangeError("minimumFractionDigits must be between 0 and the token decimals");
-  }
-  const trimTrailingZeros = options.trimTrailingZeros ?? true;
-  if (decimals === 0) {
-    return amount.toString();
-  }
-  const whole = amount / scale;
-  let fraction = (amount % scale).toString().padStart(decimals, "0");
-  if (trimTrailingZeros) {
-    fraction = fraction.replace(/0+$/, "");
-  }
-  if (fraction.length < minimumFractionDigits) {
-    fraction = fraction.padEnd(minimumFractionDigits, "0");
-  }
-  if (fraction.length === 0) {
-    return whole.toString();
-  }
-  return `${whole.toString()}.${fraction}`;
-}
-__name(formatBaseUnits, "formatBaseUnits");
-function createTokenAmount(decimals) {
-  assertDecimals(decimals, "decimals");
-  const scale = pow10(decimals);
-  function fromBaseUnits(value, label) {
-    const amount = toBigint2(value, label ?? "amount");
-    assertNonNegative(amount, label ?? "amount");
-    return amount;
-  }
-  __name(fromBaseUnits, "fromBaseUnits");
-  function fromDecimal(value, options = {}) {
-    const label = options.label ?? "value";
-    if (typeof value === "number") {
-      if (Number.isInteger(value)) {
-        if (!Number.isSafeInteger(value)) {
-          throw new RangeError(`${label} must be within the safe integer range when provided as a number`);
-        }
-        return fromBaseUnits(BigInt(value) * scale, label);
-      }
-      if (decimals === 0) {
-        throw new RangeError(`${label} cannot include fractional digits for a token with 0 decimals`);
-      }
-      const normalized = normalizeNumberInput(value, decimals, label);
-      return decimalToBaseUnits(normalized, decimals, scale, options);
-    }
-    return decimalToBaseUnits(value, decimals, scale, options);
-  }
-  __name(fromDecimal, "fromDecimal");
-  function toDecimalString(amount, options = {}) {
-    return formatBaseUnits(fromBaseUnits(amount), decimals, scale, options);
-  }
-  __name(toDecimalString, "toDecimalString");
-  function add(lhs, rhs) {
-    return checkedAdd(fromBaseUnits(lhs), fromBaseUnits(rhs));
-  }
-  __name(add, "add");
-  function subtract(lhs, rhs) {
-    return checkedSubtract(fromBaseUnits(lhs), fromBaseUnits(rhs));
-  }
-  __name(subtract, "subtract");
-  function multiplyByRatio(amount, ratio, options) {
-    return applyRatio(fromBaseUnits(amount), ratio, options);
-  }
-  __name(multiplyByRatio, "multiplyByRatio");
-  function isZero(amount) {
-    return fromBaseUnits(amount) === 0n;
-  }
-  __name(isZero, "isZero");
-  function compare(lhs, rhs) {
-    const left = fromBaseUnits(lhs);
-    const right = fromBaseUnits(rhs);
-    if (left > right) {
-      return 1;
-    }
-    if (left < right) {
-      return -1;
-    }
-    return 0;
-  }
-  __name(compare, "compare");
-  return Object.freeze({
-    add,
-    compare,
-    decimals,
-    fromBaseUnits,
-    fromDecimal,
-    isZero,
-    multiplyByRatio,
-    scale,
-    subtract,
-    toDecimalString
-  });
-}
-__name(createTokenAmount, "createTokenAmount");
-
-// src/numeric/lamports.ts
-var BASE_LAMPORTS = createTokenAmount(9);
-var LAMPORTS_PER_SOL = BASE_LAMPORTS.scale;
-var lamportsMath = Object.freeze({
-  /**
-   * Adds two lamport amounts.
-   *
-   * @param lhs - First lamport operand.
-   * @param rhs - Second lamport operand.
-   * @returns Sum as lamports.
-   */
-  add(lhs, rhs) {
-    return BASE_LAMPORTS.add(lhs, rhs);
-  },
-  /**
-   * Compares two lamport amounts.
-   *
-   * @param lhs - First lamport operand.
-   * @param rhs - Second lamport operand.
-   * @returns `1`, `0`, or `-1` corresponding to the comparison result.
-   */
-  compare(lhs, rhs) {
-    return BASE_LAMPORTS.compare(lhs, rhs);
-  },
-  decimals: BASE_LAMPORTS.decimals,
-  /**
-   * Validates and converts raw lamport inputs.
-   *
-   * @param value - Integer-like lamport amount.
-   * @param label - Optional label used for error reporting.
-   * @returns Normalized lamport bigint.
-   */
-  fromLamports(value, label) {
-    return BASE_LAMPORTS.fromBaseUnits(value, label);
-  },
-  /**
-   * Converts SOL denominated values into lamports.
-   *
-   * @param value - Decimal representation of SOL.
-   * @param options - Optional rounding and labelling configuration.
-   * @returns Lamport amount.
-   */
-  fromSol(value, options) {
-    return BASE_LAMPORTS.fromDecimal(value, options);
-  },
-  /**
-   * Determines whether a lamport amount equals zero.
-   *
-   * @param amount - Lamports to inspect.
-   * @returns `true` when the amount is zero.
-   */
-  isZero(amount) {
-    return BASE_LAMPORTS.isZero(amount);
-  },
-  /**
-   * Applies a ratio to lamports.
-   *
-   * @param amount - Lamport amount to scale.
-   * @param ratio - Ratio produced by {@link createRatio}.
-   * @param options - Optional rounding configuration.
-   * @returns Scaled lamport amount.
-   */
-  multiplyByRatio(amount, ratio, options) {
-    return BASE_LAMPORTS.multiplyByRatio(amount, ratio, options);
-  },
-  raw: BASE_LAMPORTS,
-  scale: BASE_LAMPORTS.scale,
-  /**
-   * Subtracts two lamport amounts.
-   *
-   * @param lhs - First lamport operand.
-   * @param rhs - Second lamport operand.
-   * @returns Difference as lamports.
-   */
-  subtract(lhs, rhs) {
-    return BASE_LAMPORTS.subtract(lhs, rhs);
-  },
-  /**
-   * Formats lamports into a human-readable SOL string.
-   *
-   * @param amount - Lamport amount to format.
-   * @param options - Formatting preferences.
-   * @returns SOL string representation.
-   */
-  toSolString(amount, options) {
-    return BASE_LAMPORTS.toDecimalString(amount, options);
-  }
-});
-function lamports(value, label) {
-  return lamportsMath.fromLamports(value, label);
-}
-__name(lamports, "lamports");
-function lamportsFromSol(value, options) {
-  return lamportsMath.fromSol(value, options);
-}
-__name(lamportsFromSol, "lamportsFromSol");
-function lamportsToSolString(amount, options) {
-  return lamportsMath.toSolString(amount, options);
-}
-__name(lamportsToSolString, "lamportsToSolString");
-function isWalletSession(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  return "account" in value && "connector" in value && "disconnect" in value;
-}
-__name(isWalletSession, "isWalletSession");
-function createWalletTransactionSigner(session, config = {}) {
-  const { commitment } = config;
-  const address5 = session.account.address;
-  if (session.signTransaction) {
-    const signTransaction = session.signTransaction.bind(session);
-    const modifyingSigner = Object.freeze({
-      address: address5,
-      async modifyAndSignTransactions(transactions) {
-        const signedTransactions = [];
-        for (const transaction of transactions) {
-          const castTransaction = transaction;
-          const signed = await signTransaction(
-            castTransaction
-          );
-          const signature5 = signed.signatures[address5];
-          if (!signature5) {
-            throw new Error("Wallet did not populate the expected fee payer signature.");
-          }
-          const mergedTransaction = Object.freeze({
-            ...castTransaction,
-            messageBytes: signed.messageBytes,
-            signatures: Object.freeze({
-              ...castTransaction.signatures,
-              ...signed.signatures
-            })
-          });
-          signedTransactions.push(mergedTransaction);
-        }
-        return Object.freeze(signedTransactions);
-      },
-      async signTransactions(transactions) {
-        const signedTransactions = await this.modifyAndSignTransactions(transactions);
-        return Object.freeze(
-          signedTransactions.map((signedTransaction) => {
-            const signature5 = signedTransaction.signatures[address5];
-            if (!signature5) {
-              throw new Error("Expected signer to produce a signature for the provided address.");
-            }
-            return Object.freeze({ [address5]: signature5 });
-          })
-        );
-      }
-    });
-    return {
-      mode: "partial",
-      signer: modifyingSigner
-    };
-  }
-  if (session.sendTransaction) {
-    const base58Encoder = codecsStrings.getBase58Encoder();
-    const sendTransaction2 = session.sendTransaction.bind(session);
-    const sendingSigner = Object.freeze({
-      address: address5,
-      async signAndSendTransactions(transactions) {
-        const signatures = [];
-        for (const transaction of transactions) {
-          const signatureString = await sendTransaction2(
-            transaction,
-            commitment ? { commitment } : void 0
-          );
-          const bytes = base58Encoder.encode(signatureString);
-          signatures.push(kit.signatureBytes(bytes));
-        }
-        return signatures;
-      }
-    });
-    return {
-      mode: "send",
-      signer: sendingSigner
-    };
-  }
-  throw new Error("Wallet session does not support signing or sending transactions.");
-}
-__name(createWalletTransactionSigner, "createWalletTransactionSigner");
-function resolveSignerMode(signer) {
-  if (kit.isTransactionPartialSigner(signer)) {
-    return "partial";
-  }
-  if (kit.isTransactionSendingSigner(signer)) {
-    return "send";
-  }
-  return "partial";
-}
-__name(resolveSignerMode, "resolveSignerMode");
-
-// src/features/sol.ts
-function ensureAddress(value) {
-  return typeof value === "string" ? kit.address(value) : value;
-}
-__name(ensureAddress, "ensureAddress");
-async function resolveLifetime(runtime, commitment, fallback) {
-  if (fallback) {
-    return fallback;
-  }
-  const { value } = await runtime.rpc.getLatestBlockhash({ commitment }).send();
-  return value;
-}
-__name(resolveLifetime, "resolveLifetime");
-function resolveSigner(authority, commitment) {
-  if (isWalletSession(authority)) {
-    const { signer, mode } = createWalletTransactionSigner(authority, { commitment });
-    return { mode, signer };
-  }
-  return { mode: resolveSignerMode(authority), signer: authority };
-}
-__name(resolveSigner, "resolveSigner");
-function toLamportAmount(input) {
-  return lamportsMath.fromLamports(input);
-}
-__name(toLamportAmount, "toLamportAmount");
-function createSolTransferHelper(runtime) {
-  async function prepareTransfer(config) {
-    const commitment = config.commitment;
-    const lifetime = await resolveLifetime(runtime, commitment, config.lifetime);
-    const { signer, mode } = resolveSigner(config.authority, commitment);
-    const destination = ensureAddress(config.destination);
-    const amount = toLamportAmount(config.amount);
-    const message = kit.pipe(
-      kit.createTransactionMessage({ version: config.transactionVersion ?? 0 }),
-      (m) => kit.setTransactionMessageFeePayer(signer.address, m),
-      (m) => kit.setTransactionMessageLifetimeUsingBlockhash(lifetime, m),
-      (m) => kit.appendTransactionMessageInstruction(
-        system.getTransferSolInstruction({ amount, destination, source: signer }),
-        m
-      )
-    );
-    return {
-      commitment,
-      lifetime,
-      message,
-      mode,
-      signer,
-      plan: kit.singleTransactionPlan(message)
-    };
-  }
-  __name(prepareTransfer, "prepareTransfer");
-  async function sendPreparedTransfer(prepared, options = {}) {
-    if (prepared.mode === "send" && kit.isTransactionSendingSigner(prepared.signer)) {
-      const signatureBytes2 = await kit.signAndSendTransactionMessageWithSigners(prepared.message, {
-        abortSignal: options.abortSignal,
-        minContextSlot: options.minContextSlot
-      });
-      const base58Decoder2 = codecsStrings.getBase58Decoder();
-      return kit.signature(base58Decoder2.decode(signatureBytes2));
-    }
-    const commitment = options.commitment ?? prepared.commitment;
-    const maxRetries = options.maxRetries === void 0 ? void 0 : typeof options.maxRetries === "bigint" ? options.maxRetries : BigInt(options.maxRetries);
-    let latestSignature = null;
-    const executor = kit.createTransactionPlanExecutor({
-      async executeTransactionMessage(message, config = {}) {
-        const signed = await kit.signTransactionMessageWithSigners(message, {
-          abortSignal: config.abortSignal ?? options.abortSignal,
-          minContextSlot: options.minContextSlot
-        });
-        const wire = kit.getBase64EncodedWireTransaction(signed);
-        const response = await runtime.rpc.sendTransaction(wire, {
-          encoding: "base64",
-          maxRetries,
-          preflightCommitment: commitment,
-          skipPreflight: options.skipPreflight
-        }).send({ abortSignal: config.abortSignal ?? options.abortSignal });
-        latestSignature = kit.signature(response);
-        return { transaction: signed };
-      }
-    });
-    await executor(prepared.plan ?? kit.singleTransactionPlan(prepared.message), { abortSignal: options.abortSignal });
-    if (!latestSignature) {
-      throw new Error("Failed to resolve transaction signature.");
-    }
-    return latestSignature;
-  }
-  __name(sendPreparedTransfer, "sendPreparedTransfer");
-  async function sendTransfer(config, options) {
-    const prepared = await prepareTransfer(config);
-    return await sendPreparedTransfer(prepared, options);
-  }
-  __name(sendTransfer, "sendTransfer");
-  return {
-    prepareTransfer,
-    sendPreparedTransfer,
-    sendTransfer
-  };
-}
-__name(createSolTransferHelper, "createSolTransferHelper");
-function ensureAddress2(value, fallback) {
-  if (value) {
-    return typeof value === "string" ? kit.address(value) : value;
-  }
-  if (!fallback) {
-    throw new Error("An address value was expected but not provided.");
-  }
-  return fallback;
-}
-__name(ensureAddress2, "ensureAddress");
-async function resolveLifetime2(runtime, commitment, fallback) {
-  if (fallback) {
-    return fallback;
-  }
-  const { value } = await runtime.rpc.getLatestBlockhash({ commitment }).send();
-  return value;
-}
-__name(resolveLifetime2, "resolveLifetime");
-function resolveSigner2(authority, commitment) {
-  if (isWalletSession(authority)) {
-    const { signer, mode } = createWalletTransactionSigner(authority, { commitment });
-    return { mode, signer };
-  }
-  return { mode: resolveSignerMode(authority), signer: authority };
-}
-__name(resolveSigner2, "resolveSigner");
-function createSplTokenHelper(runtime, config) {
-  const mintAddress = ensureAddress2(config.mint);
-  const tokenProgram = ensureAddress2(config.tokenProgram, kit.address(token.TOKEN_PROGRAM_ADDRESS));
-  let cachedDecimals = config.decimals;
-  let cachedMath;
-  async function resolveDecimals(commitment) {
-    if (cachedDecimals !== void 0) {
-      return cachedDecimals;
-    }
-    const account = await token.fetchMint(runtime.rpc, mintAddress, { commitment });
-    cachedDecimals = account.data.decimals;
-    return cachedDecimals;
-  }
-  __name(resolveDecimals, "resolveDecimals");
-  async function getTokenMath(commitment) {
-    if (cachedMath) {
-      return cachedMath;
-    }
-    const decimals = await resolveDecimals(commitment);
-    cachedMath = createTokenAmount(decimals);
-    return cachedMath;
-  }
-  __name(getTokenMath, "getTokenMath");
-  async function deriveAssociatedTokenAddress(owner) {
-    const [ata] = await token.findAssociatedTokenPda({
-      mint: mintAddress,
-      owner: ensureAddress2(owner),
-      tokenProgram
-    });
-    return ata;
-  }
-  __name(deriveAssociatedTokenAddress, "deriveAssociatedTokenAddress");
-  async function fetchBalance2(owner, commitment) {
-    const ataAddress = await deriveAssociatedTokenAddress(owner);
-    const decimals = await resolveDecimals(commitment);
-    try {
-      const { value } = await runtime.rpc.getTokenAccountBalance(ataAddress, { commitment }).send();
-      const math = await getTokenMath(commitment);
-      const amount = math.fromBaseUnits(value.amount, "balance");
-      const uiAmount = value.uiAmountString ?? value.amount;
-      return {
-        amount,
-        ataAddress,
-        decimals,
-        exists: true,
-        uiAmount
-      };
-    } catch {
-      return {
-        amount: 0n,
-        ataAddress,
-        decimals,
-        exists: false,
-        uiAmount: "0"
-      };
-    }
-  }
-  __name(fetchBalance2, "fetchBalance");
-  async function prepareTransfer(config2) {
-    const commitment = config2.commitment;
-    const lifetime = await resolveLifetime2(runtime, commitment, config2.lifetime);
-    const { signer, mode } = resolveSigner2(config2.authority, commitment);
-    const sourceOwner = ensureAddress2(config2.sourceOwner, signer.address);
-    const destinationOwner = ensureAddress2(config2.destinationOwner);
-    const sourceAta = ensureAddress2(config2.sourceToken, await deriveAssociatedTokenAddress(sourceOwner));
-    const destinationAta = ensureAddress2(
-      config2.destinationToken,
-      await deriveAssociatedTokenAddress(destinationOwner)
-    );
-    const math = await getTokenMath(commitment);
-    const decimals = await resolveDecimals(commitment);
-    const amount = config2.amountInBaseUnits ? math.fromBaseUnits(config2.amount, "amount") : math.fromDecimal(config2.amount, { label: "amount" });
-    const instructionList = [];
-    if (config2.ensureDestinationAta ?? true) {
-      const { value } = await runtime.rpc.getAccountInfo(destinationAta, {
-        commitment,
-        dataSlice: { length: 0, offset: 0 },
-        encoding: "base64"
-      }).send();
-      if (!value) {
-        instructionList.push(
-          token.getCreateAssociatedTokenInstruction({
-            ata: destinationAta,
-            mint: mintAddress,
-            owner: destinationOwner,
-            payer: signer,
-            tokenProgram
-          })
-        );
-      }
-    }
-    instructionList.push(
-      token.getTransferCheckedInstruction({
-        amount,
-        authority: signer,
-        decimals,
-        destination: destinationAta,
-        mint: mintAddress,
-        source: sourceAta
-      })
-    );
-    let message = kit.pipe(
-      kit.createTransactionMessage({ version: config2.transactionVersion ?? 0 }),
-      (m) => kit.setTransactionMessageFeePayer(signer.address, m),
-      (m) => kit.setTransactionMessageLifetimeUsingBlockhash(lifetime, m)
-    );
-    for (const instruction of instructionList) {
-      message = kit.appendTransactionMessageInstruction(instruction, message);
-    }
-    return {
-      amount,
-      commitment,
-      decimals,
-      destinationAta,
-      lifetime,
-      message,
-      mode,
-      signer,
-      sourceAta,
-      plan: kit.singleTransactionPlan(message)
-    };
-  }
-  __name(prepareTransfer, "prepareTransfer");
-  async function sendPreparedTransfer(prepared, options = {}) {
-    if (prepared.mode === "send" && kit.isTransactionSendingSigner(prepared.signer)) {
-      const signatureBytes2 = await kit.signAndSendTransactionMessageWithSigners(prepared.message, {
-        abortSignal: options.abortSignal,
-        minContextSlot: options.minContextSlot
-      });
-      const base58Decoder2 = codecsStrings.getBase58Decoder();
-      return kit.signature(base58Decoder2.decode(signatureBytes2));
-    }
-    const commitment = options.commitment ?? prepared.commitment;
-    const maxRetries = options.maxRetries === void 0 ? void 0 : typeof options.maxRetries === "bigint" ? options.maxRetries : BigInt(options.maxRetries);
-    let latestSignature = null;
-    const executor = kit.createTransactionPlanExecutor({
-      async executeTransactionMessage(message, config2 = {}) {
-        const signed = await kit.signTransactionMessageWithSigners(message, {
-          abortSignal: config2.abortSignal ?? options.abortSignal,
-          minContextSlot: options.minContextSlot
-        });
-        const wire = kit.getBase64EncodedWireTransaction(signed);
-        const response = await runtime.rpc.sendTransaction(wire, {
-          encoding: "base64",
-          maxRetries,
-          preflightCommitment: commitment,
-          skipPreflight: options.skipPreflight
-        }).send({ abortSignal: config2.abortSignal ?? options.abortSignal });
-        latestSignature = kit.signature(response);
-        return { transaction: signed };
-      }
-    });
-    await executor(prepared.plan ?? kit.singleTransactionPlan(prepared.message), { abortSignal: options.abortSignal });
-    if (!latestSignature) {
-      throw new Error("Failed to resolve transaction signature.");
-    }
-    return latestSignature;
-  }
-  __name(sendPreparedTransfer, "sendPreparedTransfer");
-  async function sendTransfer(config2, options) {
-    const prepared = await prepareTransfer(config2);
-    try {
-      return await sendPreparedTransfer(prepared, options);
-    } catch (error) {
-      if (kit.isSolanaError(error, kit.SOLANA_ERROR__TRANSACTION_ERROR__ALREADY_PROCESSED)) {
-        const retriedPrepared = await prepareTransfer({ ...config2, lifetime: void 0 });
-        return await sendPreparedTransfer(retriedPrepared, options);
-      }
-      throw error;
-    }
-  }
-  __name(sendTransfer, "sendTransfer");
-  return {
-    deriveAssociatedTokenAddress,
-    fetchBalance: fetchBalance2,
-    prepareTransfer,
-    sendPreparedTransfer,
-    sendTransfer
-  };
-}
-__name(createSplTokenHelper, "createSplTokenHelper");
-var STAKE_PROGRAM_ID = "Stake11111111111111111111111111111111111111";
-var SYSVAR_CLOCK = "SysvarC1ock11111111111111111111111111111111";
-var SYSVAR_STAKE_HISTORY = "SysvarStakeHistory1111111111111111111111111";
-var UNUSED_STAKE_CONFIG_ACC = "StakeConfig11111111111111111111111111111111";
-var STAKE_STATE_LEN = 200;
-function ensureAddress3(value) {
-  return typeof value === "string" ? kit.address(value) : value;
-}
-__name(ensureAddress3, "ensureAddress");
-async function resolveLifetime3(runtime, commitment, fallback) {
-  if (fallback) {
-    return fallback;
-  }
-  const { value } = await runtime.rpc.getLatestBlockhash({ commitment }).send();
-  return value;
-}
-__name(resolveLifetime3, "resolveLifetime");
-function resolveSigner3(authority, commitment) {
-  if (isWalletSession(authority)) {
-    const { signer, mode } = createWalletTransactionSigner(authority, { commitment });
-    return { mode, signer };
-  }
-  return { mode: resolveSignerMode(authority), signer: authority };
-}
-__name(resolveSigner3, "resolveSigner");
-function toLamportAmount2(input) {
-  return lamportsMath.fromLamports(input);
-}
-__name(toLamportAmount2, "toLamportAmount");
-function createStakeHelper(runtime) {
-  async function prepareStake(config) {
-    const commitment = config.commitment;
-    const lifetime = await resolveLifetime3(runtime, commitment, config.lifetime);
-    const { signer, mode } = resolveSigner3(config.authority, commitment);
-    const validatorAddress = ensureAddress3(config.validatorId);
-    const amount = toLamportAmount2(config.amount);
-    const rentExempt = await runtime.rpc.getMinimumBalanceForRentExemption(BigInt(STAKE_STATE_LEN)).send();
-    const totalLamports = rentExempt + amount;
-    const stakeAccount = await kit.generateKeyPairSigner();
-    const createIx = system.getCreateAccountInstruction({
-      payer: signer,
-      newAccount: stakeAccount,
-      lamports: totalLamports,
-      space: BigInt(STAKE_STATE_LEN),
-      programAddress: STAKE_PROGRAM_ID
-    });
-    const initializeIx = stake.getInitializeInstruction({
-      stake: stakeAccount.address,
-      arg0: {
-        staker: signer.address,
-        withdrawer: signer.address
-      },
-      arg1: {
-        unixTimestamp: 0n,
-        epoch: 0n,
-        custodian: signer.address
-      }
-    });
-    const delegateIx = stake.getDelegateStakeInstruction({
-      stake: stakeAccount.address,
-      vote: validatorAddress,
-      stakeHistory: SYSVAR_STAKE_HISTORY,
-      unused: UNUSED_STAKE_CONFIG_ACC,
-      stakeAuthority: signer
-    });
-    const message = kit.pipe(
-      kit.createTransactionMessage({ version: config.transactionVersion ?? 0 }),
-      (m) => kit.setTransactionMessageFeePayer(signer.address, m),
-      (m) => kit.setTransactionMessageLifetimeUsingBlockhash(lifetime, m),
-      (m) => kit.appendTransactionMessageInstructions([createIx, initializeIx, delegateIx], m)
-    );
-    return {
-      commitment,
-      lifetime,
-      message,
-      mode,
-      signer,
-      stakeAccount,
-      plan: kit.singleTransactionPlan(message)
-    };
-  }
-  __name(prepareStake, "prepareStake");
-  async function sendPreparedStake(prepared, options = {}) {
-    if (prepared.mode === "send" && kit.isTransactionSendingSigner(prepared.signer)) {
-      const signatureBytes2 = await kit.signAndSendTransactionMessageWithSigners(prepared.message, {
-        abortSignal: options.abortSignal,
-        minContextSlot: options.minContextSlot
-      });
-      const base58Decoder2 = codecsStrings.getBase58Decoder();
-      return kit.signature(base58Decoder2.decode(signatureBytes2));
-    }
-    const commitment = options.commitment ?? prepared.commitment;
-    const maxRetries = options.maxRetries === void 0 ? void 0 : typeof options.maxRetries === "bigint" ? options.maxRetries : BigInt(options.maxRetries);
-    let latestSignature = null;
-    const executor = kit.createTransactionPlanExecutor({
-      async executeTransactionMessage(message, config = {}) {
-        const signed = await kit.signTransactionMessageWithSigners(message, {
-          abortSignal: config.abortSignal ?? options.abortSignal,
-          minContextSlot: options.minContextSlot
-        });
-        const wire = kit.getBase64EncodedWireTransaction(signed);
-        const response = await runtime.rpc.sendTransaction(wire, {
-          encoding: "base64",
-          maxRetries,
-          preflightCommitment: commitment,
-          skipPreflight: options.skipPreflight
-        }).send({ abortSignal: config.abortSignal ?? options.abortSignal });
-        latestSignature = kit.signature(response);
-        return { transaction: signed };
-      }
-    });
-    await executor(prepared.plan ?? kit.singleTransactionPlan(prepared.message), { abortSignal: options.abortSignal });
-    if (!latestSignature) {
-      throw new Error("Failed to resolve transaction signature.");
-    }
-    return latestSignature;
-  }
-  __name(sendPreparedStake, "sendPreparedStake");
-  async function sendStake(config, options) {
-    const prepared = await prepareStake(config);
-    return await sendPreparedStake(prepared, options);
-  }
-  __name(sendStake, "sendStake");
-  async function prepareUnstake(config) {
-    const commitment = config.commitment;
-    const lifetime = await resolveLifetime3(runtime, commitment, config.lifetime);
-    const { signer, mode } = resolveSigner3(config.authority, commitment);
-    const stakeAccountAddress = ensureAddress3(config.stakeAccount);
-    const deactivateIx = stake.getDeactivateInstruction({
-      stake: stakeAccountAddress,
-      clockSysvar: SYSVAR_CLOCK,
-      stakeAuthority: signer
-    });
-    const message = kit.pipe(
-      kit.createTransactionMessage({ version: config.transactionVersion ?? 0 }),
-      (m) => kit.setTransactionMessageFeePayer(signer.address, m),
-      (m) => kit.setTransactionMessageLifetimeUsingBlockhash(lifetime, m),
-      (m) => kit.appendTransactionMessageInstructions([deactivateIx], m)
-    );
-    return {
-      commitment,
-      lifetime,
-      message,
-      mode,
-      signer,
-      plan: kit.singleTransactionPlan(message)
-    };
-  }
-  __name(prepareUnstake, "prepareUnstake");
-  async function sendPreparedUnstake(prepared, options = {}) {
-    if (prepared.mode === "send" && kit.isTransactionSendingSigner(prepared.signer)) {
-      const signatureBytes2 = await kit.signAndSendTransactionMessageWithSigners(prepared.message, {
-        abortSignal: options.abortSignal,
-        minContextSlot: options.minContextSlot
-      });
-      const base58Decoder2 = codecsStrings.getBase58Decoder();
-      return kit.signature(base58Decoder2.decode(signatureBytes2));
-    }
-    const commitment = options.commitment ?? prepared.commitment;
-    const maxRetries = options.maxRetries === void 0 ? void 0 : typeof options.maxRetries === "bigint" ? options.maxRetries : BigInt(options.maxRetries);
-    let latestSignature = null;
-    const executor = kit.createTransactionPlanExecutor({
-      async executeTransactionMessage(message, config = {}) {
-        const signed = await kit.signTransactionMessageWithSigners(message, {
-          abortSignal: config.abortSignal ?? options.abortSignal,
-          minContextSlot: options.minContextSlot
-        });
-        const wire = kit.getBase64EncodedWireTransaction(signed);
-        const response = await runtime.rpc.sendTransaction(wire, {
-          encoding: "base64",
-          maxRetries,
-          preflightCommitment: commitment,
-          skipPreflight: options.skipPreflight
-        }).send({ abortSignal: config.abortSignal ?? options.abortSignal });
-        latestSignature = kit.signature(response);
-        return { transaction: signed };
-      }
-    });
-    await executor(prepared.plan);
-    if (!latestSignature) {
-      throw new Error("Failed to resolve transaction signature.");
-    }
-    return latestSignature;
-  }
-  __name(sendPreparedUnstake, "sendPreparedUnstake");
-  async function sendUnstake(config, options) {
-    const prepared = await prepareUnstake(config);
-    return await sendPreparedUnstake(prepared, options);
-  }
-  __name(sendUnstake, "sendUnstake");
-  async function prepareWithdraw(config) {
-    const commitment = config.commitment;
-    const lifetime = await resolveLifetime3(runtime, commitment, config.lifetime);
-    const { signer, mode } = resolveSigner3(config.authority, commitment);
-    const stakeAccountAddress = ensureAddress3(config.stakeAccount);
-    const destinationAddress = ensureAddress3(config.destination);
-    const amount = toLamportAmount2(config.amount);
-    const withdrawIx = stake.getWithdrawInstruction({
-      stake: stakeAccountAddress,
-      recipient: destinationAddress,
-      clockSysvar: SYSVAR_CLOCK,
-      stakeHistory: SYSVAR_STAKE_HISTORY,
-      withdrawAuthority: signer,
-      args: amount
-    });
-    const message = kit.pipe(
-      kit.createTransactionMessage({ version: config.transactionVersion ?? 0 }),
-      (m) => kit.setTransactionMessageFeePayer(signer.address, m),
-      (m) => kit.setTransactionMessageLifetimeUsingBlockhash(lifetime, m),
-      (m) => kit.appendTransactionMessageInstructions([withdrawIx], m)
-    );
-    return {
-      commitment,
-      lifetime,
-      message,
-      mode,
-      signer,
-      plan: kit.singleTransactionPlan(message)
-    };
-  }
-  __name(prepareWithdraw, "prepareWithdraw");
-  async function sendPreparedWithdraw(prepared, options = {}) {
-    if (prepared.mode === "send" && kit.isTransactionSendingSigner(prepared.signer)) {
-      const signatureBytes2 = await kit.signAndSendTransactionMessageWithSigners(prepared.message, {
-        abortSignal: options.abortSignal,
-        minContextSlot: options.minContextSlot
-      });
-      const base58Decoder2 = codecsStrings.getBase58Decoder();
-      return kit.signature(base58Decoder2.decode(signatureBytes2));
-    }
-    const commitment = options.commitment ?? prepared.commitment;
-    const maxRetries = options.maxRetries === void 0 ? void 0 : typeof options.maxRetries === "bigint" ? options.maxRetries : BigInt(options.maxRetries);
-    let latestSignature = null;
-    const executor = kit.createTransactionPlanExecutor({
-      async executeTransactionMessage(message, config = {}) {
-        const signed = await kit.signTransactionMessageWithSigners(message, {
-          abortSignal: config.abortSignal ?? options.abortSignal,
-          minContextSlot: options.minContextSlot
-        });
-        const wire = kit.getBase64EncodedWireTransaction(signed);
-        const response = await runtime.rpc.sendTransaction(wire, {
-          encoding: "base64",
-          maxRetries,
-          preflightCommitment: commitment,
-          skipPreflight: options.skipPreflight
-        }).send({ abortSignal: config.abortSignal ?? options.abortSignal });
-        latestSignature = kit.signature(response);
-        return { transaction: signed };
-      }
-    });
-    await executor(prepared.plan);
-    if (!latestSignature) {
-      throw new Error("Failed to resolve transaction signature.");
-    }
-    return latestSignature;
-  }
-  __name(sendPreparedWithdraw, "sendPreparedWithdraw");
-  async function sendWithdraw(config, options) {
-    const prepared = await prepareWithdraw(config);
-    return await sendPreparedWithdraw(prepared, options);
-  }
-  __name(sendWithdraw, "sendWithdraw");
-  async function getStakeAccounts(wallet, validatorId) {
-    const walletAddress = typeof wallet === "string" ? wallet : String(wallet);
-    const accounts = await runtime.rpc.getProgramAccounts(STAKE_PROGRAM_ID, {
-      encoding: "jsonParsed",
-      filters: [
-        {
-          memcmp: {
-            offset: 44n,
-            bytes: walletAddress,
-            encoding: "base58"
-          }
-        }
-      ]
-    }).send();
-    if (!validatorId) {
-      return accounts;
-    }
-    const validatorIdStr = typeof validatorId === "string" ? validatorId : String(validatorId);
-    return accounts.filter((acc) => {
-      const data = acc.account?.data;
-      if (data && "parsed" in data) {
-        const info = data.parsed?.info;
-        return info?.stake?.delegation?.voter === validatorIdStr;
-      }
-      return false;
-    });
-  }
-  __name(getStakeAccounts, "getStakeAccounts");
-  return {
-    getStakeAccounts,
-    prepareStake,
-    prepareUnstake,
-    prepareWithdraw,
-    sendPreparedStake,
-    sendPreparedUnstake,
-    sendPreparedWithdraw,
-    sendStake,
-    sendUnstake,
-    sendWithdraw
-  };
-}
-__name(createStakeHelper, "createStakeHelper");
-function transactionToBase64(tx) {
-  if ("messageBytes" in tx) {
-    return kit.getBase64EncodedWireTransaction(tx);
-  }
-  return kit.getBase64EncodedWireTransaction(kit.compileTransaction(tx));
-}
-__name(transactionToBase64, "transactionToBase64");
-async function transactionToBase64WithSigners(tx) {
-  if ("messageBytes" in tx) {
-    return transactionToBase64(tx);
-  }
-  const signed = await kit.partiallySignTransactionMessageWithSigners(tx);
-  return transactionToBase64(signed);
-}
-__name(transactionToBase64WithSigners, "transactionToBase64WithSigners");
-
-// src/transactions/prepareTransaction.ts
-var DEFAULT_COMPUTE_UNIT_LIMIT_MULTIPLIER = 1.1;
-var DEFAULT_COMPUTE_UNIT_LIMIT = 2e5;
-var MAX_COMPUTE_UNIT_LIMIT = 14e5;
-function isComputeUnitLimitInstruction(instruction) {
-  return instruction.programAddress === computeBudget.COMPUTE_BUDGET_PROGRAM_ADDRESS && instruction.data?.[0] === 2;
-}
-__name(isComputeUnitLimitInstruction, "isComputeUnitLimitInstruction");
-function didExceedComputeBudget(error) {
-  let current = error;
-  while (kit.isSolanaError(current)) {
-    if (kit.isSolanaError(current, kit.SOLANA_ERROR__INSTRUCTION_ERROR__COMPUTATIONAL_BUDGET_EXCEEDED)) {
-      return true;
-    }
-    current = current.cause;
-  }
-  return false;
-}
-__name(didExceedComputeBudget, "didExceedComputeBudget");
-async function estimateComputeUnits(rpc, transaction) {
-  let target = transaction;
-  const hasLifetime = transaction.lifetimeConstraint !== void 0;
-  if (!hasLifetime) {
-    const latest = await rpc.getLatestBlockhash().send();
-    target = kit.setTransactionMessageLifetimeUsingBlockhash(
-      latest.value,
-      transaction
-    );
-  }
-  const base64Transaction = transactionToBase64(target);
-  try {
-    const { value } = await rpc.simulateTransaction(base64Transaction, {
-      encoding: "base64",
-      replaceRecentBlockhash: false,
-      sigVerify: false
-    }).send();
-    return Number(value.unitsConsumed ?? 0) || 0;
-  } catch (error) {
-    if (didExceedComputeBudget(error)) {
-      return MAX_COMPUTE_UNIT_LIMIT;
-    }
-    throw error;
-  }
-}
-__name(estimateComputeUnits, "estimateComputeUnits");
-async function prepareTransaction(config) {
-  const multiplier = config.computeUnitLimitMultiplier ?? DEFAULT_COMPUTE_UNIT_LIMIT_MULTIPLIER;
-  const shouldResetBlockhash = config.blockhashReset !== false;
-  const shouldResetComputeUnits = config.computeUnitLimitReset ?? false;
-  let transaction = config.transaction;
-  const computeLimitIndex = transaction.instructions.findIndex(isComputeUnitLimitInstruction);
-  if (computeLimitIndex === -1 || shouldResetComputeUnits) {
-    const unitsFromSimulation = await estimateComputeUnits(config.rpc, transaction);
-    const estimatedUnits = unitsFromSimulation ? Math.ceil(unitsFromSimulation * multiplier) : DEFAULT_COMPUTE_UNIT_LIMIT;
-    const units = Math.min(
-      MAX_COMPUTE_UNIT_LIMIT,
-      Math.max(DEFAULT_COMPUTE_UNIT_LIMIT, Math.max(1, estimatedUnits))
-    );
-    const instruction = computeBudget.getSetComputeUnitLimitInstruction({ units });
-    if (computeLimitIndex === -1) {
-      transaction = kit.appendTransactionMessageInstruction(instruction, transaction);
-    } else {
-      const nextInstructions = [...transaction.instructions];
-      nextInstructions.splice(computeLimitIndex, 1, instruction);
-      transaction = Object.freeze({
-        ...transaction,
-        instructions: Object.freeze(nextInstructions)
-      });
-    }
-  }
-  let transactionHasLifetime = transaction.lifetimeConstraint !== void 0;
-  if (shouldResetBlockhash || !transactionHasLifetime) {
-    const latest = await config.rpc.getLatestBlockhash().send();
-    if (!transactionHasLifetime) {
-      transaction = kit.setTransactionMessageLifetimeUsingBlockhash(latest.value, transaction);
-    } else if (shouldResetBlockhash) {
-      transaction = Object.freeze({
-        ...transaction,
-        lifetimeConstraint: latest.value
-      });
-    }
-    transactionHasLifetime = true;
-  }
-  if (config.logRequest) {
-    config.logRequest({ base64WireTransaction: transactionToBase64(transaction) });
-  }
-  return transaction;
-}
-__name(prepareTransaction, "prepareTransaction");
-
-// src/features/transactions.ts
-function toAddress(value) {
-  return typeof value === "string" ? kit.address(value) : value;
-}
-__name(toAddress, "toAddress");
-function hasSetComputeUnitLimitInstruction(instructions) {
-  return instructions.some(
-    (instruction) => kit.isInstructionForProgram(instruction, computeBudget.COMPUTE_BUDGET_PROGRAM_ADDRESS) && kit.isInstructionWithData(instruction) && instruction.data[0] === computeBudget.ComputeBudgetInstruction.SetComputeUnitLimit
-  );
-}
-__name(hasSetComputeUnitLimitInstruction, "hasSetComputeUnitLimitInstruction");
-function hasSetComputeUnitPriceInstruction(instructions) {
-  return instructions.some(
-    (instruction) => kit.isInstructionForProgram(instruction, computeBudget.COMPUTE_BUDGET_PROGRAM_ADDRESS) && kit.isInstructionWithData(instruction) && instruction.data[0] === computeBudget.ComputeBudgetInstruction.SetComputeUnitPrice
-  );
-}
-__name(hasSetComputeUnitPriceInstruction, "hasSetComputeUnitPriceInstruction");
-function instructionUsesAddressLookup(instruction) {
-  if ("addressTableLookup" in instruction && instruction.addressTableLookup != null) {
-    return true;
-  }
-  if ("addressTableLookups" in instruction && Array.isArray(instruction.addressTableLookups) && instruction.addressTableLookups.length > 0) {
-    return true;
-  }
-  return false;
-}
-__name(instructionUsesAddressLookup, "instructionUsesAddressLookup");
-function resolveVersion(requested, instructions) {
-  if (requested && requested !== "auto") {
-    return requested;
-  }
-  return instructions.some(instructionUsesAddressLookup) ? 0 : "legacy";
-}
-__name(resolveVersion, "resolveVersion");
-function normaliseCommitment(request, getFallbackCommitment) {
-  return request.commitment ?? getFallbackCommitment();
-}
-__name(normaliseCommitment, "normaliseCommitment");
-function resolveFeePayerAddress(feePayer, authoritySigner) {
-  if (!feePayer && !authoritySigner) {
-    throw new Error("A fee payer must be provided via `feePayer` or `authority`.");
-  }
-  if (feePayer && typeof feePayer === "object" && "address" in feePayer) {
-    return { address: feePayer.address, signer: feePayer };
-  }
-  if (feePayer) {
-    const address5 = toAddress(feePayer);
-    if (authoritySigner && authoritySigner.address === address5) {
-      return { address: address5, signer: authoritySigner };
-    }
-    return { address: address5 };
-  }
-  if (!authoritySigner) {
-    throw new Error("Unable to resolve authority signer for the fee payer.");
-  }
-  const authorityAddress = authoritySigner.address;
-  return { address: authorityAddress, signer: authoritySigner };
-}
-__name(resolveFeePayerAddress, "resolveFeePayerAddress");
-function resolveComputeUnitLimit(request, instructions) {
-  const value = request.computeUnitLimit;
-  if (value === void 0 || hasSetComputeUnitLimitInstruction(instructions)) {
-    return void 0;
-  }
-  return typeof value === "bigint" ? value : BigInt(Math.floor(value));
-}
-__name(resolveComputeUnitLimit, "resolveComputeUnitLimit");
-function resolveComputeUnitPrice(request, instructions) {
-  if (request.computeUnitPrice === void 0 || hasSetComputeUnitPriceInstruction(instructions)) {
-    return void 0;
-  }
-  if (typeof request.computeUnitPrice === "bigint") {
-    return request.computeUnitPrice;
-  }
-  return BigInt(Math.floor(request.computeUnitPrice));
-}
-__name(resolveComputeUnitPrice, "resolveComputeUnitPrice");
-async function createTransactionRecipe(request, context) {
-  if (!request.instructions.length) {
-    throw new Error("Add at least one instruction before preparing a transaction.");
-  }
-  const { getFallbackCommitment, runtime } = context;
-  request.abortSignal?.throwIfAborted();
-  const commitment = normaliseCommitment(request, getFallbackCommitment);
-  let authoritySigner;
-  let mode = "partial";
-  if (request.authority) {
-    if (isWalletSession(request.authority)) {
-      const { signer, mode: walletMode } = createWalletTransactionSigner(request.authority, { commitment });
-      authoritySigner = signer;
-      mode = walletMode;
-    } else {
-      authoritySigner = request.authority;
-      mode = resolveSignerMode(authoritySigner);
-    }
-  }
-  const { address: feePayer, signer: feePayerSigner } = resolveFeePayerAddress(request.feePayer, authoritySigner);
-  if (mode === "send") {
-    if (!feePayerSigner || !kit.isTransactionSendingSigner(feePayerSigner)) {
-      mode = "partial";
-    }
-  }
-  const baseInstructions = [...request.instructions];
-  const version = resolveVersion(request.version, baseInstructions);
-  const lifetime = request.lifetime ?? (await runtime.rpc.getLatestBlockhash({ commitment }).send({ abortSignal: request.abortSignal })).value;
-  request.abortSignal?.throwIfAborted();
-  const resolvedComputeUnitLimit = resolveComputeUnitLimit(request, baseInstructions);
-  const computeUnitPrice = resolveComputeUnitPrice(request, baseInstructions);
-  const prefixInstructions = [];
-  if (resolvedComputeUnitLimit !== void 0) {
-    prefixInstructions.push(computeBudget.getSetComputeUnitLimitInstruction({ units: Number(resolvedComputeUnitLimit) }));
-  }
-  if (computeUnitPrice !== void 0) {
-    prefixInstructions.push(computeBudget.getSetComputeUnitPriceInstruction({ microLamports: Number(computeUnitPrice) }));
-  }
-  const instructionSequence = [...prefixInstructions, ...baseInstructions];
-  const createMessage = /* @__PURE__ */ __name(async () => kit.pipe(
-    kit.createTransactionMessage({ version }),
-    (message) => feePayerSigner ? kit.setTransactionMessageFeePayerSigner(feePayerSigner, message) : kit.setTransactionMessageFeePayer(feePayer, message),
-    (message) => kit.setTransactionMessageLifetimeUsingBlockhash(lifetime, message)
-  ), "createMessage");
-  return Object.freeze({
-    commitment,
-    computeUnitLimit: resolvedComputeUnitLimit,
-    computeUnitPrice,
-    createTransactionMessage: createMessage,
-    feePayer,
-    instructionPlan: kit.getMessagePackerInstructionPlanFromInstructions(instructionSequence),
-    instructions: Object.freeze(baseInstructions),
-    lifetime,
-    mode,
-    version
-  });
-}
-__name(createTransactionRecipe, "createTransactionRecipe");
-function assertSingleTransactionPlan(plan) {
-  if (plan.kind !== "single") {
-    throw new Error("Transaction recipe produced a multi-transaction plan which is not supported.");
-  }
-  return plan;
-}
-__name(assertSingleTransactionPlan, "assertSingleTransactionPlan");
-function createTransactionHelper(runtime, getFallbackCommitment) {
-  async function prepare(request) {
-    const recipe = await createTransactionRecipe(request, { getFallbackCommitment, runtime });
-    const planner = kit.createTransactionPlanner({
-      createTransactionMessage: recipe.createTransactionMessage
-    });
-    const plan = await planner(recipe.instructionPlan, { abortSignal: request.abortSignal });
-    const singlePlan = assertSingleTransactionPlan(plan);
-    const prepared = Object.freeze({
-      commitment: recipe.commitment,
-      computeUnitLimit: recipe.computeUnitLimit,
-      computeUnitPrice: recipe.computeUnitPrice,
-      feePayer: recipe.feePayer,
-      instructions: recipe.instructions,
-      lifetime: recipe.lifetime,
-      message: singlePlan.message,
-      mode: recipe.mode,
-      plan,
-      version: recipe.version
-    });
-    return prepared;
-  }
-  __name(prepare, "prepare");
-  async function sign(prepared, options = {}) {
-    return await kit.signTransactionMessageWithSigners(prepared.message, {
-      abortSignal: options.abortSignal,
-      minContextSlot: options.minContextSlot
-    });
-  }
-  __name(sign, "sign");
-  async function toWire(prepared, options = {}) {
-    const signed = await sign(prepared, options);
-    return kit.getBase64EncodedWireTransaction(signed);
-  }
-  __name(toWire, "toWire");
-  async function send(prepared, options = {}) {
-    if (!prepared.plan || prepared.mode === "send") {
-      return sendDirect(prepared, options);
-    }
-    return sendWithExecutor(prepared, options);
-  }
-  __name(send, "send");
-  async function sendDirect(prepared, options) {
-    const commitment = options.commitment ?? prepared.commitment;
-    if (prepared.mode === "send") {
-      const signatureBytes2 = await kit.signAndSendTransactionMessageWithSigners(prepared.message, {
-        abortSignal: options.abortSignal,
-        minContextSlot: options.minContextSlot
-      });
-      const base58Decoder2 = codecsStrings.getBase58Decoder();
-      return kit.signature(base58Decoder2.decode(signatureBytes2));
-    }
-    const signed = await sign(prepared, {
-      abortSignal: options.abortSignal,
-      minContextSlot: options.minContextSlot
-    });
-    const wire = kit.getBase64EncodedWireTransaction(signed);
-    const maxRetries = options.maxRetries === void 0 ? void 0 : typeof options.maxRetries === "bigint" ? options.maxRetries : BigInt(options.maxRetries);
-    const response = await runtime.rpc.sendTransaction(wire, {
-      encoding: "base64",
-      maxRetries,
-      preflightCommitment: commitment,
-      skipPreflight: options.skipPreflight
-    }).send({ abortSignal: options.abortSignal });
-    return kit.signature(response);
-  }
-  __name(sendDirect, "sendDirect");
-  async function sendWithExecutor(prepared, options) {
-    if (!prepared.plan) {
-      return sendDirect(prepared, options);
-    }
-    const commitment = options.commitment ?? prepared.commitment;
-    const maxRetries = options.maxRetries === void 0 ? void 0 : typeof options.maxRetries === "bigint" ? options.maxRetries : BigInt(options.maxRetries);
-    let latestSignature = null;
-    const executor = kit.createTransactionPlanExecutor({
-      async executeTransactionMessage(message, config = {}) {
-        const signed = await kit.signTransactionMessageWithSigners(message, {
-          abortSignal: config.abortSignal ?? options.abortSignal,
-          minContextSlot: options.minContextSlot
-        });
-        const wire = kit.getBase64EncodedWireTransaction(signed);
-        const response = await runtime.rpc.sendTransaction(wire, {
-          encoding: "base64",
-          maxRetries,
-          preflightCommitment: commitment,
-          skipPreflight: options.skipPreflight
-        }).send({ abortSignal: config.abortSignal ?? options.abortSignal });
-        latestSignature = kit.signature(response);
-        return { transaction: signed };
-      }
-    });
-    await executor(prepared.plan, { abortSignal: options.abortSignal });
-    if (!latestSignature) {
-      throw new Error("Failed to resolve transaction signature.");
-    }
-    return latestSignature;
-  }
-  __name(sendWithExecutor, "sendWithExecutor");
-  async function prepareAndSend(request, options = {}) {
-    const { prepareTransaction: overrides, ...rest } = request;
-    const prepared = await prepare(rest);
-    if (overrides === false) {
-      return send(prepared, options);
-    }
-    const prepareConfig = overrides ?? {};
-    const tunedMessage = await prepareTransaction({
-      blockhashReset: prepareConfig.blockhashReset ?? false,
-      ...prepareConfig,
-      rpc: runtime.rpc,
-      transaction: prepared.message
-    });
-    const tunedPrepared = Object.freeze({
-      ...prepared,
-      message: tunedMessage,
-      plan: kit.singleTransactionPlan(tunedMessage)
-    });
-    return send(tunedPrepared, options);
-  }
-  __name(prepareAndSend, "prepareAndSend");
-  return Object.freeze({
-    prepare,
-    sign,
-    toWire,
-    send,
-    prepareAndSend
-  });
-}
-__name(createTransactionHelper, "createTransactionHelper");
-
-// src/client/createClientHelpers.ts
-function withDefaultCommitment(config, getFallback, baseCommitment) {
-  if (config.commitment !== void 0) {
-    return config;
-  }
-  const commitment = baseCommitment ?? getFallback();
-  return {
-    ...config,
-    commitment
-  };
-}
-__name(withDefaultCommitment, "withDefaultCommitment");
-function wrapSolTransferHelper(helper, getFallback) {
-  return {
-    prepareTransfer: /* @__PURE__ */ __name((config) => helper.prepareTransfer(withDefaultCommitment(config, getFallback)), "prepareTransfer"),
-    sendPreparedTransfer: helper.sendPreparedTransfer,
-    sendTransfer: /* @__PURE__ */ __name((config, options) => helper.sendTransfer(withDefaultCommitment(config, getFallback), options), "sendTransfer")
-  };
-}
-__name(wrapSolTransferHelper, "wrapSolTransferHelper");
-function wrapSplTokenHelper(helper, getFallback, baseCommitment) {
-  const resolveCommitment = /* @__PURE__ */ __name((commitment) => commitment ?? baseCommitment ?? getFallback(), "resolveCommitment");
-  return {
-    deriveAssociatedTokenAddress: helper.deriveAssociatedTokenAddress,
-    fetchBalance: /* @__PURE__ */ __name((owner, commitment) => helper.fetchBalance(owner, resolveCommitment(commitment)), "fetchBalance"),
-    prepareTransfer: /* @__PURE__ */ __name((config) => helper.prepareTransfer(withDefaultCommitment(config, getFallback, baseCommitment)), "prepareTransfer"),
-    sendPreparedTransfer: helper.sendPreparedTransfer,
-    sendTransfer: /* @__PURE__ */ __name((config, options) => helper.sendTransfer(withDefaultCommitment(config, getFallback, baseCommitment), options), "sendTransfer")
-  };
-}
-__name(wrapSplTokenHelper, "wrapSplTokenHelper");
-function wrapStakeHelper(helper, getFallback) {
-  return {
-    getStakeAccounts: helper.getStakeAccounts,
-    prepareStake: /* @__PURE__ */ __name((config) => helper.prepareStake(withDefaultCommitment(config, getFallback)), "prepareStake"),
-    prepareUnstake: /* @__PURE__ */ __name((config) => helper.prepareUnstake(withDefaultCommitment(config, getFallback)), "prepareUnstake"),
-    prepareWithdraw: /* @__PURE__ */ __name((config) => helper.prepareWithdraw(withDefaultCommitment(config, getFallback)), "prepareWithdraw"),
-    sendPreparedStake: helper.sendPreparedStake,
-    sendPreparedUnstake: helper.sendPreparedUnstake,
-    sendPreparedWithdraw: helper.sendPreparedWithdraw,
-    sendStake: /* @__PURE__ */ __name((config, options) => helper.sendStake(withDefaultCommitment(config, getFallback), options), "sendStake"),
-    sendUnstake: /* @__PURE__ */ __name((config, options) => helper.sendUnstake(withDefaultCommitment(config, getFallback), options), "sendUnstake"),
-    sendWithdraw: /* @__PURE__ */ __name((config, options) => helper.sendWithdraw(withDefaultCommitment(config, getFallback), options), "sendWithdraw")
-  };
-}
-__name(wrapStakeHelper, "wrapStakeHelper");
-function normaliseConfigValue(value) {
-  if (value === null || value === void 0) {
-    return void 0;
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  if (typeof value === "object" && "toString" in value) {
-    return String(value.toString());
-  }
-  return JSON.stringify(value);
-}
-__name(normaliseConfigValue, "normaliseConfigValue");
-function serialiseSplConfig(config) {
-  return JSON.stringify({
-    associatedTokenProgram: normaliseConfigValue(config.associatedTokenProgram),
-    commitment: normaliseConfigValue(config.commitment),
-    decimals: config.decimals,
-    mint: normaliseConfigValue(config.mint),
-    tokenProgram: normaliseConfigValue(config.tokenProgram)
-  });
-}
-__name(serialiseSplConfig, "serialiseSplConfig");
-function createClientHelpers(runtime, store) {
-  const getFallbackCommitment = /* @__PURE__ */ __name(() => store.getState().cluster.commitment, "getFallbackCommitment");
-  const splTokenCache = /* @__PURE__ */ new Map();
-  let solTransfer;
-  let stake;
-  let transaction;
-  const getSolTransfer = /* @__PURE__ */ __name(() => {
-    if (!solTransfer) {
-      solTransfer = wrapSolTransferHelper(createSolTransferHelper(runtime), getFallbackCommitment);
-    }
-    return solTransfer;
-  }, "getSolTransfer");
-  const getStake = /* @__PURE__ */ __name(() => {
-    if (!stake) {
-      stake = wrapStakeHelper(createStakeHelper(runtime), getFallbackCommitment);
-    }
-    return stake;
-  }, "getStake");
-  const getTransaction = /* @__PURE__ */ __name(() => {
-    if (!transaction) {
-      transaction = createTransactionHelper(runtime, getFallbackCommitment);
-    }
-    return transaction;
-  }, "getTransaction");
-  function getSplTokenHelper(config) {
-    const cacheKey = serialiseSplConfig(config);
-    const cached = splTokenCache.get(cacheKey);
-    if (cached) {
-      return cached.scoped;
-    }
-    const helper = createSplTokenHelper(runtime, config);
-    const scoped = wrapSplTokenHelper(helper, getFallbackCommitment, config.commitment);
-    splTokenCache.set(cacheKey, {
-      baseCommitment: config.commitment,
-      scoped
-    });
-    return scoped;
-  }
-  __name(getSplTokenHelper, "getSplTokenHelper");
-  const prepareTransactionWithRuntime = /* @__PURE__ */ __name((options) => prepareTransaction({
-    ...options,
-    rpc: runtime.rpc
-  }), "prepareTransactionWithRuntime");
-  return Object.freeze({
-    get solTransfer() {
-      return getSolTransfer();
-    },
-    splToken: getSplTokenHelper,
-    get stake() {
-      return getStake();
-    },
-    get transaction() {
-      return getTransaction();
-    },
-    prepareTransaction: prepareTransactionWithRuntime
-  });
-}
-__name(createClientHelpers, "createClientHelpers");
-function createClusterStatus() {
-  return { status: "idle" };
-}
-__name(createClusterStatus, "createClusterStatus");
-function createInitialClientState(config) {
-  const { commitment, endpoint, websocketEndpoint } = config;
-  const timestamp = Date.now();
-  return deepFreeze({
-    accounts: {},
-    cluster: {
-      commitment,
-      endpoint,
-      status: createClusterStatus(),
-      websocketEndpoint
-    },
-    lastUpdatedAt: timestamp,
-    subscriptions: {
-      account: {},
-      signature: {}
-    },
-    transactions: {},
-    wallet: { status: "disconnected" }
-  });
-}
-__name(createInitialClientState, "createInitialClientState");
-function createClientStore(initialState) {
-  return vanilla.createStore(() => initialState);
-}
-__name(createClientStore, "createClientStore");
-function createDefaultClientStore(config) {
-  return createClientStore(createInitialClientState(config));
-}
-__name(createDefaultClientStore, "createDefaultClientStore");
-
-// src/client/watchers.ts
-function createWatchers({ logger: inputLogger, runtime, store }) {
-  const logger = inputLogger ?? createLogger();
-  function setSubscriptionStatus(kind, id, status) {
-    store.setState((state) => ({
-      ...state,
-      lastUpdatedAt: now(),
-      subscriptions: {
-        ...state.subscriptions,
-        [kind]: {
-          ...state.subscriptions[kind],
-          [id]: status
-        }
-      }
-    }));
-  }
-  __name(setSubscriptionStatus, "setSubscriptionStatus");
-  function onAbort(kind, id) {
-    setSubscriptionStatus(kind, id, { status: "inactive" });
-  }
-  __name(onAbort, "onAbort");
-  function createSubscriptionHandle(kind, id, abortController) {
-    function abort() {
-      abortController.abort();
-      onAbort(kind, id);
-    }
-    __name(abort, "abort");
-    return { abort };
-  }
-  __name(createSubscriptionHandle, "createSubscriptionHandle");
-  async function handleAccountNotifications(config, listener, abortController) {
-    const commitment = config.commitment ?? store.getState().cluster.commitment;
-    const plan = runtime.rpcSubscriptions.accountNotifications(config.address, { commitment });
-    const key = config.address.toString();
-    setSubscriptionStatus("account", key, { status: "activating" });
-    abortController.signal.addEventListener("abort", () => onAbort("account", key));
-    try {
-      const iterator = await plan.subscribe({ abortSignal: abortController.signal });
-      setSubscriptionStatus("account", key, { status: "active" });
-      for await (const notification of iterator) {
-        const lamports2 = notification.value?.lamports ?? null;
-        const slot = notification.context?.slot ?? null;
-        const entry = {
-          address: config.address,
-          data: notification.value?.data,
-          error: void 0,
-          fetching: false,
-          lamports: lamports2,
-          lastFetchedAt: now(),
-          slot
-        };
-        listener(entry);
-        store.setState((state) => ({
-          ...state,
-          accounts: {
-            ...state.accounts,
-            [key]: entry
-          },
-          lastUpdatedAt: now()
-        }));
-      }
-    } catch (error) {
-      if (!abortController.signal.aborted) {
-        logger({
-          data: { address: key, ...formatError(error) },
-          level: "error",
-          message: "account subscription failed"
-        });
-        setSubscriptionStatus("account", key, { error, status: "error" });
-      }
-    }
-  }
-  __name(handleAccountNotifications, "handleAccountNotifications");
-  function watchAccount(config, listener) {
-    const abortController = new AbortController();
-    handleAccountNotifications(config, listener, abortController).catch((error) => {
-      if (!abortController.signal.aborted) {
-        logger({
-          data: { address: config.address.toString(), ...formatError(error) },
-          level: "error",
-          message: "account watcher error"
-        });
-      }
-    });
-    return createSubscriptionHandle("account", config.address.toString(), abortController);
-  }
-  __name(watchAccount, "watchAccount");
-  function watchBalance(config, listener) {
-    return watchAccount(config, (account) => {
-      if (account.lamports !== null) {
-        listener(account.lamports);
-      }
-    });
-  }
-  __name(watchBalance, "watchBalance");
-  async function handleSignatureNotifications(config, listener, abortController) {
-    const commitment = config.commitment ?? store.getState().cluster.commitment;
-    const plan = runtime.rpcSubscriptions.signatureNotifications(config.signature, {
-      commitment,
-      enableReceivedNotification: config.enableReceivedNotification
-    });
-    const key = config.signature.toString();
-    setSubscriptionStatus("signature", key, { status: "activating" });
-    abortController.signal.addEventListener("abort", () => onAbort("signature", key));
-    try {
-      const iterator = await plan.subscribe({ abortSignal: abortController.signal });
-      setSubscriptionStatus("signature", key, { status: "active" });
-      for await (const notification of iterator) {
-        listener(notification);
-        store.setState((state) => ({
-          ...state,
-          lastUpdatedAt: now(),
-          transactions: {
-            ...state.transactions,
-            [key]: {
-              lastUpdatedAt: now(),
-              signature: config.signature,
-              status: "waiting"
-            }
-          }
-        }));
-      }
-    } catch (error) {
-      if (!abortController.signal.aborted) {
-        logger({
-          data: { signature: key, ...formatError(error) },
-          level: "error",
-          message: "signature subscription failed"
-        });
-        setSubscriptionStatus("signature", key, { error, status: "error" });
-      }
-    }
-  }
-  __name(handleSignatureNotifications, "handleSignatureNotifications");
-  function watchSignature(config, listener) {
-    const abortController = new AbortController();
-    handleSignatureNotifications(config, listener, abortController).catch((error) => {
-      if (!abortController.signal.aborted) {
-        logger({
-          data: { signature: config.signature.toString(), ...formatError(error) },
-          level: "error",
-          message: "signature watcher error"
-        });
-      }
-    });
-    return createSubscriptionHandle("signature", config.signature.toString(), abortController);
-  }
-  __name(watchSignature, "watchSignature");
-  return {
-    watchAccount,
-    watchBalance,
-    watchSignature
-  };
-}
-__name(createWatchers, "createWatchers");
-
-// src/client/createClient.ts
-function createClient(config) {
-  const hydratedConfig = config.initialState ? applySerializableState(config, config.initialState) : config;
-  const resolvedCluster = resolveCluster({
-    endpoint: hydratedConfig.rpc ?? hydratedConfig.endpoint,
-    moniker: hydratedConfig.cluster,
-    websocketEndpoint: hydratedConfig.websocket ?? hydratedConfig.websocketEndpoint
-  });
-  const commitment = hydratedConfig.commitment ?? "confirmed";
-  const initialState = createInitialClientState({
-    commitment,
-    endpoint: resolvedCluster.endpoint,
-    websocketEndpoint: resolvedCluster.websocketEndpoint
-  });
-  const store = config.createStore ? config.createStore(initialState) : createClientStore(initialState);
-  const rpcClient = hydratedConfig.rpcClient ?? createSolanaRpcClient({
-    commitment,
-    endpoint: resolvedCluster.endpoint,
-    websocketEndpoint: resolvedCluster.websocketEndpoint
-  });
-  const runtime = {
-    rpc: rpcClient.rpc,
-    rpcSubscriptions: rpcClient.rpcSubscriptions
-  };
-  const connectors = createWalletRegistry(hydratedConfig.walletConnectors ?? []);
-  const logger = createLogger(hydratedConfig.logger);
-  const actions = createActions({ connectors, logger, runtime, store });
-  const watchers = createWatchers({ logger, runtime, store });
-  const helpers = createClientHelpers(runtime, store);
-  store.setState((state) => ({
-    ...state,
-    cluster: {
-      ...state.cluster,
-      status: { status: "connecting" }
-    },
-    lastUpdatedAt: now()
-  }));
-  actions.setCluster(resolvedCluster.endpoint, {
-    commitment,
-    websocketEndpoint: resolvedCluster.websocketEndpoint
-  }).catch(
-    (error) => logger({
-      data: formatError(error),
-      level: "error",
-      message: "initial cluster setup failed"
-    })
-  );
-  function destroy() {
-    store.setState(() => initialState);
-  }
-  __name(destroy, "destroy");
-  return {
-    actions,
-    config,
-    connectors,
-    destroy,
-    get helpers() {
-      return helpers;
-    },
-    runtime,
-    store,
-    get solTransfer() {
-      return helpers.solTransfer;
-    },
-    get SolTransfer() {
-      return helpers.solTransfer;
-    },
-    splToken: helpers.splToken,
-    SplToken: helpers.splToken,
-    SplHelper: helpers.splToken,
-    get stake() {
-      return helpers.stake;
-    },
-    get transaction() {
-      return helpers.transaction;
-    },
-    prepareTransaction: helpers.prepareTransaction,
-    watchers
-  };
-}
-__name(createClient, "createClient");
-var base58Decoder = codecsStrings.getBase58Decoder();
-var transactionDecoder = transactions.getTransactionDecoder();
-var transactionEncoder = transactions.getTransactionEncoder();
-function deriveConnectorId(wallet) {
-  const kebab = wallet.name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-  return `wallet-standard:${kebab}`;
-}
-__name(deriveConnectorId, "deriveConnectorId");
-function getPrimaryAccount(accounts) {
-  const primary = accounts[0];
-  if (!primary) {
-    throw new Error("Wallet returned no accounts.");
-  }
-  return primary;
-}
-__name(getPrimaryAccount, "getPrimaryAccount");
-function mapCommitment(commitment) {
-  if (commitment === "processed" || commitment === "confirmed" || commitment === "finalized") {
-    return commitment;
-  }
-  return void 0;
-}
-__name(mapCommitment, "mapCommitment");
-function toSessionAccount(walletAccount) {
-  return {
-    address: kit.address(walletAccount.address),
-    label: walletAccount.label,
-    publicKey: new Uint8Array(walletAccount.publicKey)
-  };
-}
-__name(toSessionAccount, "toSessionAccount");
-function getChain(account) {
-  const [preferred] = account.chains ?? [];
-  return preferred;
-}
-__name(getChain, "getChain");
-async function disconnectWallet2(wallet) {
-  const disconnectFeature = wallet.features[features.StandardDisconnect];
-  if (disconnectFeature) {
-    await disconnectFeature.disconnect();
-  }
-}
-__name(disconnectWallet2, "disconnectWallet");
-function createWalletStandardConnector(wallet, options = {}) {
-  const metadata = {
-    canAutoConnect: options.canAutoConnect ?? Boolean(wallet.features[features.StandardConnect]),
-    icon: options.icon ?? wallet.icon,
-    id: options.id ?? deriveConnectorId(wallet),
-    kind: options.kind ?? "wallet-standard",
-    name: options.name ?? wallet.name,
-    ready: typeof window !== "undefined"
-  };
-  async function connect(connectionOptions = {}) {
-    const connectFeature = wallet.features[features.StandardConnect];
-    const eventsFeature = wallet.features[features.StandardEvents];
-    const shouldConnectSilently = Boolean(connectionOptions.autoConnect);
-    const allowInteractiveFallback = connectionOptions.allowInteractiveFallback ?? true;
-    let walletAccounts = wallet.accounts;
-    if (connectFeature) {
-      const connectWithMode = /* @__PURE__ */ __name(async (silent) => connectFeature.connect({
-        silent
-      }), "connectWithMode");
-      try {
-        const { accounts } = await connectWithMode(shouldConnectSilently);
-        if (accounts.length) {
-          walletAccounts = accounts;
-        }
-      } catch (error) {
-        if (!shouldConnectSilently || !allowInteractiveFallback) {
-          throw error;
-        }
-        const { accounts } = await connectWithMode(false);
-        if (accounts.length) {
-          walletAccounts = accounts;
-        }
-      }
-    }
-    let currentAccount = getPrimaryAccount(walletAccounts);
-    let sessionAccount = toSessionAccount(currentAccount);
-    const signMessageFeature = wallet.features[walletStandardFeatures.SolanaSignMessage];
-    const signTransactionFeature = wallet.features[walletStandardFeatures.SolanaSignTransaction];
-    const signAndSendFeature = wallet.features[walletStandardFeatures.SolanaSignAndSendTransaction];
-    const resolvedChain = options.defaultChain ?? getChain(currentAccount);
-    const signMessage = signMessageFeature ? async (message) => {
-      const [output] = await signMessageFeature.signMessage({
-        account: currentAccount,
-        message
-      });
-      return output.signature;
-    } : void 0;
-    const signTransaction = signTransactionFeature ? async (transaction) => {
-      const wireBytes = new Uint8Array(transactionEncoder.encode(transaction));
-      const request = resolvedChain ? {
-        account: currentAccount,
-        chain: resolvedChain,
-        transaction: wireBytes
-      } : {
-        account: currentAccount,
-        transaction: wireBytes
-      };
-      const [output] = await signTransactionFeature.signTransaction(request);
-      return transactionDecoder.decode(output.signedTransaction);
-    } : void 0;
-    const sendTransaction2 = signAndSendFeature ? async (transaction, config) => {
-      const wireBytes = new Uint8Array(transactionEncoder.encode(transaction));
-      const chain = options.defaultChain ?? getChain(currentAccount) ?? "solana:mainnet-beta";
-      const [output] = await signAndSendFeature.signAndSendTransaction({
-        account: currentAccount,
-        chain,
-        options: {
-          commitment: mapCommitment(config?.commitment)
-        },
-        transaction: wireBytes
-      });
-      return base58Decoder.decode(output.signature);
-    } : void 0;
-    async function disconnectSession() {
-      changeUnsubscribe?.();
-      await disconnectWallet2(wallet);
-    }
-    __name(disconnectSession, "disconnectSession");
-    let changeUnsubscribe;
-    const onAccountsChanged = eventsFeature ? (listener) => {
-      const off = eventsFeature.on("change", ({ accounts }) => {
-        if (!accounts) return;
-        if (!accounts.length) {
-          listener([]);
-          return;
-        }
-        currentAccount = accounts[0];
-        sessionAccount = toSessionAccount(currentAccount);
-        listener(accounts.map(toSessionAccount));
-      });
-      return off;
-    } : void 0;
-    return {
-      account: sessionAccount,
-      connector: metadata,
-      disconnect: disconnectSession,
-      onAccountsChanged: onAccountsChanged ? (listener) => {
-        changeUnsubscribe = onAccountsChanged(listener);
-        return () => {
-          changeUnsubscribe?.();
-          changeUnsubscribe = void 0;
-        };
-      } : void 0,
-      sendTransaction: sendTransaction2,
-      signMessage,
-      signTransaction
-    };
-  }
-  __name(connect, "connect");
-  async function disconnect() {
-    await disconnectWallet2(wallet);
-  }
-  __name(disconnect, "disconnect");
-  function isSupported() {
-    return typeof window !== "undefined";
-  }
-  __name(isSupported, "isSupported");
-  return {
-    ...metadata,
-    connect,
-    disconnect,
-    isSupported
-  };
-}
-__name(createWalletStandardConnector, "createWalletStandardConnector");
-function mapWalletToConnector(wallet, overrides) {
-  return createWalletStandardConnector(wallet, overrides?.(wallet));
-}
-__name(mapWalletToConnector, "mapWalletToConnector");
-function getWalletStandardConnectors(options = {}) {
-  const { get } = app.getWallets();
-  const connectors = get().map((wallet) => mapWalletToConnector(wallet, options.overrides));
-  const seen = /* @__PURE__ */ new Set();
-  return connectors.filter((connector) => {
-    if (seen.has(connector.id)) {
-      return false;
-    }
-    seen.add(connector.id);
-    return true;
-  });
-}
-__name(getWalletStandardConnectors, "getWalletStandardConnectors");
-function watchWalletStandardConnectors(onChange, options = {}) {
-  const { get, on } = app.getWallets();
-  const emit = /* @__PURE__ */ __name(() => {
-    const connectors = get().map((wallet) => mapWalletToConnector(wallet, options.overrides));
-    const seen = /* @__PURE__ */ new Set();
-    const deduplicated = connectors.filter((connector) => {
-      if (seen.has(connector.id)) {
-        return false;
-      }
-      seen.add(connector.id);
-      return true;
-    });
-    onChange(deduplicated);
-  }, "emit");
-  emit();
-  const offRegister = on("register", emit);
-  const offUnregister = on("unregister", emit);
-  return () => {
-    offRegister();
-    offUnregister();
-  };
-}
-__name(watchWalletStandardConnectors, "watchWalletStandardConnectors");
-
-// src/wallet/connectors.ts
-function autoDiscover(options = {}) {
-  const { get } = app.getWallets();
-  const wallets = get().filter((wallet) => options.filter ? options.filter(wallet) : true);
-  const connectors = wallets.map((wallet) => createWalletStandardConnector(wallet, options.overrides?.(wallet)));
-  const seen = /* @__PURE__ */ new Set();
-  return connectors.filter((connector) => {
-    if (seen.has(connector.id)) return false;
-    seen.add(connector.id);
-    return true;
-  });
-}
-__name(autoDiscover, "autoDiscover");
-function injected(options) {
-  const connector = {
-    canAutoConnect: true,
-    id: "wallet-standard:injected",
-    kind: "wallet-standard",
-    name: "Injected Wallet",
-    ready: typeof window !== "undefined",
-    async connect() {
-      const wallets = app.getWallets().get();
-      const first = wallets.find((wallet) => features.StandardConnect in wallet.features);
-      if (!first) {
-        throw new Error("No Wallet Standard wallets available.");
-      }
-      return createWalletStandardConnector(first, options).connect();
-    },
-    async disconnect() {
-    },
-    isSupported() {
-      return typeof window !== "undefined";
-    }
-  };
-  return connector;
-}
-__name(injected, "injected");
-function filterByName(name) {
-  const lower = name.toLowerCase();
-  return (wallet) => wallet.name.toLowerCase().includes(lower);
-}
-__name(filterByName, "filterByName");
-function phantom(options) {
-  return autoDiscover({
-    filter: filterByName("phantom"),
-    overrides: /* @__PURE__ */ __name(() => ({ ...options, id: "wallet-standard:phantom" }), "overrides")
-  });
-}
-__name(phantom, "phantom");
-function solflare(options) {
-  return autoDiscover({
-    filter: filterByName("solflare"),
-    overrides: /* @__PURE__ */ __name(() => ({ ...options, id: "wallet-standard:solflare" }), "overrides")
-  });
-}
-__name(solflare, "solflare");
-function backpack(options) {
-  return autoDiscover({
-    filter: filterByName("backpack"),
-    overrides: /* @__PURE__ */ __name(() => ({ ...options, id: "wallet-standard:backpack" }), "overrides")
-  });
-}
-__name(backpack, "backpack");
-
-// src/client/defaultClient.ts
-function defaultWalletConnectors() {
-  return [...phantom(), ...solflare(), ...backpack(), ...autoDiscover()];
-}
-__name(defaultWalletConnectors, "defaultWalletConnectors");
-function normalizeUrl(value) {
-  if (!value) return void 0;
-  const trimmed = value.trim();
-  return trimmed.length ? trimmed : void 0;
-}
-__name(normalizeUrl, "normalizeUrl");
-function resolveClientConfig(config = {}) {
-  const {
-    cluster,
-    endpoint: endpointOverride,
-    rpc,
-    websocket,
-    websocketEndpoint,
-    walletConnectors,
-    ...passthrough
-  } = config;
-  const resolvedEndpoint = normalizeUrl(rpc) ?? normalizeUrl(endpointOverride) ?? normalizeUrl(config.endpoint);
-  const resolvedCluster = resolveCluster({
-    endpoint: resolvedEndpoint,
-    moniker: cluster ?? void 0,
-    websocketEndpoint: normalizeUrl(websocket ?? websocketEndpoint)
-  });
-  const resolvedConnectors = walletConnectors === void 0 || walletConnectors === "default" ? defaultWalletConnectors() : walletConnectors;
-  return {
-    ...passthrough,
-    endpoint: resolvedCluster.endpoint,
-    websocketEndpoint: resolvedCluster.websocketEndpoint,
-    walletConnectors: resolvedConnectors
-  };
-}
-__name(resolveClientConfig, "resolveClientConfig");
-function createDefaultClient(config = {}) {
-  return createClient(resolveClientConfig(config));
-}
-__name(createDefaultClient, "createDefaultClient");
-
-// src/state/asyncState.ts
-function createInitialAsyncState() {
-  return { status: "idle" };
-}
-__name(createInitialAsyncState, "createInitialAsyncState");
-function createAsyncState(status, payload = {}) {
-  return {
-    data: payload.data,
-    error: payload.error,
-    status
-  };
-}
-__name(createAsyncState, "createAsyncState");
-
-// src/controllers/solTransferController.ts
-function ensureAuthority(input, resolveDefault) {
-  const authority = input.authority ?? resolveDefault?.();
-  if (!authority) {
-    throw new Error("Connect a wallet or supply an `authority` before sending SOL transfers.");
-  }
-  return {
-    ...input,
-    authority
-  };
-}
-__name(ensureAuthority, "ensureAuthority");
-function createSolTransferController(config) {
-  const listeners = /* @__PURE__ */ new Set();
-  const helper = config.helper;
-  const authorityProvider = config.authorityProvider;
-  let state = createInitialAsyncState();
-  function notify() {
-    for (const listener of listeners) {
-      listener();
-    }
-  }
-  __name(notify, "notify");
-  function setState(next) {
-    state = next;
-    notify();
-  }
-  __name(setState, "setState");
-  async function send(config2, options) {
-    const request = ensureAuthority(config2, authorityProvider);
-    setState(createAsyncState("loading"));
-    try {
-      const signature5 = await helper.sendTransfer(request, options);
-      setState(createAsyncState("success", { data: signature5 }));
-      return signature5;
-    } catch (error) {
-      setState(createAsyncState("error", { error }));
-      throw error;
-    }
-  }
-  __name(send, "send");
-  function subscribe(listener) {
-    listeners.add(listener);
-    return () => {
-      listeners.delete(listener);
-    };
-  }
-  __name(subscribe, "subscribe");
-  function reset() {
-    setState(createInitialAsyncState());
-  }
-  __name(reset, "reset");
-  return {
-    getHelper: /* @__PURE__ */ __name(() => helper, "getHelper"),
-    getState: /* @__PURE__ */ __name(() => state, "getState"),
-    reset,
-    send,
-    subscribe
-  };
-}
-__name(createSolTransferController, "createSolTransferController");
-
-// src/controllers/splTransferController.ts
-function ensureTransferConfig(input, resolveAuthority, resolveSourceOwner) {
-  const authority = input.authority ?? resolveAuthority?.();
-  if (!authority) {
-    throw new Error("Connect a wallet or supply an `authority` before sending SPL tokens.");
-  }
-  const sourceOwner = input.sourceOwner ?? resolveSourceOwner?.();
-  if (!sourceOwner) {
-    throw new Error("Unable to resolve a source owner for the SPL token transfer.");
-  }
-  return {
-    ...input,
-    authority,
-    sourceOwner
-  };
-}
-__name(ensureTransferConfig, "ensureTransferConfig");
-function createSplTransferController(config) {
-  const helper = config.helper;
-  const authorityProvider = config.authorityProvider;
-  const sourceOwnerProvider = config.sourceOwnerProvider;
-  const listeners = /* @__PURE__ */ new Set();
-  let state = createInitialAsyncState();
-  function notify() {
-    for (const listener of listeners) {
-      listener();
-    }
-  }
-  __name(notify, "notify");
-  function setState(next) {
-    state = next;
-    notify();
-  }
-  __name(setState, "setState");
-  async function send(config2, options) {
-    const resolvedConfig = ensureTransferConfig(
-      config2,
-      config2.authority ? void 0 : authorityProvider,
-      config2.sourceOwner ? void 0 : sourceOwnerProvider
-    );
-    setState(createAsyncState("loading"));
-    try {
-      const signature5 = await helper.sendTransfer(resolvedConfig, options);
-      setState(createAsyncState("success", { data: signature5 }));
-      return signature5;
-    } catch (error) {
-      setState(createAsyncState("error", { error }));
-      throw error;
-    }
-  }
-  __name(send, "send");
-  function subscribe(listener) {
-    listeners.add(listener);
-    return () => {
-      listeners.delete(listener);
-    };
-  }
-  __name(subscribe, "subscribe");
-  function reset() {
-    setState(createInitialAsyncState());
-  }
-  __name(reset, "reset");
-  return {
-    getHelper: /* @__PURE__ */ __name(() => helper, "getHelper"),
-    getState: /* @__PURE__ */ __name(() => state, "getState"),
-    reset,
-    send,
-    subscribe
-  };
-}
-__name(createSplTransferController, "createSplTransferController");
-
-// src/controllers/stakeController.ts
-function ensureAuthority2(input, resolveDefault) {
-  const authority = input.authority ?? resolveDefault?.();
-  if (!authority) {
-    throw new Error("Connect a wallet or supply an `authority` before staking SOL.");
-  }
-  return {
-    ...input,
-    authority
-  };
-}
-__name(ensureAuthority2, "ensureAuthority");
-function ensureUnstakeAuthority(input, resolveDefault) {
-  const authority = input.authority ?? resolveDefault?.();
-  if (!authority) {
-    throw new Error("Connect a wallet or supply an `authority` before unstaking SOL.");
-  }
-  return {
-    ...input,
-    authority
-  };
-}
-__name(ensureUnstakeAuthority, "ensureUnstakeAuthority");
-function ensureWithdrawAuthority(input, resolveDefault) {
-  const authority = input.authority ?? resolveDefault?.();
-  if (!authority) {
-    throw new Error("Connect a wallet or supply an `authority` before withdrawing SOL.");
-  }
-  return {
-    ...input,
-    authority
-  };
-}
-__name(ensureWithdrawAuthority, "ensureWithdrawAuthority");
-function createStakeController(config) {
-  const listeners = /* @__PURE__ */ new Set();
-  const unstakeListeners = /* @__PURE__ */ new Set();
-  const withdrawListeners = /* @__PURE__ */ new Set();
-  const helper = config.helper;
-  const authorityProvider = config.authorityProvider;
-  let state = createInitialAsyncState();
-  let unstakeState = createInitialAsyncState();
-  let withdrawState = createInitialAsyncState();
-  function notify() {
-    for (const listener of listeners) {
-      listener();
-    }
-  }
-  __name(notify, "notify");
-  function notifyUnstake() {
-    for (const listener of unstakeListeners) {
-      listener();
-    }
-  }
-  __name(notifyUnstake, "notifyUnstake");
-  function notifyWithdraw() {
-    for (const listener of withdrawListeners) {
-      listener();
-    }
-  }
-  __name(notifyWithdraw, "notifyWithdraw");
-  function setState(next) {
-    state = next;
-    notify();
-  }
-  __name(setState, "setState");
-  function setUnstakeState(next) {
-    unstakeState = next;
-    notifyUnstake();
-  }
-  __name(setUnstakeState, "setUnstakeState");
-  function setWithdrawState(next) {
-    withdrawState = next;
-    notifyWithdraw();
-  }
-  __name(setWithdrawState, "setWithdrawState");
-  async function stake(config2, options) {
-    const request = ensureAuthority2(config2, authorityProvider);
-    setState(createAsyncState("loading"));
-    try {
-      const signature5 = await helper.sendStake(request, options);
-      setState(createAsyncState("success", { data: signature5 }));
-      return signature5;
-    } catch (error) {
-      setState(createAsyncState("error", { error }));
-      throw error;
-    }
-  }
-  __name(stake, "stake");
-  async function unstake(config2, options) {
-    const request = ensureUnstakeAuthority(config2, authorityProvider);
-    setUnstakeState(createAsyncState("loading"));
-    try {
-      const signature5 = await helper.sendUnstake(request, options);
-      setUnstakeState(createAsyncState("success", { data: signature5 }));
-      return signature5;
-    } catch (error) {
-      setUnstakeState(createAsyncState("error", { error }));
-      throw error;
-    }
-  }
-  __name(unstake, "unstake");
-  async function withdraw(config2, options) {
-    const request = ensureWithdrawAuthority(config2, authorityProvider);
-    setWithdrawState(createAsyncState("loading"));
-    try {
-      const signature5 = await helper.sendWithdraw(request, options);
-      setWithdrawState(createAsyncState("success", { data: signature5 }));
-      return signature5;
-    } catch (error) {
-      setWithdrawState(createAsyncState("error", { error }));
-      throw error;
-    }
-  }
-  __name(withdraw, "withdraw");
-  function subscribe(listener) {
-    listeners.add(listener);
-    return () => {
-      listeners.delete(listener);
-    };
-  }
-  __name(subscribe, "subscribe");
-  function subscribeUnstake(listener) {
-    unstakeListeners.add(listener);
-    return () => {
-      unstakeListeners.delete(listener);
-    };
-  }
-  __name(subscribeUnstake, "subscribeUnstake");
-  function subscribeWithdraw(listener) {
-    withdrawListeners.add(listener);
-    return () => {
-      withdrawListeners.delete(listener);
-    };
-  }
-  __name(subscribeWithdraw, "subscribeWithdraw");
-  function reset() {
-    setState(createInitialAsyncState());
-  }
-  __name(reset, "reset");
-  function resetUnstake() {
-    setUnstakeState(createInitialAsyncState());
-  }
-  __name(resetUnstake, "resetUnstake");
-  function resetWithdraw() {
-    setWithdrawState(createInitialAsyncState());
-  }
-  __name(resetWithdraw, "resetWithdraw");
-  return {
-    getHelper: /* @__PURE__ */ __name(() => helper, "getHelper"),
-    getState: /* @__PURE__ */ __name(() => state, "getState"),
-    getUnstakeState: /* @__PURE__ */ __name(() => unstakeState, "getUnstakeState"),
-    getWithdrawState: /* @__PURE__ */ __name(() => withdrawState, "getWithdrawState"),
-    reset,
-    resetUnstake,
-    resetWithdraw,
-    stake,
-    unstake,
-    withdraw,
-    subscribe,
-    subscribeUnstake,
-    subscribeWithdraw
-  };
-}
-__name(createStakeController, "createStakeController");
-
-// src/serialization/json.ts
-function bigintToJson(value) {
-  return value.toString();
-}
-__name(bigintToJson, "bigintToJson");
-function bigintFromJson(value) {
-  return toBigint2(value, "bigint");
-}
-__name(bigintFromJson, "bigintFromJson");
-function lamportsToJson(value) {
-  return value.toString();
-}
-__name(lamportsToJson, "lamportsToJson");
-function lamportsFromJson(value) {
-  return lamports(value, "lamports");
-}
-__name(lamportsFromJson, "lamportsFromJson");
-var COMMITMENT_PRIORITY = {
-  processed: 0,
-  confirmed: 1,
-  finalized: 2
-};
-var SIGNATURE_STATUS_TIMEOUT_MS = 2e4;
-function normalizeSignature(input) {
-  if (!input) {
-    return void 0;
-  }
-  return typeof input === "string" ? kit.signature(input) : input;
-}
-__name(normalizeSignature, "normalizeSignature");
-function deriveConfirmationStatus(status) {
-  if (!status) {
-    return null;
-  }
-  if (status.confirmationStatus === "processed" || status.confirmationStatus === "confirmed" || status.confirmationStatus === "finalized") {
-    return status.confirmationStatus;
-  }
-  if (status.confirmations === null) {
-    return "finalized";
-  }
-  if (typeof status.confirmations === "number" && status.confirmations > 0) {
-    return "confirmed";
-  }
-  return "processed";
-}
-__name(deriveConfirmationStatus, "deriveConfirmationStatus");
-function confirmationMeetsCommitment(confirmation, target) {
-  if (!confirmation) {
-    return false;
-  }
-  return COMMITMENT_PRIORITY[confirmation] >= COMMITMENT_PRIORITY[target];
-}
-__name(confirmationMeetsCommitment, "confirmationMeetsCommitment");
-var MEMO_PROGRAM_ADDRESS = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
-function ensureNonMemoInstructionIndex(instructions) {
-  const index = instructions.findIndex((instruction) => instruction.programAddress !== MEMO_PROGRAM_ADDRESS);
-  if (instructions.length === 0 || index === -1) {
-    throw new kit.SolanaError(kit.SOLANA_ERROR__INSTRUCTION_ERROR__GENERIC_ERROR, {
-      cause: "At least one non-memo instruction is required.",
-      index: instructions.length || index
-    });
-  }
-  return index;
-}
-__name(ensureNonMemoInstructionIndex, "ensureNonMemoInstructionIndex");
-function insertReferenceKey(reference, transaction) {
-  return insertReferenceKeys([reference], transaction);
-}
-__name(insertReferenceKey, "insertReferenceKey");
-function insertReferenceKeys(references, transaction) {
-  const index = ensureNonMemoInstructionIndex(transaction.instructions);
-  const targetInstruction = transaction.instructions[index];
-  const accounts = [
-    ...targetInstruction.accounts ?? [],
-    ...references.map((address5) => ({ address: address5, role: kit.AccountRole.READONLY }))
-  ];
-  const updatedInstructions = [...transaction.instructions];
-  updatedInstructions.splice(index, 1, { ...targetInstruction, accounts });
-  return Object.freeze({
-    ...transaction,
-    instructions: Object.freeze(updatedInstructions)
-  });
-}
-__name(insertReferenceKeys, "insertReferenceKeys");
-
-// src/transactions/transactionPoolController.ts
-function createStore2(initial) {
-  let snapshot = initial;
-  const listeners = /* @__PURE__ */ new Set();
-  return {
-    getSnapshot: /* @__PURE__ */ __name(() => snapshot, "getSnapshot"),
-    setSnapshot(next) {
-      snapshot = next;
-      for (const listener of listeners) {
-        listener();
-      }
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    }
-  };
-}
-__name(createStore2, "createStore");
-function freezeInstructions(list) {
-  return Object.freeze([...list]);
-}
-__name(freezeInstructions, "freezeInstructions");
-function createTransactionPoolController(config) {
-  const helper = config.helper;
-  const initialInstructions = freezeInstructions(config.initialInstructions ?? []);
-  const blockhashMaxAgeMs = config.blockhashMaxAgeMs ?? 3e4;
-  let latestBlockhashCache;
-  const instructionsStore = createStore2(initialInstructions);
-  const preparedStore = createStore2(null);
-  const prepareStateStore = createStore2(
-    createInitialAsyncState()
-  );
-  const sendStateStore = createStore2(
-    createInitialAsyncState()
-  );
-  function resetDerivedState() {
-    preparedStore.setSnapshot(null);
-    prepareStateStore.setSnapshot(createInitialAsyncState());
-    sendStateStore.setSnapshot(createInitialAsyncState());
-  }
-  __name(resetDerivedState, "resetDerivedState");
-  function commitInstructions(next) {
-    instructionsStore.setSnapshot(freezeInstructions(next));
-    resetDerivedState();
-  }
-  __name(commitInstructions, "commitInstructions");
-  function addInstruction(instruction) {
-    const next = [...instructionsStore.getSnapshot(), instruction];
-    commitInstructions(next);
-  }
-  __name(addInstruction, "addInstruction");
-  function addInstructions(instructionSet) {
-    if (!instructionSet.length) {
-      return;
-    }
-    const next = [...instructionsStore.getSnapshot(), ...instructionSet];
-    commitInstructions(next);
-  }
-  __name(addInstructions, "addInstructions");
-  function replaceInstructions(instructionSet) {
-    commitInstructions(instructionSet);
-  }
-  __name(replaceInstructions, "replaceInstructions");
-  function clearInstructions() {
-    commitInstructions([]);
-  }
-  __name(clearInstructions, "clearInstructions");
-  function removeInstruction(index) {
-    const current = instructionsStore.getSnapshot();
-    if (index < 0 || index >= current.length) {
-      return;
-    }
-    const next = current.filter((_, ii) => ii !== index);
-    commitInstructions(next);
-  }
-  __name(removeInstruction, "removeInstruction");
-  function reset() {
-    commitInstructions(initialInstructions);
-  }
-  __name(reset, "reset");
-  function ensureInstructions(instructionList) {
-    if (!instructionList.length) {
-      throw new Error("Add at least one instruction before preparing a transaction.");
-    }
-  }
-  __name(ensureInstructions, "ensureInstructions");
-  function resolveCachedLifetime() {
-    if (!latestBlockhashCache) {
-      return void 0;
-    }
-    if (Date.now() - latestBlockhashCache.updatedAt > blockhashMaxAgeMs) {
-      return void 0;
-    }
-    return latestBlockhashCache.value;
-  }
-  __name(resolveCachedLifetime, "resolveCachedLifetime");
-  async function prepare(options = {}) {
-    const { instructions: overrideInstructions, ...rest } = options;
-    const nextInstructions = overrideInstructions ?? instructionsStore.getSnapshot();
-    ensureInstructions(nextInstructions);
-    prepareStateStore.setSnapshot(createAsyncState("loading"));
-    try {
-      const cachedLifetime = rest.lifetime ?? resolveCachedLifetime();
-      const restWithLifetime = cachedLifetime && !rest.lifetime ? { ...rest, lifetime: cachedLifetime } : rest;
-      const prepared = await helper.prepare({
-        ...restWithLifetime,
-        instructions: nextInstructions
-      });
-      preparedStore.setSnapshot(prepared);
-      prepareStateStore.setSnapshot(createAsyncState("success", { data: prepared }));
-      return prepared;
-    } catch (error) {
-      prepareStateStore.setSnapshot(createAsyncState("error", { error }));
-      throw error;
-    }
-  }
-  __name(prepare, "prepare");
-  function resolvePrepared(override) {
-    const target = override ?? preparedStore.getSnapshot();
-    if (!target) {
-      throw new Error("Prepare a transaction before sending.");
-    }
-    return target;
-  }
-  __name(resolvePrepared, "resolvePrepared");
-  function resolveLifetimeOptions(options) {
-    if (options.lifetime) {
-      return options;
-    }
-    const cachedLifetime = resolveCachedLifetime();
-    if (!cachedLifetime) {
-      return options;
-    }
-    return { ...options, lifetime: cachedLifetime };
-  }
-  __name(resolveLifetimeOptions, "resolveLifetimeOptions");
-  async function send(options = {}) {
-    const { prepared: overridePrepared, ...rest } = options;
-    const target = resolvePrepared(overridePrepared);
-    sendStateStore.setSnapshot(createAsyncState("loading"));
-    try {
-      const signature5 = await helper.send(target, rest);
-      sendStateStore.setSnapshot(createAsyncState("success", { data: signature5 }));
-      return signature5;
-    } catch (error) {
-      sendStateStore.setSnapshot(createAsyncState("error", { error }));
-      throw error;
-    }
-  }
-  __name(send, "send");
-  async function prepareAndSend(request = {}, sendOptions) {
-    const { instructions: overrideInstructions, ...rest } = request;
-    const nextInstructions = overrideInstructions ?? instructionsStore.getSnapshot();
-    ensureInstructions(nextInstructions);
-    sendStateStore.setSnapshot(createAsyncState("loading"));
-    try {
-      const restWithLifetime = resolveLifetimeOptions(rest);
-      const signature5 = await helper.prepareAndSend(
-        {
-          ...restWithLifetime,
-          instructions: nextInstructions
-        },
-        sendOptions
-      );
-      sendStateStore.setSnapshot(createAsyncState("success", { data: signature5 }));
-      return signature5;
-    } catch (error) {
-      sendStateStore.setSnapshot(createAsyncState("error", { error }));
-      throw error;
-    }
-  }
-  __name(prepareAndSend, "prepareAndSend");
-  function sign(options = {}) {
-    const { prepared: overridePrepared, ...rest } = options;
-    const target = resolvePrepared(overridePrepared);
-    return helper.sign(target, rest);
-  }
-  __name(sign, "sign");
-  function toWire(options = {}) {
-    const { prepared: overridePrepared, ...rest } = options;
-    const target = resolvePrepared(overridePrepared);
-    return helper.toWire(target, rest);
-  }
-  __name(toWire, "toWire");
-  function subscribeInstructions(listener) {
-    return instructionsStore.subscribe(listener);
-  }
-  __name(subscribeInstructions, "subscribeInstructions");
-  function subscribePrepared(listener) {
-    return preparedStore.subscribe(listener);
-  }
-  __name(subscribePrepared, "subscribePrepared");
-  function subscribePrepareState(listener) {
-    return prepareStateStore.subscribe(listener);
-  }
-  __name(subscribePrepareState, "subscribePrepareState");
-  function subscribeSendState(listener) {
-    return sendStateStore.subscribe(listener);
-  }
-  __name(subscribeSendState, "subscribeSendState");
-  function setLatestBlockhashCache(cache) {
-    latestBlockhashCache = cache;
-  }
-  __name(setLatestBlockhashCache, "setLatestBlockhashCache");
-  return {
-    addInstruction,
-    addInstructions,
-    clearInstructions,
-    get helper() {
-      return helper;
-    },
-    getInstructions: instructionsStore.getSnapshot,
-    getPrepareState: prepareStateStore.getSnapshot,
-    getPrepared: preparedStore.getSnapshot,
-    getSendState: sendStateStore.getSnapshot,
-    getLatestBlockhashCache: /* @__PURE__ */ __name(() => latestBlockhashCache, "getLatestBlockhashCache"),
-    prepare,
-    prepareAndSend,
-    removeInstruction,
-    replaceInstructions,
-    reset,
-    send,
-    setLatestBlockhashCache,
-    sign,
-    subscribeInstructions,
-    subscribePrepareState,
-    subscribePrepared,
-    subscribeSendState,
-    toWire
-  };
-}
-__name(createTransactionPoolController, "createTransactionPoolController");
-function toAddress2(addressLike) {
-  return typeof addressLike === "string" ? kit.address(addressLike) : addressLike;
-}
-__name(toAddress2, "toAddress");
-function toAddressString(addressLike) {
-  return toAddress2(addressLike).toString();
-}
-__name(toAddressString, "toAddressString");
-
-// src/utils/stableStringify.ts
-function stableStringify(value) {
-  const result = JSON.stringify(value, (_key, candidate) => {
-    if (typeof candidate === "bigint") {
-      return { __type: "bigint", value: candidate.toString() };
-    }
-    if (candidate instanceof Uint8Array) {
-      return Array.from(candidate);
-    }
-    return candidate;
-  });
-  return result ?? "undefined";
-}
-__name(stableStringify, "stableStringify");
-
-exports.LAMPORTS_PER_SOL = LAMPORTS_PER_SOL;
-exports.SIGNATURE_STATUS_TIMEOUT_MS = SIGNATURE_STATUS_TIMEOUT_MS;
-exports.applyRatio = applyRatio;
-exports.applySerializableState = applySerializableState;
-exports.assertDecimals = assertDecimals;
-exports.assertNonNegative = assertNonNegative;
-exports.autoDiscover = autoDiscover;
-exports.backpack = backpack;
-exports.bigintFromJson = bigintFromJson;
-exports.bigintToJson = bigintToJson;
-exports.checkedAdd = checkedAdd;
-exports.checkedDivide = checkedDivide;
-exports.checkedMultiply = checkedMultiply;
-exports.checkedSubtract = checkedSubtract;
-exports.confirmationMeetsCommitment = confirmationMeetsCommitment;
-exports.connectWallet = connectWallet;
-exports.createAsyncState = createAsyncState;
-exports.createClient = createClient;
-exports.createClientStore = createClientStore;
-exports.createDefaultClient = createDefaultClient;
-exports.createDefaultClientStore = createDefaultClientStore;
-exports.createInitialAsyncState = createInitialAsyncState;
-exports.createInitialClientState = createInitialClientState;
-exports.createRatio = createRatio;
-exports.createSolTransferController = createSolTransferController;
-exports.createSolTransferHelper = createSolTransferHelper;
-exports.createSolanaRpcClient = createSolanaRpcClient;
-exports.createSplTokenHelper = createSplTokenHelper;
-exports.createSplTransferController = createSplTransferController;
-exports.createStakeController = createStakeController;
-exports.createStakeHelper = createStakeHelper;
-exports.createTokenAmount = createTokenAmount;
-exports.createTransactionHelper = createTransactionHelper;
-exports.createTransactionPoolController = createTransactionPoolController;
-exports.createTransactionRecipe = createTransactionRecipe;
-exports.createWalletRegistry = createWalletRegistry;
-exports.createWalletStandardConnector = createWalletStandardConnector;
-exports.defaultWalletConnectors = defaultWalletConnectors;
-exports.deriveConfirmationStatus = deriveConfirmationStatus;
-exports.deserializeSolanaState = deserializeSolanaState;
-exports.disconnectWallet = disconnectWallet;
-exports.fetchAccount = fetchAccount;
-exports.fetchBalance = fetchBalance;
-exports.fetchLookupTable = fetchLookupTable;
-exports.fetchLookupTables = fetchLookupTables;
-exports.fetchNonceAccount = fetchNonceAccount;
-exports.getInitialSerializableState = getInitialSerializableState;
-exports.getWalletStandardConnectors = getWalletStandardConnectors;
-exports.injected = injected;
-exports.insertReferenceKey = insertReferenceKey;
-exports.insertReferenceKeys = insertReferenceKeys;
-exports.lamports = lamports;
-exports.lamportsFromJson = lamportsFromJson;
-exports.lamportsFromSol = lamportsFromSol;
-exports.lamportsMath = lamportsMath;
-exports.lamportsToJson = lamportsToJson;
-exports.lamportsToSolString = lamportsToSolString;
-exports.normalizeSignature = normalizeSignature;
-exports.phantom = phantom;
-exports.pow10 = pow10;
-exports.prepareTransaction = prepareTransaction;
-exports.requestAirdrop = requestAirdrop;
-exports.resolveClientConfig = resolveClientConfig;
-exports.resolveCluster = resolveCluster;
-exports.sendTransaction = sendTransaction;
-exports.serializeSolanaState = serializeSolanaState;
-exports.setCluster = setCluster;
-exports.solflare = solflare;
-exports.stableStringify = stableStringify;
-exports.subscribeSolanaState = subscribeSolanaState;
-exports.toAddress = toAddress2;
-exports.toAddressString = toAddressString;
-exports.toBigint = toBigint2;
-exports.transactionToBase64 = transactionToBase64;
-exports.transactionToBase64WithSigners = transactionToBase64WithSigners;
-exports.watchWalletStandardConnectors = watchWalletStandardConnectors;
-//# sourceMappingURL=index.browser.cjs.map
-//# sourceMappingURL=index.browser.cjs.map