@hyperlane-xyz/widgets/dist/walletIntegrations/aleo.js

Common react components for Hyperlane projects

import { useCallback } from 'react';
import { assert, retryAsync, sleep } from '@hyperlane-xyz/utils';
import { getAdapter, setAleoNetwork } from './aleo/utils.js';
const MAX_POLLING_ATTEMPTS = 60;
const POLLING_DELAY_MS = 1000;
export { useAleoAccount, useAleoActiveChain, useAleoConnectFn, useAleoDisconnectFn, useAleoWalletDetails, } from './aleoWallet.js';
export { Network as AleoNetwork } from '@provablehq/aleo-types';
export { setAleoNetwork };
export function useAleoSwitchNetwork(multiProvider) {
    const onSwitchNetwork = useCallback(async (chainName) => {
        const displayName = multiProvider.getChainMetadata(chainName).displayName || chainName;
        // Aleo does not have switch capability
        throw new Error(`Aleo wallet must be connected to origin chain ${displayName}`);
    }, [multiProvider]);
    return { switchNetwork: onSwitchNetwork };
}
export function useAleoWatchAsset(_multiProvider) {
    const onAddAsset = useCallback(async (_token, _activeChainName) => {
        throw new Error('Watch asset not available for Aleo');
    }, []);
    return { addAsset: onAddAsset };
}
export function useAleoTransactionFns(multiProvider) {
    const { switchNetwork } = useAleoSwitchNetwork(multiProvider);
    const onSendTx = useCallback(async ({ tx, chainName, activeChainName: __, }) => {
        const transaction = tx.transaction;
        const provider = multiProvider.getAleoProvider(chainName);
        const { fee } = await provider.estimateTransactionFee({
            transaction,
        });
        const adapterInstance = getAdapter();
        const transactionResult = await adapterInstance.executeTransaction({
            program: transaction.programName,
            function: transaction.functionName,
            fee: Number(fee),
            inputs: transaction.inputs,
            privateFee: transaction.privateFee,
        });
        if (!transactionResult) {
            throw new Error(`Failed to execute Aleo transaction`);
        }
        let transactionStatus = '';
        let transactionHash = '';
        let attempts = 0;
        while (!transactionHash && attempts < MAX_POLLING_ATTEMPTS) {
            await sleep(POLLING_DELAY_MS);
            attempts++;
            try {
                const statusResponse = await retryAsync(() => adapterInstance.transactionStatus(transactionResult.transactionId));
                transactionStatus = statusResponse.status;
                if (statusResponse.status.toLowerCase() !== 'pending') {
                    if (statusResponse.transactionId) {
                        transactionHash = statusResponse.transactionId;
                        break;
                    }
                    throw new Error(`got no transaction id from ${transactionResult.transactionId}`);
                }
            }
            catch (err) {
                if (attempts >= MAX_POLLING_ATTEMPTS) {
                    throw new Error(`Failed to get transaction status from ${transactionResult.transactionId} after ${MAX_POLLING_ATTEMPTS} attempts: ${err}`);
                }
            }
        }
        if (!transactionHash) {
            throw new Error(`Transaction polling timeout after ${MAX_POLLING_ATTEMPTS} attempts (${(MAX_POLLING_ATTEMPTS * POLLING_DELAY_MS) / 1000}s) for ${transactionResult.transactionId}`);
        }
        const confirm = async () => {
            assert(transactionStatus.toLowerCase() === 'accepted', `Aleo tx failed: ${transactionStatus}`);
            return {
                type: tx.type,
                receipt: {
                    status: transactionStatus,
                    type: '',
                    index: 0n,
                    transaction: {},
                    finalize: [],
                    transactionHash,
                },
            };
        };
        return { hash: transactionHash, confirm };
    }, [multiProvider]);
    const onMultiSendTx = useCallback(async ({ txs: _, chainName: __, activeChainName: ___, }) => {
        throw new Error('Multi Transactions not supported on Aleo');
    }, []);
    return {
        sendTransaction: onSendTx,
        sendMultiTransaction: onMultiSendTx,
        switchNetwork,
    };
}
//# sourceMappingURL=aleo.js.map