@thurinlabs/identity-kit 1.3.2 → 1.3.3

package/dist/embed.global.js

@@ -24932,239 +24932,6 @@ ${prettyStateOverride(stateOverride)}`;
     }
   }
 
-  // node_modules/viem/_esm/errors/ens.js
-  init_base();
-  var EnsAvatarInvalidMetadataError = class extends BaseError {
-    constructor({ data }) {
-      super("Unable to extract image from metadata. The metadata may be malformed or invalid.", {
-        metaMessages: [
-          "- Metadata must be a JSON object with at least an `image`, `image_url` or `image_data` property.",
-          "",
-          `Provided data: ${JSON.stringify(data)}`
-        ],
-        name: "EnsAvatarInvalidMetadataError"
-      });
-    }
-  };
-  var EnsAvatarInvalidNftUriError = class extends BaseError {
-    constructor({ reason }) {
-      super(`ENS NFT avatar URI is invalid. ${reason}`, {
-        name: "EnsAvatarInvalidNftUriError"
-      });
-    }
-  };
-  var EnsAvatarUriResolutionError = class extends BaseError {
-    constructor({ uri }) {
-      super(`Unable to resolve ENS avatar URI "${uri}". The URI may be malformed, invalid, or does not respond with a valid image.`, { name: "EnsAvatarUriResolutionError" });
-    }
-  };
-  var EnsAvatarUnsupportedNamespaceError = class extends BaseError {
-    constructor({ namespace }) {
-      super(`ENS NFT avatar namespace "${namespace}" is not supported. Must be "erc721" or "erc1155".`, { name: "EnsAvatarUnsupportedNamespaceError" });
-    }
-  };
-
-  // node_modules/viem/_esm/utils/ens/avatar/utils.js
-  var networkRegex = /(?<protocol>https?:\/\/[^/]*|ipfs:\/|ipns:\/|ar:\/)?(?<root>\/)?(?<subpath>ipfs\/|ipns\/)?(?<target>[\w\-.]+)(?<subtarget>\/.*)?/;
-  var ipfsHashRegex = /^(Qm[1-9A-HJ-NP-Za-km-z]{44,}|b[A-Za-z2-7]{58,}|B[A-Z2-7]{58,}|z[1-9A-HJ-NP-Za-km-z]{48,}|F[0-9A-F]{50,})(\/(?<target>[\w\-.]+))?(?<subtarget>\/.*)?$/;
-  var base64Regex = /^data:([a-zA-Z\-/+]*);base64,([^"].*)/;
-  var dataURIRegex = /^data:([a-zA-Z\-/+]*)?(;[a-zA-Z0-9].*?)?(,)/;
-  async function isImageUri(uri) {
-    try {
-      const res = await fetch(uri, { method: "HEAD" });
-      if (res.status === 200) {
-        const contentType = res.headers.get("content-type");
-        return contentType?.startsWith("image/");
-      }
-      return false;
-    } catch (error) {
-      if (typeof error === "object" && typeof error.response !== "undefined") {
-        return false;
-      }
-      if (!Object.hasOwn(globalThis, "Image"))
-        return false;
-      return new Promise((resolve) => {
-        const img = new Image();
-        img.onload = () => {
-          resolve(true);
-        };
-        img.onerror = () => {
-          resolve(false);
-        };
-        img.src = uri;
-      });
-    }
-  }
-  function getGateway(custom2, defaultGateway) {
-    if (!custom2)
-      return defaultGateway;
-    if (custom2.endsWith("/"))
-      return custom2.slice(0, -1);
-    return custom2;
-  }
-  function resolveAvatarUri({ uri, gatewayUrls }) {
-    const isEncoded = base64Regex.test(uri);
-    if (isEncoded)
-      return { uri, isOnChain: true, isEncoded };
-    const ipfsGateway = getGateway(gatewayUrls?.ipfs, "https://ipfs.io");
-    const arweaveGateway = getGateway(gatewayUrls?.arweave, "https://arweave.net");
-    const networkRegexMatch = uri.match(networkRegex);
-    const { protocol, subpath, target, subtarget = "" } = networkRegexMatch?.groups || {};
-    const isIPNS = protocol === "ipns:/" || subpath === "ipns/";
-    const isIPFS = protocol === "ipfs:/" || subpath === "ipfs/" || ipfsHashRegex.test(uri);
-    if (uri.startsWith("http") && !isIPNS && !isIPFS) {
-      let replacedUri = uri;
-      if (gatewayUrls?.arweave)
-        replacedUri = uri.replace(/https:\/\/arweave.net/g, gatewayUrls?.arweave);
-      return { uri: replacedUri, isOnChain: false, isEncoded: false };
-    }
-    if ((isIPNS || isIPFS) && target) {
-      return {
-        uri: `${ipfsGateway}/${isIPNS ? "ipns" : "ipfs"}/${target}${subtarget}`,
-        isOnChain: false,
-        isEncoded: false
-      };
-    }
-    if (protocol === "ar:/" && target) {
-      return {
-        uri: `${arweaveGateway}/${target}${subtarget || ""}`,
-        isOnChain: false,
-        isEncoded: false
-      };
-    }
-    let parsedUri = uri.replace(dataURIRegex, "");
-    if (parsedUri.startsWith("<svg")) {
-      parsedUri = `data:image/svg+xml;base64,${btoa(parsedUri)}`;
-    }
-    if (parsedUri.startsWith("data:") || parsedUri.startsWith("{")) {
-      return {
-        uri: parsedUri,
-        isOnChain: true,
-        isEncoded: false
-      };
-    }
-    throw new EnsAvatarUriResolutionError({ uri });
-  }
-  function getJsonImage(data) {
-    if (typeof data !== "object" || !("image" in data) && !("image_url" in data) && !("image_data" in data)) {
-      throw new EnsAvatarInvalidMetadataError({ data });
-    }
-    return data.image || data.image_url || data.image_data;
-  }
-  async function getMetadataAvatarUri({ gatewayUrls, uri }) {
-    try {
-      const res = await fetch(uri).then((res2) => res2.json());
-      const image = await parseAvatarUri({
-        gatewayUrls,
-        uri: getJsonImage(res)
-      });
-      return image;
-    } catch {
-      throw new EnsAvatarUriResolutionError({ uri });
-    }
-  }
-  async function parseAvatarUri({ gatewayUrls, uri }) {
-    const { uri: resolvedURI, isOnChain } = resolveAvatarUri({ uri, gatewayUrls });
-    if (isOnChain)
-      return resolvedURI;
-    const isImage = await isImageUri(resolvedURI);
-    if (isImage)
-      return resolvedURI;
-    throw new EnsAvatarUriResolutionError({ uri });
-  }
-  function parseNftUri(uri_) {
-    let uri = uri_;
-    if (uri.startsWith("did:nft:")) {
-      uri = uri.replace("did:nft:", "").replace(/_/g, "/");
-    }
-    const [reference, asset_namespace, tokenID] = uri.split("/");
-    const [eip_namespace, chainID] = reference.split(":");
-    const [erc_namespace, contractAddress] = asset_namespace.split(":");
-    if (!eip_namespace || eip_namespace.toLowerCase() !== "eip155")
-      throw new EnsAvatarInvalidNftUriError({ reason: "Only EIP-155 supported" });
-    if (!chainID)
-      throw new EnsAvatarInvalidNftUriError({ reason: "Chain ID not found" });
-    if (!contractAddress)
-      throw new EnsAvatarInvalidNftUriError({
-        reason: "Contract address not found"
-      });
-    if (!tokenID)
-      throw new EnsAvatarInvalidNftUriError({ reason: "Token ID not found" });
-    if (!erc_namespace)
-      throw new EnsAvatarInvalidNftUriError({ reason: "ERC namespace not found" });
-    return {
-      chainID: Number.parseInt(chainID, 10),
-      namespace: erc_namespace.toLowerCase(),
-      contractAddress,
-      tokenID
-    };
-  }
-  async function getNftTokenUri(client, { nft }) {
-    if (nft.namespace === "erc721") {
-      return readContract(client, {
-        address: nft.contractAddress,
-        abi: [
-          {
-            name: "tokenURI",
-            type: "function",
-            stateMutability: "view",
-            inputs: [{ name: "tokenId", type: "uint256" }],
-            outputs: [{ name: "", type: "string" }]
-          }
-        ],
-        functionName: "tokenURI",
-        args: [BigInt(nft.tokenID)]
-      });
-    }
-    if (nft.namespace === "erc1155") {
-      return readContract(client, {
-        address: nft.contractAddress,
-        abi: [
-          {
-            name: "uri",
-            type: "function",
-            stateMutability: "view",
-            inputs: [{ name: "_id", type: "uint256" }],
-            outputs: [{ name: "", type: "string" }]
-          }
-        ],
-        functionName: "uri",
-        args: [BigInt(nft.tokenID)]
-      });
-    }
-    throw new EnsAvatarUnsupportedNamespaceError({ namespace: nft.namespace });
-  }
-
-  // node_modules/viem/_esm/utils/ens/avatar/parseAvatarRecord.js
-  async function parseAvatarRecord(client, { gatewayUrls, record }) {
-    if (/eip155:/i.test(record))
-      return parseNftAvatarUri(client, { gatewayUrls, record });
-    return parseAvatarUri({ uri: record, gatewayUrls });
-  }
-  async function parseNftAvatarUri(client, { gatewayUrls, record }) {
-    const nft = parseNftUri(record);
-    const nftUri = await getNftTokenUri(client, { nft });
-    const { uri: resolvedNftUri, isOnChain, isEncoded } = resolveAvatarUri({ uri: nftUri, gatewayUrls });
-    if (isOnChain && (resolvedNftUri.includes("data:application/json;base64,") || resolvedNftUri.startsWith("{"))) {
-      const encodedJson = isEncoded ? (
-        // if it is encoded, decode it
-        atob(resolvedNftUri.replace("data:application/json;base64,", ""))
-      ) : (
-        // if it isn't encoded assume it is a JSON string, but it could be anything (it will error if it is)
-        resolvedNftUri
-      );
-      const decoded = JSON.parse(encodedJson);
-      return parseAvatarUri({ uri: getJsonImage(decoded), gatewayUrls });
-    }
-    let uriTokenId = nft.tokenID;
-    if (nft.namespace === "erc1155")
-      uriTokenId = uriTokenId.replace("0x", "").padStart(64, "0");
-    return getMetadataAvatarUri({
-      gatewayUrls,
-      uri: resolvedNftUri.replace(/(?:0x)?{id}/, uriTokenId)
-    });
-  }
-
   // node_modules/viem/_esm/actions/ens/getEnsText.js
   init_abis();
   init_decodeFunctionResult();
@@ -25225,29 +24992,6 @@ ${prettyStateOverride(stateOverride)}`;
     }
   }
 
-  // node_modules/viem/_esm/actions/ens/getEnsAvatar.js
-  async function getEnsAvatar(client, { blockNumber, blockTag, assetGatewayUrls, name, gatewayUrls, strict, universalResolverAddress }) {
-    const record = await getAction(client, getEnsText, "getEnsText")({
-      blockNumber,
-      blockTag,
-      key: "avatar",
-      name,
-      universalResolverAddress,
-      gatewayUrls,
-      strict
-    });
-    if (!record)
-      return null;
-    try {
-      return await parseAvatarRecord(client, {
-        record,
-        gatewayUrls: assetGatewayUrls
-      });
-    } catch {
-      return null;
-    }
-  }
-
   // node_modules/viem/_esm/actions/ens/getEnsName.js
   init_abis();
   init_getChainContractAddress();
@@ -25770,19 +25514,19 @@ ${prettyStateOverride(stateOverride)}`;
     return action(rest);
   }
 
-  // node_modules/@wagmi/core/dist/esm/actions/getEnsAvatar.js
-  function getEnsAvatar2(config, parameters) {
+  // node_modules/@wagmi/core/dist/esm/actions/getEnsName.js
+  function getEnsName2(config, parameters) {
     const { chainId, ...rest } = parameters;
     const client = config.getClient({ chainId });
-    const action = getAction2(client, getEnsAvatar, "getEnsAvatar");
+    const action = getAction2(client, getEnsName, "getEnsName");
     return action(rest);
   }
 
-  // node_modules/@wagmi/core/dist/esm/actions/getEnsName.js
-  function getEnsName2(config, parameters) {
+  // node_modules/@wagmi/core/dist/esm/actions/getEnsText.js
+  function getEnsText2(config, parameters) {
     const { chainId, ...rest } = parameters;
     const client = config.getClient({ chainId });
-    const action = getAction2(client, getEnsName, "getEnsName");
+    const action = getAction2(client, getEnsText, "getEnsText");
     return action(rest);
   }
 
@@ -29891,22 +29635,6 @@ ${prettyStateOverride(stateOverride)}`;
     return ["ensAddress", filterQueryOptions(options)];
   }
 
-  // node_modules/@wagmi/core/dist/esm/query/getEnsAvatar.js
-  function getEnsAvatarQueryOptions(config, options = {}) {
-    return {
-      async queryFn({ queryKey }) {
-        const { name, scopeKey: _2, ...parameters } = queryKey[1];
-        if (!name)
-          throw new Error("name is required");
-        return getEnsAvatar2(config, { ...parameters, name });
-      },
-      queryKey: getEnsAvatarQueryKey(options)
-    };
-  }
-  function getEnsAvatarQueryKey(options = {}) {
-    return ["ensAvatar", filterQueryOptions(options)];
-  }
-
   // node_modules/@wagmi/core/dist/esm/query/getEnsName.js
   function getEnsNameQueryOptions(config, options = {}) {
     return {
@@ -29923,6 +29651,22 @@ ${prettyStateOverride(stateOverride)}`;
     return ["ensName", filterQueryOptions(options)];
   }
 
+  // node_modules/@wagmi/core/dist/esm/query/getEnsText.js
+  function getEnsTextQueryOptions(config, options = {}) {
+    return {
+      async queryFn({ queryKey }) {
+        const { key, name, scopeKey: _2, ...parameters } = queryKey[1];
+        if (!key || !name)
+          throw new Error("key and name are required");
+        return getEnsText2(config, { ...parameters, key, name });
+      },
+      queryKey: getEnsTextQueryKey(options)
+    };
+  }
+  function getEnsTextQueryKey(options = {}) {
+    return ["ensText", filterQueryOptions(options)];
+  }
+
   // node_modules/@wagmi/core/dist/esm/query/readContract.js
   function readContractQueryOptions(config, options = {}) {
     return {
@@ -30213,29 +29957,29 @@ ${prettyStateOverride(stateOverride)}`;
     return useQuery2({ ...query, ...options, enabled });
   }
 
-  // node_modules/wagmi/dist/esm/hooks/useEnsAvatar.js
-  function useEnsAvatar(parameters = {}) {
-    const { name, query = {} } = parameters;
+  // node_modules/wagmi/dist/esm/hooks/useEnsName.js
+  function useEnsName(parameters = {}) {
+    const { address, query = {} } = parameters;
     const config = useConfig(parameters);
     const chainId = useChainId({ config });
-    const options = getEnsAvatarQueryOptions(config, {
+    const options = getEnsNameQueryOptions(config, {
       ...parameters,
       chainId: parameters.chainId ?? chainId
     });
-    const enabled = Boolean(name && (query.enabled ?? true));
+    const enabled = Boolean(address && (query.enabled ?? true));
     return useQuery2({ ...query, ...options, enabled });
   }
 
-  // node_modules/wagmi/dist/esm/hooks/useEnsName.js
-  function useEnsName(parameters = {}) {
-    const { address, query = {} } = parameters;
+  // node_modules/wagmi/dist/esm/hooks/useEnsText.js
+  function useEnsText(parameters = {}) {
+    const { key, name, query = {} } = parameters;
     const config = useConfig(parameters);
     const chainId = useChainId({ config });
-    const options = getEnsNameQueryOptions(config, {
+    const options = getEnsTextQueryOptions(config, {
       ...parameters,
       chainId: parameters.chainId ?? chainId
     });
-    const enabled = Boolean(address && (query.enabled ?? true));
+    const enabled = Boolean(key && name && (query.enabled ?? true));
     return useQuery2({ ...query, ...options, enabled });
   }
 
@@ -31694,6 +31438,66 @@ ${prettyStateOverride(stateOverride)}`;
     };
   }
 
+  // src/core/avatar.ts
+  var IPFS_GATEWAY = "https://ipfs.io/ipfs/";
+  var ARWEAVE_GATEWAY = "https://arweave.net/";
+  function avatarUrl(uri) {
+    if (typeof uri !== "string") return null;
+    const u2 = uri.trim();
+    if (/^data:image\/(png|jpe?g|gif|webp|avif|svg\+xml)[;,]/i.test(u2)) return u2;
+    let m2 = u2.match(/^ipfs:\/\/(?:ipfs\/)?([a-zA-Z0-9]{46,}(?:\/[^?#\s]*)?)$/);
+    if (m2) return IPFS_GATEWAY + m2[1];
+    m2 = u2.match(/^ar:\/\/([a-zA-Z0-9_-]{43}(?:\/[^?#\s]*)?)$/);
+    if (m2) return ARWEAVE_GATEWAY + m2[1];
+    if (/^https:\/\/euc\.li\/[^?#\s]+$/.test(u2)) return u2;
+    m2 = u2.match(/^https:\/\/[^/]+\/ipfs\/([a-zA-Z0-9]{46,}(?:\/[^?#\s]*)?)$/);
+    if (m2) return IPFS_GATEWAY + m2[1];
+    return null;
+  }
+  function parseNftAvatar(raw) {
+    const m2 = typeof raw === "string" && raw.trim().match(/^eip155:(\d+)\/(erc721|erc1155):(0x[0-9a-fA-F]{40})\/(\d+)$/);
+    return m2 ? { chainId: Number(m2[1]), standard: m2[2], contract: m2[3], tokenId: BigInt(m2[4]) } : null;
+  }
+  var NFT_AVATAR_ABI = [
+    { type: "function", name: "tokenURI", stateMutability: "view", inputs: [{ type: "uint256" }], outputs: [{ type: "string" }] },
+    { type: "function", name: "uri", stateMutability: "view", inputs: [{ type: "uint256" }], outputs: [{ type: "string" }] }
+  ];
+  async function nftAvatarImage(tokenUri, tokenId, fetchFn = fetch) {
+    const uri = tokenUri.replace("{id}", tokenId.toString(16).padStart(64, "0"));
+    let meta;
+    const inline = uri.match(/^data:application\/json(;base64)?,([\s\S]*)$/);
+    if (inline) meta = JSON.parse(inline[1] ? atob(inline[2]) : decodeURIComponent(inline[2]));
+    else {
+      const url = uri.startsWith("data:") ? null : avatarUrl(uri);
+      if (!url) return null;
+      const res = await fetchFn(url);
+      if (!res.ok) return null;
+      meta = await res.json();
+    }
+    return avatarUrl(meta?.image ?? meta?.image_url);
+  }
+
+  // src/hooks/useSafeAvatar.ts
+  function useSafeAvatar(name, chainId) {
+    const { data: raw } = useEnsText({ name, key: "avatar", chainId, query: { enabled: !!name } });
+    const direct = avatarUrl(raw);
+    const nft = direct ? null : parseNftAvatar(raw);
+    const { data: tokenUri } = useReadContract({
+      address: nft?.contract,
+      abi: NFT_AVATAR_ABI,
+      functionName: nft?.standard === "erc1155" ? "uri" : "tokenURI",
+      args: nft ? [nft.tokenId] : void 0,
+      chainId,
+      query: { enabled: !!nft && nft.chainId === chainId }
+    });
+    const { data: image } = useQuery({
+      queryKey: ["thurin-nft-avatar", tokenUri, nft?.tokenId.toString()],
+      queryFn: () => nftAvatarImage(tokenUri, nft.tokenId).catch(() => null),
+      enabled: typeof tokenUri === "string" && !!nft
+    });
+    return direct ?? image ?? null;
+  }
+
   // src/hooks/useThurinIdentity.ts
   function isAddress2(value) {
     return /^0x[0-9a-fA-F]{40}$/.test(value);
@@ -31721,11 +31525,7 @@ ${prettyStateOverride(stateOverride)}`;
       query: { enabled: !!address }
     });
     const displayName = ensInput || ensName || null;
-    const { data: ensAvatar } = useEnsAvatar({
-      name: displayName ? safeNormalize(displayName) : void 0,
-      chainId: chain.id,
-      query: { enabled: !!displayName }
-    });
+    const ensAvatar = useSafeAvatar(displayName ? safeNormalize(displayName) : void 0, chain.id);
     const {
       claims,
       totalClaims,
@@ -31745,7 +31545,7 @@ ${prettyStateOverride(stateOverride)}`;
     return {
       address,
       ensName: displayName,
-      ensAvatar: ensAvatar ?? null,
+      ensAvatar,
       claims,
       totalClaims,
       activeClaims,