As a Solidity / EVM developer, how is the Agoric similar? how is it different?

[dckc]

Please explain.

[dckc]

ChatGPT explains (and gets some stuff WRONG)

I started this in office hours today. I don't have time to finish, but I'll share it anyway...

---

Agoric at a Glance

Agoric is a smart‑contract platform that lets you write on‑chain logic in Hardened JavaScript. The guiding rule is simple:

If your object holds a reference to another, it’s authorised; if it doesn’t, it’s not.

Think of an Agoric contract as a JavaScript object inside a vat. A vat is to Agoric what an EVM instance is to Solidity byte‑code: deterministic, metered, replayable, and completely isolated. Messages between vats are always asynchronous, so each contract’s state is settled before another can call back—re‑entrancy defeated by design.

The vats run on the SwingSet kernel, which schedules messages deterministically and meters CPU & memory consumption.

---

Programming Model & Language

Agoric — Hardened JavaScript

• Familiar JS syntax—dynamic constructs (including eval) still work but execute in a confined environment. The key safety lever is eliminating ambient authority: objects cannot obtain capabilities they weren’t explicitly passed, and globals are frozen to prevent privilege escalation.
• Contracts are plain objects that expose methods; capabilities flow by passing object references.
• The "eventual‑send" (E(target).method(...)) promise API expresses cross‑contract calls.
• Leverages the full JavaScript/TypeScript ecosystem (npm packages, VS Code tooling, Jest/AVA tests). Smart‑contract‑specific debuggers, coverage, and formal‑verification tools are emerging and less mature than EVM counterparts.

Ethereum — Solidity / Vyper

• Purpose‑built, statically‑typed language compiled to EVM byte‑code.
• Developers juggle storage layout and re‑entrancy guards.
• Gas micro‑optimisations are an incentive feature born from a busy network where every unit of gas costs real money and rewards efficient code.
• Access control expressed via on‑chain modifiers (onlyOwner, role contracts, etc.).
• Rich smart‑contract tooling suite—Hardhat, Foundry, Truffle, Slither, MythX—supports compilation, testing, deployment, fuzzing, and static analysis.

---

Security Model

	Agoric	Solidity / EVM
Authorisation	Possessing a reference => authority	Global addressability + require checks
Re‑entrancy	Impossible: only async calls	Dev must guard (checks‑effects‑interactions, mutex)
Higher‑level safety	Zoe framework enforces offer safety, escrow, and payout invariants	No native equivalent; each protocol reinvents guards

---

Composability & Re‑use

• Agoric: contracts publish facets that other contracts import as objects; ERTP gives a common asset vocabulary; Zoe instances can be upgraded or composed safely.
• Ethereum: direct call/delegatecall lets protocols stack freely (DeFi Lego), but every cross‑call can reopen attack surface; up‑gradability via proxies adds further risk.

---

Execution & Determinism

• Agoric: messages are queued; kernel executes them deterministically; each vat snapshot can be replayed for audit.
• EVM: synchronous execution inside a single transaction; any downstream call can re‑enter unexpectedly unless guarded.

---

Economic Layer & Resource Metering

Fees

• Every vat invocation consumes compute units (CPU time) and allocation units (memory).
• Fee token evolution: fees were originally paid in RUN (rebranded as IST). Per community proposals #787 and doc: Add an explanatory comment to files using the tildot notation #819, gas fees are transitioning to BLD, the staking / governance token.
• Developers can estimate cost with agoric run --meter or view metering reports in test logs.
• Just as Ethereum’s high gas fees motivate tight Solidity code, Agoric expects busy‑network pressure on BLD‑denominated fees to reward efficient vats.

Assets

• Agoric: ERTP represents fungible, NFT, and custom rights uniformly. BLD is the staking / governance token and is becoming the sole gas token; the former stable token IST (née RUN) is being sunset.
• Ethereum: ETH for gas; asset standards such as ERC‑20/721/1155.

---

Interop & Deployment

• Agoric is a Cosmos proof‑of‑stake zone. Transactions sign with Keplr or Leap.
• Bridges
  • IBC enables token & message flow to other Cosmos chains.
  • Gravity Bridge / Axelar move ERC‑20s between Ethereum and Agoric.
  • Inter‑Chain Accounts let external chains invoke Zoe contracts.

A Solidity team can therefore keep liquidity on Ethereum while deploying new logic on Agoric.

---

Developer Tooling Parallels

Familiar in Solidity World	Agoric Counterpart
Hardhat / Foundry tests	yarn test (AVA) with Zoe helpers
Slither static analysis	ESLint‑SES rules & Hardened JS checker
Foundry fuzz / Echidna	Property tests with PeggyJS & @agoric/zoe/tools
OpenZeppelin contracts	Zoe contract templates & ERTP mint kits

All major editors support Hardened JS via the Agoric ESLint plugin, and CI metering reports catch runaway compute.

---

Live Protocols & Code You Can Read

Project	What it shows	Repo
Inter Protocol (IST)	Legacy stablecoin backed by collateral vaults — winding down in 2025	agoric‑labs/vaultFactory
RUN Auctions	English auction pattern, async bids	agoric‑labs/auction
Oracle DAO	Off‑chain data into ERTP feeds	agoric‑example/oracle‑contract

These are audited, in‑production contracts you can inspect today.

---

Summary — When to Choose Which

Feature	Agoric	Ethereum
Language	Hardened JS (async by default)	Solidity / Vyper
Security stance	Reference‑based; re‑entrancy impossible	Modifier checks; dev‑enforced
Metering	Compute & memory units (BLD; formerly RUN / IST)	Gas (ETH)
Composability	Zoe facets & ERTP rights	Direct calls & ERC standards
Interop	IBC + Gravity/Axelar bridges	Native EVM ecosystem
Maturity	Younger, security‑first	Vast, battle‑tested

---

Final Take‑aways for Solidity Developers

• No more nonReentrant guards. Async‑only messaging means you can’t be surprised mid‑function.
• Write in JavaScript, think in objects. If you’re fluent in Node tooling, the learning curve is gentle.
• Keep your ETH liquidity. Deploy new contracts on Agoric and bridge assets as needed.
• Audit posture improves. Much of the burden (escrow logic, invariant enforcement) lives in Zoe, so you review fewer bespoke lines of code.

If you crave byte‑level optimisation and already live inside EVM, stick with Solidity. But if safer composition, JS ergonomics, and built‑in economic tooling sound appealing, give Agoric a serious look.