How SharedArc works

SharedArc is one shared USDC stream for a collective: one rate, N shares, one live runway. A pre-funded pool streams ratePerSecond USDC, split among members by mutable integer shares. Joining, leaving or re-weighting mid-stream is one O(1) write that touches nobody else's storage.

Everything on this page is what the DripPool contract actually does. The numbers ticking in the app come from the same arithmetic, mirrored in @sharedarc/sdk, so a member watching their balance fill is watching the chain, not an estimate.

#The accrual, in full

Time enters the contract in exactly one place. Every state-changing function calls _accrue before it touches the rate, the shares, the balance or what is owed.

_accrue(p):
  from = max(p.lastAccrual, p.startTime)
  if (now > from && p.ratePerSecond > 0 && p.totalShares > 0):
      available = p.balance * WAD_PER_UNIT - p.owed          // wad not yet streamed
      dt        = min(now - from, available / p.ratePerSecond) // floor: this is the freeze
      streamed  = p.ratePerSecond * dt
      p.accIndex += streamed * INDEX_SCALE / p.totalShares     // floor
      p.owed     += streamed
  p.lastAccrual = now

_settle(p, m):  // always right after _accrue
  m.pending += m.shares * (p.accIndex - m.index) / INDEX_SCALE // floor
  m.index    = p.accIndex

accIndex is the whole trick. It counts how much one share has earned since the pool was created. A member's own index records where that counter stood the last time they were settled, so the difference times their shares is what they have earned, whatever happened to anyone else in between. Adding a member is one storage write. Re-weighting a member re-prices the whole pool from that second on, and costs the same one write.

Amounts are kept in wad (USDC units × 1e12, i.e. 18 decimals) so that a small rate like 1 USDC per month — about 3.9e-7 USDC per second — does not round to zero. Transfers are still whole USDC units: the sub-unit remainder stays in pending and comes out with the next withdrawal.

#A worked example

A pool streams 3 USDC/day. Members are A with 1 share, B with 1 and C with 2. Somebody deposits 1 USDC.

#What is guaranteed

What is not guaranteed, and is said plainly: this is a payroll, so the owner can pause (setRate(0)), re-weight or cancel at any time. Members are protected for the past, never for the future.

#Statuses

#Plug a Safe, or any DAO, as owner

The pool owner is a plain address. It can be an EOA, a Safe, a governance contract or an agent's wallet — the contract has no built-in governance, no roles and no admin key of its own. Whatever can send a transaction can own a pool.

Ownership moves in two steps: the current owner calls transferPoolOwnership, the new owner calls acceptPoolOwnership. Nothing changes until that second call, so a typo cannot lose a pool. The pair keeps working on a cancelled pool.

#How it compares

#FAQ

Where does the money live? In the DripPool singleton, accounted per pool. Direct USDC transfers to the contract are ignored by the accounting and cannot be recovered — always use deposit.

What does a withdrawal cost? About 0.002 USDC at Arc's 20 gwei floor. Gas is paid in USDC, so a member holding nothing but their payroll can withdraw without acquiring any other asset.

Why do I sometimes see "nothing to withdraw"? Withdrawals move whole USDC units. Below 0.000001 USDC there is nothing to transfer yet; the amount is not lost, it keeps accruing.

Can the pool pay me somewhere else? Yes: setPayoutAddress. It works even with zero shares, which is how a member blocked by the USDC issuer can still receive what the pool owes them.

Is there a token, a fee or an upgrade path? No, no and no. One immutable contract, no admin key over it, no fees, no yield.