@keetanetwork/anchor 0.0.37 → 0.0.39

package/services/fx/server.js

@@ -1,13 +1,17 @@
+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';
-import { KeetaAnchorUserError } from '../../lib/error.js';
-import { assertConversionInputCanonicalJSON, assertConversionQuoteJSON, Errors } from './common.js';
+import { KeetaAnchorError, KeetaAnchorUserError } from '../../lib/error.js';
+import { assertConversionInputCanonicalJSON, assertKeetaFXAnchorClientCreateExchangeRequestJSON, 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';
+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.
  *
@@ -49,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 {
@@ -75,6 +79,31 @@ async function requestToAccounts(config, request) {
         signer: signer
     });
 }
+export function toValidateQuoteInput(input) {
+    const ret = {
+        account: KeetaNet.lib.Account.toAccount(input.account),
+        convertedAmount: BigInt(input.convertedAmount),
+        cost: {
+            amount: BigInt(input.cost.amount),
+            token: KeetaNet.lib.Account.toAccount(input.cost.token)
+        }
+    };
+    if ('convertedAmountBound' in input && input.convertedAmountBound !== undefined) {
+        ret.convertedAmountBound = BigInt(input.convertedAmountBound);
+    }
+    if ('signed' in input && input.signed !== undefined) {
+        ret.signed = input.signed;
+    }
+    if ('request' in input && input.request !== undefined) {
+        ret.request = {
+            from: KeetaNet.lib.Account.toAccount(input.request.from),
+            to: KeetaNet.lib.Account.toAccount(input.request.to),
+            amount: BigInt(input.request.amount),
+            affinity: input.request.affinity
+        };
+    }
+    return (ret);
+}
 class KeetaFXAnchorQueuePipelineStage1 extends KeetaAnchorQueueRunner {
     serverConfig;
     sequential = true;
@@ -107,13 +136,18 @@ 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 expectedToken = expected.token;
-        const expectedAmount = expected.amount;
+        const { block, request } = entry.request;
         const config = this.serverConfig;
         let userClient;
         if (KeetaNet.UserClient.isInstance(config.client)) {
             userClient = config.client;
+            if (!(userClient.account.comparePublicKey(entry.request.account))) {
+                return ({
+                    status: 'failed_permanently',
+                    output: null,
+                    error: `Mismatched account for FX request with configured UserClient account`
+                });
+            }
         }
         else {
             const { signer, account: checkAccount } = await requestToAccounts(config, request);
@@ -206,14 +240,55 @@ class KeetaFXAnchorQueuePipelineStage1 extends KeetaAnchorQueueRunner {
             }
         }
         /* We are clear to attempt the swap now */
-        const swapBlocks = await userClient.acceptSwapRequest({ block, expected: { token: expectedToken, amount: BigInt(expectedAmount) } });
+        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];
         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'));
+        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 ({
@@ -227,15 +302,29 @@ class KeetaFXAnchorQueuePipelineStage1 extends KeetaAnchorQueueRunner {
         });
     }
     encodeRequest(request) {
+        let expected;
+        if (request.expected === null) {
+            expected = null;
+        }
+        else {
+            expected = {
+                receive: {
+                    token: request.expected.receive.token.publicKeyString.get(),
+                    amount: request.expected.receive.amount.toString()
+                },
+                send: {
+                    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: {
-                token: request.expected.token.publicKeyString.get(),
-                amount: request.expected.amount.toString()
-            }
+            expected: expected
         };
         return (retval);
     }
@@ -249,14 +338,27 @@ class KeetaFXAnchorQueuePipelineStage1 extends KeetaAnchorQueueRunner {
         if (reqJSON.version !== 1) {
             throw (new Error(`Unsupported KeetaFXAnchorQueueStage1Request version ${reqJSON.version}`));
         }
+        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)
+                },
+                send: {
+                    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: {
-                token: KeetaNet.lib.Account.fromPublicKeyString(reqJSON.expected.token).assertKeyType(KeetaNet.lib.Account.AccountKeyAlgorithm.TOKEN),
-                amount: BigInt(reqJSON.expected.amount)
-            }
+            expected: expected
         };
         return (retval);
     }
@@ -365,13 +467,16 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
     quoteSigner;
     fx;
     pipeline;
-    pipelineAutoRunInterval = null;
+    quoteConfiguration;
+    autoRun;
+    autoRunRunning = false;
     constructor(config) {
         super(config);
         this.homepage = config.homepage ?? '';
         this.client = config.client;
         this.fx = config.fx;
         this.quoteSigner = config.quoteSigner;
+        this.quoteConfiguration = config.quoteConfiguration ?? { requiresQuote: true };
         /*
          * Setup the accounts
          */
@@ -407,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
@@ -424,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 = {};
@@ -482,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
          */
@@ -493,17 +581,37 @@ 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 };
+            }
+            else {
+                if (rateAndFee.convertedAmountBound === undefined) {
+                    instance.logger.warn('POST /api/getEstimate', 'FX configuration indicates quotes are not required, but "convertedAmountBound" was not provided in the rate and fee response');
+                }
+                else {
+                    if (conversion.affinity === 'to' && (BigInt(conversion.amount) > rateAndFee.convertedAmountBound)) {
+                        throw (new KeetaAnchorError('Affinity is to, but bound is less than estimated sent amount'));
+                    }
+                    if (conversion.affinity === 'from' && (BigInt(conversion.amount) < rateAndFee.convertedAmountBound)) {
+                        throw (new KeetaAnchorError('Affinity is from, but bound is greater than estimated received amount'));
+                    }
+                }
+                requiresQuoteBody = { requiresQuote: false, account: rateAndFee.account };
+            }
             const estimateResponse = {
                 ok: true,
                 estimate: KeetaNet.lib.Utils.Conversion.toJSONSerializable({
                     request: conversion,
                     convertedAmount: rateAndFee.convertedAmount,
+                    convertedAmountBound: rateAndFee.convertedAmountBound,
                     expectedCost: {
                         min: rateAndFee.cost.amount,
                         max: rateAndFee.cost.amount,
                         token: rateAndFee.cost.token
-                    }
+                    },
+                    ...requiresQuoteBody
                 })
             };
             return ({
@@ -511,6 +619,9 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
             });
         };
         routes['POST /api/getQuote'] = async function (_ignore_params, postData) {
+            if (!instance.quoteConfiguration.requiresQuote && !instance.quoteConfiguration.issueQuotes) {
+                throw (new Errors.QuoteIssuanceDisabled());
+            }
             if (!postData || typeof postData !== 'object') {
                 throw (new Error('No POST data provided'));
             }
@@ -518,17 +629,14 @@ 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);
-            if (PARANOID) {
-                const quoteAccount = rateAndFee.account;
-                if (!instance.accounts.has(quoteAccount)) {
-                    throw (new Error('"getConversionRateAndFee" returned an account not configured for this server'));
-                }
-            }
+            const rateAndFee = await getUnsignedQuoteData(conversion, 'quote');
             const unsignedQuote = KeetaNet.lib.Utils.Conversion.toJSONSerializable({
                 request: conversion,
                 ...rateAndFee
             });
+            if (config.quoteSigner === null) {
+                throw (new Error('Quote signer not configured, this is required when issuing quotes'));
+            }
             const signedQuote = await generateSignedQuote(config.quoteSigner, unsignedQuote);
             const quoteResponse = {
                 ok: true,
@@ -545,71 +653,161 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
             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'));
-            }
+            const request = assertKeetaFXAnchorClientCreateExchangeRequestJSON(postData.request);
             if (!('block' in request) || typeof request.block !== 'string') {
                 throw (new Error('Block was not provided in exchange request'));
             }
-            const quote = assertConversionQuoteJSON(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 quoteInput;
+            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'));
             }
-            /* Validate the quote using the optional callback */
-            if (config.fx.validateQuote !== undefined) {
-                const isAcceptable = await config.fx.validateQuote(quote);
-                if (!isAcceptable) {
+            else if ('quote' in request && request.quote) {
+                isQuoteBasedExchange = true;
+                shouldValidateQuote = true;
+                quoteInput = request.quote;
+                conversionInput = quoteInput.request;
+                const isValidQuote = await (async () => {
+                    if (config.quoteSigner === null) {
+                        return (false);
+                    }
+                    return (await verifySignedData(config.quoteSigner, quoteInput));
+                })();
+                if (!isValidQuote) {
                     throw (new Errors.QuoteValidationFailed());
                 }
+                liquidityAccount = quoteInput.account;
+                expectedConversion = convertQuoteToExpectedSwapWithoutCost({
+                    quote: toValidateQuoteInput(quoteInput),
+                    request: conversionInput
+                });
             }
-            const block = new KeetaNet.lib.Block(request.block);
-            /* 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);
-            /* If cost is required verify the amounts and token. */
-            if (BigInt(quote.cost.amount) > 0) {
-                /* If swap token matches the cost token the add the amount since they should be combined in one block and will be checked in `acceptSwapRequest` */
-                if (expectedToken.comparePublicKey(quote.cost.token)) {
-                    expectedAmount += BigInt(quote.cost.amount);
-                    /* If token is different then check block operations for matching amount and token */
+            else if ('request' in request && request.request) {
+                isQuoteBasedExchange = false;
+                if (instance.quoteConfiguration.requiresQuote) {
+                    throw (new Errors.QuoteRequired());
+                }
+                conversionInput = request.request;
+                quoteInput = await getUnsignedQuoteData(conversionInput, 'estimate');
+                if (instance.quoteConfiguration.validateQuoteBeforeExchange !== undefined) {
+                    shouldValidateQuote = instance.quoteConfiguration.validateQuoteBeforeExchange;
                 }
                 else {
-                    let requestIncludesCost = false;
-                    for (const operation of block.operations) {
-                        if (operation.type === KeetaNet.lib.Block.OperationType.SEND) {
-                            const recipientMatches = operation.to.comparePublicKey(quote.account);
-                            const tokenMatches = operation.token.comparePublicKey(quote.cost.token);
-                            const amountMatches = operation.amount === BigInt(quote.cost.amount);
-                            if (recipientMatches && tokenMatches && amountMatches) {
-                                requestIncludesCost = true;
-                            }
+                    shouldValidateQuote = config.fx.validateQuote !== undefined;
+                }
+                for (const operation of block.operations) {
+                    if (operation.type === KeetaNet.lib.Block.OperationType.SEND) {
+                        if (!config.accounts) {
+                            throw (new Error('No accounts configured for FX server, cannot infer liquidity account from block'));
+                        }
+                        if (config.accounts.has(operation.to)) {
+                            liquidityAccount = operation.to;
+                            break;
                         }
                     }
-                    if (!requestIncludesCost) {
-                        throw (new Error('Exchange missing required cost'));
-                    }
                 }
+                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'));
+            }
+            const parsedQuote = toValidateQuoteInput(quoteInput);
+            /* Validate the quote using the optional callback */
+            if (config.fx.validateQuote !== undefined && shouldValidateQuote) {
+                const isAcceptable = await config.fx.validateQuote(parsedQuote);
+                if (!isAcceptable) {
+                    throw (new Errors.QuoteValidationFailed());
+                }
+            }
+            const liquidityAccountInstance = KeetaNet.lib.Account.toAccount(liquidityAccount);
+            let allowedLiquidityAccounts;
+            if (config.accounts) {
+                allowedLiquidityAccounts = config.accounts;
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
+            }
+            else if (config.account) {
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
+                allowedLiquidityAccounts = new KeetaNet.lib.Account.Set([config.account]);
             }
+            else {
+                throw (new Error('config.account or config.accounts must be provided'));
+            }
+            assertExchangeBlockParametersAndComputeRefund({
+                block: block,
+                liquidityAccount: liquidityAccountInstance,
+                allowedLiquidityAccounts: allowedLiquidityAccounts,
+                checks: { quote: parsedQuote, request: conversionInput },
+                isQuoteBasedExchange: isQuoteBasedExchange
+            });
             /* Enqueue the exchange request */
             const exchangeID = await instance.pipeline.add({
-                account: KeetaNet.lib.Account.fromPublicKeyString(quote.account),
+                account: liquidityAccountInstance,
                 block: block,
-                request: quote.request,
-                expected: {
-                    token: expectedToken,
-                    amount: BigInt(expectedAmount)
-                }
+                request: conversionInput,
+                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)
             });
@@ -695,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();
     }
@@ -709,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 => "string" === typeof 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",
@@ -734,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",
@@ -764,10 +958,40 @@ const assertKeetaFXAnchorQueueStage1RequestJSON = (() => { const _io0 = input =>
     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, {
+}, _errorFactory)); const _ao2 = (input, _path, _exceptionable = true) => (("object" === typeof input.receive && null !== input.receive || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".receive",
+    expected: "__type.o2",
+    value: input.receive
+}, _errorFactory)) && _ao3(input.receive, _path + ".receive", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".receive",
+    expected: "__type.o2",
+    value: input.receive
+}, _errorFactory)) && (("object" === typeof input.send && null !== input.send || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".send",
+    expected: "__type.o3",
+    value: input.send
+}, _errorFactory)) && _ao4(input.send, _path + ".send", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".send",
+    expected: "__type.o3",
+    value: input.send
+}, _errorFactory)); const _ao3 = (input, _path, _exceptionable = true) => ("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: "typia.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)) && ("string" === typeof input.amount || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".amount",
     expected: "string",
+    value: input.amount
+}, _errorFactory)); const _ao4 = (input, _path, _exceptionable = true) => ("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: "typia.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)) && ("string" === typeof input.amount || __typia_transform__assertGuard._assertGuard(_exceptionable, {
     method: "typia.createAssert",