@moon-x/core 0.10.1 → 0.11.0

package/dist/lib/index.js

@@ -39,16 +39,17 @@ __export(lib_exports, {
   broadcastEthereumRaw: () => broadcastEthereumRaw,
   broadcastSolanaSigned: () => broadcastSolanaSigned,
   bs58ToBytes: () => bs58ToBytes,
+  buildChainIndex: () => buildChainIndex,
   buildUrl: () => buildUrl,
   canonicalAlgorithmFor: () => canonicalAlgorithmFor,
   createManualSiweMessage: () => createManualSiweMessage,
+  entryCaip2: () => entryCaip2,
   estimateEvmGas: () => estimateEvmGas,
   estimateEvmGasReserve: () => estimateEvmGasReserve,
   formatPasskeyLabel: () => formatPasskeyLabel,
   fromB64url: () => fromB64url,
   generatePasskeyUserId: () => generatePasskeyUserId,
   getChainById: () => getChainById,
-  getDefaultChain: () => getDefaultChain,
   getEvmGasPrice: () => getEvmGasPrice,
   getEvmMaxPriorityFeePerGas: () => getEvmMaxPriorityFeePerGas,
   getEvmNonce: () => getEvmNonce,
@@ -57,14 +58,21 @@ __export(lib_exports, {
   getSOLTransfersFromInstructions: () => getSOLTransfersFromInstructions,
   getTransferInfoFromInstructions: () => getTransferInfoFromInstructions,
   isChainSupported: () => isChainSupported,
+  isEvmEntry: () => isEvmEntry,
+  normalizeChainItem: () => normalizeChainItem,
+  normalizeChainKey: () => normalizeChainKey,
   parseDerivationPath: () => parseDerivationPath,
   prepareEvmSendTransaction: () => prepareEvmSendTransaction,
   prepareEvmSignTransaction: () => prepareEvmSignTransaction,
+  resolveChainEntry: () => resolveChainEntry,
   resolveEvmChain: () => resolveEvmChain,
+  resolveEvmChainEntry: () => resolveEvmChainEntry,
   resolvePasskeyMetadata: () => resolvePasskeyMetadata,
+  resolveRpcUrl: () => resolveRpcUrl,
+  resolveSolanaChainEntry: () => resolveSolanaChainEntry,
+  resolveWsUrl: () => resolveWsUrl,
   sanitizeUserData: () => sanitizeUserData,
   serializeEthereumTransaction: () => serializeEthereumTransaction,
-  setChainRpcUrl: () => setChainRpcUrl,
   toB64url: () => toB64url,
   validateChainConfig: () => validateChainConfig,
   verifyIdToken: () => verifyIdToken
@@ -362,18 +370,6 @@ function resolvePasskeyMetadata(input) {
 
 // src/lib/ethereum/chains.ts
 var import_viem = require("viem");
-function setChainRpcUrl(chain, rpcUrl) {
-  return {
-    ...chain,
-    rpcUrls: {
-      ...chain.rpcUrls,
-      default: {
-        http: [rpcUrl],
-        webSocket: chain.rpcUrls.default.webSocket
-      }
-    }
-  };
-}
 function getRpcUrl(chain) {
   return chain.rpcUrls.default.http[0];
 }
@@ -506,35 +502,152 @@ async function estimateEvmGasReserve(rpcUrl, chainId, opts = {}) {
   return Number((0, import_viem.formatEther)(reserveWei));
 }
 function getChainById(chains, chainId) {
-  return chains.find((chain) => chain.id === chainId);
+  for (const item of chains) {
+    const entry = normalizeChainItem(item);
+    if (isEvmEntry(entry) && entry.chain.id === chainId) return entry.chain;
+  }
+  return void 0;
 }
 function isChainSupported(chains, chainId) {
-  return chains.some((chain) => chain.id === chainId);
+  return getChainById(chains, chainId) !== void 0;
 }
-function validateChainConfig(config) {
-  const { defaultChain, supportedChains } = config;
-  if (supportedChains && supportedChains.length === 0) {
-    throw new Error("supportedChains cannot be an empty array");
+function isEvmEntry(entry) {
+  return "chain" in entry;
+}
+function normalizeChainItem(item) {
+  if ("chain" in item) return item;
+  if (typeof item.id === "number") {
+    return { chain: item };
   }
-  if (defaultChain && supportedChains) {
-    const isDefaultInSupported = supportedChains.some(
-      (chain) => chain.id === defaultChain.id
-    );
-    if (!isDefaultInSupported) {
+  return item;
+}
+function entryCaip2(entry) {
+  return isEvmEntry(entry) ? `eip155:${entry.chain.id}` : entry.id;
+}
+function slug(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function aliasesFor(entry) {
+  const keys = [];
+  if (isEvmEntry(entry)) {
+    const { chain } = entry;
+    keys.push(`eip155:${chain.id}`, String(chain.id));
+    if (chain.name) {
+      const s = slug(chain.name);
+      keys.push(`eth:${s}`, s);
+    }
+    if (chain.network) {
+      const s = slug(chain.network);
+      keys.push(`eth:${s}`, s);
+    }
+  } else {
+    keys.push(entry.id);
+    const cluster = entry.id.split(":")[1];
+    if (cluster) keys.push(`solana:${cluster}`, `sol:${cluster}`, cluster);
+  }
+  return keys;
+}
+function normalizeChainKey(key) {
+  if (typeof key === "number") return `eip155:${key}`;
+  if (typeof key === "string") return key.trim().toLowerCase();
+  const id = key?.id;
+  throw new Error(
+    typeof id === "number" ? `Invalid chain reference: expected an alias, CAIP-2 id, or numeric chainId, but got a chain object. Use "eip155:${id}" or ${id}.` : `Invalid chain reference: expected a string alias / CAIP-2 id or a numeric chainId, got ${typeof key}.`
+  );
+}
+function buildChainIndex(chains = []) {
+  const entries = chains.map(normalizeChainItem);
+  const byAlias = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const alias of aliasesFor(entry)) {
+      const key = alias.toLowerCase();
+      if (!byAlias.has(key)) byAlias.set(key, entry);
+    }
+  }
+  return { entries, byAlias };
+}
+function resolveChainEntry(chains, selector, defaultSelector) {
+  const index = buildChainIndex(chains ?? []);
+  if (selector != null) {
+    return index.byAlias.get(normalizeChainKey(selector));
+  }
+  if (defaultSelector != null) {
+    const fallback = index.byAlias.get(normalizeChainKey(defaultSelector));
+    if (fallback) return fallback;
+  }
+  return index.entries[0];
+}
+function resolveSolanaChainEntry(chains, selector, defaultSelector) {
+  const index = buildChainIndex(chains ?? []);
+  const asSolana = (k) => {
+    if (k == null) return void 0;
+    const e = index.byAlias.get(normalizeChainKey(k));
+    return e && !isEvmEntry(e) ? e : void 0;
+  };
+  if (selector != null) return asSolana(selector);
+  return asSolana(defaultSelector) ?? index.entries.find((e) => !isEvmEntry(e));
+}
+function resolveEvmChainEntry(opts) {
+  const index = buildChainIndex(opts.chains ?? []);
+  const lookup = (k) => {
+    if (k == null) return void 0;
+    const e = index.byAlias.get(normalizeChainKey(k));
+    return e && isEvmEntry(e) ? e : void 0;
+  };
+  if (opts.selector != null) return lookup(opts.selector);
+  if (opts.requestedChainId != null) return lookup(opts.requestedChainId);
+  return lookup(opts.walletChainId) ?? lookup(opts.defaultSelector) ?? index.entries.find(isEvmEntry);
+}
+function resolveRpcUrl(entry, override) {
+  if (override) return override;
+  if (isEvmEntry(entry)) return entry.rpcUrl ?? getRpcUrl(entry.chain);
+  return entry.rpcUrl;
+}
+function resolveWsUrl(entry, override) {
+  if (override) return override;
+  if (isEvmEntry(entry)) {
+    return entry.wsUrl ?? entry.chain.rpcUrls.default.webSocket?.[0];
+  }
+  return entry.wsUrl;
+}
+function validateChainConfig(config) {
+  const { chains, defaultChain } = config;
+  if (defaultChain != null) {
+    if (typeof defaultChain !== "string" && typeof defaultChain !== "number") {
+      const id = defaultChain.id;
+      throw new Error(
+        `defaultChain must be a chain reference (alias, CAIP-2 id, or numeric chainId), not a chain object.${typeof id === "number" ? ` Use "eip155:${id}" or ${id}.` : ""}`
+      );
+    }
+    if (!chains || chains.length === 0) {
       throw new Error(
-        `defaultChain (${defaultChain.name}, ID: ${defaultChain.id}) must be included in supportedChains`
+        `defaultChain "${defaultChain}" is set but no \`chains\` are configured. Add the chain to \`chains\`, or remove \`defaultChain\`.`
       );
     }
   }
-}
-function getDefaultChain(config) {
-  if (config.defaultChain) {
-    return config.defaultChain;
+  if (!chains) return;
+  if (chains.length === 0) {
+    throw new Error("chains cannot be an empty array");
   }
-  if (config.supportedChains && config.supportedChains.length > 0) {
-    return config.supportedChains[0];
+  const index = buildChainIndex(chains);
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of index.entries) {
+    const id = entryCaip2(entry);
+    if (seen.has(id)) {
+      throw new Error(`Duplicate chain in config: ${id}`);
+    }
+    seen.add(id);
+    if (!isEvmEntry(entry) && !entry.rpcUrl) {
+      throw new Error(`Solana chain "${entry.id}" is missing an rpcUrl`);
+    }
+  }
+  if (defaultChain != null && !index.byAlias.get(normalizeChainKey(defaultChain))) {
+    throw new Error(
+      `defaultChain "${defaultChain}" is not in the configured chains (${[
+        ...seen
+      ].join(", ")})`
+    );
   }
-  return void 0;
 }
 
 // src/lib/ethereum/siwe.ts
@@ -615,54 +728,91 @@ ${fields.join("\n")}`;
 
 // src/lib/ethereum/tx-prep.ts
 var import_viem3 = require("viem");
+function syntheticChain(chainId, rpcUrl) {
+  return {
+    id: chainId,
+    name: `chain-${chainId}`,
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  };
+}
 function resolveEvmChain({
+  chains,
+  chainSelector,
   requestedChainId,
   walletChainId,
-  supportedChains,
   defaultChain,
+  rpcUrlOverride,
   strict = false
 }) {
-  let target;
-  if (requestedChainId && supportedChains) {
-    target = getChainById(supportedChains, Number(requestedChainId));
-  }
-  if (!target && walletChainId && supportedChains) {
-    target = getChainById(supportedChains, walletChainId);
+  if (chainSelector != null) {
+    const entry2 = resolveEvmChainEntry({ chains, selector: chainSelector });
+    if (!entry2) {
+      throw new Error(
+        `chain "${chainSelector}" is not in the configured chains.`
+      );
+    }
+    return { chain: entry2.chain, rpcUrl: resolveRpcUrl(entry2, rpcUrlOverride) };
   }
-  if (!target) {
-    target = defaultChain;
+  if (requestedChainId != null) {
+    const entry2 = resolveEvmChainEntry({ chains, requestedChainId });
+    if (entry2) {
+      return {
+        chain: entry2.chain,
+        rpcUrl: resolveRpcUrl(entry2, rpcUrlOverride)
+      };
+    }
+    if (rpcUrlOverride) {
+      return {
+        chain: syntheticChain(Number(requestedChainId), rpcUrlOverride),
+        rpcUrl: rpcUrlOverride
+      };
+    }
+    if (strict) {
+      throw new Error(
+        `Requested chainId ${requestedChainId} is not in the configured chains.`
+      );
+    }
   }
-  if (!target) {
-    throw new Error(
-      "No chain configured. Please set ethereum.defaultChain in MoonKeyProvider config."
-    );
+  const entry = resolveEvmChainEntry({
+    chains,
+    walletChainId,
+    defaultSelector: defaultChain
+  });
+  if (entry) {
+    return { chain: entry.chain, rpcUrl: resolveRpcUrl(entry, rpcUrlOverride) };
   }
-  if (strict && requestedChainId && Number(requestedChainId) !== target.id) {
-    throw new Error(
-      `Requested chainId ${requestedChainId} is not in the configured supportedChains.`
-    );
+  if (rpcUrlOverride && requestedChainId != null) {
+    return {
+      chain: syntheticChain(Number(requestedChainId), rpcUrlOverride),
+      rpcUrl: rpcUrlOverride
+    };
   }
-  return target;
+  throw new Error(
+    "No chain configured. Set `chains` (and optionally `defaultChain`) in MoonKeyProvider config, or pass an `rpcUrl` together with the transaction's `chainId`."
+  );
 }
 async function prepareEvmSignTransaction({
   transaction,
   wallet,
-  supportedChains,
-  defaultChain
+  chains,
+  defaultChain,
+  chainSelector
 }) {
   if (typeof transaction === "string") {
     return { serializedTransaction: transaction, chain: void 0 };
   }
   const txObj = transaction;
   const transactionType = txObj.type ?? 2;
-  const chain = resolveEvmChain({
+  const { chain } = resolveEvmChain({
+    chains,
+    chainSelector,
     requestedChainId: txObj.chainId,
     walletChainId: wallet.chainId,
-    supportedChains,
     defaultChain,
     strict: false
   });
-  const derivedChainId = txObj.chainId || chain.id;
+  const derivedChainId = chainSelector != null ? chain.id : txObj.chainId || chain.id;
   const formattedTransaction = {
     to: txObj.to,
     value: txObj.value ? typeof txObj.value === "bigint" ? txObj.value : (0, import_viem3.parseEther)(txObj.value.toString()) : BigInt(0),
@@ -694,17 +844,20 @@ async function prepareEvmSignTransaction({
 async function prepareEvmSendTransaction({
   transaction,
   wallet,
-  supportedChains,
-  defaultChain
+  chains,
+  defaultChain,
+  chainSelector,
+  rpcUrlOverride
 }) {
-  const chain = resolveEvmChain({
+  const { chain, rpcUrl } = resolveEvmChain({
+    chains,
+    chainSelector,
     requestedChainId: transaction.chainId,
     walletChainId: wallet.chainId,
-    supportedChains,
     defaultChain,
+    rpcUrlOverride,
     strict: true
   });
-  const rpcUrl = getRpcUrl(chain);
   if (!rpcUrl) {
     throw new Error(
       `No RPC URL found for chain ${chain.name}. Chain may be missing rpcUrls configuration.`
@@ -1566,16 +1719,17 @@ var bs58ToBytes = async (value) => {
   broadcastEthereumRaw,
   broadcastSolanaSigned,
   bs58ToBytes,
+  buildChainIndex,
   buildUrl,
   canonicalAlgorithmFor,
   createManualSiweMessage,
+  entryCaip2,
   estimateEvmGas,
   estimateEvmGasReserve,
   formatPasskeyLabel,
   fromB64url,
   generatePasskeyUserId,
   getChainById,
-  getDefaultChain,
   getEvmGasPrice,
   getEvmMaxPriorityFeePerGas,
   getEvmNonce,
@@ -1584,14 +1738,21 @@ var bs58ToBytes = async (value) => {
   getSOLTransfersFromInstructions,
   getTransferInfoFromInstructions,
   isChainSupported,
+  isEvmEntry,
+  normalizeChainItem,
+  normalizeChainKey,
   parseDerivationPath,
   prepareEvmSendTransaction,
   prepareEvmSignTransaction,
+  resolveChainEntry,
   resolveEvmChain,
+  resolveEvmChainEntry,
   resolvePasskeyMetadata,
+  resolveRpcUrl,
+  resolveSolanaChainEntry,
+  resolveWsUrl,
   sanitizeUserData,
   serializeEthereumTransaction,
-  setChainRpcUrl,
   toB64url,
   validateChainConfig,
   verifyIdToken

package/dist/lib/index.mjs

@@ -8,16 +8,17 @@ import {
   broadcastEthereumRaw,
   broadcastSolanaSigned,
   bs58ToBytes,
+  buildChainIndex,
   buildUrl,
   canonicalAlgorithmFor,
   createManualSiweMessage,
+  entryCaip2,
   estimateEvmGas,
   estimateEvmGasReserve,
   formatPasskeyLabel,
   fromB64url,
   generatePasskeyUserId,
   getChainById,
-  getDefaultChain,
   getEvmGasPrice,
   getEvmMaxPriorityFeePerGas,
   getEvmNonce,
@@ -26,18 +27,25 @@ import {
   getSOLTransfersFromInstructions,
   getTransferInfoFromInstructions,
   isChainSupported,
+  isEvmEntry,
+  normalizeChainItem,
+  normalizeChainKey,
   parseDerivationPath,
   prepareEvmSendTransaction,
   prepareEvmSignTransaction,
+  resolveChainEntry,
   resolveEvmChain,
+  resolveEvmChainEntry,
   resolvePasskeyMetadata,
+  resolveRpcUrl,
+  resolveSolanaChainEntry,
+  resolveWsUrl,
   sanitizeUserData,
   serializeEthereumTransaction,
-  setChainRpcUrl,
   toB64url,
   validateChainConfig,
   verifyIdToken
-} from "../chunk-T3ESQWEP.mjs";
+} from "../chunk-W6BYGZ2F.mjs";
 import "../chunk-GQKIA37O.mjs";
 export {
   DEFAULT_AUTH_URL,
@@ -49,16 +57,17 @@ export {
   broadcastEthereumRaw,
   broadcastSolanaSigned,
   bs58ToBytes,
+  buildChainIndex,
   buildUrl,
   canonicalAlgorithmFor,
   createManualSiweMessage,
+  entryCaip2,
   estimateEvmGas,
   estimateEvmGasReserve,
   formatPasskeyLabel,
   fromB64url,
   generatePasskeyUserId,
   getChainById,
-  getDefaultChain,
   getEvmGasPrice,
   getEvmMaxPriorityFeePerGas,
   getEvmNonce,
@@ -67,14 +76,21 @@ export {
   getSOLTransfersFromInstructions,
   getTransferInfoFromInstructions,
   isChainSupported,
+  isEvmEntry,
+  normalizeChainItem,
+  normalizeChainKey,
   parseDerivationPath,
   prepareEvmSendTransaction,
   prepareEvmSignTransaction,
+  resolveChainEntry,
   resolveEvmChain,
+  resolveEvmChainEntry,
   resolvePasskeyMetadata,
+  resolveRpcUrl,
+  resolveSolanaChainEntry,
+  resolveWsUrl,
   sanitizeUserData,
   serializeEthereumTransaction,
-  setChainRpcUrl,
   toB64url,
   validateChainConfig,
   verifyIdToken

package/dist/react/index.mjs

@@ -1,7 +1,7 @@
 import {
   formatPasskeyLabel,
   resolvePasskeyMetadata
-} from "../chunk-T3ESQWEP.mjs";
+} from "../chunk-W6BYGZ2F.mjs";
 import "../chunk-GQKIA37O.mjs";
 import {
   SDKProvider,

package/dist/sdk/index.mjs

@@ -10,7 +10,7 @@ import {
   bs58ToBytes,
   serializeEthereumTransaction,
   toB64url
-} from "../chunk-T3ESQWEP.mjs";
+} from "../chunk-W6BYGZ2F.mjs";
 import "../chunk-GQKIA37O.mjs";
 
 // src/sdk/interfaces.ts