or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

account-chain-state.mdadvanced-features.mdblockchain-data-reading.mdconfiguration.mdconnection-management.mdcontract-interactions.mdens-operations.mdevent-watching.mdindex.mdsigning-verification.mdtanstack-query.mdtransaction-management.md
tile.json

signing-verification.mddocs/

Signing & Verification

Message and typed data signing with EIP-712 support. Essential for authentication and authorization flows.

Capabilities

Sign Message

Signs arbitrary messages for authentication and verification.

/**
 * Signs an arbitrary message
 * @param config - Wagmi configuration
 * @param parameters - Sign message parameters
 * @returns Message signature
 */
function signMessage<config extends Config>(
  config: config,
  parameters: SignMessageParameters<config>
): Promise<SignMessageReturnType>;

interface SignMessageParameters<config extends Config> {
  /** Message to sign (string or hex) */
  message: string | Hex;
  /** Account to sign with (optional, uses connected account) */
  account?: Address;
  /** Chain ID */
  chainId?: config['chains'][number]['id'];
}

type SignMessageReturnType = Hex; // Signature

type SignMessageErrorType = 
  | BaseErrorType
  | UserRejectedRequestErrorType;

Usage Example:

import { signMessage } from '@wagmi/core'

const signature = await signMessage(config, {
  message: 'Hello, wagmi!',
})
console.log('Signature:', signature)

// Sign hex message
const hexSignature = await signMessage(config, {
  message: '0x48656c6c6f2c20776167692021', // "Hello, wagmi!" in hex
})

Sign Typed Data (EIP-712)

Signs structured data according to EIP-712 standard.

/**
 * Signs EIP-712 typed data
 * @param config - Wagmi configuration
 * @param parameters - Sign typed data parameters
 * @returns Typed data signature
 */
function signTypedData<config extends Config>(
  config: config,
  parameters: SignTypedDataParameters<config>
): Promise<SignTypedDataReturnType>;

interface SignTypedDataParameters<config extends Config> {
  /** EIP-712 domain */
  domain?: {
    name?: string;
    version?: string;
    chainId?: number;
    verifyingContract?: Address;
    salt?: Hex;
  };
  /** Type definitions */
  types: Record<string, Array<{ name: string; type: string }>>;
  /** Primary type name */
  primaryType: string;
  /** Message data to sign */
  message: Record<string, any>;
  /** Account to sign with */
  account?: Address;
  /** Chain ID */
  chainId?: config['chains'][number]['id'];
}

type SignTypedDataReturnType = Hex; // Signature

type SignTypedDataErrorType = 
  | BaseErrorType
  | UserRejectedRequestErrorType;

Usage Example:

import { signTypedData } from '@wagmi/core'

const signature = await signTypedData(config, {
  domain: {
    name: 'MyApp',
    version: '1',
    chainId: 1,
    verifyingContract: '0x...',
  },
  types: {
    Person: [
      { name: 'name', type: 'string' },
      { name: 'wallet', type: 'address' },
    ],
  },
  primaryType: 'Person',
  message: {
    name: 'Alice',
    wallet: '0x...',
  },
})
console.log('EIP-712 signature:', signature)

Verify Message

Verifies signed messages.

/**
 * Verifies a signed message
 * @param config - Wagmi configuration
 * @param parameters - Verify parameters
 * @returns Verification result
 */
function verifyMessage<config extends Config>(
  config: config,
  parameters: VerifyMessageParameters<config>
): Promise<VerifyMessageReturnType>;

interface VerifyMessageParameters<config extends Config> {
  /** Original message */
  message: string | Hex;
  /** Message signature */
  signature: Hex;
  /** Expected signer address */
  address: Address;
  /** Chain ID */
  chainId?: config['chains'][number]['id'];
}

type VerifyMessageReturnType = boolean;

type VerifyMessageErrorType = BaseErrorType;

Verify Typed Data

Verifies EIP-712 signed typed data.

/**
 * Verifies EIP-712 signed typed data
 * @param config - Wagmi configuration
 * @param parameters - Verify typed data parameters
 * @returns Verification result
 */
function verifyTypedData<config extends Config>(
  config: config,
  parameters: VerifyTypedDataParameters<config>
): Promise<VerifyTypedDataReturnType>;

interface VerifyTypedDataParameters<config extends Config> {
  /** EIP-712 domain */
  domain?: {
    name?: string;
    version?: string;
    chainId?: number;
    verifyingContract?: Address;
    salt?: Hex;
  };
  /** Type definitions */
  types: Record<string, Array<{ name: string; type: string }>>;
  /** Primary type name */
  primaryType: string;
  /** Original message data */
  message: Record<string, any>;
  /** Signature to verify */
  signature: Hex;
  /** Expected signer address */
  address: Address;
  /** Chain ID */
  chainId?: config['chains'][number]['id'];
}

type VerifyTypedDataReturnType = boolean;

type VerifyTypedDataErrorType = BaseErrorType;

Usage Example:

import { verifyMessage, verifyTypedData } from '@wagmi/core'

// Verify message signature
const isValidMessage = await verifyMessage(config, {
  message: 'Hello, wagmi!',
  signature: '0x...',
  address: '0x...',
})

// Verify EIP-712 signature
const isValidTypedData = await verifyTypedData(config, {
  domain: {
    name: 'MyApp',
    version: '1',
    chainId: 1,
    verifyingContract: '0x...',
  },
  types: {
    Person: [
      { name: 'name', type: 'string' },
      { name: 'wallet', type: 'address' },
    ],
  },
  primaryType: 'Person',
  message: {
    name: 'Alice',
    wallet: '0x...',
  },
  signature: '0x...',
  address: '0x...',
})

console.log('Message valid:', isValidMessage)
console.log('Typed data valid:', isValidTypedData)