Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library SafeMath
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function div(uint256 a, uint256 b, st ...
•  contract royaltySplitter *
•    - function withdraw()
•    - function withdrawERC20(address _token ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-05-11
*/

pragma solidity ^0.8.0;

// RoyaltySplitter built by Byt, Inc.


// Part: OpenZeppelin/[email protected]/IERC20

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

    /**
     * @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);
}

// File: @openzeppelin/contracts/math/SafeMath.sol

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {

    /**
     * @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) {
        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) {
        // 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) {
        if (b == 0) return (false, 0);
        return (true, 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) {
        require(b <= a, "SafeMath: subtraction overflow");
        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) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    /**
     * @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. 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) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        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) {
        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.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * 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) {
        require(b > 0, errorMessage);
        return a / b;
    }

}

/**
 * @dev Simple payment splitter with extended ERC20 functionality
 */
contract royaltySplitter{
    using SafeMath for uint256;

    address payable wallet1=payable(0xA571c6075Ea2DF601909E914E36198528CE610E3); //secondary party wallet
    address payable wallet2=payable(0xaF62166f50b13Db316C6111Da92E4c694a75EBbd);

    uint256 secondaryPartyFee=20; //5%

    constructor () {
    }

    /**
    * Standard fallback function to allow contract to receive payments
    */
    fallback() external payable {}

    /**
     * @dev Withdraw all ether from this contract and send to prespecified 
     * wallets (Callable by anyone)
    */
    function withdraw() external {
        uint256 balance = address(this).balance;
        uint256 walletBalance = balance.mul(secondaryPartyFee).div(100);
        payable(wallet1).transfer(walletBalance);
        payable(wallet2).transfer(balance.sub(walletBalance));
    }

    /**
     * @dev Withdraw all erc20 of the signature argument address from this contract and send to prespecified 
     * wallets (Callable by anyone)
    */
    function withdrawERC20(address _token) external {
        IERC20 targetToken = IERC20(_token);
        uint256 balance = targetToken.balanceOf(address(this));
        uint256 walletBalance = balance.mul(secondaryPartyFee).div(100);
        require(balance > 0, "Nothing to withdraw");

        targetToken.transferFrom(address(this), wallet1, walletBalance);
        targetToken.transferFrom(address(this), wallet2, balance.sub(walletBalance));
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"withdrawERC20","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

7830:1498:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;8418:276;;;;;;;;;;;;;:::i;8867:458::-;;;;;;;;;;-1:-1:-1;8867:458:0;;;;;:::i;:::-;;:::i;8418:276::-;8458:15;8476:21;8458:39;;8508:21;8532:39;8567:3;8532:30;8544:17;;8532:7;:11;;:30;;;;:::i;:::-;:34;;:39::i;:::-;8590:7;;;8582:40;;8508:63;;-1:-1:-1;;;;;;8590:7:0;;8582:40;;;;;8508:63;;8582:40;;8590:7;8582:40;8508:63;8590:7;8582:40;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8641:7:0;;-1:-1:-1;;;;;8641:7:0;8633:53;8659:26;:7;8671:13;8659:11;:26::i;:::-;8633:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8447:247;;8418:276::o;8867:458::-;8990:36;;-1:-1:-1;;;8990:36:0;;9020:4;8990:36;;;451:51:1;8954:6:0;;8926:18;;-1:-1:-1;;;;;8990:21:0;;;;;424:18:1;;8990:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;8972:54;;9037:21;9061:39;9096:3;9061:30;9073:17;;9061:7;:11;;:30;;;;:::i;:39::-;9037:63;;9129:1;9119:7;:11;9111:43;;;;-1:-1:-1;;;9111:43:0;;904:2:1;9111:43:0;;;886:21:1;943:2;923:18;;;916:30;-1:-1:-1;;;962:18:1;;;955:49;1021:18;;9111:43:0;;;;;;;;;9207:7;;9167:63;;-1:-1:-1;;;9167:63:0;;9200:4;9167:63;;;1298:34:1;-1:-1:-1;;;;;9207:7:0;;;1348:18:1;;;1341:43;1400:18;;;1393:34;;;9167:24:0;;;;;;1233:18:1;;9167:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;9281:7:0;;-1:-1:-1;;;;;9241:24:0;;;;;;9274:4;;9281:7;9290:26;:7;9302:13;9290:11;:26::i;:::-;9241:76;;-1:-1:-1;;;;;;9241:76:0;;;;;;;-1:-1:-1;;;;;1316:15:1;;;9241:76:0;;;1298:34:1;1368:15;;;;1348:18;;;1341:43;1400:18;;;1393:34;1233:18;;9241:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;8915:410;;;8867:458;:::o;5409:220::-;5467:7;5491:1;5496;5491:6;5487:20;;-1:-1:-1;5506:1:0;5499:8;;5487:20;5518:9;5530:5;5534:1;5530;:5;:::i;:::-;5518:17;-1:-1:-1;5563:1:0;5554:5;5558:1;5518:17;5554:5;:::i;:::-;:10;5546:56;;;;-1:-1:-1;;;5546:56:0;;2449:2:1;5546:56:0;;;2431:21:1;2488:2;2468:18;;;2461:30;2527:34;2507:18;;;2500:62;-1:-1:-1;;;2578:18:1;;;2571:31;2619:19;;5546:56:0;2247:397:1;5546:56:0;5620:1;-1:-1:-1;5409:220:0;;;;;:::o;6107:153::-;6165:7;6197:1;6193;:5;6185:44;;;;-1:-1:-1;;;6185:44:0;;2851:2:1;6185:44:0;;;2833:21:1;2890:2;2870:18;;;2863:30;2929:28;2909:18;;;2902:56;2975:18;;6185:44:0;2649:350:1;6185:44:0;6247:5;6251:1;6247;:5;:::i;4992:158::-;5050:7;5083:1;5078;:6;;5070:49;;;;-1:-1:-1;;;5070:49:0;;3206:2:1;5070:49:0;;;3188:21:1;3245:2;3225:18;;;3218:30;3284:32;3264:18;;;3257:60;3334:18;;5070:49:0;3004:354:1;5070:49:0;5137:5;5141:1;5137;:5;:::i;14:286:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;168:23;;-1:-1:-1;;;;;220:31:1;;210:42;;200:70;;266:1;263;256:12;513:184;583:6;636:2;624:9;615:7;611:23;607:32;604:52;;;652:1;649;642:12;604:52;-1:-1:-1;675:16:1;;513:184;-1:-1:-1;513:184:1:o;1438:277::-;1505:6;1558:2;1546:9;1537:7;1533:23;1529:32;1526:52;;;1574:1;1571;1564:12;1526:52;1606:9;1600:16;1659:5;1652:13;1645:21;1638:5;1635:32;1625:60;;1681:1;1678;1671:12;1720:127;1781:10;1776:3;1772:20;1769:1;1762:31;1812:4;1809:1;1802:15;1836:4;1833:1;1826:15;1852:168;1925:9;;;1956;;1973:15;;;1967:22;;1953:37;1943:71;;1994:18;;:::i;2025:217::-;2065:1;2091;2081:132;;2135:10;2130:3;2126:20;2123:1;2116:31;2170:4;2167:1;2160:15;2198:4;2195:1;2188:15;2081:132;-1:-1:-1;2227:9:1;;2025:217::o;3363:128::-;3430:9;;;3451:11;;;3448:37;;;3465:18;;:::i

ipfs://866e71510e67eb1aadfa3e945d74bb7bad4ff9e4125fbc7b9389ed90b8911244