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

Common react components for Hyperlane projects

import { useWallet } from '@tronweb3/tronwallet-adapter-react-hooks';
import { useCallback } from 'react';
import { ProviderType, } from '@hyperlane-xyz/sdk/providers/ProviderType';
import { TronTransactionBuilder, } from '@hyperlane-xyz/tron-sdk/runtime';
export { useTronAccount, useTronActiveChain, useTronConnectFn, useTronDisconnectFn, useTronWalletDetails, } from './tronWallet.js';
export function useTronSwitchNetwork(_multiProvider) {
    const onSwitchNetwork = useCallback(async (chainName) => {
        // Most Tron wallets (like TronLink) don't support programmatic
        // network switching via a DApp standard like EIP-3326.
        throw new Error(`Please manually switch your Tron wallet to ${chainName} (Mainnet/Nile/Shasta)`);
    }, []);
    return { switchNetwork: onSwitchNetwork };
}
export function useTronWatchAsset(_multiProvider) {
    const onAddAsset = useCallback(async (_token, _activeChainName) => {
        throw new Error('Watch asset not available for Tron');
    }, []);
    return { addAsset: onAddAsset };
}
/**
 * Core Transaction Functionality for Tron.
 */
export function useTronTransactionFns(multiProvider) {
    const { address, signTransaction, connected } = useWallet();
    const { switchNetwork } = useTronSwitchNetwork(multiProvider);
    const onSendTx = useCallback(async ({ tx, chainName, activeChainName: _, }) => {
        if (!connected || !address)
            throw new Error(`Tron wallet not connected`);
        const provider = multiProvider.getProvider(chainName);
        let txID;
        let response;
        if (tx.type === ProviderType.Tron &&
            provider.type === ProviderType.Tron) {
            const ethersTx = tx.transaction;
            let tronWebUrl = provider.provider.host;
            // Remove /jsonrpc suffix if present, as TronTransactionBuilder expects the base URL
            tronWebUrl = tronWebUrl.replace('/jsonrpc', '');
            const txBuilder = new TronTransactionBuilder(tronWebUrl, address);
            const tronTx = await txBuilder.buildTransaction(ethersTx);
            const signedTransaction = await signTransaction(tronTx);
            const result = await txBuilder.trx.sendRawTransaction(signedTransaction);
            if (!result.result) {
                throw new Error(`Tron broadcast failed: ${JSON.stringify(result)}`);
            }
            txID = result.txid;
            response = txBuilder.getTransactionResponse(tx.transaction, tronTx, txID);
        }
        else {
            throw new Error(`Invalid Tron provider type ${tx.type}`);
        }
        const confirm = async () => {
            const receipt = await response.wait(1);
            return {
                type: tx.type,
                receipt,
            };
        };
        return { hash: txID, confirm };
    }, [address, connected, signTransaction, multiProvider]);
    const onMultiSendTx = useCallback(async () => {
        throw new Error('Multi Transactions not supported on Tron');
    }, []);
    return {
        sendTransaction: onSendTx,
        sendMultiTransaction: onMultiSendTx,
        switchNetwork,
    };
}
//# sourceMappingURL=tron.js.map