@n1xyz/wallet-widget 0.0.1 → 0.0.5

package/dist/Modal/NordFlow/constants.js

@@ -0,0 +1,192 @@
+import { FlowState } from './types';
+export var ANIMATION_EASE = 'cubic-bezier(0.16, 1, 0.3, 1)';
+export var TYPING_INTERVAL = 50;
+export var ANIMATION_DURATION = 3000;
+export var MIN_DEPOSIT = 10000;
+export var MAX_DEPOSIT = 10000;
+export var INITIAL_APPS = Array.from({ length: 20 }, function (_, i) { return ({
+    name: "App".concat(i + 1),
+    color: '#ff2b1f',
+    progress: 0,
+}); });
+/**
+ * Available chains for deposit
+ */
+export var AVAILABLE_CHAINS = [
+    {
+        id: 'ethereum',
+        name: 'Ethereum',
+        logo: 'ethereum-logo.svg',
+    },
+    {
+        id: 'solana',
+        name: 'Solana',
+        logo: 'solana-logo.svg',
+    },
+];
+export var CHAINS = [
+    {
+        id: 'ethereum',
+        name: 'Ethereum',
+        logo: '/images/chains/ethereum.svg',
+    },
+    {
+        id: 'polygon',
+        name: 'Polygon',
+        logo: '/images/chains/polygon.svg',
+    },
+    {
+        id: 'arbitrum',
+        name: 'Arbitrum',
+        logo: '/images/chains/arbitrum.svg',
+    },
+    {
+        id: 'optimism',
+        name: 'Optimism',
+        logo: '/images/chains/optimism.svg',
+    },
+];
+/**
+ * State machine transitions
+ * Defines all possible transitions between states and their conditions
+ */
+export var STATE_TRANSITIONS = [
+    // From IDLE state
+    {
+        from: FlowState.IDLE,
+        to: FlowState.CONNECTING_WALLET,
+        condition: function (context) { return !context.walletType; }, // Only if wallet is not connected
+    },
+    {
+        from: FlowState.CONNECTING_WALLET,
+        to: FlowState.ERROR,
+        // When wallet connection fails
+    },
+    {
+        from: FlowState.CONNECTING_WALLET,
+        to: FlowState.CHAIN_SELECTION,
+        condition: function (context) {
+            return context.walletType === 'solana';
+        }, // If Solana wallet and no Nord account
+    },
+    {
+        from: FlowState.CONNECTING_WALLET,
+        to: FlowState.AUTH_LOADING,
+        condition: function (context) {
+            return context.walletType === 'solana' && context.hasNordAccount;
+        }, // If Solana wallet and no Nord account
+    },
+    {
+        from: FlowState.CONNECTING_WALLET,
+        to: FlowState.FINAL_SUCCESS,
+        condition: function (context) {
+            return context.walletType === 'solana' && context.hasNordAccount && context.hasActiveSession;
+        }, // If Solana wallet and no Nord account
+    },
+    // From ETH_TO_SOL_AUTH state
+    {
+        from: FlowState.ETH_TO_SOL_AUTH,
+        to: FlowState.CHAIN_SELECTION,
+        condition: function (context) { return !context.hasNordAccount; }, // After ETH auth, if no Nord account
+    },
+    {
+        from: FlowState.ETH_TO_SOL_AUTH,
+        to: FlowState.AUTH_LOADING,
+        condition: function (context) { return context.hasNordAccount && !context.hasActiveSession; },
+        // After ETH auth, if has Nord account but no active session
+    },
+    {
+        from: FlowState.ETH_TO_SOL_AUTH,
+        to: FlowState.FINAL_SUCCESS,
+        condition: function (context) { return context.hasNordAccount && context.hasActiveSession; },
+        // After ETH auth, if has Nord account and active session
+    },
+    {
+        from: FlowState.ETH_TO_SOL_AUTH,
+        to: FlowState.ERROR,
+        // If ETH to SOL auth fails
+    },
+    // From CHAIN_SELECTION state
+    {
+        from: FlowState.CHAIN_SELECTION,
+        to: FlowState.AMOUNT_INPUT,
+        // After chain selection
+    },
+    // From AMOUNT_INPUT state
+    {
+        from: FlowState.AMOUNT_INPUT,
+        to: FlowState.DEPOSIT_PROGRESS,
+        // After amount input
+    },
+    {
+        from: FlowState.AMOUNT_INPUT,
+        to: FlowState.CHAIN_SELECTION,
+        // If user goes back to chain selection
+    },
+    // From DEPOSIT_PROGRESS state
+    {
+        from: FlowState.DEPOSIT_PROGRESS,
+        to: FlowState.DEPOSIT_SUCCESS,
+        // When deposit is successful
+    },
+    {
+        from: FlowState.DEPOSIT_PROGRESS,
+        to: FlowState.ERROR,
+        // When deposit fails
+    },
+    // From DEPOSIT_SUCCESS state
+    {
+        from: FlowState.DEPOSIT_SUCCESS,
+        to: FlowState.AUTH_LOADING,
+        condition: function (context) { return !context.hasActiveSession; }, // If no active Nord session
+    },
+    {
+        from: FlowState.DEPOSIT_SUCCESS,
+        to: FlowState.FINAL_SUCCESS,
+        condition: function (context) { return context.hasActiveSession; }, // If active Nord session exists
+    },
+    {
+        from: FlowState.AUTH_LOADING,
+        to: FlowState.ERROR,
+        // When Nord auth fails to start
+    },
+    // From AUTH_LOADING state
+    {
+        from: FlowState.AUTH_LOADING,
+        to: FlowState.FINAL_SUCCESS,
+        // When auth is successful
+    },
+    {
+        from: FlowState.AUTH_LOADING,
+        to: FlowState.ERROR,
+        // When auth fails
+    },
+    // From ERROR state
+    {
+        from: FlowState.ERROR,
+        to: FlowState.IDLE,
+        // When restarting after error
+    },
+    // Global recovery transition (can happen from any state upon recovery)
+    {
+        from: [
+            FlowState.CONNECTING_WALLET,
+            FlowState.ETH_TO_SOL_AUTH,
+            FlowState.CHAIN_SELECTION,
+            FlowState.AMOUNT_INPUT,
+            FlowState.DEPOSIT_PROGRESS,
+            FlowState.DEPOSIT_SUCCESS,
+            FlowState.AUTH_LOADING,
+        ],
+        to: FlowState.IDLE,
+        // For recovery after interruption
+    },
+];
+/**
+ * Local storage key for persisting flow state
+ */
+export var FLOW_STATE_STORAGE_KEY = 'n1_wallet_connection_flow_state';
+/**
+ * Time in milliseconds after which a persisted state is considered stale
+ */
+export var STATE_EXPIRY_TIME = 30 * 60 * 1000; // 30 minutes

package/dist/Modal/NordFlow/hoc/index.d.ts

@@ -0,0 +1 @@
+export * from './withImageFallback';

package/dist/Modal/NordFlow/hoc/index.js

@@ -0,0 +1 @@
+export * from './withImageFallback';

package/dist/Modal/NordFlow/hoc/withImageFallback.d.ts

@@ -0,0 +1,7 @@
+import React, { ComponentType } from 'react';
+/**
+ * A Higher-Order Component (HOC) that adds image fallback functionality to a component
+ * @param WrappedComponent The component to wrap
+ * @returns A new component with image fallback functionality
+ */
+export declare function withImageFallback<P extends object>(WrappedComponent: ComponentType<P>): React.FC<P>;

package/dist/Modal/NordFlow/hoc/withImageFallback.js

@@ -0,0 +1,60 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { ImageWithFallback } from '../components';
+/**
+ * A Higher-Order Component (HOC) that adds image fallback functionality to a component
+ * @param WrappedComponent The component to wrap
+ * @returns A new component with image fallback functionality
+ */
+export function withImageFallback(WrappedComponent) {
+    // Create a new component that wraps the original component
+    var WithImageFallback = function (props) {
+        // Function to recursively process React elements
+        var processNode = function (node) {
+            if (!React.isValidElement(node)) {
+                return node;
+            }
+            var element = node;
+            // If it's an img element, replace it with ImageWithFallback
+            if (element.type === 'img') {
+                var _a = element.props, src = _a.src, alt = _a.alt, width = _a.width, height = _a.height, className = _a.className, rest = __rest(_a, ["src", "alt", "width", "height", "className"]);
+                return (_jsx(ImageWithFallback, __assign({ src: src, alt: alt || 'Image', width: width, height: height, className: className }, rest)));
+            }
+            // If it has children, process them recursively
+            if (element.props && element.props.children) {
+                var children = React.Children.map(element.props.children, processNode);
+                return React.cloneElement(element, __assign({}, element.props), children);
+            }
+            return element;
+        };
+        // Render the wrapped component and process its output
+        var renderedComponent = _jsx(WrappedComponent, __assign({}, props));
+        return processNode(renderedComponent);
+    };
+    // Set display name for debugging
+    var wrappedComponentName = WrappedComponent.displayName || WrappedComponent.name || 'Component';
+    WithImageFallback.displayName = "withImageFallback(".concat(wrappedComponentName, ")");
+    return WithImageFallback;
+}

package/dist/Modal/NordFlow/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export * from './useDepositFlow';
+export * from './useNordWalletConnect';
+export * from './useInterruptHandler';
+export * from './useFlowState';
+export * from './useNordInstance';

package/dist/Modal/NordFlow/hooks/index.js

@@ -0,0 +1,5 @@
+export * from './useDepositFlow';
+export * from './useNordWalletConnect';
+export * from './useInterruptHandler';
+export * from './useFlowState';
+export * from './useNordInstance';

package/dist/Modal/NordFlow/hooks/useButtonTyping.d.ts

@@ -0,0 +1,7 @@
+import { Dispatch, SetStateAction } from 'react';
+import { ButtonKey, ButtonStates } from '../types';
+interface ButtonConfig {
+    text: string;
+}
+export declare function useButtonTyping(buttonStates: ButtonStates, setButtonStates: Dispatch<SetStateAction<ButtonStates>>, buttonConfigs?: Record<ButtonKey, ButtonConfig>): void;
+export {};

package/dist/Modal/NordFlow/hooks/useButtonTyping.js

@@ -0,0 +1,43 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { useEffect } from 'react';
+import { TYPING_INTERVAL } from '../constants';
+var DEFAULT_BUTTON_CONFIGS = {
+    deposit: { text: 'Deposit' },
+    continue: { text: 'Continue' },
+    openApp: { text: 'Launch' },
+};
+export function useButtonTyping(buttonStates, setButtonStates, buttonConfigs) {
+    if (buttonConfigs === void 0) { buttonConfigs = DEFAULT_BUTTON_CONFIGS; }
+    useEffect(function () {
+        Object.entries(buttonStates).forEach(function (_a) {
+            var key = _a[0], state = _a[1];
+            if (state.isTyping) {
+                var config_1 = buttonConfigs[key];
+                var index_1 = 0;
+                var interval_1 = setInterval(function () {
+                    if (index_1 <= config_1.text.length) {
+                        setButtonStates(function (prev) {
+                            var _a;
+                            return (__assign(__assign({}, prev), (_a = {}, _a[key] = __assign(__assign({}, prev[key]), { text: config_1.text.slice(0, index_1) }), _a)));
+                        });
+                        index_1++;
+                    }
+                    else {
+                        clearInterval(interval_1);
+                    }
+                }, TYPING_INTERVAL);
+                return function () { return clearInterval(interval_1); };
+            }
+        });
+    }, [buttonStates, setButtonStates, buttonConfigs]);
+}

package/dist/Modal/NordFlow/hooks/useDepositFlow.d.ts

@@ -0,0 +1,52 @@
+import { FlowContext, FlowState } from '../types';
+import { TransactionResult } from '../../../Logic/transactionManager';
+/**
+ * Hook for handling the deposit flow
+ *
+ * @param options Configuration options
+ * @returns Deposit flow methods and state
+ */
+export declare const useDepositFlow: (options: {
+    /**
+     * Flow state
+     */
+    state: FlowState;
+    /**
+     * Flow context
+     */
+    context: FlowContext;
+    /**
+     * Transition to a new state
+     */
+    transition: (newState: FlowState, contextUpdates?: Partial<FlowContext>) => boolean;
+    /**
+     * Handle errors
+     */
+    handleError: (error: Error) => void;
+    /**
+     * Update context
+     */
+    updateContext?: (contextUpdates: Partial<FlowContext>) => void;
+}) => {
+    selectedChain: string | null;
+    setSelectedChain: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    amount: string;
+    setAmount: import("react").Dispatch<import("react").SetStateAction<string>>;
+    isDepositing: boolean;
+    transactionId: string | null;
+    transactionResult: TransactionResult | null;
+    selectChain: (chainId: string) => void;
+    updateAmount: (newAmount: string) => void;
+    startDeposit: () => Promise<void>;
+    completeDeposit: () => void;
+    goBackToChainSelection: () => void;
+    getTransactionDetails: () => {
+        amount: string;
+        tx: string;
+        from: string;
+        to: string;
+        network: string;
+        status: string;
+        explorerUrl: string;
+    };
+};