What a $1M park in kUSD actually is.
This is the document /commit refers to. Read the important part first: USDC parked in the Peg Stability Module earns nothing, and there is no function on that contract that parks it in a yield strategy. That is not a temporary state or a roadmap item, it is a property of the deployed code. If rate is your decision criterion, stop here, and take a money market instead.
Read the second most important part immediately after it, because an earlier draft of this page buried it and that was the wrong call. The reserve is not beyond our reach. The same 2-of-3 Safe that administers the module also controls who can mint kUSD. Since 2026-08-06 it can no longer do either instantly. Admin and manager rights on kUSD and on all three PSM modules are held by a TimelockController with a 48 hour delay, so the sequence that mints kUSD against nothing and redeems your reserve out from under you now has to be scheduled in public and sits visible in the queue for two days first. That bounds it, it does not eliminate it. Pausing redemption is still instant, so two signatures can still stop you leaving without notice. We have simulated both and we state them in sections 2, 3 and 6 with the numbers. What is on offer is a dollar whose backing you verify yourself, with an exit you can price before you enter, held by a counterparty whose remaining discretion is written down here rather than discovered later.
Every figure on this page was read on Base at block 49,428,145 on August 1, 2026, on two independent RPC endpoints, and each carries the command that reproduces it. It is a dated snapshot rather than a live feed, because a terms document should be a statement you can check rather than a number that changes while you read it. The live view is at /transparency.
1. Entry: a mint at the published fee, no permission required
You send USDC to the Peg Stability Module and it sends you kUSD. The function is swapStableForKUSD. It carries no role gate and no whitelist: anyone can call it, including you, without asking us. Minting is enabled and the contract is not paused.
The fee is a tiered ladder set on chain, and it is charged the same way in both directions. These are not modelled rates, they are the literal returns of getFee at four sizes:
| Mint size (USDC) | Fee charged | Effective rate |
|---|---|---|
| 1,000 | 1.00 | 10 bps |
| 50,000 | 40.00 | 8 bps |
| 250,000 | 175.00 | 7 bps |
| 1,000,000 | 500.00 | 5 bps |
A $1,000,000 mint costs $500 and settles in one transaction. Capacity is not a constraint: the USDC cap is 10,000,000 with 30 currently taken, so 9,999,970 of headroom is open right now. We do not quote a flat rate anywhere, because the contract does not charge one. /dossier/capacity executes that claim rather than stating it: a fork test mints one million USDC through the deployed bytecode and asserts that one USDC past the headroom reverts.
2. What holds the money, and what it can do with it
Your USDC sits in the module, and every flow is between your own addresses and the deployed contracts. That is not the same as saying nobody can take it, so here is the ceiling rather than the slogan.
kUSD has no supply cap and swapKUSDForStableTo is permissionless, so whoever holds DEFAULT_ADMIN_ROLE on kUSD can grant the minting role, mint kUSD backed by nothing, and redeem the entire reserve to an address of its choosing. We simulated exactly that on a forked mainnet with a $1,000,000 anchor deposit in place: the module's USDC goes from $999,529.97 to $29.97, the chosen address receives $999,500, and the anchor is left holding 999,500 kUSD whose redemption reverts InsufficientStableReserves. That simulation is still the correct ceiling. What changed is the clock.
Until 2026-08-06 the 2-of-3 Safe held that role directly and the sequence above took three transactions with no delay and no warning. On 2026-08-06 at 17:00:07Z, in transaction 0xed24d495 at block 49623130, admin and manager rights on kUSD and on all three PSM modules moved to a TimelockController at 0x36A14976980B7Dd33136f6613545EB0A2C0a0D72 with a 48 hour minimum delay. The Safe is still the proposer, executor and canceller on that timelock, so it can still ask for any of this. It cannot land it instantly. The first step of the drain is now a scheduled, public operation that sits in the timelock queue for two days before it can execute.
The delay does not make the drain impossible. It makes it observable, and it gives you two days to leave, provided we do not pause the exit in the meantime, which we can still do in a single transaction with no notice. Read the delay as notice rather than as a veto. Nobody outside the Safe holds the power to cancel a queued operation, because no third party has been granted that role, so what the timelock buys you is warning and the chance to redeem, not somebody else's permission being required. Price it that way rather than as a solved problem. Two things in particular are not covered. Pausing a module is deliberately not delayed, so redemption can still be stopped in one transaction, which is the subject of section 6. And the staking vault skUSD at 0x96F5102C15b839757f811A98CEc3725Ac21DfA14 holds most of the kUSD in existence and the Safe still holds sole admin over it with no delay at all. Extending the timelock to it is the next step and it has not been taken.
Two things narrow that exposure, and we would rather state them than let the 88 percent stand unqualified. First, there is no proxy anywhere in this system. All three EIP-1967 slots, implementation, admin and beacon, read zero on all eight contracts, so there is no upgrade path that routes around the delay: the code you audit is the code that runs until a new address is deployed and publicly pointed at. Second, the skUSD admin cannot take staker principal. ItssweepDonations releases only the raw balance minus tracked assets, and that difference is exactly zero right now, both figures being 1,011.582169134048985696. Its setYieldVestingPeriod is hard bounded between one hour and thirty days and re-bases rather than jumping the share price. The honest residual on skUSD is role widening and a hot key strategist, not seizure of what stakers deposited. That is a smaller risk than the percentage alone suggests, and it is still a real one.
With that ceiling stated, here is what the contract itself is able to do with the balance while it sits there.
- There is no yield-deployment egress that outlasts a transaction. No function on the module parks reserve USDC in a strategy, a vault, a lending market or a bridge. That is why the balance earns zero, and it is a property of the code rather than a policy. One function does push the reserve to an arbitrary address,
flashLoan, and it is covered below. Every other transfer out of this contract is a redemption to the caller or a fee skim to the treasury. - The module grants no allowances.
approveandallowancedo not appear anywhere in its deployed runtime, so the reserve cannot be pulled by an allowance, and it has no ERC-1271 or fallback either, so a signature-based permit cannot authorise a pull round the back. It can still be pushed: a flash loan sends it to a caller-chosen address for one transaction, andswapKUSDForStableTosends it to a caller-chosen address against kUSD. The absence ofapprovecloses one mechanism, not every mechanism. We checked this with a method that correctly finds the selectors that are there (transfer,transferFrom,mint,burn), because a naive scan misses left-aligned call selectors and would have produced a confident false negative. The sharper control: run the identical scan against Kerne's own v2 vault and it does findapprove. So the absence on this module is a real difference between two contracts, not an artifact of how we looked. - The code cannot be changed. The runtime contains zero
DELEGATECALL, zeroCREATE, zeroCREATE2and zeroSELFDESTRUCT. It is not a proxy, and what is deployed there is what runs. Two things that does not mean. It does not mean the arrangement cannot change: the upgrade path for this system is deploying a new module and moving the mint role, which is exactly what we did on July 10, 2026, and the backing stayed behind in the old one. It does not mean the asset is immutable either, because USDC is itself an upgradeable proxy with a third-party blacklister. And note the scope: the properties in this section were verified against the live module, which is a different build from the retired one holding most of the backing, 11,376 bytes against 11,247. - The admin can skim accrued fees, and the admin also sets what counts as a fee.
skimSurplussends fee revenue to the treasury, callable only by the Safe, and we say that on the basis section 6 demands, a full replay of role events on the module rather than ahasRolecall against addresses we chose to check. It is bounded byskimmableSurplus, the lesser of the fee ledger and the balance above net backing. Nobody can inflate that ledger with a donation, and backing cannot be pulled through it. Two things to price anyway. First, your own mint fills it: a $1,000,000 entry pays $500 of fee and raises the ceiling from $0.03 to $500.03 in the same transaction, so the ceiling is a function of your deposit, not a small constant. Second, the rate is a parameter, not a promise:setTieredFeesaccepts up to 500 bps, so the same two signatures can still raise your exit fee after you have entered and convert up to 5 percent of your principal into skimmable "fees". Since 2026-08-06 that call isMANAGER_ROLEheld by the timelock, so it has to be scheduled in public and sits visible for 48 hours first. That gives you notice, not protection: nobody outside the Safe can cancel it, so the delay is time to redeem rather than a veto. A covenant in a signed letter not to worsen your redemption tier is the only thing that closes it outright, and it is contractual rather than on chain. Note also that the retired module runs its own spigot with $0.998 skimmable to a different treasury address, so the honest system-wide figure today is $1.028, not $0.03. - The second exception, which you would find in the ABI anyway: the reserve is flash-loanable. The module implements ERC-3156.
flashLoanis permissionless, the fee is currently zero, andmaxFlashLoanreturns the entire balance. Repayment is genuinely enforced: the loan must be repaid inside the same transaction or the whole call reverts, so a flash loan cannot leave the reserve short at the end of a block. That is a statement about flash loans, not a guarantee that the reserve is always full; the box above and section 3 cover the things that can actually empty it. Two further disclosures on the fee. A zero fee means your principal is free flash liquidity for any contract on Base and you are not paid for it, and when the fee is switched on it accrues to the treasury rather than to kUSD holders. AndflashFeereturns zero unconditionally for holders of anARBITRAGEUR_ROLE, which is a private fee-exemption primitive sitting in deployed code. Nobody holds it today, confirmed by replaying every role event on the module. We disclose it because we publish a "no private exemptions" line elsewhere, and a primitive that could quietly contradict it should be named by us rather than found by you.
3. Exit, and the reconciliation you would otherwise fail us on
Redemption is swapKUSDForStable. Like the mint, it carries no role gate, so no address is whitelisted and none is excluded. You get par, less the same tiered fee charged on the way in. Symmetric means the same ladder both directions, not free.
It is not unstoppable, and we are not going to imply it is. Every swap path carries whenNotPaused. Since 2026-08-06 the Safe no longer holds MANAGER_ROLE on the modules directly. It reaches pause() through a PauseGuardian at 0xC47adaf51907bB1871D07E18eA21dc75Ae93Cc8E, a contract whose only function is pause(module) and which refuses any caller except the Safe. That is still a single transaction with no delay, so two signatures can still halt redemption instantly.
The switch is asymmetric, and more so than before. unpause() requires the admin role, which now sits behind the 48 hour timelock, so restarting a paused module takes two days. We publish that as a property rather than a caveat: fast to stop, slow to restart. It removes our own ability to pause an exit and then quietly resume once we have done whatever we paused for. The quieter levers moved the same way and are no longer instant: setOracle, setSolvencyCheckDisabled(false) and setMaxDepegBps each now have to be scheduled in public and sit visible for 48 hours before they can land. You do not need our permission to leave. You do need us not to close the door, and closing it is the one move we can still make without notice.
Here is the part a five minute diligence pass finds and reads as insolvency. The live mint module holds thirty dollars. Most of the backing sits in a different, retired module:
| Module | USDC held | What it is |
|---|---|---|
Live mint PSM 0xaBDE1138aa1Ce88d1dF06422C0c3b05D70569803 | 30.00 | Holds the kUSD minting role. This is where a new mint enters. |
Retired mint PSM 0x07eBb486e11BD217e6085eb5ab663e4517595993 | 998.00 | Superseded on July 10, 2026. Its minting role is revoked, so it can no longer create kUSD, but it still redeems from its own reserve and holds most of the backing. |
Redeem reserve 0xFf3025ec18e301855aB0f36Ec6ECa115a29A5Fbc | 85.885006 | Earlier module, redeem only, backing residual kUSD. |
That reconciles, and it reconciles in our favour rather than against us. At the snapshot block above (49,428,145, August 1, 2026), total USDC across the three modules was 1,113.885006. kUSD outstanding is supply less the inventory held at all three modules, which at that point was only the 32 sitting at the redeem reserve, so 1,112.707154. Backing was 100.11 percent. Nothing is missing. The backing simply did not move when the mint role did, because moving it would have been an unnecessary transaction with real risk attached.
Those are stamped readings, not live ones. On 2026-08-03 a 3 kUSD redemption executed against the retired module, so the figures on each side are now about three dollars lower and the backing ratio is unchanged. The live values are served at kerne.fi/api/stats, and the figures below carry the same August 1, 2026 stamp.
Read that definition carefully, because the one-module version of it breaks the first time anyone uses the exit described below. The retired module does not burn what it redeems. Its runtime contains no burn call, unlike the live module, so kUSD redeemed there parks on its balance as inventory and totalSupply does not move. If you subtracted inventory at only one module, a single legitimate $998 redemption would make this page's own backing figure read about 10 percent. Subtract inventory wherever it sits and the ratio stays honest. We are pointing at this because it is the kind of formula that looks fine until it is used once.
The operational consequence is the number that matters to you, and it is the reason this section exists rather than a line in a footnote: each module pays only from its own reserve, so the deepest single-transaction exit measured at the snapshot block above was $998.00, against the retired module. Reaching all $1,113.89 required sequential transactions against three different addresses. At current book size an anchor cannot exit a meaningful position instantly, and no amount of framing changes that. What fixes it is the reserve growing, which is the same thing an anchor mint does.
That $998.00 is measured, not inferred from a balance. Simulating a redemption against the retired module at 998 kUSD clears every gate and stops only because the simulated caller has not approved its kUSD. The same simulation at 999 kUSD reverts InsufficientStableReserves. The boundary is exactly where the reserve says it is, and section 8 gives you both commands so you can watch it move as the reserve changes.
Now the half of that truth we had been leaving out, because stating only the first half answers your question wrongly. Every figure above describes the exit of somebody who did not mint. It is the right figure for a holder who bought kUSD from a third party and wants out. It is the wrong figure for you, because an anchor mint is not a claim on the reserve above. It is a deposit into the module you would redeem against, and it lands there in the same transaction that issues your kUSD.
We simulated it rather than argued it, against real deployed bytecode on a fork of Base at block 49,493,576. The three legs stood at 30.000000, 85.885006 and 998.000000 USDC. A 1,000,000.000000 USDC mint moved the live mint module from 30.000000 to 1,000,030.000000 and returned 999,500.000000 kUSD, the 500.00 difference being the 5 bps tier. Then all 999,500 kUSD redeemed in a single transaction, 155,816 gas, for 998,800.350000 USDC, and totalSupply returned to its 1,144.707154 baseline exactly, so the kUSD was burned rather than parked. No queue, no tranches, no second address. The module the swap router selects for that redemption is the smallest leg that fully covers it, which after the mint is the module holding your own money.
The rate is one for one. The round trip is not free, and the first fact must not be allowed to stand in for the second. The trip above cost 1,199.65, being 500.00 in at 5 bps and 699.65 out at 7 bps, both from the same published ladder. The redemption prices one tier cheaper than the mint for the mundane reason that 999,500 is below the 1,000,000 threshold, so the exit tier is set by what you redeem rather than by what you minted. Call it about 12 bps all in, and price it before you enter rather than after.
What this does not fix, stated in the same breath. It does not give a non-minting holder one dollar more depth than the figure above. It does not touch the pause switch in section 4, which stops redemption without stopping the clock on you. It does not touch the mint authority in section 6, which is the reason your reserve sitting in the module is not the same as your reserve being safe: the same two signatures that let us hold it let us mint against nothing and redeem it out. And it is a property of the deposit, not a reservation of it, so the reserve you fund is the same shared reserve anyone else may redeem against. What it does establish is narrow and worth having: at anchor size the exit is one transaction against a module you filled yourself, not a sequence against three addresses holding a thousand dollars between them.
4. What can stop the door, in both directions
Four things can revert a swap, and each gates redemption exactly as it gates minting. A gate that protects the reserve is also a gate that can delay your exit, and you should price both halves. Two are market conditions, below. The other two are operator controlled: the pause switch covered in section 3, which is still instant, and a solvency check which is currently switched off and which since 2026-08-06 can only be re-armed through the 48 hour timelock, so that one now comes with two days of public notice. If you price only the market gates you have mispriced your exit.
- Oracle staleness. The module reads Chainlink USDC/USD and reverts if the price is older than its configured window. The window is 172,800 seconds, which is 48 hours. It was 93,600 seconds, or 26 hours, until 2026-08-03, when a queued Safe transaction widening it executed. That feed is a 24 hour heartbeat whose worst observed gap across fifteen consecutive rounds was 24.008 hours, so the margin in the worst case is now about 24 hours rather than the 1.99 hours it was before. Read that in both directions: a missed heartbeat is far less likely to halt minting and redemption, and equally the module will now accept a price up to two days old. This was a deliberate loosening, recorded as such.
- Depeg band. If USDC itself deviates more than 2 percent from a dollar, both directions halt. This protects the reserve from being drained at a bad price and equally prevents you from redeeming during that window.
5. What it earns
Parked, nothing. kUSD pays no yield for holding it, and the reserve backing it is not deployed. Repeating the top of this page because it is the single most important thing on it: a million dollars minted and held earns zero percent.
There is a separate staking receipt, skUSD, and it is open: you can stake kUSD and redeem instantly, with no cooldown. We are not going to present that as the answer, because the honest record is that exactly one yield distribution has ever reached it in its entire life, of 0.1 kUSD, in July 2026. An incentive that had been advertised on top of it was withdrawn on August 1, 2026 when we established that no mechanism existed to pay it. The realistic carry this strategy can produce, at maximum leverage with zero cost, is under 8 percent, which is not a market-beating number and we are not going to pretend otherwise.
The disclosure an allocator should weigh most heavily is who else is here, so here is the entire holder set, replayed from every kUSD transfer since the token was created. There are 27 transfers in its whole history and seven holders:
- 1,011.58 sits inside the staking contract, and every share of it belongs to one wallet, ours.
- 84.99 sits in our own founder wallet. It was protocol-seeded liquidity in an Aerodrome pool until we withdrew that position on August 1, 2026, which moved the kUSD out of the pool contract and into the wallet. It has never been sold and the withdrawal minted and burned nothing.
- 32.00 is inventory in our own superseded redeem reserve.
- 10.09 sits in our retired staking contract, and it is not ours. Every share of it belongs to a single external wallet that is not any Kerne operational address, which bought roughly 9.99 kUSD through the module with its own USDC in June 2026 and staked it. It can redeem at will and we cannot touch it.
- 5.98 is what is left in that Aerodrome pool after the withdrawal. The pool has recorded zero buys and zero sells since it was funded.
- 0.0065 is our own operations bot.
- That leaves two external wallets holding 10.145055 kUSD between them.
So third-party demand for kUSD today is about ten dollars, across two wallets, or 0.91 percent of outstanding. One of those two arrived by buying through the module with its own money rather than by receiving a transfer from us, which is the only piece of genuine external demand this protocol has. You would not be joining a book. At $1,000,000 you would be more than 99 percent of it. Whether that is an opportunity or a disqualification is your call, but it should not be a surprise you discover after signing.
6. Who can change things, and how fast
Administration sits with a 2-of-3 Safe on Base at 0x52d3E450bA6c299B1B07298F1E87DD74732D4877, with the first signer hardware-backed.
- The Safe itself has no guard and no modules, and since 2026-08-06 the roles that matter are no longer held by the Safe. The Safe's guard slot is zero and
getModulesPaginatedreturns empty, so nothing constrains the Safe at the Safe level. The constraint was applied one layer down instead. On 2026-08-06 at 17:00:07Z, admin and manager rights on kUSD and on all three PSM modules moved to a TimelockController at 0x36A14976980B7Dd33136f6613545EB0A2C0a0D72 with a 48 hour minimum delay. So there now is a window in which an administrative action on the mint and redeem path can be observed and reacted to before it lands, and it is two days long. Two limits on that. The timelock covers kUSD and the three PSM modules only, not the staking vault skUSD, over which the Safe still holds sole admin with no delay. And the delay does not apply to pausing, which stays instant by design. - How fast, measured. This section is headed "and how fast", so here is the number rather than an assurance. Across all 19 transactions the Safe has executed, proposal to second signature ran to a median of 12 minutes and a maximum of 25 days, with 14 of 19 inside 24 hours; execution follows the second signature by a median of 8 minutes. Read that in both directions. It is how quickly we can respond to a problem, and it is equally how little warning you would have. The full distribution, the pending queue decoded from its calldata, and the commands to reproduce every figure are on the Safe queue page. It describes past behaviour and is not a service level.
- kUSD mint authority now sits behind the timelock, and the minter set is down to one.
DEFAULT_ADMIN_ROLEon kUSD is held by the timelock, not by the Safe, andgetRoleAdmin(MINTER_ROLE)is zero, so granting the minting role to anything is still possible but now takes a scheduled operation and 48 hours of public notice. The role itself is held by exactly one contract, the live mint module. 0x8ccc56B5624e2FDB592F6609d81F4c3798e3292B, the v2 vault, held it until 2026-08-03, when the Safe revoked it. It never minted with it and could not have: its deployed runtime contains no kUSD address and no mint selector. - There was a second route to the same outcome that does not touch kUSD's admin role at all, and it is covered too. The mint module at 0xaBDE1138aa1Ce88d1dF06422C0c3b05D70569803 already holds
MINTER_ROLE, because minting against deposited collateral is its job.MANAGER_ROLEon that module gates listing a new collateral asset and choosing the price feed that values it. Those two levers, used together, reach the same place as granting yourself the minting role, without ever callinggrantRoleon the token. We verified this against a fork of Base rather than reasoning about it from source. We published it because the remediation we were preparing at the time would have moved kUSD's admin role behind a delay and left this route untouched, which would have looked like a fix and would not have been one. Any delay worth the name has to cover both. The revised design covers both, and as of 2026-08-06 it is deployed and executed rather than intended. The Safe no longer holdsMANAGER_ROLEon any of the three modules. The timelock holds it, so listing a collateral asset or repointing a price feed is now a scheduled operation with 48 hours of notice. A PauseGuardian holds the same role for the single purpose of callingpause, which is how the emergency stop survived the move without becoming delayed. - The deployed kUSD has no burn role, and our published source does.
burnFromon the live token carries no role gate. Our repository restricts it to aBURNER_ROLEas a May 2026 audit fix, and that version is not what is deployed:BURNER_ROLE()reverts on the live token, theUnauthorizedBurnerselector is absent from its runtime, and a call from an unrelated address fails only on allowance. Two consequences for you. Any address you grant an ERC-20 allowance over your kUSD can burn it, not merely spend it, so approve nothing you would not hand the tokens to outright. And our published source is not a safe proxy for the deployed token, so diligence should be run against bytecode. This is the single finding on this page we would most have preferred not to write. - The deploy key was handed off and revoked, and you can watch it happen. The module was bootstrapped with the founder's own wallet holding both admin and manager, which is normal and would be a real finding if it had been left that way. It was not. Replaying role events on the module gives four grants and two revocations, and the two revocations both strip the founder's wallet, which left the Safe as the only holder of either role until the 2026-08-06 handover moved both to the timelock. Live
hasRolefor that wallet returns false on both, and it returns false on all three modules. So the fee skim and every parameter needed two signatures, and now needs two signatures plus 48 hours. This is the one part of the governance picture that is unambiguously good, which is why it is stated alongside the parts that are not. - You cannot enumerate the minter set in one call. kUSD uses plain AccessControl, so
getRoleMemberCountis absent and reverts.hasRoleonly answers for an address you already name. Proving the set is exactly one requires replaying role events from the creation block, and the command for that is below. The same is true of the timelock, which is also plain AccessControl. We mention it because a terms document that told you to "verify it in one call" would be telling you to run something that does not work.
We publish this because you would find it, and finding it yourself after reading a terms page that omitted it is worse for us than writing it down. It is a real weakness of the current setup, not a rhetorical one.
7. What a signed letter adds on top of the above
Everything in sections 1 to 6 is true for anyone who mints, with or without a relationship with us. It is the deployed system, and you should verify it rather than accept it. A signed anchor letter adds contractual protections around that deposit: a points multiplier floor, fee rebates bounded by fees actually collected, a covenant not to worsen the fee tier applicable to your redemption, priority of access if a capped founding window is ever opened, and a named transparency page scoped to your position.
The points floor is the one term already published as a rule in its own right, at the Opal anchor tier rules, so an executed letter rests on published terms rather than on its own words. Points are not yield, carry no guaranteed value, and no token generation event is scheduled.
The current earning window, Genesis Extended, ends at a snapshot fixed for August 19, 2026 at 19:59 UTC. The anchor floor above is not bounded by that date: it is an account-level rate held for the duration of the pre-TGE points program. What the date bounds is the public cohort ladder, which steps down weekly and is the rate anyone minting without a letter takes, so an unlettered deposit arriving later takes a lower multiplier on the fragments it goes on to earn.
Those fragments convert into the 5,000,000 KERNE community tranche, one part of a fixed 50,000,000 KERNE (5% of total supply) allocation that the snapshot does not re-cut. Since August 6, 2026 the allocation has been split: fragments divide that community tranche, and the 45,000,000 KERNE scale tranche is divided by dollar-hours on the part of a position above $100,000, with no multiplier. Inside the community tranche a higher multiplier is zero-sum: it moves shares from other holders rather than enlarging the tranche. Both rules, and the arithmetic that forced the split, are published at the Opal anchor tier.
A fragment is a points balance, not a token. That share becomes $KERNE only at a token generation event, and no token generation event is scheduled or guaranteed. The allocation is a published policy commitment rather than an escrowed on chain pool, and no contract exists today that converts fragments into KERNE. If no distribution ever happens, fragments convert to nothing. What a fragment is worth, and what it depends on.
To be explicit about what the date does and does not bind: it bounds the Opal points window only. It is not a deadline on this document, not a fee change, and not a deadline on the letter, which is with counsel. Nothing about a deposit made after it is worse except the points, and nothing on this page is an offer or a solicitation.
Two things you should know before asking for the letter. First, the counterparty: no Kerne legal entity is incorporated or in formation. You would contract with the founder in his individual capacity as founder and promoter, with a mandatory novation to the first incorporated entity. Second, the letter is currently with offshore counsel and is marked not for execution, so it is a draft under review and not a document we can hand you to sign today. Terms are discussed directly at liam@kerne.fi.
If you have read this far and the shape works for you, the next step is to state a size and a date rather than to sign anything. The commitment queue is not binding, takes no money and moves no funds: it records what you intend to mint and when, and holds the Opal multiplier your commitment time qualifies for so that taking longer to finish your own diligence does not cost you the rate.
8. Reproduce every number on this page
These are the actual commands. They need no API key and no cooperation from us. Any public Base RPC works.
export RPC=https://mainnet.base.org export PSM=0xaBDE1138aa1Ce88d1dF06422C0c3b05D70569803 export USDC=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 export KUSD=0x5C2EfdF0D8D286959b42308966bc2B97f5680AA3 export YOUR_ADDRESS=0x0000000000000000000000000000000000000000 # any address, read only # Section 1. The fee at $1,000,000, in USDC units. Returns 500000000, so $500. cast call $PSM "getFee(address,uint256)(uint256)" $USDC 1000000000000 --rpc-url $RPC # Section 1. Capacity: cap minus current exposure. cast call $PSM "stableCaps(address)(uint256)" $USDC --rpc-url $RPC cast call $PSM "currentExposure(address)(uint256)" $USDC --rpc-url $RPC # Section 2. The admin skim ceiling the contract computes for itself. Returns 30000, so $0.03. cast call $PSM "skimmableSurplus(address)(uint256)" $USDC --rpc-url $RPC # Section 2. The approve selector is absent from the deployed code, so the module # can never grant an allowance. Returns 0. The second line is the control: it # greps a selector that IS present and returns 1, which is how you know the # first result means "absent" rather than "my grep was wrong". cast code $PSM --rpc-url $RPC | grep -c 095ea7b3 cast code $PSM --rpc-url $RPC | grep -c a9059cbb # Section 3. The three reserves. The deepest single leg is your instant exit. cast call $USDC "balanceOf(address)(uint256)" $PSM --rpc-url $RPC cast call $USDC "balanceOf(address)(uint256)" 0x07eBb486e11BD217e6085eb5ab663e4517595993 --rpc-url $RPC cast call $USDC "balanceOf(address)(uint256)" 0xFf3025ec18e301855aB0f36Ec6ECa115a29A5Fbc --rpc-url $RPC # Section 3. Outstanding kUSD is supply less the inventory held by the redeem reserve. cast call $KUSD "totalSupply()(uint256)" --rpc-url $RPC cast call $KUSD "balanceOf(address)(uint256)" 0xFf3025ec18e301855aB0f36Ec6ECa115a29A5Fbc --rpc-url $RPC # Section 3. Do not take the exit depth on trust, probe the boundary. Simulate a # redemption against the retired module at 998 kUSD and again at 999. The first # clears every gate and stops only because the simulated caller has not approved # its kUSD (error ERC20InsufficientAllowance, 0xfb8f41b2). The second reverts # InsufficientStableReserves (0x49d5a855). That is the exit depth, measured. cast call 0x07eBb486e11BD217e6085eb5ab663e4517595993 "swapKUSDForStable(address,uint256)" \ $USDC 998000000000000000000 --from $YOUR_ADDRESS --rpc-url $RPC cast call 0x07eBb486e11BD217e6085eb5ab663e4517595993 "swapKUSDForStable(address,uint256)" \ $USDC 999000000000000000000 --from $YOUR_ADDRESS --rpc-url $RPC # Section 4. The oracle window in force, in seconds. Returns 172800, so 48 hours. cast call $PSM "maxOracleDelay(address)(uint256)" $USDC --rpc-url $RPC # Section 6. Custody. DEFAULT_ADMIN_ROLE is bytes32(0), not a keccak of the name. # Since 2026-08-06 the Safe does not hold it on kUSD or on any PSM module; a # TimelockController with a 48 hour delay does. Returns false, then true, then 172800. ADMIN=0x0000000000000000000000000000000000000000000000000000000000000000 TL=0x36A14976980B7Dd33136f6613545EB0A2C0a0D72 cast call $KUSD "hasRole(bytes32,address)(bool)" $ADMIN 0x52d3E450bA6c299B1B07298F1E87DD74732D4877 --rpc-url $RPC cast call $KUSD "hasRole(bytes32,address)(bool)" $ADMIN $TL --rpc-url $RPC cast call $TL "getMinDelay()(uint256)" --rpc-url $RPC # Section 6. The Safe is not the timelock's admin, so two signatures cannot # shorten the delay or strip a canceller. Returns false. cast call $TL "hasRole(bytes32,address)(bool)" $ADMIN 0x52d3E450bA6c299B1B07298F1E87DD74732D4877 --rpc-url $RPC # Section 6. The boundary of the claim, stated by us and checkable by you. The # staking vault is NOT behind the delay. Returns true. cast call 0x96F5102C15b839757f811A98CEc3725Ac21DfA14 \ "hasRole(bytes32,address)(bool)" $ADMIN 0x52d3E450bA6c299B1B07298F1E87DD74732D4877 --rpc-url $RPC # Section 2. No proxy anywhere. All three EIP-1967 slots read zero on all eight # contracts, so there is no upgrade path around the delay. Repeat for skUSD, the # three PSMs, the timelock, the guardian and the vault. All return 0x0...0. IMPL=0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc cast storage $KUSD $IMPL --rpc-url $RPC # Section 2. The skUSD residual is role widening, NOT seizure of principal. The # sweepable amount is raw balance minus tracked assets. Both return the same # number today, so the difference is exactly zero. cast call $KUSD "balanceOf(address)(uint256)" 0x96F5102C15b839757f811A98CEc3725Ac21DfA14 --rpc-url $RPC cast call 0x96F5102C15b839757f811A98CEc3725Ac21DfA14 "totalAssets()(uint256)" --rpc-url $RPC # Section 6. The module's own role history: four grants, two revocations, and both # revocations strip the deploy wallet. Admin and manager then moved to the timelock # in the 2026-08-06 handover batch. cast logs --from-block 48469020 --address $PSM \ "RoleGranted(bytes32,address,address)" --rpc-url $RPC cast logs --from-block 48469020 --address $PSM \ "RoleRevoked(bytes32,address,address)" --rpc-url $RPC # Section 6. No guard, no modules, threshold 2. cast call 0x52d3E450bA6c299B1B07298F1E87DD74732D4877 "getThreshold()(uint256)" --rpc-url $RPC cast call 0x52d3E450bA6c299B1B07298F1E87DD74732D4877 "getModulesPaginated(address,uint256)(address[],address)" \ 0x0000000000000000000000000000000000000001 10 --rpc-url $RPC # Section 2 and 6. The ceiling. getRoleAdmin(MINTER_ROLE) returns bytes32(0), the # admin role, which the timelock now holds. Mint-and-redeem is still reachable by # two keys, but only through a scheduled operation with 48 hours of notice. cast call $KUSD "getRoleAdmin(bytes32)(bytes32)" \ 0x9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a6 --rpc-url $RPC # Section 6. The deployed kUSD has no burn role. The first reverts (no such # constant). The second fails with ERC20InsufficientAllowance (0xfb8f41b2), not an # authorization error, which is how you know burnFrom is ungated on chain. cast call $KUSD "BURNER_ROLE()(bytes32)" --rpc-url $RPC cast call $KUSD "burnFrom(address,uint256)" $YOUR_ADDRESS 1 \ --from 0x000000000000000000000000000000000000dEaD --rpc-url $RPC # Section 3. The retired module has no burn call, so what it redeems becomes # inventory rather than reducing supply. Returns 0 here and 1 on the live module; # the transfer selector returns 1 on both, which is the control. cast code 0x07eBb486e11BD217e6085eb5ab663e4517595993 --rpc-url $RPC | grep -c 42966c68 cast code $PSM --rpc-url $RPC | grep -c 42966c68 # Section 2. The second fee spigot, on the retired module, paying a different treasury. cast call 0x07eBb486e11BD217e6085eb5ab663e4517595993 "skimmableSurplus(address)(uint256)" $USDC --rpc-url $RPC cast call 0x07eBb486e11BD217e6085eb5ab663e4517595993 "treasury()(address)" --rpc-url $RPC # Section 5. The holder set. Do not take our word for who else is here: replay # every kUSD Transfer since the creation block and net the balances. 27 transfers, # seven holders. Chunk the range if your RPC caps it. cast logs --from-block 44448090 --address $KUSD \ "Transfer(address,address,uint256)" --rpc-url $RPC # Section 6. The minter set, which is one contract. hasRole answers only for an # address you name, so the complete set requires replaying role events from the # kUSD creation block. The same is true of the timelock's own role set. cast logs --from-block 44448090 --address $KUSD \ "RoleGranted(bytes32,address,address)" --rpc-url $RPC
The same figures are served as JSON at /api/psm-status and rendered live at /transparency, including the exit depth split between the deepest single transaction and the total reachable sequentially. If any command above disagrees with this page, the chain is right and this page is stale, and we would like to know.
Anchor terms version 1.0, issued August 1, 2026, figures read at Base block 49,428,145. This page is a description of a deployed system and of terms under negotiation. It is not an offer to sell or a solicitation to buy any token or security, and it is not investment, legal, tax or accounting advice. Kerne is infrastructure, not a custodian or an investment adviser, and does not take custody of your USDC or kUSD at any point. kUSD is a protocol-issued synthetic dollar, not a fiat-backed payment stablecoin, and is not a bank deposit and not insured. kUSD pays no yield for holding it. Opal fragments are a points balance, not a token, a price, or a yield promise. Where this page and the executed anchor deposit letter conflict, the letter controls. Where this page and the chain conflict, the chain controls.