@misonetwork/sdk 0.7.0 → 0.9.0

package/src/contracts/royalty_pool/stake.ts

@@ -0,0 +1,291 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * A position holding share tokens registered against a `RoyaltyPool`.
+ *
+ * Stakes are owned objects with an immutable balance — to increase a holder's
+ * total staked amount, mint additional Stake objects rather than modify an
+ * existing one. This mirrors Sui's native staking model.
+ *
+ * Each stake tracks the royalty pools it is currently registered with via an
+ * inline `VecMap<TypeName, Registration>`, keyed by the pool's `Currency`
+ * `TypeName`. The stake cannot be destroyed while any registrations remain. Pool
+ * registrations are mutated by `royalty_pool::pool` through the package-private
+ * accessors below.
+ */
+
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+import * as balance_1 from './deps/sui/balance.ts';
+import * as vec_map from './deps/sui/vec_map.ts';
+import * as type_name from './deps/std/type_name.ts';
+const $moduleName = '@local-pkg/royalty_pool::stake';
+export const Registration = new MoveStruct({ name: `${$moduleName}::Registration`, fields: {
+        pool_id: bcs.Address,
+        last_claim_index: bcs.u256()
+    } });
+export const Stake = new MoveStruct({ name: `${$moduleName}::Stake<phantom Share>`, fields: {
+        id: bcs.Address,
+        /** The staked balance. Immutable after creation. */
+        balance: balance_1.Balance,
+        /**
+         * Active royalty-pool registrations, keyed by `Currency` `TypeName`. Must be empty
+         * to destroy.
+         */
+        registrations: vec_map.VecMap(type_name.TypeName, Registration)
+    } });
+export const StakeCreatedEvent = new MoveStruct({ name: `${$moduleName}::StakeCreatedEvent<phantom Share>`, fields: {
+        stake_id: bcs.Address,
+        amount: bcs.u64()
+    } });
+export const StakeDestroyedEvent = new MoveStruct({ name: `${$moduleName}::StakeDestroyedEvent<phantom Share>`, fields: {
+        stake_id: bcs.Address,
+        amount: bcs.u64()
+    } });
+export interface NewArguments {
+    balance: TransactionArgument;
+}
+export interface NewOptions {
+    package?: string;
+    arguments: NewArguments | [
+        balance: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Create a new stake with the given balance.
+ *
+ * Aborts if `balance` is zero.
+ */
+export function _new(options: NewOptions) {
+    const packageAddress = options.package ?? '@local-pkg/royalty_pool';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["balance"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'stake',
+        function: 'new',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface DestroyArguments {
+    stake: RawTransactionArgument<string>;
+}
+export interface DestroyOptions {
+    package?: string;
+    arguments: DestroyArguments | [
+        stake: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Destroy a stake and reclaim its balance.
+ *
+ * Aborts if the stake is still registered with any royalty pools.
+ */
+export function destroy(options: DestroyOptions) {
+    const packageAddress = options.package ?? '@local-pkg/royalty_pool';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["stake"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'stake',
+        function: 'destroy',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface BalanceArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface BalanceOptions {
+    package?: string;
+    arguments: BalanceArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export function balance(options: BalanceOptions) {
+    const packageAddress = options.package ?? '@local-pkg/royalty_pool';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'stake',
+        function: 'balance',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface ValueArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface ValueOptions {
+    package?: string;
+    arguments: ValueArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export function value(options: ValueOptions) {
+    const packageAddress = options.package ?? '@local-pkg/royalty_pool';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'stake',
+        function: 'value',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RegistrationCountArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface RegistrationCountOptions {
+    package?: string;
+    arguments: RegistrationCountArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Number of royalty pools this stake is currently registered with. */
+export function registrationCount(options: RegistrationCountOptions) {
+    const packageAddress = options.package ?? '@local-pkg/royalty_pool';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'stake',
+        function: 'registration_count',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface HasRegistrationArguments {
+    self: RawTransactionArgument<string>;
+    currency: TransactionArgument;
+}
+export interface HasRegistrationOptions {
+    package?: string;
+    arguments: HasRegistrationArguments | [
+        self: RawTransactionArgument<string>,
+        currency: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export function hasRegistration(options: HasRegistrationOptions) {
+    const packageAddress = options.package ?? '@local-pkg/royalty_pool';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "currency"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'stake',
+        function: 'has_registration',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface GetRegistrationArguments {
+    self: RawTransactionArgument<string>;
+    currency: TransactionArgument;
+}
+export interface GetRegistrationOptions {
+    package?: string;
+    arguments: GetRegistrationArguments | [
+        self: RawTransactionArgument<string>,
+        currency: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export function getRegistration(options: GetRegistrationOptions) {
+    const packageAddress = options.package ?? '@local-pkg/royalty_pool';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "currency"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'stake',
+        function: 'get_registration',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RegistrationPoolIdArguments {
+    r: TransactionArgument;
+}
+export interface RegistrationPoolIdOptions {
+    package?: string;
+    arguments: RegistrationPoolIdArguments | [
+        r: TransactionArgument
+    ];
+}
+export function registrationPoolId(options: RegistrationPoolIdOptions) {
+    const packageAddress = options.package ?? '@local-pkg/royalty_pool';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["r"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'stake',
+        function: 'registration_pool_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface RegistrationLastClaimIndexArguments {
+    r: TransactionArgument;
+}
+export interface RegistrationLastClaimIndexOptions {
+    package?: string;
+    arguments: RegistrationLastClaimIndexArguments | [
+        r: TransactionArgument
+    ];
+}
+export function registrationLastClaimIndex(options: RegistrationLastClaimIndexOptions) {
+    const packageAddress = options.package ?? '@local-pkg/royalty_pool';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["r"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'stake',
+        function: 'registration_last_claim_index',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/src/contracts.ts

@@ -4,10 +4,76 @@
 // Barrel for the codegen-generated, ABI-bound bindings (BCS structs + type-safe
 // Move calls). Re-exported from the package root as the `contracts` namespace.
 
-// Core miso protocol ONLY — the `miso` Move package. Bindings for the first-party
-// EXTENSION packages (credits, royalty pools, cover art) generate into
-// `@misofm/sdk` instead, and are re-exported from its own `contracts` namespace.
-export * as composition from "./contracts/miso/composition.ts";
-export * as recording from "./contracts/miso/recording.ts";
-export * as release from "./contracts/miso/release.ts";
+// Every package here is generated from the current first-party Move source. The
+// generated default `@local-pkg/*` identities are source labels only: callers
+// must inject exact published addresses through `MisoDeployment` before building
+// a transaction. Do not use a historic package ID as a substitute for a fresh
+// deployment.
+
+type PublicModule<M extends object, K extends readonly (keyof M)[]> = Omit<M, K[number]>;
+function withoutUnsafeCalls<M extends object, K extends readonly (keyof M)[]>(
+  module: M,
+  keys: K,
+): PublicModule<M, K> {
+  return Object.fromEntries(Object.entries(module).filter(([key]) => !keys.includes(key as keyof M))) as PublicModule<M, K>;
+}
+
+import * as rawComposition from "./contracts/miso/composition.ts";
+import * as rawRecording from "./contracts/miso/recording.ts";
+import * as rawRelease from "./contracts/miso/release.ts";
+import * as rawCompositionCredits from "./contracts/composition_credits/composition_credits.ts";
+import * as rawRecordingCredits from "./contracts/recording_credits/recording_credits.ts";
+import * as rawRecordingMasterReference from "./contracts/recording_master_reference/recording_master_reference.ts";
+import * as rawRecordingPreview from "./contracts/recording_preview/recording_preview.ts";
+import * as rawReleaseCoverArt from "./contracts/release_cover_art/release_cover_art.ts";
+import * as rawReleaseCredits from "./contracts/release_credits/release_credits.ts";
+import * as rawReleaseDescription from "./contracts/release_description/release_description.ts";
+import * as rawRoyaltyPool from "./contracts/royalty_pool/pool.ts";
+import * as rawRoyaltyStake from "./contracts/royalty_pool/stake.ts";
+import * as rawRoutedStake from "./contracts/routed_stake/routed_stake.ts";
+import * as rawParty from "./contracts/miso_party/party.ts";
+import * as rawPartyProfile from "./contracts/party_profile/party_profile.ts";
+
+// Protocol core (BCS codecs remain available; PTB-inaccessible references do not).
+export const composition = withoutUnsafeCalls(rawComposition, ["title", "uid", "uidMut"] as const);
+export const recording = withoutUnsafeCalls(rawRecording, ["uid", "uidMut"] as const);
+export const release = withoutUnsafeCalls(rawRelease, ["title", "tracks", "uid", "uidMut"] as const);
 export * as track from "./contracts/miso/track.ts";
+
+// Protocol extensions.
+export const compositionCredits = withoutUnsafeCalls(rawCompositionCredits, ["credits"] as const);
+export * as compositionPartyRole from "./contracts/composition_credits/composition_party_role.ts";
+export * as recordingAdvisory from "./contracts/recording_advisory/recording_advisory.ts";
+export const recordingCredits = withoutUnsafeCalls(rawRecordingCredits, ["credits", "primaryArtistIds", "featuredArtistIds"] as const);
+export * as recordingPartyRole from "./contracts/recording_credits/recording_party_role.ts";
+export * as recordingLanguage from "./contracts/recording_language/recording_language.ts";
+export const recordingMasterReference = withoutUnsafeCalls(rawRecordingMasterReference, ["masterReference"] as const);
+export const recordingPreview = withoutUnsafeCalls(rawRecordingPreview, ["preview"] as const);
+export const releaseCoverArt = withoutUnsafeCalls(rawReleaseCoverArt, ["cover"] as const);
+export const releaseCredits = withoutUnsafeCalls(rawReleaseCredits, ["credits"] as const);
+export * as releasePartyRole from "./contracts/release_credits/release_party_role.ts";
+export const releaseDescription = withoutUnsafeCalls(rawReleaseDescription, ["description"] as const);
+export * as releaseDspLink from "./contracts/release_dsp_link/release_dsp_link.ts";
+export * as releaseGenre from "./contracts/release_genre/release_genre.ts";
+export * as releaseKind from "./contracts/release_kind/release_kind.ts";
+
+// First-party generic primitives.
+export const royaltyPool = withoutUnsafeCalls(rawRoyaltyPool, ["balance", "_new"] as const);
+export const royaltyStake = withoutUnsafeCalls(rawRoyaltyStake, ["balance", "getRegistration"] as const);
+export const routedStake = withoutUnsafeCalls(
+  rawRoutedStake,
+  ["stake", "_new", "register", "unregister", "unstake", "restake"] as const,
+);
+
+// Party core and extensions.
+export const party = withoutUnsafeCalls(rawParty, ["groupMembers", "uid", "uidMut"] as const);
+export * as partyCta from "./contracts/party_cta/party_cta.ts";
+export * as partyGenre from "./contracts/party_genre/party_genre.ts";
+export * as partyMedia from "./contracts/party_media/party_media.ts";
+export * as partyMusic from "./contracts/party_music/party_music.ts";
+export * as partyPlatformLink from "./contracts/party_platform_link/party_platform_link.ts";
+export * as partyProLink from "./contracts/party_pro_link/party_pro_link.ts";
+export const partyProfile = withoutUnsafeCalls(rawPartyProfile, ["profile"] as const);
+export * as partyRoles from "./contracts/party_roles/party_roles.ts";
+export * as partySocial from "./contracts/party_social/party_social.ts";
+export * as partyTags from "./contracts/party_tags/party_tags.ts";

package/src/deployments.ts

@@ -1,42 +1,195 @@
 // Copyright (c) Miso Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-/** Sui networks with a protocol deployment bundled into this SDK release. */
+import { normalizeSuiAddress } from "@mysten/sui/utils";
+
+/** Sui networks for which this SDK may eventually bundle a verified deployment. */
 export type MisoNetwork = "mainnet" | "testnet";
 
 /**
- * On-chain identity for one Miso protocol deployment.
+ * Every independently published package required by this SDK surface.
+ *
+ * These names are stable deployment-manifest keys, not Move module names. Their
+ * values are never inferred from source labels or a previous publish.
+ */
+const CANONICAL_MISO_PACKAGE_NAMES = [
+  "miso",
+  "compositionCredits",
+  "recordingAdvisory",
+  "recordingCredits",
+  "recordingLanguage",
+  "recordingMasterReference",
+  "recordingPreview",
+  "releaseCoverArt",
+  "releaseCredits",
+  "releaseDescription",
+  "releaseDspLink",
+  "releaseGenre",
+  "releaseKind",
+  "royaltyPool",
+  "routedStake",
+  "misoParty",
+  "partyCta",
+  "partyGenre",
+  "partyMedia",
+  "partyMusic",
+  "partyPlatformLink",
+  "partyProLink",
+  "partyProfile",
+  "partyRoles",
+  "partySocial",
+  "partyTags",
+  "countryCode",
+  "languageCode",
+  "genre",
+] as const;
+
+/** Public immutable copy; validation always uses the private canonical tuple. */
+export const MISO_PACKAGE_NAMES = Object.freeze([
+  ...CANONICAL_MISO_PACKAGE_NAMES,
+]) as readonly [...typeof CANONICAL_MISO_PACKAGE_NAMES];
+
+export type MisoPackageName = (typeof CANONICAL_MISO_PACKAGE_NAMES)[number];
+
+/**
+ * Exact package addresses from one compatible publish set.
  *
- * Package deployments are immutable. A new publish is represented by a new SDK
- * release with updated values here, keeping the ABI bindings and addresses in
- * the same versioned artifact.
+ * A complete manifest is intentional: a caller cannot accidentally combine
+ * generated bindings for a fresh ABI with stale package IDs. Fill this only from
+ * the Ledger-backed publishing record after the dependency-ordered releases are
+ * complete.
  */
+export type MisoDeployment = Readonly<Record<MisoPackageName, string>>;
+
+/** A minimal core-only deployment, retained for callers that use only `miso()`. */
 export interface MisoProtocolDeployment {
-  /** The published `miso` package used for calls, types, and derivation. */
+  /** The published `miso` package used for calls, types, and derived IDs. */
   readonly packageId: string;
 }
 
-export const MISO_PROTOCOL_DEPLOYMENTS = {
-  testnet: {
-    packageId:
-      "0x974d453e82b09ac90d29cf65d981d3cf3cabe1e5ca9c6348f42860226ef9b5c4",
-  },
-} as const satisfies Partial<Record<MisoNetwork, MisoProtocolDeployment>>;
-
-/** Resolve a bundled deployment, failing closed for devnet/localnet/custom names. */
-export function getMisoProtocolDeployment(
-  network: string,
+/** Validate and freeze a core-only package binding at a client boundary. */
+export function normalizeMisoProtocolDeployment(
+  deployment: unknown,
 ): MisoProtocolDeployment {
+  if (!deployment || typeof deployment !== "object" || Array.isArray(deployment)) {
+    throw new Error("@misonetwork/sdk: core deployment must be an object with a normalized Miso package ID.");
+  }
+  const packageId = (deployment as { packageId?: unknown }).packageId;
+  if (typeof packageId !== "string") {
+    throw new Error("@misonetwork/sdk: core deployment is missing a Miso package ID.");
+  }
+  let normalized: string;
+  try {
+    normalized = normalizeSuiAddress(packageId);
+  } catch {
+    throw new Error("@misonetwork/sdk: core deployment package ID is not a valid Sui address.");
+  }
+  if (packageId !== normalized) {
+    throw new Error(
+      `@misonetwork/sdk: core deployment package ID must be normalized (${normalized}).`,
+    );
+  }
+  return Object.freeze({ packageId });
+}
+
+/**
+ * No current addresses are bundled. The previous Testnet ID deliberately does
+ * not appear here because it was compiled for an older ABI. Address injection is
+ * a single mechanical edit after publication: add the verified full manifest
+ * under the target network, then regenerate/check bindings before releasing.
+ */
+export const MISO_DEPLOYMENTS = {} as const satisfies Partial<
+  Record<MisoNetwork, MisoDeployment>
+>;
+
+/**
+ * @deprecated Use `MISO_DEPLOYMENTS`. This empty alias preserves source
+ * compatibility without preserving the retired protocol-only address map.
+ */
+export const MISO_PROTOCOL_DEPLOYMENTS = MISO_DEPLOYMENTS;
+
+/** Resolve a verified full manifest, failing closed until address injection. */
+export function getMisoDeployment(network: string): MisoDeployment {
   const deployment = (
-    MISO_PROTOCOL_DEPLOYMENTS as Partial<
-      Record<string, MisoProtocolDeployment>
-    >
+    MISO_DEPLOYMENTS as Partial<Record<string, MisoDeployment>>
   )[network];
   if (!deployment) {
     throw new Error(
-      `@misonetwork/sdk: no bundled Miso protocol deployment for network "${network}". ` +
-        "Pass an explicit deployment to miso() for custom networks.",
+      `@misonetwork/sdk: no verified Miso deployment is bundled for network "${network}". ` +
+        "Inject the exact post-publish manifest or pass an explicit deployment; historic package IDs are rejected.",
     );
   }
-  return deployment;
+  return normalizeMisoDeployment(deployment);
+}
+
+/** Extract the core package identity from a complete deployment manifest. */
+export function protocolDeployment(
+  deployment: MisoDeployment,
+): MisoProtocolDeployment {
+  return normalizeMisoProtocolDeployment({ packageId: normalizeMisoDeployment(deployment).miso });
+}
+
+/** Resolve the core package only, preserving the established `miso()` default API. */
+export function getMisoProtocolDeployment(
+  network: string,
+): MisoProtocolDeployment {
+  return protocolDeployment(getMisoDeployment(network));
+}
+
+/**
+ * Validates an explicit manifest before any Move target is constructed. This is
+ * useful at configuration boundaries such as environment-file loading.
+ */
+export function assertMisoDeployment(
+  deployment: unknown,
+): asserts deployment is MisoDeployment {
+  if (!deployment || typeof deployment !== "object" || Array.isArray(deployment)) {
+    throw new Error(
+      `@misonetwork/sdk: deployment must be an object with exactly ${CANONICAL_MISO_PACKAGE_NAMES.length} Miso package IDs.`,
+    );
+  }
+  const entries = deployment as Record<string, unknown>;
+  const keys = Object.keys(entries);
+  const unexpected = keys.filter((key) => !CANONICAL_MISO_PACKAGE_NAMES.includes(key as MisoPackageName));
+  if (unexpected.length > 0 || keys.length !== CANONICAL_MISO_PACKAGE_NAMES.length) {
+    throw new Error(
+      `@misonetwork/sdk: deployment must contain exactly these package IDs: ${CANONICAL_MISO_PACKAGE_NAMES.join(", ")}.`,
+    );
+  }
+  const seenPackageIds = new Set<string>();
+  for (const name of CANONICAL_MISO_PACKAGE_NAMES) {
+    const packageId = entries[name];
+    if (typeof packageId !== "string") {
+      throw new Error(
+        `@misonetwork/sdk: deployment is missing package ID for "${name}". ` +
+          "Use a complete manifest from the fresh publish record.",
+      );
+    }
+    let normalized: string;
+    try {
+      normalized = normalizeSuiAddress(packageId);
+    } catch {
+      throw new Error(`@misonetwork/sdk: deployment package ID for "${name}" is not a valid Sui address.`);
+    }
+    if (packageId !== normalized) {
+      throw new Error(
+        `@misonetwork/sdk: deployment package ID for "${name}" must be normalized (${normalized}).`,
+      );
+    }
+    if (seenPackageIds.has(packageId)) {
+      throw new Error(
+        `@misonetwork/sdk: deployment package ID for "${name}" duplicates another package. ` +
+          "A publish manifest must bind every package to its own address.",
+      );
+    }
+    seenPackageIds.add(packageId);
+  }
+}
+
+/** Validate and snapshot an untrusted manifest so later caller mutation is inert. */
+export function normalizeMisoDeployment(deployment: unknown): MisoDeployment {
+  assertMisoDeployment(deployment);
+  return Object.freeze(
+    Object.fromEntries(CANONICAL_MISO_PACKAGE_NAMES.map((name) => [name, deployment[name]])),
+  ) as MisoDeployment;
 }