Provider economics

Registering locks 1,000 KEP (minStake, owner-adjustable) in the ProviderRegistry. You stay listable only while registered, not deactivated, and stake ≥ minStake — top up any time with topUpStake(amount). Exiting is deliberate: deactivate, settle every active deal, then wait the 7-day UNSTAKE_DELAY before withdrawStake() returns the full amount.

Accepting a deal locks collateral equal to 50% of the deal's total price (collateralBps = 5000) from your wallet, on top of stake. It is returned in full at settlement — or bled away by faults. Keep enough unlocked KEP for incoming deals or the accept transaction reverts.

The client escrows the full deal price at creation. From activation, it vests to you linearly per second over the deal duration. withdrawEarnings pays out whatever has vested since the last claim; settleDeal (callable by anyone after endTime, provided no challenge is open) pays the remainder and releases collateral.

vested(t)  = totalPrice * (t - startTime) / duration
claimable  = vested(now) - paidOut

withdrawEarnings(dealId)   # provider, any time while Active
settleDeal(dealId)         # anyone, after endTime:
                           # pays remainder + returns collateral

Any KEP holder except the provider can challenge(dealId) an active deal, posting a 10 KEP bond (challengeBond), at most once per 12 h per deal (challengeCooldown). The challenged leaf is not chosen by the challenger: it is pinned from chain entropy — the blockhash of the challenge's commit block, hashed with the deal id and fault count, selects a pseudo-random chunk index only after the challenge is issued. If the blockhash lookback lapses before the index is pinned, rebaseChallenge restarts the window instead of slashing — a provider is never punished for a leaf it could not have learned.

You then have 8 h (proofWindow) to submitProof with the chunk bytes and a Merkle path. Success pays the bond to you. Failure lets anyone call reportFault:

collateral     = totalPrice * 50%          # locked at accept
slashPerFault  = collateral / 3            # fixed at accept time

per fault:
  challenger  ← slashPerFault / 2  + 10 KEP bond
  client      ← slashPerFault / 2

3rd fault (termination):
  client      ← unvested escrow + all remaining collateral
  provider    ← nothing further

Each fault slashes a third of the original collateral, split half to the challenger and half to the client. The third fault terminates the deal: the client is refunded all unvested escrow plus every remaining wei of collateral, and your unvested earnings are gone.

The daemon checks vested earnings on every maintenance pass, but claims only when it is economically sensible. A claim goes out when both hold:

claimable ≥ MIN_WITHDRAW_KEP            # worth checking at all
claimable > 2 × estimated tx cost       # worth spending gas on

tx cost = L2 gas × gas price
        + L1 data fee                   # NodeInterface.gasEstimateL1Component
                                        # on Arbitrum Nitro chains

The cost estimate covers L2 execution and, on Arbitrum Nitro chains, the L1 data-fee component queried from the NodeInterface precompile — so small drips are left to accumulate instead of being burned as gas. Earnings that are never individually worth claiming are still paid in full at settleDeal. Tune the floor with MIN_WITHDRAW_KEP.

All daemon behavior is set with environment variables (packages/provider-node/src/config.ts):

For the deploy that sets these for you, go back to the provider guide.