@solana/client 0.0.0 → 0.1.0

package/dist/index.node.mjs

@@ -0,0 +1,2745 @@
+import { createSolanaRpc, createSolanaRpcSubscriptions, address, getBase64EncodedWireTransaction, compileTransaction, partiallySignTransactionMessageWithSigners, appendTransactionMessageInstruction, setTransactionMessageLifetimeUsingBlockhash, isTransactionSendingSigner, getMessagePackerInstructionPlanFromInstructions, signature, AccountRole, pipe, createTransactionMessage, setTransactionMessageFeePayer, singleTransactionPlan, signAndSendTransactionMessageWithSigners, createTransactionPlanExecutor, signTransactionMessageWithSigners, isSolanaError, SOLANA_ERROR__TRANSACTION_ERROR__ALREADY_PROCESSED, createTransactionPlanner, setTransactionMessageFeePayerSigner, isTransactionPartialSigner, SOLANA_ERROR__INSTRUCTION_ERROR__COMPUTATIONAL_BUDGET_EXCEEDED, isInstructionForProgram, isInstructionWithData, SolanaError, SOLANA_ERROR__INSTRUCTION_ERROR__GENERIC_ERROR, airdropFactory, signatureBytes } from '@solana/kit';
+import { createBlockHeightExceedencePromiseFactory, createRecentSignatureConfirmationPromiseFactory, waitForRecentTransactionConfirmation } from '@solana/transaction-confirmation';
+import { getBase58Decoder, getBase58Encoder } from '@solana/codecs-strings';
+import { getTransferSolInstruction } from '@solana-program/system';
+import { TOKEN_PROGRAM_ADDRESS, fetchMint, findAssociatedTokenPda, getCreateAssociatedTokenInstruction, getTransferCheckedInstruction } from '@solana-program/token';
+import { getSetComputeUnitLimitInstruction, getSetComputeUnitPriceInstruction, COMPUTE_BUDGET_PROGRAM_ADDRESS, ComputeBudgetInstruction } from '@solana-program/compute-budget';
+import { createStore } from 'zustand/vanilla';
+import { getTransactionDecoder, getTransactionEncoder } from '@solana/transactions';
+import { SolanaSignMessage, SolanaSignTransaction, SolanaSignAndSendTransaction } from '@solana/wallet-standard-features';
+import { getWallets } from '@wallet-standard/app';
+import { StandardConnect, StandardDisconnect } from '@wallet-standard/features';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// 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 = createSolanaRpc(endpoint, config.rpcConfig);
+  const rpcSubscriptions = createSolanaRpcSubscriptions(websocketEndpoint, config.rpcSubscriptionsConfig);
+  async function sendAndConfirmTransaction(transaction, options = {}) {
+    const abortController = createChainedAbortController(options.abortSignal);
+    const targetCommitment = options.commitment ?? commitment;
+    const wireTransaction = 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 = createBlockHeightExceedencePromiseFactory({
+      rpc,
+      rpcSubscriptions
+    });
+    const getRecentSignatureConfirmationPromise = createRecentSignatureConfirmationPromiseFactory({
+      rpc,
+      rpcSubscriptions
+    });
+    await waitForRecentTransactionConfirmation({
+      abortSignal: abortController.signal,
+      commitment: targetCommitment,
+      getBlockHeightExceedencePromise,
+      getRecentSignatureConfirmationPromise,
+      transaction
+    });
+    return response;
+  }
+  __name(sendAndConfirmTransaction, "sendAndConfirmTransaction");
+  async function simulateTransaction(transaction, options = {}) {
+    const wireTransaction = 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/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();
+  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 setCluster(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()
+      }));
+      logger({
+        data: { endpoint, latencyMs, websocketEndpoint },
+        level: "info",
+        message: "cluster ready"
+      });
+    } 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(setCluster, "setCluster");
+  async function connectWallet(connectorId, options = {}) {
+    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.`);
+    }
+    store.setState((state) => ({
+      ...state,
+      lastUpdatedAt: now(),
+      wallet: { connectorId, status: "connecting" }
+    }));
+    try {
+      const session = await connector.connect(options);
+      store.setState((state) => ({
+        ...state,
+        lastUpdatedAt: now(),
+        wallet: { connectorId, session, status: "connected" }
+      }));
+      logger({
+        data: { address: session.account.address.toString(), connectorId },
+        level: "info",
+        message: "wallet connected"
+      });
+    } catch (error) {
+      store.setState((state) => ({
+        ...state,
+        lastUpdatedAt: now(),
+        wallet: { connectorId, error, status: "error" }
+      }));
+      logger({
+        data: { connectorId, ...formatError(error) },
+        level: "error",
+        message: "wallet connection failed"
+      });
+      throw error;
+    }
+  }
+  __name(connectWallet, "connectWallet");
+  async function disconnectWallet2() {
+    const wallet = store.getState().wallet;
+    if (wallet.status === "disconnected") {
+      return;
+    }
+    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(disconnectWallet2, "disconnectWallet");
+  async function fetchBalance(address4, commitment) {
+    const key = address4.toString();
+    store.setState((state) => ({
+      ...state,
+      accounts: {
+        ...state.accounts,
+        [key]: {
+          address: address4,
+          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(address4, { commitment: getCommitment(commitment) }).send({ abortSignal: AbortSignal.timeout(1e4) });
+      const lamports2 = response.value;
+      store.setState((state) => ({
+        ...state,
+        accounts: {
+          ...state.accounts,
+          [key]: {
+            address: address4,
+            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: address4,
+            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(fetchBalance, "fetchBalance");
+  async function fetchAccount(address4, commitment) {
+    const key = address4.toString();
+    store.setState((state) => ({
+      ...state,
+      accounts: {
+        ...state.accounts,
+        [key]: {
+          address: address4,
+          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(address4, { 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: address4,
+            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: address4,
+            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(fetchAccount, "fetchAccount");
+  async function sendTransaction(transaction, commitment) {
+    const targetCommitment = getCommitment(commitment);
+    const abortController = new AbortController();
+    const signature4 = await runtime.rpc.sendTransaction(getBase64EncodedWireTransaction(transaction), {
+      encoding: "base64",
+      preflightCommitment: targetCommitment
+    }).send({ abortSignal: abortController.signal });
+    const key = signature4.toString();
+    store.setState((state) => ({
+      ...state,
+      lastUpdatedAt: now(),
+      transactions: {
+        ...state.transactions,
+        [key]: {
+          lastUpdatedAt: now(),
+          signature: signature4,
+          status: "sending"
+        }
+      }
+    }));
+    const getBlockHeightExceedencePromise = createBlockHeightExceedencePromiseFactory({
+      rpc: runtime.rpc,
+      rpcSubscriptions: runtime.rpcSubscriptions
+    });
+    const getRecentSignatureConfirmationPromise = createRecentSignatureConfirmationPromiseFactory({
+      rpc: runtime.rpc,
+      rpcSubscriptions: runtime.rpcSubscriptions
+    });
+    try {
+      await waitForRecentTransactionConfirmation({
+        abortSignal: abortController.signal,
+        commitment: targetCommitment,
+        getBlockHeightExceedencePromise,
+        getRecentSignatureConfirmationPromise,
+        transaction
+      });
+      store.setState((state) => ({
+        ...state,
+        lastUpdatedAt: now(),
+        transactions: {
+          ...state.transactions,
+          [key]: {
+            lastUpdatedAt: now(),
+            signature: signature4,
+            status: "confirmed"
+          }
+        }
+      }));
+      return signature4;
+    } catch (error) {
+      store.setState((state) => ({
+        ...state,
+        lastUpdatedAt: now(),
+        transactions: {
+          ...state.transactions,
+          [key]: {
+            error,
+            lastUpdatedAt: now(),
+            signature: signature4,
+            status: "failed"
+          }
+        }
+      }));
+      logger({
+        data: { signature: key, ...formatError(error) },
+        level: "error",
+        message: "transaction failed to confirm"
+      });
+      throw error;
+    }
+  }
+  __name(sendTransaction, "sendTransaction");
+  async function requestAirdrop(address4, lamports2) {
+    if (!("requestAirdrop" in runtime.rpc)) {
+      throw new Error("The current RPC endpoint does not support airdrops.");
+    }
+    const factory = airdropFactory({
+      rpc: runtime.rpc,
+      rpcSubscriptions: runtime.rpcSubscriptions
+    });
+    const signature4 = await factory({
+      commitment: getCommitment("confirmed"),
+      lamports: lamports2,
+      recipientAddress: address4
+    });
+    logger({
+      data: { address: address4.toString(), lamports: lamports2.toString(), signature: signature4 },
+      level: "info",
+      message: "airdrop requested"
+    });
+    return signature4;
+  }
+  __name(requestAirdrop, "requestAirdrop");
+  return {
+    connectWallet,
+    disconnectWallet: disconnectWallet2,
+    fetchAccount,
+    fetchBalance,
+    requestAirdrop,
+    sendTransaction,
+    setCluster
+  };
+}
+__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 address4 = session.account.address;
+  if (session.signTransaction) {
+    const signTransaction = session.signTransaction.bind(session);
+    const modifyingSigner = Object.freeze({
+      address: address4,
+      async modifyAndSignTransactions(transactions) {
+        const signedTransactions = [];
+        for (const transaction of transactions) {
+          const castTransaction = transaction;
+          const signed = await signTransaction(
+            castTransaction
+          );
+          const signature4 = signed.signatures[address4];
+          if (!signature4) {
+            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 signature4 = signedTransaction.signatures[address4];
+            if (!signature4) {
+              throw new Error("Expected signer to produce a signature for the provided address.");
+            }
+            return Object.freeze({ [address4]: signature4 });
+          })
+        );
+      }
+    });
+    return {
+      mode: "partial",
+      signer: modifyingSigner
+    };
+  }
+  if (session.sendTransaction) {
+    const base58Encoder = getBase58Encoder();
+    const sendTransaction = session.sendTransaction.bind(session);
+    const sendingSigner = Object.freeze({
+      address: address4,
+      async signAndSendTransactions(transactions) {
+        const signatures = [];
+        for (const transaction of transactions) {
+          const signatureString = await sendTransaction(
+            transaction,
+            commitment ? { commitment } : void 0
+          );
+          const bytes = base58Encoder.encode(signatureString);
+          signatures.push(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 (isTransactionPartialSigner(signer)) {
+    return "partial";
+  }
+  if (isTransactionSendingSigner(signer)) {
+    return "send";
+  }
+  return "partial";
+}
+__name(resolveSignerMode, "resolveSignerMode");
+
+// src/features/sol.ts
+function ensureAddress(value) {
+  return typeof value === "string" ? 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 = pipe(
+      createTransactionMessage({ version: config.transactionVersion ?? 0 }),
+      (m) => setTransactionMessageFeePayer(signer.address, m),
+      (m) => setTransactionMessageLifetimeUsingBlockhash(lifetime, m),
+      (m) => appendTransactionMessageInstruction(
+        getTransferSolInstruction({ amount, destination, source: signer }),
+        m
+      )
+    );
+    return {
+      commitment,
+      lifetime,
+      message,
+      mode,
+      signer,
+      plan: singleTransactionPlan(message)
+    };
+  }
+  __name(prepareTransfer, "prepareTransfer");
+  async function sendPreparedTransfer(prepared, options = {}) {
+    if (prepared.mode === "send" && isTransactionSendingSigner(prepared.signer)) {
+      const signatureBytes2 = await signAndSendTransactionMessageWithSigners(prepared.message, {
+        abortSignal: options.abortSignal,
+        minContextSlot: options.minContextSlot
+      });
+      const base58Decoder2 = getBase58Decoder();
+      return 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 = createTransactionPlanExecutor({
+      async executeTransactionMessage(message, config = {}) {
+        const signed = await signTransactionMessageWithSigners(message, {
+          abortSignal: config.abortSignal ?? options.abortSignal,
+          minContextSlot: options.minContextSlot
+        });
+        const wire = getBase64EncodedWireTransaction(signed);
+        const response = await runtime.rpc.sendTransaction(wire, {
+          encoding: "base64",
+          maxRetries,
+          preflightCommitment: commitment,
+          skipPreflight: options.skipPreflight
+        }).send({ abortSignal: config.abortSignal ?? options.abortSignal });
+        latestSignature = signature(response);
+        return { transaction: signed };
+      }
+    });
+    await executor(prepared.plan ?? 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" ? 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, address(TOKEN_PROGRAM_ADDRESS));
+  let cachedDecimals = config.decimals;
+  let cachedMath;
+  async function resolveDecimals(commitment) {
+    if (cachedDecimals !== void 0) {
+      return cachedDecimals;
+    }
+    const account = await 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 findAssociatedTokenPda({
+      mint: mintAddress,
+      owner: ensureAddress2(owner),
+      tokenProgram
+    });
+    return ata;
+  }
+  __name(deriveAssociatedTokenAddress, "deriveAssociatedTokenAddress");
+  async function fetchBalance(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(fetchBalance, "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(
+          getCreateAssociatedTokenInstruction({
+            ata: destinationAta,
+            mint: mintAddress,
+            owner: destinationOwner,
+            payer: signer,
+            tokenProgram
+          })
+        );
+      }
+    }
+    instructionList.push(
+      getTransferCheckedInstruction({
+        amount,
+        authority: signer,
+        decimals,
+        destination: destinationAta,
+        mint: mintAddress,
+        source: sourceAta
+      })
+    );
+    let message = pipe(
+      createTransactionMessage({ version: config2.transactionVersion ?? 0 }),
+      (m) => setTransactionMessageFeePayer(signer.address, m),
+      (m) => setTransactionMessageLifetimeUsingBlockhash(lifetime, m)
+    );
+    for (const instruction of instructionList) {
+      message = appendTransactionMessageInstruction(instruction, message);
+    }
+    return {
+      amount,
+      commitment,
+      decimals,
+      destinationAta,
+      lifetime,
+      message,
+      mode,
+      signer,
+      sourceAta,
+      plan: singleTransactionPlan(message)
+    };
+  }
+  __name(prepareTransfer, "prepareTransfer");
+  async function sendPreparedTransfer(prepared, options = {}) {
+    if (prepared.mode === "send" && isTransactionSendingSigner(prepared.signer)) {
+      const signatureBytes2 = await signAndSendTransactionMessageWithSigners(prepared.message, {
+        abortSignal: options.abortSignal,
+        minContextSlot: options.minContextSlot
+      });
+      const base58Decoder2 = getBase58Decoder();
+      return 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 = createTransactionPlanExecutor({
+      async executeTransactionMessage(message, config2 = {}) {
+        const signed = await signTransactionMessageWithSigners(message, {
+          abortSignal: config2.abortSignal ?? options.abortSignal,
+          minContextSlot: options.minContextSlot
+        });
+        const wire = getBase64EncodedWireTransaction(signed);
+        const response = await runtime.rpc.sendTransaction(wire, {
+          encoding: "base64",
+          maxRetries,
+          preflightCommitment: commitment,
+          skipPreflight: options.skipPreflight
+        }).send({ abortSignal: config2.abortSignal ?? options.abortSignal });
+        latestSignature = signature(response);
+        return { transaction: signed };
+      }
+    });
+    await executor(prepared.plan ?? 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 (isSolanaError(error, 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,
+    prepareTransfer,
+    sendPreparedTransfer,
+    sendTransfer
+  };
+}
+__name(createSplTokenHelper, "createSplTokenHelper");
+function transactionToBase64(tx) {
+  if ("messageBytes" in tx) {
+    return getBase64EncodedWireTransaction(tx);
+  }
+  return getBase64EncodedWireTransaction(compileTransaction(tx));
+}
+__name(transactionToBase64, "transactionToBase64");
+async function transactionToBase64WithSigners(tx) {
+  if ("messageBytes" in tx) {
+    return transactionToBase64(tx);
+  }
+  const signed = await 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 === COMPUTE_BUDGET_PROGRAM_ADDRESS && instruction.data?.[0] === 2;
+}
+__name(isComputeUnitLimitInstruction, "isComputeUnitLimitInstruction");
+function didExceedComputeBudget(error) {
+  let current = error;
+  while (isSolanaError(current)) {
+    if (isSolanaError(current, 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 = 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 = getSetComputeUnitLimitInstruction({ units });
+    if (computeLimitIndex === -1) {
+      transaction = 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 = 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" ? address(value) : value;
+}
+__name(toAddress, "toAddress");
+function hasSetComputeUnitLimitInstruction(instructions) {
+  return instructions.some(
+    (instruction) => isInstructionForProgram(instruction, COMPUTE_BUDGET_PROGRAM_ADDRESS) && isInstructionWithData(instruction) && instruction.data[0] === ComputeBudgetInstruction.SetComputeUnitLimit
+  );
+}
+__name(hasSetComputeUnitLimitInstruction, "hasSetComputeUnitLimitInstruction");
+function hasSetComputeUnitPriceInstruction(instructions) {
+  return instructions.some(
+    (instruction) => isInstructionForProgram(instruction, COMPUTE_BUDGET_PROGRAM_ADDRESS) && isInstructionWithData(instruction) && instruction.data[0] === 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 address4 = toAddress(feePayer);
+    if (authoritySigner && authoritySigner.address === address4) {
+      return { address: address4, signer: authoritySigner };
+    }
+    return { address: address4 };
+  }
+  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 || !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(getSetComputeUnitLimitInstruction({ units: Number(resolvedComputeUnitLimit) }));
+  }
+  if (computeUnitPrice !== void 0) {
+    prefixInstructions.push(getSetComputeUnitPriceInstruction({ microLamports: Number(computeUnitPrice) }));
+  }
+  const instructionSequence = [...prefixInstructions, ...baseInstructions];
+  const createMessage = /* @__PURE__ */ __name(async () => pipe(
+    createTransactionMessage({ version }),
+    (message) => feePayerSigner ? setTransactionMessageFeePayerSigner(feePayerSigner, message) : setTransactionMessageFeePayer(feePayer, message),
+    (message) => setTransactionMessageLifetimeUsingBlockhash(lifetime, message)
+  ), "createMessage");
+  return Object.freeze({
+    commitment,
+    computeUnitLimit: resolvedComputeUnitLimit,
+    computeUnitPrice,
+    createTransactionMessage: createMessage,
+    feePayer,
+    instructionPlan: 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 = 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 signTransactionMessageWithSigners(prepared.message, {
+      abortSignal: options.abortSignal,
+      minContextSlot: options.minContextSlot
+    });
+  }
+  __name(sign, "sign");
+  async function toWire(prepared, options = {}) {
+    const signed = await sign(prepared, options);
+    return 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 signAndSendTransactionMessageWithSigners(prepared.message, {
+        abortSignal: options.abortSignal,
+        minContextSlot: options.minContextSlot
+      });
+      const base58Decoder2 = getBase58Decoder();
+      return signature(base58Decoder2.decode(signatureBytes2));
+    }
+    const signed = await sign(prepared, {
+      abortSignal: options.abortSignal,
+      minContextSlot: options.minContextSlot
+    });
+    const wire = 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 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 = createTransactionPlanExecutor({
+      async executeTransactionMessage(message, config = {}) {
+        const signed = await signTransactionMessageWithSigners(message, {
+          abortSignal: config.abortSignal ?? options.abortSignal,
+          minContextSlot: options.minContextSlot
+        });
+        const wire = getBase64EncodedWireTransaction(signed);
+        const response = await runtime.rpc.sendTransaction(wire, {
+          encoding: "base64",
+          maxRetries,
+          preflightCommitment: commitment,
+          skipPreflight: options.skipPreflight
+        }).send({ abortSignal: config.abortSignal ?? options.abortSignal });
+        latestSignature = 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: 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 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 transaction;
+  const getSolTransfer = /* @__PURE__ */ __name(() => {
+    if (!solTransfer) {
+      solTransfer = wrapSolTransferHelper(createSolTransferHelper(runtime), getFallbackCommitment);
+    }
+    return solTransfer;
+  }, "getSolTransfer");
+  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 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 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 commitment = config.commitment ?? "confirmed";
+  const websocketEndpoint = config.websocketEndpoint ?? config.endpoint;
+  const initialState = createInitialClientState({
+    commitment,
+    endpoint: config.endpoint,
+    websocketEndpoint
+  });
+  const store = config.createStore ? config.createStore(initialState) : createClientStore(initialState);
+  const rpcClient = config.rpcClient ?? createSolanaRpcClient({
+    commitment,
+    endpoint: config.endpoint,
+    websocketEndpoint
+  });
+  const runtime = {
+    rpc: rpcClient.rpc,
+    rpcSubscriptions: rpcClient.rpcSubscriptions
+  };
+  const connectors = createWalletRegistry(config.walletConnectors ?? []);
+  const logger = createLogger(config.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(config.endpoint, { commitment, 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 transaction() {
+      return helpers.transaction;
+    },
+    prepareTransaction: helpers.prepareTransaction,
+    watchers
+  };
+}
+__name(createClient, "createClient");
+
+// 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 signature4 = await helper.sendTransfer(request, options);
+      setState(createAsyncState("success", { data: signature4 }));
+      return signature4;
+    } 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 signature4 = await helper.sendTransfer(resolvedConfig, options);
+      setState(createAsyncState("success", { data: signature4 }));
+      return signature4;
+    } 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/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" ? 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 SolanaError(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((address4) => ({ address: address4, role: 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 signature4 = await helper.send(target, rest);
+      sendStateStore.setSnapshot(createAsyncState("success", { data: signature4 }));
+      return signature4;
+    } 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 signature4 = await helper.prepareAndSend(
+        {
+          ...restWithLifetime,
+          instructions: nextInstructions
+        },
+        sendOptions
+      );
+      sendStateStore.setSnapshot(createAsyncState("success", { data: signature4 }));
+      return signature4;
+    } 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" ? 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");
+var base58Decoder = getBase58Decoder();
+var transactionDecoder = getTransactionDecoder();
+var transactionEncoder = getTransactionEncoder();
+function deriveConnectorId(wallet) {
+  return wallet.name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+}
+__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: 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 disconnectWallet(wallet) {
+  const disconnectFeature = wallet.features[StandardDisconnect];
+  if (disconnectFeature) {
+    await disconnectFeature.disconnect();
+  }
+}
+__name(disconnectWallet, "disconnectWallet");
+function createWalletStandardConnector(wallet, options = {}) {
+  const metadata = {
+    canAutoConnect: options.canAutoConnect ?? Boolean(wallet.features[StandardConnect]),
+    icon: options.icon ?? wallet.icon,
+    id: options.id ?? deriveConnectorId(wallet),
+    name: options.name ?? wallet.name
+  };
+  async function connect(connectionOptions = {}) {
+    const connectFeature = wallet.features[StandardConnect];
+    const shouldConnectSilently = Boolean(connectionOptions.autoConnect);
+    let walletAccounts = wallet.accounts;
+    if (connectFeature) {
+      const { accounts } = await connectFeature.connect({
+        silent: shouldConnectSilently || void 0
+      });
+      if (accounts.length) {
+        walletAccounts = accounts;
+      }
+    }
+    const primaryAccount = getPrimaryAccount(walletAccounts);
+    const sessionAccount = toSessionAccount(primaryAccount);
+    const signMessageFeature = wallet.features[SolanaSignMessage];
+    const signTransactionFeature = wallet.features[SolanaSignTransaction];
+    const signAndSendFeature = wallet.features[SolanaSignAndSendTransaction];
+    const resolvedChain = options.defaultChain ?? getChain(primaryAccount);
+    const signMessage = signMessageFeature ? async (message) => {
+      const [output] = await signMessageFeature.signMessage({
+        account: primaryAccount,
+        message
+      });
+      return output.signature;
+    } : void 0;
+    const signTransaction = signTransactionFeature ? async (transaction) => {
+      const wireBytes = new Uint8Array(transactionEncoder.encode(transaction));
+      const request = resolvedChain ? {
+        account: primaryAccount,
+        chain: resolvedChain,
+        transaction: wireBytes
+      } : {
+        account: primaryAccount,
+        transaction: wireBytes
+      };
+      const [output] = await signTransactionFeature.signTransaction(request);
+      return transactionDecoder.decode(output.signedTransaction);
+    } : void 0;
+    const sendTransaction = signAndSendFeature ? async (transaction, config) => {
+      const wireBytes = new Uint8Array(transactionEncoder.encode(transaction));
+      const chain = options.defaultChain ?? getChain(primaryAccount) ?? "solana:mainnet-beta";
+      const [output] = await signAndSendFeature.signAndSendTransaction({
+        account: primaryAccount,
+        chain,
+        options: {
+          commitment: mapCommitment(config?.commitment)
+        },
+        transaction: wireBytes
+      });
+      return base58Decoder.decode(output.signature);
+    } : void 0;
+    async function disconnectSession() {
+      await disconnectWallet(wallet);
+    }
+    __name(disconnectSession, "disconnectSession");
+    return {
+      account: sessionAccount,
+      connector: metadata,
+      disconnect: disconnectSession,
+      sendTransaction,
+      signMessage,
+      signTransaction
+    };
+  }
+  __name(connect, "connect");
+  async function disconnect() {
+    await disconnectWallet(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 } = 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 } = 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");
+
+export { LAMPORTS_PER_SOL, SIGNATURE_STATUS_TIMEOUT_MS, applyRatio, assertDecimals, assertNonNegative, bigintFromJson, bigintToJson, checkedAdd, checkedDivide, checkedMultiply, checkedSubtract, confirmationMeetsCommitment, createAsyncState, createClient, createClientStore, createDefaultClientStore, createInitialAsyncState, createInitialClientState, createRatio, createSolTransferController, createSolTransferHelper, createSolanaRpcClient, createSplTokenHelper, createSplTransferController, createTokenAmount, createTransactionHelper, createTransactionPoolController, createTransactionRecipe, createWalletRegistry, createWalletStandardConnector, deriveConfirmationStatus, getWalletStandardConnectors, insertReferenceKey, insertReferenceKeys, lamports, lamportsFromJson, lamportsFromSol, lamportsMath, lamportsToJson, lamportsToSolString, normalizeSignature, pow10, prepareTransaction, stableStringify, toAddress2 as toAddress, toAddressString, toBigint2 as toBigint, transactionToBase64, transactionToBase64WithSigners, watchWalletStandardConnectors };
+//# sourceMappingURL=index.node.mjs.map
+//# sourceMappingURL=index.node.mjs.map