feat(vibenet): rest concurrent Validity conditions on 8130

Denim is 200ms, so predicates and the tape need that clock. Nonceless 8130
lets several conditions sit in the Vibenet mempool without replacing each other.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: BrianBland

.env.example

@@ -53,9 +53,10 @@ NEXT_PUBLIC_VIBENET_RPC_URL=https://rpc.vibes.base.org
 # NEXT_PUBLIC_BENCHMARK_API_BASE_URL=
 
 # Validity demo (/vibenet/demos/validity). Server-side RPC proxy only.
-# Defaults to the public Vibenet RPC (`NEXT_PUBLIC_VIBENET_RPC_URL`). ETH comes
-# from the Vibenet faucet — do not set a funder key. Override only for a local
-# node with --enable-experimental-validity-transactions.
+# Defaults to the public Vibenet RPC (`NEXT_PUBLIC_VIBENET_RPC_URL`) for both
+# reads and `base_sendRawTransactionValidity` submits. ETH comes from the
+# Vibenet faucet — do not set a funder key.
 # VALIDITY_DEMO_RPC_URL=https://rpc.vibes.base.org
-# Local Anvil / just devnet:
+# VALIDITY_DEMO_SUBMIT_RPC_URL=https://rpc.vibes.base.org
+# Local node with --enable-experimental-validity-transactions:
 # VALIDITY_DEMO_RPC_URL=http://127.0.0.1:8545

app/vibenet/demos/catalogue.ts

@@ -55,7 +55,7 @@ export const DEMOS: DemoEntry[] = [
     points: [
       'Add storage and block-number conditions to an ordinary swap',
       'A simulated AMM makes those conditions visible on a moving mid',
-      'Optional 5s / 15s / 60s bound so a stale condition cannot fire later',
+      'Stack several 8130 conditions at once, or replace the resting one',
     ],
     available: true,
   },

app/vibenet/demos/validity/ValidityDemo.tsx

@@ -1,7 +1,7 @@
 'use client';
 
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import type { Account, PublicClient, WalletClient } from 'viem';
+import type { Account, Hex, PublicClient, WalletClient } from 'viem';
 import { formatEther } from 'viem';
 
 import { trackValidityOrder } from '../../../analytics/events';
@@ -25,8 +25,9 @@ import {
   signCall,
   tokenBalance,
 } from './lib/amm';
+import { clampNoncelessExpiry, signNoncelessCall } from './lib/aa';
 import { startBots, allNeedGas, botNeedsGas, refuelValue } from './lib/bots';
-import { MAX_EXPIRY_SECONDS } from './lib/constants';
+import { BLOCK_MS, MAX_EXPIRY_SECONDS, MAX_NONCELESS_SECONDS } from './lib/constants';
 import { faucetErrorMessage, seedEthFromFaucet } from './lib/faucet';
 import {
   maxBlockForExpiry,
@@ -56,11 +57,11 @@ import {
   sendValidityTransaction,
 } from './lib/rpc';
 import { accountsFrom, createState, dropDeployment, loadState, saveState, type StoredState } from './lib/store';
-import type { ChainStatus, PlacedOrder, Rectangle, Reserves, Side } from './lib/types';
+import type { ChainStatus, PlacedOrder, Rectangle, Reserves, Side, SubmitMode } from './lib/types';
 
-const POLL_MS = 400;
-/** L2 blocks are ~2s. viem's default 4s block cache made this skip 2–3 heads. */
-const BLOCK_POLL_MS = 1_000;
+const POLL_MS = BLOCK_MS;
+/** Denim heads are 200ms. viem's default 4s block cache would skip dozens. */
+const BLOCK_POLL_MS = BLOCK_MS;
 const DEFAULT_SIZE_FRACTION = 50n; // 1/50 of inventory
 
 function wadToNumber(wad: bigint): number {
@@ -85,7 +86,8 @@ export function ValidityDemo() {
   const [hoverPrice, setHoverPrice] = useState<bigint | null>(null);
   const [side, setSide] = useState<Side>('buy');
   const [offsetBps, setOffsetBps] = useState(100);
-  const [expirySeconds, setExpirySeconds] = useState(60);
+  const [expirySeconds, setExpirySeconds] = useState(15);
+  const [submitMode, setSubmitMode] = useState<SubmitMode>('concurrent');
   const [orders, setOrders] = useState<PlacedOrder[]>([]);
   const [hoveredOrderId, setHoveredOrderId] = useState<string | null>(null);
   const [samples, setSamples] = useState<PriceSample[]>([]);
@@ -429,7 +431,7 @@ export function ValidityDemo() {
 
     const id = window.setInterval(() => {
       void tick();
-    }, 700);
+    }, 250);
     void tick();
     return () => {
       cancelled = true;
@@ -613,12 +615,16 @@ export function ValidityDemo() {
         amount0Out,
         amount1Out,
       });
-      const confirmedNonce = await publicClient.getTransactionCount({
-        address: account.address,
-        blockTag: 'latest',
-      });
-      const occupant = occupyingOrder(ordersRef.current, confirmedNonce);
-      const replaced = restingOrderToReplace(ordersRef.current, confirmedNonce);
+      const seconds =
+        submitMode === 'concurrent'
+          ? clampNoncelessExpiry(expirySeconds)
+          : Math.min(MAX_EXPIRY_SECONDS, expirySeconds);
+      const block = await publicClient.getBlockNumber({ cacheTime: 0 });
+      const maxBlock = maxBlockForExpiry(block, seconds);
+      const validity = [...draft.predicates];
+      if (status?.blockNumberPredicate) {
+        validity.push(blockExpiryPredicate(maxBlock));
+      }
       const estimated = await publicClient.estimateFeesPerGas().catch(() => null);
       const padded =
         estimated?.maxFeePerGas !== undefined && estimated.maxPriorityFeePerGas !== undefined
@@ -627,55 +633,73 @@ export function ValidityDemo() {
               maxPriorityFeePerGas: estimated.maxPriorityFeePerGas,
             })
           : null;
+      trackValidityOrder(side, 'submitted');
+      let hash: Hex;
+      let nonce: number | undefined;
       let fees = padded;
-      if (occupant?.maxFeePerGas !== undefined && occupant.maxPriorityFeePerGas !== undefined) {
-        fees = bumpReplacementFees(
-          {
-            maxFeePerGas: occupant.maxFeePerGas,
-            maxPriorityFeePerGas: occupant.maxPriorityFeePerGas,
-          },
-          padded,
-        );
-      }
-      const sign = (nextFees: typeof fees) =>
-        signCall({
-          wallet,
-          publicClient,
-          account,
+      let replaced: ReturnType<typeof restingOrderToReplace>;
+      if (submitMode === 'concurrent') {
+        replaced = undefined;
+        const signed = await signNoncelessCall({
+          privateKey: state.userKey,
+          chainId: status?.chainId ?? state.chainId,
           to: call.to,
           data: call.data,
-          nonce: confirmedNonce,
-          fees: nextFees,
+          expiresIn: seconds,
+          fees: padded,
+          publicClient,
         });
-      let signedResult = await sign(fees);
-      const seconds = Math.min(MAX_EXPIRY_SECONDS, expirySeconds);
-      const block = await publicClient.getBlockNumber({ cacheTime: 0 });
-      const maxBlock = maxBlockForExpiry(block, seconds);
-      const validity = [...draft.predicates];
-      if (status?.blockNumberPredicate) {
-        validity.push(blockExpiryPredicate(maxBlock));
-      }
-      trackValidityOrder(side, 'submitted');
-      let hash;
-      try {
-        hash = await sendValidityTransaction(publicClient, signedResult.signed, validity);
-      } catch (err) {
-        if (!isReplacementUnderpriced(err) || !signedResult.fees) throw err;
-        signedResult = await sign(bumpReplacementFees(signedResult.fees, padded));
-        hash = await sendValidityTransaction(publicClient, signedResult.signed, validity);
+        hash = await sendValidityTransaction(publicClient, signed.signed, validity);
+      } else {
+        const confirmedNonce = await publicClient.getTransactionCount({
+          address: account.address,
+          blockTag: 'latest',
+        });
+        const occupant = occupyingOrder(ordersRef.current, confirmedNonce);
+        replaced = restingOrderToReplace(ordersRef.current, confirmedNonce);
+        if (occupant?.maxFeePerGas !== undefined && occupant.maxPriorityFeePerGas !== undefined) {
+          fees = bumpReplacementFees(
+            {
+              maxFeePerGas: occupant.maxFeePerGas,
+              maxPriorityFeePerGas: occupant.maxPriorityFeePerGas,
+            },
+            padded,
+          );
+        }
+        const sign = (nextFees: typeof fees) =>
+          signCall({
+            wallet,
+            publicClient,
+            account,
+            to: call.to,
+            data: call.data,
+            nonce: confirmedNonce,
+            fees: nextFees,
+          });
+        let signedResult = await sign(fees);
+        try {
+          hash = await sendValidityTransaction(publicClient, signedResult.signed, validity);
+        } catch (err) {
+          if (!isReplacementUnderpriced(err) || !signedResult.fees) throw err;
+          signedResult = await sign(bumpReplacementFees(signedResult.fees, padded));
+          hash = await sendValidityTransaction(publicClient, signedResult.signed, validity);
+        }
+        nonce = signedResult.nonce;
+        fees = signedResult.fees;
       }
       const order: PlacedOrder = {
         id: newId(),
         side,
         targetPriceWad: draft.priceWad,
         size: amountIn,
         expirySeconds: seconds,
+        submitMode,
         maxBlock: status?.blockNumberPredicate ? maxBlock : undefined,
         submittedAt: Date.now(),
         txHash: hash,
-        nonce: signedResult.nonce,
-        maxFeePerGas: signedResult.fees?.maxFeePerGas,
-        maxPriorityFeePerGas: signedResult.fees?.maxPriorityFeePerGas,
+        nonce,
+        maxFeePerGas: fees?.maxFeePerGas,
+        maxPriorityFeePerGas: fees?.maxPriorityFeePerGas,
         status: 'pending',
         rectangle: draft.rectangle,
         validity,
@@ -747,6 +771,7 @@ export function ValidityDemo() {
       <div className="flex flex-col gap-2">
         <div className="flex flex-wrap items-center gap-x-5 gap-y-2 font-mono text-[12px] text-bds-gray-60">
           <span>{status?.readHost ?? 'no rpc'}</span>
+          <span>200ms blocks</span>
           <span>validity {status?.validitySupported ? 'on' : 'unavailable'}</span>
           {status?.blockNumberPredicate ? <span>block bounds on</span> : <span>client-side expiry only</span>}
           <span>simulation {botsOn ? (makersDry ? 'out of ETH' : 'live') : 'paused'}</span>
@@ -782,9 +807,10 @@ export function ValidityDemo() {
         <Card className="flex flex-col gap-4 bg-background p-6 dark:bg-white/5">
           <Text variant="title3">Simulated pool</Text>
           <Text variant="label.regular" tone="muted">
-            A local EOA (not the Vibenet 8130 account) signs the swaps. The faucet
-            funds it, then you deploy a VIBE/USDV pool. Simulated flow moves the mid
-            so you can see a price condition fire — or expire unused.
+            A local key signs the swaps — type-2 replacements, or 8130 nonceless
+            txs so several conditions can rest at once. The faucet funds it, then
+            you deploy a VIBE/USDV pool. Simulated flow moves the mid so you can
+            see a price condition fire — or expire unused.
           </Text>
           {address ? (
             <div className="flex items-center justify-between gap-3">
@@ -836,11 +862,18 @@ export function ValidityDemo() {
                   side={side}
                   offsetBps={offsetBps}
                   expirySeconds={expirySeconds}
+                  submitMode={submitMode}
                   busy={busy}
                   validitySupported={Boolean(status?.validitySupported)}
                   onSide={setSide}
                   onOffset={setOffsetBps}
                   onExpiry={setExpirySeconds}
+                  onSubmitMode={(mode) => {
+                    setSubmitMode(mode);
+                    if (mode === 'concurrent' && expirySeconds > MAX_NONCELESS_SECONDS) {
+                      setExpirySeconds(15);
+                    }
+                  }}
                   onSubmit={() => void placeOrder()}
                 />
               ) : (

app/vibenet/demos/validity/components/OrderList.tsx

@@ -74,7 +74,8 @@ export function OrderList({ orders, highlightedOrderId, onHighlight }: Props) {
       <div className="flex flex-col gap-2">
         <Text variant="title3">Submitted</Text>
         <Text variant="footnote" tone="muted">
-          Conditional swaps land here. They also draw as a dashed line on the tape.
+          Conditional swaps land here. Concurrent 8130 orders stack; replace
+          mode bumps the last nonce.
         </Text>
       </div>
     );
@@ -125,6 +126,7 @@ export function OrderList({ orders, highlightedOrderId, onHighlight }: Props) {
             </div>
             <Text variant="footnote" tone="muted" className="tabular-nums">
               {formatClock(order.submittedAt)}
+              {order.submitMode === 'concurrent' ? ' · 8130' : order.submitMode === 'replace' ? ' · replace' : null}
               {order.filledAt ? ` → ${formatClock(order.filledAt)}` : null}
               {filled && order.fillPriceWad !== undefined
                 ? ` · ${formatPrice(order.fillPriceWad)}`

app/vibenet/demos/validity/components/OrderTicket.tsx

@@ -2,8 +2,9 @@
 
 import { Button } from '../../../../components/ui/Button';
 import { Text } from '../../../../components/ui/Text';
+import { MAX_NONCELESS_SECONDS } from '../lib/constants';
 import { applyOffsetBps, formatPrice } from '../lib/predicates';
-import type { Side } from '../lib/types';
+import type { Side, SubmitMode } from '../lib/types';
 
 const EXPIRIES = [5, 15, 60] as const;
 const OFFSETS = [0, 50, 100, 200, 500] as const;
@@ -13,11 +14,13 @@ type Props = {
   side: Side;
   offsetBps: number;
   expirySeconds: number;
+  submitMode: SubmitMode;
   busy: boolean;
   validitySupported: boolean;
   onSide: (side: Side) => void;
   onOffset: (bps: number) => void;
   onExpiry: (seconds: number) => void;
+  onSubmitMode: (mode: SubmitMode) => void;
   onSubmit: () => void;
 };
 
@@ -31,11 +34,13 @@ export function OrderTicket({
   side,
   offsetBps,
   expirySeconds,
+  submitMode,
   busy,
   validitySupported,
   onSide,
   onOffset,
   onExpiry,
+  onSubmitMode,
   onSubmit,
 }: Props) {
   const target = applyOffsetBps(spotWad, side, offsetBps);
@@ -114,25 +119,66 @@ export function OrderTicket({
           mid {signed}
         </Text>
       </div>
+      <div className="flex flex-col gap-2">
+        <Text variant="caption" tone="muted">
+          Mempool
+        </Text>
+        <div className="grid grid-cols-2 gap-2">
+          <button
+            type="button"
+            onClick={() => onSubmitMode('replace')}
+            className={
+              submitMode === 'replace'
+                ? 'rounded-xl bg-foreground px-3 py-2 text-[13px] font-medium text-background'
+                : 'rounded-xl border border-bds-gray-10 px-3 py-2 text-[13px] dark:border-white/10'
+            }
+          >
+            Replace
+          </button>
+          <button
+            type="button"
+            onClick={() => onSubmitMode('concurrent')}
+            className={
+              submitMode === 'concurrent'
+                ? 'rounded-xl bg-foreground px-3 py-2 text-[13px] font-medium text-background'
+                : 'rounded-xl border border-bds-gray-10 px-3 py-2 text-[13px] dark:border-white/10'
+            }
+          >
+            Concurrent
+          </button>
+        </div>
+        <Text variant="footnote" tone="muted">
+          {submitMode === 'replace'
+            ? 'Same nonce, fee bump. The new swap takes the resting slot.'
+            : `8130 nonceless — stack several at once. Envelope max ${MAX_NONCELESS_SECONDS}s.`}
+        </Text>
+      </div>
       <div className="flex flex-col gap-2">
         <Text variant="caption" tone="muted">
           Expiry
         </Text>
         <div className="flex gap-2">
-          {EXPIRIES.map((seconds) => (
-            <button
-              key={seconds}
-              type="button"
-              onClick={() => onExpiry(seconds)}
-              className={
-                seconds === expirySeconds
-                  ? 'rounded-full bg-foreground px-3 py-1 text-[12px] text-background'
-                  : 'rounded-full border border-bds-gray-10 px-3 py-1 text-[12px] dark:border-white/10'
-              }
-            >
-              {seconds}s
-            </button>
-          ))}
+          {EXPIRIES.map((seconds) => {
+            const blocked = submitMode === 'concurrent' && seconds > MAX_NONCELESS_SECONDS;
+            return (
+              <button
+                key={seconds}
+                type="button"
+                disabled={blocked}
+                title={blocked ? `8130 nonceless max is ${MAX_NONCELESS_SECONDS}s` : undefined}
+                onClick={() => onExpiry(seconds)}
+                className={
+                  blocked
+                    ? 'rounded-full border border-bds-gray-10 px-3 py-1 text-[12px] text-bds-gray-40 dark:border-white/10'
+                    : seconds === expirySeconds
+                      ? 'rounded-full bg-foreground px-3 py-1 text-[12px] text-background'
+                      : 'rounded-full border border-bds-gray-10 px-3 py-1 text-[12px] dark:border-white/10'
+                }
+              >
+                {seconds}s
+              </button>
+            );
+          })}
         </div>
       </div>
       {!validitySupported ? (