@layerzerolabs/dw-model 0.2.68 → 0.2.70

package/src/deploy/index.ts

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

package/src/deploy/resourceBuilder.ts

@@ -1,79 +0,0 @@
-import type { z } from 'zod';
-
-import { throwError } from '@layerzerolabs/common-error-utils';
-import type { NormalizedHexString } from '@layerzerolabs/typescript-utils';
-
-import type {
-    BaseContractResource,
-    BaseMeshResource,
-    baseResourceSchema,
-    ContractResourceReference,
-    MeshResourceReference,
-    withIntrinsicAddress,
-} from './resources';
-
-export type ContractResourceBuilderResult<Resource extends BaseContractResource> = {
-    ref: () => ContractResourceReference<Resource>;
-    build: () => Resource;
-};
-
-export type MeshResourceBuilderResult<Resource extends BaseMeshResource> = {
-    ref: () => MeshResourceReference<Resource>;
-    build: () => Resource;
-};
-
-export const createResourceBuilder =
-    <
-        T extends typeof baseResourceSchema,
-        U extends Omit<z.infer<T>, 'type' | 'resourceBaseType' | '_INTRINSIC_normalizedAddress'>,
-    >(
-        _resourceSchema: T,
-        {
-            resourceBaseType,
-            type,
-        }: {
-            resourceBaseType: 'CONTRACT' | 'MESH';
-            type: T['shape'] extends { type: z.ZodType<infer Type> } ? Type : undefined;
-        },
-    ) =>
-    (
-        ...args: T extends ReturnType<typeof withIntrinsicAddress>
-            ? [
-                  resource: U,
-                  address: { nativeAddress: string } | { normalizedAddress: NormalizedHexString },
-              ]
-            : [resource: U]
-    ): z.infer<T> extends BaseContractResource
-        ? ContractResourceBuilderResult<z.infer<T>>
-        : z.infer<T> extends BaseMeshResource
-          ? MeshResourceBuilderResult<z.infer<T>>
-          : never => {
-        const resource = args[0];
-        if (resourceBaseType === 'CONTRACT') {
-            const _INTRINSIC_normalizedAddress: NormalizedHexString | undefined =
-                args[1] && 'nativeAddress' in args[1]
-                    ? throwError(
-                          `Native address is currently not supported, use normalizedAddress instead`,
-                      )
-                    : args[1]?.normalizedAddress;
-
-            return {
-                ref: () => `#C_REF:${resource.id}` as any,
-                build: () => ({
-                    ...resource,
-                    type,
-                    resourceBaseType,
-                    _INTRINSIC_normalizedAddress,
-                }),
-            } satisfies ContractResourceBuilderResult<any> as any;
-        }
-
-        if (resourceBaseType === 'MESH') {
-            return {
-                ref: () => `#M_REF:${resource.id}` as any,
-                build: () => ({ ...resource, type, resourceBaseType }),
-            } satisfies MeshResourceBuilderResult<any> as any;
-        }
-
-        throw new Error(`Can't handle resourceBaseType "${resourceBaseType}"`);
-    };

package/src/deploy/resources.md

@@ -1,84 +0,0 @@
-# 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/resources.ts

@@ -1,205 +0,0 @@
-import z from 'zod';
-
-import { normalizedHexSchema, type NormalizedHexString } from '@layerzerolabs/common-chain-model';
-import { throwError } from '@layerzerolabs/common-error-utils';
-import { chainNameSchema } 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
-    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: chainNameSchema,
-    upgradeConfig: upgradeableConfigSchema.optional(),
-    verifyContract: z.boolean().optional(),
-
-    chainConfig: z.any().optional(),
-});
-
-export const withIntrinsicAddress = <T extends typeof baseContractResourceSchema>(
-    resourceSchema: T,
-) =>
-    z.object({
-        ...resourceSchema.shape,
-        _INTRINSIC_normalizedAddress: normalizedHexSchema,
-    }) as z.ZodObject<
-        T['shape'] & { _INTRINSIC_normalizedAddress: typeof normalizedHexSchema },
-        z.core.$strip
-    >;
-
-export type BaseResource = z.infer<typeof baseResourceSchema>;
-export type BaseMeshResource = z.infer<typeof baseMeshResourceSchema>;
-export type BaseContractResource = z.infer<typeof baseContractResourceSchema>;
-export type BaseIntrinsicAddressContractResource = z.infer<ReturnType<typeof withIntrinsicAddress>>;
-
-// 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 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`);
-
-// Use z.ZodType<BaseContractResource> because we want to allow unions
-export type ContractResourceReferenceSchema<T extends z.ZodType<BaseContractResource>> = z.ZodType<
-    ContractResourceReference<z.infer<T>>
->;
-
-export const contractResourceReferenceSchema: ContractResourceReferenceSchema<
-    z.ZodType<BaseContractResource>
-    // 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 z.ZodType<BaseContractResource>>(
-    // TODO: use resource parameter to generate a concrete schema
-    _resource: T,
-): 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 dependency ID resolution
-        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 ResolvedContractResourceReferenceSchema<T extends z.ZodType<BaseContractResource>> =
-    z.ZodType<ResolvedContractResourceReference<z.infer<T>>>;
-
-export const resolvedContractResourceReferenceSchema: ResolvedContractResourceReferenceSchema<any> =
-    // TODO: replace with a concrete zod schema
-    z.custom<ResolvedContractResourceReference<any>>();
-
-// 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 type MeshResourceReferenceSchema<T extends typeof baseMeshResourceSchema> = z.ZodType<
-    MeshResourceReference<z.infer<T>>
->;
-
-export const meshResourceReferenceSchema: MeshResourceReferenceSchema<
-    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>(
-    // TODO: use resource parameter to generate a concrete schema
-    _resource: T,
-): 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 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> =
-    // TODO: replace with a concrete zod schema
-    z.ZodType<ResolvedMeshResourceReference<z.infer<T>>>;
-
-export const resolvedMeshResourceReferenceSchema: ResolvedMeshResourceReferenceSchema<any> =
-    z.custom<ResolvedMeshResourceReference<any>>();
-
-export type ResolvedResourceSchema<Resource extends typeof baseResourceSchema> = z.ZodObject<
-    {
-        [K in Exclude<
-            keyof Resource['shape'],
-            '_INTRINSIC_normalizedAddress'
-        >]: Resource['shape'][K] extends infer R extends z.ZodType
-            ? R extends z.ZodAny
-                ? R
-                : R extends z.ZodOptional<z.ZodAny>
-                  ? R
-                  : 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
->;
-
-export type ResolvedResource<Resource extends BaseResource> = {
-    [K in Exclude<keyof Resource, '_INTRINSIC_normalizedAddress'>]: Resource[K] extends infer R
-        ? R extends undefined
-            ? R
-            : IsAny<R> extends true
-              ? R
-              : IsAny<Exclude<R, undefined>> extends true
-                ? R
-                : 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 extractContractResourceReferences = <Resource extends BaseResource>(
-    resource: Resource,
-) =>
-    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][];
-
-// TODO: implement runtime resolution — currently returns input schema as-is
-export const createResolvedResourceSchema = <Resource extends typeof baseResourceSchema>(
-    resource: Resource,
-) => resource as ResolvedResourceSchema<Resource>;

package/src/deploy/workflow.ts

@@ -1,140 +0,0 @@
-import type { SuiObjectChange } from '@mysten/sui/client';
-import { z } from 'zod';
-
-import { successfulGatedTransactionSchema } from '@layerzerolabs/gated-transaction';
-import { chainNameSchema } from '@layerzerolabs/layerzero-definitions';
-import { functionSchema } from '@layerzerolabs/zod-utils';
-
-import type { DeploymentArtifact, SolanaDeploymentArtifactExtraInfo } from './artifact';
-import {
-    deploymentArtifactSchema,
-    fullDeploymentArtifactSchema,
-    identityOnlyDeploymentArtifactSchema,
-    verificationArtifactSchema,
-} from './artifact';
-
-// Re-export for transitive type dependencies
-export type { SuiObjectChange };
-
-// ---------------------------------------------------------------------------
-// Deprecated types (to be removed)
-// ---------------------------------------------------------------------------
-
-/** @deprecated use SolanaDeploymentArtifact from this module or define inline */
-export type SolanaDeploymentArtifact = Omit<DeploymentArtifact, 'extraDeploymentInfo'> & {
-    extraDeploymentInfo: SolanaDeploymentArtifactExtraInfo;
-};
-
-// ---------------------------------------------------------------------------
-// Deployment activity base args schemas
-// ---------------------------------------------------------------------------
-
-export const getDeploymentBaseArgsSchema = z.object({ contractName: z.string() });
-export type GetDeploymentBaseArgs = z.infer<typeof getDeploymentBaseArgsSchema>;
-
-export const saveDeploymentBaseArgsSchema = z.object({
-    deploymentArtifact: identityOnlyDeploymentArtifactSchema,
-});
-export type SaveDeploymentBaseArgs = z.infer<typeof saveDeploymentBaseArgsSchema>;
-
-// ---------------------------------------------------------------------------
-// Verification activity base args schemas
-// ---------------------------------------------------------------------------
-
-export const getVerificationBaseArgsSchema = z.object({
-    contractName: z.string(),
-});
-export type GetVerificationBaseArgs = z.infer<typeof getVerificationBaseArgsSchema>;
-
-export const extractVerificationArtifactBaseArgsSchema = z.object({
-    gtx: successfulGatedTransactionSchema(),
-    deploymentArtifact: fullDeploymentArtifactSchema,
-    nonVerifyable: z.boolean().optional(),
-});
-export type ExtractVerificationArtifactBaseArgs = z.infer<
-    typeof extractVerificationArtifactBaseArgsSchema
->;
-
-export const saveVerificationBaseArgsSchema = z.object({
-    deploymentArtifact: fullDeploymentArtifactSchema,
-    verificationArtifact: verificationArtifactSchema,
-});
-export type SaveVerificationBaseArgs = z.infer<typeof saveVerificationBaseArgsSchema>;
-
-// ---------------------------------------------------------------------------
-// Combined deployment + verification activity schema
-// ---------------------------------------------------------------------------
-
-export const baseDeploymentSavingArtifactsSchema = z.object({
-    getDeployment: functionSchema({
-        input: z.tuple([getDeploymentBaseArgsSchema]),
-        output: z.promise(deploymentArtifactSchema.optional()),
-    }),
-    saveDeployment: functionSchema({
-        input: z.tuple([saveDeploymentBaseArgsSchema]),
-        output: z.promise(z.void()),
-    }),
-    getVerification: functionSchema({
-        input: z.tuple([getVerificationBaseArgsSchema]),
-        output: z.promise(z.any()),
-    }),
-    saveVerification: functionSchema({
-        input: z.tuple([saveVerificationBaseArgsSchema]),
-        output: z.promise(z.void()),
-    }),
-});
-
-// ---------------------------------------------------------------------------
-// Deploy workflow result schemas
-// ---------------------------------------------------------------------------
-
-const failedDeployment = z.object({
-    name: z.string(),
-    success: z.literal(false),
-    error: z.string(),
-});
-
-const successfulDeployment = z.object({
-    name: z.string(),
-    success: z.literal(true),
-    deploymentArtifact: deploymentArtifactSchema,
-});
-
-export const deployWorkflowChainResultItemSchema = z.union([
-    failedDeployment,
-    successfulDeployment,
-]);
-
-export const deployWorkflowChainResultSchema = z.object({
-    results: z.array(deployWorkflowChainResultItemSchema).default([]),
-});
-
-// ---------------------------------------------------------------------------
-// Deploy workflow state schemas
-// ---------------------------------------------------------------------------
-
-export const deployWorkflowChainStateSchema = deployWorkflowChainResultSchema.extend({
-    srcChain: chainNameSchema.optional(),
-    status: z.union([z.literal('RUNNING'), z.literal('COMPLETE')]).default('RUNNING'),
-});
-
-export const deployWorkflowOrchestratorResultSchema = z.object({
-    stateByChain: z.partialRecord(chainNameSchema, deployWorkflowChainResultSchema).default({}),
-});
-
-export const deployWorkflowOrchestratorStateSchema = deployWorkflowOrchestratorResultSchema.extend({
-    status: z.union([z.literal('RUNNING'), z.literal('COMPLETE')]).default('RUNNING'),
-});
-
-// ---------------------------------------------------------------------------
-// Deploy workflow types
-// ---------------------------------------------------------------------------
-
-export type DeployWorkflowChainResultItem = z.infer<typeof deployWorkflowChainResultItemSchema>;
-export type DeployWorkflowChainResult = z.infer<typeof deployWorkflowChainResultSchema>;
-export type DeployWorkflowChainState = z.infer<typeof deployWorkflowChainStateSchema>;
-export type DeployWorkflowOrchestratorResult = z.infer<
-    typeof deployWorkflowOrchestratorResultSchema
->;
-
-export type DeployWorkflowOrchestratorState = z.infer<typeof deployWorkflowOrchestratorStateSchema>;

package/src/index.ts

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

package/src/role-management/generator.ts

@@ -1,17 +0,0 @@
-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

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