Conturi: oameni și contracte
Pe Ethereum, totul se întâmplă între conturi. Unele aparțin oamenilor și sunt controlate cu o cheie privată, altele sunt contracte și sunt controlate doar de codul lor. În această lecție vezi diferența, afli cum arată o adresă și cum se măsoară ether-ul în wei.
Două feluri de conturi
Starea Ethereum este, în esență, un tabel uriaș: pentru fiecare adresă se păstrează un cont. Există două tipuri, cu aceeași formă de adresă, dar cu puteri foarte diferite:
- Cont extern (EOA, Externally Owned Account): aparține unui om sau unei aplicații care are cheia privată. Doar un EOA poate semna și porni o tranzacție. Contul tău din MetaMask este un EOA.
- Cont de contract: are cod (bytecode-ul publicat) și storage (variabilele lui). Nu are cheie privată: nimeni nu îl poate „semna”. Face ceva doar când este apelat, de un EOA sau de alt contract.
EOA-ul este un om cu card bancar: poate decide singur să plătească. Contractul este un automat de bilete: are bani în el și reguli, dar nu pornește singur, ci doar când cineva apasă un buton.
Adresa: 20 de octeți
Din cursul Blockchain știi că adresa unui EOA se obține din cheia publică: se calculează keccak256 din cheia publică și se păstrează ultimii 20 de octeți. Scrisă în hexazecimal, are 0x + 40 de caractere.
Literele mari și mici din adresă nu sunt la întâmplare: formează un checksum (EIP-55). Dacă greșești o cifră când copiezi o adresă, portofelele observă că literele mari nu se mai potrivesc și refuză adresa.
Adresa unui contract se calculează altfel: din adresa celui care l-a publicat și nonce-ul lui (numărul de tranzacții trimise până atunci). De aceea primul contract publicat de Ana are mereu aceeași adresă în curs.
Conturile de test din curs
Blockchain-ul din pagină pornește cu 10 conturi de test, fiecare cu 100 ETH (fără valoare reală): ana, bogdan, cristina, dan, elena, florin, gabriela, horia, ioana și atacator. În scripturi le folosești direct după nume:
console.log("Adresa Anei:", ana.address);
console.log("Sold Bogdan (ETH):", ethers.formatEther(await sold(bogdan)));
console.log("1 ETH în wei:", ethers.parseEther("1"));
console.log("1,5 ETH:", ethers.formatEther(1500000000000000000n));Adresa Anei: 0xb3E0A4A6FC903B00c73497DF23dfD21EF92a2706 Sold Bogdan (ETH): 100.0 1 ETH în wei: 1000000000000000000 1,5 ETH: 1.5
Bogdan are exact 100 ETH pentru că nu a trimis încă nicio tranzacție. Ana va avea puțin mai puțin după ce publică un contract: gas-ul se plătește din soldul ei.
Ether și wei
EVM nu are numere cu virgulă, așa că soldurile se țin în cea mai mică unitate, wei. Un ether are 10¹⁸ wei, așa cum un leu are 100 de bani, doar că mult mai mulți. Unitatea intermediară, gwei (10⁹ wei), se folosește pentru prețul gas-ului.
| Unitate | Valoare în wei | Unde o vezi |
|---|---|---|
| wei | 1 | în contracte (msg.value, solduri) |
| gwei | 1 000 000 000 | prețul gas-ului (de ex. 1 gwei) |
| ether | 1 000 000 000 000 000 000 | în portofel, pe exploratoare |
În JavaScript transformi valorile cu ethers.parseEther("1") (text în ETH → wei, BigInt) și ethers.formatEther(wei) (wei → text în ETH).
Contul unui contract, văzut din afară
Hai să publicăm un contract și să comparăm conturile. provider.getCode(adresă) întoarce codul unui cont: 0x (gol) pentru un EOA, bytecode pentru un contract.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract Seif {
uint public secret = 7;
}const seif = await deploy("Seif");
console.log("Adresa:", seif.target);
console.log("Codul Anei:", await provider.getCode(ana.address));
const cod = await provider.getCode(seif.target);
console.log("Contractul are cod:", cod.length > 2);
console.log("Sold contract (ETH):", ethers.formatEther(await sold(seif)));Adresa: 0x04ae6DbF040c923A896958997fc6B85B97e65f45 Codul Anei: 0x Contractul are cod: true Sold contract (ETH): 0.0
În cod, adresa celui care apelează o funcție este msg.sender (o vei folosi des, mai ales în lecția 13). Când apelezi din alt cont, cu connect, se schimbă și msg.sender:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract Ecou {
function apelant() public view returns (address) {
return msg.sender;
}
}const ecou = await deploy("Ecou");
console.log(await ecou.apelant());
console.log(await ecou.connect(cristina).apelant());0xb3E0A4A6FC903B00c73497DF23dfD21EF92a2706 0xcCC14A1136a5317791671806FE896779a67EEd24
O funcție care întoarce o adresă declară returns (address). În JavaScript primești textul adresei, cu literele mari ale checksum-ului.
Greșeli frecvente
- „Contractul poate trimite singur o tranzacție la ora 12.” Nu: un contract acționează doar când îl apelează cineva. Automatizările folosesc un EOA sau un serviciu care apelează contractul.
- „Dacă pierd cheia privată, o recuperez de la Ethereum.” Nu există o bancă sau un buton „Am uitat parola”: fără cheie, contul EOA este pierdut.
- Confuzia ETH / wei. 1 într-un contract înseamnă 1 wei, nu 1 ether. Folosește parseEther când trimiți sume din JavaScript.
- Adrese copiate greșit. Verifică mereu checksum-ul; ether-ul trimis la o adresă greșită nu se mai întoarce.
Unde întâlnești conturile
Un portofel este, de fapt, un manager de chei private pentru unul sau mai multe EOA-uri.
Contractul WETH ține milioane de ether: un cont de contract fără cheie privată, controlat doar de cod.
Pe un explorator vezi pentru orice adresă soldul, tranzacțiile și, la contracte, codul publicat.
Scrie contractul Identitate cu funcția cineSunt(), de tip public view, care returnează adresa celui care o apelează (msg.sender). Scriptul lecției o apelează din contul Anei și din contul lui Bogdan și afișează adresele primite.
- Declară funcția cineSunt() fără parametri, public view.
- Declară că întoarce o adresă: returns (address).
- Returnează msg.sender.
Soluția exercițiului
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract Identitate {
function cineSunt() public view returns (address) {
return msg.sender;
}
} 