@moon-x/core 0.2.0

package/dist/web/index.js

@@ -0,0 +1,470 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/web/index.ts
+var web_exports = {};
+__export(web_exports, {
+  createIframeTransport: () => createIframeTransport,
+  createLocalStorageKv: () => createLocalStorageKv,
+  createWebAuthnPasskey: () => createWebAuthnPasskey,
+  getCachedPostMessageClient: () => getCachedPostMessageClient
+});
+module.exports = __toCommonJS(web_exports);
+
+// src/utils/post-message.ts
+var FORWARDED_ERROR_FIELDS = [
+  "error_type",
+  "error_code",
+  "status_code"
+];
+var generateUUID = () => {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+};
+var PostMessageClient = class {
+  constructor(target, origin = "*") {
+    this.target = target;
+    this.origin = origin;
+  }
+  async send(type, method, payload) {
+    const id = generateUUID();
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        window.removeEventListener("message", handler);
+        reject(new Error("Timeout: No response from iframe"));
+      }, 3e4);
+      const handler = (event) => {
+        if (this.origin !== "*" && event.origin !== this.origin) {
+          return;
+        }
+        const response = event.data;
+        if (response.id === id) {
+          clearTimeout(timeout);
+          window.removeEventListener("message", handler);
+          if (response.success) {
+            resolve(response.data);
+          } else {
+            const err = new Error(response.error);
+            for (const key of FORWARDED_ERROR_FIELDS) {
+              const value = response[key];
+              if (value !== void 0) {
+                err[key] = value;
+              }
+            }
+            reject(err);
+          }
+        }
+      };
+      window.addEventListener("message", handler);
+      this.target.postMessage(
+        {
+          id,
+          type,
+          method,
+          payload
+        },
+        this.origin
+      );
+    });
+  }
+  async sendOneWay(type, method, payload) {
+    const id = generateUUID();
+    const envelope = {
+      id,
+      type,
+      method,
+      payload
+    };
+    if (typeof window !== "undefined" && typeof window.ReactNativeWebView !== "undefined") {
+      try {
+        window.ReactNativeWebView.postMessage(JSON.stringify(envelope));
+      } catch {
+      }
+      return;
+    }
+    this.target.postMessage(envelope, this.origin);
+  }
+};
+var isReactNativeWebView = () => typeof window !== "undefined" && typeof window.ReactNativeWebView !== "undefined";
+var sendReactNativeReply = (response) => {
+  try {
+    window.ReactNativeWebView.postMessage(JSON.stringify(response));
+  } catch {
+  }
+};
+var PostMessageServer = class {
+  constructor(originValidator) {
+    this.trustedSources = /* @__PURE__ */ new Set();
+    this.handlers = /* @__PURE__ */ new Map();
+    this.originValidator = originValidator;
+    window.addEventListener("message", this.handleMessage.bind(this));
+  }
+  addTrustedSource(source) {
+    this.trustedSources.add(source);
+  }
+  removeTrustedSource(source) {
+    this.trustedSources.delete(source);
+  }
+  register(type, method, handler) {
+    const key = `${type}:${method}`;
+    this.handlers.set(key, handler);
+  }
+  cleanup() {
+    window.removeEventListener("message", this.handleMessage.bind(this));
+    this.handlers.clear();
+  }
+  static isLocalhostOrigin(origin) {
+    try {
+      const url = new URL(origin);
+      return url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "[::1]";
+    } catch {
+      return false;
+    }
+  }
+  isValidPostMessageRequest(data) {
+    return data && typeof data === "object" && typeof data.id === "string" && typeof data.type === "string" && typeof data.method === "string";
+  }
+  async handleMessage(event) {
+    if (!this.isValidPostMessageRequest(event.data)) {
+      return;
+    }
+    if (!event.origin || event.origin === "null") {
+      console.error("[PostMessageServer] Invalid or null origin received");
+      return;
+    }
+    const request = event.data;
+    const rnMode = isReactNativeWebView();
+    const reply = (response) => {
+      if (rnMode) {
+        sendReactNativeReply(response);
+        return;
+      }
+      if (event.source && event.origin) {
+        event.source.postMessage(response, { targetOrigin: event.origin });
+      }
+    };
+    if (this.originValidator && !rnMode) {
+      const publishableKey = request.payload?.publishableKey;
+      try {
+        const isAllowed = await this.originValidator(
+          event.origin,
+          publishableKey
+        );
+        if (!isAllowed) {
+          reply({
+            id: request.id,
+            type: request.type,
+            success: false,
+            error: `Origin ${event.origin} is not whitelisted. Please add it to your MoonKey dashboard.`
+          });
+          return;
+        }
+      } catch (error) {
+        reply({
+          id: request.id,
+          type: request.type,
+          success: false,
+          error: "Origin validation failed"
+        });
+        return;
+      }
+    }
+    const key = `${request.type}:${request.method}`;
+    const handler = this.handlers.get(key);
+    if (handler) {
+      try {
+        const data = await handler(request.payload);
+        reply({
+          id: request.id,
+          type: request.type,
+          success: true,
+          data
+        });
+      } catch (error) {
+        const extras = {};
+        if (error && typeof error === "object") {
+          for (const key2 of FORWARDED_ERROR_FIELDS) {
+            const value = error[key2];
+            if (value !== void 0) extras[key2] = value;
+          }
+        }
+        reply({
+          ...extras,
+          id: request.id,
+          type: request.type,
+          success: false,
+          error: error instanceof Error ? error.message : "Unknown error"
+        });
+      }
+    }
+  }
+};
+
+// src/utils/get-iframe-url.ts
+var DEFAULT_IFRAME_PROJECT_NAME = "moonx-wallet-iframe";
+var joinUrl = (baseUrl, path) => {
+  if (!path) return baseUrl;
+  const normalizedBase = baseUrl.replace(/\/$/, "");
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  return `${normalizedBase}${normalizedPath}`;
+};
+var withBypass = (url) => {
+  const bypass = process.env.NEXT_PUBLIC_VERCEL_PROTECTION_BYPASS;
+  if (!bypass) return url;
+  const separator = url.includes("?") ? "&" : "?";
+  return `${url}${separator}x-vercel-protection-bypass=${bypass}&x-vercel-set-bypass-cookie=samesitenone`;
+};
+var getIframeUrl = (path = "") => {
+  if (process.env.NEXT_PUBLIC_VERCEL_ENV === "preview" && process.env.NEXT_PUBLIC_VERCEL_BRANCH_URL) {
+    const vercelUrl = process.env.NEXT_PUBLIC_VERCEL_BRANCH_URL.replace(
+      /^https?:\/\//,
+      ""
+    ).replace(/\/$/, "");
+    const iframeProjectName = process.env.NEXT_PUBLIC_MOONKEY_IFRAME_PROJECT_NAME || DEFAULT_IFRAME_PROJECT_NAME;
+    const iframeUrl = /-git-/.test(vercelUrl) ? vercelUrl.replace(/^[^.]+?-git-/, `${iframeProjectName}-git-`) : (
+      // Fallback: legacy `{prefix}-{hash}.vercel.app` style
+      vercelUrl.replace(/^[^-]+-/, `${iframeProjectName}-`)
+    );
+    return withBypass(joinUrl(`https://${iframeUrl}`, path));
+  }
+  if (process.env.NEXT_PUBLIC_MOONKEY_IFRAME_URL) {
+    return joinUrl(process.env.NEXT_PUBLIC_MOONKEY_IFRAME_URL, path);
+  }
+  return joinUrl("https://iframe.moonx-dev.com", path);
+};
+var getIframeOrigin = (url) => {
+  try {
+    const urlObj = new URL(url);
+    return urlObj.origin;
+  } catch (error) {
+    console.error("Invalid URL:", url);
+    return "";
+  }
+};
+
+// src/web/iframe-transport.ts
+var clientCache = /* @__PURE__ */ new WeakMap();
+var getCachedPostMessageClient = (contentWindow) => {
+  const iframeUrl = getIframeUrl();
+  const iframeOrigin = getIframeOrigin(iframeUrl);
+  let perTarget = clientCache.get(contentWindow);
+  if (!perTarget) {
+    perTarget = /* @__PURE__ */ new Map();
+    clientCache.set(contentWindow, perTarget);
+  }
+  let client = perTarget.get(iframeOrigin);
+  if (!client) {
+    client = new PostMessageClient(contentWindow, iframeOrigin);
+    perTarget.set(iframeOrigin, client);
+  }
+  return client;
+};
+var createIframeTransport = ({
+  getContentWindow,
+  isReady
+}) => ({
+  send: async (type, method, payload) => {
+    const contentWindow = getContentWindow();
+    if (!contentWindow) throw new Error("iframe_not_ready");
+    const client = getCachedPostMessageClient(contentWindow);
+    return client.send(type, method, payload);
+  },
+  register: (type, method, handler) => {
+    const server = new PostMessageServer();
+    server.register(type, method, async (payload) => handler(payload));
+    return () => {
+    };
+  },
+  isReady
+});
+
+// src/lib/auth/authentication-state.ts
+var AuthenticationState = class {
+  constructor() {
+    this.email = null;
+  }
+  setEmail(email) {
+    this.email = email;
+  }
+  getEmail() {
+    return this.email;
+  }
+  clearEmail() {
+    this.email = null;
+  }
+  clear() {
+    this.clearEmail();
+  }
+};
+var authState = new AuthenticationState();
+
+// src/lib/passkey/passkey-codec.ts
+var fromB64url = (b64url) => {
+  const base64 = b64url.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+  const binary = atob(padded);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+};
+var toB64url = (bytes) => {
+  let str = "";
+  for (let i = 0; i < bytes.length; i++) str += String.fromCharCode(bytes[i]);
+  return btoa(str).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+};
+
+// src/lib/ethereum/chains.ts
+var import_viem = require("viem");
+
+// src/lib/ethereum/siwe.ts
+var import_siwe = require("siwe");
+var import_viem2 = require("viem");
+
+// src/lib/ethereum/tx-prep.ts
+var import_viem3 = require("viem");
+
+// src/lib/solana/siws.ts
+var nacl = __toESM(require("tweetnacl"));
+
+// src/lib/solana/transaction-log-parser.ts
+var import_web3 = require("@solana/web3.js");
+var import_bn = __toESM(require("bn.js"));
+
+// src/web/webauthn-passkey.ts
+var createWebAuthnPasskey = () => ({
+  assert: async ({ rpId, challenge }) => {
+    const challengeBytes = fromB64url(challenge);
+    const credential = await navigator.credentials.get({
+      publicKey: {
+        challenge: challengeBytes,
+        rpId,
+        userVerification: "preferred",
+        // Empty allowCredentials → discoverable login → userHandle is
+        // REQUIRED on the response. See `parent-passkey-assert.ts`
+        // for the full rationale.
+        allowCredentials: []
+      }
+    });
+    if (!credential) throw new Error("passkey_assertion_cancelled");
+    const assertion = credential.response;
+    if (!assertion.userHandle) {
+      throw new Error("user_handle_missing");
+    }
+    return {
+      rawIdB64url: toB64url(new Uint8Array(credential.rawId)),
+      userHandleB64url: toB64url(new Uint8Array(assertion.userHandle))
+    };
+  },
+  create: async ({
+    rpId,
+    rpName,
+    userId,
+    userName,
+    userDisplayName,
+    challenge,
+    excludeCredentials
+  }) => {
+    const challengeBytes = fromB64url(challenge);
+    const credential = await navigator.credentials.create({
+      publicKey: {
+        rp: { id: rpId, name: rpName },
+        user: {
+          id: userId,
+          name: userName,
+          displayName: userDisplayName
+        },
+        challenge: challengeBytes,
+        pubKeyCredParams: [
+          { type: "public-key", alg: -7 },
+          // ES256
+          { type: "public-key", alg: -257 }
+          // RS256
+        ],
+        authenticatorSelection: {
+          residentKey: "required",
+          userVerification: "preferred"
+        },
+        excludeCredentials: (excludeCredentials ?? []).map((id) => ({
+          id: fromB64url(id),
+          type: "public-key"
+        }))
+      }
+    });
+    if (!credential) throw new Error("passkey_registration_cancelled");
+    const attestation = credential.response;
+    return {
+      rawIdB64url: toB64url(new Uint8Array(credential.rawId)),
+      clientDataJSONB64url: toB64url(new Uint8Array(attestation.clientDataJSON)),
+      attestationObjectB64url: toB64url(
+        new Uint8Array(attestation.attestationObject)
+      )
+    };
+  }
+});
+
+// src/web/local-storage-kv.ts
+var createLocalStorageKv = (prefix = "moonkey:") => ({
+  get: async (key) => {
+    if (typeof window === "undefined") return null;
+    try {
+      return localStorage.getItem(prefix + key);
+    } catch {
+      return null;
+    }
+  },
+  set: async (key, value) => {
+    if (typeof window === "undefined") return;
+    try {
+      localStorage.setItem(prefix + key, value);
+    } catch (error) {
+      console.error("LocalStorageKv.set failed:", error);
+    }
+  },
+  remove: async (key) => {
+    if (typeof window === "undefined") return;
+    try {
+      localStorage.removeItem(prefix + key);
+    } catch (error) {
+      console.error("LocalStorageKv.remove failed:", error);
+    }
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createIframeTransport,
+  createLocalStorageKv,
+  createWebAuthnPasskey,
+  getCachedPostMessageClient
+});

package/dist/web/index.mjs

@@ -0,0 +1,155 @@
+import {
+  getIframeOrigin,
+  getIframeUrl
+} from "../chunk-264CEGDS.mjs";
+import {
+  PostMessageClient,
+  PostMessageServer
+} from "../chunk-SOKLPX7V.mjs";
+import {
+  fromB64url,
+  toB64url
+} from "../chunk-CDT4MC7S.mjs";
+import "../chunk-GQKIA37O.mjs";
+
+// src/web/iframe-transport.ts
+var clientCache = /* @__PURE__ */ new WeakMap();
+var getCachedPostMessageClient = (contentWindow) => {
+  const iframeUrl = getIframeUrl();
+  const iframeOrigin = getIframeOrigin(iframeUrl);
+  let perTarget = clientCache.get(contentWindow);
+  if (!perTarget) {
+    perTarget = /* @__PURE__ */ new Map();
+    clientCache.set(contentWindow, perTarget);
+  }
+  let client = perTarget.get(iframeOrigin);
+  if (!client) {
+    client = new PostMessageClient(contentWindow, iframeOrigin);
+    perTarget.set(iframeOrigin, client);
+  }
+  return client;
+};
+var createIframeTransport = ({
+  getContentWindow,
+  isReady
+}) => ({
+  send: async (type, method, payload) => {
+    const contentWindow = getContentWindow();
+    if (!contentWindow) throw new Error("iframe_not_ready");
+    const client = getCachedPostMessageClient(contentWindow);
+    return client.send(type, method, payload);
+  },
+  register: (type, method, handler) => {
+    const server = new PostMessageServer();
+    server.register(type, method, async (payload) => handler(payload));
+    return () => {
+    };
+  },
+  isReady
+});
+
+// src/web/webauthn-passkey.ts
+var createWebAuthnPasskey = () => ({
+  assert: async ({ rpId, challenge }) => {
+    const challengeBytes = fromB64url(challenge);
+    const credential = await navigator.credentials.get({
+      publicKey: {
+        challenge: challengeBytes,
+        rpId,
+        userVerification: "preferred",
+        // Empty allowCredentials → discoverable login → userHandle is
+        // REQUIRED on the response. See `parent-passkey-assert.ts`
+        // for the full rationale.
+        allowCredentials: []
+      }
+    });
+    if (!credential) throw new Error("passkey_assertion_cancelled");
+    const assertion = credential.response;
+    if (!assertion.userHandle) {
+      throw new Error("user_handle_missing");
+    }
+    return {
+      rawIdB64url: toB64url(new Uint8Array(credential.rawId)),
+      userHandleB64url: toB64url(new Uint8Array(assertion.userHandle))
+    };
+  },
+  create: async ({
+    rpId,
+    rpName,
+    userId,
+    userName,
+    userDisplayName,
+    challenge,
+    excludeCredentials
+  }) => {
+    const challengeBytes = fromB64url(challenge);
+    const credential = await navigator.credentials.create({
+      publicKey: {
+        rp: { id: rpId, name: rpName },
+        user: {
+          id: userId,
+          name: userName,
+          displayName: userDisplayName
+        },
+        challenge: challengeBytes,
+        pubKeyCredParams: [
+          { type: "public-key", alg: -7 },
+          // ES256
+          { type: "public-key", alg: -257 }
+          // RS256
+        ],
+        authenticatorSelection: {
+          residentKey: "required",
+          userVerification: "preferred"
+        },
+        excludeCredentials: (excludeCredentials ?? []).map((id) => ({
+          id: fromB64url(id),
+          type: "public-key"
+        }))
+      }
+    });
+    if (!credential) throw new Error("passkey_registration_cancelled");
+    const attestation = credential.response;
+    return {
+      rawIdB64url: toB64url(new Uint8Array(credential.rawId)),
+      clientDataJSONB64url: toB64url(new Uint8Array(attestation.clientDataJSON)),
+      attestationObjectB64url: toB64url(
+        new Uint8Array(attestation.attestationObject)
+      )
+    };
+  }
+});
+
+// src/web/local-storage-kv.ts
+var createLocalStorageKv = (prefix = "moonkey:") => ({
+  get: async (key) => {
+    if (typeof window === "undefined") return null;
+    try {
+      return localStorage.getItem(prefix + key);
+    } catch {
+      return null;
+    }
+  },
+  set: async (key, value) => {
+    if (typeof window === "undefined") return;
+    try {
+      localStorage.setItem(prefix + key, value);
+    } catch (error) {
+      console.error("LocalStorageKv.set failed:", error);
+    }
+  },
+  remove: async (key) => {
+    if (typeof window === "undefined") return;
+    try {
+      localStorage.removeItem(prefix + key);
+    } catch (error) {
+      console.error("LocalStorageKv.remove failed:", error);
+    }
+  }
+});
+export {
+  createIframeTransport,
+  createLocalStorageKv,
+  createWebAuthnPasskey,
+  getCachedPostMessageClient
+};