Meta-transactions

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

import {ERC2771Forwarder} from "@openzeppelin/contracts/metatx/ERC2771Forwarder.sol";

contract Forwarder is ERC2771Forwarder {
    constructor() ERC2771Forwarder("MyForwarder") {}
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

import {ERC2771Context} from "@openzeppelin/contracts/metatx/ERC2771Context.sol";

contract Notes is ERC2771Context {
    mapping(address => string) public noteOf;

    event NoteSet(address indexed author, string note);

    constructor(address trustedForwarder) ERC2771Context(trustedForwarder) {}

    function setNote(string calldata note) external {
        // _msgSender() is the user who signed, even when the relayer sent the transaction.
        address author = _msgSender();
        noteOf[author] = note;
        emit NoteSet(author, note);
    }
}

import { createPublicClient, createWalletClient, encodeFunctionData, http, parseAbi } from "viem";
import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
import { botChainTestnet } from "@uzolabs/sdk/chains";

const FORWARDER = "0x9bAb837f41759c737Cb2cC00Ec5D88d5fAcF74C1";
const GUEST_BOOK = "0x7962412A92E5553E66C794c3a352422DEB7BAc27";

const forwarderAbi = parseAbi([
  "struct ForwardRequestData { address from; address to; uint256 value; uint256 gas; uint48 deadline; bytes data; bytes signature; }",
  "function execute(ForwardRequestData request) payable",
  "function verify(ForwardRequestData request) view returns (bool)",
  "function nonces(address owner) view returns (uint256)",
  "function eip712Domain() view returns (bytes1 fields, string name, string version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] extensions)",
]);
const guestBookAbi = parseAbi([
  "function sign(string message) returns (uint256 id)",
  "function entryCount() view returns (uint256)",
]);
const forwardRequestTypes = {
  ForwardRequest: [
    { name: "from", type: "address" },
    { name: "to", type: "address" },
    { name: "value", type: "uint256" },
    { name: "gas", type: "uint256" },
    { name: "nonce", type: "uint256" },
    { name: "deadline", type: "uint48" },
    { name: "data", type: "bytes" },
  ],
} as const;

const publicClient = createPublicClient({ chain: botChainTestnet, transport: http() });

// The user: a brand new key with no tBOT at all. It only signs.
const user = privateKeyToAccount(generatePrivateKey());
// The relayer: a funded key that pays the gas.
const relayer = createWalletClient({
  account: privateKeyToAccount(process.env.BOT_PRIVATE_KEY as `0x${string}`),
  chain: botChainTestnet,
  transport: http(),
});

// 1. User side: build and sign the request.
const [[, name, version, chainId, verifyingContract], nonce] = await Promise.all([
  publicClient.readContract({ address: FORWARDER, abi: forwarderAbi, functionName: "eip712Domain" }),
  publicClient.readContract({ address: FORWARDER, abi: forwarderAbi, functionName: "nonces", args: [user.address] }),
]);
const message = {
  from: user.address,
  to: GUEST_BOOK,
  value: 0n,
  gas: 150_000n,
  nonce,
  deadline: Math.floor(Date.now() / 1000) + 10 * 60,
  data: encodeFunctionData({ abi: guestBookAbi, functionName: "sign", args: ["Signed for free via the Uzo docs"] }),
} as const;
const signature = await user.signTypedData({
  domain: { name, version, chainId: Number(chainId), verifyingContract },
  types: forwardRequestTypes,
  primaryType: "ForwardRequest",
  message,
});
console.log(`User ${user.address} signed (balance: ${await publicClient.getBalance({ address: user.address })} wei)`);

// 2. Relayer side: check, simulate, send.
const { nonce: _nonce, ...rest } = message;
const request = { ...rest, signature };
const valid = await publicClient.readContract({ address: FORWARDER, abi: forwarderAbi, functionName: "verify", args: [request] });
if (!valid) throw new Error("Signature does not match the request");

const { request: tx } = await publicClient.simulateContract({
  account: relayer.account,
  address: FORWARDER,
  abi: forwarderAbi,
  functionName: "execute",
  args: [request],
});
const hash = await relayer.writeContract(tx);
const receipt = await publicClient.waitForTransactionReceipt({ hash });
console.log(`Relayed ${receipt.status}: ${botChainTestnet.blockExplorers.default.url}/tx/${hash}`);
console.log(`Gas used: ${receipt.gasUsed}`);
console.log(`Entries now: ${await publicClient.readContract({ address: GUEST_BOOK, abi: guestBookAbi, functionName: "entryCount" })}`);