@settlemint/dalp-sdk 2.1.7-main.23619085876 → 2.1.7-main.23633109637

package/dist/index.js

@@ -2837,7 +2837,7 @@ var FixedYieldScheduleCreateInputSchema = MutationInputSchema.extend({
 });
 
 // ../../packages/core/validation/src/fixed-yield-schedule.ts
-import { z as z22 } from "zod";
+import { z as z21 } from "zod";
 
 // ../../packages/core/validation/src/bigdecimal.ts
 import { from, isDnum } from "dnum";
@@ -2901,22 +2901,17 @@ var DecimalsSchema = z20.union([z20.string(), z20.number()]).transform((value2,
 }).meta({ description: "Number of decimal places for the asset", examples: [0, 2, 6, 8, 18] });
 var decimals = () => DecimalsSchema;
 
-// ../../packages/core/validation/src/ethereum-hex.ts
-import { isHex } from "viem";
-import { z as z21 } from "zod";
-var ethereumHex = z21.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((value2) => value2);
-
 // ../../packages/core/validation/src/fixed-yield-schedule.ts
-var FixedYieldSchedulePeriodSchema = z22.object({
-  id: ethereumHex.meta({
-    description: "Unique identifier for the yield period (composite hex ID from subgraph)",
-    examples: ["0x1234567890abcdef"]
-  }),
+function fixedYieldSchedulePeriodId() {
+  return z21.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 = z21.object({
+  id: fixedYieldSchedulePeriodId(),
   startDate: timestamp().meta({
     description: "Unix timestamp when period starts",
     examples: [1680354000, 1704067200]
@@ -2934,9 +2929,9 @@ var FixedYieldSchedulePeriodSchema = z22.object({
     description: "Total yield generated in this period",
     examples: ["1500.0", "1000.0"]
   }),
-  completed: z22.boolean().meta({ description: "Whether this period has been completed", examples: [true, false] })
+  completed: z21.boolean().meta({ description: "Whether this period has been completed", examples: [true, false] })
 });
-var FixedYieldScheduleSchema = z22.object({
+var FixedYieldScheduleSchema = z21.object({
   id: ethereumAddress.meta({
     description: "Yield schedule contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -2949,18 +2944,18 @@ var FixedYieldScheduleSchema = z22.object({
     description: "Unix timestamp when yield ends",
     examples: [1711890000, 1735689600]
   }),
-  rate: z22.string().meta({ description: "Yield rate in basis points", examples: ["500", "1000", "250"] }),
-  interval: z22.string().meta({ description: "Payment interval in seconds", examples: ["2592000", "86400", "604800"] }),
+  rate: z21.string().meta({ description: "Yield rate in basis points", examples: ["500", "1000", "250"] }),
+  interval: z21.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: z22.object({
+  denominationAsset: z21.object({
     id: ethereumAddress.meta({
       description: "Denomination asset contract address",
       examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
     }),
     decimals: decimals().meta({ description: "Denomination asset decimals", examples: [6, 18] }),
-    symbol: z22.string().meta({ description: "Denomination asset symbol", examples: ["USDC", "USDT", "DAI"] })
+    symbol: z21.string().meta({ description: "Denomination asset symbol", examples: ["USDC", "USDT", "DAI"] })
   }),
   currentPeriod: FixedYieldSchedulePeriodSchema.nullable().meta({
     description: "Current active yield period",
@@ -2970,7 +2965,7 @@ var FixedYieldScheduleSchema = z22.object({
     description: "Next scheduled yield period",
     examples: [null]
   }),
-  periods: z22.array(FixedYieldSchedulePeriodSchema).meta({ description: "Array of all yield periods", examples: [[]] })
+  periods: z21.array(FixedYieldSchedulePeriodSchema).meta({ description: "Array of all yield periods", examples: [[]] })
 });
 var fixedYieldSchedule = () => FixedYieldScheduleSchema;
 
@@ -2997,16 +2992,16 @@ var fixedYieldScheduleReadContract = v1Contract.route({
 
 // ../../packages/core/validation/src/asset-amount.ts
 import { from as from2, isDnum as isDnum2 } from "dnum";
-import { z as z23 } from "zod";
+import { z as z22 } from "zod";
 var MAX_UINT256 = 2n ** 256n - 1n;
-var assetAmount = z23.preprocess((value2, ctx) => {
+var assetAmount = z22.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 z23.NEVER;
+    return z22.NEVER;
   }
   try {
     const dnum = from2(value2);
@@ -3015,14 +3010,14 @@ var assetAmount = z23.preprocess((value2, ctx) => {
         code: "custom",
         message: "Asset amount cannot be negative"
       });
-      return z23.NEVER;
+      return z22.NEVER;
     }
     if (dnum[0] > MAX_UINT256) {
       ctx.addIssue({
         code: "custom",
         message: "Asset amount exceeds the maximum uint256 value"
       });
-      return z23.NEVER;
+      return z22.NEVER;
     }
     return dnum[0];
   } catch {
@@ -3033,21 +3028,21 @@ var assetAmount = z23.preprocess((value2, ctx) => {
           code: "custom",
           message: "Asset amount cannot be negative"
         });
-        return z23.NEVER;
+        return z22.NEVER;
       }
       if (bigintValue > MAX_UINT256) {
         ctx.addIssue({
           code: "custom",
           message: "Asset amount exceeds the maximum uint256 value"
         });
-        return z23.NEVER;
+        return z22.NEVER;
       }
       return bigintValue;
     } catch {
       return value2;
     }
   }
-}, z23.coerce.bigint());
+}, z22.coerce.bigint());
 
 // ../../packages/dalp/api-contract/src/routes/addons/fixed-yield-schedule/routes/fixed-yield-schedule.top-up.schema.ts
 var FixedYieldScheduleTopUpInputSchema = FixedYieldScheduleMutationInputSchema.extend({
@@ -3098,11 +3093,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 z25 } from "zod";
+import { z as z24 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/schemas/xvp.input.schema.ts
-import { z as z24 } from "zod";
-var XvpSettlementReadInputSchema = z24.object({
+import { z as z23 } from "zod";
+var XvpSettlementReadInputSchema = z23.object({
   settlementAddress: ethereumAddress.meta({
     description: "The XvP settlement contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -3112,25 +3107,25 @@ 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 = z25.object({
-  transactionHash: z25.string()
+var XvpApproveOutputSchema = z24.object({
+  transactionHash: z24.string()
 });
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/routes/mutations/cancel/xvp.cancel.schema.ts
-import { z as z26 } from "zod";
+import { z as z25 } from "zod";
 var XvpCancelInputSchema = XvpSettlementMutationInputSchema;
-var XvpCancelOutputSchema = z26.object({
-  transactionHash: z26.string()
+var XvpCancelOutputSchema = z25.object({
+  transactionHash: z25.string()
 });
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/routes/mutations/create/xvp.create.schema.ts
-import { z as z27 } from "zod";
-function isHex2(value2) {
+import { z as z26 } from "zod";
+function isHex(value2) {
   return /^0x[0-9a-fA-F]*$/.test(value2);
 }
 var SECRET_MIN_LENGTH = 32;
-var LocalFlowSchema = z27.object({
-  type: z27.literal("local"),
+var LocalFlowSchema = z26.object({
+  type: z26.literal("local"),
   assetId: ethereumAddress.meta({
     description: "ERC-20 asset address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -3145,8 +3140,8 @@ var LocalFlowSchema = z27.object({
   }),
   amount: assetAmount.meta({ description: "Token amount in base units", examples: ["1000000000000000000"] })
 });
-var ExternalFlowSchema = z27.object({
-  type: z27.literal("external"),
+var ExternalFlowSchema = z26.object({
+  type: z26.literal("external"),
   assetId: ethereumAddress.meta({
     description: "ERC-20 asset address on external chain",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -3160,15 +3155,15 @@ var ExternalFlowSchema = z27.object({
     examples: ["0xbDA5747bFD65F08deb54cb465eB87D40e51B197E"]
   }),
   amount: assetAmount.meta({ description: "Token amount in base units", examples: ["1000000000000000000"] }),
-  externalChainId: z27.int().positive().meta({ description: "Target chain ID", examples: [1, 137, 42161] }),
+  externalChainId: z26.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 = z27.discriminatedUnion("type", [LocalFlowSchema, ExternalFlowSchema]);
-var RawSecretSchema = z27.string().min(SECRET_MIN_LENGTH, `Secret must be at least ${SECRET_MIN_LENGTH} characters`).meta({
+var XvpSettlementFlowSchema = z26.discriminatedUnion("type", [LocalFlowSchema, ExternalFlowSchema]);
+var RawSecretSchema = z26.string().min(SECRET_MIN_LENGTH, `Secret must be at least ${SECRET_MIN_LENGTH} characters`).meta({
   description: "Raw HTLC secret pre-image (plain text string).",
   examples: ["my-super-secret-preimage-for-htlc-swap"]
 });
-var HashlockSchema = z27.string().refine((value2) => isHex2(value2) && value2.length === 66, {
+var HashlockSchema = z26.string().refine((value2) => isHex(value2) && value2.length === 66, {
   message: "Hashlock must be a 0x-prefixed 32-byte hex string (66 chars)"
 }).meta({
   description: "Pre-computed keccak256 hashlock (bytes32)",
@@ -3191,12 +3186,12 @@ var XvpCreateBaseSchema = MutationInputSchema.extend({
     description: "The XvP addon factory contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  name: z27.string(),
-  autoExecute: z27.boolean().default(false),
+  name: z26.string(),
+  autoExecute: z26.boolean().default(false),
   cutoffDate: blocktime({ future: true }).meta({ description: "Settlement cutoff", examples: [1735689600] }),
   secret: RawSecretSchema.optional(),
   hashlock: HashlockSchema.optional(),
-  flows: z27.array(XvpSettlementFlowSchema),
+  flows: z26.array(XvpSettlementFlowSchema),
   country: isoCountryCodeNumeric.optional().meta({
     description: "ISO 3166-1 numeric country code for the settlement contract identity (required for V3 factories with identity registration)",
     examples: [840, 276, 756]
@@ -3209,8 +3204,8 @@ var XvpCreateSchema = XvpCreateBaseSchema.refine(validateHashlockRequirement, {
   message: "At least one flow must be a local flow (type: 'local').",
   path: ["flows"]
 });
-var XvpCreateOutputSchema = z27.object({
-  transactionHash: z27.string(),
+var XvpCreateOutputSchema = z26.object({
+  transactionHash: z26.string(),
   settlementId: ethereumAddress.meta({
     description: "Created XvP settlement contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -3218,81 +3213,81 @@ var XvpCreateOutputSchema = z27.object({
 });
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/routes/mutations/execute/xvp.execute.schema.ts
-import { z as z28 } from "zod";
+import { z as z27 } from "zod";
 var XvpExecuteInputSchema = XvpSettlementMutationInputSchema;
-var XvpExecuteOutputSchema = z28.object({
-  transactionHash: z28.string()
+var XvpExecuteOutputSchema = z27.object({
+  transactionHash: z27.string()
 });
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/routes/mutations/reveal-secret/xvp.reveal-secret.schema.ts
-import { z as z29 } from "zod";
-var EmailRecipientsSchema = z29.array(z29.email("Invalid email address")).max(10, "Maximum 10 email recipients allowed").optional().default([]);
+import { z as z28 } from "zod";
+var EmailRecipientsSchema = z28.array(z28.email("Invalid email address")).max(10, "Maximum 10 email recipients allowed").optional().default([]);
 var XvpRevealSecretInputSchema = XvpSettlementMutationInputSchema.extend({
   secret: RawSecretSchema,
   emailRecipients: EmailRecipientsSchema,
-  settlementName: z29.string().optional()
+  settlementName: z28.string().optional()
 });
-var EmailSendResultSchema = z29.object({
-  recipient: z29.email(),
-  success: z29.boolean(),
-  error: z29.string().optional()
+var EmailSendResultSchema = z28.object({
+  recipient: z28.email(),
+  success: z28.boolean(),
+  error: z28.string().optional()
 });
-var XvpRevealSecretOutputSchema = z29.object({
-  transactionHash: z29.string(),
-  emailResults: z29.array(EmailSendResultSchema).optional()
+var XvpRevealSecretOutputSchema = z28.object({
+  transactionHash: z28.string(),
+  emailResults: z28.array(EmailSendResultSchema).optional()
 });
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/routes/mutations/revoke-approval/xvp.revoke-approval.schema.ts
-import { z as z30 } from "zod";
+import { z as z29 } from "zod";
 var XvpRevokeApprovalInputSchema = XvpSettlementMutationInputSchema;
-var XvpRevokeApprovalOutputSchema = z30.object({
-  transactionHash: z30.string()
+var XvpRevokeApprovalOutputSchema = z29.object({
+  transactionHash: z29.string()
 });
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/routes/mutations/withdraw-cancel/xvp.withdraw-cancel.schema.ts
-import { z as z31 } from "zod";
+import { z as z30 } from "zod";
 var XvpWithdrawCancelInputSchema = XvpSettlementMutationInputSchema;
-var XvpWithdrawCancelOutputSchema = z31.object({
-  transactionHash: z31.string()
+var XvpWithdrawCancelOutputSchema = z30.object({
+  transactionHash: z30.string()
 });
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/routes/mutations/withdraw-expired/xvp.withdraw-expired.schema.ts
-import { z as z32 } from "zod";
+import { z as z31 } from "zod";
 var XvpWithdrawExpiredInputSchema = XvpSettlementMutationInputSchema;
-var XvpWithdrawExpiredOutputSchema = z32.object({
-  transactionHash: z32.string()
+var XvpWithdrawExpiredOutputSchema = z31.object({
+  transactionHash: z31.string()
 });
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/routes/xvp.decrypt.schema.ts
-import { z as z33 } from "zod";
+import { z as z32 } from "zod";
 var XvpDecryptInputSchema = XvpSettlementMutationInputSchema;
-var XvpDecryptOutputSchema = z33.object({
-  secret: z33.string().meta({
+var XvpDecryptOutputSchema = z32.object({
+  secret: z32.string().meta({
     description: "Decrypted HTLC secret in hex format",
     examples: ["0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"]
   }),
-  hashlock: z33.string().meta({
+  hashlock: z32.string().meta({
     description: "Keccak256 hashlock of the decrypted secret",
     examples: ["0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef12"]
   })
 });
 
 // ../../packages/core/validation/src/account.ts
-import { z as z34 } from "zod";
-var AccountSchema = z34.object({
+import { z as z33 } from "zod";
+var AccountSchema = z33.object({
   id: ethereumAddress,
-  isContract: z34.boolean().meta({ description: "Whether this address is a smart contract (true) or EOA (false)", examples: [true, false] })
+  isContract: z33.boolean().meta({ description: "Whether this address is a smart contract (true) or EOA (false)", examples: [true, false] })
 });
 var account = () => AccountSchema;
-var accountArray = () => z34.array(account()).meta({
+var accountArray = () => z33.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 z35 } from "zod";
-var XvpSettlementTypeSchema = z35.enum(["LOCAL", "HTLC"]);
-var XvpSettlementStatusSchema = z35.enum([
+import { z as z34 } from "zod";
+var XvpSettlementTypeSchema = z34.enum(["LOCAL", "HTLC"]);
+var XvpSettlementStatusSchema = z34.enum([
   "EXECUTED",
   "CANCELLED",
   "EXPIRED",
@@ -3300,58 +3295,58 @@ var XvpSettlementStatusSchema = z35.enum([
   "WAITING_SECRET",
   "PENDING"
 ]);
-var XvpSettlementWarningSchema = z35.enum([
+var XvpSettlementWarningSchema = z34.enum([
   "CANCEL_PROPOSED",
   "EXPIRY_APPROACHING",
   "WAITING_SECRET_DELAY",
   "WITHDRAW_EXPIRED"
 ]);
-var XvpUserParticipationRoleSchema = z35.enum(["SENDER", "RECIPIENT", "BOTH"]);
-var XvpSettlementGraphItemSchema = z35.object({
+var XvpUserParticipationRoleSchema = z34.enum(["SENDER", "RECIPIENT", "BOTH"]);
+var XvpSettlementGraphItemSchema = z34.object({
   id: ethereumAddress,
-  name: z35.string(),
-  hasExternalFlows: z35.boolean(),
+  name: z34.string(),
+  hasExternalFlows: z34.boolean(),
   cutoffDate: timestamp(),
   createdAt: timestamp(),
   createdBy: account(),
-  secretRevealTx: z35.string().nullable().optional(),
-  executed: z35.boolean(),
-  cancelled: z35.boolean(),
-  withdrawn: z35.boolean(),
+  secretRevealTx: z34.string().nullable().optional(),
+  executed: z34.boolean(),
+  cancelled: z34.boolean(),
+  withdrawn: z34.boolean(),
   allApprovedAt: timestamp().nullable(),
-  approvalsCount: z35.coerce.number().int().nonnegative(),
-  approvals: z35.array(z35.object({
-    id: z35.string()
+  approvalsCount: z34.coerce.number().int().nonnegative(),
+  approvals: z34.array(z34.object({
+    id: z34.string()
   })).optional(),
-  cancelVotesCount: z35.coerce.number().int().nonnegative(),
-  localSendersCount: z35.coerce.number().int().nonnegative(),
-  localParticipantsCount: z35.coerce.number().int().nonnegative()
+  cancelVotesCount: z34.coerce.number().int().nonnegative(),
+  localSendersCount: z34.coerce.number().int().nonnegative(),
+  localParticipantsCount: z34.coerce.number().int().nonnegative()
 });
 var XvpSettlementListItemSchema = XvpSettlementGraphItemSchema.extend({
-  userApproved: z35.boolean()
+  userApproved: z34.boolean()
 });
-var XvpSettlementListSchema = z35.array(XvpSettlementListItemSchema);
-var XvpSettlementOrderBySchema = z35.enum(["createdAt", "cutoffDate", "name"]);
+var XvpSettlementListSchema = z34.array(XvpSettlementListItemSchema);
+var XvpSettlementOrderBySchema = z34.enum(["createdAt", "cutoffDate", "name"]);
 var XvpSettlementListInputSchema = PaginatedListSchema.extend({
   participant: ethereumAddress.optional(),
   systemAddon: ethereumAddress.optional(),
   orderBy: XvpSettlementOrderBySchema.default("createdAt"),
-  orderDirection: z35.enum(["asc", "desc"]).default("desc")
+  orderDirection: z34.enum(["asc", "desc"]).default("desc")
 });
-var XvpSettlementListResponseSchema = z35.object({
+var XvpSettlementListResponseSchema = z34.object({
   xvPSettlements: XvpSettlementListSchema,
-  total: z35.number().int().nonnegative()
+  total: z34.number().int().nonnegative()
 });
 
 // ../../packages/core/validation/src/asset-symbol.ts
-import { z as z36 } from "zod";
-var AssetSymbolSchema = z36.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 z35 } from "zod";
+var AssetSymbolSchema = z35.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 z37 } from "zod";
-var apiBigInt = z37.preprocess((value2, ctx) => {
+import { z as z36 } from "zod";
+var apiBigInt = z36.preprocess((value2, ctx) => {
   if (typeof value2 === "bigint") {
     return value2;
   }
@@ -3360,7 +3355,7 @@ var apiBigInt = z37.preprocess((value2, ctx) => {
       code: "custom",
       message: "Invalid BigInt format: multiple decimal points"
     });
-    return z37.NEVER;
+    return z36.NEVER;
   }
   const isDnumValue = isDnum3(value2);
   if (Array.isArray(value2) && (value2.length !== 2 || !isDnumValue)) {
@@ -3368,7 +3363,7 @@ var apiBigInt = z37.preprocess((value2, ctx) => {
       code: "custom",
       message: "Invalid BigInt format: array (not a dnum)"
     });
-    return z37.NEVER;
+    return z36.NEVER;
   }
   try {
     const dnum = from3(value2);
@@ -3377,60 +3372,60 @@ var apiBigInt = z37.preprocess((value2, ctx) => {
   } catch {
     return value2;
   }
-}, z37.coerce.bigint());
+}, z36.coerce.bigint());
 
 // ../../packages/dalp/api-contract/src/routes/addons/xvp/routes/xvp.read.schema.ts
-import { z as z38 } from "zod";
-var XvpSettlementFlowReadSchema = z38.object({
-  id: z38.string(),
-  isExternal: z38.boolean(),
-  externalChainId: z38.coerce.number(),
+import { z as z37 } from "zod";
+var XvpSettlementFlowReadSchema = z37.object({
+  id: z37.string(),
+  isExternal: z37.boolean(),
+  externalChainId: z37.coerce.number(),
   amount: bigDecimal().meta({ description: "Flow amount with arbitrary precision", examples: ["1000.50"] }),
   amountExact: apiBigInt,
-  from: z38.object({ id: ethereumAddress }),
-  to: z38.object({ id: ethereumAddress }),
-  asset: z38.object({
+  from: z37.object({ id: ethereumAddress }),
+  to: z37.object({ id: ethereumAddress }),
+  asset: z37.object({
     id: ethereumAddress,
     decimals: decimals(),
     symbol: assetSymbol()
   }).nullable(),
-  assetReference: z38.object({
-    id: z38.string(),
+  assetReference: z37.object({
+    id: z37.string(),
     address: ethereumAddress,
     decimals: decimals()
   }).nullable()
 });
-var XvpSettlementApprovalSchema = z38.object({
-  id: z38.string(),
-  approved: z38.boolean(),
+var XvpSettlementApprovalSchema = z37.object({
+  id: z37.string(),
+  approved: z37.boolean(),
   timestamp: timestamp().nullable(),
-  account: z38.object({ id: ethereumAddress })
+  account: z37.object({ id: ethereumAddress })
 });
-var XvpSettlementCancelVoteSchema = z38.object({
-  id: z38.string(),
+var XvpSettlementCancelVoteSchema = z37.object({
+  id: z37.string(),
   votedAt: timestamp().nullable(),
-  active: z38.boolean(),
-  account: z38.object({ id: ethereumAddress })
+  active: z37.boolean(),
+  account: z37.object({ id: ethereumAddress })
 });
 var XvpSettlementReadGraphSchema = XvpSettlementGraphItemSchema.extend({
-  secret: z38.string().meta({ description: "Secret from GraphQL", examples: ["0x1234..."] }).nullable().optional(),
-  secretRevealed: z38.boolean(),
+  secret: z37.string().meta({ description: "Secret from GraphQL", examples: ["0x1234..."] }).nullable().optional(),
+  secretRevealed: z37.boolean(),
   secretRevealedAt: timestamp().nullable(),
-  secretRevealTx: z38.string().nullable(),
-  secretRevealedBy: z38.object({ id: ethereumAddress }).nullable(),
+  secretRevealTx: z37.string().nullable(),
+  secretRevealedBy: z37.object({ id: ethereumAddress }).nullable(),
   hashlock: HashlockSchema.nullable().optional(),
-  autoExecute: z38.boolean(),
-  approvals: z38.array(XvpSettlementApprovalSchema),
-  cancelVotes: z38.array(XvpSettlementCancelVoteSchema),
-  flows: z38.array(XvpSettlementFlowReadSchema),
-  systemAddon: z38.object({ id: ethereumAddress })
+  autoExecute: z37.boolean(),
+  approvals: z37.array(XvpSettlementApprovalSchema),
+  cancelVotes: z37.array(XvpSettlementCancelVoteSchema),
+  flows: z37.array(XvpSettlementFlowReadSchema),
+  systemAddon: z37.object({ id: ethereumAddress })
 });
 var XvpSettlementReadSchema = XvpSettlementReadGraphSchema.extend({
-  hasStoredSecret: z38.boolean().meta({
+  hasStoredSecret: z37.boolean().meta({
     description: "Whether an encrypted secret is stored in the database for this settlement",
     examples: [true, false]
   }),
-  userApproved: z38.boolean().meta({
+  userApproved: z37.boolean().meta({
     description: "Whether the current user has approved this settlement",
     examples: [true, false]
   })
@@ -3517,52 +3512,52 @@ var execute = v1Contract.route({
 }).input(XvpExecuteInputSchema).output(XvpExecuteOutputSchema);
 
 // ../../packages/dalp/api-contract/src/routes/admin/routes/organizations.list.schema.ts
-import { z as z39 } from "zod";
-var OrganizationListItemSchema = z39.object({
-  id: z39.string().meta({ description: "Organization ID", examples: ["org_123abc"] }),
-  name: z39.string().meta({ description: "Organization name", examples: ["Acme Corp"] }),
-  slug: z39.string().meta({
+import { z as z38 } from "zod";
+var OrganizationListItemSchema = z38.object({
+  id: z38.string().meta({ description: "Organization ID", examples: ["org_123abc"] }),
+  name: z38.string().meta({ description: "Organization name", examples: ["Acme Corp"] }),
+  slug: z38.string().meta({
     description: "Organization slug for URLs",
     examples: ["acme-corp"]
   }),
-  logo: z39.string().nullable().meta({
+  logo: z38.string().nullable().meta({
     description: "URL to organization logo",
     examples: ["https://example.com/logo.png"]
   }),
-  createdAt: z39.date().meta({ description: "When the organization was created" }),
-  ownerCount: z39.number().int().nonnegative().meta({
+  createdAt: z38.date().meta({ description: "When the organization was created" }),
+  ownerCount: z38.number().int().nonnegative().meta({
     description: "Number of owners in the organization",
     examples: [2]
   }),
-  ownerEmails: z39.array(z39.string().email()).meta({
+  ownerEmails: z38.array(z38.string().email()).meta({
     description: "Email addresses for all organization owners",
     examples: [["owner@company.com", "owner2@company.com"]]
   }),
-  memberCount: z39.number().int().nonnegative().meta({
+  memberCount: z38.number().int().nonnegative().meta({
     description: "Total number of members (including owners)",
     examples: [10]
   }),
-  assetCount: z39.number().int().nonnegative().meta({
+  assetCount: z38.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: z39.object({
-    search: z39.string().optional().meta({
+  filters: z38.object({
+    search: z38.string().optional().meta({
       description: "Search query for organization name or slug",
       examples: ["acme", "corp"]
     })
   }).optional()
 });
-var OrganizationListOutputSchema = z39.object({
-  items: z39.array(OrganizationListItemSchema).meta({ description: "List of organizations" }),
-  total: z39.number().int().nonnegative().meta({
+var OrganizationListOutputSchema = z38.object({
+  items: z38.array(OrganizationListItemSchema).meta({ description: "List of organizations" }),
+  total: z38.number().int().nonnegative().meta({
     description: "Total count of organizations matching the query"
   }),
-  limit: z39.number().int().positive().optional().meta({ description: "Applied limit" }),
-  offset: z39.number().int().nonnegative().meta({ description: "Applied offset" })
+  limit: z38.number().int().positive().optional().meta({ description: "Applied limit" }),
+  offset: z38.number().int().nonnegative().meta({ description: "Applied offset" })
 });
 
 // ../../packages/dalp/api-contract/src/routes/admin/admin.contract.ts
@@ -3575,52 +3570,52 @@ var organizationsList = v1Contract.route({
 }).input(OrganizationListInputSchema).output(OrganizationListOutputSchema);
 
 // ../../packages/dalp/api-contract/src/routes/contacts/routes/contacts.delete.schema.ts
-import { z as z40 } from "zod";
-var ContactsDeleteSchema = z40.object({
-  id: z40.uuid()
+import { z as z39 } from "zod";
+var ContactsDeleteSchema = z39.object({
+  id: z39.uuid()
 });
-var ContactsDeleteOutputSchema = z40.object({
-  success: z40.literal(true)
+var ContactsDeleteOutputSchema = z39.object({
+  success: z39.literal(true)
 });
 
 // ../../packages/dalp/api-contract/src/routes/contacts/routes/contacts.list.schema.ts
-import { z as z42 } from "zod";
+import { z as z41 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/contacts/routes/contacts.record.schema.ts
-import { z as z41 } from "zod";
-var ContactSchema = z41.object({
-  id: z41.string(),
-  name: z41.string(),
+import { z as z40 } from "zod";
+var ContactSchema = z40.object({
+  id: z40.string(),
+  name: z40.string(),
   wallet: ethereumAddress,
-  createdAt: z41.date(),
-  updatedAt: z41.date()
+  createdAt: z40.date(),
+  updatedAt: z40.date()
 });
 
 // ../../packages/dalp/api-contract/src/routes/contacts/routes/contacts.list.schema.ts
 var ContactsListInputSchema = PaginatedListSchema.extend({
-  orderBy: z42.enum(["createdAt", "updatedAt", "name", "wallet"]).default("createdAt"),
-  filters: z42.object({
-    search: z42.string().min(1).max(120).optional().meta({ description: "Case-insensitive match against name or wallet address", examples: ["alice", "0x71C7"] })
+  orderBy: z41.enum(["createdAt", "updatedAt", "name", "wallet"]).default("createdAt"),
+  filters: z41.object({
+    search: z41.string().min(1).max(120).optional().meta({ description: "Case-insensitive match against name or wallet address", examples: ["alice", "0x71C7"] })
   }).optional()
 });
-var ContactsListOutputSchema = z42.object({
+var ContactsListOutputSchema = z41.object({
   items: ContactSchema.array(),
-  total: z42.number(),
-  limit: z42.number().optional(),
-  offset: z42.number()
+  total: z41.number(),
+  limit: z41.number().optional(),
+  offset: z41.number()
 });
 
 // ../../packages/dalp/api-contract/src/routes/contacts/routes/contacts.read.schema.ts
-import { z as z43 } from "zod";
-var ContactsReadSchema = z43.object({
-  id: z43.string().uuid()
+import { z as z42 } from "zod";
+var ContactsReadSchema = z42.object({
+  id: z42.string().uuid()
 });
 
 // ../../packages/dalp/api-contract/src/routes/contacts/routes/contacts.search.schema.ts
-import { z as z44 } from "zod";
-var ContactsSearchSchema = z44.object({
-  query: z44.string().trim().min(1).max(120).meta({ description: "Case-insensitive search across contact name and wallet", examples: ["alice", "0x71C7"] }),
-  limit: z44.number().int().positive().max(50).default(10)
+import { z as z43 } from "zod";
+var ContactsSearchSchema = z43.object({
+  query: z43.string().trim().min(1).max(120).meta({ description: "Case-insensitive search across contact name and wallet", examples: ["alice", "0x71C7"] }),
+  limit: z43.number().int().positive().max(50).default(10)
 });
 var ContactSearchResultSchema = ContactSchema.pick({
   id: true,
@@ -3630,10 +3625,10 @@ var ContactSearchResultSchema = ContactSchema.pick({
 var ContactsSearchOutputSchema = ContactSearchResultSchema.array();
 
 // ../../packages/dalp/api-contract/src/routes/contacts/routes/contacts.upsert.schema.ts
-import { z as z45 } from "zod";
-var ContactsUpsertSchema = z45.object({
-  id: z45.uuid().optional(),
-  name: z45.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 z44 } from "zod";
+var ContactsUpsertSchema = z44.object({
+  id: z44.uuid().optional(),
+  name: z44.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
 });
 
@@ -3675,11 +3670,11 @@ var search = v1Contract.route({
 }).input(ContactsSearchSchema).output(ContactsSearchOutputSchema);
 
 // ../../packages/dalp/api-contract/src/routes/exchange-rates/exchange-rates.contract.ts
-import { z as z54 } from "zod";
+import { z as z53 } from "zod";
 
 // ../../packages/core/validation/src/fiat-currency.ts
 import * as cc from "currency-codes";
-import { z as z46 } from "zod";
+import { z as z45 } from "zod";
 function getValidFiatCurrencies() {
   return cc.codes().filter((code2) => {
     const currency = cc.code(code2);
@@ -3721,104 +3716,104 @@ var fiatCurrencyMetadata = Object.fromEntries(fiatCurrencies.map((code2) => {
   const metadata = getCurrencyMetadata(code2);
   return [code2, metadata ?? { name: code2, decimals: 2 }];
 }));
-var fiatCurrency = () => z46.enum(fiatCurrencies).meta({ description: "Fiat currency code (ISO 4217)", examples: ["USD", "EUR", "GBP", "JPY"] });
+var fiatCurrency = () => z45.enum(fiatCurrencies).meta({ description: "Fiat currency code (ISO 4217)", examples: ["USD", "EUR", "GBP", "JPY"] });
 
 // ../../packages/dalp/api-contract/src/routes/exchange-rates/routes/exchange-rates.delete.schema.ts
-import { z as z47 } from "zod";
-var ExchangeRatesDeleteSchema = z47.object({
+import { z as z46 } from "zod";
+var ExchangeRatesDeleteSchema = z46.object({
   baseCurrency: fiatCurrency(),
   quoteCurrency: fiatCurrency()
 });
 
 // ../../packages/dalp/api-contract/src/routes/exchange-rates/routes/exchange-rates.history.schema.ts
-import { z as z48 } from "zod";
-var ExchangeRatesHistorySchema = z48.object({
+import { z as z47 } from "zod";
+var ExchangeRatesHistorySchema = z47.object({
   baseCurrency: fiatCurrency(),
   quoteCurrency: fiatCurrency(),
-  startDate: z48.date().optional(),
-  endDate: z48.date().optional(),
-  limit: z48.number().int().positive().max(1000).default(100)
+  startDate: z47.date().optional(),
+  endDate: z47.date().optional(),
+  limit: z47.number().int().positive().max(1000).default(100)
 });
 
 // ../../packages/dalp/api-contract/src/routes/exchange-rates/routes/exchange-rates.list.schema.ts
-import { z as z49 } from "zod";
+import { z as z48 } from "zod";
 var ExchangeRatesListSchema = PaginatedListSchema.extend({
-  baseCurrencies: z49.array(fiatCurrency()).optional(),
-  quoteCurrencies: z49.array(fiatCurrency()).optional()
+  baseCurrencies: z48.array(fiatCurrency()).optional(),
+  quoteCurrencies: z48.array(fiatCurrency()).optional()
 });
-var ExchangeRatesListOutputSchema = z49.object({
-  items: z49.array(z49.object({
+var ExchangeRatesListOutputSchema = z48.object({
+  items: z48.array(z48.object({
     baseCurrency: fiatCurrency(),
     quoteCurrency: fiatCurrency(),
-    rate: z49.number().nullable(),
-    effectiveAt: z49.date().nullable(),
-    updatedAt: z49.date().nullable(),
+    rate: z48.number().nullable(),
+    effectiveAt: z48.date().nullable(),
+    updatedAt: z48.date().nullable(),
     feedAddress: ethereumAddress.nullable()
   })),
-  totalCount: z49.number(),
-  offset: z49.number(),
-  limit: z49.number().optional()
+  totalCount: z48.number(),
+  offset: z48.number(),
+  limit: z48.number().optional()
 });
 
 // ../../packages/dalp/api-contract/src/routes/exchange-rates/routes/exchange-rates.read.schema.ts
-import { z as z50 } from "zod";
-var ExchangeRatesReadSchema = z50.object({
+import { z as z49 } from "zod";
+var ExchangeRatesReadSchema = z49.object({
   baseCurrency: fiatCurrency(),
   quoteCurrency: fiatCurrency()
 });
-var ExchangeRatesReadOutputSchema = z50.object({
+var ExchangeRatesReadOutputSchema = z49.object({
   baseCurrency: fiatCurrency(),
   quoteCurrency: fiatCurrency(),
-  rate: z50.number().positive(),
-  effectiveAt: z50.date()
+  rate: z49.number().positive(),
+  effectiveAt: z49.date()
 }).nullable();
 
 // ../../packages/dalp/api-contract/src/routes/exchange-rates/routes/exchange-rates.sync.schema.ts
-import { z as z52 } from "zod";
+import { z as z51 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/exchange-rates/schemas.ts
-import { z as z51 } from "zod";
+import { z as z50 } from "zod";
 var exchangeRateProviders = ["er-api", "ECB", "manual"];
-var ExchangeRateProviderSchema = z51.enum(exchangeRateProviders).meta({ description: "Exchange rate data provider", examples: ["er-api", "ECB", "manual"] });
-var exchangeRateApiResponseSchema = z51.object({
-  result: z51.literal("success"),
-  provider: z51.string(),
-  documentation: z51.string(),
-  terms_of_use: z51.string(),
-  time_last_update_unix: z51.number(),
-  time_last_update_utc: z51.string(),
-  time_next_update_unix: z51.number(),
-  time_next_update_utc: z51.string(),
-  time_eol_unix: z51.number(),
-  base_code: z51.string(),
-  rates: z51.record(z51.string(), z51.number())
+var ExchangeRateProviderSchema = z50.enum(exchangeRateProviders).meta({ description: "Exchange rate data provider", examples: ["er-api", "ECB", "manual"] });
+var exchangeRateApiResponseSchema = z50.object({
+  result: z50.literal("success"),
+  provider: z50.string(),
+  documentation: z50.string(),
+  terms_of_use: z50.string(),
+  time_last_update_unix: z50.number(),
+  time_last_update_utc: z50.string(),
+  time_next_update_unix: z50.number(),
+  time_next_update_utc: z50.string(),
+  time_eol_unix: z50.number(),
+  base_code: z50.string(),
+  rates: z50.record(z50.string(), z50.number())
 });
 
 // ../../packages/dalp/api-contract/src/routes/exchange-rates/routes/exchange-rates.sync.schema.ts
-var ExchangeRatesSyncSchema = z52.object({
-  force: z52.boolean().default(false)
+var ExchangeRatesSyncSchema = z51.object({
+  force: z51.boolean().default(false)
 });
-var ExchangeRatesSyncInternalSchema = z52.object({
+var ExchangeRatesSyncInternalSchema = z51.object({
   provider: ExchangeRateProviderSchema.default("er-api"),
   baseCurrency: fiatCurrency().default("USD"),
-  force: z52.boolean().default(false)
+  force: z51.boolean().default(false)
 });
 
 // ../../packages/dalp/api-contract/src/routes/exchange-rates/routes/exchange-rates.update.schema.ts
-import { z as z53 } from "zod";
-var ExchangeRatesUpdateSchema = z53.object({
+import { z as z52 } from "zod";
+var ExchangeRatesUpdateSchema = z52.object({
   baseCurrency: fiatCurrency(),
   quoteCurrency: fiatCurrency(),
-  rate: z53.number().positive("Rate must be positive"),
-  effectiveAt: z53.date().optional()
+  rate: z52.number().positive("Rate must be positive"),
+  effectiveAt: z52.date().optional()
 });
-var ExchangeRatesUpdateOutputSchema = z53.object({
-  success: z53.boolean(),
-  rate: z53.object({
+var ExchangeRatesUpdateOutputSchema = z52.object({
+  success: z52.boolean(),
+  rate: z52.object({
     baseCurrency: fiatCurrency(),
     quoteCurrency: fiatCurrency(),
-    rate: z53.number().positive(),
-    effectiveAt: z53.date()
+    rate: z52.number().positive(),
+    effectiveAt: z52.date()
   })
 });
 
@@ -3829,11 +3824,11 @@ var read3 = v1Contract.route({
   description: "Get the current exchange rate between two currencies",
   successDescription: "Exchange rate retrieved successfully",
   tags: ["exchange-rates"]
-}).input(ExchangeRatesReadSchema).output(z54.object({
-  baseCurrency: z54.string(),
-  quoteCurrency: z54.string(),
-  rate: z54.number(),
-  effectiveAt: z54.date()
+}).input(ExchangeRatesReadSchema).output(z53.object({
+  baseCurrency: z53.string(),
+  quoteCurrency: z53.string(),
+  rate: z53.number(),
+  effectiveAt: z53.date()
 }).nullable());
 var list4 = v1Contract.route({
   method: "GET",
@@ -3848,13 +3843,13 @@ var update = v1Contract.route({
   description: "Manually update an exchange rate",
   successDescription: "Exchange rate updated successfully",
   tags: ["exchange-rates"]
-}).input(ExchangeRatesUpdateSchema).output(z54.object({
-  success: z54.boolean(),
-  rate: z54.object({
-    baseCurrency: z54.string(),
-    quoteCurrency: z54.string(),
-    rate: z54.number(),
-    effectiveAt: z54.date()
+}).input(ExchangeRatesUpdateSchema).output(z53.object({
+  success: z53.boolean(),
+  rate: z53.object({
+    baseCurrency: z53.string(),
+    quoteCurrency: z53.string(),
+    rate: z53.number(),
+    effectiveAt: z53.date()
   })
 }));
 var del2 = v1Contract.route({
@@ -3863,17 +3858,17 @@ var del2 = v1Contract.route({
   description: "Delete a manual exchange rate",
   successDescription: "Exchange rate deleted successfully",
   tags: ["exchange-rates"]
-}).input(ExchangeRatesDeleteSchema).output(z54.object({ success: z54.boolean() }));
+}).input(ExchangeRatesDeleteSchema).output(z53.object({ success: z53.boolean() }));
 var sync = v1Contract.route({
   method: "POST",
   path: "/exchange-rates/sync",
   description: "Synchronize exchange rates with external providers",
   successDescription: "Exchange rates synchronized successfully",
   tags: ["exchange-rates"]
-}).input(ExchangeRatesSyncSchema).output(z54.object({
-  success: z54.boolean(),
-  ratesUpdated: z54.number(),
-  syncedAt: z54.date()
+}).input(ExchangeRatesSyncSchema).output(z53.object({
+  success: z53.boolean(),
+  ratesUpdated: z53.number(),
+  syncedAt: z53.date()
 }));
 var history = v1Contract.route({
   method: "GET",
@@ -3881,34 +3876,34 @@ var history = v1Contract.route({
   description: "Get historical exchange rates for a currency pair",
   successDescription: "Historical rates retrieved successfully",
   tags: ["exchange-rates"]
-}).input(ExchangeRatesHistorySchema).output(z54.array(z54.object({
-  baseCurrency: z54.string(),
-  quoteCurrency: z54.string(),
-  rate: z54.number(),
-  effectiveAt: z54.date()
+}).input(ExchangeRatesHistorySchema).output(z53.array(z53.object({
+  baseCurrency: z53.string(),
+  quoteCurrency: z53.string(),
+  rate: z53.number(),
+  effectiveAt: z53.date()
 })));
 
 // ../../packages/dalp/api-contract/src/routes/external-token/routes/external-token.list.schema.ts
-import { z as z55 } from "zod";
-var ExternalTokenSchema = z55.object({
+import { z as z54 } from "zod";
+var ExternalTokenSchema = z54.object({
   id: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  name: z55.string().meta({ description: "The name of the token", examples: ["USD Coin", "Wrapped Ether"] }),
-  symbol: z55.string().meta({ description: "The symbol of the token", examples: ["USDC", "WETH"] }),
+  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"] }),
   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: z55.string().meta({ description: "The type assigned to the token", examples: ["stablecoin", "bond", "equity"] }),
-  pausable: z55.object({
-    paused: z55.boolean().meta({ description: "Whether the token is paused", examples: [true, false] })
+  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] })
   }).nullable().optional(),
   externalRegisteredAt: timestamp().nullable().meta({ description: "When the token was registered as external", examples: ["2024-01-15T10:30:00.000Z"] }),
-  externalRegisteredBy: z55.object({
+  externalRegisteredBy: z54.object({
     id: ethereumAddress.meta({
       description: "Address that registered the token",
       examples: ["0x2546BcD3c84621e976D8185a91A922aE77ECEc30"]
@@ -3917,18 +3912,18 @@ var ExternalTokenSchema = z55.object({
     description: "Account that registered the token",
     examples: [{ id: "0x2546BcD3c84621e976D8185a91A922aE77ECEc30" }]
   }),
-  externalDetectedInterfaces: z55.array(z55.string()).nullable().meta({ description: "Detected interfaces on the token", examples: [["ERC20", "Pausable"]] }),
-  implementsERC3643: z55.boolean().meta({ description: "Whether the token implements ERC3643", examples: [true, false] }),
-  implementsSMART: z55.boolean().meta({ description: "Whether the token implements SMART", examples: [true, false] })
+  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] })
 });
-var ExternalTokenListSchema = z55.array(ExternalTokenSchema);
-var ExternalTokenListInputSchema = z55.object({
-  orderBy: z55.string().optional().meta({ description: "Field to order by", examples: ["name", "symbol", "type"] }),
-  orderDirection: z55.enum(["asc", "desc"]).optional().meta({ description: "Order direction", examples: ["asc", "desc"] })
+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 ExternalTokenListResponseSchema = z55.object({
+var ExternalTokenListResponseSchema = z54.object({
   tokens: ExternalTokenListSchema,
-  totalCount: z55.number().int().nonnegative()
+  totalCount: z54.number().int().nonnegative()
 });
 
 // ../../packages/dalp/api-contract/src/routes/external-token/routes/external-token.list.contract.ts
@@ -3941,20 +3936,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 z56 } from "zod";
-var ExternalTokenRegisterInputSchema = z56.object({
+import { z as z55 } from "zod";
+var ExternalTokenRegisterInputSchema = z55.object({
   tokenAddress: ethereumAddress.meta({
     description: "The external token contract address to register",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  tokenType: z56.string().min(1, "Token type cannot be empty").meta({
+  tokenType: z55.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 = z56.object({
-  txHash: z56.string().meta({
+var ExternalTokenRegisterOutputSchema = z55.object({
+  txHash: z55.string().meta({
     description: "The transaction hash",
     examples: ["0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef12"]
   }),
@@ -3974,45 +3969,45 @@ var externalTokenRegisterContract = v1Contract.route({
 }).input(ExternalTokenRegisterInputSchema).output(ExternalTokenRegisterOutputSchema);
 
 // ../../packages/dalp/api-contract/src/routes/identity-recovery/routes/recovery.execute.schema.ts
-import { z as z57 } from "zod";
-var RecoveryExecuteInputSchema = z57.object({
-  userId: z57.string().min(1).meta({
+import { z as z56 } from "zod";
+var RecoveryExecuteInputSchema = z56.object({
+  userId: z56.string().min(1).meta({
     description: "The internal database ID of the user to recover"
   }),
   walletVerification: UserVerificationSchema.optional().meta({
     description: "Wallet verification (PIN/2FA) for the admin executing the recovery"
   })
 });
-var RecoveryExecuteOutputSchema = z57.object({
-  success: z57.boolean().meta({
+var RecoveryExecuteOutputSchema = z56.object({
+  success: z56.boolean().meta({
     description: "Whether the workflow was submitted successfully"
   })
 });
 
 // ../../packages/core/validation/src/identity-status.ts
-import { z as z58 } from "zod";
+import { z as z57 } from "zod";
 var identityStatuses = ["pending", "registered"];
 var theGraphIdentityStatuses = ["PENDING", "ACTIVE"];
-var IdentityStatusSchema = z58.enum(identityStatuses).meta({ description: "On-chain identity registration status", examples: ["pending", "registered"] });
+var IdentityStatusSchema = z57.enum(identityStatuses).meta({ description: "On-chain identity registration status", examples: ["pending", "registered"] });
 var identityStatus = () => IdentityStatusSchema;
-var TheGraphIdentityStatusSchema = z58.enum(theGraphIdentityStatuses).meta({ description: "TheGraph subgraph identity registration status", examples: ["PENDING", "ACTIVE"] });
+var TheGraphIdentityStatusSchema = z57.enum(theGraphIdentityStatuses).meta({ description: "TheGraph subgraph identity registration status", examples: ["PENDING", "ACTIVE"] });
 var theGraphIdentityStatus = () => TheGraphIdentityStatusSchema;
 
 // ../../packages/dalp/api-contract/src/routes/identity-recovery/routes/recovery.preview.schema.ts
-import { z as z59 } from "zod";
-var RecoveryPreviewInputSchema = z59.object({
-  userId: z59.string().min(1).meta({
+import { z as z58 } from "zod";
+var RecoveryPreviewInputSchema = z58.object({
+  userId: z58.string().min(1).meta({
     description: "The internal database ID of the user to recover"
   })
 });
-var TokenBalanceSchema = z59.object({
+var TokenBalanceSchema = z58.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address"
   }),
-  tokenName: z59.string().meta({
+  tokenName: z58.string().meta({
     description: "The token name"
   }),
-  tokenSymbol: z59.string().meta({
+  tokenSymbol: z58.string().meta({
     description: "The token symbol"
   }),
   balance: bigDecimal().meta({
@@ -4021,55 +4016,55 @@ var TokenBalanceSchema = z59.object({
   balanceExact: apiBigInt.optional().meta({
     description: "The token balance (raw on-chain uint256)"
   }),
-  decimals: z59.number().meta({
+  decimals: z58.number().meta({
     description: "The token decimals"
   })
 });
-var RecoveryPreviewOutputSchema = z59.object({
-  user: z59.object({
-    id: z59.string().meta({
+var RecoveryPreviewOutputSchema = z58.object({
+  user: z58.object({
+    id: z58.string().meta({
       description: "The internal database ID of the user"
     }),
-    email: z59.string().nullable().meta({
+    email: z58.string().nullable().meta({
       description: "The user's email address"
     }),
-    name: z59.string().nullable().meta({
+    name: z58.string().nullable().meta({
       description: "The user's display name"
     })
   }),
   lostWallet: ethereumAddress.meta({
     description: "The wallet address that has lost access"
   }),
-  identity: z59.object({
+  identity: z58.object({
     id: ethereumAddress.nullable().meta({
       description: "The OnchainID contract address"
     }),
     status: identityStatus().nullable().meta({
       description: "The identity registration status (pending or registered)"
     }),
-    isMarkedAsLost: z59.boolean().meta({
+    isMarkedAsLost: z58.boolean().meta({
       description: "Whether the wallet is already marked as lost"
     })
   }),
-  tokenBalances: z59.array(TokenBalanceSchema).meta({
+  tokenBalances: z58.array(TokenBalanceSchema).meta({
     description: "Token balances that will need recovery"
   }),
-  canRecover: z59.boolean().meta({
+  canRecover: z58.boolean().meta({
     description: "Whether recovery can proceed"
   }),
-  blockingReasons: z59.array(z59.string()).meta({
+  blockingReasons: z58.array(z58.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 z60 } from "zod";
-var RecoveryStatusInputSchema = z60.object({
-  userId: z60.string().min(1).meta({
+import { z as z59 } from "zod";
+var RecoveryStatusInputSchema = z59.object({
+  userId: z59.string().min(1).meta({
     description: "The internal database ID of the user being recovered"
   })
 });
-var RecoveryPhaseSchema = z60.enum([
+var RecoveryPhaseSchema = z59.enum([
   "creating-wallet",
   "deploying-identity",
   "recovering-identity",
@@ -4078,17 +4073,17 @@ var RecoveryPhaseSchema = z60.enum([
   "completed",
   "failed"
 ]);
-var RecoveryStatusOutputSchema = z60.object({
+var RecoveryStatusOutputSchema = z59.object({
   phase: RecoveryPhaseSchema.meta({
     description: "The current phase of the recovery workflow"
   }),
-  tokensRecovered: z60.number().meta({
+  tokensRecovered: z59.number().meta({
     description: "Number of tokens successfully recovered so far"
   }),
-  totalTokens: z60.number().meta({
+  totalTokens: z59.number().meta({
     description: "Total number of tokens to recover"
   }),
-  error: z60.string().nullable().meta({
+  error: z59.string().nullable().meta({
     description: "Error message if the workflow failed"
   }),
   newWallet: ethereumAddress.nullable().meta({
@@ -4131,6 +4126,18 @@ 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 = [
   "addonModule",
   "addonRegistryModule",
@@ -23895,7 +23902,7 @@ var dalpSerializers = [
 // package.json
 var package_default = {
   name: "@settlemint/dalp-sdk",
-  version: "2.1.7-main.23619085876",
+  version: "2.1.7-main.23633109637",
   private: false,
   description: "Fully typed SDK for the DALP tokenization platform API",
   homepage: "https://settlemint.com",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@settlemint/dalp-sdk",
-  "version": "2.1.7-main.23619085876",
+  "version": "2.1.7-main.23633109637",
   "private": false,
   "description": "Fully typed SDK for the DALP tokenization platform API",
   "homepage": "https://settlemint.com",