@misonetwork/sdk 0.7.0 → 0.8.0

package/src/client.ts

@@ -8,9 +8,15 @@ import type {
 import type { SuiGraphQLClient } from "@mysten/sui/graphql";
 import {
   getMisoProtocolDeployment,
+  normalizeMisoDeployment,
+  normalizeMisoProtocolDeployment,
+  protocolDeployment,
+  type MisoDeployment,
   type MisoProtocolDeployment,
 } from "./deployments.ts";
+import { bindModulePackage, MisoPackageBindings, REF_RETURNING_CALLS } from "./packages.ts";
 import * as parsers from "./parsers.ts";
+import { eventParsers } from "./events.ts";
 import * as queries from "./queries.ts";
 import * as view from "./view.ts";
 import type {
@@ -32,10 +38,10 @@ export interface MisoOptions<Name extends string = "miso"> {
   /** Name for the client extension. Defaults to "miso". */
   name?: Name;
   /**
-   * Complete custom deployment. Omit for bundled Mainnet/Testnet addresses,
-   * selected from the Sui client's `network`.
+   * Explicit core-only deployment or complete package manifest. Omit only after
+   * this SDK has a verified bundled manifest for the client's network.
    */
-  deployment?: MisoProtocolDeployment;
+  deployment?: MisoProtocolDeployment | MisoDeployment;
   /** @deprecated Use `deployment`. Retained for compatibility with pre-0.4 callers. */
   misoPackageId?: string;
   /**
@@ -47,17 +53,10 @@ export interface MisoOptions<Name extends string = "miso"> {
   graphqlClient?: SuiGraphQLClient;
 }
 
-/** Defaults `options.package` to `pkg` for every call-function in a generated module. */
-function bindModulePackage<M extends object>(mod: M, pkg: string): M {
-  const out: Record<string, unknown> = {};
-  for (const [key, value] of Object.entries({ ...mod })) {
-    out[key] =
-      typeof value === "function"
-        ? (options: { package?: string }) =>
-            (value as (o: unknown) => unknown)({ package: pkg, ...options })
-        : value;
-  }
-  return out as M;
+function isFullDeployment(
+  deployment: MisoProtocolDeployment | MisoDeployment,
+): deployment is MisoDeployment {
+  return "miso" in deployment;
 }
 
 /**
@@ -77,13 +76,21 @@ export function miso<const Name extends string = "miso">(
   return {
     name,
     register: (client) => {
-      const deployment =
-        options.deployment ??
-        (options.misoPackageId
-          ? { packageId: options.misoPackageId }
-          : getMisoProtocolDeployment(client.network));
+      const supplied = options.deployment;
+      const packageDeployment =
+        supplied && isFullDeployment(supplied)
+          ? normalizeMisoDeployment(supplied)
+          : undefined;
+      const deployment = supplied
+        ? isFullDeployment(supplied)
+          ? protocolDeployment(packageDeployment!)
+          : normalizeMisoProtocolDeployment(supplied)
+        : options.misoPackageId
+          ? normalizeMisoProtocolDeployment({ packageId: options.misoPackageId })
+          : getMisoProtocolDeployment(client.network);
       return new MisoProtocolClient(client, {
         deployment,
+        packageDeployment,
         graphqlClient: options.graphqlClient,
       });
     },
@@ -92,6 +99,7 @@ export function miso<const Name extends string = "miso">(
 
 export interface MisoProtocolClientOptions {
   deployment: MisoProtocolDeployment;
+  packageDeployment?: MisoDeployment;
   graphqlClient?: SuiGraphQLClient;
 }
 
@@ -99,11 +107,15 @@ export class MisoProtocolClient {
   #client: ClientWithCoreApi;
   #graphqlClient?: SuiGraphQLClient;
   #deployment: MisoProtocolDeployment;
+  #packageDeployment?: MisoDeployment;
 
   constructor(client: ClientWithCoreApi, options: MisoProtocolClientOptions) {
     this.#client = client;
     this.#graphqlClient = options.graphqlClient;
-    this.#deployment = options.deployment;
+    this.#deployment = normalizeMisoProtocolDeployment(options.deployment);
+    this.#packageDeployment = options.packageDeployment
+      ? normalizeMisoDeployment(options.packageDeployment)
+      : undefined;
   }
 
   /** The exact deployment selected for this client. */
@@ -111,6 +123,20 @@ export class MisoProtocolClient {
     return this.#deployment;
   }
 
+  /**
+   * Complete package-bound calls and BCS codecs, available only when `miso()`
+   * was given a full fresh deployment manifest.
+   */
+  get packages(): MisoPackageBindings {
+    if (!this.#packageDeployment) {
+      throw new Error(
+        "@misonetwork/sdk: full package bindings require a complete MisoDeployment. " +
+          "Pass the verified post-publish manifest to miso({ deployment }).",
+      );
+    }
+    return new MisoPackageBindings(this.#packageDeployment);
+  }
+
   get #misoPackageId(): string {
     return this.#deployment.packageId;
   }
@@ -211,6 +237,10 @@ export class MisoProtocolClient {
   async getReleaseById(releaseId: string): Promise<Release> {
     return queries.getReleaseById(this.#client, releaseId);
   }
+  /** Read the shared canonical core `miso::release::ReleaseRegistry`. */
+  async getReleaseRegistryById(registryId: string) {
+    return queries.getReleaseRegistryById(this.#client, registryId);
+  }
   async getReleasesByIds(ids: string[]): Promise<Record<string, Release>> {
     return queries.getReleasesByIds(this.#client, ids);
   }
@@ -260,9 +290,9 @@ export class MisoProtocolClient {
   get call() {
     const pkg = this.#misoPackageId;
     return {
-      composition: bindModulePackage(composition, pkg),
-      recording: bindModulePackage(recording, pkg),
-      release: bindModulePackage(release, pkg),
+      composition: bindModulePackage(composition, pkg, REF_RETURNING_CALLS.composition),
+      recording: bindModulePackage(recording, pkg, REF_RETURNING_CALLS.recording),
+      release: bindModulePackage(release, pkg, REF_RETURNING_CALLS.release),
       track: bindModulePackage(track, pkg),
     };
   }
@@ -287,7 +317,11 @@ export class MisoProtocolClient {
     return {
       compositionPublishedEvent: parsers.parseCompositionPublishedEvent,
       recordingPublishedEvent: parsers.parseRecordingPublishedEvent,
+      compositionSharesGrantedEvent:
+        parsers.parseCompositionSharesGrantedEvent,
       releasePublishedEvent: parsers.parseReleasePublishedEvent,
+      releaseRegistryCreatedEvent: parsers.parseReleaseRegistryCreatedEvent,
+      events: eventParsers,
     };
   }
 

package/src/contracts/composition_credits/composition_credits.ts

@@ -0,0 +1,169 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * First-party credits extension for compositions.
+ *
+ * Attribution (writing credits) is display-oriented and varies across platforms,
+ * so it lives here as a dynamic field on the composition rather than in immutable
+ * core. The data is attached under `ExtensionKey()` via the composition's
+ * cap-gated `uid_mut`, so every mutation is authorized by the composition's admin
+ * and credits survive into any lifecycle state (they may be attached before or
+ * after the composition is published).
+ *
+ * This is Miso's canonical credits standard; because it is an extension, other
+ * parties may publish their own composition-credits standard against the same
+ * `Composition`. Credits are NOT read by the economics — they are attribution.
+ */
+
+import { MoveTuple, 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 vec_map from './deps/sui/vec_map.ts';
+import * as credit from './deps/miso_credit/credit.ts';
+import * as composition_party_role from './composition_party_role.ts';
+const $moduleName = '@local-pkg/composition_credits::composition_credits';
+export const ExtensionKey = new MoveTuple({ name: `${$moduleName}::ExtensionKey`, fields: [bcs.bool()] });
+export const CompositionCredits = new MoveStruct({ name: `${$moduleName}::CompositionCredits`, fields: {
+        /** Map of party IDs to their credit (display name + roles). */
+        credits: vec_map.VecMap(bcs.Address, credit.Credit(composition_party_role.CompositionPartyRole))
+    } });
+export const CreditAddedEvent = new MoveStruct({ name: `${$moduleName}::CreditAddedEvent`, fields: {
+        composition_id: bcs.Address,
+        party_id: bcs.Address,
+        credit: credit.Credit(composition_party_role.CompositionPartyRole)
+    } });
+export const CreditRemovedEvent = new MoveStruct({ name: `${$moduleName}::CreditRemovedEvent`, fields: {
+        composition_id: bcs.Address,
+        party_id: bcs.Address,
+        credit: credit.Credit(composition_party_role.CompositionPartyRole)
+    } });
+export interface AddCreditArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    party: RawTransactionArgument<string>;
+    credit: TransactionArgument;
+}
+export interface AddCreditOptions {
+    package?: string;
+    arguments: AddCreditArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        party: RawTransactionArgument<string>,
+        credit: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Adds a credit for a party on the composition, lazily creating the credits record
+ * on first use. Each credit must have 1-5 roles, and a party may hold at most one
+ * credit. Requires the composition's admin capability.
+ */
+export function addCredit(options: AddCreditOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "party", "credit"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_credits',
+        function: 'add_credit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RemoveCreditArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    partyId: RawTransactionArgument<string>;
+}
+export interface RemoveCreditOptions {
+    package?: string;
+    arguments: RemoveCreditArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        partyId: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Removes a party's credit. Requires the composition's admin capability. */
+export function removeCredit(options: RemoveCreditOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "partyId"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_credits',
+        function: 'remove_credit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface HasCreditsArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface HasCreditsOptions {
+    package?: string;
+    arguments: HasCreditsArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Returns whether a credits record has been attached to this composition yet. */
+export function hasCredits(options: HasCreditsOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_credits',
+        function: 'has_credits',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface CreditsArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface CreditsOptions {
+    package?: string;
+    arguments: CreditsArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Returns the party-to-credit map. Aborts if no credits are attached. */
+export function credits(options: CreditsOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_credits',
+        function: 'credits',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}

package/src/contracts/composition_credits/composition_party_role.ts

@@ -0,0 +1,189 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Defines the roles that parties can hold on a composition. Compositions are the
+ * underlying musical works (melody + lyrics), and these roles represent the
+ * writing and adaptation contributions to them.
+ *
+ * ### Design
+ *
+ * `CompositionPartyRole` is a closed enum: variants can only be constructed and
+ * matched inside this module, so the `new_*_role` constructors are the external
+ * write-API and `name()` is the external read-API.
+ *
+ * - **No seniority axis.** Unlike recording roles, composition roles carry no
+ *   level — a writer either contributed in a given capacity or did not.
+ * - **`Custom` is the escape hatch.** The canonical variants cover the common
+ *   writing vocabulary; anything outside it is a `Custom(name)` whose name is
+ *   validated. Prefer a canonical variant when one fits.
+ * - **`name()` is the canonical identifier**, returned as a stable PascalCase
+ *   token (e.g. `"Songwriter"`). For `Custom`, `name()` returns the user-supplied
+ *   string.
+ *
+ * These identifiers are Miso's own canonical vocabulary; any overlap with an
+ * external standard (e.g. DDEX) is coincidental, not a reproduction of it.
+ */
+
+import { MoveEnum, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/composition_credits::composition_party_role';
+/** Represents a party's role on a composition. */
+export const CompositionPartyRole = new MoveEnum({ name: `${$moduleName}::CompositionPartyRole`, fields: {
+        /** Adapted an existing work into this composition. */
+        Adapter: null,
+        /** Arranged the musical parts of the composition. */
+        Arranger: null,
+        /** Composed the music of the composition. */
+        Composer: null,
+        /** Wrote the lyrics of the composition. */
+        Lyricist: null,
+        /** Wrote both music and lyrics of the composition. */
+        Songwriter: null,
+        /** Translated the lyrics of the composition. */
+        Translator: null,
+        /**
+         * A user-defined role not covered by a canonical variant. Carries the role name
+         * (validated). An escape hatch — prefer a canonical variant when one fits.
+         */
+        Custom: bcs.string()
+    } });
+export interface NewAdapterRoleOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Creates a new Adapter role. */
+export function newAdapterRole(options: NewAdapterRoleOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'new_adapter_role',
+    });
+}
+export interface NewArrangerRoleOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Creates a new Arranger role. */
+export function newArrangerRole(options: NewArrangerRoleOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'new_arranger_role',
+    });
+}
+export interface NewComposerRoleOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Creates a new Composer role. */
+export function newComposerRole(options: NewComposerRoleOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'new_composer_role',
+    });
+}
+export interface NewLyricistRoleOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Creates a new Lyricist role. */
+export function newLyricistRole(options: NewLyricistRoleOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'new_lyricist_role',
+    });
+}
+export interface NewSongwriterRoleOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Creates a new Songwriter role. */
+export function newSongwriterRole(options: NewSongwriterRoleOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'new_songwriter_role',
+    });
+}
+export interface NewTranslatorRoleOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Creates a new Translator role. */
+export function newTranslatorRole(options: NewTranslatorRoleOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'new_translator_role',
+    });
+}
+export interface NewCustomRoleArguments {
+    roleName: RawTransactionArgument<string>;
+}
+export interface NewCustomRoleOptions {
+    package?: string;
+    arguments: NewCustomRoleArguments | [
+        roleName: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Creates a new Custom role with a user-defined name. The name freezes into
+ * credits, so it is validated here. Prefer a canonical variant when one fits.
+ */
+export function newCustomRole(options: NewCustomRoleOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    const argumentsTypes = [
+        '0x1::string::String'
+    ] satisfies (string | null)[];
+    const parameterNames = ["roleName"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'new_custom_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface NameArguments {
+    self: TransactionArgument;
+}
+export interface NameOptions {
+    package?: string;
+    arguments: NameArguments | [
+        self: TransactionArgument
+    ];
+}
+/**
+ * Returns the canonical identifier of the role as a stable PascalCase token. For
+ * `Custom`, returns the user-supplied name.
+ */
+export function name(options: NameOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'name',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/src/contracts/composition_credits/deps/miso_credit/credit.ts

@@ -0,0 +1,27 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Represents a party's credit on a work or activity. A credit pairs a display name
+ * with one or more roles, identifying how a party contributed to the work.
+ */
+
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.ts';
+const $moduleName = 'miso_credit::credit';
+/**
+ * A credit attributing roles to a party on a work. Generic over the role type to
+ * support domain-specific roles.
+ */
+export function Credit<Role extends BcsType<any>>(...typeParameters: [
+    Role
+]) {
+    return new MoveStruct({ name: `${$moduleName}::Credit<${typeParameters[0].name as Role['name']}>`, fields: {
+            /** Human-readable name to display for this credit. */
+            display_name: bcs.string(),
+            /** Roles assigned to the credited party. */
+            roles: bcs.vector(typeParameters[0])
+        } });
+}

package/src/contracts/composition_credits/deps/sui/vec_map.ts

@@ -0,0 +1,33 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.ts';
+const $moduleName = '0x2::vec_map';
+/** An entry in the map */
+export function Entry<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]) {
+    return new MoveStruct({ name: `${$moduleName}::Entry<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`, fields: {
+            key: typeParameters[0],
+            value: typeParameters[1]
+        } });
+}
+/**
+ * A map data structure backed by a vector. The map is guaranteed not to contain
+ * duplicate keys, but entries are _not_ sorted by key--entries are included in
+ * insertion order. All operations are O(N) in the size of the map--the intention
+ * of this data structure is only to provide the convenience of programming against
+ * a map API. Large maps should use handwritten parent/child relationships instead.
+ * Maps that need sorted iteration rather than insertion order iteration should
+ * also be handwritten.
+ */
+export function VecMap<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]) {
+    return new MoveStruct({ name: `${$moduleName}::VecMap<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`, fields: {
+            contents: bcs.vector(Entry(typeParameters[0], typeParameters[1]))
+        } });
+}

package/src/contracts/miso/composition.ts

@@ -7,28 +7,28 @@
  * Represents a musical composition (song, instrumental work) in Miso. Compositions
  * are the underlying written works that recordings are based on. Each composition
  * has its own share token for ownership distribution.
- * 
+ *
  * ### Key Features:
- * 
+ *
  * - Share token initialization with fixed supply (10M tokens, 6 decimals)
  * - State machine: Initialized -> Published (embedded fields immutable after
  *   publish; dynamic fields remain extensible via `uid_mut`)
  * - Deterministic addresses via derived object pattern
- * 
+ *
  * Attribution (credits) is intentionally NOT part of core: it is display-oriented,
  * varies across platforms, and is never read by the economics. It lives in a
  * first-party credits extension attached via `uid_mut`, so core takes no
  * dependency on an identity package and core publish enforces no attribution.
- * 
+ *
  * ### Lifecycle and trust model
- * 
+ *
  * A composition is `key`-only with no `drop`: a fresh `Initialized` object cannot
  * be transferred, wrapped, publicly shared, or discarded, and its only by-value
  * consumer is `publish`. Create-and-publish is therefore atomic by construction —
  * an `Initialized` composition cannot outlive its creating transaction, and every
  * composition that exists on-chain is `Published` and shared. There is
  * deliberately no keep function; staged building must fit one transaction.
- * 
+ *
  * `uid_mut` works in any lifecycle state and is permanent root over ALL dynamic
  * fields on the object — including fields attached by other extensions. "Immutable
  * after publish" covers the embedded fields only; extension-layer data stays
@@ -37,10 +37,10 @@
  * holder as able to mutate or delete any extension data, forever.
  */
 
-import { MoveEnum, MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { MoveEnum, MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
 import { bcs } from '@mysten/sui/bcs';
 import { type Transaction } from '@mysten/sui/transactions';
-import * as bps from './deps/bps/bps.js';
+import * as bps from './deps/bps/bps.ts';
 const $moduleName = '@local-pkg/miso::composition';
 /** Lifecycle state of a composition. */
 export const CompositionState = new MoveEnum({ name: `${$moduleName}::CompositionState`, fields: {

package/src/contracts/miso/deps/bps/bps.ts

@@ -5,9 +5,9 @@
 
 /**
  * Basis-points arithmetic with a newtype wrapper.
- * 
+ *
  * 1 bps = 0.01%. 10_000 bps = 100%.
- * 
+ *
  * Storage-optimal: `BPS` stores a `u16` (2 bytes), the tightest width that fits
  * the `[0, 10_000]` range. Apply functions cover every standard integer width
  * (`u8` through `u256`); overflow safety on `u8`–`u128` is delegated to
@@ -17,7 +17,7 @@
  * (~1.16e73).
  */
 
-import { MoveTuple } from '../../../utils/index.js';
+import { MoveTuple } from '../../../utils/index.ts';
 import { bcs } from '@mysten/sui/bcs';
 const $moduleName = 'bps::bps';
 export const BPS = new MoveTuple({ name: `${$moduleName}::BPS`, fields: [bcs.u16()] });