Post Fiat

Post Fiat

Schwab NAVCoin (B24): Status and Handoff

A visual handoff for B24, the NAVCoin backed by a Schwab brokerage account: what is live, how a dollar of USDC becomes a coin, which steps are enforced by proofs, and where each piece lives in the code.

Schwab NAVCoin (B24): Status and Handoff

B24 is a NAVCoin backed by a Schwab brokerage account. One coin is a claim on one dollar of that account’s value, and the account’s value is read every day by sealed hardware and checked by the network before the coin’s price can change.

This page is a handoff. It shows what is running as of 16 November 2026, how money gets in, which steps nobody has to be trusted for, and where each step lives in the code.

B24 runs on the Post Fiat test network postfiat-wan-devnet-2. Its Ethereum contracts are on Ethereum mainnet.

Where it stands

Status board · 16 November 2026

What is running, what is deployed but idle, and what is not built

Live

Daily enclave reading

Runs unattended at 17:55 UTC. Three readings accepted by the network.

Live

USDC in, PFUSDC out

Ethereum deposit credited on Post Fiat after a finality proof. About 23 minutes.

Live

Create and cash in

Create at NAV plus 0.5 percent. Cash in at NAV minus 0.05 percent, up to the reserve.

Live

Order book

97 B24 on offer at $1.00 against PFUSDC.

Live

Coin pages and gallery

Price, verification split, history and liquidity for four coins. Test deployment.

Deployed, idle

Ethereum token wB24

Contract deployed. One test coin minted from a real proof. Minting paused.

Deployed, empty

Uniswap v4 pool

Initialised at $1.00 with a 0.05 percent fee. No liquidity yet.

Not built

Ethereum back to native

Returning wB24 to Post Fiat needs the next network release.

Not built

USDC withdrawal for new deposits

The vault pays only the earlier bridge setting. A matching exit must be built and proven.

What backs the coin today

B24 at block 1370 · 16 November 2026

What backs the coin, and how each part is verified

  • Attested 99.995% $420,302.38 read from Schwab by the enclave
  • Reported 0.005% 21 PFUSDC cash reserve held by the protocol
  • Proven 0% a brokerage account cannot be proven from outside
$1.000000NAV per coin
420,323.38B24 outstanding
3readings accepted since launch on 14 November
1 / 1wB24 minted on Ethereum / native B24 locked behind it

The three readings so far carry the same value because the first one landed on a Saturday and the market stayed closed. The reading on Monday 16 November is the first that should move.

How funding works

A buyer starts with USDC on Ethereum and ends with a coin. Each step below names the check that guards it and the code that performs that check.

Funding path

From USDC in MetaMask to a Schwab NAVCoin, and on to Uniswap

  • Proof a contract or the validators check a cryptographic proof
  • Attested sealed hardware signs what it read
  • Operator a person or key must act
  1. Deposit USDC into the vaultEthereum mainnet

    The buyer approves USDC and calls depositV2 with their Post Fiat address, a nonce and the route it is meant for.

    The vault has no admin withdrawal and no upgrade path. It pays out only against a proof.

    crates/ethereum-contracts/src/ERC20BridgeVaultL1.sol:127 · payout :191

  2. Prove the deposit is final on EthereumOff-chain prover

    A zero-knowledge program checks Ethereum's own finality signatures and the deposit event, and outputs one small proof.

    Anyone can run the prover. It cannot produce a proof for a deposit that did not finalise.

    programs/pfusdc-eth-mainnet-ingress/src/lib.rs:285, :336

  3. Validators verify the proof and credit PFUSDCPost Fiat

    Each validator verifies the proof against the pinned Ethereum finality state, then credits PFUSDC to the buyer. A repeated or stale deposit is rejected.

    No operator signature can credit a deposit.

    crates/execution/src/nav_vault_asset_execution.rs:1232, :1424 · stale check :1954

  4. Create B24 at NAV plus 0.5 percentPost Fiat

    The buyer's PFUSDC moves into protocol custody and new B24 is minted at the latest finalised NAV. The route's supply cap and issue capacity bound every mint.

    The cash goes to the protocol, not to an issuer wallet. It appears in the next reading as backing.

    crates/execution/src/nav_vault_asset_execution.rs:4729 · caps :4070, :4577

  5. Export to Ethereum as wB24Post Fiat to Ethereum

    Native B24 is locked. A proof of that finalised Post Fiat receipt is accepted by a verifier contract, and only then does the controller mint the same amount of wB24.

    Wrapped supply can never exceed native coins locked behind it.

    crates/ethereum-contracts/src/PFTLReceiptFinalityVerifierV2.sol:229 · PFTLUniswapHandoffController.sol:1615, :1753

  6. Seed and trade the Uniswap v4 poolEthereum mainnet

    USDC and wB24 are placed in a narrow band around NAV. Buyers swap USDC for wB24 like any other token.

    Seeding is a liquidity decision by the pool owner. The owner can withdraw that position at any time.

    Pool and token addresses are in the reference table below

Steps 1 to 5 are enforced by proofs. Step 6 is ordinary liquidity provision.

Two things follow from this design:

  • The buyer’s cash never passes through an issuer wallet. It sits in the Ethereum vault and is mirrored as PFUSDC held by the protocol.
  • Coins cannot be created ahead of the money. A mint needs PFUSDC that only exists because a deposit was proven.

How the reserve is proven

The funding path covers new money. The reserve path covers the brokerage account that backs the existing 420,302 coins.

Reserve path

How the Schwab balance reaches the chain every day

  1. A sealed enclave reads SchwabAWS Nitro

    A measured image holds a read-only Schwab key, opens the connection itself and reads the account's net liquidation value.

    The operator cannot see inside the enclave or edit what it read.

    navstrategies: containers/yolo-nitro/ · navstrategies/yolo_indices/nav_reading.py

  2. The hardware signs the resultAWS Nitro

    The attestation document names the exact image that ran and carries the reading. It chains to Amazon's root certificate.

    tools/nav-reserve-proof/crates/reserve-proof-types/src/yolo_nitro.rs:164

  3. A proof wraps the attestationOff-chain prover

    A zero-knowledge program verifies the signature chain and the image measurement, then outputs the reserve figures in the network's standard form.

    tools/nav-reserve-proof/programs/b23-nav-guest/src/main.rs:5 · reserve-proof-types/src/b23_nav.rs:141

  4. Validators verify and record the splitPost Fiat

    Every validator checks the proof against the program key pinned in the coin's proof profile. The reading is stored with separate fields for proven, attested and operator-reported value.

    A reading without a valid proof is rejected. A reading that ages past its limit halts the coin.

    crates/execution/src/nav_sp1_verifier.rs:86 · nav_vault_asset_execution.rs:3000 · types/src/account_owned_asset_types.rs:813-823

This proves what Schwab told a known program, untouched. It does not prove Schwab is right. That is why the coin is labelled Attested, not Proven.

How it appears in the Task Node

The consumer side lives inside the Task Node as a wallet with six surfaces. The design rule is simple: the browser holds the keys and signs, the Task Node server only relays, and the network enforces every rule shown above.

Task Node integration

Keys stay in the browser. The Task Node relays. The network decides.

Holds the keys

The user's browser

  • Creates the quantum-resistant Post Fiat key and signs every transaction locally.
  • Stores the seed encrypted with the user's passphrase, one vault per Task Node account.
  • Talks to MetaMask directly for the Ethereum deposit.

src/features/wallet/l1/core.js:54 · lib/vault.js:137, :208 · bridge/evm.js:14

Relays only

Task Node server

  • Accepts requests only from a signed-in session on the same site.
  • Passes on a fixed list of read and submit calls. Anything else is refused.
  • Rejects any request that contains a seed, private key, backup or passphrase.

server/l1/gateway.js:49, :54, :75 · lib/rpc-methods.js · lib/custody-boundary.js

Enforces the rules

Post Fiat network

  • Checks the signature and the rules from the funding path above.
  • Returns a receipt. The wallet shows success only on an accepted receipt.

Six validators, release 4

WalletHome · Send · Activity

Shows PFT, PFUSDC and NAVCoin balances read from the network, sends PFT, and lists history. Create, unlock, import and encrypted backup.

src/features/wallet/l1/L1WalletView.jsx:17 · WalletHome.jsx · Send.jsx · server/l1/history.js

BridgeUSDC to PFUSDC

Connect MetaMask, approve, deposit. The screen then follows the deposit through finality, proving and the credit, about 23 minutes end to end.

src/features/wallet/l1/bridge/index.jsx · controller.js · server/l1/bridge-routes.js

BuyOrder book or create

One Buy box. An order that fits the coins on offer fills from the order book. A larger order switches to creating new coins at NAV plus the fee, with a review screen first.

src/features/wallet/l1/market/index.jsx:146 · primary/model.js:17, :26 · primary/CreateReview.jsx

Cash inCoin to PFUSDC

Quotes NAV times the cash-in rate, capped at the reserve, then submits. The fee is paid to the management wallet in the same transaction.

src/features/wallet/l1/redeem/model.js:10 · redeem/index.jsx

NAVCoin galleryAll coins

Lists every NAVCoin the network knows, discovered from the chain. Each row shows NAV, size and the proven, attested and reported split computed from the latest reading.

server/l1/navcoin-registry.js:7 · src/features/wallet/l1/gallery/model.js:10

Coin page and snapshot checksNo sign-in needed

A shareable page per coin: price, split, history, liquidity and the live Uniswap pool. Every past reading links to its own page with the proof hash, program key and decoded values.

server/l1/navcoin-profile.js:66, :104, :136 · server/l1/profile/ethereum.js · src/features/wallet/l1/profile/index.jsx

Issuer actions (mint, top up the reserve, change the fee) are deliberately not in the Task Node. They run from the command line so the issuer key never enters a browser.

What this means for a user:

  • The Task Node never has custody. A compromised Task Node server cannot move a user’s coins, because it never sees a key and the network accepts only signed transactions.
  • The numbers on screen come from the network. Balances, NAV, the verification split and history are read from the validators, not from a Task Node database.
  • One wallet per Task Node account. Switching accounts never shows or overwrites another account’s wallet.

The original NAVCoin: A666

B24 is the second kind of NAVCoin. The first was A666, which is still live. A666 is backed by a working portfolio spread across six networks, and it is where the proof system was built.

A666 · the original NAVCoin

One coin, six positions, one proof

Aave loan and collateral

Arbitrum
Amount held
Proven
Dollar value
Proven

aave_v3.rs:321

Hyperliquid account

HyperEVM / HyperCore
Amount held
Proven
Dollar value
Proven

hyperliquid_receipt.rs:300

NEAR staking

NEAR
Amount held
Proven
Dollar value
Attested

near_receipt.rs:492

EVM spot holdings

Ethereum
Amount held
Proven
Dollar value
Attested

evm_spot.rs:214

Monero reserve

Monero
Amount held
Proven
Dollar value
Attested

monero_reserve.rs:216

Solana stake

Solana
Amount held
Attested
Dollar value
Attested

solana_stake.rs:395

One proof A single zero-knowledge program checks all six parts, subtracts the debt, and outputs one net asset value with the split. The validators verify that one proof.

tools/nav-reserve-proof/crates/reserve-proof-types/src/lib.rs:488 · programs/reserve-proof-guest/src/main.rs · crates/execution/src/nav_sp1_verifier.rs:86

File names in the tiles are under tools/nav-reserve-proof/crates/reserve-proof-types/src/. No wallet address or position size is published; the proof reveals only the totals.

The amount held is proven cryptographically for five of the six parts. Only the Solana stake relies on an attested reading. Dollar values are proven for the two parts that have an on-chain price source and attested for the rest.

A666 has 31,519 coins outstanding at a NAV of $1.167, nine accepted readings, and a wrapped token with a Uniswap v4 pool on Ethereum mainnet.

A multi-asset on-chain portfolio as the next coin type

A666 and B24 sit at opposite ends. A666 holds assets that live on public networks, so most of it can be proven outright. B24 holds assets inside a brokerage, so it can only be attested.

The natural next coin is a larger, deliberately built version of A666: a multi-asset portfolio held entirely on-chain. Because every position is on a public network, such a coin can aim for a split that is mostly Proven, with no enclave and no broker in the trust path.

What already exists for it:

  • A reader for each kind of position: lending, perpetuals, staking, spot and Monero. These are the six files in the diagram above.
  • A combining program that nets assets against debt and outputs one figure with its split.
  • The same chain rules B24 uses for creation, cash-in, staleness and the Ethereum wrapper.

What a new portfolio coin needs: a manifest naming its positions, a reading schedule, and its own Ethereum route. A new kind of position needs a new reader.

Private swaps

Everything above happens in public. The network also has a shielded pool, so a NAVCoin can be held and swapped without revealing the holder, the asset or the amount.

Private swaps

Public at the edges, hidden in the middle

  1. ShieldPublic to private

    A holder moves PFUSDC or a NAVCoin from their public balance into the shielded pool. The amount entering is public, so total supply stays checkable.

    crates/node/src/orchard_state_application.rs:1393

  2. Swap inside the poolPrivate

    Two parties exchange one asset for another. The transaction carries a zero-knowledge proof and encrypted notes. Observers cannot see which assets, how much, or who.

    The proof shows that, for each asset, what went in equals what came out. The validators verify it and reject a note that was already spent.

    crates/privacy_orchard/src/asset_orchard_circuit.rs · asset_orchard_action_builders.rs:264 · crates/node/src/orchard_state_application.rs:961, :1131

  3. Create or cash in privately at NAVPrivate, priced by the public reading

    A shielded holder can create new coins or cash in at the latest finalised NAV. The order is tied to that reading and to the route's current terms, and is refused if the reading is stale.

    crates/execution/src/nav_vault_asset_execution.rs:4950, :5151

  4. UnshieldPrivate to public

    The holder moves value back to a public balance, or out through the bridge. The amount leaving is public again.

    crates/node/src/orchard_state_application.rs:1523 · asset_orchard_action_builders.rs:661

The reserve proof and total supply stay public throughout. Privacy covers who holds and trades the coin, not what backs it.

The private path was proven on the test network in June and July 2026, including a 250 USDC run through every step. It is not yet offered for B24, and the Task Node wallet has no private tab. Turning it on for a coin is a matter of enabling its route for the shielded pool and adding the screens, not of building the cryptography.

What you trust, step by step

StepEnforced byYou trust
USDC held in the vaultVault contract with no admin withdrawalEthereum
Deposit credited as PFUSDCZero-knowledge proof of Ethereum finality, verified by every validatorEthereum finality and the proof system
B24 created at NAVChain rules: supply cap, issue capacity, latest finalised NAVThe Post Fiat validators
wB24 minted on EthereumProof of the Post Fiat receipt, verified by a contractThe Post Fiat validator set named in that contract
Schwab balanceHardware attestation wrapped in a proofAmazon’s Nitro hardware, the published enclave image, and Schwab’s own reporting
Cash-in reserveCounted by the chain, not independently readThe protocol’s own ledger
Uniswap liquidityUniswap v4The pool owner, for depth only

The weakest link is the brokerage itself. No proof can look inside Schwab. The design narrows that trust to one question, “did Schwab report this figure to this exact program”, and answers it with hardware.

Review surface

This is what a reviewer should read, in order of how much money or trust depends on it. Paths are in the code index at the end.

PriorityAreaThe question to answerWhere
1Deposit proofCan PFUSDC ever be credited without a real, final Ethereum deposit? Can one deposit be credited twice?programs/pfusdc-eth-mainnet-ingress/src/lib.rs, nav_vault_asset_execution.rs:1232
1Bridge vaultIs there any way to move USDC out other than a valid proof?ERC20BridgeVaultL1.sol:127, :191
1Creation and cash-inCan coins be minted beyond the caps, or cashed in beyond the reserve? Is the fee always paid in the same transaction?nav_vault_asset_execution.rs:4729, :4070, :4577
1Ethereum wrapperCan wB24 be minted without a locked native coin behind it? Can one receipt mint twice?PFTLReceiptFinalityVerifierV2.sol:229, PFTLUniswapHandoffController.sol:1615, :1753
2Enclave readingDoes the proof pin the exact enclave image? What can the machine’s operator change without detection?yolo_nitro.rs:164, b23_nav.rs:141, containers/yolo-nitro/
2Proof verification on chainIs every reading bound to the program key in the coin’s profile? What happens to a stale reading?nav_sp1_verifier.rs:86, nav_vault_asset_execution.rs:3000
2Verification splitCan a reading claim more Proven or Attested value than its proof supports?account_owned_asset_types.rs:813, gallery/model.js:10
3Task Node relayCan the server see or forward key material? Can a signed-out or cross-site request reach the network?server/l1/gateway.js:49, custody-boundary.js
3Browser walletIs the seed ever stored or sent unencrypted? Does switching accounts isolate wallets?lib/vault.js:137, core.js:54
3Daily jobWhat happens when a run fails, and who is told? Does the spending cap stop it silently?ops/b24-live/daily.py
4Private pathDoes the shielded swap conserve each asset? Is a private order bound to a fresh reading?orchard_state_application.rs:1131, nav_vault_asset_execution.rs:4950

Known gaps a reviewer will find, listed so they are not rediscovered: the withdrawal path for new deposits and the Ethereum-to-native return are not built; five of six validators sign Ethereum-side approvals with no spare; the launch needed a manual repair three times for a known network bug; and none of this code is on the public main line yet.

Second Set of Eyes

A catalogue of independent checks, written so each one can be handed to an agent as it stands. Every item says what to check, when it passes, and where to start. None of them has been run as an independent review yet; the boxes are empty on purpose.

Rules for every agent:

  • Read only. Work on a local copy or a private fork of Ethereum. No transactions on the live network, no funds moved, no services restarted.
  • No secrets. Never open, print or copy key files, tokens or credentials. Report a secret you find by its path, not its contents.
  • Evidence, not opinion. Each finding cites a file and line or pastes the command and its output.
  • One verdict per item: PASS, FAIL or UNCLEAR, followed by what would settle an UNCLEAR.
  • Do not fix. Report. Fixes are separate work.

A. Can money be created, taken or stuck?

☐IDThrow an agent atPasses whenStart at
☐A1Crediting the same Ethereum deposit twiceEvery replay route is rejected, with a test that shows itnav_vault_asset_execution.rs:1232, :1954
☐A2Crediting a deposit that never finalisedA proof built on a swapped or stale signer set is rejected, and that test exists and runsprograms/pfusdc-eth-mainnet-ingress/src/lib.rs:336
☐A3Every way USDC can leave the vaultThe only exit is a valid proof; the admin key can pause and nothing elseERC20BridgeVaultL1.sol:127, :191
☐A4Why USDC deposited now cannot be withdrawnThe claim that the vault’s checker pins the older bridge setting is confirmed or disproved from the deployed bytecodeVault 0xE7A432a2…, ERC20BridgeVaultL1.sol:191
☐A5Minting past the supply cap or issue capacityNo sequence of creates, including concurrent ones, exceeds either limitnav_vault_asset_execution.rs:4729, :4070, :4577
☐A6Rounding at creation and cash-inEvery rounding goes in the protocol’s favour and dust cannot be farmed with many small ordersnav_vault_asset_execution.rs:4482, redeem/model.js:10
☐A7Cashing in more than the reserve holdsRefused cleanly; the fee reaches the management wallet in the same transaction every timenav_vault_asset_execution.rs:5364
☐A8Minting wB24 twice from one receiptA consumed receipt cannot be reused; wrapped supply never exceeds native coins lockedPFTLUniswapHandoffController.sol:1615, :1753
☐A9Who can unpause, re-point or upgrade the Ethereum contractsA written list of every privileged function and the address that holds it, with nothing unexpectedPFTLUniswapHandoffController.sol, PFTLReceiptFinalityVerifierV2.sol:229

B. Is the Schwab number what it claims to be?

☐IDThrow an agent atPasses whenStart at
☐B1Whether the proof pins the exact enclave imageA reading from any other image fails verification, and the pinned image can be rebuilt from source to the same measurementyolo_nitro.rs:164, b23_nav.rs:141, containers/yolo-nitro/
☐B2Replaying an old attestation as today’s readingYesterday’s signed result cannot be accepted as a new readingb23_nav.rs:141, nav_vault_asset_execution.rs:3000
☐B3What the machine’s operator can change undetectedA written list of everything outside the enclave that influences the result, each shown harmless or flaggedcontainers/yolo-nitro/aws/, nav_reading.py
☐B4Who can change a coin’s proof settingReplacing the pinned program key needs the authority the design says it needs, and no weaker path existsnav_sp1_verifier.rs:86, proof profile registration
☐B5Recomputing B24’s three readings independentlyNAV, supply and the split are reproduced from the published values by a script that shares no code with oursaccount_owned_asset_types.rs:813, coin page data
☐B6Claiming more Proven or Attested value than the proof supportsThe parts can never sum past the total, on chain or on screengallery/model.js:10, nav_reserve_public_values.rs:51
☐B7What a stale coin actually refusesBMNRC is past its freshness limit today: confirm by read-only calls that creation and cash-in are refusedRoute state for BMNRC
☐B8The four items that can post to Schwab after the readingTheir worst-case size is estimated against the account and compared with the 0.05 percent cash-in marginnav_reading.py

C. Can the Task Node leak or mislead?

☐IDThrow an agent atPasses whenStart at
☐C1Smuggling key material past the relayNested, encoded and renamed secrets are all rejectedcustody-boundary.js, server/l1/gateway.js:54
☐C2Reaching the network signed out or from another siteBoth the request path and the live-update path refuseserver/l1/gateway.js:75, :82, :101
☐C3Calling anything outside the allowed listOnly the listed read and submit calls passlib/rpc-methods.js, server/l1/gateway.js:49
☐C4The browser vaultThe seed is never stored or sent unencrypted, key stretching is adequate, and one account cannot open another’s walletlib/vault.js:137, :208
☐C5Every number on the coin pagesAn independent script reads all six validators and Ethereum and matches the four coin pages exactlyserver/l1/navcoin-profile.js:66, server/l1/profile/ethereum.js
☐C6What the screen says when something failsNo path shows success without an accepted receiptmarket/index.jsx, redeem/index.jsx, bridge/controller.js
☐C7Merging the wallet branch into the public Task NodeA dry-run merge with the full test suite, and a list of what breaksTask Node b23/integration

D. Will it keep running?

☐IDThrow an agent atPasses whenStart at
☐D1How the daily job failsEach failure (expired Schwab access, cloud outage, proof failure, spending cap) ends in a clear state and somebody is toldops/b24-live/daily.py
☐D2Running the daily job twice in one dayThe second run cannot post a conflicting readingops/b24-live/daily.py
☐D3Total cloud spend against the $100 capA dated total, the run rate, and the day the cap is reachedCloud billing, job records
☐D4The network bug that needed manual repair three times at launchReproduced on a local copy with a root causeLaunch records, status/tee.md
☐D5Why the fifth validator cannot sign Ethereum-side approvalsRoot cause and the steps to restore a spare signerValidator authority keys (paths only)
☐D6Merging the network branches into the main lineA merge order, the conflicts, and a build that still produces the live network’s stateb23/* branches
☐D7Secrets in the branches and evidence folders before anything goes publicNo key, token or credential is committed; anything found is reported by path onlyAll b23/* branches, the evidence folders

E. The other coins and the private path

☐IDThrow an agent atPasses whenStart at
☐E1Why A666’s pool trades at $0.66 against a NAV of $1.167The swap history explains it: never re-centred, sold into, or something elsePool 0xc5f1e4b5…, Ethereum logs
☐E2Moving A666 to a proof setting that records its splitA plan showing its page would then report the Proven and Attested shares, with no change to its supplystakehub-six-leg-reserves-v3 profile
☐E3Restarting BMNRC’s readingThe reason it stopped in October is confirmed and the restart steps are listedBMNRC reading pipeline
☐E4Private swaps conserving each assetNo shielded swap can create or destroy value in any asset; a spent note cannot be spent againorchard_state_application.rs:961, :1131
☐E5Private create and cash-in using an old priceA private order tied to a stale or superseded reading is refusednav_vault_asset_execution.rs:4950, :5151

F. Does the writing match the code?

☐IDThrow an agent atPasses whenStart at
☐F1Every file and line on this pageEach reference opens to code that does what the page says it doesThe code tables on this page
☐F2Every number on this pageEach figure is re-read from the network or Ethereum and matches, or is marked out of dateLive numbers and split diagram
☐F3The unpublished Schwab blog postA list of every statement that is wrong now that B24 replaced B23Site pull request 29
☐F4The trust tableFor each row, an attempt to name something else the user must trust that the table leaves out“What you trust, step by step”

Live numbers

Read from the network at block 1370 and from Ethereum at block 26,423,933.

B24A666BMNRC
BackingSchwab accountSix-part StakeHub portfolioBMNR carry trade
NAV per coin$1.000000$1.167369$1.000000
Coins outstanding420,323.3831,519.44640.59
Readings accepted391
Verification99.995% AttestedLegacy profile, split not recorded2 parts Proven, 1 Attested
Uniswap v4 pool price$1.00, no liquidity$0.6594$1.0018
Wrapped on Ethereum131,418.44565.59

Reference: contracts and identifiers

ItemValue
B24 asset id52285e4ded1d58113cfaa12bbc034b8b10213f699b3224c74160450229d6bf7c…
Routepftl-b24-ethereum-wB24-usdc-v1
Proof profile source classb23-schwab-account-equity-nitro-sp1-v1
wB24 token0x540fda223a2198690d31920a921a0b9dff335dbf
Handoff controller0x2c7db4c2ff8514334f62e6630226e95e72fa6056
USDC bridge vault0xE7A432a28b20621A70E845C7F202004Cf98e7A2C
Uniswap v4 pool id0x70ab0a6fd1e33c7d3dfeae11a1ec60682efa2a9e95f028df1964b167326cc92c
Creation priceNAV × 1.0050
Cash-in priceNAV × 0.9995, capped at the reserve (21 PFUSDC)

Reference: code

Line numbers are from the branches below. This work has not yet been merged into the public main line.

RepositoryBranchCommit
postfiatl1v2b23/tee-phase6-mainnet-2026111443ddc7d6
navstrategies (Schwab reader and enclave)b23/tee-nav-phase1-20261113f6d6be7f
Task Node (wallet, gallery, coin pages)b23/integration483dd32
What it doesFile and line
Accept a USDC depositcrates/ethereum-contracts/src/ERC20BridgeVaultL1.sol:127
Pay a withdrawal against a proofcrates/ethereum-contracts/src/ERC20BridgeVaultL1.sol:191
Prove Ethereum finality and the depositprograms/pfusdc-eth-mainnet-ingress/src/lib.rs:285
Verify the deposit proof and credit PFUSDCcrates/execution/src/nav_vault_asset_execution.rs:1232
Create coins at NAV (subscription)crates/execution/src/nav_vault_asset_execution.rs:4729
Supply cap and issue capacity checkscrates/execution/src/nav_vault_asset_execution.rs:4070, :4577
Verify an SP1 Groth16 proof on chaincrates/execution/src/nav_sp1_verifier.rs:86
Reserve reading fields (proven, attested, reported)crates/types/src/account_owned_asset_types.rs:813
Verify a Nitro attestation documenttools/nav-reserve-proof/crates/reserve-proof-types/src/yolo_nitro.rs:164
Schwab reserve proof programtools/nav-reserve-proof/crates/reserve-proof-types/src/b23_nav.rs:141
Accept a Post Fiat receipt on Ethereumcrates/ethereum-contracts/src/PFTLReceiptFinalityVerifierV2.sol:229
Mint wrapped coins from an accepted receiptcrates/ethereum-contracts/src/PFTLUniswapHandoffController.sol:1615
Daily reading jobops/b24-live/daily.py
A666: combine six positions into one figuretools/nav-reserve-proof/crates/reserve-proof-types/src/lib.rs:488
A666: position readersaave_v3.rs, hyperliquid_receipt.rs, near_receipt.rs, evm_spot.rs, monero_reserve.rs, solana_stake.rs in the same folder
Private swap: circuit and proof checkcrates/privacy_orchard/src/asset_orchard_circuit.rs, asset_orchard_action_builders.rs:264
Private swap: apply and check accountingcrates/node/src/orchard_state_application.rs:961, :1131
Private create and cash-in at NAVcrates/execution/src/nav_vault_asset_execution.rs:4950, :5151
Shield and unshieldcrates/node/src/orchard_state_application.rs:1393, :1523
Task Node: relay and request checksserver/l1/gateway.js:49
Task Node: allowed network callssrc/features/wallet/l1/lib/rpc-methods.js
Task Node: key material never leaves the browsersrc/features/wallet/l1/lib/custody-boundary.js
Task Node: local signingsrc/features/wallet/l1/core.js:54
Task Node: encrypted vault per accountsrc/features/wallet/l1/lib/vault.js:137
Task Node: MetaMask depositsrc/features/wallet/l1/bridge/evm.js:14
Task Node: buy from book or createsrc/features/wallet/l1/market/index.jsx:146
Task Node: cash-in quotesrc/features/wallet/l1/redeem/model.js:10
Task Node: coin discoveryserver/l1/navcoin-registry.js:7
Task Node: verification splitsrc/features/wallet/l1/gallery/model.js:10
Task Node: coin page and snapshot dataserver/l1/navcoin-profile.js:66

Open items

  1. Fund the pool. The token and pool are deployed; liquidity and the first 5,000 wrapped coins are not.
  2. Build the exit for new deposits. USDC deposited under the current bridge setting stays in the vault as the coin’s reserve until a matching withdrawal proof exists.
  3. Ethereum back to native. Returning wB24 to Post Fiat ships with the next network release.
  4. Merge. The live network runs code from the branches above. They need to land on the main line.
  5. Public Task Node. The wallet, gallery and coin pages run on a test deployment.
  6. A666 and BMNRC. A666’s pool trades well below NAV and its split is not recorded under its older profile. BMNRC has one reading and needs its refresh restarted.
  7. Signer headroom. Five of six validators currently sign Ethereum-side approvals, which is the exact quorum.