useSignMessage | Alchemy Docs

Custom hook to sign a message using the provided client. Provides a way to sign messages within the context of an account using Ethereum-specific signature in EIP-191 format. Uses personal_sign to sign arbitrary messages (usually strings). Accepts any plain message as input.

Until the method completes, isSigningMessage is true and signedMessage is null until eventually returning either a 1271 or 6492 signature (if the smart contract account has not been deployed yet), which is useful if you need to render the signature to the UI. signedMessageAsync is useful over signedMessage if you need to chain calls together.

Using 1271 validation, the mechanisms by which you can validate the smart contract account, we verify the message was signed by the smart contract itself rather than the EOA signer.

To reiterate, the signature that is returned must be verified against the account itself not the signer. The final structure of the signature is dictated by how the account does 1271 validation. You don’t want to be verifying in a different way than the way the account itself structures the signatures to be validated. For example LightAccount has three different ways to validate the account.

Import

1 import { useSignMessage } from "@account-kit/react";

Usage

import { function useSignMessage({ client, ...mutationArgs }: UseSignMessageArgs): UseSignMessageResultCustom hook to sign a message using the provided client. Provides a way to sign messages within the context of an account using Ethereum-specific signature in EIP-191 format. Uses personal_sign to sign arbitrary messages (usually strings). Accepts any plain message as input.
Until the method completes, isSigningMessage is true and signedMessage is null until eventually returning either a 1271 or 6492 signature (if the smart contract account has not been deployed yet), which is useful if you need to render the signature to the UI. signedMessageAsync is useful over signedMessage if you need to chain calls together.
Using 1271 validation, the mechanisms by which you can validate the smart contract account, we verify the message was signed by the smart contract itself rather than the EOA signer.
To reiterate, the signature that is returned must be verified against the account itself not the signer. The final structure of the signature is dictated by how the account does 1271 validation. You don’t want to be verifying in a different way than the way the account itself structures the signatures to be validated. For example LightAccount has three different ways to validate the account.
useSignMessage, function useSmartAccountClient<TChain extends Chain | undefined = Chain | undefined, TAccount extends SupportedAccountTypes | undefined = "ModularAccountV2">(args: UseSmartAccountClientProps<TChain, TAccount>): UseSmartAccountClientResult<TChain, SupportedAccount<TAccount extends undefined ? "ModularAccountV2" : TAccount>>
useSmartAccountClient } from "@account-kit/react";
const const data: "messageToSign"
data = "messageToSign";
const { const client: {
    account: ModularAccountV2<AlchemySigner>;
    batch?: {
        multicall?: boolean | Prettify<MulticallBatchOptions> | undefined;
    } | undefined;
    ... 84 more ...;
    extend: <const client extends {
        ...;
    } & ExactPartial<...>>(fn: (client: Client<...>) => client) => Client<...>;
} | undefined
client } = useSmartAccountClient<Chain | undefined, "ModularAccountV2">(args: UseSmartAccountClientProps<Chain | undefined, "ModularAccountV2">): UseSmartAccountClientResult<Chain | undefined, ModularAccountV2<...>>
useSmartAccountClient({});

const {
  const signMessage: UseMutateFunction<`0x${string}`, Error, SignMessageArgs, unknown>
signMessage,
  const signMessageAsync: UseMutateAsyncFunction<`0x${string}`, Error, SignMessageArgs, unknown>
signMessageAsync,
  const signedMessage: `0x${string}` | undefined
signedMessage,
  const isSigningMessage: boolean
isSigningMessage,
  const error: Error | null
error,
} = function useSignMessage({ client, ...mutationArgs }: UseSignMessageArgs): UseSignMessageResultCustom hook to sign a message using the provided client. Provides a way to sign messages within the context of an account using Ethereum-specific signature in EIP-191 format. Uses personal_sign to sign arbitrary messages (usually strings). Accepts any plain message as input.
Until the method completes, isSigningMessage is true and signedMessage is null until eventually returning either a 1271 or 6492 signature (if the smart contract account has not been deployed yet), which is useful if you need to render the signature to the UI. signedMessageAsync is useful over signedMessage if you need to chain calls together.
Using 1271 validation, the mechanisms by which you can validate the smart contract account, we verify the message was signed by the smart contract itself rather than the EOA signer.
To reiterate, the signature that is returned must be verified against the account itself not the signer. The final structure of the signature is dictated by how the account does 1271 validation. You don’t want to be verifying in a different way than the way the account itself structures the signatures to be validated. For example LightAccount has three different ways to validate the account.
useSignMessage({
  client: {
    account: SupportedAccounts;
    batch?: {
        multicall?: boolean | Prettify<MulticallBatchOptions> | undefined;
    } | undefined;
    ... 84 more ...;
    extend: <const client extends {
        ...;
    } & ExactPartial<...>>(fn: (client: Client<...>) => client) => Client<...>;
} | {
    ...;
} | {
    ...;
} | {
    ...;
} | undefined
client,
  // these are optional
  onSuccess?: ((data: `0x${string}`, variables: SignMessageArgs, context: unknown) => Promise<unknown> | unknown) | undefined
onSuccess: (result: `0x${string}`
result) => {
    // do something on success
  },
  onError?: ((error: Error, variables: SignMessageArgs, context: unknown) => Promise<unknown> | unknown) | undefined
onError: (error: Error
error) => var console: ConsoleThe console module provides a simple debugging console that is similar to the JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream. * A global console instance configured to write to process.stdout and process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently synchronous like the browser APIs they resemble, nor are they consistently asynchronous like all other Node.js streams. See the note on process I/O for more information.
Example using the global console:

const name = 'Will Robinson'; console.warn(`Danger $name! Danger!`); // Prints: Danger Will Robinson! Danger!, to stderr ```

Example using the `Console` class:

```js const out = getStreamSomehow(); const err = getStreamSomehow(); const myConsole = new console.Console(out, err);

myConsole.log('hello world'); // Prints: hello world, to out myConsole.log('hello %s', 'world'); // Prints: hello world, to out myConsole.error(new Error('Whoops, something bad happened')); // Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson'; myConsole.warn(`Danger $name! Danger!`); // Prints: Danger Will Robinson! Danger!, to err ```
console.Console.error(message?: any, ...optionalParams: any[]): void (+1 overload)Prints to stderr with newline. Multiple arguments can be passed, with the first used as the primary message and all additional used as substitution values similar to printf(3) (the arguments are all passed to util.format()).
js const code = 5; console.error('error #%d', code); // Prints: error #5, to stderr console.error('error', code); // Prints: error 5, to stderr 
If formatting elements (e.g. %d) are not found in the first string then util.inspect() is called on each argument and the resulting string values are concatenated. See util.format() for more information.
error(error: Error
error),
});

const const result: void
result = await const signMessage: (variables: SignMessageArgs, options?: MutateOptions<`0x${string}`, Error, SignMessageArgs, unknown> | undefined) => void
signMessage({ message: SignableMessage
message: const data: "messageToSign"
data });

Parameters

config

UseSignMessageArgs The configuration arguments for the hook, including the client and additional mutation arguments. ref

Returns

UseSignMessageResult An object containing methods and state for signing messages. ref