编译器
0.8.23+commit.f704f362
文件 1 的 33：Address.sol
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
文件 2 的 33：Cast.sol
pragma solidity ^0.8.23;
library Cast {
error Overflow();
function toAddress(uint256 _value) internal pure returns (address) {
return address(toUint160(_value));
}
function toUint256(address _value) internal pure returns (uint256) {
return uint256(uint160(_value));
}
function toUint160(uint256 _x) internal pure returns (uint160 y) {
if (_x >> 160 != 0) revert Overflow();
assembly {
y := _x
}
}
}
文件 3 的 33：Clone.sol
pragma solidity ^0.8.23;
library Clone {
error DeploymentFailed();
uint256 private constant FREE_PTR = 0x40;
uint256 private constant ZERO_PTR = 0x60;
function cloneDeterministic(address _implementation, bytes32 _salt) internal returns (address instance) {
assembly ("memory-safe") {
let fp := mload(FREE_PTR)
mstore(0x51, 0x5af43d3d93803e605757fd5bf3)
mstore(0x44, _implementation)
mstore(0x30, 0x593da1005b3d3d3d3d363d3d37363d73)
mstore(0x20, 0x9e4ac34f21c619cefc926c8bd93b54bf5a39c7ab2127a895af1cc0691d7e3dff)
mstore(0x00, 0x60593d8160093d39f336602c57343d527f)
instance := create2(0, 0x0f, 0x71, _salt)
mstore(FREE_PTR, fp)
mstore(ZERO_PTR, 0)
if iszero(instance) {
mstore(0x00, 0x30116425)
revert(0x1c, 0x04)
}
}
}
function initCodeHash(address _implementation) internal pure returns (bytes32 hash) {
assembly {
let fp := mload(FREE_PTR)
mstore(0x51, 0x5af43d3d93803e605757fd5bf3)
mstore(0x44, _implementation)
mstore(0x30, 0x593da1005b3d3d3d3d363d3d37363d73)
mstore(0x20, 0x9e4ac34f21c619cefc926c8bd93b54bf5a39c7ab2127a895af1cc0691d7e3dff)
mstore(0x00, 0x60593d8160093d39f336602c57343d527f)
hash := keccak256(0x0f, 0x71)
mstore(FREE_PTR, fp)
mstore(ZERO_PTR, 0)
}
}
function predictDeterministicAddress(
address _implementation,
bytes32 _salt,
address _deployer
)
internal
pure
returns (address predicted)
{
bytes32 hash = initCodeHash(_implementation);
predicted = predictDeterministicAddress({ _hash: hash, _salt: _salt, _deployer: _deployer });
}
function predictDeterministicAddress(
bytes32 _hash,
bytes32 _salt,
address _deployer
)
internal
pure
returns (address predicted)
{
assembly {
mstore8(0x00, 0xff)
mstore(0x35, _hash)
mstore(0x01, shl(96, _deployer))
mstore(0x15, _salt)
predicted := keccak256(0x00, 0x55)
mstore(0x35, 0)
}
}
}
文件 4 的 33：ECDSA.sol
pragma solidity ^0.8.0;
import "../Strings.sol";
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return;
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
assembly {
mstore(0x00, "\x19Ethereum Signed Message:\n32")
mstore(0x1c, hash)
message := keccak256(0x00, 0x3c)
}
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
assembly {
let ptr := mload(0x40)
mstore(ptr, "\x19\x01")
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
data := keccak256(ptr, 0x42)
}
}
function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x00", validator, data));
}
}
文件 5 的 33：EIP712.sol
pragma solidity ^0.8.8;
import "./ECDSA.sol";
import "../ShortStrings.sol";
import "../../interfaces/IERC5267.sol";
abstract contract EIP712 is IERC5267 {
using ShortStrings for *;
bytes32 private constant _TYPE_HASH =
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 private immutable _cachedDomainSeparator;
uint256 private immutable _cachedChainId;
address private immutable _cachedThis;
bytes32 private immutable _hashedName;
bytes32 private immutable _hashedVersion;
ShortString private immutable _name;
ShortString private immutable _version;
string private _nameFallback;
string private _versionFallback;
constructor(string memory name, string memory version) {
_name = name.toShortStringWithFallback(_nameFallback);
_version = version.toShortStringWithFallback(_versionFallback);
_hashedName = keccak256(bytes(name));
_hashedVersion = keccak256(bytes(version));
_cachedChainId = block.chainid;
_cachedDomainSeparator = _buildDomainSeparator();
_cachedThis = address(this);
}
function _domainSeparatorV4() internal view returns (bytes32) {
if (address(this) == _cachedThis && block.chainid == _cachedChainId) {
return _cachedDomainSeparator;
} else {
return _buildDomainSeparator();
}
}
function _buildDomainSeparator() private view returns (bytes32) {
return keccak256(abi.encode(_TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
}
function eip712Domain()
public
view
virtual
override
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
)
{
return (
hex"0f",
_name.toStringWithFallback(_nameFallback),
_version.toStringWithFallback(_versionFallback),
block.chainid,
address(this),
bytes32(0),
new uint256[](0)
);
}
}
文件 6 的 33：ERC1155Holder.sol
pragma solidity ^0.8.0;
import "./ERC1155Receiver.sol";
contract ERC1155Holder is ERC1155Receiver {
function onERC1155Received(
address,
address,
uint256,
uint256,
bytes memory
) public virtual override returns (bytes4) {
return this.onERC1155Received.selector;
}
function onERC1155BatchReceived(
address,
address,
uint256[] memory,
uint256[] memory,
bytes memory
) public virtual override returns (bytes4) {
return this.onERC1155BatchReceived.selector;
}
}
文件 7 的 33：ERC1155Receiver.sol
pragma solidity ^0.8.0;
import "../IERC1155Receiver.sol";
import "../../../utils/introspection/ERC165.sol";
abstract contract ERC1155Receiver is ERC165, IERC1155Receiver {
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);
}
}
文件 8 的 33：ERC1271.sol
pragma solidity ^0.8.23;
import { EIP712 } from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import { SignatureChecker } from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
abstract contract ERC1271 is EIP712 {
bytes32 private constant _MESSAGE_TYPEHASH = keccak256("SplitWalletMessage(bytes32 hash)");
constructor(string memory _name, string memory _version) EIP712(_name, _version) { }
function isValidSignature(bytes32 hash, bytes calldata signature) public view virtual returns (bytes4 result) {
if (
SignatureChecker.isValidSignatureNow({
signer: getSigner(),
hash: replaySafeHash(hash),
signature: signature
})
) {
return 0x1626ba7e;
}
return 0xffffffff;
}
function replaySafeHash(bytes32 hash) public view virtual returns (bytes32) {
return _hashTypedDataV4(keccak256(abi.encode(_MESSAGE_TYPEHASH, hash)));
}
function getSigner() internal view virtual returns (address);
}
文件 9 的 33：ERC165.sol
pragma solidity ^0.8.0;
import "./IERC165.sol";
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
文件 10 的 33：ERC721Holder.sol
pragma solidity ^0.8.0;
import "../IERC721Receiver.sol";
contract ERC721Holder is IERC721Receiver {
function onERC721Received(address, address, uint256, bytes memory) public virtual override returns (bytes4) {
return this.onERC721Received.selector;
}
}
文件 11 的 33：IERC1155Receiver.sol
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
interface IERC1155Receiver is IERC165 {
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4);
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external returns (bytes4);
}
文件 12 的 33：IERC1271.sol
pragma solidity ^0.8.0;
interface IERC1271 {
function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);
}
文件 13 的 33：IERC165.sol
pragma solidity ^0.8.23;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool supported);
}
文件 14 的 33：IERC20.sol
pragma solidity ^0.8.0;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
文件 15 的 33：IERC20Permit.sol
pragma solidity ^0.8.0;
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
文件 16 的 33：IERC5267.sol
pragma solidity ^0.8.0;
interface IERC5267 {
event EIP712DomainChanged();
function eip712Domain()
external
view
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
);
}
文件 17 的 33：IERC6909.sol
pragma solidity ^0.8.23;
import { IERC165 } from "./IERC165.sol";
interface IERC6909 is IERC165 {
event Transfer(
address caller, address indexed sender, address indexed receiver, uint256 indexed id, uint256 amount
);
event OperatorSet(address indexed owner, address indexed spender, bool approved);
event Approval(address indexed owner, address indexed spender, uint256 indexed id, uint256 amount);
function balanceOf(address owner, uint256 id) external view returns (uint256 amount);
function allowance(address owner, address spender, uint256 id) external view returns (uint256 amount);
function isOperator(address owner, address spender) external view returns (bool approved);
function transfer(address receiver, uint256 id, uint256 amount) external returns (bool);
function transferFrom(address sender, address receiver, uint256 id, uint256 amount) external returns (bool);
function approve(address spender, uint256 id, uint256 amount) external returns (bool);
function setOperator(address spender, bool approved) external returns (bool);
}
文件 18 的 33：IERC721Receiver.sol
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
文件 19 的 33：ISplitsWarehouse.sol
pragma solidity ^0.8.23;
import { IERC6909 } from "./IERC6909.sol";
interface ISplitsWarehouse is IERC6909 {
function NATIVE_TOKEN() external view returns (address);
function deposit(address receiver, address token, uint256 amount) external payable;
function batchDeposit(address[] calldata receivers, address token, uint256[] calldata amounts) external;
function batchTransfer(address[] calldata receivers, address token, uint256[] calldata amounts) external;
function withdraw(address owner, address token) external;
}
文件 20 的 33：Math.sol
pragma solidity ^0.8.0;
library Math {
enum Rounding {
Down,
Up,
Zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1, "Math: mulDiv overflow");
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
文件 21 的 33：Nonces.sol
pragma solidity ^0.8.23;
abstract contract Nonces {
mapping(bytes32 hash => uint256) private _nonces;
function nonces(bytes32 _hash) public view virtual returns (uint256) {
return _nonces[_hash];
}
function useNonce(bytes32 _hash) internal virtual returns (uint256) {
unchecked {
return _nonces[_hash]++;
}
}
}
文件 22 的 33：Pausable.sol
pragma solidity ^0.8.23;
import { Ownable } from "./Ownable.sol";
abstract contract Pausable is Ownable {
error Paused();
event SetPaused(bool paused);
bool public paused;
function __initPausable(address _owner, bool _paused) internal virtual {
__initOwnable(_owner);
paused = _paused;
}
modifier pausable() virtual {
address owner_ = owner;
if (paused) {
if (msg.sender != owner_ && tx.origin != owner_ && msg.sender != address(this)) {
revert Paused();
}
}
_;
}
function setPaused(bool _paused) public virtual onlyOwner {
paused = _paused;
emit SetPaused({ paused: _paused });
}
}
文件 23 的 33：PullSplit.sol
pragma solidity ^0.8.23;
import { Cast } from "../../libraries/Cast.sol";
import { SplitV2Lib } from "../../libraries/SplitV2.sol";
import { SplitWalletV2 } from "../SplitWalletV2.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract PullSplit is SplitWalletV2 {
using SplitV2Lib for SplitV2Lib.Split;
using SafeERC20 for IERC20;
using Cast for address;
constructor(address _splitWarehouse) SplitWalletV2(_splitWarehouse) { }
function distribute(
SplitV2Lib.Split calldata _split,
address _token,
address _distributor
)
external
override
pausable
{
if (splitHash != _split.getHash()) revert InvalidSplit();
(uint256 splitBalance, uint256 warehouseBalance) = getSplitBalance(_token);
assembly {
splitBalance := sub(splitBalance, iszero(iszero(splitBalance)))
warehouseBalance := sub(warehouseBalance, iszero(iszero(warehouseBalance)))
}
if (splitBalance > 0) depositToWarehouse(_token, splitBalance);
_distribute({
_split: _split,
_token: _token,
_amount: warehouseBalance + splitBalance,
_distributor: _distributor
});
}
function distribute(
SplitV2Lib.Split calldata _split,
address _token,
uint256 _distributeAmount,
bool _performWarehouseTransfer,
address _distributor
)
external
override
pausable
{
if (splitHash != _split.getHash()) revert InvalidSplit();
if (_performWarehouseTransfer) {
uint256 amount =
(_token == NATIVE_TOKEN ? address(this).balance : IERC20(_token).balanceOf(address(this))) - 1;
depositToWarehouse(_token, amount);
}
_distribute({ _split: _split, _token: _token, _amount: _distributeAmount, _distributor: _distributor });
}
function depositToWarehouse(address _token, uint256 _amount) public {
if (_token == NATIVE_TOKEN) {
SPLITS_WAREHOUSE.deposit{ value: _amount }({ receiver: address(this), token: _token, amount: _amount });
} else {
try SPLITS_WAREHOUSE.deposit({ receiver: address(this), token: _token, amount: _amount }) { }
catch {
IERC20(_token).approve({ spender: address(SPLITS_WAREHOUSE), amount: type(uint256).max });
SPLITS_WAREHOUSE.deposit({ receiver: address(this), token: _token, amount: _amount });
}
}
}
function _distribute(
SplitV2Lib.Split calldata _split,
address _token,
uint256 _amount,
address _distributor
)
internal
{
(uint256[] memory amounts, uint256 distibutorReward) = _split.getDistributions(_amount);
SPLITS_WAREHOUSE.batchTransfer({ receivers: _split.recipients, token: _token, amounts: amounts });
if (distibutorReward > 0) {
SPLITS_WAREHOUSE.transfer({ receiver: _distributor, id: _token.toUint256(), amount: distibutorReward });
}
emit SplitDistributed({ token: _token, distributor: _distributor, amount: _amount });
}
}
文件 24 的 33：PullSplitFactory.sol
pragma solidity ^0.8.23;
import { SplitFactoryV2 } from "../SplitFactoryV2.sol";
import { PullSplit } from "./PullSplit.sol";
contract PullSplitFactory is SplitFactoryV2 {
constructor(address _splitsWarehouse) {
SPLIT_WALLET_IMPLEMENTATION = address(new PullSplit(_splitsWarehouse));
}
}
文件 25 的 33：SafeERC20.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
import "../extensions/IERC20Permit.sol";
import "../../../utils/Address.sol";
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
}
}
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
_callOptionalReturn(token, approvalCall);
}
}
function safePermit(
IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
(bool success, bytes memory returndata) = address(token).call(data);
return
success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
}
}
文件 26 的 33：ShortStrings.sol
pragma solidity ^0.8.8;
import "./StorageSlot.sol";
type ShortString is bytes32;
library ShortStrings {
bytes32 private constant _FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;
error StringTooLong(string str);
error InvalidShortString();
function toShortString(string memory str) internal pure returns (ShortString) {
bytes memory bstr = bytes(str);
if (bstr.length > 31) {
revert StringTooLong(str);
}
return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));
}
function toString(ShortString sstr) internal pure returns (string memory) {
uint256 len = byteLength(sstr);
string memory str = new string(32);
assembly {
mstore(str, len)
mstore(add(str, 0x20), sstr)
}
return str;
}
function byteLength(ShortString sstr) internal pure returns (uint256) {
uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;
if (result > 31) {
revert InvalidShortString();
}
return result;
}
function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {
if (bytes(value).length < 32) {
return toShortString(value);
} else {
StorageSlot.getStringSlot(store).value = value;
return ShortString.wrap(_FALLBACK_SENTINEL);
}
}
function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {
if (ShortString.unwrap(value) != _FALLBACK_SENTINEL) {
return toString(value);
} else {
return store;
}
}
function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {
if (ShortString.unwrap(value) != _FALLBACK_SENTINEL) {
return byteLength(value);
} else {
return bytes(store).length;
}
}
}
文件 27 的 33：SignedMath.sol
pragma solidity ^0.8.0;
library SignedMath {
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
function average(int256 a, int256 b) internal pure returns (int256) {
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
return uint256(n >= 0 ? n : -n);
}
}
}
文件 28 的 33：SplitFactoryV2.sol
pragma solidity ^0.8.23;
import { Clone } from "../libraries/Clone.sol";
import { SplitV2Lib } from "../libraries/SplitV2.sol";
import { Nonces } from "../utils/Nonces.sol";
import { SplitWalletV2 } from "./SplitWalletV2.sol";
abstract contract SplitFactoryV2 is Nonces {
event SplitCreated(address indexed split, SplitV2Lib.Split splitParams, address owner, address creator);
address public immutable SPLIT_WALLET_IMPLEMENTATION;
function createSplitDeterministic(
SplitV2Lib.Split calldata _splitParams,
address _owner,
address _creator,
bytes32 _salt
)
external
returns (address split)
{
split = Clone.cloneDeterministic({
_implementation: SPLIT_WALLET_IMPLEMENTATION,
_salt: _getSalt({ _splitParams: _splitParams, _owner: _owner, _salt: _salt })
});
SplitWalletV2(split).initialize(_splitParams, _owner);
emit SplitCreated({ split: split, splitParams: _splitParams, owner: _owner, creator: _creator });
}
function createSplit(
SplitV2Lib.Split calldata _splitParams,
address _owner,
address _creator
)
external
returns (address split)
{
bytes32 hash = keccak256(abi.encode(_splitParams, _owner));
split = Clone.cloneDeterministic({
_implementation: SPLIT_WALLET_IMPLEMENTATION,
_salt: keccak256(bytes.concat(hash, abi.encode(useNonce(hash))))
});
SplitWalletV2(split).initialize(_splitParams, _owner);
emit SplitCreated({ split: split, splitParams: _splitParams, owner: _owner, creator: _creator });
}
function predictDeterministicAddress(
SplitV2Lib.Split calldata _splitParams,
address _owner,
bytes32 _salt
)
external
view
returns (address)
{
return _predictDeterministicAddress({ _splitParams: _splitParams, _owner: _owner, _salt: _salt });
}
function predictDeterministicAddress(
SplitV2Lib.Split calldata _splitParams,
address _owner
)
external
view
returns (address)
{
bytes32 hash = keccak256(abi.encode(_splitParams, _owner));
return Clone.predictDeterministicAddress({
_implementation: SPLIT_WALLET_IMPLEMENTATION,
_salt: keccak256(bytes.concat(hash, abi.encode(nonces(hash)))),
_deployer: address(this)
});
}
function isDeployed(
SplitV2Lib.Split calldata _splitParams,
address _owner,
bytes32 _salt
)
external
view
returns (address split, bool exists)
{
split = _predictDeterministicAddress({ _splitParams: _splitParams, _owner: _owner, _salt: _salt });
exists = split.code.length > 0;
}
function _getSalt(
SplitV2Lib.Split calldata _splitParams,
address _owner,
bytes32 _salt
)
internal
pure
returns (bytes32)
{
return keccak256(bytes.concat(abi.encode(_splitParams, _owner), _salt));
}
function _predictDeterministicAddress(
SplitV2Lib.Split calldata _splitParams,
address _owner,
bytes32 _salt
)
internal
view
returns (address)
{
return Clone.predictDeterministicAddress({
_implementation: SPLIT_WALLET_IMPLEMENTATION,
_salt: _getSalt({ _splitParams: _splitParams, _owner: _owner, _salt: _salt }),
_deployer: address(this)
});
}
}
文件 29 的 33：SplitV2.sol
pragma solidity ^0.8.23;
library SplitV2Lib {
error InvalidSplit_TotalAllocationMismatch();
error InvalidSplit_LengthMismatch();
struct Split {
address[] recipients;
uint256[] allocations;
uint256 totalAllocation;
uint16 distributionIncentive;
}
uint256 internal constant PERCENTAGE_SCALE = 1e6;
function getHash(Split calldata _split) internal pure returns (bytes32) {
return keccak256(abi.encode(_split));
}
function getHashMem(Split memory _split) internal pure returns (bytes32) {
return keccak256(abi.encode(_split));
}
function validate(Split calldata _split) internal pure {
uint256 numOfRecipients = _split.recipients.length;
if (_split.allocations.length != numOfRecipients) {
revert InvalidSplit_LengthMismatch();
}
uint256 totalAllocation;
for (uint256 i; i < numOfRecipients; ++i) {
totalAllocation += _split.allocations[i];
}
if (totalAllocation != _split.totalAllocation) revert InvalidSplit_TotalAllocationMismatch();
}
function getDistributions(
Split calldata _split,
uint256 _amount
)
internal
pure
returns (uint256[] memory amounts, uint256 distributorReward)
{
uint256 numOfRecipients = _split.recipients.length;
amounts = new uint256[](numOfRecipients);
distributorReward = calculateDistributorReward(_split, _amount);
_amount -= distributorReward;
for (uint256 i; i < numOfRecipients; ++i) {
amounts[i] = calculateAllocatedAmount(_split, _amount, i);
}
}
function calculateAllocatedAmount(
Split calldata _split,
uint256 _amount,
uint256 _index
)
internal
pure
returns (uint256 allocatedAmount)
{
allocatedAmount = _amount * _split.allocations[_index] / _split.totalAllocation;
}
function calculateDistributorReward(
Split calldata _split,
uint256 _amount
)
internal
pure
returns (uint256 distributorReward)
{
distributorReward = _amount * _split.distributionIncentive / PERCENTAGE_SCALE;
}
function getDistributionsMem(
Split memory _split,
uint256 _amount
)
internal
pure
returns (uint256[] memory amounts, uint256 distributorReward)
{
uint256 numOfRecipients = _split.recipients.length;
amounts = new uint256[](numOfRecipients);
distributorReward = _amount * _split.distributionIncentive / PERCENTAGE_SCALE;
_amount -= distributorReward;
for (uint256 i; i < numOfRecipients; ++i) {
amounts[i] = _amount * _split.allocations[i] / _split.totalAllocation;
}
}
}
文件 30 的 33：SplitWalletV2.sol
pragma solidity ^0.8.23;
import { ISplitsWarehouse } from "../interfaces/ISplitsWarehouse.sol";
import { Cast } from "../libraries/Cast.sol";
import { SplitV2Lib } from "../libraries/SplitV2.sol";
import { ERC1271 } from "../utils/ERC1271.sol";
import { Wallet } from "../utils/Wallet.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
abstract contract SplitWalletV2 is Wallet, ERC1271 {
using SplitV2Lib for SplitV2Lib.Split;
using Cast for address;
error UnauthorizedInitializer();
error InvalidSplit();
event SplitUpdated(SplitV2Lib.Split _split);
event SplitDistributed(address indexed token, address indexed distributor, uint256 amount);
ISplitsWarehouse public immutable SPLITS_WAREHOUSE;
address public immutable FACTORY;
address public immutable NATIVE_TOKEN;
bytes32 public splitHash;
constructor(address _splitWarehouse) ERC1271("splitWallet", "2") {
SPLITS_WAREHOUSE = ISplitsWarehouse(_splitWarehouse);
NATIVE_TOKEN = SPLITS_WAREHOUSE.NATIVE_TOKEN();
FACTORY = msg.sender;
}
function initialize(SplitV2Lib.Split calldata _split, address _owner) external {
if (msg.sender != FACTORY) revert UnauthorizedInitializer();
_split.validate();
splitHash = _split.getHash();
Wallet.__initWallet(_owner);
}
function distribute(SplitV2Lib.Split calldata _split, address _token, address _distributor) external virtual;
function distribute(
SplitV2Lib.Split calldata _split,
address _token,
uint256 _distributeAmount,
bool _performWarehouseTransfer,
address _distributor
)
external
virtual;
function getSplitBalance(address _token) public view returns (uint256 splitBalance, uint256 warehouseBalance) {
splitBalance = (_token == NATIVE_TOKEN) ? address(this).balance : IERC20(_token).balanceOf(address(this));
warehouseBalance = SPLITS_WAREHOUSE.balanceOf(address(this), _token.toUint256());
}
function updateSplit(SplitV2Lib.Split calldata _split) external onlyOwner {
_split.validate();
splitHash = _split.getHash();
emit SplitUpdated(_split);
}
function getSigner() internal view override returns (address) {
return owner;
}
}
文件 31 的 33：StorageSlot.sol
pragma solidity ^0.8.0;
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
struct StringSlot {
string value;
}
struct BytesSlot {
bytes value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
assembly {
r.slot := slot
}
}
function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
assembly {
r.slot := store.slot
}
}
function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
assembly {
r.slot := store.slot
}
}
}
文件 32 的 33：Strings.sol
pragma solidity ^0.8.0;
import "./math/Math.sol";
import "./math/SignedMath.sol";
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
function equal(string memory a, string memory b) internal pure returns (bool) {
return keccak256(bytes(a)) == keccak256(bytes(b));
}
}
文件 33 的 33：Wallet.sol
pragma solidity ^0.8.23;
import { Pausable } from "./Pausable.sol";
import { ERC1155Holder } from "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
import { ERC721Holder } from "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
abstract contract Wallet is Pausable, ERC721Holder, ERC1155Holder {
error InvalidCalldataForEOA(Call call);
struct Call {
address to;
uint256 value;
bytes data;
}
event ExecCalls(Call[] calls);
function __initWallet(address _owner) internal {
__initPausable(_owner, false);
}
function execCalls(Call[] calldata _calls)
external
payable
returns (uint256 blockNumber, bytes[] memory returnData)
{
address caller = msg.sender;
blockNumber = block.number;
uint256 length = _calls.length;
returnData = new bytes[](length);
bool success;
for (uint256 i; i < length; ++i) {
if (caller != owner) revert Unauthorized();
Call calldata calli = _calls[i];
if (calli.to.code.length == 0) {
if (calli.data.length > 0) revert InvalidCalldataForEOA({ call: calli });
}
(success, returnData[i]) = calli.to.call{ value: calli.value }(calli.data);
require(success, string(returnData[i]));
}
emit ExecCalls({ calls: _calls });
}
}
{
"compilationTarget": {
"src/splitters/pull/PullSplitFactory.sol": "PullSplitFactory"
},
"evmVersion": "shanghai",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 5000000
},
"remappings": [
":@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/",
":@prb/test/=node_modules/@prb/test/src/",
":forge-std/=node_modules/forge-std/src/",
":multicaller/=node_modules/multicaller/",
":solady/=node_modules/solady/src/"
],
"viaIR": true
}[{"inputs":[{"internalType":"address","name":"_splitsWarehouse","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"split","type":"address"},{"components":[{"internalType":"address[]","name":"recipients","type":"address[]"},{"internalType":"uint256[]","name":"allocations","type":"uint256[]"},{"internalType":"uint256","name":"totalAllocation","type":"uint256"},{"internalType":"uint16","name":"distributionIncentive","type":"uint16"}],"indexed":false,"internalType":"struct SplitV2Lib.Split","name":"splitParams","type":"tuple"},{"indexed":false,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"address","name":"creator","type":"address"}],"name":"SplitCreated","type":"event"},{"inputs":[],"name":"SPLIT_WALLET_IMPLEMENTATION","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address[]","name":"recipients","type":"address[]"},{"internalType":"uint256[]","name":"allocations","type":"uint256[]"},{"internalType":"uint256","name":"totalAllocation","type":"uint256"},{"internalType":"uint16","name":"distributionIncentive","type":"uint16"}],"internalType":"struct SplitV2Lib.Split","name":"_splitParams","type":"tuple"},{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_creator","type":"address"}],"name":"createSplit","outputs":[{"internalType":"address","name":"split","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address[]","name":"recipients","type":"address[]"},{"internalType":"uint256[]","name":"allocations","type":"uint256[]"},{"internalType":"uint256","name":"totalAllocation","type":"uint256"},{"internalType":"uint16","name":"distributionIncentive","type":"uint16"}],"internalType":"struct SplitV2Lib.Split","name":"_splitParams","type":"tuple"},{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_creator","type":"address"},{"internalType":"bytes32","name":"_salt","type":"bytes32"}],"name":"createSplitDeterministic","outputs":[{"internalType":"address","name":"split","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address[]","name":"recipients","type":"address[]"},{"internalType":"uint256[]","name":"allocations","type":"uint256[]"},{"internalType":"uint256","name":"totalAllocation","type":"uint256"},{"internalType":"uint16","name":"distributionIncentive","type":"uint16"}],"internalType":"struct SplitV2Lib.Split","name":"_splitParams","type":"tuple"},{"internalType":"address","name":"_owner","type":"address"},{"internalType":"bytes32","name":"_salt","type":"bytes32"}],"name":"isDeployed","outputs":[{"internalType":"address","name":"split","type":"address"},{"internalType":"bool","name":"exists","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_hash","type":"bytes32"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address[]","name":"recipients","type":"address[]"},{"internalType":"uint256[]","name":"allocations","type":"uint256[]"},{"internalType":"uint256","name":"totalAllocation","type":"uint256"},{"internalType":"uint16","name":"distributionIncentive","type":"uint16"}],"internalType":"struct SplitV2Lib.Split","name":"_splitParams","type":"tuple"},{"internalType":"address","name":"_owner","type":"address"}],"name":"predictDeterministicAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address[]","name":"recipients","type":"address[]"},{"internalType":"uint256[]","name":"allocations","type":"uint256[]"},{"internalType":"uint256","name":"totalAllocation","type":"uint256"},{"internalType":"uint16","name":"distributionIncentive","type":"uint16"}],"internalType":"struct SplitV2Lib.Split","name":"_splitParams","type":"tuple"},{"internalType":"address","name":"_owner","type":"address"},{"internalType":"bytes32","name":"_salt","type":"bytes32"}],"name":"predictDeterministicAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]
