@layerzerolabs/gated-transaction 0.2.67 → 0.2.69

package/src/gatedTx.ts

@@ -1,135 +0,0 @@
-import type { Transaction, TransactionWithResult } from '@layerzerolabs/common-chain-model';
-import type { FunctionPointer } from '@layerzerolabs/function-pointer';
-
-import type {
-    BaseGatedTransaction,
-    ContractArtifactPointers,
-    FunctionalGatedTransaction,
-    GatedTransactionBundleId,
-    GatedTransactionDependencies,
-    GatedTransactionId,
-    LiteralGatedTransaction,
-    OnChainDataComparison,
-    ResolvedGatedTransaction,
-} from './schemata';
-
-/**
- * Builds a {@link GatedTransaction}
- */
-export const constructGatedTransaction = <
-    const Name extends string,
-    TxType extends Transaction,
-    CheckOutput extends Promise<any>,
-    _Dependencies extends GatedTransactionDependencies,
->(gtx: {
-    name: Name;
-    description?: string;
-    chainName: string;
-    bundleName?: string;
-    metadata?: {
-        deployInfo?: {
-            contracts: { [contractName: string]: ContractArtifactPointers };
-            alwaysResolve?: boolean;
-        };
-    };
-    check: {
-        functionPointer: FunctionPointer<[tx?: TransactionWithResult], CheckOutput>;
-        expectedResult: OnChainDataComparison<Awaited<CheckOutput>>;
-    };
-    uniqueIdKeys?: Record<string, string | number | boolean>;
-    cacheable?: boolean;
-    dependencies?: _Dependencies;
-    orderingDependencies?: GatedTransactionDependencies;
-    transaction: TxType;
-}): LiteralGatedTransaction<Name, TxType, CheckOutput, _Dependencies> => {
-    const dependencies = gtx.dependencies ?? ([] as any);
-    return { ...gtx, transactionType: 'literal', dependencies };
-};
-
-type BuildDeps<Params extends ResolvedGatedTransaction[]> = Params extends []
-    ? []
-    : Params extends readonly [
-            ResolvedGatedTransaction<infer Gtx>,
-            ...infer Rest extends ResolvedGatedTransaction[],
-        ]
-      ? [Gtx, ...BuildDeps<[...Rest]>]
-      : Params extends Array<ResolvedGatedTransaction<infer Gtx>>
-        ? Array<Gtx>
-        : never;
-
-/**
- * Builds a {@link GatedTransaction} from a pointer
- */
-export const constructGatedTransactionFromPointer = <
-    const Name extends string,
-    TxType extends Transaction,
-    CheckOutput extends Promise<any>,
-    DepInput extends [...args: any[], txes: any],
->(gtx: {
-    name: Name;
-    description?: string;
-    chainName: string;
-    bundleName?: string;
-    metadata?: {
-        deployInfo?: {
-            contracts: { [contractName: string]: ContractArtifactPointers };
-            alwaysResolve?: boolean;
-        };
-    };
-    check: {
-        functionPointer: FunctionPointer<[tx?: TransactionWithResult], CheckOutput>;
-        expectedResult: OnChainDataComparison<Awaited<CheckOutput>>;
-    };
-    uniqueIdKeys?: Record<string, string | number | boolean>;
-    cacheable?: boolean;
-    dependencies: BuildDeps<
-        DepInput extends [...any, infer Tail extends readonly ResolvedGatedTransaction[]]
-            ? Tail
-            : DepInput extends [...infer Tail extends readonly ResolvedGatedTransaction[]]
-              ? Tail
-              : never
-    >;
-    orderingDependencies?: GatedTransactionDependencies;
-    getTransaction: {
-        functionPointer: FunctionPointer<DepInput, Promise<TxType>>;
-    };
-}): FunctionalGatedTransaction<
-    Name,
-    TxType,
-    CheckOutput,
-    DepInput,
-    BuildDeps<
-        DepInput extends [...any, infer Tail extends readonly ResolvedGatedTransaction[]]
-            ? Tail
-            : DepInput extends [...infer Tail extends readonly ResolvedGatedTransaction[]]
-              ? Tail
-              : never
-    >
-> => {
-    return {
-        ...gtx,
-        transactionType: 'functional',
-    };
-};
-
-export const getIdForGatedTransaction = (gtx: BaseGatedTransaction): GatedTransactionId => {
-    const serializedUniqueIdKeys = gtx.uniqueIdKeys
-        ? Object.entries(gtx.uniqueIdKeys)
-              .map(([k, v]) => `${k}:${v}`)
-              .join('-')
-        : '';
-
-    return `${gtx.name}-${gtx.chainName}-${serializedUniqueIdKeys}`;
-};
-
-export const getBundleIdForGatedTransaction = (
-    gtx: BaseGatedTransaction,
-): GatedTransactionBundleId => {
-    const serializedUniqueIdKeys = gtx.uniqueIdKeys
-        ? Object.entries(gtx.uniqueIdKeys)
-              .map(([k, v]) => `${k}:${v}`)
-              .join('-')
-        : '';
-
-    return `${gtx.bundleName}-${gtx.chainName}-${serializedUniqueIdKeys}`;
-};

package/src/index.ts

@@ -1,2 +0,0 @@
-export * from './gatedTx';
-export * from './schemata';

package/src/schemata.ts

@@ -1,471 +0,0 @@
-import z from 'zod';
-
-import type {
-    transactionSchema as _transactionSchema,
-    TransactionWithResult,
-} from '@layerzerolabs/common-chain-model';
-import {
-    type Transaction,
-    type TransactionWithResultFor,
-    transactionWithResultSchema as _transactionWithResultSchema,
-} from '@layerzerolabs/common-chain-model';
-import type { FunctionPointer } from '@layerzerolabs/function-pointer';
-import type {
-    BrandedError,
-    BuildTuple,
-    DecimalString,
-    IsAny,
-    Or,
-} from '@layerzerolabs/typescript-utils';
-import type { InferredArray } from '@layerzerolabs/zod-utils';
-import { customSchema, functionSchema } from '@layerzerolabs/zod-utils';
-
-export type OnChainDataComparisonOperator<OnChainDataType> =
-    Or<
-        [OnChainDataType extends number | DecimalString ? true : false, IsAny<OnChainDataType>]
-    > extends true
-        ? '<' | '<=' | '=' | '!=' | '>' | '>='
-        : OnChainDataType extends string | object | boolean
-          ? '=' | '!='
-          : BrandedError<'Unsupported comparison type'>;
-
-export type OnChainDataComparison<OnChainDataType extends string | number | boolean | object> = {
-    operator: OnChainDataComparisonOperator<OnChainDataType>;
-    comparisonValue: OnChainDataType;
-};
-
-export type GatedTransactionCheck<CheckOutput extends Promise<any> = Promise<any>> = {
-    functionPointer: FunctionPointer<[tx?: TransactionWithResult], CheckOutput>;
-    expectedResult: OnChainDataComparison<Awaited<CheckOutput>>;
-};
-
-// Schema for gated transaction results
-export const gatedTransactionResultSchema = <
-    TxWithResultSchema extends typeof _transactionWithResultSchema,
-    OnchainDataSchema extends z.ZodType,
->(
-    txWithResultSchema: TxWithResultSchema,
-    onchainDataSchema: OnchainDataSchema,
-) =>
-    // TODO: use this schema as source of truth for GatedTransactionResult type
-    z.union([
-        z.object({
-            status: z.literal(GatedTransactionStatus.NO_OP),
-        }),
-        z.object({
-            status: z.literal(GatedTransactionStatus.SUCCESS),
-            submittedTransaction: txWithResultSchema,
-        }),
-        z.object({
-            status: z.literal(GatedTransactionStatus.TRANSACTION_FAILED),
-            transactionError: z.any(),
-        }),
-        z.object({
-            status: z.literal(GatedTransactionStatus.FINAL_CHECK_FAILED),
-            submittedTransaction: txWithResultSchema,
-            finalOnChainState: onchainDataSchema,
-        }),
-        z.object({
-            status: z.literal(GatedTransactionStatus.DEPENDENCY_FAILED),
-        }),
-        z.object({
-            status: z.literal(GatedTransactionStatus.DENIED),
-        }),
-        z.object({
-            status: z.literal(GatedTransactionStatus.DEFERRED_SUCCESS),
-        }),
-    ]);
-
-export type InferOnChainDataTypeFromCheck<Check> = Check extends (...args: any[]) => infer Ret
-    ? Awaited<Ret>
-    : unknown;
-export type InferOnChainDataTypeFromGatedTransaction<GatedTx extends GatedTransaction> =
-    InferOnChainDataTypeFromCheck<GatedTx['check']>;
-
-export type GatedTransactionDependencies = GatedTransaction[];
-
-/**
- * Pointer configuration for extracting a deployment artifact from a resolved GTX.
- * - FunctionPointer: Custom pointer to activity factory function
- * - 'DEFAULT': Use the default deployment activity factory function
- * - null: Don't save this artifact
- */
-export type DeploymentArtifactPointer = FunctionPointer | 'DEFAULT' | null;
-
-/**
- * Pointer configuration for extracting a verification artifact from a resolved GTX.
- * - FunctionPointer: Custom pointer to activity factory function
- * - null: Don't save this artifact
- * Note: No 'DEFAULT' option - verification requires custom implementation per contract type.
- */
-export type VerificationArtifactPointer = FunctionPointer | null;
-
-// TODO: type FunctionPointer generics on DeploymentArtifactPointer/VerificationArtifactPointer (at least output types), consider converting ContractArtifactPointers to interface
-export type ContractArtifactPointers = {
-    extractDeploymentArtifactPointer: DeploymentArtifactPointer;
-    extractVerificationArtifactPointer: VerificationArtifactPointer;
-};
-
-export type BaseGatedTransaction<
-    Name extends string = string,
-    CheckOutput extends Promise<any> = Promise<any>,
-    _Dependencies extends GatedTransactionDependencies = GatedTransactionDependencies,
-> = {
-    name: Name;
-    description?: string;
-    bundleName?: string;
-    metadata?: {
-        deployInfo?: {
-            contracts: { [contractName: string]: ContractArtifactPointers };
-            alwaysResolve?: boolean;
-        };
-    };
-    chainName: string;
-    check: GatedTransactionCheck<CheckOutput>;
-    dependencies: _Dependencies;
-    /**
-     * Ordering-only dependencies: this transaction must be executed after these transactions,
-     * but does not require their resolved output. If a transaction appears in both
-     * `dependencies` and `orderingDependencies`, the regular dependency semantics take precedence.
-     */
-    orderingDependencies?: GatedTransactionDependencies;
-    cacheable?: boolean;
-    uniqueIdKeys?: Record<string, string | number | boolean>;
-};
-
-export type LiteralGatedTransaction<
-    Name extends string = string,
-    TxType extends Transaction = Transaction,
-    CheckOutput extends Promise<any> = Promise<any>,
-    _Dependencies extends GatedTransactionDependencies = GatedTransactionDependencies,
-> = BaseGatedTransaction<Name, CheckOutput, _Dependencies> & {
-    transactionType: 'literal';
-    transaction: TxType;
-};
-
-export type FunctionalGatedTransaction<
-    Name extends string = string,
-    TxType extends Transaction = Transaction,
-    CheckOutput extends Promise<any> = Promise<any>,
-    DepInput extends [...args: any[], txes: any] = [txes: any],
-    _Dependencies extends GatedTransactionDependencies = GatedTransactionDependencies,
-> = BaseGatedTransaction<Name, CheckOutput, _Dependencies> & {
-    transactionType: 'functional';
-    getTransaction: {
-        functionPointer: FunctionPointer<DepInput, Promise<TxType>>;
-    };
-};
-
-export type GatedTransaction<
-    Name extends string = string,
-    TxType extends Transaction = Transaction,
-    CheckOutput extends Promise<any> = Promise<any>,
-    DepInput extends [...args: any[], txes: any] = [txes: any],
-    _Dependencies extends GatedTransactionDependencies = GatedTransactionDependencies,
-> =
-    | LiteralGatedTransaction<Name, TxType, CheckOutput, _Dependencies>
-    | FunctionalGatedTransaction<Name, TxType, CheckOutput, DepInput, _Dependencies>;
-
-export type BaseGatedTransactionFor<GatedTx extends GatedTransaction> =
-    GatedTx extends GatedTransaction<infer Name, any, infer CheckOutput, any, infer _Dependencies>
-        ? BaseGatedTransaction<Name, CheckOutput, _Dependencies>
-        : never;
-
-export enum GatedTransactionStatus {
-    // precheck passed, no need to send the tx
-    NO_OP = 'no_op',
-    // precheck failed, tx was sent, postcheck passed
-    SUCCESS = 'success',
-    // precheck failed, tx was sent but sender returned an error
-    TRANSACTION_FAILED = 'transaction_failed',
-    // precheck failed, tx was sent, postcheck failed
-    FINAL_CHECK_FAILED = 'final_check_failed',
-    // the tx couldn't be resolved because one of its dependencies resolved to a failed state
-    DEPENDENCY_FAILED = 'dependency_failed',
-    // approval to send the tx was explicitly denied
-    DENIED = 'denied',
-    // precheck failed, tx was sent but indeterminate, deferred execution passed on a recheck
-    DEFERRED_SUCCESS = 'deferred_success',
-}
-
-type NoOpGatedTransaction = {
-    status: GatedTransactionStatus.NO_OP;
-};
-
-export type SuccessfulGatedTransaction<TxType extends Transaction> = {
-    status: GatedTransactionStatus.SUCCESS;
-    submittedTransaction: TransactionWithResultFor<TxType>;
-};
-
-type TxFailedGatedTransaction = {
-    status: GatedTransactionStatus.TRANSACTION_FAILED;
-    transactionError: any;
-};
-
-type CheckFailedGatedTransaction<GatedTx extends GatedTransaction, TxType extends Transaction> = {
-    status: GatedTransactionStatus.FINAL_CHECK_FAILED;
-    submittedTransaction: TransactionWithResultFor<TxType>;
-    finalOnChainState: InferOnChainDataTypeFromGatedTransaction<GatedTx>;
-};
-
-type DependencyFailedGatedTransaction = {
-    status: GatedTransactionStatus.DEPENDENCY_FAILED;
-};
-
-type DeniedGatedTransaction = {
-    status: GatedTransactionStatus.DENIED;
-};
-
-type DeferredSuccessfulGatedTransaction = {
-    status: GatedTransactionStatus.DEFERRED_SUCCESS;
-};
-
-export type GatedTransactionResult<
-    GatedTx extends GatedTransaction = GatedTransaction,
-    TxType extends Transaction = Transaction,
-> =
-    | NoOpGatedTransaction
-    | SuccessfulGatedTransaction<TxType>
-    | TxFailedGatedTransaction
-    | CheckFailedGatedTransaction<GatedTx, TxType>
-    | DependencyFailedGatedTransaction
-    | DeniedGatedTransaction
-    | DeferredSuccessfulGatedTransaction;
-
-export type ResolvedGatedTransaction<
-    GatedTx extends GatedTransaction = GatedTransaction,
-    TxType extends Transaction = Transaction,
-> = BaseGatedTransactionFor<GatedTx> & {
-    result: GatedTransactionResult<GatedTx, TxType>;
-};
-
-export const isResolvedGtx = (
-    gtx: GatedTransaction | ResolvedGatedTransaction,
-): gtx is ResolvedGatedTransaction => !!(gtx as ResolvedGatedTransaction).result;
-
-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>>>().meta({
-        title: 'Gated Transaction',
-        description: 'A schema for a gated transaction',
-    });
-
-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>
-        >
-    >().meta({
-        title: 'Resolved Gated Transaction',
-        description: 'A schema for a resolved gated transaction',
-    });
-
-export const successfulGatedTransactionSchema = <
-    Name extends z.ZodString | z.ZodLiteral<string> = z.ZodString,
-    TransactionSchema extends typeof _transactionSchema = typeof _transactionSchema,
->(_?: {
-    name?: Name;
-    transactionSchema?: TransactionSchema;
-}) =>
-    customSchema<
-        BaseGatedTransactionFor<GatedTransaction<z.infer<Name>, z.infer<TransactionSchema>>> & {
-            result: SuccessfulGatedTransaction<z.infer<TransactionSchema>>;
-        }
-    >().meta({
-        title: 'Successful Gated Transaction',
-        description: 'A schema for a successful gated transaction',
-    });
-
-/**
- * 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
- * @param extraArgs Additional arguments that must be passed to the function after the txes
- * @returns A schema for the activity that builds the transaction
- */
-export const createTxArrayDependentActivitySchema = <
-    TransactionSchema extends typeof _transactionSchema = typeof _transactionSchema,
-    ExtraArgs extends z.ZodTuple = z.ZodTuple<[]>,
->(
-    transactionSchema: TransactionSchema,
-    extraArgs?: ExtraArgs,
-) => {
-    return functionSchema({
-        input: z.tuple([
-            ...(extraArgs?.def?.items ?? []),
-            z.array(
-                resolvedGatedTransactionSchema({
-                    transactionSchema,
-                }),
-            ),
-        ] as any),
-        output: z.promise(transactionSchema),
-    }) as unknown as z.ZodType<
-        [] extends z.infer<ExtraArgs>
-            ? (
-                  txs: ResolvedGatedTransaction<
-                      GatedTransaction<string, z.infer<TransactionSchema>>
-                  >[],
-              ) => Promise<z.infer<TransactionSchema>>
-            : (
-                  ...args: [
-                      ...extraArgs: z.infer<ExtraArgs>,
-                      txs: ResolvedGatedTransaction<
-                          GatedTransaction<string, z.infer<TransactionSchema>>
-                      >[],
-                  ]
-              ) => Promise<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
- * @param extraArgs Additional arguments that must be passed to the function after the txes
- * @returns A schema for the activity that builds the transaction
- */
-export const createTxTupleDependentActivitySchema = <
-    TransactionSchema extends typeof _transactionSchema = typeof _transactionSchema,
-    const TxNumber extends number = 1,
-    ExtraArgs extends z.ZodTuple = z.ZodTuple<[]>,
->(
-    transactionSchema: TransactionSchema,
-    txNumber: TxNumber,
-    extraArgs?: ExtraArgs,
-) => {
-    const txs = Array.from({ length: txNumber }, () =>
-        resolvedGatedTransactionSchema({
-            transactionSchema: transactionSchema,
-        }),
-    );
-
-    return functionSchema({
-        input: z.tuple([...(extraArgs?.def?.items ?? []), z.tuple(txs as any)] as any),
-        output: z.promise(transactionSchema),
-    }) as unknown as z.ZodType<
-        [] extends z.infer<ExtraArgs>
-            ? (
-                  txs: BuildTuple<
-                      ResolvedGatedTransaction<
-                          GatedTransaction<string, z.infer<TransactionSchema>>
-                      >,
-                      TxNumber
-                  >,
-              ) => Promise<z.infer<TransactionSchema>>
-            : (
-                  ...args: [
-                      ...extraArgs: z.infer<ExtraArgs>,
-                      txs: BuildTuple<
-                          ResolvedGatedTransaction<
-                              GatedTransaction<string, z.infer<TransactionSchema>>
-                          >,
-                          TxNumber
-                      >,
-                  ]
-              ) => Promise<z.infer<TransactionSchema>>
-    >;
-};
-
-export const createGatedTxCheckActivitySchema = <
-    Output extends z.ZodType,
-    const Input extends z.ZodType[] = [],
-    TransactionWithResultSchema extends
-        typeof _transactionWithResultSchema = typeof _transactionWithResultSchema,
->({
-    input,
-    output,
-    transactionWithResultSchema,
-}: {
-    input?: Input;
-    transactionWithResultSchema?: TransactionWithResultSchema;
-    output: Output;
-}) => {
-    const txWithResultSchema = (
-        transactionWithResultSchema ?? _transactionWithResultSchema
-    ).optional();
-
-    return functionSchema({
-        input: z.tuple([...(input ?? []), txWithResultSchema] as any),
-        output: z.promise(output),
-    }) as z.ZodType<
-        (
-            ...args: [...InferredArray<Input>, z.infer<TransactionWithResultSchema>?]
-        ) => Promise<z.infer<Output>>
-    >;
-};
-
-export type ResolvedGatedTransactionDependencies<GatedTx extends GatedTransaction> =
-    GatedTx extends GatedTransaction<any, any, any, any, infer _Dependencies>
-        ? {
-              [K in keyof _Dependencies]?: ResolvedGatedTransaction<_Dependencies[K]>;
-          }
-        : never;
-
-export interface GatedTxCheckResult {
-    expectationMet: boolean;
-    data: unknown;
-}
-
-export const gatedTxCheckResultSchema = z.object({
-    expectationMet: z.boolean(),
-    data: z.any(),
-});
-
-export const isSuccessfulGatedTransaction = <
-    GatedTx extends GatedTransaction,
-    TxType extends Transaction,
->(
-    gtx: ResolvedGatedTransaction<GatedTx, TxType>,
-): gtx is BaseGatedTransactionFor<GatedTx> & { result: SuccessfulGatedTransaction<TxType> } => {
-    return gtx.result.status === GatedTransactionStatus.SUCCESS;
-};
-
-export const gatedTransactionCacheSchema = z.object({
-    getCachedTxCheckData: functionSchema({
-        input: z.tuple([z.any()]),
-        output: z.promise(z.any()),
-    }) as z.ZodType<
-        <GatedTx extends GatedTransaction>(
-            gtx: GatedTx,
-        ) => Promise<InferOnChainDataTypeFromGatedTransaction<GatedTx> | undefined>
-    >,
-    cacheSuccessfulTxCheckData: functionSchema({
-        input: z.tuple([z.any(), z.any()]),
-        output: z.promise(z.any()),
-    }) as z.ZodType<
-        <GatedTx extends GatedTransaction>(
-            gtx: GatedTx,
-            data: InferOnChainDataTypeFromGatedTransaction<GatedTx>,
-        ) => Promise<void>
-    >,
-});
-
-export type IGatedTransactionCache = z.infer<typeof gatedTransactionCacheSchema>;
-
-/**
- * name-chain-uniqueIdKeys
- *
- * E.g., setDelegate-ethereum-oAppAddress:0xMY_OAPP
- */
-export type GatedTransactionId = `${string}-${string}-${string}`;
-
-/**
- * bundleName-chain-uniqueIdKeys
- *
- * E.g., SetPeer-ton-oAppAddress:0xMY_OAPP
- */
-export type GatedTransactionBundleId = `${string}-${string}-${string}`;

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-    "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/**/*"]
-}

package/tsup.config.ts

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