@stakekit/widget 0.0.273 → 0.0.275

package/dist/types/components/molecules/select-opportunity-list-item/index.d.ts

@@ -1,7 +1,9 @@
-import type { Yield } from "../../../domain/types/yields";
-export declare const SelectOpportunityListItem: ({ item, onYieldSelect, testId, selected, }: {
-    item: Yield;
-    onYieldSelect: (item: Yield) => void;
+import type { YieldBase } from "../../../domain/types/yields";
+type SelectOpportunityListItemProps<T extends YieldBase> = {
+    item: T;
+    onYieldSelect: (item: T) => void;
     testId?: string;
     selected?: boolean;
-}) => import("react/jsx-runtime").JSX.Element;
+};
+export declare const SelectOpportunityListItem: <T extends YieldBase>({ item, onYieldSelect, testId, selected, }: SelectOpportunityListItemProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/domain/types/stake.d.ts

@@ -7,7 +7,7 @@ import type { InitParams } from "./init-params";
 import type { PositionsData } from "./positions";
 import type { TokenBalanceScanResponseDto } from "./token-balance";
 import type { TokenString } from "./tokens";
-import { type Yield } from "./yields";
+import { type Yield, type YieldBase } from "./yields";
 export type PreferredTokenYieldsPerNetwork = {
     [Key in SupportedSKChains]?: Record<TokenString, "*" | (Yield["id"] & {})>;
 };
@@ -20,7 +20,7 @@ export declare const getInitialToken: (args: {
 }) => import("purify-ts/Maybe").Maybe<import("../../generated/api/legacy").TokenDto>;
 export declare const canBeInitialYield: (args: {
     initQueryParams: Maybe<InitParams>;
-    yieldDto: Yield;
+    yieldDto: YieldBase;
     tokenBalanceAmount: BigNumber;
     positionsData: PositionsData;
 }) => boolean;
@@ -33,5 +33,5 @@ export declare const isForceMaxAmount: (args: {
     maximum?: number | null;
 } | null | undefined) => boolean;
 export declare const isNetworkWithEnterMinBasedOnPosition: (network: Networks) => boolean;
-export declare const getMinStakeAmount: (yieldDto: Yield, positionsData: PositionsData) => BigNumber;
+export declare const getMinStakeAmount: (yieldDto: YieldBase, positionsData: PositionsData) => BigNumber;
 export declare const getMinUnstakeAmount: (yieldDto: Yield, pricePerShare: string | null) => BigNumber;

package/dist/types/domain/types/yields.d.ts

@@ -1,12 +1,11 @@
 import type { TFunction } from "i18next";
-import type { YieldDto as OldYieldDto } from "../../generated/api/legacy";
 import type { YieldType as ApiYieldType, ArgumentFieldDto, ProviderDto, ValidatorDto, YieldDto as YieldApiYieldDto, YieldRiskEntryDto } from "../../generated/api/yield";
 import type { SupportedSKChains } from "./chains";
+export type YieldProviderDetails = ProviderDto;
 export type Yield = YieldApiYieldDto & {
-    __fallback__: OldYieldDto;
     provider?: YieldProviderDetails;
 };
-export type YieldProviderDetails = ProviderDto;
+export type YieldBase = Yield;
 type YieldRiskRatingTone = "positive" | "warning" | "danger" | "neutral";
 type KnownYieldRiskRatingSource = YieldRiskEntryDto["source"];
 type YieldRiskRatingSource = KnownYieldRiskRatingSource | (string & {});
@@ -45,17 +44,18 @@ export type ValidatorsConfig = Map<SupportedSKChains | "*", {
 }>;
 export type DashboardYieldCategory = "stake" | "defi" | "rwa";
 export declare const dashboardYieldCategories: readonly ["stake", "defi", "rwa"];
-export declare const getDashboardYieldCategory: (yieldDto: Yield) => DashboardYieldCategory | null;
-export declare const getAvailableDashboardYieldCategories: (yields: Iterable<Yield>) => DashboardYieldCategory[];
+export declare const getApiYieldTypesForDashboardCategory: (category: DashboardYieldCategory) => ApiYieldType[];
+export declare const getDashboardYieldCategoryForApiYieldType: (yieldType: ApiYieldType) => DashboardYieldCategory;
+export declare const getDashboardYieldCategory: (yieldDto: YieldBase) => DashboardYieldCategory | null;
 export declare const filterValidators: ({ validatorsConfig, validators, network, yieldId, }: {
     validatorsConfig: ValidatorsConfig;
     validators: ValidatorDto[];
     network: Yield["token"]["network"];
     yieldId?: Yield["id"];
 }) => ValidatorDto[];
-export declare const getYieldActionArg: (yieldDto: Yield, type: YieldActionType, name: YieldArgumentName) => YieldArgumentConfig | null;
-export declare const isYieldActionArgRequired: (yieldDto: Yield, type: YieldActionType, name: YieldArgumentName) => boolean;
-export declare const getYieldRewardTokens: (yieldDto: Yield) => {
+export declare const getYieldActionArg: (yieldDto: YieldBase, type: YieldActionType, name: YieldArgumentName) => YieldArgumentConfig | null;
+export declare const isYieldActionArgRequired: (yieldDto: YieldBase, type: YieldActionType, name: YieldArgumentName) => boolean;
+export declare const getYieldRewardTokens: (yieldDto: YieldBase) => {
     readonly symbol: string;
     readonly name: string;
     readonly decimals: number;
@@ -74,15 +74,13 @@ export declare const getYieldCooldownPeriod: (yieldDto: Yield) => {
 export declare const getYieldWarmupPeriod: (yieldDto: Yield) => {
     days: number;
 } | undefined;
-export declare const getYieldCommission: (yieldDto: Yield) => readonly import("../../generated/api/legacy").YieldCommissionDto[] | undefined;
 export declare const getYieldTvlUsd: (yieldDto: Yield) => string | null;
 export declare const getYieldFeePercent: (yieldDto: Yield) => number | null;
 export declare const getYieldLockupPeriod: (yieldDto: Yield) => {
     days: number;
 } | undefined;
-export declare const hasYieldExitSignatureVerification: (yieldDto: Yield) => boolean;
-export declare const getExtendedYieldType: (yieldDto: Yield) => ExtendedYieldType;
-export declare const getYieldOutputToken: (yieldDto: Yield) => import("purify-ts/Maybe").Maybe<{
+export declare const getExtendedYieldType: (yieldDto: YieldBase) => ExtendedYieldType;
+export declare const getYieldOutputToken: (yieldDto: YieldBase) => import("purify-ts/Maybe").Maybe<{
     readonly symbol: string;
     readonly name: string;
     readonly decimals: number;
@@ -94,11 +92,10 @@ export declare const getYieldOutputToken: (yieldDto: Yield) => import("purify-ts
 }>;
 export declare const isUnstakeYieldType: (yieldType: ExtendedYieldType) => yieldType is "native_staking" | "staking" | "restaking" | "pooled_staking";
 export declare const isDepositYieldType: (yieldType: ExtendedYieldType) => yieldType is "vault" | "lending" | "fixed_yield" | "real_world_asset" | "concentrated_liquidity_pool" | "liquidity_pool";
-export declare const getYieldTypeLabels: (yieldDto: Yield, t: TFunction) => YieldTypeLabelsMap[keyof YieldTypeLabelsMap];
-export declare const getYieldTypesSortRank: (yieldDto: Yield) => number;
-export declare const isYieldWithProviderOptions: (yieldDto: Yield) => boolean;
-export declare const getYieldProviderYieldIds: (yieldDto: Yield) => string[];
-export declare const isYieldIntegrationAggregator: (yieldDto: Yield) => boolean;
+export declare const getYieldTypeLabels: (yieldDto: YieldBase, t: TFunction) => YieldTypeLabelsMap[keyof YieldTypeLabelsMap];
+export declare const getYieldTypesSortRank: (yieldDto: YieldBase) => number;
+export declare const isYieldWithProviderOptions: (yieldDto: YieldBase) => boolean;
+export declare const getYieldProviderYieldIds: (yieldDto: YieldBase) => string[];
 export declare const isYieldValidatorSelectionRequired: (yieldDto: Yield) => boolean;
 export declare const isEthenaUsdeStaking: (yieldId: string) => yieldId is "ethena-usde-staking";
 export declare const isBittensorStaking: (yieldId: string) => yieldId is "bittensor-native-staking";

package/dist/types/hooks/api/use-dashboard-yield-catalog.d.ts

@@ -0,0 +1,23 @@
+import type { TokenDto } from "../../domain/types/tokens";
+import { type DashboardYieldCategory } from "../../domain/types/yields";
+import { type YieldSummary } from "./use-yield-summaries";
+type DashboardCategoryInitialSelection = {
+    token: TokenDto;
+    yieldDto: YieldSummary;
+    yieldId: string;
+};
+/**
+ * Discovers available dashboard earn categories with one network-scoped,
+ * reward-rate-sorted probe per category (no dependency on the wallet's token
+ * holdings, no per-yield legacy hydration). The first visible summary of each
+ * probe seeds that category's initial token + yield selection.
+ */
+export declare const useDashboardYieldCatalog: ({ enabled, network, }?: {
+    enabled?: boolean;
+    network?: TokenDto["network"] | null;
+}) => {
+    availableCategories: DashboardYieldCategory[];
+    initialSelectionByCategory: Map<DashboardYieldCategory, DashboardCategoryInitialSelection>;
+    isLoading: boolean;
+};
+export {};

package/dist/types/hooks/api/use-multi-yields.d.ts

@@ -8,7 +8,8 @@ import { type PreferredTokenYieldsPerNetwork } from "../../domain/types/stake";
 import type { SKWallet } from "../../domain/types/wallet";
 import { type ValidatorsConfig, type Yield } from "../../domain/types/yields";
 import { useApiClient } from "../../providers/api/api-client-provider";
-export declare const useStreamMultiYields: (yieldIds: ReadonlyArray<string>) => Yield[];
+import { type YieldSummaryWithProvider } from "./use-yield-summaries";
+export declare const useStreamYieldSummaries: (yieldIds: ReadonlyArray<string>) => YieldSummaryWithProvider[];
 export declare const useMultiYields: <T = Yield[]>(yieldIds: ReadonlyArray<string>, opts?: {
     select?: (val: Yield[]) => T;
     enabled?: boolean;

package/dist/types/hooks/api/use-token-list-yields.d.ts

@@ -1,11 +1,16 @@
 import type { TokenBalanceScanResponseDto } from "../../domain/types/token-balance";
+import { type DashboardYieldCategory } from "../../domain/types/yields";
 import type { YieldDto } from "../../generated/api/yield";
-export type TokenMaxYieldRate = {
+import type { useApiClient } from "../../providers/api/api-client-provider";
+type TokenMaxYieldRate = {
     rateFormatted: string;
     rateTypeLabel: string;
 };
+export declare const fetchTokenListYieldSummaries: ({ apiClient, signal, tokenBalances, }: {
+    apiClient: ReturnType<typeof useApiClient>;
+    signal?: AbortSignal;
+    tokenBalances: ReadonlyArray<TokenBalanceScanResponseDto>;
+}) => Promise<YieldDto[]>;
+export declare const getDashboardCategoryYieldIdsForToken: (availableYieldIds: ReadonlyArray<string>, yieldsById: ReadonlyMap<string, YieldDto>, category: DashboardYieldCategory) => string[];
 export declare const getMaxYieldRateForToken: (availableYieldIds: ReadonlyArray<string>, yieldsById: ReadonlyMap<string, YieldDto>) => TokenMaxYieldRate | null;
-export declare const useTokenListYields: (tokenBalances: ReadonlyArray<TokenBalanceScanResponseDto>) => {
-    maxYieldRatesByToken: Map<string, TokenMaxYieldRate>;
-    isLoading: boolean;
-};
+export {};

package/dist/types/hooks/api/use-yield-opportunity/get-yield-opportunity.d.ts

@@ -1,6 +1,6 @@
 import type { QueryClient } from "@tanstack/react-query";
 import { EitherAsync } from "purify-ts";
-import { type Yield } from "../../../domain/types/yields";
+import { type Yield, type YieldBase } from "../../../domain/types/yields";
 import type { ApiClient } from "../../../providers/api/api-client";
 type Params = {
     yieldId: string;
@@ -15,10 +15,14 @@ type MultiParams = Omit<Params, "yieldId"> & {
 type ParamsWithQueryClient = Params & {
     queryClient: QueryClient;
 };
+type ParamsWithYieldDto = Omit<ParamsWithQueryClient, "yieldId"> & {
+    yieldDto: YieldBase;
+};
 type MultiParamsWithQueryClient = MultiParams & {
     queryClient: QueryClient;
 };
 export declare const getYieldOpportunity: (params: ParamsWithQueryClient) => EitherAsync<Error, Yield>;
+export declare const getYieldOpportunityFromSummary: (params: ParamsWithYieldDto) => EitherAsync<Error, Yield>;
 export declare const getYieldOpportunities: (params: MultiParamsWithQueryClient) => EitherAsync<Error, Yield[]>;
 export declare const queryFn: (params: ParamsWithQueryClient & {
     signal?: AbortSignal;

package/dist/types/hooks/api/use-yield-providers.d.ts

@@ -0,0 +1,13 @@
+import type { QueryClient } from "@tanstack/react-query";
+import type { YieldProviderDetails } from "../../domain/types/yields";
+import type { ApiClient } from "../../providers/api/api-client";
+export declare const fetchYieldProvider: ({ client, providerId, queryClient, }: {
+    client: ReturnType<ApiClient["withOptions"]>;
+    providerId: string;
+    queryClient: QueryClient;
+}) => Promise<YieldProviderDetails | undefined>;
+export declare const fetchYieldProviders: ({ client, providerIds, queryClient, }: {
+    client: ReturnType<ApiClient["withOptions"]>;
+    providerIds: ReadonlyArray<string>;
+    queryClient: QueryClient;
+}) => Promise<Map<string, import("../../generated/api/yield").ProviderDto>>;

package/dist/types/hooks/api/use-yield-summaries.d.ts

@@ -0,0 +1,58 @@
+import type { QueryClient } from "@tanstack/react-query";
+import { type YieldProviderDetails } from "../../domain/types/yields";
+import type { YieldDto, YieldsControllerGetYieldsParams } from "../../generated/api/yield";
+import type { useApiClient } from "../../providers/api/api-client-provider";
+/**
+ * A yield "summary" is the new yields API DTO, returned by
+ * `YieldsControllerGetYields`. It contains everything category discovery and
+ * list rendering need (`token`, `rewardRate`, `status`, `metadata`,
+ * `mechanics.type`, `providerId`).
+ */
+export type YieldSummary = YieldDto;
+export type YieldSummaryWithProvider = YieldSummary & {
+    provider?: YieldProviderDetails;
+};
+export declare const DEFAULT_YIELD_SUMMARIES_PAGE_LIMIT = 50;
+export type YieldSummariesParams = Pick<YieldsControllerGetYieldsParams, "network" | "types" | "inputToken" | "sort" | "limit">;
+/**
+ * A summary is "visible" when it is enterable, on a supported chain, and has a
+ * non-zero reward rate (matching the dashboard catalog's display semantics).
+ */
+export declare const isVisibleYieldSummary: (summary: YieldSummary) => boolean;
+export declare const getYieldSummariesQueryKey: (params: YieldSummariesParams & {
+    allPages?: boolean;
+}) => (string | (YieldSummariesParams & {
+    allPages?: boolean;
+}))[];
+type FetchArgs = {
+    apiClient: ReturnType<typeof useApiClient>;
+    params: YieldSummariesParams;
+    signal?: AbortSignal;
+};
+type FetchByIdsArgs = {
+    apiClient: ReturnType<typeof useApiClient>;
+    chunkSize?: number;
+    signal?: AbortSignal;
+    suppressRichErrors?: boolean;
+    yieldIds: ReadonlyArray<string>;
+};
+type FetchByIdsWithProvidersArgs = FetchByIdsArgs & {
+    queryClient: QueryClient;
+};
+/**
+ * Fetch a single page of yield summaries.
+ */
+export declare const fetchYieldSummariesPage: ({ apiClient, params, signal, }: FetchArgs) => Promise<YieldSummary[]>;
+/**
+ * Fetch yield summaries by ID without ever sending an unbounded `yieldIds`
+ * query array. Results are ordered according to the first occurrence of each
+ * requested ID.
+ */
+export declare const fetchYieldSummariesByIds: ({ apiClient, chunkSize, signal, suppressRichErrors, yieldIds, }: FetchByIdsArgs) => Promise<YieldSummary[]>;
+export declare const fetchYieldSummariesWithProvidersByIds: ({ apiClient, queryClient, signal, suppressRichErrors, yieldIds, }: FetchByIdsWithProvidersArgs) => Promise<YieldSummaryWithProvider[]>;
+/**
+ * Fetch every page of yield summaries for the given params, looping `offset`
+ * until all `total` items have been retrieved.
+ */
+export declare const fetchAllYieldSummaries: ({ apiClient, params, signal, }: FetchArgs) => Promise<YieldSummary[]>;
+export {};

package/dist/types/pages/details/earn-page/components/select-token-section/select-token-list-item.d.ts

@@ -1,11 +1,9 @@
 import type { TokenBalanceScanResponseDto } from "../../../../../domain/types/token-balance";
-import type { TokenMaxYieldRate } from "../../../../../hooks/api/use-token-list-yields";
 type Props = {
     item: TokenBalanceScanResponseDto;
     isConnected: boolean;
     isSelected: boolean;
-    maxYieldRate?: TokenMaxYieldRate;
     onTokenBalanceSelect: (tokenBalance: TokenBalanceScanResponseDto) => void;
 };
-export declare const SelectTokenListItem: import("react").MemoExoticComponent<({ item, isConnected, isSelected, maxYieldRate, onTokenBalanceSelect, }: Props) => import("react/jsx-runtime").JSX.Element>;
+export declare const SelectTokenListItem: import("react").MemoExoticComponent<({ item, isConnected, isSelected, onTokenBalanceSelect }: Props) => import("react/jsx-runtime").JSX.Element>;
 export {};

package/dist/types/pages/details/earn-page/components/select-token-section/styles.css.d.ts

@@ -36,8 +36,6 @@ export declare const selectTokenBalance: import("@vanilla-extract/recipes").Runt
         porto: {};
     };
 }>;
-export declare const maxYieldRateText: string;
-export declare const maxYieldRateLabel: string;
 export declare const minMaxContainer: import("@vanilla-extract/recipes").RuntimeFn<{
     variant: {
         default: string;

package/dist/types/pages/details/earn-page/state/types.d.ts

@@ -14,6 +14,7 @@ import type { SelectedStakeData } from "../types";
 export type State = {
     selectedToken: Maybe<TokenDto>;
     selectedStakeId: Maybe<TokenBalanceScanResponseDto["availableYields"][number]>;
+    autoSelectYield: boolean;
     selectedValidators: Map<ValidatorDto["address"], ValidatorDto>;
     stakeAmount: BigNumber;
     useMaxAmount: boolean;
@@ -21,6 +22,11 @@ export type State = {
     selectedProviderYieldId: Maybe<Yield["id"]>;
 };
 type TokenBalanceSelectAction = Action<"token/select", TokenDto>;
+type TokenOnlySelectAction = Action<"token-only/select", TokenDto>;
+type DashboardTokenYieldSelectAction = Action<"dashboard/token-yield/select", {
+    token: TokenDto;
+    yieldDto: Yield;
+}>;
 type YieldSelectAction = Action<"yield/select", Yield>;
 type StakeAmountChangeAction = Action<"stakeAmount/change", BigNumber>;
 type StakeAmountMaxAction = Action<"stakeAmount/max", BigNumber>;
@@ -30,7 +36,7 @@ type ValidatorMultiSelectAction = Action<"validator/multiselect", ValidatorDto>;
 type ValidatorRemoveAction = Action<"validator/remove", ValidatorDto>;
 type SelectTronResourceAction = Action<"tronResource/select", TronResourceType>;
 type ProviderYieldIdSelectAction = Action<"providerYieldId/select", Yield["id"]>;
-export type Actions = TokenBalanceSelectAction | YieldSelectAction | StakeAmountChangeAction | StakeAmountMaxAction | StateResetAction | ValidatorSelectAction | ValidatorMultiSelectAction | ValidatorRemoveAction | SelectTronResourceAction | ProviderYieldIdSelectAction;
+export type Actions = TokenBalanceSelectAction | TokenOnlySelectAction | DashboardTokenYieldSelectAction | YieldSelectAction | StakeAmountChangeAction | StakeAmountMaxAction | StateResetAction | ValidatorSelectAction | ValidatorMultiSelectAction | ValidatorRemoveAction | SelectTronResourceAction | ProviderYieldIdSelectAction;
 export type ExtraData = {
     actions: {
         onMaxClick: () => void;

package/dist/types/pages/details/earn-page/types.d.ts

@@ -1,7 +1,7 @@
-import type { ExtendedYieldType, Yield } from "../../../domain/types/yields";
+import type { ExtendedYieldType, YieldBase } from "../../../domain/types/yields";
 export type SelectedStakeData = {
-    all: Yield[];
-    filtered: Yield[];
+    all: YieldBase[];
+    filtered: YieldBase[];
     groupsWithCounts: Map<ExtendedYieldType, {
         itemsLength: number;
         title: string;

package/dist/types/pages/position-details/hooks/use-unstake-machine.d.ts

@@ -1,79 +1,34 @@
 import type { SnapshotFromStore } from "@xstate/store";
 import { Maybe } from "purify-ts";
-import type { TransactionVerificationMessageDto } from "../../../domain/types/transaction";
-import type { SKWallet } from "../../../domain/types/wallet";
 import { useExitStakeStore } from "../../../providers/exit-stake-store";
 import type { GetMaybeJust } from "../../../types/utils";
 export declare const useUnstakeMachine: ({ onDone }: {
     onDone: () => void;
 }) => [import("xstate").MachineSnapshot<{
     error: Maybe<unknown>;
-    transactionVerificationMessageDto: Maybe<TransactionVerificationMessageDto>;
-    signedMessage: Maybe<string>;
     data: ReturnType<() => Maybe<GetMaybeJust<SnapshotFromStore<ReturnType<typeof useExitStakeStore>>["context"]["data"]> & {
-        network: NonNullable<SKWallet["network"]>;
-        address: NonNullable<SKWallet["address"]>;
+        address: string;
     }>>;
 }, {
     type: "UNSTAKE";
-} | {
-    type: "__GET_VERIFICATION_MESSAGE__";
-    val: GetMaybeJust<ReturnType<() => Maybe<GetMaybeJust<SnapshotFromStore<ReturnType<typeof useExitStakeStore>>["context"]["data"]> & {
-        network: NonNullable<SKWallet["network"]>;
-        address: NonNullable<SKWallet["address"]>;
-    }>>>;
 } | {
     type: "__SUBMIT__";
     val: GetMaybeJust<ReturnType<() => Maybe<GetMaybeJust<SnapshotFromStore<ReturnType<typeof useExitStakeStore>>["context"]["data"]> & {
-        network: NonNullable<SKWallet["network"]>;
-        address: NonNullable<SKWallet["address"]>;
+        address: string;
     }>>>;
 } | {
     type: "__RESET__";
-} | {
-    type: "__GET_VERIFICATION_MESSAGE_SUCCESS__";
-    val: TransactionVerificationMessageDto;
-} | {
-    type: "__GET_VERIFICATION_MESSAGE_ERROR__";
-    val: unknown;
-} | {
-    type: "CONTINUE_MESSAGE_SIGN";
-} | {
-    type: "CANCEL_MESSAGE_SIGN";
-} | {
-    type: "__SIGN_MESSAGE_SUCCESS__";
-    val: string;
-} | {
-    type: "__SIGN_MESSAGE_ERROR__";
-    val: unknown;
 } | {
     type: "__SUBMIT_SUCCESS__";
 } | {
     type: "__SUBMIT_ERROR__";
     val: unknown;
-}, {}, "initial" | "done" | "check" | "showPopup" | {
+}, {}, "initial" | "done" | "check" | {
     submit: "error" | "loading";
-} | {
-    signMessage: "error" | "loading";
-} | {
-    getVerificationMessage: "error" | "loading";
 }, string, import("xstate").NonReducibleUnknown, import("xstate").MetaObject, {
     states: {
         readonly initial: {};
         readonly check: {};
-        readonly getVerificationMessage: {
-            states: {
-                readonly loading: {};
-                readonly error: {};
-            };
-        };
-        readonly showPopup: {};
-        readonly signMessage: {
-            states: {
-                readonly loading: {};
-                readonly error: {};
-            };
-        };
         readonly submit: {
             states: {
                 readonly loading: {};
@@ -84,36 +39,13 @@ export declare const useUnstakeMachine: ({ onDone }: {
     };
 }>, (event: {
     type: "UNSTAKE";
-} | {
-    type: "__GET_VERIFICATION_MESSAGE__";
-    val: GetMaybeJust<ReturnType<() => Maybe<GetMaybeJust<SnapshotFromStore<ReturnType<typeof useExitStakeStore>>["context"]["data"]> & {
-        network: NonNullable<SKWallet["network"]>;
-        address: NonNullable<SKWallet["address"]>;
-    }>>>;
 } | {
     type: "__SUBMIT__";
     val: GetMaybeJust<ReturnType<() => Maybe<GetMaybeJust<SnapshotFromStore<ReturnType<typeof useExitStakeStore>>["context"]["data"]> & {
-        network: NonNullable<SKWallet["network"]>;
-        address: NonNullable<SKWallet["address"]>;
+        address: string;
     }>>>;
 } | {
     type: "__RESET__";
-} | {
-    type: "__GET_VERIFICATION_MESSAGE_SUCCESS__";
-    val: TransactionVerificationMessageDto;
-} | {
-    type: "__GET_VERIFICATION_MESSAGE_ERROR__";
-    val: unknown;
-} | {
-    type: "CONTINUE_MESSAGE_SIGN";
-} | {
-    type: "CANCEL_MESSAGE_SIGN";
-} | {
-    type: "__SIGN_MESSAGE_SUCCESS__";
-    val: string;
-} | {
-    type: "__SIGN_MESSAGE_ERROR__";
-    val: unknown;
 } | {
     type: "__SUBMIT_SUCCESS__";
 } | {
@@ -121,72 +53,29 @@ export declare const useUnstakeMachine: ({ onDone }: {
     val: unknown;
 }) => void, import("xstate").Actor<import("xstate").StateMachine<{
     error: Maybe<unknown>;
-    transactionVerificationMessageDto: Maybe<TransactionVerificationMessageDto>;
-    signedMessage: Maybe<string>;
     data: ReturnType<() => Maybe<GetMaybeJust<SnapshotFromStore<ReturnType<typeof useExitStakeStore>>["context"]["data"]> & {
-        network: NonNullable<SKWallet["network"]>;
-        address: NonNullable<SKWallet["address"]>;
+        address: string;
     }>>;
 }, {
     type: "UNSTAKE";
-} | {
-    type: "__GET_VERIFICATION_MESSAGE__";
-    val: GetMaybeJust<ReturnType<() => Maybe<GetMaybeJust<SnapshotFromStore<ReturnType<typeof useExitStakeStore>>["context"]["data"]> & {
-        network: NonNullable<SKWallet["network"]>;
-        address: NonNullable<SKWallet["address"]>;
-    }>>>;
 } | {
     type: "__SUBMIT__";
     val: GetMaybeJust<ReturnType<() => Maybe<GetMaybeJust<SnapshotFromStore<ReturnType<typeof useExitStakeStore>>["context"]["data"]> & {
-        network: NonNullable<SKWallet["network"]>;
-        address: NonNullable<SKWallet["address"]>;
+        address: string;
     }>>>;
 } | {
     type: "__RESET__";
-} | {
-    type: "__GET_VERIFICATION_MESSAGE_SUCCESS__";
-    val: TransactionVerificationMessageDto;
-} | {
-    type: "__GET_VERIFICATION_MESSAGE_ERROR__";
-    val: unknown;
-} | {
-    type: "CONTINUE_MESSAGE_SIGN";
-} | {
-    type: "CANCEL_MESSAGE_SIGN";
-} | {
-    type: "__SIGN_MESSAGE_SUCCESS__";
-    val: string;
-} | {
-    type: "__SIGN_MESSAGE_ERROR__";
-    val: unknown;
 } | {
     type: "__SUBMIT_SUCCESS__";
 } | {
     type: "__SUBMIT_ERROR__";
     val: unknown;
-}, {}, never, never, never, never, "initial" | "done" | "check" | "showPopup" | {
+}, {}, never, never, never, never, "initial" | "done" | "check" | {
     submit: "error" | "loading";
-} | {
-    signMessage: "error" | "loading";
-} | {
-    getVerificationMessage: "error" | "loading";
 }, string, import("xstate").NonReducibleUnknown, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
     states: {
         readonly initial: {};
         readonly check: {};
-        readonly getVerificationMessage: {
-            states: {
-                readonly loading: {};
-                readonly error: {};
-            };
-        };
-        readonly showPopup: {};
-        readonly signMessage: {
-            states: {
-                readonly loading: {};
-                readonly error: {};
-            };
-        };
         readonly submit: {
             states: {
                 readonly loading: {};

package/dist/types/pages/review/hooks/use-stake-review.hook.d.ts

@@ -42,7 +42,43 @@ export declare const useStakeReview: () => {
     managementFee: Maybe<import("../types").FeesBps>;
     performanceFee: Maybe<import("../types").FeesBps>;
     feeConfigLoading: boolean;
-    commissionFee: import("purify-ts/Maybe").Maybe<string>;
+    commissionFee: {
+        isJust(): this is import("purify-ts").AlwaysJust;
+        isNothing(): this is /*elided*/ any;
+        inspect(): string;
+        toString(): string;
+        toJSON(): never;
+        equals<T>(other: import("purify-ts/Maybe").Maybe<T>): boolean;
+        map<U>(_: (value: never) => U): import("purify-ts/Maybe").Maybe<U>;
+        ap<U>(_: import("purify-ts/Maybe").Maybe<(value: never) => U>): import("purify-ts/Maybe").Maybe<U>;
+        alt<T>(other: import("purify-ts/Maybe").Maybe<T>): import("purify-ts/Maybe").Maybe<T>;
+        altLazy<T>(other: () => import("purify-ts/Maybe").Maybe<T>): import("purify-ts/Maybe").Maybe<T>;
+        chain<U>(_: (value: never) => import("purify-ts/Maybe").Maybe<U>): import("purify-ts/Maybe").Maybe<U>;
+        chainNullable<U>(_: (value: never) => U | undefined | null | void): import("purify-ts/Maybe").Maybe<U>;
+        join<U>(this: import("purify-ts/Maybe").Maybe<import("purify-ts/Maybe").Maybe<U>>): import("purify-ts/Maybe").Maybe<U>;
+        reduce<U>(_: (accumulator: U, value: never) => U, initialValue: U): U;
+        extend<U>(_: (value: import("purify-ts/Maybe").Maybe<never>) => U): import("purify-ts/Maybe").Maybe<U>;
+        unsafeCoerce<T>(): T;
+        caseOf<U>(patterns: import("purify-ts").MaybePatterns<never, U>): U;
+        orDefault<T>(defaultValue: T): T;
+        orDefaultLazy<T>(getDefaultValue: () => T): T;
+        toList<T>(): T[];
+        mapOrDefault<U>(_: (value: never) => U, defaultValue: U): U;
+        extract(): never;
+        extractNullable(): never;
+        toEither<L, T>(left: L): import("purify-ts").Either<L, T>;
+        ifJust(_: (value: never) => any): /*elided*/ any;
+        ifNothing(effect: () => any): /*elided*/ any;
+        filter(_: (value: never) => boolean): import("purify-ts/Maybe").Maybe<never>;
+        'fantasy-land/equals': typeof this.equals;
+        'fantasy-land/map': typeof this.map;
+        'fantasy-land/ap': typeof this.ap;
+        'fantasy-land/alt': typeof this.alt;
+        'fantasy-land/chain': typeof this.chain;
+        'fantasy-land/reduce': typeof this.reduce;
+        'fantasy-land/extend': typeof this.extend;
+        'fantasy-land/filter': typeof this.filter;
+    };
     kycGate: {
         state: "start_kyc";
         kycUrl?: string;