@etherisc/gif-next 0.0.2-e6ad61d-739 → 0.0.2-e818783-565

package/contracts/instance/base/ComponentService.sol

@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IComponent} from "../../components/IComponent.sol";
+import {IRegistry} from "../../registry/IRegistry.sol";
+import {IRegistryService} from "../../registry/IRegistryService.sol";
+import {IInstance} from "../../instance/IInstance.sol";
+import {IAccess} from "../module/IAccess.sol";
+import {ObjectType, INSTANCE, REGISTRY} from "../../types/ObjectType.sol";
+import {NftId} from "../../types/NftId.sol";
+import {RoleId} from "../../types/RoleId.sol";
+
+import {Service} from "../../shared/Service.sol";
+import {InstanceService} from "../InstanceService.sol";
+import {InstanceAccessManager} from "../InstanceAccessManager.sol";
+
+abstract contract ComponentService is Service {
+
+    error ErrorComponentServiceNotComponent(address component);
+    error ErrorComponentServiceInvalidType(address component, ObjectType requiredType, ObjectType componentType);
+    error ErrorComponentServiceSenderNotOwner(address component, address initialOwner, address sender);
+    error ErrorComponentServiceExpectedRoleMissing(NftId instanceNftId, RoleId requiredRole, address sender);
+    error ErrorComponentServiceComponentLocked(address component);
+
+    /// @dev modifier to check if caller is a registered service
+    modifier onlyService() {
+        address caller = msg.sender;
+        require(getRegistry().isRegisteredService(caller), "ERROR_NOT_SERVICE");
+        _;
+    }
+
+    // view functions
+
+    function getRegistryService() public view virtual returns (IRegistryService) {
+        return IRegistryService(_getServiceAddress(REGISTRY()));
+    }
+
+    function getInstanceService() public view returns (InstanceService) {
+        return InstanceService(_getServiceAddress(INSTANCE()));
+    }
+
+    function _getServiceAddress(ObjectType domain) internal view returns (address) {
+        return getRegistry().getServiceAddress(domain, getVersion().toMajorPart());
+    }
+
+    // internal functions
+    function _checkComponentForRegistration(
+        address componentAddress,
+        ObjectType requiredType,
+        RoleId requiredRole
+    )
+        internal
+        view
+        returns (
+            IComponent component,
+            address owner,
+            IInstance instance,
+            NftId instanceNftId
+        )
+    {
+        // component may only be registerd by initial owner of component
+        owner = msg.sender;
+
+        // check this is a component
+        component = IComponent(componentAddress);
+        if(!component.supportsInterface(type(IComponent).interfaceId)) {
+            revert ErrorComponentServiceNotComponent(componentAddress);
+        }
+
+        // check component is of required type
+        IRegistry.ObjectInfo memory componentInfo = component.getInitialInfo();
+        if(componentInfo.objectType != requiredType) {
+            revert ErrorComponentServiceInvalidType(componentAddress, requiredType, componentInfo.objectType);
+        }
+
+        // check msg.sender is component owner
+        address initialOwner = componentInfo.initialOwner;
+        if(owner != initialOwner) {
+            revert ErrorComponentServiceSenderNotOwner(componentAddress, componentInfo.initialOwner, owner);
+        }
+
+        // check instance has assigned required role to owner
+        instanceNftId = componentInfo.parentNftId;
+        instance = _getInstance(instanceNftId);
+        if(!instance.getInstanceAccessManager().hasRole(requiredRole, owner)) {
+            revert ErrorComponentServiceExpectedRoleMissing(instanceNftId, requiredRole, owner);
+        }
+    }
+
+    // internal view functions
+
+    function _getAndVerifyComponentInfoAndInstance(
+        ObjectType expectedType
+    )
+        internal
+        view
+        returns(
+            NftId nftId,
+            IRegistry.ObjectInfo memory info, 
+            IInstance instance
+        )
+    {
+        IRegistry registry = getRegistry();
+
+        info = registry.getObjectInfo(msg.sender);
+        require(info.objectType == expectedType, "OBJECT_TYPE_INVALID");
+
+        nftId = info.nftId;
+        instance = _getInstance(info.parentNftId);
+
+        if (instance.getInstanceAccessManager().isTargetLocked(info.objectAddress)) {
+            revert IAccess.ErrorIAccessTargetLocked(info.objectAddress);
+        }
+    }
+
+    function _getInstance(NftId instanceNftId) internal view returns (IInstance) {
+        return IInstance(
+            getRegistry().getObjectInfo(
+                instanceNftId).objectAddress);
+    }
+}

package/contracts/instance/base/IKeyValueStore.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Blocknumber, blockBlocknumber, zeroBlocknumber} from "../../types/Blocknumber.sol";
+import {Key32, KeyId} from "../../types/Key32.sol";
+import {NftId} from "../../types/NftId.sol";
+import {ObjectType} from "../../types/ObjectType.sol";
+import {StateId} from "../../types/StateId.sol";
+
+import {ILifecycle} from "./ILifecycle.sol";
+
+// TODO remove - internal only?
+interface IKeyValueStore is ILifecycle {
+
+    struct Value {
+        Metadata metadata;
+        bytes data;
+    }
+
+    struct Metadata {
+        ObjectType objectType;
+        StateId state;
+        // TODO updatedBy needs concept that says what value should go here
+        // eg account outside gif objects that initiated the tx
+        // implies the caller needs to be propagated through all calls up to key values store itself
+        // to always have the instance address there doesn't seem to make sense
+        address updatedBy;
+        Blocknumber updatedIn;
+        Blocknumber createdIn;
+    }
+
+    event LogInfoCreated(ObjectType objectType, KeyId keyId, StateId state, address createdBy, address txOrigin);
+    event LogInfoUpdated(ObjectType objectType, KeyId keyId, StateId state, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogStateUpdated(ObjectType objectType, KeyId keyId, StateId stateOld, StateId stateNew, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+
+    // generic state changing functions
+    // function create(Key32 key, bytes memory data) external;
+    // function update(Key32 key, bytes memory data, StateId state) external;
+    // function updateData(Key32 key, bytes memory data) external;
+    // function updateState(Key32 key, StateId state) external;
+
+    function exists(Key32 key) external view returns (bool);
+    function get(Key32 key) external view returns (Value memory value);
+    function getData(Key32 key) external view returns (bytes memory data);
+    function getMetadata(Key32 key) external view returns (Metadata memory metadata);
+    function getState(Key32 key) external view returns (StateId state);
+
+    function toKey32(ObjectType objectType, KeyId id) external pure returns(Key32);
+}

package/contracts/instance/base/ILifecycle.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {NftId} from "../../types/NftId.sol";
+import {ObjectType} from "../../types/ObjectType.sol";
+import {StateId} from "../../types/StateId.sol";
+
+interface ILifecycle {
+
+    error ErrorNoLifecycle(NftId nftId, ObjectType objectType);
+    error ErrorInvalidStateTransition(
+        ObjectType objectType,
+        StateId fromStateId,
+        StateId toStateId
+    );
+
+    function hasLifecycle(
+        ObjectType objectType
+    ) external view returns (bool);
+
+    function getInitialState(
+        ObjectType objectType
+    ) external view returns (StateId);
+
+    function isValidTransition(
+        ObjectType objectType,
+        StateId fromId,
+        StateId toId
+    ) external view returns (bool);
+}

package/contracts/instance/base/KeyValueStore.sol

@@ -0,0 +1,180 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Blocknumber, blockBlocknumber, zeroBlocknumber} from "../../types/Blocknumber.sol";
+import {Key32, KeyId, Key32Lib} from "../../types/Key32.sol";
+import {NftId} from "../../types/NftId.sol";
+import {ObjectType} from "../../types/ObjectType.sol";
+import {StateId, ACTIVE, KEEP_STATE} from "../../types/StateId.sol";
+import {Timestamp, TimestampLib} from "../../types/Timestamp.sol";
+
+import {Lifecycle} from "./Lifecycle.sol";
+import {IKeyValueStore} from "./IKeyValueStore.sol";
+
+contract KeyValueStore is Lifecycle, IKeyValueStore {
+
+    mapping(Key32 key32 => Value value) private _value;
+
+    function create(
+        Key32 key32, 
+        bytes memory data
+    )
+        internal
+    {
+        _create(key32, data);
+    }
+
+    function _create(
+        Key32 key32, 
+        bytes memory data
+    )
+        internal
+    {
+        ObjectType objectType = key32.toObjectType();
+        require(objectType.gtz(), "ERROR:KVS-010:TYPE_UNDEFINED");
+
+        Metadata storage metadata = _value[key32].metadata;
+        require(metadata.state.eqz(), "ERROR:KVS-012:ALREADY_CREATED");
+
+        address createdBy = msg.sender;
+        Blocknumber blocknumber = blockBlocknumber();
+        StateId initialState = hasLifecycle(objectType) ? getInitialState(objectType) : ACTIVE();
+
+        // set metadata
+        metadata.objectType = objectType;
+        metadata.state = initialState;
+        metadata.updatedBy = createdBy;
+        metadata.updatedIn = blocknumber;
+        metadata.createdIn = blocknumber;
+
+        // set data
+        _value[key32].data = data;
+
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogInfoCreated(key32.toObjectType(), key32.toKeyId(), initialState, createdBy, tx.origin);
+    }
+
+    function update(
+        Key32 key32, 
+        bytes memory data,
+        StateId state
+    ) 
+        internal
+    {
+        _update(key32, data, state);
+    }
+
+    function _update(
+        Key32 key32, 
+        bytes memory data,
+        StateId state
+    ) 
+        internal
+    {
+        require(state.gtz(), "ERROR:KVS-020:STATE_UNDEFINED");
+        Metadata storage metadata = _value[key32].metadata;
+        StateId stateOld = metadata.state;
+        require(stateOld.gtz(), "ERROR:KVS-021:NOT_EXISTING");
+
+        // update data
+        _value[key32].data = data;
+
+        // update state 
+        if(state != KEEP_STATE()) {
+            metadata.state = state;
+        }
+
+        // update reest of metadata
+        address updatedBy = msg.sender;
+        Blocknumber lastUpdatedIn = metadata.updatedIn;
+
+        metadata.updatedBy = updatedBy;
+        metadata.updatedIn = blockBlocknumber();
+
+        // create log entries
+        // solhint-disable avoid-tx-origin
+        emit LogStateUpdated(key32.toObjectType(), key32.toKeyId(), stateOld, state, updatedBy, tx.origin, lastUpdatedIn);
+        emit LogInfoUpdated(key32.toObjectType(), key32.toKeyId(), state, updatedBy, tx.origin, lastUpdatedIn);
+        // solhing-enable
+    }
+
+    function updateData(Key32 key32, bytes memory data) 
+        internal
+    {
+        _updateData(key32, data);
+    }
+
+    function _updateData(Key32 key32, bytes memory data) 
+        internal
+    {
+        Metadata storage metadata = _value[key32].metadata;
+        StateId state = metadata.state;
+        require(state.gtz(), "ERROR:KVS-030:NOT_EXISTING");
+
+        // update data
+        _value[key32].data = data;
+
+        // update metadata
+        address updatedBy = msg.sender;
+        Blocknumber lastUpdatedIn = metadata.updatedIn;
+        metadata.updatedBy = updatedBy;
+        metadata.updatedIn = blockBlocknumber();
+
+        // create log entry
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogInfoUpdated(key32.toObjectType(), key32.toKeyId(), state, updatedBy, tx.origin, lastUpdatedIn);
+    }
+
+    function updateState(Key32 key32, StateId state)
+        internal
+    {
+        _updateState(key32, state);
+    }
+
+    function _updateState(Key32 key32, StateId state)
+        internal
+    {
+        require(state.gtz(), "ERROR:KVS-040:STATE_UNDEFINED");
+        Metadata storage metadata = _value[key32].metadata;
+        StateId stateOld = metadata.state;
+        require(stateOld.gtz(), "ERROR:KVS-041:NOT_EXISTING");
+
+        // ensure state transistion is valid
+        checkTransition(metadata.objectType, stateOld, state);
+
+        // update metadata (and state)
+        address updatedBy = msg.sender;
+        Blocknumber lastUpdatedIn = metadata.updatedIn;
+        metadata.state = state;
+        metadata.updatedBy = updatedBy;
+        metadata.updatedIn = blockBlocknumber();
+
+        // create log entry
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogStateUpdated(key32.toObjectType(), key32.toKeyId(), stateOld, state, updatedBy, tx.origin, lastUpdatedIn);
+    }
+
+    function exists(Key32 key32) public view returns (bool) {
+        return _value[key32].metadata.state.gtz();
+    }
+
+    function get(Key32 key32) public view returns (Value memory value) {
+        return _value[key32];
+    }
+
+    function getMetadata(Key32 key32) public view returns (Metadata memory metadata) {
+        return _value[key32].metadata;
+    }
+
+    function getData(Key32 key32) public view returns (bytes memory data) {
+        return _value[key32].data;
+    }
+
+    function getState(Key32 key32) public view returns (StateId state) {
+        return _value[key32].metadata.state;
+    }
+
+    function toKey32(ObjectType objectType, KeyId id) external pure override returns(Key32) {
+        return Key32Lib.toKey32(objectType, id);
+    }
+}

package/contracts/instance/base/Lifecycle.sol

@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
+
+import {NftId} from "../../types/NftId.sol";
+import {ObjectType, COMPONENT, BUNDLE, POLICY, RISK, CLAIM} from "../../types/ObjectType.sol";
+import {StateId, ACTIVE, PAUSED, ARCHIVED, CLOSED, APPLIED, COLLATERALIZED, REVOKED, SUBMITTED, CONFIRMED, DECLINED} from "../../types/StateId.sol";
+import {ILifecycle} from "./ILifecycle.sol";
+
+contract Lifecycle is
+    Initializable,
+    ILifecycle
+{
+    mapping(ObjectType objectType => StateId initialState)
+        private _initialState;
+
+    mapping(ObjectType objectType => mapping(StateId stateFrom => mapping(StateId stateTo => bool isValid)))
+        private _isValidTransition;
+
+    function initializeLifecycle()
+        public
+        onlyInitializing
+    {
+        _setupBundleLifecycle();
+        _setupComponentLifecycle();
+        _setupPolicyLifecycle();
+        _setupClaimLifecycle();
+        _setupRiskLifecycle();
+    }
+
+    function hasLifecycle(
+        ObjectType objectType
+    )
+        public
+        view
+        override
+        returns (bool)
+    {
+        return _initialState[objectType].gtz();
+    }
+
+    function getInitialState(
+        ObjectType objectType
+    )
+        public
+        view
+        returns (StateId)
+    {
+        return _initialState[objectType];
+    }
+
+    function checkTransition(
+        ObjectType objectType,
+        StateId fromId,
+        StateId toId
+    )
+        public
+        view
+    {
+        // return if no life cycle support
+        if (_initialState[objectType].eqz()) {
+            return;
+        }
+
+        // enforce valid state transition
+        if (!_isValidTransition[objectType][fromId][toId]) {
+            revert ErrorInvalidStateTransition(objectType, fromId, toId);
+        }
+    }
+
+    function isValidTransition(
+        ObjectType objectType,
+        StateId fromId,
+        StateId toId
+    ) public view returns (bool) {
+        return _isValidTransition[objectType][fromId][toId];
+    }
+
+    function _setupComponentLifecycle() internal {
+        _initialState[COMPONENT()] = ACTIVE();
+        _isValidTransition[COMPONENT()][ACTIVE()][PAUSED()] = true;
+        _isValidTransition[COMPONENT()][PAUSED()][ACTIVE()] = true;
+        _isValidTransition[COMPONENT()][PAUSED()][ARCHIVED()] = true;
+    }
+
+    function _setupBundleLifecycle() internal {
+        _initialState[BUNDLE()] = ACTIVE();
+        _isValidTransition[BUNDLE()][ACTIVE()][PAUSED()] = true;
+        _isValidTransition[BUNDLE()][ACTIVE()][CLOSED()] = true;
+        _isValidTransition[BUNDLE()][PAUSED()][ACTIVE()] = true;
+        _isValidTransition[BUNDLE()][PAUSED()][CLOSED()] = true;
+    }
+
+    function _setupPolicyLifecycle() internal {
+        _initialState[POLICY()] = APPLIED();
+        _isValidTransition[POLICY()][APPLIED()][REVOKED()] = true;
+        _isValidTransition[POLICY()][APPLIED()][DECLINED()] = true;
+        _isValidTransition[POLICY()][APPLIED()][COLLATERALIZED()] = true;
+        _isValidTransition[POLICY()][COLLATERALIZED()][ACTIVE()] = true;
+        _isValidTransition[POLICY()][ACTIVE()][CLOSED()] = true;
+    }
+
+    function _setupClaimLifecycle() internal {
+        _initialState[CLAIM()] = SUBMITTED();
+        _isValidTransition[CLAIM()][SUBMITTED()][CONFIRMED()] = true;
+        _isValidTransition[CLAIM()][SUBMITTED()][DECLINED()] = true;
+        _isValidTransition[CLAIM()][CONFIRMED()][CLOSED()] = true;
+    }
+
+    function _setupRiskLifecycle() internal {
+        _initialState[RISK()] = ACTIVE();
+        _isValidTransition[RISK()][ACTIVE()][PAUSED()] = true;
+        _isValidTransition[RISK()][PAUSED()][ACTIVE()] = true;
+        _isValidTransition[RISK()][PAUSED()][ARCHIVED()] = true;
+    }
+}

package/contracts/instance/module/IAccess.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {ShortString, ShortStrings} from "@openzeppelin/contracts/utils/ShortStrings.sol";
+
+import {RoleId} from "../../types/RoleId.sol";
+import {Timestamp} from "../../types/Timestamp.sol";
+
+interface IAccess {
+
+    enum Type {
+        NotInitialized,
+        Core,
+        Gif,
+        Custom        
+    }
+
+    struct RoleInfo {
+        ShortString name;
+        Type rtype;
+        //bool isLocked;
+        RoleId admin;
+        Timestamp createdAt;
+        Timestamp updatedAt;
+    }
+
+    struct TargetInfo {
+        ShortString name;
+        Type ttype;
+        bool isLocked;
+        Timestamp createdAt;
+        Timestamp updatedAt;
+    }
+
+    error ErrorIAccessCallerIsNotRoleAdmin(address caller, RoleId roleId);
+
+    error ErrorIAccessRoleIdDoesNotExist(RoleId roleId);
+    error ErrorIAccessRoleIdTooBig(RoleId roleId);
+    error ErrorIAccessRoleIdTooSmall(RoleId roleId);
+    error ErrorIAccessRoleIdExists(RoleId roleId);
+    error ErrorIAccessRoleNameEmpty(RoleId roleId);
+    error ErrorIAccessRoleNameExists(RoleId roleId, RoleId existingRoleId, ShortString name);
+    error ErrorIAccessRoleTypeInvalid(RoleId roleId, Type rtype);
+
+    error ErrorIAccessTargetAddressZero();
+    error ErrorIAccessTargetDoesNotExist(address target);
+    error ErrorIAccessTargetExists(address target, ShortString name);
+    error ErrorIAccessTargetTypeInvalid(address target, Type ttype);
+    error ErrorIAccessTargetNameEmpty(address target);
+    error ErrorIAccessTargetNameExists(address target, address existingTarget, ShortString name);
+    error ErrorIAccessTargetLocked(address target);
+    error ErrorIAccessTargetNotRegistered(address target);
+    error ErrorIAccessTargetAuthorityInvalid(address target, address targetAuthority);
+}

package/contracts/instance/module/IBundle.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Amount} from "../../types/Amount.sol";
+import {NftId} from "../../types/NftId.sol";
+import {Fee} from "../../types/Fee.sol";
+import {Seconds} from "../../types/Seconds.sol";
+import {Timestamp} from "../../types/Timestamp.sol";
+
+interface IBundle {
+
+    struct BundleInfo {
+        NftId poolNftId;
+        Fee fee; // bundle fee on net premium amounts
+        bytes filter; // required conditions for applications to be considered for collateralization by this bundle
+        Amount capitalAmount; // net stakings + net premiums - payouts
+        Amount lockedAmount; // capital amount linked to collateralizaion of non-closed policies (<= capital amount)
+        Amount feeAmount; // accumulated fee amount
+        Seconds lifetime;
+        Timestamp expiredAt; // no new policies starting with this timestamp
+        Timestamp closedAt; // no open policies, locked amount = 0
+    }
+}

package/contracts/instance/module/IComponents.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {Amount} from "../../types/Amount.sol";
+import {Fee} from "../../types/Fee.sol";
+import {NftId} from "../../types/NftId.sol";
+import {RoleId} from "../../types/RoleId.sol";
+import {TokenHandler} from "../../shared/TokenHandler.sol";
+import {UFixed} from "../../types/UFixed.sol";
+
+interface IComponents {
+
+    struct ComponentInfo {
+        string name; // component name (needs to be unique per instance)
+        IERC20Metadata token;
+        TokenHandler tokenHandler;
+        address wallet;
+        Amount balanceAmount; // calculated balance (may not necessarily match withg wallet balance)
+        Amount feeAmount; // accumulated fees belonging to component owner
+        bytes data; // will hold component type specific additional info (eg encoded pool info)
+    }
+
+    struct PoolInfo {
+        NftId productNftId; // the nft of the product this pool is linked to
+        RoleId bundleOwnerRole; // the required role for bundle owners
+        // TODO maxCapitalAmount -> maxBalanceAmount
+        uint256 maxCapitalAmount; // max capital amount allowed for pool
+        uint256 balanceAmount; // current pool balance (accounting view)
+        uint256 feeAmount; // accumulated fee amount
+        bool isInterceptingBundleTransfers; // intercepts nft transfers for bundles
+        bool isExternallyManaged; // funding bundles is restricted to book keeping, actual funds may be provided as needed to support payouts
+        bool isVerifyingApplications; // underwriting requires the pool component checks/confirms the applications 
+        UFixed collateralizationLevel; // factor to calculate collateral for sum insurance (default 100%)
+        UFixed retentionLevel; // amount of collateral held in pool (default 100%)
+        Fee poolFee; // pool fee on net premium
+        Fee stakingFee; // pool fee on staked capital from investor
+        Fee performanceFee; // pool fee on profits from capital investors
+    }
+}

package/contracts/instance/module/IDistribution.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {DistributorType} from "../../types/DistributorType.sol";
+import {NftId} from "../../types/NftId.sol";
+import {Timestamp} from "../../types/Timestamp.sol";
+import {UFixed} from "../../types/UFixed.sol";
+
+interface IDistribution {
+
+    struct DistributorTypeInfo {
+        string name;
+        UFixed minDiscountPercentage;
+        UFixed maxDiscountPercentage;
+        UFixed commissionPercentage;
+        uint32 maxReferralCount;
+        uint32 maxReferralLifetime;
+        bool allowSelfReferrals;
+        bool allowRenewals;
+        bytes data;
+    }
+
+    struct DistributorInfo {
+        DistributorType distributorType;
+        bool active;
+        bytes data;
+        uint256 sumCommisions;
+        uint256 numPoliciesSold;
+    }
+
+    struct ReferralInfo {   
+        NftId distributorNftId;
+        string referralCode;
+        UFixed discountPercentage;
+        uint32 maxReferrals;
+        uint32 usedReferrals;
+        Timestamp expiryAt;
+        bytes data;
+    }
+
+}