thirdweb 5.60.1 → 5.61.0-nightly-27375af91b86eb21d251a99dec57e0a6470511ca-20241004000320

package/src/extensions/unstoppable-domains/__generated__/UnstoppableDomains/read/reverseNameOf.ts

@@ -0,0 +1,126 @@
+import type { AbiParameterToPrimitiveType } from "abitype";
+import { readContract } from "../../../../../transaction/read-contract.js";
+import type { BaseTransactionOptions } from "../../../../../transaction/types.js";
+import { encodeAbiParameters } from "../../../../../utils/abi/encodeAbiParameters.js";
+import { decodeAbiParameters } from "viem";
+import type { Hex } from "../../../../../utils/encoding/hex.js";
+import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+/**
+ * Represents the parameters for the "reverseNameOf" function.
+ */
+export type ReverseNameOfParams = {
+  addr: AbiParameterToPrimitiveType<{ type: "address"; name: "addr" }>;
+};
+
+export const FN_SELECTOR = "0xbebec6b4" as const;
+const FN_INPUTS = [
+  {
+    type: "address",
+    name: "addr",
+  },
+] as const;
+const FN_OUTPUTS = [
+  {
+    type: "string",
+    name: "reverseUri",
+  },
+] as const;
+
+/**
+ * Checks if the `reverseNameOf` method is supported by the given contract.
+ * @param availableSelectors An array of 4byte function selectors of the contract. You can get this in various ways, such as using "whatsabi" or if you have the ABI of the contract available you can use it to generate the selectors.
+ * @returns A boolean indicating if the `reverseNameOf` method is supported.
+ * @extension UNSTOPPABLE-DOMAINS
+ * @example
+ * ```ts
+ * import { isReverseNameOfSupported } from "thirdweb/extensions/unstoppable-domains";
+ * const supported = isReverseNameOfSupported(["0x..."]);
+ * ```
+ */
+export function isReverseNameOfSupported(availableSelectors: string[]) {
+  return detectMethod({
+    availableSelectors,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Encodes the parameters for the "reverseNameOf" function.
+ * @param options - The options for the reverseNameOf function.
+ * @returns The encoded ABI parameters.
+ * @extension UNSTOPPABLE-DOMAINS
+ * @example
+ * ```ts
+ * import { encodeReverseNameOfParams } from "thirdweb/extensions/unstoppable-domains";
+ * const result = encodeReverseNameOfParams({
+ *  addr: ...,
+ * });
+ * ```
+ */
+export function encodeReverseNameOfParams(options: ReverseNameOfParams) {
+  return encodeAbiParameters(FN_INPUTS, [options.addr]);
+}
+
+/**
+ * Encodes the "reverseNameOf" function into a Hex string with its parameters.
+ * @param options - The options for the reverseNameOf function.
+ * @returns The encoded hexadecimal string.
+ * @extension UNSTOPPABLE-DOMAINS
+ * @example
+ * ```ts
+ * import { encodeReverseNameOf } from "thirdweb/extensions/unstoppable-domains";
+ * const result = encodeReverseNameOf({
+ *  addr: ...,
+ * });
+ * ```
+ */
+export function encodeReverseNameOf(options: ReverseNameOfParams) {
+  // we do a "manual" concat here to avoid the overhead of the "concatHex" function
+  // we can do this because we know the specific formats of the values
+  return (FN_SELECTOR +
+    encodeReverseNameOfParams(options).slice(
+      2,
+    )) as `${typeof FN_SELECTOR}${string}`;
+}
+
+/**
+ * Decodes the result of the reverseNameOf function call.
+ * @param result - The hexadecimal result to decode.
+ * @returns The decoded result as per the FN_OUTPUTS definition.
+ * @extension UNSTOPPABLE-DOMAINS
+ * @example
+ * ```ts
+ * import { decodeReverseNameOfResult } from "thirdweb/extensions/unstoppable-domains";
+ * const result = decodeReverseNameOfResultResult("...");
+ * ```
+ */
+export function decodeReverseNameOfResult(result: Hex) {
+  return decodeAbiParameters(FN_OUTPUTS, result)[0];
+}
+
+/**
+ * Calls the "reverseNameOf" function on the contract.
+ * @param options - The options for the reverseNameOf function.
+ * @returns The parsed result of the function call.
+ * @extension UNSTOPPABLE-DOMAINS
+ * @example
+ * ```ts
+ * import { reverseNameOf } from "thirdweb/extensions/unstoppable-domains";
+ *
+ * const result = await reverseNameOf({
+ *  contract,
+ *  addr: ...,
+ * });
+ *
+ * ```
+ */
+export async function reverseNameOf(
+  options: BaseTransactionOptions<ReverseNameOfParams>,
+) {
+  return readContract({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: [options.addr],
+  });
+}

package/src/extensions/unstoppable-domains/consts.ts

@@ -0,0 +1 @@
+export const UD_POLYGON_MAINNET = "0xa9a6A3626993D487d2Dbda3173cf58cA1a9D9e9f";

package/src/extensions/unstoppable-domains/read/resolveAddress.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { TEST_CLIENT } from "~test/test-clients.js";
+import { resolveAddress } from "./resolveAddress.js";
+
+// Double check: https://unstoppabledomains.com/d/thirdwebsdk.unstoppable
+
+describe("Unstoppable Domain: resolve address", () => {
+  it("should resolve address", async () => {
+    expect(
+      (
+        await resolveAddress({
+          name: "thirdwebsdk.unstoppable",
+          client: TEST_CLIENT,
+        })
+      ).toLowerCase(),
+    ).toBe("0x12345674b599ce99958242b3D3741e7b01841DF3".toLowerCase());
+  });
+});

package/src/extensions/unstoppable-domains/read/resolveAddress.ts

@@ -0,0 +1,96 @@
+import { polygon } from "../../../chains/chain-definitions/polygon.js";
+import type { Chain } from "../../../chains/types.js";
+import type { ThirdwebClient } from "../../../client/client.js";
+import { getContract } from "../../../contract/contract.js";
+import { getAddress, isAddress } from "../../../utils/address.js";
+import { withCache } from "../../../utils/promise/withCache.js";
+import { getMany } from "../__generated__/UnstoppableDomains/read/getMany.js";
+import { namehash } from "../__generated__/UnstoppableDomains/read/namehash.js";
+import { UD_POLYGON_MAINNET } from "../consts.js";
+
+/**
+ * @extension UNSTOPPABLE-DOMAINS
+ */
+export type ResolveAddressOptions = {
+  client: ThirdwebClient;
+  name: string;
+  resolverAddress?: string;
+  resolverChain?: Chain;
+};
+
+/**
+ * Resolve an Unstoppable-Domain domain to an Ethereum address
+ * @param options - The options for resolving an UD domain
+ * @returns The Ethereum address associated with the domain name. [Learn more](https://docs.unstoppabledomains.com/reverse-resolution/)
+ * @example
+ *
+ * ### Basic usage
+ * ```ts
+ * import { resolveAddress } from "thirdweb/extension/unstoppable-domains";
+ *
+ * const address = await resolveAddress({
+ *   client,
+ *   name: "thirdweb.crypto",
+ * });
+ * ```
+ *
+ * ### Custom resolver
+ * By default this extension will try to resolve the name on Polygon mainnet,
+ * you can decide to customize the resolver contract by specifying `resolverAddress` and `resolverChain`
+ * ```ts
+ * import { ethereum } from "thirdweb/chains";
+ *
+ * const address = await resolveAddress({
+ *   client,
+ *   name: "thirdweb.crypto",
+ *   resolverAddress: "0x...",
+ *   resolverChain: ethereum,
+ * });
+ * ```
+ *
+ * @extension UNSTOPPABLE-DOMAINS
+ */
+export async function resolveAddress(
+  options: ResolveAddressOptions,
+): Promise<string> {
+  const { client, name, resolverAddress, resolverChain } = options;
+  if (isAddress(name)) {
+    return getAddress(name);
+  }
+  return withCache(
+    async () => {
+      const contract = getContract({
+        client,
+        chain: resolverChain || polygon,
+        address: resolverAddress || UD_POLYGON_MAINNET,
+      });
+
+      // Get namehash
+      const possibleTokenId = await namehash({
+        contract,
+        labels: name.split("."),
+      });
+
+      // Resolve ETH address from the tokenId
+      const resolved = await getMany({
+        contract,
+        tokenId: possibleTokenId,
+        // note that you can also retrieve the (BTC, SOL, etc.) address by using "crypto.<symbol>.address" (should that become useful one day)
+        keys: ["crypto.ETH.address"],
+      });
+
+      const possibleETHAddress = resolved[0];
+      if (!possibleETHAddress) {
+        throw new Error(
+          `Could not retrieve any ETH address associated with domain name: ${name}. Make sure you have set the base EVM address for your domain here: https://unstoppabledomains.com/manage?page=crypto&domain=<your-domain>`,
+        );
+      }
+      return possibleETHAddress;
+    },
+    {
+      cacheKey: `unstoppable-domain:addr:${resolverChain?.id || 1}:${name}`,
+      // 1min cache
+      cacheTime: 60 * 1000,
+    },
+  );
+}

package/src/extensions/unstoppable-domains/read/resolveName.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { TEST_CLIENT } from "~test/test-clients.js";
+import { resolveName } from "./resolveName.js";
+
+// Double check: https://unstoppabledomains.com/d/thirdwebsdk.unstoppable
+
+describe("Unstoppable Domain: resolve name", () => {
+  it("should resolve name", async () => {
+    expect(
+      await resolveName({
+        address: "0x12345674b599ce99958242b3D3741e7b01841DF3",
+        client: TEST_CLIENT,
+      }),
+    ).toBe("thirdwebsdk.unstoppable");
+  });
+});

package/src/extensions/unstoppable-domains/read/resolveName.ts

@@ -0,0 +1,77 @@
+import { polygon } from "../../../chains/chain-definitions/polygon.js";
+import type { Chain } from "../../../chains/types.js";
+import type { ThirdwebClient } from "../../../client/client.js";
+import { getContract } from "../../../contract/contract.js";
+import { withCache } from "../../../utils/promise/withCache.js";
+import { reverseNameOf } from "../__generated__/UnstoppableDomains/read/reverseNameOf.js";
+import { UD_POLYGON_MAINNET } from "../consts.js";
+
+/**
+ * @extension UNSTOPPABLE-DOMAINS
+ */
+export type ResolveUDNameOptions = {
+  client: ThirdwebClient;
+  address: string;
+  resolverAddress?: string;
+  resolverChain?: Chain;
+};
+
+/**
+ * Resolves the primary Untoppable-Domains name for a specified address.
+ * @param options - The options for resolving an UD domain
+ * @example
+ *
+ * ### Basic usage
+ * ```ts
+ * import { resolveName } from "thirdweb/extension/unstoppable-domains";
+ *
+ * const name = await resolveName({
+ *   client,
+ *   address: "0x...",
+ * });
+ * ```
+ *
+ * ### Custom resolver
+ * By default this extension will try to resolve the address on Polygon mainnet,
+ * you can decide to customize the resolver contract by specifying `resolverAddress` and `resolverChain`
+ * ```ts
+ * import { ethereum } from "thirdweb/chains";
+ *
+ * const address = await resolveName({
+ *   client,
+ *   address: "0x...",
+ *   resolverAddress: "0x...",
+ *   resolverChain: ethereum,
+ * });
+ * ```
+ * @extension UNSTOPPABLE-DOMAINS
+ */
+export async function resolveName(
+  options: ResolveUDNameOptions,
+): Promise<string> {
+  const { client, address, resolverAddress, resolverChain } = options;
+  return withCache(
+    async () => {
+      const contract = getContract({
+        client,
+        chain: resolverChain || polygon,
+        address: resolverAddress || UD_POLYGON_MAINNET,
+      });
+
+      // Note: if the given wallet address does not have any UD name, `reverseNameOf` will return an empty string
+      // This can still happen if you have transfered a domain to a new address, and forgot to set up the Reverse Resolution on the new address
+      const domain = await reverseNameOf({ contract, addr: address });
+      if (!domain) {
+        throw new Error(
+          `Failed to retrieve domain for address: ${address}. Make sure you have set the Reverse Resolution address for your domain at https://unstoppabledomains.com/manage?page=reverseResolution&domain=your-domain`,
+        );
+      }
+      return domain;
+    },
+    {
+      cacheKey: `unstoppable-domain:name:${resolverChain?.id || 1}:${address}`,
+      // 1min cache
+      cacheTime: 60 * 1000,
+    },
+  );
+}

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.60.1";
+export const version = "5.61.0-nightly-27375af91b86eb21d251a99dec57e0a6470511ca-20241004000320";