@solana/connector 0.1.6 → 0.1.8

package/dist/chunk-J7DHGLW6.mjs

@@ -0,0 +1,638 @@
+import { createSolanaRpc, createSolanaRpcSubscriptions, setTransactionMessageLifetimeUsingBlockhash, assertIsTransactionMessageWithBlockhashLifetime } from '@solana/kit';
+import { getBase58Encoder, getBase58Decoder } from '@solana/codecs';
+import { address } from '@solana/addresses';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key != "symbol" ? key + "" : key, value);
+
+// src/lib/kit/constants.ts
+var LAMPORTS_PER_SOL = 1e9;
+function lamportsToSol(lamports) {
+  return Number(lamports) / 1e9;
+}
+function solToLamports(sol) {
+  return BigInt(Math.floor(sol * 1e9));
+}
+
+// src/lib/kit/rpc.ts
+function getPublicSolanaRpcUrl(cluster) {
+  switch (cluster) {
+    case "devnet":
+      return "https://api.devnet.solana.com";
+    case "testnet":
+      return "https://api.testnet.solana.com";
+    case "mainnet-beta":
+    case "mainnet":
+      return "https://api.mainnet-beta.solana.com";
+    case "localnet":
+    case "localhost":
+      return "http://127.0.0.1:8899";
+    default:
+      throw new Error("Invalid cluster moniker");
+  }
+}
+
+// src/lib/kit/explorer.ts
+function getExplorerLink(props = {}) {
+  let url = new URL("https://explorer.solana.com"), cluster = props.cluster;
+  return (!cluster || cluster === "mainnet") && (cluster = "mainnet-beta"), "address" in props && props.address ? url.pathname = `/address/${props.address}` : "transaction" in props && props.transaction ? url.pathname = `/tx/${props.transaction}` : "block" in props && props.block !== void 0 && (url.pathname = `/block/${props.block}`), cluster !== "mainnet-beta" && (cluster === "localnet" || cluster === "localhost" ? (url.searchParams.set("cluster", "custom"), url.searchParams.set("customUrl", "http://localhost:8899")) : url.searchParams.set("cluster", cluster)), url.toString();
+}
+function createSolanaClient({
+  urlOrMoniker,
+  rpcConfig,
+  rpcSubscriptionsConfig
+}) {
+  if (!urlOrMoniker) throw new Error("Cluster url or moniker is required");
+  let parsedUrl;
+  if (urlOrMoniker instanceof URL)
+    parsedUrl = urlOrMoniker;
+  else
+    try {
+      parsedUrl = new URL(urlOrMoniker.toString());
+    } catch {
+      try {
+        parsedUrl = new URL(
+          getPublicSolanaRpcUrl(urlOrMoniker.toString())
+        );
+      } catch {
+        throw new Error("Invalid URL or cluster moniker");
+      }
+    }
+  if (!parsedUrl.protocol.match(/^https?:/i))
+    throw new Error("Unsupported protocol. Only HTTP and HTTPS are supported");
+  rpcConfig?.port && (parsedUrl.port = rpcConfig.port.toString());
+  let rpcUrl = parsedUrl.toString(), rpc = createSolanaRpc(rpcUrl);
+  parsedUrl.protocol = parsedUrl.protocol.replace("http", "ws"), rpcSubscriptionsConfig?.port ? parsedUrl.port = rpcSubscriptionsConfig.port.toString() : (parsedUrl.hostname === "localhost" || parsedUrl.hostname.startsWith("127")) && (parsedUrl.port = "8900");
+  let rpcSubscriptions = createSolanaRpcSubscriptions(
+    parsedUrl.toString()
+  );
+  return {
+    rpc,
+    rpcSubscriptions,
+    urlOrMoniker: rpcUrl
+  };
+}
+
+// src/lib/kit/debug.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+function getMinLogLevel() {
+  return typeof process < "u" && process.env?.CONNECTOR_DEBUG_LEVEL ? process.env.CONNECTOR_DEBUG_LEVEL : typeof globalThis < "u" && globalThis.__CONNECTOR_DEBUG_LEVEL__ ? globalThis.__CONNECTOR_DEBUG_LEVEL__ : typeof window < "u" && window.__CONNECTOR_DEBUG_LEVEL__ ? window.__CONNECTOR_DEBUG_LEVEL__ : "info";
+}
+function isDebugEnabled() {
+  return !!(typeof process < "u" && (process.env?.CONNECTOR_DEBUG_LEVEL || process.env?.CONNECTOR_DEBUG === "true" || process.env?.CONNECTOR_DEBUG === "1") || typeof globalThis < "u" && (globalThis.__CONNECTOR_DEBUG__ === true || globalThis.__CONNECTOR_DEBUG_LEVEL__) || typeof window < "u" && (window.__CONNECTOR_DEBUG__ === true || window.__CONNECTOR_DEBUG_LEVEL__));
+}
+function debug(message, level = "info", prefix = "[Connector]") {
+  if (!isDebugEnabled() || LOG_LEVELS[level] < LOG_LEVELS[getMinLogLevel()]) return;
+  let formattedMessage = typeof message == "string" ? message : JSON.stringify(message, null, 2);
+  switch (level) {
+    case "debug":
+      console.log(prefix, formattedMessage);
+      break;
+    case "info":
+      console.info(prefix, formattedMessage);
+      break;
+    case "warn":
+      console.warn(prefix, formattedMessage);
+      break;
+    case "error":
+      console.error(prefix, formattedMessage);
+      break;
+  }
+}
+
+// src/lib/kit/prepare-transaction.ts
+async function prepareTransaction(config) {
+  let blockhashReset = config.blockhashReset !== false, transaction = config.transaction, hasLifetimeConstraint = "lifetimeConstraint" in transaction;
+  if (blockhashReset || !hasLifetimeConstraint) {
+    let { value: latestBlockhash } = await config.rpc.getLatestBlockhash().send();
+    hasLifetimeConstraint ? blockhashReset && (isDebugEnabled() && debug("Auto resetting the latest blockhash.", "debug"), transaction = {
+      ...transaction,
+      lifetimeConstraint: latestBlockhash
+    }) : (isDebugEnabled() && debug("Transaction missing latest blockhash, fetching one.", "debug"), transaction = setTransactionMessageLifetimeUsingBlockhash(
+      latestBlockhash,
+      transaction
+    ));
+  }
+  return assertIsTransactionMessageWithBlockhashLifetime(transaction), transaction;
+}
+
+// src/lib/errors/index.ts
+var ConnectorError = class extends Error {
+  constructor(message, context, originalError) {
+    super(message);
+    __publicField(this, "context");
+    __publicField(this, "originalError");
+    __publicField(this, "timestamp");
+    this.name = this.constructor.name, this.context = context, this.originalError = originalError, this.timestamp = (/* @__PURE__ */ new Date()).toISOString(), Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      recoverable: this.recoverable,
+      context: this.context,
+      timestamp: this.timestamp,
+      originalError: this.originalError?.message
+    };
+  }
+}, ConnectionError = class extends ConnectorError {
+  constructor(code, message, context, originalError) {
+    super(message, context, originalError);
+    __publicField(this, "code");
+    __publicField(this, "recoverable", true);
+    this.code = code;
+  }
+}, ValidationError = class extends ConnectorError {
+  constructor(code, message, context, originalError) {
+    super(message, context, originalError);
+    __publicField(this, "code");
+    __publicField(this, "recoverable", false);
+    this.code = code;
+  }
+}, ConfigurationError = class extends ConnectorError {
+  constructor(code, message, context, originalError) {
+    super(message, context, originalError);
+    __publicField(this, "code");
+    __publicField(this, "recoverable", false);
+    this.code = code;
+  }
+}, NetworkError = class extends ConnectorError {
+  constructor(code, message, context, originalError) {
+    super(message, context, originalError);
+    __publicField(this, "code");
+    __publicField(this, "recoverable", true);
+    this.code = code;
+  }
+}, TransactionError = class extends ConnectorError {
+  constructor(code, message, context, originalError) {
+    super(message, context, originalError);
+    __publicField(this, "code");
+    __publicField(this, "recoverable");
+    this.code = code, this.recoverable = ["USER_REJECTED", "SEND_FAILED", "SIMULATION_FAILED"].includes(code);
+  }
+};
+function isConnectorError(error) {
+  return error instanceof ConnectorError;
+}
+function isConnectionError(error) {
+  return error instanceof ConnectionError;
+}
+function isValidationError(error) {
+  return error instanceof ValidationError;
+}
+function isConfigurationError(error) {
+  return error instanceof ConfigurationError;
+}
+function isNetworkError(error) {
+  return error instanceof NetworkError;
+}
+function isTransactionError(error) {
+  return error instanceof TransactionError;
+}
+var Errors = {
+  walletNotConnected: (context) => new ConnectionError("WALLET_NOT_CONNECTED", "No wallet connected", context),
+  walletNotFound: (walletName) => new ConnectionError("WALLET_NOT_FOUND", `Wallet not found${walletName ? `: ${walletName}` : ""}`, {
+    walletName
+  }),
+  connectionFailed: (originalError) => new ConnectionError("CONNECTION_FAILED", "Failed to connect to wallet", void 0, originalError),
+  accountNotAvailable: (address2) => new ConnectionError("ACCOUNT_NOT_AVAILABLE", "Requested account not available", { address: address2 }),
+  invalidTransaction: (reason, context) => new ValidationError("INVALID_TRANSACTION", `Invalid transaction: ${reason}`, context),
+  invalidFormat: (expectedFormat, actualFormat) => new ValidationError("INVALID_FORMAT", `Invalid format: expected ${expectedFormat}`, {
+    expectedFormat,
+    actualFormat
+  }),
+  unsupportedFormat: (format) => new ValidationError("UNSUPPORTED_FORMAT", `Unsupported format: ${format}`, { format }),
+  missingProvider: (hookName) => new ConfigurationError(
+    "MISSING_PROVIDER",
+    `${hookName} must be used within ConnectorProvider. Wrap your app with <ConnectorProvider> or <UnifiedProvider>.`,
+    { hookName }
+  ),
+  clusterNotFound: (clusterId, availableClusters) => new ConfigurationError(
+    "CLUSTER_NOT_FOUND",
+    `Cluster ${clusterId} not found. Available clusters: ${availableClusters.join(", ")}`,
+    { clusterId, availableClusters }
+  ),
+  rpcError: (message, originalError) => new NetworkError("RPC_ERROR", message, void 0, originalError),
+  networkTimeout: () => new NetworkError("NETWORK_TIMEOUT", "Network request timed out"),
+  signingFailed: (originalError) => new TransactionError("SIGNING_FAILED", "Failed to sign transaction", void 0, originalError),
+  featureNotSupported: (feature) => new TransactionError("FEATURE_NOT_SUPPORTED", `Wallet does not support ${feature}`, { feature }),
+  userRejected: (operation) => new TransactionError("USER_REJECTED", `User rejected ${operation}`, { operation })
+};
+function toConnectorError(error, defaultMessage = "An unexpected error occurred") {
+  if (isConnectorError(error))
+    return error;
+  if (error instanceof Error) {
+    let message = error.message.toLowerCase();
+    return message.includes("user rejected") || message.includes("user denied") ? Errors.userRejected("transaction") : message.includes("wallet not found") || message.includes("not installed") ? Errors.walletNotFound() : message.includes("not connected") ? Errors.walletNotConnected() : message.includes("network") || message.includes("fetch") ? Errors.rpcError(error.message, error) : message.includes("invalid") ? new ValidationError("VALIDATION_FAILED", error.message, void 0, error) : new TransactionError("SIGNING_FAILED", error.message, void 0, error);
+  }
+  return new TransactionError("SIGNING_FAILED", defaultMessage, { originalError: String(error) });
+}
+function getUserFriendlyMessage(error) {
+  return isConnectorError(error) ? {
+    WALLET_NOT_CONNECTED: "Please connect your wallet to continue.",
+    WALLET_NOT_FOUND: "Wallet not found. Please install a supported wallet.",
+    CONNECTION_FAILED: "Failed to connect to wallet. Please try again.",
+    USER_REJECTED: "Transaction was cancelled.",
+    FEATURE_NOT_SUPPORTED: "This wallet does not support this feature.",
+    SIGNING_FAILED: "Failed to sign transaction. Please try again.",
+    SEND_FAILED: "Failed to send transaction. Please try again.",
+    INVALID_CLUSTER: "Invalid network configuration.",
+    CLUSTER_NOT_FOUND: "Network not found.",
+    MISSING_PROVIDER: "Application not properly configured.",
+    RPC_ERROR: "Network error. Please check your connection.",
+    NETWORK_TIMEOUT: "Request timed out. Please try again."
+  }[error.code] || error.message || "An error occurred." : "An unexpected error occurred. Please try again.";
+}
+function detectMessageModification(original, modified) {
+  if (original.length !== modified.length)
+    return true;
+  for (let i = 0; i < original.length; i++)
+    if (original[i] !== modified[i])
+      return true;
+  return false;
+}
+function updateSignatureDictionary(original, signed, originalSignatures, address2, signature) {
+  let wasModified = detectMessageModification(original, signed), signatureBytes = signature, newSignatures = {};
+  return newSignatures[address2] = signatureBytes, wasModified ? newSignatures : {
+    ...originalSignatures,
+    ...newSignatures
+  };
+}
+function freezeSigner(signer) {
+  return Object.freeze(signer);
+}
+function base58ToSignatureBytes(signature) {
+  try {
+    let bytes = getBase58Encoder().encode(signature);
+    if (bytes.length !== 64)
+      throw new Error(`Invalid signature length: expected 64 bytes, got ${bytes.length}`);
+    return bytes;
+  } catch (error) {
+    throw new Error(`Failed to decode base58 signature: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function signatureBytesToBase58(bytes) {
+  try {
+    if (bytes.length !== 64)
+      throw new Error(`Invalid signature length: expected 64 bytes, got ${bytes.length}`);
+    return getBase58Decoder().decode(bytes);
+  } catch (error) {
+    throw new Error(
+      `Failed to encode signature to base58: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+// src/lib/kit/signer-factories.ts
+function createMessageSignerFromWallet(walletAddress, signMessageFn) {
+  return freezeSigner({
+    address: walletAddress,
+    async modifyAndSignMessages(messages, config) {
+      if (messages.length !== 1)
+        throw new ValidationError("INVALID_FORMAT", "Wallets only support signing one message at a time", {
+          receivedCount: messages.length,
+          expectedCount: 1
+        });
+      let [message] = messages, { content, signatures: originalSignatures } = message;
+      if (config?.abortSignal?.aborted)
+        throw Errors.userRejected("message signing");
+      try {
+        let signature = await signMessageFn(content), signatures = updateSignatureDictionary(
+          content,
+          content,
+          // Message content doesn't change in signMessage
+          originalSignatures,
+          walletAddress,
+          signature
+        );
+        return [
+          {
+            content,
+            signatures
+          }
+        ];
+      } catch (error) {
+        if (error instanceof Error) {
+          let message2 = error.message.toLowerCase();
+          throw message2.includes("user rejected") || message2.includes("user denied") ? Errors.userRejected("message signing") : new TransactionError("SIGNING_FAILED", "Failed to sign message", void 0, error);
+        }
+        throw new TransactionError("SIGNING_FAILED", "Failed to sign message", {
+          originalError: String(error)
+        });
+      }
+    }
+  });
+}
+function createTransactionSendingSignerFromWallet(walletAddress, chain, sendTransactionFn) {
+  return freezeSigner({
+    address: walletAddress,
+    async signAndSendTransactions(transactions, config) {
+      if (transactions.length !== 1)
+        throw new ValidationError("INVALID_FORMAT", "Wallets only support sending one transaction at a time", {
+          receivedCount: transactions.length,
+          expectedCount: 1
+        });
+      let [transaction] = transactions;
+      if (config?.abortSignal?.aborted)
+        throw Errors.userRejected("transaction sending");
+      try {
+        let signatureString = await sendTransactionFn(transaction);
+        return [base58ToSignatureBytes(signatureString)];
+      } catch (error) {
+        if (error instanceof Error) {
+          let message = error.message.toLowerCase();
+          throw message.includes("user rejected") || message.includes("user denied") ? Errors.userRejected("transaction sending") : message.includes("network") || message.includes("rpc") ? new TransactionError("SEND_FAILED", "Failed to send transaction", void 0, error) : new TransactionError("SEND_FAILED", "Failed to send transaction", void 0, error);
+        }
+        throw new TransactionError("SEND_FAILED", "Failed to send transaction", {
+          originalError: String(error)
+        });
+      }
+    }
+  });
+}
+function createKitSignersFromWallet(wallet, account, connection, network) {
+  if (!wallet || !account)
+    return {
+      address: null,
+      addressString: null,
+      messageSigner: null,
+      transactionSigner: null
+    };
+  let walletAddress = null, walletAddressString = null;
+  try {
+    walletAddress = address(account.address), walletAddressString = account.address;
+  } catch {
+    return {
+      address: null,
+      addressString: null,
+      messageSigner: null,
+      transactionSigner: null
+    };
+  }
+  let chain = "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
+  if (network)
+    chain = {
+      mainnet: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+      devnet: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+      testnet: "solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z"
+    }[network] || chain;
+  else if (connection) {
+    let rpcUrl = connection.rpcEndpoint || "";
+    rpcUrl.includes("mainnet") || rpcUrl.includes("api.mainnet-beta") ? chain = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp" : rpcUrl.includes("testnet") ? chain = "solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z" : chain = "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
+  }
+  let features = wallet.features, hasSignMessage = !!features["solana:signMessage"], hasSignAndSendTransaction = !!features["solana:signAndSendTransaction"], hasSendTransaction = !!features["solana:sendTransaction"], messageSigner = hasSignMessage ? createMessageSignerFromWallet(walletAddress, async (message) => {
+    if (!hasSignMessage)
+      throw Errors.featureNotSupported("message signing");
+    try {
+      let signFeature = features["solana:signMessage"], messageBytes = message instanceof Uint8Array ? message : new Uint8Array(message), results = await signFeature.signMessage({
+        account,
+        message: messageBytes,
+        ...chain ? { chain } : {}
+      });
+      if (!Array.isArray(results) || results.length === 0)
+        throw new Error("Wallet returned empty results array");
+      let firstResult = results[0];
+      if (!firstResult?.signature)
+        throw new Error("Wallet returned no signature in first result");
+      return firstResult.signature;
+    } catch (error) {
+      throw console.error("signMessage error:", error), error instanceof Error ? error : new Error(String(error));
+    }
+  }) : null, transactionSigner = hasSignAndSendTransaction || hasSendTransaction ? createTransactionSendingSignerFromWallet(walletAddress, chain, async (transaction) => {
+    if (hasSignAndSendTransaction)
+      try {
+        return (await features["solana:signAndSendTransaction"].signAndSendTransaction({
+          account,
+          transactions: [transaction],
+          ...chain ? { chain } : {},
+          ...connection ? { connection } : {}
+        })).signatures[0] || "";
+      } catch (error) {
+        throw error instanceof Error ? error : new Error(String(error));
+      }
+    if (hasSendTransaction)
+      try {
+        return (await features["solana:sendTransaction"].sendTransaction({
+          account,
+          transactions: [transaction],
+          ...chain ? { chain } : {}
+        })).signatures[0] || "";
+      } catch (error) {
+        throw error instanceof Error ? error : new Error(String(error));
+      }
+    throw Errors.featureNotSupported("transaction sending");
+  }) : null;
+  return {
+    address: walletAddress,
+    addressString: walletAddressString,
+    messageSigner,
+    transactionSigner
+  };
+}
+
+// src/lib/utils/secure-logger.ts
+var SENSITIVE_KEYS = [
+  "address",
+  "publickey",
+  "signature",
+  "account",
+  "rpcurl",
+  "url",
+  "apikey",
+  "api_key",
+  "token",
+  "secret",
+  "password",
+  "private",
+  "seed",
+  "mnemonic"
+], LOG_LEVELS2 = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+}, SecureLogger = class {
+  constructor(config = {}) {
+    __publicField(this, "config");
+    let isDevelopment = typeof process < "u" && process.env?.NODE_ENV === "development";
+    this.config = {
+      // Default to disabled - logging is opt-in via __CONNECTOR_DEBUG__ or explicit config
+      enabled: config.enabled ?? false,
+      level: config.level ?? "debug",
+      redactSensitive: config.redactSensitive ?? !isDevelopment,
+      prefix: config.prefix ?? "Connector",
+      useConnectorDebug: config.useConnectorDebug ?? true
+      // Default to using connector's debug system
+    };
+  }
+  /**
+   * Log debug information (lowest priority)
+   */
+  debug(message, data) {
+    this.log("debug", message, data);
+  }
+  /**
+   * Log general information
+   */
+  info(message, data) {
+    this.log("info", message, data);
+  }
+  /**
+   * Log warnings
+   */
+  warn(message, data) {
+    this.log("warn", message, data);
+  }
+  /**
+   * Log errors (highest priority)
+   */
+  error(message, data) {
+    this.log("error", message, data);
+  }
+  /**
+   * Internal log method that handles level filtering and redaction
+   * Integrates with connector's debug system when enabled
+   */
+  log(level, message, data) {
+    let debugEnabled = this.config.useConnectorDebug ? isDebugEnabled() : false;
+    if (!this.config.enabled && !debugEnabled) return;
+    let effectiveLevel = this.config.level;
+    if (this.config.useConnectorDebug && typeof globalThis < "u") {
+      let connectorLevel = globalThis.__CONNECTOR_DEBUG_LEVEL__;
+      connectorLevel && ["debug", "info", "warn", "error"].includes(connectorLevel) && (effectiveLevel = connectorLevel);
+    }
+    if (LOG_LEVELS2[level] < LOG_LEVELS2[effectiveLevel])
+      return;
+    let processedData = this.config.redactSensitive ? this.redact(data) : data, fullMessage = processedData !== void 0 ? `${message} ${typeof processedData == "object" ? JSON.stringify(processedData, null, 2) : processedData}` : message;
+    if (this.config.useConnectorDebug && debugEnabled)
+      debug(fullMessage, level, this.config.prefix);
+    else {
+      let prefix = `[${this.config.prefix}]`;
+      switch (level) {
+        case "debug":
+          console.debug(prefix, message, processedData !== void 0 ? processedData : "");
+          break;
+        case "info":
+          console.info(prefix, message, processedData !== void 0 ? processedData : "");
+          break;
+        case "warn":
+          console.warn(prefix, message, processedData !== void 0 ? processedData : "");
+          break;
+        case "error":
+          console.error(prefix, message, processedData !== void 0 ? processedData : "");
+          break;
+      }
+    }
+  }
+  /**
+   * Recursively redact sensitive information from data
+   */
+  redact(data) {
+    if (data == null || typeof data != "object")
+      return data;
+    if (Array.isArray(data))
+      return data.map((item) => this.redact(item));
+    let redacted = {};
+    for (let [key, value] of Object.entries(data)) {
+      let keyLower = key.toLowerCase();
+      SENSITIVE_KEYS.some((sensitiveKey) => keyLower.includes(sensitiveKey)) ? redacted[key] = this.maskValue(value) : typeof value == "object" && value !== null ? redacted[key] = this.redact(value) : redacted[key] = value;
+    }
+    return redacted;
+  }
+  /**
+   * Mask a sensitive value for logging
+   * Shows first 4 and last 4 characters for strings longer than 8 chars
+   */
+  maskValue(value) {
+    if (value == null)
+      return "***";
+    let str = String(value);
+    return str.length <= 8 ? "***" : `${str.slice(0, 4)}...${str.slice(-4)}`;
+  }
+  /**
+   * Update logger configuration at runtime
+   */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+}; new SecureLogger({
+  prefix: "Connector"
+});
+function createLogger(prefix, config) {
+  return new SecureLogger({ ...config, prefix });
+}
+
+// src/lib/core/try-catch.ts
+async function tryCatch(promise) {
+  try {
+    return { data: await promise, error: null };
+  } catch (error) {
+    return { data: null, error };
+  }
+}
+function tryCatchSync(fn) {
+  try {
+    return { data: fn(), error: null };
+  } catch (error) {
+    return { data: null, error };
+  }
+}
+function isSuccess(result) {
+  return result.error === null;
+}
+function isFailure(result) {
+  return result.error !== null;
+}
+
+// src/utils/transaction-format.ts
+function isWeb3jsTransaction(tx) {
+  return tx !== null && typeof tx == "object" && "serialize" in tx && typeof tx.serialize == "function";
+}
+function serializeTransaction(tx) {
+  if (isWeb3jsTransaction(tx))
+    return tx.serialize({
+      requireAllSignatures: false,
+      verifySignatures: false
+    });
+  if (tx instanceof Uint8Array)
+    return tx;
+  if (ArrayBuffer.isView(tx))
+    return new Uint8Array(tx.buffer, tx.byteOffset, tx.byteLength);
+  throw new Error("Unsupported transaction format - must be Transaction, VersionedTransaction, or Uint8Array");
+}
+function isLegacyTransaction(bytes) {
+  return bytes.length === 0 ? false : (bytes[0] & 128) === 0;
+}
+async function deserializeToWeb3jsTransaction(bytes) {
+  if (isLegacyTransaction(bytes)) {
+    let { Transaction } = await import('@solana/web3.js');
+    return Transaction.from(bytes);
+  } else {
+    let { VersionedTransaction } = await import('@solana/web3.js');
+    return VersionedTransaction.deserialize(bytes);
+  }
+}
+function prepareTransactionForWallet(tx) {
+  let wasWeb3js = isWeb3jsTransaction(tx);
+  return { serialized: serializeTransaction(tx), wasWeb3js };
+}
+async function convertSignedTransaction(signedBytes, wasWeb3js) {
+  return wasWeb3js ? await deserializeToWeb3jsTransaction(signedBytes) : signedBytes;
+}
+
+export { ConfigurationError, ConnectionError, ConnectorError, Errors, LAMPORTS_PER_SOL, NetworkError, TransactionError, ValidationError, __publicField, base58ToSignatureBytes, convertSignedTransaction, createKitSignersFromWallet, createLogger, createMessageSignerFromWallet, createSolanaClient, createTransactionSendingSignerFromWallet, detectMessageModification, freezeSigner, getExplorerLink, getPublicSolanaRpcUrl, getUserFriendlyMessage, isConfigurationError, isConnectionError, isConnectorError, isFailure, isNetworkError, isSuccess, isTransactionError, isValidationError, isWeb3jsTransaction, lamportsToSol, prepareTransaction, prepareTransactionForWallet, signatureBytesToBase58, solToLamports, toConnectorError, tryCatch, tryCatchSync, updateSignatureDictionary };
+//# sourceMappingURL=chunk-J7DHGLW6.mjs.map
+//# sourceMappingURL=chunk-J7DHGLW6.mjs.map