@monadns/sdk 2.0.0 → 2.2.0

package/dist/react.d.cts

@@ -204,6 +204,39 @@ declare function useMNSTextRecords(): {
         functionName: "setText";
         args: readonly [`0x${string}`, string, string];
     };
+    setAvatarValidated: (name: string, url: string) => Promise<{
+        address: "0xa2eb94c88e55d944aced2066c5cec9b759801f97";
+        abi: readonly [{
+            readonly name: "setText";
+            readonly type: "function";
+            readonly inputs: readonly [{
+                readonly name: "node";
+                readonly type: "bytes32";
+            }, {
+                readonly name: "key";
+                readonly type: "string";
+            }, {
+                readonly name: "value";
+                readonly type: "string";
+            }];
+            readonly outputs: readonly [];
+            readonly stateMutability: "nonpayable";
+        }, {
+            readonly name: "setAddr";
+            readonly type: "function";
+            readonly inputs: readonly [{
+                readonly name: "node";
+                readonly type: "bytes32";
+            }, {
+                readonly name: "a";
+                readonly type: "address";
+            }];
+            readonly outputs: readonly [];
+            readonly stateMutability: "nonpayable";
+        }];
+        functionName: "setText";
+        args: readonly [`0x${string}`, string, string];
+    }>;
     setUrl: (name: string, url: string) => {
         address: "0xa2eb94c88e55d944aced2066c5cec9b759801f97";
         abi: readonly [{
@@ -537,5 +570,59 @@ declare function useMNSAvatar(name: string | undefined, config?: MNSClientConfig
     loading: boolean;
     error: string | null;
 };
+/**
+ * Owner hook: get the owner address of a .mon name
+ *
+ * @example
+ * ```tsx
+ * function OwnerInfo({ name }: { name: string }) {
+ *   const { owner, loading } = useMNSOwner(name)
+ *   if (loading) return <div>Loading...</div>
+ *   return <div>Owner: {owner}</div>
+ * }
+ * ```
+ */
+declare function useMNSOwner(name: string | undefined, config?: MNSClientConfig): {
+    owner: string | null;
+    loading: boolean;
+    error: string | null;
+};
+/**
+ * Resolver hook: get the resolver contract address for a .mon name
+ *
+ * @example
+ * ```tsx
+ * function ResolverInfo({ name }: { name: string }) {
+ *   const { resolver, loading } = useMNSResolver(name)
+ *   return <div>Resolver: {resolver}</div>
+ * }
+ * ```
+ */
+declare function useMNSResolver(name: string | undefined, config?: MNSClientConfig): {
+    resolver: string | null;
+    loading: boolean;
+    error: string | null;
+};
+/**
+ * Expiry hook: get expiration info for a .mon name
+ *
+ * @example
+ * ```tsx
+ * function ExpiryInfo({ name }: { name: string }) {
+ *   const { expiry, expiryDate, daysUntilExpiry, isExpired, loading } = useMNSExpiry(name)
+ *   if (loading) return <div>Loading...</div>
+ *   if (isExpired) return <div className="text-red-500">Expired!</div>
+ *   return <div>Expires in {daysUntilExpiry} days</div>
+ * }
+ * ```
+ */
+declare function useMNSExpiry(name: string | undefined, config?: MNSClientConfig): {
+    expiry: number | null;
+    expiryDate: Date | null;
+    daysUntilExpiry: number | null;
+    isExpired: boolean | null;
+    loading: boolean;
+    error: string | null;
+};
 
-export { type MNSClientConfig, useMNSAddr, useMNSAddress, useMNSAvatar, useMNSDisplay, useMNSName, useMNSRegister, useMNSResolve, useMNSText, useMNSTextRecords, useRegistrationInfo };
+export { type MNSClientConfig, useMNSAddr, useMNSAddress, useMNSAvatar, useMNSDisplay, useMNSExpiry, useMNSName, useMNSOwner, useMNSRegister, useMNSResolve, useMNSResolver, useMNSText, useMNSTextRecords, useRegistrationInfo };

package/dist/react.d.ts

@@ -204,6 +204,39 @@ declare function useMNSTextRecords(): {
         functionName: "setText";
         args: readonly [`0x${string}`, string, string];
     };
+    setAvatarValidated: (name: string, url: string) => Promise<{
+        address: "0xa2eb94c88e55d944aced2066c5cec9b759801f97";
+        abi: readonly [{
+            readonly name: "setText";
+            readonly type: "function";
+            readonly inputs: readonly [{
+                readonly name: "node";
+                readonly type: "bytes32";
+            }, {
+                readonly name: "key";
+                readonly type: "string";
+            }, {
+                readonly name: "value";
+                readonly type: "string";
+            }];
+            readonly outputs: readonly [];
+            readonly stateMutability: "nonpayable";
+        }, {
+            readonly name: "setAddr";
+            readonly type: "function";
+            readonly inputs: readonly [{
+                readonly name: "node";
+                readonly type: "bytes32";
+            }, {
+                readonly name: "a";
+                readonly type: "address";
+            }];
+            readonly outputs: readonly [];
+            readonly stateMutability: "nonpayable";
+        }];
+        functionName: "setText";
+        args: readonly [`0x${string}`, string, string];
+    }>;
     setUrl: (name: string, url: string) => {
         address: "0xa2eb94c88e55d944aced2066c5cec9b759801f97";
         abi: readonly [{
@@ -537,5 +570,59 @@ declare function useMNSAvatar(name: string | undefined, config?: MNSClientConfig
     loading: boolean;
     error: string | null;
 };
+/**
+ * Owner hook: get the owner address of a .mon name
+ *
+ * @example
+ * ```tsx
+ * function OwnerInfo({ name }: { name: string }) {
+ *   const { owner, loading } = useMNSOwner(name)
+ *   if (loading) return <div>Loading...</div>
+ *   return <div>Owner: {owner}</div>
+ * }
+ * ```
+ */
+declare function useMNSOwner(name: string | undefined, config?: MNSClientConfig): {
+    owner: string | null;
+    loading: boolean;
+    error: string | null;
+};
+/**
+ * Resolver hook: get the resolver contract address for a .mon name
+ *
+ * @example
+ * ```tsx
+ * function ResolverInfo({ name }: { name: string }) {
+ *   const { resolver, loading } = useMNSResolver(name)
+ *   return <div>Resolver: {resolver}</div>
+ * }
+ * ```
+ */
+declare function useMNSResolver(name: string | undefined, config?: MNSClientConfig): {
+    resolver: string | null;
+    loading: boolean;
+    error: string | null;
+};
+/**
+ * Expiry hook: get expiration info for a .mon name
+ *
+ * @example
+ * ```tsx
+ * function ExpiryInfo({ name }: { name: string }) {
+ *   const { expiry, expiryDate, daysUntilExpiry, isExpired, loading } = useMNSExpiry(name)
+ *   if (loading) return <div>Loading...</div>
+ *   if (isExpired) return <div className="text-red-500">Expired!</div>
+ *   return <div>Expires in {daysUntilExpiry} days</div>
+ * }
+ * ```
+ */
+declare function useMNSExpiry(name: string | undefined, config?: MNSClientConfig): {
+    expiry: number | null;
+    expiryDate: Date | null;
+    daysUntilExpiry: number | null;
+    isExpired: boolean | null;
+    loading: boolean;
+    error: string | null;
+};
 
-export { type MNSClientConfig, useMNSAddr, useMNSAddress, useMNSAvatar, useMNSDisplay, useMNSName, useMNSRegister, useMNSResolve, useMNSText, useMNSTextRecords, useRegistrationInfo };
+export { type MNSClientConfig, useMNSAddr, useMNSAddress, useMNSAvatar, useMNSDisplay, useMNSExpiry, useMNSName, useMNSOwner, useMNSRegister, useMNSResolve, useMNSResolver, useMNSText, useMNSTextRecords, useRegistrationInfo };

package/dist/react.js

@@ -5,7 +5,7 @@
 import { useState as useState2, useEffect as useEffect2, useCallback as useCallback2 } from "react";
 
 // src/resolve.ts
-import { namehash } from "viem";
+import { namehash, keccak256, toBytes } from "viem";
 
 // src/client.ts
 import {
@@ -35,7 +35,9 @@ function getMNSClient(config) {
 var MNS_REGISTRY = "0x13f963486e741c8d3fcdc0a34a910920339a19ce";
 var MNS_PUBLIC_RESOLVER = "0xa2eb94c88e55d944aced2066c5cec9b759801f97";
 var MNS_CONTROLLER = "0x98866c55adbc73ec6c272bb3604ddbdee3f282a8";
+var MNS_BASE_REGISTRAR = "0x104a49db9318c284d462841b6940bdb46624ca55";
 var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var MAX_AVATAR_BYTES = 51200;
 var registryAbi = [
   {
     name: "resolver",
@@ -43,6 +45,13 @@ var registryAbi = [
     inputs: [{ name: "node", type: "bytes32" }],
     outputs: [{ name: "", type: "address" }],
     stateMutability: "view"
+  },
+  {
+    name: "owner",
+    type: "function",
+    inputs: [{ name: "node", type: "bytes32" }],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
   }
 ];
 var resolverAbi = [
@@ -167,21 +176,82 @@ async function getTextRecord(name, key, config) {
     return null;
   }
 }
-async function getAvatarUrl(name, config) {
-  const raw = await getTextRecord(name, "avatar", config);
-  if (!raw) return null;
-  if (raw.startsWith("http://") || raw.startsWith("https://")) {
-    return raw;
+async function getOwner(name, config) {
+  try {
+    const client = getMNSClient(config);
+    const node = namehash(name.toLowerCase());
+    const owner = await client.readContract({
+      address: MNS_REGISTRY,
+      abi: registryAbi,
+      functionName: "owner",
+      args: [node]
+    });
+    return owner === ZERO_ADDRESS ? null : owner;
+  } catch {
+    return null;
   }
-  if (raw.startsWith("ipfs://")) {
-    const hash = raw.slice(7);
-    return `https://ipfs.io/ipfs/${hash}`;
+}
+async function getResolver(name, config) {
+  try {
+    const client = getMNSClient(config);
+    const node = namehash(name.toLowerCase());
+    const resolver = await client.readContract({
+      address: MNS_REGISTRY,
+      abi: registryAbi,
+      functionName: "resolver",
+      args: [node]
+    });
+    return resolver === ZERO_ADDRESS ? null : resolver;
+  } catch {
+    return null;
   }
-  const nftMatch = raw.match(
-    /^eip155:(\d+)\/(erc721|erc1155):0x([a-fA-F0-9]{40})\/(\d+)$/
-  );
-  if (nftMatch) {
-    try {
+}
+async function getExpiry(name, config) {
+  try {
+    const client = getMNSClient(config);
+    const label = name.replace(".mon", "");
+    const labelHash = keccak256(toBytes(label));
+    const expiry = await client.readContract({
+      address: MNS_BASE_REGISTRAR,
+      abi: [
+        {
+          name: "nameExpires",
+          type: "function",
+          inputs: [{ name: "id", type: "uint256" }],
+          outputs: [{ name: "", type: "uint256" }],
+          stateMutability: "view"
+        }
+      ],
+      functionName: "nameExpires",
+      args: [BigInt(labelHash)]
+    });
+    return Number(expiry);
+  } catch {
+    return null;
+  }
+}
+async function getAvatarUrl(name, config, options) {
+  const raw = await getTextRecord(name, "avatar", config);
+  if (!raw) return options?.fallback || null;
+  try {
+    if (raw.startsWith("http://") || raw.startsWith("https://")) {
+      return raw;
+    }
+    if (raw.startsWith("ipfs://")) {
+      const hash = raw.slice(7);
+      return `https://ipfs.io/ipfs/${hash}`;
+    }
+    if (/^(Qm[1-9A-HJ-NP-Za-km-z]{44}|bafy[0-9A-Za-z]{50,})/.test(raw)) {
+      return `https://ipfs.io/ipfs/${raw}`;
+    }
+    if (raw.startsWith("ar://")) {
+      const hash = raw.slice(5);
+      return `https://arweave.net/${hash}`;
+    }
+    const nftMatch = raw.match(
+      /^eip155:(\d+)\/(erc721|erc1155):0x([a-fA-F0-9]{40})\/(\d+)$/
+    );
+    if (nftMatch) {
       const client = getMNSClient(config);
       const contract = `0x${nftMatch[3]}`;
       const tokenId = BigInt(nftMatch[4]);
@@ -209,15 +279,16 @@ async function getAvatarUrl(name, config) {
       if (image && image.startsWith("ipfs://")) {
         image = `https://ipfs.io/ipfs/${image.slice(7)}`;
       }
-      return image;
-    } catch {
-      return null;
+      return image || options?.fallback || null;
     }
+    if (raw.startsWith("data:")) {
+      return raw;
+    }
+    return options?.fallback || null;
+  } catch (error) {
+    console.warn("Failed to resolve avatar:", error);
+    return options?.fallback || null;
   }
-  if (raw.startsWith("data:")) {
-    return raw;
-  }
-  return null;
 }
 
 // src/react-write.ts
@@ -225,6 +296,93 @@ import { useState, useEffect, useCallback } from "react";
 
 // src/write.ts
 import { namehash as namehash2 } from "viem";
+
+// src/utils.ts
+function validateAvatarUri(uri) {
+  if (!uri) {
+    return { valid: false, error: "Avatar URI is required" };
+  }
+  if (uri.startsWith("data:")) {
+    const sizeBytes = new Blob([uri]).size;
+    if (sizeBytes > MAX_AVATAR_BYTES) {
+      return {
+        valid: false,
+        error: `Avatar size (${(sizeBytes / 1024).toFixed(1)}KB) exceeds ${MAX_AVATAR_BYTES / 1024}KB limit. Please optimize as WebP or SVG for better performance.`,
+        sizeBytes
+      };
+    }
+    return { valid: true, sizeBytes };
+  }
+  const validSchemes = ["http://", "https://", "ipfs://", "eip155:", "ar://"];
+  const hasValidScheme = validSchemes.some((scheme) => uri.startsWith(scheme));
+  if (!hasValidScheme) {
+    if (/^(Qm[1-9A-HJ-NP-Za-km-z]{44}|bafy[0-9A-Za-z]{50,})/.test(uri)) {
+      return { valid: true };
+    }
+    return {
+      valid: false,
+      error: "Avatar must be a valid HTTP, IPFS, Arweave, or NFT URI"
+    };
+  }
+  return { valid: true };
+}
+async function validateAvatarFull(uri, options) {
+  const maxBytes = options?.maxBytes || MAX_AVATAR_BYTES;
+  const timeout = options?.timeout || 5e3;
+  const formatValidation = validateAvatarUri(uri);
+  if (!formatValidation.valid) {
+    throw new Error(formatValidation.error);
+  }
+  if (uri.startsWith("data:")) {
+    return { valid: true, sizeBytes: formatValidation.sizeBytes };
+  }
+  if (uri.startsWith("eip155:")) {
+    return { valid: true };
+  }
+  let checkUrl = uri;
+  if (uri.startsWith("ipfs://")) {
+    checkUrl = `https://ipfs.io/ipfs/${uri.slice(7)}`;
+  } else if (/^(Qm[1-9A-HJ-NP-Za-km-z]{44}|bafy[0-9A-Za-z]{50,})/.test(uri)) {
+    checkUrl = `https://ipfs.io/ipfs/${uri}`;
+  } else if (uri.startsWith("ar://")) {
+    checkUrl = `https://arweave.net/${uri.slice(5)}`;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const response = await fetch(checkUrl, {
+      method: "HEAD",
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    const contentLength = response.headers.get("content-length");
+    if (contentLength) {
+      const sizeBytes = parseInt(contentLength, 10);
+      if (sizeBytes > maxBytes) {
+        throw new Error(
+          `Avatar file size (${(sizeBytes / 1024).toFixed(1)}KB) exceeds ${maxBytes / 1024}KB limit. Please optimize as WebP or SVG for better performance.`
+        );
+      }
+      return { valid: true, sizeBytes };
+    }
+    console.warn(
+      `Could not determine avatar size for ${uri}. Ensure it's under ${maxBytes / 1024}KB.`
+    );
+    return { valid: true };
+  } catch (error) {
+    if (error.name === "AbortError") {
+      console.warn(`Avatar size check timed out for ${uri}`);
+      return { valid: true };
+    }
+    if (error.message.includes("exceeds")) {
+      throw error;
+    }
+    console.warn(`Could not check avatar size: ${error.message}`);
+    return { valid: true };
+  }
+}
+
+// src/write.ts
 var controllerReadAbi = [
   {
     name: "available",
@@ -341,6 +499,17 @@ async function getRegisterTx(label, ownerAddress, durationYears = 1, config) {
   };
 }
 function getSetTextTx(name, key, value) {
+  if (key === "avatar" && value.startsWith("data:")) {
+    const validation = validateAvatarUri(value);
+    if (!validation.valid) {
+      throw new Error(validation.error);
+    }
+  }
+  if (key === "avatar" && !value.startsWith("data:")) {
+    console.warn(
+      "\u26A0\uFE0F Avatar set without size validation. For best practices, use setAvatarValidated() or validateAvatarFull() before calling setAvatar()."
+    );
+  }
   const node = namehash2(
     name.endsWith(".mon") ? name : `${name}.mon`
   );
@@ -444,6 +613,10 @@ function useMNSTextRecords() {
   const setAvatar = useCallback((name, url) => {
     return getSetTextTx(name, "avatar", url);
   }, []);
+  const setAvatarValidated = useCallback(async (name, url) => {
+    await validateAvatarFull(url);
+    return getSetTextTx(name, "avatar", url);
+  }, []);
   const setUrl = useCallback((name, url) => {
     return getSetTextTx(name, "url", url);
   }, []);
@@ -462,6 +635,7 @@ function useMNSTextRecords() {
   return {
     setTextRecord,
     setAvatar,
+    setAvatarValidated,
     setUrl,
     setTwitter,
     setGithub,
@@ -626,14 +800,95 @@ function useMNSAvatar(name, config) {
   }, [name]);
   return { url, loading, error };
 }
+function useMNSOwner(name, config) {
+  const [owner, setOwner] = useState2(null);
+  const [loading, setLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  useEffect2(() => {
+    if (!name) {
+      setOwner(null);
+      return;
+    }
+    let cancelled = false;
+    setLoading(true);
+    setError(null);
+    getOwner(name, config).then((o) => {
+      if (!cancelled) setOwner(o);
+    }).catch((e) => {
+      if (!cancelled) setError(e.message);
+    }).finally(() => {
+      if (!cancelled) setLoading(false);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [name]);
+  return { owner, loading, error };
+}
+function useMNSResolver(name, config) {
+  const [resolver, setResolver] = useState2(null);
+  const [loading, setLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  useEffect2(() => {
+    if (!name) {
+      setResolver(null);
+      return;
+    }
+    let cancelled = false;
+    setLoading(true);
+    setError(null);
+    getResolver(name, config).then((r) => {
+      if (!cancelled) setResolver(r);
+    }).catch((e) => {
+      if (!cancelled) setError(e.message);
+    }).finally(() => {
+      if (!cancelled) setLoading(false);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [name]);
+  return { resolver, loading, error };
+}
+function useMNSExpiry(name, config) {
+  const [expiry, setExpiry] = useState2(null);
+  const [loading, setLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  useEffect2(() => {
+    if (!name) {
+      setExpiry(null);
+      return;
+    }
+    let cancelled = false;
+    setLoading(true);
+    setError(null);
+    getExpiry(name, config).then((e) => {
+      if (!cancelled) setExpiry(e);
+    }).catch((e) => {
+      if (!cancelled) setError(e.message);
+    }).finally(() => {
+      if (!cancelled) setLoading(false);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [name]);
+  const expiryDate = expiry ? new Date(expiry * 1e3) : null;
+  const daysUntilExpiry = expiry ? Math.floor((expiry * 1e3 - Date.now()) / (1e3 * 60 * 60 * 24)) : null;
+  const isExpired = expiry ? expiry * 1e3 < Date.now() : null;
+  return { expiry, expiryDate, daysUntilExpiry, isExpired, loading, error };
+}
 export {
   useMNSAddr,
   useMNSAddress,
   useMNSAvatar,
   useMNSDisplay,
+  useMNSExpiry,
   useMNSName,
+  useMNSOwner,
   useMNSRegister,
   useMNSResolve,
+  useMNSResolver,
   useMNSText,
   useMNSTextRecords,
   useRegistrationInfo