Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

import "@openzeppelin/contracts/utils/math/SafeMath.sol";

contract RoyaltiesSplitter {
    using SafeMath for uint256;

    uint256 public constant DENOMINATOR = 10000;

    receive() external payable {
        uint256 totalReceived = msg.value;
        payable(0x402A07f0dD37b6209588B63a75EA21B823fAF30e).call{
            value: (totalReceived * 600) / DENOMINATOR
        }("");
        payable(0x2909Cbe186e86798d45C0b3C2ABf1989e287c7D3).call{
            value: (totalReceived * 800) / DENOMINATOR
        }("");
        payable(0x8E12127a6cC135d5479C6DD1B0776ada92D94FAF).call{
            value: (totalReceived * 600) / DENOMINATOR
        }("");
        payable(0x65D3E3D1E940f1f7a848E742a3E44D5A6227DA53).call{
            value: (totalReceived * 8000) / DENOMINATOR
        }("");
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

{
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs",
    "useLiteralContent": true
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [],
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"DENOMINATOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

608060405234801561001057600080fd5b506102a7806100206000396000f3fe6080604052600436106100225760003560e01c8063918f8674146101fe57600080fd5b366101f9573473402a07f0dd37b6209588b63a75ea21b823faf30e61271061004c83610258610246565b6100569190610226565b604051600081818185875af1925050503d8060008114610092576040519150601f19603f3d011682016040523d82523d6000602084013e610097565b606091505b50732909cbe186e86798d45c0b3c2abf1989e287c7d3915061271090506100c083610320610246565b6100ca9190610226565b604051600081818185875af1925050503d8060008114610106576040519150601f19603f3d011682016040523d82523d6000602084013e61010b565b606091505b50738e12127a6cc135d5479c6dd1b0776ada92d94faf9150612710905061013483610258610246565b61013e9190610226565b604051600081818185875af1925050503d806000811461017a576040519150601f19603f3d011682016040523d82523d6000602084013e61017f565b606091505b507365d3e3d1e940f1f7a848e742a3e44d5a6227da53915061271090506101a883611f40610246565b6101b29190610226565b604051600081818185875af1925050503d80600081146101ee576040519150601f19603f3d011682016040523d82523d6000602084013e6101f3565b606091505b50505050005b600080fd5b34801561020a57600080fd5b5061021461271081565b60405190815260200160405180910390f35b60008261024157634e487b7160e01b81526012600452602481fd5b500490565b600081600019048311821515161561026c57634e487b7160e01b81526011600452602481fd5b50029056fea264697066735822122081b9af6cbf1034173f472ae47e89a12a0ed6d7b7459f824e66a18f5e22eb990b64736f6c63430008040033

0x6080604052600436106100225760003560e01c8063918f8674146101fe57600080fd5b366101f9573473402a07f0dd37b6209588b63a75ea21b823faf30e61271061004c83610258610246565b6100569190610226565b604051600081818185875af1925050503d8060008114610092576040519150601f19603f3d011682016040523d82523d6000602084013e610097565b606091505b50732909cbe186e86798d45c0b3c2abf1989e287c7d3915061271090506100c083610320610246565b6100ca9190610226565b604051600081818185875af1925050503d8060008114610106576040519150601f19603f3d011682016040523d82523d6000602084013e61010b565b606091505b50738e12127a6cc135d5479c6dd1b0776ada92d94faf9150612710905061013483610258610246565b61013e9190610226565b604051600081818185875af1925050503d806000811461017a576040519150601f19603f3d011682016040523d82523d6000602084013e61017f565b606091505b507365d3e3d1e940f1f7a848e742a3e44d5a6227da53915061271090506101a883611f40610246565b6101b29190610226565b604051600081818185875af1925050503d80600081146101ee576040519150601f19603f3d011682016040523d82523d6000602084013e6101f3565b606091505b50505050005b600080fd5b34801561020a57600080fd5b5061021461271081565b60405190815260200160405180910390f35b60008261024157634e487b7160e01b81526012600452602481fd5b500490565b600081600019048311821515161561026c57634e487b7160e01b81526011600452602481fd5b50029056fea264697066735822122081b9af6cbf1034173f472ae47e89a12a0ed6d7b7459f824e66a18f5e22eb990b64736f6c63430008040033