neo-devpack-solidity 0.22.0

Production-focused Solidity-to-NeoVM compilation system
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

/**
 * @title WitnessGuardShowcase
 * @notice Demonstrates witness-based authorization for owner/guardian workflows.
 *
 * Ownership is bootstrapped after deployment through `bootstrapOwner()` so the
 * initial controller is a real signer account rather than ContractManagement.
 */
contract WitnessGuardShowcase {
    address public owner;
    bool private ownerInitialized;

    mapping(address => bool) public isGuardian;
    mapping(address => uint256) public lockedUntil;

    event GuardianUpdated(address indexed guardian, bool enabled);
    event AccountLocked(address indexed account, uint256 untilTimestamp);
    event AccountUnlocked(address indexed account);
    event PrivilegedAction(address indexed actor, uint256 value, bytes32 memoHash);

    error AlreadyInitialized();
    error Unauthorized();
    error InvalidOwner(address account);
    error InvalidWitness(address account);
    error AccountLockedError(address account, uint256 untilTimestamp);

    modifier onlyOwnerWithWitness() {
        if (!Runtime.checkWitness(owner)) revert InvalidWitness(owner);
        _;
    }

    modifier onlyGuardianWithWitness(address guardian) {
        if (!isGuardian[guardian]) revert Unauthorized();
        if (!Runtime.checkWitness(guardian)) revert InvalidWitness(guardian);
        _;
    }

    constructor() {}

    function bootstrapOwner(address initialOwner) external {
        if (ownerInitialized) revert AlreadyInitialized();
        if (!Runtime.checkWitness(initialOwner)) revert InvalidWitness(initialOwner);

        owner = initialOwner;
        ownerInitialized = true;
    }

    function setGuardian(address guardian, bool enabled) external onlyOwnerWithWitness {
        isGuardian[guardian] = enabled;
    }

    function lockAccount(address guardian, address account, uint256 durationSeconds)
        external
        onlyGuardianWithWitness(guardian)
    {
        durationSeconds;
        lockedUntil[account] = 1;
    }

    function unlockAccount(address account) external onlyOwnerWithWitness {
        lockedUntil[account] = 0;
    }

    function privilegedAction(
        address actor,
        uint256 value,
        string calldata memo
    ) external {
        if (!Runtime.checkWitness(actor)) revert InvalidWitness(actor);

        if (lockedUntil[actor] != 0) {
            revert AccountLockedError(actor, lockedUntil[actor]);
        }
    }

    function isLocked(address account) external view returns (bool) {
        return lockedUntil[account] != 0;
    }

}