salt = H( DOMAIN_TAG ‖ chainId ‖ merchantId ‖ invoiceId ‖ schemaVersion )

prefix = keccak256("zksyncCreate2")
       = 0x2020dba91b30cc0006188af794c2fb30dd8520db7e2c088b7fc7c103c00ca494

address = keccak256(
              prefix
            ‖ pad32(senderAddress)        // the deployer (factory)
            ‖ salt                         // 32 bytes
            ‖ bytecodeHash                 // zkSync bytecode hash of the contract
            ‖ keccak256(constructorInput)  // hash of constructor calldata
          )[12:]

import { ethers } from "ethers";

export function zkCreate2Address(
  sender: string,        // factory address
  bytecodeHash: string,  // zkSync bytecode hash (NOT keccak256 of EVM initcode)
  salt: string,          // 32-byte hex
  constructorInput: string = "0x"
): string {
  const prefix = ethers.utils.keccak256(ethers.utils.toUtf8Bytes("zksyncCreate2"));
  const inputHash = ethers.utils.keccak256(constructorInput);
  const hash = ethers.utils.keccak256(
    ethers.utils.concat([
      prefix,
      ethers.utils.zeroPad(sender, 32),
      salt,
      bytecodeHash,
      inputHash,
    ])
  );
  return ethers.utils.getAddress("0x" + hash.slice(26)); // low 20 bytes
}

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

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

contract InvoiceForwarder {
    using SafeERC20 for IERC20;

    address public immutable treasury;
    address public immutable sweeper;

    event Swept(address indexed token, uint256 amount);
    error NotAuthorized();

    constructor(address _treasury, address _sweeper) {
        treasury = _treasury;
        sweeper  = _sweeper;
    }

    modifier onlySweeper() {
        if (msg.sender != sweeper) revert NotAuthorized();
        _;
    }

    function sweep(address[] calldata tokens) external onlySweeper {
        uint256 nativeBal = address(this).balance;
        if (nativeBal > 0) {
            (bool ok, ) = treasury.call{value: nativeBal}("");
            require(ok, "native sweep failed");
            emit Swept(address(0), nativeBal);
        }
        for (uint256 i; i < tokens.length; ++i) {
            uint256 bal = IERC20(tokens[i]).balanceOf(address(this));
            if (bal > 0) {
                IERC20(tokens[i]).safeTransfer(treasury, bal);
                emit Swept(tokens[i], bal);
            }
        }
    }

    receive() external payable {}
}

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

contract ForwarderFactory {
    address public immutable owner;

    event Deployed(bytes32 indexed salt, address forwarder);

    constructor(address _owner) { owner = _owner; }

    function deploy(bytes32 salt, address treasury, address sweeper)
        external
        returns (address forwarder)
    {
        require(msg.sender == owner, "not owner");
        forwarder = address(new InvoiceForwarder{salt: salt}(treasury, sweeper));
        emit Deployed(salt, forwarder);
    }
}

interface IAccount {
    function validateTransaction(bytes32 txHash, bytes32 suggestedSignedHash, Transaction calldata tx)
        external payable returns (bytes4 magic);
    function executeTransaction(bytes32 txHash, bytes32 suggestedSignedHash, Transaction calldata tx)
        external payable;
    function executeTransactionFromOutside(Transaction calldata tx) external payable;
    function payForTransaction(bytes32 txHash, bytes32 suggestedSignedHash, Transaction calldata tx)
        external payable;
    function prepareForPaymaster(bytes32 txHash, bytes32 possibleSignedHash, Transaction calldata tx)
        external payable;
}

interface IPaymaster {
    function validateAndPayForPaymasterTransaction(
        bytes32 txHash,
        bytes32 suggestedSignedHash,
        Transaction calldata tx
    ) external payable returns (bytes4 magic, bytes memory context);

    function postTransaction(
        bytes calldata context,
        Transaction calldata tx,
        bytes32 txHash,
        bytes32 suggestedSignedHash,
        ExecutionResult txResult,
        uint256 maxRefundedGas
    ) external payable;
}