@layerzerolabs/dw-model 0.2.68 → 0.2.69

package/src/role-management/schemata.ts

@@ -1,180 +0,0 @@
-import { z } from 'zod';
-
-import { normalizedHexSchema, transactionSchema } from '@layerzerolabs/common-chain-model';
-import { gatedTransactionSchema } from '@layerzerolabs/gated-transaction';
-import { functionSchema } from '@layerzerolabs/zod-utils';
-
-export const generateCreateSetRoleTransactionsSchema = <
-    const T extends readonly [string, ...string[]],
->(
-    roles: T,
-) =>
-    functionSchema({
-        input: z.tuple([
-            z.object({
-                role: z.enum(roles),
-                accountAddress: normalizedHexSchema,
-                shouldGrant: z.boolean(),
-            }),
-        ]),
-        output: z.promise(
-            gatedTransactionSchema({
-                name: z.string(),
-                transactionSchema: transactionSchema,
-            }).array(),
-        ),
-    });
-
-export const generateHasRoleSchema = <const T extends readonly [string, ...string[]]>(roles: T) =>
-    functionSchema({
-        input: z.tuple([
-            z.object({
-                role: z.enum(roles),
-                accountAddress: normalizedHexSchema,
-            }),
-        ]),
-        output: z.promise(z.boolean()),
-    });
-
-export const generateGetRoleMembersSchema = <const T extends readonly [string, ...string[]]>(
-    roles: T,
-) =>
-    functionSchema({
-        input: z.tuple([
-            z.object({
-                role: z.enum(roles),
-            }),
-        ]),
-        output: z.promise(z.array(normalizedHexSchema)),
-    });
-
-export const generateRoleManagementSchemas = <const T extends readonly [string, ...string[]]>(
-    roles: T,
-) => ({
-    createSetRoleTransactions: generateCreateSetRoleTransactionsSchema(roles),
-    hasRole: generateHasRoleSchema(roles),
-});
-
-export const generateEnumerableRoleManagementSchemas = <
-    const T extends readonly [string, ...string[]],
->(
-    roles: T,
-) => ({
-    ...generateRoleManagementSchemas(roles),
-    getRoleMembers: generateGetRoleMembersSchema(roles),
-});
-
-export const createSetRoleTransactionsWithSpecializedInputSchema = functionSchema({
-    input: z.tuple([
-        z.object({
-            address: normalizedHexSchema,
-        }),
-        z.object({
-            role: z.string(),
-            accountAddress: normalizedHexSchema,
-            shouldGrant: z.boolean(),
-        }),
-    ]),
-    output: z.promise(
-        gatedTransactionSchema({
-            name: z.string(),
-            transactionSchema: transactionSchema,
-        }).array(),
-    ),
-});
-
-export const hasRoleWithSpecializedInputSchema = functionSchema({
-    input: z.tuple([
-        z.object({
-            address: normalizedHexSchema,
-        }),
-        z.object({
-            role: z.string(),
-            accountAddress: normalizedHexSchema,
-        }),
-    ]),
-    output: z.promise(z.boolean()),
-});
-
-export const getRoleMembersWithSpecializedInputSchema = functionSchema({
-    input: z.tuple([
-        z.object({
-            address: normalizedHexSchema,
-        }),
-        z.object({
-            role: z.string(),
-        }),
-    ]),
-    output: z.promise(z.array(normalizedHexSchema)),
-});
-
-export type CreateSetRoleTransactionsWithSpecializedInput = z.infer<
-    typeof createSetRoleTransactionsWithSpecializedInputSchema
->;
-export type HasRoleWithSpecializedInput = z.infer<typeof hasRoleWithSpecializedInputSchema>;
-export type GetRoleMembersWithSpecializedInput = z.infer<
-    typeof getRoleMembersWithSpecializedInputSchema
->;
-
-// ---------------------------------------------------------------------------
-// Admin 2-step transfer schemas
-// ---------------------------------------------------------------------------
-
-const admin2StepTransactionOutputSchema = z.promise(
-    gatedTransactionSchema({
-        name: z.string(),
-        transactionSchema: transactionSchema,
-    }).array(),
-);
-
-export const getPendingAdminSchema = functionSchema({
-    input: z.tuple([]),
-    output: z.promise(normalizedHexSchema),
-});
-
-export const createBeginAdminTransferTransactionsSchema = functionSchema({
-    input: z.tuple([z.object({ newAdmin: normalizedHexSchema })]),
-    output: admin2StepTransactionOutputSchema,
-});
-
-export const createAcceptAdminTransferTransactionsSchema = functionSchema({
-    input: z.tuple([z.object({ newAdmin: normalizedHexSchema })]),
-    output: admin2StepTransactionOutputSchema,
-});
-
-export const generateAdmin2StepSchemas = () => ({
-    getPendingAdmin: getPendingAdminSchema,
-    createBeginAdminTransferTransactions: createBeginAdminTransferTransactionsSchema,
-    createAcceptAdminTransferTransactions: createAcceptAdminTransferTransactionsSchema,
-});
-
-export const getPendingAdminWithSpecializedInputSchema = functionSchema({
-    input: z.tuple([z.object({ address: normalizedHexSchema })]),
-    output: z.promise(normalizedHexSchema),
-});
-
-export const createBeginAdminTransferTransactionsWithSpecializedInputSchema = functionSchema({
-    input: z.tuple([
-        z.object({ address: normalizedHexSchema }),
-        z.object({ newAdmin: normalizedHexSchema }),
-    ]),
-    output: admin2StepTransactionOutputSchema,
-});
-
-export const createAcceptAdminTransferTransactionsWithSpecializedInputSchema = functionSchema({
-    input: z.tuple([
-        z.object({ address: normalizedHexSchema }),
-        z.object({ newAdmin: normalizedHexSchema }),
-    ]),
-    output: admin2StepTransactionOutputSchema,
-});
-
-export type GetPendingAdminWithSpecializedInput = z.infer<
-    typeof getPendingAdminWithSpecializedInputSchema
->;
-export type CreateBeginAdminTransferTransactionsWithSpecializedInput = z.infer<
-    typeof createBeginAdminTransferTransactionsWithSpecializedInputSchema
->;
-export type CreateAcceptAdminTransferTransactionsWithSpecializedInput = z.infer<
-    typeof createAcceptAdminTransferTransactionsWithSpecializedInputSchema
->;

package/src/role-management/types.ts

@@ -1,5 +0,0 @@
-export enum BaseContractRole {
-    OWNER = 'OWNER_ROLE',
-    ADMIN = 'ADMIN_ROLE',
-    DEFAULT_ADMIN = 'DEFAULT_ADMIN_ROLE',
-}

package/src/upgrade/index.ts

@@ -1 +0,0 @@
-export * from './types';

package/src/upgrade/types.ts

@@ -1,159 +0,0 @@
-import z from 'zod';
-
-import { decimalStringSchema, hexSchema } from '@layerzerolabs/common-chain-model';
-import { assertUnreachable, NonRetryableError } from '@layerzerolabs/common-error-utils';
-import type { Identity } from '@layerzerolabs/typescript-utils';
-
-/**
- * `InitializeDataResult` schema.
- */
-export const initializeDataResultSchema = z.object({
-    /** Encoded initialization data (e.g., encodeFunctionData for initialize(...)) */
-    data: hexSchema,
-    /** Optional gas limit override for the initialization transaction */
-    gasLimit: decimalStringSchema.optional(),
-});
-
-export interface InitializeDataResult
-    extends Identity<z.infer<typeof initializeDataResultSchema>> {}
-
-export enum UpgradeType {
-    // This doesn't necessarily prevent the contract from being upgraded
-    NOT_UPGRADEABLE = 'NOT_UPGRADEABLE',
-    // Deploy a separate 'proxy' contract that will route calls to a swappable implementation
-    PROXY = 'PROXY',
-    // This doesn't necessarily allow the contract to be upgraded
-    CODE_UPGRADE = 'CODE_UPGRADE',
-}
-
-export enum EvmProxyType {
-    // TUP v5 https://docs.openzeppelin.com/contracts/5.x/api/proxy#transparentupgradeableproxy
-    TRANSPARENT_UPGRADEABLE_V5 = 'TRANSPARENT_UPGRADEABLE_V5',
-    // UUPS v5 https://docs.openzeppelin.com/contracts/5.x/api/proxy#uupsupgradeable
-    UNIVERSAL_UPGRADEABLE_V5 = 'UNIVERSAL_UPGRADEABLE_V5',
-    // OTUP v4 https://github.com/wighawag/hardhat-deploy/blob/v0.12.1/solc_0.8/proxy/OptimizedTransparentUpgradeableProxy.sol
-    OPTIMIZED_TRANSPARENT_UPGRADEABLE_V4 = 'OPTIMIZED_TRANSPARENT_UPGRADEABLE_V4',
-    // TUP v4 https://docs.openzeppelin.com/contracts/4.x/api/proxy#TransparentUpgradeableProxy
-    TRANSPARENT_UPGRADEABLE_V4 = 'TRANSPARENT_UPGRADEABLE_V4',
-    // UUPS v4 https://docs.openzeppelin.com/contracts/4.x/api/proxy#UUPSUpgradeable
-    UNIVERSAL_UPGRADEABLE_V4 = 'UNIVERSAL_UPGRADEABLE_V4',
-}
-
-/** UUPS-based proxy types (no separate `ProxyAdmin`). */
-export const UUPS_PROXY_TYPES: ReadonlySet<EvmProxyType> = new Set([
-    EvmProxyType.UNIVERSAL_UPGRADEABLE_V4,
-    EvmProxyType.UNIVERSAL_UPGRADEABLE_V5,
-]);
-
-/** TUP-based proxy types (have a `ProxyAdmin` with `getOwner`/`setOwner`). */
-export const TUP_PROXY_TYPES: ReadonlySet<EvmProxyType> = new Set([
-    EvmProxyType.TRANSPARENT_UPGRADEABLE_V4,
-    EvmProxyType.TRANSPARENT_UPGRADEABLE_V5,
-    EvmProxyType.OPTIMIZED_TRANSPARENT_UPGRADEABLE_V4,
-]);
-
-/** Proxy types that deploy a separate `ProxyAdmin` contract (v4 variants only). */
-export const SEPARATE_PROXY_ADMIN_TYPES: ReadonlySet<EvmProxyType> = new Set([
-    EvmProxyType.TRANSPARENT_UPGRADEABLE_V4,
-    EvmProxyType.OPTIMIZED_TRANSPARENT_UPGRADEABLE_V4,
-]);
-
-/** Whether the proxy type is UUPS (Universal Upgradeable Proxy Standard). */
-export const isUupsProxy = (proxyType: EvmProxyType): boolean => UUPS_PROXY_TYPES.has(proxyType);
-
-/** Whether the proxy type is TUP (Transparent Upgradeable Proxy). */
-export const isTupProxy = (proxyType: EvmProxyType): boolean => TUP_PROXY_TYPES.has(proxyType);
-
-/** Whether the proxy type requires a separate `ProxyAdmin` deployment (v4 variants). */
-export const requiresSeparateProxyAdminDeploy = (proxyType: EvmProxyType): boolean =>
-    SEPARATE_PROXY_ADMIN_TYPES.has(proxyType);
-
-export const ProxyType = {
-    ...EvmProxyType,
-};
-
-export type ProxyType = (typeof ProxyType)[keyof typeof ProxyType];
-
-export const upgradeTypeSchema = z.enum(UpgradeType);
-
-export const proxyTypeSchema = z.enum(ProxyType);
-export const proxyConfigSchema = z.object({
-    upgradeType: z.literal(UpgradeType.PROXY),
-    proxyType: proxyTypeSchema,
-});
-
-export type ProxyUpgradeableConfig = z.infer<typeof proxyConfigSchema>;
-
-export const notUpgradeableConfigSchema = z.object({
-    upgradeType: z.literal(UpgradeType.NOT_UPGRADEABLE),
-});
-
-export type NotUpgradeableConfig = z.infer<typeof notUpgradeableConfigSchema>;
-
-export const codeUpgradeableConfigSchema = z.object({
-    upgradeType: z.literal(UpgradeType.CODE_UPGRADE),
-});
-
-export type CodeUpgradeableConfig = z.infer<typeof codeUpgradeableConfigSchema>;
-
-export const upgradeableConfigSchema = z.discriminatedUnion('upgradeType', [
-    proxyConfigSchema,
-    notUpgradeableConfigSchema,
-    codeUpgradeableConfigSchema,
-]);
-
-export type UpgradeableConfig = z.infer<typeof upgradeableConfigSchema>;
-
-/** @deprecated use assertUpgradability, ensure your config is nonoptional */
-export const weakAssertUpgradability = <AllowedUpgradeConfigs extends UpgradeableConfig[]>(
-    allowedUpgradeConfigs: AllowedUpgradeConfigs,
-    upgradeableConfig?: UpgradeableConfig,
-): asserts upgradeableConfig is AllowedUpgradeConfigs[number] => {
-    if (!upgradeableConfig) {
-        return;
-    }
-
-    if (
-        allowedUpgradeConfigs.some((allowedConfig) => {
-            if (allowedConfig.upgradeType !== upgradeableConfig.upgradeType) {
-                return false;
-            }
-
-            if (allowedConfig.upgradeType === UpgradeType.NOT_UPGRADEABLE) {
-                return true;
-            }
-
-            if (allowedConfig.upgradeType === UpgradeType.CODE_UPGRADE) {
-                return true;
-            }
-
-            if (allowedConfig.upgradeType === UpgradeType.PROXY) {
-                return (
-                    allowedConfig.proxyType ===
-                    (upgradeableConfig as ProxyUpgradeableConfig).proxyType
-                );
-            }
-
-            assertUnreachable(allowedConfig);
-        })
-    ) {
-        // included in allowed array
-        return;
-    }
-
-    throw new NonRetryableError(
-        `Upgrade config ${JSON.stringify(upgradeableConfig)} is not compatible with any of the allowed upgrade configs ${JSON.stringify(allowedUpgradeConfigs)}`,
-    );
-};
-
-export const assertUpgradability = <AllowedUpgradeConfigs extends UpgradeableConfig[]>(
-    allowedUpgradeConfigs: AllowedUpgradeConfigs,
-    // Eventually make this nonoptional once callers are upgraded
-    upgradeableConfig?: UpgradeableConfig,
-): asserts upgradeableConfig is AllowedUpgradeConfigs[number] => {
-    if (!upgradeableConfig) {
-        throw new NonRetryableError('Will not handle undefined upgrade config');
-    }
-
-    return weakAssertUpgradability(allowedUpgradeConfigs, upgradeableConfig);
-};

package/src/wire/index.ts

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

package/src/wire/schemata.ts

@@ -1,63 +0,0 @@
-import { z } from 'zod';
-
-import { chainNameSchema } from '@layerzerolabs/layerzero-definitions';
-
-export const wireWorkflowFilterArgsSchema = {
-    // chain filters
-    onlyFrom: z
-        .array(chainNameSchema)
-        .optional()
-        .describe('Only wire pathways originating FROM these chains'),
-    onlyTo: z
-        .array(chainNameSchema)
-        .optional()
-        .describe('Only wire pathways going TO these chains'),
-    excludeFrom: z
-        .array(chainNameSchema)
-        .optional()
-        .describe('Exclude wiring pathways originating FROM these chains'),
-    excludeTo: z
-        .array(chainNameSchema)
-        .optional()
-        .describe('Exclude wiring pathways going TO these chains'),
-
-    // operation filters
-    onlyOperations: z.array(z.string()).optional().describe('Only perform these operations'),
-    excludeOperations: z.array(z.string()).optional().describe('Exclude these operations'),
-};
-
-export const wireWorkflowChainResultSchema = z.object({
-    results: z.array(
-        z.union([
-            z.object({
-                name: z.string(),
-                success: z.literal(false),
-                error: z.string(),
-            }),
-            z.object({
-                name: z.string(),
-                success: z.literal(true),
-                txHash: z.string(),
-            }),
-        ]),
-    ),
-});
-
-export const wireWorkflowChainStateSchema = wireWorkflowChainResultSchema.extend({
-    srcChain: chainNameSchema.optional(),
-    status: z.union([z.literal('RUNNING'), z.literal('COMPLETE')]).default('RUNNING'),
-});
-
-export type WireWorkflowChainState = z.infer<typeof wireWorkflowChainStateSchema>;
-export type WireWorkflowChainResult = z.infer<typeof wireWorkflowChainResultSchema>;
-
-export const wireWorkflowOrchestratorResultSchema = z.object({
-    stateByChain: z.partialRecord(chainNameSchema, wireWorkflowChainResultSchema).default({}),
-});
-
-export const wireWorkflowOrchestratorStateSchema = wireWorkflowOrchestratorResultSchema.extend({
-    status: z.union([z.literal('RUNNING'), z.literal('COMPLETE')]).default('RUNNING'),
-});
-
-export type WireWorkflowOrchestratorState = z.infer<typeof wireWorkflowOrchestratorStateSchema>;
-export type WireWorkflowOrchestratorResult = z.infer<typeof wireWorkflowOrchestratorResultSchema>;

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,
-}));