@hashport/react-client/dist/contexts/processingTransaction.js

React Context for hashport bridging operations

import { jsx as _jsx } from "react/jsx-runtime";
import { useBridgeParamsDispatch, useHashportClient, useHashportTransactionQueue } from '../hooks';
import { createContext, useCallback, useMemo, useReducer } from 'react';
export const ProcessingTransactionContext = createContext(null);
export const ProcessTransactionDispatchContext = createContext(null);
const processingTransactionReducer = (_, { type, payload }) => {
    switch (type) {
        case 'idle': {
            return { status: 'idle' };
        }
        case 'processing': {
            const { id } = payload;
            return { status: 'processing', id };
        }
        case 'complete': {
            const { confirmation, id } = payload;
            return { status: 'complete', id, confirmation };
        }
        case 'error': {
            const { error, id } = payload;
            return { status: 'error', id, error };
        }
    }
};
export const ProcessingTransactionProvider = ({ children }) => {
    const hashportClient = useHashportClient();
    const { resetBridgeParams } = useBridgeParamsDispatch();
    const [state, dispatch] = useReducer(processingTransactionReducer, { status: 'idle' });
    const transactionQueue = useHashportTransactionQueue();
    const currentTransaction = transactionQueue.get(state.id ?? '');
    const executeTransaction = useCallback(async (id) => {
        try {
            dispatch({ type: 'processing', payload: { id } });
            const confirmation = await hashportClient.execute(id);
            dispatch({ type: 'complete', payload: { confirmation, id } });
        }
        catch (error) {
            console.error(error);
            dispatch({ type: 'error', payload: { id, error } });
        }
    }, [hashportClient]);
    const confirmCompletion = useCallback(() => {
        if (state.status !== 'processing') {
            dispatch({ type: 'idle' });
            resetBridgeParams();
        }
    }, [state, resetBridgeParams]);
    const dispatchValue = useMemo(() => ({ executeTransaction, confirmCompletion }), [executeTransaction, confirmCompletion]);
    return (_jsx(ProcessingTransactionContext.Provider, { value: { ...state, currentTransaction }, children: _jsx(ProcessTransactionDispatchContext.Provider, { value: dispatchValue, children: children }) }));
};
//# sourceMappingURL=processingTransaction.js.map