@layerzerolabs/dw-model 0.2.21 → 0.2.23

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

@@ -39,6 +39,11 @@ export declare const generateHasRoleSchema: <const T extends readonly [string, .
     role: ({ [k_1 in T[number]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: { [k_1 in T[number]]: k_1; }[k]; } : never)[T[number]];
     accountAddress: import("@layerzerolabs/common-chain-model").NormalizedHexString;
 }) => Promise<boolean>, unknown>>;
+export declare const generateGetRoleMembersSchema: <const T extends readonly [string, ...string[]]>(roles: T) => z.ZodType<(args_0: {
+    role: ({ [k_1 in T[number]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: { [k_1 in T[number]]: k_1; }[k]; } : never)[T[number]];
+}) => Promise<import("@layerzerolabs/common-chain-model").NormalizedHexString[]>, unknown, z.core.$ZodTypeInternals<(args_0: {
+    role: ({ [k_1 in T[number]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: { [k_1 in T[number]]: k_1; }[k]; } : never)[T[number]];
+}) => Promise<import("@layerzerolabs/common-chain-model").NormalizedHexString[]>, unknown>>;
 export declare const generateRoleManagementSchemas: <const T extends readonly [string, ...string[]]>(roles: T) => {
     createSetRoleTransactions: z.ZodType<(args_0: {
         role: ({ [k_1 in T[number]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: { [k_1 in T[number]]: k_1; }[k]; } : never)[T[number]];
@@ -81,6 +86,53 @@ export declare const generateRoleManagementSchemas: <const T extends readonly [s
         accountAddress: import("@layerzerolabs/common-chain-model").NormalizedHexString;
     }) => Promise<boolean>, unknown>>;
 };
+export declare const generateEnumerableRoleManagementSchemas: <const T extends readonly [string, ...string[]]>(roles: T) => {
+    getRoleMembers: z.ZodType<(args_0: {
+        role: ({ [k_1 in T[number]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: { [k_1 in T[number]]: k_1; }[k]; } : never)[T[number]];
+    }) => Promise<import("@layerzerolabs/common-chain-model").NormalizedHexString[]>, unknown, z.core.$ZodTypeInternals<(args_0: {
+        role: ({ [k_1 in T[number]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: { [k_1 in T[number]]: k_1; }[k]; } : never)[T[number]];
+    }) => Promise<import("@layerzerolabs/common-chain-model").NormalizedHexString[]>, unknown>>;
+    createSetRoleTransactions: z.ZodType<(args_0: {
+        role: ({ [k_1 in T[number]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: { [k_1 in T[number]]: k_1; }[k]; } : never)[T[number]];
+        accountAddress: import("@layerzerolabs/common-chain-model").NormalizedHexString;
+        shouldGrant: boolean;
+    }) => Promise<import("@layerzerolabs/gated-transaction").GatedTransaction<string, {
+        chainName: string;
+        timestamps: {
+            created: number;
+            nonceAcquired?: number | undefined;
+            signed?: number | undefined;
+            sent?: number | undefined;
+            confirmed?: number | undefined;
+        };
+        properties?: Record<string, any> | undefined;
+        type?: string | undefined;
+        parallelizingKey?: string | undefined;
+    }, (...args: any[]) => any, (txs: any, ...args: any[]) => Promise<any>, import("@layerzerolabs/gated-transaction").GatedTransactionDependencies>[]>, unknown, z.core.$ZodTypeInternals<(args_0: {
+        role: ({ [k_1 in T[number]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: { [k_1 in T[number]]: k_1; }[k]; } : never)[T[number]];
+        accountAddress: import("@layerzerolabs/common-chain-model").NormalizedHexString;
+        shouldGrant: boolean;
+    }) => Promise<import("@layerzerolabs/gated-transaction").GatedTransaction<string, {
+        chainName: string;
+        timestamps: {
+            created: number;
+            nonceAcquired?: number | undefined;
+            signed?: number | undefined;
+            sent?: number | undefined;
+            confirmed?: number | undefined;
+        };
+        properties?: Record<string, any> | undefined;
+        type?: string | undefined;
+        parallelizingKey?: string | undefined;
+    }, (...args: any[]) => any, (txs: any, ...args: any[]) => Promise<any>, import("@layerzerolabs/gated-transaction").GatedTransactionDependencies>[]>, unknown>>;
+    hasRole: z.ZodType<(args_0: {
+        role: ({ [k_1 in T[number]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: { [k_1 in T[number]]: k_1; }[k]; } : never)[T[number]];
+        accountAddress: import("@layerzerolabs/common-chain-model").NormalizedHexString;
+    }) => Promise<boolean>, unknown, z.core.$ZodTypeInternals<(args_0: {
+        role: ({ [k_1 in T[number]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: { [k_1 in T[number]]: k_1; }[k]; } : never)[T[number]];
+        accountAddress: import("@layerzerolabs/common-chain-model").NormalizedHexString;
+    }) => Promise<boolean>, unknown>>;
+};
 export declare const createSetRoleTransactionsWithSpecializedInputSchema: z.ZodType<(args_0: {
     address: import("@layerzerolabs/common-chain-model").NormalizedHexString;
 }, args_1: {
@@ -129,6 +181,16 @@ export declare const hasRoleWithSpecializedInputSchema: z.ZodType<(args_0: {
     role: string;
     accountAddress: import("@layerzerolabs/common-chain-model").NormalizedHexString;
 }) => Promise<boolean>, unknown>>;
+export declare const getRoleMembersWithSpecializedInputSchema: z.ZodType<(args_0: {
+    address: import("@layerzerolabs/common-chain-model").NormalizedHexString;
+}, args_1: {
+    role: string;
+}) => Promise<import("@layerzerolabs/common-chain-model").NormalizedHexString[]>, unknown, z.core.$ZodTypeInternals<(args_0: {
+    address: import("@layerzerolabs/common-chain-model").NormalizedHexString;
+}, args_1: {
+    role: string;
+}) => Promise<import("@layerzerolabs/common-chain-model").NormalizedHexString[]>, unknown>>;
 export type CreateSetRoleTransactionsWithSpecializedInput = z.infer<typeof createSetRoleTransactionsWithSpecializedInputSchema>;
 export type HasRoleWithSpecializedInput = z.infer<typeof hasRoleWithSpecializedInputSchema>;
+export type GetRoleMembersWithSpecializedInput = z.infer<typeof getRoleMembersWithSpecializedInputSchema>;
 //# sourceMappingURL=schemata.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"schemata.d.ts","sourceRoot":"","sources":["../../src/role-management/schemata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,uCAAuC,GAChD,KAAK,CAAC,CAAC,SAAS,SAAS,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,EAE9C,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8JAgBN,CAAC;AAEP,eAAO,MAAM,qBAAqB,GAAI,KAAK,CAAC,CAAC,SAAS,SAAS,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,EAAE,OAAO,CAAC;;;;;;iCASxF,CAAC;AAEP,eAAO,MAAM,6BAA6B,GAAI,KAAK,CAAC,CAAC,SAAS,SAAS,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,EACxF,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIV,CAAC;AAEH,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8JAiB9D,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;;;;;;;;iCAW5C,CAAC;AAEH,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CAC/D,OAAO,mDAAmD,CAC7D,CAAC;AACF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC"}
+{"version":3,"file":"schemata.d.ts","sourceRoot":"","sources":["../../src/role-management/schemata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,uCAAuC,GAChD,KAAK,CAAC,CAAC,SAAS,SAAS,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,EAE9C,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8JAgBN,CAAC;AAEP,eAAO,MAAM,qBAAqB,GAAI,KAAK,CAAC,CAAC,SAAS,SAAS,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,EAAE,OAAO,CAAC;;;;;;iCASxF,CAAC;AAEP,eAAO,MAAM,4BAA4B,GAAI,KAAK,CAAC,CAAC,SAAS,SAAS,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,EACvF,OAAO,CAAC;;;;2FASN,CAAC;AAEP,eAAO,MAAM,6BAA6B,GAAI,KAAK,CAAC,CAAC,SAAS,SAAS,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,EACxF,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIV,CAAC;AAEH,eAAO,MAAM,uCAAuC,GAChD,KAAK,CAAC,CAAC,SAAS,SAAS,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,EAE9C,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIV,CAAC;AAEH,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8JAiB9D,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;;;;;;;;iCAW5C,CAAC;AAEH,eAAO,MAAM,wCAAwC;;;;;;;;2FAUnD,CAAC;AAEH,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CAC/D,OAAO,mDAAmD,CAC7D,CAAC;AACF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAC5F,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACpD,OAAO,wCAAwC,CAClD,CAAC"}

package/dist/role-management/schemata.js

@@ -1,4 +1,4 @@
-export { createSetRoleTransactionsWithSpecializedInputSchema, generateCreateSetRoleTransactionsSchema, generateHasRoleSchema, generateRoleManagementSchemas, hasRoleWithSpecializedInputSchema } from '../UE2N6Q3B.js';
+export { createSetRoleTransactionsWithSpecializedInputSchema, generateCreateSetRoleTransactionsSchema, generateEnumerableRoleManagementSchemas, generateGetRoleMembersSchema, generateHasRoleSchema, generateRoleManagementSchemas, getRoleMembersWithSpecializedInputSchema, hasRoleWithSpecializedInputSchema } from '../3XCIUHJG.js';
 import '../VUOMXK5T.js';
 //# sourceMappingURL=schemata.js.map
 //# sourceMappingURL=schemata.js.map

package/dist/upgrade/index.cjs

@@ -1,46 +1,74 @@
 'use strict';
 
 require('../IN5O3BJZ.cjs');
-var WYAGX6NX_cjs = require('../WYAGX6NX.cjs');
+var S5CHYZ3I_cjs = require('../S5CHYZ3I.cjs');
 require('../YJF4D23A.cjs');
 
 
 
 Object.defineProperty(exports, "EvmProxyType", {
   enumerable: true,
-  get: function () { return WYAGX6NX_cjs.EvmProxyType; }
+  get: function () { return S5CHYZ3I_cjs.EvmProxyType; }
 });
 Object.defineProperty(exports, "ProxyType", {
   enumerable: true,
-  get: function () { return WYAGX6NX_cjs.ProxyType; }
+  get: function () { return S5CHYZ3I_cjs.ProxyType; }
+});
+Object.defineProperty(exports, "SEPARATE_PROXY_ADMIN_TYPES", {
+  enumerable: true,
+  get: function () { return S5CHYZ3I_cjs.SEPARATE_PROXY_ADMIN_TYPES; }
+});
+Object.defineProperty(exports, "TUP_PROXY_TYPES", {
+  enumerable: true,
+  get: function () { return S5CHYZ3I_cjs.TUP_PROXY_TYPES; }
+});
+Object.defineProperty(exports, "UUPS_PROXY_TYPES", {
+  enumerable: true,
+  get: function () { return S5CHYZ3I_cjs.UUPS_PROXY_TYPES; }
 });
 Object.defineProperty(exports, "UpgradeType", {
   enumerable: true,
-  get: function () { return WYAGX6NX_cjs.UpgradeType; }
+  get: function () { return S5CHYZ3I_cjs.UpgradeType; }
 });
 Object.defineProperty(exports, "codeUpgradeableConfigSchema", {
   enumerable: true,
-  get: function () { return WYAGX6NX_cjs.codeUpgradeableConfigSchema; }
+  get: function () { return S5CHYZ3I_cjs.codeUpgradeableConfigSchema; }
+});
+Object.defineProperty(exports, "initializeDataResultSchema", {
+  enumerable: true,
+  get: function () { return S5CHYZ3I_cjs.initializeDataResultSchema; }
+});
+Object.defineProperty(exports, "isTupProxy", {
+  enumerable: true,
+  get: function () { return S5CHYZ3I_cjs.isTupProxy; }
+});
+Object.defineProperty(exports, "isUupsProxy", {
+  enumerable: true,
+  get: function () { return S5CHYZ3I_cjs.isUupsProxy; }
 });
 Object.defineProperty(exports, "notUpgradeableConfigSchema", {
   enumerable: true,
-  get: function () { return WYAGX6NX_cjs.notUpgradeableConfigSchema; }
+  get: function () { return S5CHYZ3I_cjs.notUpgradeableConfigSchema; }
 });
 Object.defineProperty(exports, "proxyConfigSchema", {
   enumerable: true,
-  get: function () { return WYAGX6NX_cjs.proxyConfigSchema; }
+  get: function () { return S5CHYZ3I_cjs.proxyConfigSchema; }
 });
 Object.defineProperty(exports, "proxyTypeSchema", {
   enumerable: true,
-  get: function () { return WYAGX6NX_cjs.proxyTypeSchema; }
+  get: function () { return S5CHYZ3I_cjs.proxyTypeSchema; }
+});
+Object.defineProperty(exports, "requiresSeparateProxyAdminDeploy", {
+  enumerable: true,
+  get: function () { return S5CHYZ3I_cjs.requiresSeparateProxyAdminDeploy; }
 });
 Object.defineProperty(exports, "upgradeTypeSchema", {
   enumerable: true,
-  get: function () { return WYAGX6NX_cjs.upgradeTypeSchema; }
+  get: function () { return S5CHYZ3I_cjs.upgradeTypeSchema; }
 });
 Object.defineProperty(exports, "upgradeableConfigSchema", {
   enumerable: true,
-  get: function () { return WYAGX6NX_cjs.upgradeableConfigSchema; }
+  get: function () { return S5CHYZ3I_cjs.upgradeableConfigSchema; }
 });
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map

package/dist/upgrade/index.js

@@ -1,5 +1,5 @@
 import '../ZCFXJFGI.js';
-export { EvmProxyType, ProxyType, UpgradeType, codeUpgradeableConfigSchema, notUpgradeableConfigSchema, proxyConfigSchema, proxyTypeSchema, upgradeTypeSchema, upgradeableConfigSchema } from '../RDYET6CZ.js';
+export { EvmProxyType, ProxyType, SEPARATE_PROXY_ADMIN_TYPES, TUP_PROXY_TYPES, UUPS_PROXY_TYPES, UpgradeType, codeUpgradeableConfigSchema, initializeDataResultSchema, isTupProxy, isUupsProxy, notUpgradeableConfigSchema, proxyConfigSchema, proxyTypeSchema, requiresSeparateProxyAdminDeploy, upgradeTypeSchema, upgradeableConfigSchema } from '../46VB3YIH.js';
 import '../VUOMXK5T.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/upgrade/types.cjs

@@ -1,45 +1,73 @@
 'use strict';
 
-var WYAGX6NX_cjs = require('../WYAGX6NX.cjs');
+var S5CHYZ3I_cjs = require('../S5CHYZ3I.cjs');
 require('../YJF4D23A.cjs');
 
 
 
 Object.defineProperty(exports, "EvmProxyType", {
   enumerable: true,
-  get: function () { return WYAGX6NX_cjs.EvmProxyType; }
+  get: function () { return S5CHYZ3I_cjs.EvmProxyType; }
 });
 Object.defineProperty(exports, "ProxyType", {
   enumerable: true,
-  get: function () { return WYAGX6NX_cjs.ProxyType; }
+  get: function () { return S5CHYZ3I_cjs.ProxyType; }
+});
+Object.defineProperty(exports, "SEPARATE_PROXY_ADMIN_TYPES", {
+  enumerable: true,
+  get: function () { return S5CHYZ3I_cjs.SEPARATE_PROXY_ADMIN_TYPES; }
+});
+Object.defineProperty(exports, "TUP_PROXY_TYPES", {
+  enumerable: true,
+  get: function () { return S5CHYZ3I_cjs.TUP_PROXY_TYPES; }
+});
+Object.defineProperty(exports, "UUPS_PROXY_TYPES", {
+  enumerable: true,
+  get: function () { return S5CHYZ3I_cjs.UUPS_PROXY_TYPES; }
 });
 Object.defineProperty(exports, "UpgradeType", {
   enumerable: true,
-  get: function () { return WYAGX6NX_cjs.UpgradeType; }
+  get: function () { return S5CHYZ3I_cjs.UpgradeType; }
 });
 Object.defineProperty(exports, "codeUpgradeableConfigSchema", {
   enumerable: true,
-  get: function () { return WYAGX6NX_cjs.codeUpgradeableConfigSchema; }
+  get: function () { return S5CHYZ3I_cjs.codeUpgradeableConfigSchema; }
+});
+Object.defineProperty(exports, "initializeDataResultSchema", {
+  enumerable: true,
+  get: function () { return S5CHYZ3I_cjs.initializeDataResultSchema; }
+});
+Object.defineProperty(exports, "isTupProxy", {
+  enumerable: true,
+  get: function () { return S5CHYZ3I_cjs.isTupProxy; }
+});
+Object.defineProperty(exports, "isUupsProxy", {
+  enumerable: true,
+  get: function () { return S5CHYZ3I_cjs.isUupsProxy; }
 });
 Object.defineProperty(exports, "notUpgradeableConfigSchema", {
   enumerable: true,
-  get: function () { return WYAGX6NX_cjs.notUpgradeableConfigSchema; }
+  get: function () { return S5CHYZ3I_cjs.notUpgradeableConfigSchema; }
 });
 Object.defineProperty(exports, "proxyConfigSchema", {
   enumerable: true,
-  get: function () { return WYAGX6NX_cjs.proxyConfigSchema; }
+  get: function () { return S5CHYZ3I_cjs.proxyConfigSchema; }
 });
 Object.defineProperty(exports, "proxyTypeSchema", {
   enumerable: true,
-  get: function () { return WYAGX6NX_cjs.proxyTypeSchema; }
+  get: function () { return S5CHYZ3I_cjs.proxyTypeSchema; }
+});
+Object.defineProperty(exports, "requiresSeparateProxyAdminDeploy", {
+  enumerable: true,
+  get: function () { return S5CHYZ3I_cjs.requiresSeparateProxyAdminDeploy; }
 });
 Object.defineProperty(exports, "upgradeTypeSchema", {
   enumerable: true,
-  get: function () { return WYAGX6NX_cjs.upgradeTypeSchema; }
+  get: function () { return S5CHYZ3I_cjs.upgradeTypeSchema; }
 });
 Object.defineProperty(exports, "upgradeableConfigSchema", {
   enumerable: true,
-  get: function () { return WYAGX6NX_cjs.upgradeableConfigSchema; }
+  get: function () { return S5CHYZ3I_cjs.upgradeableConfigSchema; }
 });
 //# sourceMappingURL=types.cjs.map
 //# sourceMappingURL=types.cjs.map

package/dist/upgrade/types.d.ts

@@ -1,28 +1,70 @@
 import z from 'zod';
+import type { DecimalString, HexString } from '@layerzerolabs/typescript-utils';
+/**
+ * Result type for `getInitializeData` function pointer.
+ * Contains the encoded initialization data and an optional gas limit override.
+ */
+export interface InitializeDataResult {
+    /** Encoded initialization data (e.g., encodeFunctionData for initialize(...)) */
+    data: HexString;
+    /** Optional gas limit override for the initialization transaction */
+    gasLimit?: DecimalString;
+}
+/**
+ * `InitializeDataResult` schema.
+ */
+export declare const initializeDataResultSchema: z.ZodObject<{
+    data: z.ZodType<`0x${string}`, unknown, z.core.$ZodTypeInternals<`0x${string}`, unknown>>;
+    gasLimit: z.ZodOptional<z.ZodType<DecimalString, unknown, z.core.$ZodTypeInternals<DecimalString, unknown>>>;
+}, z.core.$strip>;
 export declare enum UpgradeType {
     NOT_UPGRADEABLE = "NOT_UPGRADEABLE",
     PROXY = "PROXY",
     CODE_UPGRADE = "CODE_UPGRADE"
 }
 export declare enum EvmProxyType {
-    TRANSPARENT_UPGRADEABLE = "TRANSPARENT_UPGRADEABLE",
-    UNIVERSAL_UPGRADEABLE = "UNIVERSAL_UPGRADEABLE"
+    TRANSPARENT_UPGRADEABLE_V5 = "TRANSPARENT_UPGRADEABLE_V5",
+    UNIVERSAL_UPGRADEABLE_V5 = "UNIVERSAL_UPGRADEABLE_V5",
+    OPTIMIZED_TRANSPARENT_UPGRADEABLE_V4 = "OPTIMIZED_TRANSPARENT_UPGRADEABLE_V4",
+    TRANSPARENT_UPGRADEABLE_V4 = "TRANSPARENT_UPGRADEABLE_V4",
+    UNIVERSAL_UPGRADEABLE_V4 = "UNIVERSAL_UPGRADEABLE_V4"
 }
+/** UUPS-based proxy types (no separate `ProxyAdmin`). */
+export declare const UUPS_PROXY_TYPES: ReadonlySet<EvmProxyType>;
+/** TUP-based proxy types (have a `ProxyAdmin` with `getOwner`/`setOwner`). */
+export declare const TUP_PROXY_TYPES: ReadonlySet<EvmProxyType>;
+/** Proxy types that deploy a separate `ProxyAdmin` contract (v4 variants only). */
+export declare const SEPARATE_PROXY_ADMIN_TYPES: ReadonlySet<EvmProxyType>;
+/** Whether the proxy type is UUPS (Universal Upgradeable Proxy Standard). */
+export declare const isUupsProxy: (proxyType: EvmProxyType) => boolean;
+/** Whether the proxy type is TUP (Transparent Upgradeable Proxy). */
+export declare const isTupProxy: (proxyType: EvmProxyType) => boolean;
+/** Whether the proxy type requires a separate `ProxyAdmin` deployment (v4 variants). */
+export declare const requiresSeparateProxyAdminDeploy: (proxyType: EvmProxyType) => boolean;
 export declare const ProxyType: {
-    TRANSPARENT_UPGRADEABLE: EvmProxyType.TRANSPARENT_UPGRADEABLE;
-    UNIVERSAL_UPGRADEABLE: EvmProxyType.UNIVERSAL_UPGRADEABLE;
+    TRANSPARENT_UPGRADEABLE_V5: EvmProxyType.TRANSPARENT_UPGRADEABLE_V5;
+    UNIVERSAL_UPGRADEABLE_V5: EvmProxyType.UNIVERSAL_UPGRADEABLE_V5;
+    OPTIMIZED_TRANSPARENT_UPGRADEABLE_V4: EvmProxyType.OPTIMIZED_TRANSPARENT_UPGRADEABLE_V4;
+    TRANSPARENT_UPGRADEABLE_V4: EvmProxyType.TRANSPARENT_UPGRADEABLE_V4;
+    UNIVERSAL_UPGRADEABLE_V4: EvmProxyType.UNIVERSAL_UPGRADEABLE_V4;
 };
 export type ProxyType = (typeof ProxyType)[keyof typeof ProxyType];
 export declare const upgradeTypeSchema: z.ZodEnum<typeof UpgradeType>;
 export declare const proxyTypeSchema: z.ZodEnum<{
-    TRANSPARENT_UPGRADEABLE: EvmProxyType.TRANSPARENT_UPGRADEABLE;
-    UNIVERSAL_UPGRADEABLE: EvmProxyType.UNIVERSAL_UPGRADEABLE;
+    TRANSPARENT_UPGRADEABLE_V5: EvmProxyType.TRANSPARENT_UPGRADEABLE_V5;
+    UNIVERSAL_UPGRADEABLE_V5: EvmProxyType.UNIVERSAL_UPGRADEABLE_V5;
+    OPTIMIZED_TRANSPARENT_UPGRADEABLE_V4: EvmProxyType.OPTIMIZED_TRANSPARENT_UPGRADEABLE_V4;
+    TRANSPARENT_UPGRADEABLE_V4: EvmProxyType.TRANSPARENT_UPGRADEABLE_V4;
+    UNIVERSAL_UPGRADEABLE_V4: EvmProxyType.UNIVERSAL_UPGRADEABLE_V4;
 }>;
 export declare const proxyConfigSchema: z.ZodObject<{
     upgradeType: z.ZodLiteral<UpgradeType.PROXY>;
     proxyType: z.ZodEnum<{
-        TRANSPARENT_UPGRADEABLE: EvmProxyType.TRANSPARENT_UPGRADEABLE;
-        UNIVERSAL_UPGRADEABLE: EvmProxyType.UNIVERSAL_UPGRADEABLE;
+        TRANSPARENT_UPGRADEABLE_V5: EvmProxyType.TRANSPARENT_UPGRADEABLE_V5;
+        UNIVERSAL_UPGRADEABLE_V5: EvmProxyType.UNIVERSAL_UPGRADEABLE_V5;
+        OPTIMIZED_TRANSPARENT_UPGRADEABLE_V4: EvmProxyType.OPTIMIZED_TRANSPARENT_UPGRADEABLE_V4;
+        TRANSPARENT_UPGRADEABLE_V4: EvmProxyType.TRANSPARENT_UPGRADEABLE_V4;
+        UNIVERSAL_UPGRADEABLE_V4: EvmProxyType.UNIVERSAL_UPGRADEABLE_V4;
     }>;
 }, z.core.$strip>;
 export type ProxyUpgradeableConfig = z.infer<typeof proxyConfigSchema>;
@@ -37,8 +79,11 @@ export type CodeUpgradeableConfig = z.infer<typeof codeUpgradeableConfigSchema>;
 export declare const upgradeableConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     upgradeType: z.ZodLiteral<UpgradeType.PROXY>;
     proxyType: z.ZodEnum<{
-        TRANSPARENT_UPGRADEABLE: EvmProxyType.TRANSPARENT_UPGRADEABLE;
-        UNIVERSAL_UPGRADEABLE: EvmProxyType.UNIVERSAL_UPGRADEABLE;
+        TRANSPARENT_UPGRADEABLE_V5: EvmProxyType.TRANSPARENT_UPGRADEABLE_V5;
+        UNIVERSAL_UPGRADEABLE_V5: EvmProxyType.UNIVERSAL_UPGRADEABLE_V5;
+        OPTIMIZED_TRANSPARENT_UPGRADEABLE_V4: EvmProxyType.OPTIMIZED_TRANSPARENT_UPGRADEABLE_V4;
+        TRANSPARENT_UPGRADEABLE_V4: EvmProxyType.TRANSPARENT_UPGRADEABLE_V4;
+        UNIVERSAL_UPGRADEABLE_V4: EvmProxyType.UNIVERSAL_UPGRADEABLE_V4;
     }>;
 }, z.core.$strip>, z.ZodObject<{
     upgradeType: z.ZodLiteral<UpgradeType.NOT_UPGRADEABLE>;

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,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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/upgrade/types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAGpB,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAEhF;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACjC,iFAAiF;IACjF,IAAI,EAAE,SAAS,CAAC;IAChB,qEAAqE;IACrE,QAAQ,CAAC,EAAE,aAAa,CAAC;CAC5B;AAED;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;iBAGrC,CAAC;AAEH,oBAAY,WAAW;IAEnB,eAAe,oBAAoB;IAEnC,KAAK,UAAU;IAEf,YAAY,iBAAiB;CAChC;AAED,oBAAY,YAAY;IAEpB,0BAA0B,+BAA+B;IAEzD,wBAAwB,6BAA6B;IAErD,oCAAoC,yCAAyC;IAE7E,0BAA0B,+BAA+B;IAEzD,wBAAwB,6BAA6B;CACxD;AAED,yDAAyD;AACzD,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,YAAY,CAGrD,CAAC;AAEH,8EAA8E;AAC9E,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,YAAY,CAIpD,CAAC;AAEH,mFAAmF;AACnF,eAAO,MAAM,0BAA0B,EAAE,WAAW,CAAC,YAAY,CAG/D,CAAC;AAEH,6EAA6E;AAC7E,eAAO,MAAM,WAAW,GAAI,WAAW,YAAY,KAAG,OAA0C,CAAC;AAEjG,qEAAqE;AACrE,eAAO,MAAM,UAAU,GAAI,WAAW,YAAY,KAAG,OAAyC,CAAC;AAE/F,wFAAwF;AACxF,eAAO,MAAM,gCAAgC,GAAI,WAAW,YAAY,KAAG,OAC9B,CAAC;AAE9C,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 '../RDYET6CZ.js';
+export { EvmProxyType, ProxyType, SEPARATE_PROXY_ADMIN_TYPES, TUP_PROXY_TYPES, UUPS_PROXY_TYPES, UpgradeType, codeUpgradeableConfigSchema, initializeDataResultSchema, isTupProxy, isUupsProxy, notUpgradeableConfigSchema, proxyConfigSchema, proxyTypeSchema, requiresSeparateProxyAdminDeploy, upgradeTypeSchema, upgradeableConfigSchema } from '../46VB3YIH.js';
 import '../VUOMXK5T.js';
 //# sourceMappingURL=types.js.map
 //# sourceMappingURL=types.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/dw-model",
-  "version": "0.2.21",
+  "version": "0.2.23",
   "private": false,
   "license": "MIT",
   "type": "module",
@@ -15,19 +15,19 @@
   "types": "./dist/index.d.ts",
   "dependencies": {
     "zod": "4.3.5",
-    "@layerzerolabs/common-chain-model": "0.2.21",
-    "@layerzerolabs/gated-transaction": "0.2.21",
-    "@layerzerolabs/layerzero-definitions": "0.2.21",
-    "@layerzerolabs/typescript-utils": "0.2.21",
-    "@layerzerolabs/zod-utils": "0.2.21",
-    "@layerzerolabs/common-error-utils": "0.2.21"
+    "@layerzerolabs/common-chain-model": "0.2.23",
+    "@layerzerolabs/common-error-utils": "0.2.23",
+    "@layerzerolabs/layerzero-definitions": "0.2.23",
+    "@layerzerolabs/typescript-utils": "0.2.23",
+    "@layerzerolabs/gated-transaction": "0.2.23",
+    "@layerzerolabs/zod-utils": "0.2.23"
   },
   "devDependencies": {
     "@mysten/sui": "^1.35.0",
     "tsup": "^8.4.0",
     "vitest": "^3.2.3",
-    "@layerzerolabs/tsup-configuration": "0.2.21",
-    "@layerzerolabs/typescript-configuration": "0.2.21"
+    "@layerzerolabs/tsup-configuration": "0.2.23",
+    "@layerzerolabs/typescript-configuration": "0.2.23"
   },
   "publishConfig": {
     "access": "restricted",

package/src/deploy/factoryInterfaces.ts

@@ -0,0 +1,100 @@
+import z from 'zod';
+
+import { ChainName } from '@layerzerolabs/layerzero-definitions';
+import { customSchema, functionSchema } from '@layerzerolabs/zod-utils';
+
+import type { ArtifactWithType } from './artifact';
+import { ArtifactType, artifactWithTypeSchema, deploymentArtifactSchema } from './artifact';
+import type { BaseResource, ResolvedResource } from './resources';
+import { getVerificationInfoBaseArgs, saveVerificationInfoBaseArgs } from './workflow';
+
+export const resourceRefSchema = z.object({
+    resourceId: z.string(),
+    // some resources can have multiple realIDs, leave this undefined for the default
+    resourceSubKey: z.string().optional(),
+});
+
+// the real realID that might exist
+export const realIdSchema = z.object({
+    realIdKey: z.string(),
+    // some realIDs are scoped to a chain, some aren't
+    chainName: z.enum(ChainName).optional(),
+});
+
+export const artifactRegistryActivityFactorySchema = z.object({
+    getArtifact: functionSchema({
+        input: z.tuple([
+            z.object({
+                ref: resourceRefSchema,
+                artifactType: z.enum(ArtifactType),
+            }),
+        ]),
+        output: z.promise(artifactWithTypeSchema.optional()),
+        // typing to make it generic on artifact type
+    }) as z.ZodType<
+        <Type extends ArtifactType>(args: {
+            artifactType: Type;
+            ref: z.infer<typeof resourceRefSchema>;
+        }) => Promise<Extract<ArtifactWithType, { artifactType: Type }> | undefined>
+    >,
+
+    saveArtifact: functionSchema({
+        input: z.tuple([
+            z.object({
+                ref: resourceRefSchema,
+                artifact: artifactWithTypeSchema,
+            }),
+        ]),
+        output: z.promise(z.void()),
+    }),
+
+    // these internally are the same as getArtifact/saveArtifact, just specific argument shapes to match
+    // the function pointer expected by the DeployOrchestratorWorkflow
+    // we can refactor DeployOrchestratorWorkflow to remove this
+    getDeployment: functionSchema({
+        input: z.tuple([
+            z.object({
+                resource: customSchema<BaseResource | ResolvedResource<BaseResource>>(),
+            }),
+            z.object({
+                contractName: z.string(),
+            }),
+        ]),
+        output: z.promise(deploymentArtifactSchema.optional()),
+    }),
+
+    saveDeployment: functionSchema({
+        input: z.tuple([
+            z.object({
+                resource: customSchema<BaseResource | ResolvedResource<BaseResource>>(),
+            }),
+            z.object({
+                contractName: z.string(),
+                deploymentInfo: deploymentArtifactSchema,
+            }),
+        ]),
+        output: z.promise(z.void()),
+    }),
+
+    getVerificationInfo: functionSchema({
+        input: z.tuple([
+            z.object({
+                resource: customSchema<BaseResource | ResolvedResource<BaseResource>>(),
+            }),
+            getVerificationInfoBaseArgs,
+        ]),
+        output: z.promise(z.any()),
+    }),
+
+    saveVerificationInfo: functionSchema({
+        input: z.tuple([
+            z.object({
+                resource: customSchema<BaseResource | ResolvedResource<BaseResource>>(),
+            }),
+            saveVerificationInfoBaseArgs,
+        ]),
+        output: z.promise(z.void()),
+    }),
+});
+
+export interface ArtifactRegistry extends z.infer<typeof artifactRegistryActivityFactorySchema> {}

package/src/deploy/index.ts

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

package/src/deploy/resources.md

@@ -0,0 +1,84 @@
+# On the resource model
+
+## Background
+
+We started with a schema defining the config and another schema defining the
+interface of the activity factory that deploys contracts.
+
+The first problem with this is the duplication. The second problem with this is that you necessarily require
+the workflow to be able to transform between these two schemata. For example, if deploying an OFT LUA requires
+that we know the token address, the workflow must now have bespoke handling to inject this parameter into the activity factory.
+
+From here, you make the optimization of treating config as source of truth, and having activity factories receive the config,
+and additional arguments that they require and that are only known at workflow time/don't need to be in the config.
+
+This, still, requires custom workflow for any ordering of dependencies, injecting of addresses, and does not provide any way
+to compose the deployment of multiple contracts.
+
+## Resources
+
+Resources, then, are a generalization of this idea. A resource, at its most basic, is a configuration of a contract,
+which can be `resolve()`d and passed to an activity factory to deploy. The resolution step is completely generic,
+simply injecting its references to other resources.
+
+## Resource registry
+
+```typescript
+resourceRegistry: (resourceId: string, resourceSubkey?: string) => RealID;
+```
+
+The resource registry is responsible for understanding the status of reification of your resources.
+That is, the resource registry is the exclusive entity that holds the "address" of your "contracts".
+
+"Address" here is not meant literally. Rather, it is a generalization, `RealID`. A RealID
+is an identifier for a deployed resource. "Deployment" here is is not meant literally.
+For example, pushing mesh resources to LZ metadata is a deployment. Deployment _is_, however,
+whatever action creates the canonical identifier for the registry.
+
+In summary,
+
+```
+config === resource
+address === realID
+```
+
+Resource subkeys are suffixes that identify optional additional RealIDs associated with the same resource.
+For example, an OFT may have a proxy, an implementation, and a proxy admin. One of these is the canonical RealID.
+The canonical RealID is whichever RealID identifies the semantic entity, in this case whichever contract can lzReceive,
+in this case the proxy. Therefore, this resource has
+
+```
+<resourceId> -> <realId> (proxy contract)
+<resourceId/impl> -> <realId> (implementation contract)
+<resourceId/proxy-admin> -> <realId> (proxy admin contract)
+```
+
+These additional realIds are _not_ identifiers for the resource, but are persisted for contexts in which they might be relevant.
+For any consumer who is unaware of the context of proxies, they need only identify the resource by its ID to receive the "correct"
+semantic RealID. Of course correct depends on the context, which is why this strategy should be used carefully.
+
+## Artifact registry
+
+```
+artifactRegistry: (realId: string) => Artifact
+```
+
+Artifacts are metadata associated with some realId.
+For example,
+
+- The time a contract was deployed
+- The number of optimizers runs on that contract
+- Whether a contract has been pushed to metadata
+
+Each artifact is separate and identified by an `ArtifactType`.
+
+## Deployment flow
+
+Topologically sort all resources in consideration, then sequentially map resource type -> factory.
+Collect deployment transactions per factory, save RealID and optionally artifacts.
+
+## Wiring flow
+
+For each resource in consideration, fetch its RealID, specialize the relevant factory and operate.
+Generally this will not require any artifact, unless the factory in question needs to obtain an artifact for specific purposes.
+If it does, this will happen via backchannel lookup and will be hidden from the workflow.

package/src/deploy/workflow.ts

@@ -10,6 +10,7 @@ import {
     deploymentArtifactSchema,
     fullDeploymentArtifactSchema,
     identityOnlyDeploymentArtifactSchema,
+    verificationArtifactSchema,
 } from './artifact';
 
 export type { SuiObjectChange };
@@ -107,7 +108,10 @@ export const createVerificationInfoBaseArgs = z.object({
 });
 export type CreateVerificationInfoBaseArgs = z.infer<typeof createVerificationInfoBaseArgs>;
 
-export const saveVerificationInfoBaseArgs = createVerificationInfoBaseArgs;
+export const saveVerificationInfoBaseArgs = z.object({
+    deploymentInfo: fullDeploymentArtifactSchema,
+    verificationInfo: verificationArtifactSchema,
+});
 
 export type SaveVerificationInfoBaseArgs = z.infer<typeof saveVerificationInfoBaseArgs>;