Namespace Rules

First, inspect the namespace.rules field to know the current rules configuration.

type NamespaceRules = {  required: NamespaceRule;  anyOf: NamespaceRule;};

Keep note of the Rule IDs you might want to remove.

Next, update the rules configuration of the Namespace as follows.

import { bigDecimal, evmAddress } from "@lens-protocol/client";import { updateNamespaceRules } from "@lens-protocol/client/actions";
const result = await updateNamespaceRules(sessionClient, {  namespace: namespace.address,  toAdd: {    required: [      {        tokenGatedRule: {          token: {            standard: TokenStandard.Erc20,            currency: evmAddress("0x5678…"),            value: bigDecimal("1.5"), // Token value in its main unit          },        },      },    ],  },});

First, implement the configure function. This function has the purpose of initializing any required state for the rule to work properly.

It receives two parameters, a 32-byte configuration salt (configSalt), and an array of custom parameters as key-value pairs (ruleParams).

The configSalt is there to allow the same rule contract to be used many times, with different configurations, for the same Namespace. So, for a given Namespace Rule implementation, the pair (Namespace Address, Configuration Salt) should identify a rule configuration.

The ruleParams is an array of key-value pairs that can be used to pass any custom configuration parameters to the rule. Each key is bytes32, we put the hash of the parameter name there, and each value is bytes, we set the ABI-encoded parameter value there. Given that ruleParams is an array, this allows the rule to define which parameters are optional and which are required, acting accordingly when any of them are not present.

In our example, we only need to decode a boolean parameter, which will indicate if the rule will enforce Usernames to have an even or an odd length. Let's define a storage mapping to store this configuration:

contract UsernameParityLengthNamespaceRule is INamespaceRule {    mapping(address namespace => mapping(bytes32 configSalt => bool mustBeEven)) internal _mustBeEvenLength;}

Now let's code the configure function itself, decoding the boolean parameter and storing it in the mapping:

contract UsernameParityLengthNamespaceRule is INamespaceRule {    mapping(address namespace => mapping(bytes32 configSalt => bool mustBeEven)) internal _mustBeEvenLength;
    function configure(bytes32 configSalt, KeyValue[] calldata ruleParams) external override {        bool mustBeEven = true; // We set `true` as default value        for (uint256 i = 0; i < ruleParams.length; i++) {            if (ruleParams[i].key == keccak256("lens.param.mustBeEven")) {                mustBeEven = abi.decode(ruleParams[i].value, (bool));                break;            }        }        _mustBeEvenLength[msg.sender][configSalt] = mustBeEven;    }}

We treated the mustBeEven parameter as optional, defaulting to true (even length) when not present.

Next, implement the processCreation function. This function is invoked by the Namespace contract every time a username is being created, so then our custom logic can be applied to shape under which conditions this operation can succeed.

The function receives the configuration salt (configSalt), the address that is trying to create the Username (originalMsgSender), the account who will own the created Username, the username being created, an array of key-value pairs with the custom parameters passed to the Namespace (primitiveParams), and an array of key-value pairs in case the rule requires additional parameters to work (ruleParams).

The function must revert if the requirements imposed by the rule are not met.

contract UsernameParityLengthNamespaceRule is INamespaceRule {    mapping(address namespace => mapping(bytes32 configSalt => bool mustBeEven)) internal _mustBeEvenLength;
    // ...
    function processCreation(        bytes32 configSalt,        address originalMsgSender,        address account,        string calldata username,        KeyValue[] calldata primitiveParams,        KeyValue[] calldata ruleParams    ) external view override {        // Retrieve the rule configuration        bool mustBeEven = _mustBeEvenLength[msg.sender][configSalt];
        // Get the length of the username being created        uint256 usernameLength = bytes(username).length;
        // Check if the length is even (otherwise it is odd)        bool isEvenLength = usernameLength % 2 == 0;
        // Require the parity of the username being created to match        // the parity required by the rule        require(isEvenLength == mustBeEven);    }
    // ...}

Next, implement the processRemoval function. This function is invoked by the Namespace contract every time a username is being removed.

The function receives the configuration salt (configSalt), the address that is trying to remove the Username (originalMsgSender), the username being removed, an array of key-value pairs with the custom parameters passed to the Namespace (primitiveParams), and an array of key-value pairs in case the rule requires additional parameters to work (ruleParams).

The function must revert if the requirements imposed by the rule are not met. In our example, the parity rule does not apply to removal, so we revert with NotImplemented. This is good practice in case the rule is accidentally enabled for this selector.

contract UsernameParityLengthNamespaceRule is INamespaceRule {
    // ...
    function processRemoval(        bytes32 configSalt,        address originalMsgSender,        string calldata username,        KeyValue[] calldata primitiveParams,        KeyValue[] calldata ruleParams    ) external pure override {        revert Errors.NotImplemented();    }
    // ...}

Next, implement the processAssigning function. This function is invoked by the Namespace contract every time a username is being assigned to an account.

The function receives the configuration salt (configSalt), the address that is trying to assign the Username (originalMsgSender), the account who the username will be assigned to, the username being assigned, an array of key-value pairs with the custom parameters passed to the Namespace (primitiveParams), and an array of key-value pairs in case the rule requires additional parameters to work (ruleParams).

The function must revert if the requirements imposed by the rule are not met. Similar to removal, our parity rule does not apply to the assignment operation, so we revert with NotImplemented.

contract UsernameParityLengthNamespaceRule is INamespaceRule {
    // ...
    function processAssigning(        bytes32 configSalt,        address originalMsgSender,        address account,        string calldata username,        KeyValue[] calldata primitiveParams,        KeyValue[] calldata ruleParams    ) external pure override {        revert Errors.NotImplemented();    }
    // ...}

Finally, implement the processUnassigning function. This function is invoked by the Namespace contract every time a username is being unassigned from an account.

The function receives the configuration salt (configSalt), the address that is trying to unassign the Username (originalMsgSender), the account who the username will be unassigned from, the username being unassigned, an array of key-value pairs with the custom parameters passed to the Namespace (primitiveParams), and an array of key-value pairs in case the rule requires additional parameters to work (ruleParams).

The function must revert if the requirements imposed by the rule are not met. Again, our parity rule does not apply to the unassigning process, so we revert with NotImplemented.

contract UsernameParityLengthNamespaceRule is INamespaceRule {
    // ...
    function processUnassigning(        bytes32 configSalt,        address originalMsgSender,        address account,        string calldata username,        KeyValue[] calldata primitiveParams,        KeyValue[] calldata ruleParams    ) external pure override {        revert Errors.NotImplemented();    }}