@etherisc/gif-next 0.0.2-c4efd5e → 0.0.2-c6846dc-026

package/contracts/instance/Instance.sol

@@ -5,21 +5,26 @@ import {Registerable} from "../registry/Registry.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 
 import {IAccessModule, AccessModule} from "./access/Access.sol";
+import {LifecycleModule} from "./lifecycle/LifecycleModule.sol";
 import {ComponentModule} from "./component/ComponentModule.sol";
 import {ProductModule} from "./product/ProductService.sol";
 import {PolicyModule} from "./policy/PolicyModule.sol";
 import {PoolModule} from "./pool/PoolModule.sol";
+import {TreasuryModule} from "./treasury/TreasuryModule.sol";
 
 import {IInstance} from "./IInstance.sol";
+import {ObjectType, INSTANCE} from "../types/ObjectType.sol";
 import {NftId, toNftId} from "../types/NftId.sol";
 
 contract Instance is
     Registerable,
     AccessModule,
+    LifecycleModule,
     ComponentModule,
     PolicyModule,
     PoolModule,
     ProductModule,
+    TreasuryModule,
     IInstance
 {
     constructor(
@@ -33,7 +38,10 @@ contract Instance is
         PolicyModule(productService)
         ProductModule(productService)
         PoolModule(productService)
-    {}
+    // solhint-disable-next-line no-empty-blocks
+    {
+
+    }
 
     // from registerable
     function register() external override returns (NftId nftId) {
@@ -45,7 +53,7 @@ contract Instance is
     }
 
     // from registerable
-    function getParentNftId() public view override returns (NftId) {
+    function getParentNftId() public pure override returns (NftId) {
         // TODO  add self registry and exchange 0 for_registry.getNftId();
         // define parent tree for all registerables
         // eg 0 <- chain(mainnet) <- global registry <- chain registry <- instance <- component <- policy/bundle
@@ -53,12 +61,12 @@ contract Instance is
     }
 
     // from registerable
-    function getType() external view override returns (uint256 objectType) {
-        return _registry.INSTANCE();
+    function getType() external pure override returns (ObjectType objectType) {
+        return INSTANCE();
     }
 
     // from registerable
-    function getData() external view override returns (bytes memory data) {
+    function getData() external pure override returns (bytes memory data) {
         return bytes(abi.encode(0));
     }
 }

package/contracts/instance/component/ComponentModule.sol

@@ -1,15 +1,24 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
 import {RegistryLinked} from "../../registry/Registry.sol";
 import {IRegistry, IRegistryLinked} from "../../registry/IRegistry.sol";
 import {IAccessComponentTypeRoles, IAccessCheckRole} from "../access/IAccess.sol";
 import {IInstance} from "../IInstance.sol";
 
+import {LifecycleModule} from "../lifecycle/LifecycleModule.sol";
+import {ITreasuryModule} from "../treasury/ITreasury.sol";
+import {TreasuryModule} from "../treasury/TreasuryModule.sol";
 import {IComponent, IComponentContract, IComponentModule, IComponentOwnerService} from "./IComponent.sol";
 import {IProductComponent} from "../../components/IProduct.sol";
+import {IPoolComponent} from "../../components/IPool.sol";
 import {IPoolModule} from "../pool/IPoolModule.sol";
-import {NftId, NftIdLib} from "../../types/NftId.sol";
+import {ObjectType, PRODUCT, ORACLE, POOL} from "../../types/ObjectType.sol";
+import {StateId, ACTIVE, PAUSED} from "../../types/StateId.sol";
+import {NftId, NftIdLib, zeroNftId} from "../../types/NftId.sol";
+import {Fee, zeroFee} from "../../types/Fee.sol";
 
 abstract contract ComponentModule is
     IRegistryLinked,
@@ -20,12 +29,15 @@ abstract contract ComponentModule is
     using NftIdLib for NftId;
 
     mapping(NftId nftId => ComponentInfo info) private _componentInfo;
-    mapping(NftId nftId => NftId poolNftId) private _poolNftIdForProduct;
     mapping(address cAddress => NftId nftId) private _nftIdByAddress;
     NftId[] private _nftIds;
 
-    mapping(uint256 cType => bytes32 role) private _componentOwnerRole;
+    mapping(ObjectType cType => bytes32 role) private _componentOwnerRole;
 
+    // TODO maybe move this to Instance contract as internal variable?
+    LifecycleModule private _lifecycleModule;
+    TreasuryModule private _treasuryModule;
+    IPoolModule private _poolModule;
     IComponentOwnerService private _componentOwnerService;
 
     modifier onlyComponentOwnerService() {
@@ -37,51 +49,73 @@ abstract contract ComponentModule is
     }
 
     constructor(address componentOwnerService) {
+        address componentAddress = address(this);
+        _lifecycleModule = LifecycleModule(componentAddress);
+        _treasuryModule = TreasuryModule(componentAddress);
+        _poolModule = IPoolModule(componentAddress);
         _componentOwnerService = ComponentOwnerService(componentOwnerService);
     }
 
     function registerComponent(
         IComponentContract component
     ) external override onlyComponentOwnerService returns (NftId nftId) {
-        bytes32 typeRole = getRoleForType(component.getType());
+        ObjectType objectType = component.getType();
+        bytes32 typeRole = getRoleForType(objectType);
         require(
             this.hasRole(typeRole, component.getInitialOwner()),
             "ERROR:CMP-004:TYPE_ROLE_MISSING"
         );
 
         nftId = this.getRegistry().register(address(component));
+        IERC20Metadata token = component.getToken();
+        address wallet = component.getWallet();
+
+        // create component info
+        _componentInfo[nftId] = ComponentInfo(
+            nftId,
+            _lifecycleModule.getInitialState(objectType),
+            token
+        );
 
-        _componentInfo[nftId] = ComponentInfo(nftId, CState.Active);
-
-        // special case product -> persist product - pool assignment
-        if (component.getType() == this.getRegistry().PRODUCT()) {
+        // component type specific registration actions
+        if (component.getType() == PRODUCT()) {
             IProductComponent product = IProductComponent(address(component));
             NftId poolNftId = product.getPoolNftId();
             require(poolNftId.gtz(), "ERROR:CMP-005:POOL_UNKNOWN");
-            // add more validation (type, token, ...)
+            // validate pool token and product token are same
 
-            _poolNftIdForProduct[nftId] = poolNftId;
+            // register with tresury
+            // implement and add validation
+            NftId distributorNftId = zeroNftId();
+            _treasuryModule.registerProduct(
+                nftId,
+                distributorNftId,
+                poolNftId,
+                token,
+                wallet,
+                product.getPolicyFee(),
+                product.getProcessingFee()
+            );
+        } else if (component.getType() == POOL()) {
+            IPoolComponent pool = IPoolComponent(address(component));
 
-            // add creation of productInfo
-        } else if (component.getType() == this.getRegistry().POOL()) {
-            IPoolModule poolModule = IPoolModule(address(this));
-            poolModule.createPoolInfo(
+            // register with pool
+            _poolModule.registerPool(nftId);
+
+            // register with tresury
+            _treasuryModule.registerPool(
                 nftId,
-                address(component), // set pool as its wallet
-                address(0) // don't deal with token yet
+                wallet,
+                pool.getStakingFee(),
+                pool.getPerformanceFee()
             );
         }
+        // TODO add distribution
 
         _nftIdByAddress[address(component)] = nftId;
         _nftIds.push(nftId);
 
-        // add logging
-    }
-
-    function getPoolNftId(
-        NftId productNftId
-    ) external view override returns (NftId poolNftId) {
-        poolNftId = _poolNftIdForProduct[productNftId];
+        // TODO add loggingx
     }
 
     function getComponentOwnerService()
@@ -102,9 +136,17 @@ abstract contract ComponentModule is
             "ERROR:CMP-006:COMPONENT_UNKNOWN"
         );
 
+        // TODO decide if state changes should have explicit functions and not
+        // just a generic setXYZInfo and implicit state transitions
+        // when in doubt go for the explicit approach ...
+        ObjectType objectType = this.getRegistry().getInfo(nftId).objectType;
+        _lifecycleModule.checkAndLogTransition(
+            nftId,
+            objectType,
+            _componentInfo[nftId].state,
+            info.state
+        );
         _componentInfo[nftId] = info;
-
-        // add logging
     }
 
     function getComponentInfo(
@@ -113,10 +155,6 @@ abstract contract ComponentModule is
         return _componentInfo[nftId];
     }
 
-    function getComponentOwner(
-        NftId nftId
-    ) external view returns (address owner) {}
-
     function getComponentId(
         address componentAddress
     ) external view returns (NftId componentNftId) {
@@ -138,14 +176,16 @@ abstract contract ComponentModule is
         return _nftIds.length;
     }
 
-    function getRoleForType(uint256 cType) public view returns (bytes32 role) {
-        if (cType == this.getRegistry().PRODUCT()) {
+    function getRoleForType(
+        ObjectType cType
+    ) public view returns (bytes32 role) {
+        if (cType == PRODUCT()) {
             return this.PRODUCT_OWNER_ROLE();
         }
-        if (cType == this.getRegistry().POOL()) {
+        if (cType == POOL()) {
             return this.POOL_OWNER_ROLE();
         }
-        if (cType == this.getRegistry().ORACLE()) {
+        if (cType == ORACLE()) {
             return this.ORACLE_OWNER_ROLE();
         }
     }
@@ -169,7 +209,12 @@ contract ComponentOwnerService is
         _;
     }
 
-    constructor(address registry) RegistryLinked(registry) {}
+    constructor(
+        address registry
+    ) RegistryLinked(registry) // solhint-disable-next-line no-empty-blocks
+    {
+
+    }
 
     function register(
         IComponentContract component
@@ -191,9 +236,9 @@ contract ComponentOwnerService is
             component.getNftId()
         );
         require(info.nftId.gtz(), "ERROR_COMPONENT_UNKNOWN");
-        // TODO add state change validation
 
-        info.state = CState.Locked;
+        info.state = PAUSED();
+        // setComponentInfo checks for valid state changes
         instance.setComponentInfo(info);
     }
 
@@ -205,9 +250,25 @@ contract ComponentOwnerService is
             component.getNftId()
         );
         require(info.nftId.gtz(), "ERROR_COMPONENT_UNKNOWN");
-        // TODO state change validation
 
-        info.state = CState.Active;
+        info.state = ACTIVE();
+        // setComponentInfo checks for valid state changes
         instance.setComponentInfo(info);
     }
+
+    function setProductFees(
+        IComponentContract product,
+        Fee memory policyFee,
+        Fee memory processingFee
+    ) external override onlyComponentOwner(product) {
+        require(product.getType() == PRODUCT(), "ERROR_NOT_PRODUCT");
+
+        address instanceAddress = address(product.getInstance());
+        ITreasuryModule treasuryModule = ITreasuryModule(instanceAddress);
+        treasuryModule.setProductFees(
+            product.getNftId(),
+            policyFee,
+            processingFee
+        );
+    }
 }

package/contracts/instance/component/IComponent.sol

@@ -1,22 +1,21 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
 import {IOwnable, IRegistryLinked, IRegisterable} from "../../registry/IRegistry.sol";
 import {IInstance} from "../IInstance.sol";
+import {StateId} from "../../types/StateId.sol";
 import {NftId} from "../../types/NftId.sol";
+import {Fee} from "../../types/Fee.sol";
+import {UFixed} from "../../types/UFixed.sol";
 
 interface IComponent {
-    // TODO decide if enum or uints with constants (as in IRegistry.PRODUCT())
-    enum CState {
-        Undefined,
-        Active,
-        Locked
-    }
-
     // component dynamic info (static info kept in registry)
     struct ComponentInfo {
         NftId nftId;
-        CState state;
+        StateId state;
+        IERC20Metadata token;
     }
 }
 
@@ -25,7 +24,11 @@ interface IInstanceLinked {
     function getInstance() external view returns (IInstance instance);
 }
 
-interface IComponentContract is IRegisterable, IInstanceLinked, IComponent {}
+interface IComponentContract is IRegisterable, IInstanceLinked, IComponent {
+    function getToken() external view returns (IERC20Metadata token);
+
+    function getWallet() external view returns (address walletAddress);
+}
 
 interface IComponentOwnerService is IRegistryLinked {
     function register(
@@ -35,6 +38,12 @@ interface IComponentOwnerService is IRegistryLinked {
     function lock(IComponentContract component) external;
 
     function unlock(IComponentContract component) external;
+
+    function setProductFees(
+        IComponentContract product,
+        Fee memory policyFee,
+        Fee memory processingFee
+    ) external;
 }
 
 interface IComponentModule is IOwnable, IRegistryLinked, IComponent {
@@ -50,20 +59,12 @@ interface IComponentModule is IOwnable, IRegistryLinked, IComponent {
         NftId nftId
     ) external view returns (ComponentInfo memory info);
 
-    function getComponentOwner(
-        NftId nftId
-    ) external view returns (address owner);
-
     function getComponentId(
         address componentAddress
     ) external view returns (NftId nftId);
 
     function getComponentId(uint256 idx) external view returns (NftId nftId);
 
-    function getPoolNftId(
-        NftId productNftId
-    ) external view returns (NftId poolNftId);
-
     function components() external view returns (uint256 numberOfCompnents);
 
     function getComponentOwnerService()

package/contracts/instance/lifecycle/ILifecycle.sol

@@ -0,0 +1,47 @@
+// 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";
+import {NftId} from "../../types/NftId.sol";
+
+interface ILifecycle {
+    event LogComponentStateChanged(
+        NftId nftId,
+        ObjectType objectType,
+        StateId fromStateId,
+        StateId toStateId
+    );
+    event LogBundleStateChanged(
+        NftId nftId,
+        StateId fromStateId,
+        StateId toStateId
+    );
+    event LogPolicyStateChanged(
+        NftId nftId,
+        StateId fromStateId,
+        StateId toStateId
+    );
+    // event LogClaimStateChanged(NftId nftId, ClaimId claimId, StateId fromStateId, StateId toStateId);
+    // event LogPayoutStateChanged(NftId nftId, ClaimId claimId, PayoutId payoutId, StateId fromStateId, StateId toStateId);
+
+    error ErrorNoLifecycle(NftId nftId, ObjectType objectType);
+    error ErrorInvalidStateTransition(
+        NftId nftId,
+        ObjectType objectType,
+        StateId fromStateId,
+        StateId toStateId
+    );
+}
+
+interface ILifecycleModule is ILifecycle {
+    function getInitialState(
+        ObjectType objectType
+    ) external view returns (StateId);
+
+    function isValidTransition(
+        ObjectType objectType,
+        StateId fromId,
+        StateId toId
+    ) external view returns (bool);
+}

package/contracts/instance/lifecycle/LifecycleModule.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {NftId} from "../../types/NftId.sol";
+import {ObjectType, PRODUCT, ORACLE, POOL, BUNDLE, POLICY} from "../../types/ObjectType.sol";
+import {StateId, ACTIVE, PAUSED, ARCHIVED, CLOSED, APPLIED, REVOKED, DECLINED} from "../../types/StateId.sol";
+import {ILifecycleModule} from "./ILifecycle.sol";
+
+contract LifecycleModule is ILifecycleModule {
+    mapping(ObjectType objectType => StateId initialState)
+        private _initialState;
+
+    mapping(ObjectType objectType => mapping(StateId stateFrom => mapping(StateId stateTo => bool isValid)))
+        private _isValidTransition;
+
+    constructor() {
+        _setupComponentLifecycle(PRODUCT());
+        _setupComponentLifecycle(ORACLE());
+        _setupComponentLifecycle(POOL());
+
+        _setupBundleLifecycle();
+        _setupPolicyLifecycle();
+    }
+
+    function checkAndLogTransition(
+        NftId nftId,
+        ObjectType objectType,
+        StateId fromId,
+        StateId toId
+    ) public returns (StateId) // add only currentcontract? would that work?
+    {
+        if (!_isValidTransition[objectType][fromId][toId]) {
+            revert ErrorInvalidStateTransition(nftId, objectType, fromId, toId);
+        }
+
+        if (objectType == POLICY()) {
+            emit LogPolicyStateChanged(nftId, fromId, toId);
+        } else if (objectType == BUNDLE()) {
+            emit LogBundleStateChanged(nftId, fromId, toId);
+        } else if (
+            objectType == PRODUCT() ||
+            objectType == ORACLE() ||
+            objectType == POOL()
+        ) {
+            emit LogComponentStateChanged(nftId, objectType, fromId, toId);
+        } else {
+            revert ErrorNoLifecycle(nftId, objectType);
+        }
+
+        return toId;
+    }
+
+    function getInitialState(
+        ObjectType objectType
+    ) public view returns (StateId) {
+        return _initialState[objectType];
+    }
+
+    function isValidTransition(
+        ObjectType objectType,
+        StateId fromId,
+        StateId toId
+    ) public view returns (bool) {
+        return _isValidTransition[objectType][fromId][toId];
+    }
+
+    function _setupComponentLifecycle(ObjectType objectType) internal {
+        _initialState[objectType] = ACTIVE();
+        _isValidTransition[objectType][ACTIVE()][PAUSED()] = true;
+        _isValidTransition[objectType][PAUSED()][ACTIVE()] = true;
+        _isValidTransition[objectType][PAUSED()][ARCHIVED()] = true;
+    }
+
+    function _setupBundleLifecycle() internal {
+        _initialState[BUNDLE()] = ACTIVE();
+        _isValidTransition[BUNDLE()][ACTIVE()][PAUSED()] = 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()][ACTIVE()] = true;
+        _isValidTransition[POLICY()][ACTIVE()][CLOSED()] = true;
+    }
+}

package/contracts/instance/policy/IPolicy.sol

@@ -5,24 +5,20 @@ import {IOwnable, IRegistryLinked, IRegisterable, IRegistry} from "../../registr
 import {IInstance} from "../IInstance.sol";
 import {IProductService} from "../product/IProductService.sol";
 import {NftId} from "../../types/NftId.sol";
+import {StateId} from "../../types/StateId.sol";
 
 // TODO check if there is value to introuce IContract and let IPolicy derive from IContract
 interface IPolicy {
-    enum PolicyState {
-        Undefined,
-        Applied,
-        Rejected,
-        Active,
-        Closed
-    }
-
     struct PolicyInfo {
         NftId nftId;
-        PolicyState state; // applied, withdrawn, rejected, active, closed
+        StateId state; // applied, withdrawn, rejected, active, closed
+        // TODO add beneficiary address
         uint256 sumInsuredAmount;
         uint256 premiumAmount;
+        uint256 premiumPaidAmount;
         uint256 lifetime; // activatedAt + lifetime >= expiredAt
         uint256 createdAt;
+        uint256 updatedAt;
         uint256 activatedAt; // time of underwriting
         uint256 expiredAt; // no new claims
         uint256 closedAt; // no locked capital
@@ -39,6 +35,9 @@ interface IPolicyModule is IOwnable, IRegistryLinked, IPolicy {
         NftId bundleNftId
     ) external returns (NftId nftId);
 
+    // process full premium
+    function processPremium(NftId nftId) external;
+
     function activate(NftId nftId) external;
 
     function getBundleNftForPolicy(

package/contracts/instance/policy/PolicyModule.sol

@@ -4,16 +4,22 @@ pragma solidity ^0.8.19;
 // import {IOwnable, IRegistryLinked, IRegisterable} from "../../registry/IRegistry.sol";
 import {IRegistry, IRegistryLinked} from "../../registry/IRegistry.sol";
 
+import {LifecycleModule} from "../lifecycle/LifecycleModule.sol";
 import {IProductService} from "../product/IProductService.sol";
 import {IPolicy, IPolicyModule} from "./IPolicy.sol";
+import {ObjectType, POLICY} from "../../types/ObjectType.sol";
+import {ACTIVE} from "../../types/StateId.sol";
 import {NftId, NftIdLib} from "../../types/NftId.sol";
 
+import {LifecycleModule} from "../lifecycle/LifecycleModule.sol";
+
 abstract contract PolicyModule is IRegistryLinked, IPolicyModule {
     using NftIdLib for NftId;
 
     mapping(NftId nftId => PolicyInfo info) private _policyInfo;
     mapping(NftId nftId => NftId bundleNftId) private _bundleForPolicy;
 
+    LifecycleModule private _lifecycleModule;
     IProductService private _productService;
 
     // TODO find a better place to avoid dupliation
@@ -26,6 +32,7 @@ abstract contract PolicyModule is IRegistryLinked, IPolicyModule {
     }
 
     constructor(address productService) {
+        _lifecycleModule = LifecycleModule(address(this));
         _productService = IProductService(productService);
     }
 
@@ -39,25 +46,29 @@ abstract contract PolicyModule is IRegistryLinked, IPolicyModule {
     ) external override onlyProductService2 returns (NftId nftId) {
         // TODO add parameter validation
         if (bundleNftId.gtz()) {
-            IRegistry.RegistryInfo memory bundleInfo = this
-                .getRegistry()
-                .getInfo(bundleNftId);
+            // IRegistry.RegistryInfo memory bundleInfo = this
+            //     .getRegistry()
+            //     .getInfo(bundleNftId);
             // IRegistry.RegistryInfo memory poolInfo = this.getRegistry().getInfo(bundleInfo.parentNftId);
         }
 
         nftId = this.getRegistry().registerObjectForInstance(
             productInfo.nftId,
-            this.getRegistry().POLICY(),
+            POLICY(),
             applicationOwner
         );
 
         _policyInfo[nftId] = PolicyInfo(
             nftId,
-            PolicyState.Applied,
+            _lifecycleModule.getInitialState(POLICY()),
             sumInsuredAmount,
             premiumAmount,
+            0, // premium paid amount
             lifetime,
-            block.timestamp,
+            // solhint-disable-next-line not-rely-on-time
+            block.timestamp, // createdAt
+            // solhint-disable-next-line not-rely-on-time
+            block.timestamp, // updatedAt
             0, // activatedAt
             0, // expiredAt
             0 // closedAt
@@ -68,13 +79,25 @@ abstract contract PolicyModule is IRegistryLinked, IPolicyModule {
         // add logging
     }
 
+    function processPremium(NftId nftId) external override onlyProductService2 {
+        PolicyInfo storage info = _policyInfo[nftId];
+        info.premiumPaidAmount = info.premiumAmount;
+        // solhint-disable-next-line not-rely-on-time
+        info.updatedAt = block.timestamp;
+    }
+
     function activate(NftId nftId) external override onlyProductService2 {
         PolicyInfo storage info = _policyInfo[nftId];
+        // solhint-disable-next-line not-rely-on-time
         info.activatedAt = block.timestamp;
+        // solhint-disable-next-line not-rely-on-time
         info.expiredAt = block.timestamp + info.lifetime;
-        info.state = PolicyState.Active;
-
-        // add logging
+        info.state = _lifecycleModule.checkAndLogTransition(
+            nftId,
+            POLICY(),
+            info.state,
+            ACTIVE()
+        );
     }
 
     function getBundleNftForPolicy(

package/contracts/instance/pool/IPoolModule.sol

@@ -7,21 +7,15 @@ import {NftId} from "../../types/NftId.sol";
 interface IPool {
     struct PoolInfo {
         NftId nftId;
-        address wallet;
-        address token;
         uint256 capital;
         uint256 lockedCapital;
     }
 }
 
 interface IPoolModule is IOwnable, IRegistryLinked, IPool {
-    function underwrite(NftId poolNftId, NftId policyNftId) external;
+    function underwrite(NftId policyNftId, NftId productNftId) external;
 
-    function createPoolInfo(
-        NftId nftId,
-        address wallet,
-        address token
-    ) external;
+    function registerPool(NftId nftId) external;
 
     function getPoolInfo(
         NftId nftId