@keetanetwork/anchor 0.0.38 → 0.0.39

package/services/fx/server.js

@@ -1,3 +1,4 @@
+import { __addDisposableResource, __disposeResources } from "tslib";
 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';
@@ -8,7 +9,9 @@ import { KeetaAnchorQueueRunner, KeetaAnchorQueueStorageDriverMemory } from '../
 import { KeetaAnchorQueuePipelineAdvanced } from '../../lib/queue/pipeline.js';
 import { assertNever } from '../../lib/utils/never.js';
 import * as typia from 'typia';
-import { assertExchangeBlockParameters } from './util.js';
+import { assertExchangeBlockParametersAndComputeRefund, convertQuoteToExpectedSwapWithoutCost } from './util.js';
+import { AsyncDisposableStack } from '../../lib/utils/defer.js';
+import { asleep } from '../../lib/utils/asleep.js';
 /**
  * Enable additional runtime "paranoid" checks in the FX server.
  *
@@ -50,7 +53,7 @@ async function requestToAccounts(config, request) {
     let account;
     // eslint-disable-next-line @typescript-eslint/no-deprecated
     if (config.account !== undefined) {
-        const rateFee = await config.fx.getConversionRateAndFee(request);
+        const rateFee = await config.fx.getConversionRateAndFee(request, { purpose: 'estimate' });
         account = rateFee.account;
     }
     else {
@@ -133,7 +136,7 @@ class KeetaFXAnchorQueuePipelineStage1 extends KeetaAnchorQueueRunner {
      * on the network and marks the job as completed if so.
      */
     async processor(entry) {
-        const { block, expected, request } = entry.request;
+        const { block, request } = entry.request;
         const config = this.serverConfig;
         let userClient;
         if (KeetaNet.UserClient.isInstance(config.client)) {
@@ -238,6 +241,27 @@ class KeetaFXAnchorQueuePipelineStage1 extends KeetaAnchorQueueRunner {
         }
         /* We are clear to attempt the swap now */
         const builder = userClient.initBuilder();
+        let expected = entry.request.expected;
+        /**
+         * We only want to refund excess for cost/paying token if it is not a fixed rate
+         * as if it is a fixed rate transfer, you can assume the client did not send unintentionally
+         *
+         * Additionally, other FX anchors are not forced to refund any, so there is no guarantee to client that refunds will occur
+         */
+        if (expected === null) {
+            const quote = await this.serverConfig.fx.getConversionRateAndFee(request, { purpose: 'exchange', request: entry.request });
+            const { refunds } = assertExchangeBlockParametersAndComputeRefund({
+                block: block,
+                liquidityAccount: entry.request.account,
+                allowedLiquidityAccounts: null,
+                checks: { quote, request },
+                isQuoteBasedExchange: false
+            });
+            for (const refund of refunds) {
+                builder.send(block.account, refund.amount, refund.token);
+            }
+            expected = convertQuoteToExpectedSwapWithoutCost({ quote, request });
+        }
         builder.send(block.account, expected.send.amount, expected.send.token);
         const sendBlock = await builder.computeBlocks();
         const swapBlocks = [...sendBlock.blocks, block];
@@ -245,9 +269,26 @@ class KeetaFXAnchorQueuePipelineStage1 extends KeetaAnchorQueueRunner {
         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'));
+        try {
+            const publishResult = await userClient.client.transmit(swapBlocks, publishOptions);
+            if (!publishResult.publish) {
+                throw (new Error('Exchange Publish Failed'));
+            }
+        }
+        catch (error) {
+            if (KeetaNet.lib.Error.isInstance(error) &&
+                'shouldRetry' in error &&
+                // Disable this warning as there is nothing stopping this from not being a boolean
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-boolean-literal-compare
+                error.shouldRetry === false) {
+                this.serverConfig.logger?.warn('KeetaFXAnchorQueuePipelineStage1::processor', 'Non-retryable error publishing swap blocks:', error);
+                return ({
+                    status: 'failed_permanently',
+                    output: null,
+                    error: `${error.code} ${error.message}`
+                });
+            }
+            throw (error);
         }
         /* Set the output and mark the job as pending so we can run the queue again and check for completion */
         return ({
@@ -261,12 +302,12 @@ class KeetaFXAnchorQueuePipelineStage1 extends KeetaAnchorQueueRunner {
         });
     }
     encodeRequest(request) {
-        const retval = {
-            version: 1,
-            account: request.account.publicKeyString.get(),
-            block: Buffer.from(request.block.toBytes()).toString('base64'),
-            request: request.request,
-            expected: {
+        let expected;
+        if (request.expected === null) {
+            expected = null;
+        }
+        else {
+            expected = {
                 receive: {
                     token: request.expected.receive.token.publicKeyString.get(),
                     amount: request.expected.receive.amount.toString()
@@ -275,7 +316,15 @@ class KeetaFXAnchorQueuePipelineStage1 extends KeetaAnchorQueueRunner {
                     token: request.expected.send.token.publicKeyString.get(),
                     amount: request.expected.send.amount.toString()
                 }
-            }
+            };
+        }
+        ;
+        const retval = {
+            version: 1,
+            account: request.account.publicKeyString.get(),
+            block: Buffer.from(request.block.toBytes()).toString('base64'),
+            request: request.request,
+            expected: expected
         };
         return (retval);
     }
@@ -289,11 +338,12 @@ class KeetaFXAnchorQueuePipelineStage1 extends KeetaAnchorQueueRunner {
         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: {
+        let expected;
+        if (reqJSON.expected === null) {
+            expected = null;
+        }
+        else {
+            expected = {
                 receive: {
                     token: KeetaNet.lib.Account.fromPublicKeyString(reqJSON.expected.receive.token).assertKeyType(KeetaNet.lib.Account.AccountKeyAlgorithm.TOKEN),
                     amount: BigInt(reqJSON.expected.receive.amount)
@@ -302,7 +352,13 @@ class KeetaFXAnchorQueuePipelineStage1 extends KeetaAnchorQueueRunner {
                     token: KeetaNet.lib.Account.fromPublicKeyString(reqJSON.expected.send.token).assertKeyType(KeetaNet.lib.Account.AccountKeyAlgorithm.TOKEN),
                     amount: BigInt(reqJSON.expected.send.amount)
                 }
-            }
+            };
+        }
+        const retval = {
+            account: KeetaNet.lib.Account.fromPublicKeyString(reqJSON.account),
+            block: new KeetaNet.lib.Block(reqJSON.block),
+            request: reqJSON.request,
+            expected: expected
         };
         return (retval);
     }
@@ -412,7 +468,8 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
     fx;
     pipeline;
     quoteConfiguration;
-    pipelineAutoRunInterval = null;
+    autoRun;
+    autoRunRunning = false;
     constructor(config) {
         super(config);
         this.homepage = config.homepage ?? '';
@@ -455,9 +512,9 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
          * If no storage driver is provided, we default to an in-memory
          * that we auto-run
          */
-        let autorun = config.storage?.autoRun ?? false;
+        this.autoRun = config.storage?.autoRun ?? false;
         if (config.storage === undefined) {
-            autorun = true;
+            this.autoRun = true;
         }
         /*
          * Create the pipeline to process transactions
@@ -472,33 +529,6 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
             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 = {};
@@ -530,6 +560,16 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
                 });
             };
         }
+        async function getUnsignedQuoteData(conversion, purpose) {
+            const rateAndFee = await config.fx.getConversionRateAndFee(conversion, { purpose });
+            if (PARANOID) {
+                const quoteAccount = rateAndFee.account;
+                if (!instance.accounts.has(quoteAccount)) {
+                    throw (new Error('"getConversionRateAndFee" returned an account not configured for this server'));
+                }
+            }
+            return (rateAndFee);
+        }
         /**
          * Setup the request handler for an estimate request
          */
@@ -541,7 +581,7 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
                 throw (new Error('POST data missing request'));
             }
             const conversion = assertConversionInputCanonicalJSON(postData.request);
-            const rateAndFee = await config.fx.getConversionRateAndFee(conversion);
+            const rateAndFee = await getUnsignedQuoteData(conversion, 'estimate');
             let requiresQuoteBody;
             if (instance.quoteConfiguration.requiresQuote) {
                 requiresQuoteBody = { requiresQuote: true };
@@ -578,16 +618,6 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
                 output: JSON.stringify(estimateResponse)
             });
         };
-        async function getUnsignedQuoteData(conversion) {
-            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'));
-                }
-            }
-            return (rateAndFee);
-        }
         routes['POST /api/getQuote'] = async function (_ignore_params, postData) {
             if (!instance.quoteConfiguration.requiresQuote && !instance.quoteConfiguration.issueQuotes) {
                 throw (new Errors.QuoteIssuanceDisabled());
@@ -599,7 +629,7 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
                 throw (new Error('POST data missing request'));
             }
             const conversion = assertConversionInputCanonicalJSON(postData.request);
-            const rateAndFee = await getUnsignedQuoteData(conversion);
+            const rateAndFee = await getUnsignedQuoteData(conversion, 'quote');
             const unsignedQuote = KeetaNet.lib.Utils.Conversion.toJSONSerializable({
                 request: conversion,
                 ...rateAndFee
@@ -632,10 +662,13 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
             let conversionInput;
             let shouldValidateQuote;
             let liquidityAccount;
+            let expectedConversion;
+            let isQuoteBasedExchange;
             if ('quote' in request && 'estimate' in request && request.quote && request.estimate) {
                 throw (new Error('Request cannot contain both quote and estimate'));
             }
             else if ('quote' in request && request.quote) {
+                isQuoteBasedExchange = true;
                 shouldValidateQuote = true;
                 quoteInput = request.quote;
                 conversionInput = quoteInput.request;
@@ -649,13 +682,18 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
                     throw (new Errors.QuoteValidationFailed());
                 }
                 liquidityAccount = quoteInput.account;
+                expectedConversion = convertQuoteToExpectedSwapWithoutCost({
+                    quote: toValidateQuoteInput(quoteInput),
+                    request: conversionInput
+                });
             }
             else if ('request' in request && request.request) {
+                isQuoteBasedExchange = false;
                 if (instance.quoteConfiguration.requiresQuote) {
                     throw (new Errors.QuoteRequired());
                 }
                 conversionInput = request.request;
-                quoteInput = await getUnsignedQuoteData(conversionInput);
+                quoteInput = await getUnsignedQuoteData(conversionInput, 'estimate');
                 if (instance.quoteConfiguration.validateQuoteBeforeExchange !== undefined) {
                     shouldValidateQuote = instance.quoteConfiguration.validateQuoteBeforeExchange;
                 }
@@ -676,6 +714,8 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
                 if (!liquidityAccount) {
                     throw (new KeetaAnchorUserError('Could not determine liquidity account from exchange block'));
                 }
+                // No expected conversion provided when using estimate, we determine the rate when processing the exchange
+                expectedConversion = null;
             }
             else {
                 throw (new Error('Either quote or request must be provided (but not both) in exchange request'));
@@ -688,26 +728,7 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
                     throw (new Errors.QuoteValidationFailed());
                 }
             }
-            let expectedSendAmount;
-            let expectedReceiveAmount;
-            if (conversionInput.affinity === 'to') {
-                expectedSendAmount = BigInt(conversionInput.amount);
-                expectedReceiveAmount = parsedQuote.convertedAmount;
-            }
-            else {
-                expectedSendAmount = parsedQuote.convertedAmount;
-                expectedReceiveAmount = BigInt(conversionInput.amount);
-            }
             const liquidityAccountInstance = KeetaNet.lib.Account.toAccount(liquidityAccount);
-            const userSendsMinimum = { [conversionInput.from]: expectedReceiveAmount };
-            const userWillReceiveMaximum = { [conversionInput.to]: expectedSendAmount };
-            if (parsedQuote.cost.amount > 0) {
-                const feeTokenPub = parsedQuote.cost.token.publicKeyString.get();
-                if (!userSendsMinimum[feeTokenPub]) {
-                    userSendsMinimum[feeTokenPub] = 0n;
-                }
-                userSendsMinimum[feeTokenPub] += parsedQuote.cost.amount;
-            }
             let allowedLiquidityAccounts;
             if (config.accounts) {
                 allowedLiquidityAccounts = config.accounts;
@@ -720,34 +741,73 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
             else {
                 throw (new Error('config.account or config.accounts must be provided'));
             }
-            assertExchangeBlockParameters({
+            assertExchangeBlockParametersAndComputeRefund({
                 block: block,
                 liquidityAccount: liquidityAccountInstance,
                 allowedLiquidityAccounts: allowedLiquidityAccounts,
-                userSendsMinimum: userSendsMinimum,
-                userWillReceiveMaximum: userWillReceiveMaximum
+                checks: { quote: parsedQuote, request: conversionInput },
+                isQuoteBasedExchange: isQuoteBasedExchange
             });
             /* Enqueue the exchange request */
             const exchangeID = await instance.pipeline.add({
                 account: liquidityAccountInstance,
                 block: block,
                 request: conversionInput,
-                expected: {
-                    receive: {
-                        token: KeetaNet.lib.Account.fromPublicKeyString(conversionInput.from),
-                        amount: expectedReceiveAmount
-                    },
-                    send: {
-                        token: KeetaNet.lib.Account.fromPublicKeyString(conversionInput.to),
-                        amount: expectedSendAmount
-                    }
-                }
+                expected: expectedConversion
             });
             const exchangeResponse = {
                 ok: true,
                 exchangeID: exchangeID.toString(),
                 status: 'pending'
             };
+            if (instance.autoRun && !instance.autoRunRunning) {
+                const env_1 = { stack: [], error: void 0, hasError: false };
+                try {
+                    /*
+                     * Keep track of how many times, consecutively, the queue was empty when we
+                     * went to run it
+                     */
+                    let noMoreJobsCount = 0;
+                    /*
+                     * Create a mutex around the queue running so we don't have
+                     * lock contention for the worker ID if multiple requests
+                     * are being served by the same instance
+                     */
+                    instance.autoRunRunning = true;
+                    const cleanup = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
+                    cleanup.defer(async function () {
+                        instance.autoRunRunning = false;
+                    });
+                    /*
+                     * For up to 15s process the queue, stopping only when
+                     * we've had 2 consecutive runs that indicate there is
+                     * no more in the queue to process
+                     */
+                    for (const startTime = Date.now(); Date.now() - startTime < 15000;) {
+                        const more = await instance.pipeline.run({ timeoutMs: 1500 });
+                        if (!more) {
+                            noMoreJobsCount++;
+                            if (noMoreJobsCount >= 2) {
+                                break;
+                            }
+                        }
+                        else {
+                            noMoreJobsCount = 0;
+                        }
+                        await instance.pipeline.maintain();
+                        await asleep(100);
+                    }
+                }
+                catch (e_1) {
+                    env_1.error = e_1;
+                    env_1.hasError = true;
+                }
+                finally {
+                    const result_1 = __disposeResources(env_1);
+                    if (result_1)
+                        await result_1;
+                }
+            }
             return ({
                 output: JSON.stringify(exchangeResponse)
             });
@@ -833,10 +893,6 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
         });
     }
     async stop() {
-        if (this.pipelineAutoRunInterval !== null) {
-            clearInterval(this.pipelineAutoRunInterval);
-            this.pipelineAutoRunInterval = null;
-        }
         await this.pipeline.destroy();
         await super.stop();
     }
@@ -847,7 +903,7 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
  * 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 => "object" === typeof input.receive && null !== input.receive && _io3(input.receive) && ("object" === typeof input.send && null !== input.send && _io4(input.send)); const _io3 = input => "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)) && "string" === typeof input.amount; const _io4 = input => "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)) && "string" === typeof input.amount; const _ao0 = (input, _path, _exceptionable = true) => (1 === input.version || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+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)) && (null === input.expected || "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 => "object" === typeof input.receive && null !== input.receive && _io3(input.receive) && ("object" === typeof input.send && null !== input.send && _io4(input.send)); const _io3 = input => "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)) && "string" === typeof input.amount; const _io4 = input => "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)) && "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",
@@ -872,15 +928,15 @@ const assertKeetaFXAnchorQueueStage1RequestJSON = (() => { const _io0 = input =>
     path: _path + ".request",
     expected: "__type",
     value: input.request
-}, _errorFactory)) && (("object" === typeof input.expected && null !== input.expected || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+}, _errorFactory)) && (null === input.expected || ("object" === typeof input.expected && null !== input.expected || __typia_transform__assertGuard._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".expected",
-    expected: "__type.o1",
+    expected: "(__type.o1 | null)",
     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",
+    expected: "(__type.o1 | null)",
     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",