fix(3742): improve user segmentation with BigInt-based random generation

[DDDDDanica]

Explanation

Replace hash-based random number generation with BigInt-based implementation for better distribution and format support. The new implementation properly handles both UUIDv4 and hex-format metaMetricsIds, providing more consistent
and reliable user segmentation.

• Add support for UUIDv4 format with proper bit normalization
• Improve hex format handling using BigInt for precise calculations
• Remove char-by-char hashing algorithm to prevent potential collisions

References

Addresses: #5051 (comment)

Changelog

@metamask/remote-feature-flag-controller

• CHANGED: Modify generateDeterministicRandomNumber to handle both uuidv4(mobile new) and hex(mobile old and extension) side

Checklist

• I've updated the test suite for new or updated code as appropriate
• I've updated documentation (JSDoc, Markdown, etc.) for new or updated code as appropriate
• I've highlighted breaking changes using the "BREAKING" category above as appropriate
• I've prepared draft pull requests for clients and consumer packages to resolve any breaking changes

[Gudahtt]

For this, I think we need to remove it rather than replace it with f. If we replace it with f, we're skewing the result that amount away from zero. But if we remove it completely, it won't impact the result.

Suggested change

	* - Remove version (4) bits and replace with 'f'
	* - Remove version (4) bits

[Gudahtt]

Hmm, though I notice that the test does show that the minimum UUID does result in zero. Odd. It looks like the result would be skewed to me though.

[Gudahtt]

Ah, I tested it and it does skew the results, but by too small an amount. You need to use a precision of 10^15 to see a non-zero result from the minimum input, but we're only using precision of 10^6.

[Gudahtt]

Instead of using an implicit minimum of zero, and a maximum of 'f' * length, perhaps we can achieve perfect distribution by updating the final calculation to something like this:

function uuidToBigInt(id: string) {
  return BigInt(`0x${uuid.replace(/-/gu, '')}`);
}

const MIN_UUID_V4 = '00000000-0000-4000-8000-000000000000';
const MAX_UUID_V4 = 'ffffffff-ffff-4fff-bfff-ffffffffffff';
const MIN_UUID_V4_BIGINT = uuidToBigInt(MIN_UUI_V4);
const MAX_UUID_V4_BIGINT = uuidToBigInt(MAX_UUI_V4);

...

export function generateDeterministicRandomNumber(
  metaMetricsId: string,
): number {
  let idValue: BigInt;
  let maxValue: BigInt;
  // uuidv4 format
  if (uuidValidate(metaMetricsId) && uuidVersion(metaMetricsId) === 4) {
    // Adjust both values by subtracting the minimum value, so that the result isn't biased away from zero
    idValue = uuidToBigInt(metaMetricsId) - MIN_UUID_V4_BIGINT;
    maxId = MAX_UUID_V4_BIGINT - MIN_UUID_V4_BIGINT;
  } else {
    // hex format with 0x prefix
    idValue = BigInt(`0x${metaMetricsId.slice(2)}`;
    maxValue = BigInt(`0x${'f'.repeat(cleanId.length)}`);
  }
  // Use BigInt division first, then convert to number to maintain precision
  return Number((value * BigInt(1_000_000)) / maxValue) / 1_000_000;
}

By adjusting the minimum and maximum for the UUIDv4 case, it ensures we use the entire range of 0-1.

[Gudahtt]

I verified the max, and it's also skewed for the same reason as the minimum, but only if you increase precision to 10^15. Not bad! Close enough that we won't notice, it's well under a percentage.

The suggestion I left here would give us a perfect distribution (JS rounding aside; it could get slightly better with bignumber.js and/or more precision). But what you have here is good enough I think.

[DDDDDanica]

Thanks for the suggestion ! Converting uuid to hex value and then normalizing the UUID range to start from 0 instead of removing the bits within is a much better solution indeed! Adapted in 8724cc3

[Gudahtt]

LGTM! Two pending non-blocking suggestions, one to improve the distribution (we're biased slightly away from 0 and 1 right now for UUIDv4 IDs), and the second to add a guard against unexpected IDs.

[Gudahtt]

LGTM!