// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.22;

import {VerifySignatureUtil as SigUtil} from "../libraries/VerifySignatureUtil.sol";

import {Diamond} from "../Diamond.sol";
import {COWSManagement} from "../COWSManagement.sol";

import {IGlobalState} from "../interfaces/IGlobalState.sol";
import {GlobalStateFacet} from "../facets/GlobalStateFacet.sol";

import {ICustodyWallet} from "../interfaces/ICustodyWallet.sol";
import {CustodyWalletFacet} from "../facets/CustodyWalletFacet.sol";

import {IDASManagement} from "../interfaces/IDASManagement.sol";
import {DASManagementFacet} from "../facets/DASManagementFacet.sol";

import {IDirectDeposit} from "../interfaces/IDirectDeposit.sol";
import {DirectDepositFacet} from "../facets/DirectDepositFacet.sol";

import {IKeyManagement} from "../interfaces/IKeyManagement.sol";

/// @notice This struct is used to hold all COWS container related storage to be used by all facets. This struct must always be put at slot 1 in storage to allow the use of shared storage.
/// @dev These are are the values included within the shared storage for containers*:
///       - **cowsManagement** _{COWSManagement}_: address of the COWSManagement contract registers this COWS container
///       - **globalState** _{IGlobalState.COWSState}_: state of the whole container _(eg. `ActiveNormal` or `Recognized`)_
///       - **cowId** _{byte32}_: unique identifier that represents this specific container
///       - **requestIds** _{mapping(bytes32 => bool)}_: mapping of `requestId` to boolean to dictate if the request has been used yet
///       - **dasStatus** _{mapping(address => IDASManagement.DASStatus)}_: mapping of `dasAddress` to DASStatus
///       - **directDeposits** _{mapping(bytes32 => bytes)}_: mapping of `requestId` to signature used to call `directDeposit()`
///       - **complianceUserKeys** _{mapping(bytes32 => IKeyManagement.UserKeys)}_: mapping of userId to UserKeys
///       - **totalActiveUsers** _{uint256}_: total amount of approvers _(cannot be less than **5**)_
///       - **interventionKeys** _{mapping(address => IKeyManagement.KeyStatus)}_: mapping to dictate what `KeyStatus` a specific `interventionKey` is in
///       - **totalActiveInterventionKeys** _{uint8}_: total amount of intervention keys _(cannot be less than **1**)_
///       - **castlKeys** _{mapping(address => IKeyManagement.KeyStatus)}_: mapping to dictate what `KeyStatus` a specific `castlKey` is in
///       - **isUserKeyUsed** _{mapping(address => bool)}_: mapping to dictate if a user key has been used or not
///       - **emergencyKeyReplacements** _{mapping(bytes32 => IKeyManagement.EmergencyReplacement)}_: mapping of `requestId` to EmergencyReplacement
///       - **activeEmgRequestId** _{bytes32}_: unique identifier that represents current active emergency replacement request
///       - **initiator** _{bytes}_: signature used when `init()` was called
///       - **totalActiveCastlKeys** _{uint8}_: total amount of active castl keys
///
///  <br /><br />*See [Diamond](/src/Diamond.sol/contract.Diamond.html) for more information on shared storage and the Diamond proxy pattern.
struct AppStorage {
  /** ---- External Contracts ---- **/
  COWSManagement cowsManagement;
  /** ------------------------- **/

  /** ---- GlobalState ---- **/
  IGlobalState.COWSState globalState;
  bytes32 cowId;
  mapping(bytes32 => bool) requestIds;
  /** --------------------- **/

  /** ---- DASManagement ---- **/
  mapping(address => IDASManagement.DASStatus) dasStatus;
  /** ----------------------- **/

  /** ---- DirectDeposit ---- **/
  mapping(bytes32 => bytes) directDeposits;
  /** ----------------------- **/

  /** ---- KeyManagement ---- **/
  mapping(bytes32 => IKeyManagement.UserKeys) complianceUserKeys;
  uint256 totalActiveUsers;
  mapping(address => bool) isUserKeyUsed;
  mapping(address => IKeyManagement.KeyStatus) interventionKeys;
  uint8 totalActiveInterventionKeys;
  mapping(address => IKeyManagement.KeyStatus) castlKeys;
  mapping(bytes32 => IKeyManagement.EmergencyReplacement) emergencyKeyReplacements;
  bytes32 activeEmgRequestId;
  bytes initiator;
  uint8 totalActiveCastlKeys;
  /** ----------------------- **/
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.22;

import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
import {VerifySignatureUtil as SigUtil} from "./libraries/VerifySignatureUtil.sol";

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IFunctions} from "./interfaces/IDiamond.sol";

import {IGlobalState} from "./interfaces/IGlobalState.sol";
import {IKeyManagement} from "./interfaces/IKeyManagement.sol";

import {GlobalStateFacet} from "./facets/GlobalStateFacet.sol";
import {KeyMgmtUtil} from "./libraries/KeyMgmtUtil.sol";
import {KeyManagementStoreFacet} from "./facets/KeyManagementStoreFacet.sol";

/// @title COWS Management
/// @author Prometheum Inc.
/// @notice This contract is responsible for managing proxy contract addresses that represent COWS Containers. Check <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139919/Structure+Overview#COWSManagement-Contract)</b> for more concept details.
contract COWSManagement {
  using Strings for *;

  /// @notice Types of COWS containers
  enum AccountType {
    Empty,
    Omnibus,
    Investigation,
    Garbage,
    Firmwallet
  }

  /// @notice Status of COWS management keys
  enum KeyStatus {
    Nonexistent,
    Enabled,
    Expired,
    Inactive
  }

  /// @notice Contains information about the COWS container
  /// @dev [**accountType**](#accounttype) : type of the COWS container<br />**contractAddress** : address of proxy contract that represent COWS Container
  struct ContainerInfo {
    AccountType accountType;
    address contractAddress;
  }

  /// @notice Given a specific key {address} that is used to deploy this contract and be part of recognizing COWS container, returns its {[KeyStatus](#keystatus)}
  mapping(address => KeyStatus) public cowsManagementKeys;

  /// @notice Return number {uint8} of inactive COWS management keys left can be used
  uint8 public cmgtKeyLeft;

  /// @notice Given a specific COWS ID {bytes32}, returns its relevant container information {[ContainerInfo](#containerinfo)}
  mapping(bytes32 => ContainerInfo) internal cowsContainers;

  /// @notice Given a specific container {address}, returns its COWS ID {bytes32}
  mapping(address => bytes32) internal containerIds;

  /// @notice Given a specific COWS ID {bytes32}, returns the signature used to recognize that container {bytes}
  mapping(bytes32 => bytes) internal recognizeRecords;

  /// @notice  Given a specific request ID {bytes32}, returns boolean value to indicate whether it's used or not
  mapping(bytes32 => bool) internal cowsMgmtRequests;

  /// @notice Number of total active containers
  uint8 public totalActiveContainers;

  /// @notice The **Recognize** event is emitted at the end of the [`recognize()`](#recognize) function
  event Recognize();

  /// @notice The **COWSAction** event is emitted at the end of the [`pauseCOWS`](#pauseCOWS), and [`unpauseCOWS`](#unpauseCOWS) functions
  /// @dev **requestId** : unique identifier used for record keeping
  /// @dev **actionType** : type of action that was taken when this event was emitted
  /// @dev **cowId** : identifier of the container that was actioned on
  event COWSAction(bytes32 requestId, string actionType, bytes32 cowId);

  /// @notice The **SwitchCmgtKey** event is emitted at the end of the [`switchCowsManagementKey()`](#switchCowsManagementKey) function
  /// @dev **keyLeft** : amount of cows management keys left after the switch function has executed
  event SwitchCmgtKey(uint8 keyLeft);

  /// @notice sets `cowsManagementKeys` when the contract is deployed
  constructor(address[] memory _cowsManagementKeys) {
    uint8 cowsmanagementKeysLength = uint8(_cowsManagementKeys.length);
    require(cowsmanagementKeysLength > 0, "no cowsMgmt keys were given");

    cowsManagementKeys[_cowsManagementKeys[0]] = KeyStatus.Enabled;

    uint8 _cmgtKeyLeft;
    for (uint256 i = 1; i < cowsmanagementKeysLength; ) {
      require(
        cowsManagementKeys[_cowsManagementKeys[i]] == KeyStatus.Nonexistent,
        "duplicate keys are found"
      );
      cowsManagementKeys[_cowsManagementKeys[i]] = KeyStatus.Inactive;

      unchecked {
        ++i;
        ++_cmgtKeyLeft;
      }
    }
    cmgtKeyLeft = _cmgtKeyLeft;
  }

  /// @notice returns specific information about a given container related to `cowId`
  /// @param cowId unique identifier for a specific COWS container
  /// @return containerInfo information associated to the specific container `cowId`
  function getContainerInfo(
    bytes32 cowId
  ) external view returns (ContainerInfo memory containerInfo) {
    return cowsContainers[cowId];
  }

  /// @notice returns the 'cowId' of a specified 'container' address
  /// @param container address of the container
  /// @return cowId unique identifier to represent the container
  function getCowId(address container) external view returns (bytes32 cowId) {
    return containerIds[container];
  }

  /// @notice returns signature used to recognize the given COWS ID
  /// @param cowId unique identifier for a specific COWS container
  /// @return signature signature used in `recognize()` call
  function getRecognizeRecord(bytes32 cowId) external view returns (bytes memory signature) {
    return recognizeRecords[cowId];
  }

  /// @notice Returns a boolean value whether a specific request ID is used from 'cowsMgmtRequests'
  /// @param requestId the unique identifier of all kind requests within the `COWSManagement`
  function isReqIdUsed(bytes32 requestId) external view returns (bool isUsed) {
    isUsed = cowsMgmtRequests[requestId];
  }

  /// @notice Returns a boolean value whether a specific address is an Enabled cowsManagement key from `cowsManagementKeys`
  /// @param keyAddress the key address to be checked
  function isCowsManagementKey(address keyAddress) public view returns (bool isEnabled) {
    isEnabled = cowsManagementKeys[keyAddress] == KeyStatus.Enabled;
  }

  /// @dev Checks whether or not '_contract' is a contract or not
  /// @param _contract address to check whether it's a contract or not
  function _isContract(address _contract) internal view returns (bool isContract) {
    uint256 containerCodeSize;
    assembly {
      containerCodeSize := extcodesize(_contract)
    }
    return (containerCodeSize > 0);
  }

  /// @notice This function is used to verify CASTL and Approver signatures for all of the COWSManagement functions (eg. `pauseCOWS()`, `unpauseCOWS()`, etc...)
  /// @param cowId unique identifier for COWS container
  /// @param expiredAt block timestamp to expire each signature
  /// @param requestId unique identifier used to form messages and prevent replays
  /// @param castlSignature signature signed by CASTL using the 'methodType' message format
  /// @param approvalSignatures signatures from approvers using the 'methodType' message format. Also contains 'userId'
  /// @param methodType string to dictate the 'methodType' used in the formed message format
  function _verifyCOWSActionMsgs(
    bytes32 cowId,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures,
    string memory methodType
  ) internal view {
    IFunctions container = IFunctions(cowsContainers[cowId].contractAddress);

    uint256 approvalSignaturesLength = approvalSignatures.length;
    require(
      approvalSignaturesLength > 2 && approvalSignaturesLength < 6,
      "invalid signature amount"
    );

    // Form message of common parts
    string[] memory parts = new string[](4); // Preallocating 4 string slots in memory
    parts[0] = SigUtil.bytesToHex(cowId); // cowsId
    parts[1] = methodType; // methodType

    if (
      IFunctions(cowsContainers[cowId].contractAddress).getGlobalState() !=
      IGlobalState.COWSState.ActiveEmergency ||
      castlSignature.length != 0
    ) {
      require(castlSignature.length != 0, "required castl sig");

      // Form CASTL message for 3 of 5
      parts[2] = approvalSignaturesLength.toString(); // totalSigNum
      parts[3] = SigUtil.concatApproverSignatures(approvalSignatures); // approvalSignatures

      // Verify castl key
      address castlKey = SigUtil.verifySignature(
        castlSignature,
        SigUtil.formatMessageWithDelimiter(parts)
      );

      require(
        container.getCASTLKey(castlKey) == IKeyManagement.KeyStatus.Enabled,
        "invalid castl sig"
      );
    }

    // Check for duplicate approval userIds or signatures
    SigUtil._checkNoDupes(approvalSignatures);

    // Prepare the relevant hash raw for each approver message
    parts[2] = expiredAt.toString(); // expiredAt

    // If no requestId is passed, remove from message
    if (requestId == bytes32(0)) {
      SigUtil.shrinkStrArray(parts, 3); // Shrink 'parts' to 3

      // Form the hash raw, hash it with keccak256, cast it to its string representation, then set it to parts[1]
      parts[1] = SigUtil.bytesToHex(keccak256(bytes(SigUtil.formatMessageWithDelimiter(parts))));
    } else {
      parts[3] = SigUtil.bytesToHex(requestId); // requestId

      // Form the hash raw, hash it with keccak256, cast it to its string representation, then set it to parts[1]
      parts[1] = SigUtil.bytesToHex(keccak256(bytes(SigUtil.formatMessageWithDelimiter(parts))));
    }
    SigUtil.shrinkStrArray(parts, 2); // Shrink 'parts' to 2

    // At this point, 'parts' looks like this:
    // [cowId, methodTypel, hashRaw]
    // 'cowId' and 'methodType' will be replaced with each approver's 'userId' in 'verifyApproverSignature' within the loop
    for (uint256 i; i < approvalSignaturesLength; ) {
      address approvalKey = SigUtil.verifyApproverSignature(parts, approvalSignatures[i]);
      require(
        container.isValidApprovalAddress(approvalSignatures[i].userId, approvalKey),
        "invalid approver sig"
      );
      unchecked {
        ++i;
      }
    }
  }

  /// @notice This function is used by COWS management key & CASTL to recognize a deployed COWS contract suite and shows intent to initialize it
  /// @param cowId unique identifier for COWS container to recognize
  /// @param accountType account type of the specific COWS container
  /// @param containerAddress diamond proxy address for the specific COWS container
  /// @param prevActiveCowId unique identifier for a previous active COWS container. Used to form the message signed in `prevActiveCastlSignature`
  /// @param expiredAt block timestamp when 'cowsMgmtKeySignature' and 'prevActiveCastlSignature' expires
  /// @param cowsMgmtKeySignature signature signed by COWS management key with the following message format: `"{cowId}//recognize//{accountType}//{containerAddress}//"`
  /// @param castlSignature signature signed by CASTL key with the following message format: `"{cowId}//recognize//{accountType}//{containerAddress}//cowsMgmtKeySignature//prevActiveCastlSignature//"`
  /// @param prevActiveCastlSignature previous active CASTL signature signed by an active CASTL key with the following message format: `"{cowId}//recognize//{accountType}//{containerAddress}//"`
  function recognize(
    bytes32 cowId,
    AccountType accountType,
    address containerAddress,
    bytes32 prevActiveCowId,
    uint256 expiredAt,
    bytes calldata cowsMgmtKeySignature,
    bytes calldata castlSignature,
    bytes calldata prevActiveCastlSignature
  ) external {
    require(expiredAt > block.timestamp, "expired request");

    // Check if the cowId is already existed in recognizeRecords
    require(recognizeRecords[cowId].length == 0, "cow id is recognized");

    // Check that the container's internal cowId matches the passed in 'cowId'
    {
      require(_isContract(containerAddress), "invalid contract");

      // a low level call is used to prevent a generic evm revert on uniplemented methods on 'containerAddress'
      // staticcall is used to prevent any possible state changes
      (bool success, bytes memory data) = containerAddress.staticcall(
        abi.encodeWithSelector(IGlobalState.getCowId.selector)
      );

      require(success, "invalid contract");
      require(abi.decode(data, (bytes32)) == cowId, "invalid cowId");
    }

    {
      string[] memory sharedParts = new string[](7);
      SigUtil.shrinkStrArray(sharedParts, 5); // Shrink to length of 5 to form cowsMgmtSig message

      // Form signing message for cowsMgmtKeySignature
      {
        sharedParts[0] = SigUtil.bytesToHex(cowId); // cowsId
        sharedParts[1] = "recognize"; // methodType
        sharedParts[2] = uint256(accountType).toString(); // accountType
        sharedParts[3] = containerAddress.toHexString(); // containerAddress
        sharedParts[4] = expiredAt.toString(); // expiredAt

        // Check if recovered signer is a valid cowsMgmtKeyAddr
        address cowsMgmtKeyAddr = SigUtil.verifySignature(
          cowsMgmtKeySignature,
          SigUtil.formatMessageWithDelimiter(sharedParts)
        );

        require(isCowsManagementKey(cowsMgmtKeyAddr), "invalid cowsMgmt sig");
      }

      // Check if there are any active containers, if none form the CASTL message with cowsMgmtKeySignature
      if (totalActiveContainers == 0) {
        // Form signing message for castlSignature
        assembly {
          mstore(sharedParts, 6) // Set 'sharedParts' length to 6
        }

        sharedParts[5] = SigUtil.signatureToString(cowsMgmtKeySignature); // cowsMgmtKeySignature
      } else {
        // If there is a previous active CASTL Key, use it in the formed message
        IFunctions prevActiveContainer = IFunctions(
          cowsContainers[prevActiveCowId].contractAddress
        );

        require(address(prevActiveContainer) != address(0), "invalid prev cowId");

        require(prevActiveContainer.getTotalActiveCASTLKeys() > 0, "No Active CASTL Keys.");

        require(
          prevActiveContainer.getGlobalState() != IGlobalState.COWSState.Deployed,
          "invalid prev global state"
        );

        // Check if previously used castlKey is valid
        address prevCastlKey = SigUtil.verifySignature(
          prevActiveCastlSignature,
          SigUtil.formatMessageWithDelimiter(sharedParts)
        );

        require(
          prevActiveContainer.getCASTLKey(prevCastlKey) == IKeyManagement.KeyStatus.Enabled,
          "invalid prevActiveCastl sig"
        );

        assembly {
          mstore(sharedParts, 7) // Set 'parts' length to 7
        }

        sharedParts[5] = SigUtil.signatureToString(cowsMgmtKeySignature); // cowsMgmtKeySignature
        sharedParts[6] = SigUtil.signatureToString(prevActiveCastlSignature); // previously used castlSignature
      }

      // Check if previously used castlKey is valid
      address castlKey = SigUtil.verifySignature(
        castlSignature,
        SigUtil.formatMessageWithDelimiter(sharedParts)
      );
      require(
        KeyManagementStoreFacet(containerAddress).getCASTLKey(castlKey) ==
          IKeyManagement.KeyStatus.Enabled,
        "invalid castl sig"
      );
    }

    recognizeRecords[cowId] = castlSignature;

    ContainerInfo storage container = cowsContainers[cowId];
    container.contractAddress = containerAddress;
    container.accountType = accountType;

    containerIds[containerAddress] = cowId;

    // Update totalActiveContainers
    ++totalActiveContainers;

    IFunctions(containerAddress).setGlobalState(IGlobalState.COWSState.Recognized);

    // Emit event Recognize()
    emit Recognize();
  }

  /// @notice This function is used to pause a COWS container, and temporarily prevent asset/custody actions
  /// @param cowId unique identifier for COWS container to pause. Used to form the message signed in `castlSignature`
  /// @param expiredAt block timestamp when 'castlSignature' and each 'approvalSignatures' expires
  /// @param requestId unique identifier used to form messages and prevent replays
  /// @param castlSignature castl signature for verification
  /// @param approvalSignatures 3 of 5 approval signatures for verification
  function pauseCOWS(
    bytes32 cowId,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external {
    address containerAddress = cowsContainers[cowId].contractAddress;
    require(containerAddress != address(0), "invalid cowId");

    require(
      GlobalStateFacet(containerAddress).getGlobalState() == IGlobalState.COWSState.ActiveNormal,
      "invalid global state"
    );

    require(expiredAt > block.timestamp, "expired request");

    require(!cowsMgmtRequests[requestId], "request already used");

    // Verify CASTL and approver messages using the 'pauseCOWS' message format
    _verifyCOWSActionMsgs(
      cowId,
      expiredAt,
      requestId,
      castlSignature,
      approvalSignatures,
      "pauseCOWS"
    );

    cowsMgmtRequests[requestId] = true;

    GlobalStateFacet(containerAddress).setGlobalState(IGlobalState.COWSState.Paused);

    emit COWSAction(requestId, "Pause", cowId);
  }

  /// @notice This function is used to unpause a specific COWS container if it's paused
  /// @param cowId unique identifier for the COWS container to be unpaused
  /// @param expiredAt block timestamp when 'castlSignature' and each 'approvalSignatures' expires
  /// @param requestId unique identifier used to form messages and prevent replays
  /// @param castlSignature castl signature for verification
  /// @param approvalSignatures 3 of 5 approval signatures for verification
  function unpauseCOWS(
    bytes32 cowId,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external {
    address containerAddress = cowsContainers[cowId].contractAddress;
    require(containerAddress != address(0), "invalid cowId");

    require(
      GlobalStateFacet(containerAddress).getGlobalState() == IGlobalState.COWSState.Paused,
      "invalid global state"
    );

    require(expiredAt > block.timestamp, "expired request");

    require(!cowsMgmtRequests[requestId], "request already used");

    // Verify CASTL and approver messages using the 'unpauseCOWS' message format
    _verifyCOWSActionMsgs(
      cowId,
      expiredAt,
      requestId,
      castlSignature,
      approvalSignatures,
      "unpauseCOWS"
    );

    cowsMgmtRequests[requestId] = true;

    GlobalStateFacet(containerAddress).setGlobalState(IGlobalState.COWSState.ActiveNormal);

    emit COWSAction(requestId, "Unpause", cowId);
  }

  /// @notice This function is used to expire current active COWS management key and enable 1 inactive COWS management key to be new one if available
  /// @param cowId unique identifier of COWS container that the CASTL key used to sign 'castlSignature' from
  /// @param deprecateKey the current active COWS management key is going to be deprecated with this call
  /// @param enableKey any of inactive COWS management key from 'cowsManagementKeys' is going to be enabled with this call
  /// @param expiredAt block timestamp when 'castlSignature' expires
  /// @param requestId unique identifier used to form messages and prevent replays
  /// @param castlSignature castl signature for verification
  function switchCowsManagementKey(
    bytes32 cowId,
    address deprecateKey,
    address enableKey,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature
  ) external {
    address containerAddress = cowsContainers[cowId].contractAddress;
    require(containerAddress != address(0), "invalid cowId");

    require(
      GlobalStateFacet(containerAddress).getGlobalState() == IGlobalState.COWSState.ActiveNormal,
      "invalid global state"
    );

    require(expiredAt > block.timestamp, "expired request");

    require(!cowsMgmtRequests[requestId], "request already used");

    require(cowsManagementKeys[deprecateKey] == KeyStatus.Enabled, "invalid key status");

    // Verify castlSignature
    {
      string[] memory parts = new string[](6);

      parts[0] = SigUtil.bytesToHex(cowId); // cowsId
      parts[1] = "switchCowsManagementKey"; // methodType
      parts[2] = deprecateKey.toHexString(); // deprecateKey
      parts[3] = enableKey.toHexString(); // enableKey
      parts[4] = expiredAt.toString(); // expiredAt
      parts[5] = SigUtil.bytesToHex(requestId); // requestId

      // Check if recovered signer has valid CASTL key;
      address castlKey = SigUtil.verifySignature(
        castlSignature,
        SigUtil.formatMessageWithDelimiter(parts)
      );
      require(
        KeyManagementStoreFacet(containerAddress).getCASTLKey(castlKey) ==
          IKeyManagement.KeyStatus.Enabled,
        "invalid castl sig"
      );
    }

    cowsManagementKeys[deprecateKey] = KeyStatus.Expired;

    // If there's at least 1 available key left
    if (cmgtKeyLeft != 0) {
      // Require `enableKey` exists and currently 'Inactive'
      require(cowsManagementKeys[enableKey] == KeyStatus.Inactive, "invalid key status");

      cowsManagementKeys[enableKey] = KeyStatus.Enabled;
      cmgtKeyLeft--;
    }

    cowsMgmtRequests[requestId] = true;

    emit SwitchCmgtKey(cmgtKeyLeft);
  }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.22;

import {AppStorage} from "../libraries/AppStorage.sol";

import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {VerifySignatureUtil as SigUtil} from "../libraries/VerifySignatureUtil.sol";
import {KeyMgmtUtil} from "../libraries/KeyMgmtUtil.sol";

import {COWSManagement} from "../COWSManagement.sol";

import {ICustodyWallet} from "../interfaces/ICustodyWallet.sol";
import {IGlobalState} from "../interfaces/IGlobalState.sol";
import {IDASManagement} from "../interfaces/IDASManagement.sol";
import {IKeyManagement} from "../interfaces/IKeyManagement.sol";

/// @title Custody Wallet
/// @author Prometheum Inc.
/// @notice This Facet is responsible for all Custodial actions for DAS such as `dasApprovalCheck()` and `withdraw()`. This is the version used for Omnibus containers (for Investigation/Garbage, see [CustodyWalletUnrestrictedFacet](/src/facets/CustodyWalletFacet.sol/contract.CustodyWalletUnrestrictedFacet.html))
contract CustodyWalletFacet is ICustodyWallet {
  /// @notice This is a variable that contains all data used across the entire COWS Container (See [AppStorage](/src/libraries/AppStorage.sol/struct.AppStorage.html)). Data can be accessed by prefixing it s. (eg. bytes32 cowId = s.cowId;)
  AppStorage internal s;

  using Strings for *;

  /// @inheritdoc ICustodyWallet
  function dasApprovalCheck(
    address dasAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external returns (bool isSuccessful) {
    require(expiredAt > block.timestamp, "expired request");

    require(!s.requestIds[requestId], "request already used");

    require(
      s.globalState == IGlobalState.COWSState.ActiveNormal ||
        s.globalState == IGlobalState.COWSState.ActiveEmergency,
      "invalid global state"
    );

    uint256 approvalSignaturesLength = approvalSignatures.length;
    require(
      approvalSignaturesLength > 2 && approvalSignaturesLength < 6,
      "invalid signature amount"
    );

    // Check for duplicate approval userIds or signatures
    SigUtil._checkNoDupes(approvalSignatures);

    {
      // Form message of common parts
      string[] memory parts = new string[](5);
      parts[0] = SigUtil.bytesToHex(s.cowId); // cowsId
      parts[1] = "dasApprovalCheck"; // methodType

      if (
        s.globalState == IGlobalState.COWSState.ActiveNormal ||
        (s.globalState == IGlobalState.COWSState.ActiveEmergency && castlSignature.length != 0)
      ) {
        require(castlSignature.length != 0, "required castl sig");

        // Form CASTL message for 3 of 5
        SigUtil.shrinkStrArray(parts, 4); // Set 'parts' length to 4 to form the CASTL message

        parts[2] = approvalSignaturesLength.toString(); // totalSigNum
        parts[3] = SigUtil.concatApproverSignatures(approvalSignatures); // approvalSignatures

        // Verify CASTL key
        address castlKey = SigUtil.verifySignature(
          castlSignature,
          SigUtil.formatMessageWithDelimiter(parts)
        );
        require(s.castlKeys[castlKey] == IKeyManagement.KeyStatus.Enabled, "invalid castl sig");

        assembly {
          mstore(parts, 5) // Set 'parts' length back to 5
        }
      }

      // Prepare the relevant hash raw for each approver message
      parts[2] = dasAddress.toHexString(); // dasAddress
      parts[3] = expiredAt.toString(); // expiredAt
      parts[4] = SigUtil.bytesToHex(requestId); // requestId

      // Form the hash raw, hash it with keccak256, cast it to its string representation, then set it to parts[1]
      parts[1] = SigUtil.bytesToHex(keccak256(bytes(SigUtil.formatMessageWithDelimiter(parts))));
      SigUtil.shrinkStrArray(parts, 2); // Shrink 'parts' to 2

      // At this point, 'parts' looks like this:
      // cowId//hashRaw
      // 'cowId' will be replaced with each approver's 'userId' in 'verifyApproverSignature' within the loop
      for (uint256 i; i < approvalSignaturesLength; ) {
        address approvalKey = SigUtil.verifyApproverSignature(parts, approvalSignatures[i]);
        require(
          KeyMgmtUtil.verifyApprovalAddress(approvalSignatures[i].userId, approvalKey),
          "invalid approver sig"
        );

        unchecked {
          ++i;
        }
      }
    }

    s.requestIds[requestId] = true;

    // Emit event DASApprovalCheck(requestId, dasAddress, balance)
    emit DASApprovalCheck(
      requestId,
      dasAddress,
      dasAddress == address(0) ? address(this).balance : IERC20(dasAddress).balanceOf(address(this))
    );

    return true;
  }

  /// @inheritdoc ICustodyWallet
  function withdraw(
    address to,
    uint256 amount,
    address dasAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external {
    require(expiredAt > block.timestamp, "expired request");

    require(s.globalState == IGlobalState.COWSState.ActiveNormal, "invalid global state");

    IDASManagement.DASStatus dasStatus = s.dasStatus[dasAddress];

    require(
      dasStatus == IDASManagement.DASStatus.Enabled ||
        dasStatus == IDASManagement.DASStatus.PauseDeposit,
      "invalid DAS status"
    );

    require(!s.requestIds[requestId], "request already used");

    // If 'to' is a COWS container,
    if (s.cowsManagement.getCowId(to) != bytes32(0)) {
      COWSManagement.ContainerInfo memory containerInfo = s.cowsManagement.getContainerInfo(
        s.cowsManagement.getCowId(to)
      );

      // Check global state for any type of container
      IGlobalState.COWSState toGlobalState = IGlobalState(containerInfo.contractAddress)
        .getGlobalState();
      require(toGlobalState == IGlobalState.COWSState.ActiveNormal, "invalid destination state");

      // Check DAS status only for Omnibus container
      if (containerInfo.accountType == COWSManagement.AccountType.Omnibus) {
        require(
          IDASManagement(containerInfo.contractAddress).getDASStatus(dasAddress) ==
            IDASManagement.DASStatus.Enabled,
          "DAS must be enabled"
        );
      }
    }

    uint256 approvalSignaturesLength = approvalSignatures.length;
    require(
      approvalSignaturesLength > 2 && approvalSignaturesLength < 6,
      "invalid signature amount"
    );

    // Check for duplicate approval userIds or signatures
    SigUtil._checkNoDupes(approvalSignatures);

    // Form message of common parts
    string[] memory parts = new string[](7);

    parts[0] = SigUtil.bytesToHex(s.cowId); // cowsId
    parts[1] = "approveWithdrawal"; // methodType

    {
      // Form CASTL message for 3 of 5
      SigUtil.shrinkStrArray(parts, 4); // Set 'parts' length to 4 to form the CASTL message

      parts[2] = approvalSignaturesLength.toString(); // totalSigNum
      parts[3] = SigUtil.concatApproverSignatures(approvalSignatures); // approvalSignatures

      // Verify CASTL key
      address castlKey = SigUtil.verifySignature(
        castlSignature,
        SigUtil.formatMessageWithDelimiter(parts)
      );

      require(s.castlKeys[castlKey] == IKeyManagement.KeyStatus.Enabled, "invalid castl sig");

      assembly {
        mstore(parts, 7) // Set 'parts' length back to 7
      }
    }

    // Prepare the relevant hash raw for each approver message
    parts[2] = dasAddress.toHexString(); // dasAddress
    parts[3] = amount.toString(); // amount
    parts[4] = to.toHexString(); // to
    parts[5] = expiredAt.toString(); // expiredAt
    parts[6] = SigUtil.bytesToHex(requestId); // requestId

    // Form the hash raw, hash it with keccak256, cast it to its string representation, then set it to parts[1]
    parts[1] = SigUtil.bytesToHex(keccak256(bytes(SigUtil.formatMessageWithDelimiter(parts))));

    SigUtil.shrinkStrArray(parts, 2); // Shrink 'parts' to length of 2

    // At this point, 'parts' looks like this:
    // cowId//hashRaw//
    // 'cowId' will be replaced with each approver's 'userId' in 'verifyApproverSignature' within the loop
    for (uint256 i = 0; i < approvalSignaturesLength; ) {
      address approvalKey = SigUtil.verifyApproverSignature(parts, approvalSignatures[i]);
      require(
        KeyMgmtUtil.verifyApprovalAddress(approvalSignatures[i].userId, approvalKey),
        "invalid approver sig"
      );
      unchecked {
        ++i;
      }
    }

    s.requestIds[requestId] = true;

    if (dasAddress == address(0)) {
      (bool sent, ) = payable(to).call{value: amount}("");
      require(sent, "withdraw ETH failed");
    } else {
      require(IERC20(dasAddress).transfer(to, amount), "withdraw DAS failed");
    }

    emit WithdrawalRequest(requestId);
  }
}

/// @title Custody Wallet
/// @author Prometheum Inc.
/// @notice This Facet is responsible for all Custodial actions for DAS such as `dasApprovalCheck()` and `withdraw()`. This is the version used for Investigation/Garbage containers (for Omnibus, see [CustodyWalletFacet](/src/facets/CustodyWalletFacet.sol/contract.CustodyWalletFacet.html))
contract CustodyWalletUnrestrictedFacet is ICustodyWallet {
  /// @notice This is a variable that contains all data used across the entire COWS Container (See [AppStorage](/src/libraries/AppStorage.sol/struct.AppStorage.html)). Data can be accessed by prefixing it s. (eg. bytes32 cowId = s.cowId;)
  AppStorage internal s;

  using Strings for *;

  /// @inheritdoc ICustodyWallet
  function dasApprovalCheck(
    address dasAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external returns (bool) {
    require(expiredAt > block.timestamp, "expired request");

    require(!s.requestIds[requestId], "request already used");

    require(
      s.globalState == IGlobalState.COWSState.ActiveNormal ||
        s.globalState == IGlobalState.COWSState.ActiveEmergency,
      "invalid global state"
    );

    uint256 approvalSignaturesLength = approvalSignatures.length;
    require(
      approvalSignaturesLength > 2 && approvalSignaturesLength < 6,
      "invalid signature amount"
    );

    // Check for duplicate approval userIds or signatures
    SigUtil._checkNoDupes(approvalSignatures);

    {
      // Form message of common parts
      string[] memory parts = new string[](5);
      parts[0] = SigUtil.bytesToHex(s.cowId); // cowsId
      parts[1] = "dasApprovalCheck"; // methodType

      if (
        s.globalState == IGlobalState.COWSState.ActiveNormal ||
        (s.globalState == IGlobalState.COWSState.ActiveEmergency && castlSignature.length != 0)
      ) {
        require(castlSignature.length != 0, "required castl sig");

        // Form CASTL message for 3 of 5
        SigUtil.shrinkStrArray(parts, 4); // Set 'parts' length to 4 to form the CASTL message

        parts[2] = approvalSignaturesLength.toString(); // totalSigNum
        parts[3] = SigUtil.concatApproverSignatures(approvalSignatures); // approvalSignatures

        // Verify CASTL key
        address castlKey = SigUtil.verifySignature(
          castlSignature,
          SigUtil.formatMessageWithDelimiter(parts)
        );
        require(s.castlKeys[castlKey] == IKeyManagement.KeyStatus.Enabled, "invalid castl sig");

        assembly {
          mstore(parts, 5) // Set 'parts' length back to 5
        }
      }

      // Prepare the relevant hash raw for each approver message
      parts[2] = dasAddress.toHexString(); // dasAddress
      parts[3] = expiredAt.toString(); // expiredAt
      parts[4] = SigUtil.bytesToHex(requestId); // requestId

      // Form the hash raw, hash it with keccak256, cast it to its string representation, then set it to parts[1]
      parts[1] = SigUtil.bytesToHex(keccak256(bytes(SigUtil.formatMessageWithDelimiter(parts))));
      SigUtil.shrinkStrArray(parts, 2); // Shrink 'parts' to 2

      // At this point, 'parts' looks like this:
      // cowId//hashRaw//
      // 'cowId' will be replaced with each approver's 'userId' in 'verifyApproverSignature' within the loop
      for (uint256 i; i < approvalSignaturesLength; ) {
        address approvalKey = SigUtil.verifyApproverSignature(parts, approvalSignatures[i]);
        require(
          KeyMgmtUtil.verifyApprovalAddress(approvalSignatures[i].userId, approvalKey),
          "invalid approver sig"
        );

        unchecked {
          ++i;
        }
      }
    }

    s.requestIds[requestId] = true;

    // Emit event DASApprovalCheck(dasAddress, balance)
    emit DASApprovalCheck(
      requestId,
      dasAddress,
      dasAddress == address(0) ? address(this).balance : IERC20(dasAddress).balanceOf(address(this))
    );

    return true;
  }

  /// @inheritdoc ICustodyWallet
  function withdraw(
    address to,
    uint256 amount,
    address dasAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external {
    require(expiredAt > block.timestamp, "expired request");

    require(!s.requestIds[requestId], "request already used");

    require(s.globalState == IGlobalState.COWSState.ActiveNormal, "invalid global state");

    // If 'to' is a COWS container,
    if (s.cowsManagement.getCowId(to) != bytes32(0)) {
      COWSManagement.ContainerInfo memory containerInfo = s.cowsManagement.getContainerInfo(
        s.cowsManagement.getCowId(to)
      );

      // Check global state for any type of container
      IGlobalState.COWSState toGlobalState = IGlobalState(containerInfo.contractAddress)
        .getGlobalState();
      require(toGlobalState == IGlobalState.COWSState.ActiveNormal, "invalid destination state");

      // Check DAS status only for Omnibus container
      if (containerInfo.accountType == COWSManagement.AccountType.Omnibus) {
        require(
          IDASManagement(containerInfo.contractAddress).getDASStatus(dasAddress) ==
            IDASManagement.DASStatus.Enabled,
          "DAS must be enabled"
        );
      }
    }

    require(
      approvalSignatures.length > 2 && approvalSignatures.length < 6,
      "invalid signature amount"
    );

    // Check for duplicate approval userIds or signatures
    SigUtil._checkNoDupes(approvalSignatures);

    // Form message of common parts
    string[] memory parts = new string[](7);

    parts[0] = SigUtil.bytesToHex(s.cowId); // cowsId
    parts[1] = "approveWithdrawal"; // methodType

    {
      // Form CASTL message for 3 of 5
      SigUtil.shrinkStrArray(parts, 4); // Set 'parts' length to 4 to form the CASTL message

      parts[2] = approvalSignatures.length.toString(); // totalSigNum
      parts[3] = SigUtil.concatApproverSignatures(approvalSignatures); // approvalSignatures

      // Verify CASTL key
      address castlKey = SigUtil.verifySignature(
        castlSignature,
        SigUtil.formatMessageWithDelimiter(parts)
      );

      require(s.castlKeys[castlKey] == IKeyManagement.KeyStatus.Enabled, "invalid castl sig");

      assembly {
        mstore(parts, 7) // Set 'parts' length back to 7
      }
    }

    // Prepare the relevant hash raw for each approver message
    parts[2] = dasAddress.toHexString(); // dasAddress
    parts[3] = amount.toString(); // amount
    parts[4] = to.toHexString(); // to
    parts[5] = expiredAt.toString(); // expiredAt
    parts[6] = SigUtil.bytesToHex(requestId); // requestId

    // Form the hash raw, hash it with keccak256, cast it to its string representation, then set it to parts[1]
    parts[1] = SigUtil.bytesToHex(keccak256(bytes(SigUtil.formatMessageWithDelimiter(parts))));

    SigUtil.shrinkStrArray(parts, 2); // Shrink 'parts' to length of 2

    // At this point, 'parts' looks like this:
    // cowId//hashRaw//
    // 'cowId' will be replaced with each approver's 'userId' in 'verifyApproverSignature' within the loop
    for (uint256 i; i < approvalSignatures.length; ) {
      require(
        KeyMgmtUtil.verifyApprovalAddress(
          approvalSignatures[i].userId,
          SigUtil.verifyApproverSignature(parts, approvalSignatures[i])
        ),
        "invalid approver sig"
      );
      unchecked {
        ++i;
      }
    }

    s.requestIds[requestId] = true;

    if (dasAddress == address(0)) {
      (bool sent, ) = payable(to).call{value: amount}("");
      require(sent, "withdraw ETH failed");
    } else {
      require(IERC20(dasAddress).transfer(to, amount), "withdraw DAS failed");
    }

    emit WithdrawalRequest(requestId);
  }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.22;

import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

import {AppStorage} from "../libraries/AppStorage.sol";

import {IKeyManagement} from "../interfaces/IKeyManagement.sol";
import {IGlobalState} from "../interfaces/IGlobalState.sol";
import {IDASManagement} from "../interfaces/IDASManagement.sol";

import {VerifySignatureUtil as SigUtil} from "../libraries/VerifySignatureUtil.sol";
import {KeyMgmtUtil} from "../libraries/KeyMgmtUtil.sol";

import {COWSManagement} from "../COWSManagement.sol";

/// @title DAS Management
/// @author Prometheum Inc.
/// @notice This Facet is responsible for the management of DAS using operations such as `addDAS()`, `disableDAS()`, `pauseDAS()`, etc..
/// @dev This Facet is only found in Omnibus container types
contract DASManagementFacet is IDASManagement {
  /// @notice This is a variable that contains all data used across the entire COWS Container (See [AppStorage](/src/libraries/AppStorage.sol/struct.AppStorage.html)). Data can be accessed by prefixing it s. (eg. bytes32 cowId = s.cowId;)
  AppStorage internal s;

  using Strings for *;

  /// @inheritdoc IDASManagement
  function getDASStatus(address dasAddress) external view returns (DASStatus info) {
    return s.dasStatus[dasAddress];
  }

  /// @notice This function is used to verify CASTL and Approver signatures for all of the DAS Status modification functions (eg. `addDAS()`, `disableDAS()`, `pauseDASDeposits()`, etc...)
  /// @param dasAddress contract address of the DAS
  /// @param expiredAt block timestamp when `castlSignature` and each `approvalSignatures` expires
  /// @param requestId unique identifier for `methodType` requests
  /// @param expiredAt block timestamp when 'castlSignature' and each 'approvalSignatures' expires
  /// @param castlSignature signature signed by CASTL using the 'methodType' message format
  /// @param approvalSignatures signatures from approvers using the 'methodType' message format. Also contains 'userId'
  /// @param methodType string to dictate the 'methodType' used in the formed message format
  function _verifyDASStatusMsgs(
    address dasAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures,
    string memory methodType
  ) internal view {
    uint256 approvalSignaturesLength = approvalSignatures.length;
    require(
      approvalSignaturesLength > 2 && approvalSignaturesLength < 6,
      "invalid signature amount"
    );

    // Check for duplicate approval userIds or signatures
    SigUtil._checkNoDupes(approvalSignatures);

    // Form message of common parts
    string[] memory parts = new string[](5);
    parts[0] = SigUtil.bytesToHex(s.cowId); // cowsId
    parts[1] = methodType; // methodType

    if (
      s.globalState == IGlobalState.COWSState.ActiveNormal ||
      (s.globalState == IGlobalState.COWSState.ActiveEmergency && castlSignature.length != 0)
    ) {
      require(castlSignature.length != 0, "required castl sig");

      // Form CASTL message for 3 of 5
      SigUtil.shrinkStrArray(parts, 4); // Shrink to length of 4 to form CASTL message

      parts[2] = approvalSignaturesLength.toString(); // totalSigNum
      parts[3] = SigUtil.concatApproverSignatures(approvalSignatures); // approvalSignatures

      // Verify CASTL key
      address castlKey = SigUtil.verifySignature(
        castlSignature,
        SigUtil.formatMessageWithDelimiter(parts)
      );
      require(s.castlKeys[castlKey] == IKeyManagement.KeyStatus.Enabled, "invalid castl sig");

      assembly {
        mstore(parts, 5) // Set 'parts' length back to 5
      }
    }

    // Prepare the relevant hash raw for each approver message
    parts[2] = dasAddress.toHexString(); // dasAddress
    parts[3] = expiredAt.toString(); // expiredAt
    parts[4] = SigUtil.bytesToHex(requestId); // requestId

    // Form the hash raw, hash it with keccak256, cast it to its string representation, then set it to parts[1]
    parts[1] = SigUtil.bytesToHex(keccak256(bytes(SigUtil.formatMessageWithDelimiter(parts))));
    SigUtil.shrinkStrArray(parts, 2); // Shrink 'parts' to 2

    // At this point, 'parts' looks like this:
    // cowId//hashRaw//
    // 'cowId' will be replaced with each approver's 'userId' in 'verifyApproverSignature' within the loop
    for (uint256 i; i < approvalSignaturesLength; ) {
      address approvalKey = SigUtil.verifyApproverSignature(parts, approvalSignatures[i]);
      require(
        KeyMgmtUtil.verifyApprovalAddress(approvalSignatures[i].userId, approvalKey),
        "invalid approver sig"
      );
      unchecked {
        ++i;
      }
    }
  }

  /// @inheritdoc IDASManagement
  function addDAS(
    address dasAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external {
    require(expiredAt > block.timestamp, "expired request");

    require(!s.requestIds[requestId], "request already used");

    require(s.dasStatus[dasAddress] == DASStatus.NotAdded, "invalid DAS status");

    IGlobalState.COWSState _globalState = s.globalState;

    // Check signatures by different conditions
    if (_globalState == IGlobalState.COWSState.Recognized) {
      // If it's under recognized state, [castl-sig-only]
      string[] memory parts = new string[](5);
      {
        parts[0] = SigUtil.bytesToHex(s.cowId); // cowsId
        parts[1] = "addDAS"; // methodType
        parts[2] = dasAddress.toHexString(); // dasAddress
        parts[3] = expiredAt.toString(); // expiredAt
        parts[4] = SigUtil.bytesToHex(requestId); // requestId
      }

      // Check CASTL signature
      address castlKey = SigUtil.verifySignature(
        castlSignature,
        SigUtil.formatMessageWithDelimiter(parts)
      );

      require(s.castlKeys[castlKey] == IKeyManagement.KeyStatus.Enabled, "invalid castl sig");
    } else if (
      // If the container is under ActiveNormal/ActiveEmergency
      _globalState == IGlobalState.COWSState.ActiveNormal ||
      _globalState == IGlobalState.COWSState.ActiveEmergency
    ) {
      // Verify CASTL and approver messages using the 'addDAS' message format
      _verifyDASStatusMsgs(
        dasAddress,
        expiredAt,
        requestId,
        castlSignature,
        approvalSignatures,
        "addDAS"
      );
    } else {
      // If the container is not in Recognized or ActiveNormal/ActiveEmergency
      revert("invalid global state");
    }

    s.dasStatus[dasAddress] = DASStatus.Enabled;
    s.requestIds[requestId] = true;

    emit DASManagementAction(requestId, "AddDAS", dasAddress);
  }

  /// @inheritdoc IDASManagement
  function pauseDASDeposits(
    address dasAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external {
    require(expiredAt > block.timestamp, "expired request");

    require(!s.requestIds[requestId], "request already used");

    require(s.dasStatus[dasAddress] == DASStatus.Enabled, "invalid DAS status");

    require(
      s.globalState == IGlobalState.COWSState.ActiveNormal ||
        s.globalState == IGlobalState.COWSState.ActiveEmergency,
      "invalid global state"
    );

    // Verify CASTL and approver messages using the 'pauseDASDeposits' message format
    _verifyDASStatusMsgs(
      dasAddress,
      expiredAt,
      requestId,
      castlSignature,
      approvalSignatures,
      "pauseDASDeposits"
    );

    s.dasStatus[dasAddress] = DASStatus.PauseDeposit;
    s.requestIds[requestId] = true;

    emit DASManagementAction(requestId, "PauseDASDeposits", dasAddress);
  }

  /// @inheritdoc IDASManagement
  function pauseDASDepositsAndWithdrawals(
    address dasAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external {
    require(expiredAt > block.timestamp, "expired request");

    require(!s.requestIds[requestId], "request already used");

    DASStatus dasStatus = s.dasStatus[dasAddress];
    require(
      dasStatus == DASStatus.Enabled || dasStatus == DASStatus.PauseDeposit,
      "invalid DAS status"
    );

    require(
      s.globalState == IGlobalState.COWSState.ActiveNormal ||
        s.globalState == IGlobalState.COWSState.ActiveEmergency,
      "invalid global state"
    );

    // Verify CASTL and approver messages using the 'pauseDASDepositsAndWithdrawals' message format
    _verifyDASStatusMsgs(
      dasAddress,
      expiredAt,
      requestId,
      castlSignature,
      approvalSignatures,
      "pauseDASDepositsAndWithdrawals"
    );

    s.dasStatus[dasAddress] = DASStatus.PauseDepositAndWithdraw;
    s.requestIds[requestId] = true;

    emit DASManagementAction(requestId, "PauseDASDepositsAndWithdrawals", dasAddress);
  }

  /// @inheritdoc IDASManagement
  function disableDAS(
    address dasAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external {
    require(expiredAt > block.timestamp, "expired request");

    require(!s.requestIds[requestId], "request already used");

    require(
      s.globalState == IGlobalState.COWSState.ActiveNormal ||
        s.globalState == IGlobalState.COWSState.ActiveEmergency,
      "invalid global state"
    );

    // Require that the das status has been added
    require(s.dasStatus[dasAddress] != DASStatus.NotAdded, "invalid DAS status");

    // Verify CASTL and approver messages using the 'disableDAS' message format
    _verifyDASStatusMsgs(
      dasAddress,
      expiredAt,
      requestId,
      castlSignature,
      approvalSignatures,
      "disableDAS"
    );

    s.dasStatus[dasAddress] = DASStatus.Disabled;
    s.requestIds[requestId] = true;

    emit DASManagementAction(requestId, "DisableDAS", dasAddress);
  }

  /// @inheritdoc IDASManagement
  function enableDAS(
    address dasAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external {
    require(expiredAt > block.timestamp, "expired request");

    require(!s.requestIds[requestId], "request already used");

    require(
      s.globalState == IGlobalState.COWSState.ActiveNormal ||
        s.globalState == IGlobalState.COWSState.ActiveEmergency,
      "invalid global state"
    );

    DASStatus dasStatus = s.dasStatus[dasAddress];
    require(
      dasStatus != DASStatus.NotAdded && dasStatus != DASStatus.Enabled,
      "invalid DAS status"
    );

    // Verify CASTL and approver messages using the 'enableDAS' message format
    _verifyDASStatusMsgs(
      dasAddress,
      expiredAt,
      requestId,
      castlSignature,
      approvalSignatures,
      "enableDAS"
    );

    s.dasStatus[dasAddress] = DASStatus.Enabled;

    s.requestIds[requestId] = true;

    emit DASManagementAction(requestId, "EnableDAS", dasAddress);
  }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.22;

import {AppStorage} from "./libraries/AppStorage.sol";
import {LibDiamond} from "./libraries/LibDiamond.sol";

import {IDiamond} from "./interfaces/IDiamond.sol";

/// @title COWS Container
/// @author Prometheum Inc.
/// @notice This contract is a proxy contract that delegates logic to [Facet](/src/facets) contracts. Each container contract represents a whole COWS container.
/// @dev This proxy contract uses a minimal, immutable [Diamond Proxy pattern](https://eips.ethereum.org/EIPS/eip-2535) that cannot be upgraded after this container is deployed. This also uses AppStorage and DiamondStorage as its shared storage methods.
contract Diamond is IDiamond {
  /// @notice This is a variable that contains all data used across the entire COWS Container (See [AppStorage](/src/libraries/AppStorage.sol/struct.AppStorage.html)). Data can be accessed by prefixing it s. (eg. bytes32 cowId = s.cowId;)
  AppStorage internal s;

  /// @notice Initalize all necessary AppStorage and links all Facet contracts in Diamond Storage on deployment.
  constructor(
    bytes32 cowId,
    address cowMgmtAddr,
    address[] memory castlKeys,
    FacetCut[] memory initialCuts
  ) {
    LibDiamond._setCowId(cowId); // set cowId in AppStorage
    LibDiamond._setCowsMgmt(cowMgmtAddr); // set cows management in AppStorage
    LibDiamond._setCastlKeys(castlKeys); // set castl keys in AppStorage

    s.totalActiveCastlKeys += uint8(castlKeys.length);

    _cutNewDiamondFacets(initialCuts); // link each 'initialCuts.selector' to 'initialCuts.facetAddress'
  }

  /// @notice This is a internal function called within the `constructor` that cuts all of the facet contract into Diamond Storage
  /// @param cuts List of facets and selectors to include in Diamond Storage
  function _cutNewDiamondFacets(FacetCut[] memory cuts) internal {
    // loop through diamond cut
    uint256 diamondCutsLength = cuts.length;
    for (uint256 i; i < diamondCutsLength; ) {
      LibDiamond.addFacetSelectors(cuts[i].facetAddress, cuts[i].functionSelectors);

      unchecked {
        ++i;
      }
    }
  }

  /// @notice This is a special function that is called when trying to call a function that is not declared within the the contract. This function will then:<br/>1. Find the intended function selector in calldata.<br/>2. Find the facet mapped to that intended function selector in Diamond Storage.<br/>3. Use `delegatecall` to forward all calldata and state context to that facet contract
  fallback() external payable {
    // get diamond storage
    LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();

    address facet = ds.facets[msg.sig]; // get facet from function selector
    require(facet != address(0), "Diamond: Function does not exist");

    // Execute external function from facet using delegatecall and return any value.
    assembly {
      calldatacopy(0, 0, calldatasize()) // copy function selector and any arguments
      let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0) // execute function call using the facet
      returndatacopy(0, 0, returndatasize()) // get any return value
      switch result // return any return value or error back to the caller
      case 0 {
        revert(0, returndatasize())
      }
      default {
        return(0, returndatasize())
      }
    }
  }

  /// @notice This function is called when trying to call this contract with `msg.value` > 0, but no calldata _(if there's any calldata, it will call `fallback()` instead)_. It currently doesn't do/change anything, but it can be extended further if we'd like to.
  receive() external payable virtual {}
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.22;

import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

import {AppStorage} from "../libraries/AppStorage.sol";

import {IDirectDeposit} from "../interfaces/IDirectDeposit.sol";

import {IKeyManagement} from "../interfaces/IKeyManagement.sol";
import {IGlobalState} from "../interfaces/IGlobalState.sol";
import {IDASManagement} from "../interfaces/IDASManagement.sol";

import {VerifySignatureUtil as SigUtil} from "../libraries/VerifySignatureUtil.sol";

/// @title Direct Deposit
/// @author Prometheum Inc.
/// @notice This is the Facet to allow users to deposit directly to COWS Containers using their own wallet (eg. Metamask) and a previously approved CASTL signature.
/// @dev This Facet is only found in Omnibus container types
contract DirectDepositFacet is IDirectDeposit {
  /// @notice This is a variable that contains all data used across the entire COWS Container (See [AppStorage](/src/libraries/AppStorage.sol/struct.AppStorage.html)). Data can be accessed by prefixing it s. (eg. bytes32 cowId = s.cowId;)
  AppStorage internal s;

  using Strings for *;

  /// @inheritdoc IDirectDeposit
  function getDirectDeposits(bytes32 depositId) external view returns (bytes memory signature) {
    return s.directDeposits[depositId];
  }

  /// @inheritdoc IDirectDeposit
  function directDeposit(
    bytes32 depositDirectId,
    address dasAddress,
    uint256 amount,
    uint256 expiredAt,
    bytes calldata castlSignature
  ) external payable {
    require(s.globalState == IGlobalState.COWSState.ActiveNormal, "invalid global state");

    require(block.timestamp < expiredAt, "expired request");

    require(!s.requestIds[depositDirectId], "request already used");

    require(s.dasStatus[dasAddress] == IDASManagement.DASStatus.Enabled, "invalid DAS status");

    {
      // Form CASTL only message
      string[] memory parts = new string[](7);
      parts[0] = SigUtil.bytesToHex(s.cowId); // cowsId
      parts[1] = "directDeposit"; // methodType
      parts[2] = SigUtil.bytesToHex(depositDirectId); // depositDirectId
      parts[3] = msg.sender.toHexString(); // source
      parts[4] = dasAddress.toHexString(); // dasAddress
      parts[5] = amount.toString(); // amount
      parts[6] = expiredAt.toString(); // expiredAt

      // Verify CASTL key
      address castlKey = SigUtil.verifySignature(
        castlSignature,
        SigUtil.formatMessageWithDelimiter(parts)
      );
      require(s.castlKeys[castlKey] == IKeyManagement.KeyStatus.Enabled, "invalid castl sig");
    }

    if (dasAddress == address(0)) {
      require(amount == msg.value, "invalid ETH amount sent");
    }

    s.directDeposits[depositDirectId] = castlSignature;

    s.requestIds[depositDirectId] = true;

    if (dasAddress != address(0)) {
      // Transfer ERC20 fund to the custody wallet within the same COW
      require(
        IERC20(dasAddress).transferFrom(msg.sender, address(this), amount),
        "Direct deposit ERC20 failed"
      );
    }

    emit DirectDepositRequest(depositDirectId, dasAddress, amount, msg.sender.toHexString());
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.20;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS
    }

    /**
     * @dev The signature derives the `address(0)`.
     */
    error ECDSAInvalidSignature();

    /**
     * @dev The signature has an invalid length.
     */
    error ECDSAInvalidSignatureLength(uint256 length);

    /**
     * @dev The signature has an S value that is in the upper half order.
     */
    error ECDSAInvalidSignatureS(bytes32 s);

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not
     * return address(0) without also returning an error description. Errors are documented using an enum (error type)
     * and a bytes32 providing additional information about the error.
     *
     * If no error is returned, then the address can be used for verification purposes.
     *
     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError, bytes32) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[ERC-2098 short signatures]
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) {
        unchecked {
            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            // We do not check for an overflow here since the shift operation results in 0 or 1.
            uint8 v = uint8((uint256(vs) >> 255) + 27);
            return tryRecover(hash, v, r, s);
        }
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError, bytes32) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS, s);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature, bytes32(0));
        }

        return (signer, RecoverError.NoError, bytes32(0));
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.
     */
    function _throwError(RecoverError error, bytes32 errorArg) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert ECDSAInvalidSignature();
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert ECDSAInvalidSignatureLength(uint256(errorArg));
        } else if (error == RecoverError.InvalidSignatureS) {
            revert ECDSAInvalidSignatureS(errorArg);
        }
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.22;

import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";

import {AppStorage} from "../libraries/AppStorage.sol";

import {IGlobalState} from "../interfaces/IGlobalState.sol";
import {IKeyManagement} from "../interfaces/IKeyManagement.sol";

import {VerifySignatureUtil as SigUtil} from "../libraries/VerifySignatureUtil.sol";
import {KeyMgmtUtil} from "../libraries/KeyMgmtUtil.sol";

import {COWSManagement} from "../COWSManagement.sol";

/// @title Global State
/// @author Prometheum Inc.
/// @notice This is the Facet used to maintain the COWS Container statuses (eg. global states).
contract GlobalStateFacet is IGlobalState {
  /// @notice This is a variable that contains all data used across the entire COWS Container (See [AppStorage](/src/libraries/AppStorage.sol/struct.AppStorage.html)). Data can be accessed by prefixing it s. (eg. bytes32 cowId = s.cowId;)
  AppStorage internal s;

  using Strings for *;

  /// @inheritdoc IGlobalState
  function getCowId() external view returns (bytes32 cowId) {
    return s.cowId;
  }

  /// @inheritdoc IGlobalState
  function getGlobalState() external view returns (COWSState state) {
    return s.globalState;
  }

  /// @inheritdoc IGlobalState
  function isKeyUsed(address keyAddress) external view returns (bool isUsed) {
    isUsed = s.isUserKeyUsed[keyAddress];
  }

  /// @inheritdoc IGlobalState
  function isReqIdUsed(bytes32 requestId) external view returns (bool isUsed) {
    isUsed = s.requestIds[requestId];
  }

  /// @inheritdoc IGlobalState
  function setGlobalState(COWSState state) external {
    require(msg.sender == address(s.cowsManagement), "caller must be cows management");

    s.globalState = state;

    emit SetGlobalState(state);
  }

  /// @inheritdoc IGlobalState
  function confirmApproversKeys(
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo calldata approvalSignature
  ) external {
    require(expiredAt > block.timestamp, "expired request");

    require(!s.requestIds[requestId], "request already used");

    require(s.globalState == COWSState.ActiveNormal, "invalid global state");

    IKeyManagement.EmergencyReplacement storage emergencyReplacement = s.emergencyKeyReplacements[
      s.activeEmgRequestId
    ];

    require(approvalSignature.userId == emergencyReplacement.userId, "invalid user");

    // Form CASTL message
    string[] memory parts = new string[](5);

    SigUtil.shrinkStrArray(parts, 3); // Shrink to length of 3 to form CASTL message

    parts[0] = SigUtil.bytesToHex(s.cowId); // cowsId
    parts[1] = "confirmApproversKeys"; // methodType
    parts[2] = SigUtil.signatureToString(approvalSignature.signature); // approvalSignature

    // Verify CASTL key
    address castlKey = SigUtil.verifySignature(
      castlSignature,
      SigUtil.formatMessageWithDelimiter(parts)
    );
    require(s.castlKeys[castlKey] == IKeyManagement.KeyStatus.Enabled, "invalid castl sig");

    // Extend 'parts' to length of 4 for approver message
    assembly {
      mstore(parts, 5) // Normally, it's not advised not to enlarge a memory array, but the 4th slot was already preallocated when 'parts' was first instantiated
    }

    // Form approver message
    parts[2] = emergencyReplacement.newKeys.emergencyKey.toHexString(); // new replaced emergencyKey
    parts[3] = expiredAt.toString(); // expiredAt
    parts[4] = SigUtil.bytesToHex(requestId); // requestId

    // Verify new replaced approval key
    address approvalKey = SigUtil.verifySignature(
      approvalSignature.signature,
      SigUtil.formatMessageWithDelimiter(parts)
    );
    require(
      KeyMgmtUtil.verifyApprovalAddress(approvalSignature.userId, approvalKey),
      "invalid approver sig"
    );

    s.requestIds[requestId] = true;

    emit ConfirmApproversKeys(requestId);
  }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.22;

import {VerifySignatureUtil as SigUtil} from "../libraries/VerifySignatureUtil.sol";

/// @title Custody Wallet Interface
/// @author Prometheum Inc.
/// @notice This interface is for the [CustodyWalletFacet](/src/facets/CustodyWalletFacet.sol/contract.CustodyWalletFacet.html) and [CustodyWalletUnrestrictedFacet](/src/facets/CustodyWalletFacet.sol/contract.CustodyWalletUnrestrictedFacet.html) contract.
/// @notice Check <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139919/Structure+Overview#Facet-Contracts)</b> for more concept details.
interface ICustodyWallet {
  /// @notice The **DASApprovalCheck** event is emitted at the end of the [`dasApprovalCheck()`](#dasapprovalcheck) function.
  /// @dev **requestId** : unique identifier used for record keeping
  /// @dev **dasAddress** : contract address of the DAS to return the current balance of
  /// @dev **balance** : the balance of the checked DAS held by the container<br />
  event DASApprovalCheck(bytes32 requestId, address dasAddress, uint256 balance);

  /// @notice The **WithdrawalRequest** event is emitted at the end of the [`withdraw()`](#withdraw) function.
  /// @dev **requestId** : unique identifier used for record keeping
  event WithdrawalRequest(bytes32 requestId);

  /// @notice Emits DASApprovalCheck event to check current balance for a specific DAS. Contract spec can be found <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326140046/CustodyWalletFacet#dasApprovalCheck)</b>
  /// @dev Uses the <b>[dasApprovalCheck()](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139938/VerifySignatureUtil#dasApprovalCheck)</b> message format.
  /// @param dasAddress contract of the DAS to return the current balance of
  /// @param expiredAt block timestamp when `castlSignature` and each `approvalSignatures` expires
  /// @param requestId unique identifier used for record keeping in `requestIds` mapping
  /// @param castlSignature signature signed by CASTL using the `dasApprovalCheck` message format
  /// @param approvalSignatures signatures from approvers using the `dasApprovalCheck` message format. Also contains `userId`
  /// @return isSuccessful true if the call was successful
  function dasApprovalCheck(
    address dasAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external returns (bool isSuccessful);

  /// @notice Withdraw DAS for customer by valid approvals and CASTL signature. Contract spec can be found <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326140046/CustodyWalletFacet#withdraw)</b>
  /// @dev Uses the <b>[withdraw()](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139938/VerifySignatureUtil#withdraw)</b> message format.
  /// @param to address to withdraw DAS to
  /// @param amount amount of DAS to withdraw
  /// @param dasAddress contract address of DAS to withdraw
  /// @param expiredAt block timestamp when `castlSignature` and each `approvalSignatures` expires
  /// @param requestId unique identifier used to differentiate between withdraw requests
  /// @param castlSignature signature signed by CASTL using the `withdraw` message format
  /// @param approvalSignatures signatures from approvers using the `withdraw` message format. Also contains `userId`
  function withdraw(
    address to,
    uint256 amount,
    address dasAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external;
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.22;

import {VerifySignatureUtil as SigUtil} from "../libraries/VerifySignatureUtil.sol";

/// @title DAS Management Interface
/// @author Prometheum Inc.
/// @notice This interface is for the [DASManagement](/src/facets/DASManagementFacet.sol/contract.DASManagementFacet.html) contract.
/// @notice Check <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139919/Structure+Overview#Facet-Contracts)</b> for more concept details.
interface IDASManagement {
  /// @notice Representation of the varying statuses for DAS we support.
  enum DASStatus {
    NotAdded, // an empty status
    Enabled,
    Disabled,
    PauseDeposit,
    PauseDepositAndWithdraw
  }

  /// @notice Emitted when a DASManagement action is invoked successfully
  /// @dev **requestId** : unique identifier used for record keeping <br/>
  /// @dev **dasAction**: DAS action being executed (`addDAS()`, `pauseDASDeposits()`, `pauseDASDepositsAndWithdrawals()`, `disableDAS`, `enableDAS()`) <br />
  /// @dev **dasAddress** the token contract address of the DAS to be operated <br />
  event DASManagementAction(bytes32 requestId, string dasAction, address indexed dasAddress);

  /// @notice Returns the DASStatus of `dasAddress` in the `dasStatus` mapping within AppStorage
  /// @param dasAddress the address of the DAS to check the status of
  /// @return info DASStatus of the `dasAddress`
  function getDASStatus(address dasAddress) external view returns (DASStatus info);

  /// @notice Adds support for new DAS for `directDeposit()` or `depositCollect()`. Contract spec can be found <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326140128/DASManagementFacet#addDAS())</b>
  /// @dev Uses the <b>[addDAS()](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139938/VerifySignatureUtil#addDAS)</b> message format.
  /// @param dasAddress contract address of the DAS to add
  /// @param expiredAt block timestamp when 'castlSignature' and each 'approvalSignatures' expires
  /// @param requestId unique identifier for this specific 'addDAS' call
  /// @param castlSignature signature signed by CASTL using the 'addDAS()' message format
  /// @param approvalSignatures signatures from approvers using the 'addDAS()' message format. Also contains 'userId'
  function addDAS(
    address dasAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external;

  /// @notice Pauses DAS deposits from `directDeposit()` and `depositCollect()` to the container specified. <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326140128/DASManagementFacet#pauseDASDeposits())</b>
  /// @dev Uses the <b>[pauseDASDeposits()](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139938/VerifySignatureUtil#pauseDASDeposits)</b> message format.
  /// @param dasAddress token contract address of the DAS to pause
  /// @param expiredAt block timestamp when 'castlSignature' and each 'approvalSignatures' expires
  /// @param requestId unique identifier for this specific 'pauseDASDeposits()' call
  /// @param castlSignature signature signed by CASTL using the `pauseDASDeposits()` message format
  /// @param approvalSignatures signatures from approvers using the `pauseDASDeposits()` message format. Also contains `userId`
  function pauseDASDeposits(
    address dasAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external;

  /// @notice Pauses DAS deposits and withdrawals from the container specified. <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326140128/DASManagementFacet#pauseDASDepositsAndWithdrawals())</b>
  /// @dev Uses the <b>[pauseDASDepositsAndWithdrawals()](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139938/VerifySignatureUtil#pauseDASDepositsAndWithdrawals)</b> message format.
  /// @param dasAddress token contract address of the DAS to pause
  /// @param expiredAt block timestamp when 'castlSignature' and each 'approvalSignatures' expires
  /// @param requestId unique identifier used to form messages and prevent replays
  /// @param castlSignature signature signed by CASTL using the `pauseDASDepositsAndWithdrawals()` message format
  /// @param approvalSignatures signatures from approvers using the `pauseDASDepositsAndWithdrawals()` message format. Also contains `userId`
  function pauseDASDepositsAndWithdrawals(
    address dasAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external;

  /// @notice Disable DAS for any transfer to the container specified. <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326140128/DASManagementFacet#disableDAS())</b>
  /// @dev Uses the <b>[disableDAS()](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139938/VerifySignatureUtil#disableDAS)</b> message format.
  /// @param dasAddress token contract address of the DAS to disable
  /// @param expiredAt block timestamp when 'castlSignature' and each 'approvalSignatures' expires
  /// @param requestId unique identifier for this specific 'disableDAS' call
  /// @param castlSignature signature signed by CASTL using the `disableDAS()` message format
  /// @param approvalSignatures signatures from approvers using the `disableDAS()` message format. Also contains `userId`
  function disableDAS(
    address dasAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external;

  /// @notice Enable DAS for any transfer within the container specified. <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326140128/DASManagementFacet#enableDAS())</b>
  /// @dev Uses the <b>[enableDAS()](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139938/VerifySignatureUtil#enableDAS)</b> message format.
  /// @param dasAddress token contract address of the DAS to enable
  /// @param expiredAt block timestamp when 'castlSignature' and each 'approvalSignatures' expires
  /// @param requestId unique identifier for this specific 'enableDAS' call
  /// @param castlSignature signature signed by CASTL using the `enableDAS` message format
  /// @param approvalSignatures signatures from approvers using the `enableDAS` message format. Also contains `userId`
  function enableDAS(
    address dasAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external;
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.22;

import {ICustodyWallet} from "./ICustodyWallet.sol";
import {IDASManagement} from "./IDASManagement.sol";
import {IDirectDeposit} from "./IDirectDeposit.sol";
import {IGlobalState} from "./IGlobalState.sol";
import {IKeyManagementEmg, IKeyManagementInit, IKeyManagementStore, IKeyManagementOthers} from "./IKeyManagement.sol";

/// @title Diamond Interface
/// @author Prometheum Inc.
/// @notice This interface is for the [Diamond](/src/Diamond.sol/contract.Diamond.html) contract.
/// @notice Check <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139919/Structure+Overview#Container-Contracts)</b> for more concept details.
interface IDiamond {
  /// @notice Represents a single Facet's address alongside all of its available external function selectors.
  /// @dev **facetAddress**: contract address of the Facet contract<br />**functionSelectors**: list of function selectors accessable through the `facetAddress`
  struct FacetCut {
    address facetAddress;
    bytes4[] functionSelectors;
  }
}

/// @title Diamond Interface
/// @author Prometheum Inc.
/// @notice This interface inherits all possible [Facet](/src/facets/) interfaces to create an ABI that represents the capabilities of the Diamond proxy.
interface IFunctions is
  ICustodyWallet,
  IDASManagement,
  IDirectDeposit,
  IGlobalState,
  IKeyManagementStore,
  IKeyManagementEmg,
  IKeyManagementInit,
  IKeyManagementOthers
{}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.22;

import {VerifySignatureUtil as SigUtil} from "../libraries/VerifySignatureUtil.sol";

/// @title Direct Deposit Interface
/// @author Prometheum Inc.
/// @notice This interface is for the [DirectDeposit](/src/facets/DirectDepositFacet.sol/contract.DirectDepositFacet.html) contract.
/// @notice Check <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139919/Structure+Overview#Facet-Contracts)</b> for more concept details.
interface IDirectDeposit {
  /// @notice Emitted when [`directDeposit()`](#directdeposit) is invoked and executed successfully
  /// @dev **directDepositId**: unique identifier for a specific direct deposit request<br /> **dasAddress**: contract address of the DAS to deposit<br /> **amount**: amount of DAS to deposit<br /> **from**: address where the DAS was deposited from
  event DirectDepositRequest(
    bytes32 indexed directDepositId,
    address indexed dasAddress,
    uint256 amount,
    string from
  );

  /// @notice Returns the signature used for a specific depositId used for directDeposit().
  /// @param depositId specific direct deposit id to query
  /// @return signature castlSignature used in the specific direct deposit
  function getDirectDeposits(bytes32 depositId) external view returns (bytes memory signature);

  /// @notice Allows verified users to user their personal wallet to deposit DAS directly to container. Contract spec can be found <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326140020/DirectDepositFacet#directDeposit)</b>
  /// @dev Uses the <b>[directDeposit()](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139938/VerifySignatureUtil#directDeposit)</b> message format
  /// @param depositDirectId unique identifier used to record keeping
  /// @param dasAddress contract address of DAS to deposit (can be 0 to target ETH)
  /// @param amount amount of DAS to deposit
  /// @param expiredAt block timestamp of when to expire `castlSignature`
  /// @param castlSignature signature signed by CASTL using the `directDeposit` message format
  function directDeposit(
    bytes32 depositDirectId,
    address dasAddress,
    uint256 amount,
    uint256 expiredAt,
    bytes calldata castlSignature
  ) external payable;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.22;

import {VerifySignatureUtil as SigUtil} from "../libraries/VerifySignatureUtil.sol";

/// @title Global State Interface
/// @author Prometheum Inc.
/// @notice This interface is for the [GlobalState](/src/facets/GlobalStateFacet.sol/contract.GlobalStateFacet.html) contract.
/// @notice Check <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139919/Structure+Overview#Facet-Contracts)</b> for more concept details.
interface IGlobalState {
  /// @notice Representation of varying global states of a COWS Container
  enum COWSState {
    Deployed,
    Recognized,
    ActiveNormal,
    ActiveEmergency,
    Paused
  }

  /// @notice Emitted when [`confirmApproversKeys()`](#confirmApproversKeys) is invoked and executed successfully
  /// @dev **requestId** : unique identifier used for uniqueness
  event ConfirmApproversKeys(bytes32 requestId);

  /// @notice Emitted when [`setGlobalState()`](#setGlobalState) is invoked and executed successfully
  /// @dev **newGlobalState** : the global state that the container has been set to
  event SetGlobalState(COWSState newGlobalState);

  /// @notice Returns this container’s COW identifier from AppStorage
  /// @return cowId of the container
  function getCowId() external view returns (bytes32 cowId);

  /// @notice Returns this container’s current global state
  /// @return globalState the global state of the container
  function getGlobalState() external view returns (COWSState globalState);

  /// @notice Sets the container’s global state to a valid global state value
  /// @param state the states to set the container's global state to
  function setGlobalState(COWSState state) external;

  /// @notice Returns a boolean value whether a specific requestId is used from 'requestIds'
  /// @param requestId the id of all kind requests within the same cow container
  function isReqIdUsed(bytes32 requestId) external view returns (bool isUsed);

  /// @notice Returns a boolean value whether a specific key is used from 'keyAddress'
  /// @param keyAddress address of the key to be checked
  function isKeyUsed(address keyAddress) external view returns (bool isUsed);

  /// @notice Void transaction to show we have replaced key set up properly before resume normal. Contract spec can be found <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139980/GlobalStateFacet#confirmApproversKeys)</b>
  /// @dev Uses the <b>[confirmApproversKeys()](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139938/VerifySignatureUtil#confirmApproversKeys)</b> message format.
  /// @param expiredAt block timestamp when 'castlSignature' and each 'approvalSignature' expires
  /// @param requestId unique identifier for this specific confirmApproversKeys call
  /// @param castlSignature signature signed by CASTL using the 'confirmApproversKeys' message format
  /// @param approvalSignature signature from the approver that just replaced new keys via emergency replacement using the 'confirmApproversKeys' message format. Also contains 'userId'
  function confirmApproversKeys(
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo calldata approvalSignature
  ) external;
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.22;

import {VerifySignatureUtil as SigUtil} from "../libraries/VerifySignatureUtil.sol";

/// @title Key Management Interface
/// @author Prometheum Inc.
/// @notice This interface is for the Key Management related contracts. These contracts include: [KeyManagementStore](/src/facets/KeyManagementStoreFacet.sol/contract.KeyManagementStoreFacet.html)<br /> [KeyManagementInit](/src/facets/KeyManagementInitFacet.sol/contract.KeyManagementInitFacet.html)<br /> [KeyManagementEmg](/src/facets/KeyManagementEmgFacet.sol/contract.KeyManagementEmgFacet.html)
/// @notice Check <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139919/Structure+Overview#Facet-Contracts)</b> for more concept details.
interface IKeyManagement {
  /// @notice Represents the varying states that shared with both CASTL and Intervention key can be in.
  enum KeyStatus {
    Nonexistent,
    Enabled,
    Expired
  }

  /// @notice Represents the varying states that approver and its keys attached to it can be in.
  enum UserStatus {
    Nonexistent,
    Enabled,
    Disabled,
    Expired
  }

  /// @notice Represents the varying blocking states that a user can be in.
  enum UserBlocks {
    None,
    Approval,
    All
  }

  /// @notice Represents the varying states that an emergency request status can be in.
  enum EmergencyRequestStatus {
    Nonexistent,
    Started,
    Executed,
    Rejected
  }

  /// @notice Contains all key information for each user inside the `complianceUserKeys` mapping in AppStorage
  /// @dev **delayTo**: block timestamp to delay the emergency key’s functionality to<br/> **emergencyKey**: address of the user’s emergency key<br/> **approvalKeys**: list of approval key addresses owned by the user<br/> **status**: status that dictates whether this user is nonexistent/ enabled/ disabled/ expired<br/> **userBlocks**: dictates if this user if block from any functionality or not<br/>
  struct UserKeys {
    uint96 delayTo;
    address emergencyKey;
    address[] approvalKeys;
    UserStatus status;
    UserBlocks userBlocks;
  }

  /// @notice Contains data relevant for each EmergencyReplacement inside the `emergencyKeyReplacements` mapping in AppStorage
  /// @dev **gasWallet**: msg.sender of the emergency replacement transaction<br /> **userId**: identifier of the user who initiated this emergency replacement<br /> **oldKeys**: the old keys associated to the user before this emergency replacement<br /> **newKeys**: the new keys to associate with this user after this emergency replacement<br /> **signedEmergencySignature**: signature used to start this emergency replacement<br /> **signedRejectionSignature**: signature used to interrupt this emergency replacement<br /> **delayTo**: block timestamp of when this emergency replacement can be executed<br /> **isRejected**: boolean that dictates whether this emergency replacement has been interrupted or not<br /> **status**: dictates the current status of this emergency replacement
  struct EmergencyReplacement {
    address gasWallet;
    bytes32 userId;
    UserKeys oldKeys;
    UserKeys newKeys;
    uint256 delayTo;
    bool isRejected;
    EmergencyRequestStatus status;
  }

  /// @notice Contains data tied to a specific user when initializing a container
  /// @dev This is used in the input of `init()`
  struct InputUserKey {
    bytes32 userId;
    address approvalKey;
    address emgKey;
  }

  /// @notice Emitted at the end of `init()`
  event Init();

  /// @notice Emitted at the end of `addApprovalKey() and 'removeApprovalKey()`
  /// @dev **requestId** : unique identifier used for record keeping <br/> **actionType**: string that dictates what action was used for the approval key (eg. “Add” or "Remove")
  event ApprovalKeyAction(bytes32 requestId, string actionType);

  /// @notice Emitted at the end of `addUser()` and `removeUser()`
  /// @dev **requestId** : unique identifier used for record keeping <br/> **actionType**: string that dictates what action was used for the user (eg. Add, “Disable”) <br /> **userId**: userId of the User
  event UserAction(bytes32 requestId, string actionType, bytes32 userId);

  /// @notice Emitted at every step of the EmergencyReplaceUserKeys flow
  /// @dev **requestId** : unique identifier used for record keeping <br/>  **userId** : unique identifier of the user starts emergency replacement <br/> **actionType**: string that dictates what action was used in the emergency replace flow key (eg. “Start”, “Intervene”, “Execute”)
  event EmergencyReplaceUserKeysRequest(bytes32 requestId, bytes32 userId, string actionType);

  /// @notice Emitted at the end of `interventionKeyCheck()`
  /// @dev **requestId** : unique identifier used for record keeping <br/>**keyAddress**: intervention key’s address that is going to be verified
  event InterventionKeyCheck(bytes32 requestId, address keyAddress);

  /// @notice Emitted at the end of `addInterventionKey()` & `removeInterventionKey()`
  /// @dev **requestId** : unique identifier used for record keeping <br/> **actionType**: string that dictates what action was used for the intervention key (eg. “Add” or "Remove"). **keyAddress**: intervention key’s address that is going to be Added or Removed
  event InterventionKey(bytes32 requestId, string actionType, address keyAddress);

  /// @notice Emitted at the end of `addCASTLKey()` and `expireCASTLKey()`
  /// @dev **requestId** : unique identifier used for record keeping <br/> **actionType**: string that dictates whether a CASTL key was Added or Expired (eg. “Add”, "Expire") <br /> **keyAddress**: CASTL key’s address that is going to be Added or Expired
  event CASTLKey(bytes32 requestId, string actionType, address keyAddress);
}

/// @title Key Management Store Interface
/// @author Prometheum Inc.
/// @notice This interface is for the [KeyManagementStore](/src/facets/KeyManagementStoreFacet.sol/contract.KeyManagementStoreFacet.html) contract.
interface IKeyManagementStore is IKeyManagement {
  /// @notice Returns the KeyStatus of the CASTL key
  /// @param key address of the CASTL key to check its KeyStatus
  /// @return status returns the status of the passed in key
  function getCASTLKey(address key) external view returns (KeyStatus);

  /// @notice Returns the KeyStatus of the intervention key
  /// @param key address of the intervention key to check its KeyStatus
  /// @return status returns the status of the passed in key
  function getInterventionKey(address key) external view returns (KeyStatus);

  /// @notice Returns the total amount of active CASTL keys registered in this container
  /// @return totalCASTLKeys total number of CASTLKeys
  function getTotalActiveCASTLKeys() external view returns (uint8 totalCASTLKeys);

  /// @notice Returns `initiator` from storage
  /// @return signature used in the `init()` call to Initialize this container
  function getInitiator() external view returns (bytes memory signature);

  /// @notice Returns user keys associated to `userId` from `complianceUserKeys` mapping
  /// @param userId identifier of the user to fetch the keys of
  /// @return userKeys keys associated to the `userId`
  function getUserKeys(
    bytes32 userId
  ) external view returns (IKeyManagement.UserKeys memory userKeys);

  /// @notice Returns the total amount of interventions keys registered in this container
  /// @return totalActiveInterventionKeys total amount of intervention keys registered in the container
  function getTotalActiveInterventionKeys()
    external
    view
    returns (uint256 totalActiveInterventionKeys);

  /// @notice Returns the EmergencyReplacement associated to requestId from ‘emergencyKeyReplacements’ mapping in storage
  /// @param requestId identifier of the request to fetch the emergency replacement info for
  /// @return emergencyReplacement associated to the `requestId`
  function getEmergencyReplacements(
    bytes32 requestId
  ) external view returns (IKeyManagement.EmergencyReplacement memory emergencyReplacement);

  /// @notice Returns UserBlock status of the user
  /// @param userId userId of the user to check the blocked status of
  function getUserBlocks(bytes32 userId) external view returns (UserBlocks);

  /// @notice Returns boolean to check if the passed in key is currently being used
  /// @param keyAddress keyAddress of the user to check if it is used or not
  function isUserKeyUsed(address keyAddress) external view returns (bool);

  /// @notice Returns bytes32 of request id that indicates which emergency replacement is active now
  /// @return requestId identifier of the request to fetch the emergency replacement info for
  function getActiveEmgRequestId() external view returns (bytes32);

  /// @notice Returns the total amount of total active users in this container
  /// @return totalActiveUsers total amount of active users in the container
  function getTotalActiveUsers() external view returns (uint256 totalActiveUsers);

  /// @notice This confirms whether the specified 'userId' owns the specified 'recoveredAddress'. It also checks if 'userId' is unblocked and if they're enabled.
  /// @param userId user identifier to check if they own the 'recoveredAddress' or not
  /// @param recoveredAddress address to check if 'userId' owns it or not. It also checks if they're unblocked and enabled
  /// @return isValid boolean that dictates if 'userId' owns 'recoveredAddress' and if they're unblocked and enabled
  function isValidApprovalAddress(
    bytes32 userId,
    address recoveredAddress
  ) external view returns (bool isValid);
}

/// @title Key Management Init Interface
/// @author Prometheum Inc.
/// @notice This interface is for the [KeyManagementInit](/src/facets/KeyManagementInitFacet.sol/contract.KeyManagementInitFacet.html) contract.
interface IKeyManagementInit is IKeyManagement {
  /// @notice Initialize intervention keys and user’s approval and emergency key for the container. Contract spec can be found <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/348127233/KeyManagementInitFacet#init)</b>
  /// @dev  Message format is in <b>[init()](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139938/VerifySignatureUtil#init)</b> format.
  /// @param userKeys user keys to initialize the container with
  /// @param interventionKeys intervention keys to initialize the container with
  /// @param expiredAt block timestamp when 'castlSignature' expires
  /// @param castlSignature castl siganture used for verification for this initialization process
  function init(
    InputUserKey[] calldata userKeys,
    address[] calldata interventionKeys,
    uint256 expiredAt,
    bytes calldata castlSignature
  ) external;

  /// @notice Add a new approval key for specified user. Contract spec can be found <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/348127233/KeyManagementInitFacet#addApprovalKey)</b>
  /// @dev Message format is in <b>[addApprovalKey()](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139938/VerifySignatureUtil#addApprovalKey)</b> format and requires 3 of 5 approvals with 1 CASTL signature. Currently, only support adding 1 new key at a time.
  /// @param userId user id to add the approval key for
  /// @param keyAddress address of the approval key to add
  /// @param expiredAt block timestamp when 'castlSignature' and each 'approvalSignatures' expires
  /// @param requestId unique identifier used to form messages and prevent replays
  /// @param castlSignature castl signature for verification
  /// @param approvalSignatures 3 of 5 approval signatures for verification
  function addApprovalKey(
    bytes32 userId,
    address keyAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external;

  /// @notice Removes an approval key for specified user.
  /// @dev Message format is in `removeApprovalKey` format and requires 3 of 5 approvals with 1 CASTL signature. Currently, only support adding 1 new key at a time.
  /// @param userId user id to remove the approval key for
  /// @param keyAddress address of the approval key to remove
  /// @param expiredAt block timestamp when 'castlSignature' and each 'approvalSignatures' expires
  /// @param requestId unique identifier used to form messages and prevent replays
  /// @param castlSignature castl signature for verification
  /// @param approvalSignatures 3 of 5 approval signatures for verification
  function removeApprovalKey(
    bytes32 userId,
    address keyAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external;

  /// @notice Add keys for a new user. Contract spec can be found <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/348127233/KeyManagementInitFacet#addUser)</b>
  /// @dev Message format is in <b>[addUser()](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139938/VerifySignatureUtil#addUser)</b> format and requires 3 of 5 approvals with 1 CASTL signature.
  /// @param userKey user keys to add to the container
  /// @param expiredAt block timestamp when 'castlSignature' and each 'approvalSignatures' expires
  /// @param requestId unique identifier used to form messages and prevent replays
  /// @param castlSignature castl signature for verification
  /// @param approvalSignatures 3 of 5 approval signatures for verification
  function addUser(
    InputUserKey calldata userKey,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external;

  /// @notice Remove an existed user with its approval & emergency keys. Contract spec can be found <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/348127233/KeyManagementInitFacet#removeUser)</b>
  /// @dev Message format is in <b>[removeUser()](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139938/VerifySignatureUtil#removeUser)</b> format and requires 3 of 5 approvals with 1 CASTL signature.
  /// @param userId user id to remove the approval key for
  /// @param expiredAt block timestamp when 'castlSignature' and each 'approvalSignatures' expires
  /// @param requestId unique identifier used to form messages and prevent replays
  /// @param castlSignature castl signature for verification
  /// @param approvalSignatures 3 of 5 approval signatures for verification
  function removeUser(
    bytes32 userId,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external;

  /// @notice Enables an existing user (aka approver) and its keys
  /// @dev Message format is in enableUser() format and requires 3 of 5 approvals with 1 CASTL signature
  /// @param userId user id to enable the approver and its keys for
  /// @param expiredAt block timestamp when 'castlSignature' and each 'approvalSignatures' expires
  /// @param requestId unique identifier used to form messages and prevent replays
  /// @param castlSignature castl signature for verification
  /// @param approvalSignatures 3 of 5 approval signatures for verification
  function enableUser(
    bytes32 userId,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external;

  /// @notice Disables an existing user (aka approver) and its keys
  /// @dev Message format is in disableUser() format and requires 3 of 5 approvals with 1 CASTL signature
  /// @param userId user id to disable the approver and its keys for
  /// @param expiredAt block timestamp when 'castlSignature' and each 'approvalSignatures' expires
  /// @param requestId unique identifier used to form messages and prevent replays
  /// @param castlSignature castl signature for verification
  /// @param approvalSignatures 3 of 5 approval signatures for verification
  function disableUser(
    bytes32 userId,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external;
}

/// @title Key Management Emg Interface
/// @author Prometheum Inc.
/// @notice This interface is for the [KeyManagementEmg](/src/facets/KeyManagementEmgFacet.sol/contract.KeyManagementEmgFacet.html) contract.
interface IKeyManagementEmg is IKeyManagement {
  /// @notice Begins the emergency replace user keys process. This updates the globalState to ActiveEmergency. Contract spec can be found <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/348127247/KeyManagementEmgFacet#emergencyReplaceUserKeysStart)</b>
  /// @dev Message format is in <b>[emergencyReplaceUserKeysStart()](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139938/VerifySignatureUtil#emergencyReplaceUserKeysStart)</b> format.
  /// @param approvalKey new approval key to replace for user
  /// @param emergencyKey new emergency key to replace for user
  /// @param expiredAt block timestamp when 'emergencySignature' expires
  /// @param requestId unique identifier to link to each emergencyReplaceUserKeys request
  /// @param emergencySignature signature from user's emergency key using the 'emergencyReplaceUserKeysStart' message format. Also contains 'userId'
  function emergencyReplaceUserKeysStart(
    address approvalKey,
    address emergencyKey,
    uint256 expiredAt,
    bytes32 requestId,
    SigUtil.ApproverInfo calldata emergencySignature
  ) external;

  /// @notice If a specific emergency replace user keys request is deemed as non-valid, an intervention key can be used to interrupt a request using this function. Contract spec can be found <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/348127247/KeyManagementEmgFacet#emergencyReplaceUserKeysIntervene)</b>
  /// @dev Uses the <b>[emergencyReplaceUserKeysIntervene()](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139938/VerifySignatureUtil#emergencyReplaceUserKeysIntervene)</b> message format.
  /// @param expiredAt block timestamp when 'signedRejectApproval' expires
  /// @param signedRejectApproval signature from a valid intervention key
  /// @return isRejected true if the call was successful
  function emergencyReplaceUserKeysIntervene(
    uint256 expiredAt,
    bytes calldata signedRejectApproval
  ) external returns (bool isRejected);

  /// @notice Execute emergency key replacement request to complete replacement after the delay block time. Contract spec can be found <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/348127247/KeyManagementEmgFacet#emergencyReplaceUserKeysExecute)</b>
  /// @dev Uses the <b>[emergencyReplaceUserKeysExecute()](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139938/VerifySignatureUtil#emergencyReplaceUserKeysExecute)</b> message format.
  /// @param expiredAt block timestamp when 'approvalSignature' & 'emergencySignature' expires
  /// @param requestId unique identifier to link to each emergencyReplaceUserKeys request
  /// @param approvalSignature signature from user's new replaced approval key using the 'emergencyReplaceUserKeysExecute' message format.
  /// @param emergencySignature signature from user's new replaced emergency key using the 'emergencyReplaceUserKeysExecute' message format.
  function emergencyReplaceUserKeysExecute(
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata approvalSignature,
    bytes calldata emergencySignature
  ) external;
}

/// @title Key Management Others Interface
/// @author Prometheum Inc.
/// @notice This interface is for the [KeyManagementOthers](/src/facets/KeyManagementOthersFacet.sol/contract.KeyManagementOthersFacet.html) contract.
interface IKeyManagementOthers is IKeyManagement {
  /// @notice Emits InterventionKeyCheck event to check if it's Enabled for a specific intervention key. Contract spec can be found <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/373260289/KeyManagementOthersFacet#interventionKeyCheck)</b>
  /// @dev Message format is in <b>[interventionKeyCheck()](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139938/VerifySignatureUtil#interventionKeyCheck)</b> format.
  /// @param expiredAt block timestamp when 'interventionSignature' expires
  /// @param requestId unique identifier used to form messages and prevent replays
  /// @param interventionSignature intervention signature for verification
  /// @return isSuccessful true if the call was successful
  function interventionKeyCheck(
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata interventionSignature
  ) external returns (bool isSuccessful);

  /// @notice Add a new intervention key. This is a function we will use to update intervention key after init(). Contract spec can be found <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/373260289/KeyManagementOthersFacet#addInterventionKey)</b>
  /// @dev Message format is in <b>[addInterventionKey()](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139938/VerifySignatureUtil#addInterventionKey)</b> format.
  /// @param keyAddress address of the intervention key to add
  /// @param expiredAt block timestamp when 'castlSignature' and each 'approvalSignatures' expires
  /// @param requestId unique identifier used to form messages and prevent replays
  /// @param castlSignature castl signature for verification
  /// @param approvalSignatures 3 of 5 approval signatures for verification
  function addInterventionKey(
    address keyAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external;

  /// @notice Removes intervention key. Contract spec can be found <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/373260289/KeyManagementOthersFacet#removeInterventionKey)</b>
  /// @dev Message format is in <b>[removeInterventionKey()](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139938/VerifySignatureUtil#removeInterventionKey)</b> format.
  /// @param keyAddress address of the approval key to remove
  /// @param expiredAt block timestamp when 'castlSignature' and each 'approvalSignatures' expires
  /// @param requestId unique identifier used to form messages and prevent replays
  /// @param castlSignature castl signature for verification
  /// @param approvalSignatures 3 of 5 approval signatures for verification
  function removeInterventionKey(
    address keyAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external;

  /// @notice Add a new CASTL key. Contract spec can be found <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/373260289/KeyManagementOthersFacet#addCASTLKey)</b>
  /// @dev Message format is in <b>[addCASTLKey()](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139938/VerifySignatureUtil#addCASTLKey)</b> format.
  /// @param keyAddress address of the CASTL key to add
  /// @param expiredAt block timestamp when 'castlSignature' and each 'approvalSignatures' expires
  /// @param requestId unique identifier used to form messages and prevent replays
  /// @param castlSignature castl signature for verification
  /// @param approvalSignatures 3 of 5 approval signatures for verification
  function addCASTLKey(
    address keyAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external;

  /// @notice Expires an existing CASTL key. Contract spec can be found <b>[HERE](https://prometheum.atlassian.net/wiki/spaces/PE/pages/373260289/KeyManagementOthersFacet#expireCASTLKey)</b>
  /// @dev Message format is in <b>[expireCASTLKey()](https://prometheum.atlassian.net/wiki/spaces/PE/pages/326139938/VerifySignatureUtil#expireCASTLKey)</b> format.
  /// @param keyAddress address of the CASTL key to expire
  /// @param expiredAt block timestamp when 'castlSignature' and each 'approvalSignatures' expires
  /// @param requestId unique identifier used to form messages and prevent replays
  /// @param castlSignature castl signature for verification **(NOTE: This cannot be signed by `keyAddress`)**
  /// @param approvalSignatures 3 of 5 approval signatures for verification
  function expireCASTLKey(
    address keyAddress,
    uint256 expiredAt,
    bytes32 requestId,
    bytes calldata castlSignature,
    SigUtil.ApproverInfo[] calldata approvalSignatures
  ) external;
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.22;

import {AppStorage} from "../libraries/AppStorage.sol";
import {VerifySignatureUtil as SigUtil} from "../libraries/VerifySignatureUtil.sol";
import {KeyMgmtUtil} from "../libraries/KeyMgmtUtil.sol";

import {IKeyManagementStore, IKeyManagement} from "../interfaces/IKeyManagement.sol";

import {GlobalStateFacet} from "../facets/GlobalStateFacet.sol";
import {COWSManagement} from "../COWSManagement.sol";
import {KeyMgmtUtil} from "../libraries/KeyMgmtUtil.sol";

import {KeyMgmtUtil} from "../libraries/KeyMgmtUtil.sol";

/// @title Key Management Store
/// @author Prometheum Inc.
/// @notice This is the Facet that is used to return all Key Management related storage.
contract KeyManagementStoreFacet is IKeyManagementStore {
  /// @notice This is a variable that contains all data used across the entire COWS Container (See [AppStorage](/src/libraries/AppStorage.sol/struct.AppStorage.html)). Data can be accessed by prefixing it s. (eg. bytes32 cowId = s.cowId;)
  AppStorage internal s;

  /// @inheritdoc IKeyManagementStore
  function getCASTLKey(address key) external view returns (KeyStatus) {
    return s.castlKeys[key];
  }

  /// @inheritdoc IKeyManagementStore
  function getInterventionKey(address key) external view returns (KeyStatus) {
    return s.interventionKeys[key];
  }

  /// @inheritdoc IKeyManagementStore
  function getTotalActiveCASTLKeys() external view returns (uint8) {
    return s.totalActiveCastlKeys;
  }

  /// @inheritdoc IKeyManagementStore
  function getInitiator() external view returns (bytes memory) {
    return s.initiator;
  }

  /// @inheritdoc IKeyManagementStore
  function getUserKeys(bytes32 userId) external view returns (UserKeys memory) {
    return s.complianceUserKeys[userId];
  }

  /// @inheritdoc IKeyManagementStore
  function getTotalActiveInterventionKeys() external view returns (uint256) {
    return s.totalActiveInterventionKeys;
  }

  /// @inheritdoc IKeyManagementStore
  function getEmergencyReplacements(
    bytes32 requestId
  ) external view returns (EmergencyReplacement memory) {
    return s.emergencyKeyReplacements[requestId];
  }

  /// @inheritdoc IKeyManagementStore
  function getUserBlocks(bytes32 userId) external view returns (UserBlocks) {
    return s.complianceUserKeys[userId].userBlocks;
  }

  /// @inheritdoc IKeyManagementStore
  function getActiveEmgRequestId() external view returns (bytes32) {
    return s.activeEmgRequestId;
  }

  /// @inheritdoc IKeyManagementStore
  function getTotalActiveUsers() external view returns (uint256) {
    return s.totalActiveUsers;
  }

  /// @inheritdoc IKeyManagementStore
  function isUserKeyUsed(address keyAddress) external view returns (bool) {
    return s.isUserKeyUsed[keyAddress];
  }

  /// @inheritdoc IKeyManagementStore
  function isValidApprovalAddress(
    bytes32 userId,
    address recoveredAddress
  ) external view returns (bool) {
    return KeyMgmtUtil.verifyApprovalAddress(userId, recoveredAddress);
  }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.22;

import {IKeyManagement} from "../interfaces/IKeyManagement.sol";

import {AppStorage} from "./AppStorage.sol";
import {LibDiamond} from "./LibDiamond.sol";

/// @title Key Management Util Library
/// @author Prometheum Inc.
/// @notice This library is used to hold extra utility for the Key Management Facets.
library KeyMgmtUtil {
  /// @notice This verifies that `recoveredAddress` is a valid approver key that belongs to `userId`. It also checks if the address is unblocked and if it's enabled.
  /// @param userId user identifier to check if they own `recoveredAddress` or not
  /// @param recoveredAddress address to check if `userId` owns it or not. It is also checked if the address is unblocked or enabled
  /// @return isValid boolean that dictates if `userId` owns the approval key `recoveredAddress`, if it's unblocked, and if it's enabled
  function verifyApprovalAddress(
    bytes32 userId,
    address recoveredAddress
  ) internal view returns (bool isValid) {
    AppStorage storage s = LibDiamond.appStorage();

    address[] memory _approvalKeys = s.complianceUserKeys[userId].approvalKeys;

    bool isBlocked = s.complianceUserKeys[userId].userBlocks > IKeyManagement.UserBlocks.None;
    bool isEnabled = s.complianceUserKeys[userId].status == IKeyManagement.UserStatus.Enabled;
    bool isVerified;

    for (uint256 k; k < _approvalKeys.length; ) {
      if (_approvalKeys[k] == recoveredAddress) {
        isVerified = true;
        break;
      }
      unchecked {
        ++k;
      }
    }
    return (!isBlocked && isEnabled && isVerified);
  }

  /// @notice Sets all user related info in related to `userId` in storage
  /// @param userId `userId` to adjust the storage for
  /// @param delayTo `delayTo` to set in storage for `userId`
  /// @param emergencyKey `emergencyKey` to set in storage for `userId`
  /// @param approvalKeys `approvalKeys` to set in storage for `userId`
  /// @param status `status` to set in storage for `userId`
  /// @param userBlocks `userBlocks` to set in storage for `userId`
  /// @custom:reverts if 'emergencyKey' or each 'approvalKey' isn't unique to this container
  function setUserKeys(
    bytes32 userId,
    uint96 delayTo,
    address emergencyKey,
    address[] memory approvalKeys,
    IKeyManagement.UserStatus status,
    IKeyManagement.UserBlocks userBlocks
  ) internal {
    AppStorage storage s = LibDiamond.appStorage();

    IKeyManagement.UserKeys storage _userKeys = s.complianceUserKeys[userId];

    require(isKeyUnique(emergencyKey), "key already used");

    _userKeys.status = status;
    _userKeys.userBlocks = userBlocks;

    _userKeys.delayTo = delayTo;
    _userKeys.emergencyKey = emergencyKey;

    // if approval key array isn't empty, overwrite to update it
    uint256 approvalKeysLength = approvalKeys.length;
    if (approvalKeysLength != 0) {
      // for replacing all keys attach to a user (also apply to init or emergency replacement)
      address[] memory addedApprovalKeys = new address[](approvalKeysLength);

      for (uint256 i = 0; i < approvalKeysLength; ) {
        require(isKeyUnique(approvalKeys[i]), "key already used");
        addedApprovalKeys[i] = approvalKeys[i];

        unchecked {
          ++i;
        }
      }

      _userKeys.approvalKeys = addedApprovalKeys;
    }
  }

  /// @notice Finds and returns the index of 'addressToFind' in 'addressArray'.
  ///         If 'addressToFind' isn't found, '-1' is returned.
  /// @param addressArray array used to find 'addressToFind's index within.
  /// @param addressToFind address to find within 'addressArray'.
  /// @return index the index within the 'addressArray' array that 'address' is located at.
  ///         Returns '-1' if 'addressToFind' was not found.
  function findAddress(
    address[] memory addressArray,
    address addressToFind
  ) internal pure returns (int256 index) {
    for (uint256 i; i < addressArray.length; ) {
      if (addressArray[i] == addressToFind) return int256(i);
      unchecked {
        ++i;
      }
    }

    index = -1;
  }

  /// @notice Checks 'key' against all other existing keys on this
  ///         container to ensure that this key is entirely unique
  /// @param key address to check for uniqueness
  /// @return isUnique boolean to dictate if 'key' is unique or not
  function isKeyUnique(address key) internal view returns (bool isUnique) {
    AppStorage storage s = LibDiamond.appStorage();

    bool isUsedUserKey = s.isUserKeyUsed[key];
    if (isUsedUserKey) return false;

    bool isUsedCastlKey = s.castlKeys[key] != IKeyManagement.KeyStatus.Nonexistent;
    if (isUsedCastlKey) return false;

    bool isUsedInterventionKey = s.interventionKeys[key] != IKeyManagement.KeyStatus.Nonexistent;
    if (isUsedInterventionKey) return false;

    return true;
  }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.22;

import {AppStorage} from "./AppStorage.sol";
import {Diamond} from "../Diamond.sol";

import {COWSManagement} from "../COWSManagement.sol";

import {GlobalStateFacet} from "../facets/GlobalStateFacet.sol";
import {CustodyWalletFacet} from "../facets/CustodyWalletFacet.sol";
import {DASManagementFacet} from "../facets/DASManagementFacet.sol";
import {DirectDepositFacet} from "../facets/DirectDepositFacet.sol";

import {IKeyManagement} from "../interfaces/IKeyManagement.sol";

/// @title Diamond Library
/// @author Prometheum Inc.
/// @notice This is the contract used to contain functionality related to the Diamond Proxy. This includes facet cutting, AppStorage, and DiamondStorage. For more information on the Diamond Proxy, see [Diamond.sol](/src/Diamond.sol/contract.Diamond.html).
library LibDiamond {
  /*******************************/
  /*         APP STORAGE         */
  /*******************************/
  /// @notice This function returns a storage pointer at slot 0. This mimics the normal AppStorage behavior of declaring the variable at the beginning of each facet contract.
  /// @return s storage pointer at slot 0.
  function appStorage() internal pure returns (AppStorage storage s) {
    assembly {
      s.slot := 0
    }
  }

  /// @notice sets cowId in AppStorage. Used in the constructor of Diamond.sol
  /// @param cowId identifier of this container
  function _setCowId(bytes32 cowId) internal {
    AppStorage storage s = appStorage();
    s.cowId = cowId;
  }

  /// @notice sets COWS management address in AppStorage. Used in the constructor of Diamond.sol
  /// @param cowMgmtAddr address of the COWSManagement contract
  function _setCowsMgmt(address cowMgmtAddr) internal {
    AppStorage storage s = appStorage();
    s.cowsManagement = COWSManagement(cowMgmtAddr);
  }

  /// @notice sets castl keys to `KeyStatus.Enabled` in AppStorage. Used in the constructor of Diamond.sol
  /// @param castlKeys castl keys to set in app storage
  function _setCastlKeys(address[] memory castlKeys) internal {
    AppStorage storage s = appStorage();

    uint256 castlKeysLength = castlKeys.length;
    require(castlKeysLength > 0, "no castl keys were given");
    for (uint256 i; i < castlKeysLength; ) {
      s.castlKeys[castlKeys[i]] = IKeyManagement.KeyStatus.Enabled;

      unchecked {
        ++i;
      }
    }
  }

  /***********************************/
  /*         DIAMOND STORAGE         */
  /***********************************/
  /// @notice This determines the slot position of diamond storage. This is mainly used for organization and storage collision protection.
  bytes32 private constant DIAMOND_STORAGE_POSITION = keccak256("diamond.standard.diamond.storage");

  /// @notice Contains facet linking information by mapping function selectors to the facet addresses they're associated
  /// @dev **facets** {mapping(bytes4 => address)}: maps function selectors to the facet addresses that execute the functions
  struct DiamondStorage {
    mapping(bytes4 => address) facets;
  }

  /// @notice This function returns a storage pointer at slot DIAMOND_STORAGE_POSITION. This is only used to store that selector to facet address mapping at the moment, but this can easily be expanded to store more diamond related information.
  /// @return ds storage pointer located at `DIAMOND_STORAGE_POSITION`
  function diamondStorage() internal pure returns (DiamondStorage storage ds) {
    bytes32 position = DIAMOND_STORAGE_POSITION;
    assembly {
      ds.slot := position
    }
  }

  /// @notice Links all `_selectors` to the `_newFacetAddress` in DiamondStorage
  /// @param _newFacetAddress address of the facet address to link to `_selectors`
  /// @param _selectors bytes4 selectors to link up to the `_newFacetAddress`
  function addFacetSelectors(address _newFacetAddress, bytes4[] memory _selectors) internal {
    DiamondStorage storage ds = diamondStorage();

    require(_selectors.length > 0, "LibDiamondCut: No selectors in facet to cut");
    require(_newFacetAddress != address(0), "facet cannot be address(0)");

    enforceHasContractCode(_newFacetAddress, "facet has no code");

    uint256 selectorsLength = _selectors.length;
    for (uint256 i; i < selectorsLength; ) {
      // add facet for selector
      ds.facets[_selectors[i]] = _newFacetAddress;
      unchecked {
        ++i;
      }
    }
  }

  /// @notice Checks `_contract` address for bytecode. If no bytecode is found, `_errorMessage` is thrown
  /// @param _contract address to check for bytecode
  /// @param _errorMessage error message to throw if no bytecode is found
  function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {
    uint256 contractSize;
    assembly {
      contractSize := extcodesize(_contract)
    }
    require(contractSize > 0, _errorMessage);
  }
}

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

/// @notice Library for converting numbers into strings and other string operations.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibString.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibString.sol)
///
/// @dev Note:
/// For performance and bytecode compactness, most of the string operations are restricted to
/// byte strings (7-bit ASCII), except where otherwise specified.
/// Usage of byte string operations on charsets with runes spanning two or more bytes
/// can lead to undefined behavior.
library LibString {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                        CUSTOM ERRORS                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The length of the output is too small to contain all the hex digits.
    error HexLengthInsufficient();

    /// @dev The length of the string is more than 32 bytes.
    error TooBigForSmallString();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         CONSTANTS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The constant returned when the `search` is not found in the string.
    uint256 internal constant NOT_FOUND = type(uint256).max;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                     DECIMAL OPERATIONS                     */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the base 10 decimal representation of `value`.
    function toString(uint256 value) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            // The maximum value of a uint256 contains 78 digits (1 byte per digit), but
            // we allocate 0xa0 bytes to keep the free memory pointer 32-byte word aligned.
            // We will need 1 word for the trailing zeros padding, 1 word for the length,
            // and 3 words for a maximum of 78 digits.
            str := add(mload(0x40), 0x80)
            // Update the free memory pointer to allocate.
            mstore(0x40, add(str, 0x20))
            // Zeroize the slot after the string.
            mstore(str, 0)

            // Cache the end of the memory to calculate the length later.
            let end := str

            let w := not(0) // Tsk.
            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            for { let temp := value } 1 {} {
                str := add(str, w) // `sub(str, 1)`.
                // Write the character to the pointer.
                // The ASCII index of the '0' character is 48.
                mstore8(str, add(48, mod(temp, 10)))
                // Keep dividing `temp` until zero.
                temp := div(temp, 10)
                if iszero(temp) { break }
            }

            let length := sub(end, str)
            // Move the pointer 32 bytes leftwards to make room for the length.
            str := sub(str, 0x20)
            // Store the length.
            mstore(str, length)
        }
    }

    /// @dev Returns the base 10 decimal representation of `value`.
    function toString(int256 value) internal pure returns (string memory str) {
        if (value >= 0) {
            return toString(uint256(value));
        }
        unchecked {
            str = toString(~uint256(value) + 1);
        }
        /// @solidity memory-safe-assembly
        assembly {
            // We still have some spare memory space on the left,
            // as we have allocated 3 words (96 bytes) for up to 78 digits.
            let length := mload(str) // Load the string length.
            mstore(str, 0x2d) // Store the '-' character.
            str := sub(str, 1) // Move back the string pointer by a byte.
            mstore(str, add(length, 1)) // Update the string length.
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   HEXADECIMAL OPERATIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the hexadecimal representation of `value`,
    /// left-padded to an input length of `length` bytes.
    /// The output is prefixed with "0x" encoded using 2 hexadecimal digits per byte,
    /// giving a total length of `length * 2 + 2` bytes.
    /// Reverts if `length` is too small for the output to contain all the digits.
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(value, length);
        /// @solidity memory-safe-assembly
        assembly {
            let strLength := add(mload(str), 2) // Compute the length.
            mstore(str, 0x3078) // Write the "0x" prefix.
            str := sub(str, 2) // Move the pointer.
            mstore(str, strLength) // Write the length.
        }
    }

    /// @dev Returns the hexadecimal representation of `value`,
    /// left-padded to an input length of `length` bytes.
    /// The output is prefixed with "0x" encoded using 2 hexadecimal digits per byte,
    /// giving a total length of `length * 2` bytes.
    /// Reverts if `length` is too small for the output to contain all the digits.
    function toHexStringNoPrefix(uint256 value, uint256 length)
        internal
        pure
        returns (string memory str)
    {
        /// @solidity memory-safe-assembly
        assembly {
            // We need 0x20 bytes for the trailing zeros padding, `length * 2` bytes
            // for the digits, 0x02 bytes for the prefix, and 0x20 bytes for the length.
            // We add 0x20 to the total and round down to a multiple of 0x20.
            // (0x20 + 0x20 + 0x02 + 0x20) = 0x62.
            str := add(mload(0x40), and(add(shl(1, length), 0x42), not(0x1f)))
            // Allocate the memory.
            mstore(0x40, add(str, 0x20))
            // Zeroize the slot after the string.
            mstore(str, 0)

            // Cache the end to calculate the length later.
            let end := str
            // Store "0123456789abcdef" in scratch space.
            mstore(0x0f, 0x30313233343536373839616263646566)

            let start := sub(str, add(length, length))
            let w := not(1) // Tsk.
            let temp := value
            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            for {} 1 {} {
                str := add(str, w) // `sub(str, 2)`.
                mstore8(add(str, 1), mload(and(temp, 15)))
                mstore8(str, mload(and(shr(4, temp), 15)))
                temp := shr(8, temp)
                if iszero(xor(str, start)) { break }
            }

            if temp {
                mstore(0x00, 0x2194895a) // `HexLengthInsufficient()`.
                revert(0x1c, 0x04)
            }

            // Compute the string's length.
            let strLength := sub(end, str)
            // Move the pointer and write the length.
            str := sub(str, 0x20)
            mstore(str, strLength)
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is prefixed with "0x" and encoded using 2 hexadecimal digits per byte.
    /// As address are 20 bytes long, the output will left-padded to have
    /// a length of `20 * 2 + 2` bytes.
    function toHexString(uint256 value) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(value);
        /// @solidity memory-safe-assembly
        assembly {
            let strLength := add(mload(str), 2) // Compute the length.
            mstore(str, 0x3078) // Write the "0x" prefix.
            str := sub(str, 2) // Move the pointer.
            mstore(str, strLength) // Write the length.
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is prefixed with "0x".
    /// The output excludes leading "0" from the `toHexString` output.
    /// `0x00: "0x0", 0x01: "0x1", 0x12: "0x12", 0x123: "0x123"`.
    function toMinimalHexString(uint256 value) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(value);
        /// @solidity memory-safe-assembly
        assembly {
            let o := eq(byte(0, mload(add(str, 0x20))), 0x30) // Whether leading zero is present.
            let strLength := add(mload(str), 2) // Compute the length.
            mstore(add(str, o), 0x3078) // Write the "0x" prefix, accounting for leading zero.
            str := sub(add(str, o), 2) // Move the pointer, accounting for leading zero.
            mstore(str, sub(strLength, o)) // Write the length, accounting for leading zero.
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output excludes leading "0" from the `toHexStringNoPrefix` output.
    /// `0x00: "0", 0x01: "1", 0x12: "12", 0x123: "123"`.
    function toMinimalHexStringNoPrefix(uint256 value) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(value);
        /// @solidity memory-safe-assembly
        assembly {
            let o := eq(byte(0, mload(add(str, 0x20))), 0x30) // Whether leading zero is present.
            let strLength := mload(str) // Get the length.
            str := add(str, o) // Move the pointer, accounting for leading zero.
            mstore(str, sub(strLength, o)) // Write the length, accounting for leading zero.
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is encoded using 2 hexadecimal digits per byte.
    /// As address are 20 bytes long, the output will left-padded to have
    /// a length of `20 * 2` bytes.
    function toHexStringNoPrefix(uint256 value) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            // We need 0x20 bytes for the trailing zeros padding, 0x20 bytes for the length,
            // 0x02 bytes for the prefix, and 0x40 bytes for the digits.
            // The next multiple of 0x20 above (0x20 + 0x20 + 0x02 + 0x40) is 0xa0.
            str := add(mload(0x40), 0x80)
            // Allocate the memory.
            mstore(0x40, add(str, 0x20))
            // Zeroize the slot after the string.
            mstore(str, 0)

            // Cache the end to calculate the length later.
            let end := str
            // Store "0123456789abcdef" in scratch space.
            mstore(0x0f, 0x30313233343536373839616263646566)

            let w := not(1) // Tsk.
            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            for { let temp := value } 1 {} {
                str := add(str, w) // `sub(str, 2)`.
                mstore8(add(str, 1), mload(and(temp, 15)))
                mstore8(str, mload(and(shr(4, temp), 15)))
                temp := shr(8, temp)
                if iszero(temp) { break }
            }

            // Compute the string's length.
            let strLength := sub(end, str)
            // Move the pointer and write the length.
            str := sub(str, 0x20)
            mstore(str, strLength)
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is prefixed with "0x", encoded using 2 hexadecimal digits per byte,
    /// and the alphabets are capitalized conditionally according to
    /// https://eips.ethereum.org/EIPS/eip-55
    function toHexStringChecksummed(address value) internal pure returns (string memory str) {
        str = toHexString(value);
        /// @solidity memory-safe-assembly
        assembly {
            let mask := shl(6, div(not(0), 255)) // `0b010000000100000000 ...`
            let o := add(str, 0x22)
            let hashed := and(keccak256(o, 40), mul(34, mask)) // `0b10001000 ... `
            let t := shl(240, 136) // `0b10001000 << 240`
            for { let i := 0 } 1 {} {
                mstore(add(i, i), mul(t, byte(i, hashed)))
                i := add(i, 1)
                if eq(i, 20) { break }
            }
            mstore(o, xor(mload(o), shr(1, and(mload(0x00), and(mload(o), mask)))))
            o := add(o, 0x20)
            mstore(o, xor(mload(o), shr(1, and(mload(0x20), and(mload(o), mask)))))
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is prefixed with "0x" and encoded using 2 hexadecimal digits per byte.
    function toHexString(address value) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(value);
        /// @solidity memory-safe-assembly
        assembly {
            let strLength := add(mload(str), 2) // Compute the length.
            mstore(str, 0x3078) // Write the "0x" prefix.
            str := sub(str, 2) // Move the pointer.
            mstore(str, strLength) // Write the length.
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is encoded using 2 hexadecimal digits per byte.
    function toHexStringNoPrefix(address value) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            str := mload(0x40)

            // Allocate the memory.
            // We need 0x20 bytes for the trailing zeros padding, 0x20 bytes for the length,
            // 0x02 bytes for the prefix, and 0x28 bytes for the digits.
            // The next multiple of 0x20 above (0x20 + 0x20 + 0x02 + 0x28) is 0x80.
            mstore(0x40, add(str, 0x80))

            // Store "0123456789abcdef" in scratch space.
            mstore(0x0f, 0x30313233343536373839616263646566)

            str := add(str, 2)
            mstore(str, 40)

            let o := add(str, 0x20)
            mstore(add(o, 40), 0)

            value := shl(96, value)

            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            for { let i := 0 } 1 {} {
                let p := add(o, add(i, i))
                let temp := byte(i, value)
                mstore8(add(p, 1), mload(and(temp, 15)))
                mstore8(p, mload(shr(4, temp)))
                i := add(i, 1)
                if eq(i, 20) { break }
            }
        }
    }

    /// @dev Returns the hex encoded string from the raw bytes.
    /// The output is encoded using 2 hexadecimal digits per byte.
    function toHexString(bytes memory raw) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(raw);
        /// @solidity memory-safe-assembly
        assembly {
            let strLength := add(mload(str), 2) // Compute the length.
            mstore(str, 0x3078) // Write the "0x" prefix.
            str := sub(str, 2) // Move the pointer.
            mstore(str, strLength) // Write the length.
        }
    }

    /// @dev Returns the hex encoded string from the raw bytes.
    /// The output is encoded using 2 hexadecimal digits per byte.
    function toHexStringNoPrefix(bytes memory raw) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            let length := mload(raw)
            str := add(mload(0x40), 2) // Skip 2 bytes for the optional prefix.
            mstore(str, add(length, length)) // Store the length of the output.

            // Store "0123456789abcdef" in scratch space.
            mstore(0x0f, 0x30313233343536373839616263646566)

            let o := add(str, 0x20)
            let end := add(raw, length)

            for {} iszero(eq(raw, end)) {} {
                raw := add(raw, 1)
                mstore8(add(o, 1), mload(and(mload(raw), 15)))
                mstore8(o, mload(and(shr(4, mload(raw)), 15)))
                o := add(o, 2)
            }
            mstore(o, 0) // Zeroize the slot after the string.
            mstore(0x40, add(o, 0x20)) // Allocate the memory.
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   RUNE STRING OPERATIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the number of UTF characters in the string.
    function runeCount(string memory s) internal pure returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            if mload(s) {
                mstore(0x00, div(not(0), 255))
                mstore(0x20, 0x0202020202020202020202020202020202020202020202020303030304040506)
                let o := add(s, 0x20)
                let end := add(o, mload(s))
                for { result := 1 } 1 { result := add(result, 1) } {
                    o := add(o, byte(0, mload(shr(250, mload(o)))))
                    if iszero(lt(o, end)) { break }
                }
            }
        }
    }

    /// @dev Returns if this string is a 7-bit ASCII string.
    /// (i.e. all characters codes are in [0..127])
    function is7BitASCII(string memory s) internal pure returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            let mask := shl(7, div(not(0), 255))
            result := 1
            let n := mload(s)
            if n {
                let o := add(s, 0x20)
                let end := add(o, n)
                let last := mload(end)
                mstore(end, 0)
                for {} 1 {} {
                    if and(mask, mload(o)) {
                        result := 0
                        break
                    }
                    o := add(o, 0x20)
                    if iszero(lt(o, end)) { break }
                }
                mstore(end, last)
            }
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   BYTE STRING OPERATIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    // For performance and bytecode compactness, byte string operations are restricted
    // to 7-bit ASCII strings. All offsets are byte offsets, not UTF character offsets.
    // Usage of byte string operations on charsets with runes spanning two or more bytes
    // can lead to undefined behavior.

    /// @dev Returns `subject` all occurrences of `search` replaced with `replacement`.
    function replace(string memory subject, string memory search, string memory replacement)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let subjectLength := mload(subject)
            let searchLength := mload(search)
            let replacementLength := mload(replacement)

            subject := add(subject, 0x20)
            search := add(search, 0x20)
            replacement := add(replacement, 0x20)
            result := add(mload(0x40), 0x20)

            let subjectEnd := add(subject, subjectLength)
            if iszero(gt(searchLength, subjectLength)) {
                let subjectSearchEnd := add(sub(subjectEnd, searchLength), 1)
                let h := 0
                if iszero(lt(searchLength, 0x20)) { h := keccak256(search, searchLength) }
                let m := shl(3, sub(0x20, and(searchLength, 0x1f)))
                let s := mload(search)
                for {} 1 {} {
                    let t := mload(subject)
                    // Whether the first `searchLength % 32` bytes of
                    // `subject` and `search` matches.
                    if iszero(shr(m, xor(t, s))) {
                        if h {
                            if iszero(eq(keccak256(subject, searchLength), h)) {
                                mstore(result, t)
                                result := add(result, 1)
                                subject := add(subject, 1)
                                if iszero(lt(subject, subjectSearchEnd)) { break }
                                continue
                            }
                        }
                        // Copy the `replacement` one word at a time.
                        for { let o := 0 } 1 {} {
                            mstore(add(result, o), mload(add(replacement, o)))
                            o := add(o, 0x20)
                            if iszero(lt(o, replacementLength)) { break }
                        }
                        result := add(result, replacementLength)
                        subject := add(subject, searchLength)
                        if searchLength {
                            if iszero(lt(subject, subjectSearchEnd)) { break }
                            continue
                        }
                    }
                    mstore(result, t)
                    result := add(result, 1)
                    subject := add(subject, 1)
                    if iszero(lt(subject, subjectSearchEnd)) { break }
                }
            }

            let resultRemainder := result
            result := add(mload(0x40), 0x20)
            let k := add(sub(resultRemainder, result), sub(subjectEnd, subject))
            // Copy the rest of the string one word at a time.
            for {} lt(subject, subjectEnd) {} {
                mstore(resultRemainder, mload(subject))
                resultRemainder := add(resultRemainder, 0x20)
                subject := add(subject, 0x20)
            }
            result := sub(result, 0x20)
            let last := add(add(result, 0x20), k) // Zeroize the slot after the string.
            mstore(last, 0)
            mstore(0x40, add(last, 0x20)) // Allocate the memory.
            mstore(result, k) // Store the length.
        }
    }

    /// @dev Returns the byte index of the first location of `search` in `subject`,
    /// searching from left to right, starting from `from`.
    /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.
    function indexOf(string memory subject, string memory search, uint256 from)
        internal
        pure
        returns (uint256 result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            for { let subjectLength := mload(subject) } 1 {} {
                if iszero(mload(search)) {
                    if iszero(gt(from, subjectLength)) {
                        result := from
                        break
                    }
                    result := subjectLength
                    break
                }
                let searchLength := mload(search)
                let subjectStart := add(subject, 0x20)

                result := not(0) // Initialize to `NOT_FOUND`.

                subject := add(subjectStart, from)
                let end := add(sub(add(subjectStart, subjectLength), searchLength), 1)

                let m := shl(3, sub(0x20, and(searchLength, 0x1f)))
                let s := mload(add(search, 0x20))

                if iszero(and(lt(subject, end), lt(from, subjectLength))) { break }

                if iszero(lt(searchLength, 0x20)) {
                    for { let h := keccak256(add(search, 0x20), searchLength) } 1 {} {
                        if iszero(shr(m, xor(mload(subject), s))) {
                            if eq(keccak256(subject, searchLength), h) {
                                result := sub(subject, subjectStart)
                                break
                            }
                        }
                        subject := add(subject, 1)
                        if iszero(lt(subject, end)) { break }
                    }
                    break
                }
                for {} 1 {} {
                    if iszero(shr(m, xor(mload(subject), s))) {
                        result := sub(subject, subjectStart)
                        break
                    }
                    subject := add(subject, 1)
                    if iszero(lt(subject, end)) { break }
                }
                break
            }
        }
    }

    /// @dev Returns the byte index of the first location of `search` in `subject`,
    /// searching from left to right.
    /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.
    function indexOf(string memory subject, string memory search)
        internal
        pure
        returns (uint256 result)
    {
        result = indexOf(subject, search, 0);
    }

    /// @dev Returns the byte index of the first location of `search` in `subject`,
    /// searching from right to left, starting from `from`.
    /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.
    function lastIndexOf(string memory subject, string memory search, uint256 from)
        internal
        pure
        returns (uint256 result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            for {} 1 {} {
                result := not(0) // Initialize to `NOT_FOUND`.
                let searchLength := mload(search)
                if gt(searchLength, mload(subject)) { break }
                let w := result

                let fromMax := sub(mload(subject), searchLength)
                if iszero(gt(fromMax, from)) { from := fromMax }

                let end := add(add(subject, 0x20), w)
                subject := add(add(subject, 0x20), from)
                if iszero(gt(subject, end)) { break }
                // As this function is not too often used,
                // we shall simply use keccak256 for smaller bytecode size.
                for { let h := keccak256(add(search, 0x20), searchLength) } 1 {} {
                    if eq(keccak256(subject, searchLength), h) {
                        result := sub(subject, add(end, 1))
                        break
                    }
                    subject := add(subject, w) // `sub(subject, 1)`.
                    if iszero(gt(subject, end)) { break }
                }
                break
            }
        }
    }

    /// @dev Returns the byte index of the first location of `search` in `subject`,
    /// searching from right to left.
    /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.
    function lastIndexOf(string memory subject, string memory search)
        internal
        pure
        returns (uint256 result)
    {
        result = lastIndexOf(subject, search, uint256(int256(-1)));
    }

    /// @dev Returns true if `search` is found in `subject`, false otherwise.
    function contains(string memory subject, string memory search) internal pure returns (bool) {
        return indexOf(subject, search) != NOT_FOUND;
    }

    /// @dev Returns whether `subject` starts with `search`.
    function startsWith(string memory subject, string memory search)
        internal
        pure
        returns (bool result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let searchLength := mload(search)
            // Just using keccak256 directly is actually cheaper.
            // forgefmt: disable-next-item
            result := and(
                iszero(gt(searchLength, mload(subject))),
                eq(
                    keccak256(add(subject, 0x20), searchLength),
                    keccak256(add(search, 0x20), searchLength)
                )
            )
        }
    }

    /// @dev Returns whether `subject` ends with `search`.
    function endsWith(string memory subject, string memory search)
        internal
        pure
        returns (bool result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let searchLength := mload(search)
            let subjectLength := mload(subject)
            // Whether `search` is not longer than `subject`.
            let withinRange := iszero(gt(searchLength, subjectLength))
            // Just using keccak256 directly is actually cheaper.
            // forgefmt: disable-next-item
            result := and(
                withinRange,
                eq(
                    keccak256(
                        // `subject + 0x20 + max(subjectLength - searchLength, 0)`.
                        add(add(subject, 0x20), mul(withinRange, sub(subjectLength, searchLength))),
                        searchLength
                    ),
                    keccak256(add(search, 0x20), searchLength)
                )
            )
        }
    }

    /// @dev Returns `subject` repeated `times`.
    function repeat(string memory subject, uint256 times)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let subjectLength := mload(subject)
            if iszero(or(iszero(times), iszero(subjectLength))) {
                subject := add(subject, 0x20)
                result := mload(0x40)
                let output := add(result, 0x20)
                for {} 1 {} {
                    // Copy the `subject` one word at a time.
                    for { let o := 0 } 1 {} {
                        mstore(add(output, o), mload(add(subject, o)))
                        o := add(o, 0x20)
                        if iszero(lt(o, subjectLength)) { break }
                    }
                    output := add(output, subjectLength)
                    times := sub(times, 1)
                    if iszero(times) { break }
                }
                mstore(output, 0) // Zeroize the slot after the string.
                let resultLength := sub(output, add(result, 0x20))
                mstore(result, resultLength) // Store the length.
                // Allocate the memory.
                mstore(0x40, add(result, add(resultLength, 0x20)))
            }
        }
    }

    /// @dev Returns a copy of `subject` sliced from `start` to `end` (exclusive).
    /// `start` and `end` are byte offsets.
    function slice(string memory subject, uint256 start, uint256 end)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let subjectLength := mload(subject)
            if iszero(gt(subjectLength, end)) { end := subjectLength }
            if iszero(gt(subjectLength, start)) { start := subjectLength }
            if lt(start, end) {
                result := mload(0x40)
                let resultLength := sub(end, start)
                mstore(result, resultLength)
                subject := add(subject, start)
                let w := not(0x1f)
                // Copy the `subject` one word at a time, backwards.
                for { let o := and(add(resultLength, 0x1f), w) } 1 {} {
                    mstore(add(result, o), mload(add(subject, o)))
                    o := add(o, w) // `sub(o, 0x20)`.
                    if iszero(o) { break }
                }
                // Zeroize the slot after the string.
                mstore(add(add(result, 0x20), resultLength), 0)
                // Allocate memory for the length and the bytes,
                // rounded up to a multiple of 32.
                mstore(0x40, add(result, and(add(resultLength, 0x3f), w)))
            }
        }
    }

    /// @dev Returns a copy of `subject` sliced from `start` to the end of the string.
    /// `start` is a byte offset.
    function slice(string memory subject, uint256 start)
        internal
        pure
        returns (string memory result)
    {
        result = slice(subject, start, uint256(int256(-1)));
    }

    /// @dev Returns all the indices of `search` in `subject`.
    /// The indices are byte offsets.
    function indicesOf(string memory subject, string memory search)
        internal
        pure
        returns (uint256[] memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let subjectLength := mload(subject)
            let searchLength := mload(search)

            if iszero(gt(searchLength, subjectLength)) {
                subject := add(subject, 0x20)
                search := add(search, 0x20)
                result := add(mload(0x40), 0x20)

                let subjectStart := subject
                let subjectSearchEnd := add(sub(add(subject, subjectLength), searchLength), 1)
                let h := 0
                if iszero(lt(searchLength, 0x20)) { h := keccak256(search, searchLength) }
                let m := shl(3, sub(0x20, and(searchLength, 0x1f)))
                let s := mload(search)
                for {} 1 {} {
                    let t := mload(subject)
                    // Whether the first `searchLength % 32` bytes of
                    // `subject` and `search` matches.
                    if iszero(shr(m, xor(t, s))) {
                        if h {
                            if iszero(eq(keccak256(subject, searchLength), h)) {
                                subject := add(subject, 1)
                                if iszero(lt(subject, subjectSearchEnd)) { break }
                                continue
                            }
                        }
                        // Append to `result`.
                        mstore(result, sub(subject, subjectStart))
                        result := add(result, 0x20)
                        // Advance `subject` by `searchLength`.
                        subject := add(subject, searchLength)
                        if searchLength {
                            if iszero(lt(subject, subjectSearchEnd)) { break }
                            continue
                        }
                    }
                    subject := add(subject, 1)
                    if iszero(lt(subject, subjectSearchEnd)) { break }
                }
                let resultEnd := result
                // Assign `result` to the free memory pointer.
                result := mload(0x40)
                // Store the length of `result`.
                mstore(result, shr(5, sub(resultEnd, add(result, 0x20))))
                // Allocate memory for result.
                // We allocate one more word, so this array can be recycled for {split}.
                mstore(0x40, add(resultEnd, 0x20))
            }
        }
    }

    /// @dev Returns a arrays of strings based on the `delimiter` inside of the `subject` string.
    function split(string memory subject, string memory delimiter)
        internal
        pure
        returns (string[] memory result)
    {
        uint256[] memory indices = indicesOf(subject, delimiter);
        /// @solidity memory-safe-assembly
        assembly {
            let w := not(0x1f)
            let indexPtr := add(indices, 0x20)
            let indicesEnd := add(indexPtr, shl(5, add(mload(indices), 1)))
            mstore(add(indicesEnd, w), mload(subject))
            mstore(indices, add(mload(indices), 1))
            let prevIndex := 0
            for {} 1 {} {
                let index := mload(indexPtr)
                mstore(indexPtr, 0x60)
                if iszero(eq(index, prevIndex)) {
                    let element := mload(0x40)
                    let elementLength := sub(index, prevIndex)
                    mstore(element, elementLength)
                    // Copy the `subject` one word at a time, backwards.
                    for { let o := and(add(elementLength, 0x1f), w) } 1 {} {
                        mstore(add(element, o), mload(add(add(subject, prevIndex), o)))
                        o := add(o, w) // `sub(o, 0x20)`.
                        if iszero(o) { break }
                    }
                    // Zeroize the slot after the string.
                    mstore(add(add(element, 0x20), elementLength), 0)
                    // Allocate memory for the length and the bytes,
                    // rounded up to a multiple of 32.
                    mstore(0x40, add(element, and(add(elementLength, 0x3f), w)))
                    // Store the `element` into the array.
                    mstore(indexPtr, element)
                }
                prevIndex := add(index, mload(delimiter))
                indexPtr := add(indexPtr, 0x20)
                if iszero(lt(indexPtr, indicesEnd)) { break }
            }
            result := indices
            if iszero(mload(delimiter)) {
                result := add(indices, 0x20)
                mstore(result, sub(mload(indices), 2))
            }
        }
    }

    /// @dev Returns a concatenated string of `a` and `b`.
    /// Cheaper than `string.concat()` and does not de-align the free memory pointer.
    function concat(string memory a, string memory b)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let w := not(0x1f)
            result := mload(0x40)
            let aLength := mload(a)
            // Copy `a` one word at a time, backwards.
            for { let o := and(add(aLength, 0x20), w) } 1 {} {
                mstore(add(result, o), mload(add(a, o)))
                o := add(o, w) // `sub(o, 0x20)`.
                if iszero(o) { break }
            }
            let bLength := mload(b)
            let output := add(result, aLength)
            // Copy `b` one word at a time, backwards.
            for { let o := and(add(bLength, 0x20), w) } 1 {} {
                mstore(add(output, o), mload(add(b, o)))
                o := add(o, w) // `sub(o, 0x20)`.
                if iszero(o) { break }
            }
            let totalLength := add(aLength, bLength)
            let last := add(add(result, 0x20), totalLength)
            // Zeroize the slot after the string.
            mstore(last, 0)
            // Stores the length.
            mstore(result, totalLength)
            // Allocate memory for the length and the bytes,
            // rounded up to a multiple of 32.
            mstore(0x40, and(add(last, 0x1f), w))
        }
    }

    /// @dev Returns a copy of the string in either lowercase or UPPERCASE.
    /// WARNING! This function is only compatible with 7-bit ASCII strings.
    function toCase(string memory subject, bool toUpper)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let length := mload(subject)
            if length {
                result := add(mload(0x40), 0x20)
                subject := add(subject, 1)
                let flags := shl(add(70, shl(5, toUpper)), 0x3ffffff)
                let w := not(0)
                for { let o := length } 1 {} {
                    o := add(o, w)
                    let b := and(0xff, mload(add(subject, o)))
                    mstore8(add(result, o), xor(b, and(shr(b, flags), 0x20)))
                    if iszero(o) { break }
                }
                result := mload(0x40)
                mstore(result, length) // Store the length.
                let last := add(add(result, 0x20), length)
                mstore(last, 0) // Zeroize the slot after the string.
                mstore(0x40, add(last, 0x20)) // Allocate the memory.
            }
        }
    }

    /// @dev Returns a string from a small bytes32 string.
    /// `s` must be null-terminated, or behavior will be undefined.
    function fromSmallString(bytes32 s) internal pure returns (string memory result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := mload(0x40)
            let n := 0
            for {} byte(n, s) { n := add(n, 1) } {} // Scan for '\0'.
            mstore(result, n)
            let o := add(result, 0x20)
            mstore(o, s)
            mstore(add(o, n), 0)
            mstore(0x40, add(result, 0x40))
        }
    }

    /// @dev Returns the small string, with all bytes after the first null byte zeroized.
    function normalizeSmallString(bytes32 s) internal pure returns (bytes32 result) {
        /// @solidity memory-safe-assembly
        assembly {
            for {} byte(result, s) { result := add(result, 1) } {} // Scan for '\0'.
            mstore(0x00, s)
            mstore(result, 0x00)
            result := mload(0x00)
        }
    }

    /// @dev Returns the string as a normalized null-terminated small string.
    function toSmallString(string memory s) internal pure returns (bytes32 result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := mload(s)
            if iszero(lt(result, 33)) {
                mstore(0x00, 0xec92f9a3) // `TooBigForSmallString()`.
                revert(0x1c, 0x04)
            }
            result := shl(shl(3, sub(32, result)), mload(add(s, result)))
        }
    }

    /// @dev Returns a lowercased copy of the string.
    /// WARNING! This function is only compatible with 7-bit ASCII strings.
    function lower(string memory subject) internal pure returns (string memory result) {
        result = toCase(subject, false);
    }

    /// @dev Returns an UPPERCASED copy of the string.
    /// WARNING! This function is only compatible with 7-bit ASCII strings.
    function upper(string memory subject) internal pure returns (string memory result) {
        result = toCase(subject, true);
    }

    /// @dev Escapes the string to be used within HTML tags.
    function escapeHTML(string memory s) internal pure returns (string memory result) {
        /// @solidity memory-safe-assembly
        assembly {
            let end := add(s, mload(s))
            result := add(mload(0x40), 0x20)
            // Store the bytes of the packed offsets and strides into the scratch space.
            // `packed = (stride << 5) | offset`. Max offset is 20. Max stride is 6.
            mstore(0x1f, 0x900094)
            mstore(0x08, 0xc0000000a6ab)
            // Store "&quot;&amp;&#39;&lt;&gt;" into the scratch space.
            mstore(0x00, shl(64, 0x2671756f743b26616d703b262333393b266c743b2667743b))
            for {} iszero(eq(s, end)) {} {
                s := add(s, 1)
                let c := and(mload(s), 0xff)
                // Not in `["\"","'","&","<",">"]`.
                if iszero(and(shl(c, 1), 0x500000c400000000)) {
                    mstore8(result, c)
                    result := add(result, 1)
                    continue
                }
                let t := shr(248, mload(c))
                mstore(result, mload(and(t, 0x1f)))
                result := add(result, shr(5, t))
            }
            let last := result
            mstore(last, 0) // Zeroize the slot after the string.
            result := mload(0x40)
            mstore(result, sub(last, add(result, 0x20))) // Store the length.
            mstore(0x40, add(last, 0x20)) // Allocate the memory.
        }
    }

    /// @dev Escapes the string to be used within double-quotes in a JSON.
    /// If `addDoubleQuotes` is true, the result will be enclosed in double-quotes.
    function escapeJSON(string memory s, bool addDoubleQuotes)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let end := add(s, mload(s))
            result := add(mload(0x40), 0x20)
            if addDoubleQuotes {
                mstore8(result, 34)
                result := add(1, result)
            }
            // Store "\\u0000" in scratch space.
            // Store "0123456789abcdef" in scratch space.
            // Also, store `{0x08:"b", 0x09:"t", 0x0a:"n", 0x0c:"f", 0x0d:"r"}`.
            // into the scratch space.
            mstore(0x15, 0x5c75303030303031323334353637383961626364656662746e006672)
            // Bitmask for detecting `["\"","\\"]`.
            let e := or(shl(0x22, 1), shl(0x5c, 1))
            for {} iszero(eq(s, end)) {} {
                s := add(s, 1)
                let c := and(mload(s), 0xff)
                if iszero(lt(c, 0x20)) {
                    if iszero(and(shl(c, 1), e)) {
                        // Not in `["\"","\\"]`.
                        mstore8(result, c)
                        result := add(result, 1)
                        continue
                    }
                    mstore8(result, 0x5c) // "\\".
                    mstore8(add(result, 1), c)
                    result := add(result, 2)
                    continue
                }
                if iszero(and(shl(c, 1), 0x3700)) {
                    // Not in `["\b","\t","\n","\f","\d"]`.
                    mstore8(0x1d, mload(shr(4, c))) // Hex value.
                    mstore8(0x1e, mload(and(c, 15))) // Hex value.
                    mstore(result, mload(0x19)) // "\\u00XX".
                    result := add(result, 6)
                    continue
                }
                mstore8(result, 0x5c) // "\\".
                mstore8(add(result, 1), mload(add(c, 8)))
                result := add(result, 2)
            }
            if addDoubleQuotes {
                mstore8(result, 34)
                result := add(1, result)
            }
            let last := result
            mstore(last, 0) // Zeroize the slot after the string.
            result := mload(0x40)
            mstore(result, sub(last, add(result, 0x20))) // Store the length.
            mstore(0x40, add(last, 0x20)) // Allocate the memory.
        }
    }

    /// @dev Escapes the string to be used within double-quotes in a JSON.
    function escapeJSON(string memory s) internal pure returns (string memory result) {
        result = escapeJSON(s, false);
    }

    /// @dev Returns whether `a` equals `b`.
    function eq(string memory a, string memory b) internal pure returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := eq(keccak256(add(a, 0x20), mload(a)), keccak256(add(b, 0x20), mload(b)))
        }
    }

    /// @dev Returns whether `a` equals `b`, where `b` is a null-terminated small string.
    function eqs(string memory a, bytes32 b) internal pure returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            // These should be evaluated on compile time, as far as possible.
            let m := not(shl(7, div(not(iszero(b)), 255))) // `0x7f7f ...`.
            let x := not(or(m, or(b, add(m, and(b, m)))))
            let r := shl(7, iszero(iszero(shr(128, x))))
            r := or(r, shl(6, iszero(iszero(shr(64, shr(r, x))))))
            r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
            r := or(r, shl(4, lt(0xffff, shr(r, x))))
            r := or(r, shl(3, lt(0xff, shr(r, x))))
            // forgefmt: disable-next-item
            result := gt(eq(mload(a), add(iszero(x), xor(31, shr(3, r)))),
                xor(shr(add(8, r), b), shr(add(8, r), mload(add(a, 0x20)))))
        }
    }

    /// @dev Packs a single string with its length into a single word.
    /// Returns `bytes32(0)` if the length is zero or greater than 31.
    function packOne(string memory a) internal pure returns (bytes32 result) {
        /// @solidity memory-safe-assembly
        assembly {
            // We don't need to zero right pad the string,
            // since this is our own custom non-standard packing scheme.
            result :=
                mul(
                    // Load the length and the bytes.
                    mload(add(a, 0x1f)),
                    // `length != 0 && length < 32`. Abuses underflow.
                    // Assumes that the length is valid and within the block gas limit.
                    lt(sub(mload(a), 1), 0x1f)
                )
        }
    }

    /// @dev Unpacks a string packed using {packOne}.
    /// Returns the empty string if `packed` is `bytes32(0)`.
    /// If `packed` is not an output of {packOne}, the output behavior is undefined.
    function unpackOne(bytes32 packed) internal pure returns (string memory result) {
        /// @solidity memory-safe-assembly
        assembly {
            // Grab the free memory pointer.
            result := mload(0x40)
            // Allocate 2 words (1 for the length, 1 for the bytes).
            mstore(0x40, add(result, 0x40))
            // Zeroize the length slot.
            mstore(result, 0)
            // Store the length and bytes.
            mstore(add(result, 0x1f), packed)
            // Right pad with zeroes.
            mstore(add(add(result, 0x20), mload(result)), 0)
        }
    }

    /// @dev Packs two strings with their lengths into a single word.
    /// Returns `bytes32(0)` if combined length is zero or greater than 30.
    function packTwo(string memory a, string memory b) internal pure returns (bytes32 result) {
        /// @solidity memory-safe-assembly
        assembly {
            let aLength := mload(a)
            // We don't need to zero right pad the strings,
            // since this is our own custom non-standard packing scheme.
            result :=
                mul(
                    // Load the length and the bytes of `a` and `b`.
                    or(
                        shl(shl(3, sub(0x1f, aLength)), mload(add(a, aLength))),
                        mload(sub(add(b, 0x1e), aLength))
                    ),
                    // `totalLength != 0 && totalLength < 31`. Abuses underflow.
                    // Assumes that the lengths are valid and within the block gas limit.
                    lt(sub(add(aLength, mload(b)), 1), 0x1e)
                )
        }
    }

    /// @dev Unpacks strings packed using {packTwo}.
    /// Returns the empty strings if `packed` is `bytes32(0)`.
    /// If `packed` is not an output of {packTwo}, the output behavior is undefined.
    function unpackTwo(bytes32 packed)
        internal
        pure
        returns (string memory resultA, string memory resultB)
    {
        /// @solidity memory-safe-assembly
        assembly {
            // Grab the free memory pointer.
            resultA := mload(0x40)
            resultB := add(resultA, 0x40)
            // Allocate 2 words for each string (1 for the length, 1 for the byte). Total 4 words.
            mstore(0x40, add(resultB, 0x40))
            // Zeroize the length slots.
            mstore(resultA, 0)
            mstore(resultB, 0)
            // Store the lengths and bytes.
            mstore(add(resultA, 0x1f), packed)
            mstore(add(resultB, 0x1f), mload(add(add(resultA, 0x20), mload(resultA))))
            // Right pad with zeroes.
            mstore(add(add(resultA, 0x20), mload(resultA)), 0)
            mstore(add(add(resultB, 0x20), mload(resultB)), 0)
        }
    }

    /// @dev Directly returns `a` without copying.
    function directReturn(string memory a) internal pure {
        assembly {
            // Assumes that the string does not start from the scratch space.
            let retStart := sub(a, 0x20)
            let retUnpaddedSize := add(mload(a), 0x40)
            // Right pad with zeroes. Just in case the string is produced
            // by a method that doesn't zero right pad.
            mstore(add(retStart, retUnpaddedSize), 0)
            // Store the return offset.
            mstore(retStart, 0x20)
            // End the transaction, returning the string.
            return(retStart, and(not(0x1f), add(0x1f, retUnpaddedSize)))
        }
    }
}