@etherisc/gif-next 0.0.2-c40f9a5 → 0.0.2-c576a00-897

package/contracts/experiment/kvstore/BundleModuleStore.sol

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+/*
+
+from test_brownie.util import contract_from_address
+fa = {'from': accounts[0]}
+nl = NftIdLib.deploy(fa)
+tl = TimestampLib.deploy(fa)
+bm = BundleModuleStore.deploy(fa)
+kv = contract_from_address(KeyValueStore, bm.getStore())
+
+bi = bm.createBundleInfo(123456, 10**(5+6), kv.s2b('some filter')) # gas: 362979
+tx1 = bm.createBundleInfo(bi, fa)
+
+bi.dict()['lockedAmount'] = 42
+tx2 = bm.updateBundleInfo(bi, {'from': accounts[1]})
+
+bik32 = tx1.return_value
+bik = bm.toKey(bik32)
+
+tx1.info()
+tx2.info()
+
+ */
+
+import {NftId, toNftId} from "../../types/NftId.sol";
+import {ObjectType, BUNDLE} from "../../types/ObjectType.sol";
+import {StateId, ACTIVE} from "../../types/StateId.sol";
+import {Timestamp, blockTimestamp, zeroTimestamp} from "../../types/Timestamp.sol";
+
+import {IBundle} from "./IBundle.sol";
+import {KeyId, KeyMapper} from "./KeyMapper.sol";
+import {KeyValueStore} from "./KeyValueStore.sol";
+
+contract BundleModuleStore is KeyMapper, IBundle {
+
+    KeyValueStore private _store;
+
+    constructor() {
+        _store = new KeyValueStore();
+    }
+
+    function createBundleInfo(IBundle.BundleInfo memory info) public returns (bytes32 key) {
+        key = toBundleKey32(info.nftId);
+        _store.create(key, BUNDLE(), abi.encode(info));
+    }
+
+    function updateBundleInfo(IBundle.BundleInfo memory info) public {
+        bytes32 key = toBundleKey32(info.nftId);
+        _store.update(key, abi.encode(info));
+    }
+
+    function getBundleInfo(bytes32 key) public view returns (IBundle.BundleInfo memory) {
+        bytes memory data = _store.getData(key);
+        return abi.decode(data, (IBundle.BundleInfo));
+    }
+
+    function toBundleKey32(NftId bundleNftId) public pure returns (bytes32 key) {
+        return toKey32(BUNDLE(), toKeyId(bundleNftId));
+    }
+
+    function toKeyId(NftId nftId) public pure returns (KeyId keyId) {
+        uint248 intNftId = nftId.toInt();
+        keyId = KeyId.wrap(bytes31(intNftId));
+    }
+
+    function createBundleInfo(
+        uint256 bundleId,
+        uint256 amount,
+        bytes calldata filter
+    )
+        public 
+        view
+        returns(IBundle.BundleInfo memory info)
+    {
+        uint256 lifetime = 30 * 24 * 3600;
+        return IBundle.BundleInfo(
+            toNftId(bundleId),
+            toNftId(123456),
+            ACTIVE(),
+            filter,
+            amount, // capital amount
+            0, // locked amount
+            amount, // balance
+            blockTimestamp().addSeconds(lifetime), // expiredAt
+            zeroTimestamp()); // closedAt
+    }
+
+    function getStore() public view returns (KeyValueStore) {
+        return _store;
+    }
+}

package/contracts/experiment/kvstore/IBundle.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {NftId} from "../../types/NftId.sol";
+import {StateId} from "../../types/StateId.sol";
+import {Timestamp} from "../../types/Timestamp.sol";
+import {Blocknumber} from "../../types/Blocknumber.sol";
+
+interface IBundle {
+
+    struct BundleInfo {
+        NftId nftId;
+        NftId poolNftId;
+        StateId state; // active, paused, closed (expriy only implicit)
+        bytes filter; // required conditions for applications to be considered for collateralization by this bundle
+        uint256 capitalAmount; // net investment capital amount (<= balance)
+        uint256 lockedAmount; // capital amount linked to collateralizaion of non-closed policies (<= balance)
+        uint256 balanceAmount; // total amount of funds: net investment capital + net premiums - payouts
+        Timestamp expiredAt; // no new policies
+        Timestamp closedAt;
+    }
+}

package/contracts/experiment/kvstore/KeyMapper.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {ObjectType, BUNDLE, RISK} from "../../types/ObjectType.sol";
+
+type KeyId is bytes31;
+
+contract KeyMapper {
+
+    uint8 public constant TYPE_SHIFT = 31 * 8;
+    uint8 public constant ID_SHIFT = uint8(32 * 8 - TYPE_SHIFT);
+    bytes32 public constant TYPE_MASK = bytes32(bytes1(type(uint8).max)); // first byte in bytes32
+    bytes32 public constant ID_MASK = bytes32(~TYPE_MASK); // remaining bytes in bytes32
+
+    struct Key {
+        ObjectType objectType;
+        KeyId id;
+    }
+
+    function toKey(ObjectType objectType, KeyId id) public pure returns(Key memory) {
+        return Key(objectType, id);
+    }
+
+    function toKey(bytes32 key) public pure returns (Key memory) {
+        ObjectType objectType = ObjectType.wrap(uint8(uint256(key & TYPE_MASK) >> TYPE_SHIFT));
+        KeyId id = KeyId.wrap(bytes31((key & ID_MASK) << ID_SHIFT));
+        return Key(objectType, id);
+    }
+
+    function toKey32(Key memory key) public pure returns(bytes32) {
+        return toKey32(key.objectType, key.id);
+    }
+
+    function toKey32(ObjectType objectType, KeyId id) public pure returns(bytes32) {
+        uint256 uintObjectType = ObjectType.unwrap(objectType);
+        uint256 uintId = uint248(KeyId.unwrap(id));
+        uint256 uintKey = (uintObjectType << TYPE_SHIFT) + uintId;
+        return bytes32(uintKey);
+    }
+}

package/contracts/experiment/kvstore/KeyValueStore.sol

@@ -0,0 +1,156 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+/*
+
+fa = {'from': accounts[0]}
+tl = TimestampLib.deploy(fa)
+kv = KeyValueStore.deploy(fa)
+
+pk = kv.s2k('policy key 1')
+pd = kv.s2b('policy info data 1.a')
+
+rk = kv.s2k('risk key 1')
+rd = kv.s2b('risk info data 1.a')
+
+kv.exists(pk)
+ptx = kv.create(pk, kv.policy(), pd)
+rtx = kv.create(rk, kv.policy(), rd)
+kv.exists(pk)
+kv.get(pk)
+
+kv.b2s(kv.getData(pk))
+
+pd1b = kv.s2b('b')
+ptxb = kv.update(pk, pd1b, True, True) # gas: 48019, 46428
+
+pd1c = kv.s2b('c')
+ptxc = kv.update(pk, pd1c, True, True) # gas: 43819, 42228
+
+pd1d = kv.s2b('d')
+ptxd = kv.update(pk, pd1d, True, False) # gas: 32655, 32699
+
+pd1e = kv.s2b('e')
+ptxe = kv.update(pk, pd1e, False, True) # gas: 34525, 34575
+
+pd1f = kv.s2b('f')
+ptxf = kv.update(pk, pd1f, False, False) # gas: 32638, 32682
+
+pd1g = kv.s2b('g')
+ptxg = kv.update(pk, pd1f, True, True, True, False) # gas: 
+
+
+
+*/
+
+type KeyId is bytes32;
+
+import {ObjectType, RISK, POLICY} from "../../types/ObjectType.sol";
+import {Timestamp, blockTimestamp, zeroTimestamp} from "../../types/Timestamp.sol";
+import {Blocknumber, blockBlocknumber, zeroBlocknumber} from "../../types/Blocknumber.sol";
+
+contract KeyValueStore {
+
+    event LogInfoCreated(bytes32 key, ObjectType objectType, address createdBy);
+    event LogInfoUpdated(bytes32 key, ObjectType objectType, address updatedBy, Blocknumber lastUpdateIn);
+
+    struct Metadata {
+        ObjectType objectType;
+        address updatedBy;
+        Blocknumber updatedIn;
+        Blocknumber createdIn;
+    }
+
+    struct Value {
+        Metadata metadata;
+        bytes data;
+    }
+
+    mapping(bytes32 key => Value value) private _value;
+    bytes32[] private _keys;
+
+    // key store functions
+    function create(bytes32 key, ObjectType objectType, bytes memory data) public {
+        Metadata storage metadata = _value[key].metadata;
+        require(metadata.updatedBy == address(0), "ERROR_ALREADY_CREATED");
+
+        address createdBy = msg.sender;
+        Blocknumber blocknumber = blockBlocknumber();
+        metadata.objectType = objectType;
+        metadata.updatedBy = createdBy;
+        metadata.updatedIn = blocknumber;
+        metadata.createdIn = blocknumber;
+
+        _value[key].data = data;
+        _keys.push(key);
+
+        emit LogInfoCreated(key, objectType, createdBy);
+    }
+
+    function update(bytes32 key, bytes memory data) public {
+        update(key, data, true, true);
+    }
+
+    function update(bytes32 key, bytes memory data, bool updateMetadata, bool log) public {
+        _value[key].data = data;
+        Blocknumber blocknumber = blockBlocknumber();
+
+        if(updateMetadata && log) {
+            Metadata storage metadata = _value[key].metadata;
+            require(metadata.updatedBy != address(0), "ERROR_NOT_EXISTING");
+
+            if (log) {
+                emit LogInfoUpdated(key, metadata.objectType, msg.sender, metadata.updatedIn);
+            }
+
+            metadata.updatedBy = msg.sender;
+            metadata.updatedIn = blocknumber;
+        } else if (log) {
+            emit LogInfoUpdated(key, POLICY(), msg.sender, blocknumber);
+        }
+    }
+
+    function exists(bytes32 key) public view returns (bool) {
+        return _value[key].metadata.updatedBy != address(0);
+    }
+
+    function get(bytes32 key) public view returns (Value memory value) {
+        return _value[key];
+    }
+
+    function getMetadata(bytes32 key) public view returns (Metadata memory metadata) {
+        return _value[key].metadata;
+    }
+
+    function getData(bytes32 key) public view returns (bytes memory data) {
+        return _value[key].data;
+    }
+
+    function getKeyCount() public view returns (uint256 keyCount) {
+        return _keys.length;
+    }
+
+    function getKey(uint256 index) public view returns (bytes32 key) {
+        return _keys[index];
+    }
+
+    function policy() public pure returns (ObjectType) {
+        return POLICY();
+    }
+
+    function risk() public pure returns (ObjectType) {
+        return RISK();
+    }
+
+    function s2k(string memory s) public pure returns (bytes32 k) {
+        return keccak256(abi.encodePacked(s));
+    }
+
+    function s2b(string memory s) public pure returns (bytes memory b) {
+        return abi.encode(s);
+    }
+
+    function b2s(bytes memory b) public pure returns (string memory s) {
+        return abi.decode(b, (string));
+    }
+}

package/contracts/experiment/kvstore/KvStore.sol

@@ -0,0 +1,195 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+/*
+fa = {'from': accounts[0]}
+tl = TimestampLib.deploy(fa)
+kv = KvStore.deploy(fa)
+r1 = kv.createRiskInfo(kv.s2b('risk spec 1'))
+b1 = kv.createBundleInfo(123456, 10000000, kv.s2b('bundle filter 1'))
+
+(r1k, r1v) = kv.riskInfoToKeyValue(3, r1)
+
+kv.toKey(r1k)
+
+*/
+
+import {NftId, toNftId} from "../../types/NftId.sol";
+import {RiskId, toRiskId} from "../../types/RiskId.sol";
+import {ObjectType, BUNDLE, RISK} from "../../types/ObjectType.sol";
+import {VersionPart} from "../../types/Version.sol";
+import {StateId, ACTIVE} from "../../types/StateId.sol";
+import {Timestamp, blockTimestamp, zeroTimestamp} from "../../types/Timestamp.sol";
+import {Blocknumber, blockNumber} from "../../types/Blocknumber.sol";
+import {IBundle} from "./IBundle.sol";
+import {IRisk} from "../../instance/module/risk/IRisk.sol";
+
+type KeyId is bytes31;
+
+contract KvStore {
+
+    uint8 public constant TYPE_SHIFT = 31 * 8;
+    bytes32 public constant TYPE_MASK = bytes32(bytes1(type(uint8).max)); // first byte in bytes32
+    bytes32 public constant ID_MASK = bytes32(~TYPE_MASK); // remaining bytes in bytes32
+
+    struct Key {
+        ObjectType objectType;
+        KeyId id;
+    }
+
+    struct Value {
+        VersionPart majorVersion;
+        bytes data;
+    }
+
+    mapping(bytes32 key => Value value) private _store;
+    bytes32[] private _keys;
+
+    function toKey32(RiskId riskId) public pure returns (bytes32 key) {
+        uint256 objectType = uint256(ObjectType.unwrap(RISK()));
+        uint256 id = uint96(RiskId.unwrap(riskId));
+        return bytes32(objectType << TYPE_SHIFT + id);
+    }
+
+    function toKey(bytes32 key32) public pure returns (Key memory key) {
+        ObjectType objectType = ObjectType.wrap(uint8(uint256(key32 & TYPE_MASK) >> TYPE_SHIFT));
+        KeyId id = KeyId.wrap(bytes31(key32 & ID_MASK));
+        return Key(objectType, id);
+    }
+
+    function toBytes32(uint256 value) public pure returns(bytes32) { return bytes32(value); }
+
+    // key store functions
+    function create(bytes32 key, Value memory value) public {
+        // add only store
+        require(VersionPart.unwrap(_store[key].majorVersion) == 0, "ERROR_KEY_USED");
+        _store[key] = value;
+        _keys.push(key);
+    }
+
+    function update(bytes32 key, Value memory value) public {
+        // add only store
+        require(VersionPart.unwrap(_store[key].majorVersion) > 0, "ERROR_KEY_UNKNOWN");
+        _store[key] = value;
+    }
+
+    function getIdMask() public pure returns (bytes32) { return ID_MASK; }
+    function getTypeMask() public pure returns (bytes32) { return TYPE_MASK; }
+
+    function get(bytes32 key) public view returns (Value memory value) {
+        return _store[key];
+    }
+
+    function exists(bytes32 key) public view returns (bool) {
+        return VersionPart.unwrap(_store[key].majorVersion) > 0;
+    }
+
+    function getKeyCount() public view returns (uint256 keyCount) {
+        return _keys.length;
+    }
+
+    function getKey(uint256 index) public view returns (bytes32 key) {
+        return _keys[index];
+    }
+
+    function s2b(string memory s) public pure returns (bytes memory b) {
+        return abi.encodePacked(s);
+    }
+
+    function b2s(bytes memory b) public pure returns (string memory s) {
+        return abi.decode(b, (string));
+    }
+
+    // risk related functions
+
+    function keyToRiskId(Key memory key) public pure returns (RiskId id) {
+        require(key.objectType == RISK(), "ERROR_NOT_RISK_KEY");
+        return RiskId.wrap(bytes12(KeyId.unwrap(key.id)));
+    }
+
+    function createRiskInfo(
+        bytes memory specification
+    )
+        public 
+        view
+        returns(IRisk.RiskInfo memory info)
+    {
+        RiskId riskId = toRiskId(specification);
+        return IRisk.RiskInfo(
+            riskId,
+            ACTIVE(),
+            specification,
+            blockTimestamp(), // createdAt
+            blockNumber()); // updatedIn
+    }
+
+    function riskIdToKey(RiskId riskId) public pure returns(bytes32 key) {
+        return keccak256(abi.encode(RISK(), riskId));
+    }
+
+    function encodeRiskInfo(IRisk.RiskInfo memory info) public pure returns (bytes memory data) {
+        return abi.encode(info);
+    }
+
+    function decodeRiskInfo(bytes memory data) public pure returns (IRisk.RiskInfo memory info) {
+        return abi.decode(data, (IRisk.RiskInfo));
+    }
+
+    function riskInfoToKeyValue(VersionPart majorVersion, IRisk.RiskInfo memory info) public pure returns (bytes32 key, Value memory value) {
+        return (
+            toKey32(info.id),
+            Value(majorVersion, abi.encode(info))
+        );
+    }
+
+    function valueToRiskInfo(Value memory value) public pure returns (IRisk.RiskInfo memory info) {
+        return abi.decode(value.data, (IRisk.RiskInfo));
+    }
+
+    // bundle related functions
+    function createBundleInfo(
+        NftId bundleNftId,
+        uint256 amount,
+        bytes calldata filter
+    )
+        public 
+        view
+        returns(IBundle.BundleInfo memory info)
+    {
+        uint256 lifetime = 30 * 24 * 3600;
+        return IBundle.BundleInfo(
+            bundleNftId,
+            toNftId(123456),
+            ACTIVE(),
+            filter,
+            amount,
+            0,
+            amount,
+            blockTimestamp().addSeconds(lifetime), // expiredAt
+            zeroTimestamp()); // closedAt
+    }
+
+    function nftIdToKey(NftId nftId) public pure returns(bytes32 key) {
+        return keccak256(abi.encode(BUNDLE(), nftId));
+    }
+
+    function nftIdToKeyPacked(NftId nftId) public pure returns(bytes32 key) {
+        return keccak256(abi.encodePacked(BUNDLE(), nftId));
+    }
+
+    function bundleInfoToValue(VersionPart majorVersion, IBundle.BundleInfo memory info) public pure returns (Value memory value) {
+        return Value(majorVersion, abi.encode(info));
+    }
+
+    function valueToBundleInfo(Value memory value) public pure returns (IBundle.BundleInfo memory info) {
+        return abi.decode(value.data, (IBundle.BundleInfo));
+    }
+
+    function encodeBundleInfo(IBundle.BundleInfo memory info) public pure returns (bytes memory data) {
+        return abi.encode(info);
+    }
+
+    function decodeBundleInfo(bytes memory data) public pure returns (IBundle.BundleInfo memory info) {
+        return abi.decode(data, (IBundle.BundleInfo));
+    }
+}

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/README.md

@@ -0,0 +1,112 @@
+# State Machines
+
+Most GIF objects have a life cycle defined by a state machine.
+
+For each object type the set of possible states is defined together with its initial state and the set of valid state transitions.
+
+## Object Types without States
+
+* Protocol
+* Chains
+* Registries (both chain and main registry)
+
+## Object Types with States
+
+* Tokens
+* Instances
+* Products
+* Oracles
+* Pools
+* Bundles
+* Policies
+* Claim (non-NFT)
+* Payout (non-NFT)
+
+### Simple State Machine
+
+Valid states
+
+* Active (initial state)
+* Paused
+* Archived (final state)
+
+Valid state transitions:
+
+* Active -> Paused
+* Paused -> Active
+* Paused -> Archived
+
+
+Candidate object types for simple state machine
+
+* Token
+* Instance
+* Product
+* Oracle
+* Pool
+
+To discuss: 
+
+* Archived is final state
+* What mechanism should exist to revert an unintended transition to 'Archived' state. Should there be such a mechanism?
+* What mechanism should exist when the NFT of such an object is burned prematurely. Should there be such a mechanism
+
+### Bundle State Machine
+
+Valid states
+
+* Active (initial state)
+* Paused
+* Expired (implicit state)
+* Closed (final state)
+
+Expired is not an explicit state. 
+A bundle is expired for block.timestamp >= expiredAt
+
+### Policy State Machine
+
+Valid states
+
+* Applied (initial state)
+* Revoked (final state)
+* Declined (final state)
+* Active
+* Expired (implicit state)
+* Closed (final state)
+
+Expired is not an explicit state. 
+A policy is expired for block.timestamp >= expiredAt
+
+To discuss: 
+
+* Should 'Closed' be less explicit using a closedAt state variable? 
+* Or even more lighweight? ie. block.timestamp >= expiredAt and no open claims
+
+Valid state transitions:
+
+* Applied -> Revoked
+* Applied -> Declined
+* Applied -> Active
+* Active -> Closed (needs to be expired)
+
+### Claim State Machine
+
+Valid states
+* Applied (initial state)
+* Confirmed
+* Declined (final state)
+* Closed (final state)
+
+Valid state transitions:
+* Applied -> Confirmed
+* Applied -> Declined
+* Confirmed -> Closed
+
+### Payout State Machine
+
+Valid states
+* Expected
+* PaidOut
+
+Valid state transitions:
+* Expected -> PaidOut