Blockchain for Payments Professionals · Chapter 1 of 4Draft

The plumbing: what a blockchain transaction actually is

Every stablecoin dashboard and every on-chain settlement headline is built from a handful of primitive objects. Send one risk-free payment through a local sandbox, then dissect the signed transaction, receipt, block and logs the system records.

11 September 202618 min readBy NewRemit Research

We use a local sandbox blockchain running on a laptop: real protocol, fake money, published test keys, zero risk. Think of it as the scheme’s test environment — the production message formats without the consequences.

By the end, you’ll know why a technically successful blockchain transaction is not the same as a successful payment, and why a stablecoin transfer looks nothing like the simple transfer we send here.

What we skip on purpose: smart-contract development, Solidity, consensus, validators, bridges and state trees. This chapter stays strictly with the transaction lifecycle.

Chapter map

One transaction, end to end

01
Create
to, value, nonce, gas rules, data
02
Sign
private key produces the signature
03
Submit
client → JSON-RPC → node
04
Validate
signature, nonce, balance and gas rules
05
Execute
balances and fees change
06
Include
transaction enters a block
07
Receipt
status, gas used and logs

The seven stages you will unpack below. On mobile the lifecycle reads top to bottom; reduced-motion preferences show the final state immediately.

Source: Protocol mechanics; no live data.

Lesson 1.1

A blockchain on your laptop

Why this matters: a sandbox lets you learn the production rail's message format without handling real funds or real secrets.

Foundry is an Ethereum developer toolkit. Anvil is its miniature local network: it produces blocks, holds funded test accounts and exposes the same JSON-RPC interface as real nodes. Cast is its command-line client — roughly, curl for Ethereum.

Cast  →  JSON-RPC  →  Anvil (local node)

Cast / viem  →  JSON-RPC  →  Ethereum, Base, Arbitrum, Polygon…

Sandbox → production

Anvil is a full simulator speaking the production message standard. Cast is the API test console; JSON-RPC is the ISO 20022 of node access. Later, only the endpoint changes.

About the key below: Anvil ships the same publicly documented test accounts to everyone. A real private key is never shared, pasted or placed in a command.

Hands-on: start your sandbox (optional)

anvil

cast block-number
cast balance 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 --ether

Bash

Lesson 1.2

Anatomy of a payment instruction

Why this matters: nearly every field in a signed blockchain instruction has a payments cousin — including routing, duplicate protection, minor units, fee authorization and authentication.

We send 1 ETH from account 0 to account 1. The returned transaction object is dense, but its essentials divide into four familiar zones. Select a field in the explorer to translate it.

Interactive A

Anatomy of the signed instruction

Identity & routing

Money

Cost

Authorization

Explore the ten curated fields from the sandbox transaction. The raw output contains more inclusion metadata, but these are the fields needed to reason about a payment instruction.

Source: Anvil sandbox example; fixed illustrative values.

The fee fields are a pricing model

The protocol sets and burns the base fee. The sender adds a validator incentive and signs a maximum price. Total cost is gasUsed × effectiveGasPrice.

Interactive B

The fee ceiling you sign

Illustrative fee arithmetic

gwei / gas

0.875 base + 0.000000001 priority = 0.875

Priority fee: 0.000000001 gwei

0maxFee 2.000

The base fee is burned — there is no acquirer here.

Move the priority-fee slider to see the effective price rise and clamp at maxFee. Values are illustrative, expressed in gwei per unit of gas.

Source: Illustrative arithmetic from the sandbox run.

Private key signs. Signature travels. Private key stays secret. The network verifies r, s and yParity against the sender’s address without ever receiving the key.

Do not confuse an account’s nonce with a block number. A nonce counts one account’s instructions; a block number counts the whole chain’s history. Matching values are coincidence.

Hands-on: send and inspect (optional)

Public test key — never use real private keys like this.

cast send 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 \
  --value 1ether \
  --private-key 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80

cast tx 0x22d37fe154bf61a58a4eb7b33f37caaca40048de51df6b6036cfe25b82979474
cast nonce 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266

Bash · public Anvil key

Lesson 1.3

Instruction, confirmation, record

Why this matters: transaction, receipt and block answer different questions. Monitoring systems that merge them produce confident but wrong conclusions.

TRANSACTION   “What did I ask to be executed?”   → payment instruction
RECEIPT       “What actually happened?”          → settlement confirmation
BLOCK         “Where was it recorded?”            → ledger batch / page

The receipt records status = 1, gasUsed = 21000 and logs = []. That proves technical execution only. A wrong-address transfer or an exchange deposit never credited to a customer can still have status 1.

The block is the container. Each carries its own fingerprint and its parent’s fingerprint, creating the linked record that gives blockchain its name.

Interactive C

What tamper-evident means

Block 1

hash: 0x06fe…8ab1
parentHash: 0x9c22…11e0

Block 2

hash: 0xf62a…2974
parentHash: 0x06fe…8ab1

Block 3

hash: 0xa481…c902
parentHash: 0xf62a…2974

Each block stores its parent's fingerprint.

Change one character in block 1. Its fingerprint changes, so block 2's already-recorded parent reference stops matching and exposes the alteration.

Source: Illustrative shortened hashes.

Lesson 1.4

The full lifecycle, and reads vs writes

Why this matters: the read/write split is the safety rail for every analyst working with a public chain.

The complete journey

1 CREATE → 2 SIGN → 3 SUBMIT → 4 VALIDATE → 5 EXECUTE → 6 INCLUDE → 7 RECEIPT

Reads ask a node questions. They need no key, signature, fee or state change. Writes submit signed instructions and can change balances. Everything this learning path builds on real chains stays on the read side.

The original sandbox worksheet

The supplied Phase 1 reference below preserves the actual terminal views and annotations behind this chapter. Open it at full size if you want the raw transaction and block output side by side.

Annotated Phase 1 worksheet showing the transaction, block, lifecycle and glossary from the Anvil sandbox run

Lesson 1.5

The stablecoin turn

Why this matters: a stablecoin payment hides from the obvious transaction fields. This difference breaks naive on-chain analytics.

Our native transfer names Bob in to, places 1 ETH in value, carries empty input and emits no logs. An ERC-20 stablecoin transfer instead calls the token contract: to names the contract, ETH value is zero, and the beneficiary plus token amount sit in encoded calldata.

Interactive D

Same intent, different records

Native ETH transfer

to: Bob
value: 1 ETH
input: 0x
receipt.logs: []

Stablecoin transfer

to: TOKEN CONTRACT
value: 0 ETH
input: transfer(Bob, amount)
receipt.logs: Transfer(Alice, Bob, amount)

Compare the same four fields.

Reveal the four fields in sequence. The final beat shows where token analytics must look: the Transfer event emitted into the receipt.

Source: Illustrative ERC-20 transaction anatomy.

Stablecoin analytics is log analytics. The contract updates its own issuer ledger; the receipt’s Transfer event — not the transaction’s ETH value — records who paid whom.

Graduation test

Can you read the lifecycle unaided?

Q1Which lifecycle statement is accurate?
Q2What does a receipt answer?
Q3A transaction has status = 1. What is proven?
Q4Why can nonce 2 and block 2 be unrelated?
Q5Where is the authoritative payment record for an ERC-20 stablecoin transfer?

Progress

0 of 5 answered

Five single-choice questions, immediate explanations and direct links to the lesson worth revisiting. Nothing is stored.

Source: Questions map to the five graduation outcomes in this chapter.

Chapter glossary

Term	Simple meaning
Anvil	Local Ethereum sandbox: production-style RPC, fake money.
Cast	Command-line client for Ethereum-compatible nodes.
Nonce	Per-account sequence number for ordering and duplicate protection.
Wei	ETH minor unit; 10¹⁸ wei equals 1 ETH.
Gas	Computation metering used to calculate execution cost.
Transaction	The signed instruction.
Receipt	The execution result: status, cost and logs.
Block	Ordered historical container linked to its parent by hash.
Calldata	Encoded contract instruction attached as transaction input.
Log / event	A record a contract writes during execution.

Next chapter: point the same read-only ideas at Ethereum mainnet and inspect real blocks, balances, receipts and contract logs.

Back to the learning path