To create an end-to-end encrypted server data transfer, you can use a combination of public-key cryptography and symmetric-key cryptography. This will allow you to securely transfer data from the client to the server, and vice versa, without either party knowing the decryption key.

Here is an example of how you can use public-key cryptography and symmetric-key cryptography to create an end-to-end encrypted server data transfer in Node.js:

const crypto = require('crypto');

// Generate a pair of public and private keys for the server
const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', {
  modulusLength: 2048,
  publicKeyEncoding: {
    type: 'spki',
    format: 'pem'
  },
  privateKeyEncoding: {
    type: 'pkcs8',
    format: 'pem'
  }
});

// Send the server's public key to the client
sendServerPublicKeyToClient(publicKey);

// On the client-side, generate a random key for encrypting the data
const key = crypto.randomBytes(32);

// Encrypt the data using the key
const data = 'your data goes here';
const encryptedData = crypto.createCipher('aes-256-cbc', key).update(data, 'utf8', 'hex');

// Encrypt the key using the server's public key
const encryptedKey = crypto.publicEncrypt(publicKey, key);

// Send the encrypted data and the encrypted key to the server
sendEncryptedDataAndKeyToServer(encryptedData, encryptedKey);

// On the server-side, decrypt the key using the server's private key
const key = crypto.privateDecrypt(privateKey, encryptedKey);

// Decrypt the data using the key
const decryptedData = crypto.createDecipher('aes-256-cbc', key).update(encryptedData, 'hex', 'utf8');

In this example, the server generates a pair of public and private keys, and it sends the public key to the client. The client generates a random key, encrypts the data using the key, and then encrypts the key using the server's public key. The client sends the encrypted data and the encrypted key to the server. The server uses its private key to decrypt the key, and then uses the decrypted key to decrypt the data.

This way, neither the client nor the server knows the decryption key, because the key is encrypted using the server's public key, and only the server has the private key that can be used to decrypt it. This provides end-to-end encryption of the data, because the data is encrypted on the client-side using a key that is only known to the client, and it is decrypted on the server-side using a key that is only known to the server.