Deploy and interact with smart contracts

curl -L https://foundry.paradigm.xyz | bash
foundryup

forge install tempoxyz/tempo-std

[profile.default]
tempo = true

[profile.default]
src = "src"
out = "out"
libs = ["lib"]
solc_version = "0.8.30"
# NVNM Chain runs Tempo EVM (tempo/v1.14.x); Osaka opcodes (incl. CLZ) verified on devnet.
evm_version = "osaka"
optimizer = true
optimizer_runs = 200
via_ir = true

# NVNM Chain NEXT L1 — keep in sync with apps/web/src/config/chains.ts
[rpc_endpoints]
nvnm_testnet = "https://rpc.nvnm.testnet.nvnmchain.io" # chain id 787223
nvnm_devnet = "https://rpc.nvnm.canary.mantrachain.dev" # chain id 787222

# ...

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

/// @title CheckIn (打卡)
/// @notice Each address can check in once with a short text. The record is immutable and carries its
///         1-based position in the global check-in order.
contract CheckIn {
    /// @notice Maximum text length in bytes (UTF-8), not characters: a CJK character takes 3 bytes.
    uint256 public constant MAX_TEXT_LENGTH = 128;

    struct Record {
        string text;
        uint256 index;
    }

    /// @notice Number of check-ins so far; also the index of the most recent one.
    uint256 public totalCheckIns;

    mapping(address => Record) private _records;

    event CheckedIn(address indexed user, uint256 indexed index, string text);

    error AlreadyCheckedIn(address user, uint256 index);
    error TextTooLong(uint256 length, uint256 maxLength);

    /// @notice Records `text` for the caller. Reverts if the caller has already checked in.
    /// @return index The caller's position in the check-in order, starting from 1.
    function checkIn(string calldata text) external returns (uint256 index) {
        uint256 existing = _records[msg.sender].index;
        if (existing != 0) revert AlreadyCheckedIn(msg.sender, existing);
        uint256 length = bytes(text).length;
        if (length > MAX_TEXT_LENGTH) revert TextTooLong(length, MAX_TEXT_LENGTH);

        index = ++totalCheckIns;
        _records[msg.sender] = Record(text, index);
        emit CheckedIn(msg.sender, index, text);
    }

    /// @notice Returns `user`'s check-in. An `index` of 0 means `user` has not checked in.
    function getCheckIn(address user) external view returns (string memory text, uint256 index) {
        Record storage record = _records[user];
        return (record.text, record.index);
    }
}

forge build
forge test -vvv

# Start anvil in Tempo mode
anvil --tempo

# Fork a live network for local testing
anvil --tempo --fork-url $RPC_URL

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

import { Script, console } from "forge-std/Script.sol";
import { CheckIn } from "../src/CheckIn.sol";

/// @notice Deploys CheckIn with CREATE2 through the deterministic deployer (0x4e59b448…956C), so the address
///         depends only on the salt and the bytecode and is the same on every chain.
contract CheckInScript is Script {
    bytes32 public constant DEFAULT_SALT = keccak256("nvnm-demo-dapp.CheckIn");

    CheckIn public checkIn;

    function setUp() public { }

    function run() public {
        // Forge loads packages/contracts/.env. Set CHECKIN_SALT to deploy a fresh instance.
        bytes32 salt = vm.envOr("CHECKIN_SALT", DEFAULT_SALT);
        address expected = vm.computeCreate2Address(salt, keccak256(type(CheckIn).creationCode));
        if (expected.code.length != 0) {
            console.log("CheckIn already deployed at", expected);
            checkIn = CheckIn(expected);
            return;
        }

        // Without DEPLOYER_PRIVATE_KEY, broadcast as the default sender: `--account <keystore>` if given,
        // otherwise anvil's prefunded account #0.
        uint256 deployerKey = vm.envOr("DEPLOYER_PRIVATE_KEY", uint256(0));
        if (deployerKey == 0) vm.startBroadcast();
        else vm.startBroadcast(deployerKey);

        checkIn = new CheckIn{ salt: salt }();

        vm.stopBroadcast();
        console.log("CheckIn deployed at", address(checkIn));
    }
}

# Check that the contract is deployed
cast code 0xDF0555AFd6573Ad1426ACa5f834A3E1bfee71a49 \
  --rpc-url https://rpc.nvnm.canary.mantrachain.dev

# Read the total number of check-ins
cast call 0xDF0555AFd6573Ad1426ACa5f834A3E1bfee71a49 "totalCheckIns()(uint256)" \
  --rpc-url https://rpc.nvnm.canary.mantrachain.dev

import { defineConfig } from "@wagmi/cli";
import { foundry } from "@wagmi/cli/plugins";

// Generates typed ABIs from the Foundry project into src/generated.ts.
// Run `vp run web#codegen` after changing contracts.
export default defineConfig({
  out: "src/generated.ts",
  plugins: [
    foundry({
      project: "../../packages/contracts",
      include: ["CheckIn.sol/**"],
      // Deployed addresses per chain id. CheckIn uses CREATE2, so the address is the same on every chain.
      deployments: {
        CheckIn: {
          787222: "0xDF0555AFd6573Ad1426ACa5f834A3E1bfee71a49",
          787223: "0xDF0555AFd6573Ad1426ACa5f834A3E1bfee71a49",
        },
      },
    }),
  ],
});

export const checkInAbi = [
  // ...
  {
    type: 'function',
    inputs: [{ name: 'text', internalType: 'string', type: 'string' }],
    name: 'checkIn',
    outputs: [{ name: 'index', internalType: 'uint256', type: 'uint256' }],
    stateMutability: 'nonpayable',
  },
  // ...
] as const

// ...
export const checkInAddress = {
  787222: '0xDF0555AFd6573Ad1426ACa5f834A3E1bfee71a49',
  787223: '0xDF0555AFd6573Ad1426ACa5f834A3E1bfee71a49',
} as const

import type { Address } from "viem";
import { useReadContract } from "wagmi";

import type { SupportedChainId } from "@/config/wagmi";
import { checkInAbi, checkInAddress } from "@/generated";

// Reads of the CheckIn contract (`packages/contracts/src/CheckIn.sol`), deployed at one CREATE2 address on every
// supported chain. Each passes the same query options wherever it's called, so wagmi shares one query per chain (and
// account).

// The account's check-in as `[text, index]`; an index of 0 means it hasn't checked in. Polled while it hasn't, so a
// check-in made elsewhere (another tab, or a node that lagged behind the receipt) still shows up; a check-in can't
// change afterwards.
export function useCheckInRecord(account: Address, chainId: SupportedChainId) {
  return useReadContract({
    address: checkInAddress[chainId],
    abi: checkInAbi,
    functionName: "getCheckIn",
    args: [account],
    chainId,
    query: {
      refetchInterval: (query) => (query.state.data?.[1] ? false : 4_000),
      retry: 1,
    },
  });
}

// How many addresses have checked in on the chain. Polled (not `watch`, whose errors never reach the query result) so
// other people's check-ins show up.
export function useTotalCheckIns(chainId: SupportedChainId) {
  return useReadContract({
    address: checkInAddress[chainId],
    abi: checkInAbi,
    functionName: "totalCheckIns",
    chainId,
    query: { refetchInterval: 4_000, retry: 1 },
  });
}

// The contract's text limit, in UTF-8 bytes. A constant, so it's read once per chain.
export function useCheckInMaxLength(chainId: SupportedChainId) {
  return useReadContract({
    address: checkInAddress[chainId],
    abi: checkInAbi,
    functionName: "MAX_TEXT_LENGTH",
    chainId,
    query: { staleTime: Infinity, select: Number },
  });
}

const encoder = new TextEncoder();

// The length CheckIn limits: `bytes(text).length`, the UTF-8 encoding's length. Not `text.length`, which counts UTF-16
// code units: "打卡" is 2 of those but 6 bytes, and an emoji is 2 code units but 4 bytes.
export function utf8ByteLength(text: string): number {
  return encoder.encode(text).length;
}

// ...

function AccountCheckIn({ account, chain }: { account: Address; chain: SupportedChain }) {
  // ...
  const record = useCheckInRecord(account, chain.id);
  const { refetch: refetchRecord } = record;
  const { refetch: refetchTotal } = useTotalCheckIns(chain.id);
  const write = useWriteContract();
  // Shares the queries TxResultDialog runs for the same hash.
  const outcome = useTxOutcome(write.data, chain.id);

  // Show the new record and count as soon as the check-in confirms, rather than at the next poll. The result dialog
  // lives here, not in the form, so it stays open when the record replaces the form.
  const confirmed = outcome === "success";
  useEffect(() => {
    if (!confirmed) return;
    void refetchRecord();
    void refetchTotal();
  }, [confirmed, refetchRecord, refetchTotal]);

  function submit(text: string) {
    setSubmitted(text);
    write.mutate(
      {
        address: checkInAddress[chain.id],
        abi: checkInAbi,
        functionName: "checkIn",
        args: [text],
        chainId: chain.id,
      },
      { onSuccess: () => setResultOpen(true) },
    );
  }
  // ...
}

import { BaseError, type Hash } from "viem";
import { useTransactionReceipt, useWaitForTransactionReceipt } from "wagmi";

import type { SupportedChainId } from "@/config/wagmi";

export type TxOutcome = "pending" | "success" | "reverted" | "unknown";

// What became of a submitted transaction. wagmi's `waitForTransactionReceipt` never returns a reverted receipt: it
// replays the call and throws the revert reason as a plain `Error`. So a revert surfaces as an error, and the default
// retries would replay it three more times; only viem's own errors (RPC failures, timeouts) are retried. After a failed
// wait the receipt itself is fetched, which keeps its status: a revert, or a success the wait lost to an RPC error.
// Every caller passes the same options, so wagmi shares one query per hash.
export function useTxOutcome(hash: Hash | undefined, chainId: SupportedChainId): TxOutcome {
  const wait = useWaitForTransactionReceipt({
    hash,
    chainId,
    query: { retry: (failures, error) => error instanceof BaseError && failures < 3 },
  });
  const receipt = useTransactionReceipt({ hash, chainId, query: { enabled: wait.isError } });

  if (wait.isSuccess) return "success";
  if (!wait.isError) return "pending";
  if (receipt.data?.status === "success" || receipt.data?.status === "reverted")
    return receipt.data.status;
  return receipt.isFetching ? "pending" : "unknown";
}

const known: [matches: (error: ErrorLike) => boolean, message: string][] = [
  // ...
  // CheckIn's custom errors. The node reports a bare "execution reverted"; viem names the error once it decodes the
  // revert data with `checkInAbi`.
  [
    (e) => revertedWith(e, "AlreadyCheckedIn"),
    "This account has already checked in. Each address can check in once.",
  ],
  [
    (e) => revertedWith(e, "TextTooLong"),
    "The text is longer than the contract allows. Shorten it a little.",
  ],
];

// ...

// Whether viem decoded a revert to the custom error `name`, from an ABI that declares it.
function revertedWith(error: ErrorLike, name: string): boolean {
  return (
    error.name === "ContractFunctionRevertedError" &&
    (error.data as { errorName?: unknown } | undefined)?.errorName === name
  );
}