mppx 0.8.5 → 0.8.7

package/src/tempo/session/server/Session.test.ts

@@ -1,5 +1,7 @@
 import * as node_http from 'node:http'
 
+import { serve } from '@hono/node-server'
+import { Hono } from 'hono'
 import { Challenge, Constants, Credential } from 'mppx'
 import { Mppx as Mppx_server, tempo as tempo_server } from 'mppx/server'
 import {
@@ -235,6 +237,18 @@ function verifyRequestWithFeePayer(channelId: Hex, feePayer: typeof payer): Veri
   } as unknown as VerifyRequest
 }
 
+function sourceFor(account = payer): string {
+  return `did:pkh:eip155:${chainId}:${account.address}`
+}
+
+function voucherCredential(payload: SessionCredentialPayload, channelId: Hex) {
+  return {
+    challenge: makeChallenge(channelId),
+    payload,
+    source: sourceFor(),
+  }
+}
+
 let saltCounter = 0
 
 async function createOpenPayload(
@@ -1434,10 +1448,7 @@ describe('precompile server session unit guardrails', () => {
     )
 
     const receipt = (await method.verify({
-      credential: {
-        challenge: makeChallenge(openPayload.channelId),
-        payload: voucher,
-      },
+      credential: voucherCredential(voucher, openPayload.channelId),
       request: verifyRequest(openPayload.channelId),
     })) as SessionReceipt
 
@@ -1473,10 +1484,7 @@ describe('precompile server session unit guardrails', () => {
     })
 
     const receipt = (await method.verify({
-      credential: {
-        challenge: makeChallenge(openPayload.channelId),
-        payload: voucher,
-      },
+      credential: voucherCredential(voucher, openPayload.channelId),
       request: verifyRequest(openPayload.channelId),
     })) as SessionReceipt
 
@@ -1506,10 +1514,7 @@ describe('precompile server session unit guardrails', () => {
 
     await expect(
       method.verify({
-        credential: {
-          challenge: makeChallenge(openPayload.channelId),
-          payload: voucher,
-        },
+        credential: voucherCredential(voucher, openPayload.channelId),
         request: verifyRequest(openPayload.channelId),
       }),
     ).rejects.toThrow(
@@ -1534,16 +1539,13 @@ describe('precompile server session unit guardrails', () => {
 
     await expect(
       method.verify({
-        credential: {
-          challenge: makeChallenge(openPayload.channelId),
-          payload: voucher,
-        },
+        credential: voucherCredential(voucher, openPayload.channelId),
         request: verifyRequest(openPayload.channelId),
       }),
     ).rejects.toThrow(/voucher delta 150 below minimum 200/)
   })
 
-  test('accepts idempotent precompile voucher replay after on-chain settlement catches up', async () => {
+  test('rejects idempotent precompile voucher replay after on-chain settlement catches up', async () => {
     const rawStore = Store.memory()
     const store = channelStore(rawStore)
     const openPayload = await createOpenPayload({ initialAmount: 100n })
@@ -1572,17 +1574,12 @@ describe('precompile server session unit guardrails', () => {
         createStateClient(payer, { settled: 500n, deposit: 1_000n, closeRequestedAt: 0 }),
     })
 
-    const receipt = (await method.verify({
-      credential: {
-        challenge: makeChallenge(openPayload.channelId),
-        payload: voucher,
-      },
-      request: verifyRequest(openPayload.channelId),
-    })) as SessionReceipt
-
-    expect(receipt.acceptedCumulative).toBe('500')
-    expect(receipt.spent).toBe('500')
-    expect(receipt.units).toBe(10)
+    await expect(
+      method.verify({
+        credential: voucherCredential(voucher, openPayload.channelId),
+        request: verifyRequest(openPayload.channelId),
+      }),
+    ).rejects.toThrow(/below on-chain settled amount/)
   })
 
   test('rejects stale or hijacked precompile voucher signatures', async () => {
@@ -1599,16 +1596,16 @@ describe('precompile server session unit guardrails', () => {
 
     await expect(
       method.verify({
-        credential: {
-          challenge: makeChallenge(openPayload.channelId),
-          payload: {
+        credential: voucherCredential(
+          {
             action: 'voucher',
             channelId: openPayload.channelId,
             cumulativeAmount: '250',
             descriptor: openPayload.descriptor,
             signature,
           },
-        },
+          openPayload.channelId,
+        ),
         request: verifyRequest(openPayload.channelId),
       }),
     ).rejects.toThrow(/invalid voucher signature/)
@@ -1628,10 +1625,7 @@ describe('precompile server session unit guardrails', () => {
 
     await expect(
       method.verify({
-        credential: {
-          challenge: makeChallenge(openPayload.channelId),
-          payload: voucher,
-        },
+        credential: voucherCredential(voucher, openPayload.channelId),
         request: verifyRequest(openPayload.channelId),
       }),
     ).rejects.toThrow(/exceeds.*deposit|insufficient channel deposit/)
@@ -1664,10 +1658,7 @@ describe('precompile server session unit guardrails', () => {
 
     await expect(
       method.verify({
-        credential: {
-          challenge: makeChallenge(openPayload.channelId),
-          payload: voucher,
-        },
+        credential: voucherCredential(voucher, openPayload.channelId),
         request: verifyRequest(openPayload.channelId),
       }),
     ).rejects.toThrow(/pending close request/)
@@ -1699,10 +1690,7 @@ describe('precompile server session unit guardrails', () => {
 
     await expect(
       method.verify({
-        credential: {
-          challenge: makeChallenge(openPayload.channelId),
-          payload: voucher,
-        },
+        credential: voucherCredential(voucher, openPayload.channelId),
         request: verifyRequest(openPayload.channelId),
       }),
     ).rejects.toThrow(/deposit is zero|channel deposit is zero|not found/)
@@ -1853,6 +1841,7 @@ describe('precompile server session unit guardrails', () => {
             Authorization: Credential.serialize({
               challenge: Challenge.fromResponse(first.challenge),
               payload: voucher,
+              source: sourceFor(),
             }),
           },
         }),
@@ -1874,6 +1863,7 @@ describe('precompile server session unit guardrails', () => {
             Authorization: Credential.serialize({
               challenge: Challenge.fromResponse(replayChallenge.challenge),
               payload: voucher,
+              source: sourceFor(),
             }),
           },
         }),
@@ -1915,6 +1905,7 @@ describe('precompile server session unit guardrails', () => {
           Credential.serialize({
             challenge: Challenge.fromResponse(first.challenge),
             payload: voucher,
+            source: sourceFor(),
           }),
         ),
       )
@@ -1933,6 +1924,7 @@ describe('precompile server session unit guardrails', () => {
           Credential.serialize({
             challenge: Challenge.fromResponse(replayChallenge.challenge),
             payload: voucher,
+            source: sourceFor(),
           }),
         ),
       )
@@ -1963,6 +1955,7 @@ describe('precompile server session unit guardrails', () => {
                 descriptor: openPayload.descriptor,
                 signature: (await createOpenPayload({ account: wrongPayer })).signature,
               },
+              source: sourceFor(),
             }),
           },
         }),
@@ -2125,6 +2118,7 @@ describe('precompile server session unit guardrails', () => {
       let voucherPosts = 0
       const amount = options.amount ?? '1'
       const maxDeposit = options.maxDeposit ?? 3n
+      let deposit = maxDeposit
       const unitType = options.unitType ?? 'token'
       const route = Mppx_server.create({
         methods: [
@@ -2151,12 +2145,19 @@ describe('precompile server session unit guardrails', () => {
                   receipt: transactionReceipt([
                     closedLog(payload.channelId, BigInt(payload.cumulativeAmount), 0n),
                   ]),
-                  state: { settled: 0n, deposit: maxDeposit, closeRequestedAt: 0 },
+                  state: { settled: 0n, deposit, closeRequestedAt: 0 },
+                })
+              }
+              if (payload?.action === 'topUp') {
+                deposit += BigInt(payload.additionalDeposit)
+                return createServerClient([], payer, payload.channelId, {
+                  receipt: transactionReceipt([topUpLog(payload, deposit)]),
+                  state: { settled: 0n, deposit, closeRequestedAt: 0 },
                 })
               }
               return createStateClient(payer, {
                 settled: 0n,
-                deposit: maxDeposit,
+                deposit,
                 closeRequestedAt: 0,
               })
             },
@@ -2166,8 +2167,7 @@ describe('precompile server session unit guardrails', () => {
         secretKey: 'test-secret-key-test-secret-key-32',
       }).session({ amount, decimals: 0, suggestedDeposit: maxDeposit.toString(), unitType })
 
-      const fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
-        const request = new Request(input, init)
+      const handle = async (request: Request) => {
         currentPayload = undefined
         if (request.headers.has('Authorization')) {
           try {
@@ -2178,7 +2178,7 @@ describe('precompile server session unit guardrails', () => {
 
         const result = await route(request)
         if (result.status === 402) return result.challenge
-        if (currentPayload?.action === 'voucher') return new Response(null, { status: 200 })
+        if (request.method === 'POST') return result.withReceipt()
 
         if (request.headers.get('Accept')?.includes('text/event-stream')) {
           if (unitType === 'request') {
@@ -2211,8 +2211,12 @@ describe('precompile server session unit guardrails', () => {
         return result.withReceipt(new Response('ok'))
       }
 
+      const fetch = async (input: RequestInfo | URL, init?: RequestInit) =>
+        handle(new Request(input, init))
+
       return {
         fetch,
+        handle,
         rawStore,
         get voucherPosts() {
           return voucherPosts
@@ -2247,6 +2251,71 @@ describe('precompile server session unit guardrails', () => {
       expect(persisted?.finalized).toBe(true)
     })
 
+    test('handles empty management POST streams through a Node adapter', async () => {
+      const harness = createManagedSseFetch({ maxDeposit: 1n })
+      const managementPosts: Array<{
+        action: SessionCredentialPayload['action']
+        contentLength: string | null
+        hasBody: boolean
+        status: number
+      }> = []
+      const app = new Hono()
+      app.all('*', async (c) => {
+        const request = c.req.raw
+        const payload = request.headers.has('Authorization')
+          ? Credential.fromRequest<SessionCredentialPayload>(request).payload
+          : undefined
+        const response = await harness.handle(request)
+        if (request.method === 'POST' && payload)
+          managementPosts.push({
+            action: payload.action,
+            contentLength: request.headers.get('content-length'),
+            hasBody: request.body !== null,
+            status: response.status,
+          })
+        return response
+      })
+      const server = serve({ fetch: app.fetch, port: 0 })
+      await new Promise<void>((resolve) => server.once('listening', resolve))
+      const address = server.address()
+      if (!address || typeof address === 'string') throw new Error('expected TCP address')
+
+      try {
+        const fetch: typeof globalThis.fetch = async (input, init) => {
+          const response = await globalThis.fetch(input, init)
+          return new Response(response.body, response)
+        }
+        const manager = precompileSessionManager({
+          account: payer,
+          client: createSigningClient(),
+          decimals: 0,
+          fetch,
+          maxDeposit: '3',
+        })
+
+        const chunks: string[] = []
+        const stream = await manager.sse(`http://localhost:${address.port}/stream`)
+        for await (const chunk of stream) chunks.push(chunk)
+
+        expect(chunks).toEqual(['chunk-1', 'chunk-2', 'chunk-3'])
+        const closeReceipt = await manager.close()
+        expect(closeReceipt?.spent).toBe('3')
+        expect(managementPosts).toEqual(
+          expect.arrayContaining([
+            { action: 'topUp', contentLength: '0', hasBody: true, status: 204 },
+            { action: 'voucher', contentLength: '0', hasBody: true, status: 204 },
+            { action: 'close', contentLength: '0', hasBody: true, status: 204 },
+          ]),
+        )
+        expect(managementPosts.every(({ status }) => status === 204)).toBe(true)
+
+        const persisted = await channelStore(harness.rawStore).getChannel(manager.channelId!)
+        expect(persisted?.finalized).toBe(true)
+      } finally {
+        server.close()
+      }
+    })
+
     test('unitType=request auto-metered SSE responses charge once across the stream', async () => {
       const harness = createManagedSseFetch({ maxDeposit: 1n, unitType: 'request' })
       const manager = precompileSessionManager({
@@ -2848,10 +2917,7 @@ describe('precompile server session unit guardrails', () => {
     })
 
     const receipt = await method.verify({
-      credential: {
-        challenge: makeChallenge(openPayload.channelId),
-        payload: lowerVoucher,
-      },
+      credential: voucherCredential(lowerVoucher, openPayload.channelId),
       request: verifyRequest(openPayload.channelId),
     })
 

package/src/tempo/session/server/Session.ts

@@ -413,6 +413,7 @@ export function session<const parameters extends session.Parameters>(
         channelStateTtl,
         chainId: context.chainId,
         client: context.client,
+        credentialSource: credential.source,
         escrow: context.escrow,
         expectedOperator: context.methodDetails.operator,
         feePayer: context.feePayer,

package/src/validation/core.ts

@@ -0,0 +1,348 @@
+import { validateChallenge, validateErrorHandling } from '../cli/validate/challenge.js'
+import {
+  buildUrl,
+  extractEndpointsFromDiscovery,
+  extractRequestBodyFromDiscovery,
+  fetchDiscoveryDoc,
+} from '../cli/validate/discovery.js'
+import type { CheckResult, EndpointSpec, PathParameter } from '../cli/validate/helpers.js'
+import {
+  isValidIntegerAmount,
+  parseEndpointArg,
+  resolveBodyForEndpoint,
+} from '../cli/validate/helpers.js'
+import { validatePaymentFlow } from '../cli/validate/payment.js'
+import { validate as validateDiscoveryDoc } from '../discovery/Validate.js'
+
+export { buildUrl }
+export type { CheckResult, EndpointSpec, PathParameter }
+
+export type ValidateOptions = {
+  url: string
+  endpoint?: string | undefined
+  body?: string | undefined
+  query?: string[] | undefined
+  verbose?: boolean | undefined
+  yes?: boolean | undefined
+  skipPayment?: boolean | undefined
+  discoveryPath?: string | undefined
+  onPaymentResults?: (results: CheckResult[]) => void
+}
+
+export type DiscoveryResult = {
+  found: boolean
+  valid: boolean
+  endpoints: EndpointSpec[]
+  checks: CheckResult[]
+  doc: Record<string, unknown> | null
+}
+
+export type EndpointValidationResult = {
+  method: string
+  path: string
+  challenge: CheckResult[]
+  errorHandling: CheckResult[]
+  payment: CheckResult[]
+}
+
+export type ValidateResult = {
+  url: string
+  discovery: DiscoveryResult
+  endpoints: EndpointValidationResult[]
+  summary: { passed: number; failed: number; warnings: number; skipped: number }
+  flags: {
+    sawMppEndpoint: boolean
+    sawNonMppPaymentEndpoint: boolean
+    sawMalformedChallenge: boolean
+    sawTestnet: boolean
+    sawMainnet: boolean
+    paymentSucceeded: boolean
+  }
+}
+
+export type ValidateEvent =
+  | { phase: 'discovery'; discovery: DiscoveryResult; results: CheckResult[] }
+  | { phase: 'endpoint'; endpoint: EndpointSpec }
+  | {
+      phase: 'challenge'
+      endpoint: EndpointSpec
+      results: CheckResult[]
+      isMpp: boolean
+      isTestnet: boolean
+      isNonMppPayment: boolean
+      isMalformedChallenge: boolean
+    }
+  | { phase: 'errorHandling'; endpoint: EndpointSpec; results: CheckResult[] }
+  | {
+      phase: 'payment'
+      endpoint: EndpointSpec
+      results: CheckResult[]
+      succeeded: boolean
+      body?: string | undefined
+    }
+
+/** Streams validation results as each phase completes. */
+export async function* validateStream(options: ValidateOptions): AsyncGenerator<ValidateEvent> {
+  const baseUrl = options.url.replace(/\/$/, '').replace(/\/openapi\.json$/i, '')
+  const verbose = options.verbose ?? false
+
+  const discovery = await runDiscovery(baseUrl, options)
+  yield { phase: 'discovery', discovery, results: discovery.checks }
+
+  for (const endpoint of discovery.endpoints) {
+    yield { phase: 'endpoint', endpoint }
+
+    let body: string | undefined
+    if (options.endpoint) {
+      body = options.body
+    } else {
+      body = resolveBodyForEndpoint(options.body, endpoint.path)
+      if (!body && discovery.doc) {
+        body = extractRequestBodyFromDiscovery(discovery.doc, endpoint)
+      }
+    }
+
+    const { results: challengeResults, resolvedBody } = await validateChallenge(
+      baseUrl,
+      endpoint,
+      verbose,
+      {
+        body,
+        query: options.query,
+        discoveryDoc: discovery.doc ?? undefined,
+      },
+    )
+    const effectiveBody = resolvedBody ?? body
+    const isMpp = challengeResults.some(
+      (r) => r.severity === 'pass' && r.label === 'Challenge parseable',
+    )
+    const isTestnet = challengeResults.some(
+      (r) =>
+        r.severity === 'pass' &&
+        r.label.endsWith('Valid currency address') &&
+        r.detail === 'testnet',
+    )
+    const isNonMppPayment =
+      !isMpp && challengeResults.some((r) => r.label === 'Not an MPP endpoint')
+    const hasPaymentScheme = challengeResults.some(
+      (r) => r.severity === 'pass' && r.label === 'WWW-Authenticate header present',
+    )
+    const challengeFailed = challengeResults.some(
+      (r) => r.severity === 'fail' && r.label === 'Challenge parseable',
+    )
+    const isMalformedChallenge = !isMpp && hasPaymentScheme && challengeFailed
+
+    yield {
+      phase: 'challenge',
+      endpoint,
+      results: challengeResults,
+      isMpp,
+      isTestnet,
+      isNonMppPayment,
+      isMalformedChallenge,
+    }
+
+    if (isMpp) {
+      const errorResults = await validateErrorHandling(baseUrl, endpoint, {
+        body: effectiveBody,
+        query: options.query,
+      })
+      yield { phase: 'errorHandling', endpoint, results: errorResults }
+
+      if (!options.skipPayment) {
+        const onResults = options.onPaymentResults
+        const paymentResults = await validatePaymentFlow(baseUrl, endpoint, verbose, {
+          body: effectiveBody,
+          query: options.query,
+          yes: options.yes,
+          ...(onResults && { onResults }),
+        })
+        const succeeded = paymentResults.some(
+          (r) => r.severity === 'pass' && r.label === 'Payment: successful',
+        )
+        yield { phase: 'payment', endpoint, results: paymentResults, succeeded }
+      }
+    }
+  }
+}
+
+/** Runs the full validation suite and returns all results as a batch. */
+export async function validate(options: ValidateOptions): Promise<ValidateResult> {
+  const baseUrl = options.url.replace(/\/$/, '').replace(/\/openapi\.json$/i, '')
+  let discovery: DiscoveryResult | undefined
+  const endpointResults: EndpointValidationResult[] = []
+  let current: EndpointValidationResult | undefined
+
+  let sawTestnet = false
+  let sawMainnet = false
+  let paymentSucceeded = false
+  let sawMppEndpoint = false
+  let sawNonMppPaymentEndpoint = false
+  let sawMalformedChallenge = false
+
+  for await (const event of validateStream(options)) {
+    switch (event.phase) {
+      case 'discovery':
+        discovery = event.discovery
+        break
+      case 'endpoint':
+        current = {
+          method: event.endpoint.method,
+          path: event.endpoint.path,
+          challenge: [],
+          errorHandling: [],
+          payment: [],
+        }
+        endpointResults.push(current)
+        break
+      case 'challenge':
+        if (current) current.challenge = event.results
+        if (event.isMpp) {
+          sawMppEndpoint = true
+          if (event.isTestnet) sawTestnet = true
+          else sawMainnet = true
+        }
+        if (event.isNonMppPayment) sawNonMppPaymentEndpoint = true
+        if (event.isMalformedChallenge) sawMalformedChallenge = true
+        break
+      case 'errorHandling':
+        if (current) current.errorHandling = event.results
+        break
+      case 'payment':
+        if (current) current.payment = event.results
+        if (event.succeeded) paymentSucceeded = true
+        break
+    }
+  }
+
+  const summary = { passed: 0, failed: 0, warnings: 0, skipped: 0 }
+  if (discovery) {
+    for (const r of discovery.checks) {
+      if (r.severity === 'pass') summary.passed++
+      else if (r.severity === 'fail') summary.failed++
+      else if (r.severity === 'warn') summary.warnings++
+      else if (r.severity === 'skip') summary.skipped++
+    }
+  }
+  for (const ep of endpointResults) {
+    for (const r of [...ep.challenge, ...ep.errorHandling, ...ep.payment]) {
+      if (r.severity === 'pass') summary.passed++
+      else if (r.severity === 'fail') summary.failed++
+      else if (r.severity === 'warn') summary.warnings++
+      else if (r.severity === 'skip') summary.skipped++
+    }
+  }
+
+  if (!discovery) throw new Error('Discovery phase did not complete')
+
+  return {
+    url: baseUrl,
+    discovery,
+    endpoints: endpointResults,
+    summary,
+    flags: {
+      sawMppEndpoint,
+      sawNonMppPaymentEndpoint,
+      sawMalformedChallenge,
+      sawTestnet,
+      sawMainnet,
+      paymentSucceeded,
+    },
+  }
+}
+
+async function runDiscovery(baseUrl: string, options: ValidateOptions): Promise<DiscoveryResult> {
+  const checks: CheckResult[] = []
+  let endpoints: EndpointSpec[] = []
+  let discoveryDoc: Record<string, unknown> | null = null
+  let found = false
+  let valid = false
+
+  // Try the user's path first, then root, then /api.
+  const origin = new URL(baseUrl).origin
+  let candidates: string[]
+  if (options.discoveryPath) {
+    candidates = [
+      new URL(options.discoveryPath, baseUrl + '/').href.replace(/\/openapi\.json$/i, ''),
+    ]
+  } else {
+    candidates = [baseUrl, origin, `${origin}/api`]
+    candidates = [...new Set(candidates)]
+  }
+  let discoveryResult: Awaited<ReturnType<typeof fetchDiscoveryDoc>> | undefined
+  const attemptedErrors: string[] = []
+  for (const candidate of candidates) {
+    discoveryResult = await fetchDiscoveryDoc(candidate)
+    if ('error' in discoveryResult) {
+      attemptedErrors.push(`${candidate}/openapi.json: ${discoveryResult.error}`)
+    } else {
+      break
+    }
+  }
+
+  if (!discoveryResult || 'error' in discoveryResult) {
+    checks.push({
+      label: 'Document found',
+      detail: attemptedErrors.join('; '),
+      hint: 'MPP servers must serve an OpenAPI document at /openapi.json with x-payment-info extensions.',
+      severity: 'fail',
+    })
+  } else {
+    found = true
+    checks.push({ label: 'Document found and parseable', severity: 'pass' })
+
+    const issues = validateDiscoveryDoc(discoveryResult.doc)
+    const errors = issues.filter((i) => i.severity === 'error')
+    const warnings = issues.filter((i) => i.severity === 'warning')
+
+    if (errors.length > 0) {
+      checks.push({
+        label: 'Valid OpenAPI structure',
+        detail: `${errors.length} error(s)`,
+        severity: 'fail',
+      })
+      for (const e of errors) {
+        checks.push({ label: e.message, detail: e.path, severity: 'fail' })
+      }
+    } else {
+      valid = true
+      checks.push({ label: 'Valid OpenAPI structure', severity: 'pass' })
+    }
+
+    for (const w of warnings) {
+      checks.push({ label: w.message, detail: w.path, severity: 'warn' })
+    }
+
+    discoveryDoc = discoveryResult.doc as Record<string, unknown>
+  }
+
+  if (options.endpoint) {
+    const parsed = parseEndpointArg(options.endpoint)
+    if (parsed) endpoints.push(parsed)
+  } else if (discoveryDoc) {
+    endpoints = extractEndpointsFromDiscovery(discoveryDoc)
+
+    const NO_AMOUNT = BigInt('999999999999999999')
+    endpoints.sort((a, b) => {
+      const aAmt = isValidIntegerAmount(a.amount) ? BigInt(a.amount!) : NO_AMOUNT
+      const bAmt = isValidIntegerAmount(b.amount) ? BigInt(b.amount!) : NO_AMOUNT
+      return aAmt < bAmt ? -1 : aAmt > bAmt ? 1 : 0
+    })
+
+    if (endpoints.length > 0) {
+      checks.push({
+        label: 'Paid endpoints found',
+        detail: `${endpoints.length} endpoint(s)`,
+        severity: 'pass',
+      })
+    } else {
+      checks.push({
+        label: 'Paid endpoints found',
+        detail: 'No endpoints with x-payment-info',
+        severity: 'warn',
+      })
+    }
+  }
+
+  return { found, valid, endpoints, checks, doc: discoveryDoc }
+}