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 = 10^18 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.