Run a relayer

RELAYER_PRIVATE_KEY=0xyour_relayer_private_key
FORWARDER=0x9bAb837f41759c737Cb2cC00Ec5D88d5fAcF74C1
TARGET=0x7962412A92E5553E66C794c3a352422DEB7BAc27

import { createServer } from "node:http";
import { createPublicClient, createWalletClient, getAddress, http, parseAbi, toFunctionSelector, type Hex } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { botChainTestnet } from "@uzolabs/sdk/chains";

const FORWARDER = getAddress(process.env.FORWARDER as string);
const TARGET = getAddress(process.env.TARGET as string); // The only contract this relayer pays for
const ALLOWED_SELECTORS = [toFunctionSelector("sign(string)")]; // The only functions it pays for
const MAX_GAS = 300_000n; // The most gas one request may ask for
const RATE_LIMIT = 10; // Requests per signer and per IP address
const RATE_WINDOW_MS = 60 * 60 * 1000; // Per hour

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)",
]);

const account = privateKeyToAccount(process.env.RELAYER_PRIVATE_KEY as Hex);
const transport = http(process.env.RPC_URL); // Blank uses the chain's default RPC
const publicClient = createPublicClient({ chain: botChainTestnet, transport });
const walletClient = createWalletClient({ account, chain: botChainTestnet, transport });

// A simple in-memory sliding window. Use a shared store if you run more than one relayer.
const hits = new Map<string, number[]>();
function overLimit(key: string): boolean {
  const now = Date.now();
  const recent = (hits.get(key) ?? []).filter((t) => t > now - RATE_WINDOW_MS);
  recent.push(now);
  hits.set(key, recent);
  return recent.length > RATE_LIMIT;
}

// Send one transaction at a time, so two requests never use the same relayer nonce.
let queue: Promise<unknown> = Promise.resolve();
function serial<T>(task: () => Promise<T>): Promise<T> {
  const next = queue.then(task, task);
  queue = next.catch(() => undefined);
  return next;
}

class Refused extends Error {
  constructor(readonly status: number, message: string) { super(message); }
}

async function relay(body: any, ip: string) {
  const r = body?.request;
  if (!r || typeof r !== "object") throw new Refused(400, 'Send JSON like { "request": { ... } }');
  const request = {
    from: getAddress(r.from),
    to: getAddress(r.to),
    value: BigInt(r.value),
    gas: BigInt(r.gas),
    deadline: Number(r.deadline),
    data: r.data as Hex,
    signature: r.signature as Hex,
  };

  // 1. Allowlists and limits. Nothing here touches the chain.
  if (request.to !== TARGET) throw new Refused(403, "This relayer doesn't pay for that contract");
  if (!ALLOWED_SELECTORS.includes(request.data.slice(0, 10).toLowerCase() as Hex)) throw new Refused(403, "This relayer doesn't pay for that function");
  if (request.value !== 0n) throw new Refused(400, "value must be 0");
  if (request.gas === 0n || request.gas > MAX_GAS) throw new Refused(400, `gas must be between 1 and ${MAX_GAS}`);
  if (!Number.isSafeInteger(request.deadline) || request.deadline < Date.now() / 1000) throw new Refused(400, "The request has expired");
  if (overLimit(`signer:${request.from}`) || overLimit(`ip:${ip}`)) throw new Refused(429, "Too many requests");

  // 2. Let the forwarder check the signature, nonce and deadline, then dry-run it.
  const valid = await publicClient.readContract({ address: FORWARDER, abi: forwarderAbi, functionName: "verify", args: [request] });
  if (!valid) throw new Refused(400, "The signature doesn't match the request");
  const { request: tx } = await publicClient.simulateContract({ account, address: FORWARDER, abi: forwarderAbi, functionName: "execute", args: [request] });

  // 3. Send and wait.
  const hash = await serial(() => walletClient.writeContract(tx));
  const receipt = await publicClient.waitForTransactionReceipt({ hash, timeout: 60_000 });
  return { txHash: hash, status: receipt.status };
}

const server = createServer(async (req, res) => {
  const reply = (status: number, body: unknown) => {
    res.writeHead(status, { "content-type": "application/json" });
    res.end(JSON.stringify(body));
  };
  if (req.method === "GET" && req.url === "/health") {
    const balance = await publicClient.getBalance({ address: account.address });
    return reply(200, { relayer: account.address, balance: balance.toString() });
  }
  if (req.method !== "POST" || req.url !== "/relay") return reply(404, { error: "Not found" });

  let raw = "";
  for await (const chunk of req) {
    raw += chunk;
    if (raw.length > 8_192) return reply(413, { error: "Body too large" });
  }
  try {
    reply(200, await relay(JSON.parse(raw), req.socket.remoteAddress ?? "unknown"));
  } catch (error) {
    if (error instanceof Refused) return reply(error.status, { error: error.message });
    reply(400, { error: (error as { shortMessage?: string }).shortMessage ?? "Bad request" });
  }
});

server.listen(8787, () => console.log(`Relayer ${account.address} listening on http://localhost:8787`));

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

const FORWARDER = process.env.FORWARDER as `0x${string}`;
const TARGET = process.env.TARGET as `0x${string}`;
const RELAYER_URL = process.env.RELAYER_URL ?? "http://localhost:8787";

const forwarderAbi = parseAbi([
  "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)"]);
const types = {
  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(process.env.RPC_URL) });
const user = privateKeyToAccount(generatePrivateKey()); // A new wallet with no tBOT

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: TARGET,
  value: 0n,
  gas: 150_000n,
  nonce,
  deadline: Math.floor(Date.now() / 1000) + 10 * 60,
  data: encodeFunctionData({ abi: guestBookAbi, functionName: "sign", args: ["gm through my relayer"] }),
};
const signature = await user.signTypedData({
  domain: { name, version, chainId: Number(chainId), verifyingContract },
  types,
  primaryType: "ForwardRequest",
  message,
});

// JSON has no bigint, so send numbers as strings. The forwarder reads the nonce itself.
const { nonce: _, ...rest } = message;
const request = { ...rest, value: "0", gas: rest.gas.toString(), deadline: String(rest.deadline), signature };
const response = await fetch(`${RELAYER_URL}/relay`, {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify({ request }),
});
console.log(response.status, await response.json());

FORWARDER=0x9bAb837f41759c737Cb2cC00Ec5D88d5fAcF74C1
TARGET=0x7962412A92E5553E66C794c3a352422DEB7BAc27