Cryo Explorer Ethereum Mainnet

/*
  Copyright 2019-2025 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.0 (the "License").
  You may not use this file except in compliance with the License.
  You may obtain a copy of the License at

  https://www.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions
  and limitations under the License.
*/
// SPDX-License-Identifier: Apache-2.0.
pragma solidity 0.8.24;

import "starkware/starknet/solidity/IStarknetMessaging.sol";

interface ITokenWithdraw {
    function withdraw(
        address token,
        uint256 amount,
        address recipient
    ) external;
}

contract BatchWithdraw {
    IStarknetMessaging public immutable sn_core;
    address public immutable l1_bridge;
    uint256 public immutable l2_bridge;
    address public immutable l1_token;
    address public immutable l1_recipient;
    uint256[] public batch_sizes;

    constructor(
        address _sn_core,
        address _l1_bridge,
        uint256 _l2_bridge,
        address token,
        address recipient,
        uint256[] memory sizes
    ) {
        sn_core = IStarknetMessaging(_sn_core);
        l1_bridge = _l1_bridge;
        l2_bridge = _l2_bridge;
        l1_token = token;
        l1_recipient = recipient;
        for (uint256 i = 0; i < sizes.length; i++) {
            require(sizes[i] < 2**128, "AMOUNT_TOO_BIG");
            batch_sizes.push(sizes[i]);
        }
    }

    function withdrawMsgHash(uint256 amount) internal view returns (bytes32) {
        uint256[] memory payload = new uint256[](5);
        payload[0] = 0; //TRANSFER_FROM_STARKNET
        payload[1] = uint256(uint160(l1_recipient));
        payload[2] = uint256(uint160(l1_token));
        payload[3] = amount;
        payload[4] = 0;
        return sn_core.l2ToL1MsgHash(l2_bridge, l1_bridge, payload);
    }

    function pendingWithdrawals(uint256 amount) public view returns (uint256) {
        bytes32 msgHash = withdrawMsgHash(amount);
        return sn_core.l2ToL1Messages(msgHash);
    }

    function tick() external returns (uint256) {
        uint256 totalPending = 0;
        for (uint256 i = 0; i < batch_sizes.length; i++) {
            uint256 _amount = batch_sizes[i];
            uint256 _count = pendingWithdrawals(_amount);
            totalPending += _count;
            for (uint256 j = 0; j < _count; j++) {
                bytes memory _calldata = abi.encodeWithSelector(
                    ITokenWithdraw(l1_bridge).withdraw.selector,
                    l1_token,
                    _amount,
                    l1_recipient
                );

                (bool success, ) = l1_bridge.call(_calldata);
                if (!success) {
                    break;
                }
            }
        }
        return totalPending;
    }
}

/*
  Copyright 2019-2025 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.0 (the "License").
  You may not use this file except in compliance with the License.
  You may obtain a copy of the License at

  https://www.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions
  and limitations under the License.
*/
// SPDX-License-Identifier: Apache-2.0.
pragma solidity >=0.6.0 <0.9.0;

import "starkware/starknet/solidity/IStarknetMessagingEvents.sol";

interface IStarknetMessaging is IStarknetMessagingEvents {
    /**
      Returns the max fee (in Wei) that StarkNet will accept per single message.
    */
    function getMaxL1MsgFee() external pure returns (uint256);

    /**
      Returns `msg_fee + 1` if there is a pending message associated with the given 'msgHash',
      otherwise, returns 0.
    */
    function l1ToL2Messages(bytes32 msgHash) external view returns (uint256);

    /**
      Returns number of consumable messages with hash of `msgHash`.
    */
    function l2ToL1Messages(bytes32 msgHash) external view returns (uint256);

    /**
      Returns the hash of an L1 -> L2 message.
    */
    function l1ToL2MsgHash(
        address fromAddress,
        uint256 toAddress,
        uint256 selector,
        uint256[] calldata payload,
        uint256 nonce
    ) external pure returns (bytes32);

    /**
      Returns the hash of an L2 -> L1 message.
    */
    function l2ToL1MsgHash(
        uint256 fromAddress,
        address toAddress,
        uint256[] calldata payload
    ) external pure returns (bytes32);

    /**
      Sends a message to an L2 contract.
      This function is payable, the payed amount is the message fee.

      Returns the hash of the message and the nonce of the message.
    */
    function sendMessageToL2(
        uint256 toAddress,
        uint256 selector,
        uint256[] calldata payload
    ) external payable returns (bytes32, uint256);

    /**
      Consumes a message that was sent from an L2 contract.

      Returns the hash of the message.
    */
    function consumeMessageFromL2(uint256 fromAddress, uint256[] calldata payload)
        external
        returns (bytes32);

    /**
      Starts the cancellation of an L1 to L2 message.
      A message can be canceled messageCancellationDelay() seconds after this function is called.

      Note: This function may only be called for a message that is currently pending and the caller
      must be the sender of the that message.
    */
    function startL1ToL2MessageCancellation(
        uint256 toAddress,
        uint256 selector,
        uint256[] calldata payload,
        uint256 nonce
    ) external returns (bytes32);

    /**
      Cancels an L1 to L2 message, this function should be called at least
      messageCancellationDelay() seconds after the call to startL1ToL2MessageCancellation().
      A message may only be cancelled by its sender.
      If the message is missing, the call will revert.

      Note that the message fee is not refunded.
    */
    function cancelL1ToL2Message(
        uint256 toAddress,
        uint256 selector,
        uint256[] calldata payload,
        uint256 nonce
    ) external returns (bytes32);
}

/*
  Copyright 2019-2025 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.0 (the "License").
  You may not use this file except in compliance with the License.
  You may obtain a copy of the License at

  https://www.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions
  and limitations under the License.
*/
// SPDX-License-Identifier: Apache-2.0.
pragma solidity >=0.6.0 <0.9.0;

interface IStarknetMessagingEvents {
    // This event needs to be compatible with the one defined in Output.sol.
    event LogMessageToL1(uint256 indexed fromAddress, address indexed toAddress, uint256[] payload);

    // An event that is raised when a message is sent from L1 to L2.
    event LogMessageToL2(
        address indexed fromAddress,
        uint256 indexed toAddress,
        uint256 indexed selector,
        uint256[] payload,
        uint256 nonce,
        uint256 fee
    );

    // An event that is raised when a message from L2 to L1 is consumed.
    event ConsumedMessageToL1(
        uint256 indexed fromAddress,
        address indexed toAddress,
        uint256[] payload
    );

    // An event that is raised when a message from L1 to L2 is consumed.
    event ConsumedMessageToL2(
        address indexed fromAddress,
        uint256 indexed toAddress,
        uint256 indexed selector,
        uint256[] payload,
        uint256 nonce
    );

    // An event that is raised when a message from L1 to L2 Cancellation is started.
    event MessageToL2CancellationStarted(
        address indexed fromAddress,
        uint256 indexed toAddress,
        uint256 indexed selector,
        uint256[] payload,
        uint256 nonce
    );

    // An event that is raised when a message from L1 to L2 is canceled.
    event MessageToL2Canceled(
        address indexed fromAddress,
        uint256 indexed toAddress,
        uint256 indexed selector,
        uint256[] payload,
        uint256 nonce
    );
}