tapimo 0.15.0 → 0.18.0

package/src/admin/apps/route-policies.test.ts

@@ -0,0 +1,220 @@
+import { generateSpecs } from 'hono-openapi'
+import { sql } from 'kysely'
+import * as fs from 'node:fs/promises'
+
+import * as TestAdmin from '../../../test/Admin.js'
+import * as TestApp from '../../../test/App.js'
+import * as TestRoutes from '../../../test/Routes.js'
+import * as ApiKeys from '../../ApiKeys.js'
+import * as Metrics from '../../Metrics.js'
+import * as Organizations from '../../db/tables/organizations.js'
+import * as RoutesCatalog from '../../db/tables/routesCatalog.js'
+import * as RoutePolicies from './route-policies.js'
+
+describe('routePolicies', () => {
+  test('preserves existing stale rules while rejecting new absent rules', async () => {
+    const { client, db } = TestAdmin.setup()
+    const organization = await Organizations.create(db, { name: 'Catalog removal' })
+    const scope = { environment: 'production', orgId: organization.id } as const
+    await TestRoutes.publish(db)
+    const rule = {
+      destinationChainId: 'eip155:4217',
+      destinationTokenId: 'usdce',
+      providerId: 'relay',
+      sourceChainId: 'eip155:8453',
+      sourceTokenId: 'usdc',
+    }
+    const policy = { access: [], subsidyRoutes: [rule], terms: [{ ...rule, maxAmount: '0.03' }] }
+    expect(
+      (await client['route-policies'].$put({ json: { policy, scope, version: 0 } })).status,
+    ).toBe(200)
+    await RoutesCatalog.publish(db, { ...TestRoutes.data, routes: [] })
+    const saved = await client['route-policies'].$put({
+      json: { policy: { ...policy, suspended: true }, scope, version: 1 },
+    })
+    expect(saved.status).toBe(200)
+    expect(await TestApp.json(saved, RoutePolicies.schema.Response)).toMatchObject({
+      policy: { ...policy, suspended: true },
+      version: 2,
+    })
+    const changed = await client['route-policies'].$put({
+      json: { policy: { ...policy, terms: [{ ...rule, maxAmount: '0.04' }] }, scope, version: 2 },
+    })
+    expect(changed.status).toBe(400)
+    const granted = await client['route-policies'].$put({
+      json: { policy: { ...policy, access: [rule] }, scope, version: 2 },
+    })
+    expect(granted.status).toBe(400)
+    const removed = await client['route-policies'].$put({
+      json: { policy: { access: [], suspended: true }, scope, version: 2 },
+    })
+    expect(removed.status).toBe(200)
+  })
+
+  test('emits bounded read/save failure metrics with a documented alert contract', async () => {
+    const counts: Parameters<Metrics.Metrics['count']>[] = []
+    const { client, db } = TestAdmin.setup({
+      metrics: Metrics.from({
+        count(...parameters) {
+          counts.push(parameters)
+        },
+        flush() {},
+        gauge() {},
+        histogram() {},
+      }),
+    })
+    const organization = await Organizations.create(db, { name: 'Policy failure' })
+    const scope = { environment: 'production', orgId: organization.id } as const
+    await sql`DROP TABLE routes_policies`.execute(db.kysely)
+    expect((await client['route-policies'].$get({ query: scope })).status).toBe(500)
+    expect(
+      (await client['route-policies'].$put({ json: { policy: {}, scope, version: 0 } })).status,
+    ).toBe(500)
+    expect(counts.filter(([name]) => name === 'admin_route_policy_failure_count')).toEqual([
+      ['admin_route_policy_failure_count', 1, { operation: 'read' }],
+      ['admin_route_policy_failure_count', 1, { operation: 'save' }],
+    ])
+    const alerts = await fs.readFile(
+      new URL('../../../apps/api/ALERTS.md', import.meta.url),
+      'utf8',
+    )
+    expect(alerts).toContain('ApiAdminRoutePolicyFailure')
+    expect(alerts).toContain('admin_route_policy_failure_count')
+  })
+
+  test('generates examples for every policy query and response field', async () => {
+    const { app } = TestAdmin.setup()
+    const spec = await generateSpecs(app)
+    const operation = Object.values(spec.paths ?? {})
+      .map((path) => path?.get)
+      .find((operation) => operation?.operationId === 'getRoutePolicy')!
+    expect(operation).toBeDefined()
+    expect(operation.parameters).toHaveLength(4)
+    const missing: string[] = []
+    const query: Record<string, unknown> = {}
+    for (const parameter of operation.parameters ?? []) {
+      if ('$ref' in parameter) throw new Error('Unexpected referenced parameter.')
+      if (!(parameter.schema as JsonSchema)?.examples?.length)
+        missing.push(`query.${parameter.name}`)
+      query[parameter.name] = (parameter.schema as JsonSchema)?.examples?.[0]
+    }
+    const response = operation.responses?.['200']
+    if (!response || '$ref' in response) throw new Error('Missing policy response.')
+    function visit(schema: JsonSchema, path: string) {
+      if (schema.$ref) {
+        const name = schema.$ref.split('/').at(-1)!
+        visit(spec.components!.schemas![name] as JsonSchema, path)
+        return
+      }
+      for (const [key, field] of Object.entries(schema.properties ?? {})) {
+        if (!field.examples?.length) missing.push(`${path}.${key}`)
+        visit(field, `${path}.${key}`)
+      }
+      if (schema.items) visit(schema.items, `${path}[]`)
+      for (const branch of schema.anyOf ?? []) visit(branch, path)
+    }
+    const responseSchema = response.content!['application/json']!.schema as JsonSchema
+    visit(responseSchema, 'response')
+    expect(missing).toEqual([])
+    expect(RoutePolicies.schema.Query.safeParse(query).success).toBe(true)
+    const example = Object.fromEntries(
+      Object.entries(responseSchema.properties!).map(([name, field]) => [name, field.examples![0]]),
+    )
+    expect(RoutePolicies.schema.Response.safeParse(example).success).toBe(true)
+  })
+
+  test('requires an admin identity', async () => {
+    const { client } = TestAdmin.setup({ identify: () => null })
+    const response = await client['route-policies'].$get({
+      query: { environment: 'sandbox', orgId: 'org_missing' },
+    })
+    expect(response.status).toBe(401)
+  })
+
+  test('rejects a phantom organization', async () => {
+    const { client } = TestAdmin.setup()
+    const response = await client['route-policies'].$get({
+      query: { environment: 'production', orgId: 'org_missing' },
+    })
+    expect(response.status).toBe(404)
+  })
+
+  test('accepts an organization-scoped API key without a project', async () => {
+    const { client, db, store } = TestAdmin.setup()
+    const organization = await Organizations.create(db, { name: 'Policy owner' })
+    const { record } = await ApiKeys.mintBounded(db, store, {
+      environment: 'production',
+      orgId: organization.id,
+      scopes: ['data:read'],
+    })
+
+    const response = await client['route-policies'].$get({
+      query: {
+        apiKeyId: record.id,
+        environment: 'production',
+        orgId: organization.id,
+      },
+    })
+
+    expect(response.status).toBe(200)
+    expect(await TestApp.json(response, RoutePolicies.schema.Response)).toMatchObject({
+      name: null,
+    })
+  })
+
+  test('reads an absent policy and saves it with compare-and-swap', async () => {
+    const { client, db } = TestAdmin.setup()
+    const organization = await Organizations.create(db, { name: 'Policy owner' })
+    const scope = { environment: 'sandbox', orgId: organization.id } as const
+
+    const initial = await client['route-policies'].$get({ query: scope })
+    expect(initial.status).toBe(200)
+    expect(await TestApp.json(initial, RoutePolicies.schema.Response)).toMatchObject({
+      name: 'Policy owner',
+      layers: [{ policy: {}, scope, version: 0 }],
+      policy: {},
+      routes: [],
+      scope,
+      version: 0,
+    })
+
+    const saved = await client['route-policies'].$put({
+      json: { policy: { maxAmount: '25.50', subsidyEnabled: true }, scope, version: 0 },
+    })
+    expect(saved.status).toBe(200)
+    expect(await TestApp.json(saved, RoutePolicies.schema.Response)).toMatchObject({
+      name: 'Policy owner',
+      policy: { maxAmount: '25.50', subsidyEnabled: true },
+      scope,
+      version: 1,
+    })
+
+    const stale = await client['route-policies'].$put({
+      json: { policy: {}, scope, version: 0 },
+    })
+    expect(stale.status).toBe(409)
+  })
+
+  test('rejects malformed policy rules', async () => {
+    const { app, db } = TestAdmin.setup()
+    const organization = await Organizations.create(db, { name: 'Policy owner' })
+    const response = await app.request('/route-policies', {
+      body: JSON.stringify({
+        policy: { access: [{ sourceChainId: 'missing' }] },
+        scope: { environment: 'sandbox', orgId: organization.id },
+        version: 0,
+      }),
+      headers: { 'content-type': 'application/json' },
+      method: 'PUT',
+    })
+    expect(response.status).toBe(400)
+  })
+})
+
+type JsonSchema = {
+  $ref?: string
+  anyOf?: JsonSchema[]
+  examples?: unknown[]
+  items?: JsonSchema
+  properties?: Record<string, JsonSchema>
+}

package/src/admin/apps/route-policies.ts

@@ -0,0 +1,322 @@
+import { type Context, Hono } from 'hono'
+import * as z from 'zod/mini'
+
+import * as ApiKeys from '../../ApiKeys.js'
+import * as Db from '../../db/Db.js'
+import * as Organizations from '../../db/tables/organizations.js'
+import * as Projects from '../../db/tables/projects.js'
+import * as RoutesCatalog from '../../db/tables/routesCatalog.js'
+import * as RoutesPolicies from '../../db/tables/routesPolicies.js'
+import * as Catalog from '../../internal/routes/Catalog.js'
+import * as Policy from '../../internal/routes/Policy.js'
+import * as OpenApi from '../../internal/OpenApi.js'
+import * as Response from '../../internal/Response.js'
+import type * as App from '../App.js'
+
+export namespace schema {
+  export const Query = Policy.schema.Scope
+  export const Body = z.strictObject({
+    policy: Policy.schema.Overrides,
+    scope: Policy.schema.Scope,
+    version: z
+      .number()
+      .check(
+        z.int(),
+        z.minimum(0),
+        z.describe('Expected policy revision; zero for an unsaved scope.'),
+        z.meta({ examples: [0] }),
+      ),
+  })
+  export const Route = z.extend(Policy.schema.Rule, {
+    destinationChainName: z
+      .string()
+      .check(z.describe('Destination network display name.'), z.meta({ examples: ['Tempo'] })),
+    destinationTokenSymbol: z
+      .string()
+      .check(z.describe('Destination token symbol.'), z.meta({ examples: ['USDC.e'] })),
+    label: z
+      .string()
+      .check(
+        z.describe('Human-readable route and provider label.'),
+        z.meta({ examples: ['Base USDC → Tempo USDC.e (stargate)'] }),
+      ),
+    sourceChainName: z
+      .string()
+      .check(z.describe('Source network display name.'), z.meta({ examples: ['Base'] })),
+    sourceTokenSymbol: z
+      .string()
+      .check(z.describe('Source token symbol.'), z.meta({ examples: ['USDC'] })),
+  })
+  export const Response = z.object({
+    name: z
+      .nullable(z.string())
+      .check(
+        z.describe(
+          'Name of the organization, project, or API key being edited; null for unnamed keys.',
+        ),
+        z.meta({ examples: ['Checkout'] }),
+      ),
+    layers: z
+      .array(
+        z.object({
+          policy: Policy.schema.Overrides,
+          scope: Policy.schema.Scope,
+          version: z.number().check(z.describe('Saved layer revision.'), z.meta({ examples: [1] })),
+        }),
+      )
+      .check(
+        z.describe('Inherited layers in organization, project, and API-key order.'),
+        z.meta({
+          examples: [
+            [
+              {
+                policy: {},
+                scope: { environment: 'production', orgId: 'org_1a2b3c4d5e6f7g8h9j0k1m2n' },
+                version: 0,
+              },
+            ],
+          ],
+        }),
+      ),
+    legacy: z
+      .object({
+        maxAmount: z
+          .string()
+          .check(
+            z.describe('Legacy per-transaction subsidy limit in USD.'),
+            z.meta({ examples: ['0.05'] }),
+          ),
+        subsidyEnabled: z
+          .boolean()
+          .check(z.describe('Whether legacy subsidies are enabled.'), z.meta({ examples: [true] })),
+        subsidyPayer: z
+          .literal('enterprise')
+          .check(z.describe('Payer for legacy subsidies.'), z.meta({ examples: ['enterprise'] })),
+      })
+      .check(
+        z.describe('Legacy financial defaults inherited by unset fields.'),
+        z.meta({
+          examples: [{ maxAmount: '0.05', subsidyEnabled: true, subsidyPayer: 'enterprise' }],
+        }),
+      ),
+    policy: Policy.schema.Overrides,
+    routes: z.array(Route).check(
+      z.describe('Available routes and display labels.'),
+      z.meta({
+        examples: [
+          [
+            {
+              destinationChainId: 'eip155:4217',
+              destinationChainName: 'Tempo',
+              destinationTokenId: 'usdce',
+              destinationTokenSymbol: 'USDC.e',
+              label: 'Base USDC → Tempo USDC.e (stargate)',
+              providerId: 'stargate',
+              sourceChainId: 'eip155:8453',
+              sourceChainName: 'Base',
+              sourceTokenId: 'usdc',
+              sourceTokenSymbol: 'USDC',
+            },
+          ],
+        ],
+      }),
+    ),
+    scope: Policy.schema.Scope,
+    version: z
+      .number()
+      .check(
+        z.describe('Saved policy revision; zero for an unsaved scope.'),
+        z.meta({ examples: [1] }),
+      ),
+  })
+}
+
+/** Admin read/write API for independently versioned route-policy scopes. */
+export function routePolicies() {
+  return new Hono<App.Environment>()
+    .get(
+      '/',
+      OpenApi.validate('query', schema.Query, { code: 'query_invalid', message: 'Invalid query' }),
+      OpenApi.describeRoute({
+        operationId: 'getRoutePolicy',
+        responses: OpenApi.responses({
+          errors: { 404: 'Policy scope not found.' },
+          success: {
+            description: 'The policy scope, inherited layers, legacy defaults, and route catalog.',
+            schema: schema.Response,
+          },
+        }),
+        summary: 'Get route policy',
+        tags: ['Route Policies'],
+      }),
+      async (c) =>
+        execute(c, async () => {
+          const scope = c.req.valid('query')
+          const db = Db.get(c.get('db'))
+          const entity = await validScope(c, scope)
+          if (!entity) return notFound(c)
+          const [loaded, record, catalog] = await Promise.all([
+            RoutesPolicies.load(db, scope),
+            RoutesPolicies.get(db, scope),
+            Catalog.read(db),
+          ])
+          return c.json(
+            Response.validated(schema.Response, {
+              ...response(scope, record, loaded, catalog),
+              name: entity.name,
+            }),
+          )
+        }),
+    )
+    .put(
+      '/',
+      OpenApi.validate('json', schema.Body, {
+        code: 'body_invalid',
+        message: 'Invalid request body',
+      }),
+      OpenApi.describeRoute({
+        operationId: 'putRoutePolicy',
+        responses: OpenApi.responses({
+          errors: {
+            400: 'Policy contains invalid rules.',
+            404: 'Policy scope not found.',
+            409: 'Policy version is stale.',
+          },
+          success: {
+            description: 'The saved policy scope and its inherited context.',
+            schema: schema.Response,
+          },
+        }),
+        summary: 'Save route policy',
+        tags: ['Route Policies'],
+      }),
+      async (c) =>
+        execute(c, async () => {
+          const input = c.req.valid('json')
+          const policy = input.policy as Policy.Overrides
+          const db = Db.get(c.get('db'))
+          const entity = await validScope(c, input.scope)
+          if (!entity) return notFound(c)
+          const catalog = Catalog.compile(await RoutesCatalog.read(db))
+          const existing = await RoutesPolicies.get(db, input.scope)
+          if (!rulesExist(policy, catalog, existing?.policy))
+            return Response.error(c, {
+              code: 'policy_rules_invalid',
+              message: 'Policy contains routes absent from the current catalog.',
+              status: 400,
+            })
+          try {
+            await RoutesPolicies.save(db, {
+              ...input,
+              policy,
+              validateScope: async () => Boolean(await validKeyScope(c, input.scope)),
+            })
+          } catch (cause) {
+            if (cause instanceof RoutesPolicies.ConflictError)
+              return Response.error(c, {
+                code: 'version_conflict',
+                message: 'Policy version is stale.',
+                status: 409,
+              })
+            if (cause instanceof RoutesPolicies.InvalidScopeError) return notFound(c)
+            throw cause
+          }
+          const [loaded, record] = await Promise.all([
+            RoutesPolicies.load(db, input.scope),
+            RoutesPolicies.get(db, input.scope),
+          ])
+          return c.json(
+            Response.validated(schema.Response, {
+              ...response(input.scope, record, loaded, catalog),
+              name: entity.name,
+            }),
+          )
+        }),
+    )
+}
+
+async function validScope(c: Context<App.Environment>, scope: Policy.Scope) {
+  const db = Db.get(c.get('db'))
+  const organization = await Organizations.get(db, scope.orgId)
+  if (!organization) return false
+  const project = scope.projectId ? await Projects.get(db, scope.projectId) : undefined
+  if (scope.projectId && (!project || project.orgId !== scope.orgId)) return false
+  const key = await validKeyScope(c, scope)
+  if (!key) return false
+  return { name: key === true ? (project ?? organization).name : (key.name ?? null) }
+}
+
+async function validKeyScope(c: Context<App.Environment>, scope: Policy.Scope) {
+  if (scope.apiKeyId) {
+    const key = await ApiKeys.get(c.get('kv').store, scope.apiKeyId)
+    if (
+      !key ||
+      key.orgId !== scope.orgId ||
+      key.projectId !== scope.projectId ||
+      key.environment !== scope.environment
+    )
+      return false
+    return key
+  }
+  return true
+}
+
+function rulesExist(
+  policy: Policy.Overrides,
+  catalog: Catalog.Snapshot,
+  existing: Policy.Overrides = {},
+) {
+  // Catalog removals must not prevent unrelated edits. Only unchanged rules in the same field survive.
+  return (['access', 'subsidyRoutes', 'terms'] as const).every((field) =>
+    (policy[field] ?? []).every(
+      (rule) =>
+        catalog.routes.some((route) => Policy.allows([rule], Policy.fromRoute(route))) ||
+        (existing[field] ?? []).some(
+          (stored) =>
+            JSON.stringify(stored, Object.keys(stored).sort()) ===
+            JSON.stringify(rule, Object.keys(rule).sort()),
+        ),
+    ),
+  )
+}
+
+function response(
+  scope: Policy.Scope,
+  record: RoutesPolicies.Record | undefined,
+  loaded: Awaited<ReturnType<typeof RoutesPolicies.load>>,
+  catalog: Catalog.Snapshot,
+) {
+  return {
+    scope,
+    version: record?.version ?? 0,
+    policy: record?.policy ?? {},
+    ...loaded,
+    routes: catalog.routes.map((route) => ({
+      ...Policy.fromRoute(route),
+      destinationChainName: route.route.destination.chain.name,
+      destinationTokenSymbol: route.route.destination.symbol,
+      label: `${route.route.source.symbol} on ${route.route.source.chain.name} → ${route.route.destination.symbol} on ${route.route.destination.chain.name} (${route.providerId})`,
+      sourceChainName: route.route.source.chain.name,
+      sourceTokenSymbol: route.route.source.symbol,
+    })),
+  }
+}
+
+function notFound(c: Context<App.Environment>) {
+  return Response.error(c, {
+    code: 'policy_scope_not_found',
+    message: 'Policy scope not found.',
+    status: 404,
+  })
+}
+
+async function execute<T>(c: Context<App.Environment>, operation: () => Promise<T>): Promise<T> {
+  try {
+    return await operation()
+  } catch (cause) {
+    c.get('metrics')?.count('admin_route_policy_failure_count', 1, {
+      operation: c.req.method === 'PUT' ? 'save' : 'read',
+    })
+    throw cause
+  }
+}

package/src/admin/apps/routes-support.test.ts

@@ -13,6 +13,14 @@ const catalog = {
       rpcUrls: ['https://ethereum.example'],
       slug: 'ethereum',
     },
+    {
+      aliases: [],
+      id: 'eip155:8453',
+      name: 'Base',
+      parentChainId: null,
+      rpcUrls: ['https://base.example'],
+      slug: 'base',
+    },
     {
       aliases: [],
       id: 'eip155:4217',
@@ -39,6 +47,38 @@ const catalog = {
       standard: 'TIP-20',
       tokenId: 'usdce',
     },
+    {
+      address: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
+      chainId: 'eip155:1',
+      decimals: 18,
+      name: null,
+      standard: 'ERC-20',
+      tokenId: 'dai',
+    },
+    {
+      address: '0x20C0000000000000000000000000000000000001',
+      chainId: 'eip155:4217',
+      decimals: 6,
+      name: null,
+      standard: 'TIP-20',
+      tokenId: 'usdc',
+    },
+    {
+      address: '0x833589fCD6EDB6E08f4c7C32D4f71b54bDA02913',
+      chainId: 'eip155:8453',
+      decimals: 6,
+      name: null,
+      standard: 'ERC-20',
+      tokenId: 'usdc',
+    },
+    {
+      address: '0x20C0000000000000000000000000000000000002',
+      chainId: 'eip155:4217',
+      decimals: 6,
+      name: null,
+      standard: 'TIP-20',
+      tokenId: 'usdt0',
+    },
   ],
   routes: [
     {
@@ -72,8 +112,33 @@ const catalog = {
       sourceChainId: 'eip155:4217',
       sourceTokenId: 'usdce',
     },
+    {
+      capabilities: { depositAddress: true },
+      destinationChainId: 'eip155:4217',
+      destinationTokenId: 'usdce',
+      providerId: 'relay',
+      sourceChainId: 'eip155:1',
+      sourceTokenId: 'dai',
+    },
+    {
+      capabilities: { transfer: { modes: ['exactSource'] } },
+      destinationChainId: 'eip155:4217',
+      destinationTokenId: 'usdce',
+      providerId: 'relay',
+      sourceChainId: 'eip155:4217',
+      sourceTokenId: 'usdc',
+    },
+    {
+      capabilities: { transfer: { modes: ['exactSource'] } },
+      destinationChainId: 'eip155:8453',
+      destinationTokenId: 'usdc',
+      providerId: 'stargate',
+      sourceChainId: 'eip155:4217',
+      sourceTokenId: 'usdt0',
+    },
   ],
   tokens: [
+    { currency: 'USD', id: 'dai', name: 'Dai Stablecoin', symbol: 'DAI' },
     { currency: 'USD', id: 'usdc', name: 'USD Coin', symbol: 'USDC' },
     {
       currency: 'USD',
@@ -81,11 +146,12 @@ const catalog = {
       name: 'Bridged USDC (Stargate)',
       symbol: 'USDC.e',
     },
+    { currency: 'USD', id: 'usdt0', name: 'USD₮0', symbol: 'USDT0' },
   ],
 } as const satisfies RoutesCatalog.publish.Input
 
 describe('GET /routes/support', () => {
-  test('groups published capabilities and reports conditional subsidy eligibility', async () => {
+  test('groups partner-route capabilities and reports conditional subsidy eligibility', async () => {
     const { app, db } = TestAdmin.setup()
     const published = await RoutesCatalog.publish(db, catalog)
     const response = await app.request('/routes/support')
@@ -127,7 +193,7 @@ describe('GET /routes/support', () => {
             },
             "subsidies": {
               "depositAddress": true,
-              "walletTransfer": false,
+              "walletTransfer": true,
             },
             "walletTransferProviders": [
               {
@@ -177,6 +243,45 @@ describe('GET /routes/support', () => {
               },
             ],
           },
+          {
+            "depositAddressProviders": [],
+            "destinationChain": {
+              "id": "eip155:8453",
+              "name": "Base",
+              "slug": "base",
+            },
+            "destinationToken": {
+              "id": "usdc",
+              "name": "USD Coin",
+              "symbol": "USDC",
+            },
+            "id": "eip155:4217/usdt0-eip155:8453/usdc",
+            "quoteProviders": [
+              "stargate",
+            ],
+            "sourceChain": {
+              "id": "eip155:4217",
+              "name": "Tempo",
+              "slug": "tempo",
+            },
+            "sourceToken": {
+              "id": "usdt0",
+              "name": "USD₮0",
+              "symbol": "USDT0",
+            },
+            "subsidies": {
+              "depositAddress": false,
+              "walletTransfer": true,
+            },
+            "walletTransferProviders": [
+              {
+                "modes": [
+                  "exactSource",
+                ],
+                "providerId": "stargate",
+              },
+            ],
+          },
         ],
         "updatedAt": "<updatedAt>",
       }