@misofm/platform 0.27.0 → 0.28.1

package/src/contracts/composition_credits/composition_credits.ts

@@ -31,15 +31,31 @@ export const CompositionCredits = new MoveStruct({ name: `${$moduleName}::Compos
         /** 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: {
+export const CompositionCreditAddedEvent = new MoveStruct({ name: `${$moduleName}::CompositionCreditAddedEvent<phantom CompositionShare>`, fields: {
         composition_id: bcs.Address,
+        composition_admin_cap_id: bcs.Address,
         party_id: bcs.Address,
-        credit: credit.Credit(composition_party_role.CompositionPartyRole)
+        display_name: bcs.vector(bcs.u8()),
+        role_kinds: bcs.vector(bcs.u8()),
+        role_custom_names: bcs.vector(bcs.vector(bcs.u8())),
+        credit_count_before: bcs.u64(),
+        credit_count_after: bcs.u64(),
+        credit_index: bcs.u64(),
+        credits_record_existed_before: bcs.bool(),
+        credits_record_exists_after: bcs.bool()
     } });
-export const CreditRemovedEvent = new MoveStruct({ name: `${$moduleName}::CreditRemovedEvent`, fields: {
+export const CompositionCreditRemovedEvent = new MoveStruct({ name: `${$moduleName}::CompositionCreditRemovedEvent<phantom CompositionShare>`, fields: {
         composition_id: bcs.Address,
+        composition_admin_cap_id: bcs.Address,
         party_id: bcs.Address,
-        credit: credit.Credit(composition_party_role.CompositionPartyRole)
+        display_name: bcs.vector(bcs.u8()),
+        role_kinds: bcs.vector(bcs.u8()),
+        role_custom_names: bcs.vector(bcs.vector(bcs.u8())),
+        credit_count_before: bcs.u64(),
+        credit_count_after: bcs.u64(),
+        credit_index: bcs.u64(),
+        credits_record_existed_before: bcs.bool(),
+        credits_record_exists_after: bcs.bool()
     } });
 export interface AddCreditArguments {
     self: RawTransactionArgument<string>;

package/src/contracts/composition_routed_stake/composition_routed_stake.ts

@@ -11,8 +11,74 @@
  * this package adds only protocol-specific parent checks.
  */
 
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
 import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
-import { normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+const $moduleName = '@local-pkg/composition_routed_stake::composition_routed_stake';
+export const CompositionRoutedStakeCreatedEvent = new MoveStruct({ name: `${$moduleName}::CompositionRoutedStakeCreatedEvent<phantom RecordingShare, phantom CompositionShare>`, fields: {
+        composition_id: bcs.Address,
+        admin_cap_id: bcs.Address,
+        recording_id: bcs.Address,
+        routed_stake_id: bcs.Address,
+        stake_id: bcs.Address,
+        sender: bcs.Address,
+        principal_value: bcs.u64(),
+        registration_count: bcs.u64()
+    } });
+export const CompositionRoutedStakeRegisteredEvent = new MoveStruct({ name: `${$moduleName}::CompositionRoutedStakeRegisteredEvent<phantom RecordingShare, phantom CompositionShare, phantom Currency>`, fields: {
+        composition_id: bcs.Address,
+        admin_cap_id: bcs.Address,
+        recording_id: bcs.Address,
+        routed_stake_id: bcs.Address,
+        stake_id: bcs.Address,
+        pool_id: bcs.Address,
+        principal_value: bcs.u64(),
+        registration_count_before: bcs.u64(),
+        registration_count_after: bcs.u64(),
+        pool_staked_shares_before: bcs.u64(),
+        pool_staked_shares_after: bcs.u64(),
+        pool_balance: bcs.u64(),
+        pool_cumulative_reward_per_share: bcs.u256(),
+        registration_debt: bcs.u256(),
+        pool_carry: bcs.u128(),
+        pool_cumulative_deposits: bcs.u128()
+    } });
+export const CompositionRoutedStakeUnregisteredEvent = new MoveStruct({ name: `${$moduleName}::CompositionRoutedStakeUnregisteredEvent<phantom RecordingShare, phantom CompositionShare, phantom Currency>`, fields: {
+        composition_id: bcs.Address,
+        admin_cap_id: bcs.Address,
+        recording_id: bcs.Address,
+        routed_stake_id: bcs.Address,
+        stake_id: bcs.Address,
+        pool_id: bcs.Address,
+        principal_value: bcs.u64(),
+        registration_count_before: bcs.u64(),
+        registration_count_after: bcs.u64(),
+        pool_staked_shares_before: bcs.u64(),
+        pool_staked_shares_after: bcs.u64(),
+        pool_balance: bcs.u64(),
+        pool_cumulative_reward_per_share: bcs.u256(),
+        registration_debt: bcs.u256(),
+        pool_carry: bcs.u128(),
+        pool_cumulative_deposits: bcs.u128(),
+        forfeited_scaled_reward: bcs.u256()
+    } });
+export const CompositionRoutedStakeUnstakedEvent = new MoveStruct({ name: `${$moduleName}::CompositionRoutedStakeUnstakedEvent<phantom RecordingShare, phantom CompositionShare>`, fields: {
+        composition_id: bcs.Address,
+        admin_cap_id: bcs.Address,
+        routed_stake_id: bcs.Address,
+        stake_id: bcs.Address,
+        principal_value: bcs.u64()
+    } });
+export const CompositionRoutedStakeRestakedEvent = new MoveStruct({ name: `${$moduleName}::CompositionRoutedStakeRestakedEvent<phantom RecordingShare, phantom CompositionShare>`, fields: {
+        composition_id: bcs.Address,
+        admin_cap_id: bcs.Address,
+        routed_stake_id: bcs.Address,
+        stake_id: bcs.Address,
+        sender: bcs.Address,
+        principal_value: bcs.u64(),
+        registration_count: bcs.u64()
+    } });
 export interface CreateStakeArguments {
     composition: RawTransactionArgument<string>;
     adminCap: RawTransactionArgument<string>;

package/src/contracts/composition_royalty_pool/composition_royalty_pool.ts

@@ -11,8 +11,52 @@
  * register stakes and share a newly returned pool.
  */
 
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
 import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
-import { normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+const $moduleName = '@local-pkg/composition_royalty_pool::composition_royalty_pool';
+export const CompositionRoyaltyPoolCreatedEvent = new MoveStruct({ name: `${$moduleName}::CompositionRoyaltyPoolCreatedEvent<phantom CompositionShare, phantom Currency>`, fields: {
+        composition_id: bcs.Address,
+        admin_cap_id: bcs.Address,
+        pool_id: bcs.Address,
+        pool_balance: bcs.u64(),
+        staked_shares: bcs.u64(),
+        cumulative_reward_per_share: bcs.u256(),
+        carry: bcs.u128(),
+        cumulative_deposits: bcs.u128()
+    } });
+export const CompositionCoinsDepositedEvent = new MoveStruct({ name: `${$moduleName}::CompositionCoinsDepositedEvent<phantom CompositionShare, phantom Currency>`, fields: {
+        composition_id: bcs.Address,
+        admin_cap_id: bcs.Address,
+        pool_id: bcs.Address,
+        amount: bcs.u64(),
+        pool_balance_before: bcs.u64(),
+        pool_balance_after: bcs.u64(),
+        staked_shares: bcs.u64(),
+        reward_per_share_before: bcs.u256(),
+        reward_per_share_after: bcs.u256(),
+        carry_before: bcs.u128(),
+        carry_after: bcs.u128(),
+        cumulative_deposits_before: bcs.u128(),
+        cumulative_deposits_after: bcs.u128(),
+        coin_ids: bcs.vector(bcs.Address)
+    } });
+export const CompositionFundsDepositedEvent = new MoveStruct({ name: `${$moduleName}::CompositionFundsDepositedEvent<phantom CompositionShare, phantom Currency>`, fields: {
+        composition_id: bcs.Address,
+        admin_cap_id: bcs.Address,
+        pool_id: bcs.Address,
+        amount: bcs.u64(),
+        pool_balance_before: bcs.u64(),
+        pool_balance_after: bcs.u64(),
+        staked_shares: bcs.u64(),
+        reward_per_share_before: bcs.u256(),
+        reward_per_share_after: bcs.u256(),
+        carry_before: bcs.u128(),
+        carry_after: bcs.u128(),
+        cumulative_deposits_before: bcs.u128(),
+        cumulative_deposits_after: bcs.u128()
+    } });
 export interface NewPoolArguments {
     composition: RawTransactionArgument<string>;
     adminCap: RawTransactionArgument<string>;
@@ -28,7 +72,10 @@ export interface NewPoolOptions {
         string
     ];
 }
-/** Create and return the canonical unshared pool derived from `composition`. */
+/**
+ * Create and return the canonical unshared pool derived from `composition`. Emits
+ * `CompositionRoyaltyPoolCreatedEvent` after successful creation.
+ */
 export function newPool(options: NewPoolOptions) {
     const packageAddress = options.package ?? '@local-pkg/composition_royalty_pool';
     const argumentsTypes = [
@@ -65,7 +112,8 @@ export interface ReceiveAndDepositOptions {
 }
 /**
  * Receive selected coins sent to the Composition and deposit their balance into
- * the canonical pool derived from that same Composition.
+ * the canonical pool derived from that same Composition. Emits
+ * `CompositionCoinsDepositedEvent` after successful deposit.
  */
 export function receiveAndDeposit(options: ReceiveAndDepositOptions) {
     const packageAddress = options.package ?? '@local-pkg/composition_royalty_pool';
@@ -105,7 +153,8 @@ export interface RedeemAndDepositOptions {
 }
 /**
  * Redeem `value` from the Composition's funds accumulator and deposit it into the
- * canonical pool derived from that same Composition.
+ * canonical pool derived from that same Composition. Emits
+ * `CompositionFundsDepositedEvent` after successful deposit.
  */
 export function redeemAndDeposit(options: RedeemAndDepositOptions) {
     const packageAddress = options.package ?? '@local-pkg/composition_royalty_pool';

package/src/contracts/composition_royalty_pool_plugin/composition_royalty_pool_plugin.ts

@@ -5,8 +5,71 @@
 
 /** Vault adapter for Composition royalty-pool Actions. */
 
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
 import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
-import { normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+const $moduleName = '@local-pkg/composition_royalty_pool_plugin::composition_royalty_pool_plugin';
+export const CompositionRoyaltyPoolPluginInstalledEvent = new MoveStruct({ name: `${$moduleName}::CompositionRoyaltyPoolPluginInstalledEvent<phantom CompositionShare>`, fields: {
+        vault_id: bcs.Address,
+        cap_id: bcs.Address,
+        vault_admin_cap_id: bcs.Address,
+        authorized_plugins_id: bcs.Address,
+        authorized_plugin_count: bcs.u64(),
+        installed: bcs.bool()
+    } });
+export const CompositionRoyaltyPoolPluginUninstalledEvent = new MoveStruct({ name: `${$moduleName}::CompositionRoyaltyPoolPluginUninstalledEvent<phantom CompositionShare>`, fields: {
+        vault_id: bcs.Address,
+        cap_id: bcs.Address,
+        vault_admin_cap_id: bcs.Address,
+        authorized_plugins_id: bcs.Address,
+        authorized_plugin_count: bcs.u64(),
+        installed: bcs.bool()
+    } });
+export const CompositionVaultCapabilityBorrowedEvent = new MoveStruct({ name: `${$moduleName}::CompositionVaultCapabilityBorrowedEvent<phantom CompositionShare, phantom Currency>`, fields: {
+        vault_id: bcs.Address,
+        cap_id: bcs.Address,
+        composition_id: bcs.Address,
+        pool_id: bcs.Address,
+        active: bcs.bool(),
+        capability_available: bcs.bool()
+    } });
+export const CompositionCoinsDepositedEvent = new MoveStruct({ name: `${$moduleName}::CompositionCoinsDepositedEvent<phantom CompositionShare, phantom Currency>`, fields: {
+        vault_id: bcs.Address,
+        cap_id: bcs.Address,
+        composition_id: bcs.Address,
+        pool_id: bcs.Address,
+        pool_balance_before: bcs.u64(),
+        pool_balance_after: bcs.u64(),
+        staked_shares: bcs.u64(),
+        reward_per_share_before: bcs.u256(),
+        reward_per_share_after: bcs.u256(),
+        carry_before: bcs.u128(),
+        carry_after: bcs.u128(),
+        cumulative_deposits_before: bcs.u128(),
+        cumulative_deposits_after: bcs.u128(),
+        active: bcs.bool(),
+        capability_available: bcs.bool(),
+        coin_ids: bcs.vector(bcs.Address)
+    } });
+export const CompositionFundsDepositedEvent = new MoveStruct({ name: `${$moduleName}::CompositionFundsDepositedEvent<phantom CompositionShare, phantom Currency>`, fields: {
+        vault_id: bcs.Address,
+        cap_id: bcs.Address,
+        composition_id: bcs.Address,
+        pool_id: bcs.Address,
+        pool_balance_before: bcs.u64(),
+        pool_balance_after: bcs.u64(),
+        staked_shares: bcs.u64(),
+        reward_per_share_before: bcs.u256(),
+        reward_per_share_after: bcs.u256(),
+        carry_before: bcs.u128(),
+        carry_after: bcs.u128(),
+        cumulative_deposits_before: bcs.u128(),
+        cumulative_deposits_after: bcs.u128(),
+        active: bcs.bool(),
+        capability_available: bcs.bool(),
+        amount: bcs.u64()
+    } });
 export interface InstallArguments {
     vault: RawTransactionArgument<string>;
     vaultAdminCap: RawTransactionArgument<string>;

package/src/contracts/genre/genre.ts

@@ -31,9 +31,16 @@ export const Genre = new MoveStruct({ name: `${$moduleName}::Genre`, fields: {
         name: bcs.string()
     } });
 export const GenreKey = new MoveTuple({ name: `${$moduleName}::GenreKey`, fields: [bcs.string()] });
+export const GenreRegistryCreatedEvent = new MoveStruct({ name: `${$moduleName}::GenreRegistryCreatedEvent`, fields: {
+        registry_id: bcs.Address,
+        initializer: bcs.Address,
+        is_shared: bcs.bool()
+    } });
 export const GenreCreatedEvent = new MoveStruct({ name: `${$moduleName}::GenreCreatedEvent`, fields: {
+        registry_id: bcs.Address,
         genre_id: bcs.Address,
-        name: bcs.string()
+        name: bcs.vector(bcs.u8()),
+        is_frozen: bcs.bool()
     } });
 export interface NewArguments {
     registry: RawTransactionArgument<string>;

package/src/contracts/miso_pay/pay.ts

@@ -0,0 +1,356 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/** Typed payment receipts for any live Sui object. */
+
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
+import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+import * as type_name from './deps/std/type_name.ts';
+const $moduleName = '@local-pkg/miso_pay::pay';
+/** Emitted after a payment has been deposited to the target object's address. */
+export function PaymentSentEvent<Metadata extends BcsType<any>>(...typeParameters: [
+    Metadata
+]) {
+    return new MoveStruct({ name: `${$moduleName}::PaymentSentEvent<phantom Target, phantom Currency, ${typeParameters[0].name as Metadata['name']}>`, fields: {
+            target_id: bcs.Address,
+            target_type: type_name.TypeName,
+            payer: bcs.Address,
+            value: bcs.u64(),
+            metadata: typeParameters[0],
+            paid_at_ms: bcs.u64()
+        } });
+}
+export interface TargetIdArguments {
+    receipt: TransactionArgument;
+}
+export interface TargetIdOptions {
+    package?: string;
+    arguments: TargetIdArguments | [
+        receipt: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string,
+        string
+    ];
+}
+/** Object ID whose address received the deposited funds. */
+export function targetId(options: TargetIdOptions) {
+    const packageAddress = options.package ?? '@local-pkg/miso_pay';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["receipt"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'pay',
+        function: 'target_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface TargetTypeArguments {
+    receipt: TransactionArgument;
+}
+export interface TargetTypeOptions {
+    package?: string;
+    arguments: TargetTypeArguments | [
+        receipt: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string,
+        string
+    ];
+}
+/** Defining type of the object that received the payment. */
+export function targetType(options: TargetTypeOptions) {
+    const packageAddress = options.package ?? '@local-pkg/miso_pay';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["receipt"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'pay',
+        function: 'target_type',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface PayerArguments {
+    receipt: TransactionArgument;
+}
+export interface PayerOptions {
+    package?: string;
+    arguments: PayerArguments | [
+        receipt: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string,
+        string
+    ];
+}
+/** Transaction sender authenticated by the Sui runtime. */
+export function payer(options: PayerOptions) {
+    const packageAddress = options.package ?? '@local-pkg/miso_pay';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["receipt"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'pay',
+        function: 'payer',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface ValueArguments {
+    receipt: TransactionArgument;
+}
+export interface ValueOptions {
+    package?: string;
+    arguments: ValueArguments | [
+        receipt: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string,
+        string
+    ];
+}
+/** Deposited amount in the currency's smallest unit. */
+export function value(options: ValueOptions) {
+    const packageAddress = options.package ?? '@local-pkg/miso_pay';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["receipt"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'pay',
+        function: 'value',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface MetadataArguments {
+    receipt: TransactionArgument;
+}
+export interface MetadataOptions {
+    package?: string;
+    arguments: MetadataArguments | [
+        receipt: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string,
+        string
+    ];
+}
+/** Caller-defined typed payment metadata. */
+export function metadata(options: MetadataOptions) {
+    const packageAddress = options.package ?? '@local-pkg/miso_pay';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["receipt"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'pay',
+        function: 'metadata',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface PaidAtMsArguments {
+    receipt: TransactionArgument;
+}
+export interface PaidAtMsOptions {
+    package?: string;
+    arguments: PaidAtMsArguments | [
+        receipt: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string,
+        string
+    ];
+}
+/** Clock timestamp captured when the payment was deposited. */
+export function paidAtMs(options: PaidAtMsOptions) {
+    const packageAddress = options.package ?? '@local-pkg/miso_pay';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["receipt"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'pay',
+        function: 'paid_at_ms',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface PayArguments<Target extends BcsType<any>, Metadata extends BcsType<any>> {
+    target: RawTransactionArgument<Target>;
+    payment: TransactionArgument;
+    metadata: RawTransactionArgument<Metadata>;
+}
+export interface PayOptions<Target extends BcsType<any>, Metadata extends BcsType<any>> {
+    package?: string;
+    arguments: PayArguments<Target, Metadata> | [
+        target: RawTransactionArgument<Target>,
+        payment: TransactionArgument,
+        metadata: RawTransactionArgument<Metadata>
+    ];
+    typeArguments: [
+        string,
+        string,
+        string
+    ];
+}
+/**
+ * Deposits a non-zero balance at a live object's funds accumulator and emits a
+ * self-contained, typed receipt. It intentionally performs no distribution.
+ * Callers decompose a `Coin` into a `Balance` with `coin::into_balance` in the
+ * enclosing PTB.
+ *
+ * Integrator warning: funds land at the target object's address accumulator. If
+ * the target type has no withdrawal path (or the object is later deleted), the
+ * payment is stranded permanently — only pay targets with a known withdrawal
+ * route. Receipts are events: off-chain consumers must filter on the emitting
+ * package ID before trusting a `PaymentSentEvent`, and `metadata` is
+ * caller-controlled, not payee-attested.
+ */
+export function pay<Target extends BcsType<any>, Metadata extends BcsType<any>>(options: PayOptions<Target, Metadata>) {
+    const packageAddress = options.package ?? '@local-pkg/miso_pay';
+    const argumentsTypes = [
+        `${options.typeArguments[0]}`,
+        null,
+        `${options.typeArguments[2]}`,
+        '0x2::clock::Clock'
+    ] satisfies (string | null)[];
+    const parameterNames = ["target", "payment", "metadata"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'pay',
+        function: 'pay',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface PayCompositionArguments<Metadata extends BcsType<any>> {
+    self: RawTransactionArgument<string>;
+    payment: TransactionArgument;
+    metadata: RawTransactionArgument<Metadata>;
+}
+export interface PayCompositionOptions<Metadata extends BcsType<any>> {
+    package?: string;
+    arguments: PayCompositionArguments<Metadata> | [
+        self: RawTransactionArgument<string>,
+        payment: TransactionArgument,
+        metadata: RawTransactionArgument<Metadata>
+    ];
+    typeArguments: [
+        string,
+        string,
+        string
+    ];
+}
+/** Ergonomic typed form for a composition payment. */
+export function payComposition<Metadata extends BcsType<any>>(options: PayCompositionOptions<Metadata>) {
+    const packageAddress = options.package ?? '@local-pkg/miso_pay';
+    const argumentsTypes = [
+        null,
+        null,
+        `${options.typeArguments[2]}`,
+        '0x2::clock::Clock'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "payment", "metadata"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'pay',
+        function: 'pay_composition',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface PayRecordingArguments<Metadata extends BcsType<any>> {
+    self: RawTransactionArgument<string>;
+    payment: TransactionArgument;
+    metadata: RawTransactionArgument<Metadata>;
+}
+export interface PayRecordingOptions<Metadata extends BcsType<any>> {
+    package?: string;
+    arguments: PayRecordingArguments<Metadata> | [
+        self: RawTransactionArgument<string>,
+        payment: TransactionArgument,
+        metadata: RawTransactionArgument<Metadata>
+    ];
+    typeArguments: [
+        string,
+        string,
+        string,
+        string
+    ];
+}
+/** Ergonomic typed form for a recording payment. */
+export function payRecording<Metadata extends BcsType<any>>(options: PayRecordingOptions<Metadata>) {
+    const packageAddress = options.package ?? '@local-pkg/miso_pay';
+    const argumentsTypes = [
+        null,
+        null,
+        `${options.typeArguments[3]}`,
+        '0x2::clock::Clock'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "payment", "metadata"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'pay',
+        function: 'pay_recording',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface PayReleaseArguments<Metadata extends BcsType<any>> {
+    self: RawTransactionArgument<string>;
+    payment: TransactionArgument;
+    metadata: RawTransactionArgument<Metadata>;
+}
+export interface PayReleaseOptions<Metadata extends BcsType<any>> {
+    package?: string;
+    arguments: PayReleaseArguments<Metadata> | [
+        self: RawTransactionArgument<string>,
+        payment: TransactionArgument,
+        metadata: RawTransactionArgument<Metadata>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Ergonomic typed form for a release payment. */
+export function payRelease<Metadata extends BcsType<any>>(options: PayReleaseOptions<Metadata>) {
+    const packageAddress = options.package ?? '@local-pkg/miso_pay';
+    const argumentsTypes = [
+        null,
+        null,
+        `${options.typeArguments[1]}`,
+        '0x2::clock::Clock'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "payment", "metadata"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'pay',
+        function: 'pay_release',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}