200ms Blocks

full_ms(block) = 1000 * block.timestamp + millisPart      millisPart ∈ {0, 200, 400, 600, 800}
full_ms(child) = full_ms(parent) + 200                    (no skipped slots)

interface IBaseTime {
    function timestampMillisPart() external view returns (uint16); // 0 | 200 | 400 | 600 | 800
    function timestampMs() external view returns (uint256);        // 1000 * block.timestamp + part
}
IBaseTime constant BASE_TIME = IBaseTime(0x4200000000000000000000000000000000000030);
// block.timestamp is still whole seconds.

import { createPublicClient, http, hexToBigInt, decodeFunctionData, parseAbi, type Hex } from "viem";

const vibenet = {
  id: 84538453,
  name: "vibenet",
  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
  rpcUrls: { default: { http: ["https://rpc.vibes.base.org"], webSocket: ["wss://rpc.vibes.base.org/ws"] } },
  blockTime: 200, // lets viem pick sane defaults, but see "Polling" below
} as const;
const client = createPublicClient({ chain: vibenet, transport: http() });

// Cobalt fields ride along untyped — declare them once.
type CobaltBlock = { timestampMs?: Hex };
type CobaltTx = { blockTimestampMs?: Hex };

const BASE_TIME = "0x4200000000000000000000000000000000000030";
const baseTimeAbi = parseAbi([
  "function timestampMillisPart() view returns (uint16)",
  "function timestampMs() view returns (uint256)",
  "function setTimestampMillisPart(uint16)",
]);

const block = await client.getBlock({ includeTransactions: true }); // latest
const raw = (block as unknown as CobaltBlock).timestampMs;
const timestampMs = raw ? hexToBigInt(raw) : undefined; // undefined = pre-Cobalt/pruned
const millisPart = timestampMs !== undefined ? timestampMs - block.timestamp * 1000n : undefined;

// tx[1] is the BaseTime deposit; decode the part it wrote.
const baseTimeTx = block.transactions[1];
const { args: [partFromTx] } = decodeFunctionData({ abi: baseTimeAbi, data: baseTimeTx.input });

// The predeploy agrees, as long as you pin the same block.
const partFromChain = await client.readContract({
  address: BASE_TIME, abi: baseTimeAbi, functionName: "timestampMillisPart", blockNumber: block.number,
});

console.log({ number: block.number, timestamp: block.timestamp, timestampMs, millisPart, partFromTx, partFromChain });
// e.g. { number: 2845536n, timestamp: 1788960994n, timestampMs: 1788960994200n, millisPart: 200n, partFromTx: 200, partFromChain: 200 }

RPC=https://rpc.vibes.base.org
# block → timestamp (s) + timestampMs
curl -s $RPC -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_getBlockByNumber","params":["latest",false]}' \
  | jq '.result | {number, timestamp, timestampMs}'
# logs → blockTimestampMs on every log
curl -s $RPC -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_getLogs","params":[{"fromBlock":"latest","toBlock":"latest"}]}' \
  | jq '.result[0] | {blockNumber, blockTimestamp, blockTimestampMs}'
# predeploy → current millisecond part
curl -s $RPC -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_call","params":[{"to":"0x4200000000000000000000000000000000000030","data":"0x7b2fea99"},"latest"]}'

import { createPublicClient, webSocket, hexToBigInt } from "viem";

const ws = createPublicClient({ transport: webSocket("wss://rpc.vibes.base.org/ws") });
const unwatch = ws.watchBlocks({
  onBlock: (block) => {
    const ms = hexToBigInt((block as any).timestampMs);
    console.log(block.number, ms, `.${ms % 1000n}`); // 2845550n 1788960997000n .0 → .200 → .400 …
  },
});

{"jsonrpc":"2.0","id":1,"method":"eth_subscribe","params":["newHeads"]}

const receipt = await client.waitForTransactionReceipt({ hash, pollingInterval: 100 });

import { createPublicClient, createWalletClient, http, hexToBigInt, parseEther, type Hex } from "viem";
import { privateKeyToAccount, generatePrivateKey } from "viem/accounts";
// `vibenet` chain object as above (with webSocket + blockTime: 200)

const account = privateKeyToAccount(generatePrivateKey()); // throwaway devnet key
const client = createPublicClient({ chain: vibenet, transport: http() });
const wallet = createWalletClient({ account, chain: vibenet, transport: http() });

// Fund it (0.1 ETH per drip, 10s cooldown per address and per IP), then poll the balance.
await fetch("https://api.vibes.base.org/api/vibenet/faucet/drip", {
  method: "POST", headers: { "content-type": "application/json" },
  body: JSON.stringify({ address: account.address }),
});
while ((await client.getBalance({ address: account.address })) === 0n) await new Promise((r) => setTimeout(r, 100));

const sentAt = Date.now();
const hash = await wallet.sendTransaction({ to: "0x000000000000000000000000000000000000dEaD", value: parseEther("0.0001") });
const receipt = await client.waitForTransactionReceipt({ hash, pollingInterval: 100 });
const minedAt = Date.now();

const block = await client.getBlock({ blockNumber: receipt.blockNumber });
const blockMs = hexToBigInt((block as unknown as { timestampMs: Hex }).timestampMs);
console.log({
  hash, block: receipt.blockNumber, blockTimestampMs: blockMs, millisPart: blockMs % 1000n,
  receiptAfterBroadcastMs: minedAt - sentAt,
});

import { hexToBigInt, parseEther, type Hex } from "viem";
import { sendTransaction, waitForTransactionReceipt, allPhasesSucceeded } from "viem/eip8130";

const hash = await sendTransaction(client, { account, calls, gas /* from estimateGas, +20% */ });
const receipt = await waitForTransactionReceipt(client, { hash, pollingInterval: 100 });
if (!allPhasesSucceeded(receipt.eip8130)) throw new Error("a phase reverted");

const block = await client.getBlock({ blockNumber: BigInt(receipt.blockNumber) });
const blockMs = hexToBigInt((block as unknown as { timestampMs: Hex }).timestampMs);
console.log(receipt.blockNumber, blockMs, blockMs % 1000n);