@dipansrimany/mlink-sdk 0.3.1 → 0.4.2

package/dist/react/index.mjs

@@ -16,6 +16,8 @@ var MANTLE_SEPOLIA = {
 };
 var DEFAULT_CHAIN = MANTLE_SEPOLIA;
 var ACTION_QUERY_PARAM = "action";
+var REGISTRY_URL = "https://mlinks-fe.vercel.app";
+var REGISTRY_VALIDATE_ENDPOINT = "/api/registry/validate";
 
 // src/utils.ts
 function parseBlinkUrl(blinkUrl) {
@@ -39,18 +41,113 @@ var ActionButtonSchema = z.object({
   placeholder: z.string().optional(),
   disabled: z.boolean().optional()
 });
+z.enum([
+  "text",
+  "number",
+  "email",
+  "url",
+  "date",
+  "datetime-local",
+  "textarea",
+  "select",
+  "radio",
+  "checkbox",
+  "address",
+  "token",
+  "amount"
+]);
+var ActionParameterOptionSchema = z.object({
+  label: z.string().min(1),
+  value: z.string(),
+  selected: z.boolean().optional()
+});
+var ActionParameterBaseSchema = z.object({
+  name: z.string().min(1).max(50),
+  label: z.string().max(100).optional(),
+  required: z.boolean().optional(),
+  pattern: z.string().optional(),
+  patternDescription: z.string().optional(),
+  min: z.union([z.string(), z.number()]).optional(),
+  max: z.union([z.string(), z.number()]).optional()
+});
+var ActionParameterSchema = ActionParameterBaseSchema.extend({
+  type: z.enum([
+    "text",
+    "number",
+    "email",
+    "url",
+    "date",
+    "datetime-local",
+    "textarea",
+    "address",
+    "token",
+    "amount"
+  ]).optional()
+});
+var ActionParameterSelectableSchema = ActionParameterBaseSchema.extend({
+  type: z.enum(["select", "radio", "checkbox"]),
+  options: z.array(ActionParameterOptionSchema).min(1)
+});
+var TypedActionParameterSchema = z.union([
+  ActionParameterSelectableSchema,
+  ActionParameterSchema
+]);
+var LinkedActionTypeSchema = z.enum(["transaction", "post", "external-link"]);
+var LinkedActionSchema = z.object({
+  type: LinkedActionTypeSchema.optional(),
+  href: z.string().min(1),
+  label: z.string().min(1).max(50),
+  disabled: z.boolean().optional(),
+  parameters: z.array(TypedActionParameterSchema).optional()
+});
+var ActionLinksSchema = z.object({
+  actions: z.array(LinkedActionSchema).min(1)
+});
+var PostNextActionLinkSchema = z.object({
+  type: z.literal("post"),
+  href: z.string().min(1)
+});
+var InlineNextActionLinkSchema = z.object({
+  type: z.literal("inline"),
+  action: z.lazy(() => ActionMetadataSchema)
+});
+var NextActionLinkSchema = z.union([
+  PostNextActionLinkSchema,
+  InlineNextActionLinkSchema
+]);
+var iconSchema = z.string().refine(
+  (val) => {
+    if (val.startsWith("http://") || val.startsWith("https://")) return true;
+    if (val.startsWith("data:image/")) return true;
+    if (val.startsWith("/")) return true;
+    return false;
+  },
+  { message: "Icon must be a valid URL, base64 data URI, or relative path" }
+);
 var ActionMetadataSchema = z.object({
-  title: z.string().min(1).max(100),
-  icon: z.string().url(),
-  description: z.string().min(1).max(500),
-  actions: z.array(ActionButtonSchema).min(1),
+  type: z.enum(["action", "completed"]).optional(),
+  title: z.string().min(1).max(200),
+  icon: iconSchema,
+  description: z.string().min(1).max(1e3),
+  label: z.string().max(50).optional(),
+  // Legacy actions (optional)
+  actions: z.array(ActionButtonSchema).optional(),
+  // Solana-style linked actions (optional)
+  links: ActionLinksSchema.optional(),
   disabled: z.boolean().optional(),
   error: z.object({ message: z.string() }).optional()
-});
+}).refine(
+  (data) => {
+    return data.actions && data.actions.length > 0 || data.links?.actions && data.links.actions.length > 0;
+  },
+  { message: "Must have at least one action or linked action" }
+);
 z.object({
   account: z.string().regex(addressRegex, "Invalid Ethereum address"),
   action: z.string().min(1),
-  input: z.string().optional()
+  input: z.string().optional(),
+  // Solana-style parameter data
+  data: z.record(z.union([z.string(), z.array(z.string())])).optional()
 });
 var EVMTransactionSchema = z.object({
   to: z.string().regex(addressRegex, "Invalid to address"),
@@ -58,10 +155,22 @@ var EVMTransactionSchema = z.object({
   data: z.string().regex(hexRegex, "Invalid hex data"),
   chainId: z.number().positive()
 });
-var TransactionResponseSchema = z.object({
-  transaction: EVMTransactionSchema,
-  message: z.string().optional()
-});
+z.object({
+  // Single transaction (legacy)
+  transaction: EVMTransactionSchema.optional(),
+  // Multiple transactions (batch)
+  transactions: z.array(EVMTransactionSchema).optional(),
+  message: z.string().optional(),
+  // Action chaining
+  links: z.object({
+    next: NextActionLinkSchema.optional()
+  }).optional()
+}).refine(
+  (data) => {
+    return data.transaction !== void 0 || data.transactions && data.transactions.length > 0;
+  },
+  { message: "Must have either transaction or transactions" }
+);
 function validateActionMetadata(data) {
   const result = ActionMetadataSchema.safeParse(data);
   if (result.success) {
@@ -69,33 +178,77 @@ function validateActionMetadata(data) {
   }
   return { success: false, error: result.error.message };
 }
-function validateTransactionResponse(data) {
-  const result = TransactionResponseSchema.safeParse(data);
-  if (result.success) {
-    return { success: true, data: result.data };
-  }
-  return { success: false, error: result.error.message };
-}
 
 // src/react/useMlink.ts
 var DEFAULT_REFRESH_INTERVAL = 10 * 60 * 1e3;
 function useMlink(url, options = {}) {
-  const { refreshInterval = DEFAULT_REFRESH_INTERVAL, enabled = true } = options;
+  const {
+    refreshInterval = DEFAULT_REFRESH_INTERVAL,
+    enabled = true,
+    registryUrl = REGISTRY_URL,
+    requireRegistration = true,
+    allowPending = true,
+    allowBlocked = false
+  } = options;
   const [status, setStatus] = useState("idle");
   const [metadata, setMetadata] = useState(null);
   const [error, setError] = useState(null);
+  const [registration, setRegistration] = useState(null);
   const abortControllerRef = useRef(null);
   const intervalRef = useRef(null);
   const actionUrl = parseBlinkUrl(url) || url;
+  const validateRegistration = useCallback(async () => {
+    if (!actionUrl || !requireRegistration) return null;
+    try {
+      const validateUrl = `${registryUrl}${REGISTRY_VALIDATE_ENDPOINT}?url=${encodeURIComponent(actionUrl)}`;
+      const response = await fetch(validateUrl, {
+        method: "GET",
+        headers: {
+          Accept: "application/json"
+        }
+      });
+      const data = await response.json();
+      return data;
+    } catch (err) {
+      console.error("Registry validation error:", err);
+      return {
+        isRegistered: false,
+        status: null,
+        error: "Unable to validate against registry. Please try again later."
+      };
+    }
+  }, [actionUrl, registryUrl, requireRegistration]);
   const fetchMetadata = useCallback(async () => {
     if (!actionUrl || !enabled) return;
     if (abortControllerRef.current) {
       abortControllerRef.current.abort();
     }
     abortControllerRef.current = new AbortController();
-    setStatus("loading");
+    setStatus("validating");
     setError(null);
     try {
+      if (requireRegistration) {
+        const registrationResult = await validateRegistration();
+        setRegistration(registrationResult);
+        if (registrationResult) {
+          if (!registrationResult.isRegistered) {
+            setError(registrationResult.error || "This MLink is not registered.");
+            setStatus("unregistered");
+            return;
+          }
+          if (registrationResult.status === "blocked" && !allowBlocked) {
+            setError("This MLink has been blocked for policy violations.");
+            setStatus("blocked");
+            return;
+          }
+          if (registrationResult.status === "pending" && !allowPending) {
+            setError("This MLink is pending review and not yet available.");
+            setStatus("error");
+            return;
+          }
+        }
+      }
+      setStatus("loading");
       const response = await fetch(actionUrl, {
         method: "GET",
         headers: {
@@ -121,7 +274,7 @@ function useMlink(url, options = {}) {
       setError(errorMessage);
       setStatus("error");
     }
-  }, [actionUrl, enabled]);
+  }, [actionUrl, enabled, requireRegistration, validateRegistration, allowBlocked, allowPending]);
   useEffect(() => {
     if (enabled) {
       fetchMetadata();
@@ -148,7 +301,9 @@ function useMlink(url, options = {}) {
     metadata,
     error,
     url: actionUrl,
-    refresh: fetchMetadata
+    refresh: fetchMetadata,
+    registration,
+    isRegistered: registration?.isRegistered ?? false
   };
 }
 function useExecuteMlink(options) {
@@ -162,7 +317,7 @@ function useExecuteMlink(options) {
     setError(null);
   }, []);
   const execute = useCallback(
-    async (action, input) => {
+    async (action, input, data) => {
       setStatus("executing");
       setError(null);
       setTxHash(null);
@@ -179,28 +334,33 @@ function useExecuteMlink(options) {
           body: JSON.stringify({
             account,
             action,
-            input
+            input,
+            data
+            // Include parameter data
           })
         });
         if (!response.ok) {
           const errorData = await response.json().catch(() => ({}));
           throw new Error(
-            errorData.message || `HTTP ${response.status}: ${response.statusText}`
+            errorData.error?.message || errorData.message || `HTTP ${response.status}: ${response.statusText}`
           );
         }
-        const data = await response.json();
-        const validation = validateTransactionResponse(data);
-        if (!validation.success) {
-          throw new Error(`Invalid response: ${validation.error}`);
+        const responseData = await response.json();
+        const transactions = responseData.transactions ? responseData.transactions : responseData.transaction ? [responseData.transaction] : [];
+        if (transactions.length === 0) {
+          throw new Error("No transaction returned from action");
+        }
+        let lastHash = "";
+        for (const tx of transactions) {
+          lastHash = await adapter.signAndSendTransaction(tx);
         }
-        const hash = await adapter.signAndSendTransaction(data.transaction);
-        setTxHash(hash);
+        setTxHash(lastHash);
         setStatus("success");
-        onSuccess?.(hash, action);
+        onSuccess?.(lastHash, action);
         return {
           success: true,
-          txHash: hash,
-          message: data.message
+          txHash: lastHash,
+          message: responseData.message
         };
       } catch (err) {
         const errorMessage = err instanceof Error ? err.message : "Transaction failed";
@@ -346,6 +506,23 @@ function useMlinkContext() {
   }
   return context;
 }
+
+// src/builders.ts
+function buildHref(template, params) {
+  let result = template;
+  for (const [key, value] of Object.entries(params)) {
+    const placeholder = `{${key}}`;
+    const replacement = Array.isArray(value) ? value.join(",") : value;
+    result = result.replace(new RegExp(placeholder, "g"), encodeURIComponent(replacement));
+  }
+  return result;
+}
+function hasParameters(action) {
+  return Boolean(action.parameters && action.parameters.length > 0);
+}
+function isSelectableParam(param) {
+  return param.type === "select" || param.type === "radio" || param.type === "checkbox";
+}
 function Mlink({
   url,
   adapter,
@@ -353,11 +530,20 @@ function Mlink({
   onSuccess,
   onError,
   className = "",
-  stylePreset = "default"
+  stylePreset = "default",
+  registryUrl,
+  requireRegistration = true,
+  allowPending = true,
+  allowBlocked = false
 }) {
   const context = useMlinkContext();
   const resolvedTheme = themeProp ? resolveTheme(themeProp) : context.theme;
-  const { status: fetchStatus, metadata, error: fetchError } = useMlink(url);
+  const { status: fetchStatus, metadata, error: fetchError, registration } = useMlink(url, {
+    registryUrl,
+    requireRegistration,
+    allowPending,
+    allowBlocked
+  });
   const {
     execute,
     status: execStatus,
@@ -371,9 +557,14 @@ function Mlink({
     onError
   });
   const [inputValues, setInputValues] = useState({});
+  const [paramValues, setParamValues] = useState({});
+  const [selectedLinkedAction, setSelectedLinkedAction] = useState(null);
   const handleInputChange = useCallback((actionValue, value) => {
     setInputValues((prev) => ({ ...prev, [actionValue]: value }));
   }, []);
+  const handleParamChange = useCallback((name, value) => {
+    setParamValues((prev) => ({ ...prev, [name]: value }));
+  }, []);
   const handleAction = useCallback(
     async (action) => {
       const input = action.type === "input" ? inputValues[action.value] : void 0;
@@ -381,9 +572,55 @@ function Mlink({
     },
     [execute, inputValues]
   );
-  if (fetchStatus === "loading") {
+  const handleLinkedAction = useCallback(
+    async (action) => {
+      if (hasParameters(action)) {
+        setSelectedLinkedAction(action);
+        const defaults = {};
+        action.parameters?.forEach((param) => {
+          if (isSelectableParam(param)) {
+            const selectedOption = param.options.find((o) => o.selected);
+            if (selectedOption) {
+              defaults[param.name] = param.type === "checkbox" ? [selectedOption.value] : selectedOption.value;
+            }
+          }
+        });
+        setParamValues(defaults);
+      } else {
+        await execute(action.href, void 0, {});
+      }
+    },
+    [execute]
+  );
+  const handleExecuteWithParams = useCallback(async () => {
+    if (!selectedLinkedAction) return;
+    const finalHref = buildHref(selectedLinkedAction.href, paramValues);
+    await execute(finalHref, void 0, paramValues);
+    setSelectedLinkedAction(null);
+    setParamValues({});
+  }, [selectedLinkedAction, paramValues, execute]);
+  const handleCancelParams = useCallback(() => {
+    setSelectedLinkedAction(null);
+    setParamValues({});
+  }, []);
+  const hasLinkedActions = useMemo(() => {
+    return metadata?.links?.actions && metadata.links.actions.length > 0;
+  }, [metadata]);
+  if (fetchStatus === "loading" || fetchStatus === "validating") {
     return /* @__PURE__ */ jsx(MlinkContainer, { theme: resolvedTheme, className, preset: stylePreset, children: /* @__PURE__ */ jsx(MlinkSkeleton, {}) });
   }
+  if (fetchStatus === "unregistered") {
+    return /* @__PURE__ */ jsx(MlinkContainer, { theme: resolvedTheme, className, preset: stylePreset, children: /* @__PURE__ */ jsx(
+      MlinkUnregistered,
+      {
+        message: fetchError || "This MLink is not registered.",
+        registryUrl
+      }
+    ) });
+  }
+  if (fetchStatus === "blocked") {
+    return /* @__PURE__ */ jsx(MlinkContainer, { theme: resolvedTheme, className, preset: stylePreset, children: /* @__PURE__ */ jsx(MlinkBlocked, { message: fetchError || "This MLink has been blocked." }) });
+  }
   if (fetchStatus === "error" || !metadata) {
     return /* @__PURE__ */ jsx(MlinkContainer, { theme: resolvedTheme, className, preset: stylePreset, children: /* @__PURE__ */ jsx(MlinkError, { message: fetchError || "Failed to load action" }) });
   }
@@ -397,6 +634,45 @@ function Mlink({
       }
     ) });
   }
+  if (selectedLinkedAction && hasParameters(selectedLinkedAction)) {
+    return /* @__PURE__ */ jsxs(MlinkContainer, { theme: resolvedTheme, className, preset: stylePreset, children: [
+      /* @__PURE__ */ jsxs("div", { className: "mlink-content", children: [
+        /* @__PURE__ */ jsx("h3", { className: "mlink-title", children: selectedLinkedAction.label }),
+        /* @__PURE__ */ jsx("p", { className: "mlink-description", children: "Fill in the details below" })
+      ] }),
+      execError && /* @__PURE__ */ jsx("div", { className: "mlink-error-banner", children: execError }),
+      /* @__PURE__ */ jsx("div", { className: "mlink-params", children: selectedLinkedAction.parameters?.map((param) => /* @__PURE__ */ jsx(
+        ParameterInput,
+        {
+          param,
+          value: paramValues[param.name] || "",
+          onChange: (value) => handleParamChange(param.name, value),
+          disabled: execStatus === "executing"
+        },
+        param.name
+      )) }),
+      /* @__PURE__ */ jsxs("div", { className: "mlink-actions", children: [
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            className: "mlink-button",
+            onClick: handleExecuteWithParams,
+            disabled: execStatus === "executing",
+            children: execStatus === "executing" ? /* @__PURE__ */ jsx(MlinkSpinner, {}) : selectedLinkedAction.label
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            className: "mlink-button mlink-button-secondary",
+            onClick: handleCancelParams,
+            disabled: execStatus === "executing",
+            children: "Back"
+          }
+        )
+      ] })
+    ] });
+  }
   return /* @__PURE__ */ jsxs(MlinkContainer, { theme: resolvedTheme, className, preset: stylePreset, children: [
     /* @__PURE__ */ jsx("div", { className: "mlink-icon", children: /* @__PURE__ */ jsx("img", { src: metadata.icon, alt: metadata.title }) }),
     /* @__PURE__ */ jsxs("div", { className: "mlink-content", children: [
@@ -404,7 +680,29 @@ function Mlink({
       /* @__PURE__ */ jsx("p", { className: "mlink-description", children: metadata.description })
     ] }),
     execError && /* @__PURE__ */ jsx("div", { className: "mlink-error-banner", children: execError }),
-    /* @__PURE__ */ jsx("div", { className: "mlink-actions", children: metadata.actions.map((action, index) => /* @__PURE__ */ jsx(
+    hasLinkedActions && /* @__PURE__ */ jsxs("div", { className: "mlink-actions", children: [
+      /* @__PURE__ */ jsx("div", { className: "mlink-quick-actions", children: metadata.links.actions.filter((a) => !hasParameters(a)).map((action, index) => /* @__PURE__ */ jsx(
+        "button",
+        {
+          className: "mlink-button mlink-button-quick",
+          onClick: () => handleLinkedAction(action),
+          disabled: metadata.disabled || action.disabled || execStatus === "executing",
+          children: execStatus === "executing" ? /* @__PURE__ */ jsx(MlinkSpinner, {}) : action.label
+        },
+        `${action.href}-${index}`
+      )) }),
+      metadata.links.actions.filter((a) => hasParameters(a)).map((action, index) => /* @__PURE__ */ jsx(
+        "button",
+        {
+          className: "mlink-button mlink-button-custom",
+          onClick: () => handleLinkedAction(action),
+          disabled: metadata.disabled || action.disabled || execStatus === "executing",
+          children: action.label
+        },
+        `param-${action.href}-${index}`
+      ))
+    ] }),
+    !hasLinkedActions && metadata.actions && /* @__PURE__ */ jsx("div", { className: "mlink-actions", children: metadata.actions.map((action, index) => /* @__PURE__ */ jsx(
       ActionButtonComponent,
       {
         action,
@@ -418,6 +716,161 @@ function Mlink({
     )) })
   ] });
 }
+function ParameterInput({ param, value, onChange, disabled }) {
+  const strValue = Array.isArray(value) ? value.join(",") : value;
+  if (isSelectableParam(param)) {
+    return /* @__PURE__ */ jsx(
+      SelectableParamInput,
+      {
+        param,
+        value,
+        onChange,
+        disabled
+      }
+    );
+  }
+  const inputType = getInputType(param.type);
+  if (param.type === "textarea") {
+    return /* @__PURE__ */ jsxs("div", { className: "mlink-param-group", children: [
+      param.label && /* @__PURE__ */ jsx("label", { className: "mlink-param-label", children: param.label }),
+      /* @__PURE__ */ jsx(
+        "textarea",
+        {
+          className: "mlink-textarea",
+          value: strValue,
+          onChange: (e) => onChange(e.target.value),
+          disabled,
+          required: param.required
+        }
+      )
+    ] });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: "mlink-param-group", children: [
+    param.label && /* @__PURE__ */ jsxs("label", { className: "mlink-param-label", children: [
+      param.label,
+      param.required && /* @__PURE__ */ jsx("span", { className: "mlink-required", children: "*" })
+    ] }),
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        type: inputType,
+        className: "mlink-input",
+        value: strValue,
+        onChange: (e) => onChange(e.target.value),
+        disabled,
+        required: param.required,
+        pattern: param.pattern,
+        min: param.min?.toString(),
+        max: param.max?.toString(),
+        placeholder: param.label || param.name
+      }
+    ),
+    param.patternDescription && /* @__PURE__ */ jsx("span", { className: "mlink-param-hint", children: param.patternDescription })
+  ] });
+}
+function SelectableParamInput({
+  param,
+  value,
+  onChange,
+  disabled
+}) {
+  const arrayValue = Array.isArray(value) ? value : value ? [value] : [];
+  if (param.type === "select") {
+    return /* @__PURE__ */ jsxs("div", { className: "mlink-param-group", children: [
+      param.label && /* @__PURE__ */ jsxs("label", { className: "mlink-param-label", children: [
+        param.label,
+        param.required && /* @__PURE__ */ jsx("span", { className: "mlink-required", children: "*" })
+      ] }),
+      /* @__PURE__ */ jsxs(
+        "select",
+        {
+          className: "mlink-select",
+          value: arrayValue[0] || "",
+          onChange: (e) => onChange(e.target.value),
+          disabled,
+          required: param.required,
+          children: [
+            /* @__PURE__ */ jsxs("option", { value: "", children: [
+              "Select ",
+              param.label || param.name
+            ] }),
+            param.options.map((opt) => /* @__PURE__ */ jsx("option", { value: opt.value, children: opt.label }, opt.value))
+          ]
+        }
+      )
+    ] });
+  }
+  if (param.type === "radio") {
+    return /* @__PURE__ */ jsxs("div", { className: "mlink-param-group", children: [
+      param.label && /* @__PURE__ */ jsxs("label", { className: "mlink-param-label", children: [
+        param.label,
+        param.required && /* @__PURE__ */ jsx("span", { className: "mlink-required", children: "*" })
+      ] }),
+      /* @__PURE__ */ jsx("div", { className: "mlink-radio-group", children: param.options.map((opt) => /* @__PURE__ */ jsxs("label", { className: "mlink-radio-label", children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "radio",
+            name: param.name,
+            value: opt.value,
+            checked: arrayValue[0] === opt.value,
+            onChange: (e) => onChange(e.target.value),
+            disabled
+          }
+        ),
+        opt.label
+      ] }, opt.value)) })
+    ] });
+  }
+  if (param.type === "checkbox") {
+    return /* @__PURE__ */ jsxs("div", { className: "mlink-param-group", children: [
+      param.label && /* @__PURE__ */ jsxs("label", { className: "mlink-param-label", children: [
+        param.label,
+        param.required && /* @__PURE__ */ jsx("span", { className: "mlink-required", children: "*" })
+      ] }),
+      /* @__PURE__ */ jsx("div", { className: "mlink-checkbox-group", children: param.options.map((opt) => /* @__PURE__ */ jsxs("label", { className: "mlink-checkbox-label", children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "checkbox",
+            value: opt.value,
+            checked: arrayValue.includes(opt.value),
+            onChange: (e) => {
+              if (e.target.checked) {
+                onChange([...arrayValue, opt.value]);
+              } else {
+                onChange(arrayValue.filter((v) => v !== opt.value));
+              }
+            },
+            disabled
+          }
+        ),
+        opt.label
+      ] }, opt.value)) })
+    ] });
+  }
+  return null;
+}
+function getInputType(paramType) {
+  switch (paramType) {
+    case "number":
+    case "amount":
+      return "number";
+    case "email":
+      return "email";
+    case "url":
+      return "url";
+    case "date":
+      return "date";
+    case "datetime-local":
+      return "datetime-local";
+    case "address":
+    case "token":
+    case "text":
+    default:
+      return "text";
+  }
+}
 function MlinkContainer({ theme, className, preset, children }) {
   return /* @__PURE__ */ jsx(
     "div",
@@ -444,6 +897,38 @@ function MlinkError({ message }) {
     /* @__PURE__ */ jsx("p", { className: "mlink-error-message", children: message })
   ] });
 }
+function MlinkUnregistered({ message, registryUrl }) {
+  const registerUrl = registryUrl ? `${registryUrl}/dashboard/register` : "https://mlinks-fe.vercel.app/dashboard/register";
+  return /* @__PURE__ */ jsxs("div", { className: "mlink-unregistered", children: [
+    /* @__PURE__ */ jsx("div", { className: "mlink-unregistered-icon", children: /* @__PURE__ */ jsxs("svg", { width: "48", height: "48", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", children: [
+      /* @__PURE__ */ jsx("circle", { cx: "12", cy: "12", r: "10" }),
+      /* @__PURE__ */ jsx("line", { x1: "12", y1: "8", x2: "12", y2: "12" }),
+      /* @__PURE__ */ jsx("line", { x1: "12", y1: "16", x2: "12.01", y2: "16" })
+    ] }) }),
+    /* @__PURE__ */ jsx("h3", { className: "mlink-unregistered-title", children: "Unregistered MLink" }),
+    /* @__PURE__ */ jsx("p", { className: "mlink-unregistered-message", children: message }),
+    /* @__PURE__ */ jsx(
+      "a",
+      {
+        href: registerUrl,
+        target: "_blank",
+        rel: "noopener noreferrer",
+        className: "mlink-button",
+        children: "Register MLink"
+      }
+    )
+  ] });
+}
+function MlinkBlocked({ message }) {
+  return /* @__PURE__ */ jsxs("div", { className: "mlink-blocked", children: [
+    /* @__PURE__ */ jsx("div", { className: "mlink-blocked-icon", children: /* @__PURE__ */ jsxs("svg", { width: "48", height: "48", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", children: [
+      /* @__PURE__ */ jsx("circle", { cx: "12", cy: "12", r: "10" }),
+      /* @__PURE__ */ jsx("line", { x1: "4.93", y1: "4.93", x2: "19.07", y2: "19.07" })
+    ] }) }),
+    /* @__PURE__ */ jsx("h3", { className: "mlink-blocked-title", children: "Blocked MLink" }),
+    /* @__PURE__ */ jsx("p", { className: "mlink-blocked-message", children: message })
+  ] });
+}
 function MlinkSuccess({ message, txHash, onReset }) {
   const shortHash = `${txHash.slice(0, 10)}...${txHash.slice(-8)}`;
   return /* @__PURE__ */ jsxs("div", { className: "mlink-success", children: [