@misofm/sdk 0.9.0 → 0.10.0

package/src/contracts/vault/vault.ts

@@ -0,0 +1,454 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Generic capability custody and plugin authorization.
+ * 
+ * `Vault<Cap>` holds a capability in a Sui `Referent`. An authorized plugin
+ * receives the whole capability temporarily, paired with a hot-potato `Borrow`
+ * receipt that forces the same capability back into the same vault before the
+ * transaction can finish. Plugin authorization is represented by a typed dynamic
+ * field in the vault's `Bag`.
+ */
+
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import { MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+import * as borrow from './deps/sui/borrow.js';
+import * as bag from './deps/sui/bag.js';
+const $moduleName = '@local-pkg/vault::vault';
+/**
+ * Custodies one capability and the typed authorization records for plugins.
+ *
+ * `Vault` intentionally lacks `store`: only this module can share or destroy it.
+ * The wrapped capability is never exposed except through a hot-potato borrow that
+ * requires its exact return.
+ */
+export function Vault<Cap extends BcsType<any>>(...typeParameters: [
+    Cap
+]) {
+    return new MoveStruct({ name: `${$moduleName}::Vault<${typeParameters[0].name as Cap['name']}>`, fields: {
+            id: bcs.Address,
+            cap: borrow.Referent(typeParameters[0]),
+            authorized_plugins: bag.Bag
+        } });
+}
+export const VaultAdminCap = new MoveStruct({ name: `${$moduleName}::VaultAdminCap<phantom Cap>`, fields: {
+        id: bcs.Address,
+        vault_id: bcs.Address
+    } });
+export const AuthorizedPluginKey = new MoveTuple({ name: `${$moduleName}::AuthorizedPluginKey<phantom Witness>`, fields: [bcs.bool()] });
+export const VaultCreatedEvent = new MoveStruct({ name: `${$moduleName}::VaultCreatedEvent<phantom Cap>`, fields: {
+        vault_id: bcs.Address,
+        vault_admin_cap_id: bcs.Address,
+        wrapped_cap_id: bcs.Address,
+        authorized_plugins_id: bcs.Address
+    } });
+export const PluginAuthorizedEvent = new MoveStruct({ name: `${$moduleName}::PluginAuthorizedEvent<phantom Cap, phantom Witness>`, fields: {
+        vault_id: bcs.Address
+    } });
+export const PluginRevokedEvent = new MoveStruct({ name: `${$moduleName}::PluginRevokedEvent<phantom Cap, phantom Witness>`, fields: {
+        vault_id: bcs.Address
+    } });
+export const VaultDestroyedEvent = new MoveStruct({ name: `${$moduleName}::VaultDestroyedEvent<phantom Cap>`, fields: {
+        vault_id: bcs.Address,
+        wrapped_cap_id: bcs.Address
+    } });
+export interface NewArguments<Cap extends BcsType<any>> {
+    cap: RawTransactionArgument<Cap>;
+}
+export interface NewOptions<Cap extends BcsType<any>> {
+    package?: string;
+    arguments: NewArguments<Cap> | [
+        cap: RawTransactionArgument<Cap>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Custody `cap` and create its vault-specific administrator capability. */
+export function _new<Cap extends BcsType<any>>(options: NewOptions<Cap>) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        `${options.typeArguments[0]}`
+    ] satisfies (string | null)[];
+    const parameterNames = ["cap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'new',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface ShareArguments {
+    vault: RawTransactionArgument<string>;
+}
+export interface ShareOptions {
+    package?: string;
+    arguments: ShareArguments | [
+        vault: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Share a newly-created vault. */
+export function share(options: ShareOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'share',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface DestroyArguments {
+    self: RawTransactionArgument<string>;
+    adminCap: RawTransactionArgument<string>;
+}
+export interface DestroyOptions {
+    package?: string;
+    arguments: DestroyArguments | [
+        self: RawTransactionArgument<string>,
+        adminCap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Destroy an empty vault and return the exact capability it custodied. */
+export function destroy(options: DestroyOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "adminCap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'destroy',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface AuthorizePluginArguments<Witness extends BcsType<any>> {
+    self: RawTransactionArgument<string>;
+    adminCap: RawTransactionArgument<string>;
+    _: RawTransactionArgument<Witness>;
+}
+export interface AuthorizePluginOptions<Witness extends BcsType<any>> {
+    package?: string;
+    arguments: AuthorizePluginArguments<Witness> | [
+        self: RawTransactionArgument<string>,
+        adminCap: RawTransactionArgument<string>,
+        _: RawTransactionArgument<Witness>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Authorize the package identified by its canonical `witness::Witness` type.
+ *
+ * The witness is consumed here. A plugin should construct it with a package-only
+ * `witness::new()` function.
+ */
+export function authorizePlugin<Witness extends BcsType<any>>(options: AuthorizePluginOptions<Witness>) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        null,
+        `${options.typeArguments[1]}`
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "adminCap", "_"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'authorize_plugin',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RevokePluginArguments {
+    self: RawTransactionArgument<string>;
+    adminCap: RawTransactionArgument<string>;
+}
+export interface RevokePluginOptions {
+    package?: string;
+    arguments: RevokePluginArguments | [
+        self: RawTransactionArgument<string>,
+        adminCap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Revoke a plugin authorization without requiring cooperation from the plugin. */
+export function revokePlugin(options: RevokePluginOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "adminCap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'revoke_plugin',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface BorrowAsPluginArguments<Witness extends BcsType<any>> {
+    self: RawTransactionArgument<string>;
+    _: RawTransactionArgument<Witness>;
+}
+export interface BorrowAsPluginOptions<Witness extends BcsType<any>> {
+    package?: string;
+    arguments: BorrowAsPluginArguments<Witness> | [
+        self: RawTransactionArgument<string>,
+        _: RawTransactionArgument<Witness>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Temporarily lend the full custodied capability to an authorized plugin.
+ *
+ * `Borrow` has no abilities, so the exact capability must be returned through
+ * `put_back` in this transaction.
+ */
+export function borrowAsPlugin<Witness extends BcsType<any>>(options: BorrowAsPluginOptions<Witness>) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[1]}`
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "_"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'borrow_as_plugin',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface BorrowAsAdminArguments {
+    self: RawTransactionArgument<string>;
+    adminCap: RawTransactionArgument<string>;
+}
+export interface BorrowAsAdminOptions {
+    package?: string;
+    arguments: BorrowAsAdminArguments | [
+        self: RawTransactionArgument<string>,
+        adminCap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Temporarily lend the full custodied capability to the vault administrator. */
+export function borrowAsAdmin(options: BorrowAsAdminOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "adminCap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'borrow_as_admin',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface PutBackArguments<Cap extends BcsType<any>> {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<Cap>;
+    receipt: TransactionArgument;
+}
+export interface PutBackOptions<Cap extends BcsType<any>> {
+    package?: string;
+    arguments: PutBackArguments<Cap> | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<Cap>,
+        receipt: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Return the exact capability borrowed from this vault.
+ *
+ * No additional authorization is required: `Borrow` proves the originating
+ * referent and capability object ID, and blocking return would harm liveness.
+ */
+export function putBack<Cap extends BcsType<any>>(options: PutBackOptions<Cap>) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[0]}`,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "receipt"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'put_back',
+        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/vault';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface VaultIdArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface VaultIdOptions {
+    package?: string;
+    arguments: VaultIdArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export function vaultId(options: VaultIdOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'vault_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface AuthorizedPluginsIdArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface AuthorizedPluginsIdOptions {
+    package?: string;
+    arguments: AuthorizedPluginsIdArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** The ID under which `AuthorizedPluginKey` records are dynamic fields. */
+export function authorizedPluginsId(options: AuthorizedPluginsIdOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'authorized_plugins_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface AuthorizedPluginCountArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface AuthorizedPluginCountOptions {
+    package?: string;
+    arguments: AuthorizedPluginCountArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export function authorizedPluginCount(options: AuthorizedPluginCountOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'authorized_plugin_count',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface IsPluginAuthorizedArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface IsPluginAuthorizedOptions {
+    package?: string;
+    arguments: IsPluginAuthorizedArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Returns whether this witness type has an authorization record.
+ *
+ * This deliberately does not validate the witness shape: arbitrary types simply
+ * report false, while `authorize_plugin` is the only way to add one.
+ */
+export function isPluginAuthorized(options: IsPluginAuthorizedOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'is_plugin_authorized',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}

package/src/contracts.ts

@@ -14,24 +14,32 @@ 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";
 
-// The canonical release-id derivation parent — the only PTB-callable path to
-// minting a `Release` now that core's `release::new` takes `&mut UID`.
-export * as releaseRegistry from "./contracts/release_registry/release_registry.ts";
-
-// Existing launch drops remain readable and purchasable while releases move to
-// the pressing/listing contracts.
-export * as drop from "./contracts/miso_drop/drop.ts";
-
-// Royalty-pool extension (base lib + per-work extensions).
+// Generic royalty-pool primitive plus vault-custodied business-logic plugins.
 export * as royaltyPool from "./contracts/royalty_pool/pool.ts";
 export * as royaltyPoolStake from "./contracts/royalty_pool/stake.ts";
+export * as vault from "./contracts/vault/vault.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";
+export * as routedStake from "./contracts/routed_stake/routed_stake.ts";
+export * as compositionRoutedStake from "./contracts/composition_routed_stake/composition_routed_stake.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";
 
+// Release presentation, discovery, buyer-content, and runtime economics.
+export * as genre from "./contracts/genre/genre.ts";
+export * as releaseDescription from "./contracts/release_description/release_description.ts";
+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";
+export * as releaseRevenueDistributor from "./contracts/release_revenue_distributor/release_revenue_distributor.ts";
+export * as releaseSnapshotBundle from "./contracts/release_snapshot_bundle/release_snapshot_bundle.ts";
+export * as recordingAdvisory from "./contracts/recording_advisory/recording_advisory.ts";
+export * as recordingLanguage from "./contracts/recording_language/recording_language.ts";
+export * as recordingMasterReference from "./contracts/recording_master_reference/recording_master_reference.ts";
+export * as recordingPreview from "./contracts/recording_preview/recording_preview.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";

package/src/cover.ts

@@ -18,15 +18,23 @@ 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 { asU64, directAdminCap, invokeWithAdminCap, type AdminCapAuthority, type U64Input } from "./vault.ts";
 import { OPTION_NONE, OPTION_SOME } from "./internal.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 {
+type ReleaseAuthorityInput =
+  | { readonly authority: AdminCapAuthority; readonly releaseAdminCapId?: never }
+  | { readonly authority?: never; readonly releaseAdminCapId: string };
+function releaseAuthorityOf(input: ReleaseAuthorityInput): AdminCapAuthority {
+  if (input.authority !== undefined) return input.authority;
+  if (input.releaseAdminCapId !== undefined) return directAdminCap(input.releaseAdminCapId);
+  throw new Error("release authority is required");
+}
+
+interface SetReleaseCoverParamsBase {
   /** 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. */
@@ -38,39 +46,60 @@ export interface SetReleaseCoverParams {
   /** `ori` package (home of `walrus_data::new_blob` / the `WalrusData` type). */
   oriPackageId: string;
 }
+export type SetReleaseCoverParams = SetReleaseCoverParamsBase & ReleaseAuthorityInput;
+
+export type SetReleaseTrackCoverParams = SetReleaseCoverParams & {
+  /** Zero-based index in the release's flattened tracklist. */
+  trackIndex: U64Input;
+};
+
+function buildCover(tx: Parameters<TxThunk>[0], p: SetReleaseCoverParams) {
+  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)],
+        });
+
+  return tx.add(
+    coverArt._new({
+      package: p.coverArtPackageId,
+      arguments: [still, animated],
+    }),
+  );
+}
 
 /** 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],
-      }),
-    );
+    const cover = buildCover(tx, p);
+    invokeWithAdminCap(tx, releaseAuthorityOf(p), {
+      target: `${p.releaseCoverArtPackageId}::release_cover_art::set_cover`,
+      arguments: [tx.object(p.releaseId), cover],
+      adminCapIndex: 1,
+    });
+  };
+}
+
+/** Sets (or replaces) one track's cover from Walrus blob ids. */
+export function setReleaseTrackCover(p: SetReleaseTrackCoverParams): TxThunk {
+  return (tx) => {
+    const cover = buildCover(tx, p);
+    invokeWithAdminCap(tx, releaseAuthorityOf(p), {
+      target: `${p.releaseCoverArtPackageId}::release_cover_art::set_track_cover`,
+      arguments: [tx.object(p.releaseId), tx.pure.u64(asU64("trackIndex", p.trackIndex)), cover],
+      adminCapIndex: 1,
+    });
   };
 }
 
@@ -142,11 +171,7 @@ export async function getReleaseCover(
 ): Promise<ReleaseCoverView | null> {
   return (
     (
-      await getReleaseCoversByIds(
-        client,
-        [releaseId],
-        releaseCoverArtPackageId,
-      )
+      await getReleaseCoversByIds(client, [releaseId], releaseCoverArtPackageId)
     )[releaseId] ?? null
   );
 }