@misonetwork/sdk 0.3.1 → 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,
-  };
-}