thirdweb 5.74.0 → 5.75.0

package/src/transaction/serialize-transaction.ts

@@ -1,15 +1,37 @@
-import {
-  type GetTransactionType,
-  type SerializedTransactionReturnType,
-  type Signature,
-  type TransactionSerializable,
-  type TransactionType,
-  serializeTransaction as _serializeTransaction,
-} from "viem";
+import * as ox__Hex from "ox/Hex";
+import * as ox__Signature from "ox/Signature";
+import * as ox__TransactionEnvelopeEip1559 from "ox/TransactionEnvelopeEip1559";
+import * as ox__TransactionEnvelopeEip2930 from "ox/TransactionEnvelopeEip2930";
+import * as ox__TransactionEnvelopeLegacy from "ox/TransactionEnvelopeLegacy";
+import type { Hex } from "../utils/encoding/hex.js";
+
+export type SerializableTransaction = {
+  type?: string | undefined;
+  r?: Hex | bigint;
+  s?: Hex | bigint;
+  v?: bigint | number;
+  yParity?: bigint | number;
+  accessList?:
+    | ox__TransactionEnvelopeEip2930.TransactionEnvelopeEip2930["accessList"]
+    | undefined;
+  chainId?: number | undefined;
+  gasPrice?: bigint | undefined;
+  maxFeePerGas?: bigint | undefined;
+  maxPriorityFeePerGas?: bigint | undefined;
+  data?: Hex | undefined;
+  to?: string | null | undefined; // Must allow null for backwards compatibility
+  nonce?: number | bigint | undefined;
+  value?: bigint | undefined;
+  gas?: bigint | undefined;
+  gasLimit?: bigint | undefined;
+};
 
 export type SerializeTransactionOptions = {
-  transaction: TransactionSerializable;
-  signature?: Signature | undefined;
+  transaction: SerializableTransaction;
+  signature?:
+    | ox__Signature.Signature<true, Hex>
+    | ox__Signature.Legacy<Hex, bigint>
+    | undefined;
 };
 
 /**
@@ -32,18 +54,39 @@ export type SerializeTransactionOptions = {
  * });
  * ```
  */
-export function serializeTransaction<
-  const transaction extends TransactionSerializable,
-  _transactionType extends TransactionType = GetTransactionType<transaction>,
->(
+export function serializeTransaction(
   options: SerializeTransactionOptions,
-): SerializedTransactionReturnType<transaction, _transactionType> {
+): Hex {
   const { transaction } = options;
 
+  const type = getTransactionEnvelopeType(transaction);
+
   // 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) {
+    if (options.signature) {
+      if (
+        "v" in options.signature &&
+        typeof options.signature.v !== "undefined"
+      ) {
+        return ox__Signature.fromLegacy({
+          r: ox__Hex.toBigInt(options.signature.r),
+          s: ox__Hex.toBigInt(options.signature.s),
+          v: Number(options.signature.v),
+        });
+      }
+
+      return {
+        r: ox__Hex.toBigInt(options.signature.r),
+        s: ox__Hex.toBigInt(options.signature.s),
+        // We force the Signature type here because we filter for legacy type above
+        yParity: (options.signature as unknown as ox__Signature.Signature)
+          .yParity,
+      };
+    }
+    if (
+      typeof transaction.v === "undefined" &&
+      typeof transaction.yParity === "undefined"
+    ) {
       return undefined;
     }
 
@@ -52,12 +95,78 @@ export function serializeTransaction<
     }
 
     return {
-      v: transaction.v,
-      r: transaction.r,
-      s: transaction.s,
-      yParity: transaction.yParity,
+      r:
+        typeof transaction.r === "bigint"
+          ? transaction.r
+          : ox__Hex.toBigInt(transaction.r),
+      s:
+        typeof transaction.s === "bigint"
+          ? transaction.s
+          : ox__Hex.toBigInt(transaction.s),
+      yParity:
+        typeof transaction.v !== "undefined" &&
+        typeof transaction.yParity === "undefined"
+          ? ox__Signature.vToYParity(Number(transaction.v))
+          : Number(transaction.yParity),
     };
   })();
 
-  return _serializeTransaction(transaction, signature as Signature | undefined); // Trust the options type-checking did its job and that the converted signature mirrors that type
+  if (type === "eip1559") {
+    const typedTransaction =
+      transaction as ox__TransactionEnvelopeEip1559.TransactionEnvelopeEip1559;
+    ox__TransactionEnvelopeEip1559.assert(typedTransaction);
+
+    return ox__TransactionEnvelopeEip1559.serialize(typedTransaction, {
+      signature,
+    });
+  }
+
+  if (type === "legacy") {
+    const typedTransaction =
+      transaction as ox__TransactionEnvelopeLegacy.TransactionEnvelopeLegacy;
+    ox__TransactionEnvelopeLegacy.assert(typedTransaction);
+
+    return ox__TransactionEnvelopeLegacy.serialize(typedTransaction, {
+      signature,
+    });
+  }
+
+  if (type === "eip2930") {
+    const typedTransaction =
+      transaction as ox__TransactionEnvelopeEip2930.TransactionEnvelopeEip2930;
+    ox__TransactionEnvelopeEip2930.assert(typedTransaction);
+
+    return ox__TransactionEnvelopeEip2930.serialize(typedTransaction, {
+      signature,
+    });
+  }
+
+  throw new Error("Invalid transaction type");
+}
+
+/**
+ * @internal
+ */
+function getTransactionEnvelopeType(
+  transactionEnvelope: SerializableTransaction,
+) {
+  if (typeof transactionEnvelope.type !== "undefined") {
+    return transactionEnvelope.type;
+  }
+
+  if (
+    typeof transactionEnvelope.maxFeePerGas !== "undefined" ||
+    typeof transactionEnvelope.maxPriorityFeePerGas !== "undefined"
+  ) {
+    return "eip1559";
+  }
+
+  if (typeof transactionEnvelope.gasPrice !== "undefined") {
+    if (typeof transactionEnvelope.accessList !== "undefined") {
+      return "eip2930";
+    }
+    return "legacy";
+  }
+
+  throw new Error("Invalid transaction type");
 }

package/src/utils/any-evm/keyless-transaction.test.ts

@@ -0,0 +1,91 @@
+import * as ox__Hash from "ox/Hash";
+import * as ox__Hex from "ox/Hex";
+import * as ox__Signature from "ox/Signature";
+import { recoverAddress } from "viem";
+import { describe, expect, it } from "vitest";
+import { serializeTransaction } from "../../transaction/serialize-transaction.js";
+import { getKeylessTransaction } from "./keyless-transaction.js";
+
+describe("getKeylessTransaction", () => {
+  const mockTransaction = {
+    to: "0x1234567890123456789012345678901234567890",
+    value: 1000n,
+    chainId: 1,
+    gasPrice: 10n,
+  };
+
+  const mockSignature = {
+    r: "0x60fdd29ff912ce880cd3edaf9f932dc61d3dae823ea77e0323f94adb9f6a72fe",
+    s: "0x60fdd29ff912ce880cd3edaf9f932dc61d3dae823ea77e0323f94adb9f6a72fe",
+    v: 27n,
+  } as const;
+
+  it("should return the correct signer address and serialized transaction", async () => {
+    const serializedTransaction = serializeTransaction({
+      transaction: mockTransaction,
+    });
+
+    const hash = ox__Hash.keccak256(serializedTransaction);
+    const expectedAddress = await recoverAddress({
+      hash,
+      signature: ox__Signature.toHex({
+        r: ox__Hex.toBigInt(mockSignature.r),
+        s: ox__Hex.toBigInt(mockSignature.s),
+        yParity: ox__Signature.vToYParity(Number(mockSignature.v)),
+      }),
+    });
+
+    const result = await getKeylessTransaction({
+      transaction: mockTransaction,
+      signature: mockSignature,
+    });
+
+    expect(result.signerAddress).toBe(expectedAddress);
+    expect(result.transaction).toBe(
+      serializeTransaction({
+        transaction: mockTransaction,
+        signature: mockSignature,
+      }),
+    );
+  });
+
+  it("should throw if yParity is explicitly undefined", async () => {
+    const invalidSignature = {
+      r: mockSignature.r,
+      s: mockSignature.s,
+      yParity: undefined,
+    };
+
+    await expect(
+      getKeylessTransaction({
+        transaction: mockTransaction,
+        // biome-ignore lint/suspicious/noExplicitAny: Testing invalid data
+        signature: invalidSignature as any,
+      }),
+    ).rejects.toThrow();
+  });
+
+  it("should throw if a signature is not recoverable", async () => {
+    const invalidSignature = { ...mockSignature, v: undefined };
+
+    await expect(
+      getKeylessTransaction({
+        transaction: mockTransaction,
+        // biome-ignore lint/suspicious/noExplicitAny: Testing invalid data
+        signature: invalidSignature as any,
+      }),
+    ).rejects.toThrow();
+  });
+
+  it("should throw an error if the transaction is invalid", async () => {
+    const invalidTransaction = { ...mockTransaction, value: "invalid" };
+
+    await expect(
+      getKeylessTransaction({
+        // biome-ignore lint/suspicious/noExplicitAny: Testing invalid data
+        transaction: invalidTransaction as any,
+        signature: mockSignature,
+      }),
+    ).rejects.toThrow();
+  });
+});

package/src/utils/any-evm/keyless-transaction.ts

@@ -1,15 +1,18 @@
+import * as ox__Hash from "ox/Hash";
+import * as ox__Hex from "ox/Hex";
+import * as ox__Signature from "ox/Signature";
+import { recoverAddress } from "viem";
 import {
-  type Signature,
-  type TransactionSerializable,
-  recoverAddress,
+  type SerializableTransaction,
   serializeTransaction,
-  signatureToHex,
-} from "viem";
-import { keccak256 } from "../hashing/keccak256.js";
+} from "../../transaction/serialize-transaction.js";
+import type { Hex } from "../encoding/hex.js";
 
 type GetKeylessTransactionOptions = {
-  transaction: TransactionSerializable;
-  signature: Signature;
+  transaction: SerializableTransaction;
+  signature:
+    | ox__Signature.Signature<true, Hex>
+    | ox__Signature.Legacy<Hex, bigint>;
 };
 
 /**
@@ -23,20 +26,46 @@ export async function getKeylessTransaction(
   options: GetKeylessTransactionOptions,
 ) {
   // 1. Create serialized txn string
-  const hash = keccak256(serializeTransaction(options.transaction));
+  const hash = ox__Hash.keccak256(
+    serializeTransaction({ transaction: options.transaction }),
+  );
+
+  const yParity = (() => {
+    if (
+      "yParity" in options.signature &&
+      typeof options.signature.yParity !== "undefined"
+    ) {
+      return options.signature.yParity;
+    }
+
+    if (
+      "v" in options.signature &&
+      typeof options.signature.v !== "undefined"
+    ) {
+      return ox__Signature.vToYParity(Number(options.signature.v));
+    }
+
+    throw new Error(
+      "Invalid recovered signature provided with transaction, missing v or yParity",
+    );
+  })();
 
   // 2. Determine signer address from custom signature + txn
   const address = await recoverAddress({
     hash,
-    signature: signatureToHex(options.signature),
+    signature: ox__Signature.toHex({
+      r: ox__Hex.toBigInt(options.signature.r),
+      s: ox__Hex.toBigInt(options.signature.s),
+      yParity,
+    }),
   });
 
   // 3. Create the signed serialized txn string.
   // To be sent directly to the chain using a provider.
-  const transaction = serializeTransaction(
-    options.transaction,
-    options.signature,
-  );
+  const transaction = serializeTransaction({
+    transaction: options.transaction,
+    signature: options.signature,
+  });
 
   return {
     signerAddress: address,

package/src/utils/hashing/hashMessage.ts

@@ -1,13 +1,14 @@
-import { type ByteArray, type SignableMessage, concat } from "viem";
+import { Bytes as ox__Bytes } from "ox";
 import type { Hex } from "../encoding/hex.js";
 import { stringToBytes, toBytes } from "../encoding/to-bytes.js";
+import type { SignableMessage } from "../types.js";
 import { keccak256 } from "./keccak256.js";
 
 const presignMessagePrefix = "\x19Ethereum Signed Message:\n";
 type To = "hex" | "bytes";
 
 type HashMessage<TTo extends To> =
-  | (TTo extends "bytes" ? ByteArray : never)
+  | (TTo extends "bytes" ? ox__Bytes.Bytes : never)
   | (TTo extends "hex" ? Hex : never);
 
 /**
@@ -38,5 +39,5 @@ export function hashMessage<TTo extends To = "hex">(
   const prefixBytes = stringToBytes(
     `${presignMessagePrefix}${messageBytes.length}`,
   );
-  return keccak256(concat([prefixBytes, messageBytes]), to_);
+  return keccak256(ox__Bytes.concat(prefixBytes, messageBytes), to_);
 }

package/src/utils/hashing/hashTypedData.ts

@@ -1,12 +1,6 @@
-import {
-  type AbiParameter,
-  type TypedData,
-  type TypedDataDefinition,
-  concat,
-  getTypesForEIP712Domain,
-  hashDomain,
-  validateTypedData,
-} from "viem";
+import type * as ox__AbiParameters from "ox/AbiParameters";
+import * as ox__Bytes from "ox/Bytes";
+import * as ox__TypedData from "ox/TypedData";
 import { encodeAbiParameters } from "../abi/encodeAbiParameters.js";
 import { type Hex, toHex } from "../encoding/hex.js";
 import { keccak256 } from "./keccak256.js";
@@ -17,15 +11,17 @@ type MessageTypeProperty = {
 };
 
 export type HashTypedDataParams<
-  typedData extends TypedData | Record<string, unknown> = TypedData,
+  typedData extends
+    | ox__TypedData.TypedData
+    | Record<string, unknown> = ox__TypedData.TypedData,
   primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
-> = TypedDataDefinition<typedData, primaryType>;
+> = ox__TypedData.Definition<typedData, primaryType>;
 
 /**
  * @internal
  */
 export function hashTypedData<
-  const typedData extends TypedData | Record<string, unknown>,
+  const typedData extends ox__TypedData.TypedData | Record<string, unknown>,
   primaryType extends keyof typedData | "EIP712Domain",
 >(parameters: HashTypedDataParams<typedData, primaryType>): Hex {
   const {
@@ -34,13 +30,13 @@ export function hashTypedData<
     primaryType,
   } = parameters as HashTypedDataParams;
   const types = {
-    EIP712Domain: getTypesForEIP712Domain({ domain }),
+    EIP712Domain: ox__TypedData.extractEip712DomainTypes(domain),
     ...parameters.types,
   };
 
   // Need to do a runtime validation check on addresses, byte ranges, integer ranges, etc
   // as we can't statically check this with TypeScript.
-  validateTypedData({
+  ox__TypedData.validate({
     domain,
     message,
     primaryType,
@@ -50,7 +46,7 @@ export function hashTypedData<
   const parts: Hex[] = ["0x1901"];
   if (domain)
     parts.push(
-      hashDomain({
+      ox__TypedData.hashDomain({
         domain,
         types: types as Record<string, MessageTypeProperty[]>,
       }),
@@ -69,7 +65,7 @@ export function hashTypedData<
     parts.push(hashedStruct);
   }
 
-  return keccak256(concat(parts));
+  return keccak256(ox__Bytes.concat(...parts.map((p) => ox__Bytes.fromHex(p))));
 }
 
 function encodeData({
@@ -81,7 +77,7 @@ function encodeData({
   primaryType: string;
   types: Record<string, MessageTypeProperty[]>;
 }) {
-  const encodedTypes: AbiParameter[] = [{ type: "bytes32" }];
+  const encodedTypes: ox__AbiParameters.Parameter[] = [{ type: "bytes32" }];
   const encodedValues: unknown[] = [hashType({ primaryType, types })];
 
   if (!types[primaryType]) throw new Error("Invalid types");
@@ -168,7 +164,7 @@ function encodeField({
   // biome-ignore lint/suspicious/noExplicitAny: Can't anticipate types of nested values
   value: any;
   // biome-ignore lint/suspicious/noExplicitAny: Can't anticipate types of nested values
-}): [type: AbiParameter, value: any] {
+}): [type: ox__AbiParameters.Parameter, value: any] {
   if (types[type] !== undefined) {
     return [
       { type: "bytes32" },
@@ -186,15 +182,16 @@ function encodeField({
 
   if (type.lastIndexOf("]") === type.length - 1) {
     const parsedType = type.slice(0, type.lastIndexOf("["));
-    // biome-ignore lint/suspicious/noExplicitAny: Can't anticipate types of nested values
-    const typeValuePairs = (value as [AbiParameter, any][]).map((item) =>
-      encodeField({
-        name,
-        type: parsedType,
-        types,
-        value: item,
-      }),
-    );
+    const typeValuePairs =
+      // biome-ignore lint/suspicious/noExplicitAny: Can't anticipate types of nested values
+      (value as [ox__AbiParameters.Parameter, any][]).map((item) =>
+        encodeField({
+          name,
+          type: parsedType,
+          types,
+          value: item,
+        }),
+      );
     return [
       { type: "bytes32" },
       keccak256(

package/src/utils/signatures/helpers/parse-typed-data.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, test } from "vitest";
+import { parseTypedData } from "./parse-typed-data.js";
+
+describe("parseTypedData", () => {
+  test("parses typed data with hex chainId", () => {
+    const typedData = {
+      domain: {
+        chainId: "0x1" as unknown as number,
+      },
+      types: {},
+      primaryType: "EIP712Domain" as const,
+    };
+
+    const result = parseTypedData(typedData);
+    expect(result.domain.chainId).toBe(1);
+  });
+
+  test("returns typed data unchanged if chainId is not hex", () => {
+    const typedData = {
+      domain: {
+        chainId: 1,
+      },
+      types: {},
+      primaryType: "EIP712Domain" as const,
+    };
+
+    const result = parseTypedData(typedData);
+    expect(result.domain.chainId).toBe(1);
+  });
+
+  test("returns typed data unchanged if chainId is undefined", () => {
+    const typedData = {
+      domain: {},
+      types: {},
+      primaryType: "EIP712Domain" as const,
+    };
+
+    const result = parseTypedData(typedData);
+    expect(result.domain.chainId).toBeUndefined();
+  });
+
+  test("handles unknown domain properties", () => {
+    const typedData = {
+      domain: {
+        chainId: "0x1" as unknown as number,
+        name: "Test",
+      },
+      types: {},
+      primaryType: "EIP712Domain" as const,
+    };
+
+    const result = parseTypedData(typedData);
+    expect(result.domain.chainId).toBe(1);
+    expect(result.domain.name).toBe("Test");
+  });
+});

package/src/utils/signatures/helpers/parse-typed-data.ts

@@ -0,0 +1,29 @@
+import * as ox__Hex from "ox/Hex";
+import type * as ox__TypedData from "ox/TypedData";
+import type { Hex } from "../../encoding/hex.js";
+
+type UnknownDomain = unknown & { chainId?: unknown };
+type HexDomain = unknown & { chainId: Hex };
+
+/**
+ * @internal
+ */
+export function parseTypedData<
+  typedData extends
+    | ox__TypedData.TypedData
+    | Record<string, unknown> = ox__TypedData.TypedData,
+  primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
+>(
+  typedData: ox__TypedData.Definition<typedData, primaryType>,
+): ox__TypedData.Definition<typedData, primaryType> {
+  const domain = typedData.domain as UnknownDomain;
+  if (domain?.chainId !== undefined && ox__Hex.validate(domain.chainId)) {
+    typedData.domain = {
+      ...(typedData.domain as HexDomain),
+      chainId: ox__Hex.toNumber(
+        (typedData.domain as unknown as HexDomain).chainId,
+      ),
+    } as unknown as ox__TypedData.Definition<typedData, primaryType>["domain"];
+  }
+  return typedData;
+}

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

@@ -1,9 +1,10 @@
+import * as ox__Hex from "ox/Hex";
+import * as ox__PersonalMessage from "ox/PersonalMessage";
+import * as ox__Secp256k1 from "ox/Secp256k1";
+import * as ox__Signature from "ox/Signature";
 import type { Account } from "../../wallets/interfaces/wallet.js";
 import type { Hex } from "../encoding/hex.js";
-import { hashMessage } from "../hashing/hashMessage.js";
 import type { Prettify } from "../type-utils.js";
-import { sign } from "./sign.js";
-import { signatureToHex } from "./signature-to-hex.js";
 
 type Message = Prettify<
   | string
@@ -59,9 +60,17 @@ export function signMessage(
   options: SignMessageOptions | { message: Message; account: Account },
 ): Hex | Promise<Hex> {
   if ("privateKey" in options) {
-    const { message, privateKey } = options;
-    const signature = sign({ hash: hashMessage(message), privateKey });
-    return signatureToHex(signature);
+    const payload = ox__PersonalMessage.getSignPayload(
+      typeof options.message === "object"
+        ? options.message.raw
+        : ox__Hex.fromString(options.message),
+    );
+
+    const signature = ox__Secp256k1.sign({
+      payload,
+      privateKey: options.privateKey,
+    });
+    return ox__Signature.toHex(signature);
   }
   if ("account" in options) {
     const { message, account } = options;

package/src/utils/signatures/sign-typed-data.ts

@@ -1,14 +1,15 @@
-import type { TypedData } from "abitype";
-import { type TypedDataDefinition, hashTypedData } from "viem";
+import * as ox__Hex from "ox/Hex";
+import * as ox__Secp256k1 from "ox/Secp256k1";
+import * as ox__Signature from "ox/Signature";
+import * as ox__TypedData from "ox/TypedData";
 import type { Hex } from "../encoding/hex.js";
-import { parseTypedData } from "./helpers/parseTypedData.js";
-import { sign } from "./sign.js";
-import { signatureToHex } from "./signature-to-hex.js";
 
 export type SignTypedDataOptions<
-  typedData extends TypedData | Record<string, unknown> = TypedData,
+  typedData extends
+    | ox__TypedData.TypedData
+    | Record<string, unknown> = ox__TypedData.TypedData,
   primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
-> = TypedDataDefinition<typedData, primaryType> & {
+> = ox__TypedData.Definition<typedData, primaryType> & {
   privateKey: Hex;
 };
 
@@ -28,17 +29,22 @@ export type SignTypedDataOptions<
  * @utils
  */
 export function signTypedData<
-  const typedData extends TypedData | Record<string, unknown>,
+  const typedData extends ox__TypedData.TypedData | Record<string, unknown>,
   primaryType extends keyof typedData | "EIP712Domain",
 >(options: SignTypedDataOptions<typedData, primaryType>): Hex {
   const { privateKey, ...typedData } =
     options as unknown as SignTypedDataOptions;
 
-  const parsedTypeData = parseTypedData(typedData);
+  if (typeof typedData.domain?.chainId === "string") {
+    typedData.domain.chainId = ox__Hex.toNumber(typedData.domain.chainId);
+  }
 
-  const signature = sign({
-    hash: hashTypedData(parsedTypeData), // TODO: Implement native hashTypedData
+  const payload = ox__TypedData.getSignPayload(typedData);
+
+  const signature = ox__Secp256k1.sign({
+    payload,
     privateKey,
   });
-  return signatureToHex(signature);
+
+  return ox__Signature.toHex(signature);
 }

package/src/utils/signatures/sign.ts

@@ -1,5 +1,4 @@
-import { secp256k1 } from "@noble/curves/secp256k1";
-import type { Signature } from "viem";
+import * as ox__Secp256k1 from "ox/Secp256k1";
 
 import { type Hex, toHex } from "../encoding/hex.js";
 
@@ -28,12 +27,12 @@ export type SignOptions = {
  * ```
  * @utils
  */
-export function sign({ hash, privateKey }: SignOptions): Signature {
-  const { r, s, recovery } = secp256k1.sign(hash.slice(2), privateKey.slice(2));
+export function sign({ hash, privateKey }: SignOptions) {
+  const { r, s, yParity } = ox__Secp256k1.sign({ payload: hash, privateKey });
   return {
     r: toHex(r, { size: 32 }),
     s: toHex(s, { size: 32 }),
-    v: recovery ? 28n : 27n,
-    yParity: recovery,
+    v: yParity === 1 ? 28n : 27n,
+    yParity,
   };
 }