@solana/connector 0.0.0 → 0.1.1

package/dist/chunk-P4ZLJI4L.js

@@ -0,0 +1,706 @@
+'use strict';
+
+var chunkP5A3XNFF_js = require('./chunk-P5A3XNFF.js');
+var chunkSMUUAKC3_js = require('./chunk-SMUUAKC3.js');
+var core = require('@wallet-ui/core');
+var gill = require('gill');
+var bs58 = require('bs58');
+var addresses = require('@solana/addresses');
+var signers = require('@solana/signers');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var bs58__default = /*#__PURE__*/_interopDefault(bs58);
+
+var logger = chunkSMUUAKC3_js.createLogger("EnhancedStorage"), STORAGE_VERSION = "v1", EnhancedStorage = class extends core.Storage {
+  constructor(key, initial, options) {
+    super(key, initial);
+    this.options = options;
+    chunkSMUUAKC3_js.__publicField(this, "errorHandlers", /* @__PURE__ */ new Set());
+    chunkSMUUAKC3_js.__publicField(this, "validators", []);
+    chunkSMUUAKC3_js.__publicField(this, "memoryFallback");
+    this.memoryFallback = initial, options?.onError && this.errorHandlers.add(options.onError), options?.validator && this.validators.push(options.validator);
+  }
+  set(value) {
+    try {
+      return this.validate(value) ? (super.set(value), this.memoryFallback = value, true) : (logger.warn("Validation failed", { key: this.key }), false);
+    } catch (error) {
+      return this.handleError(error), this.options?.useMemoryFallback ? (this.memoryFallback = value, true) : false;
+    }
+  }
+  get() {
+    try {
+      return super.get();
+    } catch (error) {
+      return this.handleError(error), this.options?.useMemoryFallback ? this.memoryFallback : this.initial;
+    }
+  }
+  validate(value) {
+    return this.validators.every((validator) => validator(value));
+  }
+  addValidator(validator) {
+    return this.validators.push(validator), this;
+  }
+  onError(handler) {
+    return this.errorHandlers.add(handler), this;
+  }
+  transform(transformer) {
+    return transformer(this.get());
+  }
+  reset() {
+    this.set(this.initial);
+  }
+  clear() {
+    try {
+      typeof window < "u" && window.localStorage && window.localStorage.removeItem(this.key), this.reset();
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  isAvailable() {
+    try {
+      if (typeof window > "u") return false;
+      let testKey = `__storage_test_${this.key}__`;
+      return window.localStorage.setItem(testKey, "test"), window.localStorage.removeItem(testKey), true;
+    } catch {
+      return false;
+    }
+  }
+  static migrate(oldKey, newStorage) {
+    try {
+      if (typeof window > "u") return false;
+      let oldValue = window.localStorage.getItem(oldKey);
+      if (oldValue) {
+        let parsed = JSON.parse(oldValue);
+        return newStorage.set(parsed), window.localStorage.removeItem(oldKey), true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  handleError(error) {
+    logger.error("Storage error", { key: this.key, error }), this.errorHandlers.forEach((handler) => {
+      try {
+        handler(error);
+      } catch (err) {
+        logger.error("Error in error handler", { error: err });
+      }
+    });
+  }
+};
+function createEnhancedStorageAccount(options) {
+  let key = options?.key ?? `connector-kit:${STORAGE_VERSION}:account`;
+  return new EnhancedStorage(key, options?.initial, {
+    validator: options?.validator,
+    onError: options?.onError,
+    useMemoryFallback: true
+    // Always fallback for SSR
+  });
+}
+function createEnhancedStorageCluster(options) {
+  let key = options?.key ?? `connector-kit:${STORAGE_VERSION}:cluster`, storage = new EnhancedStorage(key, options?.initial ?? "solana:mainnet", {
+    onError: options?.onError,
+    useMemoryFallback: true
+  });
+  return options?.validClusters && storage.addValidator((clusterId) => options.validClusters.includes(clusterId)), storage;
+}
+function createEnhancedStorageWallet(options) {
+  let key = options?.key ?? `connector-kit:${STORAGE_VERSION}:wallet`;
+  return new EnhancedStorage(key, options?.initial, {
+    onError: options?.onError,
+    useMemoryFallback: true
+  });
+}
+var EnhancedStorageAdapter = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  get() {
+    return this.storage.get();
+  }
+  set(value) {
+    this.storage.set(value);
+  }
+  subscribe(callback) {
+    return this.storage.value.subscribe(callback);
+  }
+  validate(value) {
+    return this.storage.validate(value);
+  }
+  reset() {
+    this.storage.reset();
+  }
+  clear() {
+    this.storage.clear();
+  }
+  isAvailable() {
+    return this.storage.isAvailable();
+  }
+  transform(transformer) {
+    return this.storage.transform(transformer);
+  }
+  addValidator(validator) {
+    return this.storage.addValidator(validator), this;
+  }
+  onError(handler) {
+    return this.storage.onError(handler), this;
+  }
+};
+var logger2 = chunkSMUUAKC3_js.createLogger("DefaultConfig");
+function getDefaultConfig(options) {
+  let {
+    appName,
+    appUrl,
+    autoConnect = true,
+    debug,
+    network = "mainnet-beta",
+    enableMobile = true,
+    storage,
+    clusters,
+    customClusters = [],
+    persistClusterSelection = true,
+    clusterStorageKey,
+    enableErrorBoundary = true,
+    maxRetries = chunkP5A3XNFF_js.DEFAULT_MAX_RETRIES,
+    onError
+  } = options, defaultClusters = clusters ?? [
+    core.createSolanaMainnet(),
+    core.createSolanaDevnet(),
+    core.createSolanaTestnet(),
+    ...network === "localnet" ? [core.createSolanaLocalnet()] : [],
+    ...customClusters || []
+  ], validClusterIds = defaultClusters.map((c) => c.id), accountStorage = createEnhancedStorageAccount({
+    validator: (address3) => address3 ? gill.isAddress(address3) : true,
+    onError: (error) => {
+      debug && logger2.error("Account Storage error", { error }), onError && onError(error, {
+        componentStack: "account-storage"
+      });
+    }
+  }), clusterStorage = createEnhancedStorageCluster({
+    key: clusterStorageKey,
+    initial: getInitialCluster(network),
+    validClusters: persistClusterSelection ? validClusterIds : void 0,
+    onError: (error) => {
+      debug && logger2.error("Cluster Storage error", { error }), onError && onError(error, {
+        componentStack: "cluster-storage"
+      });
+    }
+  }), walletStorage = createEnhancedStorageWallet({
+    onError: (error) => {
+      debug && logger2.error("Wallet Storage error", { error }), onError && onError(error, {
+        componentStack: "wallet-storage"
+      });
+    }
+  });
+  if (typeof window < "u") {
+    let oldAccountKey = "connector-kit:account", oldWalletKey = "connector-kit:wallet", oldClusterKey = clusterStorageKey || "connector-kit:cluster";
+    EnhancedStorage.migrate(oldAccountKey, accountStorage), EnhancedStorage.migrate(oldWalletKey, walletStorage), EnhancedStorage.migrate(oldClusterKey, clusterStorage);
+  }
+  let defaultStorage = storage ?? {
+    account: new EnhancedStorageAdapter(accountStorage),
+    cluster: new EnhancedStorageAdapter(clusterStorage),
+    wallet: new EnhancedStorageAdapter(walletStorage)
+  };
+  return {
+    autoConnect,
+    debug: debug ?? process.env.NODE_ENV === "development",
+    storage: defaultStorage,
+    appName,
+    appUrl,
+    enableMobile,
+    network,
+    cluster: {
+      clusters: defaultClusters,
+      persistSelection: persistClusterSelection,
+      initialCluster: getInitialCluster(network)
+    },
+    errorBoundary: {
+      enabled: enableErrorBoundary,
+      maxRetries,
+      onError
+    }
+  };
+}
+function getInitialCluster(network = "mainnet-beta") {
+  return chunkP5A3XNFF_js.toClusterId(network);
+}
+function getDefaultMobileConfig(options) {
+  let baseUrl = options.appUrl || (typeof window < "u" ? window.location.origin : "https://localhost:3000");
+  return {
+    appIdentity: {
+      name: options.appName,
+      uri: baseUrl,
+      icon: `${baseUrl}/favicon.ico`
+    },
+    cluster: options.network || "mainnet-beta"
+  };
+}
+
+// src/config/unified-config.ts
+function createConfig(options) {
+  let { network = "mainnet-beta", rpcUrl: customRpcUrl, ...connectorOptions } = options, normalizedNetwork = chunkP5A3XNFF_js.normalizeNetwork(typeof network == "string" ? network : "mainnet-beta"), rpcUrl = customRpcUrl || chunkP5A3XNFF_js.getDefaultRpcUrl(normalizedNetwork), rpcNetwork = normalizedNetwork === "mainnet" ? "mainnet-beta" : normalizedNetwork, connectorConfig = getDefaultConfig({
+    ...connectorOptions,
+    network: rpcNetwork
+  }), mobile = options.enableMobile !== false && normalizedNetwork !== "localnet" ? getDefaultMobileConfig({
+    appName: options.appName,
+    appUrl: connectorConfig.appUrl,
+    network: rpcNetwork
+  }) : void 0;
+  return {
+    connectorConfig,
+    mobile,
+    network: normalizedNetwork,
+    rpcUrl,
+    app: {
+      name: options.appName,
+      url: connectorConfig.appUrl || (typeof window < "u" ? window.location.origin : "https://localhost:3000")
+    }
+  };
+}
+function isUnifiedConfig(config) {
+  return !!(config && typeof config == "object" && "connectorConfig" in config && "network" in config && "rpcUrl" in config && "app" in config);
+}
+
+// src/types/wallets.ts
+function isWalletName(value) {
+  return typeof value == "string" && value.length > 0;
+}
+function isAccountAddress(value) {
+  return typeof value == "string" && value.length >= 32 && value.length <= 44;
+}
+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, address3, signature) {
+  let wasModified = detectMessageModification(original, signed), signatureBytes = signature, newSignatures = {};
+  return newSignatures[address3] = signatureBytes, wasModified ? newSignatures : {
+    ...originalSignatures,
+    ...newSignatures
+  };
+}
+function freezeSigner(signer) {
+  return Object.freeze(signer);
+}
+function base58ToSignatureBytes(signature) {
+  try {
+    let bytes = bs58__default.default.decode(signature);
+    if (bytes.length !== 64)
+      throw new Error(`Invalid signature length: expected 64 bytes, got ${bytes.length}`);
+    return new Uint8Array(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 bs58__default.default.encode(bytes);
+  } catch (error) {
+    throw new Error(`Failed to encode signature to base58: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+// src/lib/kit-signers/factories.ts
+function createMessageSignerFromWallet(walletAddress, signMessageFn) {
+  return freezeSigner({
+    address: walletAddress,
+    async modifyAndSignMessages(messages, config) {
+      if (messages.length !== 1)
+        throw new chunkP5A3XNFF_js.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 chunkP5A3XNFF_js.Errors.userRejected("message signing");
+      try {
+        let signature = await signMessageFn(content);
+        console.log("Signature received from wallet:", {
+          signatureLength: signature?.length,
+          signatureType: signature?.constructor?.name,
+          walletAddress
+        });
+        let signatures = updateSignatureDictionary(
+          content,
+          content,
+          // Message content doesn't change in signMessage
+          originalSignatures,
+          walletAddress,
+          signature
+        );
+        return console.log("Signatures after update:", {
+          signaturesKeys: Object.keys(signatures),
+          signaturesValues: Object.values(signatures).map((s) => ({ length: s?.length, type: s?.constructor?.name }))
+        }), [
+          {
+            content,
+            signatures
+          }
+        ];
+      } catch (error) {
+        if (error instanceof Error) {
+          let message2 = error.message.toLowerCase();
+          throw message2.includes("user rejected") || message2.includes("user denied") ? chunkP5A3XNFF_js.Errors.userRejected("message signing") : new chunkP5A3XNFF_js.TransactionError("SIGNING_FAILED", "Failed to sign message", void 0, error);
+        }
+        throw new chunkP5A3XNFF_js.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 chunkP5A3XNFF_js.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 chunkP5A3XNFF_js.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") ? chunkP5A3XNFF_js.Errors.userRejected("transaction sending") : message.includes("network") || message.includes("rpc") ? new chunkP5A3XNFF_js.TransactionError("SEND_FAILED", "Failed to send transaction", void 0, error) : new chunkP5A3XNFF_js.TransactionError("SEND_FAILED", "Failed to send transaction", void 0, error);
+        }
+        throw new chunkP5A3XNFF_js.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 = addresses.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 chunkP5A3XNFF_js.Errors.featureNotSupported("message signing");
+      try {
+        let results = await features["solana:signMessage"].signMessage({
+          account,
+          message,
+          ...chain ? { chain } : {}
+        });
+        if (console.log("Wallet signMessage result:", {
+          isArray: Array.isArray(results),
+          length: results?.length,
+          firstResult: results?.[0],
+          firstSignature: results?.[0]?.signature
+        }), !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 ? { chain } : {}
+          })).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 chunkP5A3XNFF_js.Errors.featureNotSupported("transaction sending");
+    }
+  ) : null;
+  return {
+    address: walletAddress,
+    addressString: walletAddressString,
+    messageSigner,
+    transactionSigner
+  };
+}
+
+// src/lib/connection/types.ts
+function isLegacyConnection(conn) {
+  return "rpcEndpoint" in conn && typeof conn.rpcEndpoint == "string";
+}
+function isKitConnection(conn) {
+  if ("rpcEndpoint" in conn)
+    return false;
+  let asKitRpc = conn;
+  return typeof asKitRpc.getLatestBlockhash == "function" && typeof asKitRpc.sendTransaction == "function";
+}
+
+// src/lib/connection/helpers.ts
+async function getLatestBlockhash(connection, commitment = "confirmed") {
+  if (isLegacyConnection(connection))
+    return await connection.getLatestBlockhash(commitment);
+  if (isKitConnection(connection))
+    return (await connection.getLatestBlockhash({ commitment }).send()).value;
+  throw new Error("Unsupported connection type");
+}
+async function sendRawTransaction(connection, bytes, options) {
+  if (isLegacyConnection(connection))
+    return await connection.sendRawTransaction(bytes, options);
+  if (isKitConnection(connection)) {
+    let rpc = connection, base64String = Buffer.from(bytes).toString("base64");
+    return await rpc.sendTransaction(base64String, {
+      ...options?.commitment ? { commitment: options.commitment } : {},
+      ...options?.skipPreflight !== void 0 ? { skipPreflight: options.skipPreflight } : {},
+      ...options?.maxRetries !== void 0 ? { maxRetries: options.maxRetries } : {}
+    }).send();
+  }
+  throw new Error("Unsupported connection type");
+}
+
+// src/utils/chain.ts
+var SOLANA_CHAIN_IDS = {
+  mainnet: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+  devnet: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+  testnet: "solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z"
+}, CHAIN_ID_TO_CLUSTER_TYPE = {
+  [SOLANA_CHAIN_IDS.mainnet]: "mainnet",
+  [SOLANA_CHAIN_IDS.devnet]: "devnet",
+  [SOLANA_CHAIN_IDS.testnet]: "testnet"
+}, CLUSTER_ID_TO_CHAIN_ID = {
+  "solana:mainnet": SOLANA_CHAIN_IDS.mainnet,
+  "solana:mainnet-beta": SOLANA_CHAIN_IDS.mainnet,
+  "solana:devnet": SOLANA_CHAIN_IDS.devnet,
+  "solana:testnet": SOLANA_CHAIN_IDS.testnet
+};
+function getChainIdFromCluster(cluster) {
+  let clusterType = chunkP5A3XNFF_js.getClusterType(cluster);
+  return clusterType === "localnet" || clusterType === "custom" ? null : getChainIdFromClusterType(clusterType);
+}
+function getChainIdFromClusterId(clusterId) {
+  return CLUSTER_ID_TO_CHAIN_ID[clusterId] || null;
+}
+function getChainIdFromClusterType(type) {
+  switch (type) {
+    case "mainnet":
+      return SOLANA_CHAIN_IDS.mainnet;
+    case "devnet":
+      return SOLANA_CHAIN_IDS.devnet;
+    case "testnet":
+      return SOLANA_CHAIN_IDS.testnet;
+    case "localnet":
+    case "custom":
+      return null;
+  }
+}
+function getClusterTypeFromChainId(chainId) {
+  return CHAIN_ID_TO_CLUSTER_TYPE[chainId] || null;
+}
+function getClusterIdFromChainId(chainId) {
+  let clusterType = getClusterTypeFromChainId(chainId);
+  if (!clusterType)
+    return null;
+  switch (clusterType) {
+    case "mainnet":
+      return "solana:mainnet";
+    case "devnet":
+      return "solana:devnet";
+    case "testnet":
+      return "solana:testnet";
+    default:
+      return null;
+  }
+}
+function isSolanaChain(chain) {
+  return chain.startsWith("solana:");
+}
+function isKnownSolanaChain(chain) {
+  return chain === SOLANA_CHAIN_IDS.mainnet || chain === SOLANA_CHAIN_IDS.devnet || chain === SOLANA_CHAIN_IDS.testnet;
+}
+function validateKnownSolanaChain(chain) {
+  if (!isSolanaChain(chain))
+    throw new Error(`Invalid chain format: expected 'solana:...', got '${chain}'`);
+  if (!isKnownSolanaChain(chain))
+    throw new Error(`Unknown Solana chain: ${chain}. Known chains: ${Object.values(SOLANA_CHAIN_IDS).join(", ")}`);
+}
+function getClusterTypeFromConnection(connection) {
+  if (!connection)
+    return null;
+  let rpcUrl = connection.rpcEndpoint || "";
+  return rpcUrl.includes("mainnet") || rpcUrl.includes("api.mainnet-beta") ? "mainnet" : rpcUrl.includes("testnet") ? "testnet" : rpcUrl.includes("devnet") ? "devnet" : rpcUrl.includes("localhost") || rpcUrl.includes("127.0.0.1") ? "localnet" : "custom";
+}
+function getChainIdFromConnection(connection, network) {
+  if (network)
+    return getChainIdFromClusterType(network);
+  let clusterType = getClusterTypeFromConnection(connection);
+  return clusterType ? getChainIdFromClusterType(clusterType) : null;
+}
+function clusterToChainId(cluster) {
+  return getChainIdFromCluster(cluster);
+}
+function chainIdToClusterType(chainId) {
+  return getClusterTypeFromChainId(chainId);
+}
+function chainIdToClusterId(chainId) {
+  return getClusterIdFromChainId(chainId);
+}
+function getSolanaExplorerUrl(signature, options = {}) {
+  let { cluster = "mainnet", customUrl } = options, normalizedCluster = cluster === "mainnet-beta" ? "mainnet" : cluster;
+  if (normalizedCluster === "localnet")
+    return `https://explorer.solana.com/tx/${signature}?cluster=custom&customUrl=${encodeURIComponent(customUrl || "http://localhost:8899")}`;
+  let explorerCluster = ["mainnet", "devnet", "testnet"].includes(normalizedCluster) ? normalizedCluster : "devnet";
+  return gill.getExplorerLink({
+    transaction: signature,
+    cluster: explorerCluster
+  });
+}
+function getSolscanUrl(signature, options = {}) {
+  let { cluster = "mainnet" } = options, normalizedCluster = cluster === "mainnet-beta" ? "mainnet" : cluster;
+  return normalizedCluster === "mainnet" ? `https://solscan.io/tx/${signature}` : normalizedCluster === "localnet" ? `https://solscan.io/tx/${signature}?cluster=custom` : `https://solscan.io/tx/${signature}?cluster=${normalizedCluster}`;
+}
+function getXrayUrl(signature) {
+  return `https://xray.helius.xyz/tx/${signature}`;
+}
+function getSolanaFmUrl(signature, options = {}) {
+  let { cluster = "mainnet" } = options, normalizedCluster = cluster === "mainnet-beta" ? "mainnet" : cluster;
+  return normalizedCluster === "mainnet" ? `https://solana.fm/tx/${signature}` : `https://solana.fm/tx/${signature}?cluster=${normalizedCluster}`;
+}
+function getAllExplorerUrls(signature, options = {}) {
+  return {
+    "solana-explorer": getSolanaExplorerUrl(signature, options),
+    solscan: getSolscanUrl(signature, options),
+    xray: getXrayUrl(signature),
+    "solana-fm": getSolanaFmUrl(signature, options)
+  };
+}
+function formatSignature(signature, chars = 8) {
+  return signature.length <= chars * 2 ? signature : `${signature.slice(0, chars)}...${signature.slice(-chars)}`;
+}
+async function copySignature(signature) {
+  try {
+    return await navigator.clipboard.writeText(signature), true;
+  } catch {
+    return false;
+  }
+}
+
+Object.defineProperty(exports, "createSolanaDevnet", {
+  enumerable: true,
+  get: function () { return core.createSolanaDevnet; }
+});
+Object.defineProperty(exports, "createSolanaLocalnet", {
+  enumerable: true,
+  get: function () { return core.createSolanaLocalnet; }
+});
+Object.defineProperty(exports, "createSolanaMainnet", {
+  enumerable: true,
+  get: function () { return core.createSolanaMainnet; }
+});
+Object.defineProperty(exports, "createSolanaTestnet", {
+  enumerable: true,
+  get: function () { return core.createSolanaTestnet; }
+});
+Object.defineProperty(exports, "address", {
+  enumerable: true,
+  get: function () { return addresses.address; }
+});
+Object.defineProperty(exports, "createSignableMessage", {
+  enumerable: true,
+  get: function () { return signers.createSignableMessage; }
+});
+exports.EnhancedStorage = EnhancedStorage;
+exports.EnhancedStorageAdapter = EnhancedStorageAdapter;
+exports.SOLANA_CHAIN_IDS = SOLANA_CHAIN_IDS;
+exports.base58ToSignatureBytes = base58ToSignatureBytes;
+exports.chainIdToClusterId = chainIdToClusterId;
+exports.chainIdToClusterType = chainIdToClusterType;
+exports.clusterToChainId = clusterToChainId;
+exports.copySignature = copySignature;
+exports.createConfig = createConfig;
+exports.createEnhancedStorageAccount = createEnhancedStorageAccount;
+exports.createEnhancedStorageCluster = createEnhancedStorageCluster;
+exports.createEnhancedStorageWallet = createEnhancedStorageWallet;
+exports.createKitSignersFromWallet = createKitSignersFromWallet;
+exports.createMessageSignerFromWallet = createMessageSignerFromWallet;
+exports.createTransactionSendingSignerFromWallet = createTransactionSendingSignerFromWallet;
+exports.detectMessageModification = detectMessageModification;
+exports.formatSignature = formatSignature;
+exports.freezeSigner = freezeSigner;
+exports.getAllExplorerUrls = getAllExplorerUrls;
+exports.getChainIdFromCluster = getChainIdFromCluster;
+exports.getChainIdFromClusterId = getChainIdFromClusterId;
+exports.getChainIdFromClusterType = getChainIdFromClusterType;
+exports.getChainIdFromConnection = getChainIdFromConnection;
+exports.getClusterIdFromChainId = getClusterIdFromChainId;
+exports.getClusterTypeFromChainId = getClusterTypeFromChainId;
+exports.getClusterTypeFromConnection = getClusterTypeFromConnection;
+exports.getDefaultConfig = getDefaultConfig;
+exports.getDefaultMobileConfig = getDefaultMobileConfig;
+exports.getLatestBlockhash = getLatestBlockhash;
+exports.getSolanaExplorerUrl = getSolanaExplorerUrl;
+exports.getSolanaFmUrl = getSolanaFmUrl;
+exports.getSolscanUrl = getSolscanUrl;
+exports.getXrayUrl = getXrayUrl;
+exports.isAccountAddress = isAccountAddress;
+exports.isKitConnection = isKitConnection;
+exports.isKnownSolanaChain = isKnownSolanaChain;
+exports.isLegacyConnection = isLegacyConnection;
+exports.isSolanaChain = isSolanaChain;
+exports.isUnifiedConfig = isUnifiedConfig;
+exports.isWalletName = isWalletName;
+exports.sendRawTransaction = sendRawTransaction;
+exports.signatureBytesToBase58 = signatureBytesToBase58;
+exports.updateSignatureDictionary = updateSignatureDictionary;
+exports.validateKnownSolanaChain = validateKnownSolanaChain;
+//# sourceMappingURL=chunk-P4ZLJI4L.js.map
+//# sourceMappingURL=chunk-P4ZLJI4L.js.map