@tangle-network/agent-gateway 0.1.0

package/dist/nonce-store.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Nonce replay protection for x402/MPP payments.
+ * Tracks seen nonces to prevent the same payment from being used twice.
+ */
+interface NonceStore {
+    /** Check if nonce has been seen. Returns true if already used (reject). */
+    hasSeen(nonce: string): Promise<boolean>;
+    /** Mark nonce as used. TTL = how long to remember it (seconds). */
+    markSeen(nonce: string, ttlSeconds: number): Promise<void>;
+}
+/** In-memory nonce store with automatic eviction */
+declare class MemoryNonceStore implements NonceStore {
+    private seen;
+    private lastEviction;
+    hasSeen(nonce: string): Promise<boolean>;
+    markSeen(nonce: string, ttlSeconds: number): Promise<void>;
+    private evictExpired;
+}
+
+export { MemoryNonceStore, type NonceStore };

package/dist/nonce-store.js

@@ -0,0 +1,7 @@
+import {
+  MemoryNonceStore
+} from "./chunk-Z22ALGHW.js";
+export {
+  MemoryNonceStore
+};
+//# sourceMappingURL=nonce-store.js.map

package/dist/nonce-store.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/publish.d.ts

@@ -0,0 +1,42 @@
+import * as hono_types from 'hono/types';
+import { Hono } from 'hono';
+
+interface PublishedConfig {
+    enabled: boolean;
+    slug: string;
+    pricePerTokenUsd: number;
+    platformFeePercent: number;
+    /** Remote operator endpoint for sovereignty mode */
+    sandboxEndpoint?: string | null;
+    remoteSandboxId?: string | null;
+    remoteBearerToken?: string | null;
+    publishedAt: string;
+}
+interface PublishRequest {
+    slug?: string;
+    pricePerTokenUsd?: number;
+    platformFeePercent?: number;
+    sandboxEndpoint?: string | null;
+    remoteSandboxId?: string | null;
+    remoteBearerToken?: string | null;
+}
+/** Each agent implements this against their workspace/session model */
+interface PublishStore {
+    /** Get current published config for a workspace/session */
+    getPublishedConfig(ownerId: string, resourceId: string): Promise<PublishedConfig | null>;
+    /** Set published config */
+    setPublishedConfig(ownerId: string, resourceId: string, config: PublishedConfig): Promise<void>;
+    /** Clear published config (unpublish) */
+    clearPublishedConfig(ownerId: string, resourceId: string): Promise<void>;
+    /** Check the resource exists and the user owns it */
+    verifyOwnership(ownerId: string, resourceId: string): Promise<boolean>;
+}
+interface PublishRoutesConfig {
+    store: PublishStore;
+    getAuthUserId: (request: Request) => Promise<string | null>;
+    /** Base URL for gateway endpoint display (e.g. "https://gtm.tangle.tools") */
+    baseUrl?: string;
+}
+declare function createPublishRoutes(config: PublishRoutesConfig): Hono<hono_types.BlankEnv, hono_types.BlankSchema, "/">;
+
+export { type PublishRequest, type PublishRoutesConfig, type PublishStore, type PublishedConfig, createPublishRoutes };

package/dist/publish.js

@@ -0,0 +1,7 @@
+import {
+  createPublishRoutes
+} from "./chunk-5ZJPIIIV.js";
+export {
+  createPublishRoutes
+};
+//# sourceMappingURL=publish.js.map

package/dist/publish.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/rate-limit.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Sliding window rate limiter.
+ * In-memory by default. Override with KV-backed store for Workers.
+ */
+interface RateLimitConfig {
+    /** Max requests per window (default: 60) */
+    limit: number;
+    /** Window size in seconds (default: 60) */
+    windowSeconds: number;
+}
+interface RateLimitResult {
+    allowed: boolean;
+    remaining: number;
+    resetAt: number;
+    retryAfterSeconds?: number;
+}
+interface RateLimitStore {
+    /** Get timestamps of recent requests for this key */
+    get(key: string): Promise<number[]>;
+    /** Set timestamps for this key (with TTL) */
+    set(key: string, timestamps: number[], ttlSeconds: number): Promise<void>;
+}
+/** In-memory rate limit store with periodic eviction */
+declare class MemoryRateLimitStore implements RateLimitStore {
+    private store;
+    private lastEviction;
+    get(key: string): Promise<number[]>;
+    set(key: string, timestamps: number[], ttlSeconds: number): Promise<void>;
+    private evictExpired;
+}
+declare function checkRateLimit(consumerId: string, config: RateLimitConfig, store: RateLimitStore): Promise<RateLimitResult>;
+
+export { MemoryRateLimitStore, type RateLimitConfig, type RateLimitResult, type RateLimitStore, checkRateLimit };

package/dist/rate-limit.js

@@ -0,0 +1,9 @@
+import {
+  MemoryRateLimitStore,
+  checkRateLimit
+} from "./chunk-4FULF5LW.js";
+export {
+  MemoryRateLimitStore,
+  checkRateLimit
+};
+//# sourceMappingURL=rate-limit.js.map

package/dist/rate-limit.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/types.d.ts

@@ -0,0 +1,157 @@
+import { NonceStore } from './nonce-store.js';
+import { RateLimitStore } from './rate-limit.js';
+
+interface AgentMeta {
+    /** Unique agent identifier (workspace ID, session ID, etc.) */
+    id: string;
+    /** Owner/creator user ID */
+    ownerId: string;
+    /** Public URL slug */
+    slug: string;
+    /** System prompt for the agent (injected before consumer messages) */
+    systemPrompt?: string;
+    /** Per-token price in USD (default: 0.00002) */
+    pricePerTokenUsd: number;
+    /** Platform fee as decimal 0-1 (default: 0.20 = 20%) */
+    platformFeePercent: number;
+    /** Remote operator endpoint for sovereignty mode (null = centralized) */
+    sandboxEndpoint: string | null;
+    /** Sandbox ID on remote operator */
+    remoteSandboxId: string | null;
+    /** PASETO bearer token for remote operator auth */
+    remoteBearerToken: string | null;
+    /** Whether agent is published and accepting requests */
+    enabled: boolean;
+}
+type PaymentMethod = 'x402' | 'mpp' | 'apikey' | 'none';
+interface X402Config {
+    /** Ethereum operator address for SpendAuth verification */
+    operatorAddress: string;
+    /** Blockchain network ID (default: 3799) */
+    chainId: number;
+    /** ShieldedCredits contract address */
+    creditsAddress?: string;
+    /** RPC URL for on-chain verification (optional, demo mode skips this) */
+    rpcUrl?: string;
+    /** Demo mode: skip signature verification (default: false). NEVER enable in production. */
+    demoMode?: boolean;
+    /** Production signer verification. Called with the raw SpendAuth payload. Return true if signature is valid. */
+    verifySigner?: (payload: Record<string, unknown>) => Promise<boolean>;
+}
+interface MppConfig {
+    /** MPP realm (e.g. "agents.tangle.tools") */
+    realm: string;
+    /** MPP method name (default: "blueprintevm") */
+    method?: string;
+}
+interface PaymentResult {
+    method: PaymentMethod;
+    consumerId: string;
+}
+interface ApiKeyInfo {
+    keyId: string;
+    consumerId: string;
+    /** Scopes this key is authorized for (e.g. ["chat", "forms"]) */
+    scopes?: string[];
+    /** Per-key rate limit override (requests per minute). If set, overrides global rate limit. */
+    rateLimitPerMinute?: number;
+    /** Per-key daily limit override. */
+    dailyLimit?: number;
+}
+interface GatewayUsageEvent {
+    agentId: string;
+    agentSlug: string;
+    consumerId: string;
+    paymentMethod: PaymentMethod;
+    inputTokens: number;
+    outputTokens: number;
+    totalCostUsd: number;
+    ownerEarnedUsd: number;
+    platformFeeUsd: number;
+    durationMs: number;
+}
+interface SandboxStreamEvent {
+    type?: string;
+    data?: {
+        part?: {
+            type?: string;
+            text?: string;
+        };
+        delta?: string;
+        finalText?: string;
+    };
+}
+interface SandboxBox {
+    streamPrompt(message: string, opts?: {
+        sessionId?: string;
+        systemPrompt?: string;
+    }): AsyncIterable<SandboxStreamEvent>;
+}
+interface GatewayConfig {
+    /** Resolve agent metadata by slug. Return null if not found or not published. */
+    resolveAgent: (slug: string) => Promise<AgentMeta | null>;
+    /** Get a sandbox instance for the agent. Called after payment is verified. */
+    getSandbox: (agent: AgentMeta) => Promise<SandboxBox>;
+    /** Record a usage event after request completes. */
+    recordUsage: (event: GatewayUsageEvent) => Promise<void>;
+    /** x402 payment configuration */
+    x402: X402Config;
+    /** MPP (Machine Payments Protocol) configuration. If provided, gateway accepts Authorization: Payment headers. */
+    mpp?: MppConfig;
+    /**
+     * Verify an API key. Return key info if valid, null if invalid.
+     * Default: accepts any `sk_agent_*` key (demo mode).
+     */
+    verifyApiKey?: (authHeader: string) => Promise<ApiKeyInfo | null>;
+    /**
+     * Settle payment after successful response.
+     * For x402: call ShieldedCredits.claimPayment()
+     * For API key: deduct from spending limit
+     * Default: no-op (demo mode).
+     */
+    settlePayment?: (payment: PaymentResult, cost: number) => Promise<void>;
+    /** Base URL for API key purchase links (e.g. "https://film.tangle.tools") */
+    baseUrl?: string;
+    /** Max message length in chars (default: 8000) */
+    maxMessageLength?: number;
+    /** Required scope for chat endpoint (default: "chat"). API keys must include this scope. */
+    requiredScope?: string;
+    /** Block requests with detected injection patterns (default: false — log only) */
+    blockInjection?: boolean;
+    /** Rate limiting config. Default: 60 requests per 60 seconds per consumer. */
+    rateLimit?: {
+        limit: number;
+        windowSeconds: number;
+    };
+    /** Custom rate limit store (default: in-memory). Use KV-backed for Workers. */
+    rateLimitStore?: RateLimitStore;
+    /** Nonce replay protection store (default: in-memory). Rejects reused x402 nonces. */
+    nonceStore?: NonceStore;
+}
+interface ChatMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+}
+interface ChatCompletionRequest {
+    model?: string;
+    messages: ChatMessage[];
+    stream?: boolean;
+    temperature?: number;
+    max_tokens?: number;
+}
+interface ChatCompletionChunk {
+    id: string;
+    object: 'chat.completion.chunk';
+    created: number;
+    model: string;
+    choices: Array<{
+        index: number;
+        delta: {
+            content?: string;
+            role?: string;
+        };
+        finish_reason: string | null;
+    }>;
+}
+
+export type { AgentMeta, ApiKeyInfo, ChatCompletionChunk, ChatCompletionRequest, ChatMessage, GatewayConfig, GatewayUsageEvent, MppConfig, PaymentMethod, PaymentResult, SandboxBox, SandboxStreamEvent, X402Config };

package/dist/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@tangle-network/agent-gateway",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "x402 + API key payment gateway for Tangle agent products. Mount on any Hono app to expose agents as paid OpenAI-compatible endpoints.",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./middleware": {
+      "types": "./dist/middleware.d.ts",
+      "import": "./dist/middleware.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "hono": "^4.6.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0"
+  }
+}

package/src/api-keys.ts

@@ -0,0 +1,187 @@
+/**
+ * API key management — create, list, verify, revoke.
+ *
+ * The gateway package provides:
+ * - Types and interfaces (ApiKeyStore)
+ * - A Hono router for CRUD (createApiKeyRoutes)
+ * - A verifyApiKey function that checks against the store
+ *
+ * Each agent implements ApiKeyStore against their own DB.
+ */
+
+import { Hono } from 'hono'
+
+// --- Types ---
+
+export interface ApiKey {
+  id: string
+  userId: string
+  name: string
+  keyHash: string
+  keyPrefix: string
+  scopes: string[]
+  rateLimit: number      // requests per minute
+  dailyLimit: number     // requests per day
+  spendingLimitCents: number | null  // max spend in cents (null = unlimited)
+  spentCents: number     // running total spent
+  lastUsedAt: Date | null
+  expiresAt: Date | null
+  createdAt: Date
+}
+
+export interface ApiKeyCreateRequest {
+  name: string
+  scopes?: string[]
+  rateLimit?: number
+  dailyLimit?: number
+  spendingLimitCents?: number
+  expiresAt?: string
+}
+
+/** Each agent implements this against their DB */
+export interface ApiKeyStore {
+  create(userId: string, data: {
+    name: string
+    keyHash: string
+    keyPrefix: string
+    scopes: string[]
+    rateLimit: number
+    dailyLimit: number
+    spendingLimitCents: number | null
+    expiresAt: Date | null
+  }): Promise<ApiKey>
+
+  list(userId: string): Promise<Omit<ApiKey, 'keyHash'>[]>
+
+  findByHash(keyHash: string): Promise<ApiKey | null>
+
+  delete(userId: string, keyId: string): Promise<boolean>
+
+  recordUsage(keyId: string, costCents: number): Promise<void>
+}
+
+// --- Key generation ---
+
+function generateRawKey(prefix: string): string {
+  const bytes = new Uint8Array(16)
+  crypto.getRandomValues(bytes)
+  const hex = Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('')
+  return `${prefix}${hex}`
+}
+
+async function hashKey(raw: string): Promise<string> {
+  const encoded = new TextEncoder().encode(raw)
+  const digest = await crypto.subtle.digest('SHA-256', encoded)
+  return Array.from(new Uint8Array(digest)).map(b => b.toString(16).padStart(2, '0')).join('')
+}
+
+// --- Verification ---
+
+export async function verifyApiKeyFromStore(
+  authHeader: string,
+  store: ApiKeyStore,
+  prefix = 'ak_',
+): Promise<{ key: ApiKey; keyId: string; consumerId: string; scopes: string[]; rateLimitPerMinute: number; dailyLimit: number } | null> {
+  const bearerPrefix = `Bearer ${prefix}`
+  if (!authHeader.startsWith(bearerPrefix)) return null
+
+  const rawKey = authHeader.slice(7) // strip "Bearer "
+  const keyHash = await hashKey(rawKey)
+  const key = await store.findByHash(keyHash)
+  if (!key) return null
+
+  // Check expiry
+  if (key.expiresAt && key.expiresAt < new Date()) return null
+
+  // Check spending limit
+  if (key.spendingLimitCents !== null && key.spentCents >= key.spendingLimitCents) return null
+
+  return {
+    key,
+    consumerId: `apikey:${key.id}`,
+    keyId: key.id,
+    scopes: key.scopes,
+    rateLimitPerMinute: key.rateLimit,
+    dailyLimit: key.dailyLimit,
+  }
+}
+
+// --- CRUD Routes ---
+
+export interface ApiKeyRoutesConfig {
+  store: ApiKeyStore
+  /** Get the authenticated user ID from the request. Return null if not authenticated. */
+  getAuthUserId: (request: Request) => Promise<string | null>
+  /** Key prefix (default: "ak_") */
+  prefix?: string
+  /** Valid scopes for this agent (default: ["chat"]) */
+  validScopes?: string[]
+}
+
+export function createApiKeyRoutes(config: ApiKeyRoutesConfig) {
+  const router = new Hono()
+  const prefix = config.prefix ?? 'ak_'
+  const validScopes = config.validScopes ?? ['chat']
+
+  // List keys
+  router.get('/', async (c) => {
+    const userId = await config.getAuthUserId(c.req.raw)
+    if (!userId) return c.json({ error: 'Unauthorized' }, 401)
+
+    const keys = await config.store.list(userId)
+    return c.json({ keys })
+  })
+
+  // Create key
+  router.post('/', async (c) => {
+    const userId = await config.getAuthUserId(c.req.raw)
+    if (!userId) return c.json({ error: 'Unauthorized' }, 401)
+
+    const body = await c.req.json<ApiKeyCreateRequest>()
+    if (!body.name?.trim()) return c.json({ error: 'name is required' }, 400)
+
+    const scopes = (body.scopes ?? ['chat']).filter(s => validScopes.includes(s))
+    if (scopes.length === 0) scopes.push('chat')
+
+    const rawKey = generateRawKey(prefix)
+    const keyHash = await hashKey(rawKey)
+    const keyPrefix = rawKey.slice(0, prefix.length + 8)
+
+    const created = await config.store.create(userId, {
+      name: body.name.trim(),
+      keyHash,
+      keyPrefix,
+      scopes,
+      rateLimit: body.rateLimit ?? 60,
+      dailyLimit: body.dailyLimit ?? 1000,
+      spendingLimitCents: body.spendingLimitCents ?? null,
+      expiresAt: body.expiresAt ? new Date(body.expiresAt) : null,
+    })
+
+    return c.json({
+      key: rawKey,
+      id: created.id,
+      name: created.name,
+      keyPrefix: created.keyPrefix,
+      scopes: created.scopes,
+      rateLimit: created.rateLimit,
+      dailyLimit: created.dailyLimit,
+      spendingLimitCents: created.spendingLimitCents,
+      expiresAt: created.expiresAt,
+      _notice: 'Store this key securely. It will not be shown again.',
+    }, 201)
+  })
+
+  // Delete key
+  router.delete('/:keyId', async (c) => {
+    const userId = await config.getAuthUserId(c.req.raw)
+    if (!userId) return c.json({ error: 'Unauthorized' }, 401)
+
+    const deleted = await config.store.delete(userId, c.req.param('keyId'))
+    if (!deleted) return c.json({ error: 'API key not found' }, 404)
+
+    return c.json({ deleted: true })
+  })
+
+  return router
+}

package/src/filter.ts

@@ -0,0 +1,138 @@
+import type { ChatMessage } from './types'
+
+// --- Injection detection patterns ---
+
+const INJECTION_PATTERNS = [
+  // Direct instruction override
+  /ignore\s+(all\s+)?(previous|prior|above|earlier)\s+(instructions?|prompts?|rules?|directives?)/i,
+  /disregard\s+(all\s+)?(previous|prior|system)/i,
+  /forget\s+(everything|all|your)\s+(previous|instructions?|training)/i,
+  // Role assumption
+  /you\s+are\s+now\s+(a|an|the)\s+/i,
+  /pretend\s+(you\s+are|to\s+be)\s+/i,
+  /act\s+as\s+(if\s+you\s+are|a|an|the)\s+/i,
+  /new\s+instructions?:/i,
+  /\[system\]/i,
+  /\[INST\]/i,
+  // Prompt extraction
+  /what\s+(is|are)\s+your\s+(system\s+)?(prompt|instructions?|rules?|directives?)/i,
+  /repeat\s+(your|the)\s+(system\s+)?(prompt|instructions?)/i,
+  /output\s+(your|the)\s+(system\s+)?(prompt|instructions?)/i,
+  /show\s+me\s+(your|the)\s+(system|hidden|secret)\s+(prompt|instructions?|message)/i,
+  // Data exfiltration
+  /read\s+(the\s+)?(vault|workspace|config|secret|\.env)/i,
+  /cat\s+\/home\/agent\/(vault|config|\.env|secrets?)/i,
+  /list\s+(all\s+)?(vault|workspace|secret)\s+(files?|contents?|data)/i,
+]
+
+// Unicode normalization — collapse homoglyphs and zero-width chars
+function normalizeUnicode(text: string): string {
+  return text
+    // Remove zero-width chars (ZWJ, ZWNJ, ZWS, ZWSP)
+    .replace(/[\u200B-\u200F\u2028-\u202F\u2060\uFEFF]/g, '')
+    // Normalize to NFKC (collapses homoglyphs like а→a, е→e)
+    .normalize('NFKC')
+}
+
+/**
+ * Detect prompt injection attempts.
+ * Returns array of matched pattern descriptions, empty if clean.
+ */
+export function detectInjection(content: string): string[] {
+  const normalized = normalizeUnicode(content)
+  const matches: string[] = []
+
+  for (const pattern of INJECTION_PATTERNS) {
+    if (pattern.test(normalized)) {
+      matches.push(pattern.source.slice(0, 60))
+    }
+  }
+
+  // Check for base64-encoded injection attempts
+  const b64Matches = normalized.match(/[A-Za-z0-9+/]{40,}={0,2}/g)
+  if (b64Matches) {
+    for (const b64 of b64Matches) {
+      try {
+        const decoded = atob(b64)
+        if (INJECTION_PATTERNS.some(p => p.test(decoded))) {
+          matches.push('base64-encoded injection')
+        }
+      } catch { /* not valid b64 */ }
+    }
+  }
+
+  return matches
+}
+
+/**
+ * Security boundary — filter consumer messages before forwarding to agent.
+ *
+ * Defense in depth:
+ * 1. Strip system messages (consumers cannot set system prompt)
+ * 2. Normalize Unicode (collapse homoglyphs, remove zero-width chars)
+ * 3. Detect injection patterns (instruction override, prompt extraction, data exfil)
+ * 4. Redact sensitive keywords
+ * 5. Cap message length
+ *
+ * Returns filtered messages and any injection warnings detected.
+ */
+export function filterConsumerMessages(
+  messages: ChatMessage[],
+  maxLength = 8000,
+): ChatMessage[] {
+  return messages
+    .filter((m) => m.role !== 'system')
+    .map((m) => {
+      const normalized = normalizeUnicode(m.content)
+      const redacted = normalized
+        .replace(/\b(vault|workspace|owner|admin|secret|\.env|config\.json)[\s/:][^\s]*/gi, '[REDACTED]')
+        .slice(0, maxLength)
+      return { role: m.role, content: redacted }
+    })
+}
+
+/**
+ * Filter consumer messages with injection detection.
+ * Returns { messages, injectionWarnings }.
+ * If injectionWarnings is non-empty, the gateway should log and optionally reject.
+ */
+export function filterConsumerMessagesStrict(
+  messages: ChatMessage[],
+  maxLength = 8000,
+): { messages: ChatMessage[]; injectionWarnings: string[] } {
+  const filtered = filterConsumerMessages(messages, maxLength)
+  const allContent = filtered.map(m => m.content).join(' ')
+  const injectionWarnings = detectInjection(allContent)
+  return { messages: filtered, injectionWarnings }
+}
+
+/**
+ * Redact system prompt content from agent output.
+ * Prevents the agent from leaking its own instructions in responses.
+ *
+ * Strategy: if any chunk of the system prompt appears verbatim (>40 chars)
+ * in the output, replace it with [REDACTED].
+ */
+export function redactSystemPromptFromOutput(
+  output: string,
+  systemPrompt: string | undefined,
+): string {
+  if (!systemPrompt || systemPrompt.length < 40) return output
+
+  // Split system prompt into meaningful chunks (sentences or lines)
+  const chunks = systemPrompt
+    .split(/[.\n]/)
+    .map(s => s.trim())
+    .filter(s => s.length >= 40)
+
+  let redacted = output
+  for (const chunk of chunks) {
+    // Case-insensitive substring match
+    const idx = redacted.toLowerCase().indexOf(chunk.toLowerCase())
+    if (idx >= 0) {
+      redacted = redacted.slice(0, idx) + '[REDACTED — system instructions]' + redacted.slice(idx + chunk.length)
+    }
+  }
+
+  return redacted
+}