@misonetwork/sdk 0.4.0 → 0.5.0

package/src/contracts/utils/index.ts

@@ -8,7 +8,7 @@ import {
 	BcsEnum,
 	BcsTuple,
 } from '@mysten/sui/bcs';
-import { normalizeSuiAddress } from '@mysten/sui/utils';
+import { normalizeStructTag, normalizeSuiAddress } from '@mysten/sui/utils';
 import { type TransactionArgument, isArgument } from '@mysten/sui/transactions';
 import { type ClientWithCoreApi, type SuiClientTypes } from '@mysten/sui/client';
 
@@ -158,10 +158,140 @@ export function normalizeMoveArguments(
 	return normalizedArgs;
 }
 
+/* -------------------------- Move type tags -------------------------- */
+
+/** A type argument: a type tag string, or a BCS type whose name is a Move type. */
+export type TypeArgument = string | BcsType<any>;
+
+export interface TypeTagOptions {
+	package?: string;
+	typeArguments?: readonly TypeArgument[];
+}
+
+/**
+ * `typeArguments` is required when the type's name contains unfilled
+ * `phantom X` parameters (at any depth). Everything else — argument arity,
+ * position contents, and tag validity — is validated at runtime.
+ */
+type TypeTagParams<Name extends string> = Name extends `${string}phantom ${string}`
+	? [options: TypeTagOptions & { typeArguments: readonly TypeArgument[] }]
+	: [options?: TypeTagOptions];
+
+type ResolveTypeTagOptions<Name extends string> = { client: ClientWithCoreApi } & (
+	Name extends `${string}phantom ${string}`
+		? TypeTagOptions & { typeArguments: readonly TypeArgument[] }
+		: TypeTagOptions
+);
+
+const HAS_PHANTOM_REGEX = /phantom [A-Za-z_$][A-Za-z0-9_$]*/;
+
+function splitTopLevelTypeArgs(inner: string): string[] {
+	const parts: string[] = [];
+	let depth = 0;
+	let current = '';
+	for (const char of inner) {
+		if (char === ',' && depth === 0) {
+			parts.push(current.trim());
+			current = '';
+			continue;
+		}
+		if (char === '<') depth++;
+		if (char === '>') depth--;
+		current += char;
+	}
+	if (current) parts.push(current.trim());
+	return parts;
+}
+
+function buildTypeTag(name: string, options: TypeTagOptions | undefined): string {
+	const lt = name.indexOf('<');
+	const base = lt === -1 ? name : name.slice(0, lt);
+
+	if (base.split('::').length !== 3) {
+		throw new Error(`${name} is not a top-level Move type`);
+	}
+
+	let result = name;
+
+	if (options?.typeArguments) {
+		const baked = lt === -1 ? [] : splitTopLevelTypeArgs(name.slice(lt + 1, -1));
+		const supplied = options.typeArguments.map((arg) => {
+			if (typeof arg === 'string') {
+				return arg;
+			}
+			if (arg && typeof arg.serialize === 'function' && typeof arg.name === 'string') {
+				return arg.name;
+			}
+			throw new Error(`Invalid type argument ${stringify(arg)}`);
+		});
+
+		if (supplied.length !== baked.length) {
+			throw new Error(
+				`Expected ${baked.length} type arguments for ${base}, got ${supplied.length}`,
+			);
+		}
+
+		result = supplied.length === 0 ? base : `${base}<${supplied.join(', ')}>`;
+	}
+
+	if (HAS_PHANTOM_REGEX.test(result)) {
+		throw new Error(
+			options?.typeArguments
+				? `A type argument contains an unfilled phantom parameter in ${result}`
+				: `Missing type arguments for ${result}`,
+		);
+	}
+
+	if (options?.package) {
+		const [, ...rest] = result.split('::');
+		result = [options.package, ...rest].join('::');
+	}
+
+	// fully validate address-only tags (MVR names can't be parsed as type tags)
+	if (!HAS_PHANTOM_REGEX.test(result) && !/[@/]/.test(result)) {
+		TypeTagSerializer.parseFromStr(result);
+	}
+
+	return result;
+}
+
+async function resolveBuiltTypeTag(
+	name: string,
+	options: { client: ClientWithCoreApi } & TypeTagOptions,
+): Promise<string> {
+	const { client, ...rest } = options;
+	const { type } = await client.core.mvr.resolveType({
+		type: buildTypeTag(name, rest),
+	});
+	return normalizeStructTag(type);
+}
+
 export class MoveStruct<
 	T extends Record<string, BcsType<any>>,
 	const Name extends string = string,
 > extends BcsStruct<T, Name> {
+	/**
+	 * Build the type tag for this struct.
+	 *
+	 * `typeArguments` is the full positional list, in Move declaration order, and
+	 * is required when the struct has unfilled phantom parameters. The result may
+	 * contain MVR names: those are valid in transaction `typeArguments`, but for
+	 * queries or comparisons against on-chain data use `resolveTypeTag` instead.
+	 */
+	typeTag(...args: TypeTagParams<Name>): string {
+		return buildTypeTag(this.name, args[0] as TypeTagOptions | undefined);
+	}
+
+	/**
+	 * Build the type tag for this struct, then resolve any MVR names through the
+	 * client (using its configured overrides and the MVR API) and return the
+	 * normalized, address-only form suitable for queries and comparisons against
+	 * on-chain data.
+	 */
+	async resolveTypeTag(options: ResolveTypeTagOptions<Name>): Promise<string> {
+		return resolveBuiltTypeTag(this.name, options as { client: ClientWithCoreApi } & TypeTagOptions);
+	}
+
 	async get<Include extends Omit<SuiClientTypes.ObjectInclude, 'content' | 'json'> = {}>({
 		objectId,
 		...options
@@ -210,16 +340,38 @@ export class MoveStruct<
 export class MoveEnum<
 	T extends Record<string, BcsType<any> | null>,
 	const Name extends string,
-> extends BcsEnum<T, Name> {}
+> extends BcsEnum<T, Name> {
+	/** Build the type tag for this enum. See `MoveStruct.typeTag` for semantics. */
+	typeTag(...args: TypeTagParams<Name>): string {
+		return buildTypeTag(this.name, args[0] as TypeTagOptions | undefined);
+	}
+
+	/** Build and resolve the type tag for this enum. See `MoveStruct.resolveTypeTag`. */
+	async resolveTypeTag(options: ResolveTypeTagOptions<Name>): Promise<string> {
+		return resolveBuiltTypeTag(this.name, options as { client: ClientWithCoreApi } & TypeTagOptions);
+	}
+}
 
 export class MoveTuple<
 	const T extends readonly BcsType<any>[],
 	const Name extends string,
-> extends BcsTuple<T, Name> {}
+> extends BcsTuple<T, Name> {
+	/** Build the type tag for this struct. See `MoveStruct.typeTag` for semantics. */
+	typeTag(...args: TypeTagParams<Name>): string {
+		return buildTypeTag(this.name, args[0] as TypeTagOptions | undefined);
+	}
+
+	/** Build and resolve the type tag for this struct. See `MoveStruct.resolveTypeTag`. */
+	async resolveTypeTag(options: ResolveTypeTagOptions<Name>): Promise<string> {
+		return resolveBuiltTypeTag(this.name, options as { client: ClientWithCoreApi } & TypeTagOptions);
+	}
+}
 
 function stringify(val: unknown) {
 	if (typeof val === 'object') {
-		return JSON.stringify(val, (val: unknown) => val);
+		return JSON.stringify(val, (_key, value) =>
+			typeof value === 'bigint' ? value.toString() : value,
+		);
 	}
 	if (typeof val === 'bigint') {
 		return val.toString();

package/src/contracts.ts

@@ -10,5 +10,4 @@
 export * as composition from "./contracts/miso/composition.ts";
 export * as recording from "./contracts/miso/recording.ts";
 export * as release from "./contracts/miso/release.ts";
-export * as deal from "./contracts/miso/deal.ts";
 export * as track from "./contracts/miso/track.ts";

package/src/internal.ts

@@ -78,27 +78,3 @@ export function mapRelease(id: string, d: Parsed): ReleaseType {
     tracks: (d.tracks ?? []).map(mapTrack),
   };
 }
-
-/**
- * Maps the deployed disc-based Release JSON shape to the SDK's flat Release
- * view. The current protocol source stores `tracks` directly, while the
- * existing testnet package stores `discs`; both represent one ordered
- * tracklist to SDK consumers.
- */
-export function mapDiscReleaseJson(id: string, d: Parsed): ReleaseType {
-  const tracks = (d.discs ?? []).flatMap((disc: Parsed) => disc.tracks ?? []);
-  const publishedAt = d.state?.["@variant"] === "Published" ? d.state.pos0 : null;
-  return {
-    id,
-    state:
-      publishedAt == null
-        ? { type: "Initialized" }
-        : { type: "Published", timestampMs: Number(publishedAt) },
-    title: d.title,
-    tracks: tracks.map((track: Parsed) => ({
-      state: (track.state?.["@variant"] ?? "Unassigned") as TrackState,
-      recordingId: track.recording_id,
-      splitBps: { value: Number(track.split_bps?.pos0 ?? track.split_bps) },
-    })),
-  };
-}

package/src/parsers.ts

@@ -11,19 +11,11 @@ import {
 } from "./contracts/miso/composition.ts";
 import { RecordingPublishedEvent as RecordingPublishedEventBcs } from "./contracts/miso/recording.ts";
 import { ReleasePublishedEvent as ReleasePublishedEventBcs } from "./contracts/miso/release.ts";
-import {
-  DealCreatedEvent as DealCreatedEventBcs,
-  DealAcceptedEvent as DealAcceptedEventBcs,
-  DealRejectedEvent as DealRejectedEventBcs,
-} from "./contracts/miso/deal.ts";
 import type {
   CompositionPublishedEvent,
   CompositionRoyaltySetEvent,
   RecordingPublishedEvent,
   ReleasePublishedEvent,
-  DealCreatedEvent,
-  DealAcceptedEvent,
-  DealRejectedEvent,
 } from "./types.ts";
 
 // === Composition ===
@@ -51,30 +43,3 @@ export function parseReleasePublishedEvent(bytes: Uint8Array): ReleasePublishedE
   const e = ReleasePublishedEventBcs.parse(bytes);
   return { releaseId: e.release_id };
 }
-
-// === Deal ===
-
-export function parseDealCreatedEvent(bytes: Uint8Array): DealCreatedEvent {
-  const e = DealCreatedEventBcs.parse(bytes);
-  return {
-    dealId: e.deal_id,
-    releaseId: e.release_id,
-    trackSplitBps: { value: e.track_split_bps_value },
-  };
-}
-
-export function parseDealAcceptedEvent(bytes: Uint8Array): DealAcceptedEvent {
-  const e = DealAcceptedEventBcs.parse(bytes);
-  return {
-    dealId: e.deal_id,
-    releaseId: e.release_id,
-  };
-}
-
-export function parseDealRejectedEvent(bytes: Uint8Array): DealRejectedEvent {
-  const e = DealRejectedEventBcs.parse(bytes);
-  return {
-    dealId: e.deal_id,
-    releaseId: e.release_id,
-  };
-}

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.
@@ -25,20 +25,17 @@ import { graphql } from "@mysten/sui/graphql/schema";
 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 type {
   Composition,
   CompositionAdminCap,
-  Deal,
   Recording,
   RecordingAdminCap,
   Release,
@@ -345,7 +342,7 @@ export async function getWorksByIds(
 
   const { objects } = await client.core.getObjects({
     objectIds: [...kinds.keys()],
-    include: { content: true, json: true },
+    include: { content: true },
   });
   for (const obj of objects) {
     if (obj instanceof Error || !obj.content) continue;
@@ -361,10 +358,10 @@ export async function getWorksByIds(
         RecordingBcs.parse(obj.content),
       );
     } else if (kind === "releases") {
-      const json = obj.json as { discs?: unknown[] } | null;
-      out.releases[obj.objectId] = json?.discs
-        ? mapDiscReleaseJson(obj.objectId, json)
-        : mapRelease(obj.objectId, ReleaseBcs.parse(obj.content));
+      out.releases[obj.objectId] = mapRelease(
+        obj.objectId,
+        ReleaseBcs.parse(obj.content),
+      );
     }
   }
   return out;
@@ -543,7 +540,7 @@ export async function getRecordingShareType(
 
 /**
  * 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.
  */
@@ -616,33 +613,6 @@ export function deriveRecordingAdminCapId(
   );
 }
 
-// ============================================================================
-// 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,
-  };
-}
-
 // ============================================================================
 // Release
 // ============================================================================
@@ -654,15 +624,12 @@ 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;
 }
@@ -673,25 +640,10 @@ export async function getReleaseById(
 ): 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(

package/src/transactions.ts

@@ -2,18 +2,17 @@
 // SPDX-License-Identifier: Apache-2.0
 
 // Transaction builders. Every builder adds commands to a caller-owned
-// `Transaction`, so flows compose in a single PTB, but they come in two shapes.
+// `Transaction`, so flows compose in a single PTB.
 // The `create*` primitives take the `Transaction` as their FIRST argument and
 // return their by-value results, so those results can be threaded into later
-// commands. `rejectDeal` has nothing to hand back, so it keeps the Sui SDK
-// thunk shape: `(params) => (tx: Transaction) => …`. Miso calls go through the
-// codegen-generated, type-safe call functions.
+// commands. Miso calls go through the codegen-generated, type-safe call
+// functions.
 //
 // This module keeps the bare protocol PRIMITIVES only. The rule is: do the
 // minimum the Move semantics FORCE, and return anything the caller could
 // legitimately route elsewhere.
 //
-// `createComposition`, `createRecording`, and `createRelease` each append a
+// `createComposition` and `createRecording` each append a
 // single `::new` and hand back its by-value results — never dispersing a share
 // supply, publishing (sharing) the object, or routing an admin cap.
 //
@@ -28,7 +27,7 @@
 //
 // The opinionated layers — track assembly, cap disposition, minato dispersal,
 // the share-currency lifecycle — live in `@misofm/sdk`
-// (`publishRelease`/`publishReleaseFromDeals`/`publishReleaseGraph`,
+// (`release_registry::new_release`, `publishRelease`/`publishReleaseGraph`,
 // `finalizeComposition`/`finalizeRecording`/`finalizeRelease`,
 // `publishComposition`/`publishRecording`/`publishCompositionAndRecording`,
 // `share.ts`) as free functions taking `misoPackageId` explicitly. Those import
@@ -39,8 +38,7 @@ import { Transaction, type TransactionObjectArgument } from "@mysten/sui/transac
 
 import * as composition from "./contracts/miso/composition.ts";
 import * as recording from "./contracts/miso/recording.ts";
-import * as deal from "./contracts/miso/deal.ts";
-import * as release from "./contracts/miso/release.ts";
+import * as track from "./contracts/miso/track.ts";
 
 /** A thunk that adds commands to a transaction. May be async (resolves at build time). */
 export type TxThunk = (tx: Transaction) => void | Promise<void>;
@@ -153,138 +151,48 @@ export function createRecording(tx: Transaction, params: CreateRecordingParams):
 }
 
 // ============================================================================
-// Deal
+// Track
 // ============================================================================
 
-export interface CreateDealParams {
+export interface CreateTrackParams {
   recordingId: string;
   recordingAdminCapId?: string;
   recordingAdminCap?: TransactionObjectArgument;
-  /** Share type of the recording (the deal's `RecordingShare` phantom). */
+  /** Share type of the recording (the track's `RecordingShare` phantom). */
   recordingShareType: string;
-  /** Share type of the parent composition (the deal's `CompositionShare` phantom). */
+  /** Share type of the parent composition (the track's `CompositionShare` phantom). */
   compositionShareType: string;
-  releaseId: string;
+  targetReleaseId: string;
   trackSplitBps: number;
   misoPackageId: string;
 }
 
 /**
- * PRIMITIVE. Appends `deal::new` and returns the `Deal` by value without routing
- * it anywhere — the caller decides what happens next.
- *
- * LIFECYCLE NOTE — the returned `Deal` MUST be consumed in this same
- * transaction. It is `key, store` with no `drop`, so it cannot be discarded, but
- * it CAN go to either of two places, which is exactly why this does not choose:
- *
- *   1. `tx.transferObjects([deal], recipient)` — send it to whoever is
- *      assembling the release, for them to redeem later. This is the
- *      cross-party flow: a recording owner signs a deal for someone else's
- *      release.
- *   2. straight into `track::new(deal, &recording)` in this same PTB — the
- *      same-party flow, where the deal is a transient authorization rather than
- *      something anyone holds. `@misofm/sdk`'s `publishReleaseGraph` does this.
- *
- * Both are legitimate, and picking one for the caller would make the other
- * awkward, so the disposition stays with the caller. `@misofm/sdk` layers the
- * opinionated flows on top.
+ * PRIMITIVE. Appends `track::new` and returns its by-value `Track`. A track has
+ * `drop, store`, so callers may leave it unused; to assemble a release, pass
+ * returned tracks to `tx.makeMoveVec({ type: `${misoPackageId}::track::Track`,
+ * elements })` and then call `release_registry::new_release` from `@misofm/sdk`.
  *
  * The `recordingAdminCap` may be passed as an on-chain object id
  * (`recordingAdminCapId`) or as a PTB-local argument (`recordingAdminCap`) —
- * the latter lets a deal be signed against a recording created earlier in the
+ * the latter lets a track be created against a recording created earlier in the
  * same transaction, before its cap has been transferred anywhere.
  */
-export function createDeal(tx: Transaction, params: CreateDealParams): TransactionObjectArgument {
+export function createTrack(tx: Transaction, params: CreateTrackParams): TransactionObjectArgument {
   if (!params.recordingAdminCap && !params.recordingAdminCapId) {
-    throw new Error("createDeal: recordingAdminCapId or recordingAdminCap required");
+    throw new Error("createTrack: recordingAdminCapId or recordingAdminCap required");
   }
   const adminCapArg = params.recordingAdminCap ?? tx.object(params.recordingAdminCapId!);
   return tx.add(
-    deal._new({
+    track._new({
       package: params.misoPackageId,
       typeArguments: [params.recordingShareType, params.compositionShareType],
       arguments: [
         adminCapArg,
         tx.object(params.recordingId),
-        tx.pure.id(params.releaseId),
+        tx.pure.id(params.targetReleaseId),
         tx.pure.u16(params.trackSplitBps),
       ],
     }),
   );
 }
-
-export interface RejectDealParams {
-  dealId: string;
-  /** Share type of the recording (the deal's `RecordingShare` phantom). */
-  recordingShareType: string;
-  /** Share type of the parent composition (the deal's `CompositionShare` phantom). */
-  compositionShareType: string;
-  misoPackageId: string;
-}
-
-/** Rejects (destroys) a deal without including it in a release. Emits `DealRejectedEvent`. */
-export function rejectDeal(params: RejectDealParams): TxThunk {
-  return (tx) => {
-    tx.add(deal.reject({
-      package: params.misoPackageId,
-      typeArguments: [params.recordingShareType, params.compositionShareType],
-      arguments: [tx.object(params.dealId)],
-    }));
-  };
-}
-
-// ============================================================================
-// Release
-// ============================================================================
-
-/** The two by-value results of `release::new`, for threading onward in a PTB. */
-export interface ReleaseParts {
-  release: TransactionObjectArgument;
-  adminCap: TransactionObjectArgument;
-}
-
-export interface CreateReleaseParams {
-  title: string;
-  /** u256 nonce as a decimal string (deterministic release id). */
-  nonce: string;
-  releaseRegistryId: string;
-  misoPackageId: string;
-}
-
-/**
- * PRIMITIVE. Appends `release::new` over a caller-built `vector<Track>` and
- * returns its by-value results without publishing (sharing) the release or
- * routing the admin cap — the caller decides what happens next. Mirrors
- * {@link createComposition}/{@link createRecording}.
- *
- * `trackVec` is supplied by the caller because track assembly is the part that
- * genuinely varies between release flows: from recording admin caps, from
- * pre-made deals, or from a mix of fresh and existing recordings (see
- * `@misofm/sdk`'s `publishRelease`/`publishReleaseFromDeals`/
- * `publishReleaseGraph`).
- *
- * LIFECYCLE NOTE — the returned `Release` MUST be consumed by
- * `release::publish` in this same transaction. `Release` is `key`-only with no
- * `drop`, and `publish` is its only by-value consumer, so an `Initialized`
- * release cannot be transferred, wrapped, shared, or discarded, and cannot
- * outlive its creating transaction; the protocol deliberately provides no keep
- * function. That is a same-PTB requirement, NOT a same-function one — pairing
- * this with a later `finalizeRelease` command in the same `tx` satisfies it.
- * (`Composition` and `Recording` carry the identical requirement, which is why
- * all three primitives have the same shape.) The admin cap has no such
- * constraint: `ReleaseAdminCap` is `key, store` and `publish` only borrows it,
- * so it is an ordinary transferable value the caller routes as it sees fit.
- */
-export function createRelease(
-  tx: Transaction,
-  params: CreateReleaseParams,
-  trackVec: TransactionObjectArgument,
-): ReleaseParts {
-  const result = tx.add(
-    release._new({
-      package: params.misoPackageId,
-      arguments: [tx.pure.string(params.title), trackVec, tx.pure.u256(BigInt(params.nonce)), tx.object(params.releaseRegistryId)],
-    }),
-  );
-  return { release: result[0]!, adminCap: result[1]! };
-}