@bananapus/core-v6 0.0.15 → 0.0.17

package/src/interfaces/IJBTerminalStore.sol

@@ -145,6 +145,8 @@ interface IJBTerminalStore {
     /// @param cashOutCount The number of project tokens being cashed out.
     /// @param accountingContext The accounting context of the token being reclaimed.
     /// @param balanceAccountingContexts The accounting contexts to include in the balance calculation.
+    /// @param beneficiaryIsFeeless Whether the cash out's beneficiary is a feeless address. Passed through to data
+    /// hooks so they can skip their own fees when value stays in the protocol (e.g. project-to-project routing).
     /// @param metadata Extra data to pass along to the data hook.
     /// @return ruleset The project's current ruleset.
     /// @return reclaimAmount The amount reclaimed.
@@ -156,6 +158,7 @@ interface IJBTerminalStore {
         uint256 cashOutCount,
         JBAccountingContext calldata accountingContext,
         JBAccountingContext[] calldata balanceAccountingContexts,
+        bool beneficiaryIsFeeless,
         bytes calldata metadata
     )
         external

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/JBFees.sol

@@ -19,6 +19,8 @@ library JBFees {
 
     /// @notice Returns the fee that would be taken from `amountBeforeFee`.
     /// @dev Use this to forward-calculate the fee from a known pre-fee amount.
+    /// @dev Fee rounding error is bounded by N-1 wei (N = number of splits). Economically
+    /// insignificant. Rounds down (mulDiv floors), so the fee beneficiary may receive up to 1 wei less per split.
     /// @param amountBeforeFee The amount before the fee is applied, as a fixed point number.
     /// @param feePercent The fee percent, out of `JBConstants.MAX_FEE`.
     /// @return The fee amount, as a fixed point number with the same number of decimals as the provided `amount`.

package/src/libraries/JBMetadataResolver.sol

@@ -60,17 +60,18 @@ library JBMetadataResolver {
         pure
         returns (bytes memory newMetadata)
     {
+        // Validate data padding upfront so that the fast path below cannot bypass the check.
+        if (dataToAdd.length < 32) revert JBMetadataResolver_DataNotPadded();
+
         // 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);
         }
 
         // There is something in the table offset, but not a valid entry - avoid overwriting
         if (originalMetadata.length < RESERVED_SIZE + ID_SIZE + 1) revert JBMetadataResolver_MetadataTooShort();
 
-        // Make sure the data is padded to 32 bytes.
-        if (dataToAdd.length < 32) revert JBMetadataResolver_DataNotPadded();
-
         // Get the first data offset - upcast to avoid overflow (same for other offset)...
         uint256 firstOffset = uint8(originalMetadata[RESERVED_SIZE + ID_SIZE]);
 
@@ -96,13 +97,16 @@ 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) {
                     // Increment every offset by 1 (as the table now takes one more word)
                     for (uint256 j = RESERVED_SIZE + ID_SIZE; j < lastOffsetIndex + 1; j += TOTAL_ID_SIZE) {
-                        newMetadata[j] = bytes1(uint8(originalMetadata[j]) + 1);
+                        uint256 incremented = uint256(uint8(originalMetadata[j])) + 1;
+                        if (incremented > 255) revert JBMetadataResolver_MetadataTooLong();
+                        // forge-lint: disable-next-line(unsafe-typecast)
+                        newMetadata[j] = bytes1(uint8(incremented));
                     }
 
                     // Increment the last offset so the new offset will be properly set too
@@ -118,9 +122,14 @@ 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
+        // The length inflation to the next 32-byte boundary does NOT read uninitialized memory.
+        // abi.encodePacked always advances the free memory pointer to a 32-byte-aligned position, so the
+        // padding bytes (up to 31) are within the already-allocated region and guaranteed to be zero by
+        // Solidity's virgin-memory invariant. The zeros are the intended table padding per the metadata format.
         uint256 paddedLength =
             newMetadata.length % WORD_SIZE == 0 ? newMetadata.length : (newMetadata.length / WORD_SIZE + 1) * WORD_SIZE;
         assembly ("memory-safe") {
@@ -129,7 +138,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
@@ -159,6 +169,9 @@ library JBMetadataResolver {
     function createMetadata(bytes4[] memory ids, bytes[] memory datas) internal pure returns (bytes memory metadata) {
         if (ids.length != datas.length) revert JBMetadataResolver_LengthMismatch();
 
+        // Return empty bytes for empty input arrays to avoid underflow in offset calculation below.
+        if (ids.length == 0) return bytes("");
+
         // Add a first empty 32B for the protocol reserved word
         metadata = abi.encodePacked(bytes32(0));
 
@@ -181,6 +194,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;
 
@@ -214,6 +228,9 @@ library JBMetadataResolver {
 
     /// @notice Parse the metadata to find the data for a specific ID
     /// @dev Returns false and an empty bytes if no data is found
+    /// @dev Padding to 32-byte boundaries is required for ABI compatibility. The apparent
+    /// inconsistency between creation and parsing is intentional: creation pads for storage alignment,
+    /// parsing uses actual data length boundaries from the lookup table.
     /// @param id The ID to find.
     /// @param metadata The metadata to parse.
     /// @return found Whether the {id:data} was found
@@ -244,7 +261,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

@@ -16,7 +16,11 @@ import {JBTokenAmount} from "./JBTokenAmount.sol";
 /// included, and the currency of the surplus.
 /// @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 beneficiaryIsFeeless Whether the cash out's beneficiary is a feeless address. Useful for data hooks
+/// that charge their own fees — they can skip fees when value stays in the protocol (e.g. project-to-project
+/// routing).
 /// @custom:member metadata Extra data provided by the casher.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBBeforeCashOutRecordedContext {
     address terminal;
     address holder;
@@ -27,5 +31,6 @@ struct JBBeforeCashOutRecordedContext {
     JBTokenAmount surplus;
     bool useTotalSurplus;
     uint256 cashOutTaxRate;
+    bool beneficiaryIsFeeless;
     bytes metadata;
 }

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;

package/src/structs/JBRulesetMetadata.sol

@@ -33,6 +33,7 @@ pragma solidity ^0.8.0;
 /// @custom:member dataHook The data hook to use during this ruleset.
 /// @custom:member metadata Metadata of the metadata, only the 14 least significant bits can be used, the 2 most
 /// significant bits are disregarded.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBRulesetMetadata {
     uint16 reservedPercent;
     uint16 cashOutTaxRate;

package/src/structs/JBRulesetWeightCache.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.0;
 
 /// @custom:member weight The cached weight value.
 /// @custom:member weightCutMultiple The weight cut multiple that produces the given weight.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBRulesetWeightCache {
     uint112 weight;
     uint168 weightCutMultiple;

package/src/structs/JBRulesetWithMetadata.sol

@@ -6,6 +6,7 @@ import {JBRulesetMetadata} from "./JBRulesetMetadata.sol";
 
 /// @custom:member ruleset The ruleset.
 /// @custom:member metadata The ruleset's metadata.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBRulesetWithMetadata {
     JBRuleset ruleset;
     JBRulesetMetadata metadata;

package/src/structs/JBSingleAllowance.sol

@@ -7,6 +7,7 @@ pragma solidity ^0.8.0;
 /// @custom:member nonce An incrementing value indexed per owner,token,and spender for each signature.
 /// @custom:member signature The signature over the permit data. Supports EOA signatures, compact signatures defined by
 /// EIP-2098, and contract signatures defined by EIP-1271.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBSingleAllowance {
     uint256 sigDeadline;
     uint160 amount;

package/src/structs/JBSplit.sol

@@ -27,6 +27,7 @@ import {IJBSplitHook} from "./../interfaces/IJBSplitHook.sol";
 /// increased while a split is locked. If `lockedUntil` is zero, this split can be changed at any time.
 /// @custom:member hook A contract which will receive this split's tokens and properties, and can define custom
 /// behavior.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBSplit {
     uint32 percent;
     uint64 projectId;

package/src/structs/JBSplitGroup.sol

@@ -6,6 +6,7 @@ import {JBSplit} from "./JBSplit.sol";
 /// @custom:member groupId An identifier for the group. By convention, this ID is `uint256(uint160(tokenAddress))` for
 /// payouts and `1` for reserved tokens.
 /// @custom:member splits The splits in the group.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBSplitGroup {
     uint256 groupId;
     JBSplit[] splits;

package/src/structs/JBSplitHookContext.sol

@@ -10,6 +10,7 @@ import {JBSplit} from "./JBSplit.sol";
 /// @custom:member groupId The group the split belongs to. By convention, this ID is `uint256(uint160(tokenAddress))`
 /// for payouts and `1` for reserved tokens.
 /// @custom:member split The split which specified the hook.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBSplitHookContext {
     address token;
     uint256 amount;

package/src/structs/JBTerminalConfig.sol

@@ -6,6 +6,7 @@ import {IJBTerminal} from "./../interfaces/IJBTerminal.sol";
 
 /// @custom:member terminal The terminal to configure.
 /// @custom:member accountingContextsToAccept The accounting contexts to accept from the terminal.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBTerminalConfig {
     IJBTerminal terminal;
     JBAccountingContext[] accountingContextsToAccept;

package/src/structs/JBTokenAmount.sol

@@ -6,6 +6,7 @@ pragma solidity ^0.8.0;
 /// @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.
 /// @custom:member value The amount of tokens that was paid, as a fixed point number.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBTokenAmount {
     address token;
     uint8 decimals;

package/test/ComprehensiveInvariant.t.sol

@@ -1,8 +1,21 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.6;
 
-import "forge-std/StdInvariant.sol";
-import /* {*} from */ "./helpers/TestBaseWorkflow.sol";
+import {StdInvariant} from "forge-std/StdInvariant.sol";
+import {TestBaseWorkflow} from "./helpers/TestBaseWorkflow.sol";
+import {IJBRulesetApprovalHook} from "../src/interfaces/IJBRulesetApprovalHook.sol";
+import {IJBSplitHook} from "../src/interfaces/IJBSplitHook.sol";
+import {IJBToken} from "../src/interfaces/IJBToken.sol";
+import {JBConstants} from "../src/libraries/JBConstants.sol";
+import {JBRulesetMetadataResolver} from "../src/libraries/JBRulesetMetadataResolver.sol";
+import {JBCurrencyAmount} from "../src/structs/JBCurrencyAmount.sol";
+import {JBFundAccessLimitGroup} from "../src/structs/JBFundAccessLimitGroup.sol";
+import {JBRuleset} from "../src/structs/JBRuleset.sol";
+import {JBRulesetConfig} from "../src/structs/JBRulesetConfig.sol";
+import {JBRulesetMetadata} from "../src/structs/JBRulesetMetadata.sol";
+import {JBSplit} from "../src/structs/JBSplit.sol";
+import {JBSplitGroup} from "../src/structs/JBSplitGroup.sol";
+import {JBTerminalConfig} from "../src/structs/JBTerminalConfig.sol";
 import {ComprehensiveHandler} from "./invariants/handlers/ComprehensiveHandler.sol";
 import {JBAccountingContext} from "../src/structs/JBAccountingContext.sol";
 

package/test/CoreExploitTests.t.sol

@@ -1,7 +1,32 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.6;
 
-import /* {*} from */ "./helpers/TestBaseWorkflow.sol";
+import {TestBaseWorkflow} from "./helpers/TestBaseWorkflow.sol";
+import {MetadataResolverHelper} from "./helpers/MetadataResolverHelper.sol";
+import {MockERC20} from "./mock/MockERC20.sol";
+import {JBMultiTerminal} from "../src/JBMultiTerminal.sol";
+import {JBTokens} from "../src/JBTokens.sol";
+import {JBApprovalStatus} from "../src/enums/JBApprovalStatus.sol";
+import {IJBController} from "../src/interfaces/IJBController.sol";
+import {IJBMultiTerminal} from "../src/interfaces/IJBMultiTerminal.sol";
+import {IJBPayHook} from "../src/interfaces/IJBPayHook.sol";
+import {IJBRulesetApprovalHook} from "../src/interfaces/IJBRulesetApprovalHook.sol";
+import {IJBRulesetDataHook} from "../src/interfaces/IJBRulesetDataHook.sol";
+import {IJBTerminal} from "../src/interfaces/IJBTerminal.sol";
+import {IJBToken} from "../src/interfaces/IJBToken.sol";
+import {JBConstants} from "../src/libraries/JBConstants.sol";
+import {JBFees} from "../src/libraries/JBFees.sol";
+import {JBAccountingContext} from "../src/structs/JBAccountingContext.sol";
+import {JBCurrencyAmount} from "../src/structs/JBCurrencyAmount.sol";
+import {JBFee} from "../src/structs/JBFee.sol";
+import {JBFundAccessLimitGroup} from "../src/structs/JBFundAccessLimitGroup.sol";
+import {JBPayHookSpecification} from "../src/structs/JBPayHookSpecification.sol";
+import {JBRuleset} from "../src/structs/JBRuleset.sol";
+import {JBRulesetConfig} from "../src/structs/JBRulesetConfig.sol";
+import {JBRulesetMetadata} from "../src/structs/JBRulesetMetadata.sol";
+import {JBSplitGroup} from "../src/structs/JBSplitGroup.sol";
+import {JBTerminalConfig} from "../src/structs/JBTerminalConfig.sol";
+import {ERC165, IERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
 import {JBCashOuts} from "../src/libraries/JBCashOuts.sol";
 
 /// @notice Tests for edge case scenarios in Juicebox V5.
@@ -1227,7 +1252,9 @@ contract EdgeCases_Local is TestBaseWorkflow {
         uint256 hugeBorrow = uint256(type(uint112).max) + 500 ether;
 
         // Silent truncation — Solidity 0.8.x does NOT revert on explicit downcasts!
+        // forge-lint: disable-next-line(unsafe-typecast)
         uint112 truncatedCollateral = uint112(hugeCollateral);
+        // forge-lint: disable-next-line(unsafe-typecast)
         uint112 truncatedBorrow = uint112(hugeBorrow);
 
         // The truncated values are dramatically smaller.
@@ -2050,6 +2077,7 @@ contract EdgeCases_Local is TestBaseWorkflow {
 
     /// @notice Helper: launches a project with only MockERC20 (6 decimals, simulating USDC on Tempo).
     ///         No NATIVE_TOKEN accounting context is registered.
+    // forge-lint: disable-next-line(mixed-case-function)
     function _launchProjectERC20(uint16 cashOutTaxRate, uint16 reservedPercent) internal returns (uint256 projectId) {
         MockERC20 token = usdcToken();
 
@@ -2119,6 +2147,7 @@ contract EdgeCases_Local is TestBaseWorkflow {
     }
 
     /// @notice Helper: launches an ERC-20-only project with payout limits.
+    // forge-lint: disable-next-line(mixed-case-function)
     function _launchProjectERC20WithPayoutLimit(
         uint16 cashOutTaxRate,
         uint224 payoutLimit
@@ -2632,8 +2661,11 @@ contract ReentrancyAttacker {
 
 /// @notice Malicious fee terminal that reenters processHeldFeesOf during pay().
 contract ReentrantFeeTerminal is ERC165 {
+    // forge-lint: disable-next-line(screaming-snake-case-immutable)
     IJBMultiTerminal public immutable victim;
+    // forge-lint: disable-next-line(screaming-snake-case-immutable)
     uint256 public immutable targetProjectId;
+    // forge-lint: disable-next-line(screaming-snake-case-immutable)
     address public immutable targetToken;
     uint256 public payCallCount;
 
@@ -2688,6 +2720,7 @@ contract ReentrantFeeTerminal is ERC165 {
 
 /// @notice Malicious approval hook that always reverts.
 contract MaliciousApprovalHook is ERC165, IJBRulesetApprovalHook {
+    // forge-lint: disable-next-line(mixed-case-function)
     function DURATION() external pure override returns (uint256) {
         return 1 days;
     }

package/test/EconomicSimulation.t.sol

@@ -1,8 +1,16 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.6;
 
-import "forge-std/StdInvariant.sol";
-import /* {*} from */ "./helpers/TestBaseWorkflow.sol";
+import {StdInvariant} from "forge-std/StdInvariant.sol";
+import {TestBaseWorkflow} from "./helpers/TestBaseWorkflow.sol";
+import {IJBRulesetApprovalHook} from "../src/interfaces/IJBRulesetApprovalHook.sol";
+import {JBRulesetMetadataResolver} from "../src/libraries/JBRulesetMetadataResolver.sol";
+import {JBFundAccessLimitGroup} from "../src/structs/JBFundAccessLimitGroup.sol";
+import {JBRuleset} from "../src/structs/JBRuleset.sol";
+import {JBRulesetConfig} from "../src/structs/JBRulesetConfig.sol";
+import {JBRulesetMetadata} from "../src/structs/JBRulesetMetadata.sol";
+import {JBSplitGroup} from "../src/structs/JBSplitGroup.sol";
+import {JBTerminalConfig} from "../src/structs/JBTerminalConfig.sol";
 import {EconomicHandler} from "./invariants/handlers/EconomicHandler.sol";
 import {JBAccountingContext} from "../src/structs/JBAccountingContext.sol";
 import {JBConstants} from "../src/libraries/JBConstants.sol";

package/test/EntryPointPermutations.t.sol

@@ -1,7 +1,17 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.6;
 
-import /* {*} from */ "./helpers/TestBaseWorkflow.sol";
+import {TestBaseWorkflow} from "./helpers/TestBaseWorkflow.sol";
+import {IJBRulesetApprovalHook} from "../src/interfaces/IJBRulesetApprovalHook.sol";
+import {JBRulesetMetadataResolver} from "../src/libraries/JBRulesetMetadataResolver.sol";
+import {JBCurrencyAmount} from "../src/structs/JBCurrencyAmount.sol";
+import {JBFee} from "../src/structs/JBFee.sol";
+import {JBFundAccessLimitGroup} from "../src/structs/JBFundAccessLimitGroup.sol";
+import {JBRuleset} from "../src/structs/JBRuleset.sol";
+import {JBRulesetConfig} from "../src/structs/JBRulesetConfig.sol";
+import {JBRulesetMetadata} from "../src/structs/JBRulesetMetadata.sol";
+import {JBSplitGroup} from "../src/structs/JBSplitGroup.sol";
+import {JBTerminalConfig} from "../src/structs/JBTerminalConfig.sol";
 import {JBAccountingContext} from "../src/structs/JBAccountingContext.sol";
 import {JBConstants} from "../src/libraries/JBConstants.sol";
 
@@ -592,7 +602,9 @@ contract EntryPointPermutations_Local is TestBaseWorkflow {
             if (payoutLimit > 0) {
                 payoutLimits = new JBCurrencyAmount[](1);
                 payoutLimits[0] = JBCurrencyAmount({
-                    amount: uint224(payoutLimit), currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    amount: uint224(payoutLimit),
+                    currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
                 });
             } else {
                 payoutLimits = new JBCurrencyAmount[](0);
@@ -601,7 +613,9 @@ contract EntryPointPermutations_Local is TestBaseWorkflow {
             if (surplusAllowance > 0) {
                 surplusAllowances = new JBCurrencyAmount[](1);
                 surplusAllowances[0] = JBCurrencyAmount({
-                    amount: uint224(surplusAllowance), currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+                    // forge-lint: disable-next-line(unsafe-typecast)
+                    amount: uint224(surplusAllowance),
+                    currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
                 });
             } else {
                 surplusAllowances = new JBCurrencyAmount[](0);

package/test/FlashLoanAttacks.t.sol

@@ -1,7 +1,17 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.6;
 
-import /* {*} from */ "./helpers/TestBaseWorkflow.sol";
+import {TestBaseWorkflow} from "./helpers/TestBaseWorkflow.sol";
+import {IJBRulesetApprovalHook} from "../src/interfaces/IJBRulesetApprovalHook.sol";
+import {JBConstants} from "../src/libraries/JBConstants.sol";
+import {JBRulesetMetadataResolver} from "../src/libraries/JBRulesetMetadataResolver.sol";
+import {JBCurrencyAmount} from "../src/structs/JBCurrencyAmount.sol";
+import {JBFundAccessLimitGroup} from "../src/structs/JBFundAccessLimitGroup.sol";
+import {JBRuleset} from "../src/structs/JBRuleset.sol";
+import {JBRulesetConfig} from "../src/structs/JBRulesetConfig.sol";
+import {JBRulesetMetadata} from "../src/structs/JBRulesetMetadata.sol";
+import {JBSplitGroup} from "../src/structs/JBSplitGroup.sol";
+import {JBTerminalConfig} from "../src/structs/JBTerminalConfig.sol";
 import {JBAccountingContext} from "../src/structs/JBAccountingContext.sol";
 
 /// @notice Tests that flash-loan style atomic pay+cashOut attacks cannot extract profit.
@@ -548,6 +558,7 @@ contract FlashLoanAttacks_Local is TestBaseWorkflow {
 
         // Attacker front-runs: pays right before payout
         address attacker = address(0xA77AC0);
+        // forge-lint: disable-next-line(mixed-case-variable)
         uint256 attackerInitialETH = 10 ether;
         vm.deal(attacker, attackerInitialETH);
         vm.prank(attacker);