@misonetwork/sdk 0.3.1 → 0.5.0

package/src/queries.ts

@@ -7,7 +7,7 @@
 // uses GraphQL to find object addresses, then reads them through the Core path.
 //
 // Missing-object convention (null vs throw):
-//   - Core-object getters in this module (`getCompositionById`, `getDealById`,
+//   - Core-object getters in this module (`getCompositionById`,
 //     `get*AdminCapById`, …) THROW when the object is missing. Callers pass ids
 //     they obtained from the chain, so a miss means a broken reference — an
 //     exceptional state, not a normal one.
@@ -22,17 +22,20 @@
 import type { ClientWithCoreApi } from "@mysten/sui/client";
 import type { SuiGraphQLClient } from "@mysten/sui/graphql";
 import { graphql } from "@mysten/sui/graphql/schema";
-import { deriveObjectID } from "@mysten/sui/utils";
+import { deriveObjectID, normalizeSuiAddress } from "@mysten/sui/utils";
 
 import { Composition as CompositionBcs } from "./contracts/miso/composition.ts";
-import { Deal as DealBcs } from "./contracts/miso/deal.ts";
 import { Recording as RecordingBcs } from "./contracts/miso/recording.ts";
 import { Release as ReleaseBcs } from "./contracts/miso/release.ts";
-import { mapBps, mapComposition, mapDiscReleaseJson, mapRecording, mapRelease } from "./internal.ts";
+import {
+  mapBps,
+  mapComposition,
+  mapRecording,
+  mapRelease,
+} from "./internal.ts";
 import type {
   Composition,
   CompositionAdminCap,
-  Deal,
   Recording,
   RecordingAdminCap,
   Release,
@@ -50,7 +53,8 @@ import type {
  */
 export function extractTypeParam(objectType: string): string {
   const match = objectType.match(/<(.+)>$/);
-  if (!match?.[1]) throw new Error(`Could not extract type parameter from: ${objectType}`);
+  if (!match?.[1])
+    throw new Error(`Could not extract type parameter from: ${objectType}`);
   return match[1];
 }
 
@@ -62,7 +66,8 @@ export function extractTypeParams2(objectType: string): [string, string] {
     const ch = inner[i];
     if (ch === "<") depth++;
     else if (ch === ">") depth--;
-    else if (ch === "," && depth === 0) return [inner.slice(0, i).trim(), inner.slice(i + 1).trim()];
+    else if (ch === "," && depth === 0)
+      return [inner.slice(0, i).trim(), inner.slice(i + 1).trim()];
   }
   throw new Error(`Expected two type parameters in: ${objectType}`);
 }
@@ -90,13 +95,20 @@ export function extractTypeParams2(objectType: string): [string, string] {
 export function isNotFound(e: unknown): boolean {
   if (typeof e === "object" && e !== null && "code" in e) {
     const code = (e as { code: unknown }).code;
-    if (code === "notExists" || code === "deleted" || code === "dynamicFieldNotFound" || code === "notFound") {
+    if (
+      code === "notExists" ||
+      code === "deleted" ||
+      code === "dynamicFieldNotFound" ||
+      code === "notFound"
+    ) {
       return true;
     }
   }
   const msg = e instanceof Error ? e.message : String(e);
   return (
-    /\bobject\b[\s\S]*\b(?:not\s?found|does not exist|has been deleted)\b/i.test(msg) ||
+    /\bobject\b[\s\S]*\b(?:not\s?found|does not exist|has been deleted)\b/i.test(
+      msg,
+    ) ||
     /\bdynamic field\b[\s\S]*\bnot\s?found\b/i.test(msg) ||
     /\bno object\b/i.test(msg)
   );
@@ -106,8 +118,14 @@ export function isNotFound(e: unknown): boolean {
 const UNIT_STRUCT_KEY_BYTES = new Uint8Array([0x00]);
 
 /** Fetches one object's BCS content bytes (or null if absent). */
-async function getContent(client: ClientWithCoreApi, objectId: string): Promise<Uint8Array | null> {
-  const { object } = await client.core.getObject({ objectId, include: { content: true } });
+async function getContent(
+  client: ClientWithCoreApi,
+  objectId: string,
+): Promise<Uint8Array | null> {
+  const { object } = await client.core.getObject({
+    objectId,
+    include: { content: true },
+  });
   return object.content ?? null;
 }
 
@@ -119,7 +137,9 @@ async function getContent(client: ClientWithCoreApi, objectId: string): Promise<
 const AddressesByTypeQuery = graphql(`
   query AddressesByType($type: String!) {
     objects(filter: { type: $type }) {
-      nodes { address }
+      nodes {
+        address
+      }
     }
   }
 `);
@@ -136,11 +156,217 @@ const AddressesByTypeQuery = graphql(`
 const AddressesAndTypesByTypeQuery = graphql(`
   query AddressesAndTypesByType($type: String!) {
     objects(filter: { type: $type }) {
-      nodes { address asMoveObject { contents { type { repr } } } }
+      nodes {
+        address
+        asMoveObject {
+          contents {
+            type {
+              repr
+            }
+          }
+        }
+      }
     }
   }
 `);
 
+export interface WorkShareTypes {
+  compositions: readonly string[];
+  recordings: readonly string[];
+}
+
+export interface WorkAddressesByShareType {
+  compositions: Partial<Record<string, string>>;
+  recordings: Partial<Record<string, string>>;
+}
+
+interface WorkAddressConnection {
+  nodes: Array<{
+    address: string;
+    asMoveObject?: {
+      contents?: { type?: { repr?: string } | null } | null;
+    } | null;
+  }>;
+  pageInfo?: { hasNextPage: boolean; endCursor: string | null };
+}
+
+/**
+ * Resolve many work share types in one GraphQL request.
+ *
+ * Compositions can be queried by their exact one-parameter type. Recordings
+ * carry both RecordingShare and CompositionShare, while an admin cap only
+ * exposes the first, so one bare Recording scan is shared by every requested
+ * recording type and filtered client-side.
+ */
+export async function getWorkAddressesByShareTypes(
+  client: SuiGraphQLClient,
+  shareTypes: WorkShareTypes,
+  misoPackageId: string,
+): Promise<WorkAddressesByShareType> {
+  const compositions = [...new Set(shareTypes.compositions)];
+  const recordings = new Set(shareTypes.recordings);
+  const out: WorkAddressesByShareType = { compositions: {}, recordings: {} };
+  if (compositions.length === 0 && recordings.size === 0) return out;
+
+  const declarations: string[] = [];
+  const selections: string[] = [];
+  const variables: Record<string, string> = {};
+
+  compositions.forEach((shareType, index) => {
+    const variable = `compositionType${index}`;
+    declarations.push(`$${variable}: String!`);
+    selections.push(
+      `composition${index}: objects(first: 1, filter: { type: $${variable} }) { nodes { address } }`,
+    );
+    variables[variable] =
+      `${misoPackageId}::composition::Composition<${shareType}>`;
+  });
+
+  if (recordings.size > 0) {
+    declarations.push("$recordingType: String!");
+    selections.push(`recordings: objects(first: 50, filter: { type: $recordingType }) {
+      pageInfo { hasNextPage endCursor }
+      nodes { address asMoveObject { contents { type { repr } } } }
+    }`);
+    variables.recordingType = `${misoPackageId}::recording::Recording`;
+  }
+
+  const result = await client.query<
+    Record<string, WorkAddressConnection | null>,
+    Record<string, string>
+  >({
+    query: `query WorkAddressesByShareTypes(${declarations.join(", ")}) {
+      ${selections.join("\n")}
+    }`,
+    variables,
+  });
+  if (result.errors?.length) {
+    throw new AggregateError(
+      result.errors.map((error) => new Error(error.message)),
+      "Work type discovery failed",
+    );
+  }
+
+  compositions.forEach((shareType, index) => {
+    const address = result.data?.[`composition${index}`]?.nodes[0]?.address;
+    if (address) out.compositions[shareType] = address;
+  });
+
+  const readRecordingPage = (
+    page: WorkAddressConnection | null | undefined,
+  ) => {
+    for (const node of page?.nodes ?? []) {
+      const repr = node.asMoveObject?.contents?.type?.repr;
+      if (!repr) continue;
+      try {
+        const [recordingShareType] = extractTypeParams2(repr);
+        if (recordings.has(recordingShareType)) {
+          out.recordings[recordingShareType] = node.address;
+        }
+      } catch {
+        // Ignore a live object whose type does not match the deployed Recording ABI.
+      }
+    }
+  };
+
+  let recordingPage = result.data?.recordings;
+  readRecordingPage(recordingPage);
+  while (
+    recordingPage?.pageInfo?.hasNextPage &&
+    recordingPage.pageInfo.endCursor &&
+    Object.keys(out.recordings).length < recordings.size
+  ) {
+    const next = await client.query<
+      { recordings: WorkAddressConnection | null },
+      { recordingType: string; cursor: string }
+    >({
+      query: `query RecordingWorkAddresses($recordingType: String!, $cursor: String!) {
+        recordings: objects(first: 50, after: $cursor, filter: { type: $recordingType }) {
+          pageInfo { hasNextPage endCursor }
+          nodes { address asMoveObject { contents { type { repr } } } }
+        }
+      }`,
+      variables: {
+        recordingType: variables.recordingType!,
+        cursor: recordingPage.pageInfo.endCursor,
+      },
+    });
+    if (next.errors?.length) {
+      throw new AggregateError(
+        next.errors.map((error) => new Error(error.message)),
+        "Recording type discovery failed",
+      );
+    }
+    recordingPage = next.data?.recordings;
+    readRecordingPage(recordingPage);
+  }
+
+  return out;
+}
+
+export interface WorkIds {
+  compositions: readonly string[];
+  recordings: readonly string[];
+  releases: readonly string[];
+}
+
+export interface WorksById {
+  compositions: Partial<Record<string, Composition>>;
+  recordings: Partial<Record<string, Recording>>;
+  releases: Partial<Record<string, Release>>;
+}
+
+/** Fetch and parse heterogeneous work objects through one Core bulk request. */
+export async function getWorksByIds(
+  client: ClientWithCoreApi,
+  ids: WorkIds,
+): Promise<WorksById> {
+  const kinds = new Map<string, keyof WorksById>();
+  for (const [kind, objectIds] of Object.entries(ids) as Array<
+    [keyof WorksById, readonly string[]]
+  >) {
+    for (const objectId of objectIds) {
+      const normalized = normalizeSuiAddress(objectId);
+      const previous = kinds.get(normalized);
+      if (previous && previous !== kind) {
+        throw new Error(
+          `Work ${normalized} was requested as both ${previous} and ${kind}`,
+        );
+      }
+      kinds.set(normalized, kind);
+    }
+  }
+
+  const out: WorksById = { compositions: {}, recordings: {}, releases: {} };
+  if (kinds.size === 0) return out;
+
+  const { objects } = await client.core.getObjects({
+    objectIds: [...kinds.keys()],
+    include: { content: true },
+  });
+  for (const obj of objects) {
+    if (obj instanceof Error || !obj.content) continue;
+    const kind = kinds.get(normalizeSuiAddress(obj.objectId));
+    if (kind === "compositions") {
+      out.compositions[obj.objectId] = mapComposition(
+        obj.objectId,
+        CompositionBcs.parse(obj.content),
+      );
+    } else if (kind === "recordings") {
+      out.recordings[obj.objectId] = mapRecording(
+        obj.objectId,
+        RecordingBcs.parse(obj.content),
+      );
+    } else if (kind === "releases") {
+      out.releases[obj.objectId] = mapRelease(
+        obj.objectId,
+        ReleaseBcs.parse(obj.content),
+      );
+    }
+  }
+  return out;
+}
+
 // ============================================================================
 // Composition
 // ============================================================================
@@ -151,24 +377,36 @@ export async function getCompositionsByIds(
   compositionIds: string[],
 ): Promise<Record<string, Composition>> {
   if (compositionIds.length === 0) return {};
-  const { objects } = await client.core.getObjects({ objectIds: compositionIds, include: { content: true } });
+  const { objects } = await client.core.getObjects({
+    objectIds: compositionIds,
+    include: { content: true },
+  });
   const out: Record<string, Composition> = {};
   for (const obj of objects) {
     if (obj instanceof Error || !obj.content) continue;
-    out[obj.objectId] = mapComposition(obj.objectId, CompositionBcs.parse(obj.content));
+    out[obj.objectId] = mapComposition(
+      obj.objectId,
+      CompositionBcs.parse(obj.content),
+    );
   }
   return out;
 }
 
 /** Fetches a composition by its object ID. */
-export async function getCompositionById(client: ClientWithCoreApi, compositionId: string): Promise<Composition> {
+export async function getCompositionById(
+  client: ClientWithCoreApi,
+  compositionId: string,
+): Promise<Composition> {
   const content = await getContent(client, compositionId);
   if (!content) throw new Error(`Composition not found: ${compositionId}`);
   return mapComposition(compositionId, CompositionBcs.parse(content));
 }
 
 /** Extracts the share type `T` from a `Composition<T>` object. */
-export async function getCompositionShareType(client: ClientWithCoreApi, compositionId: string): Promise<string> {
+export async function getCompositionShareType(
+  client: ClientWithCoreApi,
+  compositionId: string,
+): Promise<string> {
   const { object } = await client.core.getObject({ objectId: compositionId });
   return extractTypeParam(object.type);
 }
@@ -180,8 +418,13 @@ export async function getCompositionByShareType(
   shareType: string,
   misoPackageId: string,
 ): Promise<Composition> {
-  const address = await getCompositionAddressByShareType(graphqlClient, shareType, misoPackageId);
-  if (!address) throw new Error(`Composition not found for share type: ${shareType}`);
+  const address = await getCompositionAddressByShareType(
+    graphqlClient,
+    shareType,
+    misoPackageId,
+  );
+  if (!address)
+    throw new Error(`Composition not found for share type: ${shareType}`);
   return getCompositionById(client, address);
 }
 
@@ -222,7 +465,10 @@ export async function getOwnedCompositionAdminCaps(
   misoPackageId: string,
 ): Promise<CompositionAdminCap[]> {
   const capType = `${misoPackageId}::composition::CompositionAdminCap`;
-  const { objects } = await client.core.listOwnedObjects({ owner, type: capType });
+  const { objects } = await client.core.listOwnedObjects({
+    owner,
+    type: capType,
+  });
   const caps: CompositionAdminCap[] = [];
   for (const obj of objects) {
     const match = obj.type?.match(/<(.+)>$/);
@@ -231,8 +477,15 @@ export async function getOwnedCompositionAdminCaps(
   return caps;
 }
 
-export function deriveCompositionAdminCapId(compositionId: string, misoPackageId: string): string {
-  return deriveObjectID(compositionId, `${misoPackageId}::composition::CompositionAdminCapKey`, UNIT_STRUCT_KEY_BYTES);
+export function deriveCompositionAdminCapId(
+  compositionId: string,
+  misoPackageId: string,
+): string {
+  return deriveObjectID(
+    compositionId,
+    `${misoPackageId}::composition::CompositionAdminCapKey`,
+    UNIT_STRUCT_KEY_BYTES,
+  );
 }
 
 // ============================================================================
@@ -244,16 +497,25 @@ export async function getRecordingsByIds(
   recordingIds: string[],
 ): Promise<Record<string, Recording>> {
   if (recordingIds.length === 0) return {};
-  const { objects } = await client.core.getObjects({ objectIds: recordingIds, include: { content: true } });
+  const { objects } = await client.core.getObjects({
+    objectIds: recordingIds,
+    include: { content: true },
+  });
   const out: Record<string, Recording> = {};
   for (const obj of objects) {
     if (obj instanceof Error || !obj.content) continue;
-    out[obj.objectId] = mapRecording(obj.objectId, RecordingBcs.parse(obj.content));
+    out[obj.objectId] = mapRecording(
+      obj.objectId,
+      RecordingBcs.parse(obj.content),
+    );
   }
   return out;
 }
 
-export async function getRecordingById(client: ClientWithCoreApi, recordingId: string): Promise<Recording> {
+export async function getRecordingById(
+  client: ClientWithCoreApi,
+  recordingId: string,
+): Promise<Recording> {
   const content = await getContent(client, recordingId);
   if (!content) throw new Error(`Recording not found: ${recordingId}`);
   return mapRecording(recordingId, RecordingBcs.parse(content));
@@ -265,14 +527,20 @@ export async function getRecordingById(client: ClientWithCoreApi, recordingId: s
  * them and returns the first; use {@link getRecordingShareTypes} when the
  * parent composition's share type is needed too.
  */
-export async function getRecordingShareType(client: ClientWithCoreApi, recordingId: string): Promise<string> {
-  const [recordingShareType] = await getRecordingShareTypes(client, recordingId);
+export async function getRecordingShareType(
+  client: ClientWithCoreApi,
+  recordingId: string,
+): Promise<string> {
+  const [recordingShareType] = await getRecordingShareTypes(
+    client,
+    recordingId,
+  );
   return recordingShareType;
 }
 
 /**
  * Both of a recording's share types, as `[RecordingShare, CompositionShare]`.
- * Most builders need the pair — `deal::new`, `track::new`, `recording::publish`
+ * Most builders need the pair — `track::new`, `recording::publish`
  * and the recording credit/pool extensions are all generic over both, in this
  * order.
  */
@@ -290,8 +558,13 @@ export async function getRecordingByShareType(
   shareType: string,
   misoPackageId: string,
 ): Promise<Recording> {
-  const address = await addressOfRecordingWithShareType(graphqlClient, misoPackageId, shareType);
-  if (!address) throw new Error(`Recording not found for share type: ${shareType}`);
+  const address = await addressOfRecordingWithShareType(
+    graphqlClient,
+    misoPackageId,
+    shareType,
+  );
+  if (!address)
+    throw new Error(`Recording not found for share type: ${shareType}`);
   return getRecordingById(client, address);
 }
 
@@ -317,7 +590,10 @@ export async function getOwnedRecordingAdminCaps(
   misoPackageId: string,
 ): Promise<RecordingAdminCap[]> {
   const capType = `${misoPackageId}::recording::RecordingAdminCap`;
-  const { objects } = await client.core.listOwnedObjects({ owner, type: capType });
+  const { objects } = await client.core.listOwnedObjects({
+    owner,
+    type: capType,
+  });
   const caps: RecordingAdminCap[] = [];
   for (const obj of objects) {
     const match = obj.type?.match(/<(.+)>$/);
@@ -326,27 +602,15 @@ export async function getOwnedRecordingAdminCaps(
   return caps;
 }
 
-export function deriveRecordingAdminCapId(recordingId: string, misoPackageId: string): string {
-  return deriveObjectID(recordingId, `${misoPackageId}::recording::RecordingAdminCapKey`, UNIT_STRUCT_KEY_BYTES);
-}
-
-// ============================================================================
-// Deal
-// ============================================================================
-
-/** Fetches a deal by its object ID (share types read from the type parameters). */
-export async function getDealById(client: ClientWithCoreApi, dealId: string): Promise<Deal> {
-  const { object } = await client.core.getObject({ objectId: dealId, include: { content: true } });
-  if (!object.content) throw new Error(`Deal not found: ${dealId}`);
-  const d = DealBcs.parse(object.content);
-  const [recordingShareType, compositionShareType] = extractTypeParams2(object.type);
-  return {
-    id: dealId,
-    releaseId: d.release_id,
-    trackSplitBps: mapBps(d.track_split_bps),
-    recordingShareType,
-    compositionShareType,
-  };
+export function deriveRecordingAdminCapId(
+  recordingId: string,
+  misoPackageId: string,
+): string {
+  return deriveObjectID(
+    recordingId,
+    `${misoPackageId}::recording::RecordingAdminCapKey`,
+    UNIT_STRUCT_KEY_BYTES,
+  );
 }
 
 // ============================================================================
@@ -360,44 +624,39 @@ export async function getReleasesByIds(
   if (releaseIds.length === 0) return {};
   const { objects } = await client.core.getObjects({
     objectIds: releaseIds,
-    include: { content: true, json: true },
+    include: { content: true },
   });
   const out: Record<string, Release> = {};
   for (const obj of objects) {
     if (obj instanceof Error || !obj.content) continue;
-    const json = obj.json as { discs?: unknown[] } | null;
-    out[obj.objectId] = json?.discs
-      ? mapDiscReleaseJson(obj.objectId, json)
-      : mapRelease(obj.objectId, ReleaseBcs.parse(obj.content));
+    out[obj.objectId] = mapRelease(obj.objectId, ReleaseBcs.parse(obj.content));
   }
   return out;
 }
 
-export async function getReleaseById(client: ClientWithCoreApi, releaseId: string): Promise<Release> {
+export async function getReleaseById(
+  client: ClientWithCoreApi,
+  releaseId: string,
+): Promise<Release> {
   const { object } = await client.core.getObject({
     objectId: releaseId,
-    include: { content: true, json: true },
+    include: { content: true },
   });
   if (!object.content) throw new Error(`Release not found: ${releaseId}`);
-  const json = object.json as { discs?: unknown[] } | null;
-  return json?.discs
-    ? mapDiscReleaseJson(releaseId, json)
-    : mapRelease(releaseId, ReleaseBcs.parse(object.content));
-}
-
-export async function getReleaseRegistry(client: SuiGraphQLClient, misoPackageId: string): Promise<string> {
-  const address = await firstAddressOfType(client, `${misoPackageId}::release::ReleaseRegistry`);
-  if (!address) throw new Error("ReleaseRegistry not found");
-  return address;
+  return mapRelease(releaseId, ReleaseBcs.parse(object.content));
 }
 
 export async function getReleaseAdminCapById(
   client: ClientWithCoreApi,
   adminCapId: string,
 ): Promise<ReleaseAdminCap> {
-  const { object } = await client.core.getObject({ objectId: adminCapId, include: { json: true } });
+  const { object } = await client.core.getObject({
+    objectId: adminCapId,
+    include: { json: true },
+  });
   const json = object.json as { release_id: string } | null;
-  if (!json?.release_id) throw new Error(`ReleaseAdminCap not found: ${adminCapId}`);
+  if (!json?.release_id)
+    throw new Error(`ReleaseAdminCap not found: ${adminCapId}`);
   return { id: adminCapId, releaseId: json.release_id };
 }
 
@@ -407,23 +666,29 @@ export async function getOwnedReleaseAdminCaps(
   misoPackageId: string,
 ): Promise<ReleaseAdminCap[]> {
   const capType = `${misoPackageId}::release::ReleaseAdminCap`;
-  const { objects } = await client.core.listOwnedObjects({ owner, type: capType });
-  if (objects.length === 0) return [];
-  const { objects: details } = await client.core.getObjects({
-    objectIds: objects.map((o) => o.objectId),
+  const { objects } = await client.core.listOwnedObjects({
+    owner,
+    type: capType,
     include: { json: true },
   });
   const caps: ReleaseAdminCap[] = [];
-  for (const obj of details) {
-    if (obj instanceof Error) continue;
+  for (const obj of objects) {
     const json = obj.json as { release_id: string } | null;
-    if (json?.release_id) caps.push({ id: obj.objectId, releaseId: json.release_id });
+    if (json?.release_id)
+      caps.push({ id: obj.objectId, releaseId: json.release_id });
   }
   return caps;
 }
 
-export function deriveReleaseAdminCapId(releaseId: string, misoPackageId: string): string {
-  return deriveObjectID(releaseId, `${misoPackageId}::release::ReleaseAdminCapKey`, UNIT_STRUCT_KEY_BYTES);
+export function deriveReleaseAdminCapId(
+  releaseId: string,
+  misoPackageId: string,
+): string {
+  return deriveObjectID(
+    releaseId,
+    `${misoPackageId}::release::ReleaseAdminCapKey`,
+    UNIT_STRUCT_KEY_BYTES,
+  );
 }
 
 // ============================================================================
@@ -431,7 +696,10 @@ export function deriveReleaseAdminCapId(releaseId: string, misoPackageId: string
 // ============================================================================
 
 /** Extracts the share type `T` from a `Currency<T>` object. */
-export async function getShareCurrencyType(client: ClientWithCoreApi, shareCurrencyId: string): Promise<string> {
+export async function getShareCurrencyType(
+  client: ClientWithCoreApi,
+  shareCurrencyId: string,
+): Promise<string> {
   const { object } = await client.core.getObject({ objectId: shareCurrencyId });
   return extractTypeParam(object.type);
 }
@@ -471,8 +739,14 @@ export async function getShareCurrencyTreasuryCap(
 // ============================================================================
 
 /** Returns the first object address of a fully-qualified type, or null. */
-async function firstAddressOfType(client: SuiGraphQLClient, type: string): Promise<string | null> {
-  const result = await client.query({ query: AddressesByTypeQuery, variables: { type } });
+async function firstAddressOfType(
+  client: SuiGraphQLClient,
+  type: string,
+): Promise<string | null> {
+  const result = await client.query({
+    query: AddressesByTypeQuery,
+    variables: { type },
+  });
   return result.data?.objects?.nodes?.[0]?.address ?? null;
 }