@misofm/sdk 0.11.0 → 0.12.1

package/src/contracts/party_wallet/party_wallet.ts

@@ -0,0 +1,350 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Vault-authorized withdrawals from a Party's object inbox and funds accumulator.
+ *
+ * Anyone may address objects or funds to a Party ID. This plugin is the bounded
+ * withdrawal door: it temporarily leases the matching `PartyAdminCap`, uses it
+ * only to reach that Party's UID, returns it to the Vault, and then transfers the
+ * withdrawn object or coin to the recipient selected by the Vault administrator.
+ *
+ * Installation alone never makes withdrawals permissionless. Every production
+ * withdrawal is an `entry fun` requiring the matching `VaultAdminCap`, and no
+ * endpoint returns the leased capability, its borrow receipt, or a privileged
+ * reference. The Party itself stores no plugin data.
+ */
+
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/party_wallet::party_wallet';
+export const ObjectReceivedEvent = new MoveStruct({ name: `${$moduleName}::ObjectReceivedEvent`, fields: {
+        party_id: bcs.Address,
+        object_id: bcs.Address
+    } });
+export const CoinsReceivedEvent = new MoveStruct({ name: `${$moduleName}::CoinsReceivedEvent<phantom Currency>`, fields: {
+        party_id: bcs.Address,
+        amount: bcs.u64(),
+        coins: bcs.u64()
+    } });
+export const FundsRedeemedEvent = new MoveStruct({ name: `${$moduleName}::FundsRedeemedEvent<phantom Currency>`, fields: {
+        party_id: bcs.Address,
+        amount: bcs.u64()
+    } });
+export interface InstallArguments {
+    vault: RawTransactionArgument<string>;
+    vaultAdminCap: RawTransactionArgument<string>;
+}
+export interface InstallOptions {
+    package?: string;
+    arguments: InstallArguments | [
+        vault: RawTransactionArgument<string>,
+        vaultAdminCap: RawTransactionArgument<string>
+    ];
+}
+/** Authorize this package on a Party capability Vault. */
+export function install(options: InstallOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_wallet';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault", "vaultAdminCap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_wallet',
+        function: 'install',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface UninstallArguments {
+    vault: RawTransactionArgument<string>;
+    vaultAdminCap: RawTransactionArgument<string>;
+}
+export interface UninstallOptions {
+    package?: string;
+    arguments: UninstallArguments | [
+        vault: RawTransactionArgument<string>,
+        vaultAdminCap: RawTransactionArgument<string>
+    ];
+}
+/** Revoke this package from a Party capability Vault. */
+export function uninstall(options: UninstallOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_wallet';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault", "vaultAdminCap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_wallet',
+        function: 'uninstall',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface ReceiveObjectArguments {
+    vault: RawTransactionArgument<string>;
+    party: RawTransactionArgument<string>;
+    vaultAdminCap: RawTransactionArgument<string>;
+    objectToReceive: TransactionArgument;
+    recipient: RawTransactionArgument<string>;
+}
+export interface ReceiveObjectOptions {
+    package?: string;
+    arguments: ReceiveObjectArguments | [
+        vault: RawTransactionArgument<string>,
+        party: RawTransactionArgument<string>,
+        vaultAdminCap: RawTransactionArgument<string>,
+        objectToReceive: TransactionArgument,
+        recipient: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Receive one `key + store` object addressed to the Party and transfer it to
+ * `recipient`.
+ *
+ * Aborts if the Vault administrator is wrong, the plugin is not installed, the
+ * Vault contains another Party's cap, or the receiving ticket is invalid for the
+ * supplied Party.
+ */
+export function receiveObject(options: ReceiveObjectOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_wallet';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        'address'
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault", "party", "vaultAdminCap", "objectToReceive", "recipient"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_wallet',
+        function: 'receive_object',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface ReceiveObjectsArguments {
+    vault: RawTransactionArgument<string>;
+    party: RawTransactionArgument<string>;
+    vaultAdminCap: RawTransactionArgument<string>;
+    objectsToReceive: TransactionArgument;
+    recipient: RawTransactionArgument<string>;
+}
+export interface ReceiveObjectsOptions {
+    package?: string;
+    arguments: ReceiveObjectsArguments | [
+        vault: RawTransactionArgument<string>,
+        party: RawTransactionArgument<string>,
+        vaultAdminCap: RawTransactionArgument<string>,
+        objectsToReceive: TransactionArgument,
+        recipient: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Receive several `key + store` objects of one type and transfer each to
+ * `recipient` in input order.
+ *
+ * Aborts with `ENothingToReceive` if `objects_to_receive` is empty. It also aborts
+ * under the authorization and receiving conditions documented by `receive_object`.
+ */
+export function receiveObjects(options: ReceiveObjectsOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_wallet';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'vector<null>',
+        'address'
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault", "party", "vaultAdminCap", "objectsToReceive", "recipient"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_wallet',
+        function: 'receive_objects',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface ReceiveCoinsArguments {
+    vault: RawTransactionArgument<string>;
+    party: RawTransactionArgument<string>;
+    vaultAdminCap: RawTransactionArgument<string>;
+    coins: TransactionArgument;
+    recipient: RawTransactionArgument<string>;
+}
+export interface ReceiveCoinsOptions {
+    package?: string;
+    arguments: ReceiveCoinsArguments | [
+        vault: RawTransactionArgument<string>,
+        party: RawTransactionArgument<string>,
+        vaultAdminCap: RawTransactionArgument<string>,
+        coins: TransactionArgument,
+        recipient: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Receive coin objects of one currency, merge them, and transfer the resulting
+ * Coin to `recipient`.
+ *
+ * Aborts with `ENothingToReceive` if `coins` is empty. It also aborts if the Vault
+ * administrator, plugin installation, Party capability, or a receiving ticket is
+ * invalid.
+ */
+export function receiveCoins(options: ReceiveCoinsOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_wallet';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'vector<null>',
+        'address'
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault", "party", "vaultAdminCap", "coins", "recipient"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_wallet',
+        function: 'receive_coins',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RedeemCoinArguments {
+    vault: RawTransactionArgument<string>;
+    party: RawTransactionArgument<string>;
+    vaultAdminCap: RawTransactionArgument<string>;
+    value: RawTransactionArgument<number | bigint>;
+    recipient: RawTransactionArgument<string>;
+}
+export interface RedeemCoinOptions {
+    package?: string;
+    arguments: RedeemCoinArguments | [
+        vault: RawTransactionArgument<string>,
+        party: RawTransactionArgument<string>,
+        vaultAdminCap: RawTransactionArgument<string>,
+        value: RawTransactionArgument<number | bigint>,
+        recipient: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Redeem `value` from the Party's accumulator balance, create a Coin, and transfer
+ * it to `recipient`.
+ *
+ * Aborts if the Vault administrator is wrong, the plugin is not installed, the
+ * Vault contains another Party's cap, `value` is zero, or the accumulator cannot
+ * cover the requested amount.
+ */
+export function redeemCoin(options: RedeemCoinOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_wallet';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'u64',
+        'address'
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault", "party", "vaultAdminCap", "value", "recipient"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_wallet',
+        function: 'redeem_coin',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface IsInstalledArguments {
+    vault: RawTransactionArgument<string>;
+}
+export interface IsInstalledOptions {
+    package?: string;
+    arguments: IsInstalledArguments | [
+        vault: RawTransactionArgument<string>
+    ];
+}
+/** Return whether this plugin is installed on `vault`. */
+export function isInstalled(options: IsInstalledOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_wallet';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_wallet',
+        function: 'is_installed',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface InboxAddressArguments {
+    party: RawTransactionArgument<string>;
+}
+export interface InboxAddressOptions {
+    package?: string;
+    arguments: InboxAddressArguments | [
+        party: RawTransactionArgument<string>
+    ];
+}
+/** Return the Party ID as the address to which objects or funds may be sent. */
+export function inboxAddress(options: InboxAddressOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_wallet';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["party"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_wallet',
+        function: 'inbox_address',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface SettledFundsArguments {
+    root: RawTransactionArgument<string>;
+    party: RawTransactionArgument<string>;
+}
+export interface SettledFundsOptions {
+    package?: string;
+    arguments: SettledFundsArguments | [
+        root: RawTransactionArgument<string>,
+        party: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Return the Party's accumulator balance settled at the start of the current
+ * consensus commit.
+ */
+export function settledFunds(options: SettledFundsOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_wallet';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["root", "party"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_wallet',
+        function: 'settled_funds',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}

package/src/contracts/party_wallet/witness.ts

@@ -0,0 +1,7 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveTuple } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = '@local-pkg/party_wallet::witness';
+export const Witness = new MoveTuple({ name: `${$moduleName}::Witness`, fields: [bcs.bool()] });

package/src/contracts/routed_stake/routed_stake.ts

@@ -332,33 +332,6 @@ export function sweep(options: SweepOptions) {
         typeArguments: options.typeArguments
     });
 }
-export interface IdArguments {
-    self: RawTransactionArgument<string>;
-}
-export interface IdOptions {
-    package?: string;
-    arguments: IdArguments | [
-        self: RawTransactionArgument<string>
-    ];
-    typeArguments: [
-        string,
-        string
-    ];
-}
-export function id(options: IdOptions) {
-    const packageAddress = options.package ?? '@local-pkg/routed_stake';
-    const argumentsTypes = [
-        null
-    ] satisfies (string | null)[];
-    const parameterNames = ["self"];
-    return (tx: Transaction) => tx.moveCall({
-        package: packageAddress,
-        module: 'routed_stake',
-        function: 'id',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-        typeArguments: options.typeArguments
-    });
-}
 export interface HasStakeArguments {
     self: RawTransactionArgument<string>;
 }

package/src/contracts/royalty_pool/pool.ts

@@ -412,33 +412,6 @@ export function pendingRewards(options: PendingRewardsOptions) {
         typeArguments: options.typeArguments
     });
 }
-export interface IdArguments {
-    self: RawTransactionArgument<string>;
-}
-export interface IdOptions {
-    package?: string;
-    arguments: IdArguments | [
-        self: RawTransactionArgument<string>
-    ];
-    typeArguments: [
-        string,
-        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: 'pool',
-        function: 'id',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-        typeArguments: options.typeArguments
-    });
-}
 export interface BalanceArguments {
     self: RawTransactionArgument<string>;
 }

package/src/contracts/royalty_pool/stake.ts

@@ -5,16 +5,22 @@
 
 /**
  * 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.
+ *
+ * Custody warning: `pool::claim_rewards` pays accrued rewards to the _caller_, and
+ * `Stake` is `key + store` — a bare shared stake (or one wrapped in a shared
+ * object that hands out `&mut`) is drainable by anyone. Stakes must stay
+ * address-owned, or wrapped by a contract that pins the reward route (e.g.
+ * `routed_stake`); the pool cannot enforce this itself.
  */
 
 import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
@@ -108,32 +114,6 @@ export function destroy(options: DestroyOptions) {
         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>;
 }

package/src/contracts/vault/vault.ts

@@ -229,7 +229,8 @@ export interface BorrowAsPluginOptions<Witness extends BcsType<any>> {
  * 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.
+ * `put_back` in this transaction. Aborts if the supplied type is not the exact
+ * non-generic `0xpkg::witness::Witness` shape or is not authorized on this Vault.
  */
 export function borrowAsPlugin<Witness extends BcsType<any>>(options: BorrowAsPluginOptions<Witness>) {
     const packageAddress = options.package ?? '@local-pkg/vault';
@@ -314,32 +315,6 @@ export function putBack<Cap extends BcsType<any>>(options: PutBackOptions<Cap>)
         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>;
 }

package/src/contracts.ts

@@ -20,6 +20,7 @@ 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 partyWallet from "./contracts/party_wallet/party_wallet.ts";
 export * as routedStake from "./contracts/routed_stake/routed_stake.ts";
 export * as compositionRoutedStake from "./contracts/composition_routed_stake/composition_routed_stake.ts";
 

package/src/cover.ts

@@ -162,7 +162,7 @@ function toCoverImageRef(wd: ParsedWalrusData): CoverImageRef {
  * 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.
+ * animation) as normalized Walrus refs for release displays.
  */
 export async function getReleaseCover(
   client: ClientWithCoreApi,

package/src/deployments.ts

@@ -2,14 +2,19 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type {
+  MisoDeployment,
   MisoNetwork,
-  MisoProtocolDeployment,
 } from "@misonetwork/sdk/deployments";
+import { MISO_DEPLOYMENTS } from "@misonetwork/sdk/deployments";
 
 /** Complete on-chain identity used by the Miso platform SDK on one network. */
 export interface MisoPlatformDeployment {
-  /** The protocol deployment this platform deployment was built against. */
-  readonly protocol: MisoProtocolDeployment;
+  /** Network name this immutable deployment set belongs to. */
+  readonly network: MisoNetwork;
+  /** Full ledger genesis digest used to reject a mislabeled RPC endpoint. */
+  readonly chainIdentifier: string;
+  /** The complete protocol and Party deployment this platform build targets. */
+  readonly protocol: MisoDeployment;
   readonly packages: {
     readonly pressing: string;
     readonly record: string;
@@ -26,6 +31,8 @@ export interface MisoPlatformDeployment {
     readonly compositionRoyaltyPoolPlugin: string;
     /** Vault plugin that creates and cranks Recording royalty pools. */
     readonly recordingRoyaltyPoolPlugin: string;
+    /** Vault plugin that manages a Party's royalty-bearing wallet. */
+    readonly partyWalletPlugin: string;
     /** Generic stake wrapper used by the composition routed-stake plugin. */
     readonly routedStake: string;
     /** Vault plugin for Composition-owned Recording-share staking. */
@@ -49,29 +56,10 @@ export interface MisoPlatformDeployment {
     readonly ori: string;
   };
   readonly objects: {
-    readonly recordSettings: string;
     readonly releaseRegistry: string;
     /** Shared parent used to derive canonical Genre object ids. */
     readonly genreRegistry: string;
   };
-  /** PartyOS packages used by the composed artist and wallet reads. */
-  readonly party: {
-    readonly partyPackageId: string;
-    readonly partyProfilePackageId: string;
-    readonly countryCodePackageId: string;
-    readonly languageCodePackageId: string;
-    readonly partyMediaPackageId: string;
-    readonly partyRolesPackageId: string;
-    readonly partyTagsPackageId: string;
-    readonly partyGenrePackageId: string;
-    readonly partyCtaPackageId: string;
-    readonly partyPlatformLinkPackageId: string;
-    readonly partySocialPackageId: string;
-    readonly partyMusicPackageId: string;
-    readonly partyProLinkPackageId: string;
-    readonly partyFeaturedDropPackageId: string;
-    readonly genrePackageId: string;
-  };
   readonly legacy: {
     readonly releaseCoverArtPackages: readonly string[];
   };
@@ -80,12 +68,52 @@ export interface MisoPlatformDeployment {
 /**
  * Platform deployments bundled with this SDK release.
  *
- * This release deliberately contains no bundled network deployment. The core
- * protocol is being republished as an immutable stack, so every old package ID
- * is an incompatible ABI and must not be selected by accident. The admin-cli
- * deployment flow injects verified IDs in a follow-up change.
+ * IDs come only from the verified output of the Ledger-backed deployment run.
+ * Consumers may still pass an explicit complete deployment for custom networks.
  */
-export const MISO_PLATFORM_DEPLOYMENTS = {} as const satisfies Partial<
+export const MISO_PLATFORM_DEPLOYMENTS = {
+  testnet: {
+    network: "testnet",
+    chainIdentifier: "69WiPg3DAQiwdxfncX6wYQ2siKwAe6L9BZthQea3JNMD",
+    protocol: MISO_DEPLOYMENTS.testnet,
+    packages: {
+      pressing: "0x95fba53c968978f75d6ca8a5e6f0f3ba83fdc3af301bc8419be354a3990af5b9",
+      record: "0x6150c474200f63bf73072642564886e5ecb1a4c0498ede31acd7908d94dbc83b",
+      minato: "0x8466e9864c1d947888e73b0e349b035bc22805579eef18f132966f56c8efe1d2",
+      credit: "0x20d8e38f49445cbae45fd66c262c2cbc4bf4cccab487b3fb443a491dc24071cd",
+      compositionCredits: "0x8b376967e9c32169727ec5341890f28c66d8577d7bfcecb83aa78aec3e84dce5",
+      recordingCredits: "0x7096a47b0ba12063c037d6d417bffade758665a3f313574c8ba218823cfb159a",
+      releaseCredits: "0xbe293700ef758c95b69838df6cfa8377b9cad1dd59cbf933974f68b1766d87b5",
+      royaltyPool: "0xbeddbcfc2c42ed1bcaa74dc241957621b48241451e10af136c20cdc7df8266b8",
+      vault: "0x7075ce4bfc2c738e774c94f1eeb7dc532a5f11ead9b4e3815d90dc16053eae9c",
+      compositionRoyaltyPoolPlugin: "0x8d61aecceb597441a0d675b44291706742859c8ff7755b3ed143823daa430c50",
+      recordingRoyaltyPoolPlugin: "0x6de70d4e87a328259f00f354227fb329c63fbf50efb87f057c5da26d6908e1d1",
+      partyWalletPlugin: "0xccf17215193d1ae64a47480c83df9af2881ffdb75e5ac842ab3898cadd9eeca0",
+      routedStake: "0x7a55b1841043efea865d65a6601e057400a79a0aa7bb11e781a25dbe622cbe5f",
+      compositionRoutedStakePlugin: "0x54fb4befa1be03f7457abfddcfb9334c20a8df3e01c44aa257f1c3d718cd57ee",
+      coverArt: "0x2dae28058b89df93224bacfb9af42fd3ab41f001c2c815fd57fd575024d9a50b",
+      releaseCoverArt: "0x649b18f2bb3d94f6a611a8e4ad3a29dcf8b7bba3f684056d60897a8a5e835106",
+      genre: "0x978d5f67a4fdc3eb688ed3aeb23c6c3c37ae44e358fb709001e6ab21e6f19f34",
+      releaseDescription: "0x3e26e4c4c5b3f51070d6d7bb1527eaa304f34ae5dfde078661e180e7594d6d28",
+      releaseDspLink: "0xd9f9e7240c397a82e4af1ecb9ec75b29a91ef4084127eabcf22fbf24e72cab2f",
+      releaseGenre: "0xc1012f9768f178ca908ef4a6cfd150ad33baaa3587dc2154ea9852858243cd57",
+      releaseKind: "0x3e74c960d9446ae2ebf228456ddc1b099d2090501c9cbcd284a999aa2e774e12",
+      releaseRevenueDistributorPlugin: "0x42a22b24129988a5ce8069a1f78eb31d9aa5edf360d729ae3c2c0b8ed18876e1",
+      recordingAdvisory: "0x28e0e72c5b892fc888a9007afa59ebe04ed8e47f12632ddb42cd685d09c4af2e",
+      recordingLanguage: "0x4b284a9435cf4f48e3785e4485d16be2fcbcef5beaa2b44b6556d9c1028e2c0d",
+      recordingMasterReference: "0x2b06ab58f2d5a915b42fc5879d52241fc72e804b3da782fa752b2d2f242170c0",
+      recordingPreview: "0x449aafe29707adf249df7e90355ecb19d939ea77d9e19fd3e2fdb220e73e74f0",
+      ori: "0x340057f2174fb59e4626742dd2b46c662237837b6187450cb59e4976ce7eac78",
+    },
+    objects: {
+      releaseRegistry: "0xf5941ae9640f6f24b75e921da16c95fd23d776b9e6518c275a50a5ce6337c8ba",
+      genreRegistry: "0xad34d6b717b8c59ed9ac47a520feab31324f0c04d70fd31922be45d8209fce1c",
+    },
+    legacy: {
+      releaseCoverArtPackages: [],
+    },
+  },
+} as const satisfies Partial<
   Record<MisoNetwork, MisoPlatformDeployment>
 >;
 

package/src/pressing.ts

@@ -365,9 +365,6 @@ export interface BuyRecordParams {
   amount: U64Input;
   /** The listing's `Currency` type, e.g. `0x2::sui::SUI`. */
   currencyType: string;
-  /** The `miso_record` `Settings` shared object — it must authorize `miso_pressing`'s
-   *  `MintWitness`, or the mint aborts. */
-  settingsId: string;
   /** Where to send the pressed `Record` (usually the buyer). */
   recipient: string;
   misoPressingPackageId: string;
@@ -412,7 +409,7 @@ export function buyRecord(p: BuyRecordParams): TxThunk {
     const record = tx.add(
       listing.buy({
         package: pkg,
-        arguments: [listingId, pressingId, payment, p.settingsId],
+        arguments: [listingId, pressingId, payment],
         typeArguments: [p.currencyType],
       }),
     );