@layerzerolabs/gated-transaction 0.0.8

package/test/resolver.test.ts

@@ -0,0 +1,250 @@
+import { describe, expect, test, vi } from 'vitest';
+
+import { WorkflowFunctions } from '@layerzerolabs/common-workflow';
+
+import { constructGatedTransaction, getIdForGatedTransaction } from '../src/gatedTx';
+import { resolveGatedTransactions } from '../src/resolver';
+import type { GatedTransaction } from '../src/types';
+import { GatedTransactionStatus } from '../src/types';
+
+type Handler = {
+    initial?: (...args: any[]) => any | Promise<any>;
+    final?: (...args: any[]) => any | Promise<any>;
+    throwsInitial?: any;
+    throwsFinal?: any;
+};
+
+const makeRegistry = (handlers: Record<string, Handler>) => ({
+    callByPointer: async (fn: string, params: any[]) => {
+        const h = handlers[fn];
+        if (!h) throw new Error(`No handler for ${fn}`);
+        const isFinal = params.length > 0;
+        if (isFinal) {
+            if (h.throwsFinal !== undefined) throw h.throwsFinal;
+            if (h.final) return await h.final(...params);
+            if (h.initial) return await h.initial(...params);
+            return undefined;
+        }
+        if (h.throwsInitial !== undefined) throw h.throwsInitial;
+        if (h.initial) return await h.initial(...params);
+        return undefined;
+    },
+});
+
+const makeTx = (name: string, functionPointer: string, expected: any, deps?: GatedTransaction[]) =>
+    constructGatedTransaction({
+        name,
+        transaction: { name } as any,
+        check: {
+            functionPointer: functionPointer as any,
+            params: [],
+            expectedResult: { operator: '=', comparisonValue: expected },
+        },
+        uniqueIdKeys: { name },
+        dependencies: deps,
+    });
+
+const makeProcessedTx = () =>
+    ({
+        chainName: 'test-chain',
+        timestamps: { created: Date.now() },
+    }) as any;
+
+const makeFn = (): WorkflowFunctions =>
+    ({
+        condition: async (predicate) => {
+            while (true) {
+                if (predicate()) {
+                    return true;
+                }
+                await new Promise((res) => setTimeout(res, 100));
+            }
+        },
+    }) as WorkflowFunctions;
+
+describe('resolveGatedTransactions - dependency and edge cases', () => {
+    test('internal dependency NO_OP enables dependent to execute and succeed', async () => {
+        const registry = makeRegistry({
+            checkA: { initial: () => true }, // A already satisfied
+            checkB: {
+                initial: () => false, // B needs sending
+                final: () => true, // After sending, satisfied
+            },
+        });
+
+        const processTx = vi.fn(async (_tx) => makeProcessedTx());
+
+        const txA = makeTx('A', 'checkA', true);
+        const txB = makeTx('B', 'checkB', true, [txA]);
+
+        const [resA, resB] = await resolveGatedTransactions({
+            activityRegistry: registry as any,
+            gatedTxes: [txA, txB],
+            processTx,
+            fn: makeFn(),
+        });
+
+        expect(resA.result.status).toBe(GatedTransactionStatus.NO_OP);
+        expect(resB.result.status).toBe(GatedTransactionStatus.SUCCESS);
+        expect(processTx).toHaveBeenCalledTimes(1);
+    });
+
+    test('internal dependency SUCCESS enables dependent to execute', async () => {
+        const registry = makeRegistry({
+            checkA: { initial: () => false, final: () => true },
+            checkB: { initial: () => false, final: () => true },
+        });
+        const processTx = vi.fn(async (_tx) => makeProcessedTx());
+
+        const txA = makeTx('A', 'checkA', true);
+        const txB = makeTx('B', 'checkB', true, [txA]);
+
+        const [resA, resB] = await resolveGatedTransactions({
+            activityRegistry: registry as any,
+            gatedTxes: [txA, txB],
+            processTx,
+            fn: makeFn(),
+        });
+
+        expect(resA.result.status).toBe(GatedTransactionStatus.SUCCESS);
+        expect(resB.result.status).toBe(GatedTransactionStatus.SUCCESS);
+        expect(processTx).toHaveBeenCalledTimes(2);
+    });
+
+    test('internal dependency TRANSACTION_FAILED causes dependent DEPENDENCY_FAILED', async () => {
+        const registry = makeRegistry({
+            checkA: { initial: () => false, final: () => false },
+            checkB: { initial: () => false, final: () => true },
+        });
+        const processTx = vi.fn(async (_tx) => {
+            throw new Error('failed to submit');
+        });
+
+        const txA = makeTx('A', 'checkA', true);
+        const txB = makeTx('B', 'checkB', true, [txA]);
+
+        const [resA, resB] = await resolveGatedTransactions({
+            activityRegistry: registry as any,
+            gatedTxes: [txA, txB],
+            processTx,
+            fn: makeFn(),
+        });
+
+        expect(resA.result.status).toBe(GatedTransactionStatus.TRANSACTION_FAILED);
+        expect(resB.result.status).toBe(GatedTransactionStatus.DEPENDENCY_FAILED);
+        expect(processTx).toHaveBeenCalledTimes(1);
+    });
+
+    test('external dependency satisfied by precheck allows dependent to execute', async () => {
+        const registry = makeRegistry({
+            checkExt: { initial: () => true },
+            checkB: { initial: () => false, final: () => true },
+        });
+        const processTx = vi.fn(async (_tx) => makeProcessedTx());
+
+        const ext = makeTx('Ext', 'checkExt', true);
+        const txB = makeTx('B', 'checkB', true, [ext]);
+
+        const [resB] = await resolveGatedTransactions({
+            activityRegistry: registry as any,
+            gatedTxes: [txB],
+            processTx,
+            fn: makeFn(),
+        });
+
+        expect(resB.result.status).toBe(GatedTransactionStatus.SUCCESS);
+        expect(processTx).toHaveBeenCalledTimes(1);
+    });
+
+    test('external dependency unsatisfied by precheck causes dependent DEPENDENCY_FAILED', async () => {
+        const registry = makeRegistry({
+            checkExt: { initial: () => false },
+            checkB: { initial: () => false, final: () => true },
+        });
+        const processTx = vi.fn(async (_tx) => makeProcessedTx());
+
+        const ext = makeTx('Ext', 'checkExt', true);
+        const txB = makeTx('B', 'checkB', true, [ext]);
+
+        const [resB] = await resolveGatedTransactions({
+            activityRegistry: registry as any,
+            gatedTxes: [txB],
+            processTx,
+            fn: makeFn(),
+        });
+
+        expect(resB.result.status).toBe(GatedTransactionStatus.DEPENDENCY_FAILED);
+        expect(processTx).toHaveBeenCalledTimes(0);
+    });
+
+    test('confirmation denial throws before sending', async () => {
+        const registry = makeRegistry({ checkA: { initial: () => false } });
+        const processTx = vi.fn(async (_tx) => makeProcessedTx());
+        const txA = makeTx('A', 'checkA', true);
+
+        const result = await resolveGatedTransactions({
+            activityRegistry: registry as any,
+            gatedTxes: [txA],
+            processTx,
+            userInteractionCallbacks: { confirmationCallback: async () => false },
+            fn: makeFn(),
+        });
+
+        expect(result[0].result.status).toStrictEqual(GatedTransactionStatus.DENIED);
+        expect(processTx).toHaveBeenCalledTimes(0);
+    });
+
+    test('same name + chain, different cache keys', async () => {
+        const registry = {
+            callByPointer: async (_fn: string, params: any[]) => {
+                // final check when params length > 0
+                return params.length > 0 ? true : false;
+            },
+        } as any;
+
+        const processTx = vi.fn(
+            async (_tx) =>
+                ({
+                    chainName: 'test-chain',
+                    timestamps: { created: Date.now() },
+                }) as any,
+        );
+
+        const tx1 = constructGatedTransaction({
+            name: 'X',
+            transaction: { name: 'X', chainName: 'chainA' } as any,
+            check: {
+                functionPointer: 'checkX' as any,
+                params: [],
+                expectedResult: { operator: '=', comparisonValue: true },
+            },
+            uniqueIdKeys: { key: '1' },
+        });
+
+        const tx2 = constructGatedTransaction({
+            name: 'X',
+            transaction: { name: 'X', chainName: 'chainA' } as any,
+            check: {
+                functionPointer: 'checkX' as any,
+                params: [],
+                expectedResult: { operator: '=', comparisonValue: true },
+            },
+            uniqueIdKeys: { key: '2' },
+        });
+
+        const id1 = getIdForGatedTransaction(tx1);
+        const id2 = getIdForGatedTransaction(tx2);
+        expect(id1).not.toBe(id2);
+
+        const [r1, r2] = await resolveGatedTransactions({
+            activityRegistry: registry as any,
+            gatedTxes: [tx1, tx2],
+            processTx,
+            fn: makeFn(),
+        });
+
+        expect(r1.result.status).toBe(GatedTransactionStatus.SUCCESS);
+        expect(r2.result.status).toBe(GatedTransactionStatus.SUCCESS);
+        expect(processTx).toHaveBeenCalledTimes(2);
+    });
+});

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+    "extends": "@layerzerolabs/typescript-configuration/tsconfig.base.json",
+    "compilerOptions": {
+        "rootDir": "./src",
+        "outDir": "./dist",
+        "strictPropertyInitialization": false,
+        "noUnusedLocals": false,
+        "noUnusedParameters": false,
+        "jsx": "react-jsx"
+    },
+    "exclude": [
+        "node_modules",
+        "**/__mocks__/*",
+        "**/__tests__/*",
+        "**/*.spec.ts",
+        "**/*.test.ts",
+        "dist"
+    ],
+    "include": ["src/**/*"],
+    "ts-node": {
+        "files": true,
+        "experimentalResolverFeatures": true,
+        "compilerOptions": {
+            "module": "CommonJS",
+            "types": ["node"]
+        }
+    }
+}

package/tsup.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'tsup';
+
+import { createPackageTsupConfig } from '@layerzerolabs/tsup-configuration';
+
+export default defineConfig(({ watch }) => ({
+    ...createPackageTsupConfig(),
+    clean: !watch,
+}));