@misonetwork/sdk 0.2.2 → 0.3.1

package/src/contracts/royalty_pool/stake.ts

@@ -1,317 +0,0 @@
-/**************************************************************
- * 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/cover.ts

@@ -1,136 +0,0 @@
-// 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.
-
-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,
-  };
-}