EIP-712

eip-712.ts

import { ethers, verifyTypedData, JsonRpcProvider, Wallet, TypedDataField } from "ethers";

interface IProviderAndSigner {
  provider: JsonRpcProvider;
  signer: Wallet;
}

interface IDomain {
  name: string,
  version: string,
};

async function getProviderAndSigner(): Promise<IProviderAndSigner> {
  const provider: JsonRpcProvider = new ethers.JsonRpcProvider("{RPC_URL}");
  const signer: Wallet = new ethers.Wallet("{PRIVATE_KEY}", provider);
  return { provider, signer };
}

interface Auth {
  nick: string;
}

function constructMessage(nick: string): Auth {
  return { nick };
}

async function signTransaction(
  signer: Wallet,
  domain: IDomain,
  types: Record<string, TypedDataField[]>,
  message: Auth
): Promise<string> {
  return await signer.signTypedData(domain, types, message);
}

async function verifySignature(
  domain: IDomain,
  types: Record<string, TypedDataField[]>,
  message: Auth,
  signature: string
): Promise<string> {
  return verifyTypedData(domain, types, message, signature);
}

async function main(): Promise<void> {
  const { provider, signer } = await getProviderAndSigner();

  const types: Record<string, TypedDataField[]> = {
    Auth: [
      {
        name: "nick",
        type: "string",
      },
    ],
  };

  const domain: IDomain = {
    name: "EIP712Authentication",
    version: "1.0.0",
  };

  const message: Auth = constructMessage("Unknown");
  const signature: string = await signTransaction(signer, domain, types, message);

  console.log("Signature:", signature);

  const r = signature.slice(0, 66);
    const s = "0x" + signature.slice(66, 130);
    const v = parseInt(signature.slice(130, 132), 16);
    console.log({ r, s, v });

  const signerAddress: string = await verifySignature(domain, types, message, signature);
  console.log("Signer address in the signature is:", signerAddress);
  console.log("Signer address is:", signer.address);
}

main().catch((error: Error) => {
  console.error(error);
  process.exitCode = 1;
});