thirdweb 5.56.0-nightly-a5e605c65e360a9d3d2e553d6783e58582b50a70-20240917000331 → 5.57.0-nightly-cf1683c3feea6eb36ac6b902a1dd64c8ed8803c9-20240918000340

package/src/transaction/resolve-method.ts

@@ -1,4 +1,5 @@
 import type { Abi, AbiFunction } from "abitype";
+import { parseAbiItem } from "abitype";
 import { resolveContractAbi } from "../contract/actions/resolve-abi.js";
 import type { ThirdwebContract } from "../contract/contract.js";
 
@@ -22,9 +23,19 @@ import type { ThirdwebContract } from "../contract/contract.js";
  * ```
  * @contract
  */
-export function resolveMethod<abiFn extends AbiFunction>(method: string) {
-  return async (contract: ThirdwebContract) => {
-    const resolvedAbi = await resolveContractAbi<Abi>(contract);
+export function resolveMethod<
+  abiFn extends AbiFunction,
+  TAbi extends Abi = Abi,
+>(method: string) {
+  return async (contract: ThirdwebContract<TAbi>) => {
+    if (typeof method === "string" && method.startsWith("function ")) {
+      // we know it will be an abi function so we can cast it
+      return parseAbiItem(method) as AbiFunction;
+    }
+
+    const resolvedAbi = contract.abi?.length
+      ? contract.abi
+      : await resolveContractAbi<Abi>(contract);
     // we try to find the abiFunction in the abi
     const abiFunction = resolvedAbi.find((item) => {
       // if the item is not a function we can ignore it

package/src/utils/encoding/hex.ts

@@ -436,9 +436,8 @@ export function numberToHex(
     );
   }
 
-  const hex = `0x${(signed && value < 0
-    ? (1n << BigInt(size * 8)) + BigInt(value)
-    : value
+  const hex = `0x${(
+    signed && value < 0 ? (1n << BigInt(size * 8)) + BigInt(value) : value
   ).toString(16)}` as Hex;
   if (size) {
     return padHex(hex, { size }) as Hex;

package/src/utils/promise/p-limit.ts

@@ -1,105 +1,105 @@
 // source code of yocto-queue + modified to add types
 // https://github.com/sindresorhus/yocto-queue
 class Node<T> {
-	value: T;
-	next: Node<T> | undefined;
+  value: T;
+  next: Node<T> | undefined;
 
-	constructor(value: T) {
-		this.value = value;
-	}
+  constructor(value: T) {
+    this.value = value;
+  }
 }
 
 class Queue<T> {
-	private head: Node<T> | undefined;
-	private tail: Node<T> | undefined;
-	size: number;
-
-	constructor() {
-		this.clear();
-		this.size = 0;
-	}
-
-	enqueue(value: T) {
-		const node = new Node(value);
-
-		if (this.head) {
-			if (this.tail) {
-				this.tail.next = node;
-			}
-			this.tail = node;
-		} else {
-			this.head = node;
-			this.tail = node;
-		}
-
-		this.size++;
-	}
-
-	dequeue() {
-		const current = this.head;
-		if (!current) {
-			return;
-		}
-
-		this.head = this.head?.next;
-		this.size--;
-		return current.value;
-	}
-
-	clear() {
-		this.head = undefined;
-		this.tail = undefined;
-		this.size = 0;
-	}
-
-	*[Symbol.iterator]() {
-		let current = this.head;
-
-		while (current) {
-			yield current.value;
-			current = current.next;
-		}
-	}
+  private head: Node<T> | undefined;
+  private tail: Node<T> | undefined;
+  size: number;
+
+  constructor() {
+    this.clear();
+    this.size = 0;
+  }
+
+  enqueue(value: T) {
+    const node = new Node(value);
+
+    if (this.head) {
+      if (this.tail) {
+        this.tail.next = node;
+      }
+      this.tail = node;
+    } else {
+      this.head = node;
+      this.tail = node;
+    }
+
+    this.size++;
+  }
+
+  dequeue() {
+    const current = this.head;
+    if (!current) {
+      return;
+    }
+
+    this.head = this.head?.next;
+    this.size--;
+    return current.value;
+  }
+
+  clear() {
+    this.head = undefined;
+    this.tail = undefined;
+    this.size = 0;
+  }
+
+  *[Symbol.iterator]() {
+    let current = this.head;
+
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
 }
 
 // source code of p-limit - https://github.com/sindresorhus/p-limit/ + modified to add types
 const AsyncResource = {
-	bind(fn: () => void, _type?: any, thisArg?: any) {
-		return fn.bind(thisArg);
-	},
+  bind(fn: () => void, _type?: any, thisArg?: any) {
+    return fn.bind(thisArg);
+  },
 };
 
 type LimitFunctionCallSignature = {
-	/**
-	 * @param fn - Promise-returning/async function.
-	 * @param arguments - Any arguments to pass through to `fn`. Support for passing arguments on to the `fn` is provided in order to be able to avoid creating unnecessary closures. You probably don't need this optimization unless you're pushing a lot of functions.
-	 * @returns The promise returned by calling `fn(...arguments)`.
-	 */
-	<Arguments extends unknown[], ReturnType>(
-		fn: (...arguments_: Arguments) => PromiseLike<ReturnType> | ReturnType,
-		...arguments_: Arguments
-	): Promise<ReturnType>;
+  /**
+   * @param fn - Promise-returning/async function.
+   * @param arguments - Any arguments to pass through to `fn`. Support for passing arguments on to the `fn` is provided in order to be able to avoid creating unnecessary closures. You probably don't need this optimization unless you're pushing a lot of functions.
+   * @returns The promise returned by calling `fn(...arguments)`.
+   */
+  <Arguments extends unknown[], ReturnType>(
+    fn: (...arguments_: Arguments) => PromiseLike<ReturnType> | ReturnType,
+    ...arguments_: Arguments
+  ): Promise<ReturnType>;
 };
 
 export type LimitFunction = {
-	/**
-	 * The number of promises that are currently running.
-	 */
-	readonly activeCount: number;
-
-	/**
-	 * The number of promises that are waiting to run (i.e. their internal `fn` was not called yet).
-	 */
-	readonly pendingCount: number;
-
-	/**
-	 * Discard pending promises that are waiting to run.
-	 *
-	 * This might be useful if you want to teardown the queue at the end of your program's lifecycle or discard any function calls referencing an intermediary state of your app.
-	 *
-	 * Note: This does not cancel promises that are already running.
-	 */
-	clearQueue: () => void;
+  /**
+   * The number of promises that are currently running.
+   */
+  readonly activeCount: number;
+
+  /**
+   * The number of promises that are waiting to run (i.e. their internal `fn` was not called yet).
+   */
+  readonly pendingCount: number;
+
+  /**
+   * Discard pending promises that are waiting to run.
+   *
+   * This might be useful if you want to teardown the queue at the end of your program's lifecycle or discard any function calls referencing an intermediary state of your app.
+   *
+   * Note: This does not cancel promises that are already running.
+   */
+  clearQueue: () => void;
 } & LimitFunctionCallSignature;
 
 type Fn = () => void;
@@ -110,84 +110,84 @@ type Fn = () => void;
  * @internal
  */
 export function pLimit(concurrency: number): LimitFunction {
-	if (
-		!(
-			(Number.isInteger(concurrency) ||
-				concurrency === Number.POSITIVE_INFINITY) &&
-			concurrency > 0
-		)
-	) {
-		throw new TypeError("Expected `concurrency` to be a number from 1 and up");
-	}
-
-	const queue = new Queue<Fn>();
-	let activeCount = 0;
-
-	const next = () => {
-		activeCount--;
-
-		if (queue.size > 0) {
-			const fn = queue.dequeue();
-			if (fn) {
-				fn();
-			}
-		}
-	};
-
-	const run = async (function_: Fn, resolve: any, arguments_: any[]) => {
-		activeCount++;
-
-		// @ts-ignore
-		const result = (async () => function_(...arguments_))();
-
-		resolve(result);
-
-		try {
-			await result;
-		} catch {}
-
-		next();
-	};
-
-	const enqueue = (function_: Fn, resolve: any, arguments_: any[]) => {
-		queue.enqueue(
-			AsyncResource.bind(run.bind(undefined, function_, resolve, arguments_)),
-		);
-
-		(async () => {
-			// This function needs to wait until the next microtask before comparing
-			// `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
-			// when the run function is dequeued and called. The comparison in the if-statement
-			// needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
-			await Promise.resolve();
-
-			if (activeCount < concurrency && queue.size > 0) {
-				const fn = queue.dequeue();
-				if (fn) {
-					fn();
-				}
-			}
-		})();
-	};
-
-	const generator: LimitFunctionCallSignature = (function_, ...arguments_) =>
-		new Promise((resolve) => {
-			enqueue(function_, resolve, arguments_);
-		});
-
-	Object.defineProperties(generator, {
-		activeCount: {
-			get: () => activeCount,
-		},
-		pendingCount: {
-			get: () => queue.size,
-		},
-		clearQueue: {
-			value() {
-				queue.clear();
-			},
-		},
-	});
-
-	return generator as LimitFunction;
+  if (
+    !(
+      (Number.isInteger(concurrency) ||
+        concurrency === Number.POSITIVE_INFINITY) &&
+      concurrency > 0
+    )
+  ) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+
+  const queue = new Queue<Fn>();
+  let activeCount = 0;
+
+  const next = () => {
+    activeCount--;
+
+    if (queue.size > 0) {
+      const fn = queue.dequeue();
+      if (fn) {
+        fn();
+      }
+    }
+  };
+
+  const run = async (function_: Fn, resolve: any, arguments_: any[]) => {
+    activeCount++;
+
+    // @ts-ignore
+    const result = (async () => function_(...arguments_))();
+
+    resolve(result);
+
+    try {
+      await result;
+    } catch {}
+
+    next();
+  };
+
+  const enqueue = (function_: Fn, resolve: any, arguments_: any[]) => {
+    queue.enqueue(
+      AsyncResource.bind(run.bind(undefined, function_, resolve, arguments_)),
+    );
+
+    (async () => {
+      // This function needs to wait until the next microtask before comparing
+      // `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
+      // when the run function is dequeued and called. The comparison in the if-statement
+      // needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
+      await Promise.resolve();
+
+      if (activeCount < concurrency && queue.size > 0) {
+        const fn = queue.dequeue();
+        if (fn) {
+          fn();
+        }
+      }
+    })();
+  };
+
+  const generator: LimitFunctionCallSignature = (function_, ...arguments_) =>
+    new Promise((resolve) => {
+      enqueue(function_, resolve, arguments_);
+    });
+
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount,
+    },
+    pendingCount: {
+      get: () => queue.size,
+    },
+    clearQueue: {
+      value() {
+        queue.clear();
+      },
+    },
+  });
+
+  return generator as LimitFunction;
 }

package/src/utils/signatures/sign-message.ts

@@ -62,10 +62,10 @@ export function signMessage(
     const { message, privateKey } = options;
     const signature = sign({ hash: hashMessage(message), privateKey });
     return signatureToHex(signature);
-  } else if ("account" in options) {
+  }
+  if ("account" in options) {
     const { message, account } = options;
     return account.signMessage({ message });
-  } else {
-    throw new Error("Either privateKey or account is required");
   }
+  throw new Error("Either privateKey or account is required");
 }

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.56.0-nightly-a5e605c65e360a9d3d2e553d6783e58582b50a70-20240917000331";
+export const version = "5.57.0-nightly-cf1683c3feea6eb36ac6b902a1dd64c8ed8803c9-20240918000340";

package/src/wallets/in-app/core/authentication/guest.ts

@@ -0,0 +1,37 @@
+import type { ThirdwebClient } from "../../../../client/client.js";
+import { getClientFetch } from "../../../../utils/fetch.js";
+import type { Ecosystem } from "../../web/types.js";
+import { getLoginCallbackUrl } from "./getLoginPath.js";
+import type { AuthStoredTokenWithCookieReturnType } from "./types.js";
+
+/**
+ * Does no real authentication, just issues a temporary token for the user.
+ * @internal
+ */
+export async function guestAuthenticate(args: {
+  client: ThirdwebClient;
+  ecosystem?: Ecosystem;
+}): Promise<AuthStoredTokenWithCookieReturnType> {
+  const clientFetch = getClientFetch(args.client, args.ecosystem);
+  const authResult = await (async () => {
+    const path = getLoginCallbackUrl({
+      authOption: "guest",
+      client: args.client,
+      ecosystem: args.ecosystem,
+    });
+    const res = await clientFetch(`${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        sessionId: "guest",
+      }),
+    });
+
+    if (!res.ok) throw new Error("Failed to generate guest account");
+
+    return (await res.json()) satisfies AuthStoredTokenWithCookieReturnType;
+  })();
+  return authResult;
+}

package/src/wallets/in-app/core/authentication/types.ts

@@ -3,7 +3,7 @@ import type { ThirdwebClient } from "../../../../client/client.js";
 import type { Address } from "../../../../utils/address.js";
 import type { Account } from "../../../interfaces/wallet.js";
 import type { Wallet } from "../../../interfaces/wallet.js";
-import type { AuthOption, SocialAuthOption } from "../../../types.js";
+import type { AuthOption, OAuthOption } from "../../../types.js";
 import type { Ecosystem } from "../../web/types.js";
 
 export type MultiStepAuthProviderType =
@@ -26,7 +26,7 @@ export type MultiStepAuthArgsType = MultiStepAuthProviderType & {
 
 export type SingleStepAuthArgsType =
   | {
-      strategy: SocialAuthOption;
+      strategy: OAuthOption;
       openedWindow?: Window;
       closeOpenedWindow?: (window: Window) => void;
       redirectUrl?: string;
@@ -52,6 +52,10 @@ export type SingleStepAuthArgsType =
       strategy: "wallet";
       wallet: Wallet;
       chain: Chain;
+    }
+  | {
+      strategy: "guest";
+      client: ThirdwebClient;
     };
 
 export type AuthArgsType = (MultiStepAuthArgsType | SingleStepAuthArgsType) & {
@@ -68,6 +72,7 @@ export enum RecoveryShareManagement {
 // TODO: remove usage of enums, instead use object with as const
 export enum AuthProvider {
   COGNITO = "Cognito",
+  GUEST = "Guest",
   GOOGLE = "Google",
   EMAIL_OTP = "EmailOtp",
   CUSTOM_JWT = "CustomJWT",
@@ -82,8 +87,8 @@ export enum AuthProvider {
   TELEGRAM = "Telegram",
 }
 
-export type OauthOption = {
-  strategy: SocialAuthOption;
+export type OAuthRedirectObject = {
+  strategy: OAuthOption;
   redirectUrl: string;
 };
 

package/src/wallets/in-app/core/wallet/types.ts

@@ -1,7 +1,11 @@
 import type { Chain } from "../../../../chains/types.js";
 import type { ThirdwebClient } from "../../../../client/client.js";
 import type { SmartWalletOptions } from "../../../smart/types.js";
-import type { AuthOption, SocialAuthOption } from "../../../types.js";
+import type {
+  AuthOption,
+  OAuthOption,
+  SocialAuthOption,
+} from "../../../types.js";
 import type {
   AuthStoredTokenWithCookieReturnType,
   MultiStepAuthArgsType,
@@ -24,6 +28,7 @@ export type InAppWalletAutoConnectOptions = {
 };
 
 export type InAppWalletSocialAuth = SocialAuthOption;
+export type InAppWalletOAuth = OAuthOption;
 export type InAppWalletAuth = AuthOption;
 
 export type InAppWalletCreationOptions =

package/src/wallets/in-app/native/auth/native-auth.ts

@@ -3,11 +3,12 @@ import type { Chain } from "../../../../chains/types.js";
 import type { ThirdwebClient } from "../../../../client/client.js";
 import type { Wallet } from "../../../interfaces/wallet.js";
 import { getLoginUrl } from "../../core/authentication/getLoginPath.js";
+import { guestAuthenticate } from "../../core/authentication/guest.js";
 import { siweAuthenticate } from "../../core/authentication/siwe.js";
 import type {
   AuthStoredTokenWithCookieReturnType,
   MultiStepAuthArgsType,
-  OauthOption,
+  OAuthRedirectObject,
 } from "../../core/authentication/types.js";
 import { verifyOtp } from "../../web/lib/auth/otp.js";
 import type { Ecosystem } from "../../web/types.js";
@@ -53,7 +54,7 @@ export async function otpLogin(
 }
 
 export async function authenticate(
-  auth: OauthOption,
+  auth: OAuthRedirectObject,
   client: ThirdwebClient,
 ): Promise<AuthStoredTokenWithCookieReturnType> {
   const loginUrl = getLoginUrl({
@@ -98,7 +99,7 @@ export async function authenticate(
 }
 
 export async function socialLogin(
-  auth: OauthOption,
+  auth: OAuthRedirectObject,
   client: ThirdwebClient,
 ): Promise<AuthStoredTokenWithCookieReturnType> {
   const { storedToken } = await authenticate(auth, client);
@@ -158,6 +159,36 @@ export async function siweLogin(
   }
 }
 
+export async function guestLogin(
+  client: ThirdwebClient,
+  ecosystem?: Ecosystem,
+): Promise<AuthStoredTokenWithCookieReturnType> {
+  const { storedToken } = await guestAuthenticate({
+    client,
+    ecosystem,
+  });
+  try {
+    const toStoreToken: AuthStoredTokenWithCookieReturnType["storedToken"] = {
+      jwtToken: storedToken.jwtToken,
+      authDetails: storedToken.authDetails,
+      authProvider: storedToken.authProvider,
+      developerClientId: storedToken.developerClientId,
+      cookieString: storedToken.cookieString,
+      // we should always store the jwt cookie since there's no concept of cookie in react native
+      shouldStoreCookieString: true,
+      isNewUser: storedToken.isNewUser,
+    };
+
+    await postAuth({ storedToken: toStoreToken, client });
+
+    return { storedToken };
+  } catch (e) {
+    throw new Error(
+      createErrorMessage("Malformed response from post authentication", e),
+    );
+  }
+}
+
 export async function customJwt(
   authOptions: { jwt: string; password: string },
   client: ThirdwebClient,

package/src/wallets/in-app/native/helpers/api/fetchers.ts

@@ -91,9 +91,8 @@ export const authFetchEmbeddedWalletUser = async (
         params,
         retries - 1,
       );
-    } else {
-      throw e;
     }
+    throw e;
   }
 };
 

package/src/wallets/in-app/native/helpers/wallet/sss.ts

@@ -206,12 +206,7 @@ function getRNG(type) {
     size = 32;
     elems = Math.ceil(bits / 32);
     while (str === null) {
-      str = construct(
-        bits,
-        randomBytesBuffer(elems),
-        radix,
-        size,
-      );
+      str = construct(bits, randomBytesBuffer(elems), radix, size);
     }
 
     return str;