Reference generation with valid checksum

[stoem]

I've had some real problems getting the 27 digit long reference I created validated within SwissQRBill.
Our system generates a normal invoice number such as 12345 and I simply padded this with leading zeros (up to 26 digits), then used the following function (which follows the Luhn or Modulus 10 algorithm) to generate the checksum.

function calculateLuhnChecksum(number) {
    let sum = 0;
    let shouldDouble = false; // Start with the second to last digit
    for (let i = number.length - 1; i >= 0; i--) {
        let digit = parseInt(number.charAt(i), 10);
        if (shouldDouble) {
            digit *= 2;
            if (digit > 9) {
                digit -= 9;
            }
        }
        sum += digit;
        shouldDouble = !shouldDouble;
    }
    // Calculate the checksum digit that makes the sum a multiple of 10
    let checksum = (10 - (sum % 10)) % 10;
    return checksum;
}

However this failed against the mod10 validation in this project. I asked ChatGPT about it and it told me that

The mod10 function you've provided does not implement the traditional Luhn algorithm as it's commonly known. Instead, it seems to be based on a variation of the modulus 10 checksum calculation, but with a specific lookup table and carry mechanism that differs from the standard Luhn algorithm's doubling and summing process.

I asked ChatGPT to write me an input function that validates against this project. Here's what it came up with (and this seems to work for my purposes):

/**
 * Utilizes the [swissqrbill](https://github.com/schoero/swissqrbill) mod10 function for checksum calculation.
 * @param input The input string to calculate the checksum for.
 * @returns The calculated checksum as a string.
 */
function mod10(input) {
  const trimmedInput = input.replace(/ /g, "");
  const table = [0, 9, 4, 6, 8, 2, 7, 1, 3, 5];
  let carry = 0;

  for (let i = 0; i < trimmedInput.length; i++) {
    carry = table[(carry + parseInt(trimmedInput.substring(i, i + 1), 10)) % 10];
  }

  return ((10 - carry) % 10).toString();
}

I then use this function to feed in my invoice number such as 12345 and get a reference that validates.

/**
 * Generates a 27-digit string with the invoice number right-aligned,
 * filling the rest with zeros, and ending with a checksum calculated by mod10.
 * @param invoiceNumber The invoice number to include in the string.
 * @returns A 27-digit string ending with a checksum.
 */
function createFinalStringWithChecksum(invoiceNumber) {
  let invoiceNumberStr = invoiceNumber.toString();
  // Create a base string of 26 zeros since we'll add the checksum at the end
  let baseString = '0'.repeat(26 - invoiceNumberStr.length);
  // Insert the invoice number into the base string
  let stringWithoutChecksum = baseString + invoiceNumberStr;
  // Use the mod10 function to calculate the checksum for the entire 26-digit string
  let checksum = mod10(stringWithoutChecksum);
  // Append the checksum to complete the 27-digit string
  let finalString = stringWithoutChecksum + checksum;

  return finalString;
}

Maybe this helps someone.

[schoero]

Hi @stoem 👋

Thank you for trying to improve SwissQRBill.

I think you may have used a wrong function to calculate the checksum.

SwissQRBill provides the function calculateQRReferenceChecksum() for this use case.

The correct checksum for the QR Reference 00000 00000 00000 00000 01234 5 in your example is 7.

I have verified that using various different online generators that all mark the checksum 7 as valid:

• https://www.raiffeisen.ch/qr-rechnung/de.html
• https://www.postfinance.ch/de/support/services/tools-rechner/qr-generator.html/qrbill/Index.do#/
• https://qr-rechnung.net/

This is what calculateQRReferenceChecksum() will return:

const checksum = calculateQRReferenceChecksum("00000000000000000000012345"); // -> 7

The function calculateLuhnChecksum() you have provided returns the checksum 9 for the same string, which would be invalid.

function calculateLuhnChecksum(number) {
    let sum = 0;
    let shouldDouble = false; // Start with the second to last digit
    for (let i = number.length - 1; i >= 0; i--) {
        let digit = parseInt(number.charAt(i), 10);
        if (shouldDouble) {
            digit *= 2;
            if (digit > 9) {
                digit -= 9;
            }
        }
        sum += digit;
        shouldDouble = !shouldDouble;
    }
    // Calculate the checksum digit that makes the sum a multiple of 10
    let checksum = (10 - (sum % 10)) % 10;
    return checksum;
}

calculateLuhnChecksum("00000000000000000000012345") // -> 9

The mod10() algorithm you have posted, is exactly how it is implemented in SwissQRBill

[stoem]

Ah brilliant, I thought I must have missed something. I'll use calculateQRReferenceChecksum() instead and see if I can get things working that way.