thirdweb 5.44.1 → 5.45.0-nightly-bbb4f1c53f982b1f9de00fb30efbf2c77f155e96-20240809000532

package/src/transaction/serialize-transaction.ts

@@ -1,36 +1,23 @@
 import {
-  type ExactPartial,
+  type GetTransactionType,
   type SerializedTransactionReturnType,
   type Signature,
   type TransactionSerializable,
-  type TransactionSerializableEIP1559,
-  type TransactionSerializableEIP2930,
-  type TransactionSerializableEIP4844,
-  type TransactionSerializableLegacy,
-  type TransactionSerializedEIP1559,
-  type TransactionSerializedEIP2930,
-  type TransactionSerializedLegacy,
+  type TransactionType,
   serializeTransaction as _serializeTransaction,
-  assertTransactionEIP1559,
-  assertTransactionEIP2930,
-  assertTransactionLegacy,
-  serializeAccessList,
-  toRlp,
 } from "viem";
-import { trim } from "../utils/encoding/helpers/trim.js";
-import { type Hex, toHex } from "../utils/encoding/hex.js";
 
-export type SerializeTransactionOptions<
-  _transaction extends TransactionSerializable,
-> = {
-  transaction: _transaction;
+export type SerializeTransactionOptions = {
+  transaction: TransactionSerializable;
+  signature?: Signature | undefined;
 };
 
 /**
- * Serializes a legacy, EIP-1559, EIP-2930, or EIP-4844 transaction object.
+ * Serializes a legacy, EIP-1559, EIP-2930, EIP-4844, or EIP-7702 transaction object.
  *
  * @param options - The serialization options.
- * @param options.transaction - The transaction object to be serialized, including the signature parameters if necessary.
+ * @param options.transaction - The transaction object to be serialized.
+ * @param [options.signature] - The signature to include with the transaction, if necessary.
  * @returns The serialized transaction.
  * @throws An error if the provided transaction object is invalid.
  * @transaction
@@ -46,245 +33,31 @@ export type SerializeTransactionOptions<
  * ```
  */
 export function serializeTransaction<
-  _transaction extends TransactionSerializable,
+  const transaction extends TransactionSerializable,
+  _transactionType extends TransactionType = GetTransactionType<transaction>,
 >(
-  options: SerializeTransactionOptions<_transaction>,
-): SerializedTransactionReturnType<_transaction> {
+  options: SerializeTransactionOptions,
+): SerializedTransactionReturnType<transaction, _transactionType> {
   const { transaction } = options;
 
-  if (
-    transaction.type === "eip4844" || // explicit type checks required for viem parity
-    typeof transaction.blobs !== "undefined" ||
-    typeof transaction.blobVersionedHashes !== "undefined" ||
-    typeof transaction.maxFeePerBlobGas !== "undefined" ||
-    typeof transaction.sidecars !== "undefined"
-  ) {
-    // default to viem's 4844 serialization until we have blob utilities
-    return _serializeTransaction<TransactionSerializableEIP4844>(
-      transaction,
-    ) as SerializedTransactionReturnType<_transaction>;
-  }
-
-  if (
-    transaction.type === "eip1559" ||
-    typeof transaction.maxFeePerGas !== "undefined" ||
-    typeof transaction.maxPriorityFeePerGas !== "undefined"
-  ) {
-    return serializeEIP1559Transaction({
-      transaction,
-    }) as SerializedTransactionReturnType<_transaction>;
-  }
-
-  if (
-    transaction.type === "eip2930" ||
-    (typeof transaction.gasPrice !== "undefined" &&
-      typeof transaction.accessList !== "undefined")
-  ) {
-    return serializeEIP2930Transaction({
-      transaction,
-    }) as SerializedTransactionReturnType<_transaction>;
-  }
-
-  if (
-    transaction.type === "legacy" ||
-    typeof transaction.gasPrice !== "undefined"
-  ) {
-    return serializeTransactionLegacy({
-      transaction: transaction as TransactionSerializableLegacy,
-    }) as SerializedTransactionReturnType<_transaction>;
-  }
-
-  throw new Error(
-    `Invalid transaction to serialize.\n\n${JSON.stringify(
-      transaction,
-      (_, v) => (typeof v === "bigint" ? `${v.toString()}n` : v),
-      2,
-    )}`,
-  );
-}
-
-type SerializeEIP1559TransactionOptions = {
-  transaction: TransactionSerializableEIP1559;
-};
-
-function serializeEIP1559Transaction(
-  options: SerializeEIP1559TransactionOptions,
-): TransactionSerializedEIP1559 {
-  assertTransactionEIP1559(options.transaction);
-
-  const {
-    transaction: {
-      chainId,
-      gas,
-      nonce,
-      to,
-      value,
-      maxFeePerGas,
-      maxPriorityFeePerGas,
-      accessList,
-      data,
-      r,
-      s,
-      v,
-      yParity,
-    },
-  } = options;
-
-  const serializedAccessList = serializeAccessList(accessList);
-
-  const serializedTransaction = [
-    toHex(chainId),
-    nonce ? toHex(nonce) : "0x",
-    maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
-    maxFeePerGas ? toHex(maxFeePerGas) : "0x",
-    gas ? toHex(gas) : "0x",
-    // To fix when migrating to our own version of TransactionSerializable (the viem type is downgraded from Address to string when importing)
-    (to ?? "0x") as Hex,
-    value ? toHex(value) : "0x",
-    data ?? "0x",
-    serializedAccessList,
-    ...toYParitySignatureArray({ r, s, v, yParity }),
-  ];
-
-  return `0x02${toRlp(serializedTransaction).slice(2)}`;
-}
-
-type SerializeEIP2930TransactionOptions = {
-  transaction: TransactionSerializableEIP2930;
-};
-
-function serializeEIP2930Transaction(
-  options: SerializeEIP2930TransactionOptions,
-): TransactionSerializedEIP2930 {
-  assertTransactionEIP2930(options.transaction);
-
-  const {
-    transaction: {
-      chainId,
-      gas,
-      gasPrice,
-      nonce,
-      to,
-      value,
-      accessList,
-      data,
-      r,
-      s,
-      v,
-      yParity,
-    },
-  } = options;
-
-  const serializedAccessList = serializeAccessList(accessList);
-
-  const serializedTransaction = [
-    toHex(chainId),
-    nonce ? toHex(nonce) : "0x",
-    gasPrice ? toHex(gasPrice) : "0x",
-    gas ? toHex(gas) : "0x",
-    (to ?? "0x") as Hex,
-    value ? toHex(value) : "0x",
-    data ?? "0x",
-    serializedAccessList,
-    ...toYParitySignatureArray({ r, s, v, yParity }),
-  ];
-
-  return `0x01${toRlp(serializedTransaction).slice(2)}`;
-}
-
-type SerializeLegacyTransactionOptions = {
-  transaction: TransactionSerializableLegacy;
-};
-
-function serializeTransactionLegacy(
-  options: SerializeLegacyTransactionOptions,
-): TransactionSerializedLegacy {
-  assertTransactionLegacy(options.transaction);
-
-  const {
-    chainId = 0,
-    gas,
-    data,
-    nonce,
-    to,
-    value,
-    gasPrice,
-    r,
-    s,
-    v,
-  } = options.transaction;
-
-  let serializedTransaction = [
-    nonce ? toHex(nonce) : "0x",
-    gasPrice ? toHex(gasPrice) : "0x",
-    gas ? toHex(gas) : "0x",
-    (to ?? "0x") as Hex,
-    value ? toHex(value) : "0x",
-    data ?? "0x",
-  ];
-
-  if (typeof v !== "undefined") {
-    const v_ = (() => {
-      // EIP-155 (inferred chainId)
-      if (v >= 35n) {
-        const inferredChainId = (v - 35n) / 2n;
-        if (inferredChainId > 0) return v;
-        return 27n + (v === 35n ? 0n : 1n);
-      }
-
-      // EIP-155 (explicit chainId)
-      if (chainId > 0) return BigInt(chainId * 2) + BigInt(35n + v - 27n);
-
-      // Pre-EIP-155 (no chainId)
-      const v_ = 27n + (v === 27n ? 0n : 1n);
-      if (v !== v_) throw new Error(`Invalid legacy signature value v: ${v}`);
-      return v_;
-    })();
-
-    if (typeof r === "undefined")
-      throw new Error(`Invalid legacy signature value r: ${r}`);
-    if (typeof s === "undefined")
-      throw new Error(`Invalid legacy signature value s: ${s}`);
-
-    serializedTransaction = [
-      ...serializedTransaction,
-      toHex(v_),
-      r === "0x00" ? "0x" : r,
-      s === "0x00" ? "0x" : s,
-    ];
-  } else if (chainId > 0) {
-    serializedTransaction = [
-      ...serializedTransaction,
-      toHex(chainId),
-      "0x",
-      "0x",
-    ];
-  }
-
-  return toRlp(serializedTransaction) as TransactionSerializedLegacy;
-}
-
-export function toYParitySignatureArray(
-  signature: ExactPartial<Signature>,
-): Hex[] {
-  const { v, yParity } = signature;
-
-  if (typeof signature.r === "undefined") return [];
-  if (typeof signature.s === "undefined") return [];
-
-  if (typeof v === "undefined" && typeof yParity === "undefined") return [];
-
-  const r = trim(signature.r);
-  const s = trim(signature.s);
-
-  const yParity_ = (() => {
-    if (yParity === 1 || yParity === 0) return yParity ? toHex(1) : "0x";
-    if (typeof yParity !== "undefined")
-      throw new Error(`Invalid signature value for yParity: ${yParity}`);
-
-    if (v === 0n || v === 27n) return "0x";
-    if (v === 1n || v === 28n) return toHex(1);
-    throw new Error(`Invalid signature value v: ${v}`);
+  // This is to maintain compatibility with our old interface (including the signature in the transaction object)
+  const signature = (() => {
+    if (options.signature) return options.signature;
+    if (transaction.v === undefined && transaction.yParity === undefined) {
+      return undefined;
+    }
+
+    if (transaction.r === undefined || transaction.s === undefined) {
+      throw new Error("Invalid signature provided with transaction");
+    }
+
+    return {
+      v: transaction.v,
+      r: transaction.r,
+      s: transaction.s,
+      yParity: transaction.yParity,
+    };
   })();
-  return [yParity_, r === "0x00" ? "0x" : r, s === "0x00" ? "0x" : s];
+
+  return _serializeTransaction(transaction, signature as Signature | undefined); // Trust the options type-checking did its job and that the converted signature mirrors that type
 }

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.44.1";
+export const version = "5.45.0-nightly-bbb4f1c53f982b1f9de00fb30efbf2c77f155e96-20240809000532";

package/src/wallets/coinbase/coinbase-wallet.ts

@@ -5,6 +5,7 @@
 import type { ProviderInterface } from "@coinbase/wallet-sdk";
 import { trackConnect } from "../../analytics/track.js";
 import type { Chain } from "../../chains/types.js";
+import { getCachedChainIfExists } from "../../chains/utils.js";
 import { COINBASE } from "../constants.js";
 import type { Account, Wallet } from "../interfaces/wallet.js";
 import { createWalletEmitter } from "../wallet-emitter.js";
@@ -54,7 +55,14 @@ export function coinbaseWalletSDK(args: {
   return {
     id: COINBASE,
     subscribe: emitter.subscribe,
-    getChain: () => chain,
+    getChain() {
+      if (!chain) {
+        return undefined;
+      }
+
+      chain = getCachedChainIfExists(chain.id) || chain;
+      return chain;
+    },
     getConfig: () => createOptions,
     getAccount: () => account,
     autoConnect: async (options) => {

package/src/wallets/create-wallet.ts

@@ -13,6 +13,7 @@ import type {
 } from "./wallet-types.js";
 
 import { trackConnect } from "../analytics/track.js";
+import { getCachedChainIfExists } from "../chains/utils.js";
 import { webLocalStorage } from "../utils/storage/webStorage.js";
 import { isMobile } from "../utils/web/isMobile.js";
 import { openWindow } from "../utils/web/openWindow.js";
@@ -206,7 +207,14 @@ export function createWallet<const ID extends WalletId>(
         id,
         subscribe: emitter.subscribe,
         getConfig: () => args[1],
-        getChain: () => chain,
+        getChain() {
+          if (!chain) {
+            return undefined;
+          }
+
+          chain = getCachedChainIfExists(chain.id) || chain;
+          return chain;
+        },
         getAccount: () => account,
         autoConnect: async (
           options: WalletAutoConnectionOption<

package/src/wallets/ecosystem/types.ts

@@ -1,9 +1,7 @@
-import type { Prettify } from "../../utils/type-utils.js";
 import type {
   InAppWalletAutoConnectOptions,
   InAppWalletConnectionOptions,
 } from "../in-app/core/wallet/types.js";
-import type { Ecosystem } from "../in-app/web/types.js";
 
 export type EcosystemWalletCreationOptions = {
   partnerId?: string;
@@ -12,11 +10,5 @@ export type EcosystemWalletCreationOptions = {
   };
 };
 
-export type EcosystemWalletConnectionOptions = Prettify<
-  InAppWalletConnectionOptions & {
-    ecosystem: Ecosystem;
-  }
->;
-export type EcosystemWalletAutoConnectOptions = Prettify<
-  InAppWalletAutoConnectOptions & { ecosystem: Ecosystem }
->;
+export type EcosystemWalletConnectionOptions = InAppWalletConnectionOptions;
+export type EcosystemWalletAutoConnectOptions = InAppWalletAutoConnectOptions;

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

@@ -1,16 +1,16 @@
 import type { ThirdwebClient } from "../../../../client/client.js";
 import { getThirdwebBaseUrl } from "../../../../utils/domains.js";
-import type { SocialAuthOption } from "../../../../wallets/types.js";
+import type { AuthOption } from "../../../../wallets/types.js";
 import type { Ecosystem } from "../../web/types.js";
 
-export const getSocialAuthLoginPath = ({
+export const getLoginUrl = ({
   authOption,
   client,
   ecosystem,
   mode = "popup",
   redirectUrl,
 }: {
-  authOption: SocialAuthOption;
+  authOption: AuthOption;
   client: ThirdwebClient;
   ecosystem?: Ecosystem;
   mode?: "popup" | "redirect" | "mobile";
@@ -39,3 +39,22 @@ export const getSocialAuthLoginPath = ({
 
   return baseUrl;
 };
+
+export const getLoginCallbackUrl = ({
+  authOption,
+  client,
+  ecosystem,
+}: {
+  authOption: AuthOption;
+  client: ThirdwebClient;
+  ecosystem?: Ecosystem;
+}): string => {
+  let baseUrl = `${getThirdwebBaseUrl("inAppWallet")}/api/2024-05-05/login/${authOption}/callback?clientId=${client.clientId}`;
+  if (ecosystem?.partnerId) {
+    baseUrl = `${baseUrl}&ecosystemId=${ecosystem.id}&ecosystemPartnerId=${ecosystem.partnerId}`;
+  } else if (ecosystem) {
+    baseUrl = `${baseUrl}&ecosystemId=${ecosystem.id}`;
+  }
+
+  return baseUrl;
+};

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

@@ -0,0 +1,96 @@
+import type { ThirdwebClient } from "../../../../client/client.js";
+import { getThirdwebBaseUrl } from "../../../../utils/domains.js";
+import type { Profile } from "./types.js";
+
+/**
+ * @description
+ * Links a new account to the current one using an auth token.
+ * For the public-facing API, use `wallet.linkProfile` instead.
+ *
+ * @internal
+ */
+export async function linkAccount({
+  client,
+  tokenToLink,
+}: {
+  client: ThirdwebClient;
+  tokenToLink: string;
+}): Promise<Profile[]> {
+  const IN_APP_URL = getThirdwebBaseUrl("inAppWallet");
+  const currentAccountToken = localStorage.getItem(
+    `walletToken-${client.clientId}`,
+  );
+
+  if (!currentAccountToken) {
+    throw new Error("Failed to link account, no user logged in");
+  }
+
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer iaw-auth-token:${currentAccountToken}`,
+    "x-thirdweb-client-id": client.clientId,
+  };
+
+  const linkedDetailsResp = await fetch(
+    `${IN_APP_URL}/api/2024-05-05/account/connect`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        accountAuthTokenToConnect: tokenToLink,
+      }),
+    },
+  );
+
+  if (!linkedDetailsResp.ok) {
+    const body = await linkedDetailsResp.json();
+    throw new Error(body.message || "Failed to link account.");
+  }
+
+  const { linkedAccounts } = await linkedDetailsResp.json();
+
+  return (linkedAccounts ?? []) satisfies Profile[];
+}
+
+/**
+ * @description
+ * Gets the linked accounts for the current user.
+ * For the public-facing API, use `wallet.getProfiles` instead.
+ *
+ * @internal
+ */
+export async function getLinkedProfilesInternal({
+  client,
+}: { client: ThirdwebClient }): Promise<Profile[]> {
+  const IN_APP_URL = getThirdwebBaseUrl("inAppWallet");
+  const currentAccountToken = localStorage.getItem(
+    `walletToken-${client.clientId}`,
+  );
+
+  if (!currentAccountToken) {
+    throw new Error("Failed to get linked accounts, no user logged in");
+  }
+
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer iaw-auth-token:${currentAccountToken}`,
+    "x-thirdweb-client-id": client.clientId,
+  };
+
+  const linkedAccountsResp = await fetch(
+    `${IN_APP_URL}/api/2024-05-05/accounts`,
+    {
+      method: "GET",
+      headers,
+    },
+  );
+
+  if (!linkedAccountsResp.ok) {
+    const body = await linkedAccountsResp.json();
+    throw new Error(body.message || "Failed to get linked accounts.");
+  }
+
+  const { linkedAccounts } = await linkedAccountsResp.json();
+
+  return (linkedAccounts ?? []) satisfies Profile[];
+}

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

@@ -0,0 +1,63 @@
+import { signLoginPayload } from "../../../../auth/core/sign-login-payload.js";
+import type { LoginPayload } from "../../../../auth/core/types.js";
+import type { ThirdwebClient } from "../../../../client/client.js";
+import { getClientFetch } from "../../../../utils/fetch.js";
+import type { InjectedSupportedWalletIds } from "../../../../wallets/__generated__/wallet-ids.js";
+import { createWallet } from "../../../../wallets/create-wallet.js";
+import type { Ecosystem } from "../../web/types.js";
+import { getLoginCallbackUrl, getLoginUrl } from "./getLoginPath.js";
+import type { AuthStoredTokenWithCookieReturnType } from "./types.js";
+
+/**
+ * @internal
+ */
+export async function siweAuthenticate(args: {
+  walletId: InjectedSupportedWalletIds;
+  chainId: number;
+  client: ThirdwebClient;
+  ecosystem?: Ecosystem;
+}): Promise<AuthStoredTokenWithCookieReturnType> {
+  const wallet = createWallet(args.walletId);
+  const account = await wallet.connect({ client: args.client });
+  const clientFetch = getClientFetch(args.client, args.ecosystem);
+
+  const payload = await (async () => {
+    const path = getLoginUrl({
+      authOption: "siwe",
+      client: args.client,
+    });
+    const res = await clientFetch(
+      `${path}&address=${account.address}&chainId=${args.chainId}`,
+    );
+
+    if (!res.ok) throw new Error("Failed to generate SIWE login payload");
+
+    return (await res.json()) satisfies LoginPayload;
+  })();
+  const { signature } = await signLoginPayload({ payload, account });
+
+  const authResult = await (async () => {
+    const path = getLoginCallbackUrl({
+      authOption: "siwe",
+      client: args.client,
+    });
+    const res = await clientFetch(
+      `${path}&signature=${signature}&payload=${encodeURIComponent(payload)}`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          signature,
+          payload,
+        }),
+      },
+    );
+
+    if (!res.ok) throw new Error("Failed to verify SIWE signature");
+
+    return (await res.json()) satisfies AuthStoredTokenWithCookieReturnType;
+  })();
+  return authResult;
+}

package/src/wallets/in-app/core/authentication/{type.ts → types.ts}

@@ -1,7 +1,9 @@
 import type { AuthType } from "@passwordless-id/webauthn/dist/esm/types.js";
 import type { ThirdwebClient } from "../../../../client/client.js";
+import type { Address } from "../../../../utils/address.js";
+import type { InjectedSupportedWalletIds } from "../../../../wallets/__generated__/wallet-ids.js";
 import type { Account } from "../../../interfaces/wallet.js";
-import type { SocialAuthOption } from "../../../types.js";
+import type { AuthOption, SocialAuthOption } from "../../../types.js";
 import type { Ecosystem } from "../../web/types.js";
 
 export type MultiStepAuthProviderType =
@@ -38,6 +40,11 @@ export type SingleStepAuthArgsType =
       type: "sign-up" | "sign-in";
       passkeyName?: string;
       authenticatorType?: AuthType;
+    }
+  | {
+      strategy: "siwe";
+      walletId: InjectedSupportedWalletIds;
+      chainId: number;
     };
 
 export type AuthArgsType = (MultiStepAuthArgsType | SingleStepAuthArgsType) & {
@@ -71,6 +78,16 @@ export type OauthOption = {
   redirectUrl: string;
 };
 
+export type Profile = {
+  type: AuthOption;
+  details: {
+    id?: string;
+    email?: string;
+    phone?: string;
+    address?: Address;
+  };
+};
+
 /**
  * @internal
  */

package/src/wallets/in-app/core/interfaces/connector.ts

@@ -1,23 +1,32 @@
 import type { SocialAuthOption } from "../../../../wallets/types.js";
 import type { Account } from "../../../interfaces/wallet.js";
 import type {
-  AuthArgsType,
   AuthLoginReturnType,
   AuthStoredTokenWithCookieReturnType,
   GetUser,
   LogoutReturnType,
+  MultiStepAuthArgsType,
   PreAuthArgsType,
-  SendEmailOtpReturnType,
-} from "../authentication/type.js";
+  SingleStepAuthArgsType,
+} from "../authentication/types.js";
 
 export interface InAppConnector {
   getUser(): Promise<GetUser>;
   getAccount(): Promise<Account>;
-  preAuthenticate(args: PreAuthArgsType): Promise<SendEmailOtpReturnType>;
+  preAuthenticate(args: PreAuthArgsType): Promise<void>;
+  // Authenticate generates an auth token, when redirecting it returns void as the user is redirected to a new page and the token is stored in the callback url
   authenticateWithRedirect?(strategy: SocialAuthOption): void;
+  // Login takes an auth token and connects a user with it
   loginWithAuthToken?(
     authResult: AuthStoredTokenWithCookieReturnType,
   ): Promise<AuthLoginReturnType>;
-  authenticate(args: AuthArgsType): Promise<AuthLoginReturnType>;
+  // Authenticate generates an auth token but does not log the user in
+  authenticate(
+    args: MultiStepAuthArgsType | SingleStepAuthArgsType,
+  ): Promise<AuthStoredTokenWithCookieReturnType>;
+  // Connect is authenticate + login combined
+  connect(
+    args: MultiStepAuthArgsType | SingleStepAuthArgsType,
+  ): Promise<AuthLoginReturnType>;
   logout(): Promise<LogoutReturnType>;
 }