Node.js quickstart

# npm ≥ 9.4 — direct from GitHub, prebuilt artifacts included
npm install everabyte/crypto-sdk#path:bindings/wasm/pkg-node

# or clone + vendor
git clone https://github.com/everabyte/crypto-sdk.git
cp -r crypto-sdk/bindings/wasm/pkg-node ./vendor/evb-e2ee-wasm

import fs from "node:fs/promises";
import init, {
  generate_umk,
  umk_public_keys,
  wrap_umk_with_mnemonic,
  wrap_dek_to_umk,
  unwrap_dek_from_umk,
  evb1_seal_all,
  evb1_open_all,
  generate_random_12,
  generate_random_32,
  derive_wire_alias,
  encrypt_file_name,
  decrypt_file_name,
} from "evb-e2ee-wasm";

await init();

const headers = {
  "X-Public-Key": process.env.EVB_PUBLIC_KEY,
  "X-Secret-Key": process.env.EVB_SECRET_KEY,
};
async function checkedFetch(url, options = {}) {
  const response = await fetch(url, { ...options, headers: { ...headers, ...options.headers } });
  if (!response.ok) throw new Error(`Everabyte request failed: HTTP ${response.status}`);
  return response;
}

const umk = generate_umk(); // 96 bytes — store ONLY in your own secure storage
const publics = JSON.parse(umk_public_keys(umk.subarray(0, 32), umk.subarray(32)));
const mnemonic = /* fresh 12-word BIP-39 phrase shown to the user ONCE */;
const stepUpToken = await obtainStepUpTokenFromYourApplication(); // account step-up flow
const blob = wrap_umk_with_mnemonic(umk.subarray(0, 32), umk.subarray(32), mnemonic);

const registerResponse = await checkedFetch("https://api.everabyte.io/api/e2ee/keys/register", {
  method: "POST",
  headers: {
    "X-Public-Key": process.env.EVB_PUBLIC_KEY,
    "X-Secret-Key": process.env.EVB_SECRET_KEY,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    publicKeyX25519: publics.publicKeyX25519,
    publicKeyMlkem: publics.publicKeyMlkem,
    wraps: [{ wrapKind: "mnemonic", wrappedBlob: blob }],
    stepUpToken, // account step-up flow
  }),
});
const registerResult = await registerResponse.json();

const plaintext = await fs.promises.readFile("report.pdf");
const dek = generate_random_32();
const fileNonce = generate_random_12();
const payload = evb1_seal_all(dek, fileNonce, plaintext);

const wireName = derive_wire_alias(umk.subarray(0, 32), umk.subarray(32), "report.pdf");
const encryptedName = encrypt_file_name(dek, "report.pdf", generate_random_12());
const envelope = JSON.parse(wrap_dek_to_umk(
  dek,
  Buffer.from(publics.publicKeyX25519, "base64"),
  Buffer.from(publics.publicKeyMlkem, "base64"),
));

const form = new FormData();
form.append("files", new Blob([payload]), wireName);
const bucketId = "BUCKET_ID";
await checkedFetch(`https://api.everabyte.io/api/files/upload/${bucketId}`, {
  method: "POST",
  body: form,
});

const attach = await checkedFetch("https://api.everabyte.io/api/e2ee/files/by-path/envelope", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ bucketId, fileName: wireName, encryptedName, ...envelope }),
});
const { fileId } = (await attach.json()).data; // returned by the by-path envelope endpoint

const env = (await (await checkedFetch(`https://api.everabyte.io/api/e2ee/files/${fileId}/envelope`)).json()).data;
const stored = new Uint8Array(await (await checkedFetch(`https://api.everabyte.io/api/files/${fileId}/stream?download=true`)).arrayBuffer());

const dek = unwrap_dek_from_umk(JSON.stringify(env), umk.subarray(0, 32), umk.subarray(32));
const original = evb1_open_all(dek, stored); // === plaintext, byte-identical
const realName = decrypt_file_name(dek, env.encryptedName);