lens-modules 1.0.6 → 1.0.7

package/README.md

@@ -12,6 +12,8 @@ npm i lens-modules
 
 ## Usage
 
+Boilerplate for an Open Action module:
+
 ```solidity
 pragma solidity ^0.8.21;
 
@@ -36,6 +38,14 @@ contract OpenActionModule is
         // ...
     }
 
+    function supportsInterface(
+        bytes4 interfaceID
+    ) public pure virtual override returns (bool) {
+        return
+            interfaceID == type(IPublicationActionModule).interfaceId ||
+            super.supportsInterface(interfaceID);
+    }
+    
     function initializePublicationAction(
         uint256 profileId,
         uint256 pubId,
@@ -51,4 +61,88 @@ contract OpenActionModule is
         // ...
     }
 }
+```
+
+The library also has the contracts needed to create a Follow or Collect Module. Here's a basic example of a `CollectModule` that can be registered with the platform `CollectPublicationAction` contract.
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+
+import {Types} from "lens-modules/contracts/libraries/constants/Types.sol";
+import {IPublicationActionModule} from "lens-modules/contracts/interfaces/IPublicationActionModule.sol";
+import {HubRestricted} from "lens-modules/contracts/base/HubRestricted.sol";
+import {IModuleRegistry} from "lens-modules/contracts/interfaces/IModuleRegistry.sol";
+import {LensModuleMetadata} from "lens-modules/contracts/modules/LensModuleMetadata.sol";
+import {LensModuleRegistrant} from "lens-modules/contracts/modules/base/LensModuleRegistrant.sol";
+import {ICollectModule} from "lens-modules/contracts/modules/interfaces/ICollectModule.sol";
+import {BaseFeeCollectModule} from "lens-modules/contracts/modules/act/collect/base/BaseFeeCollectModule.sol";
+import {IBaseFeeCollectModule, BaseFeeCollectModuleInitData} from "lens-modules/contracts/modules/interfaces/IBaseFeeCollectModule.sol";
+import {ModuleTypes} from "lens-modules/contracts/modules/libraries/constants/ModuleTypes.sol";
+import {LensModule} from "lens-modules/contracts/modules/LensModule.sol";
+
+contract YourCollectModule is BaseFeeCollectModule, LensModuleMetadata {
+    using SafeERC20 for IERC20;
+
+    constructor(
+        address hub,
+        address actionModule,
+        address moduleRegistry,
+        address moduleOwner
+    )
+        BaseFeeCollectModule(hub, actionModule, moduleRegistry)
+        LensModuleMetadata()
+    {}
+
+    function supportsInterface(
+        bytes4 interfaceID
+    ) public pure override(BaseFeeCollectModule, LensModule) returns (bool) {
+        return
+            BaseFeeCollectModule.supportsInterface(interfaceID) ||
+            LensModule.supportsInterface(interfaceID);
+    }
+
+    function initializePublicationCollectModule(
+        uint256 profileId,
+        uint256 pubId,
+        address /* transactionExecutor */,
+        bytes calldata data
+    ) external override onlyActionModule returns (bytes memory) {
+        BaseFeeCollectModuleInitData memory baseInitData = abi.decode(
+            data,
+            (BaseFeeCollectModuleInitData)
+        );
+        _validateBaseInitData(baseInitData);
+        _storeBasePublicationCollectParameters(profileId, pubId, baseInitData);
+        return data;
+    }
+
+    function calculateFee(
+        ModuleTypes.ProcessCollectParams calldata processCollectParams
+    ) public view virtual override returns (uint160) {
+        // Override calculateFee to add custom logic to calculate the fee
+        return
+            _dataByPublicationByProfile[processCollectParams.profileId][
+                processCollectParams.pubId
+            ].amount;
+    }
+
+    function processCollect(
+        ModuleTypes.ProcessCollectParams calldata processCollectParams
+    ) external override returns (bytes memory) {
+        _validateAndStoreCollect(processCollectParams);
+        // Override processCollect to add custom logic to process the collect
+        if (processCollectParams.referrerProfileIds.length == 0) {
+            _processCollect(processCollectParams);
+        } else {
+            _processCollectWithReferral(processCollectParams);
+        }
+        return processCollectParams.data;
+    }
+}
 ```

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lens-contracts"), exports);

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "lens-modules",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "All interfaces and base classes from Lens core used for creating follow, collect, and open action modules",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "files": [
     "/contracts/**/*.sol"
   ],
   "scripts": {
     "compile": "hardhat compile",
-    "clean": "hardhat clean"
+    "clean": "hardhat clean",
+    "build": "tsc",
+    "prepublish": "tsc"
   },
   "repository": {
     "type": "git",
@@ -27,6 +31,7 @@
   "license": "MIT",
   "devDependencies": {
     "@openzeppelin/contracts": "4.8.0",
-    "hardhat": "^2.19.4"
+    "hardhat": "^2.19.4",
+    "typescript": "^5.4.2"
   }
 }