Skip to content
Socket

Catalog / module / distribution

Fee splitter

v1

Split incoming ETH and your token between wallets, a vault and a burn, by percentage.

Deploy this module

What it does

fee-splitter v1

Splits ETH and, optionally, your launch token between up to 8 recipients by percentage. Recipients can be wallets, a burn, a reward vault or another Socket module.

What it does

Value comes in three ways:

- from your **pons fee sink** (`onPonsFees`), with no extra fee - from anyone through `deposit(tokens)` (ETH as `msg.value`) - as plain transfers straight to the splitter

Anyone can press **Split now** (`distribute()`). It first takes the fee on any plain transfer (`_absorb`), then pays each recipient its share.

| Kind | ETH | Launch token | |---|---|---| | `0` WALLET | pushed with a 100k gas cap; if refused, kept as `owed` | pushed; if refused, kept as `owed` | | `1` BURN | **not allowed** (rejected in the config) | `burn()`, then checked against `totalSupply` | | `2` VAULT | wrapped to WETH first (`wrapEth` required), then `fund(poolId, amount)` | `fund(poolId, amount)` | | `3` INSTANCE | `fund{value}(poolId, amount)`, or WETH if `wrapEth` | `fund(poolId, amount)` |

Each recipient has an `asset` mask: `1` = ETH, `2` = token, `3` = both (wallets only). ETH shares must add up to 10,000 bps, and so must token shares (when a launch token is set). VAULT and INSTANCE targets must be factory instances, and they pull the ERC-20 with `_pullIn`. The splitter is published with `FLAG_CHARGES_INFLOW`, so they see it as an exempt payer and charge nothing.

Every delivery runs in isolation. A reverting, paused, halted or capped recipient is credited `owed`, and the others are still paid. Owed value is retried on every `distribute()`. Wallets can also `claimOwed(asset)`. Value owed to a removed vault or instance can be re-split with `releaseOwed(to, asset)`.

Roles

| Role | Can | |---|---| | Anyone | `distribute()`, `deposit()`, `claimOwed()` (for its own owed), `releaseOwed()` (removed instances only) | | Owner | `proposeSplits` (applied after 72 h with `executeSplits`), `cancelSplits`, `lockSplitsForever`, `pause` / `unpause` deposits, `rescue` above custody |

`executeSplits` distributes everything already held under the **old** split before switching.

Risks in plain English

- A wrong recipient address can only be fixed after a 72 h delay, and never after `lockSplitsForever()`. - Burns rely on the token's `burn()`. A token whose `burn()` does not reduce the total supply is detected, and that share stays owed. It is never counted as burned. - Reward vaults cap how much they hold (a share of the token's supply). A full vault's share waits as owed. - Rounding dust (a few wei per recipient) stays for the next split. - No swaps in v1. ETH stays ETH (or 1:1 WETH), and tokens stay tokens.

Fee lanes

| Flow | When | |---|---| | `SplitInflow` (default 50 bps, hard cap 100) | deposits and direct transfers from outside Socket; free from a flagged instance such as the pons fee sink |

Nothing is ever charged on the way out.

What if

- **I lose my wallet?** Splitting keeps working, because anyone can call `distribute()`. Only split changes stop. - **One recipient breaks?** Its share is kept as owed and retried, and nobody else is blocked. - **Someone sends funds directly?** They are charged once and split on the next `distribute()`. - **I need to change the percentages?** `proposeSplits`, wait 72 h, then `executeSplits`.

Config

``` FeeSplitterConfig(Recipient[] recipients,address launchToken,address weth) Recipient(address to,uint16 bps,uint8 kind,uint8 asset,uint256 poolId,bool wrapEth) ```

WETH on Robinhood Chain is `0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73`. `FeeSplitterPresets` fills it in automatically.

Risks in plain English

  • You choose the recipients. A wrong address cannot be fixed for 72 hours, and never after you lock the split.
  • If a recipient refuses a payment (a wallet that rejects ETH, a paused or full vault) its share is kept for it and retried; the others are still paid.
  • Burns call the token's own burn() and check that the total supply really went down; a token without a working burn() cannot be burned.
  • Rounding dust (a few wei) stays in the splitter and is included in the next split.

What if…

What if I lose my wallet?
Splitting keeps working: anyone can press 'Split now' and every recipient keeps getting paid. You only lose the ability to change the split.
What if one recipient breaks?
Its share is set aside as 'owed' and retried each time. Wallets can claim it themselves. A removed vault's share can be re-split to the current recipients.
What if someone sends ETH or tokens straight to the splitter?
It is split like everything else on the next 'Split now', after the same small fee.
Can I change the percentages?
Yes, by proposing a new split. It takes effect after 72 hours, and what came in before is paid out under the old split first.
Am I charged twice when my pons sink feeds this splitter and it feeds my vault?
No. The fee is taken once, when the money first enters Socket.

Fees

Protocol fee per lane
LaneFee
Splitter inflowwhen money enters from outside Socket (deposits and direct transfers). Free when it comes from your pons fee sink, and free on the way out to your vault.0.5%

Fees are fixed into each contract at deploy and can never change for it. Claims, withdrawals and refunds are never charged. Hard cap 1%, written into the code.

Evidence

Form check
Built from the source files
Implementation
—
Code hash
—

Settings you choose at deploy

  • Who gets whatUp to 8. ETH shares must add up to 100%, and so must token shares.Changeable
  • Your token (optional)Needed to split or burn token-side fees.Locked forever
  • WETHLocked forever

Used in recipes