@getpara/viem-v2-integration 2.1.0 → 2.2.0-dev.0

package/dist/cjs/viemWalletClient.js

@@ -67,8 +67,14 @@ __export(viemWalletClient_exports, {
 });
 module.exports = __toCommonJS(viemWalletClient_exports);
 var import_viem = require("viem");
+var import_utils = require("viem/utils");
 var viemChains = __toESM(require("viem/chains"));
 var import_core_sdk = require("@getpara/core-sdk");
+function normalizeSignature(rawSignature) {
+  const sigHex = `0x${rawSignature}`;
+  const parsed = (0, import_viem.parseSignature)(sigHex);
+  return (0, import_viem.serializeSignature)({ r: parsed.r, s: parsed.s, yParity: parsed.yParity });
+}
 function createParaAccount(para, walletAddress) {
   let currentWallet;
   if (walletAddress) {
@@ -82,12 +88,23 @@ function createParaAccount(para, walletAddress) {
     publicKey: currentWallet.publicKey || "0x",
     source: "custom",
     type: "local",
+    /** Signs a raw hash directly. */
+    sign: (_0) => __async(this, [_0], function* ({ hash }) {
+      const res = yield para.signMessage({
+        walletId: currentWallet.id,
+        messageBase64: (0, import_core_sdk.hexStringToBase64)(hash)
+      });
+      const signature = res.signature;
+      return normalizeSignature(signature);
+    }),
+    /** Signs an EIP-191 personal message (prefixed and hashed). */
     signMessage: (_0) => __async(this, [_0], function* ({ message }) {
       const hashedMessage = (0, import_viem.hashMessage)(message);
       const res = yield para.signMessage({ walletId: currentWallet.id, messageBase64: (0, import_core_sdk.hexStringToBase64)(hashedMessage) });
       const signature = res.signature;
-      return `0x${signature}`;
+      return normalizeSignature(signature);
     }),
+    /** Signs and serializes an Ethereum transaction. */
     signTransaction: (transaction, args) => __async(this, null, function* () {
       let { serializer } = args || {};
       if (!serializer) {
@@ -104,17 +121,47 @@ function createParaAccount(para, walletAddress) {
         chainId: `${transaction.chainId}`
       });
       const signature = res.signature;
-      const formattedSig = (0, import_core_sdk.hexToSignature)(`0x${signature}`);
-      formattedSig.v += BigInt(27);
-      return serializer(transaction, formattedSig);
+      const normalizedSig = normalizeSignature(signature);
+      const parsed = (0, import_viem.parseSignature)(normalizedSig);
+      return serializer(transaction, {
+        r: parsed.r,
+        s: parsed.s,
+        v: parsed.v
+        // v is guaranteed after normalization (27n or 28n)
+      });
     }),
+    /** Signs EIP-712 typed data. */
     signTypedData: (typedDataDefinition) => __async(this, null, function* () {
       const res = yield para.signMessage({
         walletId: currentWallet.id,
         messageBase64: (0, import_core_sdk.hexStringToBase64)((0, import_viem.hashTypedData)(typedDataDefinition))
       });
       const signature = res.signature;
-      return `0x${signature}`;
+      return normalizeSignature(signature);
+    }),
+    /**
+     * Signs an EIP-7702 authorization for account delegation.
+     * Returns yParity (0/1) per EIP-7702, not legacy v (27/28).
+     */
+    signAuthorization: (authorization) => __async(this, null, function* () {
+      var _a;
+      const address = (_a = authorization.contractAddress) != null ? _a : authorization.address;
+      const hash = (0, import_utils.hashAuthorization)({ address, chainId: authorization.chainId, nonce: authorization.nonce });
+      const res = yield para.signMessage({
+        walletId: currentWallet.id,
+        messageBase64: (0, import_core_sdk.hexStringToBase64)(hash)
+      });
+      const signature = res.signature;
+      const sigHex = `0x${signature}`;
+      const parsed = (0, import_viem.parseSignature)(sigHex);
+      return {
+        address,
+        chainId: authorization.chainId,
+        nonce: authorization.nonce,
+        r: parsed.r,
+        s: parsed.s,
+        yParity: parsed.yParity
+      };
     })
   };
 }

package/dist/esm/viemWalletClient.js

@@ -37,11 +37,19 @@ var __async = (__this, __arguments, generator) => {
 import {
   createWalletClient,
   hashMessage,
-  serializeTransaction,
-  hashTypedData
+  hashTypedData,
+  parseSignature,
+  serializeSignature,
+  serializeTransaction
 } from "viem";
+import { hashAuthorization } from "viem/utils";
 import * as viemChains from "viem/chains";
-import { hexStringToBase64, hexToSignature } from "@getpara/core-sdk";
+import { hexStringToBase64 } from "@getpara/core-sdk";
+function normalizeSignature(rawSignature) {
+  const sigHex = `0x${rawSignature}`;
+  const parsed = parseSignature(sigHex);
+  return serializeSignature({ r: parsed.r, s: parsed.s, yParity: parsed.yParity });
+}
 function createParaAccount(para, walletAddress) {
   let currentWallet;
   if (walletAddress) {
@@ -55,12 +63,23 @@ function createParaAccount(para, walletAddress) {
     publicKey: currentWallet.publicKey || "0x",
     source: "custom",
     type: "local",
+    /** Signs a raw hash directly. */
+    sign: (_0) => __async(this, [_0], function* ({ hash }) {
+      const res = yield para.signMessage({
+        walletId: currentWallet.id,
+        messageBase64: hexStringToBase64(hash)
+      });
+      const signature = res.signature;
+      return normalizeSignature(signature);
+    }),
+    /** Signs an EIP-191 personal message (prefixed and hashed). */
     signMessage: (_0) => __async(this, [_0], function* ({ message }) {
       const hashedMessage = hashMessage(message);
       const res = yield para.signMessage({ walletId: currentWallet.id, messageBase64: hexStringToBase64(hashedMessage) });
       const signature = res.signature;
-      return `0x${signature}`;
+      return normalizeSignature(signature);
     }),
+    /** Signs and serializes an Ethereum transaction. */
     signTransaction: (transaction, args) => __async(this, null, function* () {
       let { serializer } = args || {};
       if (!serializer) {
@@ -77,17 +96,47 @@ function createParaAccount(para, walletAddress) {
         chainId: `${transaction.chainId}`
       });
       const signature = res.signature;
-      const formattedSig = hexToSignature(`0x${signature}`);
-      formattedSig.v += BigInt(27);
-      return serializer(transaction, formattedSig);
+      const normalizedSig = normalizeSignature(signature);
+      const parsed = parseSignature(normalizedSig);
+      return serializer(transaction, {
+        r: parsed.r,
+        s: parsed.s,
+        v: parsed.v
+        // v is guaranteed after normalization (27n or 28n)
+      });
     }),
+    /** Signs EIP-712 typed data. */
     signTypedData: (typedDataDefinition) => __async(this, null, function* () {
       const res = yield para.signMessage({
         walletId: currentWallet.id,
         messageBase64: hexStringToBase64(hashTypedData(typedDataDefinition))
       });
       const signature = res.signature;
-      return `0x${signature}`;
+      return normalizeSignature(signature);
+    }),
+    /**
+     * Signs an EIP-7702 authorization for account delegation.
+     * Returns yParity (0/1) per EIP-7702, not legacy v (27/28).
+     */
+    signAuthorization: (authorization) => __async(this, null, function* () {
+      var _a;
+      const address = (_a = authorization.contractAddress) != null ? _a : authorization.address;
+      const hash = hashAuthorization({ address, chainId: authorization.chainId, nonce: authorization.nonce });
+      const res = yield para.signMessage({
+        walletId: currentWallet.id,
+        messageBase64: hexStringToBase64(hash)
+      });
+      const signature = res.signature;
+      const sigHex = `0x${signature}`;
+      const parsed = parseSignature(sigHex);
+      return {
+        address,
+        chainId: authorization.chainId,
+        nonce: authorization.nonce,
+        r: parsed.r,
+        s: parsed.s,
+        yParity: parsed.yParity
+      };
     })
   };
 }

package/dist/types/viemWalletClient.d.ts

@@ -1,10 +1,73 @@
-import { WalletClient, WalletClientConfig, Hex, Transport, Chain, LocalAccount, RpcSchema } from 'viem';
+import type { Chain, Hex, LocalAccount, RpcSchema, Transport, WalletClient, WalletClientConfig } from 'viem';
 import * as viemChains from 'viem/chains';
 import ParaCore from '@getpara/core-sdk';
+/** Options for creating a Para viem client */
 interface ViemClientOpts {
+    /** If true, creates the client without an attached account */
     noAccount?: boolean;
 }
+/**
+ * Creates a viem-compatible LocalAccount backed by a Para wallet.
+ *
+ * This account implements all standard signing methods with proper signature
+ * formatting for maximum compatibility:
+ * - `sign`, `signMessage`, `signTypedData`, `signTransaction`: Use normalized
+ *   signatures with v=27/28 for legacy `ecrecover` compatibility
+ * - `signAuthorization`: Uses yParity=0/1 as required by EIP-7702
+ *
+ * @param para - The Para SDK instance
+ * @param walletAddress - Optional specific wallet address to use. If not provided,
+ *                        uses the first available EVM wallet.
+ * @returns A LocalAccount that can be used with viem's wallet client
+ *
+ * @example
+ * ```ts
+ * const account = createParaAccount(para);
+ * const signature = await account.signMessage({ message: 'Hello' });
+ * // signature is properly formatted for ecrecover
+ * ```
+ */
 export declare function createParaAccount(para: ParaCore, walletAddress?: Hex): LocalAccount;
+/**
+ * Looks up a viem Chain object by chain ID.
+ *
+ * @param chainId - The chain ID as a string
+ * @returns The matching viem Chain object
+ * @throws Error if no chain with the given ID is found
+ *
+ * @example
+ * ```ts
+ * const mainnet = getViemChain('1');
+ * const polygon = getViemChain('137');
+ * ```
+ */
 export declare function getViemChain(chainId: string): viemChains.Chain;
+/**
+ * Creates a viem WalletClient configured with a Para account.
+ *
+ * This is a convenience function that combines `createParaAccount` with viem's
+ * `createWalletClient`. The resulting client can be used for all standard
+ * wallet operations with properly formatted signatures.
+ *
+ * @param para - The Para SDK instance
+ * @param params - Standard viem WalletClientConfig (chain, transport, etc.)
+ * @param opts - Optional configuration
+ * @param opts.noAccount - If true, creates a client without an attached account
+ * @returns A viem WalletClient backed by the Para wallet
+ *
+ * @example
+ * ```ts
+ * import { http } from 'viem';
+ * import { mainnet } from 'viem/chains';
+ *
+ * const client = createParaViemClient(para, {
+ *   chain: mainnet,
+ *   transport: http(),
+ * });
+ *
+ * // Use standard viem methods - signatures are properly formatted
+ * const hash = await client.sendTransaction({ to: '0x...', value: 1n });
+ * ```
+ */
 export declare function createParaViemClient(para: ParaCore, params: WalletClientConfig<Transport, Chain, LocalAccount, RpcSchema>, opts?: ViemClientOpts): WalletClient<Transport, Chain, LocalAccount, RpcSchema>;
 export {};

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@getpara/viem-v2-integration",
-  "version": "2.1.0",
+  "version": "2.2.0-dev.0",
   "dependencies": {
     "@getpara/core-sdk": "2.1.0"
   },
   "devDependencies": {
     "typescript": "^5.8.3",
-    "viem": "^2.38.5"
+    "viem": "^2.39.0"
   },
   "exports": {
     ".": {
@@ -19,7 +19,7 @@
     "dist",
     "package.json"
   ],
-  "gitHead": "3ae7f836324a3a2a8a57156e16304aeaf0d37b42",
+  "gitHead": "e6e791d4e4f9afd94f2093d6045d686b85e5a682",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "peerDependencies": {