@etherisc/gif-next 0.0.2-ebbe63d → 0.0.2-ecbd488-936

package/contracts/experiment/inheritance/B.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {ISharedA} from "./IA.sol";
+import {IB} from "./IB.sol";
+
+abstract contract B is ISharedA, IB {
+    // names of private variables can be re-used in inheritance
+    uint256 private _x;
+
+    constructor() {
+        _x = 1;
+    }
+
+    // access own state
+    function getB() external view override returns (uint256) {
+        return _x;
+    }
+
+    function setB(uint256 newB) external override {
+        _x = newB;
+    }
+
+    // access state from parent contract A
+    function getAfromB() external view override returns (uint256) {
+        return this.getA();
+    }
+}

package/contracts/experiment/inheritance/C.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {ISharedA} from "./IA.sol";
+import {IB} from "./IB.sol";
+import {IC} from "./IC.sol";
+
+abstract contract C is ISharedA, IC {
+    uint256 private _x;
+
+    constructor() {
+        _x = 2;
+    }
+
+    // access own state
+    function getC() external view override returns (uint256) {
+        return _x;
+    }
+
+    function setC(uint256 newC) external override {
+        _x = newC;
+    }
+
+    // access state from parent contract A
+    function getAfromC() external view override returns (uint256) {
+        return this.getA();
+    }
+
+    // access state from other module B
+    function getBfromC() external view override returns (uint256) {
+        IB b = IB(address(this));
+        return b.getB();
+    }
+}

package/contracts/experiment/inheritance/IA.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IB} from "./IB.sol";
+import {IC} from "./IC.sol";
+
+interface ISharedA {
+    function getA() external view returns (uint256);
+
+    function setA(uint256 newA) external;
+}
+
+interface IA is ISharedA, IB, IC {}

package/contracts/experiment/inheritance/IB.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+interface IB {
+    function getAfromB() external view returns (uint256);
+
+    function getB() external view returns (uint256);
+
+    function setB(uint256 newA) external;
+}

package/contracts/experiment/inheritance/IC.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+interface IC {
+    function getAfromC() external view returns (uint256);
+
+    function getBfromC() external view returns (uint256);
+
+    function getC() external view returns (uint256);
+
+    function setC(uint256 newA) external;
+}

package/contracts/experiment/statemachine/Dummy.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {ObjectType} from "../../types/ObjectType.sol";
+import {StateId, toStateId, zeroStateId} from "../../types/StateId.sol";
+
+contract LifeCycleModule {
+    mapping(ObjectType objectType => StateId initialState)
+        private _initialState;
+
+    mapping(ObjectType objectType => mapping(StateId stateFrom => mapping(StateId stateTo => bool isValid)))
+        private _isValidTransition;
+
+    function getInitialState(
+        ObjectType objectType
+    ) external view returns (StateId) {
+        return _initialState[objectType];
+    }
+
+    function isValidTransition(
+        ObjectType objectType,
+        StateId fromId,
+        StateId toId
+    ) external view returns (bool) {
+        return _isValidTransition[objectType][fromId][toId];
+    }
+}

package/contracts/experiment/statemachine/ISM.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {StateId} from "../../types/StateId.sol";
+
+interface ISMEE {
+    error ErrorInitialStateUndefined();
+    error ErrorStartStateUndefined();
+    error ErrorNextStateUndefined();
+    error ErrorStateChangeInvalid(StateId currentStateId, StateId newStateId);
+
+    event LogInitialStateSet(StateId initialStateId);
+    event LogStateChanged(StateId oldStateId, StateId newStateId);
+}
+
+interface ISM is ISMEE {
+    function changeToState(StateId newStateId) external;
+
+    function isValidTransition(
+        StateId currentStateId,
+        StateId newStateId
+    ) external view returns (bool isValid);
+
+    function getState() external view returns (StateId currentStateId);
+}

package/contracts/experiment/statemachine/SM.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {StateId, toStateId, zeroStateId} from "../../types/StateId.sol";
+import {ISM} from "./ISM.sol";
+
+contract SM is ISM {
+    mapping(StateId currentState => mapping(StateId newState => bool isValid))
+        private _isValidTransition;
+
+    StateId internal _state;
+
+    function setInitialState(StateId initialStateId) internal {
+        if (initialStateId == zeroStateId()) {
+            revert ErrorInitialStateUndefined();
+        }
+
+        _state = initialStateId;
+    }
+
+    function addTransition(
+        StateId currentStateId,
+        StateId nextStateId
+    ) internal {
+        if (currentStateId == zeroStateId()) {
+            revert ErrorStartStateUndefined();
+        }
+
+        if (nextStateId == zeroStateId()) {
+            revert ErrorNextStateUndefined();
+        }
+
+        _isValidTransition[currentStateId][nextStateId] = true;
+    }
+
+    function changeToState(StateId newStateId) external override {
+        if (!_isValidTransition[_state][newStateId]) {
+            revert ErrorStateChangeInvalid(_state, newStateId);
+        }
+
+        StateId stateOld = _state;
+        _state = newStateId;
+
+        emit LogStateChanged(stateOld, _state);
+    }
+
+    function isValidTransition(
+        StateId currentStateId,
+        StateId newStateId
+    ) external view override returns (bool isValid) {
+        return _isValidTransition[currentStateId][newStateId];
+    }
+
+    function getState() external view override returns (StateId state) {
+        return _state;
+    }
+}

package/contracts/experiment/statemachine/SimpleStateMachine.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {StateId, toStateId} from "../../types/StateId.sol";
+import {SM} from "./SM.sol";
+
+contract SimpleStateMachine is SM {
+    uint8 public constant STATE_ACTIVE = 10;
+    uint8 public constant STATE_PAUSED = 20;
+    uint8 public constant STATE_ARCHIVED = 30;
+
+    constructor() {
+        addTransition(ACTIVE(), PAUSED());
+        addTransition(PAUSED(), ACTIVE());
+        addTransition(PAUSED(), ARCHIVED());
+
+        setInitialState(ACTIVE());
+    }
+
+    function ACTIVE() public pure returns (StateId stateId) {
+        return toStateId(STATE_ACTIVE);
+    }
+
+    function PAUSED() public pure returns (StateId stateId) {
+        return toStateId(STATE_PAUSED);
+    }
+
+    function ARCHIVED() public pure returns (StateId stateId) {
+        return toStateId(STATE_ARCHIVED);
+    }
+}

package/contracts/experiment/types/TypeA.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+/*
+# chisel session for user defined types
+
+import {TypeA, toTypeA} from "./contracts/experiment/types/TypeA.sol";
+TypeA a = toTypeA(1);
+TypeA b = toTypeA(2);
+uint(a.toInt())
+uint(b.toInt())
+a == b
+a != b
+
+import {TypeB, toTypeB} from "./contracts/experiment/types/TypeB.sol";
+TypeB x = toTypeB(33);
+uint(x.toInt())
+a == x; // -> error
+a.toInt() == x.toInt() // -> no error
+ */
+
+// bytes5 allows for chain ids up to 13 digits
+type TypeA is uint248;
+
+// type bindings
+using {eqTypeA as ==, neTypeA as !=, TypeALib.toInt} for TypeA global;
+
+// general pure free functions
+function toTypeA(uint256 typeA) pure returns (TypeA) {
+    return TypeA.wrap(uint248(typeA));
+}
+
+// pure free functions for operators
+function eqTypeA(TypeA a, TypeA b) pure returns (bool isSame) {
+    return TypeA.unwrap(a) == TypeA.unwrap(b);
+}
+
+function neTypeA(TypeA a, TypeA b) pure returns (bool isDifferent) {
+    return TypeA.unwrap(a) != TypeA.unwrap(b);
+}
+
+// library functions that operate on user defined type
+library TypeALib {
+    function toInt(TypeA typeA) internal pure returns (uint256) {
+        return uint256(TypeA.unwrap(typeA));
+    }
+}

package/contracts/experiment/types/TypeB.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+// bytes5 allows for chain ids up to 13 digits
+type TypeB is uint248;
+
+// type bindings
+using {eqTypeB as ==, addTypeB as +, TypeBLib.toInt} for TypeB global;
+
+// general pure free functions
+function toTypeB(uint256 x) pure returns (TypeB) {
+    return TypeB.wrap(uint248(x));
+}
+
+// pure free functions for operators
+function eqTypeB(TypeB a, TypeB b) pure returns (bool isSame) {
+    return TypeB.unwrap(a) == TypeB.unwrap(b);
+}
+
+function addTypeB(TypeB a, TypeB b) pure returns (TypeB sum) {
+    return TypeB.wrap(TypeB.unwrap(a) + TypeB.unwrap(b));
+}
+
+// library functions that operate on user defined type
+library TypeBLib {
+    function toInt(TypeB b) internal pure returns (uint256) {
+        return uint256(TypeB.unwrap(b));
+    }
+}

package/contracts/instance/AccessManagedSimple.sol

@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.0.0) (access/manager/AccessManaged.sol)
+
+pragma solidity ^0.8.20;
+
+import {AuthorityUtils} from "@openzeppelin/contracts/access/manager/AuthorityUtils.sol";
+import {Context} from "@openzeppelin/contracts/utils/Context.sol";
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
+import {IAuthority} from "@openzeppelin/contracts/access/manager/IAuthority.sol";
+
+import {IAccessManagerSimple} from "./IAccessManagerSimple.sol";
+
+/**
+ * @dev This contract module makes available a {restricted} modifier. Functions decorated with this modifier will be
+ * permissioned according to an "authority": a contract like {AccessManager} that follows the {IAuthority} interface,
+ * implementing a policy that allows certain callers to access certain functions.
+ *
+ * IMPORTANT: The `restricted` modifier should never be used on `internal` functions, judiciously used in `public`
+ * functions, and ideally only used in `external` functions. See {restricted}.
+ */
+abstract contract AccessManagedSimple is Context, IAccessManaged {
+    bool private _initialized;
+    address private _authority;
+
+    bool private _consumingSchedule;
+
+    function initializeAccessManagedSimple(address initialAuthority) internal {
+        require(!_initialized, "AccessManaged: already initialized");
+        _setAuthority(initialAuthority);
+        _initialized = true;
+    }
+
+
+    /**
+     * @dev Restricts access to a function as defined by the connected Authority for this contract and the
+     * caller and selector of the function that entered the contract.
+     *
+     * [IMPORTANT]
+     * ====
+     * In general, this modifier should only be used on `external` functions. It is okay to use it on `public`
+     * functions that are used as external entry points and are not called internally. Unless you know what you're
+     * doing, it should never be used on `internal` functions. Failure to follow these rules can have critical security
+     * implications! This is because the permissions are determined by the function that entered the contract, i.e. the
+     * function at the bottom of the call stack, and not the function where the modifier is visible in the source code.
+     * ====
+     *
+     * [WARNING]
+     * ====
+     * Avoid adding this modifier to the https://docs.soliditylang.org/en/v0.8.20/contracts.html#receive-ether-function[`receive()`]
+     * function or the https://docs.soliditylang.org/en/v0.8.20/contracts.html#fallback-function[`fallback()`]. These
+     * functions are the only execution paths where a function selector cannot be unambiguosly determined from the calldata
+     * since the selector defaults to `0x00000000` in the `receive()` function and similarly in the `fallback()` function
+     * if no calldata is provided. (See {_checkCanCall}).
+     *
+     * The `receive()` function will always panic whereas the `fallback()` may panic depending on the calldata length.
+     * ====
+     */
+    modifier restricted() {
+        _checkCanCall(_msgSender(), _msgData());
+        _;
+    }
+
+    /// @inheritdoc IAccessManaged
+    function authority() public view virtual returns (address) {
+        return _authority;
+    }
+
+    /// @inheritdoc IAccessManaged
+    function setAuthority(address newAuthority) public virtual {
+        address caller = _msgSender();
+        if (caller != authority()) {
+            revert AccessManagedUnauthorized(caller);
+        }
+        if (newAuthority.code.length == 0) {
+            revert AccessManagedInvalidAuthority(newAuthority);
+        }
+        _setAuthority(newAuthority);
+    }
+
+    /// @inheritdoc IAccessManaged
+    function isConsumingScheduledOp() public view returns (bytes4) {
+        return _consumingSchedule ? this.isConsumingScheduledOp.selector : bytes4(0);
+    }
+
+    /**
+     * @dev Transfers control to a new authority. Internal function with no access restriction. Allows bypassing the
+     * permissions set by the current authority.
+     */
+    function _setAuthority(address newAuthority) internal virtual {
+        _authority = newAuthority;
+        emit AuthorityUpdated(newAuthority);
+    }
+
+    /**
+     * @dev Reverts if the caller is not allowed to call the function identified by a selector. Panics if the calldata
+     * is less than 4 bytes long.
+     */
+    function _checkCanCall(address caller, bytes calldata data) internal virtual {
+        (bool immediate, uint32 delay) = AuthorityUtils.canCallWithDelay(
+            authority(),
+            caller,
+            address(this),
+            bytes4(data[0:4])
+        );
+        if (!immediate) {
+            if (delay > 0) {
+                _consumingSchedule = true;
+                IAccessManagerSimple(authority()).consumeScheduledOp(caller, data);
+                _consumingSchedule = false;
+            } else {
+                revert AccessManagedUnauthorized(caller);
+            }
+        }
+    }
+}