@bananapus/core-v6 0.0.1

package/test/TestPermissionsEdge.sol

@@ -0,0 +1,286 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.6;
+
+import /* {*} from */ "./helpers/TestBaseWorkflow.sol";
+
+/// @notice Defense-in-depth validation of JBPermissions ROOT escalation prevention.
+/// Verifies that ROOT operators cannot forward ROOT, cannot set wildcard permissions,
+/// and that the permission bitmap maintains integrity through set/get cycles.
+contract TestPermissionsEdge_Local is TestBaseWorkflow {
+    JBPermissions private _permissions;
+
+    address private _account;
+    address private _operator;
+    address private _thirdParty;
+
+    uint64 constant PROJECT_ID = 5;
+
+    function setUp() public override {
+        super.setUp();
+        _permissions = jbPermissions();
+        _account = makeAddr("account");
+        _operator = makeAddr("operator");
+        _thirdParty = makeAddr("thirdParty");
+    }
+
+    // ───────────────────── ROOT cannot be forwarded
+    // ─────────────────────
+
+    /// @notice An operator with ROOT on project N cannot set ROOT for another operator.
+    function test_rootCannotBeForwarded() external {
+        // Give operator ROOT permission on PROJECT_ID.
+        uint8[] memory rootPermissions = new uint8[](1);
+        rootPermissions[0] = JBPermissionIds.ROOT;
+
+        vm.prank(_account);
+        _permissions.setPermissionsFor(
+            _account, JBPermissionsData({operator: _operator, projectId: PROJECT_ID, permissionIds: rootPermissions})
+        );
+
+        // Verify operator has ROOT.
+        assertTrue(
+            _permissions.hasPermission(_operator, _account, PROJECT_ID, JBPermissionIds.ROOT, false, false),
+            "Operator should have ROOT"
+        );
+
+        // Now operator tries to forward ROOT to thirdParty.
+        uint8[] memory rootForThird = new uint8[](1);
+        rootForThird[0] = JBPermissionIds.ROOT;
+
+        vm.prank(_operator);
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBPermissions.JBPermissions_Unauthorized.selector, _account, _operator, PROJECT_ID, JBPermissionIds.ROOT
+            )
+        );
+        _permissions.setPermissionsFor(
+            _account, JBPermissionsData({operator: _thirdParty, projectId: PROJECT_ID, permissionIds: rootForThird})
+        );
+    }
+
+    // ───────────────────── Wildcard cannot be set by operator
+    // ─────────────────────
+
+    /// @notice An operator with ROOT cannot set permissions for the wildcard project ID.
+    function test_wildcardCannotBeSetByOperator() external {
+        // Give operator ROOT on PROJECT_ID.
+        uint8[] memory rootPermissions = new uint8[](1);
+        rootPermissions[0] = JBPermissionIds.ROOT;
+
+        vm.prank(_account);
+        _permissions.setPermissionsFor(
+            _account, JBPermissionsData({operator: _operator, projectId: PROJECT_ID, permissionIds: rootPermissions})
+        );
+
+        // Operator tries to set permissions on wildcard (project 0).
+        uint8[] memory somePermission = new uint8[](1);
+        somePermission[0] = 5; // Some non-ROOT permission.
+
+        vm.prank(_operator);
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBPermissions.JBPermissions_Unauthorized.selector, _account, _operator, 0, JBPermissionIds.ROOT
+            )
+        );
+        _permissions.setPermissionsFor(
+            _account, JBPermissionsData({operator: _thirdParty, projectId: 0, permissionIds: somePermission})
+        );
+    }
+
+    // ───────────────────── ROOT grants all permissions
+    // ─────────────────────
+
+    /// @notice Fuzz: ROOT holder always has permission for any ID (when includeRoot=true).
+    function testFuzz_rootGrantsAllPermissions(uint8 permissionId) external {
+        vm.assume(permissionId > 0); // 0 is reserved.
+
+        // Give operator ROOT.
+        uint8[] memory rootPermissions = new uint8[](1);
+        rootPermissions[0] = JBPermissionIds.ROOT;
+
+        vm.prank(_account);
+        _permissions.setPermissionsFor(
+            _account, JBPermissionsData({operator: _operator, projectId: PROJECT_ID, permissionIds: rootPermissions})
+        );
+
+        // Check any permissionId with includeRoot=true.
+        assertTrue(
+            _permissions.hasPermission(_operator, _account, PROJECT_ID, permissionId, true, false),
+            "ROOT should grant all permissions when includeRoot=true"
+        );
+
+        // Without includeRoot, only ROOT bit should be set.
+        if (permissionId != JBPermissionIds.ROOT) {
+            assertFalse(
+                _permissions.hasPermission(_operator, _account, PROJECT_ID, permissionId, false, false),
+                "Without includeRoot, only ROOT bit should match"
+            );
+        }
+    }
+
+    // ───────────────────── Permission ID boundaries
+    // ─────────────────────
+
+    /// @notice Permission 0 cannot be set.
+    function test_permissionId0_cannotBeSet() external {
+        uint8[] memory zeroPermission = new uint8[](1);
+        zeroPermission[0] = 0;
+
+        vm.prank(_account);
+        vm.expectRevert(JBPermissions.JBPermissions_NoZeroPermission.selector);
+        _permissions.setPermissionsFor(
+            _account, JBPermissionsData({operator: _operator, projectId: PROJECT_ID, permissionIds: zeroPermission})
+        );
+    }
+
+    /// @notice Permission 255 (highest) works correctly.
+    function test_permissionId255_works() external {
+        uint8[] memory maxPermission = new uint8[](1);
+        maxPermission[0] = 255;
+
+        vm.prank(_account);
+        _permissions.setPermissionsFor(
+            _account, JBPermissionsData({operator: _operator, projectId: PROJECT_ID, permissionIds: maxPermission})
+        );
+
+        assertTrue(
+            _permissions.hasPermission(_operator, _account, PROJECT_ID, 255, false, false), "Permission 255 should work"
+        );
+
+        // Permission 254 should NOT be set.
+        assertFalse(
+            _permissions.hasPermission(_operator, _account, PROJECT_ID, 254, false, false),
+            "Permission 254 should not be set"
+        );
+    }
+
+    // ───────────────────── Replacement not additive
+    // ─────────────────────
+
+    /// @notice Setting new permissions replaces old ones (old permissions lost).
+    function test_replacementNotAdditive() external {
+        // Set permission 5.
+        uint8[] memory perm5 = new uint8[](1);
+        perm5[0] = 5;
+
+        vm.prank(_account);
+        _permissions.setPermissionsFor(
+            _account, JBPermissionsData({operator: _operator, projectId: PROJECT_ID, permissionIds: perm5})
+        );
+
+        assertTrue(_permissions.hasPermission(_operator, _account, PROJECT_ID, 5, false, false), "Should have perm 5");
+
+        // Now set permission 10 — should REPLACE, not add to perm 5.
+        uint8[] memory perm10 = new uint8[](1);
+        perm10[0] = 10;
+
+        vm.prank(_account);
+        _permissions.setPermissionsFor(
+            _account, JBPermissionsData({operator: _operator, projectId: PROJECT_ID, permissionIds: perm10})
+        );
+
+        assertTrue(_permissions.hasPermission(_operator, _account, PROJECT_ID, 10, false, false), "Should have perm 10");
+        assertFalse(
+            _permissions.hasPermission(_operator, _account, PROJECT_ID, 5, false, false),
+            "Perm 5 should be LOST after replacement"
+        );
+    }
+
+    // ───────────────────── Wildcard overrides project-specific
+    // ─────────────────────
+
+    /// @notice Wildcard permission grants access to all projects.
+    function test_wildcardOverridesProjectSpecific() external {
+        // Set permission 5 on wildcard project (0).
+        uint8[] memory perm5 = new uint8[](1);
+        perm5[0] = 5;
+
+        vm.prank(_account);
+        _permissions.setPermissionsFor(
+            _account, JBPermissionsData({operator: _operator, projectId: 0, permissionIds: perm5})
+        );
+
+        // Check with includeWildcardProjectId=true on any project.
+        assertTrue(
+            _permissions.hasPermission(_operator, _account, PROJECT_ID, 5, false, true),
+            "Wildcard should grant permission on any project"
+        );
+
+        // Check without wildcard — should not have permission on specific project.
+        assertFalse(
+            _permissions.hasPermission(_operator, _account, PROJECT_ID, 5, false, false),
+            "Without wildcard flag, specific project check fails"
+        );
+    }
+
+    // ───────────────────── Bit integrity fuzz
+    // ─────────────────────
+
+    /// @notice Fuzz: packed permissions maintain bit integrity through set/get cycle.
+    function testFuzz_setPermissions_bitIntegrity(uint256 bitmap) external {
+        // Build permission ID array from bitmap.
+        // Count set bits (excluding bit 0).
+        uint256 count;
+        for (uint256 i = 1; i < 256; i++) {
+            if ((bitmap >> i) & 1 == 1) count++;
+        }
+
+        if (count == 0) return; // Skip empty bitmaps.
+
+        uint8[] memory ids = new uint8[](count);
+        uint256 idx;
+        for (uint256 i = 1; i < 256; i++) {
+            if ((bitmap >> i) & 1 == 1) {
+                ids[idx] = uint8(i);
+                idx++;
+            }
+        }
+
+        vm.prank(_account);
+        _permissions.setPermissionsFor(
+            _account, JBPermissionsData({operator: _operator, projectId: PROJECT_ID, permissionIds: ids})
+        );
+
+        // Verify packed value matches.
+        uint256 packed = _permissions.permissionsOf(_operator, _account, PROJECT_ID);
+
+        // Check each bit.
+        for (uint256 i = 1; i < 256; i++) {
+            bool expected = (bitmap >> i) & 1 == 1;
+            bool actual = ((packed >> i) & 1) == 1;
+            assertEq(actual, expected, string.concat("Bit mismatch at position ", vm.toString(i)));
+        }
+
+        // Bit 0 should never be set.
+        assertFalse(((packed >> 0) & 1) == 1, "Bit 0 should never be set");
+    }
+
+    // ───────────────────── ROOT operator can set non-ROOT permissions
+    // ─────────────────────
+
+    /// @notice ROOT operator CAN set non-ROOT permissions for others on the same project.
+    function test_rootOperator_canSetNonRootPermissions() external {
+        // Give operator ROOT.
+        uint8[] memory rootPermissions = new uint8[](1);
+        rootPermissions[0] = JBPermissionIds.ROOT;
+
+        vm.prank(_account);
+        _permissions.setPermissionsFor(
+            _account, JBPermissionsData({operator: _operator, projectId: PROJECT_ID, permissionIds: rootPermissions})
+        );
+
+        // Operator sets non-ROOT permission for thirdParty — should succeed.
+        uint8[] memory nonRootPerm = new uint8[](1);
+        nonRootPerm[0] = 5;
+
+        vm.prank(_operator);
+        _permissions.setPermissionsFor(
+            _account, JBPermissionsData({operator: _thirdParty, projectId: PROJECT_ID, permissionIds: nonRootPerm})
+        );
+
+        assertTrue(
+            _permissions.hasPermission(_thirdParty, _account, PROJECT_ID, 5, false, false),
+            "ROOT operator should be able to delegate non-ROOT permissions"
+        );
+    }
+}

package/test/TestPermit2Terminal.sol

@@ -0,0 +1,339 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.6;
+
+import /* {*} from */ "./helpers/TestBaseWorkflow.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {MockPriceFeed} from "./mock/MockPriceFeed.sol";
+
+contract TestPermit2Terminal_Local is TestBaseWorkflow {
+    uint112 private constant _WEIGHT = uint112(1000 * 10 ** 18);
+
+    IJBController private _controller;
+    IJBTerminal private _terminal;
+    IJBPrices private _prices;
+    IJBTokens private _tokens;
+    IERC20 private _usdc;
+    IPermit2 private _permit2;
+    MetadataResolverHelper private _helper;
+    address private _projectOwner;
+
+    uint256 _projectId;
+
+    // Permit2 params.
+    bytes32 DOMAIN_SEPARATOR;
+    address from;
+    uint256 fromPrivateKey;
+
+    // Price.
+    uint256 _nativePricePerUsd = 0.0005 * 10 ** 18; // 1/2000
+
+    function setUp() public override {
+        super.setUp();
+
+        _controller = jbController();
+        _projectOwner = multisig();
+        _terminal = jbMultiTerminal();
+        _prices = jbPrices();
+        _tokens = jbTokens();
+        _helper = metadataHelper();
+        _usdc = usdcToken();
+        _permit2 = permit2();
+
+        fromPrivateKey = 0x12341234;
+        from = vm.addr(fromPrivateKey);
+        DOMAIN_SEPARATOR = permit2().DOMAIN_SEPARATOR();
+
+        JBRulesetMetadata memory _metadata = JBRulesetMetadata({
+            reservedPercent: 0,
+            cashOutTaxRate: JBConstants.MAX_CASH_OUT_TAX_RATE,
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: true,
+            allowSetCustomToken: true,
+            allowTerminalMigration: false,
+            allowSetTerminals: false,
+            ownerMustSendPayouts: false,
+            allowSetController: false,
+            allowAddAccountingContext: true,
+            allowAddPriceFeed: true,
+            holdFees: false,
+            useTotalSurplusForCashOuts: false,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+
+        // Package up ruleset configuration.
+        JBRulesetConfig[] memory _rulesetConfig = new JBRulesetConfig[](1);
+        _rulesetConfig[0].mustStartAtOrAfter = 0;
+        _rulesetConfig[0].duration = 0;
+        _rulesetConfig[0].weight = _WEIGHT;
+        _rulesetConfig[0].weightCutPercent = 0;
+        _rulesetConfig[0].approvalHook = IJBRulesetApprovalHook(address(0));
+        _rulesetConfig[0].metadata = _metadata;
+        _rulesetConfig[0].splitGroups = new JBSplitGroup[](0);
+        _rulesetConfig[0].fundAccessLimitGroups = new JBFundAccessLimitGroup[](0);
+
+        JBTerminalConfig[] memory _terminalConfigurations = new JBTerminalConfig[](1);
+        JBAccountingContext[] memory _tokensToAccept = new JBAccountingContext[](2);
+        _tokensToAccept[0] = JBAccountingContext({
+            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+        });
+        _tokensToAccept[1] = JBAccountingContext({
+            token: address(usdcToken()), decimals: 6, currency: uint32(uint160(address(usdcToken())))
+        });
+        _terminalConfigurations[0] =
+            JBTerminalConfig({terminal: _terminal, accountingContextsToAccept: _tokensToAccept});
+
+        // Create a first project to collect fees.
+        _controller.launchProjectFor({
+            owner: _projectOwner,
+            projectUri: "myIPFSHash",
+            rulesetConfigurations: _rulesetConfig,
+            terminalConfigurations: _terminalConfigurations,
+            memo: ""
+        });
+
+        _projectId = _controller.launchProjectFor({
+            owner: _projectOwner,
+            projectUri: "myIPFSHash",
+            rulesetConfigurations: _rulesetConfig,
+            terminalConfigurations: _terminalConfigurations,
+            memo: ""
+        });
+
+        vm.startPrank(_projectOwner);
+        MockPriceFeed _priceFeedNativeUsd = new MockPriceFeed(_nativePricePerUsd, 18);
+        vm.label(address(_priceFeedNativeUsd), "Mock Price Feed Native-USD");
+
+        _controller.addPriceFeed({
+            projectId: _projectId,
+            pricingCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            unitCurrency: uint32(uint160(address(usdcToken()))),
+            feed: _priceFeedNativeUsd
+        });
+
+        vm.stopPrank();
+    }
+
+    function testFuzzPayPermit2(uint256 _coins, uint256 _expiration, uint256 _deadline) public {
+        // Setup: set fuzz boundaries.
+        _coins = bound(_coins, 0, uint256(type(uint160).max) + 1);
+        _expiration = bound(_expiration, block.timestamp + 1, type(uint48).max - 1);
+        _deadline = bound(_deadline, block.timestamp + 1, type(uint256).max - 1);
+
+        // Setup: prepare permit details for signing.
+        IAllowanceTransfer.PermitDetails memory details = IAllowanceTransfer.PermitDetails({
+            token: address(_usdc), amount: uint160(_coins), expiration: uint48(_expiration), nonce: 0
+        });
+
+        IAllowanceTransfer.PermitSingle memory permit =
+            IAllowanceTransfer.PermitSingle({details: details, spender: address(_terminal), sigDeadline: _deadline});
+
+        // Setup: sign permit details.
+        bytes memory sig = getPermitSignature(permit, fromPrivateKey, DOMAIN_SEPARATOR);
+
+        JBSingleAllowance memory permitData = JBSingleAllowance({
+            sigDeadline: _deadline,
+            amount: uint160(_coins),
+            expiration: uint48(_expiration),
+            nonce: uint48(0),
+            signature: sig
+        });
+
+        // Setup: prepare data for metadata helper.
+        bytes4[] memory _ids = new bytes4[](1);
+        bytes[] memory _datas = new bytes[](1);
+        _datas[0] = abi.encode(permitData);
+        _ids[0] = _helper.getId("permit2", address(_terminal));
+
+        // Setup: use the metadata library to encode.
+        bytes memory _packedData = _helper.createMetadata(_ids, _datas);
+
+        // Setup: give coins and approve permit2 contract.
+        deal(address(_usdc), from, _coins);
+        vm.prank(from);
+        IERC20(address(_usdc)).approve(address(permit2()), _coins);
+
+        if (_coins == uint256(type(uint160).max) + 1) {
+            vm.expectRevert(
+                abi.encodeWithSelector(JBMultiTerminal.JBMultiTerminal_PermitAllowanceNotEnough.selector, _coins, 0)
+            );
+        }
+
+        vm.prank(from);
+        uint256 _minted = _terminal.pay({
+            projectId: _projectId,
+            amount: _coins,
+            token: address(_usdc),
+            beneficiary: from,
+            minReturnedTokens: 0,
+            memo: "Take my permitted money!",
+            metadata: _packedData
+        });
+
+        if (_coins < uint256(type(uint160).max) + 1) {
+            // Check: that tokens were transfered.
+            assertEq(_usdc.balanceOf(address(_terminal)), _coins);
+
+            // Check: that payer receives project token/balance.
+            assertEq(_tokens.totalBalanceOf(from, _projectId), _minted);
+        }
+    }
+
+    function testFuzzAddToBalancePermit2(uint256 _coins, uint256 _expiration, uint256 _deadline) public {
+        // Setup: set fuzz boundaries.
+        _coins = bound(_coins, 0, uint256(type(uint160).max) + 1);
+        _expiration = bound(_expiration, block.timestamp + 1, type(uint48).max - 1);
+        _deadline = bound(_deadline, block.timestamp + 1, type(uint256).max - 1);
+
+        // Setup: prepare permit details for signing.
+        IAllowanceTransfer.PermitDetails memory details = IAllowanceTransfer.PermitDetails({
+            token: address(_usdc), amount: uint160(_coins), expiration: uint48(_expiration), nonce: 0
+        });
+
+        IAllowanceTransfer.PermitSingle memory permit =
+            IAllowanceTransfer.PermitSingle({details: details, spender: address(_terminal), sigDeadline: _deadline});
+
+        // Setup: sign permit details.
+        bytes memory sig = getPermitSignature(permit, fromPrivateKey, DOMAIN_SEPARATOR);
+
+        JBSingleAllowance memory permitData = JBSingleAllowance({
+            sigDeadline: _deadline,
+            amount: uint160(_coins),
+            expiration: uint48(_expiration),
+            nonce: uint48(0),
+            signature: sig
+        });
+
+        // Setup: prepare data for metadata helper.
+        bytes4[] memory _ids = new bytes4[](1);
+        bytes[] memory _datas = new bytes[](1);
+        _datas[0] = abi.encode(permitData);
+        _ids[0] = _helper.getId("permit2", address(_terminal));
+
+        // Setup: use the metadata library to encode.
+        bytes memory _packedData = _helper.createMetadata(_ids, _datas);
+
+        // Setup: give coins and approve permit2 contract.
+        deal(address(_usdc), from, _coins);
+        vm.prank(from);
+        IERC20(address(_usdc)).approve(address(permit2()), _coins);
+
+        if (_coins == uint256(type(uint160).max) + 1) {
+            vm.expectRevert(
+                abi.encodeWithSelector(JBMultiTerminal.JBMultiTerminal_PermitAllowanceNotEnough.selector, _coins, 0)
+            );
+        }
+
+        // Test: add to balance using permit2 data, which should transfer tokens.
+        vm.prank(from);
+        _terminal.addToBalanceOf(_projectId, address(_usdc), _coins, false, "testing permit2", _packedData);
+
+        // Check: that tokens were transferred.
+        if (_coins < uint256(type(uint160).max) + 1) assertEq(_usdc.balanceOf(address(_terminal)), _coins);
+    }
+
+    function testPayAmountGtMaxPermit() public {
+        // Setup: refs
+        uint160 _permitAmount = type(uint160).max;
+        uint256 _payAmount = type(uint256).max;
+        uint256 _sigDeadline = block.timestamp + 1;
+        uint48 _expiration = type(uint48).max;
+        uint48 _nonce = 0;
+
+        // Setup: prepare permit details for signing.
+        IAllowanceTransfer.PermitDetails memory details = IAllowanceTransfer.PermitDetails({
+            token: address(_usdc), amount: _permitAmount, expiration: _expiration, nonce: 0
+        });
+
+        IAllowanceTransfer.PermitSingle memory permit =
+            IAllowanceTransfer.PermitSingle({details: details, spender: address(_terminal), sigDeadline: _sigDeadline});
+
+        // Setup: sign permit details.
+        bytes memory sig = getPermitSignature(permit, fromPrivateKey, DOMAIN_SEPARATOR);
+
+        JBSingleAllowance({
+            sigDeadline: _sigDeadline, amount: _permitAmount, expiration: _expiration, nonce: _nonce, signature: sig
+        });
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBMultiTerminal.JBMultiTerminal_OverflowAlert.selector, _payAmount, type(uint160).max
+            )
+        );
+
+        vm.prank(from);
+        _terminal.pay({
+            projectId: _projectId,
+            amount: _payAmount,
+            token: address(_usdc),
+            beneficiary: from,
+            minReturnedTokens: 0,
+            memo: "Take my permitted money!",
+            metadata: ""
+        });
+    }
+
+    /// Permit2 signature helpers.
+    /// (required because `permit2/test/utils/PermitSignature.sol` imports `draft-EIP712.sol` which is no longer a
+    /// draft.)
+
+    bytes32 public constant _PERMIT_DETAILS_TYPEHASH =
+        keccak256("PermitDetails(address token,uint160 amount,uint48 expiration,uint48 nonce)");
+
+    bytes32 public constant _PERMIT_SINGLE_TYPEHASH = keccak256(
+        "PermitSingle(PermitDetails details,address spender,uint256 sigDeadline)PermitDetails(address token,uint160 amount,uint48 expiration,uint48 nonce)"
+    );
+
+    bytes32 public constant _PERMIT_BATCH_TYPEHASH = keccak256(
+        "PermitBatch(PermitDetails[] details,address spender,uint256 sigDeadline)PermitDetails(address token,uint160 amount,uint48 expiration,uint48 nonce)"
+    );
+
+    bytes32 public constant _TOKEN_PERMISSIONS_TYPEHASH = keccak256("TokenPermissions(address token,uint256 amount)");
+
+    bytes32 public constant _PERMIT_TRANSFER_FROM_TYPEHASH = keccak256(
+        "PermitTransferFrom(TokenPermissions permitted,address spender,uint256 nonce,uint256 deadline)TokenPermissions(address token,uint256 amount)"
+    );
+
+    bytes32 public constant _PERMIT_BATCH_TRANSFER_FROM_TYPEHASH = keccak256(
+        "PermitBatchTransferFrom(TokenPermissions[] permitted,address spender,uint256 nonce,uint256 deadline)TokenPermissions(address token,uint256 amount)"
+    );
+
+    function getPermitSignatureRaw(
+        IAllowanceTransfer.PermitSingle memory permit,
+        uint256 privateKey,
+        bytes32 domainSeparator
+    )
+        internal
+        pure
+        returns (uint8 v, bytes32 r, bytes32 s)
+    {
+        bytes32 permitHash = keccak256(abi.encode(_PERMIT_DETAILS_TYPEHASH, permit.details));
+
+        bytes32 msgHash = keccak256(
+            abi.encodePacked(
+                "\x19\x01",
+                domainSeparator,
+                keccak256(abi.encode(_PERMIT_SINGLE_TYPEHASH, permitHash, permit.spender, permit.sigDeadline))
+            )
+        );
+
+        (v, r, s) = vm.sign(privateKey, msgHash);
+    }
+
+    function getPermitSignature(
+        IAllowanceTransfer.PermitSingle memory permit,
+        uint256 privateKey,
+        bytes32 domainSeparator
+    )
+        internal
+        pure
+        returns (bytes memory sig)
+    {
+        (uint8 v, bytes32 r, bytes32 s) = getPermitSignatureRaw(permit, privateKey, domainSeparator);
+        return bytes.concat(r, s, bytes1(v));
+    }
+}