oprfClient.ts

const OPRF = require('oprf');
import axios from 'axios';
import { base64urlToUtf8, hexToUtf8, utf8ToBase64url, utf8ToHex } from './encodingUtils';

const green = '\x1b[32m%s\x1b[0m';
const red = '\x1b[31m%s\x1b[0m';
const yellow = '\x1b[33m%s\x1b[0m';
const blue = '\x1b[34m%s\x1b[0m';

export async function oprfClient(
  serverUrl: string,
  clientId: string,
  password: string,
  encoding: 'UTF-8' | 'base64url' | 'hex' = 'UTF-8',
): Promise<Uint8Array | null> {
  const oprf = new OPRF();
  await oprf.ready;

  console.log('Hashing password to curve point...');
  const hashPoint = oprf.hashToPoint(password);
  if (!oprf.isValidPoint(hashPoint)) {
    throw new Error('Hash Point is invalid. This should never happen.');
  }
  console.log(green, 'Hash Point is valid.');

  let maskedSaltedPointIsValid = false;
  let saltedPointIsValid = false;

  do {
    console.log('Masking hash point...');
    const maskedPoint = oprf.maskInput(hashPoint);
    if (!oprf.isValidPoint(maskedPoint.point)) {
      throw new Error('Masked Point is invalid. This should never happen.');
    }
    console.log(green, 'Masked Point is valid.');

    const encodedMaskedPoint = oprf.encodePoint(maskedPoint.point, 'UTF-8');
    const input =
      encoding === 'base64url'
        ? utf8ToBase64url(encodedMaskedPoint)
        : encoding === 'hex'
          ? utf8ToHex(encodedMaskedPoint)
          : encodedMaskedPoint;

    console.log(`Input to OPRF (${encoding}-encoded):`);
    console.log(blue, input);

    try {
      console.log(`Sending input (masked point) to server (${clientId} @ ${serverUrl}) ...`);
      const response = await axios.post(serverUrl, { id: clientId, input });
      const output = response.data.output as string;

      console.log(green, 'Received output (salted masked point) from server.');
      console.log(`Salted masked point (${encoding}-encoded):`);
      console.log(blue, output);

      const encodedMaskedSaltedPoint =
        encoding === 'base64url'
          ? base64urlToUtf8(output)
          : encoding === 'hex'
            ? hexToUtf8(output)
            : output;

      console.log('Decoding salted masked point...');
      const maskedSaltedPoint = oprf.decodePoint(encodedMaskedSaltedPoint, 'UTF-8');
      maskedSaltedPointIsValid = oprf.isValidPoint(maskedSaltedPoint);

      if (!maskedSaltedPointIsValid) {
        console.error(yellow, 'Salted masked point is invalid.');
        console.log('This can happen... Trying again with a newly masked point.');
        continue;
      }

      console.log(green, 'Salted masked point is valid.');
      try {
        console.log('Unmasking salted point...');
        const saltedPoint = oprf.unmaskPoint(maskedSaltedPoint, maskedPoint.mask);
        saltedPointIsValid = oprf.isValidPoint(saltedPoint);

        if (saltedPointIsValid) {
          console.log(green, 'Unmasked salted point is valid.');
          console.log('Unmasked salted point (hex):');
          console.log(blue, oprf.encodePoint(saltedPoint, 'hex'));
          console.log('OPRF complete.');
          return saltedPoint;
        }

        console.error(yellow, 'Unmasked salted point is invalid.');
        console.log('This can happen... Trying again with a newly masked point.');
      } catch (err) {
        const message = err instanceof Error ? err.message : String(err);
        console.error(red, 'Error:', message, '\nThis should never happen.');
      }
    } catch (err) {
      if (axios.isAxiosError(err)) {
        console.error(yellow, 'Error from OPRF server:', err.response?.data?.error ?? err.message);
        console.log('This can happen… Trying again with a newly masked point.');
        if (err.response?.status !== 400) {
          return null;
        }
      } else {
        throw err;
      }
    }
  } while (!(maskedSaltedPointIsValid && saltedPointIsValid));

  return null;
}

module.exports = oprfClient;