@keetanetwork/anchor 0.0.29 → 0.0.30

package/lib/http-server-shared.d.ts

@@ -0,0 +1,14 @@
+import type { Account } from "@keetanetwork/keetanet-client/lib/account.js";
+export interface HTTPSignedField {
+    nonce: string;
+    timestamp: string;
+    signature: string;
+}
+export declare const assertHTTPSignedField: (input: unknown) => HTTPSignedField;
+export interface HTTPSignedFieldURLParameters {
+    signedField: HTTPSignedField | null;
+    account: Account | null;
+}
+export declare function addSignatureToURL(input: URL | string, data: HTTPSignedFieldURLParameters): URL;
+export declare function parseSignatureFromURL(input: URL | string): HTTPSignedFieldURLParameters;
+//# sourceMappingURL=http-server-shared.d.ts.map

package/lib/http-server-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-server-shared.d.ts","sourceRoot":"","sources":["../../src/lib/http-server-shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,8CAA8C,CAAC;AAK5E,MAAM,WAAW,eAAe;IAC/B,KAAK,EAAE,MAAM,CAAC;IAEd,SAAS,EAAE,MAAM,CAAC;IAElB,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,eAAO,MAAM,qBAAqB,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,eAAuD,CAAC;AAEhH,MAAM,WAAW,4BAA4B;IAC5C,WAAW,EAAE,eAAe,GAAG,IAAI,CAAC;IACpC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;CACxB;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,EAAE,IAAI,EAAE,4BAA4B,GAAG,GAAG,CA0B9F;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,GAAG,4BAA4B,CAoCvF"}

package/lib/http-server-shared.js

@@ -0,0 +1,108 @@
+import * as __typia_transform__assertGuard from "typia/lib/internal/_assertGuard.js";
+import * as __typia_transform__accessExpressionAsString from "typia/lib/internal/_accessExpressionAsString.js";
+import { KeetaAnchorUserError } from "./error.js";
+import { KeetaNet } from "../client/index.js";
+import { createAssertEquals } from "typia";
+export const assertHTTPSignedField = (() => { const _io0 = (input, _exceptionable = true) => "string" === typeof input.nonce && "string" === typeof input.timestamp && "string" === typeof input.signature && (3 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["nonce", "timestamp", "signature"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.nonce || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".nonce",
+    expected: "string",
+    value: input.nonce
+}, _errorFactory)) && ("string" === typeof input.timestamp || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".timestamp",
+    expected: "string",
+    value: input.timestamp
+}, _errorFactory)) && ("string" === typeof input.signature || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".signature",
+    expected: "string",
+    value: input.signature
+}, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["nonce", "timestamp", "signature"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _io0(input, true); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssertEquals",
+            path: _path + "",
+            expected: "HTTPSignedField",
+            value: input
+        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssertEquals",
+            path: _path + "",
+            expected: "HTTPSignedField",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+export function addSignatureToURL(input, data) {
+    let url;
+    if (typeof input === 'string') {
+        url = new URL(input);
+    }
+    else {
+        url = new URL(input.toString());
+    }
+    for (const key of ['nonce', 'timestamp', 'signature']) {
+        const searchKey = `signed.${key}`;
+        if (url.searchParams.has(searchKey)) {
+            throw (new KeetaAnchorUserError(`URL already has signed field parameter: ${searchKey}`));
+        }
+        if (data.signedField) {
+            url.searchParams.set(`signed.${key}`, data.signedField[key]);
+        }
+    }
+    if (data.account) {
+        url.searchParams.set('account', data.account.publicKeyString.get());
+    }
+    return (url);
+}
+export function parseSignatureFromURL(input) {
+    let url;
+    if (typeof input === 'string') {
+        url = new URL(input);
+    }
+    else {
+        url = new URL(input.toString());
+    }
+    const signedField = (() => {
+        const nonce = url.searchParams.get('signed.nonce');
+        const timestamp = url.searchParams.get('signed.timestamp');
+        const signature = url.searchParams.get('signed.signature');
+        if (nonce === null && timestamp === null && signature === null) {
+            return (null);
+        }
+        if (!nonce || !timestamp || !signature) {
+            throw (new KeetaAnchorUserError('Incomplete signature fields in URL'));
+        }
+        return ({ nonce, timestamp, signature });
+    })();
+    const account = (() => {
+        const accountParam = url.searchParams.get('account');
+        if (accountParam === null) {
+            return (null);
+        }
+        return (KeetaNet.lib.Account.fromPublicKeyString(accountParam).assertAccount());
+    })();
+    return ({ signedField, account });
+}
+//# sourceMappingURL=http-server-shared.js.map

package/lib/http-server-shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-server-shared.js","sourceRoot":"","sources":["../../src/lib/http-server-shared.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Account } from \"@keetanetwork/keetanet-client/lib/account.js\";\nimport { KeetaAnchorUserError } from \"./error.js\";\nimport { KeetaNet } from \"../client/index.js\";\nimport { createAssertEquals } from \"typia\";\n\nexport interface HTTPSignedField {\n\tnonce: string;\n\t/* Date and time of the request in ISO 8601 format */\n\ttimestamp: string;\n\t/* Signature of the account public key and the nonce as an ASN.1 Sequence, Base64 DER */\n\tsignature: string;\n}\n\nexport const assertHTTPSignedField: (input: unknown) => HTTPSignedField = createAssertEquals<HTTPSignedField>();\n\nexport interface HTTPSignedFieldURLParameters {\n\tsignedField: HTTPSignedField | null;\n\taccount: Account | null;\n}\n\nexport function addSignatureToURL(input: URL | string, data: HTTPSignedFieldURLParameters): URL {\n\tlet url: URL;\n\n\tif (typeof input === 'string') {\n\t\turl = new URL(input);\n\t} else {\n\t\turl = new URL(input.toString());\n\t}\n\n\tfor (const key of [ 'nonce', 'timestamp', 'signature' ] as const) {\n\t\tconst searchKey = `signed.${key}`;\n\n\t\tif (url.searchParams.has(searchKey)) {\n\t\t\tthrow(new KeetaAnchorUserError(`URL already has signed field parameter: ${searchKey}`));\n\t\t}\n\n\t\tif (data.signedField) {\n\t\t\turl.searchParams.set(`signed.${key}`, data.signedField[key]);\n\t\t}\n\t}\n\n\tif (data.account) {\n\t\turl.searchParams.set('account', data.account.publicKeyString.get());\n\t}\n\n\treturn(url);\n}\n\nexport function parseSignatureFromURL(input: URL | string): HTTPSignedFieldURLParameters {\n\tlet url: URL;\n\n\tif (typeof input === 'string') {\n\t\turl = new URL(input);\n\t} else {\n\t\turl = new URL(input.toString());\n\t}\n\n\tconst signedField = ((): HTTPSignedField | null => {\n\t\tconst nonce = url.searchParams.get('signed.nonce');\n\t\tconst timestamp = url.searchParams.get('signed.timestamp');\n\t\tconst signature = url.searchParams.get('signed.signature');\n\n\t\tif (nonce === null && timestamp === null && signature === null) {\n\t\t\treturn(null);\n\t\t}\n\n\t\tif (!nonce || !timestamp || !signature) {\n\t\t\tthrow(new KeetaAnchorUserError('Incomplete signature fields in URL'));\n\t\t}\n\n\t\treturn({ nonce, timestamp, signature });\n\t})();\n\n\tconst account = ((): Account | null => {\n\t\tconst accountParam = url.searchParams.get('account');\n\t\tif (accountParam === null) {\n\t\t\treturn(null);\n\t\t}\n\n\t\treturn(KeetaNet.lib.Account.fromPublicKeyString(accountParam).assertAccount());\n\t})();\n\n\n\treturn({ signedField, account });\n}\n"]}

package/lib/http-server.d.ts

@@ -0,0 +1,62 @@
+import * as http from 'http';
+import type { JSONSerializable } from './utils/json.js';
+import type { Logger } from './log/index.js';
+export declare const AssertHTTPErrorData: (input: unknown) => {
+    error: string;
+    statusCode?: number;
+    contentType?: string;
+};
+export type Routes = {
+    [route: string]: (urlParams: Map<string, string>, postData: JSONSerializable | undefined, requestHeaders: http.IncomingHttpHeaders) => Promise<{
+        output: string | Buffer;
+        statusCode?: number;
+        contentType?: string;
+        headers?: {
+            [headerName: string]: string;
+        };
+    }>;
+};
+export interface KeetaAnchorHTTPServerConfig {
+    /**
+     * The port for the HTTP server to listen on (default is an ephemeral port).
+     */
+    port?: number;
+    /**
+     * Enable debug logging
+     */
+    logger?: Logger;
+}
+export declare abstract class KeetaNetAnchorHTTPServer<ConfigType extends KeetaAnchorHTTPServerConfig = KeetaAnchorHTTPServerConfig> implements Required<KeetaAnchorHTTPServerConfig> {
+    #private;
+    readonly port: NonNullable<KeetaAnchorHTTPServerConfig['port']>;
+    readonly logger: NonNullable<KeetaAnchorHTTPServerConfig['logger']>;
+    constructor(config: ConfigType);
+    protected abstract initRoutes(config: ConfigType): Promise<Routes>;
+    private static routeMatch;
+    private static routeFind;
+    private static addCORS;
+    private main;
+    /**
+     * Start the HTTP server and wait for it to be fully initialized.
+     */
+    start(): Promise<void>;
+    /**
+     * Wait for the server to terminate. This will only resolve once the
+     * server has been stopped.
+     */
+    wait(): Promise<void>;
+    /**
+     * Stop the HTTP server and wait for it to be fully terminated.
+     */
+    stop(): Promise<void>;
+    /**
+     * Get the URL of the server, which can be used to make requests to
+     * it.  This will use "localhost" as the hostname and the port that
+     * the server is listening on by default but can be overridden by
+     * setting a custom URL.
+     */
+    get url(): string;
+    set url(value: string | URL | ((object: this) => string));
+    [Symbol.asyncDispose](): Promise<void>;
+}
+//# sourceMappingURL=http-server.d.ts.map

package/lib/http-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-server.d.ts","sourceRoot":"","sources":["../../src/lib/http-server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAK7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,MAAM,EAAY,MAAM,gBAAgB,CAAC;AAKvD,eAAO,MAAM,mBAAmB,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAAkF,CAAC;AAOpM,MAAM,MAAM,MAAM,GAAG;IACpB,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,gBAAgB,GAAG,SAAS,EAAE,cAAc,EAAE,IAAI,CAAC,mBAAmB,KAAK,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE;YAAE,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC;SAAE,CAAC;KAAE,CAAC,CAAC;CACrQ,CAAC;AAEF,MAAM,WAAW,2BAA2B;IAC3C;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,8BAAsB,wBAAwB,CAAC,UAAU,SAAS,2BAA2B,GAAG,2BAA2B,CAAE,YAAW,QAAQ,CAAC,2BAA2B,CAAC;;IAC5K,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,2BAA2B,CAAC,MAAM,CAAC,CAAC,CAAC;IAChE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,2BAA2B,CAAC,QAAQ,CAAC,CAAC,CAAC;gBAMxD,MAAM,EAAE,UAAU;IAM9B,SAAS,CAAC,QAAQ,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAElE,OAAO,CAAC,MAAM,CAAC,UAAU;IA2BzB,OAAO,CAAC,MAAM,CAAC,SAAS;IA2BxB,OAAO,CAAC,MAAM,CAAC,OAAO;YAsGR,IAAI;IAsMlB;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAc5B;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAO3B;;;;;OAKG;IACH,IAAI,GAAG,IAAI,MAAM,CAyBhB;IAED,IAAI,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,CAAC,CAAC,MAAM,EAAE,IAAI,KAAK,MAAM,CAAC,EAEvD;IAED,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC;CAGtC"}

package/lib/http-server.js

@@ -0,0 +1,431 @@
+import * as __typia_transform__assertGuard from "typia/lib/internal/_assertGuard.js";
+import * as http from 'http';
+import { KeetaAnchorError, KeetaAnchorUserError } from './error.js';
+import { Log } from './log/index.js';
+import { createAssert } from 'typia';
+import { assertNever } from './utils/never.js';
+export const AssertHTTPErrorData = (() => { const _io0 = input => "string" === typeof input.error && (undefined === input.statusCode || "number" === typeof input.statusCode) && (undefined === input.contentType || "string" === typeof input.contentType); const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.error || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".error",
+    expected: "string",
+    value: input.error
+}, _errorFactory)) && (undefined === input.statusCode || "number" === typeof input.statusCode || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".statusCode",
+    expected: "(number | undefined)",
+    value: input.statusCode
+}, _errorFactory)) && (undefined === input.contentType || "string" === typeof input.contentType || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".contentType",
+    expected: "(string | undefined)",
+    value: input.contentType
+}, _errorFactory)); const __is = input => "object" === typeof input && null !== input && _io0(input); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "__type",
+            value: input
+        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "__type",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+/**
+ * The maximum size of a request (128KiB)
+ */
+const MAX_REQUEST_SIZE = 1024 * 128;
+;
+export class KeetaNetAnchorHTTPServer {
+    port;
+    logger;
+    #serverPromise;
+    #server;
+    #url;
+    #config;
+    constructor(config) {
+        this.#config = { ...config };
+        this.port = config.port ?? 0;
+        this.logger = config.logger ?? Log.Legacy('ANCHOR');
+    }
+    static routeMatch(requestURL, routeURL) {
+        const requestURLPaths = requestURL.pathname.split('/');
+        const routeURLPaths = routeURL.pathname.split('/');
+        if (requestURLPaths.length !== routeURLPaths.length) {
+            return ({ match: false });
+        }
+        const params = new Map();
+        for (let partIndex = 0; partIndex < requestURLPaths.length; partIndex++) {
+            const requestPath = requestURLPaths[partIndex];
+            const routePath = routeURLPaths[partIndex];
+            if (routePath === undefined || requestPath === undefined) {
+                return ({ match: false });
+            }
+            if (routePath.startsWith(':')) {
+                params.set(routePath.slice(1), requestPath);
+            }
+            else if (requestPath !== routePath) {
+                return ({ match: false });
+            }
+        }
+        return ({ match: true, params: params });
+    }
+    static routeFind(method, requestURL, routes) {
+        for (const routeKey in routes) {
+            const route = routes[routeKey];
+            if (route === undefined) {
+                continue;
+            }
+            const [routeMethod, ...routePathParts] = routeKey.split(' ');
+            const routePath = `/${routePathParts.join(' ')}`.replace(/^\/+/, '/');
+            if (method !== routeMethod) {
+                continue;
+            }
+            const routeURL = new URL(routePath, 'http://localhost');
+            const matchResult = this.routeMatch(requestURL, routeURL);
+            if (matchResult.match) {
+                return ({
+                    route: route,
+                    params: matchResult.params
+                });
+            }
+        }
+        return (null);
+    }
+    static addCORS(routes) {
+        const newRoutes = {};
+        const validMethods = new Set(['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD']);
+        const methodsByPath = {};
+        for (const routeKey in routes) {
+            const methodAndPath = routeKey.split(' ');
+            const method = methodAndPath[0];
+            const path = methodAndPath.slice(1).join(' ');
+            if (method === undefined || path === undefined) {
+                continue;
+            }
+            if (!validMethods.has(method)) {
+                continue;
+            }
+            if (!(path in methodsByPath)) {
+                methodsByPath[path] = new Set();
+            }
+            if (methodsByPath[path] === undefined) {
+                throw (new Error(`internal error: methodsByPath missing path for ${path}`));
+            }
+            methodsByPath[path].add(method);
+        }
+        const seenPaths = new Set();
+        for (const routeKey in routes) {
+            const methodAndPath = routeKey.split(' ');
+            const method = methodAndPath[0];
+            const path = methodAndPath.slice(1).join(' ');
+            const routeHandler = routes[routeKey];
+            if (routeHandler === undefined) {
+                throw (new Error(`internal error: routeHandler missing for routeKey ${routeKey}`));
+            }
+            if (method !== 'ERROR') {
+                if (method === undefined || path === undefined) {
+                    newRoutes[routeKey] = routeHandler;
+                    continue;
+                }
+                if (!validMethods.has(method)) {
+                    newRoutes[routeKey] = routeHandler;
+                    continue;
+                }
+            }
+            const validMethodsForPath = methodsByPath[path];
+            let validMethodsForPathParts = [];
+            if (validMethodsForPath !== undefined) {
+                validMethodsForPath.add('OPTIONS');
+                validMethodsForPathParts = Array.from(validMethodsForPath);
+            }
+            else {
+                validMethodsForPathParts = [...Array.from(validMethods), 'OPTIONS'];
+            }
+            newRoutes[routeKey] = async function (...args) {
+                const retval = await routeHandler(...args);
+                /* Add CORS headers to the response for the original route handler */
+                if (retval.contentType === 'application/json' || retval.contentType === undefined) {
+                    if (!('headers' in retval) || retval.headers === undefined) {
+                        retval.headers = {};
+                    }
+                    retval.headers['Access-Control-Allow-Origin'] = '*';
+                }
+                return (retval);
+            };
+            if (!seenPaths.has(path) && path !== '' && path !== undefined) {
+                const corsRouteKey = `OPTIONS ${path}`;
+                newRoutes[corsRouteKey] = async function () {
+                    return ({
+                        output: '',
+                        statusCode: 204,
+                        contentType: 'text/plain',
+                        headers: {
+                            'Access-Control-Allow-Origin': '*',
+                            'Access-Control-Allow-Methods': validMethodsForPathParts.join(', '),
+                            'Access-Control-Allow-Headers': 'Content-Type',
+                            'Access-Control-Max-Age': '86400'
+                        }
+                    });
+                };
+                seenPaths.add(path);
+            }
+        }
+        return (newRoutes);
+    }
+    async main(onSetPort) {
+        this.logger?.debug('KeetaAnchorHTTP.Server', 'Starting HTTP server...');
+        const port = this.port;
+        const routes = KeetaNetAnchorHTTPServer.addCORS({
+            ERROR: async function (_ignore_params, postData) {
+                const errorInfo = AssertHTTPErrorData(postData);
+                const retval = {
+                    output: errorInfo.error,
+                    statusCode: errorInfo.statusCode ?? 400,
+                    contentType: errorInfo.contentType ?? 'text/plain'
+                };
+                return (retval);
+            },
+            ...(await this.initRoutes(this.#config))
+        });
+        const server = new http.Server(async (request, response) => {
+            const url = new URL(request.url ?? '/', `http://${request.headers.host ?? 'localhost'}`);
+            const method = request.method ?? 'GET';
+            /*
+             * Finalize the response by syncing the logger and ending
+             * the response.
+             */
+            const responseFinalize = async () => {
+                if ('sync' in this.logger && typeof this.logger.sync === 'function') {
+                    try {
+                        await this.logger.sync();
+                    }
+                    catch {
+                        /* ignore errors */
+                    }
+                }
+                response.end();
+            };
+            /*
+             * Lookup the route based on the request
+             */
+            const requestedRouteAndParams = KeetaNetAnchorHTTPServer.routeFind(method, url, routes);
+            if (requestedRouteAndParams === null) {
+                response.statusCode = 404;
+                response.setHeader('Content-Type', 'text/plain');
+                response.write('Not Found');
+                await responseFinalize();
+                return;
+            }
+            /*
+             * Extract the route handler and the parameters from
+             * the request
+             */
+            const { route, params } = requestedRouteAndParams;
+            /**
+             * Attempt to run the route, catch any errors
+             */
+            let result = undefined;
+            let generatedResult = false;
+            try {
+                /**
+                 * If POST'ing, read and parse the POST data
+                 */
+                let postData;
+                if (request.method === 'POST') {
+                    const data = await request.map(function (chunk) {
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                        return (Buffer.from(chunk));
+                    }).reduce(function (prev, curr) {
+                        if (prev.length > MAX_REQUEST_SIZE) {
+                            throw (new Error('Request too large'));
+                        }
+                        if (!Buffer.isBuffer(curr)) {
+                            throw (new Error(`internal error: Current item is not a buffer -- ${typeof curr}`));
+                        }
+                        return (Buffer.concat([prev, curr]));
+                    }, Buffer.from(''));
+                    if (request.headers['content-type'] === 'application/json') {
+                        try {
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                            postData = JSON.parse(data.toString('utf-8'));
+                        }
+                        catch {
+                            throw (new Error('Invalid JSON data'));
+                        }
+                    }
+                    else {
+                        throw (new KeetaAnchorUserError('Unsupported content type'));
+                    }
+                    /**
+                     * Call the route handler
+                     */
+                    result = await route(params, postData, request.headers);
+                }
+                else {
+                    result = await route(params, undefined, request.headers);
+                }
+                generatedResult = true;
+            }
+            catch (err) {
+                let logLevel = 'error';
+                if (KeetaAnchorError.isInstance(err)) {
+                    /*
+                     * We're able to safely cast this here because the cast
+                     * duplicates the logic.
+                     */
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    logLevel = err.logLevel.toLowerCase();
+                }
+                /**
+                 * If an error occurs, log it and return an error page
+                 */
+                this.logger?.[logLevel]('KeetaAnchorHTTP.Server', err);
+                /**
+                 * If it is a user error, provide a user-friendly error page
+                 */
+                const errorHandlerRoute = routes['ERROR'];
+                if (errorHandlerRoute !== undefined) {
+                    if (KeetaAnchorUserError.isInstance(err)) {
+                        result = await errorHandlerRoute(new Map(), err.asErrorResponse('application/json'), request.headers);
+                    }
+                    else {
+                        result = await errorHandlerRoute(new Map(), {
+                            error: JSON.stringify({ ok: false, error: 'Internal Server Error' }),
+                            statusCode: 500,
+                            contentType: 'application/json'
+                        }, request.headers);
+                    }
+                    generatedResult = true;
+                }
+                if (!generatedResult) {
+                    /**
+                     * Otherwise provide a generic error page
+                     */
+                    response.statusCode = 500;
+                    response.setHeader('Content-Type', 'text/plain');
+                    response.write('Internal Server Error');
+                    await responseFinalize();
+                    return;
+                }
+            }
+            if (result === undefined) {
+                throw (new Error('internal error: No result'));
+            }
+            /**
+             * Write the response to the client
+             */
+            response.statusCode = result.statusCode ?? 200;
+            for (const headerKey in result.headers ?? {}) {
+                const headerValue = result.headers?.[headerKey];
+                if (headerValue !== undefined) {
+                    response.setHeader(headerKey, headerValue);
+                }
+            }
+            response.setHeader('Content-Type', result.contentType ?? 'application/json');
+            response.write(result.output);
+            await responseFinalize();
+        });
+        this.#server = server;
+        /**
+         * Create a promise to wait for the server to close
+         */
+        const waiter = new Promise((resolve) => {
+            server.on('close', () => {
+                this.logger?.debug('KeetaAnchorHTTP.Server', 'Server closed');
+                resolve();
+            });
+        });
+        /**
+         * Start listening on the port
+         */
+        server.listen(port, () => {
+            const address = server.address();
+            if (address !== null && typeof address === 'object') {
+                // @ts-ignore
+                this.port = address.port;
+                onSetPort?.(this.port);
+            }
+            this.logger?.debug('KeetaAnchorHTTP.Server', 'Listening on port:', this.port);
+        });
+        /**
+         * Wait for the server to close
+         */
+        await waiter;
+    }
+    /**
+     * Start the HTTP server and wait for it to be fully initialized.
+     */
+    async start() {
+        /*
+         * Start the server and wait for it to be initialized before returning
+         */
+        await new Promise((resolve, reject) => {
+            this.#serverPromise = this.main(function () {
+                resolve();
+            }).catch(function (error) {
+                // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Wait for the server to terminate. This will only resolve once the
+     * server has been stopped.
+     */
+    async wait() {
+        await this.#serverPromise;
+    }
+    /**
+     * Stop the HTTP server and wait for it to be fully terminated.
+     */
+    async stop() {
+        this.#server?.close();
+        // @ts-ignore
+        this.#server = undefined;
+        await this.wait();
+    }
+    /**
+     * Get the URL of the server, which can be used to make requests to
+     * it.  This will use "localhost" as the hostname and the port that
+     * the server is listening on by default but can be overridden by
+     * setting a custom URL.
+     */
+    get url() {
+        if (this.port === 0 || this.#server === undefined) {
+            throw (new Error('Server not started'));
+        }
+        if (this.#url !== undefined) {
+            let newURL;
+            if (typeof this.#url === 'string') {
+                newURL = this.#url;
+            }
+            else if (this.#url instanceof URL || ('port' in this.#url && 'hostname' in this.#url && 'toString' in this.#url)) {
+                newURL = this.#url.toString();
+            }
+            else if (typeof this.#url === 'function') {
+                newURL = this.#url(this);
+            }
+            else {
+                assertNever(this.#url);
+            }
+            const newURLObj = new URL(newURL);
+            newURLObj.pathname = '/';
+            newURLObj.search = '';
+            return (newURLObj.toString());
+        }
+        return (`http://localhost:${this.port}`);
+    }
+    set url(value) {
+        this.#url = value;
+    }
+    [Symbol.asyncDispose]() {
+        return (this.stop());
+    }
+}
+//# sourceMappingURL=http-server.js.map