The Web3 safe deployment service has suspended registration. Your mission: break in and crack the safe! NOTE: RPC Address (10.137.0.24) is incorrect. Replace it with address of your task when connecting to MetaMask

Hints (4/4)
If the OTP doesn't arrive, what is actually being limited — a single account or a series of attempts?
Updating a profile — is it always a dangerous operation?
If you need information, go directly to the source.
Something is wrong with the signatures...

{{p(data_0)}}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

contract SafeVault {
    uint256 public constant THRESHOLD = 2;

    string public label;
    uint256 public nonce;
    address[3] private _owners;
    mapping(address => bool) public isOwner;
    mapping(address => mapping(address => uint256)) public allowances;

    event Deposit(address indexed from, uint256 amount);
    event AllowanceSet(address indexed owner, address indexed spender, uint256 amount);
    event AllowanceSpent(address indexed owner, address indexed spender, address indexed to, uint256 amount);
    event WithdrawalExecuted(
        address indexed relayer,
        address indexed to,
        uint256 amount,
        bytes32 operationHash,
        address signerOne,
        address signerTwo
    );

    constructor(address[3] memory owners_, string memory label_) payable {
        label = label_;
        for (uint256 i = 0; i < owners_.length; i++) {
            address owner = owners_[i];
            require(owner != address(0), "owner");
            require(!isOwner[owner], "duplicate");
            isOwner[owner] = true;
            _owners[i] = owner;
        }
        if (msg.value > 0) {
            emit Deposit(msg.sender, msg.value);
        }
    }

    receive() external payable {
        emit Deposit(msg.sender, msg.value);
    }

    function owners() external view returns (address[3] memory) {
        return _owners;
    }

    function setAllowance(address spender, uint256 amount) external {
        require(isOwner[msg.sender], "owner");
        allowances[msg.sender][spender] = amount;
        emit AllowanceSet(msg.sender, spender, amount);
    }

    function spendAllowance(address owner, address payable to, uint256 amount) external {
        uint256 allowed = allowances[owner][msg.sender];
        require(allowed >= amount, "allowance");
        unchecked {
            allowances[owner][msg.sender] = allowed - amount;
        }
        (bool ok, ) = to.call{value: amount}("");
        require(ok, "send");
        emit AllowanceSpent(owner, msg.sender, to, amount);
    }

    function operationHash(address to, uint256 amount, uint256 nonceValue) public view returns (bytes32) {
        return keccak256(abi.encode(address(this), block.chainid, to, amount, nonceValue));
    }

    function prefixedOperationHash(address to, uint256 amount, uint256 nonceValue) public view returns (bytes32) {
        bytes32 rawHash = operationHash(to, amount, nonceValue);
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", rawHash));
    }

    function executeWithdraw(address payable to, uint256 amount, bytes[] calldata signatures) external {
        require(signatures.length == THRESHOLD, "threshold");
        require(keccak256(signatures[0]) != keccak256(signatures[1]), "duplicate signature");
        bytes32 digest = prefixedOperationHash(to, amount, nonce);
        address signerOne = recover(digest, signatures[0]);
        address signerTwo = recover(digest, signatures[1]);
        require(isOwner[signerOne], "signer one");
        require(isOwner[signerTwo], "signer two");
        nonce += 1;
        (bool ok, ) = to.call{value: amount}("");
        require(ok, "send");
        emit WithdrawalExecuted(msg.sender, to, amount, digest, signerOne, signerTwo);
    }

    function recover(bytes32 digest, bytes memory signature) internal pure returns (address) {
        require(signature.length == 65, "sig length");
        bytes32 r;
        bytes32 s;
        uint8 v;
        assembly {
            r := mload(add(signature, 0x20))
            s := mload(add(signature, 0x40))
            v := byte(0, mload(add(signature, 0x60)))
        }
        if (v < 27) {
            v += 27;
        }
        require(v == 27 || v == 28, "sig v");
        return ecrecover(digest, v, r, s);
    }
}

0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266

0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80