@settlemint/dalp-sdk 3.0.7-main.28529883879 → 3.0.7-main.28538365167

package/dist/index.js

@@ -1177,9 +1177,9 @@ var ENTRIES_INDEX = {
     retryable: false,
     expectedClientError: true,
     public: {
-      message: "User does not have the required role to execute this operation.",
-      why: "The actor lacks at least one role required by the token or system contract.",
-      fix: "Grant the required role or retry with an authorized actor."
+      message: "This action requires a role the acting wallet does not hold.",
+      why: "The token or system contract restricts this action to the {{requiredRoles}} role, and the acting wallet was granted no matching role.",
+      fix: "Ask an administrator to grant the {{requiredRoles}} role, then retry, or perform this action with a wallet that already holds it."
     },
     observability: {
       severity: "info",
@@ -1199,6 +1199,12 @@ var ENTRIES_INDEX = {
     authSensitivity: {
       existenceDisclosure: "public-safe",
       rationale: "The public response only reveals missing authorization, not protected resource existence."
+    },
+    ui: {
+      surface: "inline",
+      retry: "none",
+      ariaLive: "assertive",
+      toastMode: "title-and-why"
     }
   },
   "DALP-0007": {
@@ -42218,6 +42224,38 @@ var ENTRIES_INDEX = {
     owner: "dapi",
     orpcCode: "XVP_MIXED_CHAIN_SETTLEMENT"
   },
+  "DALP-9166": {
+    id: "DALP-9166",
+    kind: "route",
+    category: "permission",
+    status: 403,
+    retryable: false,
+    expectedClientError: true,
+    public: {
+      message: "The wallet must be registered in the token identity registry before delegating voting power.",
+      why: "Delegating voting power requires the acting wallet to hold an identity in the token's identity registry, and the selected wallet has no identity there.",
+      fix: "Register the wallet's identity in the token identity registry, then retry the delegation."
+    },
+    observability: {
+      severity: "info",
+      otelEventName: "dapi.error",
+      metricAttributeKey: "dapi.error.id",
+      dimensions: [
+        "error.id",
+        "error.category",
+        "surface",
+        "route",
+        "status_class",
+        "retryable"
+      ]
+    },
+    owner: "dapi",
+    orpcCode: "USER_NOT_AUTHORIZED",
+    authSensitivity: {
+      existenceDisclosure: "public-safe",
+      rationale: "The public response reveals only that the wallet is not registered for delegation, not any protected resource existence."
+    }
+  },
   "DALP-CHAIN-EMPTY-REVERT": {
     id: "DALP-CHAIN-EMPTY-REVERT",
     kind: "contract",
@@ -52632,6 +52670,9 @@ var DALP_ERROR_TYPED_FIELD_NAMES = {
   "DALP-9163": [],
   "DALP-9164": [],
   "DALP-9165": [],
+  "DALP-9166": [
+    "requiredRoles"
+  ],
   "DALP-CHAIN-EMPTY-REVERT": [
     "args",
     "correlationId",
@@ -52712,7 +52753,7 @@ var DALP_ERROR_DATA_SCHEMA_BY_ID = {
   "DALP-0004": DALP_ORPC_ERROR_DATA_WIRE_SCHEMA,
   "DALP-0005": DALP_ORPC_ERROR_DATA_WIRE_SCHEMA,
   "DALP-0006": DALP_ORPC_ERROR_DATA_BASE_SCHEMA.extend({
-    requiredRoles: z2.union([z2.string(), z2.array(z2.string())])
+    requiredRoles: z2.union([z2.string(), z2.array(z2.string()), z2.record(z2.string(), DALP_ORPC_JSON_VALUE_SCHEMA)])
   }).catchall(DALP_ORPC_JSON_VALUE_SCHEMA),
   "DALP-0007": DALP_ORPC_ERROR_DATA_WIRE_SCHEMA,
   "DALP-0008": DALP_ORPC_ERROR_DATA_WIRE_SCHEMA,
@@ -62715,6 +62756,9 @@ var DALP_ERROR_DATA_SCHEMA_BY_ID = {
   "DALP-9163": DALP_ORPC_ERROR_DATA_WIRE_SCHEMA,
   "DALP-9164": DALP_ORPC_ERROR_DATA_WIRE_SCHEMA,
   "DALP-9165": DALP_ORPC_ERROR_DATA_WIRE_SCHEMA,
+  "DALP-9166": DALP_ORPC_ERROR_DATA_BASE_SCHEMA.extend({
+    requiredRoles: z2.union([z2.string(), z2.array(z2.string()), z2.record(z2.string(), DALP_ORPC_JSON_VALUE_SCHEMA)])
+  }).catchall(DALP_ORPC_JSON_VALUE_SCHEMA),
   "DALP-CHAIN-EMPTY-REVERT": DALP_ORPC_ERROR_DATA_BASE_SCHEMA.extend({
     args: z2.record(z2.string(), z2.string()),
     correlationId: z2.string(),
@@ -63019,19 +63063,294 @@ function readDalpOrpcError(error) {
 import { oc } from "@orpc/contract";
 
 // ../../packages/core/validation/src/role-requirement.ts
+import { z as z7 } from "zod";
+
+// ../../packages/core/validation/src/access-control-roles.ts
+import { z as z6 } from "zod";
+
+// ../../packages/core/validation/src/account.ts
+import { z as z4 } from "zod";
+
+// ../../packages/core/validation/src/ethereum-address.ts
+import { getAddress, isAddress, zeroAddress } from "viem";
 import { z as z3 } from "zod";
-var RoleRequirementSchema = z3.lazy(() => z3.union([
-  z3.string(),
-  z3.object({
-    any: z3.array(RoleRequirementSchema)
+var ethereumAddress = z3.string().meta({
+  description: "A valid Ethereum address (42 characters, starting with 0x)",
+  examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
+}).min(42, "Ethereum address must be at least 42 characters long").max(42, "Ethereum address must be at most 42 characters long").regex(/^0x[a-fA-F0-9]{40}$/, "Ethereum address must start with 0x followed by 40 hexadecimal characters").transform((value, ctx) => {
+  if (!isAddress(value)) {
+    ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      message: "Invalid Ethereum address format or checksum"
+    });
+    return z3.NEVER;
+  }
+  return getAddress(value);
+});
+var nonZeroEthereumAddress = ethereumAddress.refine((address) => address !== zeroAddress, "Fee recipient cannot be the zero address");
+var lowercaseEthereumAddress = ethereumAddress.transform((value) => value.toLowerCase());
+
+// ../../packages/core/validation/src/account.ts
+var AccountSchema = z4.object({
+  id: ethereumAddress,
+  isContract: z4.boolean().meta({ description: "Whether this address is a smart contract (true) or EOA (false)", examples: [true, false] })
+});
+var account = () => AccountSchema;
+var accountArray = () => z4.array(account()).meta({
+  description: "Array of Account entities",
+  examples: [[{ id: "0x71C7656EC7ab88b098defB751B7401B5f6d8976F", isContract: false }]]
+});
+
+// ../../packages/core/validation/src/ethereum-hex.ts
+import { isHex } from "viem";
+import { z as z5 } from "zod";
+var ethereumHex = z5.string().meta({
+  description: "A valid Ethereum hex string (starting with 0x)",
+  examples: ["0x1234abcd", "0x00", "0xdeadbeef"]
+}).min(2, "Hex string must be at least 2 characters long (0x)").refine(isHex, {
+  message: "Invalid hex format - must start with '0x' followed by hexadecimal characters"
+}).transform((value) => value);
+
+// ../../packages/core/validation/src/v1-frozen-spec.ts
+var V1_FROZEN_SPEC_META_KEY = "x-dalp-v1-frozen-spec";
+function v1FrozenSpecMeta(directive) {
+  return { [V1_FROZEN_SPEC_META_KEY]: directive };
+}
+function v1FrozenRequired(schema, directive = {}) {
+  return schema.meta(v1FrozenSpecMeta({ required: true, ...directive }));
+}
+
+// ../../packages/core/validation/src/access-control-roles.ts
+var roles = [
+  "addonManager",
+  "addonModule",
+  "addonRegistryModule",
+  "admin",
+  "auditor",
+  "claimPolicyManager",
+  "claimIssuer",
+  "complianceManager",
+  "custodian",
+  "emergency",
+  "feedsManager",
+  "fundsManager",
+  "gasManager",
+  "governance",
+  "identityManager",
+  "identityRegistryModule",
+  "organisationIdentityManager",
+  "saleAdmin",
+  "supplyManagement",
+  "systemManager",
+  "systemModule",
+  "tokenFactoryModule",
+  "tokenFactoryRegistryModule",
+  "tokenManager",
+  "trustedIssuersMetaRegistryModule"
+];
+var accessControlRoles = z6.object(Object.fromEntries(roles.map((role) => [role, z6.boolean().default(false)])));
+var accessControlRole = z6.enum(roles);
+var assetAccessControlRoles = [
+  "admin",
+  "custodian",
+  "emergency",
+  "fundsManager",
+  "governance",
+  "saleAdmin",
+  "supplyManagement"
+];
+var assetAccessControlRole = z6.enum(assetAccessControlRoles);
+var assetAccessControlRolesSchema = accessControlRoles.pick({
+  admin: true,
+  custodian: true,
+  emergency: true,
+  fundsManager: true,
+  governance: true,
+  saleAdmin: true,
+  supplyManagement: true
+});
+var systemAccessControlRoles = [
+  "admin",
+  "auditor",
+  "systemManager",
+  "tokenManager",
+  "complianceManager",
+  "claimPolicyManager",
+  "claimIssuer",
+  "identityManager",
+  "feedsManager",
+  "gasManager"
+];
+var systemAccessControlRole = z6.enum(systemAccessControlRoles);
+var systemAccessControlRolesV1 = [...systemAccessControlRoles, "addonManager"];
+var systemAccessControlRoleV1 = z6.enum(systemAccessControlRolesV1);
+var systemAccessControlRolesSchema = accessControlRoles.pick({
+  addonManager: true,
+  admin: true,
+  auditor: true,
+  systemManager: true,
+  tokenManager: true,
+  complianceManager: true,
+  claimPolicyManager: true,
+  claimIssuer: true,
+  identityManager: true,
+  feedsManager: true,
+  gasManager: true
+});
+var roleAdminSchema = z6.object({
+  id: ethereumHex.meta({
+    description: "Role admin mapping identifier",
+    examples: ["0x0102030405060708091011121314151617181920212223242526272829303132"]
   }),
-  z3.object({
-    all: z3.array(RoleRequirementSchema)
+  role: ethereumHex.meta({
+    description: "Role identifier (bytes32)",
+    examples: ["0x0000000000000000000000000000000000000000000000000000000000000001"]
+  }),
+  roleFieldName: accessControlRole.meta({
+    description: "Role field name",
+    examples: ["admin", "tokenManager", "complianceManager"]
+  }),
+  adminRole: ethereumHex.meta({
+    description: "Admin role identifier (bytes32)",
+    examples: ["0x0000000000000000000000000000000000000000000000000000000000000000"]
+  }),
+  adminFieldName: accessControlRole.meta({
+    description: "Admin role field name",
+    examples: ["admin", "systemManager"]
+  })
+});
+var AccessControlSchema = z6.object({
+  id: ethereumAddress.meta({
+    description: "Access control contract address",
+    examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
+  }),
+  addonManager: v1FrozenRequired(accountArray().default([]).meta({
+    description: "Accounts with addon manager role. Frozen v1-compat role — always empty.",
+    examples: [[]]
+  }), { required: true }),
+  addonModule: accountArray().meta({
+    description: "Accounts with addon module role",
+    examples: [[]]
+  }),
+  addonRegistryModule: accountArray().meta({
+    description: "Accounts with addon registry module role",
+    examples: [[]]
+  }),
+  admin: accountArray().meta({
+    description: "Accounts with admin role",
+    examples: [
+      [
+        {
+          id: "0x71C7656EC7ab88b098defB751B7401B5f6d8976F",
+          isContract: false
+        }
+      ]
+    ]
+  }),
+  auditor: accountArray().meta({
+    description: "Accounts with auditor role",
+    examples: [[]]
+  }),
+  claimPolicyManager: accountArray().meta({
+    description: "Accounts with claim policy manager role",
+    examples: [[]]
+  }),
+  claimIssuer: accountArray().meta({
+    description: "Accounts with claim issuer role",
+    examples: [[]]
+  }),
+  complianceManager: accountArray().meta({
+    description: "Accounts with compliance manager role",
+    examples: [[]]
+  }),
+  custodian: accountArray().meta({
+    description: "Accounts with custodian role",
+    examples: [[]]
+  }),
+  emergency: accountArray().meta({
+    description: "Accounts with emergency role",
+    examples: [[]]
+  }),
+  feedsManager: accountArray().meta({
+    description: "Accounts with feeds manager role",
+    examples: [[]]
+  }),
+  fundsManager: accountArray().meta({
+    description: "Accounts with funds manager role",
+    examples: [[]]
+  }),
+  gasManager: accountArray().meta({
+    description: "Accounts with gas manager role",
+    examples: [[]]
+  }),
+  governance: accountArray().meta({
+    description: "Accounts with governance role",
+    examples: [[]]
+  }),
+  identityManager: accountArray().meta({
+    description: "Accounts with identity manager role",
+    examples: [[]]
+  }),
+  identityRegistryModule: accountArray().meta({
+    description: "Accounts with identity registry module role",
+    examples: [[]]
+  }),
+  organisationIdentityManager: accountArray().meta({
+    description: "Accounts with organisation identity manager role",
+    examples: [[]]
+  }),
+  saleAdmin: accountArray().meta({
+    description: "Accounts with sale admin role",
+    examples: [[]]
+  }),
+  supplyManagement: accountArray().meta({
+    description: "Accounts with supply management role",
+    examples: [[]]
+  }),
+  systemManager: accountArray().meta({
+    description: "Accounts with system manager role",
+    examples: [[]]
+  }),
+  systemModule: accountArray().meta({
+    description: "Accounts with system module role",
+    examples: [[]]
+  }),
+  tokenFactoryModule: accountArray().meta({
+    description: "Accounts with token factory module role",
+    examples: [[]]
+  }),
+  tokenFactoryRegistryModule: accountArray().meta({
+    description: "Accounts with token factory registry module role",
+    examples: [[]]
+  }),
+  tokenManager: accountArray().meta({
+    description: "Accounts with token manager role",
+    examples: [[]]
+  }),
+  trustedIssuersMetaRegistryModule: accountArray().meta({
+    description: "Accounts with trusted issuers meta registry module role",
+    examples: [[]]
+  }),
+  roleAdmins: z6.array(roleAdminSchema).meta({
+    description: "Admin role mapping per access control role",
+    examples: [[]]
+  }).default([])
+});
+var accessControlSchema = () => AccessControlSchema;
+
+// ../../packages/core/validation/src/role-requirement.ts
+var RoleRequirementSchema = z7.lazy(() => z7.union([
+  z7.string(),
+  z7.object({
+    any: z7.array(RoleRequirementSchema)
+  }),
+  z7.object({
+    all: z7.array(RoleRequirementSchema)
   })
 ]));
 
 // ../../packages/core/validation/src/asset-type-template-features.ts
-import { z as z4 } from "zod";
+import { z as z8 } from "zod";
 
 // ../../packages/core/validation/src/addon-registry.ts
 var addonFunctionalCategoryIds = [
@@ -63271,8 +63590,8 @@ var addonIds = [
   "price-resolver",
   "paymaster-signer"
 ];
-var tokenFeatureIdSchema = z4.enum(tokenFeatureIds);
-var addonIdSchema = z4.enum(addonIds);
+var tokenFeatureIdSchema = z8.enum(tokenFeatureIds);
+var addonIdSchema = z8.enum(addonIds);
 var tokenFeatureIdSet = new Set(tokenFeatureIds);
 function isTokenFeatureId(value) {
   return tokenFeatureIdSet.has(value);
@@ -63282,29 +63601,10 @@ var INCOMPATIBLE_FEATURE_PAIRS = Object.freeze([
   ["transaction-fee", "transaction-fee-accounting"]
 ]);
 
-// ../../packages/core/validation/src/ethereum-address.ts
-import { getAddress, isAddress, zeroAddress } from "viem";
-import { z as z5 } from "zod";
-var ethereumAddress = z5.string().meta({
-  description: "A valid Ethereum address (42 characters, starting with 0x)",
-  examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
-}).min(42, "Ethereum address must be at least 42 characters long").max(42, "Ethereum address must be at most 42 characters long").regex(/^0x[a-fA-F0-9]{40}$/, "Ethereum address must start with 0x followed by 40 hexadecimal characters").transform((value, ctx) => {
-  if (!isAddress(value)) {
-    ctx.addIssue({
-      code: z5.ZodIssueCode.custom,
-      message: "Invalid Ethereum address format or checksum"
-    });
-    return z5.NEVER;
-  }
-  return getAddress(value);
-});
-var nonZeroEthereumAddress = ethereumAddress.refine((address) => address !== zeroAddress, "Fee recipient cannot be the zero address");
-var lowercaseEthereumAddress = ethereumAddress.transform((value) => value.toLowerCase());
-
 // ../../packages/core/validation/src/timestamp.ts
 import { getUnixTime } from "date-fns";
-import { z as z6 } from "zod";
-var TimestampSchema = z6.preprocess((value) => {
+import { z as z9 } from "zod";
+var TimestampSchema = z9.preprocess((value) => {
   if (value instanceof Date) {
     return value;
   }
@@ -63342,66 +63642,66 @@ var TimestampSchema = z6.preprocess((value) => {
     return new Date(value);
   }
   return value;
-}, z6.date()).meta({
+}, z9.date()).meta({
   description: "A timestamp in various formats",
   examples: ["2023-04-01T12:00:00Z", 1680354000, "1680354000000"]
 });
 var timestamp = () => TimestampSchema;
 
 // ../../packages/dalp/api-contract/src/custom-error-data-schemas.ts
-import { z as z7 } from "zod";
+import { z as z10 } from "zod";
 var dapiPublicErrorBaseDataSchema = DALP_ORPC_ERROR_DATA_BASE_SCHEMA.omit({ requestId: true }).partial();
 function dapiPublicErrorDataSchema(shape) {
   return dapiPublicErrorBaseDataSchema.extend(shape);
 }
 var retryAfterDataSchema = dapiPublicErrorDataSchema({
-  retryAfterSeconds: z7.number().int().positive()
+  retryAfterSeconds: z10.number().int().positive()
 }).optional();
-var dapiErrorContextDataSchema = z7.record(z7.string(), z7.unknown()).optional();
+var dapiErrorContextDataSchema = z10.record(z10.string(), z10.unknown()).optional();
 var CUSTOM_ERROR_DATA_SCHEMAS = {
   AA_ENABLED_CONTROLLER_MISMATCH: dapiErrorContextDataSchema,
   AA_ENABLED_DRIFT_REQUIRES_ADMIN: dapiPublicErrorDataSchema({
-    count: z7.number(),
-    addresses: z7.string()
+    count: z10.number(),
+    addresses: z10.string()
   }),
   AA_ENABLED_IDENTITY_MISMATCH: dapiErrorContextDataSchema,
   AA_ENABLED_IDENTITY_SYNC_FORBIDDEN: dapiPublicErrorDataSchema({
     address: ethereumAddress,
-    missingRoles: z7.array(z7.string())
+    missingRoles: z10.array(z10.string())
   }),
   ADDON_NOT_INSTALLED: dapiPublicErrorDataSchema({
-    missingCapability: z7.string(),
-    typeId: z7.string()
+    missingCapability: z10.string(),
+    typeId: z10.string()
   }),
   CHAIN_NOT_AVAILABLE_FOR_ORGANIZATION: dapiPublicErrorDataSchema({
-    chainId: z7.number().int().positive()
+    chainId: z10.number().int().positive()
   }),
   CHAIN_NOT_READY: dapiPublicErrorDataSchema({
-    chainId: z7.number().int().positive(),
-    chainStatus: z7.enum(["pending", "deploying", "failed", "disabled"])
+    chainId: z10.number().int().positive(),
+    chainStatus: z10.enum(["pending", "deploying", "failed", "disabled"])
   }),
   CONFIRMATION_TIMEOUT: dapiPublicErrorDataSchema({
-    transactionHash: z7.string(),
-    details: z7.string().optional()
+    transactionHash: z10.string(),
+    details: z10.string().optional()
   }),
   CONTRACT_ERROR: dapiPublicErrorDataSchema({
-    dalpCode: z7.string(),
-    message: z7.string(),
-    id: z7.string().optional(),
-    category: z7.string().optional(),
-    why: z7.string().optional(),
-    fix: z7.string().optional(),
-    suggestedAction: z7.string().optional(),
-    retryable: z7.boolean(),
-    selector: z7.string(),
-    solidityError: z7.string(),
-    args: z7.record(z7.string(), z7.string()).optional(),
-    correlationId: z7.string().optional(),
-    requestId: z7.string().optional()
+    dalpCode: z10.string(),
+    message: z10.string(),
+    id: z10.string().optional(),
+    category: z10.string().optional(),
+    why: z10.string().optional(),
+    fix: z10.string().optional(),
+    suggestedAction: z10.string().optional(),
+    retryable: z10.boolean(),
+    selector: z10.string(),
+    solidityError: z10.string(),
+    args: z10.record(z10.string(), z10.string()).optional(),
+    correlationId: z10.string().optional(),
+    requestId: z10.string().optional()
   }),
   CORE_ARRAY_EMPTY: dapiErrorContextDataSchema,
   CUSTODY_CREDENTIALS_INVALID: dapiPublicErrorDataSchema({
-    reason: z7.string().optional()
+    reason: z10.string().optional()
   }).optional(),
   CUSTODY_CONFIG_NOT_FOUND: dapiErrorContextDataSchema,
   CUSTODY_CREDENTIALS_UNAVAILABLE: dapiErrorContextDataSchema,
@@ -63418,29 +63718,29 @@ var CUSTOM_ERROR_DATA_SCHEMAS = {
   CORE_UNWRAP_SYNC_QUEUE_EXECUTION_RETURNED_NO_DATA_READRESULT_CALLBACK_REQUIRED: dapiErrorContextDataSchema,
   ERC20_METADATA_PROBE_UNAVAILABLE: retryAfterDataSchema,
   FEATURE_NOT_ENABLED: dapiPublicErrorDataSchema({
-    requiredFeature: z7.string()
+    requiredFeature: z10.string()
   }),
   GAS_REQUIRED: dapiPublicErrorDataSchema({
-    shortfallWei: z7.string().regex(/^\d+$/, "wei amount must be a non-negative integer string"),
-    recommendedTotalWei: z7.string().regex(/^\d+$/, "wei amount must be a non-negative integer string"),
+    shortfallWei: z10.string().regex(/^\d+$/, "wei amount must be a non-negative integer string"),
+    recommendedTotalWei: z10.string().regex(/^\d+$/, "wei amount must be a non-negative integer string"),
     address: ethereumAddress,
-    chainId: z7.number().int().positive(),
-    tokenSymbol: z7.string().min(1),
-    walletRole: z7.string().min(1),
-    retryableByFunding: z7.boolean()
+    chainId: z10.number().int().positive(),
+    tokenSymbol: z10.string().min(1),
+    walletRole: z10.string().min(1),
+    retryableByFunding: z10.boolean()
   }),
   IDEMPOTENCY_KEY_INFLIGHT: retryAfterDataSchema,
   IDENTITY_RECOVERY_FACTORY_ADDRESS_NOT_FOUND_USER_S_INDICATES_DATA_INTEGRITY_ISSUE_INDEXER: dapiErrorContextDataSchema,
   INDEXER_REINDEXING: retryAfterDataSchema,
   INPUT_VALIDATION_FAILED: dapiPublicErrorDataSchema({
-    errors: z7.array(z7.string())
+    errors: z10.array(z10.string())
   }),
   INSUFFICIENT_TREASURY_ALLOWANCE: dapiPublicErrorDataSchema({
-    allowance: z7.string(),
-    required: z7.string(),
-    denominationAsset: z7.string(),
-    feature: z7.string(),
-    treasury: z7.string()
+    allowance: z10.string(),
+    required: z10.string(),
+    denominationAsset: z10.string(),
+    feature: z10.string(),
+    treasury: z10.string()
   }),
   TOKEN_MINT_MATURITY_REDEMPTION_MATURED: dapiPublicErrorDataSchema({
     tokenAddress: ethereumAddress
@@ -63449,25 +63749,25 @@ var CUSTOM_ERROR_DATA_SCHEMAS = {
     maturityDate: timestamp().meta({
       description: "Configured maturity date the redemption preflight gates on; emitted as ISO-8601 UTC."
     }),
-    feature: z7.string()
+    feature: z10.string()
   }),
   MIGRATION_STREAM_WORKFLOW_FAILED: dapiPublicErrorDataSchema({
-    reason: z7.string()
+    reason: z10.string()
   }),
   RESTATE_WORKFLOW_RETRY_BLOCKED: dapiPublicErrorDataSchema({
-    reason: z7.enum(["active-invocation", "already-succeeded", "purge-failed", "query-failed"]),
-    invocationIds: z7.array(z7.string())
+    reason: z10.enum(["active-invocation", "already-succeeded", "purge-failed", "query-failed"]),
+    invocationIds: z10.array(z10.string())
   }),
   SERVICE_UNAVAILABLE: dapiPublicErrorDataSchema({
-    retryAfterSeconds: z7.number().optional()
+    retryAfterSeconds: z10.number().optional()
   }),
   SETTINGS_ASSET_FAILED_TO_CREATE_CLASS_DEFINITION_DATABASE_CONNECTIVITY: dapiErrorContextDataSchema,
   SETTINGS_ASSET_FAILED_TO_CREATE_TYPE_TEMPLATE_DATABASE_CONNECTIVITY_NAME_UNIQUE: dapiErrorContextDataSchema,
   SETTINGS_ASSET_TEMPLATE_FEATURES_INCOMPATIBLE: dapiPublicErrorDataSchema({
-    conflictingPairs: z7.array(z7.tuple([tokenFeatureIdSchema, tokenFeatureIdSchema]))
+    conflictingPairs: z10.array(z10.tuple([tokenFeatureIdSchema, tokenFeatureIdSchema]))
   }),
   SETTINGS_COMPLIANCE_TEMPLATE_INCOMPATIBLE_MODULE_SET: dapiPublicErrorDataSchema({
-    typeIds: z7.array(z7.string())
+    typeIds: z10.array(z10.string())
   }),
   SETTINGS_THEME_PAYLOAD_EXCEEDS_SUPPORTED_LIMITS: dapiErrorContextDataSchema,
   SMART_WALLETS_APPROVAL_WORKFLOW_COMPLETED_WITHOUT_ENOUGH_DATA_BUILD_RESPONSE: dapiErrorContextDataSchema,
@@ -63492,16 +63792,16 @@ var CUSTOM_ERROR_DATA_SCHEMAS = {
   SYSTEM_IDENTITY_NO_ACTIVE_CLAIM_FOUND_TOPIC: dapiErrorContextDataSchema,
   SYSTEM_IDENTITY_TOPIC_CLAIM_MUST_MATCH_APPROVED_KYC_CONTENT_HASH: dapiErrorContextDataSchema,
   SYSTEM_IDENTITY_TOPIC_REQUIRES_APPROVED_KYC_PROFILE_TARGET: dapiPublicErrorDataSchema({
-    topic: z7.string()
+    topic: z10.string()
   }),
   SYSTEM_IDENTITY_TOPIC_REQUIRES_SINGLE_CLAIM_NOT_ARRAY_STRUCTURED_DATA: dapiErrorContextDataSchema,
   SYSTEM_IDENTITY_UNEXPECTED_CLAIM_MISSING_VALIDATION: dapiErrorContextDataSchema,
   SYSTEM_TRUSTED_ISSUER_ADD_REMOVE_CLAIM_TOPIC_ROUTES_SYNC_ONLY_PREFER_RESPOND_ASYNC_NOT_SUP: dapiErrorContextDataSchema,
   TARGET_CURRENCIES_REMOVAL_FORBIDDEN: dapiPublicErrorDataSchema({
-    removed: z7.array(z7.string())
+    removed: z10.array(z10.string())
   }),
   TARGET_CURRENCY_NOT_SUPPORTED: dapiPublicErrorDataSchema({
-    unsupported: z7.array(z7.string())
+    unsupported: z10.array(z10.string())
   }),
   TOKEN_CLAIM_ACCOUNT_ADDRESS_DOES_NOT_ASSOCIATED_IDENTITY_CONTRACT_ONLY_USERS_CAN_ISSUE_CLA: dapiErrorContextDataSchema,
   TOKEN_CLAIM_ACCOUNT_ADDRESS_DOES_NOT_ASSOCIATED_IDENTITY_CONTRACT_ONLY_USERS_CAN_REVOKE_CL: dapiErrorContextDataSchema,
@@ -63510,11 +63810,11 @@ var CUSTOM_ERROR_DATA_SCHEMAS = {
   TOKEN_CLAIM_TOPIC_NOT_REGISTERED_SCHEME_REGISTRY: dapiErrorContextDataSchema,
   TOKEN_CREATE_DATABASE_CONTEXT_REQUIRED_DALP_ASSET_CREATION: dapiErrorContextDataSchema,
   TOKEN_CREATE_FEATURES_INCOMPATIBLE: dapiPublicErrorDataSchema({
-    conflictingPairs: z7.array(z7.tuple([tokenFeatureIdSchema, tokenFeatureIdSchema]))
+    conflictingPairs: z10.array(z10.tuple([tokenFeatureIdSchema, tokenFeatureIdSchema]))
   }),
   TOKEN_CREATE_WORKFLOW_PHASE_FAILED: dapiPublicErrorDataSchema({
-    phase: z7.string(),
-    error: z7.string().optional()
+    phase: z10.string(),
+    error: z10.string().optional()
   }),
   TOKEN_FEATURES_NO_YIELD_AVAILABLE_CLAIM_FIRST_PERIOD_NOT_COMPLETED_YET: dapiErrorContextDataSchema,
   TOKEN_FEATURES_NO_YIELD_AVAILABLE_FOR_HOLDER: dapiErrorContextDataSchema,
@@ -63529,17 +63829,17 @@ var CUSTOM_ERROR_DATA_SCHEMAS = {
   TOKEN_INDEXED_PRICERESOLVER_REGISTRATION_MISSING_VALID_INITIALIZATION_CALLDATA: dapiErrorContextDataSchema,
   TOKEN_INDEXER_DATA_INVALID: dapiErrorContextDataSchema,
   TOKEN_INTERFACE_NOT_SUPPORTED: dapiPublicErrorDataSchema({
-    requiredInterfaces: z7.array(z7.string())
+    requiredInterfaces: z10.array(z10.string())
   }),
   TOKEN_LIST_METADATA_KEY_IDENTIFIER_INELIGIBLE: dapiPublicErrorDataSchema({
-    key: z7.string()
+    key: z10.string()
   }),
   TOKEN_LIST_METADATA_KEY_NOT_BUCKETABLE: dapiPublicErrorDataSchema({
-    key: z7.string()
+    key: z10.string()
   }),
   TOKEN_LIST_METADATA_KEY_UNKNOWN: dapiPublicErrorDataSchema({
-    key: z7.string(),
-    availableKeys: z7.array(z7.string())
+    key: z10.string(),
+    availableKeys: z10.array(z10.string())
   }),
   TOKEN_REDEEM_BOND_MATURITY_REDEMPTION_FEATURE_ATTACHED_LEGACY_TOP_UP_WOULD_NOT_FUND_CONFIG: dapiErrorContextDataSchema,
   TOKEN_REDEEM_BOND_NOT_YET_INDEXED_INDEXER_PROCESSED_INITIALIZATION_PLEASE_LATER: dapiErrorContextDataSchema,
@@ -63550,7 +63850,7 @@ var CUSTOM_ERROR_DATA_SCHEMAS = {
   USER_KYC_NO_VERSION_CLONE_INITIALDATA_NEW_USERS: dapiErrorContextDataSchema,
   USER_KYC_SOURCE_VERSION_NOT_FOUND_INITIALDATA_NEW_USERS: dapiErrorContextDataSchema,
   USER_NOT_AUTHORIZED: dapiPublicErrorDataSchema({
-    requiredRoles: z7.union([z7.string(), z7.array(z7.string()), RoleRequirementSchema])
+    requiredRoles: z10.union([z10.string(), z10.array(z10.string()), RoleRequirementSchema])
   }),
   WEBHOOK_REPLAY_RATE_LIMITED: retryAfterDataSchema
 };
@@ -67932,7 +68232,7 @@ var CUSTOM_ERRORS = {
   },
   USER_NOT_AUTHORIZED: {
     status: 403,
-    message: "User does not have the required role to execute this operation.",
+    message: "This action requires a role the acting wallet does not hold.",
     data: CUSTOM_ERROR_DATA_SCHEMAS.USER_NOT_AUTHORIZED
   },
   USER_NOT_FOUND: {
@@ -68133,23 +68433,23 @@ var v2Contract = baseContract.$route({
 });
 
 // ../../packages/dalp/api-contract/src/routes/account/routes/account.search.schema.ts
-import { z as z8 } from "zod";
-var AccountSearchGraphResponseSchema = z8.object({
-  account: z8.object({
+import { z as z11 } from "zod";
+var AccountSearchGraphResponseSchema = z11.object({
+  account: z11.object({
     id: ethereumAddress,
-    isContract: z8.boolean(),
-    contractName: z8.string().nullable().optional()
+    isContract: z11.boolean(),
+    contractName: z11.string().nullable().optional()
   }).nullable()
 });
-var AccountSearchInputSchema = z8.object({
-  query: z8.string().min(1).meta({ description: "Search query for account address", examples: ["0x71C7", "alice.eth"] }),
-  limit: z8.number().int().positive().max(50).default(10)
+var AccountSearchInputSchema = z11.object({
+  query: z11.string().min(1).meta({ description: "Search query for account address", examples: ["0x71C7", "alice.eth"] }),
+  limit: z11.number().int().positive().max(50).default(10)
 });
-var AccountSearchResultSchema = z8.object({
+var AccountSearchResultSchema = z11.object({
   id: ethereumAddress,
-  isContract: z8.boolean().optional().default(false).meta({ description: "Whether the account is a contract", examples: [true, false] }),
-  contractName: z8.string().optional().meta({ description: "The name of the contract", examples: ["MyToken", "BondFactory"] }),
-  displayName: z8.string().optional().meta({ description: "The display name of the account", examples: ["Alice", "Treasury"] })
+  isContract: z11.boolean().optional().default(false).meta({ description: "Whether the account is a contract", examples: [true, false] }),
+  contractName: z11.string().optional().meta({ description: "The name of the contract", examples: ["MyToken", "BondFactory"] }),
+  displayName: z11.string().optional().meta({ description: "The display name of the account", examples: ["Alice", "Treasury"] })
 });
 
 // ../../packages/dalp/api-contract/src/tag-registry.ts
@@ -68606,10 +68906,10 @@ var accountSearchContract = v1Contract.route({
 }).input(AccountSearchInputSchema).output(AccountSearchResultSchema.array());
 
 // ../../packages/dalp/api-contract/src/routes/actions/routes/actions.list.schema.ts
-import { z as z9 } from "zod";
-var ActionStatusSchema = z9.enum(["PENDING", "UPCOMING", "EXECUTED", "EXPIRED"]);
-var ActionSourceSchema = z9.enum(["on-chain", "off-chain"]);
-var ActionTypeSchema = z9.enum([
+import { z as z12 } from "zod";
+var ActionStatusSchema = z12.enum(["PENDING", "UPCOMING", "EXECUTED", "EXPIRED"]);
+var ActionSourceSchema = z12.enum(["on-chain", "off-chain"]);
+var ActionTypeSchema = z12.enum([
   "MatureBond",
   "RedeemBond",
   "ClaimYield",
@@ -68624,26 +68924,26 @@ var ActionTypeSchema = z9.enum([
   "CastPollBallot",
   "ActivateVotingPower"
 ]);
-var KycActionMetadataSchema = z9.object({
-  reason: z9.string().meta({
+var KycActionMetadataSchema = z12.object({
+  reason: z12.string().meta({
     description: "Reason for the update request",
     examples: ["Address change required", "Document expired"]
   }),
-  requiredFields: z9.array(z9.string()).meta({
+  requiredFields: z12.array(z12.string()).meta({
     description: "List of fields that need updating",
     examples: [["address", "phone"], ["passport"]]
   }),
-  sourceVersionId: z9.string().meta({
+  sourceVersionId: z12.string().meta({
     description: "ID of the version to clone data from when creating draft",
     examples: ["ver-001", "ver-002"]
   }),
-  requestId: z9.string().meta({
+  requestId: z12.string().meta({
     description: "ID of the KYC action request",
     examples: ["req-001", "req-002"]
   })
 });
-var MultisigActionMetadataSchema = z9.object({
-  userOpHash: z9.string().meta({
+var MultisigActionMetadataSchema = z12.object({
+  userOpHash: z12.string().meta({
     description: "UserOperation hash — needed to call POST /sign endpoint",
     examples: ["0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"]
   }),
@@ -68651,61 +68951,61 @@ var MultisigActionMetadataSchema = z9.object({
     description: "Smart wallet address — needed to build the sign URL",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  threshold: z9.string().meta({
+  threshold: z12.string().meta({
     description: "Required cumulative weight (bigint as decimal string)",
     examples: ["2"]
   }),
-  currentWeight: z9.string().meta({
+  currentWeight: z12.string().meta({
     description: "Current accumulated weight (bigint as decimal string)",
     examples: ["1"]
   }),
-  description: z9.string().nullable().meta({
+  description: z12.string().nullable().meta({
     description: "Human-readable description of the pending operation",
     examples: ["Add signer 0x1234...abcd", null]
   }),
-  operationKind: z9.string().nullable().meta({
+  operationKind: z12.string().nullable().meta({
     description: "Operation kind from the transaction queue (e.g., smart-wallet.add-signer)",
     examples: ["smart-wallet.add-signer", null]
   })
 });
-var CustodyPendingActionMetadataSchema = z9.object({
-  provider: z9.string().meta({
+var CustodyPendingActionMetadataSchema = z12.object({
+  provider: z12.string().meta({
     description: "Custody provider backing this approval",
     examples: ["luna", "dfns", "fireblocks"]
   }),
-  executable: z9.boolean().meta({
+  executable: z12.boolean().meta({
     description: "Whether the approval can be approved/denied in-app (true for DFNS/Fireblocks, false for out-of-band Luna)",
     examples: [true, false]
   }),
-  approvalId: z9.string().nullable().meta({
+  approvalId: z12.string().nullable().meta({
     description: "Provider approval id passed to the resolve-approval route; null for out-of-band providers",
     examples: ["appr-001", null]
   }),
-  transactionId: z9.string().nullable().meta({
+  transactionId: z12.string().nullable().meta({
     description: "transaction_request id this approval blocks, when known (out-of-band path)",
     examples: ["019dce7d-4bd0-7daf-a42c-fcc222517fbb", null]
   }),
-  operationKind: z9.string().nullable().meta({
+  operationKind: z12.string().nullable().meta({
     description: "Human-readable operation kind awaiting approval",
     examples: ["token.transfer", null]
   })
 });
-var GovernanceActionMetadataSchema = z9.object({
+var GovernanceActionMetadataSchema = z12.object({
   governorAddress: ethereumAddress.nullable().meta({
     description: "Governor contract address the proposal lives on (null for poll actions)",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F", null]
   }),
-  proposalId: z9.string().nullable().meta({
+  proposalId: z12.string().nullable().meta({
     description: "On-chain proposal id — uint256 as a decimal string (null for poll actions)",
     examples: ["12345678901234567890", null]
   }),
-  pollId: z9.string().nullable().meta({
+  pollId: z12.string().nullable().meta({
     description: "Off-chain poll id (null for on-chain governance actions)",
     examples: ["019dce7d-4bd0-7daf-a42c-fcc222517fbb", null]
   })
 });
-var ActionSchema = z9.object({
-  id: z9.string().meta({
+var ActionSchema = z12.object({
+  id: z12.string().meta({
     description: "Unique identifier for the action",
     examples: ["action-001", "action-002"]
   }),
@@ -68713,7 +69013,7 @@ var ActionSchema = z9.object({
     description: "Canonical action type used for filtering and execution",
     examples: ["ApproveXvPSettlement", "UpdateKYCData"]
   }),
-  name: z9.string().meta({
+  name: z12.string().meta({
     description: "Human-readable display name of the action",
     examples: ["Settlement approval for Series A", "KYC Update"]
   }),
@@ -68763,17 +69063,17 @@ var ActionSchema = z9.object({
     examples: [null]
   })
 });
-var ActionsListDataSchema = z9.array(ActionSchema);
-var ActionsListInputSchema = z9.object({
+var ActionsListDataSchema = z12.array(ActionSchema);
+var ActionsListInputSchema = z12.object({
   status: ActionStatusSchema.optional().meta({
     description: "Filter actions by their current status",
     examples: ["PENDING", "EXECUTED"]
   }),
-  targets: z9.array(ethereumAddress).optional().meta({
+  targets: z12.array(ethereumAddress).optional().meta({
     description: "Filter actions by their target addresses",
     examples: [["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]]
   }),
-  name: z9.string().optional().meta({
+  name: z12.string().optional().meta({
     description: "Filter actions by their name",
     examples: ["Transfer Approval", "KYC Update"]
   }),
@@ -68782,12 +69082,12 @@ var ActionsListInputSchema = z9.object({
     examples: ["ClaimYield", "ApproveXvPSettlement"]
   })
 });
-var ActionExecutorSchemaV1 = z9.object({
-  id: z9.string().meta({
+var ActionExecutorSchemaV1 = z12.object({
+  id: z12.string().meta({
     description: "Unique identifier for the action executor",
     examples: ["exec-001", "exec-002"]
   }),
-  executors: z9.array(ethereumAddress.nullable()).meta({
+  executors: z12.array(ethereumAddress.nullable()).meta({
     description: "List of addresses authorized to execute actions",
     examples: [["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]]
   })
@@ -68798,7 +69098,7 @@ var ActionSchemaV1 = ActionSchema.extend({
     examples: [{ id: "exec-001", executors: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"] }]
   })
 });
-var ActionsListResponseSchemaV1 = z9.array(ActionSchemaV1);
+var ActionsListResponseSchemaV1 = z12.array(ActionSchemaV1);
 
 // ../../packages/dalp/api-contract/src/routes/actions/actions.contract.ts
 var list = v1Contract.route({
@@ -68810,47 +69110,47 @@ var list = v1Contract.route({
 }).input(ActionsListInputSchema).output(ActionsListResponseSchemaV1);
 
 // ../../packages/dalp/api-contract/src/routes/addons/fixed-yield-schedule/routes/fixed-yield-schedule.claim.schema.ts
-import { z as z15 } from "zod";
+import { z as z18 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/common/schemas/mutation-output.schema.ts
-import { z as z10 } from "zod";
-var BaseMutationOutputSchema = z10.object({
-  txHash: z10.string().meta({
+import { z as z13 } from "zod";
+var BaseMutationOutputSchema = z13.object({
+  txHash: z13.string().meta({
     description: "The transaction hash",
     examples: ["0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"]
   })
 });
 
 // ../../packages/dalp/api-contract/src/routes/addons/fixed-yield-schedule/schemas/fixed-yield-schedule.input.schema.ts
-import { z as z14 } from "zod";
+import { z as z17 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/common/schemas/mutation.schema.ts
-import { z as z13 } from "zod";
+import { z as z16 } from "zod";
 
 // ../../packages/core/validation/src/verification-type.ts
-import { z as z11 } from "zod";
+import { z as z14 } from "zod";
 var verificationTypes = ["OTP", "PINCODE", "SECRET_CODES"];
 var walletVerificationTypes = ["OTP", "PINCODE", "SECRET_CODES", "OIDC_MFA"];
-var verificationType = z11.enum(verificationTypes).meta({
+var verificationType = z14.enum(verificationTypes).meta({
   description: "Type of verification",
   examples: ["OTP", "PINCODE", "SECRET_CODES"]
 });
-var walletVerificationType = z11.enum(walletVerificationTypes).describe("Type of verification for wallet transactions");
+var walletVerificationType = z14.enum(walletVerificationTypes).describe("Type of verification for wallet transactions");
 
 // ../../packages/dalp/api-contract/src/routes/common/schemas/user-verification.schema.ts
-import { z as z12 } from "zod";
-var UserVerificationSchema = z12.object({
-  secretVerificationCode: z12.string(),
+import { z as z15 } from "zod";
+var UserVerificationSchema = z15.object({
+  secretVerificationCode: z15.string(),
   verificationType: walletVerificationType.default("PINCODE")
 });
 
 // ../../packages/dalp/api-contract/src/routes/common/schemas/mutation.schema.ts
-var MutationInputSchema = z13.object({
+var MutationInputSchema = z16.object({
   walletVerification: UserVerificationSchema.optional()
 });
 
 // ../../packages/dalp/api-contract/src/routes/addons/fixed-yield-schedule/schemas/fixed-yield-schedule.input.schema.ts
-var FixedYieldScheduleReadInputSchema = z14.object({
+var FixedYieldScheduleReadInputSchema = z17.object({
   scheduleAddress: ethereumAddress.meta({
     description: "The fixed yield schedule contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -68861,7 +69161,7 @@ var FixedYieldScheduleMutationInputSchema = FixedYieldScheduleReadInputSchema.ex
 // ../../packages/dalp/api-contract/src/routes/addons/fixed-yield-schedule/routes/fixed-yield-schedule.claim.schema.ts
 var FixedYieldScheduleClaimInputSchema = FixedYieldScheduleMutationInputSchema;
 var FixedYieldScheduleClaimOutputSchema = BaseMutationOutputSchema.extend({
-  complete: z15.boolean().optional().meta({
+  complete: z18.boolean().optional().meta({
     description: "False when more completed periods remain to claim after this request (call claim again to continue); true when fully caught up. Omitted for async-accepted claims.",
     examples: [true]
   })
@@ -68877,10 +69177,10 @@ var fixedYieldScheduleClaimContract = v1Contract.route({
 }).input(FixedYieldScheduleClaimInputSchema).output(FixedYieldScheduleClaimOutputSchema);
 
 // ../../packages/core/validation/src/basis-points.ts
-import { z as z16 } from "zod";
-var BasisPointsSchema = z16.int("Basis points must be an integer").min(0, "Basis points cannot be negative").max(20000, "Basis points cannot exceed 20000 (200%)").meta({ description: "Basis points value between 0 and 20000 (0% to 200%)", examples: [100, 250, 500, 1000] }).brand("BasisPoints");
+import { z as z19 } from "zod";
+var BasisPointsSchema = z19.int("Basis points must be an integer").min(0, "Basis points cannot be negative").max(20000, "Basis points cannot exceed 20000 (200%)").meta({ description: "Basis points value between 0 and 20000 (0% to 200%)", examples: [100, 250, 500, 1000] }).brand("BasisPoints");
 var basisPoints = () => BasisPointsSchema;
-var FeeRateBpsSchema = z16.int("Fee rate basis points must be an integer").min(0, "Fee rate basis points cannot be negative").max(1e4, "Fee rate basis points cannot exceed 10000 (100%)").meta({
+var FeeRateBpsSchema = z19.int("Fee rate basis points must be an integer").min(0, "Fee rate basis points cannot be negative").max(1e4, "Fee rate basis points cannot exceed 10000 (100%)").meta({
   description: "Fee rate in basis points (0-10000, 0%-100%) — capped to match on-chain fee feature contracts",
   examples: [0, 100, 250, 1000, 1e4]
 }).brand("FeeRateBps");
@@ -68891,12 +69191,12 @@ function getBasisPoints(value2) {
 
 // ../../packages/core/validation/src/blocktime.ts
 import { getUnixTime as getUnixTime2 } from "date-fns";
-import { z as z17 } from "zod";
+import { z as z20 } from "zod";
 var blocktime = (options = {}) => {
-  const base = z17.unknown().superRefine((value2, ctx) => {
+  const base = z20.unknown().superRefine((value2, ctx) => {
     if (typeof value2 === "number" && value2 < 0) {
       ctx.addIssue({
-        code: z17.ZodIssueCode.custom,
+        code: z20.ZodIssueCode.custom,
         message: "Timestamp cannot be negative"
       });
     }
@@ -68919,7 +69219,7 @@ var blocktime = (options = {}) => {
 
 // ../../packages/core/validation/src/iso-country-code.ts
 import { iso31661, iso31661Alpha2ToNumeric, iso31661NumericToAlpha2 } from "iso-3166";
-import { z as z18 } from "zod";
+import { z as z21 } from "zod";
 var displayNamesCache = new Map;
 var KOSOVO_ALPHA2 = "XK";
 var KOSOVO_NUMERIC = "983";
@@ -68937,25 +69237,25 @@ var validNumericCountryCodes = numericCountryCodes;
 var validNumericCountryCodesAsNumbers = validNumericCountryCodes.map((code) => Number.parseInt(code, 10));
 var validNumericCountryCodesAsStrings = validNumericCountryCodesAsNumbers.map((code) => code.toString());
 var validNumericCountryCodesAsNumbersSet = new Set(validNumericCountryCodesAsNumbers);
-var validNumericCountryCodesAsNumbersSchema = z18.number().refine((n) => validNumericCountryCodesAsNumbersSet.has(n), {
+var validNumericCountryCodesAsNumbersSchema = z21.number().refine((n) => validNumericCountryCodesAsNumbersSet.has(n), {
   message: "Invalid ISO 3166-1 numeric country code"
 });
 var validNumericCountryCodesAsStringsSet = new Set(validNumericCountryCodesAsStrings);
-var validNumericCountryCodesAsStringsSchema = z18.string().refine((s) => validNumericCountryCodesAsStringsSet.has(s), {
+var validNumericCountryCodesAsStringsSchema = z21.string().refine((s) => validNumericCountryCodesAsStringsSet.has(s), {
   message: "Invalid ISO 3166-1 numeric country code"
 });
-var isoCountryCode = z18.enum(validCountryCodes).meta({ description: "ISO 3166-1 alpha-2 country code", examples: ["US", "GB", "DE", "JP"] });
-var isoCountryCodeNormalized = z18.preprocess((val) => typeof val === "string" ? val.toUpperCase() : val, isoCountryCode).meta({ description: "ISO 3166-1 alpha-2 country code (case-insensitive)", examples: ["US", "us", "Us", "GB"] });
-var isoCountryCodeNumeric = z18.union([
-  z18.enum(validNumericCountryCodes),
+var isoCountryCode = z21.enum(validCountryCodes).meta({ description: "ISO 3166-1 alpha-2 country code", examples: ["US", "GB", "DE", "JP"] });
+var isoCountryCodeNormalized = z21.preprocess((val) => typeof val === "string" ? val.toUpperCase() : val, isoCountryCode).meta({ description: "ISO 3166-1 alpha-2 country code (case-insensitive)", examples: ["US", "us", "Us", "GB"] });
+var isoCountryCodeNumeric = z21.union([
+  z21.enum(validNumericCountryCodes),
   validNumericCountryCodesAsNumbersSchema,
   validNumericCountryCodesAsStringsSchema
-]).pipe(z18.coerce.number()).meta({ description: "ISO 3166-1 numeric country code", examples: [840, 826, 276, 392] });
+]).pipe(z21.coerce.number()).meta({ description: "ISO 3166-1 numeric country code", examples: [840, 826, 276, 392] });
 
 // ../../packages/core/validation/src/time-interval.ts
-import { z as z19 } from "zod";
+import { z as z22 } from "zod";
 var timeIntervals = ["HOURLY", "DAILY", "WEEKLY", "MONTHLY", "QUARTERLY", "SEMI_ANNUAL", "YEARLY"];
-var TimeIntervalSchema = z19.enum(timeIntervals).meta({ description: "Time interval for scheduling", examples: ["DAILY", "WEEKLY", "MONTHLY", "YEARLY"] });
+var TimeIntervalSchema = z22.enum(timeIntervals).meta({ description: "Time interval for scheduling", examples: ["DAILY", "WEEKLY", "MONTHLY", "YEARLY"] });
 var timeInterval = () => TimeIntervalSchema;
 var TIME_INTERVAL_SECONDS = {
   HOURLY: 3600,
@@ -68968,15 +69268,15 @@ var TIME_INTERVAL_SECONDS = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/addons/fixed-yield-schedule/routes/fixed-yield-schedule.create.schema.ts
-import { z as z20 } from "zod";
+import { z as z23 } from "zod";
 var FixedYieldScheduleCreateInputSchema = MutationInputSchema.extend({
   yieldRate: basisPoints().meta({ description: "The yield rate in basis points (1% = 100)", examples: [500, 1000] }),
-  paymentInterval: z20.union([
+  paymentInterval: z23.union([
     timeInterval().meta({
       description: "The payment interval (HOURLY, DAILY, WEEKLY, MONTHLY, QUARTERLY, YEARLY)",
       examples: ["DAILY", "MONTHLY"]
     }),
-    z20.int().positive().meta({ description: "The payment interval in seconds", examples: [86400, 2592000] })
+    z23.int().positive().meta({ description: "The payment interval in seconds", examples: [86400, 2592000] })
   ]).meta({ description: "The payment interval", examples: ["MONTHLY"] }),
   startTime: blocktime({ future: true }).meta({
     description: "The start time for yield payments as Unix timestamp",
@@ -69005,26 +69305,15 @@ var FixedYieldScheduleCreateInputSchema = MutationInputSchema.extend({
 });
 
 // ../../packages/core/validation/src/fixed-yield-schedule.ts
-import { z as z23 } from "zod";
+import { z as z26 } from "zod";
 
 // ../../packages/core/validation/src/bigdecimal.ts
 import { add, from, greaterThan, isDnum, setDecimals, toJSON } from "dnum";
-import { z as z21 } from "zod";
-
-// ../../packages/core/validation/src/v1-frozen-spec.ts
-var V1_FROZEN_SPEC_META_KEY = "x-dalp-v1-frozen-spec";
-function v1FrozenSpecMeta(directive) {
-  return { [V1_FROZEN_SPEC_META_KEY]: directive };
-}
-function v1FrozenRequired(schema, directive = {}) {
-  return schema.meta(v1FrozenSpecMeta({ required: true, ...directive }));
-}
-
-// ../../packages/core/validation/src/bigdecimal.ts
-var BigDecimalSchema = z21.union([
-  z21.string(),
-  z21.number(),
-  z21.custom((val) => isDnum(val), {
+import { z as z24 } from "zod";
+var BigDecimalSchema = z24.union([
+  z24.string(),
+  z24.number(),
+  z24.custom((val) => isDnum(val), {
     message: "Expected a Dnum value"
   })
 ]).meta({
@@ -69041,7 +69330,7 @@ var BigDecimalSchema = z21.union([
         code: "custom",
         message: "Invalid value. NaN, Infinity, and -Infinity are not allowed"
       });
-      return z21.NEVER;
+      return z24.NEVER;
     }
   }
   try {
@@ -69051,7 +69340,7 @@ var BigDecimalSchema = z21.union([
       code: "custom",
       message: "Invalid decimal format. Please provide a valid numeric string"
     });
-    return z21.NEVER;
+    return z24.NEVER;
   }
 }).meta(v1FrozenSpecMeta({ type: "string" }));
 var bigDecimal = () => BigDecimalSchema;
@@ -69083,8 +69372,8 @@ function dnumFromDecimalString(s) {
 }
 
 // ../../packages/core/validation/src/decimals.ts
-import { z as z22 } from "zod";
-var DecimalsSchema = z22.union([z22.string(), z22.number()]).transform((value2, ctx) => {
+import { z as z25 } from "zod";
+var DecimalsSchema = z25.union([z25.string(), z25.number()]).transform((value2, ctx) => {
   if (typeof value2 === "number") {
     return value2;
   }
@@ -69094,7 +69383,7 @@ var DecimalsSchema = z22.union([z22.string(), z22.number()]).transform((value2,
       code: "custom",
       message: "Decimals must be a whole number (integer)"
     });
-    return z22.NEVER;
+    return z25.NEVER;
   }
   return parsed;
 }).refine((value2) => Number.isInteger(value2), {
@@ -69108,14 +69397,14 @@ var decimals = () => DecimalsSchema;
 
 // ../../packages/core/validation/src/fixed-yield-schedule.ts
 function fixedYieldSchedulePeriodId() {
-  return z23.string().refine((id) => /^0x[a-f0-9]{40}-period-\d+$/i.test(id), {
+  return z26.string().refine((id) => /^0x[a-f0-9]{40}-period-\d+$/i.test(id), {
     message: 'Period ID must be in format "0x{40-hex-chars}-period-{index}"'
   }).meta({
     description: "Unique identifier for a fixed yield period (composite: {scheduleAddress}-period-{index})",
     examples: ["0x1234567890abcdef1234567890abcdef12345678-period-0"]
   });
 }
-var FixedYieldSchedulePeriodSchema = z23.object({
+var FixedYieldSchedulePeriodSchema = z26.object({
   id: fixedYieldSchedulePeriodId(),
   startDate: timestamp().meta({
     description: "Unix timestamp when period starts",
@@ -69134,10 +69423,10 @@ var FixedYieldSchedulePeriodSchema = z23.object({
     description: "Total yield generated in this period",
     examples: ["1500.0", "1000.0"]
   }),
-  completed: z23.boolean().meta({ description: "Whether this period has been completed", examples: [true, false] })
+  completed: z26.boolean().meta({ description: "Whether this period has been completed", examples: [true, false] })
 });
 var fixedYieldSchedulePeriod = () => FixedYieldSchedulePeriodSchema;
-var FixedYieldScheduleSchema = z23.object({
+var FixedYieldScheduleSchema = z26.object({
   id: ethereumAddress.meta({
     description: "Yield schedule contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -69150,18 +69439,18 @@ var FixedYieldScheduleSchema = z23.object({
     description: "Unix timestamp when yield ends",
     examples: [1711890000, 1735689600]
   }),
-  rate: z23.string().meta({ description: "Yield rate in basis points", examples: ["500", "1000", "250"] }),
-  interval: z23.string().meta({ description: "Payment interval in seconds", examples: ["2592000", "86400", "604800"] }),
+  rate: z26.string().meta({ description: "Yield rate in basis points", examples: ["500", "1000", "250"] }),
+  interval: z26.string().meta({ description: "Payment interval in seconds", examples: ["2592000", "86400", "604800"] }),
   totalClaimed: bigDecimal().meta({ description: "Total yield claimed", examples: ["1000.0", "0"] }),
   totalUnclaimedYield: bigDecimal().meta({ description: "Total unclaimed yield", examples: ["500.0", "0"] }),
   totalYield: bigDecimal().meta({ description: "Total yield generated", examples: ["1500.0", "1000.0"] }),
-  denominationAsset: z23.object({
+  denominationAsset: z26.object({
     id: ethereumAddress.meta({
       description: "Denomination asset contract address",
       examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
     }),
     decimals: decimals().meta({ description: "Denomination asset decimals", examples: [6, 18] }),
-    symbol: z23.string().meta({ description: "Denomination asset symbol", examples: ["USDC", "USDT", "DAI"] })
+    symbol: z26.string().meta({ description: "Denomination asset symbol", examples: ["USDC", "USDT", "DAI"] })
   }),
   currentPeriod: FixedYieldSchedulePeriodSchema.nullable().meta({
     description: "Current active yield period",
@@ -69171,7 +69460,7 @@ var FixedYieldScheduleSchema = z23.object({
     description: "Next scheduled yield period",
     examples: [null]
   }),
-  periods: z23.array(FixedYieldSchedulePeriodSchema).meta({ description: "Array of all yield periods", examples: [[]] })
+  periods: z26.array(FixedYieldSchedulePeriodSchema).meta({ description: "Array of all yield periods", examples: [[]] })
 });
 var fixedYieldSchedule = () => FixedYieldScheduleSchema;
 
@@ -69198,17 +69487,17 @@ var fixedYieldScheduleReadContract = v1Contract.route({
 
 // ../../packages/core/validation/src/asset-amount.ts
 import { from as from2, isDnum as isDnum2 } from "dnum";
-import { z as z24 } from "zod";
+import { z as z27 } from "zod";
 var MAX_UINT256 = 2n ** 256n - 1n;
 var DNUM_WIRE_DECIMAL = /^-?\d+\.\d+$/;
-var assetAmount = z24.preprocess((value2, ctx) => {
+var assetAmount = z27.preprocess((value2, ctx) => {
   const isDnumValue = isDnum2(value2);
   if (Array.isArray(value2) && (value2.length !== 2 || !isDnumValue)) {
     ctx.addIssue({
       code: "custom",
       message: "Invalid asset amount format: array (not a dnum)"
     });
-    return z24.NEVER;
+    return z27.NEVER;
   }
   try {
     const dnum = typeof value2 === "string" && DNUM_WIRE_DECIMAL.test(value2) ? dnumFromDecimalString(value2) : from2(value2);
@@ -69217,14 +69506,14 @@ var assetAmount = z24.preprocess((value2, ctx) => {
         code: "custom",
         message: "Asset amount cannot be negative"
       });
-      return z24.NEVER;
+      return z27.NEVER;
     }
     if (dnum[0] > MAX_UINT256) {
       ctx.addIssue({
         code: "custom",
         message: "Asset amount exceeds the maximum uint256 value"
       });
-      return z24.NEVER;
+      return z27.NEVER;
     }
     return dnum[0];
   } catch {
@@ -69235,14 +69524,14 @@ var assetAmount = z24.preprocess((value2, ctx) => {
           code: "custom",
           message: "Asset amount cannot be negative"
         });
-        return z24.NEVER;
+        return z27.NEVER;
       }
       if (bigintValue > MAX_UINT256) {
         ctx.addIssue({
           code: "custom",
           message: "Asset amount exceeds the maximum uint256 value"
         });
-        return z24.NEVER;
+        return z27.NEVER;
       }
       return bigintValue;
     } catch {
@@ -69250,10 +69539,10 @@ var assetAmount = z24.preprocess((value2, ctx) => {
         code: "custom",
         message: "must be a positive number"
       });
-      return z24.NEVER;
+      return z27.NEVER;
     }
   }
-}, z24.coerce.bigint());
+}, z27.coerce.bigint());
 
 // ../../packages/dalp/api-contract/src/routes/addons/fixed-yield-schedule/routes/fixed-yield-schedule.top-up.schema.ts
 var FixedYieldScheduleTopUpInputSchema = FixedYieldScheduleMutationInputSchema.extend({
@@ -69304,11 +69593,11 @@ var fixedYieldScheduleWithdrawContract = v1Contract.route({
 }).input(FixedYieldScheduleWithdrawInputSchema).output(FixedYieldScheduleWithdrawOutputSchema);
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/routes/mutations/approve/xvp.approve.schema.ts
-import { z as z26 } from "zod";
+import { z as z29 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/schemas/xvp.input.schema.ts
-import { z as z25 } from "zod";
-var XvpSettlementReadInputSchema = z25.object({
+import { z as z28 } from "zod";
+var XvpSettlementReadInputSchema = z28.object({
   settlementAddress: ethereumAddress.meta({
     description: "The XvP settlement contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -69318,20 +69607,20 @@ var XvpSettlementMutationInputSchema = XvpSettlementReadInputSchema.extend(Mutat
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/routes/mutations/approve/xvp.approve.schema.ts
 var XvpApproveInputSchema = XvpSettlementMutationInputSchema;
-var XvpApproveOutputSchema = z26.object({
-  transactionHash: z26.string()
+var XvpApproveOutputSchema = z29.object({
+  transactionHash: z29.string()
 });
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/routes/mutations/cancel/xvp.cancel.schema.ts
-import { z as z27 } from "zod";
+import { z as z30 } from "zod";
 var XvpCancelInputSchema = XvpSettlementMutationInputSchema;
-var XvpCancelOutputSchema = z27.object({
-  transactionHash: z27.string()
+var XvpCancelOutputSchema = z30.object({
+  transactionHash: z30.string()
 });
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/routes/mutations/create/xvp.create.schema.ts
-import { z as z28 } from "zod";
-function isHex(value2) {
+import { z as z31 } from "zod";
+function isHex2(value2) {
   return /^0x[0-9a-fA-F]*$/.test(value2);
 }
 var SECRET_MIN_LENGTH = 32;
@@ -69342,8 +69631,8 @@ var XVP_CREATE_NAME_VISIBLE_CHARACTER_PATTERN = String.raw`[^\p{White_Space}\p{D
 var XVP_CREATE_NAME_HAS_VISIBLE_CHARACTER = new RegExp(XVP_CREATE_NAME_VISIBLE_CHARACTER_PATTERN, "u");
 var XVP_CREATE_FLOWS_MIN_LENGTH_MESSAGE = "At least one flow is required";
 var XVP_CREATE_FLOWS_MAX_LENGTH_MESSAGE = `At most ${XVP_CREATE_FLOWS_MAX_LENGTH} flows are supported`;
-var LocalFlowSchema = z28.object({
-  type: z28.literal("local"),
+var LocalFlowSchema = z31.object({
+  type: z31.literal("local"),
   assetId: ethereumAddress.meta({
     description: "ERC-20 asset address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -69358,8 +69647,8 @@ var LocalFlowSchema = z28.object({
   }),
   amount: assetAmount.meta({ description: "Token amount in base units", examples: ["1000000000000000000"] })
 });
-var ExternalFlowSchema = z28.object({
-  type: z28.literal("external"),
+var ExternalFlowSchema = z31.object({
+  type: z31.literal("external"),
   assetId: ethereumAddress.meta({
     description: "ERC-20 asset address on external chain",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -69373,16 +69662,16 @@ var ExternalFlowSchema = z28.object({
     examples: ["0xbDA5747bFD65F08deb54cb465eB87D40e51B197E"]
   }),
   amount: assetAmount.meta({ description: "Token amount in base units", examples: ["1000000000000000000"] }),
-  externalChainId: z28.int().positive().meta({ description: "Target chain ID", examples: [1, 137, 42161] }),
+  externalChainId: z31.int().positive().meta({ description: "Target chain ID", examples: [1, 137, 42161] }),
   externalAssetDecimals: decimals().meta({ description: "Asset decimals on external chain", examples: [18, 6, 8] })
 });
-var XvpSettlementFlowSchema = z28.discriminatedUnion("type", [LocalFlowSchema, ExternalFlowSchema]);
-var XvpSettlementFlowsSchema = z28.array(XvpSettlementFlowSchema).min(1, XVP_CREATE_FLOWS_MIN_LENGTH_MESSAGE).max(XVP_CREATE_FLOWS_MAX_LENGTH, XVP_CREATE_FLOWS_MAX_LENGTH_MESSAGE);
-var RawSecretSchema = z28.string().min(SECRET_MIN_LENGTH, `Secret must be at least ${SECRET_MIN_LENGTH} characters`).max(SECRET_MAX_LENGTH, `Secret must be at most ${SECRET_MAX_LENGTH} characters`).meta({
+var XvpSettlementFlowSchema = z31.discriminatedUnion("type", [LocalFlowSchema, ExternalFlowSchema]);
+var XvpSettlementFlowsSchema = z31.array(XvpSettlementFlowSchema).min(1, XVP_CREATE_FLOWS_MIN_LENGTH_MESSAGE).max(XVP_CREATE_FLOWS_MAX_LENGTH, XVP_CREATE_FLOWS_MAX_LENGTH_MESSAGE);
+var RawSecretSchema = z31.string().min(SECRET_MIN_LENGTH, `Secret must be at least ${SECRET_MIN_LENGTH} characters`).max(SECRET_MAX_LENGTH, `Secret must be at most ${SECRET_MAX_LENGTH} characters`).meta({
   description: "Raw HTLC secret pre-image (plain text string).",
   examples: ["my-super-secret-preimage-for-htlc-swap"]
 });
-var HashlockSchema = z28.string().refine((value2) => isHex(value2) && value2.length === 66, {
+var HashlockSchema = z31.string().refine((value2) => isHex2(value2) && value2.length === 66, {
   message: "Hashlock must be a 0x-prefixed 32-byte hex string (66 chars)"
 }).meta({
   description: "Pre-computed keccak256 hashlock (bytes32)",
@@ -69405,8 +69694,8 @@ var XvpCreateBaseSchema = MutationInputSchema.extend({
     description: "The XvP addon factory contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  name: z28.string().min(1, "Name is required").max(XVP_CREATE_NAME_MAX_LENGTH, `Name must be at most ${XVP_CREATE_NAME_MAX_LENGTH} characters`).regex(XVP_CREATE_NAME_HAS_VISIBLE_CHARACTER, "Name is required"),
-  autoExecute: z28.boolean().default(false),
+  name: z31.string().min(1, "Name is required").max(XVP_CREATE_NAME_MAX_LENGTH, `Name must be at most ${XVP_CREATE_NAME_MAX_LENGTH} characters`).regex(XVP_CREATE_NAME_HAS_VISIBLE_CHARACTER, "Name is required"),
+  autoExecute: z31.boolean().default(false),
   cutoffDate: blocktime({ future: true }).meta({ description: "Settlement cutoff", examples: [1735689600] }),
   secret: RawSecretSchema.optional(),
   hashlock: HashlockSchema.optional(),
@@ -69423,8 +69712,8 @@ var XvpCreateSchema = XvpCreateBaseSchema.refine(validateHashlockRequirement, {
   message: "At least one flow must be a local flow (type: 'local').",
   path: ["flows"]
 });
-var XvpCreateOutputSchema = z28.object({
-  transactionHash: z28.string(),
+var XvpCreateOutputSchema = z31.object({
+  transactionHash: z31.string(),
   settlementId: ethereumAddress.meta({
     description: "Created XvP settlement contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -69432,99 +69721,87 @@ var XvpCreateOutputSchema = z28.object({
 });
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/routes/mutations/execute/xvp.execute.schema.ts
-import { z as z29 } from "zod";
+import { z as z32 } from "zod";
 var XvpExecuteInputSchema = XvpSettlementMutationInputSchema;
-var XvpExecuteOutputSchema = z29.object({
-  transactionHash: z29.string()
+var XvpExecuteOutputSchema = z32.object({
+  transactionHash: z32.string()
 });
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/routes/mutations/reveal-secret/xvp.reveal-secret.schema.ts
-import { z as z30 } from "zod";
-var EmailRecipientsSchema = z30.array(z30.email("Invalid email address")).max(10, "Maximum 10 email recipients allowed").optional().default([]);
+import { z as z33 } from "zod";
+var EmailRecipientsSchema = z33.array(z33.email("Invalid email address")).max(10, "Maximum 10 email recipients allowed").optional().default([]);
 var XvpRevealSecretInputSchema = XvpSettlementMutationInputSchema.extend({
   secret: RawSecretSchema,
   emailRecipients: EmailRecipientsSchema,
-  settlementName: z30.string().optional()
+  settlementName: z33.string().optional()
 });
-var EmailSendResultSchema = z30.object({
-  recipient: z30.email(),
-  success: z30.boolean(),
-  error: z30.string().optional()
+var EmailSendResultSchema = z33.object({
+  recipient: z33.email(),
+  success: z33.boolean(),
+  error: z33.string().optional()
 });
-var XvpRevealSecretOutputSchema = z30.object({
-  transactionHash: z30.string(),
-  emailResults: z30.array(EmailSendResultSchema).optional()
+var XvpRevealSecretOutputSchema = z33.object({
+  transactionHash: z33.string(),
+  emailResults: z33.array(EmailSendResultSchema).optional()
 });
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/routes/mutations/revoke-approval/xvp.revoke-approval.schema.ts
-import { z as z31 } from "zod";
+import { z as z34 } from "zod";
 var XvpRevokeApprovalInputSchema = XvpSettlementMutationInputSchema;
-var XvpRevokeApprovalOutputSchema = z31.object({
-  transactionHash: z31.string()
+var XvpRevokeApprovalOutputSchema = z34.object({
+  transactionHash: z34.string()
 });
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/routes/mutations/withdraw-cancel/xvp.withdraw-cancel.schema.ts
-import { z as z32 } from "zod";
+import { z as z35 } from "zod";
 var XvpWithdrawCancelInputSchema = XvpSettlementMutationInputSchema;
-var XvpWithdrawCancelOutputSchema = z32.object({
-  transactionHash: z32.string()
+var XvpWithdrawCancelOutputSchema = z35.object({
+  transactionHash: z35.string()
 });
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/routes/mutations/withdraw-expired/xvp.withdraw-expired.schema.ts
-import { z as z33 } from "zod";
+import { z as z36 } from "zod";
 var XvpWithdrawExpiredInputSchema = XvpSettlementMutationInputSchema;
-var XvpWithdrawExpiredOutputSchema = z33.object({
-  transactionHash: z33.string()
+var XvpWithdrawExpiredOutputSchema = z36.object({
+  transactionHash: z36.string()
 });
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/routes/xvp.decrypt.schema.ts
-import { z as z34 } from "zod";
+import { z as z37 } from "zod";
 var XvpDecryptInputSchema = XvpSettlementMutationInputSchema;
-var XvpDecryptOutputSchema = z34.object({
-  secret: z34.string().meta({
+var XvpDecryptOutputSchema = z37.object({
+  secret: z37.string().meta({
     description: "Decrypted HTLC secret in hex format",
     examples: ["0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"]
   }),
-  hashlock: z34.string().meta({
+  hashlock: z37.string().meta({
     description: "Keccak256 hashlock of the decrypted secret",
     examples: ["0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef12"]
   })
 });
 
-// ../../packages/core/validation/src/account.ts
-import { z as z35 } from "zod";
-var AccountSchema = z35.object({
-  id: ethereumAddress,
-  isContract: z35.boolean().meta({ description: "Whether this address is a smart contract (true) or EOA (false)", examples: [true, false] })
-});
-var account = () => AccountSchema;
-var accountArray = () => z35.array(account()).meta({
-  description: "Array of Account entities",
-  examples: [[{ id: "0x71C7656EC7ab88b098defB751B7401B5f6d8976F", isContract: false }]]
-});
-
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/routes/xvp.list.schema.ts
-import { z as z38 } from "zod";
+import { z as z40 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/common/schemas/paginated-list.schema.ts
-import { z as z37 } from "zod";
+import { z as z39 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/common/schemas/sortable-list.schema.ts
-import { z as z36 } from "zod";
-var SortableListSchema = z36.object({
-  orderDirection: z36.enum(["asc", "desc"]).default("asc"),
-  orderBy: z36.string().default("id")
+import { z as z38 } from "zod";
+var SortableListSchema = z38.object({
+  orderDirection: z38.enum(["asc", "desc"]).default("asc"),
+  orderBy: z38.string().default("id")
 });
 
 // ../../packages/dalp/api-contract/src/routes/common/schemas/paginated-list.schema.ts
 var PaginatedListSchema = SortableListSchema.extend({
-  offset: z37.number().int().nonnegative().default(0),
-  limit: z37.number().int().positive().max(200).default(25)
+  offset: z39.number().int().nonnegative().default(0),
+  limit: z39.number().int().positive().max(200).default(25)
 });
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/routes/xvp.list.schema.ts
-var XvpSettlementTypeSchema = z38.enum(["LOCAL", "HTLC"]);
-var XvpSettlementStatusSchema = z38.enum([
+var XvpSettlementTypeSchema = z40.enum(["LOCAL", "HTLC"]);
+var XvpSettlementStatusSchema = z40.enum([
   "EXECUTED",
   "CANCELLED",
   "EXPIRED",
@@ -69533,59 +69810,59 @@ var XvpSettlementStatusSchema = z38.enum([
   "WAITING_SECRET",
   "PENDING"
 ]);
-var XvpSettlementWarningSchema = z38.enum([
+var XvpSettlementWarningSchema = z40.enum([
   "CANCEL_PROPOSED",
   "EXPIRY_APPROACHING",
   "WAITING_SECRET_DELAY",
   "WITHDRAW_EXPIRED"
 ]);
-var XvpUserParticipationRoleSchema = z38.enum(["SENDER", "RECIPIENT", "BOTH"]);
-var XvpSettlementGraphItemSchema = z38.object({
+var XvpUserParticipationRoleSchema = z40.enum(["SENDER", "RECIPIENT", "BOTH"]);
+var XvpSettlementGraphItemSchema = z40.object({
   id: ethereumAddress,
-  name: z38.string(),
-  hasExternalFlows: z38.boolean(),
+  name: z40.string(),
+  hasExternalFlows: z40.boolean(),
   cutoffDate: timestamp(),
   createdAt: timestamp(),
   createdBy: account(),
-  secretRevealTx: z38.string().nullable().optional(),
-  executed: z38.boolean(),
-  cancelled: z38.boolean(),
-  withdrawn: z38.boolean(),
+  secretRevealTx: z40.string().nullable().optional(),
+  executed: z40.boolean(),
+  cancelled: z40.boolean(),
+  withdrawn: z40.boolean(),
   allApprovedAt: timestamp().nullable(),
-  approvalsCount: z38.coerce.number().int().nonnegative(),
-  approvals: z38.array(z38.object({
-    id: z38.string()
+  approvalsCount: z40.coerce.number().int().nonnegative(),
+  approvals: z40.array(z40.object({
+    id: z40.string()
   })).optional(),
-  cancelVotesCount: z38.coerce.number().int().nonnegative(),
-  localSendersCount: z38.coerce.number().int().nonnegative(),
-  localParticipantsCount: z38.coerce.number().int().nonnegative()
+  cancelVotesCount: z40.coerce.number().int().nonnegative(),
+  localSendersCount: z40.coerce.number().int().nonnegative(),
+  localParticipantsCount: z40.coerce.number().int().nonnegative()
 });
 var XvpSettlementListItemSchema = XvpSettlementGraphItemSchema.extend({
-  userApproved: z38.boolean()
+  userApproved: z40.boolean()
 });
-var XvpSettlementListSchema = z38.array(XvpSettlementListItemSchema);
-var XvpSettlementOrderBySchema = z38.enum(["createdAt", "cutoffDate", "name"]);
+var XvpSettlementListSchema = z40.array(XvpSettlementListItemSchema);
+var XvpSettlementOrderBySchema = z40.enum(["createdAt", "cutoffDate", "name"]);
 var XvpSettlementListInputSchema = PaginatedListSchema.extend({
   participant: ethereumAddress.optional(),
   systemAddon: ethereumAddress.optional(),
   orderBy: XvpSettlementOrderBySchema.default("createdAt"),
-  orderDirection: z38.enum(["asc", "desc"]).default("desc")
+  orderDirection: z40.enum(["asc", "desc"]).default("desc")
 });
-var XvpSettlementListResponseSchema = z38.object({
+var XvpSettlementListResponseSchema = z40.object({
   xvPSettlements: XvpSettlementListSchema,
-  total: z38.number().int().nonnegative()
+  total: z40.number().int().nonnegative()
 });
 
 // ../../packages/core/validation/src/asset-symbol.ts
-import { z as z39 } from "zod";
-var AssetSymbolSchema = z39.string().min(1, "Asset symbol is required").max(24, "Asset symbol must not exceed 24 characters").regex(/^[A-Z0-9]+$/, "Asset symbol must contain only uppercase letters (A-Z) and numbers (0-9)").meta({ description: "Trading symbol for the asset", examples: ["ETH", "BTC", "USDC", "AAPL"] });
+import { z as z41 } from "zod";
+var AssetSymbolSchema = z41.string().min(1, "Asset symbol is required").max(24, "Asset symbol must not exceed 24 characters").regex(/^[A-Z0-9]+$/, "Asset symbol must contain only uppercase letters (A-Z) and numbers (0-9)").meta({ description: "Trading symbol for the asset", examples: ["ETH", "BTC", "USDC", "AAPL"] });
 var assetSymbol = () => AssetSymbolSchema;
 
 // ../../packages/core/validation/src/bigint.ts
 import { ceil, toString as dnumToString, floor, from as from3, isDnum as isDnum3 } from "dnum";
-import { z as z40 } from "zod";
+import { z as z42 } from "zod";
 var INTEGER_BIGINT_STRING_PATTERN = /^-?\d+$/;
-var apiBigInt = z40.preprocess((value2, ctx) => {
+var apiBigInt = z42.preprocess((value2, ctx) => {
   if (typeof value2 === "bigint") {
     return value2;
   }
@@ -69594,7 +69871,7 @@ var apiBigInt = z40.preprocess((value2, ctx) => {
       code: "custom",
       message: "Invalid BigInt format: multiple decimal points"
     });
-    return z40.NEVER;
+    return z42.NEVER;
   }
   const isDnumValue = isDnum3(value2);
   if (Array.isArray(value2) && (value2.length !== 2 || !isDnumValue)) {
@@ -69602,7 +69879,7 @@ var apiBigInt = z40.preprocess((value2, ctx) => {
       code: "custom",
       message: "Invalid BigInt format: array (not a dnum)"
     });
-    return z40.NEVER;
+    return z42.NEVER;
   }
   try {
     const dnum = from3(value2);
@@ -69611,8 +69888,8 @@ var apiBigInt = z40.preprocess((value2, ctx) => {
   } catch {
     return value2;
   }
-}, z40.coerce.bigint());
-var apiIntegerBigInt = z40.preprocess((value2, ctx) => {
+}, z42.coerce.bigint());
+var apiIntegerBigInt = z42.preprocess((value2, ctx) => {
   if (typeof value2 === "bigint") {
     return value2;
   }
@@ -69622,14 +69899,14 @@ var apiIntegerBigInt = z40.preprocess((value2, ctx) => {
         code: "custom",
         message: "Invalid integer BigInt format"
       });
-      return z40.NEVER;
+      return z42.NEVER;
     }
     if (!Number.isSafeInteger(value2)) {
       ctx.addIssue({
         code: "custom",
         message: "Unsafe integer number: pass large integer values as strings"
       });
-      return z40.NEVER;
+      return z42.NEVER;
     }
     return value2;
   }
@@ -69640,65 +69917,65 @@ var apiIntegerBigInt = z40.preprocess((value2, ctx) => {
         code: "custom",
         message: "Invalid integer BigInt format"
       });
-      return z40.NEVER;
+      return z42.NEVER;
     }
     return trimmed;
   }
   return value2;
-}, z40.coerce.bigint());
+}, z42.coerce.bigint());
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/routes/xvp.read.schema.ts
-import { z as z41 } from "zod";
-var XvpSettlementFlowReadSchema = z41.object({
-  id: z41.string(),
-  isExternal: z41.boolean(),
-  externalChainId: z41.coerce.number(),
+import { z as z43 } from "zod";
+var XvpSettlementFlowReadSchema = z43.object({
+  id: z43.string(),
+  isExternal: z43.boolean(),
+  externalChainId: z43.coerce.number(),
   amount: bigDecimal().meta({ description: "Flow amount with arbitrary precision", examples: ["1000.50"] }),
   amountExact: apiBigInt,
-  from: z41.object({ id: ethereumAddress }),
-  to: z41.object({ id: ethereumAddress }),
-  asset: z41.object({
+  from: z43.object({ id: ethereumAddress }),
+  to: z43.object({ id: ethereumAddress }),
+  asset: z43.object({
     id: ethereumAddress,
     decimals: decimals(),
     symbol: assetSymbol()
   }).nullable(),
-  assetReference: z41.object({
-    id: z41.string(),
+  assetReference: z43.object({
+    id: z43.string(),
     address: ethereumAddress,
     decimals: decimals()
   }).nullable()
 });
-var XvpSettlementApprovalSchema = z41.object({
-  id: z41.string(),
-  approved: z41.boolean(),
+var XvpSettlementApprovalSchema = z43.object({
+  id: z43.string(),
+  approved: z43.boolean(),
   timestamp: timestamp().nullable(),
-  account: z41.object({ id: ethereumAddress })
+  account: z43.object({ id: ethereumAddress })
 });
-var XvpSettlementCancelVoteSchema = z41.object({
-  id: z41.string(),
+var XvpSettlementCancelVoteSchema = z43.object({
+  id: z43.string(),
   votedAt: timestamp().nullable(),
-  active: z41.boolean(),
-  account: z41.object({ id: ethereumAddress })
+  active: z43.boolean(),
+  account: z43.object({ id: ethereumAddress })
 });
 var XvpSettlementReadGraphSchema = XvpSettlementGraphItemSchema.extend({
-  secret: z41.string().meta({ description: "Secret from GraphQL", examples: ["0x1234..."] }).nullable().optional(),
-  secretRevealed: z41.boolean(),
+  secret: z43.string().meta({ description: "Secret from GraphQL", examples: ["0x1234..."] }).nullable().optional(),
+  secretRevealed: z43.boolean(),
   secretRevealedAt: timestamp().nullable(),
-  secretRevealTx: z41.string().nullable(),
-  secretRevealedBy: z41.object({ id: ethereumAddress }).nullable(),
+  secretRevealTx: z43.string().nullable(),
+  secretRevealedBy: z43.object({ id: ethereumAddress }).nullable(),
   hashlock: HashlockSchema.nullable().optional(),
-  autoExecute: z41.boolean(),
-  approvals: z41.array(XvpSettlementApprovalSchema),
-  cancelVotes: z41.array(XvpSettlementCancelVoteSchema),
-  flows: z41.array(XvpSettlementFlowReadSchema),
-  systemAddon: z41.object({ id: ethereumAddress })
+  autoExecute: z43.boolean(),
+  approvals: z43.array(XvpSettlementApprovalSchema),
+  cancelVotes: z43.array(XvpSettlementCancelVoteSchema),
+  flows: z43.array(XvpSettlementFlowReadSchema),
+  systemAddon: z43.object({ id: ethereumAddress })
 });
 var XvpSettlementReadSchema = XvpSettlementReadGraphSchema.extend({
-  hasStoredSecret: z41.boolean().meta({
+  hasStoredSecret: z43.boolean().meta({
     description: "Whether an encrypted secret is stored in the database for this settlement",
     examples: [true, false]
   }),
-  userApproved: z41.boolean().meta({
+  userApproved: z43.boolean().meta({
     description: "Whether the current user has approved this settlement",
     examples: [true, false]
   })
@@ -69785,52 +70062,52 @@ var execute = v1Contract.route({
 }).input(XvpExecuteInputSchema).output(XvpExecuteOutputSchema);
 
 // ../../packages/dalp/api-contract/src/routes/admin/routes/organizations.list.schema.ts
-import { z as z42 } from "zod";
-var OrganizationListItemSchema = z42.object({
-  id: z42.string().meta({ description: "Organization ID", examples: ["org_123abc"] }),
-  name: z42.string().meta({ description: "Organization name", examples: ["Acme Corp"] }),
-  slug: z42.string().meta({
+import { z as z44 } from "zod";
+var OrganizationListItemSchema = z44.object({
+  id: z44.string().meta({ description: "Organization ID", examples: ["org_123abc"] }),
+  name: z44.string().meta({ description: "Organization name", examples: ["Acme Corp"] }),
+  slug: z44.string().meta({
     description: "Organization slug for URLs",
     examples: ["acme-corp"]
   }),
-  logo: z42.string().nullable().meta({
+  logo: z44.string().nullable().meta({
     description: "URL to organization logo",
     examples: ["https://example.com/logo.png"]
   }),
   createdAt: timestamp().meta({ description: "When the organization was created" }),
-  ownerCount: z42.number().int().nonnegative().meta({
+  ownerCount: z44.number().int().nonnegative().meta({
     description: "Number of owners in the organization",
     examples: [2]
   }),
-  ownerEmails: z42.array(z42.string().email()).meta({
+  ownerEmails: z44.array(z44.string().email()).meta({
     description: "Email addresses for all organization owners",
     examples: [["owner@company.com", "owner2@company.com"]]
   }),
-  memberCount: z42.number().int().nonnegative().meta({
+  memberCount: z44.number().int().nonnegative().meta({
     description: "Total number of members (including owners)",
     examples: [10]
   }),
-  assetCount: z42.number().int().nonnegative().meta({
+  assetCount: z44.number().int().nonnegative().meta({
     description: "Number of assets owned by the organization",
     examples: [5]
   })
 });
 var OrganizationListInputSchema = PaginatedListSchema.extend({
   orderBy: PaginatedListSchema.shape.orderBy.default("createdAt").describe("Field to order by (supports: name, slug, createdAt)"),
-  filters: z42.object({
-    search: z42.string().optional().meta({
+  filters: z44.object({
+    search: z44.string().optional().meta({
       description: "Search query for organization name or slug",
       examples: ["acme", "corp"]
     })
   }).optional()
 });
-var OrganizationListOutputSchema = z42.object({
-  items: z42.array(OrganizationListItemSchema).meta({ description: "List of organizations" }),
-  total: z42.number().int().nonnegative().meta({
+var OrganizationListOutputSchema = z44.object({
+  items: z44.array(OrganizationListItemSchema).meta({ description: "List of organizations" }),
+  total: z44.number().int().nonnegative().meta({
     description: "Total count of organizations matching the query"
   }),
-  limit: z42.number().int().positive().optional().meta({ description: "Applied limit" }),
-  offset: z42.number().int().nonnegative().meta({ description: "Applied offset" })
+  limit: z44.number().int().positive().optional().meta({ description: "Applied limit" }),
+  offset: z44.number().int().nonnegative().meta({ description: "Applied offset" })
 });
 
 // ../../packages/dalp/api-contract/src/routes/admin/admin.contract.ts
@@ -69843,22 +70120,22 @@ var organizationsList = v1Contract.route({
 }).input(OrganizationListInputSchema).output(OrganizationListOutputSchema);
 
 // ../../packages/dalp/api-contract/src/routes/contacts/routes/contacts.delete.schema.ts
-import { z as z43 } from "zod";
-var ContactsDeleteSchema = z43.object({
-  id: z43.uuid()
+import { z as z45 } from "zod";
+var ContactsDeleteSchema = z45.object({
+  id: z45.uuid()
 });
-var ContactsDeleteOutputSchema = z43.object({
-  success: z43.literal(true)
+var ContactsDeleteOutputSchema = z45.object({
+  success: z45.literal(true)
 });
 
 // ../../packages/dalp/api-contract/src/routes/contacts/routes/contacts.list.schema.ts
-import { z as z45 } from "zod";
+import { z as z47 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/contacts/routes/contacts.record.schema.ts
-import { z as z44 } from "zod";
-var ContactSchema = z44.object({
-  id: z44.string(),
-  name: z44.string(),
+import { z as z46 } from "zod";
+var ContactSchema = z46.object({
+  id: z46.string(),
+  name: z46.string(),
   wallet: ethereumAddress,
   createdAt: timestamp(),
   updatedAt: timestamp()
@@ -69866,29 +70143,29 @@ var ContactSchema = z44.object({
 
 // ../../packages/dalp/api-contract/src/routes/contacts/routes/contacts.list.schema.ts
 var ContactsListInputSchema = PaginatedListSchema.extend({
-  orderBy: z45.enum(["createdAt", "updatedAt", "name", "wallet"]).default("createdAt"),
-  filters: z45.object({
-    search: z45.string().min(1).max(120).optional().meta({ description: "Case-insensitive match against name or wallet address", examples: ["alice", "0x71C7"] })
+  orderBy: z47.enum(["createdAt", "updatedAt", "name", "wallet"]).default("createdAt"),
+  filters: z47.object({
+    search: z47.string().min(1).max(120).optional().meta({ description: "Case-insensitive match against name or wallet address", examples: ["alice", "0x71C7"] })
   }).optional()
 });
-var ContactsListOutputSchema = z45.object({
+var ContactsListOutputSchema = z47.object({
   items: ContactSchema.array(),
-  total: z45.number(),
-  limit: z45.number().optional(),
-  offset: z45.number()
+  total: z47.number(),
+  limit: z47.number().optional(),
+  offset: z47.number()
 });
 
 // ../../packages/dalp/api-contract/src/routes/contacts/routes/contacts.read.schema.ts
-import { z as z46 } from "zod";
-var ContactsReadSchema = z46.object({
-  id: z46.string().uuid()
+import { z as z48 } from "zod";
+var ContactsReadSchema = z48.object({
+  id: z48.string().uuid()
 });
 
 // ../../packages/dalp/api-contract/src/routes/contacts/routes/contacts.search.schema.ts
-import { z as z47 } from "zod";
-var ContactsSearchSchema = z47.object({
-  query: z47.string().trim().min(1).max(120).meta({ description: "Case-insensitive search across contact name and wallet", examples: ["alice", "0x71C7"] }),
-  limit: z47.number().int().positive().max(50).default(10)
+import { z as z49 } from "zod";
+var ContactsSearchSchema = z49.object({
+  query: z49.string().trim().min(1).max(120).meta({ description: "Case-insensitive search across contact name and wallet", examples: ["alice", "0x71C7"] }),
+  limit: z49.number().int().positive().max(50).default(10)
 });
 var ContactSearchResultSchema = ContactSchema.pick({
   id: true,
@@ -69898,10 +70175,10 @@ var ContactSearchResultSchema = ContactSchema.pick({
 var ContactsSearchOutputSchema = ContactSearchResultSchema.array();
 
 // ../../packages/dalp/api-contract/src/routes/contacts/routes/contacts.upsert.schema.ts
-import { z as z48 } from "zod";
-var ContactsUpsertSchema = z48.object({
-  id: z48.uuid().optional(),
-  name: z48.string().trim().min(1, "Contact name cannot be empty").max(120).meta({ description: "Human readable label for the contact", examples: ["Alice", "Treasury Wallet"] }),
+import { z as z50 } from "zod";
+var ContactsUpsertSchema = z50.object({
+  id: z50.uuid().optional(),
+  name: z50.string().trim().min(1, "Contact name cannot be empty").max(120).meta({ description: "Human readable label for the contact", examples: ["Alice", "Treasury Wallet"] }),
   wallet: ethereumAddress
 });
 
@@ -69943,11 +70220,11 @@ var search = v1Contract.route({
 }).input(ContactsSearchSchema).output(ContactsSearchOutputSchema);
 
 // ../../packages/dalp/api-contract/src/routes/exchange-rates/exchange-rates.contract.ts
-import { z as z53 } from "zod";
+import { z as z55 } from "zod";
 
 // ../../packages/core/validation/src/fiat-currency.ts
 import * as cc from "currency-codes";
-import { z as z49 } from "zod";
+import { z as z51 } from "zod";
 var NON_FIAT_X_CODES = new Set([
   "XAG",
   "XAU",
@@ -69991,7 +70268,7 @@ var fiatCurrencyMetadata = Object.fromEntries(allFiatCurrencies.map((code2) => {
   const metadata = getCurrencyMetadata(code2);
   return [code2, metadata ?? { name: code2, decimals: 2 }];
 }));
-var fiatCurrency = () => z49.string().regex(/^[A-Z]{3}$/, "Currency code must be 3 uppercase letters").refine((code2) => allFiatCurrenciesSet.has(code2), {
+var fiatCurrency = () => z51.string().regex(/^[A-Z]{3}$/, "Currency code must be 3 uppercase letters").refine((code2) => allFiatCurrenciesSet.has(code2), {
   message: "Invalid ISO 4217 alpha-3 currency code"
 }).meta({
   description: "Fiat currency code (ISO 4217)",
@@ -69999,45 +70276,45 @@ var fiatCurrency = () => z49.string().regex(/^[A-Z]{3}$/, "Currency code must be
 });
 
 // ../../packages/dalp/api-contract/src/routes/exchange-rates/routes/exchange-rates.history.schema.ts
-import { z as z50 } from "zod";
-var ExchangeRatesHistorySchema = z50.object({
+import { z as z52 } from "zod";
+var ExchangeRatesHistorySchema = z52.object({
   baseCurrency: fiatCurrency(),
   quoteCurrency: fiatCurrency(),
   startDate: timestamp().optional(),
   endDate: timestamp().optional(),
-  limit: z50.number().int().positive().max(1000).default(100)
+  limit: z52.number().int().positive().max(1000).default(100)
 });
 
 // ../../packages/dalp/api-contract/src/routes/exchange-rates/routes/exchange-rates.list.schema.ts
-import { z as z51 } from "zod";
+import { z as z53 } from "zod";
 var ExchangeRatesListSchema = PaginatedListSchema.extend({
-  baseCurrencies: z51.array(fiatCurrency()).optional(),
-  quoteCurrencies: z51.array(fiatCurrency()).optional()
+  baseCurrencies: z53.array(fiatCurrency()).optional(),
+  quoteCurrencies: z53.array(fiatCurrency()).optional()
 });
-var ExchangeRatesListOutputSchema = z51.object({
-  items: z51.array(z51.object({
+var ExchangeRatesListOutputSchema = z53.object({
+  items: z53.array(z53.object({
     baseCurrency: fiatCurrency(),
     quoteCurrency: fiatCurrency(),
-    rate: v1FrozenRequired(z51.number().nullable(), { nonNullable: true }),
+    rate: v1FrozenRequired(z53.number().nullable(), { nonNullable: true }),
     effectiveAt: v1FrozenRequired(timestamp().nullable(), { nonNullable: true }),
     updatedAt: v1FrozenRequired(timestamp().nullable(), { nonNullable: true }),
     feedAddress: ethereumAddress.nullable()
   })),
-  totalCount: z51.number(),
-  offset: z51.number(),
-  limit: z51.number().optional()
+  totalCount: z53.number(),
+  offset: z53.number(),
+  limit: z53.number().optional()
 });
 
 // ../../packages/dalp/api-contract/src/routes/exchange-rates/routes/exchange-rates.read.schema.ts
-import { z as z52 } from "zod";
-var ExchangeRatesReadSchema = z52.object({
+import { z as z54 } from "zod";
+var ExchangeRatesReadSchema = z54.object({
   baseCurrency: fiatCurrency(),
   quoteCurrency: fiatCurrency()
 });
-var ExchangeRatesReadOutputSchema = z52.object({
+var ExchangeRatesReadOutputSchema = z54.object({
   baseCurrency: fiatCurrency(),
   quoteCurrency: fiatCurrency(),
-  rate: z52.number().positive(),
+  rate: z54.number().positive(),
   effectiveAt: timestamp()
 }).nullable();
 
@@ -70048,10 +70325,10 @@ var read3 = v1Contract.route({
   description: "Get the current exchange rate between two currencies",
   successDescription: "Exchange rate retrieved successfully",
   tags: [V1_TAG.exchangeRates]
-}).input(ExchangeRatesReadSchema).output(z53.object({
-  baseCurrency: z53.string(),
-  quoteCurrency: z53.string(),
-  rate: z53.number(),
+}).input(ExchangeRatesReadSchema).output(z55.object({
+  baseCurrency: z55.string(),
+  quoteCurrency: z55.string(),
+  rate: z55.number(),
   effectiveAt: timestamp()
 }).nullable());
 var list4 = v1Contract.route({
@@ -70067,34 +70344,34 @@ var history = v1Contract.route({
   description: "Get historical exchange rates for a currency pair",
   successDescription: "Historical rates retrieved successfully",
   tags: [V1_TAG.exchangeRates]
-}).input(ExchangeRatesHistorySchema).output(z53.array(z53.object({
-  baseCurrency: z53.string(),
-  quoteCurrency: z53.string(),
-  rate: z53.number(),
+}).input(ExchangeRatesHistorySchema).output(z55.array(z55.object({
+  baseCurrency: z55.string(),
+  quoteCurrency: z55.string(),
+  rate: z55.number(),
   effectiveAt: timestamp()
 })));
 
 // ../../packages/dalp/api-contract/src/routes/external-token/routes/external-token.list.schema.ts
-import { z as z54 } from "zod";
-var ExternalTokenSchema = z54.object({
+import { z as z56 } from "zod";
+var ExternalTokenSchema = z56.object({
   id: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  name: z54.string().meta({ description: "The name of the token", examples: ["USD Coin", "Wrapped Ether"] }),
-  symbol: z54.string().meta({ description: "The symbol of the token", examples: ["USDC", "WETH"] }),
+  name: z56.string().meta({ description: "The name of the token", examples: ["USD Coin", "Wrapped Ether"] }),
+  symbol: z56.string().meta({ description: "The symbol of the token", examples: ["USDC", "WETH"] }),
   decimals: decimals(),
   totalSupply: bigDecimal().nullable().meta({ description: "The total supply of the token (scaled by decimals)", examples: ["1000000000.00"] }),
   totalSupplyExact: apiBigInt.optional().meta({
     description: "The total supply of the token (raw on-chain uint256)",
     examples: ["1000000000000000000000"]
   }),
-  type: z54.string().meta({ description: "The type assigned to the token", examples: ["stablecoin", "bond", "equity"] }),
-  pausable: z54.object({
-    paused: z54.boolean().meta({ description: "Whether the token is paused", examples: [true, false] })
+  type: z56.string().meta({ description: "The type assigned to the token", examples: ["stablecoin", "bond", "equity"] }),
+  pausable: z56.object({
+    paused: z56.boolean().meta({ description: "Whether the token is paused", examples: [true, false] })
   }).nullable().optional(),
   externalRegisteredAt: timestamp().nullable().meta({ description: "When the token was registered as external", examples: ["2024-01-15T10:30:00.000Z"] }),
-  externalRegisteredBy: z54.object({
+  externalRegisteredBy: z56.object({
     id: ethereumAddress.meta({
       description: "Address that registered the token",
       examples: ["0x2546BcD3c84621e976D8185a91A922aE77ECEc30"]
@@ -70103,18 +70380,18 @@ var ExternalTokenSchema = z54.object({
     description: "Account that registered the token",
     examples: [{ id: "0x2546BcD3c84621e976D8185a91A922aE77ECEc30" }]
   }),
-  externalDetectedInterfaces: z54.array(z54.string()).nullable().meta({ description: "Detected interfaces on the token", examples: [["ERC20", "Pausable"]] }),
-  implementsERC3643: z54.boolean().meta({ description: "Whether the token implements ERC3643", examples: [true, false] }),
-  implementsSMART: z54.boolean().meta({ description: "Whether the token implements SMART", examples: [true, false] })
+  externalDetectedInterfaces: z56.array(z56.string()).nullable().meta({ description: "Detected interfaces on the token", examples: [["ERC20", "Pausable"]] }),
+  implementsERC3643: z56.boolean().meta({ description: "Whether the token implements ERC3643", examples: [true, false] }),
+  implementsSMART: z56.boolean().meta({ description: "Whether the token implements SMART", examples: [true, false] })
 });
-var ExternalTokenListSchema = z54.array(ExternalTokenSchema);
-var ExternalTokenListInputSchema = z54.object({
-  orderBy: z54.string().optional().meta({ description: "Field to order by", examples: ["name", "symbol", "type"] }),
-  orderDirection: z54.enum(["asc", "desc"]).optional().meta({ description: "Order direction", examples: ["asc", "desc"] })
+var ExternalTokenListSchema = z56.array(ExternalTokenSchema);
+var ExternalTokenListInputSchema = z56.object({
+  orderBy: z56.string().optional().meta({ description: "Field to order by", examples: ["name", "symbol", "type"] }),
+  orderDirection: z56.enum(["asc", "desc"]).optional().meta({ description: "Order direction", examples: ["asc", "desc"] })
 });
-var ExternalTokenListResponseSchema = z54.object({
+var ExternalTokenListResponseSchema = z56.object({
   tokens: ExternalTokenListSchema,
-  totalCount: z54.number().int().nonnegative()
+  totalCount: z56.number().int().nonnegative()
 });
 
 // ../../packages/dalp/api-contract/src/routes/external-token/routes/external-token.list.contract.ts
@@ -70127,20 +70404,20 @@ var externalTokenListContract = v1Contract.route({
 }).input(ExternalTokenListInputSchema).output(ExternalTokenListResponseSchema);
 
 // ../../packages/dalp/api-contract/src/routes/external-token/routes/mutations/external-token.register.schema.ts
-import { z as z55 } from "zod";
-var ExternalTokenRegisterInputSchema = z55.object({
+import { z as z57 } from "zod";
+var ExternalTokenRegisterInputSchema = z57.object({
   tokenAddress: ethereumAddress.meta({
     description: "The external token contract address to register",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  tokenType: z55.string().min(1, "Token type cannot be empty").meta({
+  tokenType: z57.string().min(1, "Token type cannot be empty").meta({
     description: "The type to assign to the token",
     examples: ["bond", "equity", "stablecoin"]
   }),
   walletVerification: UserVerificationSchema.optional()
 });
-var ExternalTokenRegisterOutputSchema = z55.object({
-  txHash: z55.string().meta({
+var ExternalTokenRegisterOutputSchema = z57.object({
+  txHash: z57.string().meta({
     description: "The transaction hash",
     examples: ["0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef12"]
   }),
@@ -70160,9 +70437,9 @@ var externalTokenRegisterContract = v1Contract.route({
 }).input(ExternalTokenRegisterInputSchema).output(ExternalTokenRegisterOutputSchema);
 
 // ../../packages/dalp/api-contract/src/routes/identity-recovery/routes/recovery.execute.schema.ts
-import { z as z56 } from "zod";
-var RecoveryExecuteInputSchema = z56.object({
-  userId: z56.string().min(1).meta({
+import { z as z58 } from "zod";
+var RecoveryExecuteInputSchema = z58.object({
+  userId: z58.string().min(1).meta({
     description: "The internal database ID of the user to recover"
   }),
   wallet: ethereumAddress.optional().meta({
@@ -70172,45 +70449,45 @@ var RecoveryExecuteInputSchema = z56.object({
     description: "Wallet verification (PIN/2FA) for the admin executing the recovery"
   })
 });
-var RecoveryExecuteOutputSchema = z56.object({
-  success: z56.boolean().meta({
+var RecoveryExecuteOutputSchema = z58.object({
+  success: z58.boolean().meta({
     description: "Whether the workflow was submitted successfully"
   })
 });
 
 // ../../packages/core/validation/src/identity-status.ts
-import { z as z57 } from "zod";
+import { z as z59 } from "zod";
 var identityStatuses = ["pending", "registered"];
 var indexedIdentityStatuses = ["PENDING", "ACTIVE"];
-var IdentityStatusSchema = z57.enum(identityStatuses).meta({ description: "On-chain identity registration status", examples: ["pending", "registered"] });
+var IdentityStatusSchema = z59.enum(identityStatuses).meta({ description: "On-chain identity registration status", examples: ["pending", "registered"] });
 var identityStatus = () => IdentityStatusSchema;
-var IndexedIdentityStatusSchema = z57.enum(indexedIdentityStatuses).meta({ description: "Indexed identity registration status", examples: ["PENDING", "ACTIVE"] });
+var IndexedIdentityStatusSchema = z59.enum(indexedIdentityStatuses).meta({ description: "Indexed identity registration status", examples: ["PENDING", "ACTIVE"] });
 var indexedIdentityStatus = () => IndexedIdentityStatusSchema;
 
 // ../../packages/dalp/api-contract/src/routes/identity-recovery/routes/recovery.preview.schema.ts
-import { z as z58 } from "zod";
-var RecoveryPreviewParamsSchema = z58.object({
-  userId: z58.string().min(1).meta({
+import { z as z60 } from "zod";
+var RecoveryPreviewParamsSchema = z60.object({
+  userId: z60.string().min(1).meta({
     description: "The internal database ID of the user to recover"
   })
 });
-var RecoveryPreviewQuerySchema = z58.object({
+var RecoveryPreviewQuerySchema = z60.object({
   wallet: ethereumAddress.optional().meta({
     description: "The wallet address that has lost access and needs recovery. If omitted, defaults to the user's personal identity wallet."
   })
 });
-var RecoveryPreviewInputSchema = z58.object({
+var RecoveryPreviewInputSchema = z60.object({
   ...RecoveryPreviewParamsSchema.shape,
   ...RecoveryPreviewQuerySchema.shape
 });
-var TokenBalanceSchema = z58.object({
+var TokenBalanceSchema = z60.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address"
   }),
-  tokenName: z58.string().meta({
+  tokenName: z60.string().meta({
     description: "The token name"
   }),
-  tokenSymbol: z58.string().meta({
+  tokenSymbol: z60.string().meta({
     description: "The token symbol"
   }),
   balance: bigDecimal().meta({
@@ -70219,55 +70496,55 @@ var TokenBalanceSchema = z58.object({
   balanceExact: apiBigInt.optional().meta({
     description: "The token balance (raw on-chain uint256)"
   }),
-  decimals: z58.number().meta({
+  decimals: z60.number().meta({
     description: "The token decimals"
   })
 });
-var RecoveryPreviewOutputSchema = z58.object({
-  user: z58.object({
-    id: z58.string().meta({
+var RecoveryPreviewOutputSchema = z60.object({
+  user: z60.object({
+    id: z60.string().meta({
       description: "The internal database ID of the user"
     }),
-    email: z58.string().nullable().meta({
+    email: z60.string().nullable().meta({
       description: "The user's email address"
     }),
-    name: z58.string().nullable().meta({
+    name: z60.string().nullable().meta({
       description: "The user's display name"
     })
   }),
   lostWallet: ethereumAddress.meta({
     description: "The wallet address that has lost access"
   }),
-  identity: z58.object({
+  identity: z60.object({
     id: ethereumAddress.nullable().meta({
       description: "The OnchainID contract address"
     }),
     status: identityStatus().nullable().meta({
       description: "The identity registration status (pending or registered)"
     }),
-    isMarkedAsLost: z58.boolean().meta({
+    isMarkedAsLost: z60.boolean().meta({
       description: "Whether the wallet is already marked as lost"
     })
   }),
-  tokenBalances: z58.array(TokenBalanceSchema).meta({
+  tokenBalances: z60.array(TokenBalanceSchema).meta({
     description: "Token balances that will need recovery"
   }),
-  canRecover: z58.boolean().meta({
+  canRecover: z60.boolean().meta({
     description: "Whether recovery can proceed"
   }),
-  blockingReasons: z58.array(z58.string()).meta({
+  blockingReasons: z60.array(z60.string()).meta({
     description: "Reasons why recovery cannot proceed (if canRecover is false)"
   })
 });
 
 // ../../packages/dalp/api-contract/src/routes/identity-recovery/routes/recovery.status.schema.ts
-import { z as z59 } from "zod";
-var RecoveryStatusInputSchema = z59.object({
-  userId: z59.string().min(1).meta({
+import { z as z61 } from "zod";
+var RecoveryStatusInputSchema = z61.object({
+  userId: z61.string().min(1).meta({
     description: "The internal database ID of the user being recovered"
   })
 });
-var RecoveryPhaseSchema = z59.enum([
+var RecoveryPhaseSchema = z61.enum([
   "creating-wallet",
   "creating-identity",
   "creating-smart-wallet",
@@ -70282,14 +70559,14 @@ var RecoveryPhaseSchema = z59.enum([
   "completed-with-token-failures",
   "failed"
 ]);
-var TokenRecoveryFailureReasonSchema = z59.enum([
+var TokenRecoveryFailureReasonSchema = z61.enum([
   "TOKEN_PAUSED",
   "MISSING_CUSTODIAN_ROLE",
   "NO_TOKENS",
   "RPC_ERROR",
   "UNKNOWN"
 ]);
-var TokenRecoveryFailureSchema = z59.object({
+var TokenRecoveryFailureSchema = z61.object({
   tokenAddress: ethereumAddress.meta({
     description: "Token contract whose forcedRecover call failed"
   }),
@@ -70299,24 +70576,24 @@ var TokenRecoveryFailureSchema = z59.object({
   reason: TokenRecoveryFailureReasonSchema.meta({
     description: "Classified failure reason driving the operator's retry decision"
   }),
-  message: z59.string().meta({
+  message: z61.string().meta({
     description: "Operator-friendly explanation classified from the raw revert"
   }),
-  rawError: z59.string().meta({
+  rawError: z61.string().meta({
     description: "Verbatim error message from the contract call for debugging"
   })
 });
-var RecoveryStatusOutputSchema = z59.object({
+var RecoveryStatusOutputSchema = z61.object({
   phase: RecoveryPhaseSchema.meta({
     description: "The current phase of the recovery workflow"
   }),
-  tokensRecovered: z59.number().meta({
+  tokensRecovered: z61.number().meta({
     description: "Number of tokens successfully recovered so far"
   }),
-  totalTokens: z59.number().meta({
+  totalTokens: z61.number().meta({
     description: "Total number of tokens to recover"
   }),
-  error: z59.string().nullable().meta({
+  error: z61.string().nullable().meta({
     description: "Error message if the workflow failed"
   }),
   newWallet: ethereumAddress.nullable().meta({
@@ -70325,7 +70602,7 @@ var RecoveryStatusOutputSchema = z59.object({
   newIdentity: ethereumAddress.nullable().meta({
     description: "New OnchainID address (populated when completed)"
   }),
-  tokenRecoveryFailures: z59.array(TokenRecoveryFailureSchema).meta({
+  tokenRecoveryFailures: z61.array(TokenRecoveryFailureSchema).meta({
     description: "Per-token failure manifest. Empty when phase is 'completed'. " + "Populated when phase is 'completed-with-token-failures' — the on-chain " + "recovery link persists, so any listed token can be reclaimed later via retry."
   })
 });
@@ -70360,237 +70637,6 @@ import { z as z74 } from "zod";
 // ../../packages/dalp/api-contract/src/routes/token/routes/token.search.schema.ts
 import { z as z71 } from "zod";
 
-// ../../packages/core/validation/src/access-control-roles.ts
-import { z as z61 } from "zod";
-
-// ../../packages/core/validation/src/ethereum-hex.ts
-import { isHex as isHex2 } from "viem";
-import { z as z60 } from "zod";
-var ethereumHex = z60.string().meta({
-  description: "A valid Ethereum hex string (starting with 0x)",
-  examples: ["0x1234abcd", "0x00", "0xdeadbeef"]
-}).min(2, "Hex string must be at least 2 characters long (0x)").refine(isHex2, {
-  message: "Invalid hex format - must start with '0x' followed by hexadecimal characters"
-}).transform((value2) => value2);
-
-// ../../packages/core/validation/src/access-control-roles.ts
-var roles = [
-  "addonManager",
-  "addonModule",
-  "addonRegistryModule",
-  "admin",
-  "auditor",
-  "claimPolicyManager",
-  "claimIssuer",
-  "complianceManager",
-  "custodian",
-  "emergency",
-  "feedsManager",
-  "fundsManager",
-  "gasManager",
-  "governance",
-  "identityManager",
-  "identityRegistryModule",
-  "organisationIdentityManager",
-  "saleAdmin",
-  "supplyManagement",
-  "systemManager",
-  "systemModule",
-  "tokenFactoryModule",
-  "tokenFactoryRegistryModule",
-  "tokenManager",
-  "trustedIssuersMetaRegistryModule"
-];
-var accessControlRoles = z61.object(Object.fromEntries(roles.map((role) => [role, z61.boolean().default(false)])));
-var accessControlRole = z61.enum(roles);
-var assetAccessControlRoles = [
-  "admin",
-  "custodian",
-  "emergency",
-  "fundsManager",
-  "governance",
-  "saleAdmin",
-  "supplyManagement"
-];
-var assetAccessControlRole = z61.enum(assetAccessControlRoles);
-var assetAccessControlRolesSchema = accessControlRoles.pick({
-  admin: true,
-  custodian: true,
-  emergency: true,
-  fundsManager: true,
-  governance: true,
-  saleAdmin: true,
-  supplyManagement: true
-});
-var systemAccessControlRoles = [
-  "admin",
-  "auditor",
-  "systemManager",
-  "tokenManager",
-  "complianceManager",
-  "claimPolicyManager",
-  "claimIssuer",
-  "identityManager",
-  "feedsManager",
-  "gasManager"
-];
-var systemAccessControlRole = z61.enum(systemAccessControlRoles);
-var systemAccessControlRolesV1 = [...systemAccessControlRoles, "addonManager"];
-var systemAccessControlRoleV1 = z61.enum(systemAccessControlRolesV1);
-var systemAccessControlRolesSchema = accessControlRoles.pick({
-  addonManager: true,
-  admin: true,
-  auditor: true,
-  systemManager: true,
-  tokenManager: true,
-  complianceManager: true,
-  claimPolicyManager: true,
-  claimIssuer: true,
-  identityManager: true,
-  feedsManager: true,
-  gasManager: true
-});
-var roleAdminSchema = z61.object({
-  id: ethereumHex.meta({
-    description: "Role admin mapping identifier",
-    examples: ["0x0102030405060708091011121314151617181920212223242526272829303132"]
-  }),
-  role: ethereumHex.meta({
-    description: "Role identifier (bytes32)",
-    examples: ["0x0000000000000000000000000000000000000000000000000000000000000001"]
-  }),
-  roleFieldName: accessControlRole.meta({
-    description: "Role field name",
-    examples: ["admin", "tokenManager", "complianceManager"]
-  }),
-  adminRole: ethereumHex.meta({
-    description: "Admin role identifier (bytes32)",
-    examples: ["0x0000000000000000000000000000000000000000000000000000000000000000"]
-  }),
-  adminFieldName: accessControlRole.meta({
-    description: "Admin role field name",
-    examples: ["admin", "systemManager"]
-  })
-});
-var AccessControlSchema = z61.object({
-  id: ethereumAddress.meta({
-    description: "Access control contract address",
-    examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
-  }),
-  addonManager: v1FrozenRequired(accountArray().default([]).meta({
-    description: "Accounts with addon manager role. Frozen v1-compat role — always empty.",
-    examples: [[]]
-  }), { required: true }),
-  addonModule: accountArray().meta({
-    description: "Accounts with addon module role",
-    examples: [[]]
-  }),
-  addonRegistryModule: accountArray().meta({
-    description: "Accounts with addon registry module role",
-    examples: [[]]
-  }),
-  admin: accountArray().meta({
-    description: "Accounts with admin role",
-    examples: [
-      [
-        {
-          id: "0x71C7656EC7ab88b098defB751B7401B5f6d8976F",
-          isContract: false
-        }
-      ]
-    ]
-  }),
-  auditor: accountArray().meta({
-    description: "Accounts with auditor role",
-    examples: [[]]
-  }),
-  claimPolicyManager: accountArray().meta({
-    description: "Accounts with claim policy manager role",
-    examples: [[]]
-  }),
-  claimIssuer: accountArray().meta({
-    description: "Accounts with claim issuer role",
-    examples: [[]]
-  }),
-  complianceManager: accountArray().meta({
-    description: "Accounts with compliance manager role",
-    examples: [[]]
-  }),
-  custodian: accountArray().meta({
-    description: "Accounts with custodian role",
-    examples: [[]]
-  }),
-  emergency: accountArray().meta({
-    description: "Accounts with emergency role",
-    examples: [[]]
-  }),
-  feedsManager: accountArray().meta({
-    description: "Accounts with feeds manager role",
-    examples: [[]]
-  }),
-  fundsManager: accountArray().meta({
-    description: "Accounts with funds manager role",
-    examples: [[]]
-  }),
-  gasManager: accountArray().meta({
-    description: "Accounts with gas manager role",
-    examples: [[]]
-  }),
-  governance: accountArray().meta({
-    description: "Accounts with governance role",
-    examples: [[]]
-  }),
-  identityManager: accountArray().meta({
-    description: "Accounts with identity manager role",
-    examples: [[]]
-  }),
-  identityRegistryModule: accountArray().meta({
-    description: "Accounts with identity registry module role",
-    examples: [[]]
-  }),
-  organisationIdentityManager: accountArray().meta({
-    description: "Accounts with organisation identity manager role",
-    examples: [[]]
-  }),
-  saleAdmin: accountArray().meta({
-    description: "Accounts with sale admin role",
-    examples: [[]]
-  }),
-  supplyManagement: accountArray().meta({
-    description: "Accounts with supply management role",
-    examples: [[]]
-  }),
-  systemManager: accountArray().meta({
-    description: "Accounts with system manager role",
-    examples: [[]]
-  }),
-  systemModule: accountArray().meta({
-    description: "Accounts with system module role",
-    examples: [[]]
-  }),
-  tokenFactoryModule: accountArray().meta({
-    description: "Accounts with token factory module role",
-    examples: [[]]
-  }),
-  tokenFactoryRegistryModule: accountArray().meta({
-    description: "Accounts with token factory registry module role",
-    examples: [[]]
-  }),
-  tokenManager: accountArray().meta({
-    description: "Accounts with token manager role",
-    examples: [[]]
-  }),
-  trustedIssuersMetaRegistryModule: accountArray().meta({
-    description: "Accounts with trusted issuers meta registry module role",
-    examples: [[]]
-  }),
-  roleAdmins: z61.array(roleAdminSchema).meta({
-    description: "Admin role mapping per access control role",
-    examples: [[]]
-  }).default([])
-});
-var accessControlSchema = () => AccessControlSchema;
-
 // ../../packages/core/validation/src/asset-extensions.ts
 import { z as z62 } from "zod";
 var AssetExtensionEnum = {
@@ -96390,7 +96436,7 @@ function normalizeDalpBaseUrl(url) {
 // package.json
 var package_default = {
   name: "@settlemint/dalp-sdk",
-  version: "3.0.7-main.28529883879",
+  version: "3.0.7-main.28538365167",
   private: false,
   description: "Fully typed SDK for the DALP tokenization platform API",
   homepage: "https://settlemint.com",
@@ -98545,7 +98591,8 @@ var DAPI_ROUTE_ERROR_IDS = {
   "DALP-9162": "DALP-9162",
   "DALP-9163": "DALP-9163",
   "DALP-9164": "DALP-9164",
-  "DALP-9165": "DALP-9165"
+  "DALP-9165": "DALP-9165",
+  "DALP-9166": "DALP-9166"
 };
 var DAPI_ERROR_IDS = {
   ...DAPI_ROUTE_ERROR_IDS,