@layerzerolabs/dw-model 0.2.6 → 0.2.8

package/dist/role-management/types.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var X7GZKVDG_cjs = require('../X7GZKVDG.cjs');
+require('../YJF4D23A.cjs');
+
+
+
+Object.defineProperty(exports, "BaseContractRole", {
+  enumerable: true,
+  get: function () { return X7GZKVDG_cjs.BaseContractRole; }
+});
+//# sourceMappingURL=types.cjs.map
+//# sourceMappingURL=types.cjs.map

package/dist/role-management/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"types.cjs"}

package/dist/role-management/types.d.ts

@@ -0,0 +1,6 @@
+export declare enum BaseContractRole {
+    OWNER = "OWNER_ROLE",
+    ADMIN = "ADMIN_ROLE",
+    DEFAULT_ADMIN = "DEFAULT_ADMIN_ROLE"
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/role-management/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/role-management/types.ts"],"names":[],"mappings":"AAAA,oBAAY,gBAAgB;IACxB,KAAK,eAAe;IACpB,KAAK,eAAe;IACpB,aAAa,uBAAuB;CACvC"}

package/dist/role-management/types.js

@@ -0,0 +1,4 @@
+export { BaseContractRole } from '../JSK5QSWJ.js';
+import '../VUOMXK5T.js';
+//# sourceMappingURL=types.js.map
+//# sourceMappingURL=types.js.map

package/dist/role-management/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"types.js"}

package/dist/wire/index.cjs

@@ -1,30 +1,30 @@
 'use strict';
 
 require('../X4ZNR5GZ.cjs');
-var XPJHJHX6_cjs = require('../XPJHJHX6.cjs');
+var _5KVLMWQW_cjs = require('../5KVLMWQW.cjs');
 require('../YJF4D23A.cjs');
 
 
 
 Object.defineProperty(exports, "wireWorkflowChainResultSchema", {
   enumerable: true,
-  get: function () { return XPJHJHX6_cjs.wireWorkflowChainResultSchema; }
+  get: function () { return _5KVLMWQW_cjs.wireWorkflowChainResultSchema; }
 });
 Object.defineProperty(exports, "wireWorkflowChainStateSchema", {
   enumerable: true,
-  get: function () { return XPJHJHX6_cjs.wireWorkflowChainStateSchema; }
+  get: function () { return _5KVLMWQW_cjs.wireWorkflowChainStateSchema; }
 });
 Object.defineProperty(exports, "wireWorkflowFilterArgsSchema", {
   enumerable: true,
-  get: function () { return XPJHJHX6_cjs.wireWorkflowFilterArgsSchema; }
+  get: function () { return _5KVLMWQW_cjs.wireWorkflowFilterArgsSchema; }
 });
 Object.defineProperty(exports, "wireWorkflowOrchestratorResultSchema", {
   enumerable: true,
-  get: function () { return XPJHJHX6_cjs.wireWorkflowOrchestratorResultSchema; }
+  get: function () { return _5KVLMWQW_cjs.wireWorkflowOrchestratorResultSchema; }
 });
 Object.defineProperty(exports, "wireWorkflowOrchestratorStateSchema", {
   enumerable: true,
-  get: function () { return XPJHJHX6_cjs.wireWorkflowOrchestratorStateSchema; }
+  get: function () { return _5KVLMWQW_cjs.wireWorkflowOrchestratorStateSchema; }
 });
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map

package/dist/wire/index.js

@@ -1,5 +1,5 @@
 import '../N5VNZXZB.js';
-export { wireWorkflowChainResultSchema, wireWorkflowChainStateSchema, wireWorkflowFilterArgsSchema, wireWorkflowOrchestratorResultSchema, wireWorkflowOrchestratorStateSchema } from '../SGPTRDQO.js';
+export { wireWorkflowChainResultSchema, wireWorkflowChainStateSchema, wireWorkflowFilterArgsSchema, wireWorkflowOrchestratorResultSchema, wireWorkflowOrchestratorStateSchema } from '../EQTOSW62.js';
 import '../VUOMXK5T.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/wire/schemata.cjs

@@ -1,29 +1,29 @@
 'use strict';
 
-var XPJHJHX6_cjs = require('../XPJHJHX6.cjs');
+var _5KVLMWQW_cjs = require('../5KVLMWQW.cjs');
 require('../YJF4D23A.cjs');
 
 
 
 Object.defineProperty(exports, "wireWorkflowChainResultSchema", {
   enumerable: true,
-  get: function () { return XPJHJHX6_cjs.wireWorkflowChainResultSchema; }
+  get: function () { return _5KVLMWQW_cjs.wireWorkflowChainResultSchema; }
 });
 Object.defineProperty(exports, "wireWorkflowChainStateSchema", {
   enumerable: true,
-  get: function () { return XPJHJHX6_cjs.wireWorkflowChainStateSchema; }
+  get: function () { return _5KVLMWQW_cjs.wireWorkflowChainStateSchema; }
 });
 Object.defineProperty(exports, "wireWorkflowFilterArgsSchema", {
   enumerable: true,
-  get: function () { return XPJHJHX6_cjs.wireWorkflowFilterArgsSchema; }
+  get: function () { return _5KVLMWQW_cjs.wireWorkflowFilterArgsSchema; }
 });
 Object.defineProperty(exports, "wireWorkflowOrchestratorResultSchema", {
   enumerable: true,
-  get: function () { return XPJHJHX6_cjs.wireWorkflowOrchestratorResultSchema; }
+  get: function () { return _5KVLMWQW_cjs.wireWorkflowOrchestratorResultSchema; }
 });
 Object.defineProperty(exports, "wireWorkflowOrchestratorStateSchema", {
   enumerable: true,
-  get: function () { return XPJHJHX6_cjs.wireWorkflowOrchestratorStateSchema; }
+  get: function () { return _5KVLMWQW_cjs.wireWorkflowOrchestratorStateSchema; }
 });
 //# sourceMappingURL=schemata.cjs.map
 //# sourceMappingURL=schemata.cjs.map

package/dist/wire/schemata.d.ts

@@ -16,7 +16,7 @@ export declare const wireWorkflowChainResultSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         name: z.ZodString;
         success: z.ZodLiteral<true>;
-        txHash: z.ZodUnion<readonly [z.ZodType<`0x${string}`, unknown, z.core.$ZodTypeInternals<`0x${string}`, unknown>>, z.ZodLiteral<"NO_OP">]>;
+        txHash: z.ZodString;
     }, z.core.$strip>]>>;
 }, z.core.$strip>;
 export declare const wireWorkflowChainStateSchema: z.ZodObject<{
@@ -27,15 +27,15 @@ export declare const wireWorkflowChainStateSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         name: z.ZodString;
         success: z.ZodLiteral<true>;
-        txHash: z.ZodUnion<readonly [z.ZodType<`0x${string}`, unknown, z.core.$ZodTypeInternals<`0x${string}`, unknown>>, z.ZodLiteral<"NO_OP">]>;
+        txHash: z.ZodString;
     }, z.core.$strip>]>>;
     srcChain: z.ZodOptional<z.ZodEnum<typeof ChainName>>;
-    status: z.ZodUnion<readonly [z.ZodLiteral<"RUNNING">, z.ZodLiteral<"COMPLETE">]>;
+    status: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"RUNNING">, z.ZodLiteral<"COMPLETE">]>>;
 }, z.core.$strip>;
 export type WireWorkflowChainState = z.infer<typeof wireWorkflowChainStateSchema>;
 export type WireWorkflowChainResult = z.infer<typeof wireWorkflowChainResultSchema>;
 export declare const wireWorkflowOrchestratorResultSchema: z.ZodObject<{
-    stateByChain: z.ZodRecord<z.ZodUnion<[z.ZodEnum<typeof ChainName>, z.ZodNever]>, z.ZodObject<{
+    stateByChain: z.ZodDefault<z.ZodRecord<z.ZodUnion<[z.ZodEnum<typeof ChainName>, z.ZodNever]>, z.ZodObject<{
         results: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
             name: z.ZodString;
             success: z.ZodLiteral<false>;
@@ -43,12 +43,12 @@ export declare const wireWorkflowOrchestratorResultSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             name: z.ZodString;
             success: z.ZodLiteral<true>;
-            txHash: z.ZodUnion<readonly [z.ZodType<`0x${string}`, unknown, z.core.$ZodTypeInternals<`0x${string}`, unknown>>, z.ZodLiteral<"NO_OP">]>;
+            txHash: z.ZodString;
         }, z.core.$strip>]>>;
-    }, z.core.$strip>>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export declare const wireWorkflowOrchestratorStateSchema: z.ZodObject<{
-    stateByChain: z.ZodRecord<z.ZodUnion<[z.ZodEnum<typeof ChainName>, z.ZodNever]>, z.ZodObject<{
+    stateByChain: z.ZodDefault<z.ZodRecord<z.ZodUnion<[z.ZodEnum<typeof ChainName>, z.ZodNever]>, z.ZodObject<{
         results: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
             name: z.ZodString;
             success: z.ZodLiteral<false>;
@@ -56,10 +56,10 @@ export declare const wireWorkflowOrchestratorStateSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             name: z.ZodString;
             success: z.ZodLiteral<true>;
-            txHash: z.ZodUnion<readonly [z.ZodType<`0x${string}`, unknown, z.core.$ZodTypeInternals<`0x${string}`, unknown>>, z.ZodLiteral<"NO_OP">]>;
+            txHash: z.ZodString;
         }, z.core.$strip>]>>;
-    }, z.core.$strip>>;
-    status: z.ZodUnion<readonly [z.ZodLiteral<"RUNNING">, z.ZodLiteral<"COMPLETE">]>;
+    }, z.core.$strip>>>;
+    status: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"RUNNING">, z.ZodLiteral<"COMPLETE">]>>;
 }, z.core.$strip>;
 export type WireWorkflowOrchestratorState = z.infer<typeof wireWorkflowOrchestratorStateSchema>;
 export type WireWorkflowOrchestratorResult = z.infer<typeof wireWorkflowOrchestratorResultSchema>;

package/dist/wire/schemata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemata.d.ts","sourceRoot":"","sources":["../../src/wire/schemata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAG3B,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAEjE,eAAO,MAAM,4BAA4B;;;;;;;CAsBxC,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;;;;;;;;iBAexC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;iBAGvC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF,eAAO,MAAM,oCAAoC;;;;;;;;;;;;iBAE/C,CAAC;AAEH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;iBAE9C,CAAC;AAEH,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAC;AAChG,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAC"}
+{"version":3,"file":"schemata.d.ts","sourceRoot":"","sources":["../../src/wire/schemata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAE3B,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAEjE,eAAO,MAAM,4BAA4B;;;;;;;CAsBxC,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;;;;;;;;iBAexC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;iBAGvC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF,eAAO,MAAM,oCAAoC;;;;;;;;;;;;iBAE/C,CAAC;AAEH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;iBAE9C,CAAC;AAEH,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAC;AAChG,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAC"}

package/dist/wire/schemata.js

@@ -1,4 +1,4 @@
-export { wireWorkflowChainResultSchema, wireWorkflowChainStateSchema, wireWorkflowFilterArgsSchema, wireWorkflowOrchestratorResultSchema, wireWorkflowOrchestratorStateSchema } from '../SGPTRDQO.js';
+export { wireWorkflowChainResultSchema, wireWorkflowChainStateSchema, wireWorkflowFilterArgsSchema, wireWorkflowOrchestratorResultSchema, wireWorkflowOrchestratorStateSchema } from '../EQTOSW62.js';
 import '../VUOMXK5T.js';
 //# sourceMappingURL=schemata.js.map
 //# sourceMappingURL=schemata.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/dw-model",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "private": false,
   "license": "MIT",
   "type": "module",
@@ -15,17 +15,18 @@
   "types": "./dist/index.d.ts",
   "dependencies": {
     "zod": "3.25.56",
-    "@layerzerolabs/common-chain-model": "0.2.6",
-    "@layerzerolabs/typescript-utils": "0.2.6",
-    "@layerzerolabs/zod-utils": "0.2.6",
-    "@layerzerolabs/layerzero-definitions": "0.2.6"
+    "@layerzerolabs/common-chain-model": "0.2.8",
+    "@layerzerolabs/gated-transaction": "0.2.8",
+    "@layerzerolabs/layerzero-definitions": "0.2.8",
+    "@layerzerolabs/zod-utils": "0.2.8",
+    "@layerzerolabs/typescript-utils": "0.2.8"
   },
   "devDependencies": {
     "@mysten/sui": "^1.35.0",
     "tsup": "^8.4.0",
     "vitest": "^3.2.3",
-    "@layerzerolabs/tsup-configuration": "0.2.6",
-    "@layerzerolabs/typescript-configuration": "0.2.6"
+    "@layerzerolabs/tsup-configuration": "0.2.8",
+    "@layerzerolabs/typescript-configuration": "0.2.8"
   },
   "publishConfig": {
     "access": "restricted",
@@ -36,7 +37,6 @@
   },
   "scripts": {
     "build": "tsup",
-    "clean": "rm -rf ./node_modules .turbo ./dist",
     "lint": "eslint . --max-warnings 0 || (eslint . --fix --max-warnings 0 && false)",
     "test": "vitest --run --pass-with-no-tests --typecheck"
   }

package/src/deploy/index.ts

@@ -1 +1,3 @@
-export * from './schemata';
+export * from './resourceBuilder';
+export * from './resources';
+export * from './workflow';

package/src/deploy/resourceBuilder.ts

@@ -0,0 +1,62 @@
+import type { z } from 'zod/v4';
+
+import type {
+    BaseContractResource,
+    BaseMeshResource,
+    baseResourceSchema,
+    ContractResourceDependency,
+    MeshResourceDependency,
+} from './resources';
+
+export type ContractResourceBuilderResult<Resource extends BaseContractResource> = {
+    id: ContractResourceDependency<Resource>;
+    build: () => Resource;
+};
+
+export type MeshResourceBuilderResult<Resource extends BaseMeshResource> = {
+    id: MeshResourceDependency<Resource>;
+    build: () => Resource;
+};
+
+export const createResourceBuilder =
+    <T extends typeof baseResourceSchema, U extends Omit<z.infer<T>, 'type' | 'resourceBaseType'>>(
+        _resourceSchema: T,
+        {
+            resourceBaseType,
+            type,
+        }: {
+            resourceBaseType: 'CONTRACT' | 'MESH';
+            type: T['shape'] extends { type: z.ZodType<infer Type> } ? Type : undefined;
+        },
+    ) =>
+    (
+        resource: U,
+    ): z.infer<T> extends BaseContractResource
+        ? ContractResourceBuilderResult<z.infer<T>>
+        : z.infer<T> extends BaseMeshResource
+          ? MeshResourceBuilderResult<z.infer<T>>
+          : never => {
+        if (resourceBaseType === 'CONTRACT') {
+            return {
+                id: {
+                    __CONTRACT_RESOURCE_DEPENDENCY: true,
+                    __dependencyType: null as any,
+                    id: resource.id,
+                },
+                build: () => ({ ...resource, type, resourceBaseType }),
+            } satisfies ContractResourceBuilderResult<any> as any;
+        }
+        if (resourceBaseType === 'MESH') {
+            return {
+                id: {
+                    __MESH_RESOURCE_DEPENDENCY: true,
+                    // this is just a type brand, doesnt need to exist
+                    __dependencyType: null as any,
+                    id: resource.id,
+                },
+                build: () => ({ ...resource, type, resourceBaseType }),
+            } satisfies MeshResourceBuilderResult<any> as any;
+        }
+
+        throw new Error(`Can't handle resouceBaseType "${resourceBaseType}"`);
+    };

package/src/deploy/resources.ts

@@ -0,0 +1,171 @@
+import z from 'zod/v4';
+
+import type { NormalizedHexString } from '@layerzerolabs/common-chain-model';
+import { ChainName } from '@layerzerolabs/layerzero-definitions';
+import type { IsAny } from '@layerzerolabs/typescript-utils';
+
+import { upgradeableConfigSchema } from '../upgrade';
+
+export const baseResourceSchema = z.object({
+    id: z.string(), // account-unique ID for this resource
+    name: z.string().optional(), // display name for this resource
+    resourceBaseType: z.string() as z.ZodString | z.ZodLiteral,
+});
+
+export const baseMeshResourceSchema = z.object({
+    ...baseResourceSchema.shape,
+    resourceBaseType: z.literal('MESH'),
+});
+
+export const baseContractResourceSchema = z.object({
+    ...baseResourceSchema.shape,
+    resourceBaseType: z.literal('CONTRACT'),
+    chainName: z.enum(ChainName),
+    upgradeConfig: upgradeableConfigSchema.optional(),
+    verifyContract: z.boolean().optional(),
+
+    chainConfig: z.any().optional(),
+});
+
+export type BaseResource = z.infer<typeof baseResourceSchema>;
+export type BaseMeshResource = z.infer<typeof baseMeshResourceSchema>;
+export type BaseContractResource = z.infer<typeof baseContractResourceSchema>;
+
+export type ContractResourceDependency<T extends BaseContractResource = BaseContractResource> = {
+    id: string;
+    /** WARNING: this field is not present at runtime */
+    __dependencyType: T;
+    ['__CONTRACT_RESOURCE_DEPENDENCY']: true;
+};
+
+export const isContractResourceDependency = (o: any): o is ContractResourceDependency =>
+    o != null &&
+    typeof o === 'object' &&
+    (o as ContractResourceDependency).__CONTRACT_RESOURCE_DEPENDENCY;
+
+export type ContractResourceDependencySchema<T extends typeof baseContractResourceSchema> =
+    z.ZodType<ContractResourceDependency<z.infer<T>>>;
+
+export const contractResourceDependencySchema: ContractResourceDependencySchema<
+    typeof baseContractResourceSchema
+> = z.custom<ContractResourceDependency>(isContractResourceDependency);
+
+export const contractResourceDependencySchemaFor = <T extends typeof baseContractResourceSchema>(
+    // FIXME use this to generate a real schema
+    _resource: T,
+): ContractResourceDependencySchema<T> =>
+    z.custom<ContractResourceDependency<z.infer<T>>>(isContractResourceDependency);
+
+export type ResolvedContractResourceDependency<T extends BaseContractResource> = {
+    id: string;
+    resource: T;
+    address: NormalizedHexString;
+};
+
+export type ResolvedContractResourceDependencySchema<T extends typeof baseContractResourceSchema> =
+    z.ZodType<ResolvedContractResourceDependency<z.infer<T>>>;
+
+export const resolvedContractResourceDependencySchema: ResolvedContractResourceDependencySchema<any> =
+    // FIXME could be a real schema
+    z.custom<ResolvedContractResourceDependency<any>>();
+
+export type MeshResourceDependency<T extends BaseMeshResource = BaseMeshResource> = {
+    id: string;
+    /** WARNING: this field is not present at runtime */
+    __dependencyType: T;
+    ['__MESH_RESOURCE_DEPENDENCY']: true;
+};
+
+export const isMeshResourceDependency = (o: any): o is MeshResourceDependency =>
+    o != null && typeof o === 'object' && (o as MeshResourceDependency).__MESH_RESOURCE_DEPENDENCY;
+
+export type MeshResourceDependencySchema<T extends typeof baseMeshResourceSchema> = z.ZodType<
+    MeshResourceDependency<z.infer<T>>
+>;
+
+export const meshResourceDependencySchema: MeshResourceDependencySchema<
+    typeof baseMeshResourceSchema
+> = z.custom<MeshResourceDependency>(isMeshResourceDependency);
+
+export const meshResourceDependencySchemaFor = <T extends typeof baseMeshResourceSchema>(
+    // FIXME use this to generate a real schema
+    _resource: T,
+): MeshResourceDependencySchema<T> =>
+    z.custom<MeshResourceDependency<z.infer<T>>>(isMeshResourceDependency);
+
+export type ResolvedMeshResourceDependency<T extends BaseMeshResource> = {
+    id: string;
+    resource: T;
+    // TODO: is there any other resolved information we want to inject here?
+};
+
+export type ResolvedMeshResourceDependencySchema<T extends typeof baseMeshResourceSchema> =
+    // FIXME could be a real schema
+    z.ZodType<ResolvedMeshResourceDependency<z.infer<T>>>;
+
+export const resolvedMeshResourceDependencySchema: ResolvedMeshResourceDependencySchema<any> =
+    z.custom<ResolvedMeshResourceDependency<any>>();
+
+// FIXME this could be recursive, probably overkill
+export type ResolvedResourceSchema<Resource extends typeof baseResourceSchema> = z.ZodObject<
+    {
+        [K in keyof Resource['shape']]: Resource['shape'][K] extends infer R extends z.ZodType
+            ? R extends z.ZodAny
+                ? R
+                : R extends z.ZodOptional<z.ZodAny>
+                  ? R
+                  : R extends ContractResourceDependencySchema<infer I>
+                    ? ResolvedContractResourceDependencySchema<I>
+                    : R extends z.ZodOptional<ContractResourceDependencySchema<infer I>>
+                      ? z.ZodOptional<ResolvedContractResourceDependencySchema<I>>
+                      : R extends MeshResourceDependencySchema<infer I>
+                        ? ResolvedMeshResourceDependencySchema<I>
+                        : R extends z.ZodOptional<MeshResourceDependencySchema<infer I>>
+                          ? z.ZodOptional<ResolvedMeshResourceDependencySchema<I>>
+                          : R
+            : never;
+    },
+    z.core.$strip
+>;
+
+// FIXME this could be recursive, probably overkill
+export type ResolvedResource<Resource extends BaseResource> = {
+    [K in keyof Resource]: Resource[K] extends infer R
+        ? R extends undefined
+            ? R
+            : IsAny<R> extends true
+              ? R
+              : IsAny<Exclude<R, undefined>> extends true
+                ? R
+                : R extends ContractResourceDependency<infer I>
+                  ? ResolvedContractResourceDependency<I>
+                  : R extends ContractResourceDependency<infer I> | undefined
+                    ? ResolvedContractResourceDependency<I> | undefined
+                    : R extends MeshResourceDependency<infer I>
+                      ? ResolvedMeshResourceDependency<I>
+                      : R extends MeshResourceDependency<infer I> | undefined
+                        ? ResolvedMeshResourceDependency<I> | undefined
+                        : R
+        : never;
+};
+
+export const extractContractResourceDependencyIds = <Resource extends BaseResource>(
+    resource: Resource,
+) =>
+    Object.entries(resource).filter(([, id]) => isContractResourceDependency(id)) as unknown as [
+        prop: string,
+        id: ContractResourceDependency,
+    ][];
+
+export const extractMeshResourceDependencyIds = <Resource extends BaseResource>(
+    resource: Resource,
+) =>
+    Object.entries(resource).filter(([, id]) => isMeshResourceDependency(id)) as unknown as [
+        prop: string,
+        id: MeshResourceDependency,
+    ][];
+
+// FIXME implement runtime
+export const createResolvedResourceSchema = <Resource extends typeof baseResourceSchema>(
+    resource: Resource,
+) => resource as ResolvedResourceSchema<Resource>;

package/src/deploy/{schemata.ts → workflow.ts}

@@ -79,12 +79,12 @@ export const verificationArgumentsSchema = z.union([
 ]);
 
 export const deployWorkflowChainResultSchema = z.object({
-    results: z.array(deployWorkflowChainResultItemSchema),
+    results: z.array(deployWorkflowChainResultItemSchema).default([]),
 });
 
 export const deployWorkflowChainStateSchema = deployWorkflowChainResultSchema.extend({
     srcChain: z.enum(ChainName).optional(),
-    status: z.union([z.literal('RUNNING'), z.literal('COMPLETE')]),
+    status: z.union([z.literal('RUNNING'), z.literal('COMPLETE')]).default('RUNNING'),
 });
 
 export type DeployWorkflowChainState = z.infer<typeof deployWorkflowChainStateSchema>;
@@ -92,11 +92,11 @@ export type DeployWorkflowChainResult = z.infer<typeof deployWorkflowChainResult
 export type DeployWorkflowChainResultItem = z.infer<typeof deployWorkflowChainResultItemSchema>;
 
 export const deployWorkflowOrchestratorResultSchema = z.object({
-    stateByChain: z.partialRecord(z.enum(ChainName), deployWorkflowChainResultSchema),
+    stateByChain: z.partialRecord(z.enum(ChainName), deployWorkflowChainResultSchema).default({}),
 });
 
 export const deployWorkflowOrchestratorStateSchema = deployWorkflowOrchestratorResultSchema.extend({
-    status: z.union([z.literal('RUNNING'), z.literal('COMPLETE')]),
+    status: z.union([z.literal('RUNNING'), z.literal('COMPLETE')]).default('RUNNING'),
 });
 
 export type DeployWorkflowOrchestratorState = z.infer<typeof deployWorkflowOrchestratorStateSchema>;

package/src/index.ts

@@ -1,3 +1,4 @@
 export * from './deploy';
+export * from './role-management';
 export * from './upgrade';
 export * from './wire';

package/src/role-management/generator.ts

@@ -0,0 +1,17 @@
+import type { CreateSetRoleTransactionsWithSpecializedInput, HasRoleWithSpecializedInput } from '.';
+
+export const generateThrowCreateSetRoleTransactions =
+    (): CreateSetRoleTransactionsWithSpecializedInput => () => {
+        throw new Error('Not implemented');
+    };
+
+export const generateThrowHasRole = (): HasRoleWithSpecializedInput => () => {
+    throw new Error('Not implemented');
+};
+
+export const generateThrowRoleManagement = () => {
+    return {
+        createSetRoleTransactions: generateThrowCreateSetRoleTransactions(),
+        hasRole: generateThrowHasRole(),
+    };
+};

package/src/role-management/index.ts

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

package/src/role-management/schemata.ts

@@ -0,0 +1,81 @@
+import { z } from 'zod/v4';
+
+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 generateRoleManagementSchemas = <const T extends readonly [string, ...string[]]>(
+    roles: T,
+) => ({
+    createSetRoleTransactions: generateCreateSetRoleTransactionsSchema(roles),
+    hasRole: generateHasRoleSchema(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 type CreateSetRoleTransactionsWithSpecializedInput = z.infer<
+    typeof createSetRoleTransactionsWithSpecializedInputSchema
+>;
+export type HasRoleWithSpecializedInput = z.infer<typeof hasRoleWithSpecializedInputSchema>;

package/src/role-management/types.ts

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

package/src/wire/schemata.ts

@@ -1,6 +1,5 @@
 import { z } from 'zod/v4';
 
-import { hexSchema } from '@layerzerolabs/common-chain-model';
 import { ChainName } from '@layerzerolabs/layerzero-definitions';
 
 export const wireWorkflowFilterArgsSchema = {
@@ -38,7 +37,7 @@ export const wireWorkflowChainResultSchema = z.object({
             z.object({
                 name: z.string(),
                 success: z.literal(true),
-                txHash: z.union([hexSchema, z.literal('NO_OP')]),
+                txHash: z.string(),
             }),
         ]),
     ),
@@ -46,18 +45,18 @@ export const wireWorkflowChainResultSchema = z.object({
 
 export const wireWorkflowChainStateSchema = wireWorkflowChainResultSchema.extend({
     srcChain: z.enum(ChainName).optional(),
-    status: z.union([z.literal('RUNNING'), z.literal('COMPLETE')]),
+    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(z.enum(ChainName), wireWorkflowChainResultSchema),
+    stateByChain: z.partialRecord(z.enum(ChainName), wireWorkflowChainResultSchema).default({}),
 });
 
 export const wireWorkflowOrchestratorStateSchema = wireWorkflowOrchestratorResultSchema.extend({
-    status: z.union([z.literal('RUNNING'), z.literal('COMPLETE')]),
+    status: z.union([z.literal('RUNNING'), z.literal('COMPLETE')]).default('RUNNING'),
 });
 
 export type WireWorkflowOrchestratorState = z.infer<typeof wireWorkflowOrchestratorStateSchema>;