@layerzerolabs/gated-transaction 0.0.60 → 0.0.62

package/src/resolver.ts

@@ -1,448 +0,0 @@
-import isEqual from 'lodash.isequal';
-
-import type { ActivityRegistry } from '@layerzerolabs/common-activities';
-import type {
-    Transaction,
-    TransactionResult,
-    TransactionWithResult,
-} from '@layerzerolabs/common-chain-model';
-import type { WorkflowFunctions } from '@layerzerolabs/common-workflow';
-import type { Logger } from '@layerzerolabs/logger-node';
-
-import { getIdForGatedTransaction } from './gatedTx';
-import type {
-    BaseGatedTransactionFor,
-    GatedTransaction,
-    GatedTransactionId,
-    IGatedTransactionCache,
-    InferOnChainDataTypeFromGatedTransaction,
-    ResolvedGatedTransaction,
-    ResolvedGatedTransactionDependencies,
-    UserInteractionCallbacks,
-} from './schemata';
-import { GatedTransactionStatus } from './schemata';
-
-type OnChainCheckResult<DataType = any> = {
-    expectationMet: boolean;
-    onChainData: DataType;
-};
-
-const checkGatedTransaction = async <
-    GatedTx extends GatedTransaction,
-    TxWithResult extends TransactionWithResult,
->({
-    registry,
-    gatedTransaction,
-    cachedCheckResult,
-    submittedTransaction,
-}: {
-    registry: ActivityRegistry;
-    gatedTransaction: GatedTx;
-    cachedCheckResult?: InferOnChainDataTypeFromGatedTransaction<GatedTx>;
-    submittedTransaction?: TxWithResult;
-}): Promise<OnChainCheckResult<InferOnChainDataTypeFromGatedTransaction<GatedTx>>> => {
-    let onChainData: InferOnChainDataTypeFromGatedTransaction<GatedTx>;
-    if (cachedCheckResult !== undefined) {
-        onChainData = cachedCheckResult;
-    } else {
-        // Always inject the processed transaction as the last parameter when available
-        let params = gatedTransaction.check.params;
-        if (submittedTransaction !== undefined) {
-            params = [...gatedTransaction.check.params, submittedTransaction];
-        }
-
-        onChainData = await registry.callByPointer(gatedTransaction.check.functionPointer, params);
-    }
-
-    let expectationMet: boolean;
-
-    switch (gatedTransaction.check.expectedResult.operator) {
-        case '=':
-            expectationMet = isEqual(
-                onChainData,
-                gatedTransaction.check.expectedResult.comparisonValue,
-            );
-            break;
-        case '!=':
-            expectationMet = !isEqual(
-                onChainData,
-                gatedTransaction.check.expectedResult.comparisonValue,
-            );
-            break;
-        case '>':
-            expectationMet =
-                (onChainData as number) >
-                (gatedTransaction.check.expectedResult.comparisonValue as number);
-            break;
-        case '>=':
-            expectationMet =
-                (onChainData as number) >=
-                (gatedTransaction.check.expectedResult.comparisonValue as number);
-            break;
-        case '<':
-            expectationMet =
-                (onChainData as number) <
-                (gatedTransaction.check.expectedResult.comparisonValue as number);
-            break;
-        case '<=':
-            expectationMet =
-                (onChainData as number) <=
-                (gatedTransaction.check.expectedResult.comparisonValue as number);
-            break;
-        default:
-            throw new Error(
-                `Gated transaction operator "${gatedTransaction.check.expectedResult.operator}" is not supported`,
-            );
-    }
-
-    return {
-        expectationMet,
-        onChainData,
-    };
-};
-
-const extractGatedTransactionUnderlyingTransaction = async <
-    GatedTx extends GatedTransaction,
-    TxType extends Transaction,
->({
-    registry,
-    gatedTransaction,
-    deps,
-}: {
-    registry: ActivityRegistry;
-    gatedTransaction: GatedTx;
-    deps: ResolvedGatedTransactionDependencies<GatedTx>;
-}): Promise<TxType> => {
-    let tx: TxType;
-    if (gatedTransaction.transactionType === 'literal') {
-        tx = gatedTransaction.transaction as TxType;
-    } else {
-        tx = await registry.callByPointer(gatedTransaction.getTransaction.functionPointer, [
-            deps,
-            ...gatedTransaction.getTransaction.params,
-        ]);
-    }
-
-    if (!tx.parallelizingKey) {
-        tx.parallelizingKey = `MISSING_PARALLELIZING_KEY-${getIdForGatedTransaction(gatedTransaction)}`;
-    }
-
-    return tx;
-};
-
-const resolveGatedTransaction = async <
-    TxType extends Transaction,
-    GatedTx extends GatedTransaction<string, TxType, any>,
-    ProcessTx extends (transaction: TxType) => Promise<TransactionResult>,
->({
-    activityRegistry,
-    gatedTx,
-    getTransactionResult,
-    processTx,
-    confirmationCallback,
-    fn,
-    cache,
-    logger,
-}: {
-    activityRegistry: ActivityRegistry;
-    gatedTx: GatedTx;
-    processTx: ProcessTx;
-    getTransactionResult: (gtxId: GatedTransactionId) =>
-        | {
-              resolved?: ResolvedGatedTransaction;
-              checkResult: { onChainData?: any; expectationMet: boolean };
-          }
-        | undefined;
-    confirmationCallback: NonNullable<UserInteractionCallbacks['confirmationCallback']>;
-    fn: WorkflowFunctions;
-    cache?: IGatedTransactionCache;
-    logger: Logger;
-}): Promise<{
-    resolvedGatedTransaction: ResolvedGatedTransaction<GatedTx>;
-    lastCheckResult: OnChainCheckResult | null;
-}> => {
-    const baseGatedTx = {
-        name: gatedTx.name,
-        chainName: gatedTx.chainName,
-        bundleName: gatedTx.bundleName,
-        check: gatedTx.check,
-        dependencies: gatedTx.dependencies,
-        cacheable: gatedTx.cacheable,
-        uniqueIdKeys: gatedTx.uniqueIdKeys,
-        metadata: gatedTx.metadata,
-        description: gatedTx.description,
-    } as BaseGatedTransactionFor<GatedTx>;
-
-    const dependencyIds = (gatedTx.dependencies ?? []).map((tx) => getIdForGatedTransaction(tx));
-
-    const dependenciesAreAllProcessed = () => dependencyIds.every((id) => getTransactionResult(id));
-
-    await fn.condition(dependenciesAreAllProcessed);
-
-    //check that the dependencies succeeded
-    const dependenciesWereSuccessful = dependencyIds.every(
-        (id) => getTransactionResult(id)?.checkResult.expectationMet,
-    );
-
-    if (!dependenciesWereSuccessful) {
-        logger.error(
-            `Some dependencies of gated transaction ${gatedTx.name} failed: ${JSON.stringify(
-                Object.fromEntries(dependencyIds.map((id) => [id, getTransactionResult(id)])),
-                undefined,
-                2,
-            )}`,
-        );
-        return {
-            resolvedGatedTransaction: {
-                ...baseGatedTx,
-                result: {
-                    status: GatedTransactionStatus.DEPENDENCY_FAILED,
-                },
-            },
-            lastCheckResult: null,
-        };
-    }
-
-    const initialCheckResult = await checkGatedTransaction({
-        gatedTransaction: gatedTx,
-        registry: activityRegistry,
-        cachedCheckResult: await cache?.getCachedTxCheckData?.(gatedTx),
-    });
-
-    await cache?.cacheSuccessfulTxCheckData?.(gatedTx, initialCheckResult.onChainData);
-
-    if (initialCheckResult.expectationMet) {
-        //already met
-        return {
-            resolvedGatedTransaction: {
-                ...baseGatedTx,
-                result: {
-                    status: GatedTransactionStatus.NO_OP,
-                },
-            },
-            lastCheckResult: initialCheckResult,
-        };
-    }
-
-    //get confirmation before sending
-    const confirmation = await confirmationCallback(gatedTx);
-    if (!confirmation) {
-        return {
-            resolvedGatedTransaction: {
-                ...baseGatedTx,
-                result: {
-                    status: GatedTransactionStatus.DENIED,
-                },
-            },
-            lastCheckResult: initialCheckResult,
-        };
-    }
-
-    //send the tx
-    try {
-        const depsResults = gatedTx.dependencies.map(
-            (dep) => getTransactionResult(getIdForGatedTransaction(dep))!.resolved!,
-        ) as ResolvedGatedTransactionDependencies<GatedTx>;
-        // get the underlying calldata
-        const underlying = await extractGatedTransactionUnderlyingTransaction<GatedTx, TxType>({
-            registry: activityRegistry,
-            gatedTransaction: gatedTx,
-            deps: depsResults,
-        });
-        const processResult = await processTx(underlying);
-
-        if (processResult.type === 'error') {
-            throw new Error(`Sending gtx ${gatedTx.name} failed: ${processResult.error}`);
-        }
-
-        const submittedTransaction = { ...underlying, result: processResult };
-        const finalCheckResult = await checkGatedTransaction({
-            registry: activityRegistry,
-            gatedTransaction: gatedTx,
-            submittedTransaction,
-        });
-
-        await cache?.cacheSuccessfulTxCheckData?.(gatedTx, finalCheckResult.onChainData);
-
-        if (finalCheckResult.expectationMet) {
-            //sent and successful
-            return {
-                resolvedGatedTransaction: {
-                    ...baseGatedTx,
-                    result: {
-                        status: GatedTransactionStatus.SUCCESS,
-                        submittedTransaction,
-                    },
-                },
-                lastCheckResult: finalCheckResult,
-            };
-        } else {
-            //sent and unsuccessful
-            const stringify = (o: any) =>
-                JSON.stringify(
-                    o,
-                    (_, v) =>
-                        v === undefined ? 'undefined' : typeof v === 'bigint' ? v.toString() : v,
-                    2,
-                );
-            logger.error(
-                `Gated transaction ${gatedTx.name} final check failed:\nExpected result ${stringify(gatedTx.check.expectedResult.comparisonValue)}, but got:\n${stringify(finalCheckResult.onChainData)}, txHash: ${submittedTransaction.result.minedTxHash}`,
-            );
-            return {
-                resolvedGatedTransaction: {
-                    ...baseGatedTx,
-                    result: {
-                        status: GatedTransactionStatus.FINAL_CHECK_FAILED,
-                        submittedTransaction,
-                        finalOnChainState: finalCheckResult.onChainData,
-                    },
-                },
-                lastCheckResult: finalCheckResult,
-            };
-        }
-    } catch (e) {
-        logger.error('Gated transaction failed', e);
-        //sent and failed
-        return {
-            resolvedGatedTransaction: {
-                ...baseGatedTx,
-                result: {
-                    status: GatedTransactionStatus.TRANSACTION_FAILED,
-                    transactionError: e,
-                },
-            },
-            lastCheckResult: initialCheckResult,
-        };
-    }
-};
-
-export const resolveGatedTransactions = async <
-    TxType extends Transaction,
-    GatedTx extends GatedTransaction<string, TxType, any>,
-    ProcessTx extends (transaction: TxType) => Promise<TransactionResult>,
->({
-    activityRegistry,
-    gatedTxes,
-    processTx,
-    fn,
-    cache,
-    userInteractionCallbacks,
-    logger,
-}: {
-    activityRegistry: ActivityRegistry;
-    gatedTxes: GatedTx[];
-    processTx: ProcessTx;
-    fn: WorkflowFunctions;
-    cache?: IGatedTransactionCache;
-    userInteractionCallbacks?: UserInteractionCallbacks;
-    logger: Logger;
-}): Promise<ResolvedGatedTransaction[]> => {
-    //compute deps
-    const allInternalIds = gatedTxes.map((tx) => getIdForGatedTransaction(tx));
-    const allDeps = gatedTxes.flatMap((tx) => tx.dependencies ?? []);
-    const allExternalDeps = allDeps.filter(
-        (tx) => !allInternalIds.includes(getIdForGatedTransaction(tx)),
-    );
-
-    //prepopulate results for external dependencies
-    //this map is only used for internal status tracking
-    const results: Record<
-        GatedTransactionId,
-        {
-            resolved?: ResolvedGatedTransaction;
-            checkResult: { onChainData?: any; expectationMet: boolean };
-        }
-    > = Object.fromEntries(
-        await Promise.all(
-            allExternalDeps.map(async (tx) => {
-                const checkResult = await checkGatedTransaction({
-                    gatedTransaction: tx,
-                    registry: activityRegistry,
-                    cachedCheckResult: await cache?.getCachedTxCheckData?.(tx),
-                });
-
-                return [
-                    getIdForGatedTransaction(tx),
-                    {
-                        checkResult,
-                    },
-                ];
-            }),
-        ),
-    );
-
-    const getTransactionResult = (gtxId: GatedTransactionId) => results[gtxId];
-
-    const txFunctions = gatedTxes.map((tx) => async () => {
-        const { resolvedGatedTransaction, lastCheckResult } = await resolveGatedTransaction<
-            TxType,
-            GatedTx,
-            ProcessTx
-        >({
-            gatedTx: tx,
-            activityRegistry,
-            getTransactionResult,
-            processTx,
-            confirmationCallback:
-                userInteractionCallbacks?.confirmationCallback ?? (async () => true),
-            fn,
-            cache,
-            logger,
-        });
-
-        const resId = getIdForGatedTransaction(resolvedGatedTransaction);
-        results[resId] = {
-            resolved: resolvedGatedTransaction,
-            checkResult: {
-                expectationMet: [
-                    GatedTransactionStatus.SUCCESS,
-                    GatedTransactionStatus.NO_OP,
-                ].includes(resolvedGatedTransaction.result.status),
-                onChainData: lastCheckResult?.onChainData ?? undefined,
-            },
-        };
-
-        userInteractionCallbacks?.onResultCallback?.(resolvedGatedTransaction);
-        return resolvedGatedTransaction;
-    });
-
-    return await Promise.all(txFunctions.map((func) => func()));
-};
-
-export const resolveSequencedGatedTransactions = async <
-    TxType extends Transaction,
-    GatedTx extends GatedTransaction<string, TxType, any>,
-    ProcessTx extends (transaction: TxType) => Promise<TransactionResult>,
->({
-    activityRegistry,
-    gatedTxes,
-    processTx,
-    cache,
-    userInteractionCallbacks,
-    fn,
-    logger,
-}: {
-    activityRegistry: ActivityRegistry;
-    gatedTxes: GatedTx[][];
-    processTx: ProcessTx;
-    fn: WorkflowFunctions;
-    cache?: IGatedTransactionCache;
-    userInteractionCallbacks?: UserInteractionCallbacks;
-    logger: Logger;
-}) => {
-    const results = [];
-    for (const seq of gatedTxes) {
-        const result = await resolveGatedTransactions<TxType, GatedTx, ProcessTx>({
-            gatedTxes: seq,
-            activityRegistry,
-            processTx,
-            cache,
-            userInteractionCallbacks,
-            fn,
-            logger,
-        });
-        results.push(result);
-    }
-
-    return results;
-};