Work without eth_getLogs

import { parseAbi } from "viem";
import { useReadContract } from "wagmi";
import { botChainTestnet } from "@uzolabs/sdk/chains";

const GUEST_BOOK = "0x7962412A92E5553E66C794c3a352422DEB7BAc27";
const guestBookAbi = parseAbi([
  "struct Entry { address author; uint64 timestamp; string message; }",
  "function entryCount() view returns (uint256)",
  "function getEntries(uint256 offset, uint256 limit) view returns (Entry[])",
]);

export function LatestEntries() {
  const count = useReadContract({
    address: GUEST_BOOK,
    abi: guestBookAbi,
    functionName: "entryCount",
    chainId: botChainTestnet.id,
    query: { refetchInterval: 5_000 },
  });

  const total = count.data ?? 0n;
  const offset = total > 10n ? total - 10n : 0n;

  const entries = useReadContract({
    address: GUEST_BOOK,
    abi: guestBookAbi,
    functionName: "getEntries",
    args: [offset, 10n],
    chainId: botChainTestnet.id,
    query: { enabled: count.isSuccess },
  });

  return (
    <ul>
      {[...(entries.data ?? [])].reverse().map((entry, i) => (
        <li key={i}>
          {entry.author.slice(0, 8)}: {entry.message}
        </li>
      ))}
    </ul>
  );
}

import { createPublicClient, http, parseAbi, parseEventLogs } from "viem";
import { botChainTestnet } from "@uzolabs/sdk/chains";

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

const guestBookAbi = parseAbi(["event Signed(uint256 indexed id, address indexed author, string message)"]);

// The hash of a transaction you sent, for example from useWriteContract.
const hash = process.env.TX_HASH as `0x${string}`;
if (!hash) throw new Error("Set TX_HASH to a transaction hash");

const receipt = await client.waitForTransactionReceipt({ hash });
const events = parseEventLogs({ abi: guestBookAbi, logs: receipt.logs, eventName: "Signed" });

for (const event of events) {
  console.log(`Entry ${event.args.id} by ${event.args.author}: ${event.args.message}`);
}

Entry 1 by 0xa2fa3D8d...: Signed for free via the Uzo docs

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

/// @notice Keeps the last 32 actions in storage so apps can read recent activity without logs.
contract RecentActivity {
    struct Action {
        address account;
        uint64 timestamp;
        uint256 amount;
    }

    uint256 public constant SIZE = 32;

    Action[SIZE] private _ring;
    uint256 public totalActions;

    event Recorded(address indexed account, uint256 amount);

    function record(uint256 amount) external {
        // casting to uint64 is safe because block.timestamp will not pass 2^64 seconds for billions of years
        // forge-lint: disable-next-line(unsafe-typecast)
        _ring[totalActions % SIZE] = Action(msg.sender, uint64(block.timestamp), amount);
        totalActions += 1;
        emit Recorded(msg.sender, amount);
    }

    /// @notice The newest `n` actions, newest first. `n` is capped at SIZE and at totalActions.
    function lastActions(uint256 n) external view returns (Action[] memory actions) {
        if (n > SIZE) n = SIZE;
        if (n > totalActions) n = totalActions;
        actions = new Action[](n);
        for (uint256 i = 0; i < n; i++) {
            actions[i] = _ring[(totalActions - 1 - i) % SIZE];
        }
    }
}

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

const client = createPublicClient({ chain: botChainTestnet, transport: http() });
const nft = process.env.NFT_ADDRESS as `0x${string}`;
const owner = process.env.OWNER_ADDRESS as `0x${string}`;

const abi = parseAbi([
  "function balanceOf(address owner) view returns (uint256)",
  "function tokenOfOwnerByIndex(address owner, uint256 index) view returns (uint256)",
]);

const balance = await client.readContract({ address: nft, abi, functionName: "balanceOf", args: [owner] });
const ids = await client.multicall({
  contracts: Array.from({ length: Number(balance) }, (_, i) => ({
    address: nft,
    abi,
    functionName: "tokenOfOwnerByIndex",
    args: [owner, BigInt(i)],
  })),
  allowFailure: false,
});
console.log(ids);

const API = "https://scan.bohr.life/api/v2";
const guestBook = "0x7962412A92E5553E66C794c3a352422DEB7BAc27";

const response = await fetch(`${API}/addresses/${guestBook}/logs`);
if (!response.ok) throw new Error(`BOTScan answered ${response.status}`);
const logs = await response.json();

for (const log of logs.items) {
  const args = Object.fromEntries(log.decoded?.parameters.map((p: { name: string; value: string }) => [p.name, p.value]) ?? []);
  console.log(log.block_number, log.decoded?.method_call.split("(")[0], args);
}