Skip to main content
This reference provides detailed translations from Ethereum concepts to their Canton equivalents. Use this as a quick reference when you encounter familiar terms and need to understand their Canton counterpart.

Core Protocol Concepts

EthereumCantonKey Differences
BlockchainSynchronizerCanton synchronizers coordinate without storing state
BlockNo direct equivalentTransactions are ordered individually; participants receive only relevant views
NodeValidator / ParticipantStores only hosted parties’ data
Global stateDistributed stateNo global view; each party has their view
FinalityConfirmationDeterministic finality after confirmation
ReorgNot applicableCanton has no chain reorganizations

Identity & Accounts

EthereumCantonKey Differences
EOA (Address)PartyParties have explicit authorization semantics
Private keyParty keysCan be local (validator-held) or external
msg.senderControllerDeclared at compile-time, not runtime
Contract addressContract IDUnique identifier, not derived from deployer
ENS nameCanton Name Service (CNS)Human-readable party identifiers

Party vs. Address Deep Dive

Implications:
  • Don’t create parties frivolously (unlike Ethereum addresses)
  • Party creation requires interaction with a validator
  • Parties are not pseudonymous in the same way as Ethereum addresses

Smart Contract Concepts

EthereumCantonKey Differences
Smart contractTemplateDaml defines types and choices
Contract instanceContractImmutable; state changes create new contracts
FunctionChoiceChoices are typed and authorized
ConstructorcreateCreates contract from template
Storage variablesContract fieldsImmutable within a contract instance
ABIDaml typesType-safe interface definition

State Model Comparison

Ethereum: Mutable State
contract Token {
    mapping(address => uint256) balances;

    function transfer(address to, uint256 amount) public {
        balances[msg.sender] -= amount;  // Mutate in place
        balances[to] += amount;
    }
}
Canton: Immutable Contracts
template Token
  with
    owner : Party
    amount : Decimal
  where
    signatory owner

    choice Transfer : ContractId Token
      with newOwner : Party
      controller owner
      do
        -- Archive this contract (implicit)
        -- Create new contract with new owner
        create this with owner = newOwner
AspectEthereumCanton
ModificationUpdate storage variablesArchive old, create new
HistoryImplicit in state transitionsExplicit in contract lifecycle
AtomicityPer-transactionPer-transaction
RollbackRevert state changesHidden as part of the protocol

Transaction Concepts

EthereumCantonKey Differences
TransactionTransaction / CommandCanton transactions are privacy-preserving
Transaction hashTransaction IDUnique identifier
GasTrafficPaid in Canton Coin
Gas priceTraffic costBased on transaction size and complexity
NonceNot requiredCanton handles ordering
ReceiptCompletionConfirmation of command execution

Transaction Visibility

EthereumCanton
Transaction visible to all nodesTransaction split into views
Everyone sees sender, recipient, dataEach party sees only their view
Public mempoolEncrypted submission
Block explorer shows everythingBlock explorer shows your transactions only

Authorization Concepts

EthereumCantonKey Differences
msg.senderControllerCompile-time vs. runtime check
require()Signatory/controller declarationsEnforced by protocol
OwnableSignatory patternBuilt into the language
Access controlObserver/controller declarationsExplicit visibility control
Multi-sigMultiple signatoriesNative multi-party support

Authorization Example

Ethereum: Runtime Check
function transfer(address to, uint256 amount) public {
    require(msg.sender == owner, "Not authorized");
    // ... transfer logic
}
Canton: Compile-Time Declaration
choice Transfer : ContractId Asset
  controller owner  -- Only owner can exercise this choice
  do
    -- No runtime check needed; protocol enforces
    create this with owner = newOwner

Event & Data Concepts

EthereumCantonKey Differences
EventsTransaction treeStructured record of actions
emitImplicit in transactionAll creates/archives are recorded
Indexed parametersContract fieldsQueryable via Ledger API/PQS
LogsActive Contract Set (ACS)Current state queryable
eth_getLogsGetTransactionTreesHistorical transaction data

Network Concepts

EthereumCantonKey Differences
MainNetCanton Network MainNetProduction with real value
Testnet (Sepolia)DevNet / TestNetTest environments
Local (Hardhat/Anvil)LocalNetDevelopment environment
RPC endpointLedger APIgRPC or JSON interface
Infura/AlchemyValidator serviceHosted infrastructure
Chain IDSynchronizer IDNetwork identifier

Environment Comparison

EnvironmentEthereumCanton
Local developmentHardhat, Anvil, GanacheLocalNet (Daml SDK)
Shared testingSepolia, GoerliDevNet (requires sponsorship)
Pre-productionSepoliaTestNet (requires approval)
ProductionMainNetMainNet (full onboarding)

Development Tooling

EthereumCantonNotes
SolidityDamlDifferent paradigm: functional vs. imperative
Hardhat/Foundrydpm + daml buildBuild and test toolchain
RemixVS Code + Daml extensionIDE support
ethers.js/web3.jsLedger API (gRPC/JSON)Application integration
MetaMaskWallet SDKUser wallet integration
EtherscanScan APINetwork exploration
The GraphPQSIndexed data queries

Common Patterns

Ethereum PatternCanton Equivalent
ERC-20Token Standard (CIP-0056)
ERC-721/ERC-1155dApp Standard (CIP-0103)
Proxy patternSmart Contract Upgrade (SCU)
Factory patternTemplate instantiation
Pull paymentsPropose/accept pattern
Access control listsObserver lists
PausableContract lifecycle choices
Reentrancy guardNot needed (sequential execution)

What Doesn’t Translate

Some Ethereum concepts have no direct Canton equivalent:
EthereumCanton Reality
Public by defaultPrivate by default
Any node can query any stateQuery only your parties’ data
Anonymous participationParties have identity
Permissionless contract deploymentPackages vetted by validators
Flash loansDifferent execution model
MEV/front-runningTransactions are encrypted

Next Steps