feat(dapp): limit orders off stellar, and agents that recommend resting one

apps/dapp/app/api/agents/compete/route.ts

@@ -23,6 +23,8 @@ import {
   assertKnownTokens,
   assertNativeReserve,
 } from '../../../../lib/chains/prepare'
+import { limitPair } from '../../../../lib/chains/limit'
+import { restOption, restRoute } from '../../../../lib/agents/rest-option'
 import { chainModule } from '../../../../lib/chains/registry'
 import {
   ChainActionRefused,
@@ -172,8 +174,18 @@ async function chainRaceFacts(
   // The chain's market already leaves out Stellar's assets, prices, lending
   // rates and anchors; see `buildMarketContext`.
   const base = await buildMarketContextAsync(chain)
+  const pair = action.kind === 'swap' ? limitPair(action.tokenIn, action.tokenOut ?? '') : undefined
+  const baseToken = chainApi.tokens.find((t) => t.symbol.toUpperCase() === pair?.base)
+  const marketUsd =
+    pair === undefined || baseToken === undefined
+      ? undefined
+      : pair.selling
+        ? price
+        : await chainApi.priceUsd(baseToken).catch(() => undefined)
+  const rest = marketUsd === undefined ? undefined : restOption(chainApi, action, marketUsd)
   const market: MarketContext = {
     ...base,
+    ...(rest !== undefined ? { rest } : {}),
     prices: price !== undefined && tokenIn !== undefined ? { [tokenIn.symbol]: price } : {},
     venues: chainApi.venues
       .filter((v) => routes.some((r) => r.id === `${v.id}-1`))
@@ -519,19 +531,31 @@ export async function POST(request: Request): Promise<Response> {
       const settleAndMeasure = (proposal: AgentProposalResult): AgentProposalResult => {
         const own = (market.routes ?? []).find((r) => r.id === proposal.routeId)
         return measured(
-          chainFacts === undefined ? settlePlan(proposal, intent, book) : settleChainPlan(proposal),
+          chainFacts === undefined
+            ? settlePlan(proposal, intent, book)
+            : settleChainPlan(proposal, own !== undefined ? market.rest : undefined),
           own?.quote as SwapQuote | ChainRouteQuote | undefined,
           market.prices
         )
       }
 
+      // A plan that rests an order signs the order, not the swap it was measured against.
       const sendProposal = (proposal: AgentProposalResult): void => {
         const own = (market.routes ?? []).find((r) => r.id === proposal.routeId)
         send({
           type: 'competition:proposal',
           competitionId,
           proposal,
-          ...(own !== undefined ? { route: own.quote } : {}),
+          ...(own !== undefined
+            ? {
+                route:
+                  proposal.executionMode === 'rest' &&
+                  market.rest !== undefined &&
+                  proposal.restPriceUsd !== undefined
+                    ? restRoute(own.quote as ChainRouteQuote, market.rest, proposal.restPriceUsd)
+                    : own.quote,
+              }
+            : {}),
         })
       }
 
@@ -740,7 +764,11 @@ export async function POST(request: Request): Promise<Response> {
         ...(unmeasuredRoutes.length > 0 ? { unmeasuredRoutes } : {}),
       }
 
-      const scored = scoreProposals(proposals, { competitionId, plan })
+      const scored = scoreProposals(proposals, {
+        competitionId,
+        plan,
+        ...(chainFacts !== undefined ? { restsBelowFills: true } : {}),
+      })
       // An agent that held off has no plan to score.
       const heldOff = new Set(proposals.filter((p) => p.held === true).map((p) => p.agent))
       const winner = pickWinner(scored)

apps/dapp/app/api/chain/[chain]/orders/route.ts

@@ -0,0 +1,97 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+
+import { chainModule } from '../../../../../lib/chains/registry'
+import { BALANCE_DEADLINE_MS, ChainActionRefused } from '../../../../../lib/chains/types'
+import { enforceRateLimit } from '../../../../../lib/server/rate-limit'
+import { reportError } from '../../../../../lib/server/report'
+import { isWalletAddress } from '../../../../../lib/wallet/address'
+
+export const runtime = 'nodejs'
+export const dynamic = 'force-dynamic'
+export const maxDuration = 20
+
+const Body = z.object({
+  account: z.string().min(1).max(128),
+  orderId: z.string().min(1).max(200),
+  action: z.enum(['cancel', 'collect']),
+})
+
+/** The account's resting limit orders on this chain, read when asked and never kept. */
+export async function GET(
+  request: Request,
+  { params }: { params: Promise<{ chain: string }> }
+): Promise<NextResponse> {
+  const limited = await enforceRateLimit(request, 'read')
+  if (limited !== undefined) return limited
+
+  const chainApi = chainModule((await params).chain)
+  if (chainApi === undefined) return NextResponse.json({ error: 'unknown_chain' }, { status: 404 })
+
+  const account = new URL(request.url).searchParams.get('account') ?? ''
+  if (!isWalletAddress(account)) {
+    return NextResponse.json({ error: 'invalid_account' }, { status: 400 })
+  }
+  if (chainApi.limitBook === undefined) {
+    return NextResponse.json({ orders: [] }, { headers: { 'cache-control': 'no-store' } })
+  }
+  try {
+    const orders = await chainApi.limitBook.openOrders(
+      account,
+      AbortSignal.timeout(BALANCE_DEADLINE_MS)
+    )
+    return NextResponse.json({ orders }, { headers: { 'cache-control': 'no-store' } })
+  } catch (e) {
+    if (e instanceof ChainActionRefused) {
+      return NextResponse.json({ error: 'invalid_account' }, { status: 400 })
+    }
+    reportError('chain/orders', e, { chain: chainApi.chain })
+    return NextResponse.json({ error: 'orders_unavailable' }, { status: 503 })
+  }
+}
+
+/** Builds the cancel or the collect of a resting order for the wallet to sign. */
+export async function POST(
+  request: Request,
+  { params }: { params: Promise<{ chain: string }> }
+): Promise<NextResponse> {
+  const limited = await enforceRateLimit(request, 'build')
+  if (limited !== undefined) return limited
+
+  const chainApi = chainModule((await params).chain)
+  if (chainApi === undefined) return NextResponse.json({ error: 'unknown_chain' }, { status: 404 })
+
+  const parsed = Body.safeParse(await request.json().catch(() => undefined))
+  if (!parsed.success) return NextResponse.json({ error: 'invalid_body' }, { status: 400 })
+  if (!isWalletAddress(parsed.data.account)) {
+    return NextResponse.json({ error: 'invalid_account' }, { status: 400 })
+  }
+
+  if (chainApi.limitBook === undefined) {
+    return NextResponse.json(
+      { error: 'There are no limit orders to change on this chain. Nothing was signed or sent.' },
+      { status: 422 }
+    )
+  }
+  try {
+    const { account, orderId, action } = parsed.data
+    const prepared = await chainApi.limitBook.prepareExit(account, orderId, action)
+    const venue = chainApi.venues.find((v) => v.id === prepared.venueId)
+    if (venue === undefined) {
+      throw new ChainActionRefused(
+        'That order is not one I can build safely. Nothing was signed or sent.'
+      )
+    }
+    venue.assertSafe(prepared.signing, account, prepared.context)
+    return NextResponse.json({ prepared })
+  } catch (e) {
+    if (e instanceof ChainActionRefused) {
+      return NextResponse.json({ error: e.message }, { status: 422 })
+    }
+    reportError('chain/orders', e, { chain: chainApi.chain })
+    return NextResponse.json(
+      { error: 'This could not be built right now. Nothing was signed or sent.' },
+      { status: 502 }
+    )
+  }
+}

apps/dapp/app/api/chain/[chain]/prepare/route.ts

@@ -19,6 +19,7 @@ const Body = z.object({
       'supply',
       'stake',
       'send',
+      'limit',
       'withdraw',
       'unstake',
       'borrow',
@@ -37,6 +38,7 @@ const Body = z.object({
     tokenOut: z.string().min(1).max(16).optional(),
     venue: z.string().min(1).max(40).optional(),
     recipient: z.string().min(1).max(128).optional(),
+    limitPrice: z.string().min(1).max(40).optional(),
     durationDays: z
       .string()
       .regex(/^[1-9]\d{0,4}$/)
@@ -81,6 +83,7 @@ export async function POST(
       tokenOut,
       venue,
       recipient,
+      limitPrice,
       durationDays,
       dueDate,
       invoiceId,
@@ -95,6 +98,7 @@ export async function POST(
         ...(tokenOut !== undefined ? { tokenOut } : {}),
         ...(venue !== undefined ? { venue } : {}),
         ...(recipient !== undefined ? { recipient } : {}),
+        ...(limitPrice !== undefined ? { limitPrice } : {}),
         ...(durationDays !== undefined ? { durationDays } : {}),
         ...(dueDate !== undefined ? { dueDate } : {}),
         ...(invoiceId !== undefined ? { invoiceId } : {}),

apps/dapp/app/api/chain/[chain]/submit/route.ts

@@ -27,6 +27,7 @@ const Signed = z.discriminatedUnion('family', [
   }),
   // The venue checks its shape, so an odd answer from a wallet that may have sent is read as pending.
   z.object({ family: z.literal('evm'), hash: z.string().max(128) }),
+  z.object({ family: z.literal('evm-typed'), signature: z.string().min(1).max(200) }),
 ])
 
 const Body = z.object({
@@ -59,14 +60,16 @@ export async function POST(
 
   const venue = chainApi.venues.find((v) => v.id === venueId)
   if (venue === undefined) return NextResponse.json({ error: 'unknown_venue' }, { status: 404 })
-  // By family, since Avalanche and Monad are both EVM.
-  if (signed.family !== CHAIN_DESCRIPTORS[chainApi.chain].family) {
+  // By family, since Avalanche and Monad are both EVM. A typed message is EVM's too.
+  const family = signed.family === 'evm-typed' ? 'evm' : signed.family
+  if (family !== CHAIN_DESCRIPTORS[chainApi.chain].family) {
     return NextResponse.json({ error: 'wrong_chain' }, { status: 400 })
   }
 
   // NEAR and EVM wallets have already sent, so there are no bytes left to check. Their venues
-  // ask the chain what was sent instead.
-  if (signed.family !== 'near' && signed.family !== 'evm') {
+  // ask the chain what was sent instead. A typed message carries only its signature, so its venue
+  // rebuilds what was signed and checks it before posting anything.
+  if (signed.family === 'solana' || signed.family === 'sui') {
     const payload: SigningPayload =
       signed.family === 'solana'
         ? { family: 'solana', transaction: signed.signedTransaction }

apps/dapp/components/intents/chain-action-confirm.tsx

@@ -5,6 +5,8 @@ import { ExternalLink, Loader2 } from 'lucide-react'
 
 import type { ChainAction } from '../../hooks/use-chain-action'
 import { stepErrorMessage } from '../../lib/agents/chain-race'
+import { limitSettledNote } from '../../lib/chains/orders-view'
+import { useChain } from '../../providers/chain-provider'
 import type { PreparedAction } from '../../lib/chains/types'
 
 function cardLine({ kind, pay, venueName }: PreparedAction): string {
@@ -45,6 +47,7 @@ export function ChainActionConfirm({
   typedStep?: string | undefined
 }): JSX.Element {
   const { phase, prepared, hash, explorerUrl, earlier } = action
+  const { slug } = useChain()
   const error = stepErrorMessage(action.error, sequenceSettled, typedStep)
   const busy = phase === 'signing' || phase === 'submitting'
 
@@ -137,7 +140,29 @@ export function ChainActionConfirm({
             </p>
           ) : null}
 
-          {phase === 'settled' ? (
+          {phase === 'settled' && action.canContinue ? (
+            <div className="flex flex-col gap-2">
+              <p className="flex items-center gap-2 text-sm font-medium" role="status">
+                Done. One more signature finishes this.
+              </p>
+              <div>
+                <Button size="sm" onClick={action.continueSetup}>
+                  Continue
+                </Button>
+              </div>
+            </div>
+          ) : null}
+
+          {phase === 'settled' &&
+          !action.canContinue &&
+          prepared.kind === 'limit' &&
+          action.source?.kind === 'request' ? (
+            <p className="text-muted-foreground text-xs leading-relaxed">
+              {limitSettledNote(slug)}
+            </p>
+          ) : null}
+
+          {phase === 'settled' && action.canContinue ? null : phase === 'settled' ? (
             <p className="flex items-center gap-2 text-sm font-medium" role="status">
               Sent
               {explorerUrl !== undefined ? (