@misofm/sdk 0.1.0 → 0.2.0

package/src/contracts/royalty_pool/stake.ts

@@ -0,0 +1,317 @@
+/**************************************************************
+ * 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.js';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+import * as balance_1 from './deps/sui/balance.js';
+import * as vec_map from './deps/sui/vec_map.js';
+import * as type_name from './deps/std/type_name.js';
+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 IdArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface IdOptions {
+    package?: string;
+    arguments: IdArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export function id(options: IdOptions) {
+    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: 'id',
+        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

@@ -0,0 +1,33 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// Barrel for the codegen-generated, ABI-bound bindings (BCS structs + type-safe
+// Move calls). Re-exported from the package root as the `contracts` namespace.
+//
+// PLATFORM + EXTENSION packages. The protocol core (`miso`: Composition,
+// Recording, Release, Deal, Track) generates into `@misonetwork/sdk` and is
+// re-exported from ITS `contracts` namespace — import it from there rather than
+// mirroring it here.
+
+// The record production line (pressing runs + their per-currency listings).
+export * as pressing from "./contracts/miso_pressing/pressing.ts";
+export * as listing from "./contracts/miso_pressing/listing.ts";
+export * as certificate from "./contracts/miso_pressing/certificate.ts";
+
+// Royalty-pool extension (base lib + per-work extensions).
+export * as royaltyPool from "./contracts/royalty_pool/pool.ts";
+export * as royaltyPoolStake from "./contracts/royalty_pool/stake.ts";
+export * as compositionRoyaltyPool from "./contracts/composition_royalty_pool/composition_royalty_pool.ts";
+export * as recordingRoyaltyPool from "./contracts/recording_royalty_pool/recording_royalty_pool.ts";
+
+// Cover art (the CoverArt value type + the release attachment extension).
+export * as coverArt from "./contracts/cover_art/cover_art.ts";
+export * as releaseCoverArt from "./contracts/release_cover_art/release_cover_art.ts";
+
+// Credits extensions (per-work credit stores + their role vocabularies).
+export * as compositionCredits from "./contracts/composition_credits/composition_credits.ts";
+export * as compositionPartyRole from "./contracts/composition_credits/composition_party_role.ts";
+export * as recordingCredits from "./contracts/recording_credits/recording_credits.ts";
+export * as recordingPartyRole from "./contracts/recording_credits/recording_party_role.ts";
+export * as releaseCredits from "./contracts/release_credits/release_credits.ts";
+export * as releasePartyRole from "./contracts/release_credits/release_party_role.ts";

package/src/cover.ts

@@ -0,0 +1,140 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// Release cover art. A cover is a still image (optionally an animation) stored as
+// a Walrus blob and referenced on-chain via `ori::WalrusData`. We build the ref
+// (`ori::walrus_data::new_blob`, a raw call — ori is an external dep), wrap it in a
+// `cover_art::CoverArt`, and attach it to the Release with
+// `release_cover_art::set_cover` (gated by the ReleaseAdminCap).
+//
+// Blob ids are passed as `u256` (decimal string or bigint) — the CLI converts the
+// base64url Walrus blob id to u256 before calling.
+//
+// The `Release` being covered is a protocol object; the cover is a platform
+// opinion attached to it through the release's cap-gated `uid_mut` hook, which is
+// why this module ships from `@misofm/sdk` rather than the protocol SDK.
+
+import type { ClientWithCoreApi } from "@mysten/sui/client";
+import { bcs } from "@mysten/sui/bcs";
+import { deriveDynamicFieldID } from "@mysten/sui/utils";
+import type { TxThunk } from "./transactions.ts";
+import { OPTION_NONE, OPTION_SOME } from "./internal.ts";
+import { isNotFound } from "./queries.ts";
+import * as coverArt from "./contracts/cover_art/cover_art.ts";
+import * as releaseCoverArt from "./contracts/release_cover_art/release_cover_art.ts";
+
+export interface SetReleaseCoverParams {
+  /** The `Release` object to attach the cover to. */
+  releaseId: string;
+  /** The release's `ReleaseAdminCap`. */
+  releaseAdminCapId: string;
+  /** Walrus blob id of the still cover image, as `u256` (decimal string or bigint). */
+  stillBlobId: bigint | string;
+  /** Optional animated-cover Walrus blob id (`u256`); omit for a still-only cover. */
+  animatedBlobId?: bigint | string | null;
+  /** `cover_art` package — home of the `CoverArt` value type (`cover_art::new`). */
+  coverArtPackageId: string;
+  /** `release_cover_art` package — home of the `set_cover` extension entry point. */
+  releaseCoverArtPackageId: string;
+  /** `ori` package (home of `walrus_data::new_blob` / the `WalrusData` type). */
+  oriPackageId: string;
+}
+
+/** Sets (or replaces) a release's album-level cover from Walrus blob ids. */
+export function setReleaseCover(p: SetReleaseCoverParams): TxThunk {
+  return (tx) => {
+    const walrusType = `${p.oriPackageId}::walrus_data::WalrusData`;
+    const blob = (id: bigint | string) =>
+      tx.moveCall({ target: `${p.oriPackageId}::walrus_data::new_blob`, arguments: [tx.pure.u256(id)] });
+
+    const still = blob(p.stillBlobId);
+    const animated =
+      p.animatedBlobId == null
+        ? tx.moveCall({ target: OPTION_NONE, typeArguments: [walrusType] })
+        : tx.moveCall({ target: OPTION_SOME, typeArguments: [walrusType], arguments: [blob(p.animatedBlobId)] });
+
+    const cover = tx.add(coverArt._new({ package: p.coverArtPackageId, arguments: [still, animated] }));
+    tx.add(
+      releaseCoverArt.setCover({
+        package: p.releaseCoverArtPackageId,
+        arguments: [p.releaseId, p.releaseAdminCapId, cover],
+      }),
+    );
+  };
+}
+
+// ── Reads ────────────────────────────────────────────────────────────────────
+
+/**
+ * A normalized reference to a cover image's Walrus data. Blob ids are returned as
+ * `u256` decimal strings (the on-chain form); callers convert to a base64url
+ * aggregator URL with `@unconfirmed/ori` (`u256ToB64Url` / `walrusDataUrl`).
+ */
+export type CoverImageRef =
+  | { kind: "blob"; blobId: string }
+  | { kind: "quiltPatch"; quiltId: string; version: number; startIndex: number; endIndex: number };
+
+/** A release's album-level cover: a still image and an optional animation. */
+export interface ReleaseCoverView {
+  still: CoverImageRef;
+  animated: CoverImageRef | null;
+}
+
+// The cover is a dynamic field on the release UID under an empty `ExtensionKey()`
+// (Move's implicit `dummy_field: bool` → one `false` byte). The stored value is a
+// `Field { id, name: ExtensionKey, value: ReleaseCoverArt }`.
+const CoverArtField = bcs.struct("Field", {
+  id: bcs.Address,
+  name: releaseCoverArt.ExtensionKey,
+  value: releaseCoverArt.ReleaseCoverArt,
+});
+const COVER_ART_KEY_BYTES = releaseCoverArt.ExtensionKey.serialize([false]).toBytes();
+
+/** A parsed `ori::WalrusData` value (a MoveEnum: `Blob` or `QuiltPatch`). */
+type ParsedWalrusData =
+  | { $kind: "Blob"; Blob: [string | number | bigint, unknown] }
+  | { $kind: "QuiltPatch"; QuiltPatch: [string | number | bigint, number, number, number] };
+
+function toCoverImageRef(wd: ParsedWalrusData): CoverImageRef {
+  if (wd.$kind === "Blob") return { kind: "blob", blobId: String(wd.Blob[0]) };
+  const [quiltId, version, startIndex, endIndex] = wd.QuiltPatch;
+  return { kind: "quiltPatch", quiltId: String(quiltId), version, startIndex, endIndex };
+}
+
+/**
+ * Reads a release's album-level cover (the `release_cover_art` extension), or
+ * `null` if no cover is attached. Derives the `ExtensionKey` dynamic field on the
+ * release, parses the `ReleaseCoverArt`, and returns the still (+ optional
+ * animation) as normalized Walrus refs for the app's featured-pressing card.
+ */
+export async function getReleaseCover(
+  client: ClientWithCoreApi,
+  releaseId: string,
+  releaseCoverArtPackageId: string,
+): Promise<ReleaseCoverView | null> {
+  const fieldId = deriveDynamicFieldID(
+    releaseId,
+    `${releaseCoverArtPackageId}::release_cover_art::ExtensionKey`,
+    COVER_ART_KEY_BYTES,
+  );
+
+  let content: Uint8Array | null;
+  try {
+    const { object } = await client.core.getObject({ objectId: fieldId, include: { content: true } });
+    content = object?.content ?? null;
+  } catch (e) {
+    if (isNotFound(e)) return null;
+    throw e;
+  }
+  if (!content) return null;
+
+  const cover = CoverArtField.parse(content).value.cover as
+    | { still: ParsedWalrusData; animated: ParsedWalrusData | null }
+    | null;
+  if (!cover) return null;
+
+  return {
+    still: toCoverImageRef(cover.still),
+    animated: cover.animated ? toCoverImageRef(cover.animated) : null,
+  };
+}