@layerzerolabs/gated-transaction 0.0.61 → 0.0.63

package/test/resolver.test.ts

@@ -1,425 +0,0 @@
-import { describe, expect, test, vi } from 'vitest';
-
-import { WorkflowFunctions } from '@layerzerolabs/common-workflow';
-import { Logger } from '@layerzerolabs/logger-node';
-
-import {
-    constructGatedTransaction,
-    constructGatedTransactionFromPointer,
-    getIdForGatedTransaction,
-} from '../src/gatedTx';
-import { resolveGatedTransactions } from '../src/resolver';
-import type { GatedTransaction } from '../src/schemata';
-import { GatedTransactionStatus } from '../src/schemata';
-
-type Handler = {
-    initial?: (...args: any[]) => any | Promise<any>;
-    final?: (...args: any[]) => any | Promise<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 || (h.final != null && h.initial == null);
-        if (isFinal) {
-            if (h.final) return await h.final(...params);
-            if (h.initial) return await h.initial(...params);
-            return undefined;
-        }
-        if (h.initial) return await h.initial(...params);
-        return undefined;
-    },
-});
-
-const makeTx = (name: string, functionPointer: string, expected: any, deps?: GatedTransaction[]) =>
-    constructGatedTransaction({
-        name,
-        chainName: 'test-chain',
-        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;
-
-const makeLogger = (): Logger =>
-    ({
-        log: vi.fn(),
-        trace: vi.fn(),
-        debug: vi.fn(),
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-    }) as Logger;
-
-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(),
-            logger: makeLogger(),
-        });
-
-        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(),
-            logger: makeLogger(),
-        });
-
-        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(),
-            logger: makeLogger(),
-        });
-
-        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(),
-            logger: makeLogger(),
-        });
-
-        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(),
-            logger: makeLogger(),
-        });
-
-        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(),
-            logger: makeLogger(),
-        });
-
-        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',
-            chainName: 'test-chain',
-            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',
-            chainName: 'test-chain',
-            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(),
-            logger: makeLogger(),
-        });
-
-        expect(r1.result.status).toBe(GatedTransactionStatus.SUCCESS);
-        expect(r2.result.status).toBe(GatedTransactionStatus.SUCCESS);
-        expect(processTx).toHaveBeenCalledTimes(2);
-    });
-});
-
-describe('resolveGatedTransactions - functional transactions', () => {
-    test('functional transaction without dependencies builds and succeeds', async () => {
-        const registry = makeRegistry({
-            buildFn: {
-                final: () => ({ name: 'F', built: true }) as any,
-            },
-            checkF: {
-                initial: () => false,
-                final: () => true,
-            },
-        });
-
-        const processTx = vi.fn(async (tx) => {
-            expect(tx).toMatchObject({ name: 'F', built: true });
-            return makeProcessedTx();
-        });
-
-        const txF = constructGatedTransactionFromPointer({
-            name: 'F',
-            chainName: 'test-chain',
-            dependencies: [],
-            check: {
-                functionPointer: 'checkF' as any,
-                params: [],
-                expectedResult: { operator: '=', comparisonValue: true },
-            },
-            getTransaction: {
-                functionPointer: 'buildFn' as any,
-                params: [],
-            },
-            uniqueIdKeys: { name: 'F' },
-        });
-
-        const [resF] = await resolveGatedTransactions({
-            activityRegistry: registry as any,
-            gatedTxes: [txF],
-            processTx,
-            fn: makeFn(),
-            logger: makeLogger(),
-        });
-
-        expect(resF.result.status).toBe(GatedTransactionStatus.SUCCESS);
-        expect(processTx).toHaveBeenCalledTimes(1);
-    });
-
-    test('functional transaction builds from dependency data and succeeds', async () => {
-        const registry = makeRegistry({
-            depCheck: {
-                initial: () => false,
-                final: () => 10,
-            },
-            buildFromDep: {
-                final: (...deps: any[]) => ({ name: 'F2', builtFrom: deps[0] }) as any,
-            },
-            checkF2: {
-                initial: () => false,
-                final: () => true,
-            },
-        });
-
-        const dep = constructGatedTransaction({
-            name: 'Dep',
-            chainName: 'test-chain',
-            transaction: { name: 'DepTx' } as any,
-            check: {
-                functionPointer: 'depCheck' as any,
-                params: [],
-                expectedResult: { operator: '=', comparisonValue: 10 },
-            },
-            uniqueIdKeys: { name: 'Dep' },
-        });
-
-        const func = constructGatedTransactionFromPointer({
-            name: 'F2',
-            chainName: 'test-chain',
-            check: {
-                functionPointer: 'checkF2' as any,
-                params: [],
-                expectedResult: { operator: '=', comparisonValue: true },
-            },
-            getTransaction: {
-                functionPointer: 'buildFromDep' as any,
-                params: [],
-            },
-            uniqueIdKeys: { name: 'F2' },
-            dependencies: [dep],
-        });
-
-        const processTx = vi.fn(async (tx) => {
-            // ensure the built tx used dependency output (10)
-            if (tx.name === 'F2') {
-                delete (dep as any).transaction;
-                delete (dep as any).transactionType;
-                expect(tx.builtFrom[0]).toMatchObject(dep);
-            }
-            return makeProcessedTx();
-        });
-
-        const [resDep, resFunc] = await resolveGatedTransactions({
-            activityRegistry: registry as any,
-            gatedTxes: [dep, func],
-            processTx,
-            fn: makeFn(),
-            logger: makeLogger(),
-        });
-
-        expect(resDep.result.status).toBe(GatedTransactionStatus.SUCCESS);
-        expect(resFunc.result.status).toBe(GatedTransactionStatus.SUCCESS);
-        expect(processTx).toHaveBeenCalledTimes(2);
-    });
-
-    test('functional getTransactionPointer error yields TRANSACTION_FAILED', async () => {
-        const registry = makeRegistry({
-            buildBad: {
-                final: () => {
-                    throw new Error('build failed');
-                },
-            },
-            checkFBad: {
-                initial: () => false,
-            },
-        });
-
-        const processTx = vi.fn(async (_tx) => makeProcessedTx());
-
-        const tx = constructGatedTransactionFromPointer({
-            name: 'FBad',
-            chainName: 'test-chain',
-            dependencies: [],
-            check: {
-                functionPointer: 'checkFBad' as any,
-                params: [],
-                expectedResult: { operator: '=', comparisonValue: true },
-            },
-            getTransaction: {
-                functionPointer: 'buildBad' as any,
-                params: [],
-            },
-            uniqueIdKeys: { name: 'FBad' },
-        });
-
-        const [res] = await resolveGatedTransactions({
-            activityRegistry: registry as any,
-            gatedTxes: [tx],
-            processTx,
-            fn: makeFn(),
-            logger: makeLogger(),
-        });
-
-        expect(res.result.status).toBe(GatedTransactionStatus.TRANSACTION_FAILED);
-        expect(processTx).toHaveBeenCalledTimes(0);
-    });
-});