Both Sides of the Boundary: Solidity & ethers.js

An engineering leader reads two languages: the contract (Solidity, on-chain) and the app that calls it (TypeScript via ethers.js, off-chain). The ABI is the seam between them. Let's read both.

One tooling fact first (it's a hiring signal)

Web3.js was sunset in March 2025 by its maintainer ChainSafe.¹ For new work the field uses ethers.js (most popular, TypeScript-friendly) or viem (newer, fully type-safe, smaller). If a candidate reaches for Web3.js on a greenfield project, that's a small but real currency flag worth probing. We'll use ethers.js (v6).

The three-layer picture

The ABI (Application Binary Interface) is the key idea: it's a machine-readable description of the contract's functions and events — the ERC-20 interface from Lesson 3, turned into JSON the client uses to encode calls. Your TypeScript never sees Solidity; it sees the ABI.

Side 1 — Reading Solidity (as a reviewer, not an author)

You're not writing this; you're interrogating it. Here's the Lesson 2 registry again, annotated with what a reviewer looks for:

contract ShareRegistry {
    mapping(address => uint256) public balances;   // state: the ledger
    address public agent;                          // ← WHO is privileged?

    modifier onlyAgent() {                          // ← access control (Lesson 6 #1 risk)
        require(msg.sender == agent, "not agent");
        _;
    }

    function forcedTransfer(address from, address to, uint256 amt)
        public onlyAgent {                            // ← privileged: who can call it? guarded?
        balances[from] -= amt;
        balances[to]   += amt;
        emit Transfer(from, to, amt);              // ← event = off-chain feed (Lesson 3)
    }

    event Transfer(address indexed from, address indexed to, uint256 amt);
}

Side 2 — Calling it from TypeScript (ethers.js v6)

Three objects are the whole mental model — and they map straight onto Lesson 2:

import { ethers } from "ethers";

// read-only: a Provider is enough
const provider = new ethers.JsonRpcProvider(RPC_URL);

// the ABI — human-readable form (this IS the interface, Lesson 3)
const abi = [
  "function balanceOf(address) view returns (uint256)",
  "function transfer(address to, uint256 amount)",
  "event Transfer(address indexed from, address indexed to, uint256 value)",
];

const token = new ethers.Contract(ADDRESS, abi, provider);
const bal: bigint = await token.balanceOf(user);   // view → free, instant

// state change: connect a Signer (holds the key — Lesson 6 custody)
const signer = await provider.getSigner();
const token = new ethers.Contract(ADDRESS, abi, signer);

const tx = await token.transfer(to, ethers.parseUnits("100", 18));
// tx is SENT but not yet final — mining is async
const receipt = await tx.wait();   // wait for confirmation (a block)
// if a require() failed on-chain, this REVERTS and throws (Lesson 2)

// subscribe to events — how your back office stays in sync
token.on("Transfer", (from, to, amount, event) => {
  reconcile(from, to, amount);   // update off-chain books
});

Notice how little is new: it's just async TypeScript calling typed methods. The concepts doing the work — free reads vs gas-costing writes, the key behind the Signer, reverts, events as the sync feed — are all things you already learned. ethers.js is a thin, familiar skin over the model.

Where this connects to the rest

The Marketnode lens & interview angles

• Read both sides in review. A bug can hide in the contract or in how the app calls it (wrong decimals, unconfirmed tx.wait(), trusting an event without confirmations). Competence means reading across the boundary.
• Server-side Signers are an agent-key question. When your backend signs transactions (mint, freeze), the Signer is wrapping a powerful key — route it through MPC/custody, never a plaintext env var. This is where Lesson 6 meets day-to-day code.
• Interview probe: "Walk me through what happens, end to end, when a user clicks 'transfer' in our app." A strong hire narrates: build tx via ethers → Signer signs → broadcast → mempool → mined → tx.wait() confirms → event emitted → backend reconciles. A weak one stops at "it calls the API."
• Currency check: ethers.js / viem for new work; Web3.js is sunset. Knowing the live tooling separates current engineers from those coasting on 2021 knowledge.

Primary source

The canonical reference, well-written and TypeScript-first: ethers.js v6 — Getting Started. For the Solidity side, the Solidity docs (skim "Contracts" and "Visibility and Getters"). Context on the tooling shift: ChainSafe — Web3.js sunset; and the modern alternative viem.