Functions

DISCLAIMER // NFA // DYOR

This analysis is based on observations of the contract behavior. We are not smart contract security experts. This document aims to explain what the contract appears to do based on the code. It should not be considered a comprehensive security audit or financial advice. Always verify critical information independently and consult with blockchain security professionals for important decisions.

⊙ generated by robots | curated by humans

METADATA
Contract Address	`0x4320b7C74995E6B7BA8A5918CfA9BB3E39F5C236` (etherscan)
Network	Ethereum Mainnet
Analysis Date	2026-02-03

Function Selectors

SELECTOR	FUNCTION SIGNATURE	CATEGORY
N/A	`receive()`	User
`0x8da5cb5b`	`owner()`	View
`0xf2fde38b`	`transferOwnership(address)`	Admin
`0x6f074e32`	`batchSend(address[],uint256[],address[],uint256[])`	Admin
`0x1be19560`	`sweepToken(address)`	Admin
`0x909b19d9`	`sweepTokens(address[])`	Admin
`0xd47f6877`	`sweepETH()`	Admin

Summary

The contract implements 7 functions for batch operations and fund recovery.

CATEGORY	NUM FUNCTIONS
Total Functions	7
User Functions	1
Admin Functions	5
View Functions	1

User Functions

Function: `receive()`

OverviewActionsState ChangesCode

Fallback function that accepts ETH transfers sent directly to the contract address and emits an event for tracking purposes.

ATTRIBUTE	VALUE
Selector	N/A (fallback)
Parameters	None
Access	Public payable

STEP	ACTION
1	Accept incoming ETH automatically via payable modifier
2	Emit Received event with sender and amount

VARIABLE	CHANGE
`address(this).balance`	Increases by `msg.value`

receive() external payable {
    emit Received(msg.sender, msg.value);
}

Admin Functions

Function: `transferOwnership(address)`

OverviewKey ObservationsPreconditionsActionsState ChangesFailure CasesCode

Transfers contract ownership to a new address using one-step transfer pattern.

ATTRIBUTE	VALUE
Selector	`0xf2fde38b`
Parameters	`address newOwner`
Access	Owner only

FLAG	OBSERVATION
☒	One-step transfer with no pending/accept pattern - typos are permanent
△	Immediate effect - new owner gains control instantly with no delay
☑	Prevents zero address ownership

CONDITION	REQUIREMENT
Caller must be owner	`msg.sender == owner`
New owner not zero	`newOwner != address(0)`

STEP	ACTION
1	Check caller is owner via onlyOwner modifier
2	Validate newOwner is not address(0)
3	Emit OwnershipTransferred event
4	Update owner storage slot to newOwner

VARIABLE	CHANGE
`owner`	Updated from current owner to `newOwner`

CONDITION	REVERT MESSAGE
`msg.sender != owner`	`OwnableUnauthorizedAccount()`
`newOwner == address(0)`	`OwnableInvalidOwner()`

function transferOwnership(address newOwner) external onlyOwner {
    if (newOwner == address(0)) {
        revert OwnableInvalidOwner();
    }

    emit OwnershipTransferred(owner, newOwner);
    owner = newOwner;
}

Function: `batchSend(address[],uint256[],address[],uint256[])`

OverviewKey ObservationsPreconditionsActionsState ChangesFailure CasesCode

Sends ETH and/or ERC20 tokens to multiple recipients in a single atomic transaction. Each recipient can receive both ETH and tokens simultaneously.

ATTRIBUTE	VALUE
Selector	`0x6f074e32`
Parameters	`address[] ethRecipients, uint256[] ethAmounts, address[] tokenRecipients, uint256[] tokenAmounts`
Access	Owner only, payable

FLAG	OBSERVATION
△	External calls in loop to recipient addresses and token contracts
☒	Unbounded loop with no array length limit (gas limit risk)
☑	Atomic operation - single failure reverts entire batch
☑	Arrays validated for matching lengths before processing

CONDITION	REQUIREMENT
Caller must be owner	`msg.sender == owner`
All arrays same length	`ethRecipients.length == ethAmounts.length == tokenRecipients.length == tokenAmounts.length`
Sufficient ETH sent	`msg.value >= sum(ethAmounts)`
Token allowances granted	Contract must have allowance for tokens being sent

STEP	ACTION
1	Validate caller is owner
2	Validate all arrays have same length
3	Loop through each index i
4	If ethAmounts[i] > 0: send ETH to ethRecipients[i]
5	If tokenAmounts[i] > 0: validate token address and transfer tokens
6	Emit events for each successful transfer

VARIABLE	CHANGE
`address(this).balance`	Decreases by sum of ethAmounts
Token balances	Transfer tokenAmounts from contract to recipients

CONDITION	REVERT MESSAGE
`msg.sender != owner`	`OwnableUnauthorizedAccount()`
Arrays length mismatch	`"length mismatch"`
ETH transfer fails	`"ETH send failed"`
`tokenRecipients[i] == address(0)` when `tokenAmounts[i] > 0`	`"token=0"`
Token transfer fails	`SafeERC20FailedOperation()`

function batchSend(
    address[] calldata ethRecipients,
    uint256[] calldata ethAmounts,
    address[] calldata tokenRecipients,
    uint256[] calldata tokenAmounts
) external payable onlyOwner {
    uint256 length = ethRecipients.length;

    require(
        length == ethAmounts.length &&
        length == tokenRecipients.length &&
        length == tokenAmounts.length,
        "length mismatch"
    );

    for (uint256 i = 0; i < length; i++) {
        address ethRecipient = ethRecipients[i];
        uint256 ethAmount = ethAmounts[i];

        if (ethAmount > 0) {
            (bool success, ) = ethRecipient.call{value: ethAmount}("");
            require(success, "ETH send failed");
            emit EthSent(ethRecipient, ethAmount);
        }

        uint256 tokenAmount = tokenAmounts[i];
        address tokenAddress = tokenRecipients[i];

        if (tokenAmount > 0) {
            require(tokenAddress != address(0), "token=0");
            _safeTransfer(tokenAddress, ethRecipient, tokenAmount);
            emit TokenSent(ethRecipient, tokenAddress, tokenAmount);
        }
    }
}

Function: `sweepToken(address)`

OverviewKey ObservationsPreconditionsActionsState ChangesFailure CasesCode

Recovers the entire balance of a single ERC20 token from the contract to the owner address.

ATTRIBUTE	VALUE
Selector	`0x1be19560`
Parameters	`address token`
Access	Owner only

FLAG	OBSERVATION
☑	Silent no-op if token balance is zero (gas-efficient)
△	No token whitelist - owner responsible for selecting legitimate tokens
☑	Uses SafeERC20 pattern for broad compatibility

CONDITION	REQUIREMENT
Caller must be owner	`msg.sender == owner`
Token not zero address	`token != address(0)`

STEP	ACTION
1	Validate caller is owner
2	Validate token address is not zero
3	Query token balance of contract
4	If balance > 0: transfer entire balance to owner
5	Emit Swept event

VARIABLE	CHANGE
Token balance of contract	Decreases to 0
Token balance of owner	Increases by swept amount

CONDITION	REVERT MESSAGE
`msg.sender != owner`	`OwnableUnauthorizedAccount()`
`token == address(0)`	`"token=0"`
Token transfer fails	`SafeERC20FailedOperation()`

function sweepToken(address token) external onlyOwner {
    require(token != address(0), "token=0");

    uint256 balance = _getTokenBalance(token, address(this));

    if (balance > 0) {
        _safeTransfer(token, owner, balance);
        emit Swept(token, balance);
    }
}

Function: `sweepTokens(address[])`

OverviewKey ObservationsPreconditionsActionsState ChangesFailure CasesCode

Recovers multiple ERC20 tokens from the contract to the owner address in a single transaction.

ATTRIBUTE	VALUE
Selector	`0x909b19d9`
Parameters	`address[] tokens`
Access	Owner only

FLAG	OBSERVATION
☑	Gracefully skips zero addresses without reverting
☑	Continues on empty balances (does not revert entire batch)
☒	No array length limit (gas limit risk with large arrays)

CONDITION	REQUIREMENT
Caller must be owner	`msg.sender == owner`

STEP	ACTION
1	Validate caller is owner
2	Loop through each token in array
3	Skip if token is address(0)
4	Query token balance of contract
5	If balance > 0: transfer to owner and emit event
6	Continue to next token

VARIABLE	CHANGE
Token balances of contract	Each token balance decreases to 0
Token balances of owner	Increases by each swept amount

CONDITION	REVERT MESSAGE
`msg.sender != owner`	`OwnableUnauthorizedAccount()`
Token transfer fails	`SafeERC20FailedOperation()`

function sweepTokens(address[] calldata tokens) external onlyOwner {
    for (uint256 i = 0; i < tokens.length; i++) {
        address token = tokens[i];

        if (token == address(0)) {
            continue;
        }

        uint256 balance = _getTokenBalance(token, address(this));

        if (balance > 0) {
            _safeTransfer(token, owner, balance);
            emit Swept(token, balance);
        }
    }
}

Function: `sweepETH()`

OverviewKey ObservationsPreconditionsActionsState ChangesFailure CasesCode

Recovers the entire ETH balance from the contract to the owner address.

ATTRIBUTE	VALUE
Selector	`0xd47f6877`
Parameters	None
Access	Owner only

FLAG	OBSERVATION
☑	Uses .call() instead of .transfer() for gas forwarding
△	No reentrancy guard (owner could be contract that reenters)
☑	Transfers entire balance leaving no dust

CONDITION	REQUIREMENT
Caller must be owner	`msg.sender == owner`

STEP	ACTION
1	Validate caller is owner
2	Get current ETH balance of contract
3	If balance > 0: send entire balance to owner
4	Validate transfer success
5	Emit event

VARIABLE	CHANGE
`address(this).balance`	Decreases to 0
`owner.balance`	Increases by swept amount

CONDITION	REVERT MESSAGE
`msg.sender != owner`	`OwnableUnauthorizedAccount()`
ETH transfer fails	`"sweep ETH failed"`

function sweepETH() external onlyOwner {
    uint256 balance = address(this).balance;

    if (balance > 0) {
        (bool success, ) = owner.call{value: balance}("");
        require(success, "sweep ETH failed");
        emit UnknownSweptEvent(balance);
    }
}

View Functions

Function: `owner()`

OverviewActionsCode

Returns the current owner address.

ATTRIBUTE	VALUE
Selector	`0x8da5cb5b`
Parameters	None
Access	Public view

STEP	ACTION
1	Read owner address from storage slot 0
2	Return owner address

function owner() external view returns (address) {
    return owner;
}

Functions

Function Selectors

Summary

User Functions

Function: receive()

Admin Functions

Function: transferOwnership(address)

Function: batchSend(address[],uint256[],address[],uint256[])

Function: sweepToken(address)

Function: sweepTokens(address[])

Function: sweepETH()

View Functions

Function: owner()

Function: `receive()`

Function: `transferOwnership(address)`

Function: `batchSend(address[],uint256[],address[],uint256[])`

Function: `sweepToken(address)`

Function: `sweepTokens(address[])`

Function: `sweepETH()`

Function: `owner()`