thirdweb 5.52.0-nightly-3a32b11a80cb28f22575219ab8f80e703793ec10-20240906000338 → 5.53.0-nightly-7dd2869e240522a467c73f0017f080ee118c5bf0-20240908000435

package/src/social/profiles.ts

@@ -0,0 +1,46 @@
+import type { ThirdwebClient } from "../client/client.js";
+import { getThirdwebBaseUrl } from "../utils/domains.js";
+import { getClientFetch } from "../utils/fetch.js";
+import type { SocialProfiles } from "./types.js";
+
+/**
+ * Fetches the wallet's available social profiles.
+ * @param args - The arguments to use when fetching the social profiles.
+ * @param args.address - The wallet address to fetch the social profiles for.
+ * @param args.client - The Thirdweb client.
+ * @returns A promise resolving to the retrieved social profiles for different protocols. If a profile is not available for a protocol, the value will be `null`.
+ *
+ * @example
+ * ```ts
+ * import { getProfiles } from "thirdweb/social";
+ * const profiles = await getProfiles({
+ *   address: "0x...",
+ *   client,
+ * });
+ * ```
+ * @beta
+ */
+export async function getSocialProfiles(args: {
+  address: string;
+  client: ThirdwebClient;
+}): Promise<SocialProfiles> {
+  const { address, client } = args;
+
+  const clientFetch = getClientFetch(client);
+  const response = await clientFetch(
+    `${getThirdwebBaseUrl("social")}/v1/profiles/${address}`,
+  );
+
+  if (response.status !== 200) {
+    try {
+      const errorBody = await response.json();
+      throw new Error(`Failed to fetch profile: ${errorBody.message}`);
+    } catch {
+      throw new Error(
+        `Failed to fetch profile: ${response.status}\n${await response.text()}`,
+      );
+    }
+  }
+
+  return (await response.json()).data as SocialProfiles;
+}

package/src/social/types.ts

@@ -0,0 +1,43 @@
+export type FarcasterProfile = {
+  fid?: number;
+  bio?: string;
+  pfp?: string;
+  display?: string;
+  username?: string;
+  custodyAddress?: string;
+  addresses?: string[];
+};
+
+export type LensProfile = {
+  name?: string;
+  bio?: string;
+  picture?: string;
+  coverPicture?: string;
+};
+
+export type EnsProfile = {
+  name?: string;
+  address?: string;
+  avatar?: string;
+  display?: string;
+  description?: string;
+  keywords?: string[];
+  email?: string;
+  mail?: string;
+  notice?: string;
+  location?: string;
+  phone?: string;
+  url?: string;
+  twitter?: string;
+  github?: string;
+  discord?: string;
+  telegram?: string;
+};
+
+export type SocialProfiles = {
+  type: "farcaster" | "lens" | "ens";
+  name?: string;
+  avatar?: string;
+  bio?: string;
+  metadata?: FarcasterProfile | LensProfile | EnsProfile;
+}[];

package/src/utils/domains.ts

@@ -4,6 +4,11 @@ type DomainOverrides = {
    * @default "rpc.thirdweb.com"
    */
   rpc?: string;
+  /**
+   * The base URL for the social service.
+   * @default "social.thirdweb.com"
+   */
+  social?: string;
   /**
    * The base URL for the in-app wallet service
    * @default "embedded-wallet.thirdweb.com"
@@ -28,6 +33,7 @@ type DomainOverrides = {
 
 export const DEFAULT_RPC_URL = "rpc.thirdweb.com";
 const DEFAULT_IN_APP_WALLET_URL = "embedded-wallet.thirdweb.com";
+const DEFAULT_SOCIAL_URL = "social.thirdweb.com";
 const DEFAULT_PAY_URL = "pay.thirdweb.com";
 const DEFAULT_STORAGE_URL = "storage.thirdweb.com";
 const DEFAULT_BUNDLER_URL = "bundler.thirdweb.com";
@@ -35,6 +41,7 @@ const DEFAULT_BUNDLER_URL = "bundler.thirdweb.com";
 let domains: { [k in keyof DomainOverrides]-?: string } = {
   rpc: DEFAULT_RPC_URL,
   inAppWallet: DEFAULT_IN_APP_WALLET_URL,
+  social: DEFAULT_SOCIAL_URL,
   pay: DEFAULT_PAY_URL,
   storage: DEFAULT_STORAGE_URL,
   bundler: DEFAULT_BUNDLER_URL,
@@ -47,6 +54,7 @@ export const setThirdwebDomains = (DomainOverrides: DomainOverrides) => {
   domains = {
     rpc: DomainOverrides.rpc ?? DEFAULT_RPC_URL,
     inAppWallet: DomainOverrides.inAppWallet ?? DEFAULT_IN_APP_WALLET_URL,
+    social: DomainOverrides.social ?? DEFAULT_SOCIAL_URL,
     pay: DomainOverrides.pay ?? DEFAULT_PAY_URL,
     storage: DomainOverrides.storage ?? DEFAULT_STORAGE_URL,
     bundler: DomainOverrides.bundler ?? DEFAULT_BUNDLER_URL,

package/src/utils/function-id.ts

@@ -1,11 +1,9 @@
-import { sha256 } from "@noble/hashes/sha256";
-import { uint8ArrayToHex } from "./encoding/hex.js";
+import { randomBytesHex } from "./random.js";
 
 // biome-ignore lint/suspicious/noExplicitAny: the whoel point here is to accept anything
 type AnyFunction = (...args: any[]) => any;
 
-// WeakMap should be fine, if we de-reference the function, it should be garbage collected
-const functionIdCache = new WeakMap<AnyFunction, string>();
+const functionIdCache = new Map<AnyFunction, string>();
 
 /**
  * Retrieves the unique identifier for a given function.
@@ -20,7 +18,7 @@ export function getFunctionId(fn: AnyFunction) {
     // biome-ignore lint/style/noNonNullAssertion: the `has` above ensures that this will always be set
     return functionIdCache.get(fn)!;
   }
-  const id = uint8ArrayToHex(sha256(fn.toString()));
+  const id = randomBytesHex();
   functionIdCache.set(fn, id);
   return id;
 }

package/src/utils/ipfs.test.ts

@@ -1,6 +1,10 @@
 import { describe, expect, it } from "vitest";
 import { createThirdwebClient } from "../client/client.js";
-import { findIPFSCidFromUri, resolveScheme } from "./ipfs.js";
+import {
+  findIPFSCidFromUri,
+  getBaseUriFromBatch,
+  resolveScheme,
+} from "./ipfs.js";
 
 describe("resolveScheme", () => {
   it("should resolve ipfs scheme when not passing a gateway override", () => {
@@ -70,3 +74,55 @@ describe("resolveScheme", () => {
     expect(findIPFSCidFromUri(uri)).toBe(cid);
   });
 });
+
+describe("getBaseUriFromBatch", () => {
+  it("should return the base uri", () => {
+    const batchOfUris = ["ipfs://Qm.../0", "ipfs://Qm.../1", "ipfs://Qm.../2"];
+    const baseUri = getBaseUriFromBatch(batchOfUris);
+    expect(baseUri).toMatchInlineSnapshot(`"ipfs://Qm.../"`);
+  });
+  it("should throw if the batch is empty", () => {
+    expect(() => getBaseUriFromBatch([])).toThrowErrorMatchingInlineSnapshot(
+      "[Error: Batch of URIs is empty]",
+    );
+  });
+
+  it("should throw if an element of the array does not have the same base", () => {
+    const batchOfUris = ["ipfs://Qm.../0", "ipfs://Qm.../1", "ipfs://Qm2.../2"];
+    expect(() =>
+      getBaseUriFromBatch(batchOfUris),
+    ).toThrowErrorMatchingInlineSnapshot(
+      "[Error: All URIs in the batch must have the same base URI]",
+    );
+  });
+
+  it("should work with a custom domain", () => {
+    const batchOfUris = [
+      "https://example.com/0",
+      "https://example.com/1",
+      "https://example.com/2",
+    ];
+    const baseUri = getBaseUriFromBatch(batchOfUris);
+    expect(baseUri).toMatchInlineSnapshot(`"https://example.com/"`);
+  });
+
+  it("should work with a custom domain and path", () => {
+    const batchOfUris = [
+      "https://example.com/path/0",
+      "https://example.com/path/1",
+      "https://example.com/path/2",
+    ];
+    const baseUri = getBaseUriFromBatch(batchOfUris);
+    expect(baseUri).toMatchInlineSnapshot(`"https://example.com/path/"`);
+  });
+
+  it("should work with a custom domain and path with trailing slash", () => {
+    const batchOfUris = [
+      "https://example.com/path/0/",
+      "https://example.com/path/1/",
+      "https://example.com/path/2/",
+    ];
+    const baseUri = getBaseUriFromBatch(batchOfUris);
+    expect(baseUri).toMatchInlineSnapshot(`"https://example.com/path/"`);
+  });
+});

package/src/utils/ipfs.ts

@@ -1,5 +1,4 @@
 import type { ThirdwebClient } from "../client/client.js";
-
 import type { FileOrBufferOrString } from "../storage/upload/types.js";
 
 export type ResolveSchemeOptions = {
@@ -109,23 +108,32 @@ export async function uploadOrExtractURIs<
  * @internal
  */
 export function getBaseUriFromBatch(uris: string[]): string {
-  const urisWithSlashes = uris.map((uri) => new URL(uri));
-  const baseUri = urisWithSlashes[0];
-  for (let i = 0; i < urisWithSlashes.length; i++) {
-    const uri = urisWithSlashes[i];
-    if (baseUri?.host !== uri?.host) {
-      throw new Error(
-        `Can only create batches with the same base URI for every entry in the batch. Expected '${baseUri}' but got '${uri}'`,
-      );
+  const [base, ...rest] = uris.map((uri) => {
+    // remove query parameters
+    // biome-ignore lint/style/noParameterAssign: lemme do my stuff
+    [uri] = uri.split("?") as [string];
+    // remove fragments
+    // biome-ignore lint/style/noParameterAssign: lemme do my stuff
+    [uri] = uri.split("#") as [string];
+
+    // if the URI ends with a `/`, remove it
+    if (uri.endsWith("/")) {
+      // biome-ignore lint/style/noParameterAssign: lemme do my stuff
+      uri = uri.slice(0, -1);
     }
-  }
 
-  if (!baseUri) {
-    throw new Error("No base URI found in the batch");
+    // remove the last part of the URI & add the trailing `/`
+    return `${uri.split("/").slice(0, -1).join("/")}/`;
+  });
+
+  if (!base) {
+    throw new Error("Batch of URIs is empty");
   }
 
-  // Ensure that baseUri ends with trailing slash
-  return `${baseUri.protocol}//${baseUri.host}/`;
+  if (rest.some((uri) => uri !== base)) {
+    throw new Error("All URIs in the batch must have the same base URI");
+  }
+  return base;
 }
 
 function isUriList<T extends FileOrBufferOrString | Record<string, unknown>>(

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.52.0-nightly-3a32b11a80cb28f22575219ab8f80e703793ec10-20240906000338";
+export const version = "5.53.0-nightly-7dd2869e240522a467c73f0017f080ee118c5bf0-20240908000435";

package/src/wallets/smart/lib/userop.ts

@@ -10,6 +10,7 @@ import { getUserOpHash as getUserOpHashV06 } from "../../../extensions/erc4337/_
 import { getUserOpHash as getUserOpHashV07 } from "../../../extensions/erc4337/__generated__/IEntryPoint_v07/read/getUserOpHash.js";
 import { getDefaultGasOverrides } from "../../../gas/fee-data.js";
 import { encode } from "../../../transaction/actions/encode.js";
+import { toSerializableTransaction } from "../../../transaction/actions/to-serializable-transaction.js";
 import type { PreparedTransaction } from "../../../transaction/prepare-transaction.js";
 import type { TransactionReceipt } from "../../../transaction/types.js";
 import { isContractDeployed } from "../../../utils/bytecode/is-contract-deployed.js";
@@ -30,11 +31,17 @@ import {
   getUserOpGasFees,
   getUserOpReceipt,
 } from "./bundler.js";
-import { prepareCreateAccount } from "./calls.js";
+import {
+  predictAddress,
+  prepareBatchExecute,
+  prepareCreateAccount,
+  prepareExecute,
+} from "./calls.js";
 import {
   DUMMY_SIGNATURE,
   ENTRYPOINT_ADDRESS_v0_6,
   ENTRYPOINT_ADDRESS_v0_7,
+  getDefaultAccountFactory,
   getDefaultBundlerUrl,
   getEntryPointVersion,
 } from "./constants.js";
@@ -486,9 +493,10 @@ async function populateUserOp_v0_6(args: {
  * ```ts
  * import { signUserOp } from "thirdweb/wallets/smart";
  *
- * const userOp = createUnsignedUserOp(...);
+ * const userOp = await createUnsignedUserOp(...);
  *
  * const signedUserOp = await signUserOp({
+ *  client,
  *  userOp,
  *  chain,
  *  adminAccount,
@@ -592,3 +600,91 @@ async function getAccountNonce(options: {
     sender: accountContract.address,
   });
 }
+
+/**
+ * Create and sign a user operation.
+ * @param options - The options for creating and signing the user operation
+ * @returns - The signed user operation
+ * @example
+ * ```ts
+ * import { createAndSignUserOp } from "thirdweb/wallets/smart";
+ *
+ * const userOp = await createAndSignUserOp({
+ *  client,
+ *  adminAccount,
+ *  smartWalletOptions,
+ *  transactions,
+ * });
+ * ```
+ * @walletUtils
+ */
+export async function createAndSignUserOp(options: {
+  transactions: PreparedTransaction[];
+  adminAccount: Account;
+  client: ThirdwebClient;
+  smartWalletOptions: SmartWalletOptions;
+}) {
+  const config = options.smartWalletOptions;
+  const factoryContract = getContract({
+    address:
+      config.factoryAddress ||
+      getDefaultAccountFactory(config.overrides?.entrypointAddress),
+    chain: config.chain,
+    client: options.client,
+  });
+  const accountAddress = await predictAddress({
+    factoryContract,
+    adminAddress: options.adminAccount.address,
+    predictAddressOverride: config.overrides?.predictAddress,
+    accountSalt: config.overrides?.accountSalt,
+    accountAddress: config.overrides?.accountAddress,
+  });
+  const accountContract = getContract({
+    address: accountAddress,
+    chain: config.chain,
+    client: options.client,
+  });
+
+  let executeTx: PreparedTransaction;
+  if (options.transactions.length === 1) {
+    const tx = options.transactions[0] as PreparedTransaction;
+    const serializedTx = await toSerializableTransaction({
+      transaction: tx,
+    });
+    executeTx = prepareExecute({
+      accountContract,
+      transaction: serializedTx,
+      executeOverride: config.overrides?.execute,
+    });
+  } else {
+    const serializedTxs = await Promise.all(
+      options.transactions.map((tx) =>
+        toSerializableTransaction({
+          transaction: tx,
+        }),
+      ),
+    );
+    executeTx = prepareBatchExecute({
+      accountContract,
+      transactions: serializedTxs,
+      executeBatchOverride: config.overrides?.executeBatch,
+    });
+  }
+
+  const unsignedUserOp = await createUnsignedUserOp({
+    transaction: executeTx,
+    factoryContract,
+    accountContract,
+    adminAddress: options.adminAccount.address,
+    sponsorGas: "sponsorGas" in config ? config.sponsorGas : config.gasless,
+    overrides: config.overrides,
+  });
+  const signedUserOp = await signUserOp({
+    client: options.client,
+    chain: config.chain,
+    adminAccount: options.adminAccount,
+    entrypointAddress: config.overrides?.entrypointAddress,
+    userOp: unsignedUserOp,
+  });
+  return signedUserOp;
+}