@misonetwork/sdk 0.7.0 → 0.8.0

package/dist/contracts/routed_stake/routed_stake.d.ts

@@ -0,0 +1,356 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/**
+ * A stake whose rewards are irrevocably routed to its parent's royalty pool.
+ *
+ * A `RoutedStake<StakeShare, PoolShare>` is a derived object of any UID-bearing
+ * parent (same pattern as `RoyaltyPool`). It wraps a `Stake<StakeShare>` — shares
+ * of some other asset that the parent owns — and commits the rewards that stake
+ * earns to the parent's own `RoyaltyPool<PoolShare, Currency>`: `sweep` is the
+ * only reachable claim path, and it deposits straight into the pool derived from
+ * the same parent. The wrapper exists precisely so the raw `Stake` is never
+ * exposed — a bare shared `Stake` would let any caller claim its rewards and keep
+ * them.
+ *
+ * Because the route is fixed, the wrapper is safe to share: `sweep` is
+ * permissionless, and it does not matter who calls it, since the money can only go
+ * one place. Lifecycle operations (`register`, `unregister`, `unstake`, `restake`)
+ * instead require the parent's `&mut UID` as the credential — cap-gating happens
+ * at the parent, exactly as with `RoyaltyPool` creation. `register`/`unregister`
+ * are gated because a stake registers at most once per `Currency`: a
+ * permissionless register could grief by binding the stake to a garbage same-typed
+ * pool, permanently blocking the real one for that currency.
+ *
+ * The derivation key encodes only `StakeShare` — at most one routed stake per
+ * `(parent, StakeShare)` pair, whatever `PoolShare` it used (the same
+ * burned-by-first-claim consequence as `RoyaltyPoolKey`; the parent's cap-gated
+ * extension is expected to pin `PoolShare` to the parent's own share type). For
+ * the same reason the wrapper is never deleted: `unstake` empties it and `restake`
+ * refills it, so the one derived address per pair stays usable forever.
+ */
+import { MoveStruct, MoveTuple, type RawTransactionArgument } from '../utils/index.ts';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+export declare const RoutedStake: MoveStruct<{
+    id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    /**
+     * The wrapped position. `None` between `unstake` and `restake`; the wrapper itself
+     * persists because its derived address can never be re-claimed.
+     */
+    stake: import("@mysten/sui/bcs").BcsType<{
+        id: string;
+        balance: {
+            value: string;
+        };
+        registrations: {
+            contents: {
+                key: {
+                    name: string;
+                };
+                value: {
+                    pool_id: string;
+                    last_claim_index: string;
+                };
+            }[];
+        };
+    } | null, {
+        id: string | Uint8Array<ArrayBufferLike>;
+        balance: {
+            value: string | number | bigint;
+        };
+        registrations: {
+            contents: Iterable<{
+                key: {
+                    name: string;
+                };
+                value: {
+                    pool_id: string | Uint8Array<ArrayBufferLike>;
+                    last_claim_index: string | number | bigint;
+                };
+            }> & {
+                length: number;
+            };
+        };
+    } | null | undefined, "Option<royalty_pool::stake::Stake<phantom Share>>">;
+}, "@local-pkg/routed_stake::routed_stake::RoutedStake<phantom StakeShare, phantom PoolShare>">;
+export declare const RoutedStakeKey: MoveTuple<readonly [import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">], "@local-pkg/routed_stake::routed_stake::RoutedStakeKey<phantom StakeShare>">;
+export declare const RoutedStakeCreatedEvent: MoveStruct<{
+    routed_stake_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    parent_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    staked_value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/routed_stake::routed_stake::RoutedStakeCreatedEvent<phantom StakeShare, phantom PoolShare>">;
+export declare const RoutedStakeSweptEvent: MoveStruct<{
+    routed_stake_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    parent_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/routed_stake::routed_stake::RoutedStakeSweptEvent<phantom StakeShare, phantom PoolShare, phantom Currency>">;
+export declare const RoutedStakeUnstakedEvent: MoveStruct<{
+    routed_stake_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    parent_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    unstaked_value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/routed_stake::routed_stake::RoutedStakeUnstakedEvent<phantom StakeShare, phantom PoolShare>">;
+export declare const RoutedStakeRestakedEvent: MoveStruct<{
+    routed_stake_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    parent_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    staked_value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/routed_stake::routed_stake::RoutedStakeRestakedEvent<phantom StakeShare, phantom PoolShare>">;
+export interface NewArguments {
+    parent: RawTransactionArgument<string>;
+    balance: TransactionArgument;
+}
+export interface NewOptions {
+    package?: string;
+    arguments: NewArguments | [
+        parent: RawTransactionArgument<string>,
+        balance: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Construct a routed stake as a derived object of `parent`, wrapping `balance` as
+ * its staked position. Aborts (in `stake::new`) on a zero balance, and (in
+ * `derived_object::claim`) if the `(parent, StakeShare)` address was already
+ * claimed.
+ *
+ * Cap-gating happens at the parent: callers must obtain `&mut UID` via whatever
+ * cap-gated accessor the parent exposes.
+ */
+export declare function _new(options: NewOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ShareArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface ShareOptions {
+    package?: string;
+    arguments: ShareArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Share the routed stake so anyone can `sweep` it. */
+export declare function share(options: ShareOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RegisterArguments {
+    self: RawTransactionArgument<string>;
+    parent: RawTransactionArgument<string>;
+    stakePool: RawTransactionArgument<string>;
+}
+export interface RegisterOptions {
+    package?: string;
+    arguments: RegisterArguments | [
+        self: RawTransactionArgument<string>,
+        parent: RawTransactionArgument<string>,
+        stakePool: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string,
+        string
+    ];
+}
+/**
+ * Register the wrapped stake with the pool it earns from, so future deposits
+ * accrue to it. Which same-typed pool is the _correct_ one is the caller's concern
+ * — the parent's extension is expected to pin it (e.g. by derivation from the
+ * asset object) before delegating here.
+ */
+export declare function register(options: RegisterOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UnregisterArguments {
+    self: RawTransactionArgument<string>;
+    parent: RawTransactionArgument<string>;
+    stakePool: RawTransactionArgument<string>;
+}
+export interface UnregisterOptions {
+    package?: string;
+    arguments: UnregisterArguments | [
+        self: RawTransactionArgument<string>,
+        parent: RawTransactionArgument<string>,
+        stakePool: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string,
+        string
+    ];
+}
+/**
+ * Unregister the wrapped stake from a pool it earns from. The pool requires
+ * claimable rewards to be drained to zero first — i.e. a final `sweep` — so
+ * accrued rewards provably reach the parent's pool before the position can move.
+ */
+export declare function unregister(options: UnregisterOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UnstakeArguments {
+    self: RawTransactionArgument<string>;
+    parent: RawTransactionArgument<string>;
+}
+export interface UnstakeOptions {
+    package?: string;
+    arguments: UnstakeArguments | [
+        self: RawTransactionArgument<string>,
+        parent: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Remove the staked position and return its principal. Aborts (in
+ * `stake::destroy`) while any pool registrations remain. The emptied wrapper
+ * persists — its derived address is burned forever, so deleting it would
+ * permanently destroy the parent's ability to route-stake this share type;
+ * `restake` refills it instead.
+ */
+export declare function unstake(options: UnstakeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RestakeArguments {
+    self: RawTransactionArgument<string>;
+    parent: RawTransactionArgument<string>;
+    balance: TransactionArgument;
+}
+export interface RestakeOptions {
+    package?: string;
+    arguments: RestakeArguments | [
+        self: RawTransactionArgument<string>,
+        parent: RawTransactionArgument<string>,
+        balance: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Refill an emptied wrapper with a new staked position. Aborts if a position is
+ * already present.
+ */
+export declare function restake(options: RestakeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SweepArguments {
+    self: RawTransactionArgument<string>;
+    stakePool: RawTransactionArgument<string>;
+    routedPool: RawTransactionArgument<string>;
+    parentId: RawTransactionArgument<string>;
+}
+export interface SweepOptions {
+    package?: string;
+    arguments: SweepArguments | [
+        self: RawTransactionArgument<string>,
+        stakePool: RawTransactionArgument<string>,
+        routedPool: RawTransactionArgument<string>,
+        parentId: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string,
+        string
+    ];
+}
+/**
+ * Claim the wrapped stake's accrued rewards from `stake_pool` and deposit them
+ * into `routed_pool` — the parent's own pool. Permissionless: the caller supplies
+ * `parent_id`, but cannot lie, because both the wrapper's own address and
+ * `routed_pool`'s address must derive from it. A zero reward is a no-op (no
+ * event), so the call composes safely into batch PTBs; a positive reward aborts
+ * (in `royalty_pool::pool`) if `routed_pool` has no registered stakes — the reward
+ * stays claimable here until it does.
+ */
+export declare function sweep(options: SweepOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IdArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface IdOptions {
+    package?: string;
+    arguments: IdArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function id(options: IdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface HasStakeArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface HasStakeOptions {
+    package?: string;
+    arguments: HasStakeArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function hasStake(options: HasStakeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ValueArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface ValueOptions {
+    package?: string;
+    arguments: ValueArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Staked principal, or 0 while the wrapper is empty. */
+export declare function value(options: ValueOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface StakeArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface StakeOptions {
+    package?: string;
+    arguments: StakeArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Read-only access to the wrapped stake, e.g. for `pool::pending_rewards`. Aborts
+ * while the wrapper is empty (`has_stake` to guard).
+ */
+export declare function stake(options: StakeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DerivedAddressArguments {
+    parentId: RawTransactionArgument<string>;
+}
+export interface DerivedAddressOptions {
+    package?: string;
+    arguments: DerivedAddressArguments | [
+        parentId: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Compute the deterministic address of a routed stake given its parent ID and
+ * `StakeShare` type parameter.
+ */
+export declare function derivedAddress(options: DerivedAddressOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AssertDerivedFromArguments {
+    self: RawTransactionArgument<string>;
+    parentId: RawTransactionArgument<string>;
+}
+export interface AssertDerivedFromOptions {
+    package?: string;
+    arguments: AssertDerivedFromArguments | [
+        self: RawTransactionArgument<string>,
+        parentId: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Verify the routed stake was derived from the given parent ID. */
+export declare function assertDerivedFrom(options: AssertDerivedFromOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+//# sourceMappingURL=routed_stake.d.ts.map

package/dist/contracts/routed_stake/routed_stake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routed_stake.d.ts","sourceRoot":"","sources":["../../../src/contracts/routed_stake/routed_stake.ts"],"names":[],"mappings":"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"}

package/dist/contracts/routed_stake/routed_stake.js

@@ -0,0 +1,311 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/**
+ * A stake whose rewards are irrevocably routed to its parent's royalty pool.
+ *
+ * A `RoutedStake<StakeShare, PoolShare>` is a derived object of any UID-bearing
+ * parent (same pattern as `RoyaltyPool`). It wraps a `Stake<StakeShare>` — shares
+ * of some other asset that the parent owns — and commits the rewards that stake
+ * earns to the parent's own `RoyaltyPool<PoolShare, Currency>`: `sweep` is the
+ * only reachable claim path, and it deposits straight into the pool derived from
+ * the same parent. The wrapper exists precisely so the raw `Stake` is never
+ * exposed — a bare shared `Stake` would let any caller claim its rewards and keep
+ * them.
+ *
+ * Because the route is fixed, the wrapper is safe to share: `sweep` is
+ * permissionless, and it does not matter who calls it, since the money can only go
+ * one place. Lifecycle operations (`register`, `unregister`, `unstake`, `restake`)
+ * instead require the parent's `&mut UID` as the credential — cap-gating happens
+ * at the parent, exactly as with `RoyaltyPool` creation. `register`/`unregister`
+ * are gated because a stake registers at most once per `Currency`: a
+ * permissionless register could grief by binding the stake to a garbage same-typed
+ * pool, permanently blocking the real one for that currency.
+ *
+ * The derivation key encodes only `StakeShare` — at most one routed stake per
+ * `(parent, StakeShare)` pair, whatever `PoolShare` it used (the same
+ * burned-by-first-claim consequence as `RoyaltyPoolKey`; the parent's cap-gated
+ * extension is expected to pin `PoolShare` to the parent's own share type). For
+ * the same reason the wrapper is never deleted: `unstake` empties it and `restake`
+ * refills it, so the one derived address per pair stays usable forever.
+ */
+import { MoveStruct, MoveTuple, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+import {} from '@mysten/sui/transactions';
+import * as stake_1 from "./deps/royalty_pool/stake.js";
+const $moduleName = '@local-pkg/routed_stake::routed_stake';
+export const RoutedStake = new MoveStruct({ name: `${$moduleName}::RoutedStake<phantom StakeShare, phantom PoolShare>`, fields: {
+        id: bcs.Address,
+        /**
+         * The wrapped position. `None` between `unstake` and `restake`; the wrapper itself
+         * persists because its derived address can never be re-claimed.
+         */
+        stake: bcs.option(stake_1.Stake)
+    } });
+export const RoutedStakeKey = new MoveTuple({ name: `${$moduleName}::RoutedStakeKey<phantom StakeShare>`, fields: [bcs.bool()] });
+export const RoutedStakeCreatedEvent = new MoveStruct({ name: `${$moduleName}::RoutedStakeCreatedEvent<phantom StakeShare, phantom PoolShare>`, fields: {
+        routed_stake_id: bcs.Address,
+        parent_id: bcs.Address,
+        staked_value: bcs.u64()
+    } });
+export const RoutedStakeSweptEvent = new MoveStruct({ name: `${$moduleName}::RoutedStakeSweptEvent<phantom StakeShare, phantom PoolShare, phantom Currency>`, fields: {
+        routed_stake_id: bcs.Address,
+        parent_id: bcs.Address,
+        value: bcs.u64()
+    } });
+export const RoutedStakeUnstakedEvent = new MoveStruct({ name: `${$moduleName}::RoutedStakeUnstakedEvent<phantom StakeShare, phantom PoolShare>`, fields: {
+        routed_stake_id: bcs.Address,
+        parent_id: bcs.Address,
+        unstaked_value: bcs.u64()
+    } });
+export const RoutedStakeRestakedEvent = new MoveStruct({ name: `${$moduleName}::RoutedStakeRestakedEvent<phantom StakeShare, phantom PoolShare>`, fields: {
+        routed_stake_id: bcs.Address,
+        parent_id: bcs.Address,
+        staked_value: bcs.u64()
+    } });
+/**
+ * Construct a routed stake as a derived object of `parent`, wrapping `balance` as
+ * its staked position. Aborts (in `stake::new`) on a zero balance, and (in
+ * `derived_object::claim`) if the `(parent, StakeShare)` address was already
+ * claimed.
+ *
+ * Cap-gating happens at the parent: callers must obtain `&mut UID` via whatever
+ * cap-gated accessor the parent exposes.
+ */
+export function _new(options) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        '0x2::object::ID',
+        null
+    ];
+    const parameterNames = ["parent", "balance"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'new',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Share the routed stake so anyone can `sweep` it. */
+export function share(options) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'share',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Register the wrapped stake with the pool it earns from, so future deposits
+ * accrue to it. Which same-typed pool is the _correct_ one is the caller's concern
+ * — the parent's extension is expected to pin it (e.g. by derivation from the
+ * asset object) before delegating here.
+ */
+export function register(options) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        null
+    ];
+    const parameterNames = ["self", "parent", "stakePool"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'register',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Unregister the wrapped stake from a pool it earns from. The pool requires
+ * claimable rewards to be drained to zero first — i.e. a final `sweep` — so
+ * accrued rewards provably reach the parent's pool before the position can move.
+ */
+export function unregister(options) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        null
+    ];
+    const parameterNames = ["self", "parent", "stakePool"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'unregister',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Remove the staked position and return its principal. Aborts (in
+ * `stake::destroy`) while any pool registrations remain. The emptied wrapper
+ * persists — its derived address is burned forever, so deleting it would
+ * permanently destroy the parent's ability to route-stake this share type;
+ * `restake` refills it instead.
+ */
+export function unstake(options) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID'
+    ];
+    const parameterNames = ["self", "parent"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'unstake',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Refill an emptied wrapper with a new staked position. Aborts if a position is
+ * already present.
+ */
+export function restake(options) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        null
+    ];
+    const parameterNames = ["self", "parent", "balance"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'restake',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Claim the wrapped stake's accrued rewards from `stake_pool` and deposit them
+ * into `routed_pool` — the parent's own pool. Permissionless: the caller supplies
+ * `parent_id`, but cannot lie, because both the wrapper's own address and
+ * `routed_pool`'s address must derive from it. A zero reward is a no-op (no
+ * event), so the call composes safely into batch PTBs; a positive reward aborts
+ * (in `royalty_pool::pool`) if `routed_pool` has no registered stakes — the reward
+ * stays claimable here until it does.
+ */
+export function sweep(options) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x2::object::ID'
+    ];
+    const parameterNames = ["self", "stakePool", "routedPool", "parentId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'sweep',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function id(options) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function hasStake(options) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'has_stake',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Staked principal, or 0 while the wrapper is empty. */
+export function value(options) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'value',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Read-only access to the wrapped stake, e.g. for `pool::pending_rewards`. Aborts
+ * while the wrapper is empty (`has_stake` to guard).
+ */
+export function stake(options) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'stake',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Compute the deterministic address of a routed stake given its parent ID and
+ * `StakeShare` type parameter.
+ */
+export function derivedAddress(options) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        '0x2::object::ID'
+    ];
+    const parameterNames = ["parentId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'derived_address',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Verify the routed stake was derived from the given parent ID. */
+export function assertDerivedFrom(options) {
+    const packageAddress = options.package ?? '@local-pkg/routed_stake';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID'
+    ];
+    const parameterNames = ["self", "parentId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'routed_stake',
+        function: 'assert_derived_from',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+//# sourceMappingURL=routed_stake.js.map