@keetanetwork/anchor 0.0.33 → 0.0.35

package/services/fx/server.js

@@ -1,8 +1,24 @@
+import * as __typia_transform__assertGuard from "typia/lib/internal/_assertGuard.js";
 import * as KeetaAnchorHTTPServer from '../../lib/http-server/index.js';
 import { KeetaNet } from '../../client/index.js';
 import { KeetaAnchorUserError } from '../../lib/error.js';
 import { assertConversionInputCanonicalJSON, assertConversionQuoteJSON, Errors } from './common.js';
 import * as Signing from '../../lib/utils/signing.js';
+import { KeetaAnchorQueueRunner, KeetaAnchorQueueStorageDriverMemory } from '../../lib/queue/index.js';
+import { KeetaAnchorQueuePipelineAdvanced } from '../../lib/queue/pipeline.js';
+import { assertNever } from '../../lib/utils/never.js';
+import * as typia from 'typia';
+/**
+ * Enable additional runtime "paranoid" checks in the FX server.
+ *
+ * This may have a small performance impact but increases safety
+ * by ensuring that the accounts used in quotes are actually
+ * configured in the server.
+ *
+ * During the transition to multiple accounts this may help catch
+ * misconfigurations so it is enabled by default for now.
+ */
+const PARANOID = true;
 ;
 async function formatQuoteSignable(unsignedQuote) {
     const retval = [
@@ -30,40 +46,421 @@ async function verifySignedData(signedBy, 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 account;
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    if (config.account !== undefined) {
+        const rateFee = await config.fx.getConversionRateAndFee(request);
+        account = rateFee.account;
+    }
+    else {
+        account = null;
+    }
     let signer = null;
     if (config.signer !== undefined) {
         signer = (KeetaNet.lib.Account.isInstance(config.signer) ? config.signer : await config.signer(request)).assertAccount();
     }
-    if (signer === null) {
-        signer = account.assertAccount();
+    if (account !== null) {
+        if (signer === null) {
+            signer = account.assertAccount();
+        }
+        if (!account.isAccount() && !account.isStorage()) {
+            throw (new Error('FX Account should be an Account or Storage Account'));
+        }
     }
-    if (!account.isAccount() && !account.isStorage()) {
-        throw (new Error('FX Account should be an Account or Storage Account'));
+    else if (signer === null) {
+        throw (new Error('Either account or signer must be provided'));
     }
     return ({
-        signer: signer,
-        account: account
+        account: account,
+        signer: signer
     });
 }
+class KeetaFXAnchorQueuePipelineStage1 extends KeetaAnchorQueueRunner {
+    serverConfig;
+    sequential = true;
+    /**
+     * Timeout for processing a single job -- if exceeded the job is marked as aborted
+     */
+    processTimeout = 60 * 1000;
+    constructor(config) {
+        super(config);
+        this.serverConfig = config.serverConfig;
+        this.processorAborted = this.processorStuck.bind(this);
+    }
+    /**
+     * Handles both stuck (no status update after a long period) and
+     * aborted (timeout while processing an entry) states.
+     *
+     * We just put the job back into pending because the processor
+     * will check the network state again.
+     */
+    async processorStuck(entry) {
+        return ({
+            status: 'pending',
+            output: entry.output
+        });
+    }
+    /**
+     * Process the entry, attempting to submit the swap block(s)
+     * to the network.  Verifies the block can be submitted before
+     * attempting submission.  Also verifies if the block is already
+     * on the network and marks the job as completed if so.
+     */
+    async processor(entry) {
+        const { block, expected, request } = entry.request;
+        const expectedToken = expected.token;
+        const expectedAmount = expected.amount;
+        const config = this.serverConfig;
+        let userClient;
+        if (KeetaNet.UserClient.isInstance(config.client)) {
+            userClient = config.client;
+        }
+        else {
+            const { signer, account: checkAccount } = await requestToAccounts(config, request);
+            if (checkAccount === null) {
+                if (this.serverConfig.accounts === undefined) {
+                    throw (new Error('No accounts configured for FX server'));
+                }
+                if (!this.serverConfig.accounts.has(entry.request.account)) {
+                    return ({
+                        status: 'failed_permanently',
+                        output: null,
+                        error: `Mismatched account for FX request and configured account (no matching account found)`
+                    });
+                }
+            }
+            else if (!checkAccount.comparePublicKey(entry.request.account)) {
+                return ({
+                    status: 'failed_permanently',
+                    output: null,
+                    error: `Mismatched account for FX request and configured account (single account not matched)`
+                });
+            }
+            userClient = new KeetaNet.UserClient({
+                client: config.client.client,
+                network: config.client.network,
+                networkAlias: config.client.networkAlias,
+                account: entry.request.account,
+                signer: signer
+            });
+        }
+        /* Check for the block already being on the network, if so we can mark this job as completed */
+        const blockExists = await userClient.block(block.hash);
+        if (blockExists !== null) {
+            const existingOutput = entry.output;
+            const blocks = existingOutput?.blocks ?? [Buffer.from(block.toBytes()).toString('base64')];
+            return ({
+                status: 'completed',
+                output: {
+                    blockhash: block.hash.toString(),
+                    blocks: blocks
+                }
+            });
+        }
+        /* Get the current head block of the account in the block */
+        const accountHead = await userClient.head({ account: block.account });
+        let isHeadBlock = false;
+        if (accountHead !== null) {
+            isHeadBlock = accountHead.compare(block.previous);
+        }
+        else {
+            isHeadBlock = block['$opening'];
+        }
+        /* If the account's head block is not the block's previous, see if the block's previous exists on the network */
+        if (!isHeadBlock) {
+            let previousBlockOnNetwork = false;
+            if (block['$opening']) {
+                /* Opening block means that there is no previous block, so we are free to proceed */
+                previousBlockOnNetwork = true;
+            }
+            else {
+                const previousBlock = await userClient.block(block.previous);
+                if (previousBlock !== null) {
+                    previousBlockOnNetwork = true;
+                }
+            }
+            let blockPreviousString;
+            if (block['$opening']) {
+                blockPreviousString = '<opening>';
+            }
+            else {
+                blockPreviousString = block.previous.toString();
+            }
+            /* If block.previous exists on the network, and it's not the account head block we can mark this job as failed_permanently */
+            if (previousBlockOnNetwork) {
+                /* Block's previous exists on the network, but is not the account head -- mark as failed_permanently */
+                return ({
+                    status: 'failed_permanently',
+                    output: null,
+                    error: `Block previous (${blockPreviousString}) exists on the network but is not the account head`
+                });
+            }
+            else {
+                /* If block.previous does not exist on the network we can mark this job as failed_temporarily -- it can't process until the missing block is added */
+                /* Block's previous does not exist on the network -- mark as failed_temporarily */
+                return ({
+                    status: 'failed_temporarily',
+                    output: null,
+                    error: `Block previous (${blockPreviousString}) does not exist on the network`
+                });
+            }
+        }
+        /* We are clear to attempt the swap now */
+        const swapBlocks = await userClient.acceptSwapRequest({ block, expected: { token: expectedToken, amount: BigInt(expectedAmount) } });
+        const publishOptions = {};
+        if (userClient.config.generateFeeBlock !== undefined) {
+            publishOptions.generateFeeBlock = userClient.config.generateFeeBlock;
+        }
+        const publishResult = await userClient.client.transmit(swapBlocks, publishOptions);
+        if (!publishResult.publish) {
+            throw (new Error('Exchange Publish Failed'));
+        }
+        /* Set the output and mark the job as pending so we can run the queue again and check for completion */
+        return ({
+            status: 'pending',
+            output: {
+                blockhash: block.hash.toString(),
+                blocks: swapBlocks.map(function (block) {
+                    return (Buffer.from(block.toBytes()).toString('base64'));
+                })
+            }
+        });
+    }
+    encodeRequest(request) {
+        const retval = {
+            version: 1,
+            account: request.account.publicKeyString.get(),
+            block: Buffer.from(request.block.toBytes()).toString('base64'),
+            request: request.request,
+            expected: {
+                token: request.expected.token.publicKeyString.get(),
+                amount: request.expected.amount.toString()
+            }
+        };
+        return (retval);
+    }
+    encodeResponse(response) {
+        return (response);
+    }
+    decodeRequest(request) {
+        /* See note at bottom of file */
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        const reqJSON = assertKeetaFXAnchorQueueStage1RequestJSON(request);
+        if (reqJSON.version !== 1) {
+            throw (new Error(`Unsupported KeetaFXAnchorQueueStage1Request version ${reqJSON.version}`));
+        }
+        const retval = {
+            account: KeetaNet.lib.Account.fromPublicKeyString(reqJSON.account),
+            block: new KeetaNet.lib.Block(reqJSON.block),
+            request: reqJSON.request,
+            expected: {
+                token: KeetaNet.lib.Account.fromPublicKeyString(reqJSON.expected.token).assertKeyType(KeetaNet.lib.Account.AccountKeyAlgorithm.TOKEN),
+                amount: BigInt(reqJSON.expected.amount)
+            }
+        };
+        return (retval);
+    }
+    decodeResponse(response) {
+        /* See note at bottom of file */
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return (assertKeetaFXAnchorQueueStage1ResponseOrNull(response));
+    }
+}
+class KeetaFXAnchorQueuePipeline extends KeetaAnchorQueuePipelineAdvanced {
+    serverConfig;
+    accounts;
+    runners = {};
+    constructor(options) {
+        super(options);
+        this.serverConfig = options.serverConfig;
+        this.accounts = options.accounts;
+    }
+    async createPipeline() {
+        for (const account of this.accounts) {
+            const queue = await this.baseQueue.partition(account.publicKeyAndTypeString);
+            this.queues.push(queue);
+            const runner = new KeetaFXAnchorQueuePipelineStage1({
+                id: `keeta-fx-anchor-runner-${account.publicKeyAndTypeString}`,
+                queue: queue,
+                logger: this.logger,
+                serverConfig: this.serverConfig
+            });
+            this.runners[account.publicKeyAndTypeString] = runner;
+        }
+    }
+    getStage(_ignore_stageID) {
+        throw (new Error('method not supported'));
+    }
+    async add(request) {
+        await super.init();
+        const account = request.account.publicKeyAndTypeString;
+        const runner = this.runners[account];
+        if (runner === undefined) {
+            throw (new Error(`No queue runner for account ${account}`));
+        }
+        return (await runner.add(request));
+    }
+    async get(id) {
+        await super.init();
+        for (const account of this.accounts) {
+            const runner = this.runners[account.publicKeyAndTypeString];
+            if (runner === undefined) {
+                continue;
+            }
+            const entry = await runner.get(id);
+            if (entry !== null) {
+                return (entry);
+            }
+        }
+        return (null);
+    }
+    async run(options) {
+        await super.init();
+        let retval = false;
+        for (const account of this.accounts) {
+            const runner = this.runners[account.publicKeyAndTypeString];
+            if (runner === undefined) {
+                continue;
+            }
+            const more = await runner.run(options);
+            if (more) {
+                retval = true;
+            }
+        }
+        return (retval);
+    }
+    async maintain() {
+        await super.init();
+        for (const account of this.accounts) {
+            const runner = this.runners[account.publicKeyAndTypeString];
+            if (runner === undefined) {
+                continue;
+            }
+            await runner.maintain();
+        }
+    }
+    async destroy() {
+        const logger = this.methodLogger('destroy');
+        if (this.destroyed) {
+            return;
+        }
+        this.destroyed = true;
+        await super.destroy();
+        for (const runner of Object.values(this.runners)) {
+            try {
+                await runner.destroy();
+            }
+            catch (error) {
+                logger?.error('Error destroying runner:', error);
+            }
+        }
+    }
+}
 export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAnchorHTTPServer {
     homepage;
     client;
-    account;
+    accounts;
+    account = undefined;
     signer;
     quoteSigner;
     fx;
+    pipeline;
+    pipelineAutoRunInterval = null;
     constructor(config) {
         super(config);
         this.homepage = config.homepage ?? '';
         this.client = config.client;
         this.fx = config.fx;
-        this.account = config.account;
-        this.signer = config.signer ?? config.account;
         this.quoteSigner = config.quoteSigner;
+        /*
+         * Setup the accounts
+         */
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
+        if (config.account !== undefined && config.accounts === undefined) {
+            /*
+             * Deprecated: If a single account is provided, use that
+             * along with the signer to create the accounts set
+             */
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            this.accounts = new KeetaNet.lib.Account.Set([config.account]);
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            this.signer = config.signer ?? config.account;
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+        }
+        else if (config.accounts !== undefined && config.account === undefined) {
+            /*
+             * Only allow either "account" or "accounts"+"signer" to be provided
+             */
+            if (config.signer === undefined) {
+                throw (new Error('If "accounts" is provided, "signer" must also be provided'));
+            }
+            this.accounts = config.accounts;
+            this.signer = config.signer;
+        }
+        else {
+            throw (new Error('Either "account" (and optional "signer") or "accounts" and "signer" must be provided, but not both "account" and "accounts"'));
+        }
+        if (this.accounts.size === 0) {
+            throw (new Error('No FX accounts provided'));
+        }
+        /*
+         * If no storage driver is provided, we default to an in-memory
+         * that we auto-run
+         */
+        let autorun = config.storage?.autoRun ?? false;
+        if (config.storage === undefined) {
+            autorun = true;
+        }
+        /*
+         * Create the pipeline to process transactions
+         */
+        this.pipeline = new KeetaFXAnchorQueuePipeline({
+            id: 'keeta-fx-anchor-queue-pipeline',
+            baseQueue: config.storage?.queue ?? new KeetaAnchorQueueStorageDriverMemory({
+                id: 'keeta-fx-anchor-queue-pipeline-memory-driver',
+                logger: this.logger
+            }),
+            accounts: this.accounts,
+            logger: this.logger,
+            serverConfig: this
+        });
+        /*
+         * If auto-run is enabled, setup the interval to run the pipeline
+         */
+        if (autorun) {
+            let running = false;
+            this.pipelineAutoRunInterval = setInterval(async () => {
+                if (running) {
+                    return;
+                }
+                running = true;
+                try {
+                    await this.pipeline.maintain();
+                }
+                catch (error) {
+                    this.logger.error('KeetaNetFXAnchorHTTPServer::pipelineAutoRunInterval', 'Error maintaining pipeline:', error);
+                }
+                try {
+                    await this.pipeline.run({ timeoutMs: 5000 });
+                }
+                catch (error) {
+                    this.logger.error('KeetaNetFXAnchorHTTPServer::pipelineAutoRunInterval', 'Error running pipeline:', error);
+                }
+                finally {
+                    running = false;
+                }
+            }, 1000);
+        }
     }
     async initRoutes(config) {
         const routes = {};
+        const logger = this.logger;
+        /*
+         * To use the instance within the route handlers, we need to
+         * make a local reference to it.
+         */
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const instance = this;
         /**
          * If a homepage is provided, setup the route for it
          */
@@ -122,6 +519,12 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
             }
             const conversion = assertConversionInputCanonicalJSON(postData.request);
             const rateAndFee = await config.fx.getConversionRateAndFee(conversion);
+            if (PARANOID) {
+                const quoteAccount = rateAndFee.account;
+                if (!instance.accounts.has(quoteAccount)) {
+                    throw (new Error('"getConversionRateAndFee" returned an account not configured for this server'));
+                }
+            }
             const unsignedQuote = KeetaNet.lib.Utils.Conversion.toJSONSerializable({
                 request: conversion,
                 ...rateAndFee
@@ -165,20 +568,6 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
                 }
             }
             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
-                });
-            }
             /* Get Expected Amount and Token to Verify Swap */
             const expectedToken = KeetaNet.lib.Account.fromPublicKeyString(quote.request.from);
             let expectedAmount = quote.request.affinity === 'from' ? BigInt(quote.request.amount) : BigInt(quote.convertedAmount);
@@ -206,19 +595,20 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
                     }
                 }
             }
-            /* Verify Request and Generate the Accept Swap Block */
-            const swapBlocks = await userClient.acceptSwapRequest({ block, expected: { token: expectedToken, amount: BigInt(expectedAmount) } });
-            const publishOptions = {};
-            if (userClient.config.generateFeeBlock !== undefined) {
-                publishOptions.generateFeeBlock = userClient.config.generateFeeBlock;
-            }
-            const publishResult = await userClient.client.transmit(swapBlocks, publishOptions);
-            if (!publishResult.publish) {
-                throw (new Error('Exchange Publish Failed'));
-            }
+            /* Enqueue the exchange request */
+            const exchangeID = await instance.pipeline.add({
+                account: KeetaNet.lib.Account.fromPublicKeyString(quote.account),
+                block: block,
+                request: quote.request,
+                expected: {
+                    token: expectedToken,
+                    amount: BigInt(expectedAmount)
+                }
+            });
             const exchangeResponse = {
                 ok: true,
-                exchangeID: block.hash.toString()
+                exchangeID: exchangeID.toString(),
+                status: 'pending'
             };
             return ({
                 output: JSON.stringify(exchangeResponse)
@@ -232,14 +622,57 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
             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
-            };
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            const queueEntryInfo = await instance.pipeline.get(exchangeID);
+            const exchangeResponse = (function () {
+                const inputStatus = queueEntryInfo?.status;
+                switch (inputStatus) {
+                    case undefined:
+                        throw (new KeetaAnchorUserError('Exchange ID not found'));
+                    case 'pending':
+                    case 'processing':
+                    case 'stuck':
+                    case 'aborted':
+                    case 'failed_temporarily':
+                        return ({
+                            ok: true,
+                            status: 'pending',
+                            exchangeID: exchangeID
+                        });
+                    case 'completed': {
+                        const blockhash = queueEntryInfo?.output?.blockhash;
+                        if (blockhash === undefined) {
+                            return ({
+                                ok: true,
+                                status: 'pending',
+                                exchangeID: exchangeID
+                            });
+                        }
+                        else {
+                            return ({
+                                ok: true,
+                                status: 'completed',
+                                exchangeID: exchangeID,
+                                blockhash: blockhash
+                            });
+                        }
+                    }
+                    case 'failed_permanently':
+                        return ({
+                            ok: false,
+                            exchangeID: exchangeID,
+                            status: 'failed',
+                            error: 'Exchange failed'
+                        });
+                    case 'moved':
+                        throw (new Error('Exchange ID has been moved'));
+                    case '@internal':
+                        throw (new Error('Invalid exchange status @internal'));
+                    default:
+                        assertNever(inputStatus);
+                }
+            })();
+            logger.debug('GET /api/getExchangeStatus/:id', 'Exchange Status for ID', exchangeID, 'is', exchangeResponse, 'based on jobInfo', queueEntryInfo);
             return ({
                 output: JSON.stringify(exchangeResponse)
             });
@@ -261,5 +694,138 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
             operations: operations
         });
     }
+    async stop() {
+        if (this.pipelineAutoRunInterval !== null) {
+            clearInterval(this.pipelineAutoRunInterval);
+            this.pipelineAutoRunInterval = null;
+        }
+        await this.pipeline.destroy();
+        await super.stop();
+    }
 }
+/*
+ * These are placed at the bottom of the file because the generation
+ * breaks the code coverage computation;  Normally, we'd place these
+ * in a ".generated.ts" file but for simplicity of internal types
+ * we keep them here.
+ */
+const assertKeetaFXAnchorQueueStage1RequestJSON = (() => { const _io0 = input => 1 === input.version && "string" === typeof input.account && "string" === typeof input.block && ("object" === typeof input.request && null !== input.request && _io1(input.request)) && ("object" === typeof input.expected && null !== input.expected && _io2(input.expected)); 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.token && "string" === typeof input.amount; const _ao0 = (input, _path, _exceptionable = true) => (1 === input.version || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".version",
+    expected: "1",
+    value: input.version
+}, _errorFactory)) && ("string" === typeof input.account || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".account",
+    expected: "string",
+    value: input.account
+}, _errorFactory)) && ("string" === typeof input.block || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".block",
+    expected: "string",
+    value: input.block
+}, _errorFactory)) && (("object" === typeof input.request && null !== input.request || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".request",
+    expected: "__type",
+    value: input.request
+}, _errorFactory)) && _ao1(input.request, _path + ".request", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".request",
+    expected: "__type",
+    value: input.request
+}, _errorFactory)) && (("object" === typeof input.expected && null !== input.expected || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".expected",
+    expected: "__type.o1",
+    value: input.expected
+}, _errorFactory)) && _ao2(input.expected, _path + ".expected", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".expected",
+    expected: "__type.o1",
+    value: input.expected
+}, _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: "typia.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: "typia.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: "typia.createAssert",
+    path: _path + ".amount",
+    expected: "string",
+    value: input.amount
+}, _errorFactory)) && ("from" === input.affinity || "to" === input.affinity || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".affinity",
+    expected: "(\"from\" | \"to\")",
+    value: input.affinity
+}, _errorFactory)); const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.token || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".token",
+    expected: "string",
+    value: input.token
+}, _errorFactory)) && ("string" === typeof input.amount || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".amount",
+    expected: "string",
+    value: input.amount
+}, _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: "typia.createAssert",
+            path: _path + "",
+            expected: "KeetaFXAnchorQueueStage1RequestJSON",
+            value: input
+        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "typia.createAssert",
+            path: _path + "",
+            expected: "KeetaFXAnchorQueueStage1RequestJSON",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+const assertKeetaFXAnchorQueueStage1ResponseOrNull = (() => { const _io0 = input => Array.isArray(input.blocks) && input.blocks.every(elem => "string" === typeof elem) && "string" === typeof input.blockhash; const _ao0 = (input, _path, _exceptionable = true) => ((Array.isArray(input.blocks) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".blocks",
+    expected: "Array<string>",
+    value: input.blocks
+}, _errorFactory)) && input.blocks.every((elem, _index2) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".blocks[" + _index2 + "]",
+    expected: "string",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".blocks",
+    expected: "Array<string>",
+    value: input.blocks
+}, _errorFactory)) && ("string" === typeof input.blockhash || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".blockhash",
+    expected: "string",
+    value: input.blockhash
+}, _errorFactory)); const __is = input => null === input || "object" === typeof input && null !== input && _io0(input); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => null === input || ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "typia.createAssert",
+            path: _path + "",
+            expected: "(KeetaFXAnchorQueueStage1Response | null)",
+            value: input
+        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "typia.createAssert",
+            path: _path + "",
+            expected: "(KeetaFXAnchorQueueStage1Response | null)",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
 //# sourceMappingURL=server.js.map