@avail-project/widgets 0.0.1

package/dist/common/hooks/useTransactionExecution.d.ts

@@ -0,0 +1,62 @@
+import { type NexusClient, type OnAllowanceHookData, type OnIntentHookData } from "@avail-project/nexus-core";
+import { type Dispatch, type RefObject, type SetStateAction } from "react";
+import { type TransactionStatus } from "../tx/types";
+import { type SourceSelectionValidation, type TransactionFlowExecutor, type TransactionFlowInputs, type BridgeStepType } from "../types/transaction-flow";
+interface NexusErrorInfo {
+    code: string;
+    message: string;
+    context?: unknown;
+    details?: unknown;
+}
+type NexusErrorHandler = (error: unknown) => NexusErrorInfo;
+interface UseTransactionExecutionProps {
+    operationName: "bridge" | "transfer";
+    nexusSDK: NexusClient | null;
+    intent: RefObject<OnIntentHookData | null>;
+    allowance: RefObject<OnAllowanceHookData | null>;
+    inputs: TransactionFlowInputs;
+    configuredMaxAmount?: string;
+    allAvailableSourceChainIds: number[];
+    sourceChainsForSdk?: number[];
+    sourceSelectionKey: string;
+    sourceSelection: SourceSelectionValidation;
+    loading: boolean;
+    txError: string | null;
+    areInputsValid: boolean;
+    executeTransaction: TransactionFlowExecutor;
+    getMaxForCurrentSelection: () => Promise<string | undefined>;
+    onStepsList: (steps: BridgeStepType[]) => void;
+    onStepComplete: (step: BridgeStepType) => void;
+    resetSteps: () => void;
+    setStatus: (status: TransactionStatus) => void;
+    resetInputs: () => void;
+    setRefreshing: Dispatch<SetStateAction<boolean>>;
+    setIsDialogOpen: Dispatch<SetStateAction<boolean>>;
+    setTxError: Dispatch<SetStateAction<string | null>>;
+    setLastExplorerUrl: Dispatch<SetStateAction<string>>;
+    setSelectedSourceChains: Dispatch<SetStateAction<number[] | null>>;
+    setAppliedSourceSelectionKey: Dispatch<SetStateAction<string>>;
+    stopwatch: {
+        start: () => void;
+        stop: () => void;
+        reset: () => void;
+    };
+    handleNexusError: NexusErrorHandler;
+    onStart?: () => void;
+    onComplete?: (explorerUrl?: string) => void;
+    onError?: (message: string) => void;
+    fetchBalance: () => Promise<void>;
+    notifyHistoryRefresh?: () => void;
+}
+export declare function useTransactionExecution({ operationName, nexusSDK, intent, allowance, inputs, configuredMaxAmount, allAvailableSourceChainIds, sourceChainsForSdk, sourceSelectionKey, sourceSelection, loading, txError, areInputsValid, executeTransaction, getMaxForCurrentSelection, onStepsList, onStepComplete, resetSteps, setStatus, resetInputs, setRefreshing, setIsDialogOpen, setTxError, setLastExplorerUrl, setSelectedSourceChains, setAppliedSourceSelectionKey, stopwatch, handleNexusError, onStart, onComplete, onError, fetchBalance, notifyHistoryRefresh, }: UseTransactionExecutionProps): {
+    refreshIntent: (options?: {
+        reportError?: boolean;
+    }) => Promise<boolean>;
+    handleTransaction: () => Promise<void>;
+    startTransaction: () => void;
+    commitAmount: () => Promise<void>;
+    reset: () => void;
+    invalidatePendingExecution: () => void;
+};
+export {};
+//# sourceMappingURL=useTransactionExecution.d.ts.map

package/dist/common/hooks/useTransactionExecution.d.ts.map

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

package/dist/common/hooks/useTransactionExecution.js

@@ -0,0 +1,273 @@
+import {} from "@avail-project/nexus-core";
+import { useCallback, useRef, } from "react";
+import {} from "../tx/types";
+import {} from "../types/transaction-flow";
+export function useTransactionExecution({ operationName, nexusSDK, intent, allowance, inputs, configuredMaxAmount, allAvailableSourceChainIds, sourceChainsForSdk, sourceSelectionKey, sourceSelection, loading, txError, areInputsValid, executeTransaction, getMaxForCurrentSelection, onStepsList, onStepComplete, resetSteps, setStatus, resetInputs, setRefreshing, setIsDialogOpen, setTxError, setLastExplorerUrl, setSelectedSourceChains, setAppliedSourceSelectionKey, stopwatch, handleNexusError, onStart, onComplete, onError, fetchBalance, notifyHistoryRefresh, }) {
+    const commitLockRef = useRef(false);
+    const runIdRef = useRef(0);
+    const refreshIntent = async (options) => {
+        if (!intent.current)
+            return false;
+        const activeRunId = runIdRef.current;
+        setRefreshing(true);
+        try {
+            const updated = await intent.current.refresh(sourceChainsForSdk);
+            if (activeRunId !== runIdRef.current)
+                return false;
+            if (updated) {
+                intent.current.intent = updated;
+            }
+            setAppliedSourceSelectionKey(sourceSelectionKey);
+            return true;
+        }
+        catch (error) {
+            if (activeRunId !== runIdRef.current)
+                return false;
+            console.error("Transaction failed:", error);
+            if (options?.reportError) {
+                const message = "Unable to refresh source selection. Please try again.";
+                setTxError(message);
+                onError?.(message);
+            }
+            return false;
+        }
+        finally {
+            if (activeRunId === runIdRef.current) {
+                setRefreshing(false);
+            }
+        }
+    };
+    const onSuccess = async (explorerUrl) => {
+        stopwatch.stop();
+        setStatus("success");
+        onComplete?.(explorerUrl);
+        intent.current = null;
+        allowance.current = null;
+        resetInputs();
+        setRefreshing(false);
+        setSelectedSourceChains(null);
+        setAppliedSourceSelectionKey("ALL");
+        await fetchBalance();
+        notifyHistoryRefresh?.();
+    };
+    const handleTransaction = async () => {
+        if (commitLockRef.current)
+            return;
+        commitLockRef.current = true;
+        const currentRunId = ++runIdRef.current;
+        let didEnterExecutingState = false;
+        const cleanupSupersededExecution = () => {
+            if (!didEnterExecutingState)
+                return;
+            setRefreshing(false);
+            setIsDialogOpen(false);
+            setLastExplorerUrl("");
+            stopwatch.stop();
+            stopwatch.reset();
+            resetSteps();
+            setStatus("idle");
+        };
+        try {
+            if (!inputs?.amount ||
+                !inputs?.recipient ||
+                !inputs?.chain ||
+                !inputs?.token) {
+                console.error("Missing required inputs");
+                return;
+            }
+            if (!nexusSDK) {
+                const message = "Nexus SDK not initialized";
+                setTxError(message);
+                onError?.(message);
+                return;
+            }
+            if (allAvailableSourceChainIds.length === 0) {
+                const message = "No eligible source chains available for the selected token and destination.";
+                setTxError(message);
+                onError?.(message);
+                setStatus("error");
+                return;
+            }
+            const parsedAmount = Number(inputs.amount);
+            if (!Number.isFinite(parsedAmount) || parsedAmount <= 0) {
+                const message = "Enter a valid amount greater than 0.";
+                setTxError(message);
+                onError?.(message);
+                setStatus("error");
+                return;
+            }
+            const amountBigInt = nexusSDK.convertTokenReadableAmountToBigInt(inputs.amount, inputs.token, inputs.chain);
+            if (configuredMaxAmount) {
+                const configuredMaxRaw = nexusSDK.convertTokenReadableAmountToBigInt(configuredMaxAmount, inputs.token, inputs.chain);
+                if (amountBigInt > configuredMaxRaw) {
+                    const message = `Amount exceeds maximum limit of ${configuredMaxAmount} ${inputs.token}.`;
+                    setTxError(message);
+                    onError?.(message);
+                    setStatus("error");
+                    return;
+                }
+            }
+            const maxForCurrentSelection = await getMaxForCurrentSelection();
+            if (currentRunId !== runIdRef.current)
+                return;
+            if (!maxForCurrentSelection) {
+                const message = `Unable to determine max ${operationName} amount for selected sources. Please try again.`;
+                setTxError(message);
+                onError?.(message);
+                setStatus("error");
+                return;
+            }
+            const maxForSelectionRaw = nexusSDK.convertTokenReadableAmountToBigInt(maxForCurrentSelection, inputs.token, inputs.chain);
+            if (amountBigInt > maxForSelectionRaw) {
+                const message = `Selected sources can provide up to ${maxForCurrentSelection} ${inputs.token}. Reduce amount or enable more sources.`;
+                setTxError(message);
+                onError?.(message);
+                setStatus("error");
+                return;
+            }
+            setStatus("executing");
+            didEnterExecutingState = true;
+            setTxError(null);
+            onStart?.();
+            setLastExplorerUrl("");
+            setAppliedSourceSelectionKey(sourceSelectionKey);
+            const onEvent = (event) => {
+                if (currentRunId !== runIdRef.current)
+                    return;
+                if (event.type === "plan_preview" || event.type === "plan_confirmed") {
+                    const steps = event.plan.steps.map((step) => ({
+                        ...step,
+                        type: step.type.toUpperCase(),
+                        typeID: step.type.toUpperCase(),
+                        completed: false,
+                    }));
+                    onStepsList(steps);
+                }
+                if (event.type === "plan_progress") {
+                    if (event.stepType === "request_signing" &&
+                        event.state === "completed") {
+                        stopwatch.start();
+                    }
+                    const completed = event.state === "completed" ||
+                        event.state === "confirmed" ||
+                        event.state === "submitted";
+                    if (completed) {
+                        onStepComplete({
+                            ...event.step,
+                            type: event.stepType.toUpperCase(),
+                            typeID: event.stepType.toUpperCase(),
+                            completed: true,
+                        });
+                    }
+                }
+            };
+            const transactionResult = await executeTransaction({
+                token: inputs.token,
+                amount: amountBigInt,
+                toChainId: inputs.chain,
+                recipient: inputs.recipient,
+                sourceChains: sourceChainsForSdk,
+                onEvent,
+            });
+            if (currentRunId !== runIdRef.current) {
+                cleanupSupersededExecution();
+                return;
+            }
+            if (!transactionResult) {
+                throw new Error("Transaction rejected by user");
+            }
+            setLastExplorerUrl(transactionResult.explorerUrl);
+            await onSuccess(transactionResult.explorerUrl);
+        }
+        catch (error) {
+            if (currentRunId !== runIdRef.current) {
+                cleanupSupersededExecution();
+                return;
+            }
+            const { message, code, context, details } = handleNexusError(error);
+            console.error(`Fast ${operationName} transaction failed:`, {
+                code,
+                message,
+                context,
+                details,
+            });
+            intent.current?.deny();
+            intent.current = null;
+            allowance.current = null;
+            setTxError(message);
+            onError?.(message);
+            setIsDialogOpen(false);
+            setSelectedSourceChains(null);
+            setRefreshing(false);
+            stopwatch.stop();
+            stopwatch.reset();
+            resetSteps();
+            void fetchBalance();
+            setStatus("error");
+        }
+        finally {
+            commitLockRef.current = false;
+        }
+    };
+    const reset = () => {
+        runIdRef.current += 1;
+        intent.current?.deny();
+        intent.current = null;
+        allowance.current = null;
+        resetInputs();
+        setStatus("idle");
+        setRefreshing(false);
+        setSelectedSourceChains(null);
+        setAppliedSourceSelectionKey("ALL");
+        setLastExplorerUrl("");
+        stopwatch.stop();
+        stopwatch.reset();
+        resetSteps();
+    };
+    const startTransaction = () => {
+        if (!intent.current)
+            return;
+        if (allAvailableSourceChainIds.length === 0) {
+            const message = "No eligible source chains available for the selected token and destination.";
+            setTxError(message);
+            onError?.(message);
+            return;
+        }
+        if (sourceSelection.isBelowRequired && inputs?.token) {
+            const message = `Selected sources are not enough. Add ${sourceSelection.missingToProceed} ${inputs.token} more to make this transaction.`;
+            setTxError(message);
+            onError?.(message);
+            return;
+        }
+        void (async () => {
+            const refreshed = await refreshIntent({ reportError: true });
+            if (!refreshed || !intent.current)
+                return;
+            intent.current.allow();
+            setIsDialogOpen(true);
+            setTxError(null);
+        })();
+    };
+    const commitAmount = async () => {
+        if (intent.current || loading || txError || !areInputsValid)
+            return;
+        await handleTransaction();
+    };
+    const invalidatePendingExecution = useCallback(() => {
+        runIdRef.current += 1;
+        if (intent.current) {
+            intent.current.deny();
+            intent.current = null;
+        }
+        setRefreshing(false);
+        setAppliedSourceSelectionKey("ALL");
+    }, [intent, setAppliedSourceSelectionKey, setRefreshing]);
+    return {
+        refreshIntent,
+        handleTransaction,
+        startTransaction,
+        commitAmount,
+        reset,
+        invalidatePendingExecution,
+    };
+}

package/dist/common/hooks/useTransactionFlow.d.ts

@@ -0,0 +1,71 @@
+import { type NexusNetwork, type NexusClient, type OnAllowanceHookData, type OnIntentHookData, type TokenBalance } from "@avail-project/nexus-core";
+import { type RefObject } from "react";
+import { type Address } from "viem";
+import { type TransactionStatus } from "../tx/types";
+import { type SourceCoverageState, type TransactionFlowExecutor, type TransactionFlowInputs, type TransactionFlowPrefill, type TransactionFlowType, type BridgeStepType } from "../types/transaction-flow";
+interface BaseTransactionFlowProps {
+    type: TransactionFlowType;
+    network: NexusNetwork;
+    nexusSDK: NexusClient | null;
+    intent: RefObject<OnIntentHookData | null>;
+    allowance: RefObject<OnAllowanceHookData | null>;
+    bridgableBalance: TokenBalance[] | null;
+    prefill?: TransactionFlowPrefill;
+    onComplete?: (explorerUrl?: string) => void;
+    onStart?: () => void;
+    onError?: (message: string) => void;
+    fetchBalance: () => Promise<void>;
+    maxAmount?: string | number;
+    isSourceMenuOpen?: boolean;
+    notifyHistoryRefresh?: () => void;
+    executeTransaction: TransactionFlowExecutor;
+}
+export interface UseTransactionFlowProps extends BaseTransactionFlowProps {
+    connectedAddress?: Address;
+}
+export declare function useTransactionFlow(props: UseTransactionFlowProps): {
+    inputs: TransactionFlowInputs;
+    setInputs: (next: TransactionFlowInputs | Partial<TransactionFlowInputs>) => void;
+    timer: number;
+    setIsDialogOpen: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    setTxError: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    loading: boolean;
+    refreshing: boolean;
+    isDialogOpen: boolean;
+    txError: string | null;
+    handleTransaction: () => Promise<void>;
+    reset: () => void;
+    filteredBridgableBalance: {
+        breakdown: any;
+        balance: string;
+        value: string;
+        chainBalances: import("@avail-project/nexus-core").ChainBalance[];
+        currencyId?: number;
+        decimals: number;
+        logo: string;
+        name: string;
+        symbol: string;
+    } | undefined;
+    startTransaction: () => void;
+    commitAmount: () => Promise<void>;
+    lastExplorerUrl: string;
+    steps: import("..").GenericStep<BridgeStepType>[];
+    status: TransactionStatus;
+    availableSources: any;
+    selectedSourceChains: any;
+    toggleSourceChain: (chainId: number) => void;
+    isSourceSelectionInsufficient: boolean;
+    isSourceSelectionBelowSafetyBuffer: boolean;
+    isSourceSelectionReadyForAccept: boolean;
+    sourceCoverageState: SourceCoverageState;
+    sourceCoveragePercent: number;
+    missingToProceed: string;
+    missingToSafety: string;
+    selectedTotal: string;
+    requiredTotal: string;
+    requiredSafetyTotal: string;
+    maxAvailableAmount: string | undefined;
+    isInputsValid: boolean;
+};
+export {};
+//# sourceMappingURL=useTransactionFlow.d.ts.map

package/dist/common/hooks/useTransactionFlow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTransactionFlow.d.ts","sourceRoot":"","sources":["../../../.build-src/common/hooks/useTransactionFlow.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EAClB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAOL,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,KAAK,OAAO,EAAyB,MAAM,MAAM,CAAC;AAO3D,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC3B,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACpB,MAAM,2BAA2B,CAAC;AAUnC,UAAU,wBAAwB;IAChC,IAAI,EAAE,mBAAmB,CAAC;IAC1B,OAAO,EAAE,YAAY,CAAC;IACtB,QAAQ,EAAE,WAAW,GAAG,IAAI,CAAC;IAC7B,MAAM,EAAE,SAAS,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAC;IAC3C,SAAS,EAAE,SAAS,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAAC;IACjD,gBAAgB,EAAE,YAAY,EAAE,GAAG,IAAI,CAAC;IACxC,OAAO,CAAC,EAAE,sBAAsB,CAAC;IACjC,UAAU,CAAC,EAAE,CAAC,WAAW,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5C,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,YAAY,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAClC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC5B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,oBAAoB,CAAC,EAAE,MAAM,IAAI,CAAC;IAClC,kBAAkB,EAAE,uBAAuB,CAAC;CAC7C;AAED,MAAM,WAAW,uBAAwB,SAAQ,wBAAwB;IACvE,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAYD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,uBAAuB;;sBAmDvD,qBAAqB,GAAG,OAAO,CAAC,qBAAqB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCA6KlD,MAAM;;;;;;;;;;;;;EA6SnB"}