@layerzerolabs/gated-transaction 0.0.29 → 0.0.31

package/src/resolver.ts

@@ -1,16 +1,22 @@
 import isEqual from 'lodash.isequal';
 
 import type { ActivityRegistry } from '@layerzerolabs/common-activities';
-import type { Transaction } from '@layerzerolabs/common-chain-model';
+import type {
+    Transaction,
+    TransactionResult,
+    TransactionWithResult,
+} from '@layerzerolabs/common-chain-model';
 import type { WorkflowFunctions } from '@layerzerolabs/common-workflow';
 
 import { getIdForGatedTransaction } from './gatedTx';
 import type {
+    BaseGatedTransactionFor,
     GatedTransaction,
     GatedTransactionId,
-    GatedTransactionResult,
     IGatedTransactionCache,
     InferOnChainDataTypeFromGatedTransaction,
+    ResolvedGatedTransaction,
+    ResolvedGatedTransactionDependencies,
     UserInteractionCallbacks,
 } from './types';
 import { GatedTransactionStatus } from './types';
@@ -20,16 +26,19 @@ type OnChainCheckResult<DataType = any> = {
     onChainData: DataType;
 };
 
-const checkGatedTransaction = async <GatedTx extends GatedTransaction>({
+const checkGatedTransaction = async <
+    GatedTx extends GatedTransaction,
+    TxWithResult extends TransactionWithResult,
+>({
     registry,
     gatedTransaction,
     cachedCheckResult,
-    processedTransaction,
+    submittedTransaction,
 }: {
     registry: ActivityRegistry;
     gatedTransaction: GatedTx;
     cachedCheckResult?: InferOnChainDataTypeFromGatedTransaction<GatedTx>;
-    processedTransaction?: any;
+    submittedTransaction?: TxWithResult;
 }): Promise<OnChainCheckResult<InferOnChainDataTypeFromGatedTransaction<GatedTx>>> => {
     let onChainData: InferOnChainDataTypeFromGatedTransaction<GatedTx>;
     if (cachedCheckResult !== undefined) {
@@ -37,8 +46,8 @@ const checkGatedTransaction = async <GatedTx extends GatedTransaction>({
     } else {
         // Always inject the processed transaction as the last parameter when available
         let params = gatedTransaction.check.params;
-        if (processedTransaction !== undefined) {
-            params = [...gatedTransaction.check.params, processedTransaction];
+        if (submittedTransaction !== undefined) {
+            params = [...gatedTransaction.check.params, submittedTransaction];
         }
 
         onChainData = await registry.callByPointer(gatedTransaction.check.functionPointer, params);
@@ -91,15 +100,33 @@ const checkGatedTransaction = async <GatedTx extends GatedTransaction>({
     };
 };
 
+const extractGatedTransactionUnderlyingTransaction = async <
+    GatedTx extends GatedTransaction,
+    TxType extends Transaction,
+>({
+    registry,
+    gatedTransaction,
+    deps,
+}: {
+    registry: ActivityRegistry;
+    gatedTransaction: GatedTx;
+    deps: ResolvedGatedTransactionDependencies<GatedTx>;
+}): Promise<TxType> => {
+    if (gatedTransaction.transactionType === 'literal') {
+        return gatedTransaction.transaction as TxType;
+    } else {
+        return await registry.callByPointer(gatedTransaction.getTransactionPointer, [deps]);
+    }
+};
+
 const resolveGatedTransaction = async <
     TxType extends Transaction,
-    ProcessedTxType extends Transaction,
     GatedTx extends GatedTransaction<string, TxType, any>,
-    ProcessTx extends (transaction: TxType) => Promise<ProcessedTxType>,
+    ProcessTx extends (transaction: TxType) => Promise<TransactionResult>,
 >({
     activityRegistry,
     gatedTx,
-    isTransactionSuccessful,
+    getTransactionResult,
     processTx,
     confirmationCallback,
     fn,
@@ -108,27 +135,49 @@ const resolveGatedTransaction = async <
     activityRegistry: ActivityRegistry;
     gatedTx: GatedTx;
     processTx: ProcessTx;
-    isTransactionSuccessful: (gtxId: GatedTransactionId) => boolean | undefined;
+    getTransactionResult: (gtxId: GatedTransactionId) =>
+        | {
+              resolved?: ResolvedGatedTransaction;
+              checkResult: { onChainData?: any; expectationMet: boolean };
+          }
+        | undefined;
     confirmationCallback: NonNullable<UserInteractionCallbacks['confirmationCallback']>;
     fn: WorkflowFunctions;
     cache?: IGatedTransactionCache;
-}): Promise<GatedTx & { result: GatedTransactionResult<GatedTx, ProcessedTxType> }> => {
+}): 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,
+    } as BaseGatedTransactionFor<GatedTx>;
+
     const dependencyIds = (gatedTx.dependencies ?? []).map((tx) => getIdForGatedTransaction(tx));
 
-    const dependenciesAreAllProcessed = () =>
-        dependencyIds.every((id) => isTransactionSuccessful(id) != null);
+    const dependenciesAreAllProcessed = () => dependencyIds.every((id) => getTransactionResult(id));
 
     await fn.condition(dependenciesAreAllProcessed);
 
     //check that the dependencies succeeded
-    const dependenciesWereSuccessful = dependencyIds.every((id) => isTransactionSuccessful(id));
+    const dependenciesWereSuccessful = dependencyIds.every(
+        (id) => getTransactionResult(id)?.checkResult.expectationMet,
+    );
 
     if (!dependenciesWereSuccessful) {
         return {
-            ...gatedTx,
-            result: {
-                status: GatedTransactionStatus.DEPENDENCY_FAILED,
+            resolvedGatedTransaction: {
+                ...baseGatedTx,
+                result: {
+                    status: GatedTransactionStatus.DEPENDENCY_FAILED,
+                },
             },
+            lastCheckResult: null,
         };
     }
 
@@ -143,10 +192,13 @@ const resolveGatedTransaction = async <
     if (initialCheckResult.expectationMet) {
         //already met
         return {
-            ...gatedTx,
-            result: {
-                status: GatedTransactionStatus.NO_OP,
+            resolvedGatedTransaction: {
+                ...baseGatedTx,
+                result: {
+                    status: GatedTransactionStatus.NO_OP,
+                },
             },
+            lastCheckResult: initialCheckResult,
         };
     }
 
@@ -154,20 +206,33 @@ const resolveGatedTransaction = async <
     const confirmation = await confirmationCallback(gatedTx);
     if (!confirmation) {
         return {
-            ...gatedTx,
-            result: {
-                status: GatedTransactionStatus.DENIED,
+            resolvedGatedTransaction: {
+                ...baseGatedTx,
+                result: {
+                    status: GatedTransactionStatus.DENIED,
+                },
             },
+            lastCheckResult: initialCheckResult,
         };
     }
 
     //send the tx
     try {
-        const processed = await processTx(gatedTx.transaction);
+        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);
+        const submittedTransaction = { ...underlying, result: processResult };
         const finalCheckResult = await checkGatedTransaction({
             registry: activityRegistry,
             gatedTransaction: gatedTx,
-            processedTransaction: processed,
+            submittedTransaction,
         });
 
         await cache?.cacheSuccessfulTxCheckData?.(gatedTx, finalCheckResult.onChainData);
@@ -175,11 +240,14 @@ const resolveGatedTransaction = async <
         if (finalCheckResult.expectationMet) {
             //sent and successful
             return {
-                ...gatedTx,
-                result: {
-                    status: GatedTransactionStatus.SUCCESS,
-                    submittedTransaction: processed,
+                resolvedGatedTransaction: {
+                    ...baseGatedTx,
+                    result: {
+                        status: GatedTransactionStatus.SUCCESS,
+                        submittedTransaction,
+                    },
                 },
+                lastCheckResult: finalCheckResult,
             };
         } else {
             //sent and unsuccessful
@@ -189,31 +257,36 @@ const resolveGatedTransaction = async <
                 `Gated transaction ${gatedTx.name} final check failed:\nExpected result ${stringify(gatedTx.check.expectedResult.comparisonValue)}, but got:\n${stringify(finalCheckResult.onChainData)}`,
             );
             return {
-                ...gatedTx,
-                result: {
-                    status: GatedTransactionStatus.FINAL_CHECK_FAILED,
-                    submittedTransaction: processed,
-                    finalOnChainState: finalCheckResult.onChainData,
+                resolvedGatedTransaction: {
+                    ...baseGatedTx,
+                    result: {
+                        status: GatedTransactionStatus.FINAL_CHECK_FAILED,
+                        submittedTransaction,
+                        finalOnChainState: finalCheckResult.onChainData,
+                    },
                 },
+                lastCheckResult: finalCheckResult,
             };
         }
     } catch (e) {
         //sent and failed
         return {
-            ...gatedTx,
-            result: {
-                status: GatedTransactionStatus.TRANSACTION_FAILED,
-                transactionError: e,
+            resolvedGatedTransaction: {
+                ...baseGatedTx,
+                result: {
+                    status: GatedTransactionStatus.TRANSACTION_FAILED,
+                    transactionError: e,
+                },
             },
+            lastCheckResult: initialCheckResult,
         };
     }
 };
 
 export const resolveGatedTransactions = async <
     TxType extends Transaction,
-    ProcessedTxType extends Transaction,
     GatedTx extends GatedTransaction<string, TxType, any>,
-    ProcessTx extends (transaction: TxType) => Promise<ProcessedTxType>,
+    ProcessTx extends (transaction: TxType) => Promise<TransactionResult>,
 >({
     activityRegistry,
     gatedTxes,
@@ -228,7 +301,7 @@ export const resolveGatedTransactions = async <
     fn: WorkflowFunctions;
     cache?: IGatedTransactionCache;
     userInteractionCallbacks?: UserInteractionCallbacks;
-}): Promise<(GatedTx & { result: GatedTransactionResult })[]> => {
+}): Promise<ResolvedGatedTransaction[]> => {
     //compute deps
     const allInternalIds = gatedTxes.map((tx) => getIdForGatedTransaction(tx));
     const allDeps = gatedTxes.flatMap((tx) => tx.dependencies ?? []);
@@ -238,8 +311,13 @@ export const resolveGatedTransactions = async <
 
     //prepopulate results for external dependencies
     //this map is only used for internal status tracking
-    //map id -> was successful
-    const results: Record<GatedTransactionId, boolean> = Object.fromEntries(
+    const results: Record<
+        GatedTransactionId,
+        {
+            resolved?: ResolvedGatedTransaction;
+            checkResult: { onChainData?: any; expectationMet: boolean };
+        }
+    > = Object.fromEntries(
         await Promise.all(
             allExternalDeps.map(async (tx) => {
                 const checkResult = await checkGatedTransaction({
@@ -248,18 +326,27 @@ export const resolveGatedTransactions = async <
                     cachedCheckResult: await cache?.getCachedTxCheckData?.(tx),
                 });
 
-                return [getIdForGatedTransaction(tx), checkResult.expectationMet];
+                return [
+                    getIdForGatedTransaction(tx),
+                    {
+                        checkResult,
+                    },
+                ];
             }),
         ),
     );
 
-    const isTransactionSuccessful = (gtxId: GatedTransactionId) => results[gtxId];
+    const getTransactionResult = (gtxId: GatedTransactionId) => results[gtxId];
 
     const txFunctions = gatedTxes.map((tx) => async () => {
-        const res = await resolveGatedTransaction<TxType, ProcessedTxType, GatedTx, ProcessTx>({
+        const { resolvedGatedTransaction, lastCheckResult } = await resolveGatedTransaction<
+            TxType,
+            GatedTx,
+            ProcessTx
+        >({
             gatedTx: tx,
             activityRegistry,
-            isTransactionSuccessful,
+            getTransactionResult,
             processTx,
             confirmationCallback:
                 userInteractionCallbacks?.confirmationCallback ?? (async () => true),
@@ -267,13 +354,20 @@ export const resolveGatedTransactions = async <
             cache,
         });
 
-        const resId = getIdForGatedTransaction(res);
-        results[resId] = [GatedTransactionStatus.SUCCESS, GatedTransactionStatus.NO_OP].includes(
-            res.result.status,
-        );
+        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?.(res);
-        return res;
+        userInteractionCallbacks?.onResultCallback?.(resolvedGatedTransaction);
+        return resolvedGatedTransaction;
     });
 
     return await Promise.all(txFunctions.map((func) => func()));
@@ -281,9 +375,8 @@ export const resolveGatedTransactions = async <
 
 export const resolveSequencedGatedTransactions = async <
     TxType extends Transaction,
-    ProcessedTxType extends Transaction,
     GatedTx extends GatedTransaction<string, TxType, any>,
-    ProcessTx extends (transaction: TxType) => Promise<ProcessedTxType>,
+    ProcessTx extends (transaction: TxType) => Promise<TransactionResult>,
 >({
     activityRegistry,
     gatedTxes,
@@ -301,7 +394,7 @@ export const resolveSequencedGatedTransactions = async <
 }) => {
     const results = [];
     for (const seq of gatedTxes) {
-        const result = await resolveGatedTransactions<TxType, ProcessedTxType, GatedTx, ProcessTx>({
+        const result = await resolveGatedTransactions<TxType, GatedTx, ProcessTx>({
             gatedTxes: seq,
             activityRegistry,
             processTx,

package/src/types.ts

@@ -1,11 +1,14 @@
 import z from 'zod/v4';
 
-import type {
-    Transaction,
-    transactionSchema as _transactionSchema,
+import {
+    type Transaction,
+    type transactionSchema as _transactionSchema,
+    type TransactionWithResultFor,
+    type transactionWithResultSchema as _transactionWithResultSchema,
 } from '@layerzerolabs/common-chain-model';
 import type { FunctionPointer } from '@layerzerolabs/common-utils';
-import { functionSchema } from '@layerzerolabs/zod-utils';
+import type { BuildTuple } from '@layerzerolabs/typescript-utils';
+import { customSchema, functionSchema } from '@layerzerolabs/zod-utils';
 
 export type OnChainDataComparisonOperator<OnChainDataType> = OnChainDataType extends number
     ? '<' | '<=' | '=' | '!=' | '>' | '>='
@@ -17,39 +20,19 @@ export type OnChainDataComparison<OnChainDataType> = {
 };
 
 export type GatedTransactionCheck<
-    Method extends (...args: any[]) => any = (...args: any[]) => unknown,
+    Method extends (...args: any[]) => Promise<any> = (...args: any[]) => Promise<unknown>,
 > = {
     functionPointer: FunctionPointer<Method>;
-    params: any[];
+    params: Parameters<Method>;
     expectedResult: OnChainDataComparison<Awaited<ReturnType<Method>>>;
 };
 
-export const gatedTransactionSchema = <TransactionSchema extends typeof _transactionSchema>({
-    transactionSchema,
-    name,
-}: {
-    transactionSchema: TransactionSchema;
-    name: z.ZodString | z.ZodLiteral<string>;
-}) =>
-    z.object({
-        name,
-        transaction: transactionSchema,
-        check: z.object({
-            functionPointer: z.any(),
-            params: z.array(z.any()),
-            expectedResult: z.object({
-                operator: z.custom<OnChainDataComparisonOperator<any>>(),
-                comparisonValue: z.any(),
-            }),
-        }),
-    });
-
 // Schema for gated transaction results
 export const gatedTransactionResultSchema = <
-    TransactionSchema extends typeof _transactionSchema,
+    TxWithResultSchema extends typeof _transactionWithResultSchema,
     OnchainDataSchema extends z.ZodType,
 >(
-    transactionSchema: TransactionSchema,
+    txWithResultSchema: TxWithResultSchema,
     onchainDataSchema: OnchainDataSchema,
 ) =>
     z.union([
@@ -58,7 +41,7 @@ export const gatedTransactionResultSchema = <
         }),
         z.object({
             status: z.literal(GatedTransactionStatus.SUCCESS),
-            submittedTransaction: transactionSchema,
+            submittedTransaction: txWithResultSchema,
         }),
         z.object({
             status: z.literal(GatedTransactionStatus.TRANSACTION_FAILED),
@@ -66,7 +49,7 @@ export const gatedTransactionResultSchema = <
         }),
         z.object({
             status: z.literal(GatedTransactionStatus.FINAL_CHECK_FAILED),
-            submittedTransaction: transactionSchema,
+            submittedTransaction: txWithResultSchema,
             finalOnChainState: onchainDataSchema,
         }),
         z.object({
@@ -77,55 +60,62 @@ export const gatedTransactionResultSchema = <
         }),
     ]);
 
-// Schema for processed gated transactions (with results)
-export const processedGatedTransactionSchema = <
-    TransactionSchema extends typeof _transactionSchema,
-    OnchainDataSchema extends z.ZodType,
->({
-    transactionSchema,
-    onchainDataSchema,
-    name,
-}: {
-    transactionSchema: TransactionSchema;
-    onchainDataSchema: OnchainDataSchema;
-    name: z.ZodString | z.ZodLiteral<string>;
-}) =>
-    gatedTransactionSchema({
-        transactionSchema,
-        name,
-    }).and(
-        z.object({
-            result: gatedTransactionResultSchema(transactionSchema, onchainDataSchema),
-        }),
-    );
-
-type GatedTransactionDependencies = GatedTransaction[];
+export type InferOnChainDataTypeFromCheck<Check> = Check extends (...args: any[]) => infer Ret
+    ? Awaited<Ret>
+    : unknown;
+export type InferOnChainDataTypeFromGatedTransaction<GatedTx extends GatedTransaction> =
+    InferOnChainDataTypeFromCheck<GatedTx['check']>;
 
-export type GatedTransaction<
+export type GatedTransactionDependencies = GatedTransaction[];
+export type BaseGatedTransaction<
     Name extends string = string,
-    TxType extends Transaction = Transaction,
     CheckMethod extends (...args: any[]) => any = (...args: any[]) => any,
-    Dependencies extends GatedTransactionDependencies = GatedTransactionDependencies,
+    _Dependencies extends GatedTransactionDependencies = GatedTransactionDependencies,
 > = {
-    bundleName?: string;
     name: Name;
-    transaction: TxType;
+    bundleName?: string;
+    chainName: string;
     check: GatedTransactionCheck<CheckMethod>;
+    dependencies: _Dependencies;
     cacheable?: boolean;
     uniqueIdKeys?: Record<string, string | number | boolean>;
-    dependencies?: Dependencies;
 };
 
-export type ProcessedGatedTransaction<
+export type LiteralGatedTransaction<
     Name extends string = string,
     TxType extends Transaction = Transaction,
     CheckMethod extends (...args: any[]) => any = (...args: any[]) => any,
-> = GatedTransaction<Name, TxType, CheckMethod> & {
-    result: GatedTransactionResult<GatedTransaction<Name, TxType, CheckMethod>, TxType>;
+    _Dependencies extends GatedTransactionDependencies = GatedTransactionDependencies,
+> = BaseGatedTransaction<Name, CheckMethod, _Dependencies> & {
+    transactionType: 'literal';
+    transaction: TxType;
 };
 
-export type InferOnChainDataTypeFromGatedTransaction<GatedTx extends GatedTransaction> =
-    GatedTx extends GatedTransaction<any, any, infer Check> ? Awaited<ReturnType<Check>> : unknown;
+export type FunctionalGatedTransaction<
+    Name extends string = string,
+    TxType extends Transaction = Transaction,
+    CheckMethod extends (...args: any[]) => any = (...args: any[]) => any,
+    DepMethod extends (txs: any) => Promise<TxType> = (txs: any) => Promise<any>,
+    _Dependencies extends GatedTransactionDependencies = GatedTransactionDependencies,
+> = BaseGatedTransaction<Name, CheckMethod, _Dependencies> & {
+    transactionType: 'functional';
+    getTransactionPointer: FunctionPointer<DepMethod>;
+};
+
+export type GatedTransaction<
+    Name extends string = string,
+    TxType extends Transaction = Transaction,
+    CheckMethod extends (...args: any[]) => any = (...args: any[]) => any,
+    DepMethod extends (txs: any) => Promise<TxType> = (txs: any) => Promise<any>,
+    _Dependencies extends GatedTransactionDependencies = GatedTransactionDependencies,
+> =
+    | LiteralGatedTransaction<Name, TxType, CheckMethod, _Dependencies>
+    | FunctionalGatedTransaction<Name, TxType, CheckMethod, DepMethod, _Dependencies>;
+
+export type BaseGatedTransactionFor<GatedTx extends GatedTransaction> =
+    GatedTx extends GatedTransaction<infer Name, any, infer CheckMethod, any, infer _Dependencies>
+        ? BaseGatedTransaction<Name, CheckMethod, _Dependencies>
+        : never;
 
 export enum GatedTransactionStatus {
     NO_OP = 'no_op',
@@ -140,9 +130,9 @@ type NoOpGatedTransaction = {
     status: GatedTransactionStatus.NO_OP;
 };
 
-type SuccessfulGatedTransaction<ProcessedTx extends Transaction> = {
+type SuccessfulGatedTransaction<TxType extends Transaction> = {
     status: GatedTransactionStatus.SUCCESS;
-    submittedTransaction: ProcessedTx;
+    submittedTransaction: TransactionWithResultFor<TxType>;
 };
 
 type TxFailedGatedTransaction = {
@@ -150,10 +140,10 @@ type TxFailedGatedTransaction = {
     transactionError: any;
 };
 
-type CheckFailedGatedTransaction<ProcessedTx extends Transaction, State> = {
+type CheckFailedGatedTransaction<GatedTx extends GatedTransaction, TxType extends Transaction> = {
     status: GatedTransactionStatus.FINAL_CHECK_FAILED;
-    submittedTransaction: ProcessedTx;
-    finalOnChainState: State;
+    submittedTransaction: TransactionWithResultFor<TxType>;
+    finalOnChainState: InferOnChainDataTypeFromGatedTransaction<GatedTx>;
 };
 
 type DependencyFailedGatedTransaction = {
@@ -166,15 +156,12 @@ type DeniedGatedTransaction = {
 
 export type GatedTransactionResult<
     GatedTx extends GatedTransaction = GatedTransaction,
-    ProcessedTxType extends Transaction = Transaction,
+    TxType extends Transaction = Transaction,
 > =
     | NoOpGatedTransaction
-    | SuccessfulGatedTransaction<ProcessedTxType>
+    | SuccessfulGatedTransaction<TxType>
     | TxFailedGatedTransaction
-    | CheckFailedGatedTransaction<
-          ProcessedTxType,
-          InferOnChainDataTypeFromGatedTransaction<GatedTx>
-      >
+    | CheckFailedGatedTransaction<GatedTx, TxType>
     | DependencyFailedGatedTransaction
     | DeniedGatedTransaction;
 
@@ -207,7 +194,78 @@ export type IGatedTransactionCache = z.infer<typeof gatedTransactionCacheSchema>
  */
 export type GatedTransactionId = `${string}-${string}-${string}`;
 
+export type ResolvedGatedTransaction<
+    GatedTx extends GatedTransaction = GatedTransaction,
+    TxType extends Transaction = Transaction,
+> = BaseGatedTransactionFor<GatedTx> & {
+    result: GatedTransactionResult<GatedTx, TxType>;
+};
+
 export type UserInteractionCallbacks = {
     confirmationCallback?: (gtx: GatedTransaction) => Promise<boolean>;
-    onResultCallback?: (result: GatedTransaction & { result: GatedTransactionResult }) => void;
+    onResultCallback?: (result: ResolvedGatedTransaction) => void;
 };
+
+export const gatedTransactionSchema = <
+    Name extends z.ZodString | z.ZodLiteral<string> = z.ZodString,
+    TransactionSchema extends typeof _transactionSchema = typeof _transactionSchema,
+>(_?: {
+    name?: Name;
+    transactionSchema?: TransactionSchema;
+}) => customSchema<GatedTransaction<z.infer<Name>, z.infer<TransactionSchema>>>();
+
+export const resolvedGatedTransactionSchema = <
+    Name extends z.ZodString | z.ZodLiteral<string> = z.ZodString,
+    TransactionSchema extends typeof _transactionSchema = typeof _transactionSchema,
+>(_?: {
+    name?: Name;
+    transactionSchema?: TransactionSchema;
+}) =>
+    customSchema<
+        ResolvedGatedTransaction<
+            GatedTransaction<z.infer<Name>, z.infer<TransactionSchema>>,
+            z.infer<TransactionSchema>
+        >
+    >();
+
+/**
+ * Builds a schema for an activity that builds a transaction based on the results of other transactions
+ * @param transactionSchema The schema for the transaction to be built
+ * @param transactionWithResultSchema The schema for the results of the transactions you're building off of
+ * @param txNumber The number of transactions you're building off of
+ * @returns A schema for the activity that builds the transaction
+ */
+export const createTxDependentActivitySchema = <
+    TransactionSchema extends typeof _transactionSchema = typeof _transactionSchema,
+    const TxNumber extends number = 1,
+>(
+    transactionSchema: TransactionSchema,
+    txNumber: TxNumber,
+) => {
+    const txs = Array.from({ length: txNumber }, () =>
+        resolvedGatedTransactionSchema({
+            name: z.string(),
+            transactionSchema: transactionSchema,
+        }),
+    );
+    return functionSchema({
+        input: z.tuple([z.tuple(txs as any)]),
+        output: z.promise(transactionSchema),
+    }) as z.ZodType<
+        (
+            txs: BuildTuple<
+                ResolvedGatedTransaction<
+                    GatedTransaction<string, z.infer<TransactionSchema>, any, any, any>
+                >,
+                TxNumber
+            >,
+        ) => Promise<z.infer<TransactionSchema>>
+    >;
+};
+
+export type ResolvedGatedTransactionDependencies<GatedTx extends GatedTransaction> =
+    GatedTx extends GatedTransaction<any, any, any, any, infer _Dependencies>
+        ? {
+              [K in keyof _Dependencies]?: ResolvedGatedTransaction<_Dependencies[K]>;
+          }
+        : never;