0xtrails 0.16.2 → 0.17.1

package/dist/widget/bluvo/bluvo-lib/useBluvoFlow.d.ts

@@ -1,325 +0,0 @@
-import { BluvoFlowClient, BluvoFlowClientOptions, QuoteRequestOptions, ResumeWithdrawalFlowOptions, SilentResumeWithdrawalFlowOptions, WithdrawalFlowOptions } from './BluvoFlowClient.js';
-import { FlowActionType, FlowState } from './flow.types.js';
-import { Machine } from './machine.types.js';
-export interface UseBluvoFlowOptions extends BluvoFlowClientOptions {
-}
-export declare function useBluvoFlow(options: UseBluvoFlowOptions): {
-    listExchanges: (status?: "live" | "offline" | "maintenance" | "coming_soon") => Promise<any[] | null>;
-    startWithdrawalFlow: (flowOptions: WithdrawalFlowOptions) => Promise<{
-        machine: Machine<FlowState, FlowActionType>;
-        closeOAuthWindow: null;
-    } | {
-        machine: Machine<FlowState, FlowActionType>;
-        closeOAuthWindow: () => void;
-    }>;
-    resumeWithdrawalFlow: (flowOptions: ResumeWithdrawalFlowOptions) => Promise<{
-        machine: Machine<FlowState, FlowActionType>;
-        closeOAuthWindow: null;
-    }>;
-    silentResumeWithdrawalFlow: (flowOptions: SilentResumeWithdrawalFlowOptions) => Promise<{
-        machine: Machine<FlowState, FlowActionType>;
-    } | null>;
-    requestQuote: (quoteOptions: QuoteRequestOptions) => Promise<{
-        success: boolean;
-        error: string;
-        type?: undefined;
-        rawQuote?: undefined;
-        quoteData?: undefined;
-        result?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        type: string | undefined;
-        rawQuote?: undefined;
-        quoteData?: undefined;
-        result?: undefined;
-    } | {
-        rawQuote: any;
-        quoteData: {
-            id: any;
-            asset: any;
-            amount: string;
-            estimatedFee: string;
-            estimatedTotal: string;
-            amountWithFeeInFiat: string;
-            amountNoFeeInFiat: string;
-            estimatedFeeInFiat: string;
-            additionalInfo: any;
-            expiresAt: number;
-        };
-        success: boolean;
-        result: {
-            rawQuote: any;
-            quoteData: {
-                id: any;
-                asset: any;
-                amount: string;
-                estimatedFee: string;
-                estimatedTotal: string;
-                amountWithFeeInFiat: string;
-                amountNoFeeInFiat: string;
-                estimatedFeeInFiat: string;
-                additionalInfo: any;
-                expiresAt: number;
-            };
-        };
-        error?: undefined;
-        type?: undefined;
-    }>;
-    executeWithdrawal: (quoteId: string) => Promise<any>;
-    submit2FA: (code: string) => Promise<any>;
-    submitSMS: (code: string) => Promise<any>;
-    submit2FAMultiStep: (stepType: "GOOGLE" | "EMAIL" | "SMS", code: string) => Promise<{
-        success: boolean;
-        error: string;
-        type?: undefined;
-        result?: undefined;
-    } | {
-        success: boolean;
-        error: any;
-        type: string | undefined;
-        result?: undefined;
-    } | {
-        success: boolean;
-        result: any;
-        error?: undefined;
-        type?: undefined;
-    }>;
-    pollFaceVerification: () => Promise<{
-        success: boolean;
-        error: string;
-        type?: undefined;
-        result?: undefined;
-    } | {
-        success: boolean;
-        error: any;
-        type: string | undefined;
-        result?: undefined;
-    } | {
-        success: boolean;
-        result: any;
-        error?: undefined;
-        type?: undefined;
-    }>;
-    pollRoamingFidoVerification: () => Promise<{
-        success: boolean;
-        error: string;
-        type?: undefined;
-        result?: undefined;
-    } | {
-        success: boolean;
-        error: any;
-        type: string | undefined;
-        result?: undefined;
-    } | {
-        success: boolean;
-        result: any;
-        error?: undefined;
-        type?: undefined;
-    }>;
-    confirmWithdrawal: () => Promise<{
-        success: boolean;
-        error: string;
-        type?: undefined;
-        result?: undefined;
-    } | {
-        success: boolean;
-        error: any;
-        type: string | undefined;
-        result?: undefined;
-    } | {
-        success: boolean;
-        result: any;
-        error?: undefined;
-        type?: undefined;
-    }>;
-    retryWithdrawal: () => Promise<any>;
-    cancel: () => void;
-    refreshQRCode: () => Promise<{
-        success: boolean;
-        error: any;
-    } | {
-        success: boolean;
-        error?: undefined;
-    }>;
-    testWithdrawalComplete: (transactionId?: string) => void;
-    isIdle: boolean;
-    isFlowCancelled: boolean;
-    isExchangesLoading: boolean;
-    isExchangesReady: boolean;
-    isExchangesError: boolean;
-    exchangesError: Error | null;
-    isOAuthPending: boolean;
-    isOAuthWaiting: boolean;
-    isOAuthProcessing: boolean;
-    isOAuthError: boolean;
-    isOAuthFatal: boolean;
-    isWalletConnectionInvalid: boolean;
-    isOAuthComplete: boolean;
-    isOAuthWindowBeenClosedByTheUser: boolean;
-    isQRCodePending: boolean | undefined;
-    isQRCodeWaiting: boolean;
-    isQRCodeDisplaying: boolean;
-    isQRCodeScanning: boolean;
-    isQRCodeError: boolean;
-    isQRCodeFatal: boolean;
-    isQRCodeTimeout: boolean;
-    qrCodeUrl: string | undefined;
-    qrCodeExpiresAt: number | undefined;
-    qrCodeStatus: import('./WorkflowTypes.js').QRCodeStatus | undefined;
-    isQRCodeFlow: boolean;
-    isWalletLoading: boolean;
-    isWalletError: boolean;
-    isWalletReady: boolean;
-    isQuoteLoading: boolean;
-    isQuoteReady: boolean;
-    isQuoteExpired: boolean;
-    isQuoteError: boolean;
-    isWithdrawing: boolean;
-    isWithdrawProcessing: boolean;
-    isWithdrawalComplete: boolean;
-    isWithdrawBlocked: boolean;
-    hasFatalError: boolean;
-    requires2FA: boolean;
-    requires2FAMultiStep: boolean;
-    isReadyToConfirm: boolean;
-    requiresSMS: boolean;
-    requiresKYC: boolean;
-    requiresValid2FAMethod: boolean;
-    requiresEmailVerification: boolean;
-    hasInsufficientBalance: boolean;
-    canRetry: boolean;
-    hasAmountError: boolean;
-    hasAddressError: boolean;
-    hasNetworkError: boolean;
-    hasWalletNotFoundError: boolean;
-    hasInvalidCredentialsError: boolean;
-    invalid2FAAttempts: number;
-    retryAttempts: number;
-    maxRetryAttempts: number;
-    exchanges: {
-        id: string;
-        name: string;
-        logoUrl: string;
-        status: string;
-    }[];
-    walletBalances: {
-        asset: string;
-        balance: string;
-        balanceInFiat?: string;
-        networks?: Array<{
-            id: string;
-            name: string;
-            displayName: string;
-            minWithdrawal: string;
-            maxWithdrawal?: string;
-            assetName: string;
-            addressRegex?: string | null;
-        }>;
-        extra?: {
-            slug?: string;
-            assetId?: string;
-        };
-    }[];
-    quote: {
-        id: string;
-        asset: string;
-        amount: string;
-        estimatedFee: string;
-        estimatedTotal: string;
-        amountWithFeeInFiat: string;
-        amountNoFeeInFiat: string;
-        estimatedFeeInFiat: string;
-        additionalInfo: {
-            minWithdrawal: string | null;
-            maxWithdrawal?: string | null;
-        };
-        expiresAt: number;
-    } | undefined;
-    withdrawal: {
-        id: string;
-        status: string;
-        transactionId?: string;
-    } | undefined;
-    valid2FAMethods: string[] | undefined;
-    multiStep2FA: {
-        bizNo: string;
-        steps: Array<{
-            type: "GOOGLE" | "EMAIL" | "FACE" | "SMS" | "ROAMING_FIDO";
-            status: "pending" | "success" | "failed";
-            required: boolean;
-            metadata?: {
-                email?: string;
-                emailSent?: boolean;
-                qrCodeUrl?: string;
-                qrCodeValidSeconds?: number;
-                roamingFlowId?: string;
-            };
-        }>;
-        relation: "AND" | "OR";
-        collectedCodes?: {
-            twofa?: string;
-            emailCode?: string;
-            smsCode?: string;
-        };
-        faceQrCodeUrl?: string;
-        faceQrCodeExpiresAt?: number;
-        mfa?: {
-            verified: {
-                GOOGLE?: boolean;
-                EMAIL?: boolean;
-                FACE?: boolean;
-                SMS?: boolean;
-                ROAMING_FIDO?: boolean;
-            };
-        };
-    } | undefined;
-    multiStep2FASteps: {
-        type: "GOOGLE" | "EMAIL" | "FACE" | "SMS" | "ROAMING_FIDO";
-        status: "pending" | "success" | "failed";
-        required: boolean;
-        metadata?: {
-            email?: string;
-            emailSent?: boolean;
-            qrCodeUrl?: string;
-            qrCodeValidSeconds?: number;
-            roamingFlowId?: string;
-        };
-    }[];
-    multiStep2FABizNo: string | undefined;
-    multiStep2FARelation: "AND" | "OR" | undefined;
-    collectedMultiStep2FACodes: {
-        twofa?: string;
-        emailCode?: string;
-        smsCode?: string;
-    } | undefined;
-    hasGoogleStep: boolean;
-    hasEmailStep: boolean;
-    hasFaceStep: boolean;
-    hasRoamingFidoStep: boolean;
-    hasSmsStep: boolean;
-    isGoogleStepVerified: boolean;
-    isEmailStepVerified: boolean;
-    isFaceStepVerified: boolean;
-    isRoamingFidoStepVerified: boolean;
-    isSmsStepVerified: boolean;
-    mfaVerified: {
-        GOOGLE?: boolean;
-        EMAIL?: boolean;
-        FACE?: boolean;
-        SMS?: boolean;
-        ROAMING_FIDO?: boolean;
-    } | undefined;
-    allMultiStep2FAStepsVerified: boolean;
-    faceQrCodeUrl: string | undefined;
-    faceQrCodeExpiresAt: number | undefined;
-    client: BluvoFlowClient;
-    state: FlowState | null;
-    send: (action: FlowActionType) => void;
-    isInState: (stateType: FlowState["type"]) => boolean;
-    hasError: boolean;
-    error: Error | null | undefined;
-    context: (Record<string, any> & import('./flow.types.js').FlowContext) | undefined;
-};
-export type UseBluvoFlowHook = ReturnType<typeof useBluvoFlow>;
-//# sourceMappingURL=useBluvoFlow.d.ts.map

package/dist/widget/bluvo/bluvo-lib/useBluvoFlow.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useBluvoFlow.d.ts","sourceRoot":"","sources":["../../../../src/widget/bluvo/bluvo-lib/useBluvoFlow.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,eAAe,EACf,KAAK,sBAAsB,EAC3B,KAAK,mBAAmB,EACxB,KAAK,2BAA2B,EAChC,KAAK,iCAAiC,EACtC,KAAK,qBAAqB,EAC3B,MAAM,sBAAsB,CAAA;AAC7B,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAIjD,MAAM,WAAW,mBAAoB,SAAQ,sBAAsB;CAAG;AAEtE,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB;6BA4GrC,MAAM,GAAG,SAAS,GAAG,aAAa,GAAG,aAAa;uCArF9C,qBAAqB;;;;;;;wCAYrB,2BAA2B;;;;8CAS3B,iCAAiC;;;iCAahC,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAOxB,MAAM;sBAOT,MAAM;sBAON,MAAM;mCAWF,QAAQ,GAAG,OAAO,GAAG,KAAK,QAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CAiExC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAjHzB,CAAA;;wBAE8C,CAAC;;;gBACH,CAAC;mBACzC,CAAA;;;;;;;;;;;;;;yBAW4B,CAAC;;;;;;;;;;;;;;;;oBAiCxB,CAAC;qBAAkB,CAAA;yBAA0B,CAAC;yBACzC,CAAC;kCAAmC,CAAC;6BAE1C,CAAC;;;;;iBAIK,CAAC;qBAAwB,CAAC;mBAC7B,CAAC;;;;;;sBAMkC,CAAA;qBAC/B,CAAC;oBAAsB,CAAC;mBAC3B,CAAC;4BAEU,CAAC;;;;;;;;;iBAlBG,CAAA;qBAA0B,CAAC;qBACzC,CAAC;8BAAmC,CAAC;yBAE1C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsQX;AAED,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAA"}

package/dist/widget/bluvo/bluvo-lib/useBluvoFlow.js

@@ -1,152 +0,0 @@
-"use client";
-import { BluvoFlowClient as I } from "./BluvoFlowClient.js";
-import { useFlowMachine as b } from "./useFlowMachine.js";
-import { useCallback as a, useEffect as G, useRef as B, useState as l } from "react";
-function k(w) {
-  const [r] = l(() => new I(w)), [h, c] = l(null), [d, m] = l([]), [y, p] = l(!1), [f, u] = l(null), n = B(null), e = b(h), F = a(async (t) => {
-    const s = await r.startWithdrawalFlow(t);
-    return c(s.machine), s.closeOAuthWindow && (n.current = s.closeOAuthWindow), s;
-  }, [r]), A = a(async (t) => {
-    const s = await r.resumeWithdrawalFlow(t);
-    return c(s.machine), s;
-  }, [r]), x = a(async (t) => {
-    const s = await r.silentResumeWithdrawalFlow(t);
-    return s ? (c(s.machine), s) : (console.error("Error resuming withdrawal flow silently"), null);
-  }, [r]), g = a(async (t) => await r.requestQuote(t), [r]), S = a(async (t) => await r.executeWithdrawal(t), [r]), C = a(async (t) => await r.submit2FA(t), [r]), E = a(async (t) => await r.submitSMS(t), [r]), q = a(async () => await r.retryWithdrawal(), [r]), R = a(async (t, s) => await r.submit2FAMultiStep(t, s), [r]), W = a(async () => await r.pollFaceVerification(), [r]), M = a(async () => await r.pollRoamingFidoVerification(), [r]), O = a(async () => await r.confirmWithdrawal(), [r]), Q = a(async (t) => {
-    p(!0), u(null);
-    try {
-      const s = await r.loadExchanges(t);
-      if (!s)
-        return console.error("Error loading exchanges"), null;
-      if (!s.success) {
-        const o = new Error(s.error || "Failed to load exchanges");
-        throw u(o), o;
-      }
-      const i = s.exchanges || s.result || [];
-      return m(i), i;
-    } catch (s) {
-      const i = s instanceof Error ? s : /* @__PURE__ */ new Error("Failed to load exchanges");
-      throw u(i), i;
-    } finally {
-      p(!1);
-    }
-  }, [r]), v = a(() => {
-    r.cancel(), c(null), n.current && (n.current(), n.current = null);
-  }, [r]), L = a(async () => await r.refreshQRCode(), [r]), V = a((t) => {
-    r.testWithdrawalComplete(t);
-  }, [r]);
-  return G(() => () => {
-    r.dispose(), n.current && n.current();
-  }, [r]), {
-    ...e,
-    listExchanges: Q,
-    startWithdrawalFlow: F,
-    resumeWithdrawalFlow: A,
-    silentResumeWithdrawalFlow: x,
-    requestQuote: g,
-    executeWithdrawal: S,
-    submit2FA: C,
-    submitSMS: E,
-    submit2FAMultiStep: R,
-    pollFaceVerification: W,
-    pollRoamingFidoVerification: M,
-    confirmWithdrawal: O,
-    retryWithdrawal: q,
-    cancel: v,
-    refreshQRCode: L,
-    testWithdrawalComplete: V,
-    isIdle: e.state?.type === "idle",
-    isFlowCancelled: e.state?.type === "flow:cancelled",
-    isExchangesLoading: y || e.state?.type === "exchanges:loading",
-    isExchangesReady: e.state?.type === "exchanges:ready" || d.length > 0,
-    isExchangesError: e.state?.type === "exchanges:error",
-    exchangesError: f || e.state?.type === "exchanges:error" && e.error || null,
-    isOAuthPending: e.state?.type === "oauth:waiting" || e.state?.type === "oauth:processing",
-    isOAuthWaiting: e.state?.type === "oauth:waiting",
-    isOAuthProcessing: e.state?.type === "oauth:processing",
-    isOAuthError: e.state?.type === "oauth:error" || e.state?.type === "oauth:fatal",
-    isOAuthFatal: e.state?.type === "oauth:fatal",
-    isWalletConnectionInvalid: e.state?.type === "oauth:fatal" || e.state?.type === "qrcode:fatal",
-    isOAuthComplete: e.state?.type === "oauth:completed",
-    isOAuthWindowBeenClosedByTheUser: e.state?.type === "oauth:window_closed_by_user",
-    isQRCodePending: e.state?.type?.startsWith("qrcode:") && ![
-      "qrcode:error",
-      "qrcode:fatal",
-      "qrcode:timeout"
-    ].includes(e.state?.type || ""),
-    isQRCodeWaiting: e.state?.type === "qrcode:waiting",
-    isQRCodeDisplaying: e.state?.type === "qrcode:displaying",
-    isQRCodeScanning: e.state?.type === "qrcode:scanning",
-    isQRCodeError: e.state?.type === "qrcode:error" || e.state?.type === "qrcode:fatal",
-    isQRCodeFatal: e.state?.type === "qrcode:fatal",
-    isQRCodeTimeout: e.state?.type === "qrcode:timeout",
-    qrCodeUrl: e.context?.qrCodeUrl,
-    qrCodeExpiresAt: e.context?.qrCodeExpiresAt,
-    qrCodeStatus: e.context?.qrCodeStatus,
-    isQRCodeFlow: e.context?.isQRCodeFlow || !1,
-    isWalletLoading: e.state?.type === "wallet:loading",
-    isWalletError: e.state?.type === "wallet:error",
-    isWalletReady: e.state?.type === "wallet:ready",
-    isQuoteLoading: e.state?.type === "quote:requesting",
-    isQuoteReady: e.state?.type === "quote:ready",
-    isQuoteExpired: e.state?.type === "quote:expired",
-    isQuoteError: e.state?.type === "quote:error",
-    isWithdrawing: e.state?.type === "withdraw:processing" || e.state?.type === "withdraw:retrying" || !1,
-    isWithdrawProcessing: e.state?.type === "withdraw:processing",
-    isWithdrawalComplete: e.state?.type === "withdraw:completed",
-    isWithdrawBlocked: e.state?.type === "withdraw:blocked",
-    hasFatalError: e.state?.type === "withdraw:fatal",
-    requires2FA: e.state?.type === "withdraw:error2FA",
-    requires2FAMultiStep: e.state?.type === "withdraw:error2FAMultiStep",
-    isReadyToConfirm: e.state?.type === "withdraw:readyToConfirm",
-    requiresSMS: e.state?.type === "withdraw:errorSMS",
-    requiresKYC: e.state?.type === "withdraw:errorKYC",
-    requiresValid2FAMethod: e.state?.type === "withdraw:fatal" && !!e.context?.errorDetails?.valid2FAMethods || !1,
-    requiresEmailVerification: e.state?.type === "withdraw:fatal" && e.error?.message?.includes("email") || !1,
-    hasInsufficientBalance: e.state?.type === "withdraw:errorBalance",
-    canRetry: e.state?.type === "withdraw:retrying",
-    hasAmountError: (e.state?.type === "quote:error" || e.state?.type === "withdraw:fatal") && (e.error?.message?.toLowerCase().includes("amount") || e.error?.message?.includes("minimum") || e.error?.message?.includes("maximum")) || !1,
-    hasAddressError: (e.state?.type === "quote:error" || e.state?.type === "withdraw:fatal") && (e.error?.message?.toLowerCase().includes("address") || e.error?.message?.toLowerCase().includes("invalid destination")) || !1,
-    hasNetworkError: (e.state?.type === "quote:error" || e.state?.type === "withdraw:fatal") && e.error?.message?.toLowerCase().includes("network") || !1,
-    hasWalletNotFoundError: e.state?.type === "wallet:error" && e.error?.message?.toLowerCase().includes("not found") || !1,
-    hasInvalidCredentialsError: e.state?.type === "wallet:error" && e.error?.message?.toLowerCase().includes("invalid") && e.error?.message?.toLowerCase().includes("credential") || !1,
-    invalid2FAAttempts: e.context?.invalid2FAAttempts || 0,
-    retryAttempts: e.context?.retryAttempts || 0,
-    maxRetryAttempts: e.context?.maxRetryAttempts || 3,
-    exchanges: e.context?.exchanges || d,
-    walletBalances: e.context?.walletBalances || [],
-    quote: e.context?.quote,
-    withdrawal: e.context?.withdrawal,
-    valid2FAMethods: e.context?.errorDetails?.valid2FAMethods,
-    multiStep2FA: e.context?.multiStep2FA,
-    multiStep2FASteps: e.context?.multiStep2FA?.steps || [],
-    multiStep2FABizNo: e.context?.multiStep2FA?.bizNo,
-    multiStep2FARelation: e.context?.multiStep2FA?.relation,
-    collectedMultiStep2FACodes: e.context?.multiStep2FA?.collectedCodes,
-    hasGoogleStep: e.context?.multiStep2FA?.steps?.some((t) => t.type === "GOOGLE") || !1,
-    hasEmailStep: e.context?.multiStep2FA?.steps?.some((t) => t.type === "EMAIL") || !1,
-    hasFaceStep: e.context?.multiStep2FA?.steps?.some((t) => t.type === "FACE") || !1,
-    hasRoamingFidoStep: e.context?.multiStep2FA?.steps?.some((t) => t.type === "ROAMING_FIDO") || !1,
-    hasSmsStep: e.context?.multiStep2FA?.steps?.some((t) => t.type === "SMS") || !1,
-    isGoogleStepVerified: e.context?.multiStep2FA?.mfa?.verified?.GOOGLE === !0 || e.context?.multiStep2FA?.steps?.find((t) => t.type === "GOOGLE")?.status === "success",
-    isEmailStepVerified: e.context?.multiStep2FA?.mfa?.verified?.EMAIL === !0 || e.context?.multiStep2FA?.steps?.find((t) => t.type === "EMAIL")?.status === "success",
-    isFaceStepVerified: e.context?.multiStep2FA?.mfa?.verified?.FACE === !0 || e.context?.multiStep2FA?.steps?.find((t) => t.type === "FACE")?.status === "success",
-    isRoamingFidoStepVerified: e.context?.multiStep2FA?.mfa?.verified?.ROAMING_FIDO === !0 || e.context?.multiStep2FA?.steps?.find((t) => t.type === "ROAMING_FIDO")?.status === "success",
-    isSmsStepVerified: e.context?.multiStep2FA?.mfa?.verified?.SMS === !0 || e.context?.multiStep2FA?.steps?.find((t) => t.type === "SMS")?.status === "success",
-    mfaVerified: e.context?.multiStep2FA?.mfa?.verified,
-    allMultiStep2FAStepsVerified: (() => {
-      const t = e.context?.multiStep2FA;
-      if (!t?.steps) return !1;
-      const s = t.steps.filter((o) => o.required);
-      if (s.length === 0) return !1;
-      const i = t.mfa?.verified;
-      return i ? s.every((o) => i[o.type] === !0) : s.every((o) => o.status === "success");
-    })(),
-    faceQrCodeUrl: e.context?.multiStep2FA?.faceQrCodeUrl,
-    faceQrCodeExpiresAt: e.context?.multiStep2FA?.faceQrCodeExpiresAt,
-    client: r
-  };
-}
-export {
-  k as useBluvoFlow
-};

package/dist/widget/bluvo/bluvo-lib/useFlowMachine.d.ts

@@ -1,11 +0,0 @@
-import { FlowActionType, FlowState } from './flow.types.js';
-import { Machine } from './machine.types.js';
-export declare function useFlowMachine(machine: Machine<FlowState, FlowActionType> | null): {
-    state: FlowState | null;
-    send: (action: FlowActionType) => void;
-    isInState: (stateType: FlowState["type"]) => boolean;
-    hasError: boolean;
-    error: Error | null | undefined;
-    context: (Record<string, any> & import('./flow.types.js').FlowContext) | undefined;
-};
-//# sourceMappingURL=useFlowMachine.d.ts.map

package/dist/widget/bluvo/bluvo-lib/useFlowMachine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useFlowMachine.d.ts","sourceRoot":"","sources":["../../../../src/widget/bluvo/bluvo-lib/useFlowMachine.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAEjD,wBAAgB,cAAc,CAC5B,OAAO,EAAE,OAAO,CAAC,SAAS,EAAE,cAAc,CAAC,GAAG,IAAI;;mBAwBhB,cAAc;2BAOvB,SAAS,CAAC,MAAM,CAAC;;;;EAK3C"}

package/dist/widget/bluvo/bluvo-lib/useFlowMachine.js

@@ -1,25 +0,0 @@
-import { useCallback as n, useEffect as o, useRef as l, useState as f } from "react";
-function a(t) {
-  const [e, s] = f(() => t?.getState() || null), u = l(t);
-  return u.current = t, o(() => {
-    if (!t) {
-      s(null);
-      return;
-    }
-    return s(t.getState()), t.subscribe((r) => {
-      s(r);
-    });
-  }, [t]), {
-    state: e,
-    send: n((r) => {
-      u.current?.send(r);
-    }, []),
-    isInState: (r) => e?.type === r,
-    hasError: e?.error !== null,
-    error: e?.error,
-    context: e?.context
-  };
-}
-export {
-  a as useFlowMachine
-};

package/dist/widget/bluvo/bluvo-lib/useWithdrawMachine.d.ts

@@ -1,17 +0,0 @@
-import { Machine } from './machine.types.js';
-import { WithdrawalActionType, WithdrawalState } from './withdrawal.types.js';
-export declare function useWithdrawMachine(machine: Machine<WithdrawalState, WithdrawalActionType> | null): {
-    state: WithdrawalState | null;
-    send: (action: WithdrawalActionType) => void;
-    isInState: (stateType: WithdrawalState["type"]) => boolean;
-    hasError: boolean;
-    error: Error | null | undefined;
-    context: (Record<string, any> & import('./withdrawal.types.js').WithdrawalContext) | undefined;
-    requires2FA: boolean;
-    requiresSMS: boolean;
-    requiresKYC: boolean;
-    isCompleted: boolean;
-    isBlocked: boolean;
-    canRetry: boolean;
-};
-//# sourceMappingURL=useWithdrawMachine.d.ts.map

package/dist/widget/bluvo/bluvo-lib/useWithdrawMachine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useWithdrawMachine.d.ts","sourceRoot":"","sources":["../../../../src/widget/bluvo/bluvo-lib/useWithdrawMachine.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AACjD,OAAO,KAAK,EACV,oBAAoB,EACpB,eAAe,EAChB,MAAM,uBAAuB,CAAA;AAE9B,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,OAAO,CAAC,eAAe,EAAE,oBAAoB,CAAC,GAAG,IAAI;;mBAwB5B,oBAAoB;2BAO7B,eAAe,CAAC,MAAM,CAAC;;;;;;;;;;EAYjD"}

package/dist/widget/bluvo/bluvo-lib/withdrawal.types.d.ts

@@ -1,46 +0,0 @@
-import { StateValue } from './machine.types.js';
-export type WithdrawalStateType = "idle" | "processing" | "waitingFor2FA" | "waitingForSMS" | "waitingForKYC" | "retrying" | "completed" | "blocked" | "failed";
-export interface WithdrawalContext {
-    quoteId: string;
-    walletId: string;
-    idempotencyKey: string;
-    retryCount: number;
-    maxRetries: number;
-    lastError?: Error;
-    transactionId?: string;
-    requiredActions?: Array<"2fa" | "sms" | "kyc">;
-    twoFactorCode?: string;
-    smsCode?: string;
-}
-export type WithdrawalState = StateValue<WithdrawalStateType> & {
-    context: WithdrawalContext;
-};
-export type WithdrawalActionType = {
-    type: "EXECUTE";
-    quoteId: string;
-    walletId: string;
-} | {
-    type: "REQUIRES_2FA";
-} | {
-    type: "REQUIRES_SMS";
-} | {
-    type: "REQUIRES_KYC";
-} | {
-    type: "SUBMIT_2FA";
-    code: string;
-} | {
-    type: "SUBMIT_SMS";
-    code: string;
-} | {
-    type: "RETRY";
-} | {
-    type: "SUCCESS";
-    transactionId?: string;
-} | {
-    type: "BLOCKED";
-    reason: string;
-} | {
-    type: "FAIL";
-    error: Error;
-};
-//# sourceMappingURL=withdrawal.types.d.ts.map

package/dist/widget/bluvo/bluvo-lib/withdrawal.types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"withdrawal.types.d.ts","sourceRoot":"","sources":["../../../../src/widget/bluvo/bluvo-lib/withdrawal.types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAEpD,MAAM,MAAM,mBAAmB,GAC3B,MAAM,GACN,YAAY,GACZ,eAAe,GACf,eAAe,GACf,eAAe,GACf,UAAU,GACV,WAAW,GACX,SAAS,GACT,QAAQ,CAAA;AAEZ,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,cAAc,EAAE,MAAM,CAAA;IACtB,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,KAAK,CAAA;IACjB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,eAAe,CAAC,EAAE,KAAK,CAAC,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC,CAAA;IAC9C,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,mBAAmB,CAAC,GAAG;IAC9D,OAAO,EAAE,iBAAiB,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,oBAAoB,GAC5B;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACtD;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,GACxB;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,GACxB;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,GACxB;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,GAC3C;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACnC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAA"}

package/dist/widget/bluvo/bluvo-lib/withdrawalErrorHandler.d.ts

@@ -1,29 +0,0 @@
-import { FlowActionType, FlowState } from './flow.types.js';
-import { Machine } from './machine.types.js';
-import { BluvoError } from './error-codes.js';
-/**
- * Maps error codes to flow machine actions
- * Centralized error handling logic to avoid duplication
- */
-export declare class WithdrawalErrorHandler {
-    /**
-     * Handle withdrawal execution errors and send appropriate actions to the flow machine
-     * @param error The error to handle
-     * @param flowMachine The flow machine to send actions to
-     * @returns True if the error was handled, false otherwise
-     */
-    static handleWithdrawalError(error: BluvoError, flowMachine: Machine<FlowState, FlowActionType> | undefined): boolean;
-    /**
-     * Map error code to flow machine action
-     */
-    private static mapErrorCodeToAction;
-    /**
-     * Check if an error is recoverable (can retry or provide additional info)
-     */
-    static isRecoverableError(error: BluvoError): boolean;
-    /**
-     * Check if an error is fatal (cannot recover)
-     */
-    static isFatalError(error: BluvoError): boolean;
-}
-//# sourceMappingURL=withdrawalErrorHandler.d.ts.map

package/dist/widget/bluvo/bluvo-lib/withdrawalErrorHandler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"withdrawalErrorHandler.d.ts","sourceRoot":"","sources":["../../../../src/widget/bluvo/bluvo-lib/withdrawalErrorHandler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AACrD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,EACL,KAAK,UAAU,EAKhB,MAAM,kBAAkB,CAAA;AAEzB;;;GAGG;AAEH,qBAAa,sBAAsB;IACjC;;;;;OAKG;IACH,MAAM,CAAC,qBAAqB,CAC1B,KAAK,EAAE,UAAU,EACjB,WAAW,EAAE,OAAO,CAAC,SAAS,EAAE,cAAc,CAAC,GAAG,SAAS,GAC1D,OAAO;IAiBV;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAmLnC;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO;IAyBrD;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO;CAGhD"}