Discrete fourier transforms have always been a way of doing fast polynomial multiplication -- which is also called convolution. That is we can do

     (a0 + a1^z + a2*z^2...) * (b0 + b1^z + b2*z^2...)

As

    fa = DFT([a0, a1, a2...])   # O(N log N)
    fa = DFT([b0, b1, b2...])   # O(N log N)
    fab = element-by-element multiply fa by fb # O(N)
    return InverseDFT(fab) # O(N log N)

Now this is well established if we are literally doing a convolution of two sequences of complex numbers. But this is different from integer quite multiplication because:

1. Polynomial multiplication doesn't have carries.

2. It does inexact arithmetic on complex-numbers, we want exact results on integer digits.

I am guessing (2) is solved by getting modulo-arithmetic do the same algebraic gymnastics that make the FFT work.

Also I didn't think any of this was new -- I vaguely remember reading about fast convolutions using discrete algebras in old textbooks from the '70s. Maybe the hard thing was to do it in a way that leaves enough information left over to do the carries.