@heliofi/withdraw-react 0.0.3 → 0.0.4

package/dist/withdraw-react.es.d.ts

@@ -0,0 +1,422 @@
+import { AnyActorRef } from 'xstate';
+import { ApiClientConfig } from '@heliofi/withdraw-core';
+import { BalanceResponse } from '@heliofi/withdraw-core';
+import { EventObject } from 'xstate';
+import { MetaObject } from 'xstate';
+import { NonReducibleUnknown } from 'xstate';
+import { ParameterizedObject } from 'xstate';
+import { PolymarketWalletPreparedTransaction } from '@heliofi/withdraw-core';
+import { PreparedTransaction } from '@heliofi/withdraw-core';
+import { PrepareWithdrawalParams } from '@heliofi/withdraw-core';
+import { ProvidedActor } from 'xstate';
+import { QuoteResponse } from '@heliofi/withdraw-core';
+import { QuoteSummary } from '@heliofi/withdraw-core';
+import { RawPreparedTransaction } from '@heliofi/withdraw-core';
+import { ReactNode } from 'react';
+import { RoutesResponse } from '@heliofi/withdraw-core';
+import { SignedTransactionKind } from '@heliofi/withdraw-core';
+import { StateMachine } from 'xstate';
+import { StateValue } from 'xstate';
+import { StatusResponse } from '@heliofi/withdraw-core';
+import { SubmitResponse } from '@heliofi/withdraw-core';
+import { SubmitWithdrawalParams } from '@heliofi/withdraw-core';
+import { TERMINAL_STATES } from '@heliofi/withdraw-core';
+import type { useMachine } from '@xstate/react';
+import { UserOpPreparedTransaction } from '@heliofi/withdraw-core';
+import { WithdrawalApiError } from '@heliofi/withdraw-core';
+import { WithdrawalConfig } from '@heliofi/withdraw-core';
+import type { WithdrawalCustomerSwapRoute } from '@heliofi/withdraw-core';
+import { WithdrawalErrorCode } from '@heliofi/withdraw-core';
+import { WithdrawalJwtPayload } from '@heliofi/withdraw-core';
+import type { WithdrawalSDK } from '@heliofi/withdraw-core';
+import { WithdrawalState } from '@heliofi/withdraw-core';
+
+export { ApiClientConfig }
+
+export { BalanceResponse }
+
+export declare type BlockchainEngineType = 'EVM' | 'SOL' | 'BTC' | 'TRON';
+
+export declare enum FormInputState {
+    EDITING = "editing",
+    QUOTING = "quoting",
+    QUOTED = "quoted"
+}
+
+export declare const MoonPayCommerceWithdraw: (props: MoonPayCommerceWithdrawProps) => JSX.Element;
+
+export declare interface MoonPayCommerceWithdrawProps {
+    withdrawalConfigId: string;
+    publicApiKey: string;
+    handleSign: (signingPayload: SigningPayload) => Promise<string>;
+    sourceWalletAddress: string;
+    onSuccess?: (result: WithdrawResult) => void;
+    onError?: (error: WithdrawError) => void;
+    connectedWalletAddress?: string;
+    connectedWalletEngineType?: BlockchainEngineType;
+    baseUrl?: string;
+    debug?: boolean;
+}
+
+export { PolymarketWalletPreparedTransaction }
+
+export { PreparedTransaction }
+
+export { PrepareWithdrawalParams }
+
+export { QuoteResponse }
+
+export { QuoteSummary }
+
+export { RawPreparedTransaction }
+
+export { RoutesResponse }
+
+export { SignedTransactionKind }
+
+export declare interface SigningPayload {
+    kind: 'transaction' | 'typed_data';
+    data: unknown;
+}
+
+export { StatusResponse }
+
+export { SubmitResponse }
+
+export { SubmitWithdrawalParams }
+
+export { TERMINAL_STATES }
+
+declare interface UseGetBalanceResult {
+    data: BalanceResponse | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: WithdrawQueryError | undefined;
+}
+
+export declare const useGetBalances: (fromWallet: string | undefined) => UseGetBalanceResult;
+
+export declare const useGetRoutes: () => UseGetRoutesResult;
+
+declare interface UseGetRoutesResult {
+    data: RoutesResponse | undefined;
+    availableRoutes: WithdrawalCustomerSwapRoute[];
+    routesById: Record<string, WithdrawalCustomerSwapRoute>;
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: WithdrawQueryError | undefined;
+}
+
+export declare const useGetStatus: (withdrawalDetailId: string | undefined) => UseGetStatusResult;
+
+declare interface UseGetStatusResult {
+    data: StatusResponse | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: WithdrawQueryError | undefined;
+}
+
+export declare const useGetWithdraw: () => UseGetWithdrawResult;
+
+declare interface UseGetWithdrawResult {
+    data: WithdrawalConfig | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: WithdrawQueryError | undefined;
+}
+
+export declare const usePrepare: () => UsePrepareResult;
+
+declare interface UsePrepareResult {
+    trigger: (params: PrepareWithdrawalParams) => Promise<QuoteResponse>;
+    data: QuoteResponse | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: WithdrawQueryError | undefined;
+}
+
+export { UserOpPreparedTransaction }
+
+export declare const useSubmitWithdraw: () => UseSubmitWithdrawResult;
+
+declare interface UseSubmitWithdrawResult {
+    trigger: (params: SubmitWithdrawalParams) => Promise<SubmitResponse>;
+    data: SubmitResponse | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: WithdrawQueryError | undefined;
+}
+
+declare const useWithdrawContext: () => WithdrawFlowContextValue;
+export { useWithdrawContext }
+export { useWithdrawContext as useWithdrawFlowContext }
+
+export declare const useWithdrawCryptoMachine: () => WithdrawCryptoMachineContextValue;
+
+export { WithdrawalApiError }
+
+export { WithdrawalConfig }
+
+export { WithdrawalErrorCode }
+
+export { WithdrawalJwtPayload }
+
+export { WithdrawalState }
+
+export declare interface WithdrawCryptoContext {
+    toCurrencyId?: string;
+    withdrawalDetailId?: string;
+    quote?: QuoteResponse;
+    signature?: string;
+    error?: WithdrawError;
+    result?: WithdrawResult;
+}
+
+export declare type WithdrawCryptoEvent = {
+    type: 'LOADED';
+    initialCurrencyId?: string;
+} | {
+    type: 'LOAD_FAILED';
+    error: WithdrawError;
+} | {
+    type: 'OPEN_CURRENCY_SELECT';
+} | {
+    type: 'OPEN_BLOCKCHAIN_SELECT';
+} | {
+    type: 'SELECT_CURRENCY';
+    toCurrencyId: string;
+} | {
+    type: 'SELECT_BLOCKCHAIN';
+    toCurrencyId: string;
+} | {
+    type: 'BACK';
+} | {
+    type: 'FIELDS_CHANGED';
+} | {
+    type: 'QUOTE_REQUESTED';
+} | {
+    type: 'QUOTE_SUCCESS';
+    withdrawalDetailId: string;
+    quote: QuoteResponse;
+} | {
+    type: 'QUOTE_ERROR';
+    error: WithdrawError;
+} | {
+    type: 'CONTINUE';
+} | {
+    type: 'SIGNED';
+    signedPayload: string;
+} | {
+    type: 'SIGN_FAILED';
+    error: WithdrawError;
+} | {
+    type: 'SUBMITTED';
+} | {
+    type: 'SUBMIT_FAILED';
+    error: WithdrawError;
+} | {
+    type: 'COMPLETED';
+    result: WithdrawResult;
+} | {
+    type: 'FAILED';
+    error: WithdrawError;
+} | {
+    type: 'BACK_TO_FORM';
+} | {
+    type: 'RETRY';
+} | {
+    type: 'RESET';
+};
+
+export declare const withdrawCryptoEvents: {
+    loaded: (initialCurrencyId?: string) => WithdrawCryptoEvent;
+    loadFailed: (error: WithdrawError) => WithdrawCryptoEvent;
+    openCurrencySelect: () => WithdrawCryptoEvent;
+    openBlockchainSelect: () => WithdrawCryptoEvent;
+    selectCurrency: (toCurrencyId: string) => WithdrawCryptoEvent;
+    selectBlockchain: (toCurrencyId: string) => WithdrawCryptoEvent;
+    back: () => WithdrawCryptoEvent;
+    fieldsChanged: () => WithdrawCryptoEvent;
+    quoteRequested: () => WithdrawCryptoEvent;
+    quoteSuccess: (withdrawalDetailId: string, quote: QuoteResponse) => WithdrawCryptoEvent;
+    quoteError: (error: WithdrawError) => WithdrawCryptoEvent;
+    continue: () => WithdrawCryptoEvent;
+    signed: (signedPayload: string) => WithdrawCryptoEvent;
+    signFailed: (error: WithdrawError) => WithdrawCryptoEvent;
+    submitted: () => WithdrawCryptoEvent;
+    submitFailed: (error: WithdrawError) => WithdrawCryptoEvent;
+    completed: (result: WithdrawResult) => WithdrawCryptoEvent;
+    failed: (error: WithdrawError) => WithdrawCryptoEvent;
+    backToForm: () => WithdrawCryptoEvent;
+    retry: () => WithdrawCryptoEvent;
+    reset: () => WithdrawCryptoEvent;
+};
+
+declare const withdrawCryptoMachine: StateMachine<WithdrawCryptoContext, {
+    type: "LOADED";
+    initialCurrencyId?: string | undefined;
+} | {
+    type: "LOAD_FAILED";
+    error: WithdrawError;
+} | {
+    type: "OPEN_CURRENCY_SELECT";
+} | {
+    type: "OPEN_BLOCKCHAIN_SELECT";
+} | {
+    type: "SELECT_CURRENCY";
+    toCurrencyId: string;
+} | {
+    type: "SELECT_BLOCKCHAIN";
+    toCurrencyId: string;
+} | {
+    type: "BACK";
+} | {
+    type: "FIELDS_CHANGED";
+} | {
+    type: "QUOTE_REQUESTED";
+} | {
+    type: "QUOTE_SUCCESS";
+    withdrawalDetailId: string;
+    quote: QuoteResponse;
+} | {
+    type: "QUOTE_ERROR";
+    error: WithdrawError;
+} | {
+    type: "CONTINUE";
+} | {
+    type: "SIGNED";
+    signedPayload: string;
+} | {
+    type: "SIGN_FAILED";
+    error: WithdrawError;
+} | {
+    type: "SUBMITTED";
+} | {
+    type: "SUBMIT_FAILED";
+    error: WithdrawError;
+} | {
+    type: "COMPLETED";
+    result: WithdrawResult;
+} | {
+    type: "FAILED";
+    error: WithdrawError;
+} | {
+    type: "BACK_TO_FORM";
+} | {
+    type: "RETRY";
+} | {
+    type: "RESET";
+}, Record<string, AnyActorRef>, ProvidedActor, ParameterizedObject, ParameterizedObject, string, StateValue, string, unknown, NonReducibleUnknown, EventObject, MetaObject, any>;
+
+declare interface WithdrawCryptoMachineContextValue {
+    state: ReturnType<typeof useMachine<typeof withdrawCryptoMachine>>[0];
+    send: ReturnType<typeof useMachine<typeof withdrawCryptoMachine>>[1];
+}
+
+export declare const WithdrawCryptoMachineProvider: ({ children, }: {
+    children: ReactNode;
+}) => JSX.Element;
+
+export declare enum WithdrawCryptoState {
+    LOADING = "loading",
+    LOAD_ERROR = "loadError",
+    FORM_INPUT = "formInput",
+    CURRENCY_SELECT = "currencySelect",
+    BLOCKCHAIN_SELECT = "blockchainSelect",
+    SIGNING = "signing",
+    SIGN_ERROR = "signError",
+    SUBMITTING = "submitting",
+    SUBMIT_ERROR = "submitError",
+    STATUS = "status",
+    COMPLETED = "completed",
+    FAILED = "failed"
+}
+
+export declare interface WithdrawError {
+    code: WithdrawErrorCode;
+    message: string;
+}
+
+declare enum WithdrawErrorCode {
+    LOAD_FAILED = "LOAD_FAILED",
+    MISSING_ID = "MISSING_ID",
+    QUOTE_FAILED = "QUOTE_FAILED",
+    SIGN_FAILED = "SIGN_FAILED",
+    SUBMIT_FAILED = "SUBMIT_FAILED",
+    STATUS_FAILED = "STATUS_FAILED"
+}
+
+export declare interface WithdrawFlowContextValue {
+    withdrawalConfigId: string | undefined;
+    withdrawalConfig: WithdrawalConfig | undefined;
+    withdrawalConfigLoading: boolean;
+    withdrawalConfigError: boolean;
+    sourceWalletAddress: string | undefined;
+    handleSign: (signingPayload: SigningPayload) => Promise<string>;
+    onSuccess?: (result: WithdrawResult) => void;
+    onError?: (error: WithdrawError) => void;
+    connectedWalletAddress?: string;
+    connectedWalletEngineType?: BlockchainEngineType;
+    activeFlow: WithdrawFlowType | null;
+    setActiveFlow: (flow: WithdrawFlowType | null) => void;
+    currentStep: WithdrawStepId;
+    setCurrentStep: (step: WithdrawStepId) => void;
+}
+
+export declare enum WithdrawFlowType {
+    CRYPTO = "crypto",
+    CARD_BANK = "card_bank"
+}
+
+export declare const WithdrawProvider: ({ publicApiKey, baseUrl, ...rest }: WithdrawProviderProps) => JSX.Element;
+
+export declare interface WithdrawProviderProps {
+    publicApiKey: string;
+    baseUrl?: string;
+    withdrawalConfigId?: string;
+    sourceWalletAddress?: string;
+    handleSign: (signingPayload: SigningPayload) => Promise<string>;
+    onSuccess?: (result: WithdrawResult) => void;
+    onError?: (error: WithdrawError) => void;
+    connectedWalletAddress?: string;
+    connectedWalletEngineType?: BlockchainEngineType;
+    children: ReactNode;
+}
+
+declare interface WithdrawQueryError {
+    reason: string;
+    originalError: Error;
+    code?: WithdrawalErrorCode;
+}
+
+export declare interface WithdrawResult {
+    withdrawalDetailId: string;
+    status: string;
+}
+
+export declare enum WithdrawStepId {
+    ROUTE_SELECT = "route_select",
+    CRYPTO_LOADING = "crypto_loading",
+    CRYPTO_LOAD_ERROR = "crypto_load_error",
+    CRYPTO_FORM = "crypto_form",
+    CRYPTO_CURRENCY_SELECT = "crypto_currency_select",
+    CRYPTO_BLOCKCHAIN_SELECT = "crypto_blockchain_select",
+    CRYPTO_SIGNING = "crypto_signing",
+    CRYPTO_SIGN_ERROR = "crypto_sign_error",
+    CRYPTO_SUBMITTING = "crypto_submitting",
+    CRYPTO_SUBMIT_ERROR = "crypto_submit_error",
+    CRYPTO_STATUS = "crypto_status",
+    CRYPTO_COMPLETED = "crypto_completed",
+    CRYPTO_FAILED = "crypto_failed",
+    CARD_BANK_COMING_SOON = "card_bank_coming_soon"
+}
+
+export declare const WithdrawStoreProvider: ({ sdk, children, }: WithdrawStoreProviderProps) => JSX.Element;
+
+export declare interface WithdrawStoreProviderProps {
+    sdk: WithdrawalSDK;
+    children: ReactNode;
+}
+
+export { }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heliofi/withdraw-react",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "type": "module",
   "scripts": {
     "dev": "vite --port=8097",
@@ -20,11 +20,11 @@
   },
   "main": "./dist/withdraw-react.es.js",
   "module": "./dist/withdraw-react.es.js",
-  "types": "./dist/index.d.ts",
+  "types": "./dist/withdraw-react.es.d.ts",
   "style": "./dist/withdraw-react.css",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
+      "types": "./dist/withdraw-react.es.d.ts",
       "import": "./dist/withdraw-react.es.js"
     },
     "./dist/withdraw-react.css": "./dist/withdraw-react.css"

package/dist/apps/withdraw-react/src/api/errors.d.ts

@@ -1,24 +0,0 @@
-import type { WithdrawalErrorCode } from '@heliofi/withdraw-core';
-export interface WithdrawQueryError {
-    reason: string;
-    originalError: Error;
-    code?: WithdrawalErrorCode;
-}
-export declare enum RecoveryActionType {
-    GO_BACK = "GO_BACK"
-}
-export type ErrorRecoveryAction = {
-    type: RecoveryActionType;
-};
-export interface ErrorDisplay {
-    message: string;
-    buttonLabel: string;
-    recovery: ErrorRecoveryAction;
-}
-export declare const getErrorDisplay: (code: string) => ErrorDisplay;
-export declare const returnData: <T>(data: T) => {
-    data: T;
-};
-export declare const returnError: (err: unknown, reason: string) => {
-    error: WithdrawQueryError;
-};

package/dist/apps/withdraw-react/src/balance/useGetBalances.d.ts

@@ -1,10 +0,0 @@
-import type { BalanceResponse } from '@heliofi/withdraw-core';
-import type { WithdrawQueryError } from '../api/errors';
-interface UseGetBalanceResult {
-    data: BalanceResponse | undefined;
-    isLoading: boolean;
-    isError: boolean;
-    error: WithdrawQueryError | undefined;
-}
-export declare const useGetBalances: (fromWallet: string | undefined) => UseGetBalanceResult;
-export {};

package/dist/apps/withdraw-react/src/components/DebugPanel.d.ts

@@ -1,4 +0,0 @@
-import type { MoonPayCommerceWithdrawProps } from '../flow/types';
-export declare const DebugPanel: ({ props, }: {
-    props: MoonPayCommerceWithdrawProps;
-}) => JSX.Element;

package/dist/apps/withdraw-react/src/components/moonPayCommerceWithdraw.d.ts

@@ -1,3 +0,0 @@
-import type { MoonPayCommerceWithdrawProps } from '../flow/types';
-export type { MoonPayCommerceWithdrawProps };
-export declare const MoonPayCommerceWithdraw: (props: MoonPayCommerceWithdrawProps) => JSX.Element;

package/dist/apps/withdraw-react/src/config/useGetWithdraw.d.ts

@@ -1,10 +0,0 @@
-import type { WithdrawalConfig } from '@heliofi/withdraw-core';
-import type { WithdrawQueryError } from '../api/errors';
-interface UseGetWithdrawResult {
-    data: WithdrawalConfig | undefined;
-    isLoading: boolean;
-    isError: boolean;
-    error: WithdrawQueryError | undefined;
-}
-export declare const useGetWithdraw: () => UseGetWithdrawResult;
-export {};

package/dist/apps/withdraw-react/src/constants/steps.d.ts

@@ -1,5 +0,0 @@
-import type { StepProps } from '../../../../packages/solis-ui/src/components/Core/Stepper/types.ts';
-import { WithdrawStepId } from '../flow/types';
-type WithdrawStep = StepProps<WithdrawStepId>;
-export declare const WITHDRAW_STEPS: WithdrawStep[];
-export {};

package/dist/apps/withdraw-react/src/crypto-flow/WithdrawCryptoMachineProvider.d.ts

@@ -1,6 +0,0 @@
-import { type ReactNode } from 'react';
-import { type WithdrawCryptoMachineContextValue } from './machine';
-export declare const WithdrawCryptoMachineProvider: ({ children, }: {
-    children: ReactNode;
-}) => JSX.Element;
-export declare const useWithdrawCryptoMachine: () => WithdrawCryptoMachineContextValue;

package/dist/apps/withdraw-react/src/crypto-flow/machine.d.ts

@@ -1,107 +0,0 @@
-import type { QuoteResponse } from '@heliofi/withdraw-core';
-import type { useMachine } from '@xstate/react';
-import type { WithdrawCryptoContext, WithdrawCryptoEvent } from './types';
-import type { WithdrawError, WithdrawResult } from '../flow/types';
-import { WithdrawStepId } from '../flow/types';
-export declare enum WithdrawCryptoState {
-    LOADING = "loading",
-    LOAD_ERROR = "loadError",
-    FORM_INPUT = "formInput",
-    CURRENCY_SELECT = "currencySelect",
-    BLOCKCHAIN_SELECT = "blockchainSelect",
-    SIGNING = "signing",
-    SIGN_ERROR = "signError",
-    SUBMITTING = "submitting",
-    SUBMIT_ERROR = "submitError",
-    STATUS = "status",
-    COMPLETED = "completed",
-    FAILED = "failed"
-}
-export declare enum FormInputState {
-    EDITING = "editing",
-    QUOTING = "quoting",
-    QUOTED = "quoted"
-}
-export declare const withdrawCryptoMachine: import("xstate").StateMachine<WithdrawCryptoContext, {
-    type: "LOADED";
-    initialCurrencyId?: string | undefined;
-} | {
-    type: "LOAD_FAILED";
-    error: WithdrawError;
-} | {
-    type: "OPEN_CURRENCY_SELECT";
-} | {
-    type: "OPEN_BLOCKCHAIN_SELECT";
-} | {
-    type: "SELECT_CURRENCY";
-    toCurrencyId: string;
-} | {
-    type: "SELECT_BLOCKCHAIN";
-    toCurrencyId: string;
-} | {
-    type: "BACK";
-} | {
-    type: "FIELDS_CHANGED";
-} | {
-    type: "QUOTE_REQUESTED";
-} | {
-    type: "QUOTE_SUCCESS";
-    withdrawalDetailId: string;
-    quote: QuoteResponse;
-} | {
-    type: "QUOTE_ERROR";
-    error: WithdrawError;
-} | {
-    type: "CONTINUE";
-} | {
-    type: "SIGNED";
-    signedPayload: string;
-} | {
-    type: "SIGN_FAILED";
-    error: WithdrawError;
-} | {
-    type: "SUBMITTED";
-} | {
-    type: "SUBMIT_FAILED";
-    error: WithdrawError;
-} | {
-    type: "COMPLETED";
-    result: WithdrawResult;
-} | {
-    type: "FAILED";
-    error: WithdrawError;
-} | {
-    type: "BACK_TO_FORM";
-} | {
-    type: "RETRY";
-} | {
-    type: "RESET";
-}, Record<string, import("xstate").AnyActorRef>, import("xstate").ProvidedActor, import("xstate").ParameterizedObject, import("xstate").ParameterizedObject, string, import("xstate").StateValue, string, unknown, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, any>;
-export declare const getStepIdFromMachineState: (stateValue: string | Record<string, unknown>) => WithdrawStepId | undefined;
-export declare const withdrawCryptoEvents: {
-    loaded: (initialCurrencyId?: string) => WithdrawCryptoEvent;
-    loadFailed: (error: WithdrawError) => WithdrawCryptoEvent;
-    openCurrencySelect: () => WithdrawCryptoEvent;
-    openBlockchainSelect: () => WithdrawCryptoEvent;
-    selectCurrency: (toCurrencyId: string) => WithdrawCryptoEvent;
-    selectBlockchain: (toCurrencyId: string) => WithdrawCryptoEvent;
-    back: () => WithdrawCryptoEvent;
-    fieldsChanged: () => WithdrawCryptoEvent;
-    quoteRequested: () => WithdrawCryptoEvent;
-    quoteSuccess: (withdrawalDetailId: string, quote: QuoteResponse) => WithdrawCryptoEvent;
-    quoteError: (error: WithdrawError) => WithdrawCryptoEvent;
-    continue: () => WithdrawCryptoEvent;
-    signed: (signedPayload: string) => WithdrawCryptoEvent;
-    signFailed: (error: WithdrawError) => WithdrawCryptoEvent;
-    submitted: () => WithdrawCryptoEvent;
-    submitFailed: (error: WithdrawError) => WithdrawCryptoEvent;
-    completed: (result: WithdrawResult) => WithdrawCryptoEvent;
-    failed: (error: WithdrawError) => WithdrawCryptoEvent;
-    backToForm: () => WithdrawCryptoEvent;
-    retry: () => WithdrawCryptoEvent;
-    reset: () => WithdrawCryptoEvent;
-};
-export interface WithdrawCryptoMachineContextValue {
-    state: ReturnType<typeof useMachine<typeof withdrawCryptoMachine>>[0];
-    send: ReturnType<typeof useMachine<typeof withdrawCryptoMachine>>[1];
-}

package/dist/apps/withdraw-react/src/crypto-flow/types.d.ts

@@ -1,65 +0,0 @@
-import type { QuoteResponse } from '@heliofi/withdraw-core';
-import type { WithdrawError, WithdrawResult } from '../flow/types';
-export interface WithdrawCryptoContext {
-    toCurrencyId?: string;
-    withdrawalDetailId?: string;
-    quote?: QuoteResponse;
-    signature?: string;
-    error?: WithdrawError;
-    result?: WithdrawResult;
-}
-export type WithdrawCryptoEvent = {
-    type: 'LOADED';
-    initialCurrencyId?: string;
-} | {
-    type: 'LOAD_FAILED';
-    error: WithdrawError;
-} | {
-    type: 'OPEN_CURRENCY_SELECT';
-} | {
-    type: 'OPEN_BLOCKCHAIN_SELECT';
-} | {
-    type: 'SELECT_CURRENCY';
-    toCurrencyId: string;
-} | {
-    type: 'SELECT_BLOCKCHAIN';
-    toCurrencyId: string;
-} | {
-    type: 'BACK';
-} | {
-    type: 'FIELDS_CHANGED';
-} | {
-    type: 'QUOTE_REQUESTED';
-} | {
-    type: 'QUOTE_SUCCESS';
-    withdrawalDetailId: string;
-    quote: QuoteResponse;
-} | {
-    type: 'QUOTE_ERROR';
-    error: WithdrawError;
-} | {
-    type: 'CONTINUE';
-} | {
-    type: 'SIGNED';
-    signedPayload: string;
-} | {
-    type: 'SIGN_FAILED';
-    error: WithdrawError;
-} | {
-    type: 'SUBMITTED';
-} | {
-    type: 'SUBMIT_FAILED';
-    error: WithdrawError;
-} | {
-    type: 'COMPLETED';
-    result: WithdrawResult;
-} | {
-    type: 'FAILED';
-    error: WithdrawError;
-} | {
-    type: 'BACK_TO_FORM';
-} | {
-    type: 'RETRY';
-} | {
-    type: 'RESET';
-};

package/dist/apps/withdraw-react/src/crypto-flow/withdrawCryptoSteps.d.ts

@@ -1,2 +0,0 @@
-import { WithdrawStepId } from '../flow/types';
-export declare const withdrawCryptoSteps: Record<WithdrawStepId, boolean>;