toiljs 0.0.39 → 0.0.41

package/server/globals/email.ts

@@ -0,0 +1,188 @@
+// EmailService + EmailTemplate + the `EmailStatus` enum: the guest surface for
+// the per-tenant outbound email primitive, available as a no-import global (the
+// toilscript `--lib` mechanism, like `AuthService` and `RateLimitService`). A
+// handler calls `EmailService.send(...)` for a one-off, or defines a reusable
+// `EmailTemplate` (with `{{placeholder}}` interpolation, plain text and/or HTML)
+// and calls `template.send(to, vars)`.
+//
+// The host hands the message to the off-core mailer and SUSPENDS the call until
+// the provider responds (on the async edge executor) without blocking the
+// worker. `purpose` is a short tag ("verify", "reset", ...) the host folds into
+// its dedup + per-recipient abuse keys; it is never logged raw. The recipient is
+// validated at the host boundary (no header injection / multiple addresses) and
+// the send is capped per tenant.
+//
+// Backed by the `email_send` host import (toil-backend `email_send_import.rs`,
+// and the toiljs dev-server mock). A tenant that never sends email never imports
+// `email_send`, so AssemblyScript tree-shakes it; a module that does must be
+// deployed to an edge built with the `email` feature.
+
+// Host import: submit one email and resolve to its status code. `reqPtr`/`reqLen`
+// is the length-prefixed request blob (header below). Suspends the wasm call
+// until the off-core send completes.
+// @ts-ignore: decorator
+@external('env', 'email_send')
+declare function __toilEmailSend(reqPtr: usize, reqLen: i32): i32;
+
+/**
+ * The result of a send. Kept in sync with `EmailStatus` in toil-backend
+ * `email.rs` (`#[repr(i32)]`). `Sent` and `Deduped` are success; the rest say
+ * why it was not delivered and whether a retry could help.
+ */
+export enum EmailStatus {
+    /** Accepted by the provider. */
+    Sent = 0,
+    /** This host has no `[email]` capability (or it is disabled / not on this path). */
+    Disabled = 1,
+    /** The tenant's per-minute budget is exhausted. Retriable later. */
+    Budget = 2,
+    /** The per-recipient hourly cap was hit. Terminal for this recipient/window. */
+    RecipientCapped = 3,
+    /** An identical recent (recipient, purpose) send was collapsed. Treat as sent. */
+    Deduped = 4,
+    /** The mailer was saturated / a queue was full. Retriable; back off. */
+    TryLater = 5,
+    /** The recipient failed host-side validation (CRLF, multiple addresses, malformed). */
+    BadRecipient = 6,
+    /** The provider rejected the send, or transport failed after retries. Terminal. */
+    ProviderError = 7,
+}
+
+export namespace EmailService {
+    /** Header: u16 to_len | u16 subject_len | u16 purpose_len | u32 body_len | u32 html_len. */
+    const HEADER_LEN: i32 = 14;
+
+    /**
+     * Send one email to `to` and return its {@link EmailStatus}. Suspends until
+     * the off-core mailer reports a result.
+     *
+     * `body` is the plain-text body; pass a non-empty `html` to send an HTML
+     * message (then `body` is the plain-text alternative — set both for the best
+     * deliverability, or leave `body` empty for HTML-only). `purpose` is a short,
+     * non-PII tag used for host-side dedup/abuse keying.
+     */
+    export function send(
+        to: string,
+        subject: string,
+        body: string,
+        purpose: string = 'tx',
+        html: string = '',
+    ): EmailStatus {
+        const toB = Uint8Array.wrap(String.UTF8.encode(to));
+        const subjB = Uint8Array.wrap(String.UTF8.encode(subject));
+        const purpB = Uint8Array.wrap(String.UTF8.encode(purpose));
+        const bodyB = Uint8Array.wrap(String.UTF8.encode(body));
+        const htmlB = Uint8Array.wrap(String.UTF8.encode(html));
+
+        const total =
+            HEADER_LEN + toB.length + subjB.length + purpB.length + bodyB.length + htmlB.length;
+        const buf = new Uint8Array(total);
+        const base = buf.dataStart;
+
+        // Little-endian header (wasm stores are LE), then the five payloads in
+        // the order the host parser expects: to, subject, purpose, body, html.
+        store<u16>(base, <u16>toB.length, 0);
+        store<u16>(base, <u16>subjB.length, 2);
+        store<u16>(base, <u16>purpB.length, 4);
+        store<u32>(base, <u32>bodyB.length, 6);
+        store<u32>(base, <u32>htmlB.length, 10);
+
+        let off = base + HEADER_LEN;
+        memory.copy(off, toB.dataStart, toB.length);
+        off += toB.length;
+        memory.copy(off, subjB.dataStart, subjB.length);
+        off += subjB.length;
+        memory.copy(off, purpB.dataStart, purpB.length);
+        off += purpB.length;
+        memory.copy(off, bodyB.dataStart, bodyB.length);
+        off += bodyB.length;
+        memory.copy(off, htmlB.dataStart, htmlB.length);
+
+        return <EmailStatus>__toilEmailSend(base, total);
+    }
+}
+
+/** One template rendered against a variable map: the concrete parts to send. */
+export class RenderedEmail {
+    subject: string;
+    body: string;
+    html: string;
+    constructor(subject: string, body: string, html: string) {
+        this.subject = subject;
+        this.body = body;
+        this.html = html;
+    }
+}
+
+/**
+ * A reusable email template with `{{placeholder}}` interpolation, defined once
+ * and sent many times with different variables:
+ *
+ *   const welcome = new EmailTemplate(
+ *     'Welcome, {{name}}!',
+ *     'Hi {{name}}, your code is {{code}}.',
+ *     '<h1>Welcome, {{name}}</h1><p>Your code is <b>{{code}}</b>.</p>',
+ *   );
+ *   const vars = new Map<string,string>();
+ *   vars.set('name', 'Alice'); vars.set('code', '123456');
+ *   welcome.send('alice@example.com', vars, 'welcome');
+ *
+ * `{{ key }}` (with surrounding spaces) is accepted; an unknown placeholder
+ * renders to the empty string. `html` is optional — omit it for a plain-text
+ * template.
+ */
+export class EmailTemplate {
+    private subjectTpl: string;
+    private bodyTpl: string;
+    private htmlTpl: string;
+
+    constructor(subject: string, body: string, html: string = '') {
+        this.subjectTpl = subject;
+        this.bodyTpl = body;
+        this.htmlTpl = html;
+    }
+
+    /** Render the template against `vars` without sending (preview / testing). */
+    render(vars: Map<string, string>): RenderedEmail {
+        return new RenderedEmail(
+            interpolate(this.subjectTpl, vars),
+            interpolate(this.bodyTpl, vars),
+            this.htmlTpl.length > 0 ? interpolate(this.htmlTpl, vars) : '',
+        );
+    }
+
+    /** Render and send to `to`. Returns the send's {@link EmailStatus}. */
+    send(to: string, vars: Map<string, string>, purpose: string = 'tx'): EmailStatus {
+        const r = this.render(vars);
+        return EmailService.send(to, r.subject, r.body, purpose, r.html);
+    }
+}
+
+/**
+ * Substitute every `{{key}}` in `pattern` with `vars.get(key)`. Surrounding
+ * whitespace in the placeholder is ignored (`{{ name }}` == `{{name}}`); an
+ * unknown key renders to the empty string; an unterminated `{{` is emitted
+ * literally. Module-private (not part of the `--lib` global surface).
+ */
+function interpolate(pattern: string, vars: Map<string, string>): string {
+    let out = '';
+    let i = 0;
+    const n = pattern.length;
+    while (i < n) {
+        const open = pattern.indexOf('{{', i);
+        if (open < 0) {
+            out += pattern.substring(i);
+            break;
+        }
+        out += pattern.substring(i, open);
+        const close = pattern.indexOf('}}', open + 2);
+        if (close < 0) {
+            out += pattern.substring(open); // unterminated -> literal
+            break;
+        }
+        const key = pattern.substring(open + 2, close).trim();
+        if (vars.has(key)) out += vars.get(key);
+        i = close + 2;
+    }
+    return out;
+}

package/server/globals/ratelimit.ts

@@ -0,0 +1,89 @@
+// RateLimitService + the `RateLimit` strategy enum: the server half of the
+// `@ratelimit` route decorator, available as a no-import global (registered via
+// the toilscript `--lib` mechanism, the same way `AuthService` and `crypto`
+// are). The toilscript `@ratelimit(strategy, limit, window)` decorator lowers to
+// a single `RateLimitService.guard(...)` call at the top of the route, before
+// the `@auth` guard and the handler.
+//
+// The actual counting happens host-side in an EXACT limiter shared across all
+// edge workers and keyed, by default, on the request's UNSPOOFABLE peer IP (the
+// socket's remote address, never a forgeable header). Backed by the
+// `ratelimit_check` host import (toil-backend `ratelimit_check_import.rs`, and
+// the toiljs dev-server mock). A tenant that does not use `@ratelimit` never
+// references this namespace, so AssemblyScript tree-shakes it and the module
+// never imports `ratelimit_check` (only opt-in routes pay anything).
+
+import { Response } from 'toiljs/server/runtime';
+
+// Host import: account one event against the route's shared limiter. Args are
+// `(route_id, strategy_tag, limit, window, key_ptr, key_len)`; the two param
+// slots mean `(limit, window_secs)` for the window strategies and
+// `(burst, refill_per_sec)` for the token bucket. Returns the remaining budget
+// (`>= 0`, allowed) or a NEGATIVE `Retry-After` in seconds (denied). When
+// `key_len` is 0 the host keys on the peer IP.
+// @ts-ignore: decorator
+@external('env', 'ratelimit_check')
+declare function __toilRateLimitCheck(
+    routeId: i32,
+    strategy: i32,
+    limit: i32,
+    window: i32,
+    keyPtr: usize,
+    keyLen: i32,
+): i32;
+
+/**
+ * Rate-limit strategy, the first argument to `@ratelimit(...)`. The numeric
+ * values are the host's strategy tags (kept in sync with `Strategy` in
+ * toil-backend `ratelimit.rs`); the toilscript decorator transform reads the
+ * member by name, so reordering would only affect a bare-integer decorator arg.
+ *
+ *  - `FixedWindow`: at most `limit` events per `window` seconds. Cheapest; a
+ *    caller hammering the boundary can briefly land up to ~2x `limit`.
+ *  - `SlidingWindow`: weights the previous window to smooth that boundary burst.
+ *  - `TokenBucket`: `limit` is the burst size, `window` the refill-per-second;
+ *    allows an initial burst then a steady rate.
+ */
+export enum RateLimit {
+    FixedWindow = 0,
+    SlidingWindow = 1,
+    TokenBucket = 2,
+}
+
+export namespace RateLimitService {
+    /**
+     * The `@ratelimit` decorator's guard. Accounts one event for this request
+     * against the route's shared limiter, keyed on the UNSPOOFABLE peer IP.
+     * Returns a `429 Too Many Requests` (with a `Retry-After` header) when over
+     * the limit, or `null` to let the request proceed.
+     */
+    export function guard(routeId: i32, strategy: i32, limit: i32, window: i32): Response | null {
+        const r = __toilRateLimitCheck(routeId, strategy, limit, window, 0, 0);
+        return r >= 0 ? null : tooMany(-r);
+    }
+
+    /**
+     * Like {@link guard} but keyed on a tenant-chosen identity `key` (e.g. an
+     * authenticated user id) instead of the peer IP, for per-user limits. An
+     * empty `key` falls back to the peer IP (host-side).
+     */
+    export function guardKeyed(
+        routeId: i32,
+        strategy: i32,
+        limit: i32,
+        window: i32,
+        key: string,
+    ): Response | null {
+        const kb = Uint8Array.wrap(String.UTF8.encode(key));
+        const r = __toilRateLimitCheck(routeId, strategy, limit, window, kb.dataStart, kb.length);
+        return r >= 0 ? null : tooMany(-r);
+    }
+
+    /** A `429` response carrying the host-computed `Retry-After` (whole seconds). */
+    function tooMany(retryAfterSecs: i32): Response {
+        return Response.text('Too Many Requests\n', 429).setHeader(
+            'Retry-After',
+            retryAfterSecs.toString(),
+        );
+    }
+}

package/server/globals/twofactor.ts

@@ -0,0 +1,212 @@
+// TwoFactor: a STATELESS email verification-code primitive (2FA / confirm /
+// magic-code), available as a no-import global (the toilscript `--lib`
+// mechanism, like `AuthService`, `EmailService`, `RateLimitService`). No
+// database: the server stores nothing between mint and verify.
+//
+// How stateless verification works: `mint`/`issue` generates a random code,
+// emails it to the recipient, and returns a signed TOKEN that commits to the
+// code via HMAC over `(recipient, purpose, exp, code)` -- WITHOUT putting the
+// code in the token (the code is only in the email). Hand the token to the
+// client (a cookie or hidden field). On `verify(token, recipient, code)` the
+// server recomputes the HMAC from the token's `(purpose, exp)` + the caller's
+// `(recipient, code)` and constant-time compares. A valid `(token, code)` pair
+// can only be produced by someone who BOTH received the email (knows the code)
+// AND holds the token. The HMAC binds the recipient + purpose + expiry, so a
+// token can't be replayed for another address, flow, or past its TTL.
+//
+// LIMITATION: this is integrity + expiry, NOT single-use. A valid code can be
+// verified multiple times within its (short) TTL -- there is no server state to
+// burn it. For true single-use, keep a per-recipient last-verified-at (a DB /
+// the edge store) and reject codes at or before it, plus a short TTL.
+
+import {
+    CryptoKey,
+    HmacImportParams,
+    HmacParams,
+    ALG_SHA_256,
+    USAGE_SIGN,
+    USAGE_VERIFY,
+} from 'crypto';
+import { DataWriter, DataReader } from 'data';
+
+import { base64UrlEncode, base64UrlDecode, Time } from 'toiljs/server/runtime';
+
+// HMAC key for the verification tokens. The SAME secret must be configured on
+// every edge instance and kept out of any client bundle. The default is a loud
+// DEV placeholder; a real deployment calls `TwoFactor.setSecret(...)` at startup
+// (a build-time constant is consistent across instances).
+// TODO(secret): move to a per-deployment host-config secret.
+let __twofaSecret: Uint8Array = Uint8Array.wrap(
+    String.UTF8.encode('toil-dev-insecure-2fa-secret-CHANGE-ME'),
+);
+
+/** Token format version (first byte of both the token and the signed message). */
+const TWOFA_VERSION: u8 = 1;
+
+function importHmac(key: Uint8Array): CryptoKey {
+    return crypto.subtle.importKey(
+        'raw',
+        key,
+        new HmacImportParams(ALG_SHA_256),
+        false,
+        USAGE_SIGN | USAGE_VERIFY,
+    );
+}
+
+/** HMAC-SHA256 over `msg` with the configured secret. */
+function hmac(msg: Uint8Array): Uint8Array {
+    return crypto.subtle.sign(new HmacParams(), importHmac(__twofaSecret), msg);
+}
+
+/** Constant-time HMAC verify (the host's `crypto.verify` compares in constant time). */
+function hmacVerify(mac: Uint8Array, msg: Uint8Array): bool {
+    return crypto.subtle.verify(new HmacParams(), importHmac(__twofaSecret), mac, msg);
+}
+
+/**
+ * The canonical signed message, a FIXED length-prefixed binary layout (no JSON,
+ * so fields can't be confused): `u8 version | str recipient | str purpose |
+ * u64 exp | str code`. The code is signed here but NEVER stored in the token.
+ */
+function canonicalMessage(recipient: string, purpose: string, exp: u64, code: string): Uint8Array {
+    const w = new DataWriter();
+    w.writeU8(TWOFA_VERSION);
+    w.writeString(recipient);
+    w.writeString(purpose);
+    w.writeU64(exp);
+    w.writeString(code);
+    return w.toBytes();
+}
+
+/** The client token: `u8 version | str purpose | u64 exp | bytes mac` (base64url). */
+function encodeToken(purpose: string, exp: u64, mac: Uint8Array): string {
+    const w = new DataWriter();
+    w.writeU8(TWOFA_VERSION);
+    w.writeString(purpose);
+    w.writeU64(exp);
+    w.writeBytes(mac);
+    return base64UrlEncode(w.toBytes());
+}
+
+/** A random numeric code of `digits` digits, from the CSPRNG. */
+function randomCode(digits: i32): string {
+    const buf = new Uint8Array(digits);
+    crypto.getRandomValues(buf);
+    let s = '';
+    for (let i = 0; i < digits; i++) {
+        // byte % 10: the tiny modulo bias is irrelevant for a short-lived code.
+        s += (<i32>buf[i] % 10).toString();
+    }
+    return s;
+}
+
+function clampDigits(digits: i32): i32 {
+    if (digits < 4) return 4;
+    if (digits > 10) return 10;
+    return digits;
+}
+
+/** A generated code + its token, for the bring-your-own-email path ({@link TwoFactor.issue}). */
+export class TwoFactorIssue {
+    code: string;
+    token: string;
+    constructor(code: string, token: string) {
+        this.code = code;
+        this.token = token;
+    }
+}
+
+/** The result of {@link TwoFactor.send}: the token to hand the client + the email status. */
+export class TwoFactorChallenge {
+    token: string;
+    status: EmailStatus;
+    constructor(token: string, status: EmailStatus) {
+        this.token = token;
+        this.status = status;
+    }
+}
+
+export namespace TwoFactor {
+    /** Default code lifetime if none is given. Keep it short (stateless => not single-use). */
+    export const DEFAULT_TTL_SECS: u64 = 600; // 10 minutes
+    /** Default number of digits in a code. */
+    export const DEFAULT_DIGITS: i32 = 6;
+
+    /**
+     * Configure the HMAC secret used to sign verification tokens. Call once at
+     * startup from `main.ts`. Must be identical on every edge instance and kept
+     * out of any client bundle.
+     */
+    export function setSecret(secret: Uint8Array): void {
+        __twofaSecret = secret;
+    }
+
+    /**
+     * Generate a code + token WITHOUT sending an email (bring your own email,
+     * e.g. an `EmailTemplate`): mint the code yourself-friendly path. Email
+     * `result.code` to `recipient` and hand `result.token` to the client.
+     */
+    export function issue(
+        recipient: string,
+        purpose: string,
+        ttlSecs: u64 = DEFAULT_TTL_SECS,
+        digits: i32 = DEFAULT_DIGITS,
+    ): TwoFactorIssue {
+        const code = randomCode(clampDigits(digits));
+        const exp = Time.nowSeconds() + ttlSecs;
+        const mac = hmac(canonicalMessage(recipient, purpose, exp, code));
+        return new TwoFactorIssue(code, encodeToken(purpose, exp, mac));
+    }
+
+    /**
+     * Issue a code and send it in a built-in email; returns the token + the send
+     * {@link EmailStatus}. For a branded email, use {@link issue} + your own
+     * `EmailTemplate`/`EmailService.send` instead.
+     */
+    export function send(
+        recipient: string,
+        purpose: string,
+        ttlSecs: u64 = DEFAULT_TTL_SECS,
+        digits: i32 = DEFAULT_DIGITS,
+    ): TwoFactorChallenge {
+        const issued = issue(recipient, purpose, ttlSecs, digits);
+        const subject = 'Your verification code';
+        const text =
+            'Your verification code is ' +
+            issued.code +
+            '. It expires shortly. If you did not request it, ignore this email.';
+        const html =
+            '<table width="100%" style="font-family:Arial,sans-serif"><tbody><tr><td style="padding:24px">' +
+            '<p style="color:#111827;font-size:15px;margin:0 0 8px">Your verification code is</p>' +
+            '<p style="font-size:30px;font-weight:bold;letter-spacing:6px;color:#111827;margin:0">' +
+            issued.code +
+            '</p>' +
+            '<p style="color:#9ca3af;font-size:12px;margin-top:20px">It expires shortly. If you did not request it, ignore this email.</p>' +
+            '</td></tr></tbody></table>';
+        const status = EmailService.send(recipient, subject, text, purpose, html);
+        return new TwoFactorChallenge(issued.token, status);
+    }
+
+    /**
+     * Verify a `(token, code)` pair for `recipient`. Stateless: recomputes the
+     * HMAC from the token's `(purpose, exp)` + the supplied `(recipient, code)`
+     * and constant-time compares, after checking the version and expiry. Returns
+     * `true` only for a code that was issued for this recipient and has not
+     * expired. NOT single-use within the TTL (see the file header).
+     */
+    export function verify(token: string, recipient: string, code: string): bool {
+        const raw = base64UrlDecode(token);
+        if (raw == null) return false;
+
+        const r = new DataReader(raw);
+        if (r.readU8() != TWOFA_VERSION) return false;
+        const purpose = r.readString();
+        const exp = r.readU64();
+        const mac = r.readBytes();
+        if (!r.ok) return false; // truncated / malformed token
+
+        if (Time.nowSeconds() >= exp) return false; // expired
+
+        return hmacVerify(mac, canonicalMessage(recipient, purpose, exp, code));
+    }
+}

package/server/runtime/rest/RouteContext.ts

@@ -7,6 +7,14 @@
 
 import { Request } from '../request';
 
+// Host import: write the request's UNSPOOFABLE peer IP (the socket's remote
+// address, NOT a client-supplied header) into a guest buffer. Returns the byte
+// length written, 0 when there is no peer IP, or -1 if the buffer is too small.
+// Backed by `client_ip_import.rs` on the edge and the dev-server host.
+// @ts-ignore: decorator
+@external('env', 'client_ip')
+declare function __toilClientIp(ptr: usize, cap: i32): i32;
+
 export class RouteContext {
     /** The raw incoming request (method, path, headers, body). */
     request: Request;
@@ -55,6 +63,20 @@ export class RouteContext {
         return String.UTF8.decodeUnsafe(body.dataStart, body.byteLength);
     }
 
+    /**
+     * The connecting client's IP as a string ("203.0.113.7" or an IPv6 form),
+     * or "" if unavailable. This is the TRUSTED socket peer the edge observed,
+     * not a forgeable header like X-Forwarded-For, so it is safe to key rate
+     * limits, geo, or audit logs on it.
+     */
+    clientIp(): string {
+        const cap = 64; // max IPv6 text is 45 bytes; 64 leaves headroom
+        const buf = new Uint8Array(cap);
+        const n = __toilClientIp(buf.dataStart, cap);
+        if (n <= 0) return '';
+        return String.UTF8.decodeUnsafe(buf.dataStart, n);
+    }
+
     private ensureQuery(): void {
         if (this.queryKeys != null) return;
         const keys = new Array<string>();

package/src/cli/create.ts

@@ -295,6 +295,17 @@ declare const Cookies: typeof import('toiljs/server/runtime/http/cookies').Cooki
 type Cookies = import('toiljs/server/runtime/http/cookies').Cookies;
 declare const SecureCookies: typeof import('toiljs/server/runtime/http/securecookies').SecureCookies;
 type SecureCookies = import('toiljs/server/runtime/http/securecookies').SecureCookies;
+// Email, rate-limit, 2FA, and auth globals (server/globals/*), hand-declared
+// because their AssemblyScript source can't be type-aliased from tsc.
+declare enum EmailStatus { Sent, Disabled, Budget, RecipientCapped, Deduped, TryLater, BadRecipient, ProviderError }
+declare namespace EmailService { function send(to: string, subject: string, body: string, purpose?: string, html?: string): EmailStatus; }
+declare class RenderedEmail { subject: string; body: string; html: string; constructor(subject: string, body: string, html: string); }
+declare class EmailTemplate { constructor(subject: string, body: string, html?: string); render(vars: Map<string, string>): RenderedEmail; send(to: string, vars: Map<string, string>, purpose?: string): EmailStatus; }
+declare enum RateLimit { FixedWindow, SlidingWindow, TokenBucket }
+declare class TwoFactorIssue { code: string; token: string; constructor(code: string, token: string); }
+declare class TwoFactorChallenge { token: string; status: EmailStatus; constructor(token: string, status: EmailStatus); }
+declare namespace TwoFactor { function setSecret(secret: Uint8Array): void; function issue(recipient: string, purpose: string, ttlSecs?: u64, digits?: i32): TwoFactorIssue; function send(recipient: string, purpose: string, ttlSecs?: u64, digits?: i32): TwoFactorChallenge; function verify(token: string, recipient: string, code: string): bool; }
+declare namespace AuthService { const SESSION_COOKIE: string; const USER_COOKIE: string; const LOGIN_CONTEXT: string; const PUBLIC_KEY_LEN: i32; const SIGNATURE_LEN: i32; const DEFAULT_SESSION_TTL_SECS: u64; function setSecret(secret: Uint8Array): void; function hasSession(): bool; function getSessionBytes(): Uint8Array | null; function mintSession(userData: Uint8Array, ttlSecs?: u64): Cookie; function clearSession(): Cookie; function userCookie(userData: Uint8Array, ttlSecs?: u64): Cookie; function clearUserCookie(): Cookie; function buildLoginMessage(sub: string, aud: string, cid: Uint8Array, nonce: Uint8Array, iat: u64, exp: u64): Uint8Array; function verifyLogin(publicKey: Uint8Array, message: Uint8Array, signature: Uint8Array): bool; }
 `;
 
 /**