@keetanetwork/anchor 0.0.2 → 0.0.5

package/services/fx/server.js

@@ -0,0 +1,693 @@
+import * as __typia_transform__assertGuard from "typia/lib/internal/_assertGuard.js";
+import * as http from 'http';
+import KeetaNet from '@keetanetwork/keetanet-client';
+import { createAssert } from 'typia';
+import { KeetaAnchorUserError } from '../../lib/error.js';
+import { acceptSwapRequest } from './common.js';
+import * as Signing from '../../lib/utils/signing.js';
+import { Log } from '../../lib/log/index.js';
+/**
+ * The maximum size of a request (128KiB)
+ */
+const MAX_REQUEST_SIZE = 1024 * 128;
+const assertConversionInputCanonical = (() => { const _io0 = input => "string" === typeof input.from && (RegExp(/^keeta_am(.*)/).test(input.from) || RegExp(/^keeta_an(.*)/).test(input.from) || RegExp(/^keeta_ao(.*)/).test(input.from) || RegExp(/^keeta_ap(.*)/).test(input.from) || RegExp(/^tyblocks_am(.*)/).test(input.from) || RegExp(/^tyblocks_an(.*)/).test(input.from) || RegExp(/^tyblocks_ao(.*)/).test(input.from) || RegExp(/^tyblocks_ap(.*)/).test(input.from)) && ("string" === typeof input.to && (RegExp(/^keeta_am(.*)/).test(input.to) || RegExp(/^keeta_an(.*)/).test(input.to) || RegExp(/^keeta_ao(.*)/).test(input.to) || RegExp(/^keeta_ap(.*)/).test(input.to) || RegExp(/^tyblocks_am(.*)/).test(input.to) || RegExp(/^tyblocks_an(.*)/).test(input.to) || RegExp(/^tyblocks_ao(.*)/).test(input.to) || RegExp(/^tyblocks_ap(.*)/).test(input.to))) && "string" === typeof input.amount && ("from" === input.affinity || "to" === input.affinity); const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.from && (RegExp(/^keeta_am(.*)/).test(input.from) || RegExp(/^keeta_an(.*)/).test(input.from) || RegExp(/^keeta_ao(.*)/).test(input.from) || RegExp(/^keeta_ap(.*)/).test(input.from) || RegExp(/^tyblocks_am(.*)/).test(input.from) || RegExp(/^tyblocks_an(.*)/).test(input.from) || RegExp(/^tyblocks_ao(.*)/).test(input.from) || RegExp(/^tyblocks_ap(.*)/).test(input.from)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".from",
+    expected: "(`keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.from
+}, _errorFactory)) && ("string" === typeof input.to && (RegExp(/^keeta_am(.*)/).test(input.to) || RegExp(/^keeta_an(.*)/).test(input.to) || RegExp(/^keeta_ao(.*)/).test(input.to) || RegExp(/^keeta_ap(.*)/).test(input.to) || RegExp(/^tyblocks_am(.*)/).test(input.to) || RegExp(/^tyblocks_an(.*)/).test(input.to) || RegExp(/^tyblocks_ao(.*)/).test(input.to) || RegExp(/^tyblocks_ap(.*)/).test(input.to)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".to",
+    expected: "(`keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.to
+}, _errorFactory)) && ("string" === typeof input.amount || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".amount",
+    expected: "string",
+    value: input.amount
+}, _errorFactory)) && ("from" === input.affinity || "to" === input.affinity || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".affinity",
+    expected: "(\"from\" | \"to\")",
+    value: input.affinity
+}, _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: "ConversionInputCanonical",
+            value: input
+        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "ConversionInputCanonical",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+const assertConversionQuote = (() => { const _io0 = input => "object" === typeof input.request && null !== input.request && _io1(input.request) && "string" === typeof input.account && "string" === typeof input.convertedAmount && ("object" === typeof input.cost && null !== input.cost && _io2(input.cost)) && ("object" === typeof input.signed && null !== input.signed && _io3(input.signed)); const _io1 = input => "string" === typeof input.from && (RegExp(/^keeta_am(.*)/).test(input.from) || RegExp(/^keeta_an(.*)/).test(input.from) || RegExp(/^keeta_ao(.*)/).test(input.from) || RegExp(/^keeta_ap(.*)/).test(input.from) || RegExp(/^tyblocks_am(.*)/).test(input.from) || RegExp(/^tyblocks_an(.*)/).test(input.from) || RegExp(/^tyblocks_ao(.*)/).test(input.from) || RegExp(/^tyblocks_ap(.*)/).test(input.from)) && ("string" === typeof input.to && (RegExp(/^keeta_am(.*)/).test(input.to) || RegExp(/^keeta_an(.*)/).test(input.to) || RegExp(/^keeta_ao(.*)/).test(input.to) || RegExp(/^keeta_ap(.*)/).test(input.to) || RegExp(/^tyblocks_am(.*)/).test(input.to) || RegExp(/^tyblocks_an(.*)/).test(input.to) || RegExp(/^tyblocks_ao(.*)/).test(input.to) || RegExp(/^tyblocks_ap(.*)/).test(input.to))) && "string" === typeof input.amount && ("from" === input.affinity || "to" === input.affinity); const _io2 = input => "string" === typeof input.amount && ("string" === typeof input.token && (RegExp(/^keeta_am(.*)/).test(input.token) || RegExp(/^keeta_an(.*)/).test(input.token) || RegExp(/^keeta_ao(.*)/).test(input.token) || RegExp(/^keeta_ap(.*)/).test(input.token) || RegExp(/^tyblocks_am(.*)/).test(input.token) || RegExp(/^tyblocks_an(.*)/).test(input.token) || RegExp(/^tyblocks_ao(.*)/).test(input.token) || RegExp(/^tyblocks_ap(.*)/).test(input.token))); const _io3 = input => "string" === typeof input.nonce && "string" === typeof input.timestamp && "string" === typeof input.signature; const _ao0 = (input, _path, _exceptionable = true) => (("object" === typeof input.request && null !== input.request || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".request",
+    expected: "ConversionInputCanonical",
+    value: input.request
+}, _errorFactory)) && _ao1(input.request, _path + ".request", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".request",
+    expected: "ConversionInputCanonical",
+    value: input.request
+}, _errorFactory)) && ("string" === typeof input.account || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".account",
+    expected: "string",
+    value: input.account
+}, _errorFactory)) && ("string" === typeof input.convertedAmount || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".convertedAmount",
+    expected: "string",
+    value: input.convertedAmount
+}, _errorFactory)) && (("object" === typeof input.cost && null !== input.cost || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".cost",
+    expected: "__type",
+    value: input.cost
+}, _errorFactory)) && _ao2(input.cost, _path + ".cost", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".cost",
+    expected: "__type",
+    value: input.cost
+}, _errorFactory)) && (("object" === typeof input.signed && null !== input.signed || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".signed",
+    expected: "__type.o1",
+    value: input.signed
+}, _errorFactory)) && _ao3(input.signed, _path + ".signed", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".signed",
+    expected: "__type.o1",
+    value: input.signed
+}, _errorFactory)); const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.from && (RegExp(/^keeta_am(.*)/).test(input.from) || RegExp(/^keeta_an(.*)/).test(input.from) || RegExp(/^keeta_ao(.*)/).test(input.from) || RegExp(/^keeta_ap(.*)/).test(input.from) || RegExp(/^tyblocks_am(.*)/).test(input.from) || RegExp(/^tyblocks_an(.*)/).test(input.from) || RegExp(/^tyblocks_ao(.*)/).test(input.from) || RegExp(/^tyblocks_ap(.*)/).test(input.from)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".from",
+    expected: "(`keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.from
+}, _errorFactory)) && ("string" === typeof input.to && (RegExp(/^keeta_am(.*)/).test(input.to) || RegExp(/^keeta_an(.*)/).test(input.to) || RegExp(/^keeta_ao(.*)/).test(input.to) || RegExp(/^keeta_ap(.*)/).test(input.to) || RegExp(/^tyblocks_am(.*)/).test(input.to) || RegExp(/^tyblocks_an(.*)/).test(input.to) || RegExp(/^tyblocks_ao(.*)/).test(input.to) || RegExp(/^tyblocks_ap(.*)/).test(input.to)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".to",
+    expected: "(`keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.to
+}, _errorFactory)) && ("string" === typeof input.amount || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".amount",
+    expected: "string",
+    value: input.amount
+}, _errorFactory)) && ("from" === input.affinity || "to" === input.affinity || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".affinity",
+    expected: "(\"from\" | \"to\")",
+    value: input.affinity
+}, _errorFactory)); const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.amount || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".amount",
+    expected: "string",
+    value: input.amount
+}, _errorFactory)) && ("string" === typeof input.token && (RegExp(/^keeta_am(.*)/).test(input.token) || RegExp(/^keeta_an(.*)/).test(input.token) || RegExp(/^keeta_ao(.*)/).test(input.token) || RegExp(/^keeta_ap(.*)/).test(input.token) || RegExp(/^tyblocks_am(.*)/).test(input.token) || RegExp(/^tyblocks_an(.*)/).test(input.token) || RegExp(/^tyblocks_ao(.*)/).test(input.token) || RegExp(/^tyblocks_ap(.*)/).test(input.token)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".token",
+    expected: "(`keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.token
+}, _errorFactory)); const _ao3 = (input, _path, _exceptionable = true) => ("string" === typeof input.nonce || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".nonce",
+    expected: "string",
+    value: input.nonce
+}, _errorFactory)) && ("string" === typeof input.timestamp || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".timestamp",
+    expected: "string",
+    value: input.timestamp
+}, _errorFactory)) && ("string" === typeof input.signature || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".signature",
+    expected: "string",
+    value: input.signature
+}, _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: "KeetaFXAnchorQuote",
+            value: input
+        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "KeetaFXAnchorQuote",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+const assertErrorData = (() => { 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;
+}; })();
+;
+async function formatQuoteSignable(unsignedQuote) {
+    const retval = [
+        unsignedQuote.request.from,
+        unsignedQuote.request.to,
+        unsignedQuote.request.amount,
+        unsignedQuote.request.affinity,
+        unsignedQuote.account,
+        unsignedQuote.convertedAmount,
+        unsignedQuote.cost.token,
+        unsignedQuote.cost.amount
+    ];
+    return (retval);
+}
+async function generateSignedQuote(signer, unsignedQuote) {
+    const signableQuote = await formatQuoteSignable(unsignedQuote);
+    const signed = await Signing.SignData(signer, signableQuote);
+    return ({
+        ...unsignedQuote,
+        signed: signed
+    });
+}
+async function verifySignedData(signedBy, quote) {
+    const signableQuote = await formatQuoteSignable(quote);
+    return (await Signing.VerifySignedData(signedBy, signableQuote, quote.signed));
+}
+async function requestToAccounts(config, request) {
+    const account = KeetaNet.lib.Account.isInstance(config.account) ? config.account : await config.account(request);
+    let signer = null;
+    if (config.signer !== undefined) {
+        signer = (KeetaNet.lib.Account.isInstance(config.signer) ? config.signer : await config.signer(request)).assertAccount();
+    }
+    return ({
+        signer: signer ?? account.assertAccount(),
+        account: account.assertAccount()
+    });
+}
+async function initRoutes(config) {
+    const routes = {};
+    /**
+     * If a homepage is provided, setup the route for it
+     */
+    if ('homepage' in config) {
+        routes['GET /'] = async function () {
+            let homepageData;
+            if (typeof config.homepage === 'string') {
+                homepageData = config.homepage;
+            }
+            else {
+                if (!config.homepage) {
+                    throw (new Error('internal error: No homepage function provided'));
+                }
+                homepageData = await config.homepage();
+            }
+            return ({
+                output: homepageData,
+                contentType: 'text/html'
+            });
+        };
+    }
+    /**
+     * Setup the request handler for an estimate request
+     */
+    routes['POST /api/getEstimate'] = async function (_ignore_params, postData) {
+        if (!postData || typeof postData !== 'object') {
+            throw (new Error('No POST data provided'));
+        }
+        if (!('request' in postData)) {
+            throw (new Error('POST data missing request'));
+        }
+        const conversion = assertConversionInputCanonical(postData.request);
+        const rateAndFee = await config.fx.getConversionRateAndFee(conversion);
+        const estimateResponse = {
+            ok: true,
+            estimate: {
+                request: conversion,
+                convertedAmount: rateAndFee.convertedAmount,
+                expectedCost: {
+                    min: rateAndFee.cost.amount,
+                    max: rateAndFee.cost.amount,
+                    token: rateAndFee.cost.token
+                }
+            }
+        };
+        return ({
+            output: JSON.stringify(estimateResponse)
+        });
+    };
+    routes['POST /api/getQuote'] = async function (_ignore_params, postData) {
+        if (!postData || typeof postData !== 'object') {
+            throw (new Error('No POST data provided'));
+        }
+        if (!('request' in postData)) {
+            throw (new Error('POST data missing request'));
+        }
+        const conversion = assertConversionInputCanonical(postData.request);
+        const rateAndFee = await config.fx.getConversionRateAndFee(conversion);
+        const unsignedQuote = {
+            request: conversion,
+            ...rateAndFee
+        };
+        const signedQuote = await generateSignedQuote(config.quoteSigner, unsignedQuote);
+        const quoteResponse = {
+            ok: true,
+            quote: signedQuote
+        };
+        return ({
+            output: JSON.stringify(quoteResponse)
+        });
+    };
+    routes['POST /api/createExchange'] = async function (_ignore_params, postData) {
+        if (!postData || typeof postData !== 'object') {
+            throw (new Error('No POST data provided'));
+        }
+        if (!('request' in postData)) {
+            throw (new Error('POST data missing request'));
+        }
+        const request = postData.request;
+        if (!request || typeof request !== 'object') {
+            throw (new Error('Request is not an object'));
+        }
+        if (!('quote' in request)) {
+            throw (new Error('Quote is missing from request'));
+        }
+        if (!('block' in request) || typeof request.block !== 'string') {
+            throw (new Error('Block was not provided in exchange request'));
+        }
+        const quote = assertConversionQuote(request.quote);
+        const isValidQuote = await verifySignedData(config.quoteSigner, quote);
+        if (!isValidQuote) {
+            throw (new Error('Invalid quote signature'));
+        }
+        const block = new KeetaNet.lib.Block(request.block);
+        let userClient;
+        if (KeetaNet.UserClient.isInstance(config.client)) {
+            userClient = config.client;
+        }
+        else {
+            const { account, signer } = await requestToAccounts(config, quote.request);
+            userClient = new KeetaNet.UserClient({
+                client: config.client.client,
+                network: config.client.network,
+                networkAlias: config.client.networkAlias,
+                account: account,
+                signer: signer
+            });
+        }
+        const expectedToken = KeetaNet.lib.Account.fromPublicKeyString(quote.request.from);
+        const expectedAmount = quote.request.affinity === 'from' ? quote.request.amount : quote.convertedAmount;
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
+        const swapBlocks = await acceptSwapRequest(userClient, block, { token: expectedToken, amount: BigInt(expectedAmount) });
+        const publishResult = await userClient.client.transmit(swapBlocks);
+        if (!publishResult.publish) {
+            throw (new Error('Exchange Publish Failed'));
+        }
+        const exchangeResponse = {
+            ok: true,
+            exchangeID: block.hash.toString()
+        };
+        return ({
+            output: JSON.stringify(exchangeResponse)
+        });
+    };
+    routes['GET /api/getExchangeStatus/:id'] = async function (params) {
+        if (params === undefined || params === null) {
+            throw (new KeetaAnchorUserError('Expected params'));
+        }
+        const exchangeID = params.get('id');
+        if (typeof exchangeID !== 'string') {
+            throw (new Error('Missing exchangeID in params'));
+        }
+        const blockLookup = await config.client.client.getVoteStaple(exchangeID);
+        if (blockLookup === null) {
+            throw (new Error('Block Not Found'));
+        }
+        const exchangeResponse = {
+            ok: true,
+            exchangeID: exchangeID
+        };
+        return ({
+            output: JSON.stringify(exchangeResponse)
+        });
+    };
+    routes['ERROR'] = async function (_ignore_params, postData) {
+        const errorInfo = assertErrorData(postData);
+        const retval = {
+            output: errorInfo.error,
+            statusCode: errorInfo.statusCode ?? 400,
+            contentType: errorInfo.contentType ?? 'text/plain'
+        };
+        return (retval);
+    };
+    return (routes);
+}
+export class KeetaNetFXAnchorHTTPServer {
+    port;
+    homepage;
+    client;
+    logger;
+    account;
+    signer;
+    quoteSigner;
+    fx;
+    #serverPromise;
+    #server;
+    constructor(config) {
+        this.homepage = config.homepage ?? '';
+        this.port = config.port ?? 0;
+        this.client = config.client;
+        this.fx = config.fx;
+        this.account = config.account;
+        this.signer = config.signer ?? config.account;
+        this.quoteSigner = config.quoteSigner;
+        this.logger = config.logger ?? new Log();
+    }
+    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('KeetaAnchorFX.Server', 'Starting HTTP server...');
+        const port = this.port;
+        const routes = KeetaNetFXAnchorHTTPServer.addCORS(await initRoutes(this));
+        const server = new http.Server(async (request, response) => {
+            const url = new URL(request.url ?? '/', `http://${request.headers.host ?? 'localhost'}`);
+            const method = request.method ?? 'GET';
+            /*
+             * Lookup the route based on the request
+             */
+            const requestedRouteAndParams = KeetaNetFXAnchorHTTPServer.routeFind(method, url, routes);
+            if (requestedRouteAndParams === null) {
+                response.statusCode = 404;
+                response.setHeader('Content-Type', 'text/plain');
+                response.write('Not Found');
+                response.end();
+                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, 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);
+                }
+                else {
+                    result = await route(params, undefined);
+                }
+                generatedResult = true;
+            }
+            catch (err) {
+                /**
+                 * If an error occurs, log it and return an error page
+                 */
+                this.logger?.error('KeetaAnchorFX.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'));
+                        generatedResult = true;
+                    }
+                    else {
+                        result = await errorHandlerRoute(new Map(), {
+                            error: JSON.stringify({ ok: false, error: 'Internal Server Error' }),
+                            statusCode: 500,
+                            contentType: 'application/json'
+                        });
+                        generatedResult = true;
+                    }
+                }
+                if (!generatedResult) {
+                    /**
+                     * Otherwise provide a generic error page
+                     */
+                    response.statusCode = 500;
+                    response.setHeader('Content-Type', 'text/plain');
+                    response.write('Internal Server Error');
+                    response.end();
+                    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);
+            response.end();
+        });
+        this.#server = server;
+        /**
+         * Create a promise to wait for the server to close
+         */
+        const waiter = new Promise((resolve) => {
+            server.on('close', () => {
+                this.logger?.debug('KeetaAnchorFX.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('KeetaAnchorFX.Server', 'Listening on port:', this.port);
+        });
+        /**
+         * Wait for the server to close
+         */
+        await waiter;
+    }
+    async start() {
+        await new Promise((resolve) => {
+            this.#serverPromise = this.main(function () {
+                resolve();
+            });
+        });
+    }
+    async wait() {
+        await this.#serverPromise;
+    }
+    async stop() {
+        this.#server?.close();
+        await this.wait();
+    }
+    get url() {
+        if (this.port === 0 || this.#server === undefined) {
+            throw (new Error('Server not started'));
+        }
+        return (`http://localhost:${this.port}`);
+    }
+    [Symbol.asyncDispose]() {
+        return (this.stop());
+    }
+}
+//# sourceMappingURL=server.js.map