@layerzerolabs/dw-model 0.2.13 → 0.2.18

package/dist/upgrade/types.cjs

@@ -1,45 +1,45 @@
 'use strict';
 
-var W3NEISER_cjs = require('../W3NEISER.cjs');
+var WYAGX6NX_cjs = require('../WYAGX6NX.cjs');
 require('../YJF4D23A.cjs');
 
 
 
 Object.defineProperty(exports, "EvmProxyType", {
   enumerable: true,
-  get: function () { return W3NEISER_cjs.EvmProxyType; }
+  get: function () { return WYAGX6NX_cjs.EvmProxyType; }
 });
 Object.defineProperty(exports, "ProxyType", {
   enumerable: true,
-  get: function () { return W3NEISER_cjs.ProxyType; }
+  get: function () { return WYAGX6NX_cjs.ProxyType; }
 });
 Object.defineProperty(exports, "UpgradeType", {
   enumerable: true,
-  get: function () { return W3NEISER_cjs.UpgradeType; }
+  get: function () { return WYAGX6NX_cjs.UpgradeType; }
 });
 Object.defineProperty(exports, "codeUpgradeableConfigSchema", {
   enumerable: true,
-  get: function () { return W3NEISER_cjs.codeUpgradeableConfigSchema; }
+  get: function () { return WYAGX6NX_cjs.codeUpgradeableConfigSchema; }
 });
 Object.defineProperty(exports, "notUpgradeableConfigSchema", {
   enumerable: true,
-  get: function () { return W3NEISER_cjs.notUpgradeableConfigSchema; }
+  get: function () { return WYAGX6NX_cjs.notUpgradeableConfigSchema; }
 });
 Object.defineProperty(exports, "proxyConfigSchema", {
   enumerable: true,
-  get: function () { return W3NEISER_cjs.proxyConfigSchema; }
+  get: function () { return WYAGX6NX_cjs.proxyConfigSchema; }
 });
 Object.defineProperty(exports, "proxyTypeSchema", {
   enumerable: true,
-  get: function () { return W3NEISER_cjs.proxyTypeSchema; }
+  get: function () { return WYAGX6NX_cjs.proxyTypeSchema; }
 });
 Object.defineProperty(exports, "upgradeTypeSchema", {
   enumerable: true,
-  get: function () { return W3NEISER_cjs.upgradeTypeSchema; }
+  get: function () { return WYAGX6NX_cjs.upgradeTypeSchema; }
 });
 Object.defineProperty(exports, "upgradeableConfigSchema", {
   enumerable: true,
-  get: function () { return W3NEISER_cjs.upgradeableConfigSchema; }
+  get: function () { return WYAGX6NX_cjs.upgradeableConfigSchema; }
 });
 //# sourceMappingURL=types.cjs.map
 //# sourceMappingURL=types.cjs.map

package/dist/upgrade/types.d.ts

@@ -1,4 +1,4 @@
-import z from 'zod/v4';
+import z from 'zod';
 export declare enum UpgradeType {
     NOT_UPGRADEABLE = "NOT_UPGRADEABLE",
     PROXY = "PROXY",
@@ -44,6 +44,6 @@ export declare const upgradeableConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObje
     upgradeType: z.ZodLiteral<UpgradeType.NOT_UPGRADEABLE>;
 }, z.core.$strip>, z.ZodObject<{
     upgradeType: z.ZodLiteral<UpgradeType.CODE_UPGRADE>;
-}, z.core.$strip>]>;
+}, z.core.$strip>], "upgradeType">;
 export type UpgradeableConfig = z.infer<typeof upgradeableConfigSchema>;
 //# sourceMappingURL=types.d.ts.map

package/dist/upgrade/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/upgrade/types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAEvB,oBAAY,WAAW;IAEnB,eAAe,oBAAoB;IAEnC,KAAK,UAAU;IAEf,YAAY,iBAAiB;CAChC;AAED,oBAAY,YAAY;IAEpB,uBAAuB,4BAA4B;IAEnD,qBAAqB,0BAA0B;CAClD;AAED,eAAO,MAAM,SAAS;;;CAErB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAEnE,eAAO,MAAM,iBAAiB,+BAAsB,CAAC;AAErD,eAAO,MAAM,eAAe;;;EAAoB,CAAC;AACjD,eAAO,MAAM,iBAAiB;;;;;;iBAG5B,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEvE,eAAO,MAAM,0BAA0B;;iBAErC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,2BAA2B;;iBAEtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,uBAAuB;;;;;;;;;;mBAIlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/upgrade/types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,oBAAY,WAAW;IAEnB,eAAe,oBAAoB;IAEnC,KAAK,UAAU;IAEf,YAAY,iBAAiB;CAChC;AAED,oBAAY,YAAY;IAEpB,uBAAuB,4BAA4B;IAEnD,qBAAqB,0BAA0B;CAClD;AAED,eAAO,MAAM,SAAS;;;CAErB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAEnE,eAAO,MAAM,iBAAiB,+BAAsB,CAAC;AAErD,eAAO,MAAM,eAAe;;;EAAoB,CAAC;AACjD,eAAO,MAAM,iBAAiB;;;;;;iBAG5B,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEvE,eAAO,MAAM,0BAA0B;;iBAErC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,2BAA2B;;iBAEtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,uBAAuB;;;;;;;;;;kCAIlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/upgrade/types.js

@@ -1,4 +1,4 @@
-export { EvmProxyType, ProxyType, UpgradeType, codeUpgradeableConfigSchema, notUpgradeableConfigSchema, proxyConfigSchema, proxyTypeSchema, upgradeTypeSchema, upgradeableConfigSchema } from '../U463T6CN.js';
+export { EvmProxyType, ProxyType, UpgradeType, codeUpgradeableConfigSchema, notUpgradeableConfigSchema, proxyConfigSchema, proxyTypeSchema, upgradeTypeSchema, upgradeableConfigSchema } from '../RDYET6CZ.js';
 import '../VUOMXK5T.js';
 //# sourceMappingURL=types.js.map
 //# sourceMappingURL=types.js.map

package/dist/wire/index.cjs

@@ -1,30 +1,30 @@
 'use strict';
 
 require('../X4ZNR5GZ.cjs');
-var _5KVLMWQW_cjs = require('../5KVLMWQW.cjs');
+var QLEJL4UB_cjs = require('../QLEJL4UB.cjs');
 require('../YJF4D23A.cjs');
 
 
 
 Object.defineProperty(exports, "wireWorkflowChainResultSchema", {
   enumerable: true,
-  get: function () { return _5KVLMWQW_cjs.wireWorkflowChainResultSchema; }
+  get: function () { return QLEJL4UB_cjs.wireWorkflowChainResultSchema; }
 });
 Object.defineProperty(exports, "wireWorkflowChainStateSchema", {
   enumerable: true,
-  get: function () { return _5KVLMWQW_cjs.wireWorkflowChainStateSchema; }
+  get: function () { return QLEJL4UB_cjs.wireWorkflowChainStateSchema; }
 });
 Object.defineProperty(exports, "wireWorkflowFilterArgsSchema", {
   enumerable: true,
-  get: function () { return _5KVLMWQW_cjs.wireWorkflowFilterArgsSchema; }
+  get: function () { return QLEJL4UB_cjs.wireWorkflowFilterArgsSchema; }
 });
 Object.defineProperty(exports, "wireWorkflowOrchestratorResultSchema", {
   enumerable: true,
-  get: function () { return _5KVLMWQW_cjs.wireWorkflowOrchestratorResultSchema; }
+  get: function () { return QLEJL4UB_cjs.wireWorkflowOrchestratorResultSchema; }
 });
 Object.defineProperty(exports, "wireWorkflowOrchestratorStateSchema", {
   enumerable: true,
-  get: function () { return _5KVLMWQW_cjs.wireWorkflowOrchestratorStateSchema; }
+  get: function () { return QLEJL4UB_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 '../EQTOSW62.js';
+export { wireWorkflowChainResultSchema, wireWorkflowChainStateSchema, wireWorkflowFilterArgsSchema, wireWorkflowOrchestratorResultSchema, wireWorkflowOrchestratorStateSchema } from '../I5L5NLZY.js';
 import '../VUOMXK5T.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/wire/schemata.cjs

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

package/dist/wire/schemata.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod/v4';
+import { z } from 'zod';
 import { ChainName } from '@layerzerolabs/layerzero-definitions';
 export declare const wireWorkflowFilterArgsSchema: {
     onlyFrom: z.ZodOptional<z.ZodArray<z.ZodEnum<typeof ChainName>>>;
@@ -35,7 +35,7 @@ export declare const wireWorkflowChainStateSchema: z.ZodObject<{
 export type WireWorkflowChainState = z.infer<typeof wireWorkflowChainStateSchema>;
 export type WireWorkflowChainResult = z.infer<typeof wireWorkflowChainResultSchema>;
 export declare const wireWorkflowOrchestratorResultSchema: z.ZodObject<{
-    stateByChain: z.ZodDefault<z.ZodRecord<z.ZodUnion<[z.ZodEnum<typeof ChainName>, z.ZodNever]>, z.ZodObject<{
+    stateByChain: z.ZodDefault<z.ZodRecord<z.ZodEnum<typeof ChainName> & z.core.$partial, z.ZodObject<{
         results: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
             name: z.ZodString;
             success: z.ZodLiteral<false>;
@@ -48,7 +48,7 @@ export declare const wireWorkflowOrchestratorResultSchema: z.ZodObject<{
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export declare const wireWorkflowOrchestratorStateSchema: z.ZodObject<{
-    stateByChain: z.ZodDefault<z.ZodRecord<z.ZodUnion<[z.ZodEnum<typeof ChainName>, z.ZodNever]>, z.ZodObject<{
+    stateByChain: z.ZodDefault<z.ZodRecord<z.ZodEnum<typeof ChainName> & z.core.$partial, z.ZodObject<{
         results: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
             name: z.ZodString;
             success: z.ZodLiteral<false>;

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;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"}
+{"version":3,"file":"schemata.d.ts","sourceRoot":"","sources":["../../src/wire/schemata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,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 '../EQTOSW62.js';
+export { wireWorkflowChainResultSchema, wireWorkflowChainStateSchema, wireWorkflowFilterArgsSchema, wireWorkflowOrchestratorResultSchema, wireWorkflowOrchestratorStateSchema } from '../I5L5NLZY.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.13",
+  "version": "0.2.18",
   "private": false,
   "license": "MIT",
   "type": "module",
@@ -14,19 +14,20 @@
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "dependencies": {
-    "zod": "3.25.56",
-    "@layerzerolabs/common-chain-model": "0.2.13",
-    "@layerzerolabs/gated-transaction": "0.2.13",
-    "@layerzerolabs/zod-utils": "0.2.13",
-    "@layerzerolabs/typescript-utils": "0.2.13",
-    "@layerzerolabs/layerzero-definitions": "0.2.13"
+    "zod": "4.3.5",
+    "@layerzerolabs/common-chain-model": "0.2.18",
+    "@layerzerolabs/common-error-utils": "0.2.18",
+    "@layerzerolabs/gated-transaction": "0.2.18",
+    "@layerzerolabs/layerzero-definitions": "0.2.18",
+    "@layerzerolabs/typescript-utils": "0.2.18",
+    "@layerzerolabs/zod-utils": "0.2.18"
   },
   "devDependencies": {
     "@mysten/sui": "^1.35.0",
     "tsup": "^8.4.0",
     "vitest": "^3.2.3",
-    "@layerzerolabs/tsup-configuration": "0.2.13",
-    "@layerzerolabs/typescript-configuration": "0.2.13"
+    "@layerzerolabs/tsup-configuration": "0.2.18",
+    "@layerzerolabs/typescript-configuration": "0.2.18"
   },
   "publishConfig": {
     "access": "restricted",

package/src/deploy/artifact.ts

@@ -0,0 +1,93 @@
+import type { SuiObjectChange } from '@mysten/sui/client';
+import { z } from 'zod';
+
+import { hexSchema, normalizedHexSchema } from '@layerzerolabs/common-chain-model';
+import { ChainName } from '@layerzerolabs/layerzero-definitions';
+export type { ChainName };
+
+export type { SuiObjectChange };
+
+export enum ArtifactType {
+    // should merge deployment, verification artifacts
+
+    // full record from deployment on-chain
+    DEPLOYMENT = 'deployment',
+    // information to verify contracts
+    VERIFICATION = 'verification',
+    // record of a successful push to lz metadata
+    METADATA = 'metadata',
+}
+
+// Chain-specific extra deployment info schemas
+export const solanaDeploymentArtifactExtraInfoSchema = z.object({
+    accounts: z.record(z.string(), normalizedHexSchema),
+});
+
+export type SolanaDeploymentArtifactExtraInfo = z.infer<
+    typeof solanaDeploymentArtifactExtraInfoSchema
+>;
+
+export const suiDeploymentArtifactExtraInfoSchema = z.object({
+    digest: z.string(),
+    objectChanges: z.array(z.custom<SuiObjectChange>()),
+});
+
+export type SuiDeploymentArtifactExtraInfo = z.infer<typeof suiDeploymentArtifactExtraInfoSchema>;
+
+export const identityOnlyDeploymentArtifactSchema = z.object({
+    contractName: z.string(),
+    chainName: z.enum(ChainName),
+    address: normalizedHexSchema,
+});
+export type IdentityOnlyDeploymentArtifact = z.infer<typeof identityOnlyDeploymentArtifactSchema>;
+
+// FIXME also include verification info in this
+export const fullDeploymentArtifactSchema = z.object({
+    ...identityOnlyDeploymentArtifactSchema.shape,
+    contractName: z.string(),
+    chainName: z.enum(ChainName),
+    address: normalizedHexSchema,
+    nativeAddress: z.string(),
+    bytecodeHash: z.string().optional(),
+    deploymentTimestamp: z.number(),
+    deployerAddress: normalizedHexSchema,
+    txHash: z.string(),
+    // should probably remove this
+    abiEncodedConstructorArguments: hexSchema.optional(),
+    extraDeploymentInfo: z.any().optional(),
+});
+export type FullDeploymentArtifact = z.infer<typeof fullDeploymentArtifactSchema>;
+
+export const deploymentArtifactSchema = z.union([
+    // check this first since it's a superset
+    fullDeploymentArtifactSchema,
+    identityOnlyDeploymentArtifactSchema,
+]);
+
+export type DeploymentArtifact = z.infer<typeof deploymentArtifactSchema>;
+
+export const verificationArtifactSchema = z.any();
+
+export type VerificationArtifact = z.infer<typeof verificationArtifactSchema>;
+
+export const metadataArtifactSchema = z.void();
+
+export type MetadataArtifact = z.infer<typeof metadataArtifactSchema>;
+
+export const artifactWithTypeSchema = z.discriminatedUnion('artifactType', [
+    z.object({
+        artifactType: z.literal(ArtifactType.DEPLOYMENT),
+        artifact: deploymentArtifactSchema,
+    }),
+    z.object({
+        artifactType: z.literal(ArtifactType.VERIFICATION),
+        artifact: z.any(),
+    }),
+    z.object({
+        artifactType: z.literal(ArtifactType.METADATA),
+        // not implemented yet
+        artifact: z.never(),
+    }),
+]);
+
+export type ArtifactWithType = z.infer<typeof artifactWithTypeSchema>;

package/src/deploy/index.ts

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

package/src/deploy/resourceBuilder.ts

@@ -1,20 +1,20 @@
-import type { z } from 'zod/v4';
+import type { z } from 'zod';
 
 import type {
     BaseContractResource,
     BaseMeshResource,
     baseResourceSchema,
-    ContractResourceDependency,
-    MeshResourceDependency,
+    ContractResourceReference,
+    MeshResourceReference,
 } from './resources';
 
 export type ContractResourceBuilderResult<Resource extends BaseContractResource> = {
-    id: ContractResourceDependency<Resource>;
+    ref: () => ContractResourceReference<Resource>;
     build: () => Resource;
 };
 
 export type MeshResourceBuilderResult<Resource extends BaseMeshResource> = {
-    id: MeshResourceDependency<Resource>;
+    ref: () => MeshResourceReference<Resource>;
     build: () => Resource;
 };
 
@@ -38,22 +38,13 @@ export const createResourceBuilder =
           : never => {
         if (resourceBaseType === 'CONTRACT') {
             return {
-                id: {
-                    __CONTRACT_RESOURCE_DEPENDENCY: true,
-                    __dependencyType: null as any,
-                    id: resource.id,
-                },
+                ref: () => `#C_REF:${resource.id}` as any,
                 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,
-                },
+                ref: () => `#M_REF:${resource.id}` as any,
                 build: () => ({ ...resource, type, resourceBaseType }),
             } satisfies MeshResourceBuilderResult<any> as any;
         }

package/src/deploy/resources.ts

@@ -1,6 +1,7 @@
-import z from 'zod/v4';
+import z from 'zod';
 
 import type { NormalizedHexString } from '@layerzerolabs/common-chain-model';
+import { throwError } from '@layerzerolabs/common-error-utils';
 import { ChainName } from '@layerzerolabs/layerzero-definitions';
 import type { IsAny } from '@layerzerolabs/typescript-utils';
 
@@ -31,82 +32,104 @@ 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;
+// the actual expected runtime value for this type is #C_REF:${id}
+export type ContractResourceReference<T extends BaseContractResource = BaseContractResource> = {
+    /** WARNING: these fields are not present at runtime */
+    __resourceReferenceType: T;
+    ['__CONTRACT_RESOURCE_REFERENCE']: true;
 };
 
-export const isContractResourceDependency = (o: any): o is ContractResourceDependency =>
-    o != null &&
-    typeof o === 'object' &&
-    (o as ContractResourceDependency).__CONTRACT_RESOURCE_DEPENDENCY;
+export const extractIdFromContractResourceReference = (ref: ContractResourceReference) =>
+    ((ref as unknown as string).startsWith('#C_REF:') &&
+        (ref as unknown as string).slice('#C_REF:'.length)) ||
+    throwError(`Ref ${JSON.stringify(ref)} is not a contract resource ref`);
 
-export type ContractResourceDependencySchema<T extends typeof baseContractResourceSchema> =
-    z.ZodType<ContractResourceDependency<z.infer<T>>>;
+export type ContractResourceReferenceSchema<T extends typeof baseContractResourceSchema> =
+    z.ZodType<ContractResourceReference<z.infer<T>>>;
 
-export const contractResourceDependencySchema: ContractResourceDependencySchema<
+export const contractResourceReferenceSchema: ContractResourceReferenceSchema<
     typeof baseContractResourceSchema
-> = z.custom<ContractResourceDependency>(isContractResourceDependency);
-
-export const contractResourceDependencySchemaFor = <T extends typeof baseContractResourceSchema>(
+    // at runtime, we expect a string
+> = z.string().meta({
+    id: 'contract-resource-dependency',
+    title: 'Contract dependency to any',
+    description: 'A reference to another contract resource (any)',
+}) as unknown as z.ZodType<ContractResourceReference>;
+
+let contractResourceDependencyForSchemaZodMetaIdIdx = 0;
+export const contractResourceReferenceSchemaFor = <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> = {
+): ContractResourceReferenceSchema<T> =>
+    z.string().meta({
+        id: `contract-resource-dependency-for-${++contractResourceDependencyForSchemaZodMetaIdIdx}`,
+        // we can't generate this properly yet because this function needs more information
+        // will be fixed when we clean up the runtime of dependencies id
+        title: 'Contract dependency to (unknown)',
+        description: 'A reference to another contract resource (unknown)',
+    }) as unknown as z.ZodType<ContractResourceReference<z.infer<T>>>;
+
+export type ResolvedContractResourceReference<T extends BaseContractResource> = {
     id: string;
     resource: T;
     address: NormalizedHexString;
 };
 
-export type ResolvedContractResourceDependencySchema<T extends typeof baseContractResourceSchema> =
-    z.ZodType<ResolvedContractResourceDependency<z.infer<T>>>;
+export type ResolvedContractResourceReferenceSchema<T extends typeof baseContractResourceSchema> =
+    z.ZodType<ResolvedContractResourceReference<z.infer<T>>>;
 
-export const resolvedContractResourceDependencySchema: ResolvedContractResourceDependencySchema<any> =
+export const resolvedContractResourceReferenceSchema: ResolvedContractResourceReferenceSchema<any> =
     // FIXME could be a real schema
-    z.custom<ResolvedContractResourceDependency<any>>();
+    z.custom<ResolvedContractResourceReference<any>>();
 
-export type MeshResourceDependency<T extends BaseMeshResource = BaseMeshResource> = {
-    id: string;
-    /** WARNING: this field is not present at runtime */
-    __dependencyType: T;
-    ['__MESH_RESOURCE_DEPENDENCY']: true;
+// the actual expected runtime value for this type is #M_REF:${id}
+export type MeshResourceReference<T extends BaseMeshResource = BaseMeshResource> = {
+    /** WARNING: these fields are not present at runtime */
+    __resourceReferenceType: T;
+    ['__MESH_RESOURCE_REFERENCE']: 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 type MeshResourceReferenceSchema<T extends typeof baseMeshResourceSchema> = z.ZodType<
+    MeshResourceReference<z.infer<T>>
 >;
 
-export const meshResourceDependencySchema: MeshResourceDependencySchema<
+export const meshResourceReferenceSchema: MeshResourceReferenceSchema<
     typeof baseMeshResourceSchema
-> = z.custom<MeshResourceDependency>(isMeshResourceDependency);
-
-export const meshResourceDependencySchemaFor = <T extends typeof baseMeshResourceSchema>(
+> = z.string().meta({
+    id: 'mesh-resource-dependency',
+    title: 'Mesh dependency to any',
+    description: 'A reference to another mesh resource (any)',
+}) as unknown as z.ZodType<MeshResourceReference>;
+
+let meshResourceDependencyForSchemaZodMetaIdIdx = 0;
+export const meshResourceReferenceSchemaFor = <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> = {
+): MeshResourceReferenceSchema<T> =>
+    z.string().meta({
+        id: `mesh-resource-dependency-for-${++meshResourceDependencyForSchemaZodMetaIdIdx}`,
+        title: 'Mesh dependency to (unknown)',
+        description: 'A reference to another mesh resource (unknown)',
+    }) as unknown as z.ZodType<MeshResourceReference<z.infer<T>>>;
+
+export type ResolvedMeshResourceReference<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> =
+export const extractIdFromMeshResourceReference = (ref: MeshResourceReference) =>
+    ((ref as unknown as string).startsWith('#M_REF:') &&
+        (ref as unknown as string).slice('#M_REF:'.length)) ||
+    throwError(`Ref ${JSON.stringify(ref)} is not a mesh resource ref`);
+
+export type ResolvedMeshResourceReferenceSchema<T extends typeof baseMeshResourceSchema> =
     // FIXME could be a real schema
-    z.ZodType<ResolvedMeshResourceDependency<z.infer<T>>>;
+    z.ZodType<ResolvedMeshResourceReference<z.infer<T>>>;
 
-export const resolvedMeshResourceDependencySchema: ResolvedMeshResourceDependencySchema<any> =
-    z.custom<ResolvedMeshResourceDependency<any>>();
+export const resolvedMeshResourceReferenceSchema: ResolvedMeshResourceReferenceSchema<any> =
+    z.custom<ResolvedMeshResourceReference<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
@@ -114,21 +137,20 @@ export type ResolvedResourceSchema<Resource extends typeof baseResourceSchema> =
                 ? 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 extends ContractResourceReferenceSchema<infer I>
+                    ? ResolvedContractResourceReferenceSchema<I>
+                    : R extends z.ZodOptional<ContractResourceReferenceSchema<infer I>>
+                      ? z.ZodOptional<ResolvedContractResourceReferenceSchema<I>>
+                      : R extends MeshResourceReferenceSchema<infer I>
+                        ? ResolvedMeshResourceReferenceSchema<I>
+                        : R extends z.ZodOptional<MeshResourceReferenceSchema<infer I>>
+                          ? z.ZodOptional<ResolvedMeshResourceReferenceSchema<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
@@ -137,33 +159,29 @@ export type ResolvedResource<Resource extends BaseResource> = {
               ? 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 extends ContractResourceReference<infer I>
+                  ? ResolvedContractResourceReference<I>
+                  : R extends ContractResourceReference<infer I> | undefined
+                    ? ResolvedContractResourceReference<I> | undefined
+                    : R extends MeshResourceReference<infer I>
+                      ? ResolvedMeshResourceReference<I>
+                      : R extends MeshResourceReference<infer I> | undefined
+                        ? ResolvedMeshResourceReference<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>(
+export const extractContractResourceReferences = <Resource extends BaseResource>(
     resource: Resource,
 ) =>
-    Object.entries(resource).filter(([, id]) => isMeshResourceDependency(id)) as unknown as [
-        prop: string,
-        id: MeshResourceDependency,
-    ][];
+    Object.entries(resource).filter(
+        ([, id]) => typeof id === 'string' && id.startsWith('#C_REF:'),
+    ) as unknown as [prop: string, id: ContractResourceReference][];
+
+export const extractMeshResourceReferences = <Resource extends BaseResource>(resource: Resource) =>
+    Object.entries(resource).filter(
+        ([, id]) => typeof id === 'string' && id.startsWith('#M_REF:'),
+    ) as unknown as [prop: string, id: MeshResourceReference][];
 
 // FIXME implement runtime
 export const createResolvedResourceSchema = <Resource extends typeof baseResourceSchema>(