Errors

error NotASettlement()

modifier onlySettlement() {
    if (msg.sender != settlement) {
        revert NotASettlement();
    }
    _;
}

function execute(Hook[] calldata hooks) external onlySettlement {
    // Hook execution logic
}

// Settlement contract calls trampoline
address trampoline = 0x1234...;
address settlement = 0x9008D19f58AAbD9eD0D60971565AA8510560ab41;

// From settlement contract context:
HooksTrampoline(trampoline).execute(hooks); // Success

// User or other contract tries to call trampoline directly
address trampoline = 0x1234...;
address user = 0x5678...;

// From user context:
HooksTrampoline(trampoline).execute(hooks); // Reverts with NotASettlement()

try HooksTrampoline(trampoline).execute(hooks) {
    // Hooks executed successfully
} catch (bytes memory reason) {
    // Check if error is NotASettlement
    if (reason.length == 4) {
        bytes4 errorSelector = bytes4(reason);
        bytes4 notSettlementSelector = HooksTrampoline.NotASettlement.selector;

        if (errorSelector == notSettlementSelector) {
            // Handle NotASettlement error
            revert("Unauthorized: Only settlement can execute hooks");
        }
    }
}

// Get the error selector for NotASettlement
bytes4 selector = HooksTrampoline.NotASettlement.selector;
// selector: 0x... (4-byte selector)

// WRONG: Don't do this
function myFunction() external {
    HooksTrampoline(trampoline).execute(hooks); // Will revert!
}

// RIGHT: Let settlement contract call trampoline
// Instead, create an order with hooks, and implement a hook target:
contract MyHookTarget {
    function onTrade(address token, uint256 amount) external {
        // This will be called BY the trampoline
        // DURING settlement execution
        // Your logic here
    }
}

// In your test file
function testHookExecution() public {
    address settlement = 0x9008D19f58AAbD9eD0D60971565AA8510560ab41;
    HooksTrampoline trampoline = new HooksTrampoline(settlement);

    Hook[] memory hooks = new Hook[](1);
    hooks[0] = Hook({
        target: address(hookTarget),
        callData: abi.encodeWithSignature("onTrade()"),
        gasLimit: 50000
    });

    // Simulate call from settlement contract
    vm.prank(settlement);
    trampoline.execute(hooks); // Success

    // Call from other address should fail
    vm.prank(address(this));
    vm.expectRevert(HooksTrampoline.NotASettlement.selector);
    trampoline.execute(hooks); // Reverts
}

// If hook.gasLimit exceeds available gas
// The trampoline will revert by wasting all remaining gas
function execute(Hook[] calldata hooks) external onlySettlement {
    // ...
    uint256 forwardedGas = gasleft() * 63 / 64;
    if (forwardedGas < hook.gasLimit) {
        revertByWastingGas(); // Consumes all gas
    }
    // ...
}

// Hook target reverts
contract MyHookTarget {
    function onTrade() external {
        revert("Something went wrong");
    }
}

// In trampoline: revert is caught
(bool success,) = hook.target.call{gas: hook.gasLimit}(hook.callData);
// success will be false, but execution continues
success; // Explicitly ignoring the result