@bananapus/core-v6 0.0.15 → 0.0.16

package/src/JBController.sol

@@ -336,7 +336,7 @@ contract JBController is JBPermissioned, ERC2771Context, IJBController, IJBMigra
         require(msg.sender == address(this));
 
         // Approve the tokens being paid.
-        IERC20(address(token)).forceApprove(address(terminal), splitTokenCount);
+        IERC20(address(token)).forceApprove({spender: address(terminal), value: splitTokenCount});
 
         // slither-disable-next-line unused-return
         terminal.pay({
@@ -350,7 +350,7 @@ contract JBController is JBPermissioned, ERC2771Context, IJBController, IJBMigra
         });
 
         // Make sure that the terminal received the tokens.
-        if (IERC20(address(token)).allowance(address(this), address(terminal)) != 0) {
+        if (IERC20(address(token)).allowance({owner: address(this), spender: address(terminal)}) != 0) {
             revert JBController_TerminalTokensNotTransferred();
         }
     }
@@ -646,6 +646,21 @@ contract JBController is JBPermissioned, ERC2771Context, IJBController, IJBMigra
         TOKENS.setTokenFor({projectId: projectId, token: token});
     }
 
+    /// @notice Sets the name and symbol of a project's token.
+    /// @dev Can only be called by the project's owner or an address with the owner's permission to
+    /// `SET_TOKEN_METADATA`.
+    /// @param projectId The ID of the project whose token is being updated.
+    /// @param name The new name.
+    /// @param symbol The new symbol.
+    function setTokenMetadataOf(uint256 projectId, string calldata name, string calldata symbol) external override {
+        // Enforce permissions.
+        _requirePermissionFrom({
+            account: PROJECTS.ownerOf(projectId), projectId: projectId, permissionId: JBPermissionIds.SET_TOKEN_METADATA
+        });
+
+        TOKENS.setTokenMetadataFor({projectId: projectId, name: name, symbol: symbol});
+    }
+
     /// @notice Set a project's metadata URI.
     /// @dev This is typically an IPFS hash, optionally with an `ipfs://` prefix.
     /// @dev Can only be called by the project's owner or an address with the owner's permission to
@@ -1026,7 +1041,7 @@ contract JBController is JBPermissioned, ERC2771Context, IJBController, IJBMigra
                                 });
 
                                 // If it fails, transfer the tokens from this contract to the beneficiary.
-                                IERC20(address(token)).safeTransfer(beneficiary, splitTokenCount);
+                                IERC20(address(token)).safeTransfer({to: beneficiary, value: splitTokenCount});
                             }
                         }
                     } else if (beneficiary == address(0xdead)) {

package/src/JBERC20.sol

@@ -47,7 +47,7 @@ contract JBERC20 is ERC20Votes, ERC20Permit, Ownable, IJBToken {
     /// @param account The address to burn tokens from.
     /// @param amount The amount of tokens to burn, as a fixed point number with 18 decimals.
     function burn(address account, uint256 amount) external override onlyOwner {
-        return _burn(account, amount);
+        return _burn({account: account, value: amount});
     }
 
     /// @notice Mints more of this token.
@@ -55,7 +55,16 @@ contract JBERC20 is ERC20Votes, ERC20Permit, Ownable, IJBToken {
     /// @param account The address to mint the new tokens to.
     /// @param amount The amount of tokens to mint, as a fixed point number with 18 decimals.
     function mint(address account, uint256 amount) external override onlyOwner {
-        return _mint(account, amount);
+        return _mint({account: account, value: amount});
+    }
+
+    /// @notice Sets the token's name and symbol.
+    /// @dev Can only be called by this contract's owner.
+    /// @param name_ The new name.
+    /// @param symbol_ The new symbol.
+    function setMetadata(string memory name_, string memory symbol_) external override onlyOwner {
+        _name = name_;
+        _symbol = symbol_;
     }
 
     //*********************************************************************//
@@ -130,6 +139,6 @@ contract JBERC20 is ERC20Votes, ERC20Permit, Ownable, IJBToken {
 
     /// @notice Required override.
     function _update(address from, address to, uint256 value) internal virtual override(ERC20, ERC20Votes) {
-        super._update(from, to, value);
+        super._update({from: from, to: to, value: value});
     }
 }

package/src/JBFundAccessLimits.sol

@@ -177,6 +177,7 @@ contract JBFundAccessLimits is JBControlled, IJBFundAccessLimits {
 
             // If the currencies match, return the value.
             if (currency == packedPayoutLimitData >> 224) {
+                // forge-lint: disable-next-line(unsafe-typecast)
                 return uint256(uint224(packedPayoutLimitData));
             }
         }
@@ -217,8 +218,12 @@ contract JBFundAccessLimits is JBControlled, IJBFundAccessLimits {
             uint256 packedPayoutLimitData = packedPayoutLimitsData[i];
 
             // The limit amount is in bits 0-223. The currency is in bits 224-255.
+            // forge-lint: disable-next-line(unsafe-typecast)
             payoutLimits[i] = JBCurrencyAmount({
-                currency: uint32(packedPayoutLimitData >> 224), amount: uint224(packedPayoutLimitData)
+                // forge-lint: disable-next-line(unsafe-typecast)
+                currency: uint32(packedPayoutLimitData >> 224),
+                // forge-lint: disable-next-line(unsafe-typecast)
+                amount: uint224(packedPayoutLimitData)
             });
         }
     }
@@ -258,6 +263,7 @@ contract JBFundAccessLimits is JBControlled, IJBFundAccessLimits {
 
             // If the currencies match, return the value.
             if (currency == packedSurplusAllowanceData >> 224) {
+                // forge-lint: disable-next-line(unsafe-typecast)
                 return uint256(uint224(packedSurplusAllowanceData));
             }
         }
@@ -300,8 +306,12 @@ contract JBFundAccessLimits is JBControlled, IJBFundAccessLimits {
             uint256 packedSurplusAllowanceData = packedSurplusAllowancesData[i];
 
             // The limit is in bits 0-223. The currency is in bits 224-255.
+            // forge-lint: disable-next-line(unsafe-typecast)
             surplusAllowances[i] = JBCurrencyAmount({
-                currency: uint32(packedSurplusAllowanceData >> 224), amount: uint224(packedSurplusAllowanceData)
+                // forge-lint: disable-next-line(unsafe-typecast)
+                currency: uint32(packedSurplusAllowanceData >> 224),
+                // forge-lint: disable-next-line(unsafe-typecast)
+                amount: uint224(packedSurplusAllowanceData)
             });
         }
     }

package/src/JBMultiTerminal.sol

@@ -1834,6 +1834,7 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
                 JBFee({
                     amount: amount,
                     beneficiary: beneficiary,
+                    // forge-lint: disable-next-line(unsafe-typecast)
                     unlockTimestamp: uint48(block.timestamp + _FEE_HOLDING_SECONDS)
                 })
             );
@@ -1877,7 +1878,7 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
         }
 
         // If there's sufficient approval, transfer normally.
-        if (IERC20(token).allowance(address(from), address(this)) >= amount) {
+        if (IERC20(token).allowance({owner: address(from), spender: address(this)}) >= amount) {
             return IERC20(token).safeTransferFrom({from: from, to: to, value: amount});
         }
 
@@ -1885,6 +1886,7 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
         if (amount > type(uint160).max) revert JBMultiTerminal_OverflowAlert(amount, type(uint160).max);
 
         // Otherwise we attempt to use the PERMIT2 method.
+        // forge-lint: disable-next-line(unsafe-typecast)
         PERMIT2.transferFrom({from: from, to: to, amount: uint160(amount), token: token});
     }
 

package/src/JBPermissions.sol

@@ -250,6 +250,7 @@ contract JBPermissions is ERC2771Context, IJBPermissions {
             uint256 permissionId = permissionIds[i];
 
             // Turn on the bit at the ID.
+            // forge-lint: disable-next-line(incorrect-shift)
             packed |= 1 << permissionId;
         }
     }

package/src/JBProjects.sol

@@ -74,7 +74,7 @@ contract JBProjects is ERC721, ERC2771Context, Ownable, IJBProjects {
         emit Create({projectId: projectId, owner: owner, caller: _msgSender()});
 
         // Mint the project.
-        _safeMint(owner, projectId);
+        _safeMint({to: owner, tokenId: projectId});
     }
 
     //*********************************************************************//

package/src/JBRulesets.sol

@@ -247,6 +247,7 @@ contract JBRulesets is JBControlled, IJBRulesets {
         // Calculate the weight cut multiple.
         uint168 weightCutMultiple;
         unchecked {
+            // forge-lint: disable-next-line(unsafe-typecast)
             weightCutMultiple = uint168(startDistance / targetRuleset.duration);
         }
 
@@ -955,26 +956,34 @@ contract JBRulesets is JBControlled, IJBRulesets {
         // slither-disable-next-line incorrect-equality
         if (rulesetId == 0) return ruleset;
 
+        // forge-lint: disable-next-line(unsafe-typecast)
         ruleset.id = uint48(rulesetId);
 
         uint256 packedIntrinsicProperties = _packedIntrinsicPropertiesOf[projectId][rulesetId];
 
         // `weight` in bits 0-111 bits.
+        // forge-lint: disable-next-line(unsafe-typecast)
         ruleset.weight = uint112(packedIntrinsicProperties);
         // `basedOnId` in bits 112-159 bits.
+        // forge-lint: disable-next-line(unsafe-typecast)
         ruleset.basedOnId = uint48(packedIntrinsicProperties >> 112);
         // `start` in bits 160-207 bits.
+        // forge-lint: disable-next-line(unsafe-typecast)
         ruleset.start = uint48(packedIntrinsicProperties >> 160);
         // `cycleNumber` in bits 208-255 bits.
+        // forge-lint: disable-next-line(unsafe-typecast)
         ruleset.cycleNumber = uint48(packedIntrinsicProperties >> 208);
 
         uint256 packedUserProperties = _packedUserPropertiesOf[projectId][rulesetId];
 
         // approval hook in bits 0-159 bits.
+        // forge-lint: disable-next-line(unsafe-typecast)
         ruleset.approvalHook = IJBRulesetApprovalHook(address(uint160(packedUserProperties)));
         // `duration` in bits 160-191 bits.
+        // forge-lint: disable-next-line(unsafe-typecast)
         ruleset.duration = uint32(packedUserProperties >> 160);
         // weight cut percent in bits 192-223 bits.
+        // forge-lint: disable-next-line(unsafe-typecast)
         ruleset.weightCutPercent = uint32(packedUserProperties >> 192);
 
         ruleset.metadata = _metadataOf[projectId][rulesetId];
@@ -1021,9 +1030,11 @@ contract JBRulesets is JBControlled, IJBRulesets {
         });
 
         return JBRuleset({
+            // forge-lint: disable-next-line(unsafe-typecast)
             cycleNumber: uint48(rulesetCycleNumber),
             id: baseRuleset.id,
             basedOnId: baseRuleset.basedOnId,
+            // forge-lint: disable-next-line(unsafe-typecast)
             start: uint48(start),
             duration: baseRuleset.duration,
             weight: uint112(

package/src/JBSplits.sol

@@ -271,10 +271,13 @@ contract JBSplits is JBControlled, IJBSplits {
             JBSplit memory split;
 
             // `percent` in bits 0-31.
+            // forge-lint: disable-next-line(unsafe-typecast)
             split.percent = uint32(packedSplitPart1);
             // `projectId` in bits 32-95.
+            // forge-lint: disable-next-line(unsafe-typecast)
             split.projectId = uint64(packedSplitPart1 >> 32);
             // `beneficiary` in bits 96-255.
+            // forge-lint: disable-next-line(unsafe-typecast)
             split.beneficiary = payable(address(uint160(packedSplitPart1 >> 96)));
 
             // Get a reference to the second part of the split's packed data.
@@ -285,8 +288,10 @@ contract JBSplits is JBControlled, IJBSplits {
                 // `preferAddToBalance` in bit 0.
                 split.preferAddToBalance = packedSplitPart2 & 1 == 1;
                 // `lockedUntil` in bits 1-48.
+                // forge-lint: disable-next-line(unsafe-typecast)
                 split.lockedUntil = uint48(packedSplitPart2 >> 1);
                 // `hook` in bits 49-208.
+                // forge-lint: disable-next-line(unsafe-typecast)
                 split.hook = IJBSplitHook(address(uint160(packedSplitPart2 >> 49)));
             }
 

package/src/JBTerminalStore.sol

@@ -868,6 +868,7 @@ contract JBTerminalStore is IJBTerminalStore {
                         terminal
                     ][projectId][accountingContext.token][ruleset.cycleNumber][payoutLimit.currency];
                 if (remaining > type(uint224).max) revert JBTerminalStore_Uint224Overflow(remaining);
+                // forge-lint: disable-next-line(unsafe-typecast)
                 payoutLimit.amount = uint224(remaining);
             }
 
@@ -877,6 +878,7 @@ contract JBTerminalStore is IJBTerminalStore {
                     value: payoutLimit.amount, decimals: accountingContext.decimals, targetDecimals: targetDecimals
                 });
                 if (adjusted > type(uint224).max) revert JBTerminalStore_Uint224Overflow(adjusted);
+                // forge-lint: disable-next-line(unsafe-typecast)
                 payoutLimit.amount = uint224(adjusted);
             }
 
@@ -894,6 +896,7 @@ contract JBTerminalStore is IJBTerminalStore {
                     })
                 );
                 if (converted > type(uint224).max) revert JBTerminalStore_Uint224Overflow(converted);
+                // forge-lint: disable-next-line(unsafe-typecast)
                 payoutLimit.amount = uint224(converted);
             }
 

package/src/JBTokens.sol

@@ -128,7 +128,7 @@ contract JBTokens is JBControlled, IJBTokens {
         });
 
         // Burn the tokens.
-        if (tokensToBurn > 0) token.burn(holder, tokensToBurn);
+        if (tokensToBurn > 0) token.burn({account: holder, amount: tokensToBurn});
     }
 
     /// @notice Redeem credits to claim tokens into a holder's wallet.
@@ -177,7 +177,7 @@ contract JBTokens is JBControlled, IJBTokens {
         });
 
         // Mint the equivalent amount of the project's token for the holder.
-        token.mint(beneficiary, count);
+        token.mint({account: beneficiary, amount: count});
     }
 
     /// @notice Deploys an ERC-20 token for a project. It will be used when claiming tokens.
@@ -211,7 +211,11 @@ contract JBTokens is JBControlled, IJBTokens {
 
         token = salt == bytes32(0)
             ? IJBToken(Clones.clone(address(TOKEN)))
-            : IJBToken(Clones.cloneDeterministic(address(TOKEN), keccak256(abi.encode(msg.sender, salt))));
+            : IJBToken(
+                Clones.cloneDeterministic({
+                    implementation: address(TOKEN), salt: keccak256(abi.encode(msg.sender, salt))
+                })
+            );
 
         // Store the token contract.
         tokenOf[projectId] = token;
@@ -257,7 +261,7 @@ contract JBTokens is JBControlled, IJBTokens {
         if (tokensWereClaimed) {
             // If tokens should be claimed, mint tokens into the holder's wallet.
             // slither-disable-next-line reentrancy-events
-            token.mint(holder, count);
+            token.mint({account: holder, amount: count});
         } else {
             // Otherwise, add the tokens to their credits and the credit supply.
             creditBalanceOf[holder][projectId] += count;
@@ -298,6 +302,38 @@ contract JBTokens is JBControlled, IJBTokens {
         emit SetToken({projectId: projectId, token: token, caller: msg.sender});
     }
 
+    /// @notice Sets the name and symbol of a project's token.
+    /// @dev Only a project's controller can set the token's name and symbol.
+    /// @param projectId The ID of the project whose token is being updated.
+    /// @param name The new name.
+    /// @param symbol The new symbol.
+    function setTokenMetadataFor(
+        uint256 projectId,
+        string calldata name,
+        string calldata symbol
+    )
+        external
+        override
+        onlyControllerOf(projectId)
+    {
+        // Get a reference to the project's current token.
+        IJBToken token = tokenOf[projectId];
+
+        // The project must have a token contract attached.
+        if (token == IJBToken(address(0))) revert JBTokens_TokenNotFound();
+
+        // There must be a name.
+        if (bytes(name).length == 0) revert JBTokens_EmptyName();
+
+        // There must be a symbol.
+        if (bytes(symbol).length == 0) revert JBTokens_EmptySymbol();
+
+        emit SetTokenMetadata({projectId: projectId, name: name, symbol: symbol, caller: msg.sender});
+
+        // Set the name and symbol.
+        token.setMetadata({name: name, symbol: symbol});
+    }
+
     /// @notice Allows a holder to transfer credits to another account.
     /// @dev Only a project's controller can transfer credits for that project.
     /// @param holder The address to transfer credits from.

package/src/interfaces/IJBController.sol

@@ -345,6 +345,12 @@ interface IJBController is IERC165, IJBProjectUriRegistry, IJBDirectoryAccessCon
     /// @param token The new token's address.
     function setTokenFor(uint256 projectId, IJBToken token) external;
 
+    /// @notice Sets the name and symbol of a project's token.
+    /// @param projectId The ID of the project whose token is being updated.
+    /// @param name The new name.
+    /// @param symbol The new symbol.
+    function setTokenMetadataOf(uint256 projectId, string calldata name, string calldata symbol) external;
+
     /// @notice Transfers credits from one address to another.
     /// @param holder The address to transfer credits from.
     /// @param projectId The ID of the project whose credits are being transferred.

package/src/interfaces/IJBPermitTerminal.sol

@@ -14,5 +14,6 @@ interface IJBPermitTerminal is IJBTerminal {
     event Permit2AllowanceFailed(address indexed token, address indexed owner, bytes reason);
 
     /// @notice The Permit2 contract used for token approvals.
+    // forge-lint: disable-next-line(mixed-case-function)
     function PERMIT2() external returns (IPermit2);
 }

package/src/interfaces/IJBToken.sol

@@ -36,4 +36,9 @@ interface IJBToken {
     /// @param account The address to mint tokens to.
     /// @param amount The amount of tokens to mint.
     function mint(address account, uint256 amount) external;
+
+    /// @notice Sets the token's name and symbol.
+    /// @param name The new name.
+    /// @param symbol The new symbol.
+    function setMetadata(string memory name, string memory symbol) external;
 }

package/src/interfaces/IJBTokens.sol

@@ -64,6 +64,13 @@ interface IJBTokens {
     /// @param caller The address that set the token.
     event SetToken(uint256 indexed projectId, IJBToken indexed token, address caller);
 
+    /// @notice A project token's name and symbol were updated.
+    /// @param projectId The ID of the project whose token was updated.
+    /// @param name The new token name.
+    /// @param symbol The new token symbol.
+    /// @param caller The address that called the function.
+    event SetTokenMetadata(uint256 indexed projectId, string name, string symbol, address caller);
+
     /// @notice Credits were transferred from one holder to another.
     /// @param holder The address that transferred the credits.
     /// @param projectId The ID of the project whose credits were transferred.
@@ -146,6 +153,12 @@ interface IJBTokens {
     /// @param token The token to set.
     function setTokenFor(uint256 projectId, IJBToken token) external;
 
+    /// @notice Sets the name and symbol of a project's token.
+    /// @param projectId The ID of the project whose token is being updated.
+    /// @param name The new name.
+    /// @param symbol The new symbol.
+    function setTokenMetadataFor(uint256 projectId, string calldata name, string calldata symbol) external;
+
     /// @notice Transfers credits from one holder to another.
     /// @param holder The address to transfer credits from.
     /// @param projectId The ID of the project whose credits are being transferred.

package/src/libraries/JBMetadataResolver.sol

@@ -62,6 +62,7 @@ library JBMetadataResolver {
     {
         // Empty original metadata and maybe something in the first 32 bytes: create new metadata
         if (originalMetadata.length <= RESERVED_SIZE) {
+            // forge-lint: disable-next-line(unsafe-typecast)
             return abi.encodePacked(bytes32(originalMetadata), bytes32(abi.encodePacked(idToAdd, uint8(2))), dataToAdd);
         }
 
@@ -96,7 +97,7 @@ library JBMetadataResolver {
                 numberOfWordslastData = (originalMetadata.length - lastOffset * WORD_SIZE) / WORD_SIZE;
 
                 // Copy the reserved word and the table and remove the previous padding
-                newMetadata = _sliceBytes(originalMetadata, 0, lastOffsetIndex + 1);
+                newMetadata = _sliceBytes({data: originalMetadata, start: 0, end: lastOffsetIndex + 1});
 
                 // Check if the new entry is still fitting in this word
                 if (i + TOTAL_ID_SIZE >= firstOffset * WORD_SIZE) {
@@ -118,6 +119,7 @@ library JBMetadataResolver {
         // Compute in uint256 first — casting directly to uint8 silently wraps offsets > 255.
         uint256 newOffset = lastOffset + numberOfWordslastData;
         if (newOffset > 255) revert JBMetadataResolver_MetadataTooLong();
+        // forge-lint: disable-next-line(unsafe-typecast)
         newMetadata = abi.encodePacked(newMetadata, idToAdd, bytes1(uint8(newOffset)));
 
         // Pad as needed - inlined for gas saving
@@ -129,7 +131,8 @@ library JBMetadataResolver {
 
         // Add existing data at the end
         newMetadata = abi.encodePacked(
-            newMetadata, _sliceBytes(originalMetadata, firstOffset * WORD_SIZE, originalMetadata.length)
+            newMetadata,
+            _sliceBytes({data: originalMetadata, start: firstOffset * WORD_SIZE, end: originalMetadata.length})
         );
 
         // Pad as needed
@@ -181,6 +184,7 @@ library JBMetadataResolver {
                 revert JBMetadataResolver_DataNotPadded();
             }
 
+            // forge-lint: disable-next-line(unsafe-typecast)
             metadata = abi.encodePacked(metadata, ids[i], bytes1(uint8(offset)));
             offset += data.length / JBMetadataResolver.WORD_SIZE;
 
@@ -244,7 +248,7 @@ library JBMetadataResolver {
                     ? metadata.length
                     : uint256(uint8(metadata[i + NEXT_ID_OFFSET])) * WORD_SIZE;
 
-                return (true, _sliceBytes(metadata, currentOffset * WORD_SIZE, end));
+                return (true, _sliceBytes({data: metadata, start: currentOffset * WORD_SIZE, end: end}));
             }
             unchecked {
                 i += TOTAL_ID_SIZE;

package/src/libraries/JBRulesetMetadataResolver.sol

@@ -135,26 +135,26 @@ library JBRulesetMetadataResolver {
     /// @param ruleset The funding cycle having its metadata expanded.
     /// @return rulesetMetadata The ruleset's metadata object.
     function expandMetadata(JBRuleset memory ruleset) internal pure returns (JBRulesetMetadata memory) {
-        return JBRulesetMetadata(
-            reservedPercent(ruleset),
-            cashOutTaxRate(ruleset),
-            baseCurrency(ruleset),
-            pausePay(ruleset),
-            pauseCreditTransfers(ruleset),
-            allowOwnerMinting(ruleset),
-            allowSetCustomToken(ruleset),
-            allowTerminalMigration(ruleset),
-            allowSetTerminals(ruleset),
-            allowSetController(ruleset),
-            allowAddAccountingContext(ruleset),
-            allowAddPriceFeed(ruleset),
-            ownerMustSendPayouts(ruleset),
-            holdFees(ruleset),
-            useTotalSurplusForCashOuts(ruleset),
-            useDataHookForPay(ruleset),
-            useDataHookForCashOut(ruleset),
-            dataHook(ruleset),
-            metadata(ruleset)
-        );
+        return JBRulesetMetadata({
+            reservedPercent: reservedPercent(ruleset),
+            cashOutTaxRate: cashOutTaxRate(ruleset),
+            baseCurrency: baseCurrency(ruleset),
+            pausePay: pausePay(ruleset),
+            pauseCreditTransfers: pauseCreditTransfers(ruleset),
+            allowOwnerMinting: allowOwnerMinting(ruleset),
+            allowSetCustomToken: allowSetCustomToken(ruleset),
+            allowTerminalMigration: allowTerminalMigration(ruleset),
+            allowSetTerminals: allowSetTerminals(ruleset),
+            allowSetController: allowSetController(ruleset),
+            allowAddAccountingContext: allowAddAccountingContext(ruleset),
+            allowAddPriceFeed: allowAddPriceFeed(ruleset),
+            ownerMustSendPayouts: ownerMustSendPayouts(ruleset),
+            holdFees: holdFees(ruleset),
+            useTotalSurplusForCashOuts: useTotalSurplusForCashOuts(ruleset),
+            useDataHookForPay: useDataHookForPay(ruleset),
+            useDataHookForCashOut: useDataHookForCashOut(ruleset),
+            dataHook: dataHook(ruleset),
+            metadata: metadata(ruleset)
+        });
     }
 }

package/src/structs/JBAccountingContext.sol

@@ -5,6 +5,7 @@ pragma solidity ^0.8.0;
 /// @custom:member decimals The number of decimals expected in that token's fixed point accounting.
 /// @custom:member currency The currency that the token is priced in terms of. By convention, this is
 /// `uint32(uint160(tokenAddress))` for tokens, or a constant ID from e.g. `JBCurrencyIds` for other currencies.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBAccountingContext {
     address token;
     uint8 decimals;

package/src/structs/JBAfterCashOutRecordedContext.sol

@@ -16,6 +16,7 @@ import {JBTokenAmount} from "./JBTokenAmount.sol";
 /// @custom:member beneficiary The address the reclaimed amount will be sent to.
 /// @custom:member hookMetadata Extra data specified by the data hook, which is sent to the cash out hook.
 /// @custom:member cashOutMetadata Extra data specified by the account cashing out, which is sent to the cash out hook.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBAfterCashOutRecordedContext {
     address holder;
     uint256 projectId;

package/src/structs/JBAfterPayRecordedContext.sol

@@ -15,6 +15,7 @@ import {JBTokenAmount} from "./JBTokenAmount.sol";
 /// @custom:member beneficiary The address which receives any tokens this payment yields.
 /// @custom:member hookMetadata Extra data specified by the data hook, which is sent to the pay hook.
 /// @custom:member payerMetadata Extra data specified by the payer, which is sent to the pay hook.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBAfterPayRecordedContext {
     address payer;
     uint256 projectId;

package/src/structs/JBBeforeCashOutRecordedContext.sol

@@ -17,6 +17,7 @@ import {JBTokenAmount} from "./JBTokenAmount.sol";
 /// @custom:member useTotalSurplus If surplus across all of a project's terminals is being used when making cash outs.
 /// @custom:member cashOutTaxRate The cash out tax rate of the ruleset the cash out is being made during.
 /// @custom:member metadata Extra data provided by the casher.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBBeforeCashOutRecordedContext {
     address terminal;
     address holder;

package/src/structs/JBBeforePayRecordedContext.sol

@@ -15,6 +15,7 @@ import {JBTokenAmount} from "./JBTokenAmount.sol";
 /// @custom:member weight The weight of the ruleset during which the payment is being made.
 /// @custom:member reservedPercent The reserved percent of the ruleset the payment is being made during.
 /// @custom:member metadata Extra data specified by the payer.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBBeforePayRecordedContext {
     address terminal;
     address payer;

package/src/structs/JBCashOutHookSpecification.sol

@@ -8,6 +8,7 @@ import {IJBCashOutHook} from "../interfaces/IJBCashOutHook.sol";
 /// @custom:member hook The cash out hook to use when fulfilling this specification.
 /// @custom:member amount The amount to send to the hook.
 /// @custom:member metadata Metadata to pass to the hook.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBCashOutHookSpecification {
     IJBCashOutHook hook;
     uint256 amount;

package/src/structs/JBCurrencyAmount.sol

@@ -4,6 +4,7 @@ pragma solidity ^0.8.0;
 /// @custom:member amount The amount of the currency.
 /// @custom:member currency The currency. By convention, this is `uint32(uint160(tokenAddress))` for tokens, or a
 /// constant ID from e.g. `JBCurrencyIds` for other currencies.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBCurrencyAmount {
     uint224 amount;
     uint32 currency;

package/src/structs/JBFee.sol

@@ -5,6 +5,7 @@ pragma solidity ^0.8.0;
 /// decimals as the terminal in which this struct was created.
 /// @custom:member beneficiary The address that will receive the tokens that are minted as a result of the fee payment.
 /// @custom:member unlockTimestamp The timestamp at which the fee is unlocked and can be processed.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBFee {
     uint256 amount;
     address beneficiary;

package/src/structs/JBFundAccessLimitGroup.sol

@@ -20,6 +20,7 @@ import {JBCurrencyAmount} from "./JBCurrencyAmount.sol";
 /// @custom:member surplusAllowances An array of surplus allowances. The surplus allowances cumulatively dictates the
 /// maximum value of `token`s a project can pay out from its surplus (balance less payouts) in a terminal during a
 /// ruleset. Each surplus allowance can have a unique currency and amount.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBFundAccessLimitGroup {
     address terminal;
     address token;

package/src/structs/JBPayHookSpecification.sol

@@ -8,6 +8,7 @@ import {IJBPayHook} from "../interfaces/IJBPayHook.sol";
 /// @custom:member hook The pay hook to use when fulfilling this specification.
 /// @custom:member amount The amount to send to the hook.
 /// @custom:member metadata Metadata to pass the hook.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBPayHookSpecification {
     IJBPayHook hook;
     uint256 amount;

package/src/structs/JBPermissionsData.sol

@@ -6,6 +6,7 @@ pragma solidity ^0.8.0;
 /// permissions under this project's scope. An ID of 0 is a wildcard, which gives an operator permissions across all
 /// projects.
 /// @custom:member permissionIds The IDs of the permissions being given. See the `JBPermissionIds` library.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBPermissionsData {
     address operator;
     uint64 projectId;

package/src/structs/JBRuleset.sol

@@ -29,6 +29,7 @@ import {IJBRulesetApprovalHook} from "./../interfaces/IJBRulesetApprovalHook.sol
 /// ruleset is rejected, it won't go into effect. An approval hook can be used to create rules which dictate how a
 /// project owner can change their ruleset over time.
 /// @custom:member metadata Extra data associated with a ruleset which can be used by other contracts.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBRuleset {
     uint48 cycleNumber;
     uint48 id;

package/src/structs/JBRulesetConfig.sol

@@ -31,6 +31,7 @@ import {JBSplitGroup} from "./JBSplitGroup.sol";
 /// its balance in each payment terminal while the ruleset is active. Amounts are fixed point numbers using the same
 /// number of decimals as the corresponding terminal. The `_payoutLimit` and `_surplusAllowance` parameters must fit in
 /// a `uint232`.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBRulesetConfig {
     uint48 mustStartAtOrAfter;
     uint32 duration;