How it works.

Offhrs is an autonomous marketplace where AI trading agents arbitrage tokenized pre-IPO equity after the regular market closes, and stream the proceeds to the people holding each agent's token — paid in the wrapped share itself, not in a stablecoin.

The on-chain half is a single Anchor program, `stock_vault`. It solves two problems that have nothing to do with each other except that both stand between the thesis and a working product.

1. 01Raw PreStocks cannot be a bonding-curve quote assetThey are Token-2022 mints carrying a non-zero transfer fee. Meteora's DBC program rejects them with QuoteMintHasNonZeroTransferFee (6081), and a token badge does not help — a badge cannot authorise a non-zero fee. The wrapper mints a zero-fee classic-SPL twin so a stock-paired pool can exist at all.
2. 02Dividends cannot be farmedA lump-sum reward pool pays a pro-rata share to anyone who stakes in the same block as the deposit. The vault streams rewards per slot instead, so yield is paid for time held and the vault is solvent by construction.

The official value of a tokenized share comes from Pyth. When the underlying exchange closes, the equity feed's publish time stops advancing — the price does not move because there is no new price. The tokenized share keeps trading on Solana all night, so its mark drifts from the stale reference.

That drift is the tradable object. An agent buys the token when it trades below the last reference and sells when it trades above, and only when the gap clears its costs. The result is a measurable basis, not a narrative: the basis is the difference between the DEX price and the reference mark, in basis points.

• The mark is quoted unscaled; the DEX price is not. Apply the scaledUiAmount multiplier before comparing them.
• The tokenized share is illiquid. A large sell moves the price; the gap can close against the agent.
• When the real market reopens, the reference can gap to the tokenized price rather than the other way round.

A PreStock is a Token-2022 mint with the extensions a compliant security token needs: a transfer-fee configuration (50bps at launch, stepping up later), a permanent delegate, a pausable configuration and a scaled-UI-amount multiplier. They are exactly what makes the token usable as a regulated share — and exactly what makes it unusable as a DBC quote mint.

initialize_wrapper creates two accounts per PreStock: a classic SPL mint whose mint authority is the WrapperConfig PDA, and a reserve token account that holds the raw PreStock backing it. The wrapped mint is the DBC quote asset — the only reason a stock-paired curve is possible.

wrap measures the reserve delta rather than trusting the requested amount. A raw PreStock transfer arrives net of its fee, so the program reads the reserve balance before and after and mints exactly what arrived. Minting the request would create unbacked supply on every wrap.

wrapped_mint.supply == reserve.amount

// wrap:    delta = reserve.after - reserve.before   → mint delta
// unwrap:  burn amount                              → transfer amount, fee paid here

The config carries four transparency counters — total_requested_in, total_received_in, total_fee_paid_in and total_unwrapped — so the fee actually paid on the way in is visible on chain, not estimated in a UI.

Every agent has one DividendVault. Holders stake the agent's `$AGENT` token into it and earn wrapped PreStock. The vault is the Synthetix staking-rewards pattern: deposits set a reward rate over a duration, and the per-share accumulator is advanced by however many slots have elapsed since it was last touched.

PRECISION = 1e12

payout  = min(reward_rate * elapsed, reward_reserve)   // capped at what it holds
increment = payout * PRECISION / total_staked
acc_reward_per_share += increment
reward_reserve       -= payout

// what a holder can claim:
pending = staked * acc_reward_per_share / PRECISION - reward_debt

1. 01Solvent by constructionPayout is capped at reward_reserve, so the accumulator can never credit more than the vault holds, whatever the rate or elapsed time.
2. 02Not flash-loanableA stream pays for time held. Stake one slot before a deposit and you earn one slot's worth; a full-duration holder earns the whole stream. min_hold_slots adds a hard retention lock on top.
3. 03No per-user bookkeepingreward_debt is the holder's settled share of the accumulator. stake and unstake settle into accrued first, so an action never silently forfeits rewards.

An Agent account binds the creator, the execution signer (the Clawpump bot's keypair), the `$AGENT` mint, the wrapped PreStock it pays out in, and the vault address. register_agent is permissionless — anyone can launch an agent — and the account is addressed by the agent's own mint, so the mint is the identity.

The `$AGENT` token trades on a Meteora Dynamic Bonding Curve. The config is created by the app when Clawpump is unavailable, and the one setting that matters for the product is the quote asset: the pool is quoted in wPreStock, and fees are collected in the quote token. That is what makes “dividends paid in equity” literally true rather than a marketing line.

quoteMint:            wPreStock            // the zero-fee wrapper
collectFeeMode:       QuoteToken           // fees accrue in the share
creatorTradingFeePercentage: 0            // the creator does not skim the vault
migrationOption:      MET_DAMM_V2          // graduates to a DAMM v2 pool
migrationQuoteThreshold: 100 wPreStock

• The `$AGENT` mint is created in the same transaction as the pool, as an Immutable SPL mint. The ephemeral keypairs that sign it have no power once it lands.
• Buying at launch is a DBC first buy, sent straight to the creator's wallet — so launching leaves you holding your own token, not just a pool.
• The app's buy box quotes the curve server-side with Meteora's SDK; the browser only ever receives an unsigned transaction.

record_signal reads a Pyth PriceUpdateV2 account on chain — permissionless, no API key — checks that it is owned by the Pyth receiver, that it carries the expected feed id, and that it is inside the caller's staleness policy, then writes a Signal. The regime is derived from publish_time: a feed that has stopped advancing is Frozen, which is the thesis encoded as an enum.

log_arb then copies the oracle fields from the referenced Signal rather than accepting them from the caller. The Pyth price, exponent, publish time and staleness on an ArbExecution are therefore attestation, not assertion — which is what makes the execution log evidence.

ArbExecution {
  agent, index, venue,
  amount_in, amount_out,
  profit,                       // amount_out.saturating_sub(amount_in), on chain
  oracle, feed_id, pyth_price, pyth_exponent,
  pyth_publish_time, pyth_staleness_secs,
  regime, executed_at,
}

The frontend does not carry an Anchor client. It decodes these accounts with small explicit Borsh readers that assert the 8-byte discriminator first, so a layout change fails loudly rather than decoding garbage.

An agent token trades on a bonding curve. The trading fee is charged in the quote asset — wPreStock — and that fee is the vault's income: it streams to stakers as the share itself. The creator's own trading-fee percentage is zero, so the vault is not competing with the creator for the same fees.

The program runs on devnet, where the whole loop works. The market inputs are read from mainnet and the program writes land on devnet.

# Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Solana CLI (Agave)
sh -c "$(curl -sSfL https://release.anza.xyz/stable/install)"

# Anchor, through avm
cargo install --git https://github.com/coral-xyz/anchor avm --locked --force
avm install latest && avm use latest

# Node 20+ and pnpm
corepack enable && corepack prepare pnpm@latest --activate

• macOS — install the Xcode Command Line Tools (xcode-select --install). If the linker rejects the SDK with a malformed-file or unknown-architecture error, pin SDKROOT to the SDK inside the CommandLineTools directory before building.
• Linux (Debian/Ubuntu) — apt-get install -y build-essential pkg-config libssl-dev libudev-dev libclang-dev. Fedora and Arch need the equivalents.
• Windows — WSL2 + Ubuntu, then the Linux line above. Keep the repo inside the WSL filesystem, not under /mnt/c, or file watching and the validator get slow.

anchor build
anchor test                                   # 30 integration tests
cargo test --manifest-path programs/stock_vault/Cargo.toml   # 15 unit tests

cd web
pnpm exec next dev -p 3939                     # dev server
pnpm exec next build && pnpm exec next start -p 3939

ANGEL_ONCE=1 pnpm exec tsx agent/src/index.ts          # one read-only pass
ANGEL_SYMBOL=OPENAI pnpm exec tsx agent/src/index.ts   # a different asset
pnpm exec tsx agent/src/index.ts --feeds               # known on-chain feeds

The check scripts are the fastest way to verify a subsystem end to end: position-check for the vault maths, trade-check for buy/auto-stake/sell/wrap/unwrap on devnet, and browser-sign-check for a real Wallet Standard signature through the UI.

• Non-custodial by construction: there are no accounts and no passwords, and the only identity is a wallet address.
• Writes are built unsigned on the server, signed in the browser by the wallet, and relayed back. The server never sees a private key.
• The devnet faucet is the one server-held key. It is devnet-gated and refuses before touching a key on a mainnet RPC; it only sends test tokens.
• Every write path is bounded — a wallet that never resolves its approval cannot leave a control spinning forever.

• The reference mark can gap when the real market reopens — the position can lose money.
• The wrapped share is only as good as the issuer's permanent delegate allows; the backing can be moved out from under the wrapper.
• Pyth equity feeds are gated on Hermes and absent on chain; the program's own reads cover the crypto/FX scope that is available permissionlessly.
• Real PreStocks wrappers only exist on mainnet, so this build uses devnet mocks.
• Trading is devnet-only today; the Jupiter USDC route is mainnet-only and is mocked on devnet.

• 15 unit tests cover the accumulator in isolation: solvency (payout capped at the reserve), duration weighting, pro-rata correctness, and an independent reference model that distributes each slot's payout exactly.
• 30 integration tests run the program against a local validator: wrapper invariants, vault streaming, Pyth attestation and the execution log.
• The accumulator is checked against a naive model that is deliberately not a reimplementation, so the test measures agreement rather than the same bug twice.

anchor test                                   # 30 integration tests
cargo test --manifest-path programs/stock_vault/Cargo.toml   # 15 unit tests

The app ships its own checks, which are the honest way to verify a subsystem against a live cluster rather than a mock: position-check (the vault maths), trade-check (buy/auto-stake/sell/wrap/unwrap), launch-curve-check (a real DBC config and pool), and browser-sign-check (a real Wallet Standard signature through the UI).

• Wallet on the wrong network — the faucet and the program run on devnet. Switch the wallet itself to Devnet, not just the app.
• Faucet cooldown — one drop per wallet every ten minutes; the drop funds test SOL and wPreStock for every mock asset.
• Empty dashboard or 429s — the public devnet RPC rate-limits the program scans. Point PROGRAM_RPC_URL and NEXT_PUBLIC_SOLANA_RPC_URL at a dedicated endpoint.
• A stale mark — the site says when the issuer API was unreachable and shows the snapshot; it never presents a snapshot as live.