More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 1,333 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
Value | ||||
---|---|---|---|---|---|---|---|---|---|
Transfer | 20196410 | 27 mins ago | IN | 0.01372239 ETH | 0.00004249 | ||||
Transfer | 20196303 | 49 mins ago | IN | 0.02779966 ETH | 0.00004605 | ||||
Transfer | 20196144 | 1 hr ago | IN | 0.04258957 ETH | 0.00005039 | ||||
Transfer | 20196119 | 1 hr ago | IN | 0.01406243 ETH | 0.00004907 | ||||
Transfer | 20195710 | 2 hrs ago | IN | 0.01677753 ETH | 0.0000433 | ||||
Transfer | 20195596 | 3 hrs ago | IN | 0.0149748 ETH | 0.0000409 | ||||
Transfer | 20195051 | 5 hrs ago | IN | 0.01212632 ETH | 0.00003125 | ||||
Transfer | 20194630 | 6 hrs ago | IN | 0.01456946 ETH | 0.00003361 | ||||
Transfer | 20194309 | 7 hrs ago | IN | 0.02031843 ETH | 0.00003544 | ||||
Transfer | 20194104 | 8 hrs ago | IN | 0.01640325 ETH | 0.00003713 | ||||
Transfer | 20194020 | 8 hrs ago | IN | 0.01997248 ETH | 0.00003512 | ||||
Transfer | 20193995 | 8 hrs ago | IN | 0.03047212 ETH | 0.00003436 | ||||
Transfer | 20193588 | 9 hrs ago | IN | 0.17377833 ETH | 0.00003701 | ||||
Transfer | 20193229 | 11 hrs ago | IN | 0.02347108 ETH | 0.0000409 | ||||
Transfer | 20192947 | 12 hrs ago | IN | 0.01803048 ETH | 0.00004219 | ||||
Transfer | 20191889 | 15 hrs ago | IN | 0.02106282 ETH | 0.00011283 | ||||
Transfer | 20191790 | 15 hrs ago | IN | 0.04274374 ETH | 0.00008499 | ||||
Transfer | 20191206 | 17 hrs ago | IN | 0.05118459 ETH | 0.00016639 | ||||
Transfer | 20190965 | 18 hrs ago | IN | 0.12574264 ETH | 0.00022949 | ||||
Transfer | 20190658 | 19 hrs ago | IN | 0.03076468 ETH | 0.00017428 | ||||
Transfer | 20190550 | 20 hrs ago | IN | 0.11835281 ETH | 0.00010121 | ||||
Transfer | 20190524 | 20 hrs ago | IN | 0.02141527 ETH | 0.00009157 | ||||
Transfer | 20190195 | 21 hrs ago | IN | 0.05359339 ETH | 0.0001025 | ||||
Transfer | 20189440 | 23 hrs ago | IN | 0.03692499 ETH | 0.00007169 | ||||
Transfer | 20189400 | 23 hrs ago | IN | 0.01754825 ETH | 0.00010569 |
Latest 10 internal transactions
Advanced mode:
Parent Transaction Hash | Block | From | To | Value | ||
---|---|---|---|---|---|---|
19779015 | 58 days ago | 46.29015529 ETH | ||||
19735355 | 64 days ago | 0.01260349 ETH | ||||
19727804 | 65 days ago | 0.00577062 ETH | ||||
19724797 | 65 days ago | 0.001 ETH | ||||
19545720 | 91 days ago | 0.00075712 ETH | ||||
19545720 | 91 days ago | 0.00283729 ETH | ||||
19489417 | 98 days ago | 0.01373044 ETH | ||||
19489417 | 98 days ago | 0.01839695 ETH | ||||
19473892 | 101 days ago | 0.09582472 ETH | ||||
19375697 | 114 days ago | Contract Creation | 0 ETH |
Loading...
Loading
Minimal Proxy Contract for 0xd94c0ce4f8eefa4ebf44bf6665688edeef213b33
Contract Name:
SplitWallet
Compiler Version
v0.8.4+commit.c7e474f2
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// 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 <[email protected]> * @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); } }
// 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 <[email protected]> */ 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 ); }
// 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 } } } }
{ "optimizer": { "enabled": true, "runs": 200 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "metadata": { "useLiteralContent": true }, "libraries": {} }
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"Unauthorized","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"split","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ReceiveETH","type":"event"},{"inputs":[{"internalType":"contract ERC20","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"sendERC20ToMain","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"sendETHToMain","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"splitMain","outputs":[{"internalType":"contract ISplitMain","name":"","type":"address"}],"stateMutability":"view","type":"function"}]
Latest 25 blocks (From a total of 50 blocks with 1.72 Ether produced)
Block | Transaction | Difficulty | Gas Used | Reward | |
---|---|---|---|---|---|
20019397 | 24 days ago | 61 | 0.00 TH | 4,350,832 (14.50%) | 0.01401044905015604 ETH |
19974221 | 31 days ago | 34 | 0.00 TH | 18,110,417 (60.37%) | 0.229786637082919261 ETH |
19886454 | 43 days ago | 112 | 0.00 TH | 9,412,077 (31.37%) | 0.046740180875103635 ETH |
19815503 | 53 days ago | 34 | 0.00 TH | 1,696,567 (5.66%) | 0.005737629532990898 ETH |
19797317 | 55 days ago | 35 | 0.00 TH | 1,785,072 (5.95%) | 0.003718963063134045 ETH |
19766288 | 60 days ago | 25 | 0.00 TH | 1,211,007 (4.04%) | 0.010016278197779947 ETH |
19727804 | 65 days ago | 160 | 0.00 TH | 13,876,740 (46.26%) | 0.037629002257674288 ETH |
19724797 | 65 days ago | 175 | 0.00 TH | 17,581,255 (58.60%) | 0.088005413825069511 ETH |
19672759 | 73 days ago | 60 | 0.00 TH | 2,555,595 (8.52%) | 0.005580061682990488 ETH |
19665853 | 74 days ago | 89 | 0.00 TH | 4,059,118 (13.53%) | 0.008951920744942948 ETH |
19665224 | 74 days ago | 33 | 0.00 TH | 1,928,771 (6.43%) | 0.003410129988673031 ETH |
19662009 | 74 days ago | 63 | 0.00 TH | 2,822,314 (9.41%) | 0.007921779590608313 ETH |
19661443 | 74 days ago | 78 | 0.00 TH | 4,723,555 (15.75%) | 0.018250837608949539 ETH |
19660687 | 74 days ago | 55 | 0.00 TH | 2,953,327 (9.84%) | 0.008732533061735762 ETH |
19655647 | 75 days ago | 42 | 0.00 TH | 2,726,790 (9.09%) | 0.008793453468335309 ETH |
19649390 | 76 days ago | 169 | 0.00 TH | 9,374,579 (31.25%) | 0.068772960916298789 ETH |
19645783 | 77 days ago | 37 | 0.00 TH | 1,684,752 (5.62%) | 0.004407042633638631 ETH |
19641416 | 77 days ago | 63 | 0.00 TH | 4,419,935 (14.73%) | 0.059547948602499831 ETH |
19637729 | 78 days ago | 31 | 0.00 TH | 1,430,618 (4.77%) | 0.003855225628965093 ETH |
19633109 | 78 days ago | 45 | 0.00 TH | 1,556,665 (5.19%) | 0.005525757860552497 ETH |
19632583 | 78 days ago | 62 | 0.00 TH | 2,852,015 (9.51%) | 0.008175874977026752 ETH |
19631348 | 79 days ago | 174 | 0.00 TH | 7,684,278 (25.61%) | 0.029103613115571134 ETH |
19626549 | 79 days ago | 61 | 0.00 TH | 5,220,074 (17.40%) | 0.013060850765399943 ETH |
19624209 | 80 days ago | 58 | 0.00 TH | 3,034,262 (10.11%) | 0.00816385080984708 ETH |
19621214 | 80 days ago | 83 | 0.00 TH | 4,414,468 (14.71%) | 0.012850411661164235 ETH |
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|---|---|---|---|---|
ETH | 100.00% | $3,384.08 | 71.3464 | $241,441.92 |
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.