Understanding currying functions

First, let's add some missing semicolons, since without them that code fails in an obscure way (ASI won't add a ; between multiply(2) and [5,8... because taken together they're syntactically-valid, though logically nonsensical). Let's also add a console.log on the last line:

const operationOnTwoNumbers = f => x => y => f(x,y);
const multiply = operationOnTwoNumbers((x,y) => x*y);
const double = multiply(2);
console.log([5,8,3,1,7,6,2].map(double));

(You've said you're very new to JavaScript and TypeScript. I strongly recommend not relying on ASI. Put ; at the ends of all statements that aren't flow-control structures ending in blocks. So you'd have one in the places above, and you wouldn't have one on [say] a while (condition) { ... } statement.)

operationOnTwoNumbers is a function that takes in f as an argument, and returns a function that takes x as an argument that returns a function that takes y as an argument that returns a function that does something to x and y.

Am i correct with the interpretation?

Very nearly. "...that returns a function that takes y as an argument that returns a function that does something to x and y." isn't correct, it should be "...that returns the result of calling f passing in x and y." (Also, technically, f, x, and y are parameters, not arguments¹, but it's very common to call them arguments and you're not likely to run into much trouble doing it.) So the full explanation is: "operationOnTwoNumbers is a function that takes in f as an argument, and returns a function that takes x as an argument that returns a function that takes y as an argument that returns the result of calling f passing in x and y."

It may help to see the equivalent non-arrow version (since those functions aren't using any of the features of arrow functions other than conciseness):

const operationOnTwoNumbers = function(f) {
    return function(x) {
        return function(y) {
            return f(x,y);
        };
    };
};

multiply is a function that takes operationOnTwoNumbers as a function, that operationOnTwoNumbers take (x,y) as an argument and returns a function that multiplies x and y.

Not quite, multiply is the result of calling operationOnTwoNumbers and passing in a function, (x, y) => x * y (this becomes the f in operationOnTwoNumbers). So multiply is the function created by operationOnTwoNumbers that accepts x.

Then double is the result of calling multiply with 2, so 2 becomes x and double is the function that accepts y. So for instance, if we do double(3), then 3 is the y and since x is 2 and f is (x, y) => x * y, the result of calling double(3) is 6.

Then the map call calls double for each entry in the array, returning a new array with each value doubled.

¹ parameter vs. argument: A function declares a parameter; when you call a function, you supply an argument for that parameter. For example:

function example(v) {
    return v * 2;
}
console.log(example(7));

In example, v is a parameter (specifically a formal parameter). In the call example(7), 7 is the argument for the v parameter.