@account-kit/wallet-client 0.1.0-alpha.8 → 4.50.0

package/src/client/actions/formatSign.ts

@@ -0,0 +1,55 @@
+import type { Static } from "@sinclair/typebox";
+import type { wallet_formatSign } from "@alchemy/wallet-api-types/rpc";
+import type { InnerWalletApiClient, WithoutChainId } from "../../types.ts";
+import { toHex, type Address, type IsUndefined } from "viem";
+import { AccountNotFoundError } from "@aa-sdk/core";
+
+export type FormatSignParams<
+  TAccount extends Address | undefined = Address | undefined,
+> = Omit<
+  WithoutChainId<
+    Static<
+      (typeof wallet_formatSign)["properties"]["Request"]["properties"]["params"]
+    >[0]
+  >,
+  "from"
+> &
+  (IsUndefined<TAccount> extends true ? { from: Address } : { from?: never });
+
+export type FormatSignResult = Static<typeof wallet_formatSign>["ReturnType"];
+
+/**
+ * Formats a signature request for signing messages or transactions.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {FormatSignParams} params - Parameters for formatting the signature
+ * @returns {Promise<FormatSignResult>} A Promise that resolves to the formatSign result containing the formatted signature.
+ *
+ * @example
+ * ```ts
+ * // Formats a signature
+ * const result = await client.formatSign({
+ *    from: "0x1234...",
+ *    signature: {
+ *      type: "ecdsa",
+ *      data: "0xabcd..."
+ *    },
+ * });
+ * ```
+ */
+export async function formatSign<
+  TAccount extends Address | undefined = Address | undefined,
+>(
+  client: InnerWalletApiClient,
+  params: FormatSignParams<TAccount>,
+): Promise<FormatSignResult> {
+  const from = params.from ?? client.account?.address;
+  if (!from) {
+    throw new AccountNotFoundError();
+  }
+
+  return client.request({
+    method: "wallet_formatSign",
+    params: [{ ...params, from, chainId: toHex(client.chain.id) }],
+  });
+}

package/src/client/actions/getCallsStatus.ts

@@ -1,12 +1,14 @@
-import type {
-  GetCallsStatusParams as IsomorphicGetCallsStatusParams,
-  GetCallsStatusResponse as IsomorphicGetCallsStatusResult,
-} from "../../isomorphic/actions/getCallsStatus.ts";
 import type { InnerWalletApiClient } from "../../types.ts";
+import type { Static } from "@sinclair/typebox";
+import { wallet_getCallsStatus } from "@alchemy/wallet-api-types/rpc";
 
-export type GetCallsStatusParams = IsomorphicGetCallsStatusParams;
+export type GetCallsStatusParams = Static<
+  typeof wallet_getCallsStatus
+>["Request"]["params"][0];
 
-export type GetCallsStatusResult = IsomorphicGetCallsStatusResult;
+export type GetCallsStatusResult = Static<
+  typeof wallet_getCallsStatus
+>["ReturnType"];
 
 /**
  * Gets the status of a prepared call by its ID.
@@ -21,11 +23,13 @@ export type GetCallsStatusResult = IsomorphicGetCallsStatusResult;
  *   - receipts: Optional array of transaction receipts if the batch has been executed
  *
  * @example
+ * ```ts
  * // After sending prepared calls
  * const sendResult = await client.sendPreparedCalls({...});
  *
  * // Check the status of the first call ID
  * const status = await client.getCallsStatus(sendResult.preparedCallIds[0]);
+ * ```
  */
 export async function getCallsStatus(
   client: InnerWalletApiClient,

package/src/client/actions/grantPermissions.ts

@@ -1,14 +1,30 @@
 import { AccountNotFoundError, type SmartAccountSigner } from "@aa-sdk/core";
-import { type Address, type Hex, type IsUndefined, toHex } from "viem";
-import type { CreateSessionParams } from "../../isomorphic/actions/createSession.ts";
+import {
+  toHex,
+  type Address,
+  type Hex,
+  type IsUndefined,
+  type Prettify,
+} from "viem";
 import type { InnerWalletApiClient } from "../../types.ts";
+import type { Static } from "@sinclair/typebox";
+import { wallet_createSession } from "@alchemy/wallet-api-types/rpc";
+import { encodePermissionsContext } from "@alchemy/wallet-api-types/capabilities";
+import { signSignatureRequest } from "./signSignatureRequest.js";
 
 export type GrantPermissionsParams<
   TAccount extends Address | undefined = Address | undefined,
-> = Omit<CreateSessionParams, "account" | "chainId"> &
-  (IsUndefined<TAccount> extends true
-    ? { account: Address }
-    : { account?: never });
+> = Prettify<
+  Omit<
+    Static<
+      (typeof wallet_createSession)["properties"]["Request"]["properties"]["params"]
+    >[0],
+    "account" | "chainId"
+  > &
+    (IsUndefined<TAccount> extends true
+      ? { account: Address }
+      : { account?: never })
+>;
 
 export type GrantPermissionsResult = {
   context: Hex;
@@ -23,21 +39,21 @@ export type GrantPermissionsResult = {
  * @param {GrantPermissionsParams} params - The parameters for granting permissions
  * @param {Address} [params.account] - The account address (required if client was not initialized with an account)
  * @param {number} params.expirySec - Unix timestamp when the permissions expire
- * @param {object} params.key - The session key information
+ * @param {sessionKeyData} params.key - The session key information
  * @param {string} params.key.publicKey - The public key of the session key
  * @param {string} params.key.type - The type of the key (e.g., "secp256k1")
  * @param {Array} params.permissions - Array of permission objects defining what the session key can do
  * @returns {Promise<GrantPermissionsResult>} A Promise that resolves to the result containing a context identifier
- * @returns {Hex} result.context - A hex identifier for the granted permissions context
  *
  * @example
+ * ```ts
  * // Create a session key and grant root permissions
  * const sessionKey = LocalAccountSigner.generatePrivateKeySigner();
  * const account = await client.requestAccount();
  *
  * const permissions = await client.grantPermissions({
  *   account: account.address,
- *   expiry: Math.floor(Date.now() / 1000) + 60 * 60, // 1 hour from now
+ *   expirySec: Math.floor(Date.now() / 1000) + 60 * 60, // 1 hour from now
  *   key: {
  *     publicKey: await sessionKey.getAddress(),
  *     type: "secp256k1",
@@ -58,10 +74,7 @@ export type GrantPermissionsResult = {
  * });
  *
  * // Sign with the session key
- * const signedCalls = await client.signPreparedCalls(
- *   sessionKey,
- *   preparedCalls,
- * );
+ * const signedCalls = await signPreparedCalls(sessionKey, preparedCalls);
  *
  * // Send the prepared call using the session key
  * const result = await client.sendPreparedCalls({
@@ -70,6 +83,7 @@ export type GrantPermissionsResult = {
  *     permissions,
  *   },
  * });
+ * ```
  */
 export async function grantPermissions<
   TAccount extends Address | undefined = Address | undefined,
@@ -79,14 +93,28 @@ export async function grantPermissions<
   params: GrantPermissionsParams<TAccount>,
 ): Promise<GrantPermissionsResult> {
   const account = params.account ?? client.account?.address;
-
   if (!account) {
     throw new AccountNotFoundError();
   }
 
-  return client.grantPermissions(signer, {
-    ...params,
-    account,
-    chainId: toHex(client.chain.id),
+  const { sessionId, signatureRequest } = await client.request({
+    method: "wallet_createSession",
+    params: [
+      {
+        ...params,
+        account,
+        chainId: toHex(client.chain.id),
+      },
+    ],
   });
+
+  const signature = await signSignatureRequest(signer, signatureRequest);
+
+  return {
+    context: encodePermissionsContext({
+      contextVersion: "REMOTE_MODE_DEFERRED_ACTION",
+      sessionId,
+      signature: signature.data,
+    }),
+  };
 }

package/src/client/actions/listAccounts.ts

@@ -1,10 +1,13 @@
 import type { Static } from "@sinclair/typebox";
-import type { wallet_listAccounts } from "../../rpc/request.ts";
+import type { wallet_listAccounts } from "@alchemy/wallet-api-types/rpc";
 import type { InnerWalletApiClient } from "../../types.ts";
+import type { SmartAccountSigner } from "@aa-sdk/core";
+import type { Address } from "viem";
 
-export type ListAccountsParams = Static<
-  typeof wallet_listAccounts
->["Request"]["params"][0];
+export type ListAccountsParams = Omit<
+  Static<typeof wallet_listAccounts>["Request"]["params"][0],
+  "signerAddress"
+> & { signerAddress?: Address };
 
 export type ListAccountsResult = Static<
   typeof wallet_listAccounts
@@ -14,6 +17,7 @@ export type ListAccountsResult = Static<
  * Lists all smart accounts for a given signer using the wallet API client.
  *
  * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {SmartAccountSigner} signer - The signer for which to list accounts
  * @param {ListAccountsParams} params - Parameters for listing accounts
  * @param {string} params.signerAddress - The address of the signer to list accounts for
  * @param {number} [params.limit] - Optional maximum number of accounts to return (default: 100, max: 100)
@@ -21,6 +25,7 @@ export type ListAccountsResult = Static<
  * @returns {Promise<ListAccountsResult>} A Promise that resolves to the list of accounts and pagination metadata
  *
  * @example
+ * ```ts
  * // Fetch the first page of accounts
  * const firstPage = await client.listAccounts({
  *   signerAddress: "0x123...",
@@ -33,10 +38,22 @@ export type ListAccountsResult = Static<
  *   limit: 10,
  *   after: firstPage.meta.after
  * });
+ * ```
  */
 export async function listAccounts(
   client: InnerWalletApiClient,
+  signer: SmartAccountSigner,
   params: ListAccountsParams,
 ): Promise<ListAccountsResult> {
-  return client.request({ method: "wallet_listAccounts", params: [params] });
+  const signerAddress = params.signerAddress ?? (await signer.getAddress());
+
+  return client.request({
+    method: "wallet_listAccounts",
+    params: [
+      {
+        ...params,
+        signerAddress,
+      },
+    ],
+  });
 }

package/src/client/actions/prepareCalls.ts

@@ -1,10 +1,8 @@
 import { AccountNotFoundError } from "@aa-sdk/core";
 import { toHex, type Address, type IsUndefined } from "viem";
-import type {
-  PrepareCallsParams as IsomorphicPrepareCallsParams,
-  PrepareCallsResult as IsomorphicPrepareCallsResult,
-} from "../../isomorphic/actions/prepareCalls.ts";
 import type { InnerWalletApiClient } from "../../types.ts";
+import type { Static } from "@sinclair/typebox";
+import { wallet_prepareCalls } from "@alchemy/wallet-api-types/rpc";
 
 export type GetAccountParam<TAccount> =
   IsUndefined<TAccount> extends true
@@ -13,10 +11,17 @@ export type GetAccountParam<TAccount> =
 
 export type PrepareCallsParams<
   TAccount extends Address | undefined = Address | undefined,
-> = Omit<IsomorphicPrepareCallsParams, "from" | "chainId"> &
+> = Omit<
+  Static<
+    (typeof wallet_prepareCalls)["properties"]["Request"]["properties"]["params"]
+  >[0],
+  "from" | "chainId"
+> &
   (IsUndefined<TAccount> extends true ? { from: Address } : { from?: never });
 
-export type PrepareCallsResult = IsomorphicPrepareCallsResult;
+export type PrepareCallsResult = Static<
+  typeof wallet_prepareCalls
+>["ReturnType"];
 
 /**
  * Prepares a set of contract calls for execution by building a user operation.
@@ -32,6 +37,7 @@ export type PrepareCallsResult = IsomorphicPrepareCallsResult;
  * the user operation data and signature request
  *
  * @example
+ * ```ts
  * // Prepare a sponsored user operation call
  * const result = await client.prepareCalls({
  *   calls: [{
@@ -43,6 +49,7 @@ export type PrepareCallsResult = IsomorphicPrepareCallsResult;
  *     paymasterService: { policyId: "your-policy-id" }
  *   }
  * });
+ * ```
  */
 export async function prepareCalls<
   TAccount extends Address | undefined = Address | undefined,
@@ -51,26 +58,25 @@ export async function prepareCalls<
   params: PrepareCallsParams<TAccount>,
 ): Promise<PrepareCallsResult> {
   const from = params.from ?? client.account?.address;
-
   if (!from) {
     throw new AccountNotFoundError();
   }
 
-  if (client.policyId && !params.capabilities?.paymasterService) {
+  if (client.policyIds && !params.capabilities?.paymasterService) {
     params.capabilities = {
       ...params.capabilities,
-      paymasterService: { policyId: client.policyId },
+      paymasterService: { policyIds: client.policyIds },
     };
   }
 
-  const params_ = {
-    ...params,
-    chainId: toHex(client.chain.id),
-    from,
-  };
-
   return await client.request({
     method: "wallet_prepareCalls",
-    params: [params_],
+    params: [
+      {
+        ...params,
+        chainId: toHex(client.chain.id),
+        from,
+      },
+    ],
   });
 }

package/src/client/actions/prepareSign.ts

@@ -0,0 +1,51 @@
+import type { InnerWalletApiClient } from "../../types.ts";
+import { toHex, type Address, type IsUndefined } from "viem";
+import { AccountNotFoundError } from "@aa-sdk/core";
+import type { Static } from "@sinclair/typebox";
+import { wallet_prepareSign } from "@alchemy/wallet-api-types/rpc";
+
+export type PrepareSignParams<
+  TAccount extends Address | undefined = Address | undefined,
+> = Omit<
+  Static<
+    (typeof wallet_prepareSign)["properties"]["Request"]["properties"]["params"]
+  >[0],
+  "from" | "chainId"
+> &
+  (IsUndefined<TAccount> extends true ? { from: Address } : { from?: never });
+
+export type PrepareSignResult = Static<typeof wallet_prepareSign>["ReturnType"];
+
+/**
+ * Prepares a signature request for signing messages or transactions.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {PrepareSignParams} params - Parameters for preparing the signature request
+ * @returns {Promise<PrepareSignResult>} A Promise that resolves to the prepare sign result containing a signature request
+ *
+ * @example
+ * ```ts
+ * // Prepare a message to be signed
+ * const result = await client.prepareSign({
+ *    from: "0x1234...",
+ *    type: "personal_sign",
+ *    data: "Hello, world!",
+ * });
+ * ```
+ */
+export async function prepareSign<
+  TAccount extends Address | undefined = Address | undefined,
+>(
+  client: InnerWalletApiClient,
+  params: PrepareSignParams<TAccount>,
+): Promise<PrepareSignResult> {
+  const from = params.from ?? client.account?.address;
+  if (!from) {
+    throw new AccountNotFoundError();
+  }
+
+  return client.request({
+    method: "wallet_prepareSign",
+    params: [{ ...params, from, chainId: toHex(client.chain.id) }],
+  });
+}

package/src/client/actions/requestAccount.ts

@@ -7,10 +7,10 @@ import { Value } from "@sinclair/typebox/value";
 import type { Address } from "abitype";
 import deepEqual from "deep-equal";
 import { custom } from "viem";
-import { createAccount } from "../../isomorphic/utils/createAccount.js";
-import type { wallet_requestAccount } from "../../rpc/request.js";
-import { TypeSerializedInitcode } from "../../schemas.js";
+import type { wallet_requestAccount } from "@alchemy/wallet-api-types/rpc";
+import { SerializedInitcode } from "@alchemy/wallet-api-types";
 import type { InnerWalletApiClient } from "../../types.js";
+import { createAccount } from "../../internal/account.js";
 
 export type RequestAccountParams = Omit<
   Extract<
@@ -35,9 +35,11 @@ export type RequestAccountResult = SmartContractAccount;
  * @returns {Promise<RequestAccountResult>} A Promise that resolves to a SmartContractAccount instance
  *
  * @example
+ * ```ts
  * // Request an account with default parameters using a local signer
  * const signer = LocalAccountSigner.privateKeyToAccountSigner("0x...");
  * const account = await client.requestAccount(signer);
+ * ```
  */
 export async function requestAccount(
   client: InnerWalletApiClient,
@@ -76,7 +78,7 @@ export async function requestAccount(
   const account = await createAccount({
     accountAddress,
     counterfactualInfo: counterfactualInfo
-      ? Value.Parse(TypeSerializedInitcode, counterfactualInfo)
+      ? Value.Parse(SerializedInitcode, counterfactualInfo)
       : undefined,
     delegation,
     chain: client.chain,

package/src/client/actions/sendPreparedCalls.ts

@@ -1,6 +1,6 @@
 import type { Static } from "@sinclair/typebox";
 import { toHex } from "viem";
-import type { wallet_sendPreparedCalls } from "../../rpc/request.ts";
+import type { wallet_sendPreparedCalls } from "@alchemy/wallet-api-types/rpc";
 import type { InnerWalletApiClient, WithoutChainId } from "../../types.ts";
 
 export type SendPreparedCallsParams = WithoutChainId<
@@ -22,6 +22,7 @@ export type SendPreparedCallsResult = Static<
  * @returns {Promise<SendPreparedCallsResult>} A Promise that resolves to the result containing the prepared call IDs
  *
  * @example
+ * ```ts
  * // First prepare the calls
  * const preparedCalls = await client.prepareCalls({
  *   calls: [{
@@ -41,6 +42,7 @@ export type SendPreparedCallsResult = Static<
  * const result = await client.sendPreparedCalls({
  *   signedCalls,
  * });
+ * ```
  */
 export async function sendPreparedCalls(
   client: InnerWalletApiClient,

package/src/client/actions/signMessage.ts

@@ -13,16 +13,19 @@ export type SignMessageResult = Hex;
  *
  * @param {InnerWalletApiClient} client - The wallet API client to use for the request
  * @param {SmartAccountSigner} signer - The signer of the smart account
- * @param {SignableMessage} message - The message to sign
+ * @param {SignMessageParams} params - Parameters for signing the message
+ * @param {SignableMessage} params.message - The message to sign using EIP-191. Can be a string, or object with raw bytes.
+ * @param {Address} [params.account] - Optional account address to use for signing. If not provided, uses the client's current account.
  * @returns {Promise<SignMessageResult>} A Promise that resolves to the signed message as a hex string
  *
  * @example
+ * ```ts
  * // Sign a simple text message
  * const signature = await client.signMessage("Hello, world!");
  *
- * @example
  * // Sign a raw hex message
  * const signature = await client.signMessage({ raw: "0x48656c6c6f2c20776f726c6421" });
+ * ```
  */
 export async function signMessage(
   client: InnerWalletApiClient,

package/src/client/actions/signPreparedCalls.ts

@@ -2,8 +2,12 @@ import type { PrepareCallsResult } from "./prepareCalls.ts";
 import type { SmartAccountSigner } from "@aa-sdk/core";
 import { signSignatureRequest } from "./signSignatureRequest.js";
 import type { Static } from "@sinclair/typebox";
-import { wallet_sendPreparedCalls } from "../../rpc/request.js";
-import { assertNever } from "../../utils.js";
+import { wallet_sendPreparedCalls } from "@alchemy/wallet-api-types/rpc";
+import {
+  type PreparedCall_Authorization,
+  type PreparedCall_UserOpV060,
+  type PreparedCall_UserOpV070,
+} from "@alchemy/wallet-api-types";
 
 export type SignPreparedCallsParams = PrepareCallsResult;
 
@@ -17,56 +21,47 @@ export type SignPreparedCallsResult = Static<
  * @param {SmartAccountSigner} signer - The signer to use
  * @param {SignPreparedCallsParams} params - The prepared calls with signature requests
  * @returns {Promise<SignPreparedCallsResult>} A Promise that resolves to the signed calls
- **/
+ */
 export async function signPreparedCalls(
   signer: SmartAccountSigner,
   params: SignPreparedCallsParams,
 ): Promise<SignPreparedCallsResult> {
-  if (params.type !== "array") {
-    const { signatureRequest, ...call } = params;
-    const signature = await signSignatureRequest(signer, signatureRequest);
+  const signAuthorizationCall = async (call: PreparedCall_Authorization) => {
+    const { signatureRequest: _signatureRequest, ...rest } = call;
+    const signature = await signSignatureRequest(signer, {
+      type: "eip7702Auth",
+      data: {
+        ...rest.data,
+        chainId: call.chainId,
+      },
+    });
     return {
-      ...call,
+      ...rest,
       signature,
     };
-  }
+  };
 
-  return {
-    type: "array" as const,
-    data: await Promise.all(
-      params.data.map(async (call) => {
-        switch (call.type) {
-          case "authorization": {
-            const { signatureRequest: _signatureRequest, ...rest } = call;
-            const signature = await signSignatureRequest(signer, {
-              type: "eip7702Auth",
-              data: {
-                ...call.data,
-                chainId: call.chainId,
-              },
-            });
-            return {
-              ...rest,
-              signature,
-            };
-          }
-          case "user-operation-v060":
-          case "user-operation-v070": {
-            const { signatureRequest, ...rest } = call;
-            const signature = await signSignatureRequest(
-              signer,
-              signatureRequest,
-            );
-            return {
-              ...rest,
-              signature,
-            };
-          }
-          default: {
-            return assertNever(call, "Unexpected call type");
-          }
-        }
-      }),
-    ),
+  const signUserOperationCall = async (
+    call: PreparedCall_UserOpV060 | PreparedCall_UserOpV070,
+  ) => {
+    const { signatureRequest, ...rest } = call;
+    const signature = await signSignatureRequest(signer, signatureRequest);
+    return {
+      ...rest,
+      signature,
+    };
   };
+
+  return params.type === "array"
+    ? {
+        type: "array" as const,
+        data: await Promise.all(
+          params.data.map((call) =>
+            call.type === "authorization"
+              ? signAuthorizationCall(call)
+              : signUserOperationCall(call),
+          ),
+        ),
+      }
+    : signUserOperationCall(params);
 }

package/src/client/actions/signSignatureRequest.ts

@@ -1,21 +1,20 @@
 import type { SmartAccountSigner } from "@aa-sdk/core";
-import type { Static } from "@sinclair/typebox";
 import { type Hex, hexToNumber, serializeSignature } from "viem";
 import { assertNever } from "../../utils.js";
 import {
-  TypeAuthorizationSignatureRequest,
-  TypePersonalSignSignatureRequest,
-  TypeTypedDataSignatureRequest,
-} from "../../schemas.js";
-import { TypeEip7702UnsignedAuth } from "../../schemas.js";
+  type PersonalSignSignatureRequest,
+  type TypedDataSignatureRequest,
+  type AuthorizationSignatureRequest,
+  type Eip7702UnsignedAuth,
+} from "@alchemy/wallet-api-types";
 import { vToYParity } from "ox/Signature";
 import type { WithoutRawPayload } from "../../types.ts";
 
 export type SignSignatureRequestParams = WithoutRawPayload<
-  | Static<typeof TypePersonalSignSignatureRequest>
-  | Static<typeof TypeTypedDataSignatureRequest>
-  | (Static<typeof TypeAuthorizationSignatureRequest> & {
-      data: Static<typeof TypeEip7702UnsignedAuth>;
+  | PersonalSignSignatureRequest
+  | TypedDataSignatureRequest
+  | (AuthorizationSignatureRequest & {
+      data: Eip7702UnsignedAuth;
     })
 >;
 
@@ -31,20 +30,17 @@ export type SignSignatureRequestResult = {
  * @param {SmartAccountSigner} signer - The signer to use for signing the request
  * @param {SignSignatureRequestParams} params - The signature request parameters
  * @param {string} params.type - The type of signature request ('personal_sign', 'eth_signTypedData_v4', or 'signature_with_authorization')
- * @param {any} params.data - The data to sign, format depends on the signature type
+ * @param {SignSignatureRequestParams["data"]} params.data - The data to sign, format depends on the signature type
  * @returns {Promise<SignSignatureRequestResult>} A Promise that resolves to the signature result
- * @returns {string} result.type - The signature type (currently only 'secp256k1' is supported)
- * @returns {Hex} result.signature - The hex-encoded signature
- * @returns {Eip7702ExtendedFields["eip7702Auth"]} result.signedAuthorization - The signed EIP-7702 authorization, if applicable
  *
  * @example
+ * ```ts
  * // Sign a personal message
  * const result = await client.signSignatureRequest({
  *   type: 'personal_sign',
  *   data: 'Hello, world!'
  * });
  *
- * @example
  * // Sign typed data (EIP-712)
  * const result = await client.signSignatureRequest({
  *   type: 'eth_signTypedData_v4',
@@ -55,6 +51,7 @@ export type SignSignatureRequestResult = {
  *     message: { ... }
  *   }
  * });
+ * ```
  */
 
 export async function signSignatureRequest(

package/src/client/actions/signTypedData.ts

@@ -19,6 +19,7 @@ export type SignTypedDataResult = Hex;
  * @returns {Promise<SignTypedDataResult>} A Promise that resolves to the signature as a hex string
  *
  * @example
+ * ```ts
  * // Sign typed data
  * const signature = await client.signTypedData({
  *   domain: {
@@ -39,6 +40,7 @@ export type SignTypedDataResult = Hex;
  *     wallet: '0xAaAaAaAaAaAaAaAaAaAAAAAAAAaaaAaAaAaaAaAa'
  *   }
  * });
+ * ```
  */
 export async function signTypedData(
   client: InnerWalletApiClient,