Misc bug fixes #702

sidhujag · 2025-05-23T19:18:40Z

No description provided.

updateTransactionsFromCurrentAccount handles both btc and non btc based tx cache so use it instead of always fetching from backend when updateUserTransactionsState is called

This reverts commit ef13531.

also add pali headers to JSON-RPC requests

remove checkForPendingTransactionsUpdate as it was doing similar things but just unconfirmations, checkForUpdates had a bug which was not checking for unconfirms.. now it is so we merge in one. Also fix setting active account twice in set active account model. FIxing eip1559 checks in utxo model if not bitcoin based. Fix setting account in setAccount, which was breaking sending funds when switching accounts.

accounts were mixing up tx list because of the prev merge fix in validateAndManageUserTransactions

keep alive to fix blank screen issue, add hints for api url on ux, fix going back on menu (not to home)

also menu context navigation, as well as fix blank screen

sometimes it cant parse vault and causes enforced import seed again

… as replaced - Replace transactions immediately when speed-up or cancel is initiated - Remove complex replacement chain tracking since only one tx per nonce exists - Update setTransactionStatusToAccelerated to replace old tx with new one - Add optional cancelTransaction parameter to setTransactionStatusToCanceled - Remove updateReplacementChainOnConfirmation logic (now a no-op) - Remove all cleanup code from validateAndManageUserTransactions This matches blockchain reality where only one transaction per nonce can exist, simplifying the UI and preventing stuck 'replaced' states when wallet misses confirmation events.

- Revert immediate transaction replacement approach from commit 4675a98 - Mark old transactions as replaced instead of removing them - Add simple nonce-based cleanup: if any tx is confirmed, keep only that one - Remove 0-value transaction filtering to match blockchain explorers - Preserve transaction metadata (isReplaced, isSpeedUp) during deduplication - Fix timestamp sorting to handle both EVM and SYS transactions This approach is simpler and more robust: transactions are marked as replaced during speed-up/cancel, then cleaned up during sync when one confirms.

- Create unified `treatAndSortTransactions` function that combines deduplication, sorting, and limiting in a single pass (reduced from 3-4 loops to 2) - Remove redundant `treatDuplicatedTxs` function - Add new `setAccountTransactions` Redux action for simple transaction updates - Consolidate transaction processing in controllers instead of Redux Consistency improvements: - Both EVM and UTXO now process transactions in their controllers and dispatch to Redux consistently - Move all EVM transaction processing to `pollingEvmTransactions` to eliminate double processing in RPC fallback path - Remove unnecessary `flatMap` usage in EVM controller Performance gains: - Eliminate duplicate merging/deduplication between controllers and Redux - Process transactions only once instead of multiple times - Reduce memory allocations with optimized data structures Code cleanup: - Fix unused variable warnings in EvmList.tsx and MainController.ts - Fix interface property ordering in transaction types - Fix variable shadowing in handleListeners.ts - Remove `setMultipleTransactionToState` usage in favor of simpler action The transaction limit of 30 is now consistently applied at the processing stage rather than in Redux, making the data flow clearer and more efficient.

cursor

Bug: API Change Breaks Existing Callers

Breaking API change in the findUserTxsInProviderByBlocksRange function. Its signature changed from accepting (provider, startBlock, endBlock) to (provider, numBlocks). Existing callers using the old 3-parameter format will cause runtime errors or incorrect behavior due to mismatched parameter interpretation.

source/scripts/Background/controllers/transactions/utils.ts#L42-L46

pali-wallet/source/scripts/Background/controllers/transactions/utils.ts

Lines 42 to 46 in cdc9b2e

    
           export const findUserTxsInProviderByBlocksRange = async ( 
        
             provider: CustomJsonRpcProvider, 
        
             numBlocks: number 
        
           ): Promise<IEvmTransactionResponse[] | any> => {


	export const findUserTxsInProviderByBlocksRange = async (
	provider: CustomJsonRpcProvider,
	numBlocks: number
	): Promise<IEvmTransactionResponse[] \| any> => {

	// For EVM transactions with nonce, use nonce to detect replacements
	// For UTXO or transactions without nonce, use hash/txid
	let id: string;
	if ('nonce' in tx && typeof tx.nonce === 'number') {
	id = tx.nonce.toString();
	} else {
	id = ('hash' in tx ? tx.hash : tx.txid).toLowerCase();
	}

	// Single pass: Group transactions by their ID and keep the best version
	const txMap = new Map<string, UnifiedTransaction>();

	for (const tx of transactions) {
	// For EVM transactions with nonce, use nonce to detect replacements
	// For UTXO or transactions without nonce, use hash/txid
	let id: string;
	if ('nonce' in tx && typeof tx.nonce === 'number') {
	id = tx.nonce.toString();
	} else {
	id = ('hash' in tx ? tx.hash : tx.txid).toLowerCase();
	}

	const existing = txMap.get(id);

	if (!existing \|\| tx.confirmations > existing.confirmations) {

	// For native ETH, also validate against max amount (balance - gas)
	try {
	// Calculate max sendable amount
	const maxAmountStr = await calculateMaxAmount();
	const maxAmountBN =
	ethers.utils.parseEther(maxAmountStr);

	// If amount exceeds max (balance - gas), show specific error
	if (valueBN.gt(maxAmountBN)) {
	// Check if it's just slightly over (within gas fee range)
	if (valueBN.lte(balanceBN)) {
	return Promise.reject(
	t('send.insufficientFundsForGas') \|\|
	'Insufficient funds for gas'
	);
	}
	}
	} catch (error) {
	console.error('Error validating max amount:', error);
	// If we can't calculate gas, just check against balance
	// The actual transaction will fail if gas is insufficient
	}

	// Check if this is a MAX send by comparing amount to balance
	let isMax = false;
	if (!selectedAsset) {
	try {
	const balanceEth = String(activeAccount?.balances?.ethereum \|\| '0');
	const amountBN = ethers.utils.parseEther(values.amount);
	const balanceBN = ethers.utils.parseEther(balanceEth);
	isMax = amountBN.eq(balanceBN);
	} catch {
	// If parsing fails, it's not a MAX send
	isMax = false;
	}
	}

	// If MAX is clicked for native ETH, check if value equals full balance
	if (isMaxSend && !selectedAsset) {
	const balanceEth = String(
	activeAccount?.balances?.ethereum \|\| '0'
	);
	const balanceBN = ethers.utils.parseEther(balanceEth);

	// If the amount equals the full balance, it's valid
	if (valueBN.eq(balanceBN)) {
	return Promise.resolve();
	}
	}

	}
	}, [selectedAsset, activeAccount.address, controllerEmitter, form]); // isCalculatingGas excluded to prevent loops

	const calculateMaxAmount = useCallback(async (): Promise<string> => {
	if (selectedAsset) {
	// For tokens, use full balance as fees are paid in native token
	return String(selectedAsset.balance);
	}

	try {
	// Get balance in wei using the full precision stored balance
	const balanceEth = activeAccount?.balances?.ethereum \|\| '0';
	const balanceWei = ethers.utils.parseEther(String(balanceEth));

	// Try to get fresh fee data or use cached data
	let totalFeeWei = BigNumber.from(0);

	if (!cachedFeeData) {
	// Try to calculate fresh fee data
	try {
	const receiver =
	form.getFieldValue('receiver') \|\| activeAccount.address;

	const { maxFeePerGas, maxPriorityFeePerGas } =
	(await controllerEmitter([
	'wallet',
	'ethereumTransaction',
	'getFeeDataWithDynamicMaxPriorityFeePerGas',
	])) as any;

	// Estimate gas limit for a simple transfer
	const gasLimit = await controllerEmitter(
	['wallet', 'ethereumTransaction', 'getTxGasLimit'],
	[
	{
	from: activeAccount.address,
	to: receiver,
	value: '0x1', // Small test value
	maxFeePerGas,
	maxPriorityFeePerGas,
	},
	]
	).then((gas) => BigNumber.from(gas));

	// Calculate total fee in wei
	totalFeeWei = gasLimit.mul(BigNumber.from(maxFeePerGas));

	// Cache the fee data for future use
	const totalFeeEth = Number(ethers.utils.formatEther(totalFeeWei));
	setCachedFeeData({
	maxFeePerGas: maxFeePerGas.toString(),
	maxPriorityFeePerGas: maxPriorityFeePerGas.toString(),
	gasLimit: gasLimit.toString(),
	totalFeeEth,
	});
	} catch (error) {
	console.error('Error calculating fresh fee data:', error);
	// Use conservative estimate based on network
	const conservativeFeeEth =
	activeNetwork.chainId === 570 ? '0.00001' : '0.001';
	totalFeeWei = ethers.utils.parseEther(conservativeFeeEth);
	}
	} else {
	// Use cached fee data - reconstruct wei value from components
	const gasLimit = BigNumber.from(cachedFeeData.gasLimit);
	const maxFeePerGas = BigNumber.from(cachedFeeData.maxFeePerGas);
	totalFeeWei = gasLimit.mul(maxFeePerGas);
	}

	// Calculate max amount in wei (no buffer needed when using BigNumber)
	const maxAmountWei = balanceWei.sub(totalFeeWei);

	// If result would be negative, return 0
	if (maxAmountWei.lt(0)) {
	return '0';
	}

	// Convert back to ETH as a string to preserve precision
	const maxAmountEth = ethers.utils.formatEther(maxAmountWei);

	// Return as string to preserve full precision
	return maxAmountEth;
	} catch (error) {
	console.error('Error calculating max amount:', error);
	// Fallback: return balance minus conservative fee using BigNumber
	try {
	const balanceEth = activeAccount?.balances?.ethereum \|\| '0';
	const balanceWei = ethers.utils.parseEther(String(balanceEth));
	const conservativeFee =
	activeNetwork.chainId === 570 ? '0.00001' : '0.001';
	const conservativeFeeWei = ethers.utils.parseEther(conservativeFee);
	const maxAmountWei = balanceWei.sub(conservativeFeeWei);

	if (maxAmountWei.lt(0)) {
	return '0';
	}

	return ethers.utils.formatEther(maxAmountWei);
	} catch (fallbackError) {
	console.error('Error in fallback calculation:', fallbackError);
	return '0';
	}
	}
	}, [
	selectedAsset,
	cachedFeeData,
	activeAccount?.balances?.ethereum,
	activeAccount?.address,
	activeNetwork.chainId,
	controllerEmitter,
	form,
	]);

	// Check for application-level errors
	if (response && response.error) {
	// If it's a structured error from syscoinjs-lib, pass it through as-is
	if (response.error === true && response.code) {
	return reject(response);
	}
	// Also check if the entire response is the error object
	if (response.code && typeof response.error === 'boolean') {
	return reject(response);
	}
	// For simple error messages, wrap in Error object
	return reject(new Error(response.error));
	}

	// Also check if response itself is a structured error
	if (response && response.code && response.error === true) {
	return reject(response);
	}

	resolve(response);
	}


	// Memoized unified account rendering
	const renderAccount = useCallback(
	(account: IKeyringAccountState, accountType: KeyringAccountType) => {
	const config = ACCOUNT_TYPE_CONFIG[accountType];
	const IconComponent = config.icon;

	return (
	<li
	key={`${accountType}-${account.id}`}
	className="my-3 py-2 w-full flex justify-between items-center transition-all duration-300 border-b border-dashed border-dashed-light cursor-default"
	>
	<div className="flex items-center">
	<span
	style={{ maxWidth: '16.25rem', textOverflow: 'ellipsis' }}
	className="w-max flex items-center justify-start whitespace-nowrap overflow-hidden"
	>
	<IconComponent />
	{account.label} ({ellipsis(account.address, 4, 4)})
	</span>
	<span
	className={`text-xs ml-2 px-2 py-0.5 text-white ${config.bgColor} rounded-full`}
	>
	{config.label}
	</span>
	{isActiveAccount(account, accountType) && (
	<Icon name="greenCheck" isSvg className="ml-2 w-4" />
	)}
	</div>

	<div className="flex gap-x-2 items-center justify-between">
	<IconButton
	onClick={() => editAccount(account)}
	type="primary"
	shape="circle"
	>
	<Icon
	name="edit"
	size={20}
	className="hover:text-brand-royalblue text-xl"
	/>
	</IconButton>

	{canRemoveAccount(account, accountType) && (
	<IconButton
	onClick={() => handleRemoveClick(account, accountType)}
	type="primary"
	shape="circle"
	className="hover:bg-red-500 hover:bg-opacity-20"
	>
	<Icon
	name="delete"
	size={20}
	className="hover:text-red-500 text-xl"
	/>
	</IconButton>
	)}
	</div>
	</li>
	);
	},
	[editAccount, isActiveAccount]
	);

	// For MAX sends, deduct gas fees from the value
	// This is required because ethers.js validates balance >= value + gas
	if (basicTxValues.isMax) {
	const gasLimit = BigNumber.from(
	validateCustomGasLimit
	? customFee.gasLimit * 10 ** 9
	: fee.gasLimit
	);

	if (isEIP1559Compatible) {
	// EIP-1559 transaction
	const maxFeePerGasWei = ethers.utils.parseUnits(
	String(
	Boolean(customFee.isCustom && customFee.maxFeePerGas > 0)
	? customFee.maxFeePerGas.toFixed(9)
	: fee.maxFeePerGas.toFixed(9)
	),
	9
	);
	const maxGasFeeWei = gasLimit.mul(maxFeePerGasWei);
	value = value.sub(maxGasFeeWei);
	} else {
	// Legacy transaction
	const gasPriceWei = BigNumber.from(gasPrice);
	const gasFeeWei = gasLimit.mul(gasPriceWei);
	value = value.sub(gasFeeWei);
	}

	// Ensure value doesn't go negative
	if (value.lt(0)) {
	alert.error(t('send.insufficientFundsForGas'));
	setLoading(false);
	return;
	}

	// Get hasEncryptedVault from global state to distinguish between locked and forgotten states
	const hasEncryptedVault = useSelector(
	(state: RootState) => state.vaultGlobal.hasEncryptedVault
	);

	// Function to check unlock status
	const checkUnlockStatus = async () => {
	try {
	const unlocked = await controllerEmitter(['wallet', 'isUnlocked'], []);
	const wasUnlocked = isUnlocked;
	const nowUnlocked = !!unlocked;

	setIsUnlocked(nowUnlocked);

	// If wallet was unlocked but now locked, redirect to unlock screen
	// BUT only if there's still an encrypted vault (not forgotten)
	if (wasUnlocked && !nowUnlocked && !isLoading && hasEncryptedVault) {
	console.log(
	'[useController] Wallet became locked, redirecting to unlock screen'
	);
	navigate('/', { replace: true });
	}

	// If there's no encrypted vault, don't force redirect - let routing logic handle it
	if (wasUnlocked && !nowUnlocked && !isLoading && !hasEncryptedVault) {
	console.log(
	'[useController] Wallet was forgotten, allowing routing logic to handle navigation'
	);
	}

	return nowUnlocked;
	} catch (error: any) {
	// Don't spam console with connection errors during service worker lifecycle
	if (
	!error.message?.includes('Could not establish connection') &&
	!error.message?.includes('Receiving end does not exist') &&
	!error.message?.includes('Network request timed out')
	) {
	console.error('[useController] Error checking unlock status:', error);
	}

	gasLimit: BigNumber.from(
	validateCustomGasLimit
	? customFee.gasLimit * 10 ** 9 // Multiply gasLimit to reach correctly decimal value
	: fee.gasLimit
	),
	},

Misc bug fixes #702

Are you sure you want to change the base?

Misc bug fixes #702

Conversation

sidhujag commented May 23, 2025

Uh oh!

cursor bot left a comment

Choose a reason for hiding this comment

Bug: API Change Breaks Existing Callers

Uh oh!

cursor bot left a comment

Choose a reason for hiding this comment

Bug: EVM Deduplication Fails Across Accounts

Uh oh!

cursor bot left a comment

Choose a reason for hiding this comment

Bug: EVM Deduplication Fails with Replaced Transactions

Uh oh!

cursor bot left a comment

Choose a reason for hiding this comment

Bug: Native ETH Transfer Validation Fails

Bug: MAX Send Button Fails Gas Fee Validation

Bug: Invalid Ethereum Values and Stale Dependencies

Uh oh!

cursor bot left a comment

Choose a reason for hiding this comment

Bug: Error Handling Flaw in Response Processing

Bug: Inconsistent Null Checks and Gas Estimation Issues

Bug: ETH "MAX" Send Validation Ignores Gas Fees

Uh oh!

cursor bot left a comment

Choose a reason for hiding this comment

Bug: EVM Transaction Deduplication Fails with Nonce

Bug: Flawed Error Handling in `controllerEmitter`

Uh oh!

cursor bot left a comment

Choose a reason for hiding this comment

Bug: Incomplete Dependency Array Causes Stale Closures

Uh oh!

cursor bot left a comment

Choose a reason for hiding this comment

Bug: Missing Dependencies in `renderAccount` Hook

Uh oh!

cursor bot left a comment

Choose a reason for hiding this comment

Bug: Gas Limit Conversion Error

Bug: Stale State in `useEffect` Causes Incorrect Wallet Handling

Uh oh!

Uh oh!