Create2Error

CreateError

newController

InvalidNewController

accountsLength

allocationsLength

InvalidSplit__AccountsAndAllocationsMismatch

index

InvalidSplit__AccountsOutOfOrder

InvalidSplit__AllocationMustBePositive

allocationsSum

InvalidSplit__InvalidAllocationsSum

distributorFee

InvalidSplit__InvalidDistributorFee

hash

InvalidSplit__InvalidHash

InvalidSplit__TooFewAccounts

sender

Unauthorized

split

CancelControlTransfer

previousController

ControlTransfer

CreateSplit

token

amount

distributorAddress

DistributeERC20

DistributeETH

newPotentialController

InitiateControlTransfer

UpdateSplit

account

ethAmount

tokens

tokenAmounts

Withdrawal

PERCENTAGE_SCALE

acceptControl

cancelControlTransfer

accounts

percentAllocations

controller

createSplit

distributeERC20

distributeETH

getController

getERC20Balance

getETHBalance

getHash

getNewPotentialController

makeSplitImmutable

predictImmutableSplitAddress

transferControl

updateAndDistributeERC20

updateAndDistributeETH

updateSplit

walletImplementation

withdrawETH

withdraw

SplitMain

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.4;

import {ERC20} from '@rari-capital/solmate/src/tokens/ERC20.sol';

/**
 * @title ISplitMain
 * @author 0xSplits <will@0xSplits.xyz>
 */
interface ISplitMain {
  /**
   * FUNCTIONS
   */

  function walletImplementation() external returns (address);

  function createSplit(
    address[] calldata accounts,
    uint32[] calldata percentAllocations,
    uint32 distributorFee,
    address controller
  ) external returns (address);

  function predictImmutableSplitAddress(
    address[] calldata accounts,
    uint32[] calldata percentAllocations,
    uint32 distributorFee
  ) external view returns (address);

  function updateSplit(
    address split,
    address[] calldata accounts,
    uint32[] calldata percentAllocations,
    uint32 distributorFee
  ) external;

  function transferControl(address split, address newController) external;

  function cancelControlTransfer(address split) external;

  function acceptControl(address split) external;

  function makeSplitImmutable(address split) external;

  function distributeETH(
    address split,
    address[] calldata accounts,
    uint32[] calldata percentAllocations,
    uint32 distributorFee,
    address distributorAddress
  ) external;

  function updateAndDistributeETH(
    address split,
    address[] calldata accounts,
    uint32[] calldata percentAllocations,
    uint32 distributorFee,
    address distributorAddress
  ) external;

  function distributeERC20(
    address split,
    ERC20 token,
    address[] calldata accounts,
    uint32[] calldata percentAllocations,
    uint32 distributorFee,
    address distributorAddress
  ) external;

  function updateAndDistributeERC20(
    address split,
    ERC20 token,
    address[] calldata accounts,
    uint32[] calldata percentAllocations,
    uint32 distributorFee,
    address distributorAddress
  ) external;

  function withdraw(
    address account,
    uint256 withdrawETH,
    ERC20[] calldata tokens
  ) external;

  /**
   * EVENTS
   */

  /** @notice emitted after each successful split creation
   *  @param split Address of the created split
   */
  event CreateSplit(address indexed split);

  /** @notice emitted after each successful split update
   *  @param split Address of the updated split
   */
  event UpdateSplit(address indexed split);

  /** @notice emitted after each initiated split control transfer
   *  @param split Address of the split control transfer was initiated for
   *  @param newPotentialController Address of the split's new potential controller
   */
  event InitiateControlTransfer(
    address indexed split,
    address indexed newPotentialController
  );

  /** @notice emitted after each canceled split control transfer
   *  @param split Address of the split control transfer was canceled for
   */
  event CancelControlTransfer(address indexed split);

  /** @notice emitted after each successful split control transfer
   *  @param split Address of the split control was transferred for
   *  @param previousController Address of the split's previous controller
   *  @param newController Address of the split's new controller
   */
  event ControlTransfer(
    address indexed split,
    address indexed previousController,
    address indexed newController
  );

  /** @notice emitted after each successful ETH balance split
   *  @param split Address of the split that distributed its balance
   *  @param amount Amount of ETH distributed
   *  @param distributorAddress Address to credit distributor fee to
   */
  event DistributeETH(
    address indexed split,
    uint256 amount,
    address indexed distributorAddress
  );

  /** @notice emitted after each successful ERC20 balance split
   *  @param split Address of the split that distributed its balance
   *  @param token Address of ERC20 distributed
   *  @param amount Amount of ERC20 distributed
   *  @param distributorAddress Address to credit distributor fee to
   */
  event DistributeERC20(
    address indexed split,
    ERC20 indexed token,
    uint256 amount,
    address indexed distributorAddress
  );

  /** @notice emitted after each successful withdrawal
   *  @param account Address that funds were withdrawn to
   *  @param ethAmount Amount of ETH withdrawn
   *  @param tokens Addresses of ERC20s withdrawn
   *  @param tokenAmounts Amounts of corresponding ERC20s withdrawn
   */
  event Withdrawal(
    address indexed account,
    uint256 ethAmount,
    ERC20[] tokens,
    uint256[] tokenAmounts
  );
}


ISplitMain

ReceiveETH

sendERC20ToMain

sendETHToMain

splitMain

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.4;

import {ISplitMain} from './interfaces/ISplitMain.sol';
import {ERC20} from '@rari-capital/solmate/src/tokens/ERC20.sol';
import {SafeTransferLib} from '@rari-capital/solmate/src/utils/SafeTransferLib.sol';

/**
 * ERRORS
 */

/// @notice Unauthorized sender
error Unauthorized();

/**
 * @title SplitWallet
 * @author 0xSplits <will@0xSplits.xyz>
 * @notice The implementation logic for `SplitProxy`.
 * @dev `SplitProxy` handles `receive()` itself to avoid the gas cost with `DELEGATECALL`.
 */
contract SplitWallet {
  using SafeTransferLib for address;
  using SafeTransferLib for ERC20;

  /**
   * EVENTS
   */

  /** @notice emitted after each successful ETH transfer to proxy
   *  @param split Address of the split that received ETH
   *  @param amount Amount of ETH received
   */
  event ReceiveETH(address indexed split, uint256 amount);

  /**
   * STORAGE
   */

  /**
   * STORAGE - CONSTANTS & IMMUTABLES
   */

  /// @notice address of SplitMain for split distributions & EOA/SC withdrawals
  ISplitMain public immutable splitMain;

  /**
   * MODIFIERS
   */

  /// @notice Reverts if the sender isn't SplitMain
  modifier onlySplitMain() {
    if (msg.sender != address(splitMain)) revert Unauthorized();
    _;
  }

  /**
   * CONSTRUCTOR
   */

  constructor() {
    splitMain = ISplitMain(msg.sender);
  }

  /**
   * FUNCTIONS - PUBLIC & EXTERNAL
   */

  /** @notice Sends amount `amount` of ETH in proxy to SplitMain
   *  @dev payable reduces gas cost; no vulnerability to accidentally lock
   *  ETH introduced since fn call is restricted to SplitMain
   *  @param amount Amount to send
   */
  function sendETHToMain(uint256 amount) external payable onlySplitMain() {
    address(splitMain).safeTransferETH(amount);
  }

  /** @notice Sends amount `amount` of ERC20 `token` in proxy to SplitMain
   *  @dev payable reduces gas cost; no vulnerability to accidentally lock
   *  ETH introduced since fn call is restricted to SplitMain
   *  @param token Token to send
   *  @param amount Amount to send
   */
  function sendERC20ToMain(ERC20 token, uint256 amount)
    external
    payable
    onlySplitMain()
  {
    token.safeTransfer(address(splitMain), amount);
  }
}


SplitWallet

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.4;

/// @notice create opcode failed
error CreateError();
/// @notice create2 opcode failed
error Create2Error();

library Clones {
  /**
   * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`
   * except when someone calls `receive()` and then it emits an event matching
   * `SplitWallet.ReceiveETH(indexed address, amount)`
   * Inspired by OZ & 0age's minimal clone implementations based on eip 1167 found at
   * https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.3.0/contracts/proxy/Clones.sol
   * and https://medium.com/coinmonks/the-more-minimal-proxy-5756ae08ee48
   *
   * This function uses the create2 opcode and a `salt` to deterministically deploy
   * the clone. Using the same `implementation` and `salt` multiple time will revert, since
   * the clones cannot be deployed twice at the same address.
   *
   * init: 0x3d605d80600a3d3981f3
   * 3d   returndatasize  0
   * 605d push1 0x5d      0x5d 0
   * 80   dup1            0x5d 0x5d 0
   * 600a push1 0x0a      0x0a 0x5d 0x5d 0
   * 3d   returndatasize  0 0x0a 0x5d 0x5d 0
   * 39   codecopy        0x5d 0                      destOffset offset length     memory[destOffset:destOffset+length] = address(this).code[offset:offset+length]       copy executing contracts bytecode
   * 81   dup2            0 0x5d 0
   * f3   return          0                           offset length                return memory[offset:offset+length]                                                   returns from this contract call
   *
   * contract: 0x36603057343d52307f830d2d700a97af574b186c80d40429385d24241565b08a7c559ba283a964d9b160203da23d3df35b3d3d3d3d363d3d37363d73bebebebebebebebebebebebebebebebebebebebe5af43d3d93803e605b57fd5bf3
   *     0x000     36       calldatasize      cds
   *     0x001     6030     push1 0x30        0x30 cds
   * ,=< 0x003     57       jumpi
   * |   0x004     34       callvalue         cv
   * |   0x005     3d       returndatasize    0 cv
   * |   0x006     52       mstore
   * |   0x007     30       address           addr
   * |   0x008     7f830d.. push32 0x830d..   id addr
   * |   0x029     6020     push1 0x20        0x20 id addr
   * |   0x02b     3d       returndatasize    0 0x20 id addr
   * |   0x02c     a2       log2
   * |   0x02d     3d       returndatasize    0
   * |   0x02e     3d       returndatasize    0 0
   * |   0x02f     f3       return
   * `-> 0x030     5b       jumpdest
   *     0x031     3d       returndatasize    0
   *     0x032     3d       returndatasize    0 0
   *     0x033     3d       returndatasize    0 0 0
   *     0x034     3d       returndatasize    0 0 0 0
   *     0x035     36       calldatasize      cds 0 0 0 0
   *     0x036     3d       returndatasize    0 cds 0 0 0 0
   *     0x037     3d       returndatasize    0 0 cds 0 0 0 0
   *     0x038     37       calldatacopy      0 0 0 0
   *     0x039     36       calldatasize      cds 0 0 0 0
   *     0x03a     3d       returndatasize    0 cds 0 0 0 0
   *     0x03b     73bebe.. push20 0xbebe..   0xbebe 0 cds 0 0 0 0
   *     0x050     5a       gas               gas 0xbebe 0 cds 0 0 0 0
   *     0x051     f4       delegatecall      suc 0 0
   *     0x052     3d       returndatasize    rds suc 0 0
   *     0x053     3d       returndatasize    rds rds suc 0 0
   *     0x054     93       swap4             0 rds suc 0 rds
   *     0x055     80       dup1              0 0 rds suc 0 rds
   *     0x056     3e       returndatacopy    suc 0 rds
   *     0x057     605b     push1 0x5b        0x5b suc 0 rds
   * ,=< 0x059     57       jumpi             0 rds
   * |   0x05a     fd       revert
   * `-> 0x05b     5b       jumpdest          0 rds
   *     0x05c     f3       return
   *
   */
  function clone(address implementation) internal returns (address instance) {
    assembly {
      let ptr := mload(0x40)
      mstore(
        ptr,
        0x3d605d80600a3d3981f336603057343d52307f00000000000000000000000000
      )
      mstore(
        add(ptr, 0x13),
        0x830d2d700a97af574b186c80d40429385d24241565b08a7c559ba283a964d9b1
      )
      mstore(
        add(ptr, 0x33),
        0x60203da23d3df35b3d3d3d3d363d3d37363d7300000000000000000000000000
      )
      mstore(add(ptr, 0x46), shl(0x60, implementation))
      mstore(
        add(ptr, 0x5a),
        0x5af43d3d93803e605b57fd5bf300000000000000000000000000000000000000
      )
      instance := create(0, ptr, 0x67)
    }
    if (instance == address(0)) revert CreateError();
  }

  function cloneDeterministic(address implementation, bytes32 salt)
    internal
    returns (address instance)
  {
    assembly {
      let ptr := mload(0x40)
      mstore(
        ptr,
        0x3d605d80600a3d3981f336603057343d52307f00000000000000000000000000
      )
      mstore(
        add(ptr, 0x13),
        0x830d2d700a97af574b186c80d40429385d24241565b08a7c559ba283a964d9b1
      )
      mstore(
        add(ptr, 0x33),
        0x60203da23d3df35b3d3d3d3d363d3d37363d7300000000000000000000000000
      )
      mstore(add(ptr, 0x46), shl(0x60, implementation))
      mstore(
        add(ptr, 0x5a),
        0x5af43d3d93803e605b57fd5bf300000000000000000000000000000000000000
      )
      instance := create2(0, ptr, 0x67, salt)
    }
    if (instance == address(0)) revert Create2Error();
  }

  /**
   * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
   */
  function predictDeterministicAddress(
    address implementation,
    bytes32 salt,
    address deployer
  ) internal pure returns (address predicted) {
    assembly {
      let ptr := mload(0x40)
      mstore(
        ptr,
        0x3d605d80600a3d3981f336603057343d52307f00000000000000000000000000
      )
      mstore(
        add(ptr, 0x13),
        0x830d2d700a97af574b186c80d40429385d24241565b08a7c559ba283a964d9b1
      )
      mstore(
        add(ptr, 0x33),
        0x60203da23d3df35b3d3d3d3d363d3d37363d7300000000000000000000000000
      )
      mstore(add(ptr, 0x46), shl(0x60, implementation))
      mstore(
        add(ptr, 0x5a),
        0x5af43d3d93803e605b57fd5bf3ff000000000000000000000000000000000000
      )
      mstore(add(ptr, 0x68), shl(0x60, deployer))
      mstore(add(ptr, 0x7c), salt)
      mstore(add(ptr, 0x9c), keccak256(ptr, 0x67))
      predicted := keccak256(add(ptr, 0x67), 0x55)
    }
  }

  /**
   * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
   */
  function predictDeterministicAddress(address implementation, bytes32 salt)
    internal
    view
    returns (address predicted)
  {
    return predictDeterministicAddress(implementation, salt, address(this));
  }
}


owner

spender

Approval

from

Transfer

DOMAIN_SEPARATOR

PERMIT_TYPEHASH

allowance

approve

balanceOf

decimals

name

nonces

value

deadline

permit

symbol

totalSupply

transfer

transferFrom

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC20.sol)
/// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol)
/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.
abstract contract ERC20 {
    /*///////////////////////////////////////////////////////////////
                                  EVENTS
    //////////////////////////////////////////////////////////////*/

    event Transfer(address indexed from, address indexed to, uint256 amount);

    event Approval(address indexed owner, address indexed spender, uint256 amount);

    /*///////////////////////////////////////////////////////////////
                             METADATA STORAGE
    //////////////////////////////////////////////////////////////*/

    string public name;

    string public symbol;

    uint8 public immutable decimals;

    /*///////////////////////////////////////////////////////////////
                              ERC20 STORAGE
    //////////////////////////////////////////////////////////////*/

    uint256 public totalSupply;

    mapping(address => uint256) public balanceOf;

    mapping(address => mapping(address => uint256)) public allowance;

    /*///////////////////////////////////////////////////////////////
                             EIP-2612 STORAGE
    //////////////////////////////////////////////////////////////*/

    bytes32 public constant PERMIT_TYPEHASH =
        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");

    uint256 internal immutable INITIAL_CHAIN_ID;

    bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;

    mapping(address => uint256) public nonces;

    /*///////////////////////////////////////////////////////////////
                               CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

    constructor(
        string memory _name,
        string memory _symbol,
        uint8 _decimals
    ) {
        name = _name;
        symbol = _symbol;
        decimals = _decimals;

        INITIAL_CHAIN_ID = block.chainid;
        INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
    }

    /*///////////////////////////////////////////////////////////////
                              ERC20 LOGIC
    //////////////////////////////////////////////////////////////*/

    function approve(address spender, uint256 amount) public virtual returns (bool) {
        allowance[msg.sender][spender] = amount;

        emit Approval(msg.sender, spender, amount);

        return true;
    }

    function transfer(address to, uint256 amount) public virtual returns (bool) {
        balanceOf[msg.sender] -= amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(msg.sender, to, amount);

        return true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual returns (bool) {
        uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.

        if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;

        balanceOf[from] -= amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(from, to, amount);

        return true;
    }

    /*///////////////////////////////////////////////////////////////
                              EIP-2612 LOGIC
    //////////////////////////////////////////////////////////////*/

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual {
        require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");

        // Unchecked because the only math done is incrementing
        // the owner's nonce which cannot realistically overflow.
        unchecked {
            bytes32 digest = keccak256(
                abi.encodePacked(
                    "\x19\x01",
                    DOMAIN_SEPARATOR(),
                    keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline))
                )
            );

            address recoveredAddress = ecrecover(digest, v, r, s);

            require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER");

            allowance[recoveredAddress][spender] = value;
        }

        emit Approval(owner, spender, value);
    }

    function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
        return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
    }

    function computeDomainSeparator() internal view virtual returns (bytes32) {
        return
            keccak256(
                abi.encode(
                    keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
                    keccak256(bytes(name)),
                    keccak256("1"),
                    block.chainid,
                    address(this)
                )
            );
    }

    /*///////////////////////////////////////////////////////////////
                       INTERNAL MINT/BURN LOGIC
    //////////////////////////////////////////////////////////////*/

    function _mint(address to, uint256 amount) internal virtual {
        totalSupply += amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(address(0), to, amount);
    }

    function _burn(address from, uint256 amount) internal virtual {
        balanceOf[from] -= amount;

        // Cannot underflow because a user's balance
        // will never be larger than the total supply.
        unchecked {
            totalSupply -= amount;
        }

        emit Transfer(from, address(0), amount);
    }
}


// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

import {ERC20} from "../tokens/ERC20.sol";

/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/utils/SafeTransferLib.sol)
/// @author Modified from Gnosis (https://github.com/gnosis/gp-v2-contracts/blob/main/src/contracts/libraries/GPv2SafeERC20.sol)
/// @dev Use with caution! Some functions in this library knowingly create dirty bits at the destination of the free memory pointer.
library SafeTransferLib {
    /*///////////////////////////////////////////////////////////////
                            ETH OPERATIONS
    //////////////////////////////////////////////////////////////*/

    function safeTransferETH(address to, uint256 amount) internal {
        bool callStatus;

        assembly {
            // Transfer the ETH and store if it succeeded or not.
            callStatus := call(gas(), to, amount, 0, 0, 0, 0)
        }

        require(callStatus, "ETH_TRANSFER_FAILED");
    }

    /*///////////////////////////////////////////////////////////////
                           ERC20 OPERATIONS
    //////////////////////////////////////////////////////////////*/

    function safeTransferFrom(
        ERC20 token,
        address from,
        address to,
        uint256 amount
    ) internal {
        bool callStatus;

        assembly {
            // Get a pointer to some free memory.
            let freeMemoryPointer := mload(0x40)

            // Write the abi-encoded calldata to memory piece by piece:
            mstore(freeMemoryPointer, 0x23b872dd00000000000000000000000000000000000000000000000000000000) // Begin with the function selector.
            mstore(add(freeMemoryPointer, 4), and(from, 0xffffffffffffffffffffffffffffffffffffffff)) // Mask and append the "from" argument.
            mstore(add(freeMemoryPointer, 36), and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // Mask and append the "to" argument.
            mstore(add(freeMemoryPointer, 68), amount) // Finally append the "amount" argument. No mask as it's a full 32 byte value.

            // Call the token and store if it succeeded or not.
            // We use 100 because the calldata length is 4 + 32 * 3.
            callStatus := call(gas(), token, 0, freeMemoryPointer, 100, 0, 0)
        }

        require(didLastOptionalReturnCallSucceed(callStatus), "TRANSFER_FROM_FAILED");
    }

    function safeTransfer(
        ERC20 token,
        address to,
        uint256 amount
    ) internal {
        bool callStatus;

        assembly {
            // Get a pointer to some free memory.
            let freeMemoryPointer := mload(0x40)

            // Write the abi-encoded calldata to memory piece by piece:
            mstore(freeMemoryPointer, 0xa9059cbb00000000000000000000000000000000000000000000000000000000) // Begin with the function selector.
            mstore(add(freeMemoryPointer, 4), and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // Mask and append the "to" argument.
            mstore(add(freeMemoryPointer, 36), amount) // Finally append the "amount" argument. No mask as it's a full 32 byte value.

            // Call the token and store if it succeeded or not.
            // We use 68 because the calldata length is 4 + 32 * 2.
            callStatus := call(gas(), token, 0, freeMemoryPointer, 68, 0, 0)
        }

        require(didLastOptionalReturnCallSucceed(callStatus), "TRANSFER_FAILED");
    }

    function safeApprove(
        ERC20 token,
        address to,
        uint256 amount
    ) internal {
        bool callStatus;

        assembly {
            // Get a pointer to some free memory.
            let freeMemoryPointer := mload(0x40)

            // Write the abi-encoded calldata to memory piece by piece:
            mstore(freeMemoryPointer, 0x095ea7b300000000000000000000000000000000000000000000000000000000) // Begin with the function selector.
            mstore(add(freeMemoryPointer, 4), and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // Mask and append the "to" argument.
            mstore(add(freeMemoryPointer, 36), amount) // Finally append the "amount" argument. No mask as it's a full 32 byte value.

            // Call the token and store if it succeeded or not.
            // We use 68 because the calldata length is 4 + 32 * 2.
            callStatus := call(gas(), token, 0, freeMemoryPointer, 68, 0, 0)
        }

        require(didLastOptionalReturnCallSucceed(callStatus), "APPROVE_FAILED");
    }

    /*///////////////////////////////////////////////////////////////
                         INTERNAL HELPER LOGIC
    //////////////////////////////////////////////////////////////*/

    function didLastOptionalReturnCallSucceed(bool callStatus) private pure returns (bool success) {
        assembly {
            // Get how many bytes the call returned.
            let returnDataSize := returndatasize()

            // If the call reverted:
            if iszero(callStatus) {
                // Copy the revert message into memory.
                returndatacopy(0, 0, returnDataSize)

                // Revert with the same message.
                revert(0, returnDataSize)
            }

            switch returnDataSize
            case 32 {
                // Copy the return data into memory.
                returndatacopy(0, 0, returnDataSize)

                // Set success to whether it returned true.
                success := iszero(iszero(mload(0)))
            }
            case 0 {
                // There was no return data.
                success := 1
            }
            default {
                // It returned some malformed input.
                success := 0
            }
        }
    }
}


Set and perform payment splits in either ETH or Tokens. Can be used for royalty splits or automated payment splits. Accepts both ETH and ERC20 tokens. Splits can be updated and transferred. Whenever a Split receives income, each recipient gets their share.

On-Chain income splitter and distributor

This function is used to distribute ERC20 tokens from a split wallet address to a set of accounts. The function takes in the split wallet address, the ERC20 token to be distributed, an array of accounts to receive the tokens, an array of percentages to allocate the tokens to each account, a distributor fee, and the address of the distributor. The function first calculates the amount of tokens to be split by subtracting 1 from the main balance and the proxy balance of the split wallet address. It then emits an event to log the distribution of the tokens. If a distributor fee is specified, the function calculates the amount of tokens to be allocated to the distributor and subtracts it from the amount to be split. The function then iterates through the array of accounts and allocates the tokens to each account based on the percentage allocations specified. Finally, if there is a proxy balance, the function sends the tokens to the main wallet address. (autogenerated documentation)

This function is used to distribute ETH from a split wallet to a set of accounts. The function takes in the address of the split wallet, an array of addresses to which the ETH should be distributed, an array of percentages that indicate how much ETH should be allocated to each address, a fee that should be taken from the total amount of ETH to be distributed, and an address for the fee to be sent to. The function first calculates the total amount of ETH to be distributed by subtracting 1 from the main balance of the split wallet and adding the proxy balance. It then emits an event to indicate that ETH is being distributed from the split wallet. If a fee is specified, the function calculates the fee amount and subtracts it from the total amount of ETH to be distributed. The function then iterates through the array of addresses and allocates the ETH to each address according to the specified percentages. Finally, if there is any ETH left in the proxy balance, the function sends it to the main balance of the split wallet. (autogenerated documentation)

This function is an internal function that takes an array of uint32 numbers as an argument and returns the sum of all the numbers in the array. It does this by looping through the array and adding each number to the sum variable. The loop is unchecked, meaning that it will not throw an error if the index is out of bounds. (autogenerated documentation)

This function is an internal pure function that takes in an array of addresses, an array of uint32s, and a uint32 as parameters. It returns a bytes32. The function works by taking the parameters and encoding them into a single bytes32 using the abi.encodePacked() function. This bytes32 is then hashed using the keccak256() function, and the resulting hash is returned. (autogenerated documentation)

This function takes in two uint256 values, an amount and a scaledPercent, and returns a scaledAmount. It works by first multiplying the amount by the scaledPercent, and then dividing the result by the PERCENTAGE_SCALE constant. This allows the function to scale the amount by the given percentage. (autogenerated documentation)

This function updates a split in the Splits contract. It takes in an address for the split, an array of addresses for the accounts, an array of uint32 for the percent allocations, and a uint32 for the distributor fee. It then calculates a hash of the split using the _hashSplit() function, and stores the hash in the splits mapping. Finally, it emits an UpdateSplit event. (autogenerated documentation)

This function is used to validate a split hash. It takes in an address split, an array of addresses (accounts), an array of uint32 (percentAllocations), and a uint32 (distributorFee) as parameters. It then calculates a hash using the _hashSplit() function, which takes in the same parameters. It then compares the calculated hash to the hash stored in the splits mapping. If the hashes do not match, the function reverts with an InvalidSplit__InvalidHash error. (autogenerated documentation)

This function is an internal function that allows users to withdraw their ETH balance from an account. It takes an address as an argument and returns the amount of ETH withdrawn. The function subtracts 1 from the ETH balance of the account and sets the balance to 1. It then sends the withdrawn amount to the account using the safeTransferETH function. (autogenerated documentation)

This function is used to withdraw ERC20 tokens from an account. It takes two parameters, an address of the account from which the tokens are to be withdrawn, and an ERC20 token. The function then subtracts 1 from the erc20Balances array for the specified token and account, and then calls the token's safeTransfer function to transfer the withdrawn amount to the specified account. (autogenerated documentation)

This function is used to transfer control of a split (identified by its address) from its current controller to a new controller. It is an external function that overrides the onlySplitNewPotentialController function. The function first deletes the newPotentialController property from the split object in the splits mapping. It then emits a ControlTransfer event, passing in the split address, the current controller address, and the new controller address. Finally, it sets the controller address of the split to the new controller address. (autogenerated documentation)

This function is used to cancel a control transfer of a split. It is an external function that can only be called by the split controller of the split in question. It takes the address of the split as an argument. The function deletes the new potential controller from the splits mapping and emits an event to notify that the control transfer has been cancelled. (autogenerated documentation)

This function creates a new split contract, which is a type of wallet contract that allows multiple users to share ownership of a single wallet. The function takes in an array of addresses (accounts), an array of uint32s (percentAllocations), a uint32 (distributorFee), and an address (controller). It first calculates a hash of the split using the _hashSplit() function, which is used to ensure that the split is unique. If the controller address is 0, then the split is cloned deterministically using the walletImplementation address and the splitHash. If the controller address is not 0, then the split is cloned using the walletImplementation address and the controller address is set to the controller address provided. The splitHash is then stored in the splits mapping and an event is emitted to indicate that the split has been created. (autogenerated documentation)

This function is used to distribute ERC20 tokens to a set of accounts based on a given set of percentages. The function takes in the address of the split, the ERC20 token to be distributed, an array of accounts to receive the tokens, an array of percentages to allocate the tokens, a distributor fee, and the address of the distributor. It first checks to make sure that the split, accounts, percentages, and distributor fee are valid. It then calls the _validSplitHash function to generate a hash of the split, accounts, percentages, and distributor fee. Finally, it calls the _distributeERC20 function to distribute the ERC20 tokens to the accounts based on the given percentages, with the distributor receiving the distributor fee. (autogenerated documentation)

This function is used to distribute ETH to a set of accounts based on a given set of percentages. The function takes in five parameters: the split address, an array of accounts, an array of percent allocations, a distributor fee, and a distributor address. The function first checks to make sure that the split, accounts, and percent allocations are valid, and then it distributes the ETH to the accounts based on the given percentages. The distributor fee is taken out of the total amount of ETH being distributed, and the remaining ETH is sent to the distributor address. (autogenerated documentation)

This function is used to retrieve the address of the controller associated with a given split. The function takes in an address of a split as an argument and returns the address of the controller associated with that split. The function works by accessing the splits mapping, which stores the address of the controller associated with each split. The function then returns the address of the controller associated with the split address that was passed in as an argument. (autogenerated documentation)

This function is used to get the balance of an ERC20 token for a given account. It does this by first looking up the balance of the account in the erc20Balances array, which stores the balance of the account for each token. It then checks if the account has any pending splits, which are stored in the splits array. If there are any pending splits, the function will then call the balanceOf() function of the token to get the balance of the account. Finally, it returns the sum of the two values as the balance of the account for the given token. (autogenerated documentation)

This function is used to get the ETH balance of a given account. It does this by first looking up the account in the ethBalances mapping and returning the value associated with it. If the account is not found in the ethBalances mapping, the function then checks the splits mapping to see if the account has a hash associated with it. If it does, the function returns the balance of the account. If the account is not found in either mapping, the function returns 0. (autogenerated documentation)

This function is used to retrieve the hash associated with a given address split. It takes in an address split as an argument and returns the corresponding hash as a bytes32 value. The function works by accessing the splits mapping, which stores the address split as the key and the associated hash as the value. The function then returns the value associated with the given address split. (autogenerated documentation)

This function is used to retrieve the address of the new potential controller of a given split. It takes in the address of the split as an argument and returns the address of the new potential controller. The function is marked as external and view, meaning that it does not modify the state of the contract and can be called from outside of the contract. The address of the new potential controller is stored in the splits mapping, which is a key-value store that maps split addresses to their associated data. (autogenerated documentation)

This function is used to make a split immutable. It does this by deleting the newPotentialController field from the split, and then emitting a ControlTransfer event with the split address, the current controller address, and a zero address. This sets the controller address to zero, making the split immutable. (autogenerated documentation)

This function is used to predict the address of an immutable split contract. It takes in an array of addresses (accounts), an array of uint32 (percentAllocations) and a uint32 (distributorFee) as input parameters. It first calculates a hash of the split using the _hashSplit() function, which takes in the same input parameters. It then uses the Clones.predictDeterministicAddress() function to predict the address of the immutable split contract using the walletImplementation and the splitHash as parameters. The function returns the address of the immutable split contract. (autogenerated documentation)

This function is used to transfer control of a split contract from one address to another. It takes two parameters, the address of the split contract and the address of the new controller. It first checks that the caller is the current controller of the split contract, and that the new controller is a valid address. If these checks pass, it sets the newPotentialController of the split contract to the new controller address and emits an InitiateControlTransfer event. (autogenerated documentation)

This function is used to update and distribute ERC20 tokens from a given split address. It takes in the split address, the ERC20 token, an array of accounts, an array of percent allocations, a distributor fee, and a distributor address as parameters. The function first calls the _updateSplit() function to update the split with the given accounts, percent allocations, and distributor fee. It then calls the _distributeERC20() function to distribute the ERC20 tokens to the given accounts according to the percent allocations, with the distributor address receiving the distributor fee. (autogenerated documentation)

This function is used to update and distribute ETH from a split contract. It takes in five parameters: the address of the split contract, an array of addresses of the accounts to receive the ETH, an array of uint32s representing the percent allocations for each account, a uint32 representing the distributor fee, and an address of the distributor. The function first calls the _updateSplit() function, which updates the split contract with the new accounts, percent allocations, and distributor fee. It then calls the _distributeETH() function, which distributes the ETH from the split contract to the accounts according to the percent allocations, taking into account the distributor fee. The ETH is sent to the distributor address. (autogenerated documentation)

This function allows the Split Controller to update the details of a given split. The split is identified by its address, and the new details are passed in as calldata parameters. The accounts parameter is an array of addresses that will receive the split funds, the percentAllocations parameter is an array of integers representing the percentage of the split funds each account will receive, and the distributorFee parameter is an integer representing the percentage of the split funds that will be taken as a fee. The function checks that the split controller is authorized to update the split, and that the new details are valid. If both of these conditions are met, the function calls the _updateSplit function to update the split with the new details. (autogenerated documentation)

This function allows a user to withdraw ETH and ERC20 tokens from their account. It takes in an address, the amount of ETH to withdraw, and an array of ERC20 tokens to withdraw. It then creates an array of token amounts to withdraw and stores the amount of ETH to withdraw in a variable. It then calls the _withdraw() and _withdrawERC20() functions to withdraw the ETH and ERC20 tokens respectively. Finally, it emits an event with the account address, the amount of ETH withdrawn, the tokens withdrawn, and the amounts of each token withdrawn. (autogenerated documentation)