// SPDX-License-Identifier: MIT pragma solidity ^0.8.24; import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol"; /// @title Solastnina brez veta — PROTOTIP (samo za preizkus, ni revidirano) /// @notice Ena stvar (npr. hisa) je razdeljena na N enakih delezev. Vsak lastnik /// deleza sam napove ceno svojega deleza. Vsak DRUG solastnik ga sme /// kadarkoli odkupiti po tej ceni. Za napovedano ceno lastnik placuje /// letni prispevek v skupni sklad (vzdrzevanje stvari). /// /// Zakaj to odpravi veto: nihce ne more preprečiti, da se solastnina /// razresi — lahko doloci samo ceno svojega deleza, in visoka cena ga stane. /// /// Tri zascite: /// 1. SPODNJA MEJA: nihce ne more biti prisiljen prodati pod neodvisno /// cenitvijo (cenitev / N). Revnejsi solastnik dobi vsaj posteno ceno. /// 2. ZAMIK: nova cena velja sele po ZAMIK dneh, zato je ni mogoce dvigniti /// v trenutku, ko nekdo zeli odkupiti. /// 3. ZAMUDA: kdor prispevka ne placa vec kot ROK_ZAMUDE po roku, ima /// delez naprodaj po spodnji meji (vzorec HSI: zamujeni rok sprozi /// dolocen postopek, ne tisine). /// /// Veriga vodi napovedi, prispevke in placilo odkupa. Pravni prenos /// (zemljiska knjiga, notarski zapis) mora slediti po dogovoru, ki so ga /// solastniki podpisali — pogodba ga ne more izvrsiti sama. contract Solastnina is ReentrancyGuard { using SafeERC20 for IERC20; uint256 public constant STOPNJA_BPS = 100; // 1 % napovedane cene na leto uint256 public constant ZAMIK = 14 days; // nova cena velja po tem casu uint256 public constant ROK_ZAMUDE = 90 days; // po tem je delez naprodaj po spodnji meji uint256 public constant MAKS_SPREMEMBA_BPS = 2000; // cenitev naenkrat najvec +-20 % uint256 public constant RAZMIK_CENITEV = 30 days; // najvec ena sprememba cenitve na 30 dni uint256 private constant LETO = 365 days; struct Delez { address lastnik; uint256 cena; // veljavna napovedana cena (USDC, 6 decimalk) uint256 novaCena; // napovedana, se ne velja uint256 novaOd; // od kdaj velja novaCena (0 = ni napovedi) uint256 placanoDo; // do kdaj je prispevek placan } IERC20 public immutable usdc; address public immutable overitelj; // neodvisni cenilec (UORS) address public immutable sklad; // kam gredo prispevki (npr. skupni Safe) Delez[] private delezi; uint256 public cenitev; // cenitev CELE stvari uint256 public cenitevSpremenjena; event CenaNapovedana(uint256 indexed delez, uint256 cena, uint256 veljaOd); event PrispevekPlacan(uint256 indexed delez, address placnik, uint256 znesek, uint256 placanoDo); event Odkup(uint256 indexed delez, address indexed prodajalec, address indexed kupec, uint256 cena, bool zaradiZamude); event CenitevSpremenjena(uint256 stara, uint256 nova); constructor( IERC20 _usdc, address _overitelj, address _sklad, uint256 _cenitev, address[] memory lastniki, uint256[] memory cene ) { require(lastniki.length > 1 && lastniki.length == cene.length, "Napacni delezi"); require(_cenitev > 0, "Ni cenitve"); usdc = _usdc; overitelj = _overitelj; sklad = _sklad; cenitev = _cenitev; cenitevSpremenjena = block.timestamp; uint256 meja = _cenitev / lastniki.length; for (uint256 i = 0; i < lastniki.length; i++) { require(lastniki[i] != address(0), "Prazen naslov"); require(cene[i] >= meja, "Cena pod cenitvijo"); delezi.push(Delez(lastniki[i], cene[i], 0, 0, block.timestamp)); } } // ── Branje ──────────────────────────────────────────────────────────────── function steviloDelezev() external view returns (uint256) { return delezi.length; } function lastnik(uint256 i) external view returns (address) { return delezi[i].lastnik; } /// @notice Najnizja cena, po kateri je delez sploh mogoce odkupiti. function spodnjaMeja() public view returns (uint256) { return cenitev / delezi.length; } /// @notice Cena, ki velja ta trenutek (upostevan zamik in spodnja meja). function veljavnaCena(uint256 i) public view returns (uint256 c) { Delez storage d = delezi[i]; c = (d.novaOd != 0 && block.timestamp >= d.novaOd) ? d.novaCena : d.cena; uint256 meja = spodnjaMeja(); if (c < meja) c = meja; // cenitev se je morda dvignila nad napoved } function letniPrispevek(uint256 i) public view returns (uint256) { return veljavnaCena(i) * STOPNJA_BPS / 10_000; } /// @notice Do kdaj je prispevek placan. Ko zacne veljati nova cena, se ze /// placani cas preracuna na novo ceno: kdor dvigne ceno, mu predplacilo /// sorazmerno hitreje potece. Sicer bi si lahko nekdo predplacal leta po /// nizki ceni in nato brezplacno blokiral z visoko. function placanoDo(uint256 i) public view returns (uint256) { return _efektivnoPlacanoDo(delezi[i]); } function vZamudi(uint256 i) public view returns (bool) { return block.timestamp > placanoDo(i) + ROK_ZAMUDE; } /// @notice Po koliko bi ta trenutek lahko kupil delez i. function odkupnaCena(uint256 i) public view returns (uint256) { return vZamudi(i) ? spodnjaMeja() : veljavnaCena(i); } function jeSolastnik(address kdo) public view returns (bool) { for (uint256 i = 0; i < delezi.length; i++) if (delezi[i].lastnik == kdo) return true; return false; } // ── Lastnik deleza ──────────────────────────────────────────────────────── /// @notice Napove novo ceno; velja cez ZAMIK. Navzgor in navzdol enako. function napoviCeno(uint256 i, uint256 nova) external { Delez storage d = delezi[i]; require(msg.sender == d.lastnik, "Ni tvoj delez"); require(nova >= spodnjaMeja(), "Cena pod cenitvijo"); _uveljaviNapoved(d); d.novaCena = nova; d.novaOd = block.timestamp + ZAMIK; emit CenaNapovedana(i, nova, d.novaOd); } /// @notice Placa prispevek za delez i (placa lahko kdorkoli, npr. iz najemnine). /// Znesek podaljsa `placanoDo` sorazmerno z veljavnim letnim prispevkom. function placajPrispevek(uint256 i, uint256 znesek) external nonReentrant { require(znesek > 0, "Nic"); Delez storage d = delezi[i]; _uveljaviNapoved(d); uint256 letno = letniPrispevek(i); uint256 cas = znesek * LETO / letno; d.placanoDo += cas; // steje od dosedanjega roka: zamujeni cas se doplaca usdc.safeTransferFrom(msg.sender, sklad, znesek); emit PrispevekPlacan(i, msg.sender, znesek, d.placanoDo); } // ── Odkup ───────────────────────────────────────────────────────────────── /// @notice Solastnik odkupi delez i. `maksCena` varuje kupca, ce se cena /// med oddajo in izvedbo transakcije spremeni. function odkupi(uint256 i, uint256 maksCena) external nonReentrant { Delez storage d = delezi[i]; require(jeSolastnik(msg.sender), "Samo solastnik"); require(msg.sender != d.lastnik, "Ze tvoj"); bool zamuda = vZamudi(i); uint256 cena = odkupnaCena(i); require(cena <= maksCena, "Cena visja od maksCena"); address prodajalec = d.lastnik; d.lastnik = msg.sender; d.cena = cena; // novi lastnik zacne s ceno, po kateri je kupil d.novaCena = 0; d.novaOd = 0; d.placanoDo = block.timestamp; usdc.safeTransferFrom(msg.sender, prodajalec, cena); emit Odkup(i, prodajalec, msg.sender, cena, zamuda); } // ── Overitelj ───────────────────────────────────────────────────────────── /// @notice Nova neodvisna cenitev. Omejena po velikosti in pogostosti, da /// cenilec ne more cez noc premakniti spodnje meje. function posodobiCenitev(uint256 nova) external { require(msg.sender == overitelj, "Samo overitelj"); require(block.timestamp >= cenitevSpremenjena + RAZMIK_CENITEV, "Prehitro"); uint256 stara = cenitev; uint256 razlika = nova > stara ? nova - stara : stara - nova; require(razlika * 10_000 <= stara * MAKS_SPREMEMBA_BPS, "Sprememba prevelika"); cenitev = nova; cenitevSpremenjena = block.timestamp; emit CenitevSpremenjena(stara, nova); } function _efektivnoPlacanoDo(Delez storage d) private view returns (uint256) { if (d.novaOd != 0 && block.timestamp >= d.novaOd && d.placanoDo > d.novaOd) { return d.novaOd + (d.placanoDo - d.novaOd) * d.cena / d.novaCena; } return d.placanoDo; } function _uveljaviNapoved(Delez storage d) private { if (d.novaOd != 0 && block.timestamp >= d.novaOd) { d.placanoDo = _efektivnoPlacanoDo(d); d.cena = d.novaCena; d.novaCena = 0; d.novaOd = 0; } } }