fix: resolve World owner profile on /jump cards via Worlds Content Server (#563)

* fix: resolve World owner profile on /jump cards via Worlds Content Server

The places card resolved its "By <creator>" name through `getSceneMetadata`,
which always queried the main Catalyst's active entity at the Genesis City
`position` and read that scene's `deployedBy`. Worlds are not deployed on the
main Catalyst at a position — their scene lives on the Worlds Content Server
keyed by the world name — so for a World URL (e.g.
`/jump?realm=impssbldimnsn.dcl.eth&position=25,4`) the lookup resolved an
unrelated Genesis City scene deployer (or nothing), and the real world owner's
profile was never fetched. The card then fell back to the Places API
`contact_name`.

Make `getSceneMetadata` world-aware: when `realm` is an ENS name, fetch the
world's active scene entity from `WORLDS_CONTENT_SERVER_URL` and resolve the
owner from the entity's `metadata.owner`, looking that profile up on the
Catalyst lambdas. Genesis City keeps the existing scene deploy-audit path.
The shared profile-resolution logic is extracted into `resolveDeployerInfo`.

* fix: treat a /jump World absent from the Worlds Content Server as an invalid jump

* fix: use the owner address for the /jump creator profile link, not the display name

* fix: hide profile badges when the address has no Catalyst profile

---------

Co-authored-by: Braian Mellor <braianj@gmail.com>

Author: LautaroPetaccio

src/features/places/index.ts

@@ -1,4 +1,5 @@
 export {
+  isWorldNotFoundError,
   placesEndpoints,
   useGetJumpEventByIdQuery,
   useGetJumpEventsQuery,

src/features/places/places.client.spec.ts

@@ -549,6 +549,152 @@ describe('placesEndpoints', () => {
         expect(result.data).toBeNull()
       })
     })
+
+    describe('and the realm is a World (ENS name)', () => {
+      const mockWorldsAndPeer = (key: string) => {
+        if (key === 'WORLDS_CONTENT_SERVER_URL') return 'https://worlds.test'
+        if (key === 'PEER_URL') return 'https://peer.test'
+        return undefined
+      }
+
+      describe('and the world scene entity exposes an owner with a Catalyst profile', () => {
+        beforeEach(() => {
+          mockGetEnv.mockImplementation(mockWorldsAndPeer)
+          fetchSpy
+            .mockResolvedValueOnce({
+              ok: true,
+              json: () => Promise.resolve([{ id: 'world-entity', metadata: { owner: '0xOwner' } }])
+            } as unknown as Response)
+            .mockResolvedValueOnce({
+              ok: true,
+              json: () =>
+                Promise.resolve([
+                  {
+                    timestamp: 0,
+                    avatars: [
+                      {
+                        name: 'Chiri',
+                        userId: '0xOwner',
+                        avatar: { snapshots: { face256: 'owner.png', body: 'body.png' } }
+                      }
+                    ]
+                  }
+                ])
+            } as unknown as Response)
+        })
+
+        it('should resolve the owner profile from the Worlds Content Server scene entity', async () => {
+          const store = createTestStore()
+          const result = await store.dispatch(
+            placesEndpoints.endpoints.getSceneMetadata.initiate({ position: '25,4', realm: 'MyWorld.dcl.eth' })
+          )
+
+          expect(fetchSpy).toHaveBeenCalledWith(
+            'https://worlds.test/entities/active',
+            expect.objectContaining({ method: 'POST', body: JSON.stringify({ pointers: ['myworld.dcl.eth'] }) })
+          )
+          expect(result.data).toEqual({
+            deployerAddress: '0xOwner',
+            deployerName: 'Chiri',
+            deployerAvatar: 'owner.png'
+          })
+        })
+
+        it('should not query the main Catalyst active-entities endpoint by position', async () => {
+          // Drop call history accumulated by earlier suites so the assertion only
+          // reflects this dispatch; the `mockResolvedValueOnce` queue survives.
+          fetchSpy.mockClear()
+          const store = createTestStore()
+          await store.dispatch(placesEndpoints.endpoints.getSceneMetadata.initiate({ position: '25,4', realm: 'myworld.dcl.eth' }))
+
+          const calledUrls = fetchSpy.mock.calls.map(call => call[0])
+          expect(calledUrls).toContain('https://worlds.test/entities/active')
+          expect(calledUrls).not.toContain('https://peer.test/content/entities/active')
+        })
+      })
+
+      describe('and the world has no active scene entity (server answered 200 with [])', () => {
+        beforeEach(() => {
+          mockGetEnv.mockImplementation(mockWorldsAndPeer)
+          fetchSpy.mockResolvedValueOnce({ ok: true, json: () => Promise.resolve([]) } as unknown as Response)
+        })
+
+        it('should surface WORLD_NOT_FOUND so the page can treat the realm as an invalid jump', async () => {
+          const store = createTestStore()
+          const result = await store.dispatch(
+            placesEndpoints.endpoints.getSceneMetadata.initiate({ position: '0,0', realm: 'empty.dcl.eth' })
+          )
+          expect(result.error).toEqual(expect.objectContaining({ status: 'WORLD_NOT_FOUND' }))
+        })
+      })
+
+      describe('and the world scene entity has no owner', () => {
+        beforeEach(() => {
+          mockGetEnv.mockImplementation(mockWorldsAndPeer)
+          fetchSpy.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve([{ id: 'world-entity', metadata: {} }])
+          } as unknown as Response)
+        })
+
+        it('should return null', async () => {
+          const store = createTestStore()
+          const result = await store.dispatch(
+            placesEndpoints.endpoints.getSceneMetadata.initiate({ position: '0,0', realm: 'ownerless.dcl.eth' })
+          )
+          expect(result.data).toBeNull()
+        })
+      })
+
+      describe('and the owner has no Catalyst profile', () => {
+        beforeEach(() => {
+          mockGetEnv.mockImplementation(mockWorldsAndPeer)
+          fetchSpy
+            .mockResolvedValueOnce({
+              ok: true,
+              json: () => Promise.resolve([{ id: 'world-entity', metadata: { owner: '0xOwner' } }])
+            } as unknown as Response)
+            .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve([]) } as unknown as Response)
+        })
+
+        it('should return null so the Places API contact_name is used', async () => {
+          const store = createTestStore()
+          const result = await store.dispatch(
+            placesEndpoints.endpoints.getSceneMetadata.initiate({ position: '0,0', realm: 'noprofile.dcl.eth' })
+          )
+          expect(result.data).toBeNull()
+        })
+      })
+
+      describe('and the Worlds Content Server returns a server error', () => {
+        beforeEach(() => {
+          mockGetEnv.mockImplementation(mockWorldsAndPeer)
+          fetchSpy.mockResolvedValueOnce({ ok: false, status: 503 } as unknown as Response)
+        })
+
+        it('should surface FETCH_ERROR (not WORLD_NOT_FOUND) so an outage does not redirect valid worlds to invalid', async () => {
+          const store = createTestStore()
+          const result = await store.dispatch(
+            placesEndpoints.endpoints.getSceneMetadata.initiate({ position: '0,0', realm: 'down.dcl.eth' })
+          )
+          expect(result.error).toEqual(expect.objectContaining({ status: 'FETCH_ERROR' }))
+        })
+      })
+
+      describe('and WORLDS_CONTENT_SERVER_URL is not set', () => {
+        beforeEach(() => {
+          mockGetEnv.mockImplementation(key => (key === 'PEER_URL' ? 'https://peer.test' : undefined))
+        })
+
+        it('should surface FETCH_ERROR', async () => {
+          const store = createTestStore()
+          const result = await store.dispatch(
+            placesEndpoints.endpoints.getSceneMetadata.initiate({ position: '0,0', realm: 'noenv.dcl.eth' })
+          )
+          expect(result.error).toEqual(expect.objectContaining({ status: 'FETCH_ERROR' }))
+        })
+      })
+    })
   })
 
   describe('getJumpPlaces with no position or realm', () => {

src/features/places/places.client.ts

@@ -21,6 +21,19 @@ import type {
   SceneDeployerInfo
 } from './places.types'
 
+// Custom RTK Query error status used by getSceneMetadata to signal that an ENS
+// realm does not resolve to a real World on the Worlds Content Server. Consumers
+// (PlacesPage) match on it via isWorldNotFoundError to redirect to
+// /jump/places/invalid.
+const WORLD_NOT_FOUND = 'WORLD_NOT_FOUND'
+
+// Narrow a getSceneMetadata error to the WORLD_NOT_FOUND signal. Keeps the
+// producer and consumer matching on one shape instead of a structural cast at
+// the call site, so the contract stays in a single place.
+function isWorldNotFoundError(error: unknown): boolean {
+  return typeof error === 'object' && error !== null && (error as { status?: unknown }).status === WORLD_NOT_FOUND
+}
+
 function resolveIdentity(address: string | undefined) {
   // Resolving the identity inside queryFn (instead of accepting it as a query
   // arg) keeps the ephemeral key material out of `state.placesClient.queries.*.
@@ -82,6 +95,27 @@ async function fetchPeerDeployment(peerUrl: string, entityId: string): Promise<P
   return body.deployments?.[0] ?? null
 }
 
+// Worlds live on the Worlds Content Server, which exposes the active scene
+// entity (carrying `metadata.owner`) under `/entities/active` keyed by the world
+// name — note the path has no `/content` prefix, unlike the main Catalyst's
+// `fetchPeerSceneEntity`.
+//
+// A `null` return is meaningful: it means the server answered 200 with no
+// active entity, i.e. the world does not exist on the WCS. A non-OK response
+// (outage, 5xx) THROWS instead, so callers can tell "world doesn't exist" apart
+// from "couldn't reach the server" and avoid treating a transient outage as a
+// missing world.
+async function fetchWorldSceneEntity(worldsUrl: string, worldName: string): Promise<PeerSceneEntity | null> {
+  const response = await fetch(`${worldsUrl}/entities/active`, {
+    method: 'POST',
+    headers: { Accept: '*/*', 'Content-Type': 'application/json' },
+    body: JSON.stringify({ pointers: [worldName] })
+  })
+  if (!response.ok) throw new Error(`Worlds Content Server responded ${response.status}`)
+  const entities: PeerSceneEntity[] = await response.json()
+  return entities?.[0] ?? null
+}
+
 async function fetchPeerProfile(peerUrl: string, address: string): Promise<PeerProfile | null> {
   const response = await fetch(`${peerUrl}/lambdas/profiles`, {
     method: 'POST',
@@ -104,6 +138,23 @@ function toCreator(address: string, profile: PeerProfile | null): Creator | null
   }
 }
 
+// Resolve a Catalyst profile into the card's creator slot. Returns null when the
+// address has no profile name — curated scenes (e.g. Genesis Plaza) and some
+// world owners are deployed by / owned by addresses with no Catalyst user
+// profile, and returning null lets the Card fall back to the Places API's
+// contact_name instead of overriding it with a placeholder like "Unknown".
+async function resolveDeployerInfo(peerUrl: string, address: string): Promise<SceneDeployerInfo | null> {
+  const profile = await fetchPeerProfile(peerUrl, address)
+  const avatar = profile?.avatars?.[0]
+  const deployerName = avatar?.name || avatar?.realName
+  if (!deployerName) return null
+  return {
+    deployerAddress: address,
+    deployerName,
+    deployerAvatar: avatar?.avatar?.snapshots?.face256
+  }
+}
+
 const placesEndpoints = placesClient.injectEndpoints({
   endpoints: build => ({
     getJumpPlaces: build.query<JumpPlace[], GetPlacesArgs>({
@@ -171,37 +222,45 @@ const placesEndpoints = placesClient.injectEndpoints({
       providesTags: (_result, _error, { id }) => [{ type: 'JumpEvent', id }]
     }),
     getSceneMetadata: build.query<SceneDeployerInfo | null, GetSceneMetadataArgs>({
-      queryFn: async ({ position }) => {
+      queryFn: async ({ position, realm }) => {
         try {
           const peerUrl = getEnv('PEER_URL')
           if (!peerUrl) throw new Error('PEER_URL is not set')
 
+          // Worlds aren't on the main Catalyst at `position` — their scene lives
+          // on the Worlds Content Server keyed by the world name. Resolve the
+          // owner from the scene entity's `metadata.owner` and look that profile
+          // up on the Catalyst lambdas.
+          if (realm && isEns(realm)) {
+            const worldsUrl = getEnv('WORLDS_CONTENT_SERVER_URL')
+            if (!worldsUrl) throw new Error('WORLDS_CONTENT_SERVER_URL is not set')
+
+            const entity = await fetchWorldSceneEntity(worldsUrl, realm.toLowerCase())
+            // No active scene entity means the realm is not a real World on the
+            // WCS — even when the Places API still serves a stale record for it.
+            // Surface a typed not-found so the page can redirect to
+            // /jump/places/invalid; this is distinct from a FETCH_ERROR raised on
+            // a WCS outage (fetchWorldSceneEntity throws), which must NOT redirect.
+            if (!entity) return { error: { status: WORLD_NOT_FOUND } }
+
+            const ownerAddress = entity.metadata?.owner
+            if (!ownerAddress) return { data: null }
+
+            return { data: await resolveDeployerInfo(peerUrl, ownerAddress) }
+          }
+
           const entity = await fetchPeerSceneEntity(peerUrl, position)
           if (!entity) return { data: null }
 
           const deployment = await fetchPeerDeployment(peerUrl, entity.id)
           if (!deployment) return { data: null }
 
-          const profile = await fetchPeerProfile(peerUrl, deployment.deployedBy)
-          const avatar = profile?.avatars?.[0]
-          const deployerName = avatar?.name || avatar?.realName
-          // Curated scenes (e.g. Genesis Plaza) are deployed by addresses that
-          // have no Catalyst user profile. Returning null here lets the Card
-          // fall back to the Places API's contact_name instead of overriding
-          // it with a placeholder like "Unknown".
-          if (!deployerName) return { data: null }
-
-          const info: SceneDeployerInfo = {
-            deployerAddress: deployment.deployedBy,
-            deployerName,
-            deployerAvatar: avatar?.avatar?.snapshots?.face256
-          }
-          return { data: info }
+          return { data: await resolveDeployerInfo(peerUrl, deployment.deployedBy) }
         } catch (error) {
           return { error: { status: 'FETCH_ERROR', error: error instanceof Error ? error.message : 'Unknown error' } }
         }
       },
-      providesTags: (_result, _err, args) => [{ type: 'SceneMetadata', id: args.position }]
+      providesTags: (_result, _err, args) => [{ type: 'SceneMetadata', id: args.realm ? args.realm.toLowerCase() : args.position }]
     }),
     getProfileCreator: build.query<Creator | null, { address: string }>({
       queryFn: async ({ address }) => {
@@ -225,6 +284,7 @@ const { useGetJumpEventByIdQuery, useGetJumpEventsQuery, useGetJumpPlacesQuery,
   placesEndpoints
 
 export {
+  isWorldNotFoundError,
   placesEndpoints,
   useGetJumpEventByIdQuery,
   useGetJumpEventsQuery,

src/features/places/places.mappers.spec.ts

@@ -103,6 +103,70 @@ describe('jump.mappers', () => {
       it('should default user_name to Unknown', () => {
         expect(fromPlace(place).user_name).toBe('Unknown')
       })
+
+      it('should leave user undefined when there is no owner', () => {
+        expect(fromPlace(place).user).toBeUndefined()
+      })
+    })
+
+    describe('and the owner is a real wallet address', () => {
+      const place: JumpPlace = {
+        id: 'p5',
+        title: 'Owned World',
+        image: '',
+        description: '',
+        positions: ['0,0'],
+        base_position: '0,0',
+        owner: '0xd46a1da2aae4afc4a272dc3f28b2025ae9c18df1',
+        world: true,
+        world_name: 'dexou.dcl.eth'
+      }
+
+      it('should expose the address as user so the profile link resolves', () => {
+        expect(fromPlace(place).user).toBe('0xd46a1da2aae4afc4a272dc3f28b2025ae9c18df1')
+      })
+    })
+
+    describe('and the owner is a Places API display string instead of an address', () => {
+      // Some (notably stale) World records carry a display string in `owner`,
+      // e.g. zone returns "dexou by xyz.lb" for dexou.dcl.eth.
+      const place: JumpPlace = {
+        id: 'p6',
+        title: 'DEXOU',
+        image: '',
+        description: '',
+        positions: ['0,0'],
+        base_position: '0,0',
+        owner: 'dexou by xyz.lb                           ',
+        world: true,
+        world_name: 'dexou.dcl.eth'
+      }
+
+      it('should not turn the display string into a profile link (user stays undefined)', () => {
+        expect(fromPlace(place).user).toBeUndefined()
+      })
+
+      it('should still surface the display string as the creator name', () => {
+        expect(fromPlace(place).user_name).toBe('dexou by xyz.lb                           ')
+      })
+    })
+
+    describe('and the owner is a whitespace-padded address', () => {
+      // The address validator is anchored and does not trim, so a padded value
+      // is rejected — guards against feeding a non-canonical address to the link.
+      const place: JumpPlace = {
+        id: 'p7',
+        title: 'Padded',
+        image: '',
+        description: '',
+        positions: ['0,0'],
+        base_position: '0,0',
+        owner: ' 0xd46a1da2aae4afc4a272dc3f28b2025ae9c18df1 '
+      }
+
+      it('should leave user undefined', () => {
+        expect(fromPlace(place).user).toBeUndefined()
+      })
     })
   })
 

src/features/places/places.mappers.ts

@@ -1,5 +1,6 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import decentralandLogo from '../../images/jump/decentraland-logo.svg'
+import { isValidEthAddress } from '../../utils/avatar'
 import { resolveEventRealm } from '../../utils/whatsOnUrl'
 import type { CardData, JumpEvent, JumpPlace } from './places.types'
 
@@ -11,12 +12,18 @@ function fromPlace(data: JumpPlace): CardData {
   // foundation. User-deployed places can also have owner=null + a contact_name
   // (e.g. "Pink Oasis"), and those should fall back to the generic avatar.
   const isFoundationPlace = data.contact_name === FOUNDATION_CONTACT_NAME
+  // `owner` doubles as a display string on some records (zone returns
+  // "dexou by xyz.lb" for dexou.dcl.eth), so only feed it to the profile link +
+  // avatar lookup when it is a real wallet address. A non-address owner still
+  // shows as the creator name, but the name is not turned into a profile link
+  // that would resolve to a bogus `?profile=<display name>`.
+  const ownerAddress = isValidEthAddress(data.owner) ? data.owner : undefined
   return {
     id: data.id,
     type: 'place',
     title: data.title,
     user_name: data.owner || data.contact_name || 'Unknown',
-    user: data.owner ?? undefined,
+    user: ownerAddress,
     user_avatar: isFoundationPlace ? decentralandLogo : undefined,
     coordinates,
     image: data.image,