@keetanetwork/anchor 0.0.39 → 0.0.41

package/services/fx/server.js

@@ -104,6 +104,64 @@ export function toValidateQuoteInput(input) {
     }
     return (ret);
 }
+function encodeKeetaFXAnchorQueueStage1Request(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: expected
+    };
+    return (retval);
+}
+function decodeKeetaFXAnchorQueueStage1Request(request) {
+    /* See note at bottom of file */
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    const reqJSON = assertKeetaFXAnchorQueueStage1RequestJSON(request);
+    if (reqJSON.version !== 1) {
+        throw (new Error(`Unsupported KeetaFXAnchorQueueStage1Request version ${reqJSON.version}`));
+    }
+    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: expected
+    };
+    return (retval);
+}
 class KeetaFXAnchorQueuePipelineStage1 extends KeetaAnchorQueueRunner {
     serverConfig;
     sequential = true;
@@ -302,65 +360,13 @@ 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: expected
-        };
-        return (retval);
+        return (encodeKeetaFXAnchorQueueStage1Request(request));
     }
     encodeResponse(response) {
         return (response);
     }
     decodeRequest(request) {
-        /* See note at bottom of file */
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        const reqJSON = assertKeetaFXAnchorQueueStage1RequestJSON(request);
-        if (reqJSON.version !== 1) {
-            throw (new Error(`Unsupported KeetaFXAnchorQueueStage1Request version ${reqJSON.version}`));
-        }
-        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: expected
-        };
-        return (retval);
+        return (decodeKeetaFXAnchorQueueStage1Request(request));
     }
     decodeResponse(response) {
         /* See note at bottom of file */
@@ -372,12 +378,88 @@ class KeetaFXAnchorQueuePipeline extends KeetaAnchorQueuePipelineAdvanced {
     serverConfig;
     accounts;
     runners = {};
+    extensions;
+    successStageRunner = null;
+    failureStageRunner = null;
     constructor(options) {
         super(options);
         this.serverConfig = options.serverConfig;
         this.accounts = options.accounts;
+        this.extensions = options.extensions;
     }
     async createPipeline() {
+        const failureExtension = this.extensions?.failure;
+        const successExtension = this.extensions?.success;
+        if (failureExtension || successExtension) {
+            class BaseExtensionClass extends KeetaAnchorQueueRunner {
+                #configSet = false;
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+                #processorMethod = (() => {
+                    throw (new Error('config not set'));
+                });
+                _setConfigurationAndProcessor(config) {
+                    if (this.#configSet) {
+                        throw (new Error('Configuration can only be set once'));
+                    }
+                    this.#configSet = true;
+                    if (typeof config === 'function') {
+                        this.#processorMethod = config;
+                    }
+                    else {
+                        const { processor, ...parameters } = config;
+                        this.#processorMethod = processor;
+                        this.setConfiguration(parameters);
+                    }
+                }
+                async processor(entry) {
+                    return (await this.#processorMethod(entry));
+                }
+            }
+            if (failureExtension) {
+                const failureQueue = await this.baseQueue.partition('failed');
+                this.queues.push(failureQueue);
+                const runner = (new class extends BaseExtensionClass {
+                    encodeRequest(request) { return (encodeKeetaFXAnchorQueueStage1Request(request)); }
+                    decodeRequest(request) { return (decodeKeetaFXAnchorQueueStage1Request(request)); }
+                    encodeResponse(response) { return (response); }
+                    decodeResponse(response) { return (response); }
+                }({
+                    id: 'keeta-fx-anchor-failure-runner',
+                    queue: failureQueue,
+                    logger: this.logger
+                }));
+                runner._setConfigurationAndProcessor(failureExtension);
+                this.failureStageRunner = runner;
+            }
+            if (successExtension) {
+                const successQueue = await this.baseQueue.partition('success');
+                this.queues.push(successQueue);
+                const runner = (new class extends BaseExtensionClass {
+                    encodeRequest(request) { return (request); }
+                    decodeRequest(request) {
+                        /* See note at bottom of file */
+                        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                        const parsed = assertKeetaFXAnchorQueueStage1ResponseOrNull(request);
+                        if (parsed === null) {
+                            throw (new Error('Invalid request for success extension'));
+                        }
+                        return (parsed);
+                    }
+                    encodeResponse(response) { return (response); }
+                    decodeResponse(response) {
+                        /* See note at bottom of file */
+                        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                        return (assertKeetaFXAnchorQueueStage1ResponseOrNull(response));
+                    }
+                }({
+                    id: 'keeta-fx-anchor-success-runner',
+                    queue: successQueue,
+                    logger: this.logger
+                }));
+                runner._setConfigurationAndProcessor(successExtension);
+                this.successStageRunner = runner;
+            }
+        }
         for (const account of this.accounts) {
             const queue = await this.baseQueue.partition(account.publicKeyAndTypeString);
             this.queues.push(queue);
@@ -387,6 +469,12 @@ class KeetaFXAnchorQueuePipeline extends KeetaAnchorQueuePipelineAdvanced {
                 logger: this.logger,
                 serverConfig: this.serverConfig
             });
+            if (this.successStageRunner) {
+                runner.pipe(this.successStageRunner, { exclusiveTarget: false });
+            }
+            if (this.failureStageRunner) {
+                runner.pipeFailed(this.failureStageRunner, { exclusiveTarget: false });
+            }
             this.runners[account.publicKeyAndTypeString] = runner;
         }
     }
@@ -402,6 +490,14 @@ class KeetaFXAnchorQueuePipeline extends KeetaAnchorQueuePipelineAdvanced {
         }
         return (await runner.add(request));
     }
+    /**
+     * Get the status of a request by ID.
+     * If the request is found in any of the runners, it is returned with its current status.
+     * Because typically the user will only care about the status of the first stage-
+     * The request will be marked as failed or completed if it is found in the success or failure stages, instead of the status from those stages.
+     * @param id The ID of the request to get the status of
+     * @returns The inferred status of the request, or null if the request is not found
+     */
     async get(id) {
         await super.init();
         for (const account of this.accounts) {
@@ -411,19 +507,65 @@ class KeetaFXAnchorQueuePipeline extends KeetaAnchorQueuePipelineAdvanced {
             }
             const entry = await runner.get(id);
             if (entry !== null) {
+                if (entry.status === 'moved') {
+                    let failedFound = null;
+                    let successFound = null;
+                    if (this.failureStageRunner || this.successStageRunner) {
+                        await Promise.all([
+                            (async () => {
+                                if (!this.failureStageRunner) {
+                                    return (null);
+                                }
+                                failedFound = await this.failureStageRunner.get(id);
+                            })(),
+                            (async () => {
+                                if (!this.successStageRunner) {
+                                    return (null);
+                                }
+                                successFound = await this.successStageRunner.get(id);
+                            })()
+                        ]);
+                    }
+                    if (failedFound && successFound) {
+                        this.logger?.warn(`Request with ID ${String(id)} was found in both the success and failure stages -- this should not happen`, { requestID: id });
+                    }
+                    else if (failedFound) {
+                        entry.status = 'failed_permanently';
+                    }
+                    else if (successFound) {
+                        entry.status = 'completed';
+                    }
+                    else {
+                        this.logger?.warn(`Request with ID ${String(id)} has moved from the main processing stage but was not found in either the success or failure stages -- leaving status as "moved"`, { requestID: id });
+                    }
+                }
                 return (entry);
             }
         }
         return (null);
     }
-    async run(options) {
-        await super.init();
-        let retval = false;
+    #getAllRunners() {
+        const runners = [];
         for (const account of this.accounts) {
             const runner = this.runners[account.publicKeyAndTypeString];
             if (runner === undefined) {
                 continue;
             }
+            runners.push(runner);
+        }
+        if (this.successStageRunner) {
+            runners.push(this.successStageRunner);
+        }
+        if (this.failureStageRunner) {
+            runners.push(this.failureStageRunner);
+        }
+        return (runners);
+    }
+    async run(options) {
+        await super.init();
+        const runners = this.#getAllRunners();
+        let retval = false;
+        for (const runner of runners) {
             const more = await runner.run(options);
             if (more) {
                 retval = true;
@@ -433,11 +575,8 @@ class KeetaFXAnchorQueuePipeline extends KeetaAnchorQueuePipelineAdvanced {
     }
     async maintain() {
         await super.init();
-        for (const account of this.accounts) {
-            const runner = this.runners[account.publicKeyAndTypeString];
-            if (runner === undefined) {
-                continue;
-            }
+        const runners = this.#getAllRunners();
+        for (const runner of runners) {
             await runner.maintain();
         }
     }
@@ -448,7 +587,8 @@ class KeetaFXAnchorQueuePipeline extends KeetaAnchorQueuePipelineAdvanced {
         }
         this.destroyed = true;
         await super.destroy();
-        for (const runner of Object.values(this.runners)) {
+        const runners = this.#getAllRunners();
+        for (const runner of runners) {
             try {
                 await runner.destroy();
             }
@@ -527,7 +667,8 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
             }),
             accounts: this.accounts,
             logger: this.logger,
-            serverConfig: this
+            serverConfig: this,
+            extensions: config.queueRunnerExtensions
         });
     }
     async initRoutes(config) {
@@ -591,10 +732,10 @@ export class KeetaNetFXAnchorHTTPServer extends KeetaAnchorHTTPServer.KeetaNetAn
                     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)) {
+                    if (conversion.affinity === 'to' && (BigInt(rateAndFee.convertedAmount) > 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)) {
+                    if (conversion.affinity === 'from' && (BigInt(rateAndFee.convertedAmount) < rateAndFee.convertedAmountBound)) {
                         throw (new KeetaAnchorError('Affinity is from, but bound is greater than estimated received amount'));
                     }
                 }