Reference · Web3 with Go & Polygon
Glossary
The canonical vocabulary for this course. Every lesson, exercise, and bank question uses
these words with exactly these meanings. Terms are added as the course introduces them —
currently through Unit 1.
The network
- Node (RPC node)
- A computer running Polygon that keeps a copy of the chain and answers requests over
HTTP (the endpoint is an RPC URL). Our backend is a client of one, never a node
itself. Avoid: "server", "the API".
- Amoy
- Polygon's test network — chain id
80002, gas paid in test POL. The whole
course lives here. Avoid: "Mumbai" (its dead predecessor, chain 80001).
- Chain id
- The number that uniquely identifies an EVM network (Amoy = 80002). Baked into every
signature so a transaction for one chain can't be replayed on another.
ethclient- The go-ethereum package that translates Go method calls into the node's JSON-RPC
dialect. Opened with
ethclient.Dial(rpcURL).
Accounts & money
- Account
- An entry in the chain's state, named by a 20-byte address (
0x…, 40 hex
chars). Comes in exactly two kinds: EOA or contract account.
- EOA (externally owned account)
- An account controlled by a private key. Investors are EOAs. Has a balance and nothing
else. Avoid: "wallet" for the on-chain thing — the wallet is the key-holding
software; the EOA is the ledger entry.
- Contract account
- An account controlled by code deployed on-chain, not a key. Has a balance and
stored data. The property-share token will be one.
- POL
- Polygon's native token; what gas is paid in. On Amoy it's free faucet money.
Avoid: "MATIC" (the pre-2024 name).
- wei
- The smallest unit of the native token: 1 POL = 1018 wei. The chain stores
every amount as a whole number of wei — decimals exist only in display code.
big.Int- Go's arbitrary-size integer, the type of every on-chain quantity. Compare with
Cmp (never == — that compares pointers); keep money math in
integer wei (never floats); results write into the receiver:
new(big.Int).Add(a, b).
- State
- The chain's current "spreadsheet": every account's balance and every contract's stored
data, as of a given block. Reads like
BalanceAt query state; only
transactions change it.
How the chain moves
- Transaction
- A signed, deterministic instruction to change state — the only way state ever
changes. Costs gas. Avoid: "tx" in prose (fine in code).
- Block
- A batch of transactions sealed ~every 2 seconds on Polygon, carrying the hash of the
previous block — which is what makes history append-only (immutability).
- Consensus / proof-of-stake
- How independent nodes agree on the next block. Polygon's validators stake tokens,
earn rewards for honest blocks, and are slashed for cheating.
- Gas
- The per-operation fee a transaction pays, in POL. Exists to stop spam and to guarantee
code halts. Reads are free; writes always cost gas.
- EVM
- The deterministic virtual machine every node runs contract bytecode on. "EVM-compatible"
(Polygon) = same contracts, standards, and tooling as Ethereum.
The product (introduced in Unit 1, detailed in Act III)
- ERC-20
- The standard interface for fungible tokens. Our Unit 4 practice token — legally a toy,
never the client deliverable.
- ERC-3643 (T-REX)
- The permissioned-token standard real security-token deals use: an ERC-20 plus on-chain
identity and compliance checks on every transfer. The client deliverable.
A term missing, or a definition that stopped feeling right? Tell me — the glossary is
supposed to be revised as your understanding deepens.