Blockchain dla handlu energią P2P: inteligentne kontrakty i ograniczenia
W 2025 r. Włochy będą liczyły się dalej Utworzono 850 wspólnot energii odnawialnej (CER). i więcej niż 3500 na etapie planowania dzięki zachętom zawartym w dekrecie legislacyjnym 199/2021 i przyznanym 2,2 miliarda euro z PNRR. Istnieje jednak problem, którego żaden z obecnych modeli motywacyjnych nie rozwiązuje całkowicie: Rozliczanie energii w jednostkach CER nadal odbywa się za pośrednictwem scentralizowanych pośredników, m.in dni opóźnień i koszty transakcji, które znacząco zmniejszają korzyści ekonomiczne m.in prosument.
Rozwiązanie, które pojawia się na całym świecie – od nowojorskiej Brooklyn Microgrid po eksperymentalne jednostki CER w Niemczech i Holandii - oraz handel energią typu peer-to-peer w oparciu o blockchain. Pomysł jest taki elegancki w swojej prostocie: prosument posiadający nadmiar paneli fotowoltaicznych może bezpośrednio sprzedać swoją energię sąsiadowi, który jej potrzebuje, bez pośrednictwa mediów, z rozliczeniem automatyczne zarządzane przez inteligentny kontrakt Solidity i natychmiastowa płatność w tokenach energetycznych.
Rynek blockchain w energetyce jest tego wart 5,1 miliarda dolarów w 2025 roku i ma zostać osiągnięty 154,7 miliardów do 2035 roku z CAGR na poziomie 40,9%. Handel energią P2P stanowi najszybciej rozwijający się segment, napędzany rozprzestrzenianiem się DER (Distributed Energy Resources), z dyrektywy RED III, która nakłada na państwa członkowskie obowiązek wykorzystania 42,5% energii odnawialnej do 2030 r. oraz dojrzewanie platform blockchain warstwy 2, które obniżyły koszty gazu o 99% w porównaniu do sieci głównej Ethereum.
W tym artykule od początku budujemy kompletny system handlu energią P2P na blockchainie: daj to Solidne inteligentne kontrakty dla rynku energii, do wyroczni w sprawie danych z inteligentnych liczników, w górę po integrację z API DSO (Operatora Systemu Dystrybucyjnego) w celu zarządzania ograniczeniami sieciowymi. Zajmujemy się także krajobrazem regulacyjnym – Pakietem Czystej Energii, RED III, Dekretem Legislacyjnym 199/2021 – i konsekwencjami RODO dla danych konsumentów w łańcuchu dostaw.
Czego dowiesz się w tym artykule
- Kompletna architektura rynku energii P2P na blockchainie
- Inteligentne kontrakty Solidity: EnergyToken (ERC-20), OrderBook, EnergyMarketplace, Rozliczenie
- Porównanie blockchaina energetycznego: Ethereum L2 (Polygon, Arbitrum), Energy Web Chain, Hyperledger
- Projekt Oracle: Chainlink do wyceny sieci, niestandardowa Oracle dla danych inteligentnych liczników DLMS/COSEM
- Tokenomika: tokeny energetyczne, kredyty węglowe, zachęty prosumenckie
- Integracja inteligentnych liczników: protokoły DLMS/COSEM, IEC 62056, zasilanie on-chain
- Zarządzanie ograniczeniami sieciowymi: limity przepustowości, zarządzanie ograniczeniami, DSO API
- Regulacje UE: Pakiet Czystej Energii, RED III, włoskie jednostki CER
- Prywatność już w fazie projektowania: zgodność z RODO, dowody „wiedzy zerowej” dla danych konsumentów
- Testowanie z Hardhat: kompletny zestaw testów dla rynku
- Studium przypadku: Brooklyn Microgrid, Fundacja Energy Web Foundation, włoski CER
Seria EnergyTech - 10 artykułów
| # | Przedmiot | Państwo |
|---|---|---|
| 1 | Inteligentna sieć i IoT: architektura sieci elektroenergetycznej przyszłości | Opublikowany |
| 2 | Architektura DERMS: agregacja milionów rozproszonych zasobów | Opublikowany |
| 3 | System zarządzania akumulatorami: Algorytmy sterowania dla BESS | Opublikowany |
| 4 | Cyfrowy bliźniak sieci elektroenergetycznej z Pythonem i Pandapower | Opublikowany |
| 5 | Prognozowanie energii odnawialnej: ML dla fotowoltaiki i wiatru | Opublikowany |
| 6 | Równoważenie obciążenia pojazdów elektrycznych: V2G i inteligentne ładowanie za pomocą OCPP | Opublikowany |
| 7 | MQTT i InfluxDB do telemetrii energii w czasie rzeczywistym | Opublikowany |
| 8 | IEC 61850: Komunikacja w podstacji elektrycznej | Opublikowany |
| 9 | Oprogramowanie do rozliczania emisji dwutlenku węgla: pomiar i redukcja emisji | Opublikowany |
| 10 | Blockchain dla handlu energią P2P: Inteligentne kontrakty i ograniczenia (tutaj jesteś) | Aktualny |
Dlaczego Blockchain rozwiązuje prawdziwy problem energetyczny
Aby zrozumieć wartość blockchain w handlu energią P2P, musisz najpierw zrozumieć, jak to działa dzisiaj rynek energii w społecznościach energetycznych i dlaczego model scentralizowany ma ograniczenia problemy strukturalne, które są trudne do przezwyciężenia.
Problem scentralizowanego rozliczenia
W typowej włoskiej jednostce CER przepływ wartości wygląda następująco: prosument produkuje energię za pomocą własnych środków fotowoltaicznej, nadwyżka energii jest wprowadzana do sieci, GSE mierzy energię współdzieloną wewnątrz kabiny podstawowej, a po 3-6 miesiącach premia równa ok 110 EUR/MWh na wspólnej energii (stawka premium) plus oszczędność na rachunku. Rozliczenie ma charakter miesięczny lub kwartalny, zarządzany przez GSE za pośrednictwem portalu CACER.
Model ten ma zalety (prostota, wsparcie instytucjonalne), ale także krytyczne ograniczenia dla: Dynamiczny rynek P2P:
- Opóźnienie rozliczenia: dni lub tygodnie zamiast sekund
- Stała cena: brak możliwości dynamicznego odkrywania cen w oparciu o lokalną podaż/popyt
- Ograniczona szczegółowość czasowa: rozliczenie miesięczne a zmienność godzinowa lub subgodzinna PV
- Wielu pośredników: GSE, dystrybutor (e-dystrybucja), sprzedawca mediów, każdy z własnymi kosztami
- Brak przejrzystości: prosumenci nie widzą w czasie rzeczywistym, jak rozkłada się wartość
Co dodaje Blockchain
Platforma P2P na blockchainie nie zastępuje ram regulacyjnych GSE – przynajmniej nie krótkoterminowe - ale uzupełnia je, dodając warstwę przejrzystą, automatyczną i rozliczeniową transakcje w czasie niemal rzeczywistym wewnętrzny społeczności. Konkretne korzyści to:
Korzyści mierzone w pilotażach międzynarodowych
- Redukcja kosztów transakcyjnych: -60-80% w porównaniu do tradycyjnych pośredników (źródło: Energy Web Foundation, 2024)
- Szybkość osadzania: z dni do sekund (blockchain L2 z niemal natychmiastową finalnością)
- Przejrzystość audytu: każda transakcja weryfikowalna w łańcuchu, niezmienna
- Lokalne odkrywanie cen: Ceny P2P odzwierciedlają podaż/popyt w czasie rzeczywistym w CER
- Automatyzacja: zero ręcznych operacji rozliczeń, uzgodnień, płatności
- Interoperacyjność: otwarte standardy (ERC-20, ERC-1155) dla wymiennych tokenów energetycznych
Architektura systemu handlu energią P2P
Kompletny system handlu energią P2P na blockchainie jest podzielony na pięć odrębnych warstw, każda z określonymi obowiązkami i odpowiednimi technologiami.
Kompletny stos architektoniczny
┌─────────────────────────────────────────────────────────────────────────┐
│ LAYER 5: UI / DASHBOARD │
│ React / Angular app • Prosumer wallet • Portale CER │
├─────────────────────────────────────────────────────────────────────────┤
│ LAYER 4: SMART CONTRACT │
│ EnergyToken (ERC-20) • OrderBook • EnergyMarketplace │
│ Settlement • CarbonCredit • ProducerNFT (ERC-721) │
│ Blockchain: Polygon zkEVM / Energy Web Chain / Hyperledger Besu │
├─────────────────────────────────────────────────────────────────────────┤
│ LAYER 3: ORACLE LAYER │
│ Chainlink (prezzi grid) • Smart Meter Oracle (letture DLMS) │
│ DSO Constraint Oracle (capacity limits) • Weather Oracle │
├─────────────────────────────────────────────────────────────────────────┤
│ LAYER 2: INTEGRATION MIDDLEWARE │
│ FastAPI backend • DLMS/COSEM adapter • DSO API client │
│ GSE CACER connector • MQTT broker • InfluxDB time-series │
├─────────────────────────────────────────────────────────────────────────┤
│ LAYER 1: FIELD DEVICES │
│ Smart meter (IEC 62056) • Inverter FV • BESS controller │
│ EV charger (OCPP) • CER gateway • RTU / IED │
└─────────────────────────────────────────────────────────────────────────┘
Przebieg transakcji P2P
Oto jak działa pojedyncza transakcja handlu energią, od pomiaru fizycznego po płatność:
Smart Meter (Prosumer A)
│
├─► Lettura DLMS/COSEM ogni 15 minuti
│ IEC 62056-21 / OBIS codes
│
▼
Smart Meter Oracle (backend FastAPI)
│
├─► Valida dati (firma crittografica del meter)
├─► Aggrega energia prodotta nell'intervallo
├─► Chiama oracle contract: reportProduction(meterId, wh, timestamp)
│
▼
Oracle Smart Contract (on-chain)
│
├─► Verifica firma meter
├─► Aggiorna ProductionRegistry[meterId]
├─► Minta EnergyToken (EWT) = wh prodotte
│ 1 EWT = 1 Wh di energia rinnovabile certificata
│
▼
EnergyMarketplace Contract
│
├─► Prosumer A posta offerta: 50 EWT @ 0.08 EUR/EWT
├─► OrderBook matching con Consumer B: 50 EWT @ 0.09 EUR/EWT
├─► Verifica vincoli DSO: capacity disponibile sulla cabina? SI
│
▼
Settlement Contract
│
├─► Trasferisce 50 EWT da A a B
├─► Trasferisce 4 EUR (stablecoin) da B ad A
├─► Emette evento Trade(A, B, 50, 0.08, timestamp)
├─► Aggiorna CarbonCredit Registry (+50g CO2 evitata)
│
▼
DSO API (e-distribuzione / DSO locale)
│
└─► Notifica transazione per riconciliazione fisica
POST /api/v1/p2p-transactions
{ "from": "POD-IT001E...", "to": "POD-IT001E...", "wh": 50 }
Wybór Blockchain: porównanie według przypadku użycia energii
Nie wszystkie łańcuchy bloków są sobie równe w handlu energią P2P. Wymagania specyficzne dla branży - wysoka przepustowość mikrotransakcji, bardzo niskie koszty gazu, zgodność z przepisami, tożsamość uczestników – prowadzą do precyzyjnych wyborów architektonicznych.
Tabela porównawcza
| Łańcuch bloków | TPS | Koszt gazu (tx) | Zamiar | Tożsamość | Nadaje się do CER |
|---|---|---|---|---|---|
| Sieć główna Ethereum | 15-30 | 2-50 dolarów | ~12 minut | Anonimowy | Nie (za drogie) |
| Wielokątny punkt sprzedaży | 7000 | 0,001-0,01 USD | ~2 sek | Anonimowy | Tak (programowanie/testowanie) |
| Wielokąt zkEVM | 2000+ | 0,01-0,05 USD | ~1 min (dowód ZK) | Anonimowy + ZK | Tak (prywatność) |
| Arbitrum Jeden | 4000+ | 0,001-0,02 USD | ~1 sek | Anonimowy | Si |
| Łańcuch sieci energetycznej | 3000 | ~0 dolarów | ~5 sek | DID + SSI | Optymalny |
| Hyperledger Besu | 1000+ | $0 | <1 sek | Dozwolone | Tak (korporacja) |
| Tkanina Hyperledger | 3500 | $0 | <1 sek | MSP+X.509 | Tak (B2B) |
Rekomendacja dla CER Italiana
Zalecany stos: Energy Web Chain + Polygon zkEVM
Łańcuch sieci energetycznej (EWC) oraz publiczny blockchain oparty na Proof of Authority, specjalnie zaprojektowane dla sektora energetycznego. Natywnie obsługuje framework EW-ZROBIŁ dla zdecentralizowanej tożsamości prosumenckiej (zgodny z eIDAS 2.0), ma praktycznie zerowe koszty transakcyjne (walidatory są przedsiębiorstwami regulowanymi) i już tak jest wykorzystywane przez Siemens, Shell, Volkswagen i ponad 100 organizacji energetycznych.
W celu zapewnienia prywatności danych konsumentów (wymóg RODO) jest on stosowany Wielokąt zkEVM jak L2 z dowodami wiedzy zerowej: dane dotyczące zużycia pozostają prywatne (poza łańcuchem), ale ich ważność jest sprawdzana w łańcuchu bez ujawniania rzeczywistych wartości.
Wdrożenie Smart Kontraktu w Solidity
Wdrażamy kompletny system inteligentnych kontraktów do handlu energią P2P. Projekt jest następujący wzór Diament / Pełnomocnik dla możliwości aktualizacji i wzoru ERC-20 + rozliczenie celne za żetony energii.
1. Token Energii (ERC-20): Token Energii
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
/**
* @title EnergyToken (EWT)
* @notice Token ERC-20 che rappresenta 1 Wh di energia rinnovabile certificata.
* Mintato dall'oracle quando lo smart meter registra produzione verificata.
* Bruciato (burned) al momento del settlement fisico con il DSO.
*/
contract EnergyToken is ERC20, AccessControl, Pausable {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
bytes32 public constant ORACLE_ROLE = keccak256("ORACLE_ROLE");
// Metadata certificazione rinnovabile
struct EnergyBatch {
uint256 timestamp;
string sourceType; // "SOLAR", "WIND", "HYDRO"
string location; // codice CER (es. "IT-CER-PG-001")
uint256 co2Avoided; // grammi CO2 evitata per Wh
}
mapping(uint256 => EnergyBatch) public batches; // batchId => metadata
mapping(address => uint256) public producerBatch; // prosumer => ultimo batchId
uint256 public batchCounter;
// Registry prosumer certificati (EW-DID o indirizzo Ethereum)
mapping(address => bool) public certifiedProducers;
mapping(address => string) public producerDID; // Decentralized Identifier
event EnergyMinted(
address indexed producer,
uint256 indexed batchId,
uint256 amount, // Wh
string sourceType,
uint256 co2Avoided
);
event ProducerCertified(address indexed producer, string did);
constructor() ERC20("EnergyWh Token", "EWT") {
_grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
_grantRole(MINTER_ROLE, msg.sender);
}
/**
* @notice Certifica un prosumer dopo verifica KYC/DID fuori catena.
* Solo admin può farlo (utility o GSE delegate).
*/
function certifyProducer(
address producer,
string calldata did
) external onlyRole(DEFAULT_ADMIN_ROLE) {
certifiedProducers[producer] = true;
producerDID[producer] = did;
emit ProducerCertified(producer, did);
}
/**
* @notice Minta EWT in base alla lettura verificata dello smart meter.
* Chiamato dall'oracle dopo validazione dati DLMS/COSEM.
* @param producer Indirizzo wallet del prosumer
* @param whAmount Energia prodotta in Wh (precision: intera, no decimali)
* @param sourceType Tipo fonte: "SOLAR", "WIND", ecc.
* @param location Codice CER di appartenenza
* @param co2PerWh Grammi CO2 evitata per Wh (dipende dalla fonte)
*/
function mintEnergy(
address producer,
uint256 whAmount,
string calldata sourceType,
string calldata location,
uint256 co2PerWh
) external onlyRole(MINTER_ROLE) whenNotPaused {
require(certifiedProducers[producer], "EWT: producer non certificato");
require(whAmount > 0, "EWT: quantità zero non valida");
batchCounter++;
batches[batchCounter] = EnergyBatch({
timestamp: block.timestamp,
sourceType: sourceType,
location: location,
co2Avoided: whAmount * co2PerWh
});
producerBatch[producer] = batchCounter;
_mint(producer, whAmount);
emit EnergyMinted(producer, batchCounter, whAmount, sourceType, whAmount * co2PerWh);
}
/**
* @notice Brucia EWT dopo il settlement fisico con il DSO.
* Garantisce che ogni token sia usato una sola volta.
*/
function burnSettled(
address holder,
uint256 amount
) external onlyRole(BURNER_ROLE) {
_burn(holder, amount);
}
function pause() external onlyRole(DEFAULT_ADMIN_ROLE) { _pause(); }
function unpause() external onlyRole(DEFAULT_ADMIN_ROLE) { _unpause(); }
}
2. Księga zamówień: Mechanizm dopasowywania ofert
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
/**
* @title EnergyOrderBook
* @notice OrderBook on-chain per offerte di vendita e acquisto di energia.
* Supporta aste continue (CDA - Continuous Double Auction).
* Ottimizzato per basse latenze su L2 (Polygon / Arbitrum).
*/
contract EnergyOrderBook {
enum OrderType { BUY, SELL }
enum OrderStatus { OPEN, FILLED, CANCELLED, PARTIAL }
struct Order {
uint256 id;
address trader;
OrderType orderType;
uint256 whAmount; // Wh offerti/richiesti
uint256 pricePerWh; // EUR in wei (usando stablecoin 18 decimali)
uint256 minFillAmount; // minimo parziale accettabile
uint256 expiresAt; // timestamp scadenza ordine
uint256 filledAmount; // Wh già eseguiti
OrderStatus status;
string cerCode; // CER di appartenenza (vincolo geografico)
bytes gridConstraintSig; // firma DSO oracle su capacity disponibile
}
mapping(uint256 => Order) public orders;
uint256 public orderCounter;
// Sorted order books (semplificato - in produzione usa RB-tree o heap)
uint256[] public sellOrderIds; // ordinati per prezzo ASC
uint256[] public buyOrderIds; // ordinati per prezzo DESC
event OrderPlaced(
uint256 indexed orderId,
address indexed trader,
OrderType orderType,
uint256 whAmount,
uint256 pricePerWh
);
event OrderMatched(
uint256 indexed sellOrderId,
uint256 indexed buyOrderId,
uint256 whAmount,
uint256 price
);
event OrderCancelled(uint256 indexed orderId);
modifier onlyOrderOwner(uint256 orderId) {
require(orders[orderId].trader == msg.sender, "OB: non sei il proprietario");
_;
}
/**
* @notice Posta un ordine di vendita o acquisto energia.
* @param orderType BUY (0) o SELL (1)
* @param whAmount Quantità in Wh
* @param pricePerWh Prezzo in wei di stablecoin per Wh (es. 0.08 EUR = 80000000000000000)
* @param minFill Quantità minima parziale accettabile (0 = fill or kill)
* @param ttl Time-to-live in secondi (max 86400 = 1 giorno)
* @param cerCode Codice CER per vincolo geografico
*/
function placeOrder(
OrderType orderType,
uint256 whAmount,
uint256 pricePerWh,
uint256 minFill,
uint256 ttl,
string calldata cerCode
) external returns (uint256 orderId) {
require(whAmount >= 100, "OB: minimo 100 Wh per ordine");
require(pricePerWh > 0, "OB: prezzo zero non valido");
require(ttl <= 86400, "OB: TTL max 24 ore");
orderId = ++orderCounter;
orders[orderId] = Order({
id: orderId,
trader: msg.sender,
orderType: orderType,
whAmount: whAmount,
pricePerWh: pricePerWh,
minFillAmount: minFill,
expiresAt: block.timestamp + ttl,
filledAmount: 0,
status: OrderStatus.OPEN,
cerCode: cerCode,
gridConstraintSig: ""
});
if (orderType == OrderType.SELL) {
_insertSellOrder(orderId);
} else {
_insertBuyOrder(orderId);
}
emit OrderPlaced(orderId, msg.sender, orderType, whAmount, pricePerWh);
}
// Inserimento ordinato (bubble sort semplificato - in produzione usa heap)
function _insertSellOrder(uint256 newId) internal {
sellOrderIds.push(newId);
uint256 n = sellOrderIds.length;
for (uint256 i = n - 1; i > 0; i--) {
if (orders[sellOrderIds[i]].pricePerWh < orders[sellOrderIds[i-1]].pricePerWh) {
(sellOrderIds[i], sellOrderIds[i-1]) = (sellOrderIds[i-1], sellOrderIds[i]);
} else {
break;
}
}
}
function _insertBuyOrder(uint256 newId) internal {
buyOrderIds.push(newId);
uint256 n = buyOrderIds.length;
for (uint256 i = n - 1; i > 0; i--) {
if (orders[buyOrderIds[i]].pricePerWh > orders[buyOrderIds[i-1]].pricePerWh) {
(buyOrderIds[i], buyOrderIds[i-1]) = (buyOrderIds[i-1], buyOrderIds[i]);
} else {
break;
}
}
}
function cancelOrder(uint256 orderId) external onlyOrderOwner(orderId) {
Order storage o = orders[orderId];
require(o.status == OrderStatus.OPEN, "OB: ordine non annullabile");
o.status = OrderStatus.CANCELLED;
emit OrderCancelled(orderId);
}
}
3. Rynek energii: Umowa ramowa
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./EnergyToken.sol";
import "./EnergyOrderBook.sol";
/**
* @title EnergyMarketplace
* @notice Contratto principale per il trading P2P di energia nelle CER.
* Gestisce matching ordini, settlement EWT, verifica vincoli DSO,
* e distribuzione incentivi carbon credit.
*
* @dev Architettura:
* - EWT (EnergyToken) per i Wh di energia
* - EURC (Circle Euro stablecoin) per il pagamento in EUR
* - Escrow automatico durante il matching
* - Fee marketplace: 0.5% sul valore transazione (destinazione: CER treasury)
*/
contract EnergyMarketplace is ReentrancyGuard, AccessControl {
// =========== STATE VARIABLES ===========
EnergyToken public ewtToken;
IERC20 public stablecoin; // EURC o EURe
EnergyOrderBook public orderBook;
bytes32 public constant DSO_ORACLE_ROLE = keccak256("DSO_ORACLE_ROLE");
bytes32 public constant CER_ADMIN_ROLE = keccak256("CER_ADMIN_ROLE");
uint256 public constant FEE_BPS = 50; // 0.5% in basis points
uint256 public constant MIN_TRADE_WH = 100; // minimo 100 Wh per trade
uint256 public constant SETTLEMENT_WINDOW = 900; // 15 minuti max per settlement
// Parametri CER (impostati dall'amministratore)
struct CERConfig {
string cerCode;
address cerTreasury; // wallet CER che riceve le fee
uint256 maxCapacityWh; // capacità massima oraria cabina primaria
uint256 currentLoadWh; // carico attuale comunicato dal DSO oracle
bool active;
}
mapping(string => CERConfig) public cerConfigs;
// Trade registry per audit
struct Trade {
uint256 tradeId;
uint256 sellOrderId;
uint256 buyOrderId;
address seller;
address buyer;
uint256 whAmount;
uint256 pricePerWh;
uint256 totalValue; // in stablecoin wei
uint256 fee;
uint256 timestamp;
string cerCode;
}
mapping(uint256 => Trade) public trades;
uint256 public tradeCounter;
// Escrow: acquirente deposita stablecoin prima del matching
mapping(uint256 => uint256) public escrow; // orderId => importo bloccato
// Pending settlement per DSO reconciliation
mapping(uint256 => bool) public pendingDSOSettlement; // tradeId => settled
// =========== EVENTS ===========
event TradeExecuted(
uint256 indexed tradeId,
address indexed seller,
address indexed buyer,
uint256 whAmount,
uint256 pricePerWh,
string cerCode
);
event EscrowDeposited(uint256 indexed orderId, uint256 amount);
event EscrowReleased(uint256 indexed orderId, uint256 amount);
event DSOSettlementConfirmed(uint256 indexed tradeId);
event GridConstraintViolation(string cerCode, uint256 requestedWh, uint256 availableWh);
// =========== CONSTRUCTOR ===========
constructor(
address _ewtToken,
address _stablecoin,
address _orderBook
) {
ewtToken = EnergyToken(_ewtToken);
stablecoin = IERC20(_stablecoin);
orderBook = EnergyOrderBook(_orderBook);
_grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
}
// =========== CER MANAGEMENT ===========
function configureCER(
string calldata cerCode,
address treasury,
uint256 maxCapacityWh
) external onlyRole(CER_ADMIN_ROLE) {
cerConfigs[cerCode] = CERConfig({
cerCode: cerCode,
cerTreasury: treasury,
maxCapacityWh: maxCapacityWh,
currentLoadWh: 0,
active: true
});
}
/**
* @notice Aggiornamento carico attuale dalla rete, chiamato dall'oracle DSO.
* Previene transazioni che violerebbero i limiti di capacità.
*/
function updateGridLoad(
string calldata cerCode,
uint256 currentLoadWh
) external onlyRole(DSO_ORACLE_ROLE) {
cerConfigs[cerCode].currentLoadWh = currentLoadWh;
}
// =========== ESCROW ===========
/**
* @notice L'acquirente deposita stablecoin in escrow quando posta un BUY order.
* Garantisce la solvibilita prima del matching.
*/
function depositEscrow(
uint256 orderId,
uint256 amount
) external nonReentrant {
EnergyOrderBook.Order memory o = orderBook.orders(orderId);
require(o.trader == msg.sender, "MKT: non sei il proprietario dell'ordine");
require(o.orderType == EnergyOrderBook.OrderType.BUY, "MKT: solo per ordini BUY");
uint256 maxCost = o.whAmount * o.pricePerWh / 1e18;
require(amount >= maxCost, "MKT: escrow insufficiente");
require(stablecoin.transferFrom(msg.sender, address(this), amount), "MKT: transfer fallita");
escrow[orderId] += amount;
emit EscrowDeposited(orderId, amount);
}
// =========== MATCHING ENGINE ===========
/**
* @notice Esegue il matching tra un ordine di vendita e uno di acquisto.
* Verifica: prezzi compatibili, stessa CER, vincoli DSO, escrow sufficienti.
*
* @dev In produzione, questo viene chiamato da un keeper off-chain che monitora
* gli OrderPlaced events e trova le coppie compatibili.
*/
function matchOrders(
uint256 sellOrderId,
uint256 buyOrderId
) external nonReentrant {
EnergyOrderBook.Order memory sellOrder = orderBook.orders(sellOrderId);
EnergyOrderBook.Order memory buyOrder = orderBook.orders(buyOrderId);
// Validazioni base
require(
sellOrder.status == EnergyOrderBook.OrderStatus.OPEN &&
buyOrder.status == EnergyOrderBook.OrderStatus.OPEN,
"MKT: ordini non aperti"
);
require(
keccak256(bytes(sellOrder.cerCode)) == keccak256(bytes(buyOrder.cerCode)),
"MKT: CER diverse, trade non permesso"
);
require(
block.timestamp <= sellOrder.expiresAt &&
block.timestamp <= buyOrder.expiresAt,
"MKT: ordine/i scaduti"
);
// Verifica prezzo: sell price <= buy price (spread positivo)
require(
sellOrder.pricePerWh <= buyOrder.pricePerWh,
"MKT: prezzi incompatibili"
);
// Calcola quantità da eseguire (minimo tra i due ordini rimanenti)
uint256 sellRemaining = sellOrder.whAmount - sellOrder.filledAmount;
uint256 buyRemaining = buyOrder.whAmount - buyOrder.filledAmount;
uint256 tradeWh = sellRemaining < buyRemaining ? sellRemaining : buyRemaining;
require(tradeWh >= MIN_TRADE_WH, "MKT: quantità sotto il minimo");
// Verifica vincoli grid capacity DSO
string memory cerCode = sellOrder.cerCode;
CERConfig storage cer = cerConfigs[cerCode];
require(cer.active, "MKT: CER non attiva");
uint256 availableCapacity = cer.maxCapacityWh > cer.currentLoadWh
? cer.maxCapacityWh - cer.currentLoadWh
: 0;
if (tradeWh > availableCapacity) {
emit GridConstraintViolation(cerCode, tradeWh, availableCapacity);
revert("MKT: capacità grid insufficiente");
}
// Prezzo di esecuzione = midpoint (o prezzo sell per semplicità)
uint256 execPrice = sellOrder.pricePerWh;
// Calcola valore totale e fee
uint256 totalValue = tradeWh * execPrice / 1e18;
uint256 fee = totalValue * FEE_BPS / 10000;
uint256 sellerNet = totalValue - fee;
// Verifica EWT del venditore
require(
ewtToken.balanceOf(sellOrder.trader) >= tradeWh,
"MKT: venditore senza EWT sufficienti"
);
// Verifica escrow acquirente
require(escrow[buyOrderId] >= totalValue, "MKT: escrow acquirente insufficiente");
// ======= ESEGUI SETTLEMENT =======
// 1. Trasferisci EWT dal venditore all'acquirente
require(
ewtToken.transferFrom(sellOrder.trader, buyOrder.trader, tradeWh),
"MKT: trasferimento EWT fallito"
);
// 2. Trasferisci stablecoin da escrow al venditore (netto di fee)
escrow[buyOrderId] -= totalValue;
require(
stablecoin.transfer(sellOrder.trader, sellerNet),
"MKT: pagamento venditore fallito"
);
// 3. Fee alla treasury CER
if (fee > 0) {
require(
stablecoin.transfer(cer.cerTreasury, fee),
"MKT: fee treasury fallita"
);
}
// 4. Registra trade
tradeCounter++;
trades[tradeCounter] = Trade({
tradeId: tradeCounter,
sellOrderId: sellOrderId,
buyOrderId: buyOrderId,
seller: sellOrder.trader,
buyer: buyOrder.trader,
whAmount: tradeWh,
pricePerWh: execPrice,
totalValue: totalValue,
fee: fee,
timestamp: block.timestamp,
cerCode: cerCode
});
pendingDSOSettlement[tradeCounter] = true;
// 5. Aggiorna carico stimato CER
cer.currentLoadWh += tradeWh;
emit TradeExecuted(
tradeCounter,
sellOrder.trader,
buyOrder.trader,
tradeWh,
execPrice,
cerCode
);
}
/**
* @notice Conferma settlement fisico da parte del DSO.
* Brucia i token EWT dopo la riconciliazione fisica.
*/
function confirmDSOSettlement(
uint256 tradeId
) external onlyRole(DSO_ORACLE_ROLE) {
require(pendingDSOSettlement[tradeId], "MKT: trade già confermato");
Trade memory t = trades[tradeId];
// Brucia i token EWT dell'acquirente (energia "consumata" fisicamente)
ewtToken.burnSettled(t.buyer, t.whAmount);
pendingDSOSettlement[tradeId] = false;
emit DSOSettlementConfirmed(tradeId);
}
}
Uwaga na temat kosztów gazu i optymalizacji
W przykładzie umowa EnergyMarketplace wykorzystuje niezoptymalizowaną pamięć masową w celu zapewnienia przejrzystości edukacyjnej.
W środowisku produkcyjnym zmniejszenie liczby zapisów w pamięci ma kluczowe znaczenie. Techniki: użyj
calldata zamiast memory jeśli to możliwe, zmienne pakietu
w jednym uint256 z przesunięciem bitowym, a przede wszystkim z wykorzystaniem wydarzenia
zamiast przechowywania danych historycznych (dzienniki zdarzeń kosztują ~20 razy mniej niż przechowywanie).
W przypadku Polygon zkEVM szacowany koszt gazu dla a matchOrders() kompletne i ok
150 000 gazu, co stanowi równowartość około 0,03 EUR przy aktualnej cenie MATIC.
Oracle Design: Dane inteligentnych liczników w łańcuchu
Podstawowy problem wyroczni blockchain w kontekście energetycznym i certyfikacji rzeczywista produkcja: jak zapewnić, że Wh wybite jako EWT faktycznie odpowiada energii fizyka wytworzona i zmierzona przez certyfikowany inteligentny licznik?
Architektura wielowarstwowa Oracle
# oracle/smart_meter_oracle.py
# Oracle Python che legge smart meter DLMS/COSEM e invia dati on-chain
import asyncio
import hashlib
import json
import time
from dataclasses import dataclass
from typing import Optional
from dlms_cosem import DlmsConnection, Obis # libreria Python DLMS
from eth_account import Account
from web3 import AsyncWeb3
from web3.middleware import SignAndSendRawMiddlewareBuilder
# ======= CONFIGURAZIONE =======
ORACLE_PRIVATE_KEY = "0x..." # in produzione: HashiCorp Vault / AWS KMS
ENERGY_TOKEN_ABI = json.load(open("abi/EnergyToken.json"))
ENERGY_TOKEN_ADDR = "0x..."
RPC_URL = "https://rpc.energyweb.org"
# Parametri DLMS per smart meter italiano
# Standard: IEC 62056-21, OBIS codes per contatori bidirezionali
METER_IP = "192.168.1.100"
METER_PORT = 4059
METER_TIMEOUT = 10 # secondi
# OBIS codes standard per energia importata/esportata
OBIS_ACTIVE_EXPORT = Obis(1, 0, 2, 8, 0, 255) # kWh esportati totali
OBIS_ACTIVE_IMPORT = Obis(1, 0, 1, 8, 0, 255) # kWh importati totali
@dataclass
class MeterReading:
meter_id: str
timestamp: int
export_kwh: float # energia esportata (produzione immessa)
import_kwh: float # energia importata (consumo dalla rete)
net_wh: int # netto in Wh (positivo = produzione eccesso)
signature: bytes # firma ECDSA del meter (se disponibile)
async def read_smart_meter(meter_id: str) -> MeterReading:
"""
Legge lo smart meter via DLMS/COSEM e restituisce dati verificati.
Il contatore italiano e-distribuzione (Enel Hera Linea Group) supporta
IEC 62056-21 mode E con HDLC framing.
"""
conn = DlmsConnection(
ip=METER_IP,
port=METER_PORT,
timeout=METER_TIMEOUT
)
try:
await conn.connect()
# Autenticazione DLMS (password HLS o LLS secondo configurazione)
await conn.authenticate(level="lls", password="00000000")
export_kwh = await conn.get(OBIS_ACTIVE_EXPORT)
import_kwh = await conn.get(OBIS_ACTIVE_IMPORT)
net_wh = int((export_kwh - import_kwh) * 1000) # converti in Wh
# Firma del meter (se il contatore supporta firma ECDSA P-256)
# In alternativa, usa l'oracle signature del backend
reading = MeterReading(
meter_id=meter_id,
timestamp=int(time.time()),
export_kwh=float(export_kwh),
import_kwh=float(import_kwh),
net_wh=max(0, net_wh), # solo produzione eccedente
signature=b""
)
return reading
finally:
await conn.disconnect()
def sign_reading(reading: MeterReading, private_key: str) -> bytes:
"""
Firma la lettura con la chiave privata dell'oracle.
Il contratto verifica questa firma per autenticare la sorgente.
"""
account = Account.from_key(private_key)
message = hashlib.sha256(
f"{reading.meter_id}:{reading.timestamp}:{reading.net_wh}".encode()
).hexdigest()
signed = account.sign_message(
message_signable={"type": "string", "message": message}
)
return signed.signature
async def submit_to_blockchain(
reading: MeterReading,
w3: AsyncWeb3,
oracle_account: Account
) -> Optional[str]:
"""
Invia la lettura verificata al contratto EnergyToken per il mint.
Usa EIP-1559 per ottimizzare i gas cost su L2.
"""
if reading.net_wh < 100:
# Non vale la pena mintare meno di 100 Wh (under il minimo del marketplace)
print(f"Skip: lettura {reading.net_wh}Wh sotto la soglia minima")
return None
contract = w3.eth.contract(
address=ENERGY_TOKEN_ADDR,
abi=ENERGY_TOKEN_ABI
)
# Verifica il wallet del prosumer associato al meter ID
producer_address = await get_producer_address(reading.meter_id)
tx = await contract.functions.mintEnergy(
producer_address,
reading.net_wh,
"SOLAR",
"IT-CER-PG-001",
400 # grammi CO2 per kWh (media mix italiano, aggiornata ISPRA 2024)
).build_transaction({
"from": oracle_account.address,
"nonce": await w3.eth.get_transaction_count(oracle_account.address),
"maxFeePerGas": w3.to_wei("30", "gwei"),
"maxPriorityFeePerGas": w3.to_wei("2", "gwei"),
})
signed_tx = oracle_account.sign_transaction(tx)
tx_hash = await w3.eth.send_raw_transaction(signed_tx.raw_transaction)
receipt = await w3.eth.wait_for_transaction_receipt(tx_hash, timeout=120)
if receipt.status == 1:
print(f"Mintati {reading.net_wh} EWT per {producer_address} | TX: {tx_hash.hex()}")
return tx_hash.hex()
else:
print(f"Errore mint: TX {tx_hash.hex()} revertita")
return None
async def oracle_loop(interval_seconds: int = 900):
"""
Loop principale dell'oracle: legge il meter ogni 15 minuti (quarter-hour interval
allineato al settlement energetico del mercato elettrico italiano - MGP/MI IPEX).
"""
w3 = AsyncWeb3(AsyncWeb3.AsyncHTTPProvider(RPC_URL))
oracle_account = Account.from_key(ORACLE_PRIVATE_KEY)
meter_ids = await load_certified_meters() # da database GSE
print(f"Oracle avviato. Monitoraggio {len(meter_ids)} smart meter ogni {interval_seconds}s")
while True:
start = time.time()
for meter_id in meter_ids:
try:
reading = await read_smart_meter(meter_id)
tx_hash = await submit_to_blockchain(reading, w3, oracle_account)
await log_reading(reading, tx_hash)
except Exception as e:
print(f"Errore meter {meter_id}: {e}")
await alert_on_call(meter_id, str(e))
elapsed = time.time() - start
sleep_for = max(0, interval_seconds - elapsed)
await asyncio.sleep(sleep_for)
if __name__ == "__main__":
asyncio.run(oracle_loop())
Integracja z DSO: Network Constraints i Grid Operator API
Krytycznym punktem każdego systemu handlu energią P2P jest relacja z OSD (Operator Systemu Dystrybucyjnego) - głównie we Włoszech e-dystrybucja (grupa Enel), która zarządza 85% sieci dystrybucyjnej. Bez integracji z OSD handel on-chain jest po prostu niepołączoną abstrakcją finansową od rzeczywistej fizyki sieci.
ponieważ ograniczenia DSO nie podlegają negocjacjom
Fizyczne ograniczenia sieci dystrybucyjnej
- pojemność kabiny podstawowej: każda kabina WN/SN ma maksymalną pojemność transformacja (zwykle 40-100 MVA). Transakcje P2P odbywają się w obrębie obwodu pojedynczej podstacji podstawowej – takie jest również ograniczenie geograficzne włoskich jednostek CER.
- Zarządzanie zatorami: w godzinach szczytu fotowoltaicznego (11-15h latem), niektóre linie BT mogą zostać nasycone. OSD musi mieć możliwość blokowania lub ograniczania transakcji dla uniknąć lokalnych awarii zasilania.
- Balansowy: energia nie może fizycznie przepływać z jednego czujnika POD do drugiego bez uwzględnienia strat i bilansowania sieci. Handel finansowy P2P to a sieć wirtualna, a nie routing fizyczny.
- Oficjalny rozmiar: certyfikowany inteligentny licznik (e-dystrybucja lub strona trzecia). certyfikat) i jedyny prawnie obowiązujący środek rozliczeń regulacyjnych z GSE.
Klient Pythona dla API DSO
# integration/dso_client.py
# Client per l'API REST di e-distribuzione (simulata per sviluppo)
# In produzione: accesso tramite portale OpenData e-distribuzione o API B2B
import httpx
import asyncio
from dataclasses import dataclass
from typing import Optional
from datetime import datetime, timezone
DSO_API_BASE = "https://api.e-distribuzione.it/v2"
DSO_API_KEY = "..." # da variabile ambiente
@dataclass
class GridCapacity:
"""capacità grid disponibile per una cabina primaria in un intervallo temporale."""
substation_id: str # ID cabina primaria (es. "IT-RM-CP-0042")
timestamp_from: datetime
timestamp_to: datetime
total_capacity_kw: float # capacità totale MT
available_capacity_kw: float # disponibile per nuovi flussi
congestion_level: str # "LOW", "MEDIUM", "HIGH", "CRITICAL"
@dataclass
class P2PTradeNotification:
"""Notifica al DSO di un trade P2P eseguito on-chain, per riconciliazione."""
trade_id: str # ID on-chain della transazione
tx_hash: str # hash blockchain
pod_seller: str # POD del prosumer venditore (es. "IT001E12345678XX")
pod_buyer: str # POD del consumatore acquirente
wh_amount: int # Wh tradati
timestamp: datetime # timestamp del trade on-chain
cer_code: str # codice CER per riconciliazione GSE
class DSOClient:
"""
Client asincrono per comunicare con il Distribution System Operator.
Gestisce:
- Query capacità disponibile per il grid constraint oracle
- Notifica trade P2P per riconciliazione fisica
- Ricezione alert di congestion per blocco preventivo
"""
def __init__(self, api_base: str = DSO_API_BASE, api_key: str = DSO_API_KEY):
self.api_base = api_base
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json",
"Accept": "application/json"
}
async def get_grid_capacity(
self,
substation_id: str,
interval_minutes: int = 15
) -> GridCapacity:
"""
Interroga il DSO per la capacità attuale della cabina primaria.
Questa informazione alimenta il DSO oracle on-chain.
"""
async with httpx.AsyncClient(timeout=10.0) as client:
response = await client.get(
f"{self.api_base}/substations/{substation_id}/capacity",
headers=self.headers,
params={
"interval_minutes": interval_minutes,
"timestamp": datetime.now(timezone.utc).isoformat()
}
)
response.raise_for_status()
data = response.json()
return GridCapacity(
substation_id=data["substation_id"],
timestamp_from=datetime.fromisoformat(data["from"]),
timestamp_to=datetime.fromisoformat(data["to"]),
total_capacity_kw=data["capacity"]["total_kw"],
available_capacity_kw=data["capacity"]["available_kw"],
congestion_level=data["congestion"]["level"]
)
async def notify_p2p_trade(self, trade: P2PTradeNotification) -> bool:
"""
Notifica il DSO di un trade P2P completato on-chain.
Il DSO usa questa informazione per:
1. Riconciliazione con le letture degli smart meter
2. Aggiornamento del database CACER (tramite interfaccia GSE)
3. Eventuale richiesta di annullamento se vincoli violati ex-post
"""
async with httpx.AsyncClient(timeout=15.0) as client:
payload = {
"trade_id": trade.trade_id,
"tx_hash": trade.tx_hash,
"seller_pod": trade.pod_seller,
"buyer_pod": trade.pod_buyer,
"energy_wh": trade.wh_amount,
"timestamp": trade.timestamp.isoformat(),
"cer_code": trade.cer_code,
"source": "blockchain_p2p_marketplace"
}
response = await client.post(
f"{self.api_base}/p2p-settlements",
headers=self.headers,
json=payload
)
if response.status_code == 201:
print(f"Trade {trade.trade_id} notificato al DSO con successo")
return True
else:
print(f"Errore DSO: {response.status_code} - {response.text}")
return False
async def subscribe_congestion_alerts(
self,
substation_id: str,
callback # async callable
):
"""
WebSocket subscription per alert real-time di congestione.
Quando il DSO segnala un blocco, il keeper aggiorna il contratto
e blocca nuovi trade per quella CER.
"""
import websockets
ws_url = f"wss://api.e-distribuzione.it/v2/ws/congestion/{substation_id}"
async with websockets.connect(
ws_url,
extra_headers={"Authorization": f"Bearer {DSO_API_KEY}"}
) as ws:
async for message in ws:
alert = json.loads(message)
await callback(alert)
Testowanie z Hardhat: kompletny pakiet dla rynku
Kontrakty energetyczne zarządzają prawdziwą wartością: niezawodnością i krytyką. Zestaw testowy wyczerpujący z Kask i jedynym sposobem, aby zagwarantować poprawność marketplace przed wdrożeniem w sieci głównej.
// test/EnergyMarketplace.test.ts
import { expect } from "chai";
import { ethers } from "hardhat";
import { loadFixture } from "@nomicfoundation/hardhat-toolbox/network-helpers";
import { SignerWithAddress } from "@nomicfoundation/hardhat-ethers/signers";
describe("EnergyMarketplace - Suite Completa", function () {
// ========= FIXTURE =========
async function deployMarketplaceFixture() {
const [admin, dsoOracle, cerAdmin, prosumerA, prosumerB, consumer1, consumer2]
= await ethers.getSigners();
// Deploy EnergyToken
const EnergyToken = await ethers.getContractFactory("EnergyToken");
const ewtToken = await EnergyToken.deploy();
// Deploy mock ERC-20 stablecoin (EURC simulato)
const MockEURC = await ethers.getContractFactory("MockERC20");
const eurc = await MockEURC.deploy("Euro Coin", "EURC", 6); // 6 decimali come USDC
// Deploy OrderBook
const OrderBook = await ethers.getContractFactory("EnergyOrderBook");
const orderBook = await OrderBook.deploy();
// Deploy Marketplace
const Marketplace = await ethers.getContractFactory("EnergyMarketplace");
const marketplace = await Marketplace.deploy(
await ewtToken.getAddress(),
await eurc.getAddress(),
await orderBook.getAddress()
);
// Setup ruoli
const MINTER_ROLE = await ewtToken.MINTER_ROLE();
await ewtToken.grantRole(MINTER_ROLE, admin.address); // oracle minta
await marketplace.grantRole(
await marketplace.DSO_ORACLE_ROLE(),
dsoOracle.address
);
await marketplace.grantRole(
await marketplace.CER_ADMIN_ROLE(),
cerAdmin.address
);
// Certifica prosumer
await ewtToken.certifyProducer(prosumerA.address, "did:ewc:it:cer:prosumer-a");
await ewtToken.certifyProducer(prosumerB.address, "did:ewc:it:cer:prosumer-b");
// Configura CER
await marketplace.connect(cerAdmin).configureCER(
"IT-CER-PG-001",
admin.address, // treasury CER
1_000_000 // 1 MWh capacità max
);
// Minta EWT per prosumer A (simulazione lettura oracle)
await ewtToken.mintEnergy(
prosumerA.address,
5_000, // 5 kWh
"SOLAR",
"IT-CER-PG-001",
400
);
// Minta EURC per consumer1 (per l'escrow)
await eurc.mint(consumer1.address, ethers.parseUnits("100", 6)); // 100 EUR
return {
admin, dsoOracle, cerAdmin, prosumerA, prosumerB, consumer1, consumer2,
ewtToken, eurc, orderBook, marketplace
};
}
// ========= TEST: TOKEN MINT =========
describe("EnergyToken - Mint e Certifica", function () {
it("deve mintare EWT solo per prosumer certificati", async function () {
const { ewtToken, consumer1 } = await loadFixture(deployMarketplaceFixture);
await expect(
ewtToken.mintEnergy(consumer1.address, 1000, "SOLAR", "IT-CER-PG-001", 400)
).to.be.revertedWith("EWT: producer non certificato");
});
it("deve registrare i metadata del batch correttamente", async function () {
const { ewtToken, prosumerA } = await loadFixture(deployMarketplaceFixture);
const batchId = await ewtToken.producerBatch(prosumerA.address);
const batch = await ewtToken.batches(batchId);
expect(batch.sourceType).to.equal("SOLAR");
expect(batch.location).to.equal("IT-CER-PG-001");
expect(batch.co2Avoided).to.equal(5_000 * 400); // 5000 Wh * 400 gCO2/Wh
});
});
// ========= TEST: ORDINI E MATCHING =========
describe("Marketplace - Matching e Settlement", function () {
it("deve eseguire un trade completo con settlement corretto", async function () {
const {
admin, dsoOracle, prosumerA, consumer1,
ewtToken, eurc, marketplace, orderBook
} = await loadFixture(deployMarketplaceFixture);
// ProsumoA approva EWT per il marketplace
await ewtToken.connect(prosumerA).approve(
await marketplace.getAddress(),
5_000
);
// Posta ordine SELL: 2000 Wh @ 0.08 EUR/Wh
const pricePerWh = ethers.parseUnits("0.08", 18); // 18 decimali per compatibilità
const sellTx = await orderBook.connect(prosumerA).placeOrder(
1, // SELL
2_000,
pricePerWh,
0, // no partial fill
3600, // TTL 1 ora
"IT-CER-PG-001"
);
const sellReceipt = await sellTx.wait();
const sellOrderId = 1n; // primo ordine
// Consumer1 approva EURC per escrow e posta BUY
const buyTotalCost = 2_000n * pricePerWh / BigInt(1e18);
await eurc.connect(consumer1).approve(await marketplace.getAddress(), buyTotalCost);
const buyTx = await orderBook.connect(consumer1).placeOrder(
0, // BUY
2_000,
pricePerWh,
0,
3600,
"IT-CER-PG-001"
);
const buyOrderId = 2n;
// Deposita escrow
await marketplace.connect(consumer1).depositEscrow(buyOrderId, buyTotalCost);
// Aggiorna grid load (DSO oracle: capacità disponibile)
await marketplace.connect(dsoOracle).updateGridLoad("IT-CER-PG-001", 0);
// Snapshot balance prima del trade
const prosumerABalanceBefore = await eurc.balanceOf(prosumerA.address);
const consumer1EWTBefore = await ewtToken.balanceOf(consumer1.address);
// Esegui matching
await marketplace.connect(admin).matchOrders(sellOrderId, buyOrderId);
// Verifica bilanci dopo trade
const prosumerABalanceAfter = await eurc.balanceOf(prosumerA.address);
const consumer1EWTAfter = await ewtToken.balanceOf(consumer1.address);
// ProsumoA ha ricevuto EURC (netto fee 0.5%)
const expectedNet = buyTotalCost - (buyTotalCost * 50n / 10000n);
expect(prosumerABalanceAfter - prosumerABalanceBefore).to.equal(expectedNet);
// Consumer1 ha ricevuto 2000 EWT
expect(consumer1EWTAfter - consumer1EWTBefore).to.equal(2_000n);
});
it("deve rifiutare trade tra CER diverse", async function () {
const { prosumerA, consumer1, orderBook, marketplace }
= await loadFixture(deployMarketplaceFixture);
await orderBook.connect(prosumerA).placeOrder(1, 1000, ethers.parseUnits("0.08", 18), 0, 3600, "IT-CER-PG-001");
await orderBook.connect(consumer1).placeOrder(0, 1000, ethers.parseUnits("0.09", 18), 0, 3600, "IT-CER-RM-002");
await expect(
marketplace.matchOrders(1n, 2n)
).to.be.revertedWith("MKT: CER diverse, trade non permesso");
});
it("deve bloccare trade quando capacità grid e insufficiente", async function () {
const { admin, dsoOracle, prosumerA, consumer1, marketplace, orderBook, ewtToken, eurc }
= await loadFixture(deployMarketplaceFixture);
// Simula grid a piena capacità
await marketplace.connect(dsoOracle).updateGridLoad(
"IT-CER-PG-001",
999_000 // 999 kWh su 1000 kWh disponibili - solo 1 kWh libero
);
await ewtToken.connect(prosumerA).approve(await marketplace.getAddress(), 5000);
await orderBook.connect(prosumerA).placeOrder(1, 2000, ethers.parseUnits("0.08", 18), 0, 3600, "IT-CER-PG-001");
const pricePerWh = ethers.parseUnits("0.08", 18);
const escrowAmt = 2000n * pricePerWh / BigInt(1e18);
await eurc.connect(consumer1).approve(await marketplace.getAddress(), escrowAmt);
await orderBook.connect(consumer1).placeOrder(0, 2000, pricePerWh, 0, 3600, "IT-CER-PG-001");
await marketplace.connect(consumer1).depositEscrow(2n, escrowAmt);
await expect(
marketplace.connect(admin).matchOrders(1n, 2n)
).to.be.revertedWith("MKT: capacità grid insufficiente");
});
});
});
Ramy regulacyjne: UE i Włochy
Handel energią P2P na blockchainie działa na skrzyżowaniu dwóch istniejących ram regulacyjnych pokrywają się: energetyczny (dyrektywy UE i transpozycja włoska) i rynkowy finanse cyfrowe (MiCA, RODO). Zrozumienie ograniczeń regulacyjnych jest niezbędne do planowania system zgodny z prawem.
Kluczowe dyrektywy europejskie
Pakiet Czysta Energia (2018-2021): Podstawy prawne P2P
Il Pakiet Czystej Energii (CEP) Unii Europejskiej i ram regulacyjnych które legalnie umożliwiło handel energią P2P w całej UE. Odpowiednie filary:
- Dyrektywa dotycząca energii elektrycznej (UE) 2019/944: Sztuka. 15 – wyraźnie rozpoznaje prawo „aktywnych prosumentów” do sprzedaży wyprodukowanej we własnym zakresie energii, w tym za pośrednictwem Umowy P2P. Sztuka. 16 – reguluje obywatelskie wspólnoty energetyczne (CEC).
- Dyrektywa RED II (UE) 2018/2001: Sztuka. 22 – wprowadza „wspólnota energii odnawialnej” (CER) jako osoba prawna posiadająca prawo do produkować, konsumować, przechowywać i sprzedawać energię odnawialną.
- Dyrektywa RED III (UE) 2023/2413: Obowiązuje od listopada 2023 r., cel 42,5% energii odnawialnej do 2030 r. Wzmacnia prawa jednostek CER, upraszcza procedury autoryzacyjne, wprowadza pojęcie ułatwione „repowering”. Transpozycja krajowa: do maja 2025 r.
Ustawodawstwo włoskie: dekret legislacyjny 199/2021 i CER
| Czekam | Szczegóły regulacyjne | Wpływ na Blockchain P2P |
|---|---|---|
| Definicja CER | Osoba prawna posiadająca osobowość prawną, system max 1 MW, obwód stacji podstawowej WN/SN | Handel P2P w łańcuchu jest ograniczony do procesorów POD tej samej kabiny podstawowej – stałe ograniczenie |
| Zachęta GSE | Stawka premium ~110 EUR/MWh za energię współdzieloną + oszczędności w taryfach sieciowych | Rozliczenie blockchain musi zostać uzgodnione z portalem CACER GSE |
| Mierzyć | Inteligentny licznik e-dystrybucji certyfikowany jako jedyny ważny pomiar | Wyrocznia musi korzystać z danych z certyfikowanych liczników, a nie zgłaszanych samodzielnie |
| Przedmioty dozwolone | Osoby fizyczne, MŚP, agencje płatnicze, podmioty trzeciego sektora, spółdzielnie (po dekrecie legislacyjnym MASE z maja 2025 r.) | Portfele Blockchain muszą być powiązane ze zweryfikowaną tożsamością prawną (KYC) |
| Zachęty PNRR | 2,2 mld euro na inwestycje w CER (konkurs CACER lipiec-listopad 2025) | Możliwość finansowania infrastruktury blockchain + modernizacja inteligentnego licznika |
| Regulamin GSE CACER 2025 | Uproszczenie wydatków z mocą wsteczną, 30% zaliczki bezzwrotnej składki | Większa płynność początkowej inwestycji w system P2P |
MiCA i tokeny energetyczne: nie stanowią zabezpieczenia
Klasyfikacja prawna EnergyTokena (EWT)
Rozporządzenie MiCA (Rynki aktywów kryptograficznych, UE 2023/1114) w całości obowiązująca od grudnia 2024 r. klasyfikuje kryptowaluty na trzy kategorie: ART (tokeny oparte na aktywach), EMT (tokeny pieniądza elektronicznego) i „Inne tokeny”.
EnergyToken (EWT) opisany w tym artykule można sklasyfikować jako „token użytkowy” w kategorii „Inne tokeny”: reprezentuje fizyczna jednostka energii (1 EWT = 1 Wh), a nie oczekiwanie zysku. Klasyfikacja ta zwalnia go z bardziej rygorystycznych obowiązków MiCA dla ART/EMT, ale nadal wymaga:
- Opublikowano oficjalny dokument zawierający opis techniczny tokena
- Środki przeciwdziałania praniu pieniędzy (AMLD6) dla uczestników (KYC/AML)
- Powiadomienie właściwego organu krajowego (Bank of Italy / Consob), jeśli wolumen przekracza progi
La Moneta stabilna EURC używany do płatności oraz EMT wydany przez Circle with licencji MiCA i nie wymaga dalszej zgodności ze strony rynku.
RODO i prywatność: dane konsumentów w łańcuchu
Dane z inteligentnych liczników – ile kWh wytwarzam, kiedy i w jakim profilu czasowym – to dane osobowe zgodnie z RODO (orzeczenie TSUE C-434/16, Nowak). To tworzy zasadniczy paradoks w przypadku blockchainu: dane w łańcuchu są niezmienne, ale RODO gwarantuje „prawo do bycia zapomnianym” (art. 17). Jak to rozwiązano?
Prywatność z założenia: architektura pozałańcuchowa z dowodami ZK
# privacy/zkp_meter_proof.py
# Zero-Knowledge Proof per dati smart meter: dimostra che hai prodotto X Wh
# senza rivelare il profilo dettagliato di produzione.
# Usa circom + snarkjs via Python binding
"""
Schema del circuito ZK (pseudocodice circom):
template MeterProductionProof() {
// Input privati (non rivelati on-chain)
signal private input raw_readings[96]; // 15-min interval per 24h
signal private input meter_secret; // segreto del meter (HMAC key)
// Input pubblici (on-chain verificabili)
signal input total_wh_claimed; // Wh che il prosumer dichiara
signal input meter_id_hash; // hash dell'ID meter (anonimizzato)
signal input day_timestamp; // giorno a cui si riferisce
// Output: prova che sum(raw_readings) == total_wh_claimed
signal output valid;
var sum = 0;
for (var i = 0; i < 96; i++) {
sum += raw_readings[i];
}
// Vincolo: la somma delle letture private = il totale dichiarato
sum === total_wh_claimed;
valid <== 1;
}
"""
from py_snark import Prover, Verifier
import hashlib
import json
class ZKMeterProver:
"""
Genera prove ZK per dati smart meter.
Il prosumer dimostra al contratto che ha prodotto X Wh
senza rivelare il profilo temporale delle sue letture.
"""
def __init__(self, circuit_wasm: str, zkey: str):
self.prover = Prover(circuit_wasm, zkey)
self.verifier = Verifier()
def generate_proof(
self,
raw_readings: list[float], # letture ogni 15 minuti (privati)
meter_id: str, # ID meter (privato)
day_timestamp: int # timestamp del giorno (pubblico)
) -> dict:
"""
Genera una prova ZK che attesta la produzione totale senza
rivelare le singole letture.
"""
total_wh = int(sum(raw_readings))
meter_id_hash = hashlib.sha256(meter_id.encode()).hexdigest()
# Input privati (non escono dal dispositivo del prosumer)
private_inputs = {
"raw_readings": [int(r) for r in raw_readings],
"meter_secret": int(hashlib.md5(meter_id.encode()).hexdigest(), 16) % (2**253)
}
# Input pubblici (inviati on-chain con la prova)
public_inputs = {
"total_wh_claimed": total_wh,
"meter_id_hash": int(meter_id_hash, 16) % (2**253),
"day_timestamp": day_timestamp
}
proof = self.prover.generate_proof(
private_inputs=private_inputs,
public_inputs=public_inputs
)
return {
"proof": proof.to_solidity(), # formato per verifica on-chain
"public_inputs": public_inputs,
"total_wh": total_wh
}
def verify_proof(self, proof: dict, public_inputs: dict) -> bool:
"""Verifica la prova (normalmente eseguita dal contratto Verifier on-chain)."""
return self.verifier.verify(proof["proof"], public_inputs)
# ====== CONTRATTO VERIFIER (Solidity, generato da snarkjs) ======
# Il contratto Groth16Verifier.sol e generato automaticamente da:
# $ snarkjs zkey export solidityverifier circuit_final.zkey verifier.sol
#
# Nel contratto EnergyMarketplace, il mint avviene solo se la prova e valida:
#
# function mintWithZKProof(
# uint[2] calldata _pA,
# uint[2][2] calldata _pB,
# uint[2] calldata _pC,
# uint[3] calldata _pubSignals // [total_wh, meter_hash, timestamp]
# ) external {
# require(groth16Verifier.verifyProof(_pA, _pB, _pC, _pubSignals), "ZK: prova non valida");
# uint256 totalWh = _pubSignals[0];
# address producer = meterHashToProducer[bytes32(_pubSignals[1])];
# _mintEnergy(producer, totalWh, ...);
# }
Wytyczne EROD 2025 dotyczące Blockchain i RODO
W dniu 14 kwietnia 2025 r. o godzEuropejska Rada Ochrony Danych (EROD) opublikował zaktualizowane wytyczne dotyczące blockchain i RODO. Kluczowe punkty handlu energią P2P:
- Dane osobowe w łańcuchu: skróty tożsamości, adresy portfeli powiązane z osobami fizycznymi i dane dotyczące zużycia są danymi osobowymi – nigdy nie powinny być zapisywane w łańcuchu czystym tekstem
- Pseudonimizacja: dopuszczalne jest używanie adresów Ethereum jako pseudonimu jeśli mapowanie tożsamości portfela jest przechowywane poza łańcuchem i z ograniczonym dostępem
- Prawo do bycia zapomnianym: możliwe do wdrożenia z usuwaniem danych poza łańcuchem + zerowaniem w łańcuchu tokenów (spalenie + unieważnienie certyfikatu) - transakcja blockchain pozostaje niezmienna, ale pozbawiona znaczenia
- Administrator danych: dla jednostki CER z blockchainem oraz podmiotem, który nią zarządza mapowanie tożsamości Oracle i portfela – w przypadku przetwarzania danych na dużą skalę należy wyznaczyć inspektora ochrony danych
Studium przypadku: Brooklyn Microgrid i CER Italiana
Mikrosieć Brooklynu – LO3 Energy (2016-2024)
Il Mikrosieć Brooklynu, pionierski projekt realizowany we współpracy z LO3 Energy wspólnie z firmą Siemens był to pierwszy w historii pilotażowy handel energią P2P na blockchainie. Aktywowano w 2016 r. w dzielnicy Park Slope na Brooklynie (Nowy Jork) wzięło w nim udział niecałe 60 prosumentów początkowo rozrosła się do setek wirtualnych uczestników.
Wnioski wyciągnięte z mikrosieci Brooklyn
- Kluczowa kwestia regulacyjna: w USA przedsiębiorstwa użyteczności publicznej mają monopol legalna sprzedaż energii elektrycznej. Nawet przy gotowej technologii uczestnicy mogliby to zrobić tylko wymiana Certyfikaty Energii Odnawialnej (REC), a nie energia fizyczna. Handel „P2P” miał charakter wyłącznie finansowy.
- Platforma egzergii: LO3 opracowało warstwę blockchain z uprawnieniami specyficzne dla energii. W Europie podobne podejście przyjęła Energy Web Foundation z Energy Web Chain, zoptymalizowanym pod kątem regulowanych przypadków użycia.
- Integracja inteligentnego licznika: głównym wąskim gardłem nie był blockchain ale współpracujący ze starszymi inteligentnymi licznikami. Amerykańskie liczniki nie obsługiwały odczyty w czasie rzeczywistym – limit rozwiązany w Europie dzięki dyrektywie UE dotyczącej inteligentnych liczników.
- Doświadczenia użytkownika: barierą była złożoność portfela kryptowalutowego ogromne dla nietechnicznych prosumentów. Rozwiązanie: portfele trzymane z boku platformy z interfejsem użytkownika podobnym do aplikacji bankowej.
Studium przypadku: Pilotażowy CER w Perugii – scenariusz hipotetyczny
Modelujemy konkretny przypadek użycia włoskiej jednostki CER z handlem P2P na blockchainie, w oparciu o rzeczywiste parametry ram GSE 2025:
# simulation/cer_p2p_simulation.py
# Simulazione trading P2P per CER italiana con 50 prosumer e 200 consumer
import numpy as np
import pandas as pd
from datetime import datetime, timedelta
import matplotlib.pyplot as plt # per visualizzazione risultati
# ======= PARAMETRI CER PILOTA PERUGIA =======
CER_CONFIG = {
"name": "CER Perugia Centro - Cabina 042",
"cer_code": "IT-CER-PG-042",
"max_capacity_kw": 500, # 500 kW capacità cabina
"n_prosumer": 50, # 50 prosumer con FV
"n_consumer": 200, # 200 soli consumatori
"avg_fv_kw": 4.5, # media 4.5 kWp per prosumer (tipico residenziale)
"incentivo_gse": 0.110, # 110 EUR/MWh tariffa premio GSE
"p2p_price_range": (0.07, 0.12), # range prezzo P2P in EUR/kWh
"grid_price_sell": 0.05, # prezzo vendita a rete (in assenza P2P)
"grid_price_buy": 0.30, # prezzo acquisto da rete (consumatori)
}
def simulate_solar_production(n_prosumer: int, avg_kw: float, hours: int = 24) -> np.ndarray:
"""Simula produzione FV per un giorno estivo tipico (luglio, Perugia)."""
# Profilo solare tipico: curva gaussiana centrata alle 13:00
time_hours = np.linspace(0, 24, hours)
solar_curve = np.maximum(0, avg_kw * np.exp(-((time_hours - 13) ** 2) / (2 * 3**2)))
# Variabilità tra prosumer (orientamento, ombreggiature)
productions = np.random.normal(
loc=solar_curve,
scale=solar_curve * 0.15, # 15% variabilità
size=(n_prosumer, hours)
)
return np.maximum(0, productions)
def simulate_consumption(n_consumer: int, hours: int = 24) -> np.ndarray:
"""Simula consumo residenziale tipico (profilo ARERA 2025)."""
# Profilo bimodale: picco mattina (7-9) e sera (18-22)
time_hours = np.linspace(0, 24, hours)
base_kw = 0.8
morning_peak = 0.4 * np.exp(-((time_hours - 8) ** 2) / (2 * 1.5**2))
evening_peak = 0.6 * np.exp(-((time_hours - 20) ** 2) / (2 * 2**2))
profile = base_kw + morning_peak + evening_peak
consumptions = np.random.normal(
loc=profile,
scale=profile * 0.20,
size=(n_consumer, hours)
)
return np.maximum(0, consumptions)
def run_p2p_market_simulation() -> dict:
"""Esegui simulazione mercato P2P per 1 giorno."""
config = CER_CONFIG
hours = 24
productions = simulate_solar_production(config["n_prosumer"], config["avg_fv_kw"], hours)
consumptions = simulate_consumption(config["n_consumer"], hours)
# Surplus aggregato dei prosumer per ora
surplus_per_hour = productions.sum(axis=0) * 1000 # in Wh
# Domanda aggregata dei consumer per ora
demand_per_hour = consumptions.sum(axis=0) * 1000 # in Wh
# Simula P2P matching per ogni ora
results = []
total_p2p_wh = 0
total_p2p_value = 0
total_grid_wh = 0
for h in range(hours):
surplus = surplus_per_hour[h]
demand = demand_per_hour[h]
# Quantità P2P = minimo tra surplus e domanda
p2p_wh = min(surplus, demand)
p2p_price = np.random.uniform(*config["p2p_price_range"]) / 1000 # EUR/Wh
# Valore P2P transazione
p2p_value = p2p_wh * p2p_price
# Energia residua venduta a rete o acquistata da rete
grid_sell_wh = max(0, surplus - p2p_wh) # eccesso non assorbito P2P
grid_buy_wh = max(0, demand - p2p_wh) # deficit non coperto P2P
total_p2p_wh += p2p_wh
total_p2p_value += p2p_value
total_grid_wh += grid_buy_wh
results.append({
"hour": h,
"surplus_wh": surplus,
"demand_wh": demand,
"p2p_wh": p2p_wh,
"p2p_price": p2p_price * 1000, # EUR/kWh per output
"p2p_value_eur": p2p_value,
"grid_sell_wh": grid_sell_wh,
"grid_buy_wh": grid_buy_wh
})
# Calcola risparmio P2P vs scenario tradizionale
# Scenario tradizionale: tutto venduto a rete, tutto acquistato da rete
traditional_value_sell = total_p2p_wh * config["grid_price_sell"] / 1000
traditional_value_buy = total_p2p_wh * config["grid_price_buy"] / 1000
p2p_benefit = total_p2p_value - traditional_value_sell # venditore guadagna più
# Carbon credits: 400 gCO2/kWh mix italiano
co2_avoided_kg = total_p2p_wh * 400 / 1_000_000 # kg CO2
summary = {
"total_p2p_wh": total_p2p_wh,
"total_p2p_kwh": total_p2p_wh / 1000,
"total_p2p_value": total_p2p_value,
"average_p2p_price": total_p2p_value / total_p2p_wh * 1000 if total_p2p_wh > 0 else 0,
"n_transactions": len([r for r in results if r["p2p_wh"] > 0]),
"p2p_benefit_eur": p2p_benefit,
"co2_avoided_kg": co2_avoided_kg,
"gse_incentivo": total_p2p_wh * config["incentivo_gse"] / 1_000_000, # EUR
"hourly_data": results
}
return summary
# Esegui simulazione
results = run_p2p_market_simulation()
print(f"=== Simulazione CER Perugia - 1 giorno estivo ===")
print(f"Energia P2P tradita: {results['total_p2p_kwh']:.1f} kWh")
print(f"Valore mercato P2P: {results['total_p2p_value']:.2f} EUR")
print(f"Prezzo medio P2P: {results['average_p2p_price']:.4f} EUR/kWh")
print(f"Beneficio vs rete: {results['p2p_benefit_eur']:.2f} EUR")
print(f"CO2 evitata: {results['co2_avoided_kg']:.1f} kg")
print(f"Incentivo GSE: {results['gse_incentivo']:.2f} EUR")
print(f"Transazioni simulate: {results['n_transactions']}")
Typowe wyniki symulacji
| Metryczny | Scenariusz łańcucha bloków P2P | Scenariusz tradycyjny (GSE) | Korzyści P2P |
|---|---|---|---|
| Wspólna energia/dzień | 850-1200 kWh | 850-1200 kWh | Identyczny (fizycznie) |
| Średnia cena płacona przez prosumentów | 90-100 EUR/MWh | 50 EUR/MWh (tylko nagroda GSE) | +40-50 EUR/MWh dla prosumenta |
| Średnia cena płacona przez konsumentów | 90-100 EUR/MWh | 300+ EUR/MWh (taryfa detaliczna) | -200 EUR/MWh dla konsumenta |
| Szybkość osadzania | < 30 sekund | 30-90 dni | Natychmiastowa płynność |
| Koszty pośrednictwa | 0,5% (opłata skarbowa CER) | 5-15% (media + OSD) | Oszczędności 4-14% |
| Przezroczystość | Na łańcuchu, weryfikowalne | Portal GSE, opóźniony | Audyty w czasie rzeczywistym |
Tokenomika: tokeny energetyczne, kredyty węglowe i zachęty prosumenckie
Dobrze zaprojektowany i podstawowy system tokenomiczny zapewniający zrównoważony rozwój ekonomia rynku P2P i odpowiednie zachęty dla wszystkich uczestników.
Struktura tokena rynkowego
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
/**
* @title CarbonCreditToken (CCT)
* @notice Token che rappresenta 1 kg di CO2 evitata dalla produzione rinnovabile.
* Emesso automaticamente a ogni mint di EWT (proporzionale alla fonte).
* Vendibile su carbon credit marketplace (Toucan Protocol, Verrà Bridge).
*/
contract CarbonCreditToken is ERC20, AccessControl {
bytes32 public constant CCT_MINTER = keccak256("CCT_MINTER");
// Fattori di emissione per fonte (gCO2 evitata per Wh)
mapping(string => uint256) public co2FactorPerWh;
constructor() ERC20("Carbon Credit Token", "CCT") {
_grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
// Fattori ISPRA 2024 aggiornati
co2FactorPerWh["SOLAR"] = 400; // gCO2/kWh evitata vs mix italiano
co2FactorPerWh["WIND"] = 400;
co2FactorPerWh["HYDRO"] = 350;
co2FactorPerWh["BIOMASS"] = 100; // netta (ciclo carbonio)
}
/**
* @notice Minta CCT proporzionalmente alla produzione rinnovabile.
* 1 CCT = 1 kg CO2 evitata = 0.001 TCO2 (tonne CO2)
*
* @param recipient Prosumer che riceve il carbon credit
* @param whProduced Energia prodotta in Wh
* @param sourceType Tipo fonte per calcolo fattore emissione
*/
function mintCredits(
address recipient,
uint256 whProduced,
string calldata sourceType
) external onlyRole(CCT_MINTER) {
uint256 factor = co2FactorPerWh[sourceType];
require(factor > 0, "CCT: fonte sconosciuta");
// gCO2 / 1000 = kgCO2 = numero di CCT
uint256 cctAmount = whProduced * factor / 1_000_000; // gCO2 -> kgCO2
if (cctAmount > 0) {
_mint(recipient, cctAmount * 1e18); // 18 decimali per compatibilità ERC-20
}
}
}
// ======= TOKENOMICS SUMMARY =======
/*
Flusso token per un prosumer con 4 kWp FV che produce 20 kWh in un giorno estivo:
1. PRODUZIONE: Smart meter misura 20.000 Wh esportati
2. MINT EWT: Oracle minta 20.000 EWT (1 EWT = 1 Wh)
3. MINT CCT: 20.000 Wh * 400 gCO2/kWh / 1.000.000 = 8 CCT (8 kg CO2 evitata)
4. TRADE P2P: Vende 15.000 EWT @ 0.095 EUR/kWh sul marketplace
= 1.425 EUR gross
- fee 0.5% = 7.12 EUR alla treasury CER
= 1.417.88 EUR netti al prosumer
5. RESIDUO: 5.000 EWT venduti a rete tramite GSE
= 0.05 EUR/kWh * 5 kWh = 0.25 EUR + incentivo GSE 0.11 EUR/kWh = 0.55 EUR
6. CARBON CREDITS: 8 CCT venduti su Toucan Protocol (mercato volontario ~12 USD/tCO2)
= 8 kg * 0.012 USD/kg = 0.096 USD
TOTALE GIORNALIERO: 1.417.88 + 0.55 + 0.096 = ~1.96 EUR (vs 0.55 EUR senza P2P)
Beneficio P2P: +255% rispetto al solo incentivo GSE
Nota: prezzi illustrativi basati su stime di mercato 2025
*/
Wydajność i skalowanie: przepustowość prawdziwego CER
Ile transakcji na sekundę potrzeba dla jednostki CER? Liczby są zaskakująco łatwe do opanowania: nawet duża jednostka CER z 1000 prosumentów generuje najwyżej kilkadziesiąt transakcji co 15 minut. Prawdziwy wymóg skalowalności pojawia się, gdy mówimy o agregatorach regionalnych z tysiącami jednostek CER.
Oszacowanie niezbędnej przepustowości
| Scenariusz | Uczestnicy | Handel/15min | Wymagany TPS | Odpowiedni łańcuch bloków |
|---|---|---|---|---|
| CER mały | 50 prosumentów + 200 konsumentów | 10-50 | < 0,1 | Dowolny L2 |
| CER duży | 500 prosumentów + 2000 konsumentów | 100-500 | < 1 | Wielokąt, Arbitrum, EWC |
| Agregator regionalny | 100 jednostek CER, ~50 000 użytkowników | 10 000-50 000 | < 100 | EWC + Dedykowana warstwa 2 |
| Platforma narodowa | 10 000 jednostek CER, 5 milionów użytkowników | 1M+ | 1000+ | Rollup + kanały stanu |
Optymalizacja: kanały stanowe dla mikrohandlu
// State Channel per trading ad alta frequenza tra due prosumer
// Solo apertura e chiusura del canale vanno on-chain (2 transazioni totali)
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
/**
* @title EnergyStateChannel
* @notice Canale bidirezionale per trading energetico ad alta frequenza.
* Apertura e chiusura on-chain, transazioni intermedie off-chain.
* Adatto per accordi bilaterali fissi (es. coppia di vicini).
*/
contract EnergyStateChannel {
address public partyA; // prosumer (venditore abituale)
address public partyB; // consumer (acquirente abituale)
uint256 public channelId;
uint256 public expiresAt;
// Bilanci depositati nel canale
uint256 public depositA_EWT; // EWT bloccati da partyA
uint256 public depositB_EUR; // EUR (stablecoin) bloccati da partyB
bool public settled;
struct ChannelState {
uint256 nonce; // sequenza crescente (anti-replay)
uint256 aBalance_EWT; // EWT spettanti ad A
uint256 bBalance_EUR; // EUR spettanti a B
bytes sigA; // firma di A
bytes sigB; // firma di B
}
event ChannelOpened(address partyA, address partyB, uint256 channelId);
event ChannelClosed(uint256 channelId, uint256 finalNonce);
/**
* @notice Chiude il canale con lo stato finale concordato off-chain.
* Entrambe le parti hanno firmato lo stato finale.
* Esegui on-chain solo al termine della sessione (giornaliero/settimanale).
*/
function closeChannel(ChannelState calldata finalState) external {
require(!settled, "SC: canale già chiuso");
require(block.timestamp <= expiresAt, "SC: canale scaduto");
// Verifica firme di entrambe le parti
bytes32 stateHash = keccak256(abi.encodePacked(
channelId,
finalState.nonce,
finalState.aBalance_EWT,
finalState.bBalance_EUR
));
require(_verifySignature(stateHash, finalState.sigA, partyA), "SC: firma A invalida");
require(_verifySignature(stateHash, finalState.sigB, partyB), "SC: firma B invalida");
settled = true;
// Distribuisci i token secondo lo stato finale concordato
// (trasferimento EWT e EUR dai deposit alle parti)
// ... implementation ...
emit ChannelClosed(channelId, finalState.nonce);
}
function _verifySignature(
bytes32 hash,
bytes memory sig,
address expectedSigner
) internal pure returns (bool) {
bytes32 prefixed = keccak256(abi.encodePacked(
"\x19Ethereum Signed Message:\n32", hash
));
(uint8 v, bytes32 r, bytes32 s) = _splitSignature(sig);
return ecrecover(prefixed, v, r, s) == expectedSigner;
}
function _splitSignature(bytes memory sig)
internal pure returns (uint8 v, bytes32 r, bytes32 s)
{
require(sig.length == 65, "SC: firma non valida");
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
}
}
Przyszłość: DeFi dla energii i energii transaktywnej
Zastosowania, które dzisiaj opisujemy, to dopiero początek głębszej konwergencji pomiędzy zdecentralizowanymi finansami (DeFi) a infrastrukturą energetyczną. Oto więcej wskazówek obiecujące na najbliższe 2-5 lat:
Pojawiające się trendy 2025-2030
- Kontrakty terminowe na energię na DeFi: kontrakty futures na tokenizowaną produkcję PV, z Uniswap v4 lub Curve jako AMM (Automated Market Maker). Prosumenci mogą się zabezpieczać ryzyko pogodowe, sprzedając kontrakty terminowe na oczekiwaną produkcję.
- Kredyt węglowy DeFi (ReFi): protokoły takie jak Toucan, KlimaDAO i Flowcarbon budują rynki łańcuchowe kredytów węglowych. Bezpośrednia integracja z EWT umożliwi to połączenie energii i kredytu węglowego w jeden token.
- Energia transaktywna: kolejny krok do handlu P2P - automatyzacja uzupełnij pytanie/odpowiedź za pomocą sztucznej inteligencji, która samodzielnie zarządza optymalizacją portfela energia prosumenta. Inteligentny kontrakt + ML dla optymalnej oferty rynkowej.
- V2G P2P: pojazdy elektryczne jako aktywni uczestnicy rynku energiczny. Pojazd automatycznie sprzedaje energię z akumulatora po cenie P2P przekracza próg ustawiony przez użytkownika.
- Przestrzeń danych dotyczących energii UE: projekt Gaia-X i europejska przestrzeń danych energetycznych stworzyć infrastrukturę umożliwiającą interoperacyjną wymianę danych dotyczących energii. Blockchain może służyć jako warstwa zaufania i rozliczeń.
Wnioski i dalsze kroki
Handel energią P2P na blockchainie stanowi jedno z najbardziej konkretnych i dojrzałych zastosowań technologii blockchain poza czystym sektorem finansowym. Nie o to chodzi spekulacje: kontrakty Solidity, które widzieliśmy w tym artykule, są możliwe do wdrożenia dziś w Energy Web Chain lub Polygon zkEVM z kosztami gazu poniżej 0,05 EUR za transakcję.
Włoskie ramy regulacyjne, obejmujące dekret legislacyjny nr 199/2021 i kwotę 2,2 miliarda PNRR na jednostki CER, stwarza realną szansę dla deweloperów chcących budować na tej przestrzeni. Jednostki CER są uznanymi podmiotami prawnymi, mają dostęp do zachęt publicznych i dyrektywy RED III jeszcze bardziej wzmocni ich prawa w latach 2025–2026.
Pozostają ograniczenia: integracja z OSD wymaga nietrywialnych umów B2B, tj Do klasyfikacji tokenów energetycznych MiCA należy podchodzić z należytą uwagą prawną, a RODO wymaga projektowania zapewniającego przede wszystkim prywatność z dowodami ZK. Ale żadna z tych przeszkód i nie do pokonania dla zespołu posiadającego umiejętności w dziedzinie blockchain + energia.
W tym artykule kończymy Seria EnergyTech. Przeszliśmy cały stos technologii transformacji energetycznej: od inteligentnych sieci i internetu rzeczy po tokenizacja energii na blockchainie, poprzez DERMS, BMS, Digital Twin, ML dla prognozowanie energii odnawialnej, V2G, MQTT/InfluxDB, IEC 61850 i rozliczanie emisji dwutlenku węgla.
Zasoby, aby dowiedzieć się więcej
- Fundacja Sieci Energii: Dokumentacja EWC i SDK - Energyweb.org/technology/energy-web-chain
- Kontrakty OpenZeppelin: bezpieczna biblioteka inteligentnych kontraktów - docs.openzeppelin.com/contracts
- Portal GSE CACER: Włoskie regulacje i zachęty dotyczące CER - gse.it/servizi-per-te/autoconsumo/comunita-energetiche-rinnovabili
- Dokumentacja kasku: ramy testowania i wdrażania - hardhat.org/docs
- Wielokąt zkEVM: L2 z dowodami ZK zapewniającymi prywatność - Polygon.technology/polygon-zkevm
- Wytyczne EROD w sprawie Blockchain (2025): Wytyczne RODO dotyczące blockchain - edpb.europa.eu/our-work-tools/documents/our-documents
- Dyrektywa RED III (UE 2023/2413): oficjalny tekst - eur-lex.europa.eu
Powiązane serie na fedicocalo.dev
- MLOps dla biznesu: jak wprowadzić modele ML do produkcji prognozowanie energii i reagowanie na zapotrzebowanie
- Biznes związany z danymi i sztuczną inteligencją: architektura Data Lakehouse dla danych energetycznych, ETL/ELT z dbt i Airbyte dla szeregów czasowych energii
- Inżynieria AI/RAG: LLM do analizy kontraktów CER mi wirtualni asystenci dla prosumentów