create-kozalak-l1 0.1.0

package/templates/soulbound-credential/test/Soulbound.t.sol

@@ -0,0 +1,319 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.34;
+
+import {Test} from "forge-std/Test.sol";
+import {KozaCredential} from "../src/KozaCredential.sol";
+import {IAccessControl} from "@openzeppelin/contracts/access/IAccessControl.sol";
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IERC721Errors} from "@openzeppelin/contracts/interfaces/draft-IERC6093.sol";
+
+/**
+ * @title SoulboundTest
+ * @notice Unit + fuzz tests for KozaCredential (Phase 1, Template 4).
+ * @dev Foundry suite covering constructor/roles, issue, soulbound transfer lock,
+ *      revoke (flag), isValid, tokenURI, getCredential, AccessControl grant/revoke.
+ *      Invariant tests are in Soulbound.invariants.t.sol.
+ */
+contract SoulboundTest is Test {
+    /*//////////////////////////////////////////////////////////////
+                                 STATE
+    //////////////////////////////////////////////////////////////*/
+
+    KozaCredential internal cred;
+
+    address internal admin;
+    address internal issuer;
+    address internal alice;
+    address internal bob;
+
+    string internal constant NAME = "ARIA Hub Credential";
+    string internal constant SYMBOL = "ARIA";
+    string internal constant COURSE = "Avalanche L1 Workshop";
+
+    bytes32 internal ISSUER_ROLE;
+    bytes32 internal DEFAULT_ADMIN_ROLE;
+
+    /*//////////////////////////////////////////////////////////////
+                                 SETUP
+    //////////////////////////////////////////////////////////////*/
+
+    function setUp() public {
+        admin = makeAddr("admin");
+        issuer = makeAddr("issuer");
+        alice = makeAddr("alice");
+        bob = makeAddr("bob");
+
+        cred = new KozaCredential(NAME, SYMBOL, admin, issuer);
+        ISSUER_ROLE = cred.ISSUER_ROLE();
+        DEFAULT_ADMIN_ROLE = cred.DEFAULT_ADMIN_ROLE();
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                              CONSTRUCTOR
+    //////////////////////////////////////////////////////////////*/
+
+    function test_Constructor_SetsMetadataAndRoles() public view {
+        assertEq(cred.name(), NAME);
+        assertEq(cred.symbol(), SYMBOL);
+        assertEq(cred.totalIssued(), 0);
+        assertTrue(cred.hasRole(DEFAULT_ADMIN_ROLE, admin));
+        assertTrue(cred.hasRole(ISSUER_ROLE, issuer));
+        assertFalse(cred.hasRole(ISSUER_ROLE, alice));
+    }
+
+    function test_Constructor_SupportsInterfaces() public view {
+        assertTrue(cred.supportsInterface(type(IERC721).interfaceId));
+        assertTrue(cred.supportsInterface(type(IAccessControl).interfaceId));
+        assertTrue(cred.supportsInterface(type(IERC165).interfaceId));
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                                 ISSUE
+    //////////////////////////////////////////////////////////////*/
+
+    function test_Issue_Succeeds() public {
+        vm.expectEmit(true, true, true, true);
+        emit KozaCredential.CredentialIssued(1, alice, issuer, COURSE);
+
+        vm.prank(issuer);
+        uint256 tokenId = cred.issue(alice, COURSE);
+
+        assertEq(tokenId, 1);
+        assertEq(cred.ownerOf(1), alice);
+        assertEq(cred.balanceOf(alice), 1);
+        assertEq(cred.totalIssued(), 1);
+        assertTrue(cred.isValid(1));
+
+        KozaCredential.Credential memory c = cred.getCredential(1);
+        assertEq(c.course, COURSE);
+        assertEq(c.issuer, issuer);
+        assertEq(c.issuedAt, uint64(block.timestamp));
+        assertFalse(c.revoked);
+    }
+
+    function test_Issue_IncrementsTokenId() public {
+        vm.startPrank(issuer);
+        assertEq(cred.issue(alice, COURSE), 1);
+        assertEq(cred.issue(bob, COURSE), 2);
+        assertEq(cred.issue(alice, "Second Course"), 3);
+        vm.stopPrank();
+
+        assertEq(cred.totalIssued(), 3);
+        assertEq(cred.balanceOf(alice), 2);
+    }
+
+    function test_Issue_RecordsTimestamp() public {
+        vm.warp(1_900_000_000);
+        vm.prank(issuer);
+        cred.issue(alice, COURSE);
+        assertEq(cred.getCredential(1).issuedAt, uint64(1_900_000_000));
+    }
+
+    function test_RevertWhen_IssueNotIssuer() public {
+        vm.expectRevert(
+            abi.encodeWithSelector(IAccessControl.AccessControlUnauthorizedAccount.selector, alice, ISSUER_ROLE)
+        );
+        vm.prank(alice);
+        cred.issue(bob, COURSE);
+    }
+
+    function test_RevertWhen_IssueEmptyCourse() public {
+        vm.expectRevert(KozaCredential.EmptyCourse.selector);
+        vm.prank(issuer);
+        cred.issue(alice, "");
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                          SOULBOUND (NON-TRANSFER)
+    //////////////////////////////////////////////////////////////*/
+
+    function test_RevertWhen_TransferFrom() public {
+        vm.prank(issuer);
+        cred.issue(alice, COURSE);
+
+        vm.expectRevert(KozaCredential.Soulbound.selector);
+        vm.prank(alice);
+        cred.transferFrom(alice, bob, 1);
+    }
+
+    function test_RevertWhen_SafeTransferFrom() public {
+        vm.prank(issuer);
+        cred.issue(alice, COURSE);
+
+        vm.expectRevert(KozaCredential.Soulbound.selector);
+        vm.prank(alice);
+        cred.safeTransferFrom(alice, bob, 1);
+    }
+
+    function test_RevertWhen_TransferAfterApprove() public {
+        vm.prank(issuer);
+        cred.issue(alice, COURSE);
+
+        // approve is allowed (no-op effectively) but transfer still blocked
+        vm.prank(alice);
+        cred.approve(bob, 1);
+
+        vm.expectRevert(KozaCredential.Soulbound.selector);
+        vm.prank(bob);
+        cred.transferFrom(alice, bob, 1);
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                                 REVOKE
+    //////////////////////////////////////////////////////////////*/
+
+    function test_Revoke_Succeeds() public {
+        vm.prank(issuer);
+        cred.issue(alice, COURSE);
+
+        vm.expectEmit(true, true, false, false);
+        emit KozaCredential.CredentialRevoked(1, issuer);
+        vm.prank(issuer);
+        cred.revoke(1);
+
+        assertFalse(cred.isValid(1));
+        assertTrue(cred.getCredential(1).revoked);
+        // token is not burned — ownerOf still resolves
+        assertEq(cred.ownerOf(1), alice);
+    }
+
+    function test_RevertWhen_RevokeNotIssuer() public {
+        vm.prank(issuer);
+        cred.issue(alice, COURSE);
+
+        vm.expectRevert(
+            abi.encodeWithSelector(IAccessControl.AccessControlUnauthorizedAccount.selector, alice, ISSUER_ROLE)
+        );
+        vm.prank(alice);
+        cred.revoke(1);
+    }
+
+    function test_RevertWhen_RevokeNonexistent() public {
+        vm.expectRevert(abi.encodeWithSelector(IERC721Errors.ERC721NonexistentToken.selector, 99));
+        vm.prank(issuer);
+        cred.revoke(99);
+    }
+
+    function test_RevertWhen_RevokeAlreadyRevoked() public {
+        vm.startPrank(issuer);
+        cred.issue(alice, COURSE);
+        cred.revoke(1);
+        vm.expectRevert(abi.encodeWithSelector(KozaCredential.AlreadyRevoked.selector, 1));
+        cred.revoke(1);
+        vm.stopPrank();
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                                IS VALID
+    //////////////////////////////////////////////////////////////*/
+
+    function test_IsValid_FalseForNonexistent() public view {
+        assertFalse(cred.isValid(1));
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                               TOKEN URI
+    //////////////////////////////////////////////////////////////*/
+
+    function test_TokenURI_IsOnChainJson() public {
+        vm.prank(issuer);
+        cred.issue(alice, COURSE);
+
+        string memory uri = cred.tokenURI(1);
+        assertTrue(_startsWith(uri, "data:application/json;base64,"), "tokenURI must be on-chain base64 JSON");
+    }
+
+    function test_TokenURI_ChangesAfterRevoke() public {
+        vm.prank(issuer);
+        cred.issue(alice, COURSE);
+        string memory beforeURI = cred.tokenURI(1);
+
+        vm.prank(issuer);
+        cred.revoke(1);
+        string memory afterURI = cred.tokenURI(1);
+
+        // status flips Valid -> Revoked, so the encoded metadata must differ
+        assertTrue(keccak256(bytes(beforeURI)) != keccak256(bytes(afterURI)), "metadata must reflect revoke");
+    }
+
+    function test_RevertWhen_TokenURINonexistent() public {
+        vm.expectRevert(abi.encodeWithSelector(IERC721Errors.ERC721NonexistentToken.selector, 1));
+        cred.tokenURI(1);
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                            ACCESS CONTROL
+    //////////////////////////////////////////////////////////////*/
+
+    function test_AdminCanGrantIssuerRole() public {
+        vm.prank(admin);
+        cred.grantRole(ISSUER_ROLE, bob);
+
+        vm.prank(bob);
+        uint256 tokenId = cred.issue(alice, COURSE);
+        assertEq(tokenId, 1);
+    }
+
+    function test_AdminCanRevokeIssuerRole() public {
+        vm.prank(admin);
+        cred.revokeRole(ISSUER_ROLE, issuer);
+
+        vm.expectRevert(
+            abi.encodeWithSelector(IAccessControl.AccessControlUnauthorizedAccount.selector, issuer, ISSUER_ROLE)
+        );
+        vm.prank(issuer);
+        cred.issue(alice, COURSE);
+    }
+
+    function test_RevertWhen_NonAdminGrantsRole() public {
+        vm.expectRevert(
+            abi.encodeWithSelector(IAccessControl.AccessControlUnauthorizedAccount.selector, alice, DEFAULT_ADMIN_ROLE)
+        );
+        vm.prank(alice);
+        cred.grantRole(ISSUER_ROLE, bob);
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                                  FUZZ
+    //////////////////////////////////////////////////////////////*/
+
+    function testFuzz_IssuedCredentialsAreSoulbound(address to, address attacker) public {
+        vm.assume(to != address(0) && to.code.length == 0);
+        vm.assume(attacker != address(0));
+
+        vm.prank(issuer);
+        uint256 tokenId = cred.issue(to, COURSE);
+
+        vm.expectRevert(KozaCredential.Soulbound.selector);
+        vm.prank(to);
+        cred.transferFrom(to, attacker, tokenId);
+    }
+
+    function testFuzz_RevokeInvalidatesCredential(uint64 ts) public {
+        ts = uint64(bound(ts, 1, type(uint64).max));
+        vm.warp(ts);
+
+        vm.startPrank(issuer);
+        cred.issue(alice, COURSE);
+        assertTrue(cred.isValid(1));
+        cred.revoke(1);
+        vm.stopPrank();
+
+        assertFalse(cred.isValid(1));
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                                HELPERS
+    //////////////////////////////////////////////////////////////*/
+
+    function _startsWith(string memory str, string memory prefix) internal pure returns (bool) {
+        bytes memory s = bytes(str);
+        bytes memory p = bytes(prefix);
+        if (s.length < p.length) return false;
+        for (uint256 i = 0; i < p.length; i++) {
+            if (s[i] != p[i]) return false;
+        }
+        return true;
+    }
+}

package/templates/treasury-multisig/.env.example

@@ -0,0 +1,19 @@
+# ============================================
+# Bu dosyayı kopyalayıp `.env` olarak adlandırın. `.env` ASLA commit edilmez.
+# ============================================
+
+# ---- Deploy Wallet (Fuji testnet) ----
+# UYARI: Mainnet private key'i ASLA buraya koyma. Sadece testnet için.
+# Production'da Foundry Cast Wallet (encrypted keystore) veya hardware wallet kullan.
+PRIVATE_KEY=
+
+# Deployer adres (sanity check, opsiyonel)
+DEPLOYER_ADDRESS=
+
+# ---- Block Explorer (Routescan) ----
+# routescan.io'dan ücretsiz `rs_` prefix'li API key al. `--verify` için gerekir.
+SNOWTRACE_API_KEY=
+
+# ---- ICM / Teleporter ----
+# Avalanche Teleporter messenger — tüm L1'lerde deterministic adres.
+TELEPORTER_MESSENGER_ADDRESS=0x253b2784c75e510dD0fF1da844684a1aC0aa5fcf

package/templates/treasury-multisig/.gitmodules

@@ -0,0 +1,6 @@
+[submodule "lib/forge-std"]
+	path = lib/forge-std
+	url = https://github.com/foundry-rs/forge-std
+[submodule "lib/openzeppelin-contracts"]
+	path = lib/openzeppelin-contracts
+	url = https://github.com/OpenZeppelin/openzeppelin-contracts

package/templates/treasury-multisig/README.md

@@ -0,0 +1,48 @@
+# Treasury Multisig (Timelock)
+
+OpenZeppelin TimelockController tabanlı, gecikmeli-yürütme hazine kontratı (KozaTreasury).
+
+Bu, kozalak-l1 deposundan üretilmiş **standalone** bir Foundry projesidir;
+kendi başına derlenir ve test edilir.
+
+## Kurulum
+
+```bash
+forge install foundry-rs/forge-std@8987040ede9553cea20c95ad40d0455930f9c8e0 OpenZeppelin/openzeppelin-contracts@e4f70216d759d8e6a64144a9e1f7bbeed78e7079
+forge build
+forge test
+```
+
+> `forge install ...@<commit>` bağımlılıkları repo ile birebir aynı commit'lere
+> pinler (aşağıdaki tabloya bakın). `.gitmodules` ve `remappings.txt`
+> bu pinlerle uyumludur.
+
+## Deploy (Fuji testnet)
+
+```bash
+cp .env.example .env      # PRIVATE_KEY + SNOWTRACE_API_KEY doldur
+forge script script/DeployTreasury.s.sol \
+    --rpc-url fuji \
+    --broadcast \
+    --verify
+```
+
+> Production: `PRIVATE_KEY` yalnızca testnet olmalı; sahiplik/yönetici
+> adreslerini bir multisig'e (Safe) yönlendir, EOA bırakma.
+
+## Yeniden adlandırma
+
+Contract'ı kendi adınla yeniden adlandırmak istersen `src/`, `test/` ve
+`script/` altındaki dosyalarda contract/dosya adını birlikte güncelle
+(import'lar tek-seviye relative olduğu için tutarlı kalmalı).
+
+## Bağımlılık pinleri
+
+| Bağımlılık | Tag | Commit (pin) |
+| --- | --- | --- |
+| `forge-std` | v1.16.0 | `8987040ede9553cea20c95ad40d0455930f9c8e0` |
+| `openzeppelin-contracts` | v5.3.0 | `e4f70216d759d8e6a64144a9e1f7bbeed78e7079` |
+
+---
+
+_Bu proje `create-kozalak-l1` tarafından üretildi. Kaynak: kozalak-l1 mono-repo._

package/templates/treasury-multisig/foundry.toml

@@ -0,0 +1,35 @@
+[profile.default]
+src = "src"
+out = "out"
+libs = ["lib"]
+test = "test"
+script = "script"
+# Bu şablon solc 0.8.34 pragma'sı kullanır. auto_detect_solc dosya
+# pragma'sına göre doğru derleyiciyi otomatik indirir/seçer.
+auto_detect_solc = true
+optimizer = true
+optimizer_runs = 200
+via_ir = true
+bytecode_hash = "none"
+cbor_metadata = false
+remappings = [
+    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
+    "forge-std/=lib/forge-std/src/"
+]
+
+[fmt]
+line_length = 120
+tab_width = 4
+bracket_spacing = false
+int_types = "long"
+multiline_func_header = "all"
+quote_style = "double"
+number_underscore = "thousands"
+
+[rpc_endpoints]
+fuji = "https://api.avax-test.network/ext/bc/C/rpc"
+avalanche = "https://api.avax.network/ext/bc/C/rpc"
+
+[etherscan]
+fuji = { key = "${SNOWTRACE_API_KEY}", url = "https://api.routescan.io/v2/network/testnet/evm/43113/etherscan", chain = 43113 }
+avalanche = { key = "${SNOWTRACE_API_KEY}", url = "https://api.routescan.io/v2/network/mainnet/evm/43114/etherscan", chain = 43114 }

package/templates/treasury-multisig/gitignore

@@ -0,0 +1,5 @@
+.env
+out/
+cache/
+broadcast/
+lib/

package/templates/treasury-multisig/remappings.txt

@@ -0,0 +1,2 @@
+@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/
+forge-std/=lib/forge-std/src/

package/templates/treasury-multisig/script/DeployTreasury.s.sol

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.34;
+
+import {Script} from "forge-std/Script.sol";
+import {console2} from "forge-std/console2.sol";
+import {KozaTreasury} from "../src/KozaTreasury.sol";
+
+/**
+ * @title DeployTreasury
+ * @notice Foundry deployment script for KozaTreasury (Phase 1, Template 5).
+ *
+ *         Usage (Fuji testnet, with .env populated):
+ *
+ *             forge script script/deploy/DeployTreasury.s.sol:DeployTreasury \
+ *                 --rpc-url fuji --broadcast --verify
+ *
+ *         Required env:
+ *           - PRIVATE_KEY              — deployer private key (testnet only!)
+ *
+ *         Optional env (defaults below if unset):
+ *           - TREASURY_MIN_DELAY       (172800 = 48h)
+ *           - TREASURY_PROPOSER        (broadcaster)  — production: Safe multisig
+ *           - TREASURY_EXECUTOR        (broadcaster)  — `address(0)` → açık execute
+ *           - TREASURY_ADMIN           (broadcaster)  — production: address(0) (self-administered)
+ *
+ *         Production checklist:
+ *           - TREASURY_MIN_DELAY kritik hazine için 48h+ olmalı
+ *           - TREASURY_PROPOSER / TREASURY_EXECUTOR birer Safe (Gnosis) multisig olmalı
+ *           - TREASURY_ADMIN = address(0) (self-administered) en güvenli; deployer verilirse
+ *             kurulum sonrası renounceRole(DEFAULT_ADMIN_ROLE, deployer)
+ *           - Korunan kontratların ownership'i bu timelock'a devredilmeli
+ */
+contract DeployTreasury is Script {
+    /*//////////////////////////////////////////////////////////////
+                                DEFAULTS
+    //////////////////////////////////////////////////////////////*/
+
+    uint256 internal constant DEFAULT_MIN_DELAY = 48 hours; // 172800 s
+
+    /*//////////////////////////////////////////////////////////////
+                                  RUN
+    //////////////////////////////////////////////////////////////*/
+
+    /// @notice Entry point invoked by `forge script`. Reads parameters from env.
+    function run() external returns (KozaTreasury treasury, address deployer) {
+        uint256 minDelay = vm.envOr("TREASURY_MIN_DELAY", DEFAULT_MIN_DELAY);
+
+        address broadcaster = _resolveBroadcaster();
+        address proposer = vm.envOr("TREASURY_PROPOSER", broadcaster);
+        address executor = vm.envOr("TREASURY_EXECUTOR", broadcaster);
+        address admin = vm.envOr("TREASURY_ADMIN", broadcaster);
+
+        address[] memory proposers = new address[](1);
+        proposers[0] = proposer;
+        address[] memory executors = new address[](1);
+        executors[0] = executor;
+
+        return deploy(minDelay, proposers, executors, admin, broadcaster);
+    }
+
+    /// @notice Test-friendly entry point. Takes explicit parameters instead of env.
+    function deploy(
+        uint256 minDelay,
+        address[] memory proposers,
+        address[] memory executors,
+        address admin,
+        address broadcaster
+    )
+        public
+        returns (KozaTreasury treasury, address deployer)
+    {
+        _logPreDeploy(minDelay, proposers, executors, admin, broadcaster);
+
+        vm.startBroadcast();
+        treasury = new KozaTreasury(minDelay, proposers, executors, admin);
+        vm.stopBroadcast();
+
+        deployer = broadcaster;
+
+        _logPostDeploy(treasury);
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                              INTERNALS
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Order: explicit DEPLOYER_ADDRESS > derived from PRIVATE_KEY > tx.origin.
+    function _resolveBroadcaster() internal view returns (address) {
+        address explicitDeployer = vm.envOr("DEPLOYER_ADDRESS", address(0));
+        if (explicitDeployer != address(0)) return explicitDeployer;
+
+        uint256 pk = vm.envOr("PRIVATE_KEY", uint256(0));
+        if (pk != 0) return vm.addr(pk);
+
+        return tx.origin;
+    }
+
+    function _logPreDeploy(
+        uint256 minDelay,
+        address[] memory proposers,
+        address[] memory executors,
+        address admin,
+        address broadcaster
+    )
+        internal
+        pure
+    {
+        console2.log("=== Deploying KozaTreasury ===");
+        console2.log("  Broadcaster: ", broadcaster);
+        console2.log("  Min delay (s):", minDelay);
+        console2.log("  Proposer[0]: ", proposers[0]);
+        console2.log("  Executor[0]: ", executors[0]);
+        console2.log("  Admin:       ", admin);
+    }
+
+    function _logPostDeploy(KozaTreasury treasury) internal view {
+        console2.log("=== Deployed ===");
+        console2.log("  Address:     ", address(treasury));
+        console2.log("  Min delay:   ", treasury.getMinDelay());
+        console2.log("");
+        console2.log("Next steps:");
+        console2.log("  1) Fonla: native gonder veya korunan kontrat ownership'ini timelock'a devret");
+        console2.log("  2) proposer: cast send <addr> 'schedule(address,uint256,bytes,bytes32,bytes32,uint256)' ...");
+        console2.log(
+            "  3) minDelay sonra executor: cast send <addr> 'execute(address,uint256,bytes,bytes32,bytes32)' ..."
+        );
+    }
+}

package/templates/treasury-multisig/src/KozaTreasury.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.34;
+
+import {TimelockController} from "@openzeppelin/contracts/governance/TimelockController.sol";
+
+/**
+ * @title KozaTreasury
+ * @author kozalak-L1 contributors
+ * @notice Zaman-kilitli (timelock) hazine — OpenZeppelin `TimelockController` ince wrapper'ı.
+ *         DAO/topluluk fonlarını rol-bazlı + gecikmeli yürütmeyle korur. Avalanche L1 /
+ *         C-Chain için audit-grade boilerplate.
+ * @dev OZ v5.3+ `TimelockController`'ı doğrudan miras alır; custom logic eklemez. Audit-grade
+ *      prensibi: minimum custom layer on top of audited primitives.
+ *
+ *      "Multisig" katmanı: bir Safe (Gnosis) multisig'i `proposers`/`executors` olarak atanır.
+ *      Öneri Safe'te imzalanır → timelock gecikmesi dolar → execute. Tek nokta güven yoktur;
+ *      gecikme, kötü niyetli/yanlış önerilere tepki penceresi sağlar.
+ *
+ *      Parent `TimelockController`'ın sağladıkları:
+ *        - Roller: PROPOSER_ROLE (schedule), EXECUTOR_ROLE (execute), CANCELLER_ROLE (cancel),
+ *          DEFAULT_ADMIN_ROLE (rol yönetimi).
+ *        - `schedule`/`scheduleBatch` → minDelay bekle → `execute`/`executeBatch`.
+ *        - `cancel` (henüz yürütülmemiş öneriyi iptal).
+ *        - `updateDelay` — YALNIZCA timelock'un kendi önerisiyle değiştirilebilir.
+ *        - `receive()` payable — native fon tutar; ERC20'ler `schedule(token, 0, transferCalldata, ...)`
+ *          ile zaman-kilitli gönderilir.
+ *        - `executor = address(0)` → açık execute (herkes yürütebilir, schedule yine korumalı).
+ *
+ *      Production hazırlık checklist'i:
+ *        - `minDelay` kritik hazine için anlamlı olmalı (örn. 48h+). Çok düşük delay timelock'un
+ *          güvenlik değerini düşürür.
+ *        - `proposers`/`executors` birer Safe multisig olmalı; EOA mainnet'te tek nokta risktir.
+ *        - `admin = address(0)` (self-administered) en güvenlidir: roller yalnız timelock'un kendi
+ *          gecikmeli önerisiyle değişir. Kurulum kolaylığı için deployer verilirse, kurulum
+ *          sonrası `renounceRole(DEFAULT_ADMIN_ROLE, deployer)` ile bırakılması önerilir.
+ *        - Hazine sahipliği: korunan kontratların `owner`/admin'i bu timelock olmalı.
+ *
+ * @custom:security-contact security@bekirerdem.dev
+ */
+contract KozaTreasury is TimelockController {
+    /**
+     * @param minDelay Önerinin yürütülebilmesi için geçmesi gereken minimum süre (saniye)
+     * @param proposers PROPOSER_ROLE + CANCELLER_ROLE alacak adresler (production: Safe multisig)
+     * @param executors EXECUTOR_ROLE alacak adresler (`address(0)` → açık execute)
+     * @param admin DEFAULT_ADMIN_ROLE (production: `address(0)` self-administered önerilir)
+     */
+    constructor(
+        uint256 minDelay,
+        address[] memory proposers,
+        address[] memory executors,
+        address admin
+    )
+        TimelockController(minDelay, proposers, executors, admin)
+    {}
+}