@keetanetwork/anchor 0.0.37 → 0.0.38

package/services/fx/server.js

@@ -1,13 +1,14 @@
 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 { assertExchangeBlockParameters } from './util.js';
 /**
  * Enable additional runtime "paranoid" checks in the FX server.
  *
@@ -75,6 +76,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;
@@ -108,12 +134,17 @@ class KeetaFXAnchorQueuePipelineStage1 extends KeetaAnchorQueueRunner {
      */
     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;
+            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,7 +237,10 @@ 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();
+        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;
@@ -233,8 +267,14 @@ class KeetaFXAnchorQueuePipelineStage1 extends KeetaAnchorQueueRunner {
             block: Buffer.from(request.block.toBytes()).toString('base64'),
             request: request.request,
             expected: {
-                token: request.expected.token.publicKeyString.get(),
-                amount: request.expected.amount.toString()
+                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()
+                }
             }
         };
         return (retval);
@@ -254,8 +294,14 @@ class KeetaFXAnchorQueuePipelineStage1 extends KeetaAnchorQueueRunner {
             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)
+                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)
+                }
             }
         };
         return (retval);
@@ -365,6 +411,7 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
     quoteSigner;
     fx;
     pipeline;
+    quoteConfiguration;
     pipelineAutoRunInterval = null;
     constructor(config) {
         super(config);
@@ -372,6 +419,7 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
         this.client = config.client;
         this.fx = config.fx;
         this.quoteSigner = config.quoteSigner;
+        this.quoteConfiguration = config.quoteConfiguration ?? { requiresQuote: true };
         /*
          * Setup the accounts
          */
@@ -494,23 +542,56 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
             }
             const conversion = assertConversionInputCanonicalJSON(postData.request);
             const rateAndFee = await config.fx.getConversionRateAndFee(conversion);
+            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 ({
                 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());
+            }
             if (!postData || typeof postData !== 'object') {
                 throw (new Error('No POST data provided'));
             }
@@ -518,17 +599,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);
             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,64 +623,124 @@ 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'));
-            }
-            /* Validate the quote using the optional callback */
-            if (config.fx.validateQuote !== undefined) {
-                const isAcceptable = await config.fx.validateQuote(quote);
-                if (!isAcceptable) {
+            const block = new KeetaNet.lib.Block(request.block);
+            let quoteInput;
+            let conversionInput;
+            let shouldValidateQuote;
+            let liquidityAccount;
+            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) {
+                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;
             }
-            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) {
+                if (instance.quoteConfiguration.requiresQuote) {
+                    throw (new Errors.QuoteRequired());
+                }
+                conversionInput = request.request;
+                quoteInput = await getUnsignedQuoteData(conversionInput);
+                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'));
+                }
+            }
+            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());
+                }
+            }
+            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;
+                // 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'));
+            }
+            assertExchangeBlockParameters({
+                block: block,
+                liquidityAccount: liquidityAccountInstance,
+                allowedLiquidityAccounts: allowedLiquidityAccounts,
+                userSendsMinimum: userSendsMinimum,
+                userWillReceiveMaximum: userWillReceiveMaximum
+            });
             /* Enqueue the exchange request */
             const exchangeID = await instance.pipeline.add({
-                account: KeetaNet.lib.Account.fromPublicKeyString(quote.account),
+                account: liquidityAccountInstance,
                 block: block,
-                request: quote.request,
+                request: conversionInput,
                 expected: {
-                    token: expectedToken,
-                    amount: BigInt(expectedAmount)
+                    receive: {
+                        token: KeetaNet.lib.Account.fromPublicKeyString(conversionInput.from),
+                        amount: expectedReceiveAmount
+                    },
+                    send: {
+                        token: KeetaNet.lib.Account.fromPublicKeyString(conversionInput.to),
+                        amount: expectedSendAmount
+                    }
                 }
             });
             const exchangeResponse = {
@@ -709,7 +847,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)) && ("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",
@@ -764,10 +902,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",